1541fs.cpp

Go to the documentation of this file.

/*
 *  1541fs.cpp - 1541 emulation in host file system
 *
 *  Frodo (C) 1994-1997 Christian Bauer

 *
 * Notes:
 * ------
 *
 *  - If the directory is opened (file name "$"), a temporary file
 *    with the structure of a 1541 directory file is created and
 *    opened. It can then be accessed in the same way as all other
 *    files.
 *
 * Incompatibilities:
 * ------------------
 *
 *  - No "raw" directory reading
 *  - No relative/sequential/user files
 *  - Only "I" and "UJ" commands implemented
 */

#include "sysdeps.h"

#include "1541fs.h"
#include "IEC.h"
#include "main.h"
#include "Prefs.h"

#ifdef __riscos__
#include "ROlib.h"
#endif


// Access modes
enum {
        FMODE_READ, FMODE_WRITE, FMODE_APPEND
};

// File types
enum {
        FTYPE_PRG, FTYPE_SEQ
};

// Prototypes
static bool match(char *p, char *n);


/*
 *  Constructor: Prepare emulation
 */

FSDrive::FSDrive(IEC *iec, char *path) : Drive(iec)
{
        __CHECK_NULL(iec);
        __CHECK_NULL(path);

        strcpy(orig_dir_path, path);
        dir_path[0] = 0;

        if (change_dir(orig_dir_path)) {
                for (int i=0; i<16; i++)
                        file[i] = NULL;

                Reset();

                Ready = true;
        }

        CTOR(FSDrive);

}


/*
 *  Destructor
 */

FSDrive::~FSDrive()
{
        if (Ready) {
                close_all_channels();
                Ready = false;
        }

        DTOR(FSDrive);
}


/*
 *  Change emulation directory
 */

bool FSDrive::change_dir(char *dirpath)
{
#ifndef __riscos__
        DIR *dir;

        if ((dir = opendir(dirpath)) != NULL) {
                closedir(dir);
                strcpy(dir_path, dirpath);
                strncpy(dir_title, dir_path, 16);
                return true;
        } else
                return false;
#else
        int Info[4];

        if ((ReadCatalogueInfo(dirpath,Info) & 2) != 0) // Directory or image file
        {
          strcpy(dir_path, dirpath);
          strncpy(dir_title, dir_path, 16);
          return true;
        }
        else
        {
          return false;
        }
#endif
}


/*
 *  Open channel
 */

uint8 FSDrive::Open(int channel, char *filename)
{
        set_error(ERR_OK);

        // Channel 15: Execute file name as command
        if (channel == 15) {
                execute_command(filename);
                return ST_OK;
        }

        // Close previous file if still open
        if (file[channel]) {
                fclose(file[channel]);
                file[channel] = NULL;
        }

        if (filename[0] == '$')
                return open_directory(channel, filename+1);

        if (filename[0] == '#') {
                set_error(ERR_NOCHANNEL);
                return ST_OK;
        }

        return open_file(channel, filename);
}


/*
 *  Open file
 */

uint8 FSDrive::open_file(int channel, char *filename)
{
        char plainname[NAMEBUF_LENGTH];
        int filemode = FMODE_READ;
        int filetype = FTYPE_PRG;
        bool wildflag = false;
        char *mode = "rb";
        
        convert_filename(filename, plainname, &filemode, &filetype, &wildflag);

        // Channel 0 is READ PRG, channel 1 is WRITE PRG
        if (!channel) {
                filemode = FMODE_READ;
                filetype = FTYPE_PRG;
        }
        if (channel == 1) {
                filemode = FMODE_WRITE;
                filetype = FTYPE_PRG;
        }

        // Wildcards are only allowed on reading
        if (wildflag) {
                if (filemode != FMODE_READ) {
                        set_error(ERR_SYNTAX33);
                        return ST_OK;
                }
                find_first_file(plainname);
        }

        // Select fopen() mode according to file mode
        switch (filemode) {
                case FMODE_READ:
                        mode = "rb";
                        break;
                case FMODE_WRITE:
                        mode = "wb";
                        break;
                case FMODE_APPEND:
                        mode = "ab";
                        break;
        }

        // Open file
#ifndef __riscos__
        if (chdir_cmd(dir_path)) //JoeF modified to use chdir_cmd
                set_error(ERR_NOTREADY);
        else if ((file[channel] = fopen(plainname, mode)) != NULL) {
                if (filemode == FMODE_READ)     // Read and buffer first byte
                        read_char[channel] = fgetc(file[channel]);
        } else
                set_error(ERR_FILENOTFOUND);
        chdir_cmd(AppDirPath); //JoeF modified to use chdir_cmd 04.11.99
#else
        {
          char fullname[NAMEBUF_LENGTH];

          // On RISC OS make a full filename
          sprintf(fullname,"%s.%s",dir_path,plainname);
          if ((file[channel] = fopen(fullname, mode)) != NULL)
          {
            if (filemode == FMODE_READ)
            {
              read_char[channel] = fgetc(file[channel]);
            }
          }
          else
          {
            set_error(ERR_FILENOTFOUND);
          }
        }
#endif

        return ST_OK;
}


