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