![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to file.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|
Return to file.c CVS log | Up to [MW Coherent from dump] / coherent / d / bin |
1.1 root 1: char _version[] = "Version 1.1";
2: /*
3: * Look at a file and try to
4: * figure out its type. Knows about the various
5: * flavours of filesystem entries, object files of various
6: * types, C programs, input to one of the various flavours
7: * of text formatter, etc.
8: */
9: #include <stdio.h>
10: #include <ctype.h>
11: #include <sys/stat.h>
12: #include <sys/uproc.h>
13: #include <n.out.h>
14: #include <filehdr.h>
15: #include <canon.h>
16: #include <ar.h>
17:
18: /* UNIX archive magic numbers */
19: #define COFFARMAG "!<arch>\n"
20: #define COFFARMAG_RAN "!<arch>\n/"
21: #define UARMAG 0177545 /* UNIX v7 archives */
22: #define OUARMAG 0177555 /* UNIX v6 and previous archives */
23:
24: #define COMPRESSED 0x9D1F /* Output of "compress(1)" command. */
25:
26: #define EXEC (S_IEXEC|(S_IEXEC<<3)|(S_IEXEC<<6))
27:
28: /*
29: * This is a tar header.
30: */
31: struct th_info {
32: char th_name[100],
33: th_mode[8],
34: th_uid[8],
35: th_gid[8],
36: th_size[12],
37: th_mtime[12],
38: th_check[8],
39: th_islink,
40: th_link[100],
41: th_pad[255];
42: };
43:
44: /*
45: * The first BUFSIZ bytes of the
46: * file in question are read into this
47: * union. It contains members for accessing
48: * the possible file structures.
49: */
50:
51: union iobuf
52: {
53: char u_buf[BUFSIZ]; /* General data */
54: struct ldheader u_lout; /* L.out object file header */
55: struct filehdr u_coff; /* COFF object file header */
56: UPROC u_u; /* core file header */
57: int u_armag; /* Archive number */
58: struct th_info u_tar; /* Tar header */
59: };
60:
61: char *type;
62:
63: union iobuf iobuf;
64: char *file();
65: char *textclass();
66: char *objclass();
67: char *coffclass();
68: char *dirtype();
69: char *mtype();
70: char *coffmtype();
71: char *strcat();
72:
73: main(argc, argv)
74: char *argv[];
75: {
76: struct stat sb;
77: register char *p;
78: register int i;
79: register int estat;
80:
81: if (argc < 2) {
82: fprintf(stderr, "Usage: file name ...\n");
83: exit(1);
84: }
85: estat = 0;
86: for (i=1; i<argc; i++) {
87: p = argv[i];
88: if (stat(p, &sb) < 0) {
89: fprintf(stderr, "file: %s: not accessible\n", p);
90: estat = 1;
91: continue;
92: }
93: printf("%s: %s\n", p, file(&sb, p));
94: }
95: exit(estat);
96: }
97:
98: /*
99: * Routine to guess filetype
100: */
101: char *
102: file(sbp, fn)
103: struct stat *sbp;
104: char *fn;
105: {
106: static char buf[50];
107: int magic;
108: register int nb;
109: register int fd = -1;
110:
111: if ((sbp->st_mode&S_IFMT) != S_IFREG) {
112: switch (sbp->st_mode & S_IFMT) {
113: case S_IFDIR:
114: return (dirtype(fn));
115:
116: case S_IFBLK:
117: sprintf(buf, "block special file %d/%d",
118: major(sbp->st_rdev), minor(sbp->st_rdev));
119: return (buf);
120:
121: case S_IFCHR:
122: sprintf(buf, "character special file %d/%d",
123: major(sbp->st_rdev), minor(sbp->st_rdev));
124: return (buf);
125:
126: case S_IFMPB:
127: return ("block multiplexor file");
128:
129: case S_IFMPC:
130: return ("character multiplexor file");
131:
132: case S_IFPIP:
133: return ("named pipe");
134:
135: default:
136: return ("invalid filetype");
137: }
138: }
139: if ((fd = open(fn, 0)) < 0)
140: return ("unreadable");
141: if ((nb = read(fd, (char *) &iobuf, sizeof(iobuf))) < 0) {
142: close(fd);
143: return ("read error");
144: }
145: close(fd);
146: if (nb == 0)
147: return ("empty");
148: /* l.out executable? */
149: if (nb >= sizeof(struct ldheader)) {
150: magic = iobuf.u_lout.l_magic;
151: canint(magic);
152: if (magic == L_MAGIC) {
153: canint(iobuf.u_lout.l_flag);
154: canint(iobuf.u_lout.l_machine);
155: return (objclass(fd, &iobuf.u_lout));
156: }
157: }
158: /* COFF executable? */
159: if (nb >= sizeof(struct filehdr)) {
160: magic = iobuf.u_coff.f_magic;
161: if (ISCOFF(magic)) {
162: return (coffclass(&iobuf.u_coff));
163: }
164: }
165:
166: /* COFF archive? */
167: if (nb >= strlen(COFFARMAG_RAN)) {
168: if ( strncmp(COFFARMAG_RAN,
169: iobuf.u_buf,
170: strlen(COFFARMAG_RAN)) == 0) {
171: return("COFF archive (ranlib)");
172: }
173: if ( strncmp(COFFARMAG, iobuf.u_buf, strlen(COFFARMAG)) == 0) {
174: return("COFF archive");
175: }
176: }
177:
178: if (nb >= sizeof(struct th_info)) {
179: if ( tar_path(iobuf.u_tar.th_name, 100) &&
180: tar_oct(iobuf.u_tar.th_mode, 8) &&
181: tar_dec(iobuf.u_tar.th_uid, 8) &&
182: tar_dec(iobuf.u_tar.th_gid, 8) &&
183: tar_dec(iobuf.u_tar.th_size, 12) &&
184: tar_dec(iobuf.u_tar.th_mtime, 12) &&
185: strlen(iobuf.u_tar.th_pad) < 8 ) {
186:
187: type = malloc(64);
188:
189: type[0] ='\0';
190: if ( '\0' != iobuf.u_tar.th_pad[0]) {
191: strcpy(type, iobuf.u_tar.th_pad);
192: } else {
193: strcpy(type, "v7 tar");
194: }
195:
196: strcat(type, " archive");
197: return(type);
198: } /* if looks like a tar header. */
199: }
200:
201: /* core file?
202: * This is pure heuristic. If the last signal number was legal
203: * (a 13/256 random chance) and if the command string is NUL
204: * terminated (about 1/5 random chance) and at least one long,
205: * and if all of the
206: * characters are printable (~ (96/256)^4), we assume it really
207: * is a core file. (Pardon the crude statistics.)
208: * That all adds up to a less than 0.1% chance of incorrectly
209: * classifying a random binary file.
210: */
211: if (nb > sizeof(UPROC)) {
212: if ((iobuf.u_u.u_signo < NSIG) && /* Legal signal? */
213: (iobuf.u_u.u_comm[9] == '\0') ) { /* Terminated command? */
214: char *comm;
215: int i;
216: int len;
217:
218: /* Check to see if the command is printable. */
219: comm = iobuf.u_u.u_comm;
220: len = strlen(comm);
221:
222: for (i=0; isprint(comm[i]) && (i < len); i++) {
223: /* Do nothing. */
224: }
225: /* If we go to the end, probably a core file. */
226: if (len == i && len > 0) {
227: type = malloc(64);
228: sprintf(type, "core file from \"%s\"", comm);
229: return(type);
230: }
231:
232: }
233: }
234:
235: /* Archive or compress'ed file? */
236: if (nb >= sizeof (int)) {
237: magic = iobuf.u_armag;
238: canint(magic);
239: if (magic == ARMAG)
240: return ("l.out archive");
241: if (magic == UARMAG)
242: return ("seventh edition archive");
243: if (magic == OUARMAG)
244: return ("sixth edition archive");
245: if (magic == COMPRESSED){
246: type = malloc(64);
247: sprintf(type, "%d bit compressed file",
248: (int) (0x7f & iobuf.u_buf[2]));
249: return(type);
250: }
251: }
252:
253: if (hasnonascii((unsigned char *) &iobuf, nb))
254: return ("binary data");
255: if ((sbp->st_mode&EXEC) != 0) {
256: if (strncmp(iobuf.u_buf, "#!", 2) == 0) {
257: type = malloc(64);
258: sprintf(type, "%s script",
259: strtok(&(iobuf.u_buf[2]), " \t\n"));
260: return(type);
261: } else {
262: return ("commands");
263: }
264: }
265: return (textclass((unsigned char *) &iobuf, nb));
266: }
267:
268: /*
269: * Return the type of the directory.
270: * Currently, only "s.*" is recognised as SCCS directory.
271: */
272: char *
273: dirtype(dn)
274: register char *dn;
275: {
276: register char *cp;
277:
278: for (cp=dn; *cp!='\0'; cp++)
279: ;
280: while (cp > dn)
281: if (*--cp == '/') {
282: cp++;
283: break;
284: }
285: if (cp[0]=='s' && cp[1]=='.')
286: return ("SCCS directory");
287:
288: if (strcmp(cp, "RCS") == 0)
289: return ("RCS directory");
290:
291: return ("directory");
292: }
293:
294: /*
295: * Return true if there ar characters
296: * in the buffer that do not look like good
297: * ascii characters.
298: * This routine knows that ascii is a seven
299: * bit code.
300: */
301: hasnonascii(bp, nb)
302: register unsigned char *bp;
303: register nb;
304: {
305: while (nb--) {
306: if (!isascii(*bp))
307: return (1);
308: if (!(isprint(*bp) || isspace(*bp) || *bp=='\b' || *bp=='\a'))
309: return (1);
310: bp++;
311: }
312: return (0);
313: }
314:
315: /*
316: * Classify the first `nb'
317: * bytes of a text file.
318: */
319: char *
320: textclass(bp, nb)
321: register unsigned char *bp;
322: register nb;
323: {
324: register int c;
325: int nlf = 1;
326: int nlbrace;
327: int nrbrace;
328: int nsharps;
329: int nsemi;
330: int xmail;
331: char *sbp = bp;
332:
333: nlbrace = 0;
334: nrbrace = 0;
335: nsharps = 0;
336: nsemi = 0;
337: xmail = 0;
338: while (nb--) {
339: c = *bp++;
340: if (c=='.' && strncmp(bp, "globl", 5)==0)
341: return ("assembler");
342: if (nlf) {
343: if (c == '.')
344: return ("nroff, tbl or eqn input");
345: else if (c == ':')
346: return ("commands");
347: else if (c == '#')
348: ++nsharps;
349: else if (c=='%')
350: if (*bp=='%' || *bp=='{' || *bp=='}')
351: return ("yacc or lex input");
352: }
353: if (c == '{')
354: ++nlbrace;
355: else if (c == '}')
356: ++nrbrace;
357: if (c == '\n') {
358: nlf = 1;
359: if (bp[-2] == ';')
360: nsemi++;
361: if (((bp-sbp) % 22) == 0) {
362: if (bp[-2]==' ' || bp[-2]=='!')
363: xmail++;
364: } else
365: xmail = 0;
366: } else
367: nlf = 0;
368: }
369: if (xmail)
370: return ("xmail encoded text");
371: if ((nsharps || nsemi) && (nlbrace || nrbrace))
372: return ("C program");
373: return ("probably text");
374: }
375:
376: /*
377: * Figure out the type of an l.out
378: * object file. Tag it with the machine
379: * id if not for the machine upon which the
380: * command is running.
381: */
382: char *
383: objclass(fd, lhp)
384: register struct ldheader *lhp;
385: {
386: static char type[64];
387: register char *mch;
388: struct ldsym lds;
389: register fsize_t stbase;
390: register i;
391:
392: type[0] = '\0';
393: if ((lhp->l_flag&LF_32) != 0)
394: strcat(type, "32 bit ");
395: if ((lhp->l_flag&LF_SLIB) != 0)
396: strcat(type, "shared library ");
397: if ((lhp->l_flag&LF_SLREF) != 0)
398: strcat(type, "libref ");
399: if ((lhp->l_flag&LF_SHR) != 0)
400: strcat(type, "shared ");
401: if ((lhp->l_flag&LF_SEP) != 0)
402: strcat(type, "separate ");
403: if ((lhp->l_flag&LF_KER) != 0) {
404: register unsigned ssize;
405:
406: ssize = sizeof (lds);
407: if ((lhp->l_flag & LF_32) == 0) {
408: stbase = sizeof(*lhp) - 2*sizeof(int);
409: ssize -= sizeof (int);
410: } else {
411: canshort(lhp->l_tbase);
412: stbase = lhp->l_tbase;
413: }
414: for (i=L_SHRI; i<L_SYM; ++i)
415: if (i!=L_BSSI && i!=L_BSSD) {
416: cansize(lhp->l_ssize[i]);
417: stbase += lhp->l_ssize[i];
418: }
419: lseek(fd, stbase, 0);
420: cansize(lhp->l_ssize[L_SYM]);
421: while (lhp->l_ssize[L_SYM] != 0) {
422: if (read(fd, &lds, ssize) != ssize)
423: break;
424: canshort(lds.ls_type);
425: if (strncmp(lds.ls_id, "conftab_", NCPLN) == 0
426: && (lds.ls_type&LR_SEG) != L_REF)
427: break;
428: lhp->l_ssize[L_SYM] -= ssize;
429: }
430: strcat(type, lhp->l_ssize[L_SYM]==0?"kernel ":"driver ");
431: }
432: strcat(type, "executable");
433: if ((lhp->l_flag&LF_NRB) == 0)
434: strcat(type, " with relocation");
435: if ((mch = mtype(lhp->l_machine)) == NULL)
436: mch = "Unknown machine type";
437: sprintf(type, "%s (%s)", type, mch);
438: return (type);
439: }
440:
441: /*
442: * Figure out the type of a coff
443: * object file. Tag it with the machine
444: * id if not for the machine upon which the
445: * command is running.
446: */
447: char *
448: coffclass(chp)
449: register struct filehdr *chp;
450: {
451: static char type[64];
452: register char *mch;
453:
454: sprintf(type, "COFF ");
455: if ((chp->f_flags&F_MINMAL) != 0)
456: strcat(type, "minimal ");
457: if ((chp->f_flags&F_UPDATE) != 0)
458: strcat(type, "update ");
459: if ((chp->f_flags&F_SWABD) != 0)
460: strcat(type, "swapped bytes ");
461: if ((chp->f_flags&F_PATCH) != 0)
462: strcat(type, "patch ");
463: if ((chp->f_flags&F_NODF) != 0)
464: strcat(type, "no decision ");
465: if ((chp->f_flags&F_EXEC) != 0){
466: if ((chp->f_flags&F_LSYMS) != 0)
467: strcat(type, "stripped ");
468: strcat(type, "executable ");
469: } else {
470: strcat(type, "object ");
471: if ((chp->f_flags&F_RELFLG) != 0)
472: strcat(type, "stripped relocation ");
473:
474: if ((chp->f_flags&F_LSYMS) != 0)
475: strcat(type, "stripped symbols ");
476: }
477:
478: if ((mch = coffmtype(chp->f_magic)) == NULL)
479: mch = "Unknown machine type";
480: sprintf(type, "%s(%s) ", type, mch);
481:
482: if (chp->f_nsyms > 0) {
483: strcat(type, "not stripped ");
484: }
485: return (type);
486: }
487:
488:
489: /*
490: * Identify a COFF executable.
491: */
492: char *
493: coffmtype(magic)
494: unsigned short magic;
495: {
496: switch ((unsigned) magic) {
497:
498: case IAPX16:
499: case IAPX16TV:
500: case IAPX20:
501: case IAPX20TV:
502: return("iAPX");
503:
504: case B16MAGIC:
505: case BTVMAGIC:
506: return("Intel Basic-16");
507:
508: case X86MAGIC:
509: case XTVMAGIC:
510: return("Intel x86");
511:
512: case I286SMAGIC:
513: return("Intel 286");
514:
515: case I386MAGIC:
516: return("Intel 386");
517:
518: case N3BMAGIC:
519: case NTVMAGIC:
520: return("New 3B");
521:
522: case WE32MAGIC:
523: case RBOMAGIC:
524: case MTVMAGIC:
525: return("MAC-32, 3515, 3B5");
526:
527: case VAXWRMAGIC:
528: case VAXROMAGIC:
529: return("VAX 11/780 or /750");
530:
531: case 0401:
532: case 0405:
533: case 0407:
534: case 0410:
535: case 0411:
536: case 0437:
537: return("pdp11");
538:
539: case MC68MAGIC:
540: case MC68TVMAGIC:
541: case M68MAGIC:
542: case M68TVMAGIC:
543: return("Motorola 680xx");
544:
545: /* case I286LMAGIC: */
546: case MC68KPGMAGIC:
547: return("UNIX PC or iAPX 286");
548:
549: case U370WRMAGIC:
550: case U370ROMAGIC:
551: return("IBM 370");
552:
553: case AMDWRMAGIC:
554: case AMDROMAGIC:
555: return("Amdahl 470/580");
556: default:
557: return(NULL);
558:
559: }
560: } /* coffmtype() */
561:
562: /*
563: * Decide if character array 'str' of length 'len' is an acceptable tar
564: * octal field. Returns TRUE if it is acceptable, FALSE otherwise.
565: */
566: int
567: tar_oct(str, len)
568: char *str;
569: int len;
570: {
571: for (; len > 0; --len, ++str) {
572: if (*str != '\0' && *str != ' ' &&
573: !('0' <= *str && *str <= '7')) {
574: break;
575: }
576: }
577:
578: return(0 == len);
579: } /* tar_oct() */
580:
581: /*
582: * Decide if character array 'str' of length 'len' is an acceptable tar
583: * decimal field. Returns TRUE if it is acceptable, FALSE otherwise.
584: */
585: int
586: tar_dec(str, len)
587: char *str;
588: int len;
589: {
590: for (; len > 0; --len, ++str) {
591: if (*str != '\0' && *str != ' ' &&
592: !isdigit(*str)) {
593: break;
594: }
595: }
596:
597: return(0 == len);
598: } /* tar_dec() */
599:
600: /*
601: * Decide if character array 'str' of length 'len' is an acceptable tar
602: * path type field. Returns TRUE if it is acceptable, FALSE otherwise.
603: */
604: int
605: tar_path(str, len)
606: char *str;
607: int len;
608: {
609: for (; len > 0; --len, ++str) {
610: if (*str != '\0' && *str != ' ' &&
611: !isprint(*str)) {
612: break;
613: }
614: }
615:
616: return(0 == len);
617: } /* tar_path() */
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.