test.c

Bookmarks
Notes
Line SL5
sideBar
Line:

Add To:
  1. '   
  2. /* --------------------------------------------------------------------------
  3.    Nifty James' Famous File Find Utility

  5.    Version 1.00 of 20 November 1989
    Enter comment.
    Enter comment.
    Enter comment.
  6.    Version 1.10 of 16 December 1989
  7.    Version 1.11 of  5 January  1990
  8.    Version 1.12 of 13 February 1990
  9.    Version 1.50 of 25 March    1990
  10.    Version 2.00 of  3 April    1990
  11.    Version 2.10 of 25 August   1991
  12.    Version 2.15 of  9 December 1991
  13.    Version 2.16 of 19 October  1992
  14.    Version 2.17 of 22 March    1993 

  16.    (C) Copyright 1989, 1990, 1991, 1992 by Mike Blaszczak
  17.    All Rights Reserved.

  19.    Written for the Microsoft C Compiler Version 6.00AX.
  20.    LINK with an increased stack size!

  22.    Updated for Microsoft C/C++ Version 8.00 at Version 2.17
  23. */


  26. /* --------------------------------------------------------------------------
  27.    Needed #include Files
  28. */

  30. #pragma pack(1)                           /* don't space structure members */
  31. #include <ctype.h>
  32. #include <dos.h>
  33. #include <signal.h>
  34. #include <stdio.h>
  35. #include <stdlib.h>
  36. #include <string.h>
  37. #include <time.h>

  39. typedef  unsigned char byte;
  40. typedef  unsigned int word;
  41. typedef  unsigned long dword;    
  42. typedef  char boolean; 

  44. #define  TRUE     (1==1)
  45. #define  FALSE    (!TRUE)

  47. #define ELEMENTS(array) (sizeof(array)/sizeof(array[0]))

  49. /* --------------------------------------------------------------------------
  50.    Structures used here
  51. */

  53. struct   fullfilename               /* used internally to hold filenames   */
  54. {
  55.    char  filename[9];
  56.    char  fileextension[4];
  57. };


  60. /* This is the "local file header" for zip files.  The zip_lfh structure
  61.    preceeds each file in the ZIP file, and describes the individual files
  62.    stored there.  Note that we read one of these and then fseek() over it
  63.    by using the value in zip_lfh.csize to get the new area.
  64. */

  66. struct   zip_lfh
  67. {
  68.    dword signature;                 /* signature, must be 0x04034B50       */
  69.    word  exversion;                 /* version needed to extract           */
  70.    word  bitflags;                  /* general purpose bit flags           */
  71.    word  compression;               /* compression method                  */
  72.    word  modtime;
  73.    word  moddate;                   /* last modification time and date     */
  74.    dword crc32;                     /* crc32 filecheck for file            */
  75.    dword csize;                     /* compressed size                     */
  76.    dword usize;                     /* uncompressed size                   */
  77.    word  fnlength;                  /* filename length                     */
  78.    word  extralength;               /* extra field length                  */
  79. };

  81. /* This is the "local file header" for ARC files.  The arc_lfh structure
  82.    preceeds each file in the ARC file, and describes the individual files
  83.    stored there.  Note that we read one of these and then fseek() over
  84.    the compressed file by using the value arc_lfh.csize to get the new
  85.    area.

  87.    Note that ARC and PAK files use this same structure!
  88. */

  90. struct   arc_lfh
  91. {
  92.    byte  marker;                    /* always 01Ah                         */
  93.    byte  compression;               /* how was this file stored?           */
  94.    char  filename[13];              /* filename is always 13 long          */
  95.    dword csize;                     /* compressed size                     */
  96.    word  date;                      /* date of original file               */
  97.    word  time;                      /* time of original file               */
  98.    word  crc;                       /* sixteen-bit CRC for this file       */
  99.    dword usize;                     /* uncompressed size                   */
  100. };


  103. struct   lzh_lfh
  104. {
  105.    byte  unknown[7];                /* unknown area                        */
  106.    dword csize;                     /* compressed size                     */
  107.    dword usize;                     /* original size                       */
  108.    word  time;                      /* last modification of date and time  */
  109.    word  date;                      /*     of the stored file              */
  110.    byte  unknown3[2];
  111.    byte  fnlength;                  /* length of file name                 */
  112. };


  115. struct   zoo_lfh
  116. {
  117.    word  time;                      /* last modification of date and time  */
  118.    word  date;                      /*     of the stored file              */       
  119.    word  unknownword;
  120.    dword usize;                     /* original file size                  */
  121.    dword csize;                     /* compressed size                     */
  122.    byte  unknown[10];               /* unknown area ...                    */
  123.    char  filename[13];              /* ASCIIZ filename                     */
  124. };

  126. struct   dwc_lfh
  127. {
  128.    char  name[13];                  /* file name                           */
  129.    dword size;                      /* original size                       */
  130.    dword time;                      /* file timestamp                      */
  131.    dword new_size;                  /* compressed size                     */
  132.    dword pos;                       /* fseek() of this file in archive     */
  133.    byte  method;                    /* compression code                    */
  134.    byte  comment_size;              /* length of file comment              */
  135.    byte  directory_size;            /* length of directory name tag        */
  136.    word  crc;                       /* file CRC value                      */
  137. };


  140. /* DWC files are different because they have a big archive-wide information
  141.    area that NJFIND needs to use.  This is defined in dwc_block.
  142. */

  144. struct   dwc_block
  145. {
  146.    word  size;                      /* size of this structure              */
  147.    byte  ent_sz;                    /* size of dwc_lfh structure           */
  148.    char  header[13];                /* name of header file for listings    */
  149.    dword time;                      /* timestamp of last archive change    */
  150.    dword entries;                   /* entries in the archive              */
  151.    char  id[3];                     /* "DWC" to identify archive           */
  152. };


  155. /* ARJ files are even stranger; they have their own information block
  156.    which is defined here, starting in Version 2.10.
  157. */

  159. struct   arj_lfh
  160. {
  161.    unsigned int   wHeaderID;
  162.    unsigned int   wBasicHeaderSize;
  163.    unsigned char  bFirstHeaderSize;
  164.    unsigned char  bArchiverVersionNumber;
  165.    unsigned char  bMinimumToExtract;
  166.    unsigned char  bHostOS;
  167.    unsigned char  bARJFlags;
  168.    unsigned char  bMethod;
  169.    unsigned char  bFileType;
  170.    unsigned char  bReserved;
  171.    unsigned long  dwDateTimeStamp;
  172.    unsigned long  dwCompressedSize;
  173.    unsigned long  dwOriginalSize;
  174.    unsigned long  dwOriginalFileCRC;
  175.    unsigned int   wEntryNamePos;
  176.    unsigned int   wFileAccessMode;
  177.    unsigned int   wHostData;
  178. };



  182. /* --------------------------------------------------------------------------
  183.    Global Variables
  184. */

  186. unsigned       result;              /* stored result of _dos_find*() calls */
  187. char           *temp;               /* temporary pointer for strings       */
  188. char           *extension;          /* pointer to file extension           */
  189. char           template[_MAX_PATH]; /* template to match files searched    */
  190. char           *inputfile;          /* pointer to wildcard name            */

  192. struct fullfilename
  193.                tempfullname,        /* full name of file we're working on  */
  194.                matchname;           /* name to match                       */

  196. unsigned       found =0;            /* count of found files                */
  197. unsigned long  totallength = 0L;    /* total of file lengths               */

  199. unsigned       archivefound = 0;    /* count of found files in archves     */
  200. unsigned long  archivetotallength = 0L;
  201.                                     /* total file lengths of archive files.*/

  203. struct zip_lfh zipworker;           /* workspace for zip files             */
  204. struct arc_lfh arcworker;           /* workspace for arc files             */
  205. struct lzh_lfh lzhworker;           /* workspace for lzh files             */
  206. struct zoo_lfh zooworker;           /* workspace for zoo files             */

  208. boolean        searchzips = TRUE;   /* flags for options on searching      */
  209. boolean        searchlzhs = TRUE;   /*    the different archive types      */
  210. boolean        searchzoos = TRUE;
  211. boolean        searcharcs = TRUE;
  212. boolean        searchpaks = TRUE;
  213. boolean        searchdwcs = TRUE;
  214. boolean        searcharjs = TRUE;

  216. boolean        verbose = FALSE;     /* TRUE for verbose mode               */
  217. boolean        progress = FALSE;    /* TRUE to show progress               */
  218. boolean        totalsmode = FALSE;  /* TURE for display totals             */
  219. boolean        changedrive = FALSE; /* set TRUE if user changed disks      */

  221. boolean        broken = FALSE;      /* set true if user does CTRL+BREAK    */

  223. boolean        alldrives = FALSE;   /* search through all drives           */

  225. char           fiftyspaces[55];     /* a bunch of spaces for printmatch()  */

  227. unsigned       drivecount;          /* used to change disk drives          */
  228. unsigned       newdrive;
  229. unsigned       olddrive;
  230. unsigned       lastdrive;
  231. char           newdriveletter[3];

  233. char           drivelist[28];       /* list of drives to search            */
  234. char           *currentdrive;

  236. char           szFileNameBuffer[4096];


  239. /* --------------------------------------------------------------------------
  240.    Global Constants
  241. */

  243. const char     *fmessageread  = "Couldn't open file \"%s\" for read.\n";
  244. const char     *readbinary    = "rb";
  245. const char     *notsearching  = "Not searching %s files\n";
  246. const char     *eraseline     = "\t\t\t\t\t\t\t\t\t\r";
  247. const char     *wfi           = " was found in ";
  248. const char     *swfis         = "%s was found in %s%s";

  250. const char *month3names[12] =
  251. {
  252.    "Jan", "Feb", "Mar", "Apr", "May", "Jun",
  253.    "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"
  254. };


  257. /* --------------------------------------------------------------------------
  258.    ANSI-C Standard Function Prototypes
  259. */

  261. void  processzip(char *filename, struct find_t *info);
  262. void  processpak(char *filename, struct find_t *info);
  263. void  processarc(char *filename, struct find_t *info);
  264. void  processlzh(char *filename, struct find_t *info);
  265. void  processzoo(char *filename, struct find_t *info);
  266. void  processdwc(char *filename, struct find_t *info);
  267. void  processarj(char *filename, struct find_t *info);

  269. void  printinside(char *filename, char *archive, dword filesize, word date, word time);
  270. void  printinsidedwc(char *filename, char *archive, dword filesize, time_t date);
  271. void  printmatch(char *filename, dword filesize, word date, word time);
  272. void  printdate(word date);
  273. void  printtime(word time);
  274. int   comparenames(struct fullfilename *left, struct fullfilename *right);
  275. void  maketemplate(void);
  276. void  makefullname(struct fullfilename *ffn, char *path);
  277. void  searchdir(char *dirname);
  278. void  showusage(void);
  279. void  handleoption(char *option, boolean inenvironment);
  280. void  breakout(void);
  281. void  builddrivelist(void);
  282. void  handleenvironment(void);
  283. void  main(int argc, char *argv[]);


  286. /* --------------------------------------------------------------------------
  287. */

  289. void  processzip(char *filename, struct find_t *info)
  290. {
  291.    FILE                 *zipfile;
  292.    char                 *insidefilename = NULL;
  293.    struct fullfilename  zipfullname;
  294.    char                 *temporary;

  296. #if defined(DEBUG)
  297.    printf("processzip(\"%s\")\n", info->name);
  298. #endif

  300.    /* if the file name doesn't match the requested template name,
  301.       return now and don't even bother opening the zip file.
  302.    */

  304.    if (comparenames(&tempfullname, &matchname) == 0)
  305.       {
  306.       found++;
  307.       if (totalsmode == FALSE)
  308.          if (verbose == TRUE)
  309.             printmatch(filename, info->size, info->wr_date, info->wr_time);
  310.          else
  311.             printf("%s%s\n", newdriveletter, filename);

  313.       totallength += info->size;
  314.       }

  316.    if (searchzips == FALSE)
  317.       return;

  319.    /* open the zip file by name and see if it was successful.
  320.    */

  322.    zipfile = fopen(filename, readbinary);
  323.    if (zipfile == NULL)
  324.       {
  325.       fprintf(stderr, fmessageread, filename);
  326.       return;
  327.       }

  329.    /* loop through the whole file
  330.    */

  332.    while(!feof(zipfile))
  333.       {
  334.    /* read the local file header.
  335.       if we don't get it, break the loop.
  336.       At this same time, check it for a valid signature.
  337.    */

  339.       if (fread(&zipworker, sizeof(struct zip_lfh), (size_t) 1, zipfile) != 1)
  340.          break;

  342.       if (zipworker.signature != 0x04034B50)
  343.          break;

  345.    /* free the temporary file name area
  346.       and allocate a space for the new name.
  347.       read it from the zip file.
  348.    */
  349.       insidefilename = szFileNameBuffer;

  351.       if (fread((void *) insidefilename,  zipworker.fnlength, (size_t) 1, zipfile) != 1)
  352.          break;
  353.       insidefilename[zipworker.fnlength] = '\0';

  355.       temporary = strrchr(insidefilename, '/');
  356.       if (temporary != NULL)
  357.          temporary++;
  358.       else
  359.          temporary = insidefilename;

  361.       makefullname(&zipfullname, temporary);
  362.       if (comparenames(&zipfullname, &matchname) == 0)
  363.          {
  364.          archivefound++;
  365.          archivetotallength += zipworker.usize;
  366.          if (totalsmode == FALSE)
  367.             if (verbose == TRUE)
  368.                printinside(filename, temporary, zipworker.usize,
  369.                   zipworker.moddate, zipworker.modtime);
  370.             else
  371.                {
  372.                printf(swfis, temporary, newdriveletter, filename);
  373.                putchar('\n');
  374.                }
  375.          }
  376.       else
  377.          if (progress == TRUE)
  378.             printf("%s%s\t\t\r", newdriveletter, temporary);

  380. #if defined(DEBUG)
  381.       printf("temporary = \"%s\"\n", temporary);
  382. #endif

  384.    /* seek around the compressed file.
  385.    */
  386.       fseek(zipfile, zipworker.csize + zipworker.extralength, SEEK_CUR);

  388.    /* at this point, the file pointer is once again at the
  389.       next local file header ...
  390.    */
  391.       }


  394.    if (progress == TRUE)
  395.       printf(eraseline);
  396.    fclose(zipfile);
  397.    return;
  398. }


  401. /* --------------------------------------------------------------------------
  402. */

  404. void  processpak(char *filename, struct find_t *info)
  405. {
  406.    FILE                 *pakfile;
  407.    struct fullfilename  pakfullname;

  409. #if defined(DEBUG)
  410.    printf("processpak(\"%s\")\n", info->name);
  411. #endif

  413.    /* if the file name doesn't match the requested template name,
  414.       return now and don't even bother opening the zip file.
  415.    */

  417.    if (comparenames(&tempfullname, &matchname) == 0)
  418.       {
  419.       found++;
  420.       if (totalsmode == FALSE)
  421.          if (verbose == TRUE)
  422.             printmatch(filename, info->size, info->wr_date, info->wr_time);
  423.          else
  424.             printf("%s%s\n", newdriveletter, filename);
  425.       totallength += info->size;
  426.       }

  428.    if (searchpaks == FALSE)
  429.       return;

  431.    /* open the pak file by name and see if it was successful.
  432.    */

  434.    pakfile = fopen(filename, readbinary);
  435.    if (pakfile == NULL)
  436.       {
  437.       fprintf(stderr, fmessageread, filename);
  438.       return;
  439.       }

  441.    /* loop through the whole file
  442.    */

  444.    while(!feof(pakfile))
  445.       {
  446.    /* read the local file header.
  447.       if we don't get it, break the loop.
  448.    */

  450.       if (fread(&arcworker, sizeof(struct arc_lfh), (size_t) 1, pakfile) != 1)
  451.          break;

  453.    /* check the compression method.
  454.       if it is zero, the pak file is over.
  455.    */

  457.       if (arcworker.compression == 0)
  458.          break;

  460.       makefullname(&pakfullname, arcworker.filename);
  461.       if (comparenames(&pakfullname, &matchname) == 0)
  462.          {
  463.          archivefound++;
  464.          archivetotallength += arcworker.usize;
  465.          if (totalsmode == FALSE)
  466.             if (verbose == TRUE)
  467.                printinside(filename, arcworker.filename, arcworker.usize,
  468.                   arcworker.date, arcworker.time);
  469.             else
  470.                {
  471.                printf(swfis, arcworker.filename, newdriveletter, filename);
  472.                putchar('\n');
  473.                }
  474.          }
  475.       else
  476.          if (progress == TRUE)
  477.             printf("%s\t\t\r", arcworker.filename);

  479. #if defined(DEBUG)
  480.       printf("filename = \"%s\"\n", arcworker.filename);
  481. #endif

  483.    /* seek around the compressed file.
  484.    */
  485.       fseek(pakfile, arcworker.csize, SEEK_CUR);

  487.    /* at this point, the file pointer is once again at the
  488.       next local file header ...
  489.    */
  490.       }

  492.    if (progress == TRUE)
  493.       printf(eraseline);
  494.    fclose(pakfile);
  495.    return;
  496. }


  499. /* --------------------------------------------------------------------------
  500. */

  502. void  processarc(char *filename, struct find_t *info)
  503. {
  504.    FILE                 *arcfile;
  505.    struct fullfilename  arcfullname;

  507. #if defined(DEBUG)
  508.    printf("processarc(\"%s\")\n", info->name);
  509. #endif

  511.    /* if the file name doesn't match the requested template name,
  512.       return now and don't even bother opening the zip file.
  513.    */

  515.    if (comparenames(&tempfullname, &matchname) == 0)
  516.       {
  517.       found++;
  518.       if (totalsmode == FALSE)
  519.          if (verbose == TRUE)
  520.             printmatch(filename, info->size, info->wr_date, info->wr_time);
  521.          else
  522.             printf("%s%s\n", newdriveletter, filename);
  523.       totallength += info->size;
  524.       }

  526.    if (searcharcs == FALSE)
  527.       return;

  529.    /* open the arc file by name and see if it was successful.
  530.    */

  532.    arcfile = fopen(filename, readbinary);
  533.    if (arcfile == NULL)
  534.       {
  535.       fprintf(stderr, fmessageread, filename);
  536.       return;
  537.       }

  539.    /* loop through the whole file
  540.    */

  542.    while(!feof(arcfile))
  543.       {
  544.    /* read the local file header.
  545.       if we don't get it, break the loop.
  546.    */

  548.       if (fread(&arcworker, sizeof(struct arc_lfh), (size_t) 1, arcfile) != 1)
  549.          break;

  551.    /* check the compression method.
  552.       if it is zero, the pak file is over.
  553.    */

  555.       if (arcworker.compression == 0)
  556.          break;

  558.       makefullname(&arcfullname, arcworker.filename);
  559.       if (comparenames(&arcfullname, &matchname) == 0)
  560.          {
  561.          archivefound++;
  562.          archivetotallength += arcworker.usize;
  563.          if (totalsmode == FALSE)
  564.             if (verbose == TRUE)
  565.                printinside(filename, arcworker.filename, arcworker.usize,
  566.                   arcworker.date, arcworker.time);
  567.             else
  568.                {
  569.                printf(swfis, arcworker.filename, newdriveletter, filename);
  570.                putchar('\n');
  571.                }
  572.          }
  573.       else
  574.          if (progress == TRUE)
  575.             printf("%s\t\t\r", arcworker.filename);

  577. #if defined(DEBUG)
  578.       printf("filename = \"%s\"\n", arcworker.filename);
  579. #endif

  581.    /* seek around the compressed file.
  582.    */
  583.       fseek(arcfile, arcworker.csize, SEEK_CUR);

  585.    /* at this point, the file pointer is once again at the
  586.       next local file header ...
  587.    */
  588.       }

  590.    if (progress == TRUE)
  591.       printf(eraseline);
  592.    fclose(arcfile);
  593.    return;
  594. }


  597. /* --------------------------------------------------------------------------
  598. */

  600. void  processlzh(char *filename, struct find_t *info)
  601. {
  602.    FILE                 *lzhfile;
  603.    char                 *insidefilename = NULL;
  604.    struct fullfilename  lzhfullname;
  605.    char                 *temporary;

  607. #if defined(DEBUG)
  608.    printf("processlzh(\"%s\")\n", info->name);
  609. #endif

  611.    /* if the file name doesn't match the requested template name,
  612.       return now and don't even bother opening the lzh file.
  613.    */

  615.    if (comparenames(&tempfullname, &matchname) == 0)
  616.       {
  617.       found++;
  618.       if (totalsmode == FALSE)
  619.          if (verbose == TRUE)
  620.             printmatch(filename, info->size, info->wr_date, info->wr_time);
  621.          else
  622.             printf("%s%s\n", newdriveletter, filename);
  623.       totallength += info->size;
  624.       }

  626.    if (searchlzhs == FALSE)
  627.       return;

  629.    /* open the lzh file by name and see if it was successful.
  630.    */

  632.    lzhfile = fopen(filename, readbinary);
  633.    if (lzhfile == NULL)
  634.       {
  635.       fprintf(stderr, fmessageread, filename);
  636.       return;
  637.       }

  639.    /* loop through the whole file
  640.    */

  642.    while(!feof(lzhfile))
  643.       {
  644.    /* read the local file header.
  645.       if we don't get it, break the loop.
  646.    */

  648.       if (fread(&lzhworker, sizeof(struct lzh_lfh), (size_t) 1, lzhfile) != 1)
  649.          break;

  651.       insidefilename = szFileNameBuffer;

  653.       if (fread((void *) insidefilename,  lzhworker.fnlength, (size_t) 1, lzhfile) != 1)
  654.          break;
  655.       insidefilename[lzhworker.fnlength] = '\0';

  657.       temporary = strrchr(insidefilename, '\\');
  658.       if (temporary != NULL)
  659.          {
  660.          temporary++;
  661.          }
  662.       else
  663.          {
  664.          temporary = insidefilename;
  665.          }

  667.       makefullname(&lzhfullname, temporary);
  668.       if (comparenames(&lzhfullname, &matchname) == 0)
  669.          {
  670.          archivefound++;
  671.          archivetotallength += lzhworker.usize;
  672.          if (totalsmode == FALSE)
  673.             if (verbose == TRUE)
  674.                printinside(filename, temporary, lzhworker.usize,
  675.                   lzhworker.date, lzhworker.time);
  676.             else
  677.                {
  678.                printf(swfis, temporary, newdriveletter, filename);
  679.                putchar('\n');
  680.                }
  681.          }
  682.       else
  683.          if (progress == TRUE)
  684.             printf("%s\t\t\r", temporary);

  686. #if defined(DEBUG)
  687.       printf("temporary = \"%s\"\n", temporary);
  688. #endif

  690.    /* seek around the compressed file.
  691.    */
  692.       fseek(lzhfile, lzhworker.csize+2L, SEEK_CUR);

  694.    /* at this point, the file pointer is once again at the
  695.       next local file header ...
  696.    */
  697.       }

  699.    if (progress == TRUE)
  700.       printf(eraseline);
  701.    fclose(lzhfile);
  702.    return;
  703. }


  706. /* --------------------------------------------------------------------------
  707. */

  709. void  processzoo(char *filename, struct find_t *info)
  710. {
  711.    FILE                 *zoofile;
  712.    struct fullfilename  zoofullname;
  713.    int                  thischar;

  715. #if defined(DEBUG)
  716.    printf("processzoo(\"%s\")\n", info->name);
  717. #endif

  719.    /* if the file name doesn't match the requested template name,
  720.       return now and don't even bother opening the zip file.
  721.    */

  723.    if (comparenames(&tempfullname, &matchname) == 0)
  724.       {
  725.       if (totalsmode == FALSE)
  726.          if (verbose == TRUE)
  727.             printmatch(filename, info->size, info->wr_date, info->wr_time);
  728.          else
  729.             printf("%s%s\n", filename);
  730.       found++;
  731.       totallength += info->size;
  732.       }

  734.    if (searchzoos == FALSE)
  735.       return;

  737.    /* open the zoo file by name and see if it was successful.
  738.    */

  740.    zoofile = fopen(filename, readbinary);
  741.    if (zoofile == NULL)
  742.       {
  743.       fprintf(stderr, fmessageread, filename);
  744.       return;
  745.       }

  747.    /* first, skip over the ZOO FILE message
  748.    */

  750.    while (!feof(zoofile))
  751.       {
  752.       thischar = fgetc(zoofile);
  753.       if (thischar == 0x1A)
  754.          break;
  755.       }

  757.    if (feof(zoofile))
  758.       {
  759.       fclose(zoofile);
  760.       return;
  761.       }

  763.    /* skip over more header junk */

  765.    fseek(zoofile, 38L, SEEK_CUR);

  767.    /* loop through the whole file
  768.    */

  770.    while(!feof(zoofile))
  771.       {
  772.    /* read the local file header.
  773.       if we don't get it, break the loop.
  774.    */

  776.       if (fread(&zooworker, sizeof(struct zoo_lfh), (size_t) 1, zoofile) != 1)
  777.          break;

  779.    /* check the compression method.
  780.       if it is zero, the pak file is over.
  781.    */

  783.       if (zooworker.filename[0] == '\0')
  784.          break;

  786.       strupr(zooworker.filename);
  787.       makefullname(&zoofullname, zooworker.filename);
  788.       if (comparenames(&zoofullname, &matchname) == 0)
  789.          {
  790.          archivefound++;
  791.          totallength += zooworker.usize;
  792.          if (totalsmode == FALSE)
  793.             if (verbose == TRUE)
  794.                printinside(filename, zooworker.filename, zooworker.usize,
  795.                   zooworker.date, zooworker.time);
  796.             else
  797.                {
  798.                printf(swfis, zooworker.filename, newdriveletter, filename);
  799.                putchar('\n');
  800.                }
  801.          }
  802.       else
  803.          if (progress == TRUE)
  804.             printf("%s\t\t\r", zooworker.filename);

  806. #if defined(DEBUG)
  807.       printf("filename = \"%s\"\n", zooworker.filename);
  808. #endif

  810.    /* seek around the compressed file.
  811.    */
  812.       fseek(zoofile, zooworker.csize+34L, SEEK_CUR);

  814.    /* at this point, the file pointer is once again at the
  815.       next local file header ...
  816.    */
  817.       }

  819.    if (progress == TRUE)
  820.       printf(eraseline);
  821.    fclose(zoofile);
  822.    return;
  823. }


  826. /* --------------------------------------------------------------------------
  827. */

  829. void  processdwc(char *filename, struct find_t *info)
  830. {
  831.    char                 buff[256];
  832.    dword                entrycount;
  833.    long                 l;
  834.    int                  num;
  835.    int                  i=-1;
  836.    int                  j;
  837.    FILE                 *dwcfile;
  838.    struct dwc_block     archive_block;
  839.    struct dwc_lfh       dwc_entry;
  840.    struct fullfilename  dwcfullname;

  842. #if defined(DEBUG)
  843.    printf("processdwc(\"%s\")\n", info->name);
  844. #endif

  846.    /* if the file name doesn't match the requested template name,
  847.       return now and don't even bother opening the zip file.
  848.    */

  850.    if (comparenames(&tempfullname, &matchname) == 0)
  851.       {
  852.       if (totalsmode == FALSE)
  853.          if (verbose == TRUE)
  854.             printmatch(filename, info->size, info->wr_date, info->wr_time);
  855.          else
  856.             printf("%s%s\n", filename);
  857.       found++;
  858.       totallength += info->size;
  859.       }

  861.    if (searchzoos == FALSE)
  862.       return;

  864.    /* open the zoo file by name and see if it was successful.
  865.    */

  867.    dwcfile = fopen(filename, readbinary);
  868.    if (dwcfile == NULL)
  869.       {
  870.       fprintf(stderr, fmessageread, filename);
  871.       return;
  872.       }

  874.    /* find (and read) the archive descriptor structure
  875.    */

  877.    for (j=1; j <11 && i<0; j++)
  878.       {
  879.       if (fseek(dwcfile, - ((long) ELEMENTS(buff)*j - (j-1)*5), SEEK_END))
  880.          {
  881.          fseek(dwcfile, 0L, SEEK_SET);
  882.          }
  883.       else
  884.          {
  885.          l = ftell(dwcfile);
  886.          }

  888.       num = fread((void *) buff, sizeof(char), ELEMENTS(buff), dwcfile);

  890.       for (i = num-3; i>=0 && strncmp(buff+i, "DWC", 3); i--)
  891.          ;
  892.       }

  894.    if (i<0)
  895.       {
  896.       fprintf(stderr, "NJFIND: Invalid DWC file format in file %s\n", filename);
  897.       fclose(dwcfile);
  898.       return;
  899.       }

  901.    l += i+3;

  903.    fseek(dwcfile, l - sizeof(archive_block), SEEK_SET);
  904.    fread((void *) &archive_block, sizeof(archive_block), 1, dwcfile);

  906.    if (archive_block.entries > 5000 || archive_block.entries < 0)
  907.       {
  908.       fprintf(stderr, "NJFIND: Invalid DWC file format in file %s\n", filename);
  909.       fclose(dwcfile);
  910.       return;
  911.       }

  913.    l -= ((long) archive_block.entries * archive_block.ent_sz +
  914.       archive_block.size);

  916.    fseek(dwcfile, l, SEEK_SET);

  918.    /* get each one   */

  920.    for (entrycount = 0; entrycount < archive_block.entries; entrycount++)
  921.       {
  922.       fread((void *) &dwc_entry, sizeof(dwc_entry), 1, dwcfile);

  924.       if (sizeof(dwc_entry) < archive_block.ent_sz)
  925.          fseek(dwcfile, (long) (archive_block.ent_sz - sizeof(dwc_entry)), SEEK_CUR);

  927.       makefullname(&dwcfullname, dwc_entry.name);

  929.       if (comparenames(&dwcfullname, &matchname) == 0)
  930.          {
  931.          archivefound++;
  932.          archivetotallength += dwc_entry.new_size;
  933.          if (totalsmode == FALSE)
  934.             if (verbose == TRUE)
  935.                {
  936.                printinsidedwc(filename, dwc_entry.name, dwc_entry.new_size,
  937.                   dwc_entry.time);
  938.                }
  939.             else
  940.                {
  941.                printf(swfis, dwc_entry.name, newdriveletter, filename);
  942.                putchar('\n');
  943.                }
  944.          }
  945.       else
  946.          if (progress == TRUE)
  947.             printf("%s%s\t\t\r", newdriveletter, dwc_entry.name);
  948.       }


  951.    if (progress == TRUE)
  952.       printf(eraseline);

  954.    fclose(dwcfile);
  955.    return;
  956. }


  959. /* --------------------------------------------------------------------------
  960. */

  962. void  processarj(char *pstrFileName, struct find_t *info)
  963. {
  964.    FILE                 *fARJFile;
  965.    char                 *pstrTemporary;
  966.    struct fullfilename  zipfullname;
  967.    unsigned int         wExtHeaderSize;
  968.    boolean              bSkippedHeader;
  969.    struct arj_lfh       sBlock;
  970.    int                  nNameLength;

  972.    fARJFile = fopen(pstrFileName, "rb");
  973.    if (fARJFile == NULL)
  974.       {
  975.       fprintf(stderr, "NJFIND: Invalid ARJ file format in %s\n", pstrFileName);
  976.       fclose(fARJFile);
  977.       return;
  978.       }

  980.    bSkippedHeader = FALSE;

  982.    while (!feof(fARJFile))
  983.       {
  984.       fread(&sBlock, sizeof(struct arj_lfh), 1, fARJFile);

  986.       if (sBlock.wBasicHeaderSize == 0)
  987.          continue;

  989.       nNameLength = sBlock.wBasicHeaderSize-sizeof(struct arj_lfh)+4;

  991.       fread(szFileNameBuffer, 1, nNameLength, fARJFile);

  993.       fseek(fARJFile, 4L, SEEK_CUR);

  995.       while ((wExtHeaderSize = (unsigned int) getw(fARJFile)) != 0)
  996.          {
  997.          fseek(fARJFile, wExtHeaderSize+2, SEEK_CUR);
  998.          }

  1000.       fseek(fARJFile, sBlock.dwCompressedSize, SEEK_CUR);

  1002.       if (bSkippedHeader == FALSE)
  1003.          {
  1004.          bSkippedHeader = TRUE;
  1005.          }
  1006.       else
  1007.          {
  1008.          pstrTemporary = strchr(szFileNameBuffer, '/');

  1010.          if (pstrTemporary != NULL)
  1011.             {
  1012.             pstrTemporary++;
  1013.             }
  1014.          else
  1015.             {
  1016.             pstrTemporary = szFileNameBuffer;
  1017.             }

  1019.          makefullname(&zipfullname, pstrTemporary);
  1020.          if (comparenames(&zipfullname, &matchname) == 0)
  1021.             {
  1022.             archivefound++;
  1023.             archivetotallength += sBlock.dwOriginalSize;

  1025.             if (totalsmode == FALSE)
  1026.                {
  1027.                if (verbose == TRUE)
  1028.                   {
  1029.                   printinside(pstrFileName, pstrTemporary, sBlock.dwOriginalSize,
  1030.                      (word) (sBlock.dwDateTimeStamp >> 16),
  1031.                      (word) (sBlock.dwDateTimeStamp & 0x0000FFFFL));
  1032.                   }
  1033.                else
  1034.                   {
  1035.                   printf(swfis, szFileNameBuffer, newdriveletter, pstrFileName);
  1036.                   putchar('\n');
  1037.                   }
  1038.                }
  1039.             }
  1040.          else
  1041.             {
  1042.             if (progress == TRUE)
  1043.                {
  1044.                printf("%s%s\t\t\r", newdriveletter, szFileNameBuffer);
  1045.                }
  1046.             }
  1047.          }
  1048.       }

  1050.    fclose(fARJFile);
  1051.    return;
  1052. }



  1056. /* --------------------------------------------------------------------------
  1057. */

  1059. void  processnormal(char *filename, struct find_t *info)
  1060. {
  1061. #if defined(DEBUG)
  1062.    printf("processnormal(\"%s\")   ", info->name);
  1063.    printf("comparenames = %d\n", comparenames(&tempfullname, &matchname));
  1064. #endif

  1066.    if (comparenames(&tempfullname, &matchname) == 0)
  1067.       {
  1068.       found++;
  1069.       if (totalsmode == FALSE)
  1070.          if (verbose == TRUE)
  1071.             printmatch(filename, info->size, info->wr_date, info->wr_time);
  1072.          else
  1073.             printf("%s%s\n", newdriveletter, filename);
  1074.       totallength += info->size;
  1075.       }
  1076.    else
  1077.       if (progress == TRUE)
  1078.          printf("%s\t\t\r", info->name);

  1080.    return;
  1081. }


  1084. /* --------------------------------------------------------------------------
  1085.    printinside() prints out the file information from within an archive.
  1086.    This makes it different than printmatch only in that the file name
  1087.    *and* the name of the archive the file was in are printed.
  1088. */

  1090. void  printinside(char *filename, char *archive,
  1091.                dword filesize, word date, word time)
  1092. {
  1093.    int   count;

  1095.    count = strlen(filename) + 14 + strlen(archive) + strlen(newdriveletter);
  1096.    printf(swfis, archive, newdriveletter, filename);

  1098.    if (count > 48)
  1099.       {
  1100.       putchar('\n');
  1101.       printf("%s", fiftyspaces);
  1102.       }
  1103.    else
  1104.       while (count < 48)
  1105.          {
  1106.          putchar(' ');
  1107.          count++;
  1108.          }

  1110.    printf("%8lu ", filesize);
  1111.    printdate(date);
  1112.    printtime(time);
  1113.    putchar('\n');

  1115.    return;
  1116. }



  1120. /* --------------------------------------------------------------------------
  1121.    printinsidedwc() prints out the file information from within a DWC
  1122.    archive.  DWC archives are a little different because they store
  1123.    the date and time stamp for each file in the Unix-like "localtime()"
  1124.    format.

  1126.    For this function, then, we've repleaced the printdate() and
  1127.    printtime() calls with slightly different code.
  1128. */

  1130. void  printinsidedwc(char *filename, char *archive,
  1131.             dword filesize, time_t date)
  1132. {
  1133.    int   count;
  1134.    struct tm *filetime;

  1136.    filetime = localtime(&date);

  1138.    count = strlen(filename) + 14 + strlen(archive) + strlen(newdriveletter);
  1139.    printf(swfis, archive, newdriveletter, filename);

  1141.    if (count > 48)
  1142.       {
  1143.       putchar('\n');
  1144.       printf("%s", fiftyspaces);
  1145.       }
  1146.    else
  1147.       while (count < 48)
  1148.          {
  1149.          putchar(' ');
  1150.          count++;
  1151.          }

  1153.    printf("%8lu ", filesize);

  1155.    printf("%02d-%s-%d  ", filetime->tm_mday, month3names[filetime->tm_mon],
  1156.       filetime->tm_year);

  1158.    printf("%2.2d:%2.2d:%2.2d\n", filetime->tm_hour, filetime->tm_min,
  1159.       filetime->tm_sec);

  1161.    return;
  1162. }



  1166. /* --------------------------------------------------------------------------
  1167. */

  1169. void  printinsidearj(char *filename, char *archive, dword filesize, dword date, dword time)
  1170. {
  1171.    int   count;

  1173.    count = strlen(filename) + 14 + strlen(archive) + strlen(newdriveletter);
  1174.    printf(swfis, archive, newdriveletter, filename);

  1176.    if (count > 48)
  1177.       {
  1178.       putchar('\n');
  1179.       printf("%s", fiftyspaces);
  1180.       }
  1181.    else
  1182.       {
  1183.       while (count < 48)
  1184.          {
  1185.          putchar(' ');
  1186.          count++;
  1187.          }
  1188.       }

  1190.    printf("%8lu ", filesize);
  1191.    printdate((word) (date >> 16));
  1192.    printtime((word) (time & 0x0000FFFFL));
  1193.    putchar('\n');
  1194.    return;
  1195. }


  1198. /* --------------------------------------------------------------------------
  1199.    printmatch() prints out the file's information.  It does this all in a
  1200.    neat, tidy way.  The width of 50 characters for the file name is imposed
  1201.    because for eleven characters of a date, eight characters for a time,
  1202.    one character for a space, and nine characters for a file size.
  1203. */

  1205. void  printmatch(char *filename, dword filesize, word date, word time)
  1206. {
  1207.    int count;

  1209.    count = strlen(filename)+strlen(newdriveletter);
  1210.    printf("%s%s", newdriveletter, filename);

  1212.    if (count > 48)
  1213.       {
  1214.       putchar('\n');
  1215.       printf("%s", fiftyspaces);
  1216.       }
  1217.    else
  1218.       while (count < 48)
  1219.          {
  1220.          putchar(' ');
  1221.          count++;
  1222.          }

  1224.    printf("%8lu ", filesize);
  1225.    printdate(date);
  1226.    printtime(time);
  1227.    putchar('\n');

  1229.    return;
  1230. }

  1232. /* --------------------------------------------------------------------------
  1233.    printdate() accepts a word of the DOS date and prints it out in
  1234.    the format "DD-MMM-CC".  MMM is a three-letter name for the month.
  1235. */

  1237. void  printdate(word date)
  1238. {
  1239.    printf("%02d-%s-%d  ", date & 0x001F,
  1240.       month3names[((date >> 5) & 0x000F) -1], 1980+(date >> 9));

  1242.    return;
  1243. }


  1246. /* --------------------------------------------------------------------------
  1247.    printtime() accepts the DOS-format for the time as a word and
  1248.    prints out the time in the format "HH:MM:SS".  Note that the
  1249.    time is in twenty-four hour format.
  1250. */

  1252. void  printtime(word time)
  1253. {
  1254.    printf("%2.2d:%2.2d:%2.2d", 
  1255.       time >> 11, (time >> 5) & 0x003F, (time & 0x001F) << 1);

  1257.    return;
  1258. }


  1261. /* --------------------------------------------------------------------------
  1262.    This function compares two fill file name structures.  It ignores
  1263.    question marks during the comparison, so it will match filenames that
  1264.    have expanded wildcards.  This routine will return a zero if the files
  1265.    are equivalent (or match by wildcard), and will return a one if the
  1266.    files names are not comparable.
  1267. */

  1269. int   comparenames(struct fullfilename *left, struct fullfilename *right)
  1270. {
  1271.    register char  *source;                /* working pointers for compare  */
  1272.    register char  *dest;

  1274.    source = left->filename;
  1275.    dest   = right->filename;

  1277.    while(*source && *dest)
  1278.       {
  1279.       if (*source != '?' && *dest != '?')
  1280.          if (*source != *dest)
  1281.             return 1;               /* not equal!  */
  1282.       source++;
  1283.       dest++;
  1284.       }

  1286.    /* code added version 1.11 */

  1288.    if (*source == '\0' && *dest != '\0')
  1289.       return 1;

  1291.    /* end code added version 1.11   */

  1293.    source = left->fileextension;
  1294.    dest   = right->fileextension;

  1296.    while(*source && *dest)
  1297.       {
  1298.       if (*source != '?' && *dest != '?')       /* skip questionmarks   */
  1299.          if (*source != *dest)
  1300.             return 1;               /* not equal!  */
  1301.       source++;
  1302.       dest++;
  1303.       }

  1305.    /* code added version 1.11 */

  1307.    if (*source == '\0' && *dest != '\0')
  1308.       return 1;

  1310.    /* end code added version 1.11   */

  1312.    return 0;                        /* zero indicates success  */
  1313. }


  1316. /* --------------------------------------------------------------------------
  1317.    maketemplate() takes inputfile[] and expands all the asterisks to
  1318.    question marks.  This is done once, first, so that the checkmatch()
  1319.    routine can more quickly and efficiently check for matches in file
  1320.    names.
  1321. */

  1323. void  maketemplate()
  1324. {
  1325.    register char  *source = inputfile; /* pointers for copying data  */
  1326.    register char  *dest = template;
  1327.    int   count = 0;                    /* count of template length   */
  1328.    int   inextension = 0;              /* set after we get a .       */

  1330.    *dest++ = '\\';

  1332.    while(*source != '\0' && count < 13 && inextension < 4)
  1333.       {
  1334.       if (*source != '*')
  1335.          {
  1336.          *dest++ = *source;
  1337.          count++;
  1338.          if (count == 9 || *source == '.')
  1339.             inextension++;
  1340.          source++;
  1341.          }
  1342.       else
  1343.          {
  1344.          if (inextension != 0)
  1345.             {
  1346.             for ( ; inextension<4; inextension++)
  1347.                *dest++ = '?';
  1348.             *dest = '\0';
  1349.             break;
  1350.             }
  1351.          else
  1352.             {
  1353.             for ( ; count<8; count++)
  1354.                *dest++ = '?';
  1355.             *dest++ = '.';
  1356.             inextension = 1;
  1357.             source++;
  1358.             if (*source == '.')
  1359.                source++;
  1360.             }
  1361.          }
  1362.       }

  1364.    *dest = '\0';
  1365.    return;
  1366. }


  1369. /* --------------------------------------------------------------------------
  1370.    makefullname() accepts a pointer to a DOS path name and a pointer to
  1371.    a fullfilename structure.  makefullname() puts the file name from
  1372.    the path into the fullfilename structure and returns.
  1373. */

  1375. void  makefullname(struct fullfilename *ffn, char *path)
  1376. {
  1377.    register char  *source;
  1378.    register char  *dest;
  1379.    int            counter;

  1381.    source = strrchr(path, '\\');
  1382.    if (source == NULL)
  1383.       source = path;
  1384.    else
  1385.       source++;

  1387.    for (dest = ffn->filename, counter = 0; *source && counter<8; counter++)
  1388.       if (*source == '.')
  1389.          *dest++ = ' ';
  1390.       else
  1391.          *dest++ = *source++;

  1393.    *dest = '\0';
  1394.    if (*source != '\0')
  1395.       source++;

  1397.    for (dest = ffn->fileextension, counter = 0; counter<3; counter++)
  1398.       if (*source == '\0')
  1399.          *dest++ = ' ';
  1400.       else
  1401.          *dest++ = *source++;

  1403.    *dest = '\0';

  1405.    return;
  1406. }


  1409. /* --------------------------------------------------------------------------
  1410.    searchdir() accepts the name of a directory.  That name *MUST* include
  1411.    wildcards, and may include a partial filename, a full pathname, or a
  1412.    drive specification.

  1414.    The function will search all directories and go lower, and will call
  1415.    itself recursively if it finds any more subdirectories.  In this way,
  1416.    it traverses the subdirectory tree in an "inorder" fasion.
  1417. */

  1419. void searchdir(char *dirname)
  1420. {
  1421.    char           temppath[_MAX_PATH];
  1422.    char           thisfilename[_MAX_DIR+_MAX_FNAME+_MAX_EXT];
  1423.    struct find_t  dirinfo;

  1425.    strcpy(temppath, dirname);
  1426.    result = _dos_findfirst(temppath, _A_NORMAL | _A_SUBDIR, &dirinfo);

  1428.    do {
  1429.       strcpy(thisfilename, dirname);
  1430.       *(strrchr(thisfilename, '\\')+1) = '\0';
  1431.       strcat(thisfilename, dirinfo.name);
  1432. #if defined(DEBUG)
  1433.       printf("%s ", thisfilename);
  1434. #endif

  1436.       if ((dirinfo.attrib & _A_SUBDIR) &&
  1437.            dirinfo.name[0] != '.')
  1438.          {
  1439. #if defined(DEBUG)
  1440.          printf("(DIRECTORY) %s\n", thisfilename);
  1441. #endif
  1442.          strcat(thisfilename, "\\*.*");
  1443.          searchdir(thisfilename);
  1444.          }
  1445.       else
  1446.          {
  1447. #if defined(DEBUG)
  1448.          putchar('\n');
  1449. #endif

  1451.          while(broken == FALSE)
  1452.             {
  1453.             extension = strchr(thisfilename, '.');
  1454.             if (*(extension-1) == '\\')
  1455.                break;

  1457.             makefullname(&tempfullname, thisfilename);

  1459.             if (extension != NULL)
  1460.                {
  1461.                if (strcmp(extension, ".LZH") == 0)
  1462.                   {
  1463.                   processlzh(thisfilename, &dirinfo);
  1464.                   break;
  1465.                   }

  1467.          /* Note that we call the same routine for .PAK and .ARC.
  1468.             They have the same (basic) format!
  1469.          */

  1471.                if (strcmp(extension, ".PAK") == 0)
  1472.                   {
  1473.                   processpak(thisfilename, &dirinfo);
  1474.                   break;
  1475.                   }

  1477.                if (strcmp(extension, ".ARC") == 0)
  1478.                   {
  1479.                   processarc(thisfilename, &dirinfo);
  1480.                   break;
  1481.                   }

  1483.                if (strcmp(extension, ".ZOO") == 0)
  1484.                   {
  1485.                   processzoo(thisfilename, &dirinfo);
  1486.                   break;
  1487.                   }

  1489.                if (strcmp(extension, ".ZIP") == 0)
  1490.                   {
  1491.                   processzip(thisfilename, &dirinfo);
  1492.                   break;
  1493.                   }

  1495.          /* DWC was added in version 2.00 */

  1497.                if (strcmp(extension, ".DWC") == 0)
  1498.                   {
  1499.                   processdwc(thisfilename, &dirinfo);
  1500.                   break;
  1501.                   }

  1503.          /* ARJ was added in version 2.10 */

  1505.                if (strcmp(extension, ".ARJ") == 0)
  1506.                   {
  1507.                   processarj(thisfilename, &dirinfo);
  1508.                   break;
  1509.                   }
  1510.                
  1511.                }

  1513.             processnormal(thisfilename, &dirinfo);
  1514.             break;
  1515.             }
  1516.          }

  1518.       result = _dos_findnext(&dirinfo);
  1519.       } while (result == 0 && broken == FALSE);

  1521.    if (progress == TRUE)
  1522.       printf(eraseline);
  1523.    return;
  1524. }


  1527. /* --------------------------------------------------------------------------
  1528.    showusage() is a kind of error routine.  It is called when we get confused
  1529.    parsing the command line and bail out gracefully.  This prints the
  1530.    program usage and quits.
  1531. */

  1533. void  showusage()
  1534. {
  1535.    fputs("Usage: NJFIND [options] <filespec>\n", stderr);
  1536.    fputs("[options] include:\n", stderr);
  1537.    fputs("\t/A - do not search *.ARC files\n", stderr);
  1538.    fputs("\t/J - do not search *.ARJ files\n", stderr);
  1539.    fputs("\t/W - do not search *.DWC files\n", stderr);
  1540.    fputs("\t/L - do not search *.LZH files\n", stderr);
  1541.    fputs("\t/P - do not search *.PAK files\n", stderr);
  1542.    fputs("\t/O - do not search *.ZOO files\n", stderr);
  1543.    fputs("\t/Z - do not search *.ZIP files\n", stderr);
  1544.    fputs("\t/N - only search normal files (combo of /W /J /O /Z /P /A /L)\n\n", stderr);
  1545.    fputs("\t/V - verbose mode; prints statistics\n", stderr);
  1546.    fputs("\t/T - totals mode; prints no found filenames\n", stderr);
  1547.    fputs("\t/D - progress display prints filenames as searched\n", stderr);
  1548.    fputs("\t/R - run search across all DOS drives\n\n", stderr);

  1550.    exit(1);
  1551. }


  1554. /* --------------------------------------------------------------------------
  1555.    handleoption() takes care of the options the program accepts.  since
  1556.    these are all just switches, we just tweak the boolean variables that
  1557.    represent each option.
  1558. */

  1560. void  handleoption(char *option, boolean inenvironment)
  1561. {
  1562.    switch(toupper(*option))
  1563.       {
  1564.       case 'N':   searchzoos =
  1565.                   searchpaks =
  1566.                   searcharcs =
  1567.                   searchlzhs =            /* normal files ...     */
  1568.                   searchzips = FALSE;
  1569.                   fprintf(stderr, notsearching, "ARC, ARJ, DWC, LZH, PAK, ZIP, or ZOO");
  1570.                   break;

  1572.       case 'O':   searchzoos = FALSE;     /* turn off ZOO files   */
  1573.                   fprintf(stderr, notsearching, "ZOO");
  1574.                   break;

  1576.    /* added code, version 2.00   */

  1578.       case 'W':   searchdwcs = FALSE;     /* turn off DWC files   */
  1579.                   fprintf(stderr, notsearching, "DWC");
  1580.                   break;

  1582.    /* end added code */

  1584.    /* added code, version 2.10   */

  1586.       case 'J':   searcharjs = FALSE;
  1587.                   fprintf(stderr, notsearching, "ARJ");
  1588.                   break;

  1590.    /* end added code */

  1592.       case 'Z':   searchzips = FALSE;     /* turn off ZIP files   */
  1593.                   fprintf(stderr, notsearching, "ZIP");
  1594.                   break;

  1596.       case 'A':   searcharcs = FALSE;     /* turn off ARC files   */
  1597.                   fprintf(stderr, notsearching, "ARC");
  1598.                   break;

  1600.       case 'L':   searchlzhs = FALSE;
  1601.                   fprintf(stderr, notsearching, "LZH");
  1602.                   break;

  1604.       case 'P':   searchpaks = FALSE;
  1605.                   fprintf(stderr, notsearching, "PAK");
  1606.                   break;

  1608.       case 'V':   verbose = TRUE;
  1609.                   fputs("Verbose mode\n", stderr);
  1610.                   break;

  1612.       case 'D':   progress = TRUE;
  1613.                   fputs("Progress displays enabled\n", stderr);
  1614.                   break;

  1616.       case 'T':   totalsmode = TRUE;
  1617.                   fputs("Totals mode only\n", stderr);
  1618.                   break;

  1620.    /* added code, version 1.10   */

  1622.       case 'R':   alldrives = TRUE;
  1623.                   fputs("Search all drives\n", stderr);
  1624.                   break;

  1626.    /* end of added code          */

  1628.       default:    fprintf(stderr, "NJFIND: Unrecognized Option '%c'", *option);
  1629.       
  1630.    /* added code, version 2.00   */

  1632.                   if (inenvironment == TRUE)
  1633.                      fprintf(stderr, " in NJFIND environment variable");
  1634.                   fputc('\n', stderr);
  1635.                   fputc('\n', stderr);

  1637.    /* end added code */
  1638.                   showusage();
  1639.       }

  1641.    return;
  1642. }



  1646. /* --------------------------------------------------------------------------
  1647. */

  1649. void vBuildDOS6List(void)
  1650. {
  1651.    unsigned int   nMax;
  1652.    unsigned int   nTry;
  1653.    unsigned int   nOld;
  1654.    unsigned int   nCurrent;
  1655.    char           *pstrDest;
  1656.    unsigned int   far *uipNewWalker;

  1658.    union REGS     inregs;
  1659.    struct SREGS   segregs;

  1661.    pstrDest = drivelist;

  1663.    _dos_getdrive(&nOld);
  1664.    _dos_setdrive(nOld, &nMax);

  1666.    for (nTry = 1; nTry < nMax; nTry++)
  1667.       {
  1668.       _dos_setdrive(nTry, &nMax);
  1669.       _dos_getdrive(&nCurrent);

  1671.       if (nCurrent == nTry)
  1672.          {
  1673.          inregs.h.bl = (unsigned char) nTry;
  1674.          inregs.x.ax = 0x4408;
  1675.          int86x(0x21, &inregs, &inregs, &segregs);

  1677.          if (inregs.x.ax == 0x0001)
  1678.             {
  1679.             inregs.h.ah = 0x1C;
  1680.             inregs.h.dl = (unsigned char) nTry;
  1681.             int86x(0x21, &inregs, &inregs, &segregs);

  1683.             FP_OFF(uipNewWalker) = inregs.x.bx;
  1684.             FP_SEG(uipNewWalker) = segregs.ds;

  1686.             if ((*uipNewWalker & 0x00FF) == 0xF8)
  1687.                {
  1688.                *pstrDest++ = 'A' + nTry - 1;
  1689.                *pstrDest = '\0';
  1690.                }
  1691.             }
  1692.          }
  1693.       }

  1695.    _dos_setdrive(nOld, &nMax);

  1697.    return;
  1698. }


  1701. /* --------------------------------------------------------------------------
  1702.    builddrivelist() sets drivelist to an ASCII string of the drive
  1703.    letters that are valid on this system.  drivelist will only contain
  1704.    the identifiers of hard disk drives (with the media type 0xF8.)
  1705.    This function was added for Version 1.10.  This function was changed
  1706.    with Version 2.10 to accomodate DOS 5.0.
  1707. */

  1709. void builddrivelist()
  1710. {
  1711.    union REGS     inregs;
  1712.    struct SREGS   segregs;

  1714.    unsigned int   far *walker;
  1715.    unsigned int   far *newwalker;
  1716.    unsigned int   far *nextone_off;
  1717.    unsigned int   far *nextone_seg;
  1718.    char  far *media_type;
  1719.    char  *dest;

  1721.    if (_osmajor == 6)
  1722.       {
  1723.       vBuildDOS6List();
  1724.       return;
  1725.       }

  1727.    dest = drivelist;
  1728.    *dest = '\0';

  1730.    inregs.h.ah = 0x52;
  1731.    int86x(0x21, &inregs, &inregs, &segregs);

  1733.    FP_OFF(newwalker) = inregs.x.bx;
  1734.    FP_SEG(newwalker) = segregs.es;

  1736.    FP_OFF(walker) = newwalker[0];
  1737.    FP_SEG(walker) = newwalker[1];

  1739.    while(1)
  1740.       {
  1741.       switch (_osmajor)
  1742.          {
  1743.          case 2:
  1744.             media_type = (char far *) walker + 0x16;
  1745.             nextone_off = walker + 0x0C;
  1746.             nextone_seg = walker + 0x0D;
  1747.             break;

  1749.          case 3:
  1750.             media_type = (char far *) walker + 0x16;
  1751.             nextone_off = walker + 0x0C;
  1752.             nextone_seg = walker + 0x0D;
  1753.             break;

  1755.          case 4:
  1756.          case 5:
  1757.             media_type = (char far *) walker + 0x17;
  1758.             nextone_off = (unsigned int far *) ((char far *) walker + 0x19);
  1759.             nextone_seg = (unsigned int far *) ((char far *) walker + 0x1B);
  1760.             break;

  1762.          default:
  1763.             fprintf(stderr, "NJFIND: Incompatible DOS Version: %d.%d\n",
  1764.                _osmajor, _osminor);
  1765.             exit(1);
  1766.             break;
  1767.          }

  1769.       if ((*media_type & 0x00FF) == 0xF8)
  1770.          {
  1771.          *dest++ = (char) *walker + 'A';
  1772.          *dest = '\0';
  1773.          }

  1775.       FP_OFF(walker) = *nextone_off;
  1776.       FP_SEG(walker) = *nextone_seg;

  1778.       if (FP_OFF(walker) == 0xFFFF)
  1779.          break;

  1781.       if ((*walker & 0x00FF) > 26)
  1782.          break;
  1783.       }

  1785.    return;
  1786. }


  1789. /* --------------------------------------------------------------------------
  1790.    The breakout() function handles the SIGINT signal for the program.
  1791.    Here, we simply set a flag so that the working loop will terminate
  1792.    and return.  This allows us to leave neatly, by resetting the
  1793.    current drive and printing out our totals.  (That doesn't take very
  1794.    long and should not be much of an annoyance to the user.)
  1795. */

  1797. void  breakout(void)
  1798. {
  1799.    signal(SIGINT, SIG_IGN);
  1800.    signal(SIGINT, breakout);

  1802.    putchar('\n');
  1803.    broken = TRUE;

  1805.    return;
  1806. }


  1809. /* --------------------------------------------------------------------------
  1810.    handleenvironment() takes care of looking at the environment to
  1811.    find NJFIND settings.  If such an entry is found, it is parsed by
  1812.    running pointers through it and calling handleoption().

  1814.    This function is new for Version 2.00.
  1815. */

  1817. void handleenvironment()
  1818. {
  1819.    char *environment;
  1820.    char *walker;
  1821.    char *destination;
  1822.    char copy[10];
  1823.    int  len;

  1825.    environment = getenv("NJFIND");
  1826.    if (environment == NULL)
  1827.       return;

  1829. #if defined(DEBUG)
  1830.    printf("NJFIND found!\n");
  1831. #endif

  1833.    walker = environment;

  1835.    while (*walker != '\0')
  1836.       {
  1837.       while (isspace(*walker))
  1838.          {
  1839.          walker++;
  1840.          }

  1842.       if (*walker == '\0')
  1843.          break;

  1845.       destination = copy;
  1846.       len = 0;

  1848.       while (!isspace(*walker) && *walker != '\0')
  1849.          {
  1850.          *destination++ = *walker++;
  1851.          *destination = '\0';

  1853.          if (++len == ELEMENTS(copy))
  1854.             {
  1855.             fputs("NJFIND: option too long in environment\n", stderr);
  1856.             exit(1);
  1857.             }
  1858.          }

  1860.       if (copy[0] == '/' || copy[0] == '-')
  1861.          handleoption(copy+1, TRUE);
  1862.       else
  1863.          {
  1864.          fputs("NJFIND: only options supported in environment\n", stderr);
  1865.          exit(1);
  1866.          }

  1868.       }

  1870.    return;
  1871. }


  1874. /* --------------------------------------------------------------------------
  1875.    The Main Thang.
  1876. */

  1878. void main(int argc, char *argv[])
  1879. {
  1880.    int   argcounter;
  1881.    char  *userfilespec;

  1883.    signal(SIGINT, breakout);

  1885.    for (argcounter = 0; argcounter < 50; argcounter++)
  1886.       fiftyspaces[argcounter] = ' ';
  1887.    fiftyspaces[argcounter] = '\0';

  1889.    fputs("Nifty James' File Finder\n", stderr);
  1890.    fputs("Version 2.17/ASP of 22 March, 1993\n", stderr);
  1891.    fputs("(C) Copyright 1989-1993 by Mike Blaszczak\n\n", stderr);

  1893.    builddrivelist();

  1895.    if (argc < 2)
  1896.       {
  1897.       showusage();
  1898.       }

  1900.    userfilespec = NULL;
  1901.    for (argcounter = 1; argcounter<argc; argcounter++)
  1902.       {
  1903.       if (argv[argcounter][0] == '/' || argv[argcounter][0] == '-')
  1904.          {
  1905.          handleoption(argv[argcounter]+1, FALSE);
  1906.          }
  1907.       else
  1908.          {
  1909.          if (userfilespec == NULL)
  1910.             {
  1911.             userfilespec = argv[argcounter];
  1912.             }
  1913.          else
  1914.             {
  1915.             fputs("Only one filespec allowed!\n\n", stderr);
  1916.             exit(1);
  1917.             }
  1918.          }
  1919.       }

  1921.    handleenvironment();

  1923.    /* moved from handleoption in version 2.00   */

  1925.    fputc('\n', stderr);

  1927.    /* end of moved code */

  1929.    _dos_getdrive(&olddrive);
  1930.    newdriveletter[0] = '\0';

  1932.    if (userfilespec == NULL)
  1933.       {
  1934.       userfilespec = "X:\\*.*";
  1935.       userfilespec[0] = (char) olddrive + 'A';
  1936.       drivelist[0] = userfilespec[0];
  1937.       drivelist[1] = '\0';
  1938.       }
  1939.    else
  1940.       if (alldrives == FALSE)
  1941.          {
  1942.          if (userfilespec[1] == ':')
  1943.             {
  1944.             *userfilespec = (char) toupper(*userfilespec);
  1945.             newdrive = (unsigned) (*userfilespec - 'A' +1);
  1946.             _dos_setdrive(newdrive, &drivecount);
  1947.             _dos_getdrive(&lastdrive);

  1949.             if (lastdrive != newdrive)
  1950.                {
  1951.                fprintf(stderr, "NJFIND: Invalid drive %c:.\n", *userfilespec);
  1952.                fprintf(stderr, "        Valid drives are A: to %c:\n",
  1953.                   drivelist[strlen(drivelist)-1]);
  1954.                exit(1);
  1955.                }
  1956.             else
  1957.                {
  1958.                changedrive = TRUE;
  1959.                drivelist[0] = *userfilespec;
  1960.                drivelist[1] = '\0';
  1961.                userfilespec += 2;
  1962.                }
  1963.             }
  1964.          else
  1965.             {
  1966.             drivelist[0] = (char) (olddrive + 'A' -1);
  1967.             drivelist[1] = '\0';
  1968.             }
  1969.          }
  1970.       else
  1971.          {
  1972.          changedrive = TRUE;
  1973.          if (userfilespec[1] == ':')
  1974.             userfilespec += 2;
  1975.          }

  1977.    inputfile = strupr(userfilespec);
  1978.    maketemplate();
  1979.    makefullname(&matchname, template);
  1980. #if defined(DEBUG)
  1981.    printf("template: %s\n", template);
  1982. #endif

  1984.    for (currentdrive = drivelist; *currentdrive != '\0';
  1985.             currentdrive++)
  1986.       {
  1987.       newdriveletter[0] = *currentdrive;
  1988.       newdriveletter[1] = ':';
  1989.       newdriveletter[2] = '\0';

  1991.       newdrive = (unsigned) (*currentdrive - 'A' +1);
  1992.       _dos_setdrive(newdrive, &drivecount);
  1993.       searchdir("\\*.*");
  1994.       }

  1996.    if (broken == TRUE)
  1997.       printf("\nNJFIND: Searching interrupted!\n\n");

  1999.    /* print out statistics */

  2001.    printf("\n   %5u file", found);
  2002.    if (found != 1)
  2003.       putchar('s');
  2004.    printf(" found.\n");
  2005.    printf("   %5u archived file", archivefound);
  2006.    if (archivefound != 1)
  2007.       putchar('s');
  2008.    printf(" found.\n");

  2010.    if (found != 0 && archivefound != 0)
  2011.       printf("   %5u files found in total.\n", found + archivefound);
  2012.    else
  2013.       putchar('\n');

  2015.    putchar('\n');
  2016.     
  2017.    if (totalsmode == TRUE || verbose == TRUE)
  2018.       {
  2019.       if (found != 0)
  2020.          printf("Found files total %lu bytes.\n", totallength);
  2021.       if (archivefound != 0)
  2022.          printf("Found archive files total %lu bytes.\n", archivetotallength);
  2023.       }

  2025.    if (changedrive == TRUE)
  2026.       _dos_setdrive(olddrive, &drivecount);

  2028.    exit(0);
  2029. }