home *** CD-ROM | disk | FTP | other *** search
/ OS/2 Shareware BBS: 9 Archive / 09-Archive.zip / lha100bt.zip / lha-1.00 / src / lharc.c < prev    next >
C/C++ Source or Header  |  1994-09-08  |  26KB  |  1,182 lines
  1.  
  2. /*----------------------------------------------------------------------*/
  3. /*        LHarc Archiver Driver for UNIX                */
  4. /*        This is part of LHarc UNIX Archiver Driver        */
  5. /*                                    */
  6. /*        Copyright(C) MCMLXXXIX  Yooichi.Tagawa            */
  7. /*        Thanks to H.Yoshizaki. (MS-DOS LHarc)            */
  8. /*                                    */
  9. /*  V0.00  Original                1988.05.23  Y.Tagawa    */
  10. /*  V0.01  Alpha Version (for 4.2BSD)        1989.05.28  Y.Tagawa    */
  11. /*  V0.02  Alpha Version Rel.2            1989.05.29  Y.Tagawa    */
  12. /*  V0.03  Release #3  Beta Version        1989.07.02  Y.Tagawa    */
  13. /*  V0.03a Debug                1989.07.03  Y.Tagawa    */
  14. /*  V0.03b Modified                1989.07.13  Y.Tagawa    */
  15. /*  V0.03c Debug (Thanks to void@rena.dit.junet)1989.08.09  Y.Tagawa    */
  16. /*  V0.03d Modified (quiet and verbose)        1989.09.14  Y.Tagawa    */
  17. /*  V1.00  Fixed                1989.09.22  Y.Tagawa    */
  18. /*  V1.01  Bug Fixed                1989.12.25  Y.Tagawa    */
  19. /*                                    */
  20. /*  DOS-Version Original LHx V C2.01         (C) H.Yohizaki        */
  21. /*                                    */
  22. /*  V2.00  UNIX Lharc + DOS LHx -> OSK LHx    1990.11.01  Momozou    */
  23. /*  V2.01  Minor Modified            1990.11.24  Momozou    */
  24. /*                                    */
  25. /*  V0.02  LHx for UNIX                1991.11.18  M.Oki    */
  26. /*  V0.03  LHa for UNIX                1991.12.17  M.Oki    */
  27. /*  V0.04  LHa for UNIX    beta version        1992.01.20  M.Oki    */
  28. /*  V1.00  LHa for UNIX    Fixed            1992.03.19  M.Oki    */
  29.  
  30. /*  V1.01  LHa for OS2    Modified        1994.08.31 Enrico Demarin    */
  31.  
  32. /*----------------------------------------------------------------------*/
  33.  
  34. #include "lharc.h"
  35.  
  36. /*****************************************
  37. Added 31-8-1994     by Enrico Demarin 
  38. ******************************************/
  39.  
  40. #define INCL_DOS
  41. #define INCL_ERRORS
  42. #include <os2emx.h>
  43. #include <stdlib.h>
  44. #include <malloc.h>
  45.  
  46. /*****************************************/
  47.  
  48. /*----------------------------------------------------------------------*/
  49. /*                PROGRAM                 */
  50. /*----------------------------------------------------------------------*/
  51.  
  52.  
  53. #define CMD_UNKNOWN    0
  54. #define CMD_EXTRACT    1
  55. #define CMD_ADD        2
  56. #define CMD_LIST    3
  57. #define CMD_DELETE    4
  58.  
  59. static int    cmd = CMD_UNKNOWN;
  60. char    **cmd_filev;
  61. int    cmd_filec;
  62.  
  63. char    *archive_name="";
  64. char    expanded_archive_name[FILENAME_LENGTH];
  65. char    temporary_name[FILENAME_LENGTH];
  66. char    backup_archive_name[FILENAME_LENGTH];
  67.  
  68. /* static functions */
  69. static void sort_files();
  70.  
  71. /*****************************************
  72.  
  73. Added  31-8-1994 by Enrico Demarin
  74.  
  75. Include SYSTEM and HIDDEN files ?
  76. Recurse subdirectories ?
  77.  
  78. ******************************************/
  79. void     convert_slash(char *);
  80. int      expand_wildcards(char *,char *);
  81.  
  82. boolean recurse_subdirs = FALSE;
  83. boolean make_backups = FALSE;
  84. int file_mask = FILE_DIRECTORY | FILE_ARCHIVED | FILE_READONLY;
  85.  
  86. /*****************************************/
  87.  
  88. /* options */
  89. boolean    quiet = FALSE;
  90. boolean    text_mode = FALSE;
  91. boolean    verbose = FALSE;
  92. boolean    noexec = FALSE;    /* debugging option */
  93. boolean    force = FALSE;
  94. boolean    prof = FALSE;
  95. int compress_method = 5;    /* deafult -lh5- */
  96. int header_level = HEADER_LEVEL1;
  97. #ifdef EUC
  98. boolean euc_mode = FALSE;
  99. #endif
  100.  
  101. /* view command flags */
  102. boolean    verbose_listing = FALSE;
  103.  
  104. /* extract command flags */
  105. boolean    output_to_stdout = FALSE;
  106.  
  107. /* append command flags */
  108. boolean    new_archive = FALSE;
  109. boolean    update_if_newer = FALSE;
  110. boolean    delete_after_append = FALSE;
  111. boolean    generic_format = FALSE;
  112.  
  113. boolean    remove_temporary_at_error = FALSE;
  114. boolean    recover_archive_when_interrupt = FALSE;
  115. boolean    remove_extracting_file_when_interrupt = FALSE;
  116. boolean get_filename_from_stdin = FALSE;
  117. boolean ignore_directory = FALSE;
  118. boolean verify_mode = FALSE;
  119.  
  120.  
  121.  
  122. char *extract_directory = NULL;
  123. char **xfilev;
  124. int  xfilec = 257;
  125. char name[CCHMAXPATH];
  126. char *nameptr;                 
  127. int res;
  128.  
  129. /*----------------------------------------------------------------------*/
  130. /* NOTES :        Text File Format                */
  131. /*    GENERATOR        NewLine                    */
  132. /*    [generic]        0D 0A                    */
  133. /*    [MS-DOS]        0D 0A                    */
  134. /*    [OS9][MacOS]        0D                    */
  135. /*    [UNIX]            0A                    */
  136. /*----------------------------------------------------------------------*/
  137.  
  138.  
  139. static void
  140. print_tiny_usage_and_exit ()
  141. {
  142.   fprintf(stderr, "Usage: lha [-]{axelvudmcpRBSH}[qvnfodizg012][w=<dir>] archive_file [file...]\n\n\
  143. Commands:                           options:\n\
  144.  a   Add(or replace) to archive      q  quiet\n\
  145.  x,e EXtract from archive            v  verbose\n\
  146.  l,v List / Verbose List             n  not execute\n\
  147.  u   Update newer files to archive   f  force (over write at extract)\n\
  148.  d   Delete from archive             t  FILES are TEXT file\n\
  149.  m   Move to archive (means 'ad')    o  use LHarc compatible method (a/u)\n\
  150.  c   re-Construct new archive        w=<dir> specify extract directory (x/e)\n\
  151.  p   Print to STDOUT from archive    d  delete FILES after (a/u/c)\n\
  152.  t   Test file CRC in archive        i  ignore directory path (x/e)\n\
  153.                                      z  files not compress (a/u)\n\
  154.                                      g  [Generic] format (for compatibility)\n\
  155.                                      0/1/2 header level (a/u)\n\
  156.                                      R   Recurse subdirs\n\
  157.                                      S   Include system files\n\
  158.                                      H   Include hidden files\n\
  159.                                      B   Make Backups
  160. ");                                    
  161. #ifdef EUC
  162.   fprintf (stderr, "\
  163.                                      e  TEXT code convert from/to EUC\n\
  164. ");
  165. #endif
  166.   exit (1);
  167. }
  168.  
  169. void
  170. main (argc, argv)
  171.      int argc;
  172.      char *argv[];
  173. {
  174.   char *p , inpbuf[256];
  175.   int i,filename_pos=1;
  176.  
  177.   fprintf (stderr, "Lha for OS/2 V1.00Beta 31-08-1994 by Enrico Demarin\n\n"); 
  178.  
  179.   
  180.   if (argc < 2)
  181.     print_tiny_usage_and_exit ();
  182.   if (argc < 3) {
  183.   /* archive file name */
  184.   archive_name = argv[1];
  185.   filename_pos = 1;
  186.     cmd = CMD_LIST;
  187.     goto work;
  188.   }
  189.   
  190.  
  191.   for (i=1; i<argc; i++)
  192.   {
  193.   
  194.   if ((cmd==CMD_UNKNOWN)&&(argv[i][0]!='-'))
  195.   {   
  196.   if (strlen(argv[i])>1)
  197.         { fprintf(stderr, "LHa: nothing to do !\n"); exit(1);  }
  198.      
  199.  
  200.   switch ( argv[i][0] )
  201.     {
  202.     case 'x':
  203.     case 'e':
  204.       cmd = CMD_EXTRACT;
  205.       break;
  206.  
  207.     case 'p':
  208.       output_to_stdout = TRUE;
  209.       cmd = CMD_EXTRACT;
  210.       break;
  211.  
  212.     case 'c':
  213.       new_archive = TRUE;
  214.       cmd = CMD_ADD;
  215.       break;
  216.  
  217.     case 'a':
  218.       cmd = CMD_ADD;
  219.       break;
  220.  
  221.     case 'd':
  222.       cmd = CMD_DELETE;
  223.       break;
  224.  
  225.     case 'u':
  226.       update_if_newer = TRUE;
  227.       cmd = CMD_ADD;
  228.       break;
  229.  
  230.     case 'm':
  231.       delete_after_append = TRUE;
  232.       cmd = CMD_ADD;
  233.       break;
  234.  
  235.     case 'v':
  236.       verbose_listing = TRUE;
  237.       cmd = CMD_LIST;
  238.       break;
  239.  
  240.     case 'l':
  241.       cmd = CMD_LIST;
  242.       break;
  243.  
  244.     case 't':
  245.       cmd = CMD_EXTRACT;
  246.       verify_mode = TRUE;
  247.       break;
  248.  
  249.     default:
  250.         print_tiny_usage_and_exit ();
  251.     
  252.     }
  253.     argv[i][0]=0;
  254.    }
  255.     else { 
  256.            if (argv[i][0]!='-')
  257.          { archive_name=argv[i]; filename_pos=i; break;   }
  258.         }
  259.  
  260.   }
  261.   
  262.   for (i=1; i<argc; i++)
  263.   { 
  264.   /* options */
  265.   p = &argv[i][1];
  266.   if (argv[i][0]=='-')
  267.   { 
  268.   for (p = &argv[i][1]; *p; )
  269.     {
  270.       switch ( (*p++) )
  271.     {
  272.  
  273.     case 'H':
  274.       file_mask|=FILE_HIDDEN;
  275.       break;
  276.     case 'S':
  277.       file_mask|=FILE_SYSTEM;
  278.       break;
  279.     case 'R':
  280.       recurse_subdirs=TRUE;
  281.       break;
  282.     case 'B':
  283.       make_backups=TRUE;
  284.       break;
  285.       
  286.        
  287.     
  288.         case 'q':    quiet = TRUE; break;
  289.         case 'f':    force = TRUE; break;
  290.         case 'p':    prof = TRUE; break;
  291.         case 'v':    verbose = TRUE; break;
  292.         case 't':    text_mode = TRUE; break;
  293. #ifdef EUC
  294.         case 'e':    text_mode = TRUE; euc_mode = TRUE; break;
  295. #endif
  296.         case 'n':    noexec = TRUE; break;
  297.         case 'g':    generic_format = TRUE; header_level = 0; break;
  298.         case 'd':    delete_after_append = TRUE; break;
  299.         case 'o':    compress_method = 1; header_level = 0; break;
  300.         case 'z':    compress_method = 0; break;
  301.         case 'i':    ignore_directory = TRUE; break;
  302.         case 'w':    if ( *p=='=' ) p++;
  303.                     extract_directory=p;
  304.                     while (*p) p++;
  305.                     break;
  306.         case '0':    header_level = HEADER_LEVEL0; break;
  307.         case '1':    header_level = HEADER_LEVEL1; break;
  308.         case '2':    header_level = HEADER_LEVEL2; break;
  309.         default:
  310.           fprintf(stderr, "LHa: Unknown option '%c'.\n", p[-1]);
  311.           exit(1);
  312.         }
  313.     }
  314.      }
  315.    }  
  316.  
  317. work:
  318.     
  319.    
  320.  
  321.  
  322.   if (!strcmp(archive_name, "-"))
  323.     {
  324.       if (!isatty(1) && cmd == CMD_ADD) quiet = TRUE;
  325.     }
  326.   else
  327.     {
  328.       if (argc == 3 && !isatty(0))
  329.     get_filename_from_stdin = TRUE;
  330.     }
  331.  
  332.   /* target file name */
  333.   if ( get_filename_from_stdin )
  334.   {
  335.       cmd_filec = 0;
  336.     if ( (xfilev = (char **)malloc(sizeof(char *) * xfilec)) == NULL)
  337.         fatal_error("Virtual memory exhausted\n");
  338.      while ( gets( inpbuf ) )
  339.      {
  340.         if ( cmd_filec >= xfilec )
  341.         {
  342.             xfilec += 256;
  343.             cmd_filev = (char **)realloc(xfilev,
  344.                           sizeof(char *) * xfilec);
  345.             if ( cmd_filev == NULL )
  346.                 fatal_error("Virtual memory exhausted\n");
  347.             xfilev = cmd_filev;
  348.         }                
  349.          if ( strlen( inpbuf )<1 ) continue;
  350.          if ( (xfilev[cmd_filec++]=(char *)strdup(inpbuf))==NULL )
  351.              fatal_error("Virtual memory exhausted\n");
  352.      }
  353.      xfilev[cmd_filec] = NULL;
  354.      cmd_filev = xfilev;
  355.   }
  356.   
  357.   else
  358.   {
  359.    int count;
  360. /*****************************************************
  361.  Added  31-8-1994 by Enrico Demarin
  362.  Wild card matching for OS-2
  363. ******************************************************/
  364.  
  365. if (cmd==CMD_ADD)
  366. { 
  367.  
  368.   
  369. cmd_filec = 0;
  370. cmd_filev = NULL;
  371.         
  372. for (count=filename_pos+1; count<argc; count++)
  373. { 
  374.  if ((argv[count][0])&&(argv[count][0]!='-'))
  375.  { 
  376.  nameptr=(char *)_getname(argv[count]);
  377.         
  378.  if (nameptr!=argv[count]) 
  379.   {
  380.    strcpy(name,nameptr);
  381.    *nameptr=0;
  382.    res=expand_wildcards(argv[count],name);
  383.   } else res=expand_wildcards(NULL,argv[count]);
  384.  if (!res) fatal_error("Virtual memory exhausted\n");
  385.  }
  386. }
  387.  }  else { 
  388.     cmd_filec = argc-filename_pos-1;
  389.     cmd_filev = argv+filename_pos+1;
  390.      }
  391.  
  392. }
  393.  
  394.              
  395. /*****************************************************/
  396.   sort_files ();
  397.  
  398.   /* make crc table */
  399.   make_crctable();
  400.  
  401.  
  402.  
  403.   switch (cmd)
  404.     {
  405.     case CMD_ADD:    cmd_add ();    break;
  406.     case CMD_DELETE:    cmd_delete ();    break;
  407.  
  408.     case CMD_EXTRACT:            /* Archive pattern matching */
  409.     case CMD_LIST:    
  410.     { 
  411.     HDIR handle = HDIR_CREATE;
  412.     static FILEFINDBUF3 ffbuf;
  413.     ULONG count = 1;
  414.     APIRET goon;
  415.     char *filter=archive_name;
  416.     
  417.  
  418.  
  419.     goon = DosFindFirst(filter, &handle,
  420.             0, (void *) &ffbuf, sizeof(ffbuf), &count, FIL_STANDARD);
  421.  
  422.     while (goon==NO_ERROR)
  423.     { 
  424.       fprintf (stderr, "Processing archive : %s\n", ffbuf.achName);
  425.       archive_name=ffbuf.achName;
  426.       
  427.       if (cmd=CMD_EXTRACT) 
  428.       cmd_extract (); else cmd_list ();    
  429.       
  430.       count = 1;
  431.       goon = DosFindNext(handle, &ffbuf, sizeof(ffbuf), &count);
  432.         
  433.       fprintf (stderr, "Done.\n\n", ffbuf.achName);
  434.     
  435.     }
  436.    
  437.    if (handle) DosFindClose(handle);
  438.      
  439.     } break;
  440.  
  441.  
  442.     }
  443.     
  444.  
  445. #ifdef USE_PROF
  446.   if (!prof)
  447.     exit (0);
  448. #endif
  449.  
  450.   exit (0);
  451. }
  452.  
  453. static void
  454. message_1 (title, subject, name)
  455.      char *title, *subject, *name;
  456. {
  457.   fprintf (stderr, "LHa: %s%s ", title, subject);
  458.   fflush (stderr);
  459.  
  460.   if (errno == 0)
  461.     fprintf (stderr, "%s\n", name);
  462.   else
  463.     perror (name);
  464. }
  465.  
  466. void
  467. message (subject, name)
  468.      char *subject, *name;
  469. {
  470.   message_1 ("", subject, name);
  471. }
  472.  
  473. void
  474. warning (subject, name)
  475.      char *subject, *name;
  476. {
  477.   message_1 ("Warning: ", subject, name);
  478. }
  479.  
  480. void
  481. error (subject, msg)
  482.      char *subject, *msg;
  483. {
  484.   message_1 ("Error: ", subject, msg);
  485. }
  486.  
  487. void
  488. fatal_error (msg)
  489.      char *msg;
  490. {
  491.   message_1 ("Fatal error:", "", msg);
  492.  
  493.   if (remove_temporary_at_error)
  494.     unlink (temporary_name);
  495.  
  496.   exit (1);
  497. }
  498.  
  499. char *writting_filename;
  500. char *reading_filename;
  501.  
  502. void
  503. write_error ()
  504. {
  505.   fatal_error (writting_filename);
  506. }
  507.  
  508. void
  509. read_error ()
  510. {
  511.   fatal_error (reading_filename);
  512. }
  513.  
  514. void
  515. interrupt (signo)
  516.      int signo;
  517. {
  518.   errno = 0;
  519.   message ("Interrupted\n", "");
  520.  
  521.   if ( temporary_fp ) fclose (temporary_fp);
  522.   unlink (temporary_name);
  523.   if (recover_archive_when_interrupt)
  524.     rename (backup_archive_name, archive_name);
  525.   if (remove_extracting_file_when_interrupt)
  526.     {
  527.       errno = 0;
  528.       message ("Removing", writting_filename);
  529.       unlink (writting_filename);
  530.     }
  531.   signal (SIGINT, SIG_DFL);
  532.   signal (SIGHUP, SIG_DFL);
  533.   kill (getpid (), signo);
  534. }
  535.  
  536.  
  537.  
  538. /*----------------------------------------------------------------------*/
  539. /*                                    */
  540. /*----------------------------------------------------------------------*/
  541.  
  542. static int
  543. sort_by_ascii (a, b)
  544.      char **a, **b;
  545. {
  546.   register char *p, *q;
  547.   register int c1, c2;
  548.  
  549.   p = *a, q = *b;
  550.   if (generic_format)
  551.     {
  552.       do
  553.     {
  554.       c1 = *(unsigned char*)p ++;
  555.       c2 = *(unsigned char*)q ++;
  556.       if (!c1 || !c2)
  557.         break;
  558.       if (islower (c1))
  559.         c1 = toupper (c1);
  560.       if (islower (c2))
  561.         c2 = toupper (c2);
  562.     }
  563.       while (c1 == c2) ;
  564.       return c1 - c2;
  565.     }
  566.   else
  567.     {
  568.       while (*p == *q && *p != '\0')
  569.     p ++, q ++;
  570.       return *(unsigned char*)p - *(unsigned char*)q;
  571.     }
  572. }
  573.  
  574. static void
  575. sort_files ()
  576. {
  577.   if (cmd_filec > 1)
  578.     qsort (cmd_filev, cmd_filec, sizeof (char*), sort_by_ascii);
  579. }
  580.  
  581. char *xmalloc (size)
  582.      int size;
  583. {
  584.   char *p = (char *)malloc (size);
  585.   if (!p)
  586.     fatal_error ("Not enough memory");
  587.   return p;
  588. }
  589.  
  590. char *xrealloc (old, size)
  591.      char *old;
  592.      int size;
  593. {
  594.   char *p = (char *)realloc (old, size);
  595.   if (!p)
  596.     fatal_error ("Not enough memory");
  597.   return p;
  598. }
  599.  
  600. /*----------------------------------------------------------------------*/
  601. /*                STRING POOL                */
  602. /*----------------------------------------------------------------------*/
  603.  
  604. /*
  605.  * string pool :
  606.  *    +-------------+-------------+---     ---+-------------+----------+
  607.  *    | N A M E 1 \0| N A M E 2 \0|    ...    | N A M E n \0|             |
  608.  *    +-------------+-------------+---     ---+-------------+----------+
  609.  *    ^                              ^         ^
  610.  * buffer+0                        buffer+used  buffer+size
  611.  */
  612.  
  613. /*
  614.  * vector :
  615.  *    +---------------+---------------+-------------     -------------+
  616.  *    | pointer to    | pointer to    | pointer to   ...  pointer to    |
  617.  *    |  string pool    |  N A M E 1    |  N A M E 2   ...   N A M E n    |
  618.  *    +---------------+---------------+-------------     -------------+
  619.  *    ^        ^
  620.  *   malloc base      returned
  621.  */
  622.  
  623. void
  624. init_sp (sp)
  625.      struct string_pool *sp;
  626. {
  627.   sp->size = 1024 - 8;        /* any ( >=0 ) */
  628.   sp->used = 0;
  629.   sp->n = 0;
  630.   sp->buffer = (char*)xmalloc (sp->size * sizeof (char));
  631. }
  632.  
  633. void
  634. add_sp (sp, name, len)
  635.      struct string_pool *sp;
  636.      char *name;        /* stored '\0' at tail */
  637.      int len;            /* include '\0' */
  638. {
  639.   while (sp->used + len > sp->size)
  640.     {
  641.       sp->size *= 2;
  642.       sp->buffer = (char*) xrealloc (sp->buffer, sp->size * sizeof (char));
  643.     }
  644.   bcopy (name, sp->buffer + sp->used, len);
  645.   sp->used += len;
  646.   sp->n ++;
  647. }
  648.  
  649. void
  650. finish_sp (sp, v_count, v_vector)
  651.      register struct string_pool *sp;
  652.      int *v_count;
  653.      char ***v_vector;
  654. {
  655.   int i;
  656.   register char *p;
  657.   char **v;
  658.  
  659.   v = (char**) xmalloc ((sp->n + 1) * sizeof (char*));
  660.   *v++ = sp->buffer;
  661.   *v_vector = v;
  662.   *v_count = sp->n;
  663.   p = sp->buffer;
  664.   for (i = sp->n; i; i --)
  665.     {
  666.       *v++ = p;
  667.       if (i - 1)
  668.     p += strlen (p) + 1;
  669.     }
  670. }
  671.  
  672. void
  673. free_sp (vector)
  674.      char **vector;
  675. {
  676.   vector --;
  677.   free (*vector);        /* free string pool */
  678.   free (vector);
  679. }
  680.  
  681.  
  682. /*----------------------------------------------------------------------*/
  683. /*            READ DIRECTORY FILES                */
  684. /*----------------------------------------------------------------------*/
  685.  
  686. static boolean
  687. include_path_p (path, name)
  688.      char *path, *name;
  689. {
  690.   char *n = name;
  691.   while (*path)
  692.     if (*path++ != *n++)
  693.       return (path[-1] == '/' && *n == '\0');
  694.   return (*n == '/' || (n != name && path[-1] == '/' && n[-1] == '/'));
  695. }
  696.  
  697. #define STREQU(a,b)    (((a)[0] == (b)[0]) ? (strcmp ((a),(b)) == 0) : FALSE)
  698. void
  699. cleaning_files (v_filec, v_filev)
  700.      int *v_filec;
  701.      char ***v_filev;
  702. {
  703.   char *flags;
  704.   struct stat stbuf;
  705.   register char **filev = *v_filev;
  706.   register int filec = *v_filec;
  707.   register char *p;
  708.   register int i, j;
  709.  
  710.   if (filec == 0)
  711.     return;
  712.  
  713.   flags = xmalloc (filec * sizeof (char));
  714.  
  715.   /* flags & 0x01 :    1: ignore */
  716.   /* flags & 0x02 :    1: directory, 0 : regular file */
  717.   /* flags & 0x04 :    1: need delete */
  718.  
  719.   for (i = 0; i < filec; i ++)
  720.     if (stat (filev[i], &stbuf) < 0)
  721.       {
  722.     flags[i] = 0x04;
  723.     fprintf (stderr,
  724.          "LHa: Cannot access \"%s\", ignored.\n", filev[i]);
  725.       }
  726.     else
  727.       {
  728.     if (is_regularfile (&stbuf))
  729.       flags[i] = 0x00;
  730.     else if (is_directory (&stbuf))
  731.       flags[i] = 0x02;
  732.     else
  733.       {
  734.         flags[i] = 0x04;
  735.         fprintf (stderr,
  736.              "LHa: Cannot archive \"%s\", ignored.\n", filev[i]);
  737.       }
  738.       }
  739.   errno = 0;
  740.  
  741.   for (i = 0; i < filec; i ++)
  742.     {
  743.       p = filev[i];
  744.       if ((flags[i] & 0x07) == 0x00)
  745.     {            /* regular file, not deleted/ignored */
  746.       for (j = i + 1; j < filec; j ++)
  747.         {
  748.           if ((flags[j] & 0x07) == 0x00)
  749.         {        /* regular file, not deleted/ignored */
  750.           if (STREQU (p, filev[j]))
  751.             flags[j] = 0x04; /* delete */
  752.         }
  753.         }
  754.     }
  755.       else if ((flags[i] & 0x07) == 0x02)
  756.     {            /* directory, not deleted/ignored */
  757.       for (j = i + 1; j < filec; j ++)
  758.         {
  759.           if ((flags[j] & 0x07) == 0x00)
  760.         {        /* regular file, not deleted/ignored */
  761.           if (include_path_p (p, filev[j]))
  762.             flags[j] = 0x04; /* delete */
  763.         }
  764.           else if ((flags[j] & 0x07) == 0x02)
  765.         {        /* directory, not deleted/ignored */
  766.           if (include_path_p (p, filev[j]))
  767.             flags[j] = 0x04; /* delete */
  768.         }
  769.         }
  770.     }
  771.     }
  772.  
  773.   for (i = j = 0; i < filec; i ++)
  774.     {
  775.       if ((flags[i] & 0x04) == 0)
  776.     {
  777.       if (i != j)
  778.         filev[j] = filev[i];
  779.       j ++;
  780.     }
  781.     }
  782.   *v_filec = j;
  783.  
  784.   free (flags);
  785. }
  786.  
  787. #ifdef NODIRECTORY
  788. /* please need your imprementation */
  789. boolean
  790. find_files (name, v_filec, v_filev)
  791.      char *name;
  792.      int *v_filec;
  793.      char ***v_filev;
  794. {
  795.   return FALSE;            /* DUMMY */
  796. }
  797.  
  798. void
  799. free_files (filec, filev)
  800.      int filec;
  801.      char **filev;
  802. {
  803.   /* do nothing */
  804. }
  805. #else
  806. boolean
  807. find_files (name, v_filec, v_filev)
  808.      char *name;
  809.      int *v_filec;
  810.      char ***v_filev;
  811. {
  812.   struct string_pool sp;
  813.   char newname[FILENAME_LENGTH];
  814.   int len, n;
  815.   DIR *dirp;
  816.   DIRENTRY *dp;
  817.   struct stat tmp_stbuf, arc_stbuf, fil_stbuf;
  818.  
  819.   strcpy (newname, name);
  820.   len = strlen (name);
  821.   if (len > 0 && newname[len-1] != '/')
  822.     newname[len++] = '/';
  823.  
  824.   dirp = opendir (name);
  825.   if (!dirp)
  826.     return FALSE;
  827.  
  828.   init_sp (&sp);
  829.  
  830.   GETSTAT(temporary_name, &tmp_stbuf);
  831.   GETSTAT(archive_name, &arc_stbuf);
  832.  
  833.   for (dp = readdir (dirp); dp != NULL; dp = readdir (dirp))
  834.     {
  835.       n = NAMLEN (dp);
  836.       strncpy (newname+len, dp->d_name, n);
  837.       newname[len + n] = '\0';
  838.       if (GETSTAT(newname, &fil_stbuf) < 0) continue;
  839.       if ((dp->d_ino != 0) &&
  840.       /* exclude '.' and '..' */
  841.       ((dp->d_name[0] != '.') ||
  842.        ((n != 1) &&
  843.         ((dp->d_name[1] != '.') ||
  844.          (n != 2)))) &&
  845.       ((tmp_stbuf.st_dev != fil_stbuf.st_dev ||
  846.         tmp_stbuf.st_ino != fil_stbuf.st_ino) &&
  847.        (arc_stbuf.st_dev != fil_stbuf.st_dev ||
  848.         arc_stbuf.st_ino != fil_stbuf.st_ino)))
  849.  
  850.     {
  851.       add_sp (&sp, newname, len + n + 1);
  852.     }
  853.     }
  854.   closedir (dirp);
  855.   finish_sp (&sp, v_filec, v_filev);
  856.   if (*v_filec > 1)
  857.     qsort (*v_filev, *v_filec, sizeof (char*), sort_by_ascii);
  858.   cleaning_files (v_filec, v_filev);
  859.  
  860.   return TRUE;
  861. }
  862.  
  863. void
  864. free_files (filec, filev)
  865.      int filec;
  866.      char **filev;
  867. {
  868.   free_sp (filev);
  869. }
  870. #endif
  871.  
  872. /*----------------------------------------------------------------------*/
  873. /*                                    */
  874. /*----------------------------------------------------------------------*/
  875.  
  876. /* Build temporary file name and store to TEMPORARY_NAME */
  877. void
  878. build_temporary_name ()
  879. {
  880. #ifdef TMP_FILENAME_TEMPLATE
  881.   /* "/tmp/lhXXXXXX" etc. */
  882.   strcpy (temporary_name, TMP_FILENAME_TEMPLATE);
  883.   mktemp (temporary_name);
  884. #else
  885.   char *p, *s;
  886.  
  887.   strcpy (temporary_name, archive_name);
  888.   for (p = temporary_name, s = (char*)0; *p; p ++)
  889.     if (*p == '/')
  890.       s = p;
  891.   strcpy ((s ? s+1 : temporary_name), "lhXXXXXX");
  892.   mktemp (temporary_name);
  893. #endif
  894. }
  895.  
  896. static void
  897. modify_filename_extention (buffer, ext)
  898.      char *buffer;
  899.      char *ext;
  900. {
  901.   register char *p, *dot;
  902.  
  903.   for (p = buffer, dot = (char*)0; *p; p ++)
  904.     {
  905.       if (*p == '.')
  906.         dot = p;
  907.       else if (*p == '/')
  908.         dot = (char*)0;
  909.     }
  910.  
  911.   if (dot)
  912.     p = dot;
  913.  
  914.   strcpy (p, ext);
  915. }
  916.  
  917. /* build backup file name */
  918. void
  919. build_backup_name (buffer, original)
  920.      char *buffer;
  921.      char *original;
  922. {
  923.   strcpy (buffer, original);
  924.   modify_filename_extention (buffer, BACKUPNAME_EXTENTION); /* ".bak" */
  925. }
  926.  
  927. void
  928. build_standard_archive_name (buffer, orginal)
  929.      char *buffer;
  930.      char *orginal;
  931. {
  932.   strcpy (buffer, orginal);
  933.   modify_filename_extention (buffer, ARCHIVENAME_EXTENTION); /* ".lzh" */
  934. }
  935.  
  936. /*----------------------------------------------------------------------*/
  937. /*                                    */
  938. /*----------------------------------------------------------------------*/
  939.  
  940. extern int patmatch();
  941.  
  942. boolean
  943. need_file (name)
  944.      char *name;
  945. {
  946.   int i;
  947.  
  948.   if (cmd_filec == 0)
  949.     return TRUE;
  950.  
  951.   for (i = 0; i < cmd_filec; i ++)
  952.     {
  953.       if (patmatch(cmd_filev[i], name, 0 ) )
  954.         return TRUE;
  955.     }
  956.  
  957.   return FALSE;
  958. }
  959.  
  960. FILE *
  961. xfopen (name, mode)
  962.      char *name, *mode;
  963. {
  964.   FILE *fp;
  965.  
  966.   if ((fp = fopen (name, mode)) == NULL)
  967.     fatal_error (name);
  968.  
  969.   return fp;
  970. }
  971.  
  972.  
  973. /*----------------------------------------------------------------------*/
  974. /*                                    */
  975. /*----------------------------------------------------------------------*/
  976. int    archive_file_mode;
  977. int    archive_file_gid;
  978.  
  979. static boolean
  980. open_old_archive_1 (name, v_fp)
  981.      char *name;
  982.      FILE **v_fp;
  983. {
  984.   FILE *fp;
  985.   struct stat stbuf;
  986.  
  987.   if (stat (name, &stbuf) >= 0 &&
  988.       is_regularfile (&stbuf) &&
  989.       (fp = fopen (name, READ_BINARY)) != NULL)
  990.     {
  991.       *v_fp = fp;
  992.       archive_file_gid = stbuf.st_gid;
  993.       archive_file_mode = stbuf.st_mode;
  994.       return TRUE;
  995.     }
  996.  
  997.   *v_fp = NULL;
  998.   archive_file_gid = -1;
  999.   return FALSE;
  1000. }
  1001.  
  1002. FILE *
  1003. open_old_archive ()
  1004. {
  1005.   FILE *fp;
  1006.   char *p;
  1007.  
  1008.   if (!strcmp(archive_name, "-"))
  1009.     {
  1010.       if (cmd == CMD_EXTRACT || cmd == CMD_LIST) return stdin;
  1011.       else return NULL;
  1012.     }
  1013.   if (p = (char *)rindex(archive_name,'.'))
  1014.     {
  1015.       if ( strucmp(".LZH",p)==0
  1016.           || strucmp(".LZS",p)==0
  1017.           || strucmp(".COM",p)==0        /* DOS SFX */
  1018.           || strucmp(".EXE",p)==0
  1019.             || strucmp(".X"  ,p)==0        /* HUMAN SFX */
  1020.           || strucmp(".BAK",p)==0 )    /* for BackUp */
  1021.       {
  1022.         open_old_archive_1 (archive_name, &fp );
  1023.         return fp;
  1024.       }
  1025.     }
  1026.  
  1027.   if ( open_old_archive_1 (archive_name, &fp) )
  1028.         return fp;
  1029.   sprintf( expanded_archive_name , "%s.lzh",archive_name);
  1030.  
  1031.   if ( open_old_archive_1 (expanded_archive_name, &fp) )
  1032.   {
  1033.     archive_name = expanded_archive_name;
  1034.     return fp;
  1035.   }
  1036.   sprintf( expanded_archive_name, "%s.lzs",archive_name);
  1037.   if ( open_old_archive_1 (expanded_archive_name, &fp ) )
  1038.   {
  1039.       archive_name = expanded_archive_name;
  1040.     return fp;
  1041.   }
  1042.   return NULL;
  1043. }
  1044.  
  1045. int
  1046. inquire (msg, name, selective)
  1047.      char *msg, *name, *selective;
  1048. {
  1049.   char buffer[1024];
  1050.   char *p;
  1051.  
  1052.   for (;;)
  1053.     {
  1054.       fprintf (stderr, "%s %s ", name, msg);
  1055.       fflush (stderr);
  1056.  
  1057.       fgets (buffer, 1024, stdin);
  1058.  
  1059.       for (p = selective; *p; p++)
  1060.     if (buffer[0] == *p)
  1061.       return p - selective;
  1062.     }
  1063.   /*NOTREACHED*/
  1064. }
  1065.  
  1066. void
  1067. write_archive_tail (nafp)
  1068.      FILE *nafp;
  1069. {
  1070.   putc (0x00, nafp);
  1071. }
  1072.  
  1073. void
  1074. copy_old_one (oafp, nafp, hdr)
  1075.      FILE *oafp, *nafp;
  1076.      LzHeader *hdr;
  1077. {
  1078.   if (noexec)
  1079.     {
  1080.       fseek (oafp, (long)(hdr->header_size + 2) + hdr->packed_size, SEEK_CUR);
  1081.     }
  1082.   else
  1083.     {
  1084.       reading_filename = archive_name;
  1085.       writting_filename = temporary_name;
  1086.       copyfile (oafp, nafp, (long)(hdr->header_size + 2) + hdr->packed_size,0);
  1087.     }
  1088. }
  1089.  
  1090. /**************************************
  1091.  Added  31/8/1994  by Enrico Demarin
  1092. ***************************************/
  1093.  
  1094.  
  1095. int expand_wildcards(char *path,char *arg)
  1096. { 
  1097.     HDIR handle = HDIR_CREATE;
  1098.     FILEFINDBUF3 ffbuf;
  1099.     ULONG count = 1;
  1100.     ULONG len = CCHMAXPATH;
  1101.     char *filter;
  1102.     char *fullname;
  1103.     char **newptr;
  1104.     APIRET goon;
  1105.     
  1106.  
  1107.  
  1108.     if (!path) path="";
  1109.     
  1110.     filter=(char *)malloc(strlen(path)+strlen(arg)+4);
  1111.     if (!filter) return FALSE;
  1112.     
  1113.     
  1114.     strcpy(filter,path);
  1115.     strcat(filter,arg);
  1116.  
  1117.     
  1118.     goon = DosFindFirst(filter, &handle,
  1119.             file_mask, (void *) &ffbuf, sizeof(ffbuf), &count, FIL_STANDARD);
  1120.     
  1121.     
  1122.  
  1123.     while (goon==NO_ERROR)
  1124.     {
  1125.       fullname=(char *)malloc(strlen(path)+strlen(ffbuf.achName)+4);
  1126.      
  1127.      if (!fullname) { free(filter); return FALSE;  } 
  1128.     
  1129.      if (ffbuf.achName[0]!='.')
  1130.      { 
  1131.        if (ffbuf.attrFile & FILE_DIRECTORY)
  1132.         {
  1133.              if (recurse_subdirs)
  1134.              { 
  1135.              sprintf(fullname,"%s%s\\",path,ffbuf.achName);
  1136.              expand_wildcards(fullname,arg);
  1137.              }
  1138.         } 
  1139.         
  1140.         if ((!(ffbuf.attrFile & FILE_DIRECTORY))||(recurse_subdirs))
  1141.         {
  1142.          
  1143.          sprintf(fullname,"%s%s",path,ffbuf.achName);
  1144.          cmd_filec++;
  1145.          newptr=(char **)realloc((void *)cmd_filev,(sizeof(char *))*cmd_filec);
  1146.          cmd_filev=newptr;
  1147.          convert_slash(fullname);
  1148.           cmd_filev[cmd_filec-1]=fullname;
  1149.          fullname=NULL;         
  1150.  
  1151.          } else free(fullname);
  1152.       }     
  1153.         count = 1;
  1154.         goon = DosFindNext(handle, &ffbuf, sizeof(ffbuf), &count);
  1155.         
  1156.     }
  1157.    
  1158.    if (handle) DosFindClose(handle);
  1159.    if (filter) free(filter);
  1160.     
  1161.     
  1162.    switch (goon)
  1163.     { 
  1164.      case NO_ERROR:
  1165.      case ERROR_NO_MORE_FILES:
  1166.                  return TRUE;      
  1167.      default:
  1168.           fatal_error("LHA Error : filename not matched!");
  1169.      } 
  1170.  
  1171. }
  1172.  
  1173.  
  1174. void convert_slash(char *dest)
  1175. { 
  1176.  while (*dest) 
  1177.  { 
  1178.   if (*dest=='\\') *dest='/';
  1179.   dest++;
  1180.   }
  1181. }   
  1182.