Frodo4/Src/1541fs.cpp

/*
 *  1541fs.cpp - 1541 emulation in host file system
 *
 *  Frodo (C) 1994-1997,2002-2005 Christian Bauer
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 */

/*
 * 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


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


/*
 *  Constructor: Prepare emulation
 */

FSDrive::FSDrive(IEC *iec, const char *path) : Drive(iec)
{
        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;
        }
}


/*
 *  Destructor
 */

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


/*
 *  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, const uint8 *name, int name_len)
{
        set_error(ERR_OK);

        // Channel 15: Execute file name as command
        if (channel == 15) {
                execute_cmd(name, name_len);
                return ST_OK;
        }

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

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

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

        return open_file(channel, name, name_len);
}


/*
 *  Open file
 */

uint8 FSDrive::open_file(int channel, const uint8 *name, int name_len)
{
        char plain_name[NAMEBUF_LENGTH];
        int plain_name_len;
        int mode = FMODE_READ;
        int type = FTYPE_PRG;
        int rec_len = 0;
        parse_file_name(name, name_len, (uint8 *)plain_name, plain_name_len, mode, type, rec_len, true);

        // Channel 0 is READ, channel 1 is WRITE
        if (channel == 0 || channel == 1) {
                mode = channel ? FMODE_WRITE : FMODE_READ;
                if (type == FTYPE_DEL)
                        type = FTYPE_PRG;
        }

        bool writing = (mode == FMODE_WRITE || mode == FMODE_APPEND);

        // Expand wildcards (only allowed on reading)
        if (strchr(plain_name, '*') || strchr(plain_name, '?')) {
                if (writing) {
                        set_error(ERR_SYNTAX33);
                        return ST_OK;
                } else
                        find_first_file(plain_name);
        }

        // Relative files are not supported
        if (type == FTYPE_REL) {
                set_error(ERR_UNIMPLEMENTED);
                return ST_OK;
        }

        // Select fopen() mode according to file mode
        const char *mode_str = "rb";
        switch (mode) {
                case FMODE_WRITE:
                        mode_str = "wb";
                        break;
                case FMODE_APPEND:
                        mode_str = "ab";
                        break;
        }

        // Open file
#ifndef __riscos__
        if (chdir(dir_path))
                set_error(ERR_NOTREADY);
        else if ((file[channel] = fopen(plain_name, mode_str)) != NULL) {
                if (mode == FMODE_READ || mode == FMODE_M)      // Read and buffer first byte
                        read_char[channel] = fgetc(file[channel]);
        } else
                set_error(ERR_FILENOTFOUND);
        chdir(AppDirPath);
#else
        {
          char fullname[NAMEBUF_LENGTH];

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

        return ST_OK;
}


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

// Return true if name 'n' matches pattern 'p'
static bool match(const char *p, const 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 *pattern)
{
#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(pattern, de->d_name)) {
                        strncpy(pattern, 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 && match(name,Buffer)) {
                        strncpy(name, Buffer, NAMEBUF_LENGTH);
                        return;
                }
        } while (de.readno > 0);
#endif
}


/*
 *  Open directory, create temporary file
 */

