![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dos1.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 dos1.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin / dos |
1.1 root 1: /* dos1.c */
2: /* Globals and functions common to the "dos" and "dosshrink" commands. */
3:
4: #include "dos0.h"
5:
6: /* Diskette parameters. */
7: BPB d8floppy = { 512, 2, 1, 2, 112, 640, 0xFF, 1, 8, 2, 0 };
8: BPB d9floppy = { 512, 2, 1, 2, 112, 720, 0xFD, 2, 9, 2, 0 };
9: BPB d15floppy = { 512, 1, 1, 2, 224, 2400, 0xF9, 7, 15, 2, 0 };
10: BPB d18floppy = { 512, 1, 1, 2, 224, 2880, 0xF0, 9, 18, 2, 0 };
11: BPB q9floppy = { 512, 2, 1, 2, 112, 1440, 0xF9, 3, 9, 2, 0 };
12: BPB s8floppy = { 512, 1, 1, 2, 64, 320, 0xFE, 1, 8, 1, 0 };
13: BPB s9floppy = { 512, 1, 1, 2, 64, 360, 0xFC, 2, 9, 1, 0 };
14:
15: /* Globals. */
16: char *argv0; /* Command name */
17: unsigned char bootb[BBSIZE]; /* Boot block */
18: BPB *bpb; /* Disk parameters */
19: short cflag; /* Readonly */
20: unsigned char *clbuf; /* One cluster buffer */
21: unsigned short clsize; /* Sectors per cluster */
22: unsigned short dirbase; /* First root directory sector */
23: unsigned short dirsize; /* Root dir size in sectors */
24: unsigned short fatbase; /* First FAT sector */
25: unsigned short fatbytes; /* Bytes per FAT entry (1 means 1.5)*/
26: unsigned short *fatcache; /* File allocation table cache */
27: unsigned short fatccount; /* Sectors in FAT cache */
28: unsigned short fatcfirst; /* First sector in FAT cache */
29: short fatcflag; /* FAT must be written */
30: unsigned short fatcmax; /* Max cluster in FAT cache */
31: unsigned short fatcmin; /* Min cluster in FAT cache */
32: unsigned short fatsize; /* FAT size in sectors */
33: unsigned short filebase; /* First disk file data sector */
34: short fsfd; /* File system file descriptor */
35: unsigned short heads; /* Heads */
36: unsigned short maxcluster; /* Max cluster number */
37: unsigned short mdirsize; /* MDIRs per cluster */
38: unsigned short nspt; /* Sectors per track */
39: unsigned short sectors; /* Sectors */
40: unsigned short ssize; /* Sector size */
41: char *usagemsg; /* Usage message */
42: short vflag; /* Verbose */
43:
44: /*
45: * Convert cluster number n to a block number.
46: * Complain if the cluster number is out of range.
47: */
48: unsigned long
49: cltosec(n) register unsigned short n;
50: {
51: if (n < 2 || n > maxcluster)
52: fatal("cluster number %u out of range", n);
53: return ((long)(n - 2) * (long)clsize + filebase);
54: }
55:
56: /*
57: * Decode or encode a FAT with 1.5-byte entries.
58: * The FAT is already in the FAT cache and the cache is big enough
59: * for the expanded version with 2-byte entries.
60: * The flag is 0 to decode after read, 1 to encode before write.
61: * This lazy code uses short pointers on char boundaries.
62: */
63: void
64: decodefat(flag) short flag;
65: {
66: register unsigned short i;
67: register unsigned short u, *ip;
68: register unsigned char *cp;
69:
70: cp = fatcache;
71: if (flag == 0) {
72: /* Expand 1.5-byte entries to unsigned shorts. */
73: for (i = maxcluster; ; i--) {
74: ip = &cp[i*3/2];
75: fatcache[i] = *ip;
76: if (i & 1)
77: fatcache[i] >>= 4;
78: else
79: fatcache[i] &= FATMASK;
80: if (fatcache[i] > (CLMAX & FATMASK))
81: fatcache[i] |= 0xF000;
82: if (i == 0)
83: break;
84: }
85: } else {
86: /* Compress the FAT table to 1.5-byte entries. */
87: for (i = 0; i <= maxcluster; i++) {
88: u = fatcache[i] & FATMASK;
89: ip = &cp[i*3/2];
90: if (i & 1) {
91: *ip &= ~(FATMASK << 4);
92: *ip |= u << 4;
93: } else {
94: *ip &= ~FATMASK;
95: *ip |= u;
96: }
97: }
98: }
99: }
100:
101: /*
102: * Read size sectors starting at block n into buf.
103: * Failure is fatal.
104: */
105: void
106: diskread(buf, n, size, msg) char *buf; unsigned long n; short size; char *msg;
107: {
108: diskseek(n);
109: while (size-- > 0) {
110: if (read(fsfd, buf, ssize) != ssize)
111: fatal("%s read error", msg);
112: buf += ssize;
113: }
114: }
115:
116: /*
117: * Seek to the specified sector on the disk.
118: */
119: void
120: diskseek(n) unsigned long n;
121: {
122: if (lseek(fsfd, partseek + n * ssize, 0) == -1L)
123: fatal("seek failed 0x%lx", n * ssize);
124: }
125:
126: /*
127: * Write size sectors starting at block n from buf.
128: * Failure is fatal.
129: */
130: void
131: diskwrite(buf, n, size, msg) char *buf; unsigned long n; short size; char *msg;
132: {
133: if (cflag)
134: return;
135: diskseek(n);
136: while (size--) {
137: if (write(fsfd, buf, ssize) != ssize)
138: fatal("%s write error", msg);
139: buf += ssize;
140: }
141: }
142:
143: /*
144: * Cry and die.
145: * Uses the nonportable "%r" format.
146: */
147: void
148: fatal(x) char *x;
149: {
150: fflush(stdout);
151: fprintf(stderr, "%s: %r\n", argv0, &x);
152: rm_lock();
153: exit(1);
154: }
155:
156: void
157: fatal1(x) char *x;
158: {
159: fflush(stdout);
160: fprintf(stderr, "%s: %r\n", argv0, &x);
161: exit(1);
162: }
163:
164: /*
165: * Flush the FAT cache.
166: */
167: void
168: fatcflush()
169: {
170: register unsigned short i, n;
171:
172: if (fatcflag)
173: for (n = fatbase + fatcfirst, i = 1;
174: i <= bpb->b_fats;
175: n += fatsize, i++)
176: diskwrite(fatcache, (long)n, fatccount, "FAT cache");
177: fatcflag = 0;
178: }
179:
180: /*
181: * Read segment of FAT including cluster n into the FAT cache.
182: */
183: void
184: fatcread(n) register unsigned short n;
185: {
186: fatcflush(); /* flush previous contents */
187: fatcflag = 0; /* clear dirty flag */
188: fatcfirst = (n/FATCCOUNT) * FATCSECS; /* first FAT sector to read */
189: fatccount = FATCSECS; /* sectors to read */
190: if (fatcfirst + fatccount > fatsize)
191: fatccount = fatsize - fatcfirst; /* read less at end */
192: fatcmin = fatcfirst * FATCNPSEC; /* min cluster in cache */
193: fatcmax = (fatcfirst + fatccount) * FATCNPSEC - 1; /* max cl */
194: /*
195: printf("n=%d,fatbase=%d,fatcfirst=%d,(long)(fatbase+fatcfirst)=%d,fatccount=%d\n",
196: n,fatbase,fatcfirst,(long)(fatbase + fatcfirst),fatccount);
197: */
198: diskread(fatcache, (long)(fatbase + fatcfirst),fatccount,"FAT cache");
199: }
200:
201: /*
202: * Get the FAT entry for cluster n.
203: */
204: unsigned short
205: getcluster(n) register unsigned short n;
206: {
207: if (n < 2 || n > maxcluster)
208: fatal("getcluster: bad cluster number %u", n);
209: if (n < fatcmin || n > fatcmax)
210: fatcread(n);
211: return fatcache[n - fatcmin];
212: }
213:
214: /*
215: * Convert up to n characters from src (an MS-DOS filename or extension)
216: * to dst (a COHERENT filename buffer),
217: * mapping to lower case and stopping at ' '.
218: * Return a pointer to the NUL terminator.
219: */
220: char *
221: lcname(dst, src, n) unsigned char *dst, *src; register short n;
222: {
223: register short c;
224:
225: while (n--) {
226: if ((c = *src++) == ' ')
227: break;
228: else if (isupper(c))
229: c = tolower(c);
230: *dst++ = c;
231: }
232: *dst = '\0';
233: return dst;
234: }
235:
236: /*
237: * Put val in the FAT entry for cluster n.
238: */
239: void
240: putcluster(n, val) unsigned short n; register short val;
241: {
242: if (n < 2 || n > maxcluster)
243: fatal("putcluster: bad cluster number %u", n);
244: if (n < fatcmin || n > fatcmax)
245: fatcread(n);
246: fatcache[n - fatcmin] = val;
247: fatcflag = 1;
248: }
249:
250: /*
251: * Read the file allocation table.
252: * Try the rational approach:
253: * read the boot block and use the boot block BPB info.
254: * This being MS-DOS, the rational approach sometimes loses,
255: * because the BPB information is not always there;
256: * try e.g. DOS 3.2 "format a: /8".
257: * Hence, the somewhat backhanded approach below.
258: */
259: void
260: readfat()
261: {
262: register unsigned short i;
263: unsigned char id[3];
264: char *s;
265:
266: if (xpart != 0)
267: xpartition();
268:
269: /* Read the boot block and hope its BPB is rational. */
270: lseek(fsfd, partseek, 0);
271: if (read(fsfd, bootb, BBSIZE) != BBSIZE)
272: fatal("boot block read error");
273: bpb = &bootb[BPBOFF];
274: if (is_media_id(bpb->b_media))
275: s = "Found";
276: else {
277: /*
278: * The boot block BPB is missing,
279: * check for media id at start of block 1.
280: */
281: lseek(fsfd, (long)BBSIZE, 0);
282: if (read(fsfd, id, 3) != 3)
283: fatal("media id read error");
284: i = id[0];
285: if ((i!=0xFC && i!=0xFD && i!=0xFE && i!=0xFF)
286: || id[1]!=0xFF || id[2]==0xFF)
287: fatal("Probably not a DOS disk (media descriptor 0x%02x)", id[0]);
288: /* Known diskette format. */
289: s = "Known";
290: switch (i) {
291: case 0xFC: bpb = &s9floppy; break;
292: case 0xFD: bpb = &d9floppy; break;
293: case 0xFE: bpb = &s8floppy; break;
294: case 0xFF: bpb = &d8floppy; break;
295: }
296: }
297: setglobals();
298: #if DEBUG
299: printf("%s BPB: %u %u %u %u %u %u 0x%x %u %u %u %u\n",
300: s,
301: ssize,
302: clsize,
303: fatbase,
304: bpb->b_fats,
305: bpb->b_files,
306: sectors,
307: bpb->b_media,
308: fatsize,
309: nspt,
310: heads,
311: bpb->b_hidden);
312: #endif
313: /*
314: * Allocate space for a FAT cache.
315: * If the FAT contains 1.5-byte entries, the cache must be big
316: * enough for the entire FAT table.
317: * Read start of FAT for sanity check below.
318: */
319: if ((fatcache = malloc(FATCSECS * ssize)) == NULL)
320: fatal("FAT allocation failed");
321: if (fatbytes == 1) { /* 1.5-byte FAT entries */
322: if (fatsize > FATCSECS)
323: fatal("FAT cache botch fatsize=%d", fatsize);
324: fatcread(0);
325: fatcmax = (fatsize * ssize * 2 / 3) - 1;
326: if (fatcmax < maxcluster)
327: fatal("FAT cache botch max=%d", fatcmax);
328: decodefat(0); /* expand entries to two bytes each */
329: } else if (fatbytes == 2) /* 2-byte FAT entries */
330: fatcread(0);
331: else /* 4-byte FAT entries, presumably */
332: fatal("fatbytes=%u", fatbytes);
333:
334: /* Sanity check. */
335: if (fatcache[0] != (0xFF00 | bpb->b_media) || fatcache[1] != 0xFFFF)
336: fatal("bad MS-DOS diskette format 0x%x 0x%x", fatcache[0], fatcache[1]);
337: }
338:
339: /*
340: * Set globals based on values in BPB.
341: * This is mostly for efficiency.
342: */
343: void
344: setglobals()
345: {
346: ssize = bpb->b_ssize;
347: clsize = bpb->b_clsize;
348: fatbase = bpb->b_reserved;
349: sectors = bpb->b_sectors;
350: fatsize = bpb->b_fatsize;
351: nspt = bpb->b_tracks;
352: heads = bpb->b_heads;
353:
354: /* This program is untested for sector size != 512. */
355: /* It might work, it might not; let's be prudent. */
356: if (ssize != BBSIZE)
357: fatal("ssize=%u BBSIZE=%u", ssize, BBSIZE);
358:
359: /* Compute base file sector, number of clusters, etc. */
360: dirbase = fatbase + fatsize * bpb->b_fats;
361: dirsize = (bpb->b_files * sizeof(MDIR) + ssize - 1) / ssize;
362: filebase = dirbase + dirsize;
363: mdirsize = clsize * ssize / sizeof(MDIR);
364:
365: if (sectors == 0) {
366: fatbytes = 2;
367: maxcluster=1+(unsigned short)((bpb->b_bigsectors-filebase)/clsize);
368: }
369: else {
370: fatbytes = (sectors / clsize > (FATMASK & CLMAX)) ? 2 : 1;
371: maxcluster = 1 + (sectors - filebase) / clsize;
372: }
373:
374: dbprintf(("dirbase=%u dirsize=%u fatbytes=%u filebase=%u maxcluster=%u mdirsize=%u\n", dirbase, dirsize, fatbytes, filebase, maxcluster, mdirsize));
375: }
376:
377: /*
378: * Print usage message and die.
379: */
380: void
381: usage(msg) char *msg;
382: {
383: fprintf(stderr, usagemsg);
384: if (msg)
385: fatal(msg);
386: else
387: exit(1);
388: }
389:
390: /*
391: * Write the file allocation table.
392: * If fatbytes==1, the FAT is compressed into 1.5-byte entries;
393: * it is not directly usable after compression.
394: */
395: void
396: writefat()
397: {
398: if (fatbytes == 1)
399: decodefat(1);
400: fatcflush();
401: }
402:
403: /*
404: * If the desired MS-DOS filesystem is an extended MS-DOS partition,
405: * find the seek into the COHERENT partition
406: * which specifies the base of the actual MS-DOS filessytem.
407: */
408: void
409: xpartition()
410: {
411: register short part;
412: HDISK_S hd;
413: FDISK_S *p1, *p2;
414:
415: partseek = 0L;
416: for (part = 1; part <= xpart; ++part) {
417: if (lseek(fsfd, partseek, 0) == -1L)
418: fatal("extended partition lseek failed part=%d seek=%lx",
419: part, partseek);
420: if (read(fsfd, &hd, sizeof hd) != sizeof hd)
421: fatal("extended partition table %d read failed", part);
422: if (hd.hd_sig != HDSIG)
423: fatal("no signature found on extended partition table %d",
424: part);
425: p1 = &(hd.hd_partn[0]);
426: p2 = &(hd.hd_partn[1]);
427: if (part == xpart) {
428: partseek += p1->p_base * BBSIZE;
429: break;
430: } else if (p2->p_sys == SYS_DOS_XP)
431: partseek = p2->p_base * BBSIZE;
432: else
433: fatal("extended MS-DOS partition does not contain %d drives",
434: xpart);
435: }
436: }
437:
438: /* end of dos1.c */
439:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.