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