uint8 FSDrive::open_directory(int channel, const uint8 *pattern, int pattern_len)
{
        char buf[] = "\001\004\001\001\0\0\022\042                \042 00 2A";
        char str[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 (pattern[0] == '0' && pattern[1] == 0) {
                pattern++;
                pattern_len--;
        }

        // Skip everything before the ':' in the pattern
        uint8 *t = (uint8 *)memchr(pattern, ':', pattern_len);
        if (t)
                pattern = t + 1;

        // Convert pattern to ASCII
        char ascii_pattern[NAMEBUF_LENGTH];
        petscii2ascii(ascii_pattern, pattern, NAMEBUF_LENGTH);

        // 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++ = ascii2petscii(dir_title[i]);
        fwrite(buf, 1, 32, file[channel]);

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

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

                        // Get file statistics
                        chdir(dir_path);
                        stat(de->d_name, &statbuf);
                        chdir(AppDirPath);

                        // 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++ = ascii2petscii(str[i]);
                        *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;
        unsigned char c;

        // Much of this is very similar to the original
        if ((pattern[0] == '0') && (pattern[1] == 0)) {pattern++;}

        // Concatenate dir_path and ascii_pattern in buffer ascii_pattern ==> read subdirs!
        strcpy(ascii_pattern,dir_path); i = strlen(ascii_pattern); ascii_pattern[i++] = '.'; ascii_pattern[i] = 0;
        convert_filename(pattern, ascii_pattern + i, &filemode, &filetype, &wildflag);
        p = ascii_pattern + i; q = p;
        do {c = *q++; if (c == '.') p = q;} while (c >= 32);
        *(p-1) = 0;  // separate directory-path and ascii_pattern
        if ((uint8)(*p) < 32) {*p = '*'; *(p+1) = 0;}

        // 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 = p;

        // 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(ascii_pattern,&di,&de) != NULL)
                        de.offset = -1;
                else if (de.readno > 0) {       // 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 >= 58)
                        return ST_TIMEOUT;
                
                cmd_buf[cmd_len++] = byte;

                if (eoi) {
                        execute_cmd(cmd_buf, cmd_len);
                        cmd_len = 0;
                }
                return ST_OK;
        }

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

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

        return ST_OK;
}


/*
 *  Execute drive commands
 */

// INITIALIZE
void FSDrive::initialize_cmd(void)
{
        close_all_channels();
}

// VALIDATE
void FSDrive::validate_cmd(void)
{
}


/*
 *  Reset drive
 */

void FSDrive::Reset(void)
{
        close_all_channels();
        cmd_len = 0;    
        set_error(ERR_STARTUP);
}
Revision:	1.9
Committed:	2005-06-27T19:55:48Z (19 years, 4 months ago) by cebix
Branch:	MAIN
CVS Tags:	VERSION_4_2, HEAD
Changes since 1.8:	+1 -1 lines
Log Message:	updated copyright dates
#	Content
1	/*
2	* 1541fs.cpp - 1541 emulation in host file system
3	*
4	* Frodo (C) 1994-1997,2002-2005 Christian Bauer
5	*
6	* This program is free software; you can redistribute it and/or modify
7	* it under the terms of the GNU General Public License as published by
8	* the Free Software Foundation; either version 2 of the License, or
9	* (at your option) any later version.
10	*
11	* This program is distributed in the hope that it will be useful,
12	* but WITHOUT ANY WARRANTY; without even the implied warranty of
13	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14	* GNU General Public License for more details.
15	*
16	* You should have received a copy of the GNU General Public License
17	* along with this program; if not, write to the Free Software
18	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
19	*/
20
21	/*
22	* Notes:
23	* ------
24	*
25	* - If the directory is opened (file name "$"), a temporary file
26	* with the structure of a 1541 directory file is created and
27	* opened. It can then be accessed in the same way as all other
28	* files.
29	*
30	* Incompatibilities:
31	* ------------------
32	*
33	* - No "raw" directory reading
34	* - No relative/sequential/user files
35	* - Only "I" and "UJ" commands implemented
36	*/
37
38	#include "sysdeps.h"
39
40	#include "1541fs.h"
41	#include "IEC.h"
42	#include "main.h"
43	#include "Prefs.h"
44
45	#ifdef __riscos__
46	#include "ROlib.h"
47	#endif
48
49
50	// Prototypes
51	static bool match(const char p, const char n);
52
53
54	/*
55	* Constructor: Prepare emulation
56	*/
57
58	FSDrive::FSDrive(IEC iec, const char path) : Drive(iec)
59	{
60	strcpy(orig_dir_path, path);
61	dir_path[0] = 0;
62
63	if (change_dir(orig_dir_path)) {
64	for (int i=0; i<16; i++)
65	file[i] = NULL;
66
67	Reset();
68
69	Ready = true;
70	}
71	}
72
73
74	/*
75	* Destructor
76	*/
77
78	FSDrive::~FSDrive()
79	{
80	if (Ready) {
81	close_all_channels();
82	Ready = false;
83	}
84	}
85
86
87	/*
88	* Change emulation directory
89	*/
90
91	bool FSDrive::change_dir(char *dirpath)
92	{
93	#ifndef __riscos__
94	DIR *dir;
95
96	if ((dir = opendir(dirpath)) != NULL) {
97	closedir(dir);
98	strcpy(dir_path, dirpath);
99	strncpy(dir_title, dir_path, 16);
100	return true;
101	} else
102	return false;
103	#else
104	int Info[4];
105
106	if ((ReadCatalogueInfo(dirpath,Info) & 2) != 0) { // Directory or image file
107	strcpy(dir_path, dirpath);
108	strncpy(dir_title, dir_path, 16);
109	return true;
110	} else
111	return false;
112	#endif
113	}
114
115
116	/*
117	* Open channel
118	*/
119
120	uint8 FSDrive::Open(int channel, const uint8 *name, int name_len)
121	{
122	set_error(ERR_OK);
123
124	// Channel 15: Execute file name as command
125	if (channel == 15) {
126	execute_cmd(name, name_len);
127	return ST_OK;
128	}
129
130	// Close previous file if still open
131	if (file[channel]) {
132	fclose(file[channel]);
133	file[channel] = NULL;
134	}
135
136	if (name[0] == '#') {
137	set_error(ERR_NOCHANNEL);
138	return ST_OK;
139	}
140
141	if (name[0] == '$')
142	return open_directory(channel, name + 1, name_len - 1);
143
144	return open_file(channel, name, name_len);
145	}
146
147
148	/*
149	* Open file
150	*/
151
152	uint8 FSDrive::open_file(int channel, const uint8 *name, int name_len)
153	{
154	char plain_name[NAMEBUF_LENGTH];
155	int plain_name_len;
156	int mode = FMODE_READ;
157	int type = FTYPE_PRG;
158	int rec_len = 0;
159	parse_file_name(name, name_len, (uint8 *)plain_name, plain_name_len, mode, type, rec_len, true);
160
161	// Channel 0 is READ, channel 1 is WRITE
162	if (channel == 0 \|\| channel == 1) {
163	mode = channel ? FMODE_WRITE : FMODE_READ;
164	if (type == FTYPE_DEL)
165	type = FTYPE_PRG;
166	}
167
168	bool writing = (mode == FMODE_WRITE \|\| mode == FMODE_APPEND);
169
170	// Expand wildcards (only allowed on reading)
171	if (strchr(plain_name, '*') \|\| strchr(plain_name, '?')) {
172	if (writing) {
173	set_error(ERR_SYNTAX33);
174	return ST_OK;
175	} else
176	find_first_file(plain_name);
177	}
178
179	// Relative files are not supported
180	if (type == FTYPE_REL) {
181	set_error(ERR_UNIMPLEMENTED);
182	return ST_OK;
183	}
184
185	// Select fopen() mode according to file mode
186	const char *mode_str = "rb";
187	switch (mode) {
188	case FMODE_WRITE:
189	mode_str = "wb";
190	break;
191	case FMODE_APPEND:
192	mode_str = "ab";
193	break;
194	}
195
196	// Open file
197	#ifndef __riscos__
198	if (chdir(dir_path))
199	set_error(ERR_NOTREADY);
200	else if ((file[channel] = fopen(plain_name, mode_str)) != NULL) {
201	if (mode == FMODE_READ \|\| mode == FMODE_M) // Read and buffer first byte
202	read_char[channel] = fgetc(file[channel]);
203	} else
204	set_error(ERR_FILENOTFOUND);
205	chdir(AppDirPath);
206	#else
207	{
208	char fullname[NAMEBUF_LENGTH];
209
210	// On RISC OS make a full filename
211	sprintf(fullname,"%s.%s",dir_path,plain_name);
212	if ((file[channel] = fopen(fullname, mode)) != NULL)
213	{
214	if (mode == FMODE_READ \|\| mode == FMODE_M)
215	{
216	read_char[channel] = fgetc(file[channel]);
217	}
218	}
219	else
220	{
221	set_error(ERR_FILENOTFOUND);
222	}
223	}
224	#endif
225
226	return ST_OK;
227	}
228
229
230	/*
231	* Find first file matching wildcard pattern and get its real name
232	*/
233
234	// Return true if name 'n' matches pattern 'p'
235	static bool match(const char p, const char n)
236	{
237	if (!*p) // Null pattern matches everything
238	return true;
239
240	do {
241	if (p == '') // Wildcard '*' matches all following characters
242	return true;
243	if ((p != n) && (*p != '?')) // Wildcard '?' matches single character
244	return false;
245	p++; n++;
246	} while (*p);
247
248	return !*n;
249	}
250
251	void FSDrive::find_first_file(char *pattern)
252	{
253	#ifndef __riscos__
254	DIR *dir;
255	struct dirent *de;
256
257	// Open directory for reading and skip '.' and '..'
258	if ((dir = opendir(dir_path)) == NULL)
259	return;
260	de = readdir(dir);
261	while (de && (0 == strcmp(".", de->d_name) \|\| 0 == strcmp("..", de->d_name)))
262	de = readdir(dir);
263
264	while (de) {
265
266	// Match found? Then copy real file name
267	if (match(pattern, de->d_name)) {
268	strncpy(pattern, de->d_name, NAMEBUF_LENGTH);
269	closedir(dir);
270	return;
271	}
272
273	// Get next directory entry
274	de = readdir(dir);
275	}
276
277	closedir(dir);
278	#else
279	dir_env de;
280	char Buffer[NAMEBUF_LENGTH];
281
282	de.offset = 0; de.buffsize = NAMEBUF_LENGTH; de.match = name;
283	do {
284	de.readno = 1;
285	if (ReadDirName(dir_path,Buffer,&de) != NULL)
286	de.offset = -1;
287	else if (de.offset != -1 && match(name,Buffer)) {
288	strncpy(name, Buffer, NAMEBUF_LENGTH);
289	return;
290	}
291	} while (de.readno > 0);
292	#endif
293	}
294
295
296	/*
297	* Open directory, create temporary file
298	*/
299
300	uint8 FSDrive::open_directory(int channel, const uint8 *pattern, int pattern_len)
301	{
302	char buf[] = "\001\004\001\001\0\0\022\042 \042 00 2A";
303	char str[NAMEBUF_LENGTH];
304	char p, q;
305	int i;
306	int filemode;
307	int filetype;
308	bool wildflag;
309
310	#ifndef __riscos__
311	DIR *dir;
312	struct dirent *de;
313	struct stat statbuf;
314
315	// Special treatment for "$0"
316	if (pattern[0] == '0' && pattern[1] == 0) {
317	pattern++;
318	pattern_len--;
319	}
320
321	// Skip everything before the ':' in the pattern
322	uint8 t = (uint8 )memchr(pattern, ':', pattern_len);
323	if (t)
324	pattern = t + 1;
325
326	// Convert pattern to ASCII
327	char ascii_pattern[NAMEBUF_LENGTH];
328	petscii2ascii(ascii_pattern, pattern, NAMEBUF_LENGTH);
329
330	// Open directory for reading and skip '.' and '..'
331	if ((dir = opendir(dir_path)) == NULL) {
332	set_error(ERR_NOTREADY);
333	return ST_OK;
334	}
335	de = readdir(dir);
336	while (de && (0 == strcmp(".", de->d_name) \|\| 0 == strcmp("..", de->d_name)))
337	de = readdir(dir);
338
339	// Create temporary file
340	if ((file[channel] = tmpfile()) == NULL) {
341	closedir(dir);
342	return ST_OK;
343	}
344
345	// Create directory title
346	p = &buf[8];
347	for (i=0; i<16 && dir_title[i]; i++)
348	*p++ = ascii2petscii(dir_title[i]);
349	fwrite(buf, 1, 32, file[channel]);
350
351	// Create and write one line for every directory entry
352	while (de) {
353
354	// Include only files matching the ascii_pattern
355	if (match(ascii_pattern, de->d_name)) {
356
357	// Get file statistics
358	chdir(dir_path);
359	stat(de->d_name, &statbuf);
360	chdir(AppDirPath);
361
362	// Clear line with spaces and terminate with null byte
363	memset(buf, ' ', 31);
364	buf[31] = 0;
365
366	p = buf;
367	*p++ = 0x01; // Dummy line link
368	*p++ = 0x01;
369
370	// Calculate size in blocks (254 bytes each)
371	i = (statbuf.st_size + 254) / 254;
372	*p++ = i & 0xff;
373	*p++ = (i >> 8) & 0xff;
374
375	p++;
376	if (i < 10) p++; // Less than 10: add one space
377	if (i < 100) p++; // Less than 100: add another space
378
379	// Convert and insert file name
380	strcpy(str, de->d_name);
381	*p++ = '\"';
382	q = p;
383	for (i=0; i<16 && str[i]; i++)
384	*q++ = ascii2petscii(str[i]);
385	*q++ = '\"';
386	p += 18;
387
388	// File type
389	if (S_ISDIR(statbuf.st_mode)) {
390	*p++ = 'D';
391	*p++ = 'I';
392	*p++ = 'R';
393	} else {
394	*p++ = 'P';
395	*p++ = 'R';
396	*p++ = 'G';
397	}
398
399	// Write line
400	fwrite(buf, 1, 32, file[channel]);
401	}
402
403	// Get next directory entry
404	de = readdir(dir);
405	}
406	#else
407	dir_full_info di;
408	dir_env de;
409	unsigned char c;
410
411	// Much of this is very similar to the original
412	if ((pattern[0] == '0') && (pattern[1] == 0)) {pattern++;}
413
414	// Concatenate dir_path and ascii_pattern in buffer ascii_pattern ==> read subdirs!
415	strcpy(ascii_pattern,dir_path); i = strlen(ascii_pattern); ascii_pattern[i++] = '.'; ascii_pattern[i] = 0;
416	convert_filename(pattern, ascii_pattern + i, &filemode, &filetype, &wildflag);
417	p = ascii_pattern + i; q = p;
418	do {c = *q++; if (c == '.') p = q;} while (c >= 32);
419	*(p-1) = 0; // separate directory-path and ascii_pattern
420	if ((uint8)(p) < 32) {p = ''; (p+1) = 0;}
421
422	// We don't use tmpfile() -- problems involved!
423	DeleteFile(RO_TEMPFILE); // first delete it, if it exists
424	if ((file[channel] = fopen(RO_TEMPFILE,"wb+")) == NULL)
425	return(ST_OK);
426	de.offset = 0; de.buffsize = NAMEBUF_LENGTH; de.match = p;
427
428	// Create directory title - copied from above
429	p = &buf[8];
430	for (i=0; i<16 && dir_title[i]; i++)
431	*p++ = conv_to_64(dir_title[i], false);
432	fwrite(buf, 1, 32, file[channel]);
433
434	do {
435	de.readno = 1;
436	if (ReadDirNameInfo(ascii_pattern,&di,&de) != NULL)
437	de.offset = -1;
438	else if (de.readno > 0) { // don't have to check for match here
439	memset(buf,' ',31); buf[31] = 0; // most of this: see above
440	p = buf; p++ = 0x01; p++ = 0x01;
441	i = (di.length + 254) / 254; p++ = i & 0xff; p++ = (i>>8) & 0xff;
442	p++;
443	if (i < 10)
444	*p++ = ' ';
445	if (i < 100)
446	*p++ = ' ';
447	strcpy(str, di.name);
448	*p++ = '\"'; q = p;
449	for (i=0; (i<16 && str[i]); i++)
450	*q++ = conv_to_64(str[i], true);
451	*q++ = '\"'; p += 18;
452	if ((di.otype & 2) == 0) {
453	p++ = 'P'; p++ = 'R'; *p++ = 'G';
454	} else {
455	p++ = 'D'; p++ = 'I'; *p++ = 'R';
456	}
457	fwrite(buf, 1, 32, file[channel]);
458	}
459	} while (de.offset != -1);
460	#endif
461
462	// Final line
463	fwrite("\001\001\0\0BLOCKS FREE. \0\0", 1, 32, file[channel]);
464
465	// Rewind file for reading and read first byte
466	rewind(file[channel]);
467	read_char[channel] = fgetc(file[channel]);
468
469	#ifndef __riscos
470	// Close directory
471	closedir(dir);
472	#endif
473
474	return ST_OK;
475	}
476
477
478	/*
479	* Close channel
480	*/
481
482	uint8 FSDrive::Close(int channel)
483	{
484	if (channel == 15) {
485	close_all_channels();
486	return ST_OK;
487	}
488
489	if (file[channel]) {
490	fclose(file[channel]);
491	file[channel] = NULL;
492	}
493
494	return ST_OK;
495	}
496
497
498	/*
499	* Close all channels
500	*/
501
502	void FSDrive::close_all_channels(void)
503	{
504	for (int i=0; i<15; i++)
505	Close(i);
506
507	cmd_len = 0;
508	}
509
510
511	/*
512	* Read from channel
513	*/
514
515	uint8 FSDrive::Read(int channel, uint8 &byte)
516	{
517	int c;
518
519	// Channel 15: Error channel
520	if (channel == 15) {
521	byte = *error_ptr++;
522
523	if (byte != '\r')
524	return ST_OK;
525	else { // End of message
526	set_error(ERR_OK);
527	return ST_EOF;
528	}
529	}
530
531	if (!file[channel]) return ST_READ_TIMEOUT;
532
533	// Read one byte
534	byte = read_char[channel];
535	c = fgetc(file[channel]);
536	if (c == EOF)
537	return ST_EOF;
538	else {
539	read_char[channel] = c;
540	return ST_OK;
541	}
542	}
543
544
545	/*
546	* Write to channel
547	*/
548
549	uint8 FSDrive::Write(int channel, uint8 byte, bool eoi)
550	{
551	// Channel 15: Collect chars and execute command on EOI
552	if (channel == 15) {
553	if (cmd_len >= 58)
554	return ST_TIMEOUT;
555
556	cmd_buf[cmd_len++] = byte;
557
558	if (eoi) {
559	execute_cmd(cmd_buf, cmd_len);
560	cmd_len = 0;
561	}
562	return ST_OK;
563	}
564
565	if (!file[channel]) {
566	set_error(ERR_FILENOTOPEN);
567	return ST_TIMEOUT;
568	}
569
570	if (putc(byte, file[channel]) == EOF) {
571	set_error(ERR_WRITE25);
572	return ST_TIMEOUT;
573	}
574
575	return ST_OK;
576	}
577
578
579	/*
580	* Execute drive commands
581	*/
582
583	// INITIALIZE
584	void FSDrive::initialize_cmd(void)
585	{
586	close_all_channels();
587	}
588
589	// VALIDATE
590	void FSDrive::validate_cmd(void)
591	{
592	}
593
594
595	/*
596	* Reset drive
597	*/
598
599	void FSDrive::Reset(void)
600	{
601	close_all_channels();
602	cmd_len = 0;
603	set_error(ERR_STARTUP);
604	}