![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dos3.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [MW Coherent from dump] / coherent / d / bin / dos|
Return to dos3.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / dos |
1.1 root 1: /* #define DEBUG 1 */
2: /* dos3.c */
3:
4: #include "dos0.h"
5:
6: MDIR *smdp;
7: DIR *sdp;
8: char *scp, *sname;
9: char *trim();
10:
11: /*
12: * Find the given filename relative to the given directory.
13: * Return a pointer to the MDIR identifying the file, or NULL if not found.
14: * Store a DIR pointer through the supplied dpp.
15: * The stored DIR pointer gives the containing DIR for non-directory files
16: * and the subdirectory DIR for directories.
17: */
18: MDIR *
19: find(name, dp, dpp) char *name; register DIR *dp; DIR **dpp;
20: {
21: register MDIR *mdp;
22: register char *s;
23: register char *cp;
24: char *tname;
25:
26: dbprintf(("find(%s)\n", name));
27: if ((s = strchr(name, '/')) == NULL)
28: {
29: /* No pathname, look for name in the directory. */
30: tname = trim(name);
31: cp = dosname(tname);
32: for (mdp = dp->d_dir; mdp < dp->d_edp; mdp++)
33: {
34: s = mdp->m_name;
35: if ((*s == MEMPTY) || (*s == MFREE))
36: continue;
37: dbprintf(("lmatch(%s,%s) = %d\n", tname, cohn(s),
38: lmatch(tname, cohn(s))));
39: if (lmatch(tname, cohn(s)) == 1)
40: {
41: if((strncmp (s, cp, 11) ==0) && isdir(mdp))
42: {
43: /* Subdirectory, find its DIR. */
44: for (dp = dp->d_child; dp != NULL;
45: dp = dp->d_sibling)
46: if (strncmp(dp->d_dname, cp,
47: 11) == 0)
48: break;
49: if (dp == NULL)
50: fatal("find subdirectory botch");
51: /* Read in the MDIR if necessary. */
52: if (dp->d_dir == NULL)
53: readmdir(dp);
54: }
55: if (dpp != NULL)
56: *dpp = dp;
57: smdp = mdp;
58: scp = cp;
59: sdp = dp;
60: sname = name;
61: return mdp;
62: }
63: }
64: return NULL;
65: }
66: else if (s == name)
67: return find(++s, dp, dpp); /* "/foo" means look for "foo" */
68: /* Explicit pathname, find the directory and recur. */
69: *s = '\0'; /* NUL-terminate dirname */
70: cp = dosname(name);
71: *s++ = '/'; /* Restore the '/' */
72: for (dp = dp->d_child; dp != NULL; dp = dp->d_sibling)
73: if (strncmp(dp->d_dname, cp, 11) == 0)
74: break;
75: if (dp == NULL)
76: return NULL; /* Not found */
77: if (dp->d_dir == NULL)
78: readmdir(dp);
79: return find(s, dp, dpp);
80: }
81:
82: MDIR *
83: findnext(dpp) DIR **dpp;
84: {
85: register MDIR *mdp = ++smdp;
86: register char *s;
87: register char *cp = scp;
88: register DIR *dp = sdp;
89:
90: dbprintf(("findnext(%s)\n", sname));
91: for (; mdp < dp->d_edp; mdp++)
92: {
93: s = mdp->m_name;
94: if ((*s == MEMPTY) || (*s == MFREE))
95: continue;
96: dbprintf(("lmatch(%s,%s) = %d\n", sname, cohn(s), lmatch(sname, cohn(s))));
97: if (lmatch(sname, cohn(s)) == 1)
98: {
99: if ((strncmp (s, cp, 11) ==0) && isdir(mdp))
100: {
101: /* Subdirectory, find its DIR. */
102: for (dp = dp->d_child; dp != NULL;
103: dp = dp->d_sibling)
104: if (strncmp(dp->d_dname, cp, 11) == 0)
105: break;
106: if (dp == NULL)
107: fatal("find subdirectory botch");
108: /* Read in the MDIR if necessary. */
109: if (dp->d_dir == NULL)
110: readmdir(dp);
111: }
112: if (dpp != NULL)
113: *dpp = dp;
114: smdp = mdp;
115: return mdp;
116: }
117: }
118: return NULL;
119: }
120:
121:
122: /*
123: * See if a pattern matches a string.
124: * '\' escapes the next character.
125: */
126: lmatch(pp, sp)
127: register char *pp;
128: register char *sp;
129: {
130: short c2;
131: register short c1;
132:
133: if ((*sp == '.') && ((sp[1] == '.') || (sp[1] == '\0')))
134: return 0;
135:
136: if ((strcspn(pp, " ") == 0) && (strcspn(sp, " ") == 0))
137: return 1;
138: while ((c1=*pp++)) {
139: switch (c1) {
140: case '?':
141: if (*sp++)
142: continue;
143: return (0);
144: case '*':
145: do {
146: if (lmatch(pp, sp))
147: return (1);
148: } while (*sp++);
149: return (0);
150: case '[':
151: if ((c2=*sp++) == '\0')
152: return (0);
153: for (;;) {
154: if ((c1=*pp++) == '\0' || c1 == ']')
155: return (0);
156: if (c1 == '\\' && (c1=*pp++) == '\0')
157: return (0);
158: if (c1 == c2)
159: break;
160: if (*pp == '-') {
161: pp += 1;
162: if (c2 < c1)
163: continue;
164: if ((c1=*pp++) == '\0')
165: return (0);
166: if (c1 == '\\' && (c1=*pp++) == '\0')
167: return (0);
168: if (c2 <= c1)
169: break;
170: }
171: }
172: while ((c1 = *pp++) != ']') {
173: if (c1 == '\0')
174: return (0);
175: if (c1 == '\\' && *pp++ == '\0')
176: return (0);
177: }
178: continue;
179: case '\\':
180: if ((c1=*pp++) == '\0')
181: return (0);
182: /* fall through */
183: default:
184: if (c1 == *sp++)
185: continue;
186: return (0);
187: }
188: }
189: return (*sp=='\0');
190: }
191:
192:
193: char *
194: trim(name) register char *name;
195: {
196: register char *s, *dotp;
197: char c;
198: static char buf[16];
199:
200: dotp = strrchr(name, '.');
201: if (dotp == name)
202: dotp = NULL;
203: for (s = buf; name != dotp && (c = *name) != '\0'; name++)
204: if (s < &buf[8]) /* copy name */
205: *s++ = (c == '.') ? '_' : c;
206: if (name++ == dotp) {
207: *s++ = '.';
208: for ( ; *name != '\0'; name++)
209: if (s < &buf[12])
210: *s++ = *name; /* copy extension */
211: }
212: *s = '\0'; /* NUL terminate */
213: return buf;
214: }
215:
216: char * cohn(name) char * name;
217: {
218: static char lname[22];
219: char *tmp = lname;
220: short i = 0;
221:
222: do {
223: if (*name == ' ')
224: *name++;
225: else {
226: *(tmp++) = tolower(*name);
227: name++;
228: }
229: i++;
230: } while (i<8);
231:
232: if ((*name != ' ')) {
233: *(tmp++) = '.';
234: do {
235: if (*name == ' ')
236: *name++;
237: else {
238: *(tmp++) = tolower(*name);
239: name++;
240: }
241: i++;
242: } while (i<11);
243: }
244: *tmp = '\0';
245:
246: return lname;
247: }
248:
249:
250: /*
251: * Input up to nb characters into bp from COHERENT file fp,
252: * taking into account the ASCII flag.
253: * Pad to nb characters with NUL or CTRLZ.
254: * Return the number of characters actually read.
255: */
256: short
257: finput(fp, bp, nb) FILE *fp; register char *bp; unsigned short nb;
258: {
259: register short c;
260: register unsigned short n, n2;
261: register char *ep;
262: static char needlf = 0;
263:
264: if (!aflag) {
265: n2 = n = read(fileno(fp), bp, nb);
266: while (n2 && n < nb)
267: {
268: n2 = read(fileno(fp), bp + n, nb - n);
269: n += n2;
270: }
271: for (ep = bp+nb, bp += n; bp < ep; )
272: *bp++ = '\0';
273: return n;
274: }
275: for (n = 0, ep = bp+nb; bp < ep; ) {
276: if (needlf) {
277: c = '\n';
278: needlf = 0;
279: } else {
280: if ((c = getc(fp)) == '\r')
281: continue;
282: else if (c == '\n') {
283: c = '\r';
284: needlf++;
285: } else if (c == EOF)
286: c = CTRLZ;
287: }
288: if (c == CTRLZ)
289: break;
290: n++;
291: *bp++ = c;
292: }
293: while (bp < ep)
294: *bp++ = CTRLZ; /* pad with EOFs */
295: return n;
296: }
297:
298: /*
299: * Format an MS-DOS filesystem.
300: * The optional argument is a boot block.
301: */
302: void
303: format(nargs, args) short nargs; char *args[];
304: {
305: register char *cp;
306: short i, c;
307: char *bp;
308: unsigned short nsize;
309: struct stat sbuf;
310:
311: /* Prompt to make sure. */
312: printf("Are you sure you want to build an MS-DOS filesystem on device %s? ", device);
313: fflush(stdout);
314: c = getchar();
315: while (c != '\n' && (i = getchar()) != '\n' && i != EOF)
316: ;
317: if (c != 'y' && c != 'Y') {
318: rm_lock();
319: exit(1);
320: }
321: if (nargs > 1)
322: fatal("format: only one bootstrap file allowed");
323:
324: /* Get BPB for the specified format. */
325: if (fstat(fsfd, &sbuf) < 0)
326: fatal("format: cannot stat");
327: i = sbuf.st_rdev;
328: if (major(i) != FL_MAJOR)
329: fatal("format: illegal device major number");
330: switch (minor(i) & 0x0F) {
331: case 0: bpb = &s8floppy; break;
332: case 3: bpb = &s9floppy; break;
333: case 9: bpb = &d8floppy; break;
334: case 12: bpb = &d9floppy; break;
335: case 13: bpb = &q9floppy; break;
336: case 14: bpb = &d15floppy; break;
337: case 15: bpb = &d18floppy; break;
338: default:
339: fatal("format: unsupported diskette type %d", minor(i) & 0x0F);
340: }
341: setglobals();
342:
343: /* Read boot block or build one. */
344: if (nargs > 0) {
345: if ((i=open(args[0], 0)) < 0)
346: fatal("format: cannot open boot block file \"%s\"", args[0]);
347: if (read(i, bootb, BBSIZE) != BBSIZE)
348: fatal("format: boot block read error");
349: close(i);
350: } else {
351: /* Patch in "jmp short ." with required flag byte. */
352: bootb[0] = 0xEB; /* JMP short */
353: bootb[1] = 0xFE; /* . (PC-relative) */
354: bootb[2] = 0x90; /* required flag */
355: strncpy(&bootb[3], "COHERENT", 8);
356: for (cp=&bootb[BPBOFF], bp=bpb, i=0; i < sizeof(BPB); i++)
357: *cp++ = *bp++; /* copy the BPB */
358: }
359: if (write(fsfd, bootb, BBSIZE) != BBSIZE)
360: fatal("format: boot block write error");
361:
362: /* Write the FATs (media id and zero bytes). */
363: if (fatbytes != 1)
364: fatal("format: fatbytes=%d", fatbytes);
365: nsize = (maxcluster + 1) * sizeof(short);
366: if (nsize < fatsize * ssize)
367: nsize = fatsize * ssize;
368: if ((fatcache = calloc(nsize, 1)) == NULL)
369: fatal("format: FAT allocation failed");
370: fatcache[0] = 0xFF00 | bpb->b_media;
371: fatcache[1] = CLEOF;
372: fatcfirst = 0;
373: fatccount = fatsize;
374: fatcflag = 1;
375: writefat();
376: free(fatcache);
377:
378: /* Write the directory (all zero bytes). */
379: if ((cp = calloc(dirsize, ssize)) == NULL)
380: fatal("format: directory allocation failed");
381: diskwrite(cp, (long)dirbase, dirsize, "directory");
382: free(cp);
383: }
384:
385: /*
386: * Output nb characters from bp to COHERENT file fp,
387: * taking into account the ASCII flag.
388: * Return the number of characters actually written.
389: */
390: short
391: foutput(fn, fp, bp, nb) char *fn; FILE *fp; register char *bp; unsigned short nb;
392: {
393: register unsigned short n;
394: register char *ep;
395:
396: if (!aflag) {
397: if (write(fileno(fp), bp, nb) != nb)
398: fatal("extract: write error on file \"%s\"", fn);
399: return nb;
400: }
401: for (n = 0, ep = bp+nb; bp < ep; bp++) {
402: if (*bp == '\r')
403: continue;
404: else if (*bp == CTRLZ)
405: break;
406: n++;
407: putc(*bp, fp);
408: }
409: if (ferror(fp))
410: fatal("extract: write error on file \"%s\"", fn);
411: return n;
412: }
413:
414: /*
415: * Return the next free cluster on the diskette.
416: * Stick an EOF marker in the cluster.
417: * Failure is fatal.
418: */
419: unsigned short
420: freecluster()
421: {
422: register unsigned short n;
423:
424: for (n = 2; n <= maxcluster; n++)
425: if (getcluster(n) == CLFREE) {
426: putcluster(n, CLEOF);
427: return n;
428: }
429: fatal("out of space on MS-DOS disk");
430: }
431:
432: /*
433: * Read the key for the command.
434: * Set globals accordingly.
435: * Return the required device mode for the command.
436: */
437: short
438: key(s) register char *s;
439: {
440: register short c, nfun;
441:
442: nfun = 0;
443: bflag = 1; /* assume binary */
444: if (*s == '-')
445: ++s; /* ignore optional '-' */
446: while ((c = *s++) != '\0')
447: switch (c) {
448:
449: /* Functions. */
450: case 'd': fun = delete; ++nfun; break;
451: case 'F': fun = format; ++nfun; break;
452: case 'l': fun = label; ++nfun; break;
453: case 'r': fun = replace; ++nfun; break;
454: case 't': fun = table; ++nfun; break;
455: case 'x': fun = extract; ++nfun; break;
456:
457: /* Flags. */
458: case 'a': aflag++; bflag--; break;
459: case 'c': cflag++; break;
460: case 'k': kflag++; break;
461: case 'n': nflag++; break;
462: case 'p': pflag++; break;
463: case 's': sflag++; break;
464: case 'v': vflag++; break;
465: case 'V':
466: fprintf(stderr, "dos: V%s\n", VERSION);
467: break;
468: case '1':
469: case '2':
470: case '3':
471: case '4':
472: case '5':
473: case '6':
474: case '7':
475: case '8':
476: case '9':
477: xpart = c - '0';
478: break;
479:
480: default:
481: usage();
482: }
483:
484: if (nfun == 0)
485: fun = table; /* default */
486: else if (nfun > 1)
487: fatal("must specify one function [dFlrtx]");
488: return (cflag || fun==table || fun==extract) ? 0 : 2;
489: }
490:
491: /*
492: * Label a disk with a volume label.
493: */
494: void
495: label(nargs, args) short nargs; char *args[];
496: {
497: char tmp[13], *b;
498: short i;
499:
500: if (nargs > 1)
501: fatal("label: single argument required");
502: else if (nargs == 0) {
503: if (volume == NULL)
504: printf("Volume in Drive %s is unlabeled.\n",adev);
505: else {
506: strncpy(tmp, volume->m_name, 11);
507: tmp[11] = '\0';
508: printf("Volume in Drive %s is labeled %s.\n",adev,tmp);
509: }
510: }
511: else {
512: if ((i = strlen(args[0])) > 8) {
513: if (i > 11)
514: args[0][11] = '\0';
515: strncpy(tmp, args[0], 8);
516: tmp[8] = '.';
517: strcpy(&tmp[9], &args[0][8]);
518:
519: b = tmp;
520: }
521: else
522: b= args[0];
523:
524: if (volume != NULL)
525: deletefile(volume, root);
526: if (find(b, root, NULL) != NULL)
527: fatal("label: file \"%s\" already exists", b);
528: if (strchr(b, '/') != NULL)
529: fatal("label: label cannot use character '/'");
530: volume = creatfile(b, root);
531: volume->m_attr = MVOLUME;
532: }
533: }
534:
535: /*
536: * Initialize an MDIR with the current time and date,
537: * the given name, attribute and cluster, and size 0L.
538: * Set the flag requiring the DIR to be written.
539: */
540: void
541: mdirinit(mdp, dp, name, attr, cluster)
542: register MDIR *mdp;
543: DIR *dp;
544: char *name;
545: unsigned short attr, cluster;
546: {
547: register short i;
548:
549: dbprintf(("mdirinit(mdp=%x dp=\"%s\" name=\"%s\" attr=%x cl=%x)\n", mdp, dp->d_dname, name, attr, cluster));
550: strncpy(mdp->m_name, name, 11);
551: mdp->m_attr = attr;
552: for (i=0; i<10; i++)
553: mdp->m_junk[i] = 0;
554: dostime(mdp, NULL);
555: mdp->m_cluster = cluster;
556: mdp->m_size = 0;
557: dp->d_dirflag = 1;
558: }
559:
560: /* end of dos3.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.