![[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 [Research Unix] / researchv10no / cmd / lp|
Return to file.c CVS log | Up to [Research Unix] / researchv10no / cmd / lp |
1.1 root 1: #include <u.h>
2: #include <libc.h>
3: #include <ctype.h>
4: #ifdef plan9
5: Dir mbuf;
6: #else
7: #define print printf
8: struct stat mbuf;
9: #define OREAD 0
10: #endif
11: /*
12: * file - determine type of file
13: */
14:
15: uchar buf[6000];
16: short cfreq[140];
17: short wfreq[50];
18: int nbuf;
19: int flag;
20: int (*call[])(void);
21:
22: enum
23: {
24: Cword,
25: Fword,
26: Aword,
27: I1,
28: I2,
29: I3,
30: Clatin = 128,
31: Cbinary,
32: Cnull,
33: Ceascii,
34: };
35: struct
36: {
37: char* word;
38: int flag;
39: } dict[] =
40: {
41: "TEXT", Aword,
42: "block", Fword,
43: "char", Cword,
44: "common", Fword,
45: "data", Fword,
46: "dimension", Fword,
47: "double", Cword,
48: "extern", Cword,
49: "fio", I2,
50: "float", Cword,
51: "function", Fword,
52: "h", I3,
53: "include", I1,
54: "int", Cword,
55: "integer", Fword,
56: "libc", I2,
57: "long", Cword,
58: "real", Fword,
59: "register", Cword,
60: "short", Cword,
61: "static", Cword,
62: "stdio", I2,
63: "struct", Cword,
64: "subroutine", Fword,
65: "u", I2,
66: "void", Cword,
67: };
68:
69: enum
70: {
71: Short = 1<<0, /* size < 100 */
72: Long = 1<<1,
73:
74: Fascii = 1<<2, /* printable ascii */
75: Flatin = 1<<3,
76: Fbinary = 1<<4,
77: Feascii = 1<<5, /* including extended */
78: Fnull = 1<<6,
79: };
80:
81: void type(char*, int);
82: long lendian(uchar*);
83:
84: int
85: main(int argc, char *argv[])
86: {
87: int i, l;
88:
89: l = 0;
90: for(i=1; i<argc; i++)
91: if(strlen(argv[i]) > l)
92: l = strlen(argv[i]);
93: for(i=1; i<argc; i++)
94: type(argv[i], l);
95: exit(0);
96: }
97:
98: void
99: type(char *file, int nlen)
100: {
101: int i, f, l, m, c;
102: char *p, *ep, word[20];
103:
104: print("%s:%*s", file, nlen-strlen(file)+1, "");
105: #ifdef plan9
106: if(dirstat(file, &mbuf) < 0) {
107: print("cannot stat\n");
108: return;
109: }
110: if(mbuf.mode & CHDIR) {
111: print("directory\n");
112: return;
113: }
114: if(mbuf.type != 'M') {
115: print("special file #%c\n", mbuf.type);
116: return;
117: }
118: #else
119: if(stat(file, &mbuf) < 0) {
120: print("cannot stat\n");
121: return;
122: }
123: switch(mbuf.st_mode&S_IFMT) {
124: case S_IFDIR:
125: print("directory\n");
126: return;
127: case S_IFCHR:
128: print("character special file\n");
129: return;
130: case S_IFBLK:
131: print("block special file\n");
132: return;
133: }
134: #endif
135:
136: f = open(file, OREAD);
137: if(f < 0) {
138: print("cannot open\n");
139: return;
140: }
141: nbuf = read(f, buf, sizeof(buf));
142: close(f);
143:
144: if(nbuf < 0) {
145: print("cannot read\n");
146: return;
147: }
148: if(nbuf == 0) {
149: print("empty\n");
150: return;
151: }
152:
153: /*
154: * build histogram table
155: */
156: memset(cfreq, 0, sizeof(cfreq));
157: flag = 0;
158: if(nbuf > 100)
159: flag |= Long;
160: else
161: flag |= Short;
162:
163: for(i=0; i<nbuf; i++) {
164: f = buf[i] & 0xff;
165: if(f >= 128) {
166: if(f >= 128+32)
167: f = Clatin; /* latin */
168: else
169: f = Cbinary; /* not latin */
170: } else
171: if(!isprint(f) && !isspace(f))
172: if(f == 0)
173: f = Cnull;
174: else
175: f = Ceascii;
176: cfreq[f]++;
177: }
178:
179: /*
180: * gross classify
181: */
182: if(cfreq[Cbinary])
183: flag |= Fbinary;
184: else
185: if(cfreq[Clatin])
186: flag |= Flatin;
187: else
188: if(cfreq[Ceascii])
189: flag |= Feascii;
190: else
191: if(cfreq[Cnull])
192: flag |= Fnull;
193: else
194: flag |= Fascii;
195:
196: if(flag & Fnull) {
197: print("null\n");
198: return;
199: }
200:
201: /*
202: * lookup dictionary words
203: */
204: memset(wfreq, 0, sizeof(wfreq));
205: if(flag & Fascii) {
206: ep = word+sizeof(word)-2;
207: for(i=0; i<nbuf; i++) {
208: f = buf[i];
209: if(!isalpha(f))
210: continue;
211: p = word;
212: for(; i<nbuf; i++) {
213: f = buf[i];
214: if(!isalnum(f))
215: break;
216: *p++ = f;
217: if(p >= ep)
218: break;
219: }
220: *p = 0;
221: f = 0;
222: l = sizeof(dict)/sizeof(dict[0]);
223: for(;;) {
224: if(f >= l)
225: break;
226: m = (f+l)/2;
227: c = strcmp(dict[m].word, word);
228: if(c == 0) {
229: wfreq[dict[m].flag]++;
230: break;
231: }
232: if(c < 0)
233: f = m+1;
234: else
235: l = m;
236: }
237: }
238: }
239:
240: /*
241: * call individual classify routines
242: */
243: for(i=0; call[i]; i++)
244: if((*call[i])())
245: return;
246:
247: /*
248: * if all else fails,
249: * print out gross classification
250: */
251: if(flag & Short)
252: print("short ");
253: if(flag & Fascii)
254: print("ascii\n");
255: else
256: if(flag & Feascii)
257: print("extended ascii\n");
258: else
259: if(flag & Flatin)
260: print("latin ascii\n");
261: else
262: print("binary\n");
263: }
264:
265: long
266: lendian(uchar *p)
267: {
268:
269: return (p[0]) |
270: (p[1] << 8) |
271: (p[2] << 16) |
272: (p[3] << 24);
273: }
274:
275: int
276: long0(void)
277: {
278:
279: switch((unsigned)lendian(buf)) {
280: default:
281: return 0;
282:
283: case 0413:
284: print("demand paged ");
285:
286: case 0410:
287: print("pure ");
288: goto exec;
289:
290: case 0406:
291: print("mpx 68000 ");
292: goto exec;
293:
294: exec:
295: case 0407:
296: print("unix vax executable");
297: if(lendian(buf+4) != 0)
298: print(" not stripped");
299: print("\n");
300: break;
301:
302: case 0411:
303: print("jfr 411 executable\n");
304: break;
305:
306: case 0177555:
307: print("very old archive\n");
308: break;
309:
310: case 0177545:
311: print("old archive\n");
312: break;
313:
314: case 0135246: /* andrew/ehg */
315: print("view2d input file\n");
316: break;
317:
318: case 0135256: /* andrew */
319: print("apl file\n");
320: break;
321:
322: case 0164200: /* td */
323: print("Lucasfilm picture\n");
324: break;
325:
326: case 0600560:
327: print("mux downloadable file\n");
328: break;
329:
330: case 0x07010000:
331: print("68020 plan9 executable\n");
332: break;
333:
334: case 0x07040000:
335: print("mips plan9 executable\n");
336: break;
337:
338: case 0x97010000:
339: print("hobbit plan9 executable\n");
340: break;
341:
342: case 0xab020000:
343: print("sparc plan9 executable\n");
344: break;
345:
346: case 0xeb010000:
347: print("386 plan9 executable\n");
348: break;
349: case 0x0b1f1bdc:
350: print("daisy\n");
351: break;
352: case 0x64205300:
353: print("S data object\n");
354: break;
355: }
356: return 1;
357: }
358:
359: int
360: short0(void)
361: {
362:
363: switch(lendian(buf) & 0xffff) {
364: default:
365: return 0;
366:
367: case 070707:
368: print("cpio archive\n");
369: break;
370:
371: case 0x02f7:
372: print("tex dvi\n");
373: break;
374:
375: case 0405:
376: case 0407:
377: case 0410:
378: case 0411:
379: print("pdp-11 executable\n");
380: break;
381: case 0x0000:
382: print("bitmap\n");
383: break;
384: }
385: return 1;
386: }
387:
388: /*
389: * initial words to classify file
390: */
391: char* iwords[] =
392: {
393: "!<arch>\n__.SYMDEF",
394: "archive random library",
395: "!<arch>\n",
396: "archive",
397: "070707",
398: "cpio archive - ascii header",
399: "#FIG",
400: "fig ouput",
401: "#!/bin/echo",
402: "cyntax object file",
403: "#!/bin/rc",
404: "rc executable file",
405: "#!/bin/sh",
406: "sh executable file",
407: "%!",
408: "postscript",
409: "@document(",
410: "imagen",
411: "x T i300",
412: "troff output for i300",
413: "x T im300",
414: "troff output for im300",
415: "x T post",
416: "troff output for post",
417: "x T opost",
418: "troff output for opost",
419: "x T Latin1",
420: "troff output for Latin1",
421: "x T 202",
422: "troff output for 202",
423: "x T aps",
424: "troff output for aps",
425: 0,0
426: };
427:
428: int
429: istring(void)
430: {
431: int i, n;
432: char *p;
433:
434: for(i=0; p=iwords[i]; i+=2) {
435: n = strlen(p);
436: if(nbuf >= n && !strncmp((char*)buf, p, n)) {
437: print("%s\n", iwords[i+1]);
438: return 1;
439: }
440: }
441: if(strncmp((char*)buf, "TYPE=", 5) == 0) { /* td */
442: for(i=5; i<nbuf; i++)
443: if(buf[i] == '\n')
444: break;
445: print("%.*s picture\n", i-5, buf+5);
446: return 1;
447: }
448: return 0;
449: }
450:
451: /*
452: * low entropy means encrypted
453: */
454: int
455: ismung(void)
456: {
457: int i, bucket[8];
458: float cs;
459:
460: if(nbuf < 64)
461: return 0;
462: memset(bucket, 0, sizeof(bucket));
463: for(i=0; i<64; i++)
464: bucket[(buf[i]>>5)&07] += 1;
465:
466: cs = 0.;
467: for(i=0; i<8; i++)
468: cs += (bucket[i]-8)*(bucket[i]-8);
469: cs /= 8.;
470: if(cs <= 24.322) {
471: if(buf[0]==037 && buf[1]==0235)
472: print("compressed\n");
473: else
474: print("encrypted\n");
475: return 1;
476: }
477: return 0;
478: }
479:
480: /*
481: * english by punctuation and frequencies
482: */
483: int
484: isenglish(void)
485: {
486: int i, vow, comm, rare, badpun, punct;
487: char *p;
488:
489: if(!(flag & (Fascii|Feascii)))
490: return 0;
491: badpun = 0;
492: punct = 0;
493: for(i=0; i<nbuf-1; i++)
494: switch(buf[i]) {
495: case '.':
496: case ',':
497: case ')':
498: case '%':
499: case ';':
500: case ':':
501: case '?':
502: punct++;
503: if(buf[i+1] != ' ' && buf[i+1] != '\n')
504: badpun++;
505: }
506: if(badpun*5 > punct)
507: return 0;
508: if(cfreq['>']+cfreq['<']+cfreq['/'] > cfreq['e']) /* shell file test */
509: return 0;
510: if(2*cfreq[';'] > cfreq['e'])
511: return 0;
512:
513: vow = 0;
514: for(p="AEIOU"; *p; p++) {
515: vow += cfreq[*p];
516: vow += cfreq[tolower(*p)];
517: }
518: comm = 0;
519: for(p="ETAION"; *p; p++) {
520: comm += cfreq[*p];
521: comm += cfreq[tolower(*p)];
522: }
523: rare = 0;
524: for(p="VJKQXZ"; *p; p++) {
525: rare += cfreq[*p];
526: rare += cfreq[tolower(*p)];
527: }
528: if(vow*5 >= nbuf-cfreq[' '] && comm >= 10*rare) {
529: print("English text\n");
530: return 1;
531: }
532: return 0;
533: }
534:
535: int
536: isc(void)
537: {
538: int n;
539:
540: n = wfreq[I1];
541: /*
542: * includes
543: */
544: if(n >= 2 && wfreq[I2] >= n && wfreq[I3] >= n && cfreq['.'] >= n)
545: goto yes;
546: /*
547: * declarations
548: */
549: if(wfreq[Cword] >= 5 && cfreq[';'] >= 5)
550: goto yes;
551: /*
552: * assignments
553: */
554: if(cfreq[';'] >= 10 && cfreq['='] >= 10)
555: goto yes;
556: return 0;
557:
558: yes:
559: print("c program text\n");
560: return 1;
561: }
562:
563: int
564: isas(void)
565: {
566:
567: /*
568: * includes
569: */
570: if(wfreq[Aword] >= 2)
571: goto yes;
572: return 0;
573:
574: yes:
575: print("assembler program text\n");
576: return 1;
577: }
578:
579: int
580: iscint(void)
581: {
582:
583: if(buf[0] == 0x3a) /* as = ANAME */
584: if(buf[1] == 0x11) /* type = D_FILE */
585: if(buf[2] == 1) /* sym */
586: if(buf[3] == '<') { /* name of file */
587: print("mips .v intermediate\n");
588: return 1;
589: }
590:
591: if(buf[0] == 0x4d) /* aslo = ANAME */
592: if(buf[1] == 0x01) /* ashi = ANAME */
593: if(buf[2] == 0x32) /* type = D_FILE */
594: if(buf[3] == 1) /* sym */
595: if(buf[4] == '<') { /* name of file */
596: print("68020 .2 intermediate\n");
597: return 1;
598: }
599:
600: if(buf[0] == 0x43) /* as = ANAME */
601: if(buf[1] == 0x0d) /* type */
602: if(buf[2] == 1) /* sym */
603: if(buf[3] == '<') { /* name of file */
604: print("hobbit .z intermediate\n");
605: return 1;
606: }
607:
608: if(buf[0] == 0x74) /* as = ANAME */
609: if(buf[1] == 0x10) /* type */
610: if(buf[2] == 1) /* sym */
611: if(buf[3] == '<') { /* name of file */
612: print("sparc .k intermediate\n");
613: return 1;
614: }
615:
616: if(buf[0] == 0x7e) /* aslo = ANAME */
617: if(buf[1] == 0x00) /* ashi = ANAME */
618: if(buf[2] == 0x45) /* type = D_FILE */
619: if(buf[3] == 1) /* sym */
620: if(buf[4] == '<') { /* name of file */
621: print("386 .8 intermediate\n");
622: return 1;
623: }
624:
625: return 0;
626: }
627:
628: /*
629: * pick up a number with
630: * syntax _*[0-9]+_
631: */
632: #define P9BITLEN 12
633: int
634: p9bitnum(uchar *bp)
635: {
636: int n, c, len;
637:
638: len = P9BITLEN;
639: while(*bp == ' ') {
640: bp++;
641: len--;
642: if(len <= 0)
643: return -1;
644: }
645: n = 0;
646: while(len > 1) {
647: c = *bp++;
648: if(!isdigit(c))
649: return -1;
650: n = n*10 + c-'0';
651: len--;
652: }
653: if(*bp != ' ')
654: return -1;
655: return n;
656: }
657:
658: int
659: isp9bit(void)
660: {
661: int ldep, lox, loy, hix, hiy;
662: long len;
663:
664: ldep = p9bitnum(buf + 0*P9BITLEN);
665: lox = p9bitnum(buf + 1*P9BITLEN);
666: loy = p9bitnum(buf + 2*P9BITLEN);
667: hix = p9bitnum(buf + 3*P9BITLEN);
668: hiy = p9bitnum(buf + 4*P9BITLEN);
669:
670: if(ldep < 0 || lox < 0 || loy < 0 || hix < 0 || hiy < 0)
671: return 0;
672:
673: len = (hix-lox) * (1<<ldep); /* row length */
674: len = (len + 7) / 8; /* rounded to bytes */
675: len *= (hiy-loy); /* col length */
676: len += 60; /* size of initial ascii */
677:
678: /*
679: * for regular file length is non-zero and must match calculation above
680: * for /dev/window and /dev/screen the length is always zero
681: */
682: #ifdef plan9
683: if(mbuf.length != len && mbuf.length != 0)
684: #else
685: if(mbuf.st_size != len && mbuf.st_size != 0)
686: #endif
687: return 0;
688: print("plan 9 bitmap\n");
689: return 1;
690: }
691:
692: int (*call[])(void) =
693: {
694: long0, /* recognizable by first 4 bytes */
695: short0, /* recognizable by first 2 bytes */
696: istring, /* recognizable by first string */
697: iscint, /* c intermediate */
698: isc, /* c compiler key words */
699: isas, /* assembler key words */
700: ismung, /* entropy compressed/encrypted */
701: isenglish, /* char frequency English */
702: isp9bit, /* plan 9 bitmap (as from /dev/window) */
703: 0
704: };
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.