![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to filesys.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [UNIX Amiga Emulator] / uae|
Return to filesys.c CVS log | Up to [UNIX Amiga Emulator] / uae |
1.1 root 1: /*
2: * UAE - The Un*x Amiga Emulator
3: *
4: * Unix file system handler for AmigaDOS
5: *
6: * (c) 1996 Ed Hanway
7: *
8: * Version 0.1: 28-Jan-1996
9: *
10: * Based on example code (c) 1988 The Software Distillery
11: * and published in Transactor for the Amiga, Volume 2, Issues 2-5.
12: * (May - August 1989)
13: *
14: * Known limitations:
15: * Does not support ACTION_INHIBIT (big deal).
16: * Does not support any 2.0+ packet types (except ACTION_SAME_LOCK)
17: * Does not actually enforce exclusive locks.
18: * Does not support removable volumes.
19: * May not return the correct error code in some cases.
20: * Does not check for sane values passed by AmigaDOS. May crash the emulation
21: * if passed garbage values.
22: *
23: * TODO someday:
24: * Support booting.
25: * Implement real locking using flock. Needs test cases.
26: */
27:
28: #include <stdio.h>
29: #include <stdlib.h>
30: #include <string.h>
31: #include <strings.h>
32: #include <assert.h>
33:
34: #ifdef __unix
35: #include <unistd.h>
36: #include <fcntl.h>
37: #include <sys/vfs.h>
38: #include <sys/types.h>
39: #include <sys/stat.h>
40: #ifndef __linux
41: #include <sys/statfs.h>
42: #endif
43: #include <dirent.h>
44: #include <utime.h>
45: #include <errno.h>
46: #endif
47:
48: #include "config.h"
49: #include "amiga.h"
50: #include "options.h"
51: #include "events.h"
52: #include "memory.h"
53: #include "custom.h"
54: #include "newcpu.h"
55: #include "xwin.h"
56: #include "autoconf.h"
57: #include "filesys.h"
58:
59: #define MAKE_CASE_INSENSITIVE
60:
61: typedef struct {
62: char *devname; /* device name, e.g. UAE0: */
63: char *volname; /* volume name, e.g. CDROM, WORK, etc. */
64: char *rootdir; /* root unix directory */
65: bool readonly; /* disallow write access? */
66: } UnitInfo;
67:
68: #define MAX_UNITS 20
69: static int num_units = 0;
70: static UnitInfo ui[MAX_UNITS];
71:
72: static ULONG devnameaddr[100];
73:
74: static ULONG doslibname, fsdevname, filesysseglist;
75:
76: /* strdup missing? */
77: static char*
78: my_strdup(const char*s)
79: {
80: char*x = (char*)malloc(strlen(s) + 1);
81: strcpy(x, s);
82: return x;
83: }
84:
85:
86: void
87: add_filesys_unit(char *volname, char *rootdir, bool readonly)
88: {
89: UnitInfo* u;
90: static char buf[80];
91:
92: if (num_units >= MAX_UNITS) {
93: fprintf(stderr, "Maximum number of unix file systems mounted.\n");
94: return;
95: }
96:
97: u = &ui[num_units];
98: sprintf(buf, "UAE%d", num_units);
99: u->devname = my_strdup(buf);
100: u->volname = my_strdup(volname);
101: u->rootdir = my_strdup(rootdir);
102: u->readonly = readonly;
103:
104: num_units++;
105: }
106:
107: #ifdef TRACING_ENABLED
108: #define TRACE(x) printf x;
109: #define DUMPLOCK(x) dumplock(x)
110: #else
111: #define TRACE(x)
112: #define DUMPLOCK(x)
113: #endif
114:
115: /* minimal AmigaDOS definitions */
116:
117: /* field offsets in DosPacket */
118: #define dp_Type (8)
119: #define dp_Res1 (12)
120: #define dp_Res2 (16)
121: #define dp_Arg1 (20)
122: #define dp_Arg2 (24)
123: #define dp_Arg3 (28)
124: #define dp_Arg4 (32)
125:
126: /* result codes */
127: #define DOS_TRUE (-1L)
128: #define DOS_FALSE (0L)
129:
130: /* packet types */
131: #define ACTION_CURRENT_VOLUME 7
132: #define ACTION_LOCATE_OBJECT 8
133: #define ACTION_RENAME_DISK 9
134: #define ACTION_FREE_LOCK 15
135: #define ACTION_DELETE_OBJECT 16
136: #define ACTION_RENAME_OBJECT 17
137: #define ACTION_COPY_DIR 19
138: #define ACTION_SET_PROTECT 21
139: #define ACTION_CREATE_DIR 22
140: #define ACTION_EXAMINE_OBJECT 23
141: #define ACTION_EXAMINE_NEXT 24
142: #define ACTION_DISK_INFO 25
143: #define ACTION_INFO 26
144: #define ACTION_FLUSH 27
145: #define ACTION_SET_COMMENT 28
146: #define ACTION_PARENT 29
147: #define ACTION_SET_DATE 34
148: #define ACTION_SAME_LOCK 40
149: #define ACTION_FIND_WRITE 1004
150: #define ACTION_FIND_INPUT 1005
151: #define ACTION_FIND_OUTPUT 1006
152: #define ACTION_END 1007
153: #define ACTION_SEEK 1008
154: #define ACTION_IS_FILESYSTEM 1027
155: #define ACTION_READ 'R'
156: #define ACTION_WRITE 'W'
157:
158: #define DISK_TYPE (0x444f5301) /* DOS\1 */
159:
160: /* errors */
161: #define ERROR_NO_FREE_STORE 103
162: #define ERROR_OBJECT_IN_USE 202
163: #define ERROR_OBJECT_EXISTS 203
164: #define ERROR_DIR_NOT_FOUND 204
165: #define ERROR_OBJECT_NOT_FOUND 205
166: #define ERROR_ACTION_NOT_KNOWN 209
167: #define ERROR_OBJECT_WRONG_TYPE 212
168: #define ERROR_DISK_WRITE_PROTECTED 214
169: #define ERROR_DIRECTORY_NOT_EMPTY 216
170: #define ERROR_DEVICE_NOT_MOUNTED 218
171: #define ERROR_SEEK_ERROR 219
172: #define ERROR_DISK_FULL 221
173: #define ERROR_WRITE_PROTECTED 223
174: #define ERROR_NO_MORE_ENTRIES 232
175: #define ERROR_NOT_IMPLEMENTED 236
176:
177: static long dos_errno(void)
178: {
179: int e = errno;
180:
181: switch(e) {
182: case ENOMEM: return ERROR_NO_FREE_STORE;
183: case EEXIST: return ERROR_OBJECT_EXISTS;
184: case EISDIR: return ERROR_OBJECT_WRONG_TYPE;
185: case ETXTBSY: return ERROR_OBJECT_IN_USE;
186: case EACCES: return ERROR_WRITE_PROTECTED;
187: case ENOENT: return ERROR_OBJECT_NOT_FOUND;
188: case ENOTDIR: return ERROR_OBJECT_WRONG_TYPE;
189: case EROFS: return ERROR_DISK_WRITE_PROTECTED;
190: case ENOSPC: return ERROR_DISK_FULL;
191: case EBUSY: return ERROR_OBJECT_IN_USE;
192: case ENOTEMPTY: return ERROR_DIRECTORY_NOT_EMPTY;
193:
194: default:
195: TRACE(("Unimplemented error %s\n", strerror(e)));
196: return ERROR_NOT_IMPLEMENTED;
197: }
198: }
199:
200: /* handler state info */
201:
202: typedef struct _unit {
203: struct _unit *next;
204:
205: /* Amiga stuff */
206: CPTR dosbase;
207: CPTR volume;
208: CPTR port; /* Our port */
209:
210: /* Native stuff */
211: long unit; /* unit number */
212: UnitInfo ui; /* unit startup info */
213: } Unit;
214:
215: typedef struct {
216: CPTR addr; /* addr of real packet */
217: long type;
218: long res1;
219: long res2;
220: long arg1;
221: long arg2;
222: long arg3;
223: long arg4;
224: } DosPacket;
225:
226: static char *
227: bstr(CPTR addr)
228: {
229: static char buf[256];
230: int n = get_byte(addr++);
231: int i;
232: for(i = 0; i < n; i++)
233: buf[i] = get_byte(addr++);
234: buf[i] = 0;
235: return buf;
236: }
237:
238: static Unit *units = NULL;
239: static int unit_num = 0;
240:
241: static Unit*
242: find_unit(CPTR port)
243: {
244: Unit* u;
245: for(u = units; u; u = u->next)
246: if(u->port == port)
247: break;
248:
249: return u;
250: }
251:
252: static CPTR DosAllocMem(ULONG len)
253: {
254: ULONG i;
255: CPTR addr;
256:
257: regs.d[0] = len + 4;
258: regs.d[1] = 1; /* MEMF_PUBLIC */
259: addr = CallLib(regs.a[6], -198); /* AllocMem */
260:
261: if(addr) {
262: put_long(addr, len);
263: addr += 4;
264:
265: /* faster to clear memory here rather than use MEMF_CLEAR */
266: for(i = 0; i < len; i += 4)
267: put_long(addr + i, 0);
268: }
269:
270: return addr;
271: }
272:
273: static void DosFreeMem(CPTR addr)
274: {
275: addr -= 4;
276: regs.d[0] = get_long(addr) + 4;
277: regs.a[1] = addr;
278: CallLib(regs.a[6], -210); /* FreeMem */
279: }
280:
281: static void
282: startup(DosPacket* packet)
283: {
284: int i, namelen;
285: char* devname = bstr(packet->arg1 << 2);
286: char* s;
287: Unit* unit;
288:
289: /* find UnitInfo with correct device name */
290: s = strchr(devname, ':');
291: if(s) *s = '\0';
292: #if 0 /* Kick 1.3 send us a bogus string. */
293: for(i = 0; i < num_units; i++) {
294: if(0 == strcmp(ui[i].devname, devname))
295: break;
296: }
297: #endif
298:
299: i = 0;
300:
301: if(i == num_units || 0 != access(ui[i].rootdir, R_OK)) {
302: fprintf(stderr, "Failed attempt to mount device %s\n", devname);
303: packet->res1 = DOS_FALSE;
304: packet->res2 = ERROR_DEVICE_NOT_MOUNTED;
305: return;
306: }
307:
308: unit = (Unit *) malloc(sizeof(Unit));
309: unit->next = units;
310: units = unit;
311:
312: unit->volume = 0;
313: unit->port = regs.a[5];
314: unit->unit = unit_num++;
315:
316: unit->ui.devname = ui[i].devname;
317: unit->ui.volname = my_strdup(ui[i].volname); /* might free later for rename */
318: unit->ui.rootdir = ui[i].rootdir;
319: unit->ui.readonly = ui[i].readonly;
320:
321: TRACE(("**** STARTUP volume %s\n", unit->ui.volname));
322:
323: /* fill in our process in the device node */
324: put_long((packet->arg3 << 2) + 8, unit->port);
325:
326: /* open dos.library */
327: regs.d[0] = 0;
328: regs.a[1] = doslibname;
329: unit->dosbase = CallLib(regs.a[6], -552); /* OpenLibrary */
330:
331: {
332: CPTR rootnode = get_long(unit->dosbase + 34);
333: CPTR dos_info = get_long(rootnode + 24) << 2;
334: /* make new volume */
335: unit->volume = DosAllocMem(80 + 1 + 44);
336: put_long(unit->volume + 4, 2); /* Type = dt_volume */
337: put_long(unit->volume + 12, 0); /* Lock */
338: put_long(unit->volume + 16, 3800); /* Creation Date */
339: put_long(unit->volume + 20, 0);
340: put_long(unit->volume + 24, 0);
341: put_long(unit->volume + 28, 0); /* lock list */
342: put_long(unit->volume + 40, (unit->volume + 44) >> 2); /* Name */
343: namelen = strlen(unit->ui.volname);
344: put_byte(unit->volume + 44, namelen);
345: for(i = 0; i < namelen; i++)
346: put_byte(unit->volume + 45 + i, unit->ui.volname[i]);
347:
348: /* link into DOS list */
349: put_long(unit->volume, get_long(dos_info + 4));
350: put_long(dos_info + 4, unit->volume >> 2);
351: }
352:
353: put_long(unit->volume + 8, unit->port);
354: put_long(unit->volume + 32, DISK_TYPE);
355:
356: packet->res1 = DOS_TRUE;
357: }
358:
359: static void
360: do_info(Unit* unit, DosPacket* packet, CPTR info)
361: {
362: struct statfs statbuf;
363: #ifdef __linux
364: if(-1 == statfs(unit->ui.rootdir, &statbuf))
365: #else
366: if(-1 == statfs(unit->ui.rootdir, &statbuf, sizeof(struct statfs), 0))
367: #endif
368: {
369: packet->res1 = DOS_FALSE;
370: packet->res2 = dos_errno();
371: }
372:
373: put_long(info, 0); /* errors */
374: put_long(info + 4, unit->unit); /* unit number */
375: put_long(info + 8, unit->ui.readonly ? 80 : 82); /* state */
376: put_long(info + 12, statbuf.f_blocks); /* numblocks */
377: #ifdef __linux
378: put_long(info + 16, statbuf.f_blocks - statbuf.f_bavail); /* inuse */
379: #else
380: put_long(info + 16, statbuf.f_blocks - statbuf.f_bfree); /* inuse */
381: #endif
382: put_long(info + 20, statbuf.f_bsize); /* bytesperblock */
383: put_long(info + 24, DISK_TYPE); /* disk type */
384: put_long(info + 28, unit->volume >> 2); /* volume node */
385: put_long(info + 32, 0); /* inuse */
386: packet->res1 = DOS_TRUE;
387: }
388:
389: static void
390: action_disk_info(Unit* unit, DosPacket* packet)
391: {
392: TRACE(("ACTION_DISK_INFO\n"));
393: do_info(unit, packet, packet->arg1 << 2);
394: }
395:
396: static void
397: action_info(Unit* unit, DosPacket* packet)
398: {
399: TRACE(("ACTION_INFO\n"));
400: do_info(unit, packet, packet->arg2 << 2);
401: }
402:
403: typedef struct {
404: char *path;
405: int fd;
406: } Key;
407:
408: static void
409: free_key(Key*k)
410: {
411: free(k->path);
412: free(k);
413: }
414:
415: static void
416: dumplock(CPTR lock)
417: {
418: if(!lock) {
419: fprintf(stderr, "LOCK: 0x0\n");
420: return;
421: }
422: fprintf(stderr,
423: "LOCK: 0x%lx { next=0x%lx, key=%s, mode=%ld, handler=0x%lx, volume=0x%lx }\n",
424: lock,
425: get_long(lock)<<2, ((Key*)get_long(lock+4))->path, get_long(lock+8),
426: get_long(lock+12), get_long(lock+16));
427: }
428:
429: static char*
430: get_path(Unit* unit, const char *base, const char *rel)
431: {
432: static char buf[1024];
433: char *s = buf;
434: char *p;
435: char *r;
436:
437: int i;
438:
439: TRACE(("get_path(%s,%s)\n", base, rel));
440:
441: /* root-relative path? */
442: for(i = 0; rel[i] && rel[i] != '/' && rel[i] != ':'; i++);
443: if(':' == rel[i]) {
444: base = unit->ui.rootdir; rel += i+1;
445: }
446:
447: while(*base) {
448: *s++ = *base++;
449: }
450: p = s; /* start of relative path */
451: r = buf + strlen(unit->ui.rootdir); /* end of fixed path */
452:
453: while(*rel) {
454: /* start with a slash? go up a level. */
455: if('/' == *rel) {
456: while(s > r && '/' != *s)
457: s--;
458: rel++;
459: } else {
460: *s++ = '/';
461: while(*rel && '/' != *rel) {
462: *s++ = *rel++;
463: }
464: if('/' == *rel)
465: rel++;
466: }
467: }
468: *s = 0;
469:
470: #ifdef MAKE_CASE_INSENSITIVE
471: TRACE(("path=\"%s\"\n", buf));
472: /* go through each section of the path and if it does not exist,
473: * scan its directory for any case insensitive matches
474: */
475: while(*p) {
476: char *p2 = strchr(p+1, '/');
477: char oldp2;
478: if(!p2) {
479: p2 = p+1;
480: while(*p2) p2++;
481: }
482: oldp2 = *p2;
483: *p2 = '\0';
484: if(0 != access(buf, F_OK|R_OK)) {
485: DIR* dir;
486: struct dirent* de;
487:
488: /* does not exist -- check dir for case insensitive match */
489: *p++ = '\0'; /* was '/' */
490: dir = opendir(buf);
491: if (dir) {
492: while((de = readdir(dir))) {
493: if(0 == strcasecmp(de->d_name, p))
494: break;
495: }
496: if(de) {
497: strcpy(p, de->d_name);
498: }
499: closedir(dir);
500: }
501: *--p = '/';
502: }
503: *p2 = oldp2;
504: p = p2;
505: }
506: #endif
507: TRACE(("path=\"%s\"\n", buf));
508:
509: return my_strdup(buf);
510: }
511:
512: static Key*
513: make_key(Unit* unit, CPTR lock, const char *name)
514: {
515: Key *k = (Key*)malloc(sizeof(Key));
516:
517: k->fd = 0;
518:
519: if(!lock) {
520: k->path = get_path(unit, unit->ui.rootdir, name);
521: } else {
522: Key*oldk = (Key*)get_long(lock + 4);
523: TRACE(("key: 0x%08lx", (ULONG)oldk));
524: TRACE((" \"%s\"\n", oldk->path));
525: k->path = get_path(unit, oldk->path, name);
526: }
527:
528: TRACE(("key=\"%s\"\n", k->path));
529: return k;
530: }
531:
532: static Key*
533: dup_key(Key*k)
534: {
535: Key *newk = (Key*)malloc(sizeof(Key));
536: newk->path = my_strdup(k->path);
537: newk->fd = 0;
538: return newk;
539: }
540:
541: static CPTR
542: make_lock(Unit* unit, Key *key, long mode)
543: {
544: /* allocate lock */
545: CPTR lock = DosAllocMem(20);
546:
547: put_long(lock + 4, (ULONG) key);
548: put_long(lock + 8, mode);
549: put_long(lock + 12, unit->port);
550: put_long(lock + 16, unit->volume >> 2);
551:
552: /* prepend to lock chain */
553: put_long(lock, get_long(unit->volume + 28));
554: put_long(unit->volume + 28, lock >> 2);
555:
556: DUMPLOCK(lock);
557: return lock;
558: }
559:
560: static void
561: free_lock(Unit* unit, CPTR lock)
562: {
563: if(!lock)
564: return;
565:
566: if(lock == get_long(unit->volume + 28) << 2) {
567: put_long(unit->volume + 28, get_long(lock));
568: } else {
569: CPTR current = get_long(unit->volume + 28);
570: CPTR next = 0;
571: while(current) {
572: next = get_long(current << 2);
573: if(lock == next << 2)
574: break;
575: current = next;
576: }
577: put_long(current << 2, get_long(lock));
578: }
579: free_key((Key*)get_long(lock + 4));
580: DosFreeMem(lock);
581: }
582:
583: static void
584: action_lock(Unit* unit, DosPacket* packet)
585: {
586: CPTR lock = packet->arg1 << 2;
587: CPTR name = packet->arg2 << 2;
588: long mode = packet->arg3;
589: int access_mode = (mode == -2) ? R_OK : R_OK|W_OK;
590: Key *k;
591:
592: TRACE(("ACTION_LOCK(0x%lx, \"%s\", %d)\n",lock, bstr(name), mode));
593: DUMPLOCK(lock);
594:
595: k = make_key(unit, lock, bstr(name));
596:
597: if(k && 0 == access(k->path, access_mode)) {
598: packet->res1 = make_lock(unit, k, mode) >> 2;
599: } else {
600: if(k)
601: free_key(k);
602: packet->res1 = 0;
603: packet->res2 = ERROR_OBJECT_NOT_FOUND;
604: }
605: }
606:
607: static void
608: action_free_lock(Unit* unit, DosPacket* packet)
609: {
610: CPTR lock = packet->arg1 << 2;
611: TRACE(("ACTION_FREE_LOCK(0x%lx)\n", lock));
612: DUMPLOCK(lock);
613:
614: free_lock(unit, lock);
615:
616: packet->res1 = DOS_TRUE;
617: }
618:
619: static void
620: action_dup_lock(Unit* unit, DosPacket* packet)
621: {
622: CPTR lock = packet->arg1 << 2;
623:
624: TRACE(("ACTION_DUP_LOCK(0x%lx)\n", lock));
625: DUMPLOCK(lock);
626:
627: if(!lock) {
628: packet->res1 = 0;
629: return;
630: }
631:
632: {
633: CPTR oldkey = get_long(lock + 4);
634: CPTR oldmode = get_long(lock + 8);
635: packet->res1 = make_lock(unit, dup_key((Key*)oldkey), oldmode) >> 2;
636: }
637: }
638:
639: /* convert time_t to/from AmigaDOS time */
640: const int secs_per_day = 24 * 60 * 60;
641: const int diff = (8 * 365 + 2) * (24 * 60 * 60);
642:
643: static void
644: get_time(time_t t, long* days, long* mins, long* ticks)
645: {
646: /* time_t is secs since 1-1-1970 */
647: /* days since 1-1-1978 */
648: /* mins since midnight */
649: /* ticks past minute @ 50Hz */
650:
651: t -= diff;
652: *days = t / secs_per_day;
653: t -= *days * secs_per_day;
654: *mins = t / 60;
655: t -= *mins * 60;
656: *ticks = t * 50;
657: }
658:
659: static time_t
660: put_time(long days, long mins, long ticks)
661: {
662: time_t t;
663: t = ticks / 50;
664: t += mins * 60;
665: t += days * secs_per_day;
666: t += diff;
667:
668: return t;
669: }
670:
671:
672: typedef struct {
673: char *path;
674: DIR* dir;
675: } ExamineKey;
676:
677: /* Since ACTION_EXAMINE_NEXT is so braindamaged, we have to keep
678: * some of these around
679: */
680:
681: #define EXKEYS 100
682: static ExamineKey examine_keys[EXKEYS];
683: static int next_exkey = 0;
684:
685: static void
686: free_exkey(ExamineKey* ek)
687: {
688: free(ek->path);
689: ek->path = 0;
690: if(ek->dir)
691: closedir(ek->dir);
692: }
693:
694: static ExamineKey*
695: new_exkey(char *path)
696: {
697: ExamineKey* ek= &examine_keys[next_exkey++];
698: if(next_exkey==EXKEYS)
699: next_exkey = 0;
700: if(ek->path) {
701: free_exkey(ek);
702: }
703: ek->path = my_strdup(path);
704: ek->dir = 0;
705: return ek;
706: }
707:
708: static void
709: get_fileinfo(DosPacket* packet, CPTR info, char *buf)
710: {
711: struct stat statbuf;
712: long days, mins, ticks;
713:
714: if(-1 == stat(buf, &statbuf)) {
715: packet->res1 = DOS_FALSE;
716: packet->res2 = dos_errno();
717: } else {
718: put_long(info + 4, S_ISDIR(statbuf.st_mode) ? 2 : -3);
719: {
720: /* file name */
721: int i = 8;
722: int n;
723: char *x = strrchr(buf,'/');
724: if(x)
725: x++;
726: else
727: x = buf;
728: TRACE(("name=\"%s\"\n", x));
729: n = strlen(x);
730: if(n > 106) n = 106;
731: put_byte(info + i++, n);
732: while(n--)
733: put_byte(info + i++, *x++);
734: while(i < 108)
735: put_byte(info + i++, 0);
736: }
737: put_long(info + 116,
738: (S_IRUSR & statbuf.st_mode ? 0 : (1<<3)) |
739: (S_IWUSR & statbuf.st_mode ? 0 : (1<<2)) |
740: (S_IXUSR & statbuf.st_mode ? 0 : (1<<1)) |
741: (S_IWUSR & statbuf.st_mode ? 0 : (1<<0)));
742: put_long(info + 120, S_ISDIR(statbuf.st_mode) ? 2 : -3);
743: put_long(info + 124, statbuf.st_size);
744: put_long(info + 128, statbuf.st_blocks);
745: get_time(statbuf.st_mtime, &days, &mins, &ticks);
746: put_long(info + 132, days);
747: put_long(info + 136, mins);
748: put_long(info + 140, ticks);
749: put_long(info + 144, 0); /* no comment */
750: packet->res1 = DOS_TRUE;
751: }
752: }
753:
754: static void
755: do_examine(DosPacket* packet, ExamineKey* ek, CPTR info)
756: {
757: static char buf[1024];
758: struct dirent* de;
759:
760: if(!ek->dir) {
761: ek->dir = opendir(ek->path);
762: }
763: if(!ek->dir) {
764: free_exkey(ek);
765: packet->res1 = DOS_FALSE;
766: packet->res2 = ERROR_NO_MORE_ENTRIES;
767: return;
768: }
769:
770: de = readdir(ek->dir);
771:
772: while(de &&
773: (0 == strcmp(".", de->d_name) ||
774: 0 == strcmp("..", de->d_name)))
775: {
776: de = readdir(ek->dir);
777: }
778:
779: if(!de) {
780: TRACE(("no more entries\n"));
781: free_exkey(ek);
782: packet->res1 = DOS_FALSE;
783: packet->res2 = ERROR_NO_MORE_ENTRIES;
784: return;
785: }
786:
787: TRACE(("entry=\"%s\"\n", de->d_name));
788:
789: sprintf(buf, "%s/%s", ek->path, de->d_name);
790:
791: get_fileinfo(packet, info, buf);
792: }
793:
794: static void
795: action_examine_object(Unit* unit, DosPacket* packet)
796: {
797: CPTR lock = packet->arg1 << 2;
798: CPTR info = packet->arg2 << 2;
799: char *path;
800: ExamineKey* ek;
801:
802: TRACE(("ACTION_EXAMINE_OBJECT(0x%lx,0x%lx)\n", lock, info));
803: DUMPLOCK(lock);
804:
805: if(!lock) {
806: path = unit->ui.rootdir;
807: } else {
808: Key*k = (Key *)get_long(lock + 4);
809: path = k->path;
810: }
811:
812: get_fileinfo(packet, info, path);
813: ek = new_exkey(path);
814: put_long(info, (ULONG)ek);
815: }
816:
817: static void
818: action_examine_next(Unit* unit, DosPacket* packet)
819: {
820: CPTR lock = packet->arg1 << 2;
821: CPTR info = packet->arg2 << 2;
822:
823: TRACE(("ACTION_EXAMINE_NEXT(0x%lx,0x%lx)\n", lock, info));
824: DUMPLOCK(lock);
825:
826: do_examine(packet, (ExamineKey*)get_long(info), info);
827: }
828:
829: static void
830: do_find(Unit* unit, DosPacket* packet, mode_t mode)
831: {
832: CPTR fh = packet->arg1 << 2;
833: CPTR lock = packet->arg2 << 2;
834: CPTR name = packet->arg3 << 2;
835: Key *k;
836: struct stat st;
837:
838: TRACE(("ACTION_FIND_*(0x%lx,0x%lx,\"%s\",%d)\n",fh,lock,bstr(name),mode));
839: DUMPLOCK(lock);
840:
841: k = make_key(unit, lock, bstr(name));
842: if(!k) {
843: packet->res1 = DOS_FALSE;
844: packet->res2 = ERROR_NO_FREE_STORE;
845: return;
846: }
847:
848: /* Fixme: may not quite be right */
849: if (0 == stat (k->path, &st)) {
850: if (S_ISDIR (st.st_mode)) {
851: packet->res1 = DOS_FALSE;
852: packet->res2 = ERROR_OBJECT_WRONG_TYPE;
853: return;
854: }
855: }
856:
857: k->fd = open(k->path, mode, 0777);
858:
859: if(k->fd < 0) {
860: packet->res1 = DOS_FALSE;
861: packet->res2 = dos_errno();
862: free_key(k);
863: return;
864: }
865: success:
866: put_long(fh+36, (ULONG)k);
867:
868: packet->res1 = DOS_TRUE;
869: }
870:
871: static void
872: action_find_input(Unit* unit, DosPacket* packet)
873: {
874: do_find(unit, packet, O_RDONLY);
875: }
876:
877: static void
878: action_find_output(Unit* unit, DosPacket* packet)
879: {
880: if(unit->ui.readonly) {
881: packet->res1 = DOS_FALSE;
882: packet->res2 = ERROR_DISK_WRITE_PROTECTED;
883: return;
884: }
885: do_find(unit, packet, O_WRONLY|O_CREAT|O_TRUNC);
886: }
887:
888: static void
889: action_find_write(Unit* unit, DosPacket* packet)
890: {
891: if(unit->ui.readonly) {
892: packet->res1 = DOS_FALSE;
893: packet->res2 = ERROR_DISK_WRITE_PROTECTED;
894: return;
895: }
896: do_find(unit, packet, O_RDWR);
897: }
898:
899: static void
900: action_end(Unit* unit, DosPacket* packet)
901: {
902: Key*k;
903: TRACE(("ACTION_END(0x%lx)\n", packet->arg1));
904:
905: k = (Key*)(packet->arg1);
906: close(k->fd);
907: free_key(k);
908: packet->res1 = DOS_TRUE;
909: }
910:
911: static void
912: action_read(Unit* unit, DosPacket* packet)
913: {
914: Key*k = (Key*)(packet->arg1);
915: CPTR addr = packet->arg2;
916: long size = packet->arg3;
917: int actual;
918: char *buf;
919:
920: TRACE(("ACTION_READ(%s,0x%lx,%ld)\n",k->path,addr,size));
921:
922: /* ugh this is inefficient but easy */
923: buf = (char *)malloc(size);
924: if(!buf) {
925: packet->res1 = -1;
926: packet->res2 = ERROR_NO_FREE_STORE;
927: return;
928: }
929:
930: actual = read(k->fd, buf, size);
931:
932: packet->res1 = actual;
933:
934: if(actual > 0) {
935: int i;
936: unsigned char *bp = (unsigned char *)buf;
937: UWORD *realpt;
938: if (addr & 1) { /* Eeek! */
939: actual--;
940: put_byte(addr, *bp++);
941: addr++;
942: }
943: if (valid_address (addr, actual)) {
944: realpt = get_real_address (addr);
945: for (i = 0; i < (actual & ~1); i+=2) {
946: UWORD data = ((UWORD)(*bp++) << 8);
947: data |= *bp++;
948: *realpt++ = data;
949: }
950: if (actual & 1)
951: put_byte (addr + actual - 1, *bp);
952: } else {
953: /* fprintf (stderr, "unixfs warning: Bad pointer passed for read\n");*/
954: for(i = 0; i < actual; i++)
955: put_byte(addr + i, buf[i]);
956: }
957: } else {
958: packet->res2 = dos_errno();
959: }
960: free(buf);
961: }
962:
963: static void
964: action_write(Unit* unit, DosPacket* packet)
965: {
966: Key*k = (Key*)(packet->arg1);
967: CPTR addr = packet->arg2;
968: long size = packet->arg3;
969: char *buf;
970: int i;
971:
972: TRACE(("ACTION_WRITE(%s,0x%lx,%ld)\n",k->path,addr,size));
973:
974: if(unit->ui.readonly) {
975: packet->res1 = DOS_FALSE;
976: packet->res2 = ERROR_DISK_WRITE_PROTECTED;
977: return;
978: }
979:
980: /* ugh this is inefficient but easy */
981: buf = (char *)malloc(size);
982: if(!buf) {
983: packet->res1 = -1;
984: packet->res2 = ERROR_NO_FREE_STORE;
985: return;
986: }
987:
988: for(i = 0; i < size; i++)
989: buf[i] = get_byte(addr + i);
990:
991: packet->res1 = write(k->fd, buf, size);
992: if(packet->res1 != size)
993: packet->res2 = dos_errno();
994:
995: free(buf);
996: }
997:
998: static void
999: action_seek(Unit* unit, DosPacket* packet)
1000: {
1001: Key* k = (Key*) (packet->arg1);
1002: long pos = packet->arg2;
1003: long mode = packet->arg3;
1004: off_t res;
1005: long old;
1006: int whence = SEEK_CUR;
1007: if(mode > 0) whence = SEEK_END;
1008: if(mode < 0) whence = SEEK_SET;
1009:
1010: TRACE(("ACTION_SEEK(%s,%d,%d)\n",k->path,pos,mode));
1011:
1012: old = lseek(k->fd, 0, SEEK_CUR);
1013: res = lseek(k->fd, pos, whence);
1014:
1015: if(-1 == res)
1016: packet->res1 = res;
1017: else
1018: packet->res1 = old;
1019: }
1020:
1021: static void
1022: action_set_protect(Unit* unit, DosPacket* packet)
1023: {
1024: CPTR lock = packet->arg2 << 2;
1025: CPTR name = packet->arg3 << 2;
1026: ULONG mask = packet->arg4;
1027: struct stat statbuf;
1028: mode_t mode;
1029: Key *k;
1030:
1031: TRACE(("ACTION_SET_PROTECT(0x%lx,\"%s\",0x%lx)\n",lock,bstr(name),mask));
1032:
1033: if(unit->ui.readonly) {
1034: packet->res1 = DOS_FALSE;
1035: packet->res2 = ERROR_DISK_WRITE_PROTECTED;
1036: return;
1037: }
1038:
1039: k = make_key(unit, lock, bstr(name));
1040: if(!k) {
1041: packet->res1 = DOS_FALSE;
1042: packet->res2 = ERROR_NO_FREE_STORE;
1043: return;
1044: }
1045:
1046: if(-1 == stat(k->path, &statbuf)) {
1047: free_key(k);
1048: packet->res1 = DOS_FALSE;
1049: packet->res2 = ERROR_OBJECT_NOT_FOUND;
1050: return;
1051: }
1052:
1053: mode = statbuf.st_mode;
1054:
1055: if(mask & (1 << 3))
1056: mode &= ~S_IRUSR;
1057: else
1058: mode |= S_IRUSR;
1059:
1060: if(mask & (1 << 2) || mask & (1 << 0))
1061: mode &= ~S_IWUSR;
1062: else
1063: mode |= S_IWUSR;
1064:
1065: if(mask & (1 << 1))
1066: mode &= ~S_IXUSR;
1067: else
1068: mode |= S_IXUSR;
1069:
1070: if(-1 == chmod(k->path, mode)) {
1071: packet->res1 = DOS_FALSE;
1072: packet->res2 = dos_errno();
1073: } else {
1074: packet->res1 = DOS_TRUE;
1075: }
1076: free_key(k);
1077: }
1078:
1079: static void
1080: action_same_lock(Unit* unit, DosPacket* packet)
1081: {
1082: CPTR lock1 = packet->arg1 << 2;
1083: CPTR lock2 = packet->arg2 << 2;
1084:
1085: TRACE(("ACTION_SAME_LOCK(0x%lx,0x%lx)\n",lock1,lock2));
1086: DUMPLOCK(lock1); DUMPLOCK(lock2);
1087:
1088: if(!lock1 || !lock2) {
1089: packet->res1 = (lock1 == lock2) ? DOS_TRUE : DOS_FALSE;
1090: } else {
1091: Key* key1 = (Key*) get_long(lock1 + 4);
1092: Key* key2 = (Key*) get_long(lock2 + 4);
1093: packet->res1 = (0 == strcmp(key1->path, key2->path)) ? DOS_TRUE : DOS_FALSE;
1094: }
1095: }
1096:
1097: static void
1098: action_parent(Unit* unit, DosPacket* packet)
1099: {
1100: CPTR lock = packet->arg1 << 2;
1101: Key*k;
1102:
1103: TRACE(("ACTION_PARENT(0x%lx)\n",lock));
1104:
1105: if(!lock) {
1106: packet->res1 = 0;
1107: packet->res2 = 0;
1108: return;
1109: }
1110:
1111: k = dup_key((Key*) get_long(lock + 4));
1112: if(0 == strcmp(k->path, unit->ui.rootdir)) {
1113: free_key(k);
1114: packet->res1 = 0;
1115: packet->res2 = 0;
1116: return;
1117: }
1118: {
1119: char *x = strrchr(k->path,'/');
1120: if(!x) {
1121: free_key(k);
1122: packet->res1 = 0;
1123: packet->res2 = 0;
1124: return;
1125: } else {
1126: *x = '\0';
1127: }
1128: }
1129: packet->res1 = make_lock(unit, k, -2) >> 2;
1130: }
1131:
1132: static void
1133: action_create_dir(Unit* unit, DosPacket* packet)
1134: {
1135: CPTR lock = packet->arg1 << 2;
1136: CPTR name = packet->arg2 << 2;
1137: Key* k;
1138:
1139: TRACE(("ACTION_CREATE_DIR(0x%lx,\"%s\")\n",lock,bstr(name)));
1140:
1141: if(unit->ui.readonly) {
1142: packet->res1 = DOS_FALSE;
1143: packet->res2 = ERROR_DISK_WRITE_PROTECTED;
1144: return;
1145: }
1146:
1147: k = make_key(unit, lock, bstr(name));
1148:
1149: if(!k) {
1150: packet->res1 = DOS_FALSE;
1151: packet->res2 = ERROR_NO_FREE_STORE;
1152: return;
1153: }
1154: if(-1 == mkdir(k->path, 0777)) {
1155: packet->res1 = DOS_FALSE;
1156: packet->res2 = dos_errno();
1157: free_key(k);
1158: return;
1159: }
1160: packet->res1 = make_lock(unit, k, -2) >> 2;
1161: }
1162:
1163: static void
1164: action_delete_object(Unit* unit, DosPacket* packet)
1165: {
1166: CPTR lock = packet->arg1 << 2;
1167: CPTR name = packet->arg2 << 2;
1168: Key* k;
1169: struct stat statbuf;
1170:
1171: TRACE(("ACTION_DELETE_OBJECT(0x%lx,\"%s\")\n",lock,bstr(name)));
1172:
1173: if(unit->ui.readonly) {
1174: packet->res1 = DOS_FALSE;
1175: packet->res2 = ERROR_DISK_WRITE_PROTECTED;
1176: return;
1177: }
1178:
1179: k = make_key(unit, lock, bstr(name));
1180:
1181: if(!k) {
1182: packet->res1 = DOS_FALSE;
1183: packet->res2 = ERROR_NO_FREE_STORE;
1184: return;
1185: }
1186: if(-1 == stat(k->path, &statbuf)) {
1187: packet->res1 = DOS_FALSE;
1188: packet->res2 = dos_errno();
1189: free_key(k);
1190: return;
1191: }
1192: if(S_ISDIR(statbuf.st_mode)) {
1193: if(-1 == rmdir(k->path)) {
1194: packet->res1 = DOS_FALSE;
1195: packet->res2 = dos_errno();
1196: free_key(k);
1197: return;
1198: }
1199: } else {
1200: if(-1 == unlink(k->path)) {
1201: packet->res1 = DOS_FALSE;
1202: packet->res2 = dos_errno();
1203: free_key(k);
1204: return;
1205: }
1206: }
1207: free_key(k);
1208: packet->res1 = DOS_TRUE;
1209: }
1210:
1211: static void
1212: action_set_date(Unit* unit, DosPacket* packet)
1213: {
1214: CPTR lock = packet->arg2 << 2;
1215: CPTR name = packet->arg3 << 2;
1216: CPTR date = packet->arg4;
1217: Key* k;
1218: struct utimbuf ut;
1219:
1220: TRACE(("ACTION_SET_DATE(0x%lx,\"%s\")\n",lock,bstr(name)));
1221:
1222: if(unit->ui.readonly) {
1223: packet->res1 = DOS_FALSE;
1224: packet->res2 = ERROR_DISK_WRITE_PROTECTED;
1225: return;
1226: }
1227:
1228: ut.actime = ut.modtime = put_time(get_long(date),get_long(date+4),get_long(date+8));
1229: k = make_key(unit, lock, bstr(name));
1230:
1231: if(!k) {
1232: packet->res1 = DOS_FALSE;
1233: packet->res2 = ERROR_NO_FREE_STORE;
1234: return;
1235: }
1236: if(-1 == utime(k->path, &ut)) {
1237: packet->res1 = DOS_FALSE;
1238: packet->res2 = dos_errno();
1239: free_key(k);
1240: return;
1241: }
1242: free_key(k);
1243: packet->res1 = DOS_TRUE;
1244: }
1245:
1246: static void
1247: action_rename_object(Unit* unit, DosPacket* packet)
1248: {
1249: CPTR lock1 = packet->arg1 << 2;
1250: CPTR name1 = packet->arg2 << 2;
1251: Key* k1;
1252: CPTR lock2 = packet->arg3 << 2;
1253: CPTR name2 = packet->arg4 << 2;
1254: Key* k2;
1255:
1256: TRACE(("ACTION_RENAME_OBJECT(0x%lx,\"%s\",",lock1,bstr(name1)));
1257: TRACE(("0x%lx,\"%s\")\n",lock2,bstr(name2)));
1258:
1259: if(unit->ui.readonly) {
1260: packet->res1 = DOS_FALSE;
1261: packet->res2 = ERROR_DISK_WRITE_PROTECTED;
1262: return;
1263: }
1264:
1265: k1 = make_key(unit, lock1, bstr(name1));
1266: if(!k1) {
1267: packet->res1 = DOS_FALSE;
1268: packet->res2 = ERROR_NO_FREE_STORE;
1269: return;
1270: }
1271: k2 = make_key(unit, lock2, bstr(name2));
1272: if(!k2) {
1273: free_key(k1);
1274: packet->res1 = DOS_FALSE;
1275: packet->res2 = ERROR_NO_FREE_STORE;
1276: return;
1277: }
1278:
1279: if(-1 == rename(k1->path, k2->path)) {
1280: packet->res1 = DOS_FALSE;
1281: packet->res2 = dos_errno();
1282: free_key(k1);
1283: free_key(k2);
1284: return;
1285: }
1286: free_key(k1);
1287: free_key(k2);
1288: packet->res1 = DOS_TRUE;
1289: }
1290:
1291: static void
1292: action_current_volume(Unit* unit, DosPacket* packet)
1293: {
1294: packet->res1 = unit->volume >> 2;
1295: }
1296:
1297: static void
1298: action_rename_disk(Unit* unit, DosPacket* packet)
1299: {
1300: CPTR name = packet->arg1 << 2;
1301: int i;
1302: int namelen;
1303:
1304: TRACE(("ACTION_RENAME_DISK(\"%s\")\n", bstr(name)));
1305:
1306: if(unit->ui.readonly) {
1307: packet->res1 = DOS_FALSE;
1308: packet->res2 = ERROR_DISK_WRITE_PROTECTED;
1309: return;
1310: }
1311:
1312: /* get volume name */
1313: namelen = get_byte(name++);
1314: free(unit->ui.volname);
1315: unit->ui.volname = (char *) malloc(namelen + 1);
1316: for(i = 0; i < namelen; i++)
1317: unit->ui.volname[i] = get_byte(name++);
1318: unit->ui.volname[i] = 0;
1319:
1320: put_byte(unit->volume + 44, namelen);
1321: for(i = 0; i < namelen; i++)
1322: put_byte(unit->volume + 45 + i, unit->ui.volname[i]);
1323:
1324: packet->res1 = DOS_TRUE;
1325: }
1326:
1327: static void
1328: action_is_filesystem(Unit* unit, DosPacket* packet)
1329: {
1330: packet->res1 = DOS_TRUE;
1331: }
1332:
1333: static void
1334: action_flush(Unit* unit, DosPacket* packet)
1335: {
1336: /* sync(); */ /* pretty drastic, eh */
1337: packet->res1 = DOS_TRUE;
1338: }
1339:
1340: static ULONG
1341: filesys_handler(void)
1342: {
1343: DosPacket packet;
1344: Unit *unit = find_unit(regs.a[5]);
1345:
1346: /* got DosPacket in A4 */
1347: packet.addr = regs.a[4];
1348: packet.type = get_long(packet.addr + dp_Type);
1349: packet.res1 = get_long(packet.addr + dp_Res1);
1350: packet.res2 = get_long(packet.addr + dp_Res2);
1351: packet.arg1 = get_long(packet.addr + dp_Arg1);
1352: packet.arg2 = get_long(packet.addr + dp_Arg2);
1353: packet.arg3 = get_long(packet.addr + dp_Arg3);
1354: packet.arg4 = get_long(packet.addr + dp_Arg4);
1355:
1356: if(!unit) {
1357: startup(&packet);
1358: put_long(packet.addr + dp_Res1, packet.res1);
1359: put_long(packet.addr + dp_Res2, packet.res2);
1360: return 0;
1361: }
1362:
1363: if(!unit->volume) {
1364: printf("no volume\n");
1365: return 0;
1366: }
1367:
1368: switch(packet.type) {
1369: case ACTION_LOCATE_OBJECT:
1370: action_lock(unit, &packet);
1371: break;
1372:
1373: case ACTION_FREE_LOCK:
1374: action_free_lock(unit, &packet);
1375: break;
1376:
1377: case ACTION_COPY_DIR:
1378: action_dup_lock(unit, &packet);
1379: break;
1380:
1381: case ACTION_DISK_INFO:
1382: action_disk_info(unit, &packet);
1383: break;
1384:
1385: case ACTION_INFO:
1386: action_info(unit, &packet);
1387: break;
1388:
1389: case ACTION_EXAMINE_OBJECT:
1390: action_examine_object(unit, &packet);
1391: break;
1392:
1393: case ACTION_EXAMINE_NEXT:
1394: action_examine_next(unit, &packet);
1395: break;
1396:
1397: case ACTION_FIND_INPUT:
1398: action_find_input(unit, &packet);
1399: break;
1400:
1401: case ACTION_FIND_WRITE:
1402: action_find_write(unit, &packet);
1403: break;
1404:
1405: case ACTION_FIND_OUTPUT:
1406: action_find_output(unit, &packet);
1407: break;
1408:
1409: case ACTION_END:
1410: action_end(unit, &packet);
1411: break;
1412:
1413: case ACTION_READ:
1414: action_read(unit, &packet);
1415: break;
1416:
1417: case ACTION_WRITE:
1418: action_write(unit, &packet);
1419: break;
1420:
1421: case ACTION_SEEK:
1422: action_seek(unit, &packet);
1423: break;
1424:
1425: case ACTION_SET_PROTECT:
1426: action_set_protect(unit, &packet);
1427: break;
1428:
1429: case ACTION_SAME_LOCK:
1430: action_same_lock(unit, &packet);
1431: break;
1432:
1433: case ACTION_PARENT:
1434: action_parent(unit, &packet);
1435: break;
1436:
1437: case ACTION_CREATE_DIR:
1438: action_create_dir(unit, &packet);
1439: break;
1440:
1441: case ACTION_DELETE_OBJECT:
1442: action_delete_object(unit, &packet);
1443: break;
1444:
1445: case ACTION_RENAME_OBJECT:
1446: action_rename_object(unit, &packet);
1447: break;
1448:
1449: case ACTION_SET_DATE:
1450: action_set_date(unit, &packet);
1451: break;
1452:
1453: case ACTION_CURRENT_VOLUME:
1454: action_current_volume(unit, &packet);
1455: break;
1456:
1457: case ACTION_RENAME_DISK:
1458: action_rename_disk(unit, &packet);
1459: break;
1460:
1461: case ACTION_IS_FILESYSTEM:
1462: action_is_filesystem(unit, &packet);
1463: break;
1464:
1465: case ACTION_FLUSH:
1466: action_flush(unit, &packet);
1467: break;
1468:
1469: default:
1470: TRACE(("*** UNSUPPORTED PACKET %ld\n", packet.type));
1471: packet.res1 = DOS_FALSE;
1472: packet.res2 = ERROR_ACTION_NOT_KNOWN;
1473: break;
1474: }
1475:
1476: put_long(packet.addr + dp_Res1, packet.res1);
1477: put_long(packet.addr + dp_Res2, packet.res2);
1478: TRACE(("reply: %8lx, %ld\n", packet.res1, packet.res2));
1479:
1480: return 0;
1481: }
1482:
1483: static ULONG
1484: filesys_init(void)
1485: {
1486: ULONG tmp1, tmp2;
1487: bool have36 = false;
1488: int i;
1489:
1490: regs.d[0] = 88; regs.d[1] = 1; /* MEMF_PUBLIC */
1491: tmp1 = CallLib (regs.a[6], -198); /* AllocMem() */
1492: if (tmp1 == 0) {
1493: fprintf(stderr, "Not enough memory for filesystem!\n");
1494: return 0;
1495: }
1496:
1497: /* Open expansion.lib */
1498: regs.d[0] = 36; /* Let's try this... */
1499: regs.a[1] = explibname;
1500: regs.a[4] = CallLib (regs.a[6], -552); /* OpenLibrary() */
1501: if (regs.a[4])
1502: have36 = true;
1503: else {
1504: regs.d[0] = 0;
1505: regs.a[1] = explibname;
1506: regs.a[4] = CallLib (regs.a[6], -552); /* OpenLibrary() */
1507: }
1508: put_long (tmp1+4, fsdevname);
1509: put_long (tmp1+12, 0); /* Device flags */
1510: put_long (tmp1+16, 16); /* Env. size */
1511: put_long (tmp1+20, 128); /* 512 bytes/block */
1512: put_long (tmp1+24, 0); /* unused */
1513: put_long (tmp1+28, 1); /* heads */
1514: put_long (tmp1+32, 1); /* unused */
1515: put_long (tmp1+36, 32); /* secs per track */
1516: put_long (tmp1+40, 1); /* reserved blocks */
1517: put_long (tmp1+44, 0); /* unused */
1518: put_long (tmp1+48, 0); /* interleave */
1519: put_long (tmp1+52, 0); /* lowCyl */
1520: put_long (tmp1+56, 511); /* upperCyl */
1521: put_long (tmp1+60, 0); /* Number of buffers */
1522: put_long (tmp1+64, 0); /* Buffer mem type */
1523: put_long (tmp1+68, 0x7FFFFFFF); /* largest transfer */
1524: put_long (tmp1+72, ~1); /* addMask (?) */
1525: put_long (tmp1+76, (ULONG)-1); /* bootPri */
1526: if (have36)
1527: put_long (tmp1+80, 0x444f5301); /* DOS\1 */
1528: else
1529: put_long (tmp1+80, 0x444f5300); /* DOS\0 */
1530:
1531: put_long (tmp1+84, 0); /* pad */
1532:
1533: /* re-use the same parameter packet to make each
1534: * dos node, which will then get tweaked
1535: */
1536: for(i = 0; i < num_units; i++) {
1537: put_long (tmp1, devnameaddr[i]);
1538: put_long (tmp1+8, i); /* Unit no. (not really necessary) */
1539: regs.a[0] = tmp1;
1540: tmp2 = CallLib (regs.a[4], -144); /* MakeDosNode() */
1541: put_long(tmp2+8, 0x0); /* dn_Task */
1542: put_long(tmp2+16, 0x0); /* dn_Handler */
1543: put_long(tmp2+20, 4000); /* dn_StackSize */
1544: put_long(tmp2+32, filesysseglist >> 2); /* dn_SegList */
1545: put_long(tmp2+36, (ULONG)-1); /* dn_GlobalVec */
1546:
1547: regs.a[0] = tmp2;
1548: regs.d[0] = (ULONG)-1;
1549: regs.a[1] = 0;
1550: regs.d[1] = 0;
1551: CallLib (regs.a[4], -150); /* AddDosNode() */
1552: }
1553:
1554: regs.a[1] = tmp1;
1555: regs.d[0] = 88;
1556: CallLib (regs.a[6], -210); /* FreeMem() */
1557:
1558: regs.a[1] = regs.a[4];
1559: CallLib (regs.a[6], -414); /* CloseLibrary() */
1560:
1561: return 0;
1562: }
1563:
1564: void
1565: filesys_install(void)
1566: {
1567: ULONG begin, end, resname, resid;
1568: int i;
1569:
1570: if(0 == num_units)
1571: return;
1572:
1573: resname = ds("UAEunixfs.resource");
1574: resid = ds("UAE unixfs 0.1");
1575:
1576: doslibname = ds("dos.library");
1577: fsdevname = ds("unixfs.device"); /* does not really exist */
1578:
1579: for(i = 0; i < num_units; i++) {
1580: devnameaddr[i] = ds(ui[i].devname);
1581: }
1582:
1583: begin = here();
1584: dw(0x4AFC); /* RTC_MATCHWORD */
1585: dl(begin); /* our start address */
1586: dl(0); /* Continue scan here */
1587: dw(0x0101); /* RTF_COLDSTART; Version 1 */
1588: dw(0x0805); /* NT_RESOURCE; pri 5 */
1589: dl(resname); /* name */
1590: dl(resid); /* ID */
1591: dl(here() + 4); /* Init area: directly after this */
1592:
1593: calltrap(deftrap(filesys_init)); dw(RTS);
1594:
1595: /* align */
1596: align(4);
1597: /* Fake seglist */
1598: dl(16);
1599: filesysseglist = here();
1600: dl(0); /* NextSeg */
1601:
1602: /* start of code */
1603:
1604: /* I don't trust calling functions that Wait() directly,
1605: * so here's a little bit of 68000 code to receive and send our
1606: * DosPackets
1607: */
1608: dw(0x2c79); dl(4); /* move.l $4,a6 */
1609: dw(0x2279); dl(0); /* move.l 0,a1 */
1610: dw(0x4eae); dw(0xfeda); /* jsr FindTask(a6) */
1611: dw(0x2040); /* move.l d0,a0 */
1612: dw(0x4be8); dw(0x005c); /* lea.l pr_MsgPort(a0),a5 */
1613: /* loop: */
1614: dw(0x204d); /* move.l a5,a0 */
1615: dw(0x4eae); dw(0xfe80); /* jsr WaitPort(a6) */
1616: dw(0x204d); /* move.l a5,a0 */
1617: dw(0x4eae); dw(0xfe8c); /* jsr GetMsg(a6) */
1618: dw(0x2840); /* move.l d0,a4 */
1619: dw(0x286c); dw(10); /* move.l LN_NAME(a4),a4 */
1620: calltrap(deftrap(filesys_handler));
1621: dw(0x226c); dw(0); /* move.l dp_Link(a4),a1 */
1622: dw(0x206c); dw(4); /* move.l dp_Port(a4),a0 */
1623: dw(0x294d); dw(4); /* move.l a5,dp_Port(a4) */
1624: dw(0x4eae); dw(0xfe92); /* jsr PutMsg(a6) */
1625: dw(0x60d6); /* bra.s loop */
1626:
1627: end = here();
1628: org(begin + 6);
1629: dl(end);
1630:
1631: org(end);
1632: }
1633:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.