![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dos4.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 dos4.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / dos |
1.1 root 1: /* #define DEBUG 1*/
2: /* dos4.c */
3:
4: #include "dos0.h"
5: char *fequiv();
6: /*
7: * Compare two MDIR names.
8: * Directories precede ordinary files.
9: * Called by qsort().
10: */
11: short
12: namecmp(mdpp1, mdpp2) MDIR **mdpp1, **mdpp2;
13: {
14: register MDIR *mdp1, *mdp2;
15: unsigned long t1, t2;
16:
17: mdp1 = *mdpp1;
18: mdp2 = *mdpp2;
19: if (isdir(mdp1) != isdir(mdp2))
20: return (isdir(mdp1)) ? -1 : 1;
21: if (nflag) {
22: /*
23: * Compare by time with unsigned long compare.
24: * m_junk[10] is really the first byte of the time.
25: * Kludgy but it works.
26: */
27: t1 = *(unsigned long *)&mdp1->m_junk[10];
28: t2 = *(unsigned long *)&mdp2->m_junk[10];
29: if (t1 != t2)
30: return (t1 < t2) ? -1 : 1;
31: }
32: return strncmp(mdp1->m_name, mdp2->m_name, 11);
33: }
34:
35: /*
36: * Allocate a new DIR and link it into the DIR tree.
37: * Initialize it with the supplied information.
38: * Return a pointer to it.
39: * The MDIR array is not allocated and read until required.
40: */
41: DIR *
42: newdir(parent, mdp, files)
43: DIR *parent;
44: register MDIR *mdp;
45: short files;
46: {
47: register DIR *dp;
48:
49: /* Allocate a new DIR. */
50: dbprintf(("newdir(parent=\"%s\" mdp=%x files=%u): \n", (parent==NULL)?"<root> ":parent->d_dname, mdp, files));
51: if ((dp = (DIR *)malloc(sizeof(DIR))) == NULL)
52: fatal("directory allocation failed");
53:
54: /* Initialize the DIR. */
55: dp->d_parent = parent;
56: dp->d_child = NULL;
57: if (parent == NULL) {
58: /* Root. */
59: dp->d_sibling = NULL;
60: dp->d_cluster = 0;
61: strcpy(dp->d_dname, "<root> ");
62: } else {
63: /* Subdirectory. */
64: dp->d_sibling = parent->d_child;
65: parent->d_child = dp;
66: dp->d_cluster = mdp->m_cluster;
67: strncpy(dp->d_dname, mdp->m_name, 11);
68: dp->d_dname[11] = '\0';
69: }
70: dp->d_files = files;
71: dp->d_dirblocks = (files * sizeof(MDIR) + ssize - 1) / ssize;
72: dp->d_dir = dp->d_edp = NULL;
73: dp->d_dirflag = 0;
74: dbprintf(("\"%s\" cl=%x blocks=%u dp=%x\n", dp->d_dname, dp->d_cluster, dp->d_dirblocks, dp));
75: return dp;
76: }
77:
78: /*
79: * Print a nonfatal error message.
80: * Set the return status to 1.
81: * Uses the nonportable "%r" format.
82: */
83: void
84: nonfatal(x) char *x;
85: {
86: fprintf(stderr, "dos: %r\n", &x);
87: estat = 1;
88: }
89:
90: /*
91: * Allocate space for an MS-DOS directory.
92: * Read in the directory unless dp is not root and its d_cluster is 0.
93: */
94: void
95: readmdir(dp) register DIR *dp;
96: {
97: register MDIR *mdp;
98: register unsigned short n;
99:
100: dbprintf(("readmdir(%s) blocks=%u cl=%x\n", dp->d_dname, dp->d_dirblocks, dp->d_cluster));
101: if ((mdp = (MDIR *)calloc(dp->d_dirblocks, ssize)) == NULL)
102: fatal("directory allocation failed");
103: dp->d_dir = mdp;
104: dp->d_edp = mdp + dp->d_files;
105:
106: if (dp->d_cluster == 0) {
107: if (dp->d_parent != NULL)
108: return; /* new subdirectory */
109: diskread(mdp, (long)dirbase, dp->d_dirblocks, "directory");
110: } else
111: for (n = dp->d_cluster ; n <= CLMAX; n = getcluster(n)) {
112: diskread(mdp, cltosec(n), clsize, "subdirectory");
113: mdp += mdirsize;
114: }
115:
116: /* Scan through the directory for volume label and subdirectories. */
117: for (mdp = dp->d_dir; mdp < dp->d_edp; mdp++) {
118: if ((n = mdp->m_name[0]) == MFREE || n == MEMPTY || n == MMDIR)
119: continue;
120: if (mdp->m_attr & MVOLUME)
121: volume = mdp;
122: if isdir(mdp)
123: newdir(dp, mdp, dirclusters(mdp) * mdirsize);
124: }
125: }
126:
127: /*
128: * Replace one or more files on the MS-DOS file system.
129: */
130: void
131: replace(nargs, args) short nargs; char *args[];
132: {
133: register char **ap;
134: struct stat s;
135:
136: if ((clbuf = malloc(clsize * ssize)) == NULL)
137: fatal("cluster buffer allocation failed");
138: if (nargs == 0)
139: replacedir(NULL);
140: else if (!strcmp(args[0], "-") || pflag) {
141: pflag = 1;
142: if (nargs!=1)
143: fatal("replace: exactly one file required with 'p' option");
144: replacefile(args[0]);
145: } else for (ap=args; nargs; ap++, nargs--) {
146: if (stat(*ap, &s) == -1)
147: fatal("replace: \"%s\" not found", *ap);
148:
149: if (strncmp(*ap, "./", 2) == 0)
150: *ap += 2;
151:
152: if (strcmp(*ap, ".") == 0)
153: {
154: replacedir(NULL);
155: break;
156: }
157:
158: base = basehold;
159: strcpy(base,*ap);
160:
161: if (s.st_mode & S_IFDIR) {
162: if (!sflag)
163: replacedir(*ap);
164: }
165: else
166: replacefile(*ap);
167: }
168: free(clbuf);
169: }
170:
171: /*
172: * Replace a directory; NULL means ".".
173: * Replace subdirectories recursively unless sflag.
174: */
175: void
176: replacedir(name) char *name;
177: {
178: register struct direct *dirp;
179: register char *cp;
180: short fd;
181: struct stat s;
182: char dirbuf[sizeof(struct direct) + 1];
183: char namebuf[NAMEMAX];
184:
185: dbprintf(("replacedir(%s)\n", name));
186: if (name == NULL || strcmp(name, ".") == 0) {
187: name = ".";
188: cp = namebuf;
189: } else {
190: strcpy(namebuf, name);
191: strcat(namebuf, "/");
192: cp = &namebuf[strlen(namebuf)];
193: }
194: dirp = dirbuf;
195: dirbuf[sizeof(struct direct)] = '\0'; /* NUL-terminate d_name */
196: if ((fd = open(name, 0)) == -1)
197: fatal("cannot search directory \"%s\"", name);
198: while(read(fd,dirbuf, sizeof(struct direct))==sizeof(struct direct)) {
199: if (dirp->d_ino == 0
200: || strcmp(dirp->d_name, ".") == 0
201: || strcmp(dirp->d_name, "..") == 0)
202: continue;
203: strncpy(cp, dirp->d_name, DIRSIZ);
204: cp[strlen(dirp->d_name)] = '\0';
205:
206: if (stat(namebuf, &s) == -1)
207: fatal("replacedir botch");
208: else if (s.st_mode & S_IFDIR) {
209: if (!sflag)
210: replacedir(namebuf);
211: }
212: else if (s.st_mode & S_IFREG)
213: replacefile(namebuf);
214: }
215: close(fd);
216: }
217:
218: /*
219: * Replace a file.
220: */
221: void
222: replacefile(file) char *file;
223: {
224: register MDIR *mdp;
225: register short nread;
226: DIR *dp;
227: FILE *ifp;
228: char *cp, *filename;
229: short writesize;
230: unsigned short next, prev;
231: char *tmp, tmp2[6], *files;
232:
233: if (!pflag && !oldstyle) {
234: if (!bflag && ((tmp = strrchr(file, '.')) != NULL)) {
235: sprintf(tmp2, "%s.", tmp);
236: if (!aflag)
237: aflag = (strstr(ext, tmp2) != NULL) ? 1 : 0;
238: }
239: }
240:
241: /* Create the file in the appropriate directory. */
242: dbprintf(("replacefile(%s)\n", file));
243: files = makef(file, 0);
244:
245: if ((cp = strrchr(files, '/')) == NULL) {
246: filename = files;
247: dp = root;
248: } else {
249: filename = cp + 1;
250: *cp = '\0'; /* NUL-terminate dirname */
251: dp = creatdir(files); /* find the directory */
252: *cp = '/'; /* restore the / */
253: }
254:
255: mdp = creatfile(filename, dp); /* create the file */
256:
257: /* Read from the COHERENT file and write the MS-DOS file. */
258: if (vflag)
259: fprintf(stderr, "r %s\n", file);
260: if (pflag)
261: ifp = stdin;
262: else if ((ifp = fopen(file, "r")) == NULL)
263: fatal("replace: cannot open \"%s\"", file);
264: writesize = clsize * ssize;
265: for (prev = 0; ; prev = next) {
266: if ((nread = finput(ifp, clbuf, writesize)) == 0)
267: break;
268: mdp->m_size += nread;
269: next = freecluster();
270: if (prev == 0)
271: mdp->m_cluster = next;
272: else
273: putcluster(prev, next);
274: diskwrite(clbuf, cltosec(next), clsize, file);
275: if (nread < writesize)
276: break;
277: }
278: if (nread < 0)
279: fatal("replace: read error on file \"%s\"", file);
280: if (!pflag)
281: fclose(ifp);
282: dostime(mdp, file);
283: }
284:
285: #define NUM_D_RES 13
286:
287: int istrcmp();
288:
289: char * d_reserved[NUM_D_RES] =
290: {
291: "aux",
292: "clock$",
293: "con",
294: "com1",
295: "com2",
296: "com3",
297: "com4",
298: "lpt1",
299: "lpt2",
300: "lpt3",
301: "lpt4",
302: "nul",
303: "prn"
304: };
305:
306: /*
307: * Make a full path from base and name
308: */
309: char * makef(name, cr) char * name; short cr;
310: {
311: static char tname[80];
312: register char *t = tname, *h;
313: struct stat s;
314: short done = 0, rs;
315: register MDIR *mdp;
316: short srcd, destd, deste;
317:
318: if (base1) {
319: strcpy(t, base1);
320: t += strlen(base1);
321:
322: if (cr) {
323: srcd = isdir_keep;
324: rs = stat(base1, &s);
325: deste = (rs == 0);
326: destd = (s.st_mode & S_IFDIR);
327: }
328: else {
329: mdp = find(base1,root,NULL);
330: deste = (mdp != NULL);
331: destd = isdir(mdp);
332: if (!pflag)
333: {
334: stat(base, &s);
335: srcd = (s.st_mode & S_IFDIR);
336: }
337: else
338: srcd = 0;
339: }
340:
341: /* dbprintf(("numargs = %d, deste = %d, destd = %d, srcd = %d\n",numargs,deste,destd,srcd));*/
342:
343: if (pflag)
344: if (destd)
345: fatal("Error: <%s> is a directory", base1);
346: else
347: done = 1;
348:
349: if ((numargs > 1) && (deste) && !(destd))
350: fatal("Error: <%s> is a file", base1);
351:
352: if (numargs == 1) {
353: if (!deste) {
354: if (!srcd)
355: done = 1;
356: }
357: else {
358: if (!destd) {
359: if (srcd)
360: fatal("Error: <%s> is a file"
361: , base1);
362: else
363: done = 1;
364: }
365: }
366: }
367: }
368:
369: if (!done) {
370: if ((h = fequiv(name)) != NULL) {
371: if (base1)
372: *t++ = '/';
373: strcpy(t, h);
374: }
375: }
376:
377: if (cr)
378: maketree(tname);
379:
380: if ((t = strrchr(tname, '/')) != NULL)
381: t++;
382: else
383: t = tname;
384:
385: if (bsearch(t, d_reserved, NUM_D_RES, sizeof (char *), istrcmp) != NULL)
386: {
387: printf("Dos reserved name used <%s>. Changing filename to <%s!>\n",
388: t, t);
389: rs = strlen(t);
390: t[rs] = '!';
391: t[rs+1] = '\0';
392: }
393:
394:
395: dbprintf(("base = <%s>, base1 = <%s>\n name = <%s>, tname = <%s>\n", base, base1, name, tname));
396: return tname;
397: }
398:
399: istrcmp(a, b)
400: char *a, **b;
401: {
402: return strcmp(a,*b);
403: }
404:
405: char *fequiv(name) char *name;
406: {
407: char *tmp;
408: short basesize;
409:
410: if (!base) /* No base at all means a full disk copy */
411: return name;
412: /* No path means return the whole name */
413: if (strchr(name, '/') == NULL)
414: return name;
415:
416: if (!strcmp(base, name)) /* No wc or subdir means return the fname */
417: return strrchr(name, '/') + 1;
418:
419: tmp = strrchr(base + 1, '/');
420:
421: if (tmp != NULL)
422: basesize = tmp-base;
423: else
424: basesize = strlen(base);
425:
426: return name + basesize + 1;
427: }
428:
429: maketree(name) char *name;
430: {
431:
432: char *h, c[80];
433: struct stat s;
434:
435: h = strchr(name, '/');
436: while (h) {
437: *h = '\0';
438: if (stat(name, &s) == -1) {
439: sprintf(c, "mkdir %s", name);
440: system(c);
441: if (stat(name, &s) == -1)
442: fatal("Cannot create directory %s", name);
443: }
444: *h = '/';
445: h = strchr(h+1, '/');
446: }
447: }
448:
449:
450:
451:
452:
453:
454: /*
455: * Produce a listing of the MS-DOS file system.
456: */
457: void
458: table(nargs, args) short nargs; char *args[];
459: {
460: register unsigned short n, i;
461: register char **ap, *npap, *temp;
462: register MDIR *mdp;
463: DIR *dp;
464: short free, bad, reserved;
465: char buf[12];
466:
467: if (vflag) {
468: /* Print media information. */
469: free = bad = reserved = 0;
470: for (n = 2; n <= maxcluster; n++)
471: if ((i = getcluster(n)) == 0)
472: ++free;
473: else if (i == CLBAD)
474: ++bad;
475: else if (i > CLMAX && i < CLBAD)
476: ++reserved;
477: if (volume == NULL)
478: printf("Unlabelled disk:\n");
479: else {
480: strncpy(buf, volume->m_name, 11);
481: buf[11] = '\0';
482: printf("Volume in Drive %s is labeled %s\n",adev,buf);
483: }
484: printf("\t%lu bytes free\n",
485: (long unsigned)free*clsize*ssize);
486: if (bad)
487: printf("\t%ld bytes in bad sectors\n",
488: (long)bad*clsize*ssize);
489: if (reserved)
490: printf("\t%ld bytes in reserved sectors\n",
491: (long)reserved*clsize*ssize);
492: putchar('\n');
493: }
494: if (nargs == 0)
495: tabledir(root, NULL);
496: else for (ap = args; *ap != NULL; ap++) {
497: if ((mdp = find(*ap, root, &dp)) == NULL)
498: nonfatal("%s not found", *ap);
499: else {
500: npap = (temp = strrchr(*ap, '/')) ? temp+1 : *ap;
501: do {
502: if((strcmp(npap,cohn(mdp->m_name)) == 0)
503: && isdir(mdp))
504:
505: tabledir(dp, cohn(mdp->m_name));
506: else
507: tablefile(mdp, cohn(mdp->m_name));
508: } while (mdp = findnext(&dp));
509: }
510: }
511: }
512:
513: /*
514: * Print a sorted directory.
515: * Suppress '.', '..' and volume label.
516: */
517: void
518: tabledir(dp, name) register DIR *dp; char *name;
519: {
520: register MDIR *mdp;
521: register MDIR **pp, **beg, **end;
522: unsigned char c;
523:
524: if (name != NULL)
525: printf("Directory %s:\n", name);
526: if ((beg = pp = (MDIR **)malloc(dp->d_files * sizeof(MDIR *))) == NULL)
527: fatal("cannot allocate directory pointer table");
528: for (mdp = dp->d_dir; mdp < dp->d_edp; mdp++)
529: if ((c = mdp->m_name[0]) != MFREE && c != MEMPTY && c != MMDIR
530: && (mdp->m_attr & MVOLUME) == 0)
531: *pp++ = mdp;
532: end = pp;
533: qsort(beg, end - beg, sizeof(MDIR *), namecmp);
534: for (pp = beg; pp < end; pp++)
535: tablefile(*pp, NULL);
536: free(beg);
537: putchar('\n');
538: }
539:
540: /*
541: * Print a line describing a file.
542: */
543: void
544: tablefile(mdp, name) register MDIR *mdp; char *name;
545: {
546: register short attr;
547:
548: if (vflag) {
549: attr = mdp->m_attr;
550: putchar((attr & MRONLY ) ? 'r' : '-');
551: putchar((attr & MHIDDEN) ? 'h' : '-');
552: putchar((attr & MSYSTEM) ? 's' : '-');
553: putchar((attr & MVOLUME) ? 'v' : '-');
554: putchar((attr & MARCHIV) ? 'a' : '-');
555: putchar((attr & MSUBDIR) ? 'd' : '-');
556:
557: printf(" %02d/%02d/%02d %02d:%02d %9ld ",
558: m_month(mdp), m_day(mdp), m_year(mdp)+80,
559: m_hour(mdp), m_min(mdp), (isdir(mdp)) ?
560: (long)dirclusters(mdp)*clsize*ssize : mdp->m_size);
561: }
562:
563: if (name == NULL) {
564: cohname(mdp->m_name, root);
565: name = cohfile;
566: }
567: printf("%s\n", name);
568: }
569:
570:
571: /*
572: * Convert NUL-terminated name to UPPERCASE in place.
573: */
574: char *
575: uppercase(name) unsigned char *name;
576: {
577: register unsigned char *s;
578: register short c;
579:
580: for (s = name; (c = *s) != '\0'; s++)
581: if (islower(c))
582: *s = toupper(c);
583: return name;
584: }
585:
586: /*
587: * Write the changed directories of the MS-DOS file system.
588: */
589: void
590: writedir(dp) register DIR *dp;
591: {
592: register MDIR *mdp;
593: register unsigned short n;
594:
595: if (dp->d_child != NULL)
596: writedir(dp->d_child);
597: if (dp->d_sibling != NULL)
598: writedir(dp->d_sibling);
599: mdp = dp->d_dir;
600: dbprintf(("writedir(%s) flag=%u cl=%x blocks=%u mdp=%x\n",
601: dp->d_dname, dp->d_dirflag, dp->d_cluster, dp->d_dirblocks, mdp));
602:
603: if (dp->d_dirflag == 0)
604: return; /* DIR was unchanged */
605: if (dp->d_cluster == 0) /* Write the root */
606: diskwrite(dp->d_dir, (long)dirbase, dp->d_dirblocks, "directory");
607: else /* Write a subdirectory */
608: for (mdp = dp->d_dir, n = dp->d_cluster; n <= CLMAX; n = getcluster(n)) {
609: diskwrite(mdp, cltosec(n), clsize, "subdirectory");
610: mdp += mdirsize;
611: }
612: }
613:
614: /* end of dos4.c */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.