![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dosdir.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Atari MiNT] / MiNT / src|
Return to dosdir.c CVS log | Up to [Atari MiNT] / MiNT / src |
1.1 root 1: /*
2:
3: Copyright 1990,1991,1992 Eric R. Smith. All rights reserved.
4:
5: */
6:
7:
8:
9: /* DOS directory functions */
10:
11:
12:
13: #include "mint.h"
14:
15:
16:
17: /* change to a new drive: should always return a map of valid drives */
18:
19:
20:
21: long
22:
23: d_setdrv(d)
24:
25: int d;
26:
27: {
28:
29: long r;
30:
31: extern long dosdrvs; /* in filesys.c */
32:
33:
34:
35: r = drvmap() | dosdrvs | PSEUDODRVS;
36:
37:
38:
39: TRACE("Dsetdrv(%d)", d);
40:
41: if (d < 0 || d >= NUM_DRIVES || (r & (1L << d)) == 0) {
42:
43: DEBUG("Dsetdrv: invalid drive %d", d);
44:
45: return r;
46:
47: }
48:
49:
50:
51: curproc->base->p_defdrv = curproc->curdrv = d;
52:
53: return r;
54:
55: }
56:
57:
58:
59: long
60:
61: d_getdrv()
62:
63: {
64:
65: TRACE("Dgetdrv");
66:
67: return curproc->curdrv;
68:
69: }
70:
71:
72:
73: long
74:
75: d_free(buf, d)
76:
77: long *buf;
78:
79: int d;
80:
81: {
82:
83: fcookie *dir;
84:
85:
86:
87: TRACE("Dfree(%d)", d);
88:
89:
90:
91: /* drive 0 means current drive, otherwise it's d-1 */
92:
93: if (d)
94:
95: d = d-1;
96:
97: else
98:
99: d = curproc->curdrv;
100:
101:
102:
103: if (d < 0 || d >= NUM_DRIVES)
104:
105: return EDRIVE;
106:
107:
108:
109: /* check for a media change -- we don't care much either way, but it
110:
111: * does keep the results more accurate
112:
113: */
114:
115: (void)disk_changed(d);
116:
117:
118:
119: /* use current directory, not root, since it's more likely that
120:
121: * programs are interested in the latter (this makes U: work much
122:
123: * better)
124:
125: */
126:
127: dir = &curproc->curdir[d];
128:
129: if (!dir->fs) {
130:
131: DEBUG("Dfree: bad drive");
132:
133: return EDRIVE;
134:
135: }
136:
137:
138:
139: return (*dir->fs->dfree)(dir, buf);
140:
141: }
142:
143:
144:
145: /* temp1 is a convenient place for path2fs puts the last component of
146:
147: * the path name
148:
149: */
150:
151:
152:
153: extern char temp1[PATH_MAX]; /* in filesys.c */
154:
155:
156:
157: long
158:
159: d_create(path)
160:
161: const char *path;
162:
163: {
164:
165: fcookie dir;
166:
167: long r;
168:
169:
170:
171: TRACE("Dcreate(%s)", path);
172:
173:
174:
175: r = path2cookie(path, temp1, &dir);
176:
177: if (r) {
178:
179: DEBUG("Dcreate(%s): returning %ld", path, r);
180:
181: return r; /* an error occured */
182:
183: }
184:
185: /* check for write permission on the directory */
186:
187: r = dir_access(&dir, S_IWOTH);
188:
189: if (r) {
190:
191: DEBUG("Dcreate(%s): access to directory denied",path);
192:
193: return r;
194:
195: }
196:
197: return (*dir.fs->mkdir)(&dir, temp1, DEFAULT_DIRMODE & ~curproc->umask);
198:
199: }
200:
201:
202:
203: long
204:
205: d_delete(path)
206:
207: const char *path;
208:
209: {
210:
211: fcookie parentdir, targdir;
212:
213: long r;
214:
215: PROC *p;
216:
217: int i;
218:
219: XATTR xattr;
220:
221:
222:
223: TRACE("Ddelete(%s)", path);
224:
225:
226:
227: r = path2cookie(path, temp1, &parentdir);
228:
229:
230:
231: if (r) {
232:
233: DEBUG("Ddelete(%s): error %lx", path, r);
234:
235: return r;
236:
237: }
238:
239: /* check for write permission on the directory which the target
240:
241: * is located
242:
243: */
244:
245: if (r = dir_access(&parentdir, S_IWOTH)) {
246:
247: DEBUG("Ddelete(%s): access to directory denied", path);
248:
249: return r;
250:
251: }
252:
253:
254:
255: /* now get the info on the file itself */
256:
257:
258:
259: r = relpath2cookie(&parentdir, temp1, NULL, &targdir, 0);
260:
261: if (r || (r = (*targdir.fs->getxattr)(&targdir, &xattr))) {
262:
263: DEBUG("Ddelete: error %ld on %s", r, path);
264:
265: return r;
266:
267: }
268:
269:
270:
271: /* if the "directory" is a symbolic link, really unlink it */
272:
273: if ( (xattr.mode & S_IFMT) == S_IFLNK ) {
274:
275: return (*parentdir.fs->remove)(&parentdir, temp1);
276:
277: }
278:
279: if ( (xattr.mode & S_IFMT) != S_IFDIR ) {
280:
281: DEBUG("Ddelete: %s is not a directory", path);
282:
283: return EPTHNF;
284:
285: }
286:
287:
288:
289: /* don't delete anyone else's root or current directory */
290:
291: for (p = proclist; p; p = p->gl_next) {
292:
293: if (p->wait_q == ZOMBIE_Q || p->wait_q == TSR_Q)
294:
295: continue;
296:
297: for (i = 0; i < NUM_DRIVES; i++) {
298:
299: if (samefile(&targdir, &p->root[i])) {
300:
301: DEBUG("Ddelete: directory %s is a root directory",
302:
303: path);
304:
305: return EACCDN;
306:
307: } else if (samefile(&targdir, &p->curdir[i])) {
308:
309: if (i == p->curdrv && p != curproc)
310:
311: DEBUG("Ddelete: directory %s is in use",
312:
313: path);
314:
315: else {
316:
317: p->curdir[i] = p->root[i];
318:
319: }
320:
321: }
322:
323: }
324:
325: }
326:
327:
328:
329: return (*parentdir.fs->rmdir)(&parentdir, temp1);
330:
331: }
332:
333:
334:
335: long
336:
337: d_setpath(path)
338:
339: const char *path;
340:
341: {
342:
343: fcookie dir;
344:
345: int drv = curproc->curdrv;
346:
347: int i;
348:
349: char c;
350:
351: long r;
352:
353: XATTR xattr;
354:
355:
356:
357: TRACE("Dsetpath(%s)", path);
358:
359:
360:
361: r = path2cookie(path, follow_links, &dir);
362:
363:
364:
365: if (r) {
366:
367: DEBUG("Dsetpath(%s): returning %ld", path, r);
368:
369: return r;
370:
371: }
372:
373:
374:
375: if (path[0] && path[1] == ':') {
376:
377: c = *path;
378:
379: if (c >= 'a' && c <= 'z')
380:
381: drv = c-'a';
382:
383: else if (c >= 'A' && c <= 'Z')
384:
385: drv = c-'A';
386:
387: }
388:
389:
390:
391: r = (*dir.fs->getxattr)(&dir, &xattr);
392:
393:
394:
395: if (r < 0) {
396:
397: DEBUG("Dsetpath: file '%s': attributes not found", path);
398:
399: return r;
400:
401: }
402:
403:
404:
405: if (!(xattr.attr & FA_DIR)) {
406:
407: DEBUG("Dsetpath(%s): not a directory",path);
408:
409: return EPTHNF;
410:
411: }
412:
413:
414:
415: /*
416:
417: * watch out for symbolic links; if c:\foo is a link to d:\bar, then
418:
419: * "cd c:\foo" should also change the drive to d:
420:
421: */
422:
423: if (drv != UNIDRV && dir.dev != curproc->root[drv].dev) {
424:
425: for (i = 0; i < NUM_DRIVES; i++) {
426:
427: if (curproc->root[i].dev == dir.dev &&
428:
429: curproc->root[i].fs == dir.fs) {
430:
431: if (drv == curproc->curdrv)
432:
433: curproc->curdrv = i;
434:
435: drv = i;
436:
437: break;
438:
439: }
440:
441: }
442:
443: }
444:
445: curproc->curdir[drv] = dir;
446:
447: return 0;
448:
449: }
450:
451:
452:
453: long
454:
455: d_getpath(path, drv)
456:
457: char *path;
458:
459: int drv;
460:
461: {
462:
463: fcookie *dir, *root;
464:
465:
466:
467: TRACE("Dgetpath(%c)", drv + '@');
468:
469: if (drv < 0 || drv > NUM_DRIVES)
470:
471: return EDRIVE;
472:
473:
474:
475: drv = (drv == 0) ? curproc->curdrv : drv-1;
476:
477:
478:
479: root = &curproc->root[drv];
480:
481:
482:
483: if (!root->fs) { /* maybe not initialized yet? */
484:
485: changedrv(drv);
486:
487: root = &curproc->curdir[drv];
488:
489: if (!root->fs)
490:
491: return EDRIVE;
492:
493: }
494:
495: dir = &curproc->curdir[drv];
496:
497:
498:
499: return (*root->fs->getname)(root, dir, path);
500:
501: }
502:
503:
504:
505: long
506:
507: f_setdta(dta)
508:
509: DTABUF *dta;
510:
511: {
512:
513:
514:
515: TRACE("Fsetdta: %lx", dta);
516:
517: curproc->dta = dta;
518:
519: curproc->base->p_dta = (char *)dta;
520:
521: return 0;
522:
523: }
524:
525:
526:
527: long
528:
529: f_getdta()
530:
531: {
532:
533: long r;
534:
535:
536:
537: r = (long)curproc->dta;
538:
539: TRACE("Fgetdta: returning %lx", r);
540:
541: return r;
542:
543: }
544:
545:
546:
547: /*
548:
549: * Fsfirst/next are actually implemented in terms of opendir/readdir/closedir.
550:
551: */
552:
553:
554:
555: long
556:
557: f_sfirst(path, attrib)
558:
559: const char *path;
560:
561: int attrib;
562:
563: {
564:
565: char *s, *slash;
566:
567: FILESYS *fs;
568:
569: fcookie dir, newdir;
570:
571: DTABUF *dta;
572:
573: DIR *dirh;
574:
575: XATTR xattr;
576:
577: long r;
578:
579: int i, havelabel;
580:
581:
582:
583: /* a special hack just for ksh0.4 -- it uses '/' in a search where
584:
585: * '\' was better. Note that normally we shouldn't go around changing
586:
587: * the strings that people send us!
588:
589: */
590:
591: if (curproc->domain == DOM_MINT && !strncmp(path, "x:/*.", 5))
592:
593: ((char *)path)[2] = '\\';
594:
595:
596:
597: TRACE("Fsfirst(%s, %x)", path, attrib);
598:
599:
600:
601: r = path2cookie(path, temp1, &dir);
602:
603:
604:
605: if (r) {
606:
607: DEBUG("Fsfirst(%s): path2cookie returned %ld", path, r);
608:
609: return r;
610:
611: }
612:
613:
614:
615: /*
616:
617: * we need to split the last name (which may be a pattern) off from
618:
619: * the rest of the path, even if FS_KNOPARSE is true
620:
621: */
622:
623: slash = 0;
624:
625: s = temp1;
626:
627: while (*s) {
628:
629: if (*s == '\\')
630:
631: slash = s;
632:
633: s++;
634:
635: }
636:
637:
638:
639: if (slash) {
640:
641: *slash++ = 0; /* slash now points to a name or pattern */
642:
643: r = relpath2cookie(&dir, temp1, follow_links, &newdir, 0);
644:
645: if (r) {
646:
647: DEBUG("Fsfirst(%s): lookup returned %ld", path, r);
648:
649: return r;
650:
651: }
652:
653: dir = newdir;
654:
655: } else {
656:
657: slash = temp1;
658:
659: }
660:
661:
662:
663: /* BUG? what if there really is an empty file name? */
664:
665: if (!*slash) {
666:
667: DEBUG("Fsfirst: empty pattern");
668:
669: return EFILNF;
670:
671: }
672:
673:
674:
675: fs = dir.fs;
676:
677: dta = curproc->dta;
678:
679:
680:
681: /* Now, see if we can find a DIR slot for the search. We use the following
682:
683: * heuristics to try to avoid destroying a slot:
684:
685: * (1) if the search doesn't use wildcards, don't bother with a slot
686:
687: * (2) if an existing slot was for the same DTA address, re-use it
688:
689: * (3) if there's a free slot, re-use it. Slots are freed when the
690:
691: * corresponding search is terminated.
692:
693: */
694:
695:
696:
697: for (i = 0; i < NUM_SEARCH; i++) {
698:
699: if (curproc->srchdta[i] == dta) {
700:
701: dirh = &curproc->srchdir[i];
702:
703: if (dirh->fc.fs) {
704:
705: (*dirh->fc.fs->closedir)(dirh);
706:
707: dirh->fc.fs = 0;
708:
709: }
710:
711: curproc->srchdta[i] = 0; /* slot is now free */
712:
713: }
714:
715: }
716:
717:
718:
719: /* copy the pattern over into dta_pat into TOS 8.3 form */
720:
721: /* remember that "slash" now points at the pattern (it follows the last \,
722:
723: if any)
724:
725: */
726:
727: copy8_3(dta->dta_pat, slash);
728:
729:
730:
731: /* if attrib & FA_LABEL, read the volume label */
732:
733: /* BUG: the label date and time are wrong. Does it matter?
734:
735: */
736:
737: havelabel = 0;
738:
739: if (attrib & FA_LABEL) {
740:
741: r = (*fs->readlabel)(&dir, dta->dta_name, TOS_NAMELEN);
742:
743: dta->dta_attrib = FA_LABEL;
744:
745: dta->dta_time = dta->dta_date = 0;
746:
747: dta->dta_size = 0;
748:
749: dta->magic = EVALID;
750:
751: if (r == 0 && !pat_match(dta->dta_name, dta->dta_pat))
752:
753: r = EFILNF;
754:
755: if (attrib == FA_LABEL)
756:
757: return r;
758:
759: else if (r == 0)
760:
761: havelabel = 1;
762:
763: }
764:
765:
766:
767: if (!havelabel && has_wild(slash) == 0) { /* no wild cards in pattern */
768:
769: r = relpath2cookie(&dir, slash, follow_links, &newdir, 0);
770:
771: if (r == 0) {
772:
773: r = (*newdir.fs->getxattr)(&newdir, &xattr);
774:
775: }
776:
777: if (r) {
778:
779: DEBUG("Fsfirst(%s): couldn't get file attributes",path);
780:
781: return r;
782:
783: }
784:
785: dta->magic = EVALID;
786:
787: dta->dta_attrib = xattr.attr;
788:
789: dta->dta_time = xattr.mtime;
790:
791: dta->dta_date = xattr.mdate;
792:
793: dta->dta_size = xattr.size;
794:
795: strncpy(dta->dta_name, slash, TOS_NAMELEN-1);
796:
797: dta->dta_name[TOS_NAMELEN-1] = 0;
798:
799: if (curproc->domain == DOM_TOS &&
800:
801: !(fs->fsflags & FS_CASESENSITIVE))
802:
803: strupr(dta->dta_name);
804:
805:
806:
807: return 0;
808:
809: }
810:
811:
812:
813: /* There is a wild card. Try to find a slot for an opendir/readdir
814:
815: * search. NOTE: we also come here if we were asked to search for
816:
817: * volume labels and found one.
818:
819: */
820:
821: for (i = 0; i < NUM_SEARCH; i++) {
822:
823: if (curproc->srchdta[i] == 0)
824:
825: break;
826:
827: }
828:
829: if (i == NUM_SEARCH) {
830:
831: int oldest = 0; int oldtime = curproc->srchtim[0];
832:
833:
834:
835: DEBUG("Fsfirst(%s): having to re-use a directory slot!",path);
836:
837: for (i = 1; i < NUM_SEARCH; i++) {
838:
839: if (curproc->srchtim[i] < oldtime) {
840:
841: oldest = i;
842:
843: oldtime = curproc->srchtim[i];
844:
845: }
846:
847: }
848:
849: /* OK, close this directory for re-use */
850:
851: i = oldest;
852:
853: dirh = &curproc->srchdir[i];
854:
855: if (dirh->fc.fs) {
856:
857: (*dirh->fc.fs->closedir)(dirh);
858:
859: dirh->fc.fs = 0;
860:
861: }
862:
863: curproc->srchdta[i] = 0;
864:
865: }
866:
867:
868:
869: /* check to see if we have read permission on the directory (and make
870:
871: * sure that it really is a directory!
872:
873: */
874:
875: r = dir_access(&dir, S_IROTH);
876:
877: if (r) {
878:
879: DEBUG("Fsfirst(%s): access to directory denied",path);
880:
881: return r;
882:
883: }
884:
885:
886:
887: /* set up the directory for a search */
888:
889: dirh = &curproc->srchdir[i];
890:
891: dirh->fc = dir;
892:
893: dirh->index = 0;
894:
895: dirh->flags = TOS_SEARCH;
896:
897: r = (*dir.fs->opendir)(dirh, dirh->flags);
898:
899: if (r != 0) {
900:
901: DEBUG("Fsfirst(%s): couldn't open directory (error %ld)",
902:
903: path, r);
904:
905: return r;
906:
907: }
908:
909:
910:
911: /* mark the slot as in-use */
912:
913: curproc->srchdta[i] = dta;
914:
915:
916:
917: /* set up the DTA for Fsnext */
918:
919: dta->index = i;
920:
921: dta->magic = SVALID;
922:
923: dta->dta_sattrib = attrib;
924:
925:
926:
927: /* OK, now basically just do Fsnext, except that instead of ENMFIL we
928:
929: * return EFILNF.
930:
931: * NOTE: If we already have found a volume label from the search above,
932:
933: * then we skip the f_snext and just return that.
934:
935: */
936:
937: if (havelabel)
938:
939: return 0;
940:
941:
942:
943: r = f_snext();
944:
945: if (r == ENMFIL) r = EFILNF;
946:
947: if (r)
948:
949: TRACE("Fsfirst: returning %ld", r);
950:
951: return r;
952:
953: }
954:
955:
956:
957: /*
958:
959: * Counter for Fsfirst/Fsnext, so that we know which search slots are
960:
961: * least recently used. This is updated once per second by the code
962:
963: * in timeout.c.
964:
965: * BUG: 1/second is pretty low granularity
966:
967: */
968:
969:
970:
971: long searchtime;
972:
973:
974:
975: long
976:
977: f_snext()
978:
979: {
980:
981: static char buf[TOS_NAMELEN+1];
982:
983: DTABUF *dta = curproc->dta;
984:
985: FILESYS *fs;
986:
987: fcookie fc;
988:
989: int i;
990:
991: DIR *dirh;
992:
993: long r;
994:
995: XATTR xattr;
996:
997:
998:
999: TRACE("Fsnext");
1000:
1001:
1002:
1003: if (dta->magic == EVALID) {
1004:
1005: DEBUG("Fsnext: DTA marked a failing search");
1006:
1007: return ENMFIL;
1008:
1009: }
1010:
1011: if (dta->magic != SVALID) {
1012:
1013: DEBUG("Fsnext: dta incorrectly set up");
1014:
1015: return EINVFN;
1016:
1017: }
1018:
1019:
1020:
1021: i = dta->index;
1022:
1023: dirh = &curproc->srchdir[i];
1024:
1025: curproc->srchtim[i] = searchtime;
1026:
1027:
1028:
1029: fs = dirh->fc.fs;
1030:
1031: if (!fs) /* oops -- the directory got closed somehow */
1032:
1033: return EINTRN;
1034:
1035:
1036:
1037: /* BUG: f_snext and readdir should check for disk media changes */
1038:
1039:
1040:
1041: for(;;) {
1042:
1043: r = (*fs->readdir)(dirh, buf, TOS_NAMELEN+1, &fc);
1044:
1045:
1046:
1047: if (r == ENAMETOOLONG) {
1048:
1049: DEBUG("Fsnext: name too long");
1050:
1051: continue; /* TOS programs never see these names */
1052:
1053: }
1054:
1055: if (r != 0) {
1056:
1057: baderror:
1058:
1059: (void)(*fs->closedir)(dirh);
1060:
1061: dirh->fc.fs = 0;
1062:
1063: curproc->srchdta[i] = 0;
1064:
1065: dta->magic = EVALID;
1066:
1067: if (r != ENMFIL)
1068:
1069: DEBUG("Fsnext: returning %ld", r);
1070:
1071: return r;
1072:
1073: }
1074:
1075:
1076:
1077: if (!pat_match(buf, dta->dta_pat))
1078:
1079: continue; /* different patterns */
1080:
1081:
1082:
1083: /* check for search attributes */
1084:
1085: r = (*fc.fs->getxattr)(&fc, &xattr);
1086:
1087: if (r) {
1088:
1089: DEBUG("Fsnext: couldn't get file attributes");
1090:
1091: goto baderror;
1092:
1093: }
1094:
1095: /* if the file is a symbolic link, try to find what it's linked to */
1096:
1097: if ( (xattr.mode & S_IFMT) == S_IFLNK ) {
1098:
1099: char linkedto[PATH_MAX];
1100:
1101: r = (*fc.fs->readlink)(&fc, linkedto, PATH_MAX);
1102:
1103: if (r == 0) {
1104:
1105: /* the "1" tells relpath2cookie that we read a link */
1106:
1107: r = relpath2cookie(&dirh->fc, linkedto,
1108:
1109: follow_links, &fc, 1);
1110:
1111: if (r == 0)
1112:
1113: r = (*fc.fs->getxattr)(&fc, &xattr);
1114:
1115: }
1116:
1117: if (r) {
1118:
1119: DEBUG("Fsnext: couldn't follow link: error %ld",
1120:
1121: r);
1122:
1123: }
1124:
1125: }
1126:
1127:
1128:
1129: /* silly TOS rules for matching attributes */
1130:
1131: if (xattr.attr == 0) break;
1132:
1133: if (xattr.attr & 0x21) break;
1134:
1135: if (dta->dta_sattrib & xattr.attr)
1136:
1137: break;
1138:
1139: }
1140:
1141:
1142:
1143: /* here, we have a match */
1144:
1145: dta->dta_attrib = xattr.attr;
1146:
1147: dta->dta_time = xattr.mtime;
1148:
1149: dta->dta_date = xattr.mdate;
1150:
1151: dta->dta_size = xattr.size;
1152:
1153: strcpy(dta->dta_name, buf);
1154:
1155:
1156:
1157: if (curproc->domain == DOM_TOS && !(fs->fsflags & FS_CASESENSITIVE)) {
1158:
1159: strupr(dta->dta_name);
1160:
1161: }
1162:
1163: return 0;
1164:
1165: }
1166:
1167:
1168:
1169: long
1170:
1171: f_attrib(name, rwflag, attr)
1172:
1173: const char *name;
1174:
1175: int rwflag;
1176:
1177: int attr;
1178:
1179: {
1180:
1181: fcookie fc;
1182:
1183: XATTR xattr;
1184:
1185: long r;
1186:
1187:
1188:
1189: TRACE("Fattrib(%s, %d)", name, attr);
1190:
1191:
1192:
1193: r = path2cookie(name, (char *)0, &fc);
1194:
1195:
1196:
1197: if (r) {
1198:
1199: DEBUG("Fattrib(%s): error %ld", name, r);
1200:
1201: return r;
1202:
1203: }
1204:
1205:
1206:
1207: r = (*fc.fs->getxattr)(&fc, &xattr);
1208:
1209:
1210:
1211: if (r) {
1212:
1213: DEBUG("Fattrib(%s): getxattr returned %ld", name, r);
1214:
1215: return r;
1216:
1217: }
1218:
1219:
1220:
1221: if (rwflag) {
1222:
1223: if (attr & (FA_LABEL|FA_DIR)) {
1224:
1225: DEBUG("Fattrib(%s): illegal attributes specified",name);
1226:
1227: return EACCDN;
1228:
1229: } else if (curproc->euid && curproc->euid != xattr.uid) {
1230:
1231: DEBUG("Fattrib(%s): not the file's owner",name);
1232:
1233: return EACCDN;
1234:
1235: } else if (xattr.attr & (FA_LABEL|FA_DIR)) {
1236:
1237: DEBUG("Fattrib(%s): file is a volume label "
1238:
1239: "or directory",name);
1240:
1241: return EACCDN;
1242:
1243: }
1244:
1245: return (*fc.fs->chattr)(&fc, attr);
1246:
1247: } else {
1248:
1249: return xattr.attr;
1250:
1251: }
1252:
1253: }
1254:
1255:
1256:
1257: long
1258:
1259: f_delete(name)
1260:
1261: const char *name;
1262:
1263: {
1264:
1265: fcookie dir;
1266:
1267: long r;
1268:
1269:
1270:
1271: TRACE("Fdelete(%s)", name);
1272:
1273:
1274:
1275: r = path2cookie(name, temp1, &dir);
1276:
1277:
1278:
1279: if (r) {
1280:
1281: DEBUG("Fdelete: error %ld", r);
1282:
1283: return r;
1284:
1285: }
1286:
1287:
1288:
1289: /* check for write permission on directory */
1290:
1291: r = dir_access(&dir, S_IWOTH);
1292:
1293: if (r) {
1294:
1295: DEBUG("Fdelete(%s): write access to directory denied",name);
1296:
1297: return r;
1298:
1299: }
1300:
1301: /* BUG: we should check here for a read-only file */
1302:
1303: return (*dir.fs->remove)(&dir,temp1);
1304:
1305: }
1306:
1307:
1308:
1309: long
1310:
1311: f_rename(junk, old, new)
1312:
1313: int junk; /* ignored, for TOS compatibility */
1314:
1315: const char *old, *new;
1316:
1317: {
1318:
1319: fcookie olddir, newdir, oldfil;
1320:
1321: XATTR xattr;
1322:
1323: char temp2[PATH_MAX];
1324:
1325: long r;
1326:
1327:
1328:
1329: TRACE("Frename(%s, %s)", old, new);
1330:
1331:
1332:
1333: r = path2cookie(old, temp2, &olddir);
1334:
1335: if (r) {
1336:
1337: DEBUG("Frename(%s,%s): error parsing old name",old,new);
1338:
1339: return r;
1340:
1341: }
1342:
1343: /* check for permissions on the old file
1344:
1345: * GEMDOS doesn't allow rename if the file is FA_RDONLY
1346:
1347: * we enforce this restriction only on regular files; processes,
1348:
1349: * directories, and character special files can be renamed at will
1350:
1351: */
1352:
1353: r = relpath2cookie(&olddir, temp2, follow_links, &oldfil, 0);
1354:
1355: if (r) {
1356:
1357: DEBUG("Frename(%s,%s): old file not found",old,new);
1358:
1359: return r;
1360:
1361: }
1362:
1363: r = (*oldfil.fs->getxattr)(&oldfil, &xattr);
1364:
1365: if (r ||
1366:
1367: ((xattr.mode & S_IFMT) == S_IFREG && (xattr.attr & FA_RDONLY)) )
1368:
1369: {
1370:
1371: DEBUG("Frename(%s,%s): access to old file not granted",old,new);
1372:
1373: return EACCDN;
1374:
1375: }
1376:
1377: r = path2cookie(new, temp1, &newdir);
1378:
1379: if (r) {
1380:
1381: DEBUG("Frename(%s,%s): error parsing new name",old,new);
1382:
1383: return r;
1384:
1385: }
1386:
1387:
1388:
1389: if (newdir.fs != olddir.fs) {
1390:
1391: DEBUG("Frename(%s,%s): different file systems",old,new);
1392:
1393: return EXDEV; /* cross device rename */
1394:
1395: }
1396:
1397:
1398:
1399: /* check for write permission on both directories */
1400:
1401: r = dir_access(&olddir, S_IWOTH);
1402:
1403: if (!r) r = dir_access(&newdir, S_IWOTH);
1404:
1405: if (r) {
1406:
1407: DEBUG("Frename(%s,%s): access to a directory denied",old,new);
1408:
1409: return r;
1410:
1411: }
1412:
1413: return (*newdir.fs->rename)(&olddir, temp2, &newdir, temp1);
1414:
1415: }
1416:
1417:
1418:
1419: /*
1420:
1421: * GEMDOS extension: Dpathconf(name, which)
1422:
1423: * returns information about filesystem-imposed limits; "name" is the name
1424:
1425: * of a file or directory about which the limit information is requested;
1426:
1427: * "which" is the limit requested, as follows:
1428:
1429: * -1 max. value of "which" allowed
1430:
1431: * 0 internal limit on open files, if any
1432:
1433: * 1 max. number of links to a file {LINK_MAX}
1434:
1435: * 2 max. path name length {PATH_MAX}
1436:
1437: * 3 max. file name length {NAME_MAX}
1438:
1439: * 4 no. of bytes in atomic write to FIFO {PIPE_BUF}
1440:
1441: * 5 file name truncation rules
1442:
1443: * 6 file name case translation rules
1444:
1445: *
1446:
1447: * unlimited values are returned as 0x7fffffffL
1448:
1449: *
1450:
1451: * see also Sysconf() in dos.c
1452:
1453: */
1454:
1455:
1456:
1457: long
1458:
1459: d_pathconf(name, which)
1460:
1461: const char *name;
1462:
1463: int which;
1464:
1465: {
1466:
1467: fcookie dir;
1468:
1469: long r;
1470:
1471:
1472:
1473: r = path2cookie(name, (char *)0, &dir);
1474:
1475: if (r) {
1476:
1477: DEBUG("Dpathconf(%s): bad path",name);
1478:
1479: return r;
1480:
1481: }
1482:
1483: r = (*dir.fs->pathconf)(&dir, which);
1484:
1485: if (which == DP_CASE && r == EINVFN) {
1486:
1487: /* backward compatibility with old .XFS files */
1488:
1489: return (dir.fs->fsflags & FS_CASESENSITIVE) ? DP_CASESENS :
1490:
1491: DP_CASEINSENS;
1492:
1493: }
1494:
1495: return r;
1496:
1497: }
1498:
1499:
1500:
1501: /*
1502:
1503: * GEMDOS extension: Opendir/Readdir/Rewinddir/Closedir offer a new,
1504:
1505: * POSIX-like alternative to Fsfirst/Fsnext, and as a bonus allow for
1506:
1507: * arbitrary length file names
1508:
1509: */
1510:
1511:
1512:
1513: long
1514:
1515: d_opendir(name, flag)
1516:
1517: const char *name;
1518:
1519: int flag;
1520:
1521: {
1522:
1523: DIR *dirh;
1524:
1525: fcookie dir;
1526:
1527: long r;
1528:
1529:
1530:
1531: r = path2cookie(name, follow_links, &dir);
1532:
1533: if (r) {
1534:
1535: DEBUG("Dopendir(%s): error %ld", name, r);
1536:
1537: return r;
1538:
1539: }
1540:
1541: r = dir_access(&dir, S_IROTH);
1542:
1543: if (r) {
1544:
1545: DEBUG("Dopendir(%s): read permission denied", name);
1546:
1547: return r;
1548:
1549: }
1550:
1551:
1552:
1553: dirh = (DIR *)umalloc(SIZEOF(DIR));
1554:
1555: if (!dirh) return ENSMEM;
1556:
1557:
1558:
1559: dirh->fc = dir;
1560:
1561: dirh->index = 0;
1562:
1563: dirh->flags = flag;
1564:
1565: r = (*dir.fs->opendir)(dirh, flag);
1566:
1567: if (r) {
1568:
1569: DEBUG("d_opendir(%s): opendir returned %ld", name, r);
1570:
1571: ufree(dirh);
1572:
1573: return r;
1574:
1575: }
1576:
1577: return (long)dirh;
1578:
1579: }
1580:
1581:
1582:
1583: long
1584:
1585: d_readdir(len, handle, buf)
1586:
1587: int len;
1588:
1589: long handle;
1590:
1591: char *buf;
1592:
1593: {
1594:
1595: DIR *dirh = (DIR *)handle;
1596:
1597: fcookie fc;
1598:
1599:
1600:
1601: if (!dirh->fc.fs)
1602:
1603: return EIHNDL;
1604:
1605: return (*dirh->fc.fs->readdir)(dirh, buf, len, &fc);
1606:
1607: }
1608:
1609:
1610:
1611: long
1612:
1613: d_rewind(handle)
1614:
1615: long handle;
1616:
1617: {
1618:
1619: DIR *dirh = (DIR *)handle;
1620:
1621:
1622:
1623: if (!dirh->fc.fs)
1624:
1625: return EIHNDL;
1626:
1627: return (*dirh->fc.fs->rewinddir)(dirh);
1628:
1629: }
1630:
1631:
1632:
1633: long
1634:
1635: d_closedir(handle)
1636:
1637: long handle;
1638:
1639: {
1640:
1641: long r;
1642:
1643: DIR *dirh = (DIR *)handle;
1644:
1645:
1646:
1647: if (!dirh->fc.fs)
1648:
1649: return EIHNDL;
1650:
1651: r = (*dirh->fc.fs->closedir)(dirh);
1652:
1653: dirh->fc.fs = 0;
1654:
1655:
1656:
1657: if (r) {
1658:
1659: DEBUG("Dclosedir: error %ld", r);
1660:
1661: }
1662:
1663: ufree(dirh);
1664:
1665: return r;
1666:
1667: }
1668:
1669:
1670:
1671: /*
1672:
1673: * GEMDOS extension: Fxattr gets extended attributes for a file. "flag"
1674:
1675: * is 0 if symbolic links are to be followed (like stat), 1 if not (like
1676:
1677: * lstat).
1678:
1679: */
1680:
1681:
1682:
1683: long
1684:
1685: f_xattr(flag, name, xattr)
1686:
1687: int flag;
1688:
1689: const char *name;
1690:
1691: XATTR *xattr;
1692:
1693: {
1694:
1695: fcookie fc;
1696:
1697: long r;
1698:
1699:
1700:
1701: TRACE("Fxattr(%d, %s)", flag, name);
1702:
1703:
1704:
1705: r = path2cookie(name, flag ? (char *)0 : follow_links, &fc);
1706:
1707: if (r) {
1708:
1709: DEBUG("Fxattr(%s): path2cookie returned %ld", name, r);
1710:
1711: return r;
1712:
1713: }
1714:
1715: r = (*fc.fs->getxattr)(&fc, xattr);
1716:
1717: if (r) {
1718:
1719: DEBUG("Fxattr(%s): returning %ld", name, r);
1720:
1721: }
1722:
1723: return r;
1724:
1725: }
1726:
1727:
1728:
1729: /*
1730:
1731: * GEMDOS extension: Flink(old, new) creates a hard link named "new"
1732:
1733: * to the file "old".
1734:
1735: */
1736:
1737:
1738:
1739: long
1740:
1741: f_link(old, new)
1742:
1743: const char *old, *new;
1744:
1745: {
1746:
1747: fcookie olddir, newdir;
1748:
1749: char temp2[PATH_MAX];
1750:
1751: long r;
1752:
1753:
1754:
1755: TRACE("Flink(%s, %s)", old, new);
1756:
1757:
1758:
1759: r = path2cookie(old, temp2, &olddir);
1760:
1761: if (r) {
1762:
1763: DEBUG("Flink(%s,%s): error parsing old name",old,new);
1764:
1765: return r;
1766:
1767: }
1768:
1769: r = path2cookie(new, temp1, &newdir);
1770:
1771: if (r) {
1772:
1773: DEBUG("Flink(%s,%s): error parsing new name",old,new);
1774:
1775: return r;
1776:
1777: }
1778:
1779:
1780:
1781: if (newdir.fs != olddir.fs) {
1782:
1783: DEBUG("Flink(%s,%s): different file systems",old,new);
1784:
1785: return EXDEV; /* cross device link */
1786:
1787: }
1788:
1789:
1790:
1791: /* check for write permission on the destination directory */
1792:
1793:
1794:
1795: r = dir_access(&newdir, S_IWOTH);
1796:
1797: if (r) {
1798:
1799: DEBUG("Flink(%s,%s): access to directory denied",old,new);
1800:
1801: return r;
1802:
1803: }
1804:
1805: return (*newdir.fs->hardlink)(&olddir, temp2, &newdir, temp1);
1806:
1807: }
1808:
1809:
1810:
1811: /*
1812:
1813: * GEMDOS extension: Fsymlink(old, new): create a symbolic link named
1814:
1815: * "new" that contains the path "old".
1816:
1817: */
1818:
1819:
1820:
1821: long
1822:
1823: f_symlink(old, new)
1824:
1825: const char *old, *new;
1826:
1827: {
1828:
1829: fcookie newdir;
1830:
1831: long r;
1832:
1833:
1834:
1835: TRACE("Fsymlink(%s, %s)", old, new);
1836:
1837:
1838:
1839: r = path2cookie(new, temp1, &newdir);
1840:
1841: if (r) {
1842:
1843: DEBUG("Fsymlink(%s,%s): error parsing %s", old,new,new);
1844:
1845: return r;
1846:
1847: }
1848:
1849: r = dir_access(&newdir, S_IWOTH);
1850:
1851: if (r) {
1852:
1853: DEBUG("Fsymlink(%s,%s): access to directory denied",old,new);
1854:
1855: return r;
1856:
1857: }
1858:
1859: return (*newdir.fs->symlink)(&newdir, temp1, old);
1860:
1861: }
1862:
1863:
1864:
1865: /*
1866:
1867: * GEMDOS extension: Freadlink(buflen, buf, linkfile):
1868:
1869: * read the contents of the symbolic link "linkfile" into the buffer
1870:
1871: * "buf", which has length "buflen".
1872:
1873: */
1874:
1875:
1876:
1877: long
1878:
1879: f_readlink(buflen, buf, linkfile)
1880:
1881: int buflen;
1882:
1883: char *buf;
1884:
1885: const char *linkfile;
1886:
1887: {
1888:
1889: fcookie file;
1890:
1891: long r;
1892:
1893: XATTR xattr;
1894:
1895:
1896:
1897: TRACE("Freadlink(%s)", linkfile);
1898:
1899:
1900:
1901: r = path2cookie(linkfile, (char *)0, &file);
1902:
1903: if (r) {
1904:
1905: DEBUG("Freadlink: unable to find %s", linkfile);
1906:
1907: return r;
1908:
1909: }
1910:
1911: r = (*file.fs->getxattr)(&file, &xattr);
1912:
1913: if (r) {
1914:
1915: DEBUG("Freadlink: unable to get attributes for %s", linkfile);
1916:
1917: return r;
1918:
1919: }
1920:
1921: if ( (xattr.mode & S_IFMT) == S_IFLNK )
1922:
1923: return (*file.fs->readlink)(&file, buf, buflen);
1924:
1925:
1926:
1927: DEBUG("Freadlink: %s is not a link", linkfile);
1928:
1929: return EACCDN;
1930:
1931: }
1932:
1933:
1934:
1935: /*
1936:
1937: * GEMDOS extension: Dcntl(): do file system specific functions
1938:
1939: */
1940:
1941:
1942:
1943: long
1944:
1945: d_cntl(cmd, name, arg)
1946:
1947: int cmd;
1948:
1949: const char *name;
1950:
1951: long arg;
1952:
1953: {
1954:
1955: fcookie dir;
1956:
1957: long r;
1958:
1959:
1960:
1961: TRACE("Dcntl(cmd=%x, file=%s, arg=%lx)", cmd, name, arg);
1962:
1963:
1964:
1965: r = path2cookie(name, temp1, &dir);
1966:
1967: if (r) {
1968:
1969: DEBUG("Dcntl: couldn't find %s", name);
1970:
1971: return r;
1972:
1973: }
1974:
1975: return (*dir.fs->fscntl)(&dir, temp1, cmd, arg);
1976:
1977: }
1978:
1979:
1980:
1981: /*
1982:
1983: * GEMDOS extension: Fchown(name, uid, gid) changes the user and group
1984:
1985: * ownerships of a file to "uid" and "gid" respectively.
1986:
1987: */
1988:
1989:
1990:
1991: long
1992:
1993: f_chown(name, uid, gid)
1994:
1995: const char *name;
1996:
1997: int uid, gid;
1998:
1999: {
2000:
2001: fcookie fc;
2002:
2003: XATTR xattr;
2004:
2005: long r;
2006:
2007:
2008:
2009: TRACE("Fchown(%s, %d, %d)", name, uid, gid);
2010:
2011:
2012:
2013: r = path2cookie(name, follow_links, &fc);
2014:
2015: if (r) {
2016:
2017: DEBUG("Fchown(%s): error %ld", name, r);
2018:
2019: return r;
2020:
2021: }
2022:
2023:
2024:
2025: /* MiNT acts like _POSIX_CHOWN_RESTRICTED: a non-privileged process can
2026:
2027: * only change the ownership of a file that is owned by this user, to
2028:
2029: * the effective group id of the process
2030:
2031: */
2032:
2033: if (curproc->euid) {
2034:
2035: if (curproc->egid != gid) return EACCDN;
2036:
2037: r = (*fc.fs->getxattr)(&fc, &xattr);
2038:
2039: if (r) {
2040:
2041: DEBUG("Fchown(%s): unable to get file attributes",name);
2042:
2043: return r;
2044:
2045: }
2046:
2047: if (xattr.uid != curproc->euid || xattr.uid != uid) {
2048:
2049: DEBUG("Fchown(%s): not the file's owner",name);
2050:
2051: return EACCDN;
2052:
2053: }
2054:
2055: }
2056:
2057: return (*fc.fs->chown)(&fc, uid, gid);
2058:
2059: }
2060:
2061:
2062:
2063: /*
2064:
2065: * GEMDOS extension: Fchmod(file, mode) changes a file's access
2066:
2067: * permissions.
2068:
2069: */
2070:
2071:
2072:
2073: long
2074:
2075: f_chmod(name, mode)
2076:
2077: const char *name;
2078:
2079: unsigned mode;
2080:
2081: {
2082:
2083: fcookie fc;
2084:
2085: long r;
2086:
2087: XATTR xattr;
2088:
2089:
2090:
2091: TRACE("Fchmod(%s, %o)", name, mode);
2092:
2093: r = path2cookie(name, follow_links, &fc);
2094:
2095: if (r) {
2096:
2097: DEBUG("Fchmod(%s): error %ld", name, r);
2098:
2099: return r;
2100:
2101: }
2102:
2103: r = (*fc.fs->getxattr)(&fc, &xattr);
2104:
2105: if (r) {
2106:
2107: DEBUG("Fchmod(%s): couldn't get file attributes",name);
2108:
2109: return r;
2110:
2111: }
2112:
2113: if (curproc->euid && curproc->euid != xattr.uid) {
2114:
2115: DEBUG("Fchmod(%s): not the file's owner",name);
2116:
2117: return EACCDN;
2118:
2119: }
2120:
2121: r = (*fc.fs->chmode)(&fc, mode & ~S_IFMT);
2122:
2123: if (r) DEBUG("Fchmod: error %ld", r);
2124:
2125: return r;
2126:
2127: }
2128:
2129:
2130:
2131: /*
2132:
2133: * GEMDOS extension: Dlock(mode, dev): locks or unlocks access to
2134:
2135: * a BIOS device. "mode" is 0 for unlock, 1 for lock; "dev" is a
2136:
2137: * BIOS device (0 for A:, 1 for B:, etc.).
2138:
2139: * Returns: 0 if the operation was successful
2140:
2141: * EACCDN if a lock attempt is made on a drive that is being
2142:
2143: * used
2144:
2145: * ELOCKED if the drive is locked by another process
2146:
2147: * ENSLOCK if a program attempts to unlock a drive it
2148:
2149: * hasn't locked.
2150:
2151: */
2152:
2153:
2154:
2155: PROC *dlockproc[NUM_DRIVES];
2156:
2157:
2158:
2159: long
2160:
2161: d_lock(mode, dev)
2162:
2163: int mode, dev;
2164:
2165: {
2166:
2167: PROC *p;
2168:
2169: FILEPTR *f;
2170:
2171: int i;
2172:
2173: DIR *dirh;
2174:
2175:
2176:
2177: TRACE("Dlock(%x,%c:)", mode, dev+'A');
2178:
2179: if (dev < 0 || dev >= NUM_DRIVES) return EDRIVE;
2180:
2181:
2182:
2183: if ( (mode&1) == 0) { /* unlock */
2184:
2185: if (dlockproc[dev] == curproc) {
2186:
2187: dlockproc[dev] = 0;
2188:
2189: changedrv(dev);
2190:
2191: return 0;
2192:
2193: }
2194:
2195: DEBUG("Dlock: no such lock");
2196:
2197: return ENSLOCK;
2198:
2199: }
2200:
2201:
2202:
2203: /* code for locking */
2204:
2205: /* is the drive already locked? */
2206:
2207: if (dlockproc[dev]) {
2208:
2209: DEBUG("Dlock: drive already locked");
2210:
2211: return (dlockproc[dev] == curproc) ? 0 : ELOCKED;
2212:
2213: }
2214:
2215: /* see if the drive is in use */
2216:
2217: for (p = proclist; p; p = p->gl_next) {
2218:
2219: if (p->wait_q == ZOMBIE_Q || p->wait_q == TSR_Q)
2220:
2221: continue;
2222:
2223: for (i = MIN_HANDLE; i < MAX_OPEN; i++) {
2224:
2225: if ( ((f = p->handle[i]) != 0) && (f->fc.dev == dev) ) {
2226:
2227: DEBUG("Dlock: process %d has an open handle on the drive", p->pid);
2228:
2229: return EACCDN;
2230:
2231: }
2232:
2233: }
2234:
2235: for (i = 0; i < NUM_SEARCH; i++) {
2236:
2237: dirh = &curproc->srchdir[i];
2238:
2239: if (dirh && dirh->fc.fs && dirh->fc.dev == dev) {
2240:
2241: DEBUG("Dlock: process %d has an open directory on the drive",p->pid);
2242:
2243: return EACCDN;
2244:
2245: }
2246:
2247: }
2248:
2249: }
2250:
2251:
2252:
2253: /* if we reach here, the drive is not in use */
2254:
2255: /* we lock it by setting dlockproc and by setting all root and current
2256:
2257: * directories referring to the device to a null file system
2258:
2259: */
2260:
2261: for (p = proclist; p; p = p->gl_next) {
2262:
2263: for (i = 0; i < NUM_DRIVES; i++) {
2264:
2265: if (p->root[i].dev == dev)
2266:
2267: p->root[i].fs = 0;
2268:
2269: if (p->curdir[i].dev == dev)
2270:
2271: p->curdir[i].fs = 0;
2272:
2273: }
2274:
2275: }
2276:
2277:
2278:
2279: dlockproc[dev] = curproc;
2280:
2281: return 0;
2282:
2283: }
2284:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.