![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to ansitape.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDTahoe / new / ansi|
Return to ansitape.c CVS log | Up to [CSRG BSD Unix] / 43BSDTahoe / new / ansi |
1.1 root 1: #include <sys/types.h>
2: #include <sys/time.h>
3: #include <sys/mtio.h>
4: #include <sys/ioctl.h>
5: #include <sys/file.h>
6: #include <sys/stat.h>
7: #include <a.out.h>
8: #include <stdio.h>
9: #include <ctype.h>
10:
11: char *malloc();
12: static void rewind();
13: long lseek();
14: int wflag;
15: int xflag;
16: int tflag;
17: int cflag;
18: int vflag;
19: int dflag;
20: int fflag;
21: int totalreadfiles = 0 ;
22: int totalreadblocks = 0 ;
23: int totalreadlines = 0 ;
24: int totalreadchars = 0 ;
25: int totalwritefiles = 0 ;
26: int totalwriteblocks = 0 ;
27: int totalwritelines = 0 ;
28: int totalwritechars = 0 ;
29:
30: main(argc,argv)
31: int argc;
32: char *argv[];
33: {
34: struct tm *tm;
35: long timetemp,time();
36: int year;
37: int day;
38: char *tapename;
39: char *filename;
40: char *namelist=NULL;
41: char *device = "/dev/rmt12";
42: int tape;
43: int file;
44: int filenum;
45: int argnum;
46: char line[1001];
47: char vmsname[1000];
48: char unixname[1000];
49: FILE *names;
50: int count;
51: int tmp;
52: char blockchar;
53: int blocksize=2048;
54: int recordsize=1;
55:
56: char *key;
57:
58: timetemp = time((long *)NULL);
59: tm = localtime(&timetemp);
60: year = tm->tm_year;
61: day = tm->tm_yday;
62: tapename = malloc(10);
63: gethostname(tapename,6);
64: tapename[7]='\0';
65:
66: /* parse command line */
67: if (argc < 2)
68: usage();
69:
70: argv++;
71: argc--;
72: /* loop through first argument (key) */
73: argc--;
74: for (key = *argv++; *key; key++)
75: switch(*key) {
76:
77: case 'f':
78: if (*argv == NULL || argc <1) {
79: fprintf(stderr,
80: "ansitape: 'f' option requires tape name \n");
81: usage();
82: }
83: device = *argv++;
84: argc--;
85: break;
86:
87: case 'n':
88: if (*argv == NULL || argc <1) {
89: fprintf(stderr,
90: "ansitape: 'n' option requires file name\n");
91: usage();
92: }
93: namelist = *argv++;
94: argc--;
95: break;
96:
97: case 'l':
98: if (*argv == NULL || argc<1) {
99: fprintf(stderr,
100: "ansitape: 'l' option requires label\n");
101: usage();
102: }
103: tapename = *argv++;
104: argc--;
105: break;
106:
107: case 'F':
108: if(*argv == NULL) {
109: fprintf(stderr,
110: "ansitape: 'F' options requires recordsize and blocksize specifiers.\n"
111: );
112: usage();
113: }
114: tmp = sscanf(*argv++," %d%c ",&recordsize,&blockchar);
115: argc--;
116: if(tmp<1) {
117: fprintf(stderr,"illegal recordsize: recordsize set to 80\n");
118: recordsize=80;
119: } else if(tmp>1) {
120: if(blockchar == 'b') recordsize *= 512;
121: if(blockchar == 'k') recordsize *= 1024;
122: }
123:
124: if (*argv == NULL) {
125: fprintf(stderr,
126: "ansitape: 'F' option requires blocksize specifier \n");
127: usage();
128: }
129: tmp = sscanf(*argv++," %d%c ",&blocksize,&blockchar);
130: argc--;
131: if(tmp<1) {
132: fprintf(stderr,"illegal blocksize: blocksize set to 2048\n");
133: blocksize=2048;
134: } else if(tmp>1) {
135: if(blockchar == 'b') blocksize *= 512;
136: if(blockchar == 'k') blocksize *= 1024;
137: }
138: if(blocksize <18) blocksize=18;
139: if(blocksize >62*1024) blocksize=62*1024;
140: fflag++;
141: break;
142:
143: case 'b':
144: if (*argv == NULL) {
145: fprintf(stderr,
146: "ansitape: 'b' option requires blocksize specifier \n");
147: usage();
148: }
149: tmp = sscanf(*argv++," %d%c ",&blocksize,&blockchar);
150: argc--;
151: if(tmp<1) {
152: fprintf(stderr,"illegal blocksize: blocksize set to 2048\n");
153: blocksize=2048;
154: } else if(tmp>1) {
155: if(blockchar == 'b') blocksize *= 512;
156: if(blockchar == 'k') blocksize *= 1024;
157: }
158: if(blocksize <18) blocksize=18;
159: if(blocksize >62*1024) blocksize=62*1024;
160: break;
161:
162: case 'c':
163: cflag++;
164: wflag++;
165: break;
166:
167: case 'r':
168: /*I know, this should be rflag, but I just don't like r for write*/
169: wflag++;
170: break;
171:
172: case 'v':
173: vflag++;
174: break;
175:
176: case 'x':
177: xflag++;
178: break;
179:
180: case 't':
181: tflag++;
182: break;
183:
184: case '-':
185: break;
186:
187: default:
188: fprintf(stderr, "ansitape: %c: unknown option\n", *key);
189: usage();
190: }
191:
192: if (!wflag && !xflag && !tflag)
193: usage();
194:
195: tape = open(device,wflag?O_RDWR:O_RDONLY,NULL);
196: if(tape<0) {
197: perror(device);
198: fprintf(stderr,"tape not accessable - check if drive online and write ring present\n");
199: exit(1);
200: }
201: rewind(tape);
202: filenum=1;
203: casefix(tapename);
204:
205: if(cflag) {
206: writevol(tapename,tape);
207: } else {
208: getvol(tapename,tape);
209: while(1) {
210: /* read files */
211: if( readfile(tape,argc,argv) ) break;
212: filenum++;
213: }
214: backspace(tape);
215: }
216:
217: if(wflag) {
218: if(namelist) {
219: if(*namelist == '-') {
220: names = stdin;
221: } else {
222: names=fopen(namelist,"r");
223: if(names == NULL) {
224: fprintf(stderr,"unable to open namelist file - no files added to tape\n");
225: }
226: }
227: while(1) {
228: fgets(line,1000,names);
229: if(feof(names)) break;
230: count = sscanf(line,"%s %s",unixname,vmsname);
231: if(count<1) continue; /* blank line */
232: if(count==1) strcpy(vmsname,unixname);
233: casefix(vmsname);
234: if(filecheck(&file,unixname)) continue;
235: writefile(tape,file,vmsname,tapename,filenum,year,day,blocksize,
236: recordsize);
237: filenum++;
238: close(file);
239: }
240: } else {
241: for(argnum=0;argnum<argc;argnum++) {
242: filename = argv[argnum];
243: if(filecheck(&file,filename)) continue;
244: casefix(filename);
245: writefile(tape,file,filename,tapename,filenum,year,day,
246: blocksize,recordsize);
247: filenum++;
248: close(file);
249: }
250: }
251: writetm(tape);
252: writetm(tape);
253: writetm(tape);
254: writetm(tape);
255: }
256: rewind(tape);
257: close(tape);
258: if(vflag && (tflag || xflag)) {
259: fprintf(stdout," read %d files in %d blocks (%d lines, %d chars)\n",
260: totalreadfiles,totalreadblocks,totalreadlines,totalreadchars);
261: }
262: if(vflag && wflag) {
263: fprintf(stdout," wrote %d files in %d blocks (%d lines, %d chars)\n",
264: totalwritefiles,totalwriteblocks,totalwritelines,totalwritechars);
265: }
266: return(0);
267: }
268: usage() {
269: fprintf(stderr,
270: "ansitape: usage: ansitape -{rxtc}[flnvb] [filename] [label] [filename] [blocksize] [files]\n");
271: exit(1);
272: }
273:
274: writefile(tape,file,filename,tapename,filenum,year,day,blocksize,recordsize)
275: int tape;
276: int file;
277: char *filename;
278: char *tapename;
279: int filenum;
280: int year;
281: int day;
282: int blocksize;
283: int recordsize;
284:
285: {
286: int blocks;
287: writehdr1(tape,filename,tapename,filenum,year,day);
288: writehdr2(tape,blocksize,recordsize);
289: writehdr3(tape);
290: writetm(tape);
291: writedata(tape,file,filename,&blocks,blocksize,recordsize);
292: writetm(tape);
293: writeeof1(tape,filename,tapename,filenum,year,day,blocks);
294: writeeof2(tape,blocksize,recordsize);
295: writeeof3(tape);
296: writetm(tape);
297: totalwritefiles++;
298: }
299:
300: writedata(tape,file,filename,blocks,blocksize,recsize)
301: int tape;
302: int file;
303: char *filename;
304: int *blocks;
305: int blocksize;
306: int recsize;
307: {
308: char *ibuf;
309: char *ibufstart;
310: char *obuf;
311: char *obufstart;
312: char *endibuf;
313: char *endobuf;
314: int got;
315: int i;
316: char *j;
317: int numchar = 0 ;
318: int numline = 0 ;
319: int numblock = 0;
320: int success;
321:
322: ibufstart = ibuf = malloc((unsigned)(blocksize<4096?8200:(2*blocksize+10)));
323: obufstart = obuf = malloc((unsigned)(blocksize+10));
324: endobuf = obuf + blocksize;
325: endibuf = ibuf;
326:
327:
328: i=0;
329: if (!fflag) {
330: while(1) {
331: if(ibuf+i>=endibuf) { /* end of input buffer */
332: strncpy(ibufstart,ibuf,endibuf-ibuf); /* copy leftover to start */
333: ibuf = ibufstart+(endibuf-ibuf); /* point to end of valid data */
334: got = read(file,ibuf,blocksize<4096?4096:2*blocksize); /* read in a chunk */
335: endibuf = ibuf + got;
336: ibuf = ibufstart; /* point to beginning of data */
337: if(got == 0) { /* end of input */
338: if(ibuf==ibufstart){ /* no leftovers */
339: break; /* done */
340: } else {
341: ibuf[i]='\n'; /* fake extra newline */
342: }
343: }
344: }
345:
346: if(obuf+i+4 > endobuf) { /* end of output buffer */
347: if(i>blocksize-4) {
348: printf("record exceeds blocksize - file truncated\n");
349: break;
350: }
351: /* filled up output record - have to fill,output,restart*/
352: for(j=obuf;j<endobuf;j++) {
353: *j = '^';
354: }
355: success = write(tape,obufstart,blocksize);
356: if(success != blocksize) {
357: perror("tape");
358: fprintf(stderr," hard write error: write aborted\n");
359: rewind(tape);
360: exit(1);
361: }
362: obuf=obufstart;
363: numchar -= i;
364: i=0;
365: numblock++;
366: continue;
367: }
368:
369: if(ibuf[i] == '\n') { /* end of line */
370: obuf[0] = ((i+4)/1000) + '0';
371: obuf[1] = (((i+4)/100)%10) + '0';
372: obuf[2] = (((i+4)/10)%10) + '0';
373: obuf[3] = (((i+4)/1)%10) + '0';
374: obuf += (4+i); /* size + strlen */
375: ibuf += (1+i); /* newline + strlen */
376: i=0;
377: numline++;
378: continue; /* back to the top */
379: }
380:
381: obuf[i+4]=ibuf[i];
382: numchar++;
383: i++;
384:
385: }
386: /* exited - write last record and go for lunch */
387: if(obuf != obufstart) {
388: for(j=obuf;j<endobuf;j++) {
389: *j = '^';
390: }
391: success = write(tape,obufstart,blocksize);
392: if(success != blocksize) {
393: perror("tape");
394: fprintf(stderr," hard write error: write aborted\n");
395: rewind(tape);
396: exit(1);
397: }
398: numblock++;
399: }
400: } else {
401: fflush(stdout);
402: while(1) {
403: /* writing an 'F' format tape */
404: got = read(file,ibuf,recsize+1);
405: if(got == 0) {
406: /* end of input */
407: if(obuf<=obufstart) {
408: break; /* done */
409: } else {
410: /* no more data, so force the record out */
411: recsize = blocksize+1;
412: }
413: } else if(got != recsize+1) {
414: printf("short read: filled\n");
415: } else if( *(ibuf+recsize) != '\n') {
416: printf("corrupted record - write aborted\b");
417: rewind(tape);
418: exit(1);
419: }
420: if(obuf+recsize >endobuf) {
421: /*would overflow output buffer, so fill up old buffer */
422: for(j=obuf;j<endobuf;j++) {
423: *j = '^';
424: }
425: /* and write it */
426: success = write(tape,obufstart,blocksize);
427: if(success != blocksize) {
428: perror("tape");
429: fprintf(stderr," hard write error: write aborted\n");
430: rewind(tape);
431: exit(1);
432: }
433: obuf=obufstart;
434: numblock++;
435: }
436: bcopy(ibuf,obuf,recsize);
437: obuf+=got-1;
438: numline++;
439: numchar += recsize;
440: }
441: numchar -= recsize;
442: numline--;
443: }
444: free(ibufstart);
445: free(obufstart);
446: if(vflag) {
447: fprintf(stdout,"r - %s: %d lines (%d chars) in %d tape blocks\n",
448: filename,numline,numchar,numblock);
449: }
450: totalwritechars += numchar;
451: totalwritelines += numline;
452: totalwriteblocks += numblock;
453: *blocks = numblock;
454: }
455:
456: writetm(tape)
457: int tape;
458: {
459: struct mtop mtop;
460: mtop.mt_op = MTWEOF;
461: mtop.mt_count = 1;
462: ioctl(tape,MTIOCTOP,&mtop);
463: }
464:
465: void
466: static rewind(tape)
467: int tape;
468: {
469: struct mtop mtop;
470: mtop.mt_op = MTREW;
471: mtop.mt_count = 1;
472: ioctl(tape,MTIOCTOP,&mtop);
473: }
474:
475: skipfile(tape)
476: int tape;
477: {
478: struct mtop mtop;
479: mtop.mt_op = MTFSF;
480: mtop.mt_count = 1;
481: ioctl(tape,MTIOCTOP,&mtop);
482: }
483:
484: backspace(tape)
485: int tape;
486: {
487: struct mtop mtop;
488: mtop.mt_op = MTBSF;
489: mtop.mt_count = 1;
490: ioctl(tape,MTIOCTOP,&mtop);
491: }
492:
493: writehdr1(tape,filename,tapename,filenum,year,day)
494: int tape;
495: char *filename;
496: char *tapename;
497: int filenum;
498: int year;
499: int day;
500: {
501: char buf[81];
502: sprintf(buf,
503: "HDR1%-17.17s%-6.6s0001%4.4d000101 %2.2d%3.3d %2.2d%3.3d 000000DECFILE11A "
504: ,filename,tapename,filenum,year,day,year,day);
505: write(tape,buf,80);
506: }
507:
508: writeeof1(tape,filename,tapename,filenum,year,day,blocks)
509: int tape;
510: char *filename;
511: char *tapename;
512: int filenum;
513: int year;
514: int day;
515: int blocks;
516: {
517: char buf[81];
518: sprintf(buf,
519: "EOF1%-17.17s%-6.6s0001%4.4d000101 %2.2d%3.3d %2.2d%3.3d %6.6dDECFILE11A "
520: ,filename,tapename,filenum,year,day,year,day,blocks);
521: write(tape,buf,80);
522: }
523:
524: writehdr2(tape,blocksize,recordsize)
525: int tape;
526: int blocksize;
527: int recordsize;
528: {
529: char buf[81];
530: sprintf(buf,"HDR2%c%5.5d%5.5d%35.35s00%28.28s",fflag?'F':'D',
531: blocksize,recordsize," "," ");
532: write(tape,buf,80);
533: }
534:
535: writeeof2(tape,blocksize,recordsize)
536: int tape;
537: int blocksize;
538: int recordsize;
539: {
540: char buf[81];
541: sprintf(buf,"EOF2%c%5.5d%5.5d%35.35s00%28.28s",fflag?'F':'D',
542: blocksize,recordsize," "," ");
543: write(tape,buf,80);
544: }
545:
546: writehdr3(tape)
547: int tape;
548: {
549: char buf[81];
550: sprintf(buf, "HDR3%76.76s"," ");
551: write(tape,buf,80);
552: }
553:
554: writeeof3(tape)
555: int tape;
556: {
557: char buf[81];
558: sprintf(buf, "EOF3%76.76s"," ");
559: write(tape,buf,80);
560: }
561:
562: writevol(tapename,tape)
563: int tape;
564: char *tapename;
565: {
566: char buf[81];
567: sprintf(buf,"VOL1%-6.6s %26.26sD%cC%10.10s1%28.28s3",tapename," ",'%'," "," ");
568: write(tape,buf,80);
569: if(vflag) {
570: fprintf(stdout," tape labeled %-6.6s\n",tapename);
571: }
572: }
573:
574: getvol(tapename,tape)
575: int tape;
576: char *tapename;
577: {
578: char buf[81];
579: read(tape,buf,80);
580: sscanf(buf,"VOL1%6s",tapename);
581: if(vflag) {
582: fprintf(stdout," tape was labeled %-6.6s\n",tapename);
583: }
584: }
585:
586: casefix(string)
587: register char *string;
588: {
589: while(*string) {
590: if(islower(*string)) {
591: *string = toupper(*string);
592: }
593: string++;
594: }
595: }
596:
597: int
598: readfile(tape,argc,argv)
599: int tape;
600: int argc;
601: char *argv[];
602: {
603: char buf[80];
604: char mode;
605: char filename[18];
606: FILE *file;
607: int extract;
608: char *ibuf;
609: char *ibufstart;
610: char *endibuf;
611: char *fixpoint;
612: int size;
613: int numblock = 0 ;
614: int numchar = 0 ;
615: int numline = 0 ;
616: int argnum;
617: int ok;
618: int blocksize;
619: int recordsize;
620:
621: if(!(read(tape,buf,80))) return(1); /* no hdr record, so second eof */
622: sscanf(buf,"HDR1%17s",filename);
623: read(tape,buf,80);
624: sscanf(buf,"HDR2%c%5d%5d",&mode,&blocksize,&recordsize);
625: blocksize = blocksize>recordsize?blocksize:recordsize;
626: skipfile(tape); /* throw away rest of header(s) - not interesting */
627: ibufstart=ibuf=malloc((unsigned)(blocksize+10));
628: endibuf=ibufstart+blocksize;
629: extract=0;
630: if(tflag || xflag) {
631: ok=0;
632: if(!argc) {
633: ok=1;
634: } else for(argnum=0;argnum<argc;argnum++) {
635: casefix(argv[argnum]);
636: if(!strcmp(filename,argv[argnum])) {
637: ok=1;
638: break;
639: }
640: }
641: if(mode == 'D') {
642: if(xflag && ok) {
643: file = fopen(filename,"w");
644: if(file == NULL) {
645: perror(filename);
646: } else {
647: extract = 1;
648: }
649: }
650: while(size=read(tape,ibufstart,blocksize)) {
651: if(size != blocksize) {
652: /*
653: * somebody's brain damaged program leaves
654: * short blocks on the tape - fill them up to size
655: * (this is work THEY should have done before writing
656: * their undersized blocks)
657: */
658: for(fixpoint=ibufstart+size;fixpoint<endibuf;fixpoint++) {
659: *fixpoint='^';
660: }
661: }
662: numblock++;
663: ibuf = ibufstart;
664: while(strncmp("^^^^",ibuf,4)) {
665: #define getsize(a) ((a[0]-'0')*1000)+((a[1]-'0')*100)+((a[2]-'0')*10)+(a[3]-'0')
666: #define bad(a) (!(isdigit(ibuf[a])))
667: if(bad(0) || bad(1) || bad(2) || bad(3)) {
668: fprintf(stderr, "error: bad record length field - file may be corrupted, skipping\n");
669: break;
670: }
671: size = getsize(ibuf);
672: if(extract) {
673: fwrite(ibuf+4,sizeof(char),size-4,file);
674: fwrite("\n",1,1,file);
675: }
676: ibuf += (size);
677: numline++;
678: numchar += (size-4);
679: if(ibuf > endibuf+1) {
680: fprintf(stderr,"error: bad tape records(s) - file may be corrupted\n");
681: break;
682: }
683: if(ibuf>endibuf-4) break;
684: }
685: }
686: if(extract) {
687: fclose(file);
688: }
689: } else if (mode == 'F') {
690: if(xflag && ok) {
691: file = fopen(filename,"w");
692: if(file == NULL) {
693: perror(filename);
694: } else {
695: extract = 1;
696: }
697: }
698: while(read(tape,ibufstart,blocksize)) {
699: numblock++;
700: ibuf = ibufstart;
701: while(ibuf+recordsize <= endibuf) {
702: if(extract) {
703: fwrite(ibuf,sizeof(char),recordsize,file);
704: fwrite("\n",1,1,file);
705: }
706: ibuf += recordsize;
707: numline++;
708: numchar += recordsize;
709: }
710: }
711: if(extract) {
712: fclose(file);
713: }
714: } else {
715: fprintf(stderr,"unknown record mode (%c) - file %s skipped\n",
716: mode,filename);
717: skipfile(tape); /* throw away actual file */
718: }
719: } else {
720: /* not interested in contents of file, so move fast */
721: skipfile(tape);
722: }
723: skipfile(tape); /* throw away eof stuff - not interesting */
724: totalreadchars += numchar;
725: totalreadlines += numline;
726: totalreadblocks += numblock;
727: totalreadfiles ++;
728: if(xflag && vflag && ok) {
729: fprintf(stdout,"x - %s: %d lines (%d chars) in %d tape blocks\n",
730: filename,numline,numchar,numblock);
731: } else if(tflag && ok) {
732: fprintf(stdout,"t - %s: %d lines (%d chars) in %d tape blocks\n",
733: filename,numline,numchar,numblock);
734: }
735: free(ibufstart);
736: return(0);
737: }
738:
739: filecheck(file,name)
740: int *file;
741: char *name;
742:
743: {
744:
745: struct stat buf;
746: struct exec sample;
747:
748: stat(name,&buf);
749: if ((buf.st_mode & S_IFDIR)==S_IFDIR) {
750: fprintf(stderr,"%s: directory - skipped\n",name);
751: return(1);
752: }
753: if ((buf.st_mode & S_IFCHR)==S_IFCHR) {
754: fprintf(stderr,"%s: character device - skipped\n",name);
755: return(1);
756: }
757: if ((buf.st_mode & S_IFBLK)==S_IFBLK) {
758: fprintf(stderr,"%s: block device - skipped\n",name);
759: return(1);
760: }
761: if ((buf.st_mode & S_IFLNK)==S_IFLNK) {
762: fprintf(stderr,"%s: symbolic link - skipped\n",name);
763: return(1);
764: }
765: if ((buf.st_mode & S_IFSOCK)==S_IFSOCK) {
766: fprintf(stderr,"%s: socket - skipped\n",name);
767: return(1);
768: }
769: *file = open(name,O_RDONLY,NULL);
770: if(*file <0) {
771: perror(name);
772: return(1);
773: }
774: if(read(*file,&sample,sizeof(struct exec))>= sizeof(struct exec)) {
775: if(!(N_BADMAG(sample))) {
776: /* executable */
777: /* the format requires either fixed blocked records,
778: * or variable format records with each record remaining
779: * entirely within a tape block - this limits the
780: * distance between \n's to 2044 bytes, something
781: * which is VERY rarely true of executables, so
782: * we don't even try with them....
783: */
784: close(*file);
785: fprintf(stderr,"%s: executable - skipped\n",name);
786: return(1);
787: }
788: }
789: /* either couldn't read sizeof(struct exec) or wasn't executable */
790: /* so we assume it is a reasonable file until proven otherwise */
791: lseek(*file,0l,0);
792: return(0);
793: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.