Commit | Line | Data |
---|---|---|
6de9a741 C |
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 | } |