![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to dd.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / bin / dd|
Return to dd.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / bin / dd |
1.1 root 1: #ifndef lint
2: static char *sccsid = "@(#)dd.c 4.8 (Berkeley) 6/25/90";
3: #endif
4:
5: #include <sys/types.h>
6: #include <sys/file.h>
7: #include <sys/ioctl.h>
8: #include <sys/mtio.h>
9: #include <sys/stat.h>
10: #include <stdio.h>
11: #include <signal.h>
12:
13: #define BIG 2147483647
14: #define LCASE 01
15: #define UCASE 02
16: #define SWAB 04
17: #define NERR 010
18: #define SYNC 020
19: int cflag;
20: int fflag;
21: int skip;
22: int seekn;
23: int count;
24: int files = 1;
25: char *string;
26: char *ifile;
27: char *ofile;
28: char *ibuf;
29: char *obuf;
30: char *sbrk();
31: int ibs = 512;
32: int obs = 512;
33: int bs;
34: int cbs;
35: int ibc;
36: int obc;
37: int cbc;
38: int nifr;
39: int nipr;
40: int nofr;
41: int nopr;
42: int ntrunc;
43: int ibf;
44: int obf;
45: char *op;
46: int nspace;
47: char etoa[] = {
48: 0000,0001,0002,0003,0234,0011,0206,0177,
49: 0227,0215,0216,0013,0014,0015,0016,0017,
50: 0020,0021,0022,0023,0235,0205,0010,0207,
51: 0030,0031,0222,0217,0034,0035,0036,0037,
52: 0200,0201,0202,0203,0204,0012,0027,0033,
53: 0210,0211,0212,0213,0214,0005,0006,0007,
54: 0220,0221,0026,0223,0224,0225,0226,0004,
55: 0230,0231,0232,0233,0024,0025,0236,0032,
56: 0040,0240,0241,0242,0243,0244,0245,0246,
57: 0247,0250,0133,0056,0074,0050,0053,0041,
58: 0046,0251,0252,0253,0254,0255,0256,0257,
59: 0260,0261,0135,0044,0052,0051,0073,0136,
60: 0055,0057,0262,0263,0264,0265,0266,0267,
61: 0270,0271,0174,0054,0045,0137,0076,0077,
62: 0272,0273,0274,0275,0276,0277,0300,0301,
63: 0302,0140,0072,0043,0100,0047,0075,0042,
64: 0303,0141,0142,0143,0144,0145,0146,0147,
65: 0150,0151,0304,0305,0306,0307,0310,0311,
66: 0312,0152,0153,0154,0155,0156,0157,0160,
67: 0161,0162,0313,0314,0315,0316,0317,0320,
68: 0321,0176,0163,0164,0165,0166,0167,0170,
69: 0171,0172,0322,0323,0324,0325,0326,0327,
70: 0330,0331,0332,0333,0334,0335,0336,0337,
71: 0340,0341,0342,0343,0344,0345,0346,0347,
72: 0173,0101,0102,0103,0104,0105,0106,0107,
73: 0110,0111,0350,0351,0352,0353,0354,0355,
74: 0175,0112,0113,0114,0115,0116,0117,0120,
75: 0121,0122,0356,0357,0360,0361,0362,0363,
76: 0134,0237,0123,0124,0125,0126,0127,0130,
77: 0131,0132,0364,0365,0366,0367,0370,0371,
78: 0060,0061,0062,0063,0064,0065,0066,0067,
79: 0070,0071,0372,0373,0374,0375,0376,0377,
80: };
81: char atoe[] = {
82: 0000,0001,0002,0003,0067,0055,0056,0057,
83: 0026,0005,0045,0013,0014,0015,0016,0017,
84: 0020,0021,0022,0023,0074,0075,0062,0046,
85: 0030,0031,0077,0047,0034,0035,0036,0037,
86: 0100,0117,0177,0173,0133,0154,0120,0175,
87: 0115,0135,0134,0116,0153,0140,0113,0141,
88: 0360,0361,0362,0363,0364,0365,0366,0367,
89: 0370,0371,0172,0136,0114,0176,0156,0157,
90: 0174,0301,0302,0303,0304,0305,0306,0307,
91: 0310,0311,0321,0322,0323,0324,0325,0326,
92: 0327,0330,0331,0342,0343,0344,0345,0346,
93: 0347,0350,0351,0112,0340,0132,0137,0155,
94: 0171,0201,0202,0203,0204,0205,0206,0207,
95: 0210,0211,0221,0222,0223,0224,0225,0226,
96: 0227,0230,0231,0242,0243,0244,0245,0246,
97: 0247,0250,0251,0300,0152,0320,0241,0007,
98: 0040,0041,0042,0043,0044,0025,0006,0027,
99: 0050,0051,0052,0053,0054,0011,0012,0033,
100: 0060,0061,0032,0063,0064,0065,0066,0010,
101: 0070,0071,0072,0073,0004,0024,0076,0341,
102: 0101,0102,0103,0104,0105,0106,0107,0110,
103: 0111,0121,0122,0123,0124,0125,0126,0127,
104: 0130,0131,0142,0143,0144,0145,0146,0147,
105: 0150,0151,0160,0161,0162,0163,0164,0165,
106: 0166,0167,0170,0200,0212,0213,0214,0215,
107: 0216,0217,0220,0232,0233,0234,0235,0236,
108: 0237,0240,0252,0253,0254,0255,0256,0257,
109: 0260,0261,0262,0263,0264,0265,0266,0267,
110: 0270,0271,0272,0273,0274,0275,0276,0277,
111: 0312,0313,0314,0315,0316,0317,0332,0333,
112: 0334,0335,0336,0337,0352,0353,0354,0355,
113: 0356,0357,0372,0373,0374,0375,0376,0377,
114: };
115: char atoibm[] =
116: {
117: 0000,0001,0002,0003,0067,0055,0056,0057,
118: 0026,0005,0045,0013,0014,0015,0016,0017,
119: 0020,0021,0022,0023,0074,0075,0062,0046,
120: 0030,0031,0077,0047,0034,0035,0036,0037,
121: 0100,0132,0177,0173,0133,0154,0120,0175,
122: 0115,0135,0134,0116,0153,0140,0113,0141,
123: 0360,0361,0362,0363,0364,0365,0366,0367,
124: 0370,0371,0172,0136,0114,0176,0156,0157,
125: 0174,0301,0302,0303,0304,0305,0306,0307,
126: 0310,0311,0321,0322,0323,0324,0325,0326,
127: 0327,0330,0331,0342,0343,0344,0345,0346,
128: 0347,0350,0351,0255,0340,0275,0137,0155,
129: 0171,0201,0202,0203,0204,0205,0206,0207,
130: 0210,0211,0221,0222,0223,0224,0225,0226,
131: 0227,0230,0231,0242,0243,0244,0245,0246,
132: 0247,0250,0251,0300,0117,0320,0241,0007,
133: 0040,0041,0042,0043,0044,0025,0006,0027,
134: 0050,0051,0052,0053,0054,0011,0012,0033,
135: 0060,0061,0032,0063,0064,0065,0066,0010,
136: 0070,0071,0072,0073,0004,0024,0076,0341,
137: 0101,0102,0103,0104,0105,0106,0107,0110,
138: 0111,0121,0122,0123,0124,0125,0126,0127,
139: 0130,0131,0142,0143,0144,0145,0146,0147,
140: 0150,0151,0160,0161,0162,0163,0164,0165,
141: 0166,0167,0170,0200,0212,0213,0214,0215,
142: 0216,0217,0220,0232,0233,0234,0235,0236,
143: 0237,0240,0252,0253,0254,0255,0256,0257,
144: 0260,0261,0262,0263,0264,0265,0266,0267,
145: 0270,0271,0272,0273,0274,0275,0276,0277,
146: 0312,0313,0314,0315,0316,0317,0332,0333,
147: 0334,0335,0336,0337,0352,0353,0354,0355,
148: 0356,0357,0372,0373,0374,0375,0376,0377,
149: };
150:
151: enum ftype { unknown, reg, chr, tape, pipe } iftype;
152: enum ftype checktype();
153:
154: main(argc, argv)
155: int argc;
156: char **argv;
157: {
158: int (*conv)();
159: register char *ip;
160: register c;
161: int ebcdic(), ibm(), ascii(), null(), cnull(), term(), block(), unblock();
162: int a;
163:
164: conv = null;
165: for(c=1; c<argc; c++) {
166: string = argv[c];
167: if(match("ibs=")) {
168: ibs = number(BIG);
169: continue;
170: }
171: if(match("obs=")) {
172: obs = number(BIG);
173: continue;
174: }
175: if(match("cbs=")) {
176: cbs = number(BIG);
177: continue;
178: }
179: if (match("bs=")) {
180: bs = number(BIG);
181: continue;
182: }
183: if(match("if=")) {
184: ifile = string;
185: continue;
186: }
187: if(match("of=")) {
188: ofile = string;
189: continue;
190: }
191: if(match("skip=")) {
192: skip = number(BIG);
193: continue;
194: }
195: if(match("seek=")) {
196: seekn = number(BIG);
197: continue;
198: }
199: if(match("count=")) {
200: count = number(BIG);
201: continue;
202: }
203: if(match("files=")) {
204: files = number(BIG);
205: continue;
206: }
207: if(match("conv=")) {
208: cloop:
209: if(match(","))
210: goto cloop;
211: if(*string == '\0')
212: continue;
213: if(match("ebcdic")) {
214: conv = ebcdic;
215: goto cloop;
216: }
217: if(match("ibm")) {
218: conv = ibm;
219: goto cloop;
220: }
221: if(match("ascii")) {
222: conv = ascii;
223: goto cloop;
224: }
225: if(match("block")) {
226: conv = block;
227: goto cloop;
228: }
229: if(match("unblock")) {
230: conv = unblock;
231: goto cloop;
232: }
233: if(match("lcase")) {
234: cflag |= LCASE;
235: goto cloop;
236: }
237: if(match("ucase")) {
238: cflag |= UCASE;
239: goto cloop;
240: }
241: if(match("swab")) {
242: cflag |= SWAB;
243: goto cloop;
244: }
245: if(match("noerror")) {
246: cflag |= NERR;
247: goto cloop;
248: }
249: if(match("sync")) {
250: cflag |= SYNC;
251: goto cloop;
252: }
253: }
254: fprintf(stderr,"bad arg: %s\n", string);
255: exit(1);
256: }
257: if(conv == null && cflag&(LCASE|UCASE))
258: conv = cnull;
259: if (ifile)
260: ibf = open(ifile, 0);
261: else
262: ibf = dup(0);
263: if(ibf < 0) {
264: perror(ifile);
265: exit(1);
266: }
267: iftype = checktype(ibf);
268: obf = ofile ? open(ofile, O_WRONLY|O_CREAT, 0666) : dup(1);
269: if(obf < 0) {
270: fprintf(stderr,"cannot create: %s\n", ofile);
271: exit(1);
272: }
273: if (bs) {
274: ibs = obs = bs;
275: if (conv == null && (cflag &~ (SYNC|NERR)) == 0)
276: fflag++;
277: }
278: if(ibs == 0 || obs == 0) {
279: fprintf(stderr,"counts: cannot be zero\n");
280: exit(1);
281: }
282: ibuf = sbrk(ibs);
283: if (fflag)
284: obuf = ibuf;
285: else
286: obuf = sbrk(obs);
287: sbrk(64); /* For good measure */
288: if(ibuf == (char *)-1 || obuf == (char *)-1) {
289: fprintf(stderr, "not enough memory\n");
290: exit(1);
291: }
292: ibc = 0;
293: obc = 0;
294: cbc = 0;
295: op = obuf;
296:
297: if (signal(SIGINT, SIG_IGN) != SIG_IGN)
298: signal(SIGINT, term);
299: if (skip)
300: switch (iftype) {
301: case tape: {
302: struct mtop op;
303:
304: op.mt_op = MTFSR;
305: op.mt_count = skip;
306: if (ioctl(ibf, MTIOCTOP, (char *)&op) < 0)
307: perror("dd: skip: tape forward-space-record");
308: }
309: break;
310: case reg:
311: lseek(ibf, skip*ibs, L_INCR);
312: break;
313: default:
314: while (skip--)
315: read(ibf, ibuf, ibs);
316: break;
317: }
318: if (seekn)
319: switch (checktype(obf)) {
320: case reg:
321: lseek(obf, (long)obs*seekn, L_INCR);
322: break;
323: case pipe:
324: fprintf(stderr, "dd: can't seek on pipe\n");
325: break;
326: default:
327: while (seekn--)
328: lseek(obf, (long)obs, L_INCR);
329: break;
330: }
331:
332: loop:
333: if(ibc-- == 0) {
334: ibc = 0;
335: if(count==0 || nifr+nipr!=count) {
336: if (cflag&NERR)
337: bzero((char *)ibuf, ibs);
338: ibc = read(ibf, ibuf, ibs);
339: }
340: if(ibc == -1) {
341: perror("read");
342: if((cflag&NERR) == 0) {
343: flsh();
344: term();
345: }
346: /* guess actual read size; default still -1 */
347: for(c=0; c<ibs; c++)
348: if(ibuf[c] != 0)
349: ibc = c + 1;
350: stats();
351: advance(ibf, iftype, ibs);
352: }
353: if(ibc == 0 && --files<=0) {
354: flsh();
355: term();
356: }
357: if(ibc != ibs) {
358: if (ibc == -1)
359: ibc = 0;
360: nipr++;
361: if (cflag&SYNC) {
362: bzero(ibuf + ibc, ibs - ibc);
363: ibc = ibs;
364: }
365: } else
366: nifr++;
367: ip = ibuf;
368: c = ibc >> 1;
369: if(cflag&SWAB && c)
370: do {
371: a = *ip++;
372: ip[-1] = *ip;
373: *ip++ = a;
374: } while(--c);
375: ip = ibuf;
376: if (fflag) {
377: obc = ibc;
378: flsh();
379: ibc = 0;
380: }
381: goto loop;
382: }
383: c = 0;
384: c |= *ip++;
385: c &= 0377;
386: (*conv)(c);
387: goto loop;
388: }
389:
390: flsh()
391: {
392: register c;
393:
394: if(obc) {
395: if(obc == obs)
396: nofr++; else
397: nopr++;
398: c = write(obf, obuf, obc);
399: if(c != obc) {
400: perror("write");
401: term();
402: }
403: obc = 0;
404: }
405: }
406:
407: match(s)
408: char *s;
409: {
410: register char *cs;
411:
412: cs = string;
413: while(*cs++ == *s)
414: if(*s++ == '\0')
415: goto true;
416: if(*s != '\0')
417: return(0);
418:
419: true:
420: cs--;
421: string = cs;
422: return(1);
423: }
424:
425: number(big)
426: {
427: register char *cs;
428: long n;
429:
430: cs = string;
431: n = 0;
432: while(*cs >= '0' && *cs <= '9')
433: n = n*10 + *cs++ - '0';
434: for(;;)
435: switch(*cs++) {
436:
437: case 'k':
438: n *= 1024;
439: continue;
440:
441: case 'w':
442: n *= sizeof(int);
443: continue;
444:
445: case 'b':
446: n *= 512;
447: continue;
448:
449: case '*':
450: case 'x':
451: string = cs;
452: n *= number(BIG);
453:
454: case '\0':
455: if (n>=big || n<0) {
456: fprintf(stderr, "dd: argument %ld out of range\n", n);
457: exit(1);
458: }
459: return(n);
460: }
461: /* never gets here */
462: }
463:
464: cnull(cc)
465: {
466: register c;
467:
468: c = cc;
469: if(cflag&UCASE && c>='a' && c<='z')
470: c += 'A'-'a';
471: if(cflag&LCASE && c>='A' && c<='Z')
472: c += 'a'-'A';
473: null(c);
474: }
475:
476: null(c)
477: {
478:
479: *op = c;
480: op++;
481: if(++obc >= obs) {
482: flsh();
483: op = obuf;
484: }
485: }
486:
487: ascii(cc)
488: {
489: register c;
490:
491: c = etoa[cc] & 0377;
492: if(cbs == 0) {
493: cnull(c);
494: return;
495: }
496: if(c == ' ') {
497: nspace++;
498: goto out;
499: }
500: while(nspace > 0) {
501: null(' ');
502: nspace--;
503: }
504: cnull(c);
505:
506: out:
507: if(++cbc >= cbs) {
508: null('\n');
509: cbc = 0;
510: nspace = 0;
511: }
512: }
513:
514: unblock(cc)
515: {
516: register c;
517:
518: c = cc & 0377;
519: if(cbs == 0) {
520: cnull(c);
521: return;
522: }
523: if(c == ' ') {
524: nspace++;
525: goto out;
526: }
527: while(nspace > 0) {
528: null(' ');
529: nspace--;
530: }
531: cnull(c);
532:
533: out:
534: if(++cbc >= cbs) {
535: null('\n');
536: cbc = 0;
537: nspace = 0;
538: }
539: }
540:
541: ebcdic(cc)
542: {
543: register c;
544:
545: c = cc;
546: if(cflag&UCASE && c>='a' && c<='z')
547: c += 'A'-'a';
548: if(cflag&LCASE && c>='A' && c<='Z')
549: c += 'a'-'A';
550: c = atoe[c] & 0377;
551: if(cbs == 0) {
552: null(c);
553: return;
554: }
555: if(cc == '\n') {
556: while(cbc < cbs) {
557: null(atoe[' ']);
558: cbc++;
559: }
560: cbc = 0;
561: return;
562: }
563: if(cbc == cbs)
564: ntrunc++;
565: cbc++;
566: if(cbc <= cbs)
567: null(c);
568: }
569:
570: ibm(cc)
571: {
572: register c;
573:
574: c = cc;
575: if(cflag&UCASE && c>='a' && c<='z')
576: c += 'A'-'a';
577: if(cflag&LCASE && c>='A' && c<='Z')
578: c += 'a'-'A';
579: c = atoibm[c] & 0377;
580: if(cbs == 0) {
581: null(c);
582: return;
583: }
584: if(cc == '\n') {
585: while(cbc < cbs) {
586: null(atoibm[' ']);
587: cbc++;
588: }
589: cbc = 0;
590: return;
591: }
592: if(cbc == cbs)
593: ntrunc++;
594: cbc++;
595: if(cbc <= cbs)
596: null(c);
597: }
598:
599: block(cc)
600: {
601: register c;
602:
603: c = cc;
604: if(cflag&UCASE && c>='a' && c<='z')
605: c += 'A'-'a';
606: if(cflag&LCASE && c>='A' && c<='Z')
607: c += 'a'-'A';
608: c &= 0377;
609: if(cbs == 0) {
610: null(c);
611: return;
612: }
613: if(cc == '\n') {
614: while(cbc < cbs) {
615: null(' ');
616: cbc++;
617: }
618: cbc = 0;
619: return;
620: }
621: if(cbc == cbs)
622: ntrunc++;
623: cbc++;
624: if(cbc <= cbs)
625: null(c);
626: }
627:
628: term()
629: {
630:
631: stats();
632: exit(0);
633: }
634:
635: stats()
636: {
637:
638: fprintf(stderr,"%u+%u records in\n", nifr, nipr);
639: fprintf(stderr,"%u+%u records out\n", nofr, nopr);
640: if(ntrunc)
641: fprintf(stderr,"%u truncated records\n", ntrunc);
642: }
643:
644: enum ftype
645: checktype(fd)
646: int fd;
647: {
648: struct stat st;
649: struct mtget mt;
650:
651: if (fstat(fd, &st) == -1)
652: return (unknown);
653: if (S_ISFIFO(st.st_mode))
654: return (pipe);
655: if (S_ISCHR(st.st_mode)) {
656: if (ioctl(fd, MTIOCGET, (char *)&mt) != -1)
657: return (tape);
658: return (chr);
659: }
660: return (reg); /* or dir, symlink, blk, or ??? */
661: }
662:
663: advance(fd, fdtype, count)
664: {
665:
666: switch (fdtype) {
667: case reg:
668: case chr:
669: lseek(fd, count, L_INCR);
670: break;
671: case pipe:
672: case tape:
673: break;
674: default:
675: fprintf(stderr, "dd: unknown input type, can't resynchronize\n");
676: exit(99);
677: }
678: }
679:
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.