/*
 *  Analyze file name, get access mode and type
 */

void FSDrive::convert_filename(char *srcname, char *destname, int *filemode, int *filetype, bool *wildflag)
{
        char *p, *q;
        int i;

        // Search for ':', p points to first character after ':'
        if ((p = strchr(srcname, ':')) != NULL)
                p++;
        else
                p = srcname;

        // Convert char set of the remaining string -> destname
        q = destname;
        for (i=0; i<NAMEBUF_LENGTH && (*q++ = conv_from_64(*p++, true)); i++) ;

        // Look for mode parameters seperated by ','
        p = destname;
        while ((p = strchr(p, ',')) != NULL) {

                // Cut string after the first ','
                *p++ = 0;

                switch (*p) {
                        case 'p':
                                *filetype = FTYPE_PRG;
                                break;
                        case 's':
                                *filetype = FTYPE_SEQ;
                                break;
                        case 'r':
                                *filemode = FMODE_READ;
                                break;
                        case 'w':
                                *filemode = FMODE_WRITE;
                                break;
                        case 'a':
                                *filemode = FMODE_APPEND;
                                break;
                }
        }

        // Search for wildcards
        *wildflag = (strchr(destname, '?') != NULL) || (strchr(destname, '*') != NULL);
}


/*
 *  Find first file matching wildcard pattern and get its real name
 */

// Return true if name 'n' matches pattern 'p'
static bool match(char *p, char *n)
{
        if (!*p)                // Null pattern matches everything
                return true;

        do {
                if (*p == '*')  // Wildcard '*' matches all following characters
                        return true;
                if ((*p != *n) && (*p != '?'))  // Wildcard '?' matches single character
                        return false;
                p++; n++;
        } while (*p);

        return !*n;
}

void FSDrive::find_first_file(char *name)
{
#ifndef __riscos__
        DIR *dir;
        struct dirent *de;

        // Open directory for reading and skip '.' and '..'
        if ((dir = opendir(dir_path)) == NULL)
                return;
        de = readdir(dir);
        while (de && (0 == strcmp(".", de->d_name) || 0 == strcmp("..", de->d_name))) 
                de = readdir(dir);

        while (de) {

                // Match found? Then copy real file name
                if (match(name, de->d_name)) {
                        strncpy(name, de->d_name, NAMEBUF_LENGTH);
                        closedir(dir);
                        return;
                }

                // Get next directory entry
                de = readdir(dir);
        }

        closedir(dir);
#else
        dir_env de;
        char Buffer[NAMEBUF_LENGTH];

        de.offset = 0; de.buffsize = NAMEBUF_LENGTH; de.match = name;
        do
        {
          de.readno = 1;
          if (ReadDirName(dir_path,Buffer,&de) != NULL) {de.offset = -1;}
          else if (de.offset != -1)
          {
            if (match(name,Buffer))
            {
              strncpy(name, Buffer, NAMEBUF_LENGTH);
              return;
            }
          }
        }
        while (de.offset != -1);
#endif
}


/*
 *  Open directory, create temporary file
 */

