src/lharc.c

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