home *** CD-ROM | disk | FTP | other *** search
/ Club Amiga de Montreal - CAM / CAM_CD_1.iso / files / 278.lha / File_v1.0 / file.c < prev    next >
Encoding:
C/C++ Source or Header  |  1989-08-08  |  8.3 KB  |  372 lines
  1. /*
  2.  * file v1.0 - a Unix-like utility to determine the type of a file
  3.  *
  4.  * Copyright 1989 Edwin Hoogerbeets
  5.  *
  6.  * This code is freely redistributable as long as no charge other than
  7.  * reasonable copying fees is levied for it.
  8.  *
  9.  *
  10.  * Usage: file file [file ...]
  11.  *
  12.  */
  13. #include <stdio.h>
  14. #include <ctype.h>
  15. #include <libraries/dosextens.h>
  16. #include <exec/memory.h>
  17.  
  18. #define toint(a) (int)((a) - '0')
  19. #define BLOCKSIZE 484L              /* almost size of one disk block */
  20.  
  21. typedef struct asdf {
  22.   int  length;
  23.   char *name;
  24.   char *pattern;
  25. } pattern;
  26.  
  27. /* for binary files that start with a magic number */
  28. pattern bmagic[] = {
  29.   4,"Amiga load file",                "\x00\x00\x03\xf3",
  30.   4,"Amiga object file",              "\x00\x00\x03\xe7",
  31.   2,"Amiga run-time library",         "\xec\x62",
  32.   2,"Manx 3.6 run-time library",      "\x61\x6a",
  33.   2,"Manx 3.6 object file",           "\x41\x4a",
  34.   2,"Manx 3.4 object file",           "\x6a\x67",
  35.   27,"TeX device independent output file",
  36.                                       "\xf7\x02\x01\x83\x92\xc0"
  37.                                       "\x1c\x3b\x00\x00\x00\x00"
  38.                                       "\x03\xe8\x1b\x20\x54\x65"
  39.                                       "\x58\x20\x6f\x75\x74\x70"
  40.                                       "\x75\x74\x20",
  41.   2,"Amiga icon .info file",          "\xe3\x10",
  42.   4,"Amiga .info file",               "\xf3\x4c\x00\x12",
  43.   2,"Amiga .font file",               "\x0f\x00",
  44.   2,"SEA ARC compressed archive",     "\x1a\x08",
  45.   NULL, NULL, NULL,
  46. };
  47.  
  48. /* for ascii files that start with a magic number */
  49. pattern amagic[] = {
  50.   2, "shell script file",             "#!",
  51.   2, "ARexx script file",             "/*",
  52.   4, "execute script file",           ".key",
  53.   4, "execute script file",           ".bra",
  54.   4, "execute script file",           ".ket",
  55.   NULL, NULL, NULL,
  56. };
  57.  
  58. /* patterns to search for in ascii files */
  59. pattern asearch[] = {
  60.   14,"LaTeX source code",            "\\documentstyle",
  61.   6, "TeX source code",              "\n\\",
  62.   4, "C source code",                "int ",
  63.   5, "C source code",                "\n#inc",
  64.   5, "C source code",                "\n#def",
  65.   2, "C source code",                "{\n",
  66.   21,"Modula II source code",        "IMPLEMENTATION MODULE",
  67.   17,"Modula II source code",        "DEFINITION MODULE",
  68.   5, "execute script file",          "\n.key",
  69.   5, "execute script file",          "\n.bra",
  70.   5, "execute script file",          "\n.ket",
  71.   1, "yacc input file",              "\n%TOKEN",
  72.   1, "yacc or lex input file",       "\n%%",
  73.   1, "shell commands",               "\nalias",
  74.   1, "shell commands",               "\nAlias",
  75.   1, "shell commands",               "\nset",
  76.   1, "commands text",                "\nrun",
  77.   1, "commands text",                "\nRun",
  78.   1, "uuencoded file",               "\nbegin ",
  79.   NULL, NULL, NULL,
  80. };
  81.  
  82. pattern IFFforms[] = {
  83.   4,"IFF interleave bit map file",        "ILBM",
  84.   4,"IFF Amiga compressed bit map files", "ACBM",
  85.   4,"IFF anim format file",               "ANIM",
  86.   4,"IFF instrument file",                "8SVX",
  87.   4,"IFF simple music file",              "SMUS",
  88.   NULL, NULL, NULL,
  89. };
  90.  
  91. pattern compress = {
  92.   2,"block compressed %d bit code data",  "\x1f\x9d",
  93. };
  94.  
  95. pattern zoo = {
  96.   4,"Zoo archive",                        "ZOO ",
  97. };
  98.  
  99. int type(ty,name)
  100. char *ty,*name;
  101. {
  102.   printf("%-16s %s\n",name,ty);
  103. }
  104.  
  105. int memncmp(a,b,length)
  106. char *a, *b;
  107. int length;
  108. {
  109.   register int index;
  110.  
  111.   for ( index = 0; index < length; index++ ) {
  112.     if ( a[index] != b[index] ) {
  113.       return(a[index] > b[index] ? -1 : 1);
  114.     }
  115.   }
  116.  
  117.   return(0);
  118. }
  119.  
  120. char *strrpbrk(str, charset)
  121. register char *str, *charset;
  122. {
  123.   register char *temp;
  124.   extern char *index();
  125.  
  126.   temp = str + strlen(str) - 1;
  127.  
  128.   while ( temp != (str - 1)  && !index(charset, *temp) )
  129.     --temp;
  130.  
  131.   return( (temp != (str - 1)) ? temp : NULL);
  132. }
  133.  
  134. char *basename(buf)
  135. register char *buf;
  136. {
  137.   register char *foo = strrpbrk(buf,":/");
  138.  
  139.   return( foo ? (foo + 1) : buf );
  140. }
  141.  
  142. usage(name)
  143. char *name;
  144. {
  145.   printf("usage: %s file [file ...]\n",name);
  146.   exit(-1);
  147. }
  148.  
  149. main(argc,argv)
  150. int argc;
  151. char **argv;
  152. {
  153.   register int index;
  154.   register char *myname;
  155.  
  156.   /* if there are no arguments, take from the stdin */
  157.   if ( argc <= 1 ) {
  158.     usage(argv[0]);
  159.   }
  160.  
  161.   myname = basename(argv[0]);
  162.  
  163.   for ( index = 1 ; index < argc ; index++ ) {
  164.     filetype(myname,argv[index]);
  165.   }
  166. }
  167.  
  168. #define FIBSIZE (long) sizeof(struct FileInfoBlock)
  169. extern char *AllocMem();
  170. extern struct FileLock *Lock();
  171.  
  172. /* find whether file is directory or real file */
  173. filetype(myname,filename)
  174. char *myname, *filename;
  175. {
  176.   struct FileLock *lock;
  177.   struct FileInfoBlock *fib;
  178.  
  179.   if ( lock = Lock(filename,ACCESS_READ) ) {
  180.     if ( fib = (struct FileInfoBlock *) AllocMem(FIBSIZE,MEMF_CLEAR) ) {
  181.       Examine(lock,fib);
  182.  
  183.       dofile(myname,filename,fib);
  184.  
  185.       UnLock(lock);
  186.       FreeMem(fib,FIBSIZE);
  187.  
  188.     } else {
  189.       UnLock(lock);
  190.       fprintf(stderr,"%s: not enough memory!\n",myname,filename);
  191.       exit(-1);
  192.     }
  193.   } else {
  194.     fprintf(stderr,"%s: could not access file %s\n",myname,filename);
  195.   }
  196. }
  197.  
  198. /* find what type of file filename is */
  199. int dofile(myname,filename,fib)
  200. char *myname, *filename;
  201. struct FileInfoBlock *fib;
  202. {
  203.   register char *f = &fib->fib_FileName[0];
  204.  
  205.   if ( fib->fib_DirEntryType > 0 ) {
  206.  
  207.     type("directory",f);
  208.  
  209.   } else if ( fib->fib_Size == 0 ) {
  210.  
  211.     type("empty",f);
  212.  
  213.   } else {
  214.     char *buf;
  215.     long filehandle;
  216.  
  217.     if ( !(filehandle = Open(filename,MODE_OLDFILE)) ) {
  218.       fprintf(stderr,"%s: could not open file %s\n",myname,filename);
  219.       return(0);
  220.     }
  221.  
  222.     if ( !(buf = AllocMem(BLOCKSIZE+1,MEMF_PUBLIC)) ) {
  223.       fprintf(stderr,"%s: not enough memory\n",myname);
  224.       Close(filehandle);
  225.       return(0);
  226.     }
  227.  
  228.     if ( !Read(filehandle,buf,BLOCKSIZE) ) {
  229.       fprintf(stderr,"%s: read error on file %s\n",myname,f);
  230.       FreeMem(buf,BLOCKSIZE+1);
  231.       Close(filehandle);
  232.       return(0);
  233.     }
  234.  
  235.     matchtype(myname,buf,f,fib);
  236.  
  237.     Close(filehandle);
  238.     FreeMem(buf,BLOCKSIZE+1);
  239.   }
  240.  
  241.   return(0);
  242. }
  243.  
  244. int isasciifile(buf,len)
  245. char *buf;
  246. int len;
  247. {
  248.   register int index, flag = 1;
  249.  
  250.   for ( index = 0; index < len ; index++ ) {
  251.     if ( !isprint(buf[index]) && !isspace(buf[index]) ) {
  252.       flag = 0;
  253.       break;
  254.     }
  255.   }
  256.  
  257.   return(flag);
  258. }
  259.  
  260. matchtype(myname,buf,file, fib)
  261. char *myname, *buf, *file;
  262. struct FileInfoBlock *fib;
  263. {
  264.   register int index;
  265.   int len = (fib->fib_Size < BLOCKSIZE) ? fib->fib_Size : BLOCKSIZE;
  266.  
  267.   if ( isasciifile(buf,len) ) {
  268.  
  269.     index = 0;
  270.  
  271.     /* check magic numbers */
  272.     while ( asearch[index].length ) {
  273.       if ( search(asearch[index].pattern,buf,len) ) {
  274.         type(asearch[index].name,file);
  275.         return(0);
  276.       }
  277.       ++index;
  278.     }
  279.  
  280.     index = 0;
  281.  
  282.     /* check magic numbers */
  283.     while ( amagic[index].length ) {
  284.       if ( !memncmp(amagic[index].pattern,buf,amagic[index].length) ) {
  285.         type(amagic[index].name,file);
  286.         return(0);
  287.       }
  288.       ++index;
  289.     }
  290.  
  291.     /* check script bit */
  292.     if ( fib->fib_Protection & (1<<6) ) {
  293.       type("script file",file);
  294.       return(0);
  295.     }
  296.  
  297.     type("text",file);
  298.  
  299.   } else {
  300.  
  301.     index = 0;
  302.  
  303.     /* check magic numbers */
  304.     while ( bmagic[index].length ) {
  305.       if ( !memncmp(bmagic[index].pattern,buf,bmagic[index].length) ) {
  306.         type(bmagic[index].name,file);
  307.         return(0);
  308.       }
  309.       ++index;
  310.     }
  311.  
  312.     /* check for IFF forms -- assume FORM is first header block */
  313.     if ( !memncmp("FORM",buf,4) ) {
  314.       char buffer[40];
  315.  
  316.       index = 0;
  317.       buffer[0] = '\0';
  318.  
  319.       while ( IFFforms[index].length ) {
  320.         if ( !memncmp(IFFforms[index].pattern,&buf[8],IFFforms[index].length) ) {
  321.           type(IFFforms[index].name,file);
  322.           return(0);
  323.         }
  324.         ++index;
  325.       }
  326.       sprintf(buffer,"IFF form %c%c%c%c",buf[8],buf[9],buf[10],buf[11]);
  327.       type(buffer,file);
  328.       return(0);
  329.     }
  330.  
  331.     if ( !memncmp(compress.pattern,buf,compress.length) ) {
  332.       char buffer[40];
  333.  
  334.       sprintf(buffer,compress.name,buf[2]&0x0f);
  335.       type(buffer,file);
  336.       return(0);
  337.     }
  338.  
  339.     if ( !memncmp(zoo.pattern,buf,zoo.length) ) {
  340.  
  341.       /* make a string out of ZOO x.xx Archive\0 to print out */
  342.       buf[16] = '\0';
  343.  
  344.       type(buf,file);
  345.       return(0);
  346.     }
  347.  
  348.     type("data",file);
  349.   }
  350. }
  351.  
  352. int search(pat, text, len)
  353. char *pat, *text;
  354. register int len;
  355. {
  356.   register int index = 0, patlen = strlen(pat);
  357.  
  358.   while ( memncmp(pat,&text[index],patlen) && index < len ) {
  359.     index++;
  360.   }
  361.  
  362.   return(index < len ? 1 : 0);
  363. }
  364.  
  365.  
  366.  
  367.  
  368.  
  369.  
  370.  
  371.  
  372.