uint8 FSDrive::open_directory(int channel, char *filename)
{
        char buf[] = "\001\004\001\001\0\0\022\042                \042 00 2A";
        char str[NAMEBUF_LENGTH];
        char pattern[NAMEBUF_LENGTH];
        char *p, *q;
        int i;
        int filemode;
        int filetype;
        bool wildflag;

#ifndef __riscos__
        DIR *dir;
        struct dirent *de;
        struct stat statbuf;

        // Special treatment for "$0"
        if (filename[0] == '0' && filename[1] == 0)
                filename += 1;

        // Convert filename ('$' already stripped), filemode/type are ignored
        convert_filename(filename, pattern, &filemode, &filetype, &wildflag);

        // Open directory for reading and skip '.' and '..'
        if ((dir = opendir(dir_path)) == NULL) {
                set_error(ERR_NOTREADY);
                return ST_OK;
        }
        de = readdir(dir);
        while (de && (0 == strcmp(".", de->d_name) || 0 == strcmp("..", de->d_name))) 
                de = readdir(dir);

        // Create temporary file
        if ((file[channel] = tmpfile()) == NULL) {
                closedir(dir);
                return ST_OK;
        }

        // Create directory title
        p = &buf[8];
        for (i=0; i<16 && dir_title[i]; i++)
                *p++ = conv_to_64(dir_title[i], false);
        fwrite(buf, 1, 32, file[channel]);

        // Create and write one line for every directory entry
        while (de) {

                // Include only files matching the pattern
                if (match(pattern, de->d_name)) {

                        // Get file statistics
                        chdir_cmd(dir_path); //JoeF modified to use chdir_cmd 04.11.99
                        stat(de->d_name, &statbuf);
                        chdir_cmd(AppDirPath); //JoeF modified to use chdir_cmd 04.11.99

                        // Clear line with spaces and terminate with null byte
                        memset(buf, ' ', 31);
                        buf[31] = 0;

                        p = buf;
                        *p++ = 0x01;    // Dummy line link
                        *p++ = 0x01;

                        // Calculate size in blocks (254 bytes each)
                        i = (statbuf.st_size + 254) / 254;
                        *p++ = i & 0xff;
                        *p++ = (i >> 8) & 0xff;

                        p++;
                        if (i < 10) p++;        // Less than 10: add one space
                        if (i < 100) p++;       // Less than 100: add another space

                        // Convert and insert file name
                        strcpy(str, de->d_name);
                        *p++ = '\"';
                        q = p;
                        for (i=0; i<16 && str[i]; i++)
                                *q++ = conv_to_64(str[i], true);
                        *q++ = '\"';
                        p += 18;

                        // File type
                        if (S_ISDIR(statbuf.st_mode)) {
                                *p++ = 'D';
                                *p++ = 'I';
                                *p++ = 'R';
                        } else {
                                *p++ = 'P';
                                *p++ = 'R';
                                *p++ = 'G';
                        }

                        // Write line
                        fwrite(buf, 1, 32, file[channel]);
                }

                // Get next directory entry
                de = readdir(dir);
        }
#else
        dir_full_info di;
        dir_env de;

        // Much of this is very similar to the original
        if ((filename[0] == '0') && (filename[1] == 0)) {filename++;}
        // Concatenate dir_path and pattern in buffer pattern ==> read subdirs!
        strcpy(pattern,dir_path);
        convert_filename(filename, pattern + strlen(pattern), &filemode, &filetype, &wildflag);

        // We don't use tmpfile() -- problems involved!
        DeleteFile(RO_TEMPFILE);        // first delete it, if it exists
        if ((file[channel] = fopen(RO_TEMPFILE,"wb+")) == NULL)
        {
          return(ST_OK);
        }
        de.offset = 0; de.buffsize = NAMEBUF_LENGTH; de.match = filename;

        // Create directory title - copied from above
        p = &buf[8];
        for (i=0; i<16 && dir_title[i]; i++)
                *p++ = conv_to_64(dir_title[i], false);
        fwrite(buf, 1, 32, file[channel]);

        do
        {
          de.readno = 1;
          if (ReadDirNameInfo(pattern,&di,&de) != NULL) {de.offset = -1;}
          else if (de.offset != -1)     // don't have to check for match here
          {
            memset(buf,' ',31); buf[31] = 0;    // most of this: see above
            p = buf; *p++ = 0x01; *p++ = 0x01;
            i = (di.length + 254) / 254; *p++ = i & 0xff; *p++ = (i>>8) & 0xff;
            p++;
            if (i < 10)  {*p++ = ' ';}
            if (i < 100) {*p++ = ' ';}
            strcpy(str, di.name);
            *p++ = '\"'; q = p;
            for (i=0; (i<16 && str[i]); i++)
            {
              *q++ = conv_to_64(str[i], true);
            }
            *q++ = '\"'; p += 18;
            if ((di.otype & 2) == 0)
            {
              *p++ = 'P'; *p++ = 'R'; *p++ = 'G';
            }
            else
            {
              *p++ = 'D'; *p++ = 'I'; *p++ = 'R';
            }
            fwrite(buf, 1, 32, file[channel]);
          }
        }
        while (de.offset != -1);
#endif

        // Final line
        fwrite("\001\001\0\0BLOCKS FREE.             \0\0", 1, 32, file[channel]);

        // Rewind file for reading and read first byte
        rewind(file[channel]);
        read_char[channel] = fgetc(file[channel]);

#ifndef __riscos
        // Close directory
        closedir(dir);
#endif

        return ST_OK;
}


