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