/*
 *  Close channel
 */

uint8 FSDrive::Close(int channel)
{
        if (channel == 15) {
                close_all_channels();
                return ST_OK;
        }

        if (file[channel]) {
                fclose(file[channel]);
                file[channel] = NULL;
        }

        return ST_OK;
}


/*
 *  Close all channels
 */

void FSDrive::close_all_channels(void)
{
        for (int i=0; i<15; i++)
                Close(i);

        cmd_len = 0;
}


/*
 *  Read from channel
 */

uint8 FSDrive::Read(int channel, uint8 *byte)
{
        int c;

        // Channel 15: Error channel
        if (channel == 15) {
                *byte = *error_ptr++;

                if (*byte != '\r')
                        return ST_OK;
                else {  // End of message
                        set_error(ERR_OK);
                        return ST_EOF;
                }
        }

        if (!file[channel]) return ST_READ_TIMEOUT;

        // Read one byte
        *byte = read_char[channel];
        c = fgetc(file[channel]);
        if (c == EOF)
                return ST_EOF;
        else {
                read_char[channel] = c;
                return ST_OK;
        }
}


/*
 *  Write to channel
 */

uint8 FSDrive::Write(int channel, uint8 byte, bool eoi)
{
        // Channel 15: Collect chars and execute command on EOI
        if (channel == 15) {
                if (cmd_len >= 40)
                        return ST_TIMEOUT;
                
                cmd_buffer[cmd_len++] = byte;

                if (eoi) {
                        cmd_buffer[cmd_len] = 0;
                        cmd_len = 0;
                        execute_command(cmd_buffer);
                }
                return ST_OK;
        }

        if (!file[channel]) {
                set_error(ERR_FILENOTOPEN);
                return ST_TIMEOUT;
        }

        if (fputc(byte, file[channel]) == EOF) {
                set_error(ERR_WRITEERROR);
                return ST_TIMEOUT;
        }

        return ST_OK;
}


/*
 *  Execute command string
 */

void FSDrive::execute_command(char *command)
{
        switch (command[0]) {
                case 'I':
                        close_all_channels();
                        set_error(ERR_OK);
                        break;

                case 'U':
                        if ((command[1] & 0x0f) == 0x0a) {
                                Reset();
                        } else
                                set_error(ERR_SYNTAX30);
                        break;

                case 'G':
                        if (command[1] != ':')
                                set_error(ERR_SYNTAX30);
                        else
                                chdir_cmd(&command[2]);
                        break;

                default:
                        set_error(ERR_SYNTAX30);
        }
}


/*
 *  Execute 'G' command
 */

int FSDrive::chdir_cmd(char *dirpath)
{
        char str[NAMEBUF_LENGTH];
        char *p = str;

        close_all_channels();

        // G:. resets the directory path to its original setting
        if (dirpath[0] == '.' && dirpath[1] == 0) {
                change_dir(orig_dir_path);
        } else {

                // Convert directory name
                for (int i=0; i<NAMEBUF_LENGTH && (*p++ = conv_from_64(*dirpath++, false)); i++) ;

                if (!change_dir(str))
                        {
                        set_error(ERR_NOTREADY);
                        return 1;                       //JoeF 04.11.99 ...hacked! this function was originally void!!!
                        }
        }
        return 0;
}


/*
 *  Reset drive
 */

void FSDrive::Reset(void)
{
        close_all_channels();
        cmd_len = 0;    
        set_error(ERR_STARTUP);

        ELOG1(_L8("FS drive reset\n"));
}


/*
 *  Conversion PETSCII->ASCII
 */

uint8 FSDrive::conv_from_64(uint8 c, bool map_slash)
{
        if ((c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z'))
                return c ^ 0x20;
        if ((c >= 0xc1) && (c <= 0xda))
                return c ^ 0x80;
        if ((c == '/') && map_slash) 
#ifdef __riscos__
                return '.';     // directory separator is '.' in RO
        if (c == '.') {return('_');}    // convert dot to underscore
#else
                return '\\';
#endif
        return c;
}


/*
 *  Conversion ASCII->PETSCII
 */

uint8 FSDrive::conv_to_64(uint8 c, bool map_slash)
{
        if ((c >= 'A') && (c <= 'Z') || (c >= 'a') && (c <= 'z'))
                return c ^ 0x20;
#ifdef __riscos__
        if ((c == '.') && map_slash && ThePrefs.MapSlash)
#else
        if ((c == '\\') && map_slash) 
#endif
                return '/';
#ifdef __riscos__
        if (c == '_') {return('.');}    // convert underscore to dot
#endif
        return c;
}

---