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 Symbolic Link                1993.06.25  N.Watazaki      */
  32 /*  Ver. 1.11  for Symbolic 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 static int      cmd = CMD_UNKNOWN;
  48 static int error_occurred;
  49
  50 /* static functions */
  51 static void     sort_files();
  52 static void     print_version();
  53
  54 extern int optional_archive_kanji_code;
  55 extern int optional_system_kanji_code;
  56
  57 /* ------------------------------------------------------------------------ */
  58 static void
  59 init_variable()     /* Added N.Watazaki */
  60 {
  61 /* options */
  62     quiet           = FALSE;
  63     text_mode       = FALSE;
  64     verbose         = 0;
  65     noexec          = FALSE;    /* debugging option */
  66     force           = FALSE;
  67     timestamp_archive = FALSE;
  68
  69     compress_method = DEFAULT_LZHUFF_METHOD; /* defined in config.h */
  70
  71     header_level    = 2;        /* level 2 */
  72     quiet_mode      = 0;
  73
  74 #ifdef EUC
  75     euc_mode        = FALSE;
  76 #endif
  77
  78 /* view command flags */
  79     verbose_listing = FALSE;
  80
  81 /* extract command flags */
  82     output_to_stdout = FALSE;
  83
  84 /* append command flags */
  85     new_archive         = FALSE;
  86     update_if_newer     = FALSE;
  87     delete_after_append = FALSE;
  88     generic_format      = FALSE;
  89
  90     recover_archive_when_interrupt          = FALSE;
  91     remove_extracting_file_when_interrupt   = FALSE;
  92     get_filename_from_stdin                 = FALSE;
  93     ignore_directory                        = FALSE;
  94     exclude_files                           = NULL;
  95     verify_mode                             = FALSE;
  96
  97     convertcase                             = FALSE;
  98
  99     extract_directory = NULL;
 100     temporary_fd = -1;
 101
 102 #if BACKUP_OLD_ARCHIVE
 103     backup_old_archive = TRUE;
 104 #else
 105     backup_old_archive = FALSE;
 106 #endif
 107
 108     extract_broken_archive = FALSE;
 109     decode_macbinary_contents = FALSE;
 110     sort_contents = TRUE;
 111     recursive_archiving = TRUE;
 112     dump_lzss = FALSE;
 113 }
 114
 115 /* ------------------------------------------------------------------------ */
 116 /* NOTES :          Text File Format                                        */
 117 /* GENERATOR        NewLine                                                 */
 118 /* [generic]        0D 0A                                                   */
 119 /* [MS-DOS]         0D 0A                                                   */
 120 /* [OS9][MacOS]     0D                                                      */
 121 /* [UNIX]           0A                                                      */
 122 /* ------------------------------------------------------------------------ */
 123 static void
 124 print_tiny_usage()
 125 {
 126     fprintf(stdout, "\
 127 usage: lha [-]<commands>[<options>] [-<options> ...] archive_file [file...]\n\
 128   commands:  [axelvudmcpt]\n\
 129   options:   [q[012]vnfto[567]dizg012%s%s[w=<dir>|x=<pattern>]]\n\
 130   long options: --system-kanji-code={euc,sjis,utf8,cap}\n\
 131                 --archive-kanji-code={euc,sjis,utf8,cap}\n\
 132                 --extract-broken-archive\n\
 133                 --convert-filename-case\n\
 134                 --ignore-mac-files\n\
 135                 --timestamp-archive\n\
 136                 --traditional\n\
 137                 --help\n\
 138                 --version\n"
 139 #ifdef EUC
 140             ,"e"
 141 #else
 142             ,""
 143 #endif
 144 #if HAVE_LIBAPPLEFILE
 145             ,"b"                 /* decode_macbinary_contents */
 146 #else
 147             ,""
 148 #endif
 149             );
 150 }
 151
 152 static void
 153 print_usage()
 154 {
 155     fprintf(stdout, "\
 156 LHarc    for UNIX  V 1.02  Copyright(C) 1989  Y.Tagawa\n\
 157 LHx      for MSDOS V C2.01 Copyright(C) 1990  H.Yoshizaki\n\
 158 LHx(arc) for OSK   V 2.01  Modified     1990  Momozou\n\
 159 LHa      for UNIX  V 1.00  Copyright(C) 1992  Masaru Oki\n\
 160 LHa      for UNIX  V 1.14  Modified     1995  Nobutaka Watazaki\n\
 161 LHa      for UNIX  V 1.14i Modified     2000  Tsugio Okamoto\n\
 162 LHA-PMA  for UNIX  V 2     PMA added    2000  Maarten ter Huurne\n\
 163                    Autoconfiscated 2001-2008  Koji Arai\n\
 164 ");
 165
 166     print_tiny_usage();
 167
 168     fprintf(stdout, "\
 169 commands:                           options:\n\
 170  a   Add(or replace) to archive      q{num} quiet (num:quiet mode)\n\
 171  x,e EXtract from archive            v  verbose\n\
 172  l,v List / Verbose List             n  not execute\n\
 173  u   Update newer files to archive   f  force (over write at extract)\n\
 174  d   Delete from archive             t  FILES are TEXT file\n");
 175 #ifdef SUPPORT_LH7
 176     fprintf(stdout, "\
 177  m   Move to archive (means 'ad')    o[567] compression method (a/u/c)\n\
 178 ");
 179 #endif
 180 #ifndef SUPPORT_LH7
 181     fprintf(stdout, "\
 182  m   Move to archive (means 'ad')    o  use LHarc compatible method (a/u/c)\n\
 183 ");
 184 #endif
 185     fprintf(stdout, "\
 186  c   re-Construct new archive        d  delete FILES after (a/u/c)\n\
 187  p   Print to STDOUT from archive    i  ignore directory path (x/e)\n\
 188  t   Test file CRC in archive        z  files not compress (a/u/c)\n\
 189                                      g  Generic format (for compatibility)\n\
 190                                      0/1/2 header level (a/u/c)\n\
 191 ");
 192 #ifdef EUC
 193     fprintf(stdout, "\
 194                                      e  TEXT code convert from/to EUC\n\
 195 ");
 196 #endif
 197 #if HAVE_LIBAPPLEFILE
 198     fprintf(stdout, "\
 199                                      b  decode MacBinary (x/e)\n\
 200 ");
 201 #endif
 202     fprintf(stdout, "\
 203                                      w=<dir> specify extract directory (x/e)\n\
 204                                      x=<pattern>  eXclude files (a/u/c)\n\
 205 ");
 206 }
 207
 208 #include "getopt_long.h"
 209
 210 /*
 211   Parse LHA options
 212 */
 213 static int
 214 parse_suboption(int argc, char **argv)
 215 {
 216     enum {
 217         HELP_OPTION = 256,
 218         VERSION_OPTION,
 219         SYSTEM_KANJI_CODE_OPTION,
 220         ARCHIVE_KANJI_CODE_OPTION,
 221         TRADITIONAL_BEHAVIOR,
 222         IGNORE_MAC_FILES,
 223         DEBUG_OPTION,
 224     };
 225
 226     struct option long_options[] = {
 227         /* These options set a flag. */
 228         {"help",    no_argument,       0, HELP_OPTION},
 229         {"version", no_argument,       0, VERSION_OPTION},
 230
 231         {"system-kanji-code", required_argument, 0, SYSTEM_KANJI_CODE_OPTION},
 232         {"archive-kanji-code", required_argument, 0, ARCHIVE_KANJI_CODE_OPTION},
 233         {"extract-broken-archive", no_argument, &extract_broken_archive, 1},
 234         {"convert-filename-case", no_argument, &convertcase, TRUE},
 235         {"traditional", no_argument, 0, TRADITIONAL_BEHAVIOR},
 236         {"ignore-mac-files", no_argument, 0, IGNORE_MAC_FILES},
 237         {"timestamp-archive", no_argument, &timestamp_archive, 1},
 238         {"debug", required_argument, 0, DEBUG_OPTION},
 239         {0, 0, 0, 0}
 240     };
 241     int i;
 242
 243     char short_options[256] = "q[012]vnfto[567]dizg012ew:x:";
 244     /* "[...]" means optional 1 byte argument (original extention) */
 245
 246 #if HAVE_LIBAPPLEFILE
 247     strncat(short_options, "b", sizeof(short_options)-strlen(short_options)-1);
 248 #endif
 249
 250     /* parse option */
 251     while (1) {
 252         int option_index = 0;
 253         int c = getopt_long(argc, argv,
 254                             short_options, long_options,
 255                             &option_index);
 256
 257         if (c == -1) break;     /* end of options */
 258
 259         switch (c) {
 260         case 0:
 261             /* Already set a flag variable by the definition of the
 262                long_options. */
 263             break;
 264         case '?':
 265             /* Invalid option */
 266             print_tiny_usage();
 267             exit(2);
 268         case HELP_OPTION:
 269             print_usage();
 270             exit(0);
 271         case VERSION_OPTION:
 272             print_version();
 273             exit(0);
 274         case 'q':
 275             if (!optarg) {
 276                 /* In quiet mode, no confirm to overwrite */
 277                 force = TRUE;
 278                 quiet = TRUE;
 279                 break;
 280             }
 281
 282             switch (*optarg) {
 283             case '0':           /* no quiet */
 284             case '1':           /* no use the incremental indicator */
 285                 quiet_mode = *optarg - '0';
 286                 break;
 287             case '2':           /* no output */
 288                 /* fall through */
 289             default:
 290                 force = TRUE;
 291                 quiet = TRUE;
 292                 break;
 293             }
 294             break;
 295         case 'f':
 296             force = TRUE;
 297             break;
 298         case 'v':
 299             verbose++;
 300             break;
 301         case 't':
 302             text_mode = TRUE;
 303             break;
 304 #ifdef EUC
 305         case 'e':
 306             text_mode = TRUE;
 307             euc_mode = TRUE;
 308             break;
 309 #endif
 310 #if HAVE_LIBAPPLEFILE
 311         case 'b':
 312             decode_macbinary_contents = TRUE;
 313             break;
 314 #endif
 315         case 'n':
 316             noexec = TRUE;
 317             break;
 318         case 'g':
 319             generic_format = TRUE;
 320             header_level = 0;
 321             break;
 322         case 'd':
 323             delete_after_append = TRUE;
 324             break;
 325         case 'o':
 326             if (!optarg) {
 327                 compress_method = LZHUFF1_METHOD_NUM;
 328                 header_level = 0;
 329                 break;
 330             }
 331             switch (*optarg) {
 332             case '5':
 333                 compress_method = LZHUFF5_METHOD_NUM;
 334                 break;
 335 #ifdef SUPPORT_LH7
 336             case '6':
 337                 compress_method = LZHUFF6_METHOD_NUM;
 338                 break;
 339             case '7':
 340                 compress_method = LZHUFF7_METHOD_NUM;
 341                 break;
 342 #endif
 343             default:
 344                 error("invalid compression method 'o%c'", *optarg);
 345                 return -1;
 346             }
 347             break;
 348         case 'z':
 349             compress_method = LZHUFF0_METHOD_NUM;   /* Changed N.Watazaki */
 350             break;
 351         case 'i':
 352             ignore_directory = TRUE;
 353             break;
 354         case 'x':
 355             if (!optarg) {
 356                 error("exclude files does not specified for `-x'");
 357                 exit(2);
 358             }
 359
 360             for (i = 0; exclude_files && exclude_files[i]; i++)
 361                 ;
 362             exclude_files = (char**)xrealloc(exclude_files,
 363                                              sizeof(char*) * (i+2));
 364
 365             if (*optarg == '=')
 366                 optarg++;
 367             exclude_files[i] = optarg;
 368             exclude_files[i+1] = 0;
 369
 370             break;
 371         case 'w':
 372             if (!optarg) {
 373                 error("working directory does not specified for `-w'");
 374                 exit(2);
 375             }
 376             if (*optarg == '=')
 377                 optarg++;
 378
 379             extract_directory = optarg;
 380             break;
 381         case '0':
 382             header_level = 0;
 383             break;
 384         case '1':
 385             header_level = 1;
 386             break;
 387         case '2':
 388             header_level = 2;
 389             break;
 390         case SYSTEM_KANJI_CODE_OPTION:
 391             if (!optarg) {
 392                 error("kanji code not specified for --%s",
 393                       long_options[option_index].name);
 394                 return -1;
 395             }
 396             if (strcmp(optarg, "euc") == 0) {
 397                 optional_system_kanji_code = CODE_EUC;
 398             }
 399             else if (strcmp(optarg, "sjis") == 0) {
 400                 optional_system_kanji_code = CODE_SJIS;
 401             }
 402             else if (strcmp(optarg, "utf8") == 0) {
 403                 optional_system_kanji_code = CODE_UTF8;
 404             }
 405             else if (strcmp(optarg, "cap") == 0) {
 406                 optional_system_kanji_code = CODE_CAP;
 407             }
 408             else {
 409                 error("unknown kanji code \"%s\"", optarg);
 410                 return -1;
 411             }
 412             break;
 413
 414         case ARCHIVE_KANJI_CODE_OPTION:
 415             if (!optarg) {
 416                 error("kanji code not specified for --%s",
 417                       long_options[option_index].name);
 418                 return -1;
 419             }
 420             if (strcmp(optarg, "euc") == 0) {
 421                 optional_archive_kanji_code = CODE_EUC;
 422             }
 423             else if (strcmp(optarg, "sjis") == 0) {
 424                 optional_archive_kanji_code = CODE_SJIS;
 425             }
 426             else if (strcmp(optarg, "utf8") == 0) {
 427                 optional_archive_kanji_code = CODE_UTF8;
 428             }
 429             else if (strcmp(optarg, "cap") == 0) {
 430                 optional_archive_kanji_code = CODE_CAP;
 431             }
 432             else {
 433                 error("unknown kanji code \"%s\"", optarg);
 434                 return -1;
 435             }
 436             break;
 437
 438         case TRADITIONAL_BEHAVIOR:
 439             convertcase = TRUE;
 440             break;
 441
 442         case IGNORE_MAC_FILES:
 443             /* ignore Mac specific files (._*, .DS_Store and Icon\r)
 444                when archiving */
 445             for (i = 0; exclude_files && exclude_files[i]; i++)
 446                 ;
 447             exclude_files = (char**)xrealloc(exclude_files,
 448                                              sizeof(char*) * (i+4));
 449
 450             exclude_files[i] = xstrdup("._*");
 451             exclude_files[i+1] = xstrdup(".DS_Store");
 452             exclude_files[i+2] = xstrdup("Icon\r");
 453             exclude_files[i+3] = 0;
 454             break;
 455
 456         case DEBUG_OPTION:
 457             if (!optarg) {
 458                 error("debugging item is not specified for --%s",
 459                       long_options[option_index].name);
 460                 return -1;
 461             }
 462             if (strcmp(optarg, "nosort") == 0) {
 463                 sort_contents = FALSE;
 464             }
 465             else if (strcmp(optarg, "norecursion") == 0) {
 466                 recursive_archiving = FALSE;
 467             }
 468             else if (strcmp(optarg, "dumplzss") == 0) {
 469                 dump_lzss = TRUE;
 470                 quiet = TRUE;
 471             }
 472             else {
 473                 error("unknown debugging item \"%s\" for --%s",
 474                       optarg, long_options[option_index].name);
 475                 return -1;
 476             }
 477             break;
 478
 479         default:
 480             error("unknown option `-%c'.", c);
 481             return -1;
 482         }
 483     }
 484
 485     argc -= optind;
 486     argv += optind;
 487
 488     if (!archive_name) {
 489         archive_name = *argv++;
 490         argc--;
 491     }
 492
 493     cmd_filec = argc;
 494     cmd_filev = argv;
 495
 496     return 0;
 497 }
 498
 499 /*
 500   Parse LHA command and options.
 501 */
 502 static int
 503 parse_option(int argc, char **argv)
 504 {
 505     char *cmd_char;
 506
 507     if (argv[1] == NULL || strcmp(argv[1], "--help") == 0) {
 508         print_usage();
 509         exit(0);
 510     }
 511
 512     if (strcmp(argv[1], "--version") == 0) {
 513         print_version();
 514         exit(0);
 515     }
 516
 517     if (argc == 2 && *argv[1] != '-') {
 518         archive_name = argv[1];
 519         cmd = CMD_LIST;
 520         cmd_filec = 0;
 521         cmd_filev = 0;
 522         return 0;
 523     }
 524
 525     cmd_char = argv[1];
 526
 527     if (cmd_char[0] == '-')
 528         cmd_char++;
 529
 530     /* parse commands */
 531     switch (*cmd_char) {
 532     case 'x':
 533     case 'e':
 534         cmd = CMD_EXTRACT;
 535         break;
 536
 537     case 'p':
 538         output_to_stdout = TRUE;
 539         cmd = CMD_EXTRACT;
 540         break;
 541
 542     case 'c':
 543         new_archive = TRUE;
 544         cmd = CMD_ADD;
 545         break;
 546
 547     case 'a':
 548         cmd = CMD_ADD;
 549         break;
 550
 551     case 'd':
 552         cmd = CMD_DELETE;
 553         break;
 554
 555     case 'u':
 556         update_if_newer = TRUE;
 557         cmd = CMD_ADD;
 558         break;
 559
 560     case 'm':
 561         delete_after_append = TRUE;
 562         cmd = CMD_ADD;
 563         break;
 564
 565     case 'v':
 566         verbose_listing = TRUE;
 567         cmd = CMD_LIST;
 568         break;
 569
 570     case 'l':
 571         cmd = CMD_LIST;
 572         break;
 573
 574     case 't':
 575         cmd = CMD_EXTRACT;
 576         verify_mode = TRUE;
 577         break;
 578
 579     default:
 580         error("unknown command `-%c'", *cmd_char);
 581         return -1;
 582     }
 583
 584     if (cmd_char[1] == '\0') {
 585         /* argv[1] is command name */
 586         argv[1] = argv[0];
 587         argv++;
 588         argc--;
 589     }
 590     else {
 591         /* Eliminate command character
 592            e.g.) lha  cv foo.lzh -> lha -v foo.lzh
 593                  lha -cv foo.lzh -> lha -v foo.lzh
 594         */
 595         cmd_char[0] = '-';
 596         argv[1] = cmd_char;
 597     }
 598
 599     return parse_suboption(argc, argv);
 600 }
 601
 602 /* ------------------------------------------------------------------------ */
 603 int
 604 main(argc, argv)
 605     int             argc;
 606     char           *argv[];
 607 {
 608     char           *p;
 609
 610     int i;
 611
 612     init_variable();        /* Added N.Watazaki */
 613
 614     if (parse_option(argc, argv) == -1) {
 615         fputs("\n", stderr);
 616         print_tiny_usage();
 617         exit(2);
 618     }
 619
 620     if (!archive_name) {
 621         error("archive file does not specified");
 622         fputs("\n", stderr);
 623         print_tiny_usage();
 624         exit(2);
 625     }
 626
 627     if (!strcmp(archive_name, "-")) {
 628         if (!isatty(1) && cmd == CMD_ADD)
 629             quiet = TRUE;
 630     }
 631 #if 0 /* Comment out; IMHO, this feature is useless. by Koji Arai */
 632     else {
 633         if (argc == 3 && !isatty(0)) { /* 1999.7.18 */
 634             /* Bug(?) on MinGW, isatty() return 0 on Cygwin console.
 635                mingw-runtime-1.3-2 and Cygwin 1.3.10(0.51/3/2) on Win2000 */
 636             get_filename_from_stdin = TRUE;
 637         }
 638     }
 639 #endif
 640
 641     /* target file name */
 642     if (get_filename_from_stdin) {
 643         char inpbuf[4096];
 644         char **xfilev;
 645         int xfilec = 257;
 646
 647         cmd_filec = 0;
 648         xfilev = (char **)xmalloc(sizeof(char *) * xfilec);
 649         while (fgets(inpbuf, sizeof(inpbuf), stdin)) {
 650             /* delete \n if it exist */
 651             i=0; p=inpbuf;
 652             while (i < sizeof(inpbuf) && p != 0) {
 653                 if (*p == '\n') {
 654                     *p = 0;
 655                     break;
 656                 }
 657                 p++; i++;
 658             }
 659
 660             if (cmd_filec >= xfilec) {
 661                 xfilec += 256;
 662                 xfilev = (char **) xrealloc(xfilev,
 663                            sizeof(char *) * xfilec);
 664             }
 665             if (strlen(inpbuf) < 1)
 666                 continue;
 667             xfilev[cmd_filec++] = xstrdup(inpbuf);
 668         }
 669         xfilev[cmd_filec] = NULL;
 670         cmd_filev = xfilev;
 671     }
 672
 673     sort_files();
 674
 675     /* make crc table */
 676     make_crctable();
 677
 678     switch (cmd) {
 679     case CMD_EXTRACT:
 680         cmd_extract();
 681         break;
 682     case CMD_ADD:
 683         cmd_add();
 684         break;
 685     case CMD_LIST:
 686         cmd_list();
 687         break;
 688     case CMD_DELETE:
 689         cmd_delete();
 690         break;
 691     }
 692
 693     if (error_occurred)
 694         return 1;
 695     return 0;
 696 }
 697
 698
 699 /* ------------------------------------------------------------------------ */
 700 static void
 701 print_version()
 702 {
 703     /* macro PACKAGE_NAME, PACKAGE_VERSION and PLATFORM are
 704        defined in config.h by configure script */
 705     fprintf(stderr, "%s version %s (%s)\n",
 706             PACKAGE_NAME, PACKAGE_VERSION, PLATFORM);
 707     fprintf(stderr, "  configure options: %s\n", LHA_CONFIGURE_OPTIONS);
 708 }
 709
 710 void
 711 #if STDC_HEADERS
 712 message(char *fmt, ...)
 713 #else
 714 message(fmt, va_alist)
 715     char *fmt;
 716     va_dcl
 717 #endif
 718 {
 719     int errno_sv = errno;
 720     va_list v;
 721
 722     fprintf(stderr, "LHa: ");
 723
 724     va_init(v, fmt);
 725     vfprintf(stderr, fmt, v);
 726     va_end(v);
 727
 728     fputs("\n", stderr);
 729
 730     errno =  errno_sv;
 731 }
 732
 733 /* ------------------------------------------------------------------------ */
 734 void
 735 #if STDC_HEADERS
 736 warning(char *fmt, ...)
 737 #else
 738 warning(fmt, va_alist)
 739     char *fmt;
 740     va_dcl
 741 #endif
 742 {
 743     int errno_sv = errno;
 744     va_list v;
 745
 746     fprintf(stderr, "LHa: Warning: ");
 747
 748     va_init(v, fmt);
 749     vfprintf(stderr, fmt, v);
 750     va_end(v);
 751
 752     fputs("\n", stderr);
 753
 754     errno =  errno_sv;
 755 }
 756
 757 /* ------------------------------------------------------------------------ */
 758 void
 759 #if STDC_HEADERS
 760 error(char *fmt, ...)
 761 #else
 762 error(fmt, va_alist)
 763     char *fmt;
 764     va_dcl
 765 #endif
 766 {
 767     int errno_sv = errno;
 768     va_list v;
 769
 770     fprintf(stderr, "LHa: Error: ");
 771
 772     va_init(v, fmt);
 773     vfprintf(stderr, fmt, v);
 774     va_end(v);
 775
 776     fputs("\n", stderr);
 777
 778     error_occurred = 1;
 779
 780     errno =  errno_sv;
 781 }
 782
 783 void
 784 #if STDC_HEADERS
 785 fatal_error(char *fmt, ...)
 786 #else
 787 fatal_error(fmt, va_alist)
 788     char *fmt;
 789     va_dcl
 790 #endif
 791 {
 792     int errno_sv = errno;
 793     va_list v;
 794
 795     fprintf(stderr, "LHa: Fatal error: ");
 796
 797     va_init(v, fmt);
 798     vfprintf(stderr, fmt, v);
 799     va_end(v);
 800
 801     if (errno)
 802         fprintf(stderr, ": %s\n", strerror(errno_sv));
 803     else
 804         fputs("\n", stderr);
 805
 806     exit(1);
 807 }
 808
 809 void
 810 cleanup()
 811 {
 812     if (temporary_fd != -1) {
 813         close(temporary_fd);
 814         temporary_fd = -1;
 815         unlink(temporary_name);
 816     }
 817
 818     if (recover_archive_when_interrupt) {
 819         rename(backup_archive_name, archive_name);
 820         recover_archive_when_interrupt = FALSE;
 821     }
 822     if (remove_extracting_file_when_interrupt) {
 823         message("Removing: %s", writing_filename);
 824         unlink(writing_filename);
 825         remove_extracting_file_when_interrupt = FALSE;
 826     }
 827 }
 828
 829 RETSIGTYPE
 830 interrupt(signo)
 831     int signo;
 832 {
 833     message("Interrupted");
 834
 835     cleanup();
 836
 837     signal(SIGINT, SIG_DFL);
 838 #ifdef SIGHUP
 839     signal(SIGHUP, SIG_DFL);
 840 #endif
 841     kill(getpid(), signo);
 842 }
 843
 844 /* ------------------------------------------------------------------------ */
 845 /*                                                                          */
 846 /* ------------------------------------------------------------------------ */
 847 static int
 848 sort_by_ascii(a, b)
 849     char          **a, **b;
 850 {
 851     register char  *p, *q;
 852     register int    c1, c2;
 853
 854     p = *a, q = *b;
 855     if (generic_format) {
 856         do {
 857             c1 = *(unsigned char *) p++;
 858             c2 = *(unsigned char *) q++;
 859             if (!c1 || !c2)
 860                 break;
 861             if (islower(c1))
 862                 c1 = toupper(c1);
 863             if (islower(c2))
 864                 c2 = toupper(c2);
 865         }
 866         while (c1 == c2);
 867         return c1 - c2;
 868     }
 869     else {
 870         while (*p == *q && *p != '\0')
 871             p++, q++;
 872         return *(unsigned char *) p - *(unsigned char *) q;
 873     }
 874 }
 875
 876 /* ------------------------------------------------------------------------ */
 877 static void
 878 sort_files()
 879 {
 880     if (cmd_filec > 1 && sort_contents)
 881         qsort(cmd_filev, cmd_filec, sizeof(char *), sort_by_ascii);
 882 }
 883
 884 /* ------------------------------------------------------------------------ */
 885 void *
 886 xmalloc(size)
 887     size_t size;
 888 {
 889     void *p = malloc(size);
 890     if (!p)
 891         fatal_error("Not enough memory");
 892     return p;
 893 }
 894
 895 /* ------------------------------------------------------------------------ */
 896 void *
 897 xrealloc(old, size)
 898     void *old;
 899     size_t size;
 900 {
 901     void *p = (char *) realloc(old, size);
 902     if (!p)
 903         fatal_error("Not enough memory");
 904     return p;
 905 }
 906
 907 char *
 908 xstrdup(str)
 909     char *str;
 910 {
 911     int len = strlen(str);
 912     char *p = (char *)xmalloc(len + 1);
 913     strcpy(p, str);             /* ok */
 914     return p;
 915 }
 916
 917 /* ------------------------------------------------------------------------ */
 918 /*                              STRING POOL                                 */
 919 /* ------------------------------------------------------------------------ */
 920 /*
 921   string pool :
 922     +-------------+-------------+------+-------------+----------+
 923     | N A M E 1 \0| N A M E 2 \0| .... | N A M E n \0|          |
 924     +-------------+-------------+------+-------------+----------+
 925       ^ ^        ^ buffer+0 buffer+used buffer+size
 926
 927   vector :
 928     +---------------+---------------+------------- -----------------+
 929     | pointer to    | pointer to    | pointer to   ...  pointer to  |
 930     |  stringpool   |  N A M E 1    |  N A M E 2   ...   N A M E n  |
 931     +---------------+---------------+-------------     -------------+
 932     ^ malloc base      returned
 933 */
 934
 935 /* ------------------------------------------------------------------------ */
 936 void
 937 init_sp(sp)
 938     struct string_pool *sp;
 939 {
 940     sp->size = 1024 - 8;    /* any ( >=0 ) */
 941     sp->used = 0;
 942     sp->n = 0;
 943     sp->buffer = (char *) xmalloc(sp->size * sizeof(char));
 944 }
 945
 946 /* ------------------------------------------------------------------------ */
 947 void
 948 add_sp(sp, name, len)
 949     struct string_pool *sp;
 950     char           *name;   /* stored '\0' at tail */
 951     int             len;    /* include '\0' */
 952 {
 953     while (sp->used + len > sp->size) {
 954         sp->size *= 2;
 955         sp->buffer = (char *) xrealloc(sp->buffer, sp->size * sizeof(char));
 956     }
 957     memmove(sp->buffer + sp->used, name, len);
 958     sp->used += len;
 959     sp->n++;
 960 }
 961
 962 /* ------------------------------------------------------------------------ */
 963 void
 964 finish_sp(sp, v_count, v_vector)
 965     register struct string_pool *sp;
 966     int            *v_count;
 967     char         ***v_vector;
 968 {
 969     int             i;
 970     register char  *p;
 971     char          **v;
 972
 973     v = (char **) xmalloc((sp->n + 1) * sizeof(char *));
 974     *v++ = sp->buffer;
 975     *v_vector = v;
 976     *v_count = sp->n;
 977     p = sp->buffer;
 978     for (i = sp->n; i; i--) {
 979         *v++ = p;
 980         if (i - 1)
 981             p += strlen(p) + 1;
 982     }
 983 }
 984
 985 /* ------------------------------------------------------------------------ */
 986 void
 987 free_sp(vector)
 988     char          **vector;
 989 {
 990     vector--;
 991     free(*vector);      /* free string pool */
 992     free(vector);
 993 }
 994
 995
 996 /* ------------------------------------------------------------------------ */
 997 /*                          READ DIRECTORY FILES                            */
 998 /* ------------------------------------------------------------------------ */
 999 static          boolean
1000 include_path_p(path, name)
1001     char           *path, *name;
1002 {
1003     char           *n = name;
1004     while (*path)
1005         if (*path++ != *n++)
1006             return (path[-1] == '/' && *n == '\0');
1007     return (*n == '/' || (n != name && path[-1] == '/' && n[-1] == '/'));
1008 }
1009
1010 /* ------------------------------------------------------------------------ */
1011 void
1012 cleaning_files(v_filec, v_filev)
1013     int            *v_filec;
1014     char         ***v_filev;
1015 {
1016     char           *flags;
1017     struct stat     stbuf;
1018
1019     register char **filev = *v_filev;
1020     register int    filec = *v_filec;
1021     register char  *p;
1022     register int    i, j;
1023
1024     if (filec == 0)
1025         return;
1026
1027     flags = xmalloc(filec * sizeof(char));
1028
1029     /* flags & 0x01 :   1: ignore */
1030     /* flags & 0x02 :   1: directory, 0 : regular file */
1031     /* flags & 0x04 :   1: need delete */
1032
1033     for (i = 0; i < filec; i++)
1034         if (GETSTAT(filev[i], &stbuf) < 0) {
1035             flags[i] = 0x04;
1036             warning("Cannot access \"%s\" : %s; ignored.", filev[i],
1037                     strerror(errno));
1038         }
1039         else {
1040             if (is_regularfile(&stbuf))
1041                 flags[i] = 0x00;
1042             else if (is_directory(&stbuf))
1043                 flags[i] = 0x02;
1044 #ifdef S_IFLNK
1045             else if (is_symlink(&stbuf)) /* t.okamoto */
1046                 flags[i] = 0x00;
1047 #endif
1048             else {
1049                 flags[i] = 0x04;
1050                 warning("Cannot archive \"%s\", ignored.", filev[i]);
1051             }
1052         }
1053
1054     for (i = 0; i < filec; i++) {
1055         p = filev[i];
1056         if ((flags[i] & 0x07) == 0x00) {    /* regular file, not
1057                              * deleted/ignored */
1058             for (j = i + 1; j < filec; j++) {
1059                 if ((flags[j] & 0x07) == 0x00) {    /* regular file, not
1060                                      * deleted/ignored */
1061                     if (STREQU(p, filev[j]))
1062                         flags[j] = 0x04;    /* delete */
1063                 }
1064             }
1065         }
1066         else if ((flags[i] & 0x07) == 0x02) {   /* directory, not
1067                              * deleted/ignored */
1068             for (j = i + 1; j < filec; j++) {
1069                 if ((flags[j] & 0x07) == 0x00) {    /* regular file, not
1070                                      * deleted/ignored */
1071                     if (include_path_p(p, filev[j]))
1072                         flags[j] = 0x04;    /* delete */
1073                 }
1074                 else if ((flags[j] & 0x07) == 0x02) {   /* directory, not
1075                                      * deleted/ignored */
1076                     if (include_path_p(p, filev[j]))
1077                         flags[j] = 0x04;    /* delete */
1078                 }
1079             }
1080         }
1081     }
1082
1083     for (i = j = 0; i < filec; i++) {
1084         if ((flags[i] & 0x04) == 0) {
1085             if (i != j)
1086                 filev[j] = filev[i];
1087             j++;
1088         }
1089     }
1090     *v_filec = j;
1091
1092     free(flags);
1093 }
1094
1095 /* ------------------------------------------------------------------------ */
1096 boolean
1097 find_files(name, v_filec, v_filev)
1098     char           *name;
1099     int            *v_filec;
1100     char         ***v_filev;
1101 {
1102     struct string_pool sp;
1103     char            newname[FILENAME_LENGTH];
1104     int             len, n, i;
1105     DIR            *dirp;
1106     struct dirent  *dp;
1107     struct stat     tmp_stbuf, arc_stbuf, fil_stbuf;
1108     int exist_tmp = 1, exist_arc = 1;
1109
1110     len = str_safe_copy(newname, name, sizeof(newname));
1111     if (len > 0 && newname[len - 1] != '/') {
1112         if (len < sizeof(newname)-1)
1113             strcpy(&newname[len++], "/"); /* ok */
1114         else
1115             warning("the length of pathname \"%s\" is too long.", name);
1116     }
1117
1118     dirp = opendir(name);
1119     if (!dirp)
1120         return FALSE;
1121
1122     init_sp(&sp);
1123
1124     if (GETSTAT(temporary_name, &tmp_stbuf) == -1)
1125         exist_tmp = 0;
1126     if (GETSTAT(archive_name, &arc_stbuf) == -1)
1127         exist_arc = 0;
1128
1129     while ((dp = readdir(dirp)) != NULL) {
1130         n = NAMLEN(dp);
1131
1132         /* exclude '.' and '..' */
1133         if (strncmp(dp->d_name, ".", n) == 0
1134             || strncmp(dp->d_name, "..", n) == 0)
1135             continue;
1136
1137         /* exclude exclude_files supplied by user */
1138         for (i = 0; exclude_files && exclude_files[i]; i++) {
1139             if (fnmatch(exclude_files[i], dp->d_name,
1140                         FNM_PATHNAME|FNM_NOESCAPE|FNM_PERIOD) == 0)
1141                 goto next;
1142         }
1143
1144         if (len + n >= sizeof(newname)) {
1145             warning("filename is too long");
1146             continue;
1147         }
1148
1149         strncpy(newname + len, dp->d_name, n);
1150         newname[len + n] = '\0';
1151         if (GETSTAT(newname, &fil_stbuf) < 0)
1152             continue;
1153
1154 #if defined(HAVE_STRUCT_STAT_ST_INO) && !__MINGW32__
1155         /* MinGW has meaningless st_ino */
1156
1157         /* exclude temporary file, archive file and these links */
1158         if (exist_tmp &&
1159             tmp_stbuf.st_dev == fil_stbuf.st_dev &&
1160             tmp_stbuf.st_ino == fil_stbuf.st_ino)
1161             continue;
1162
1163         if (exist_arc &&
1164             arc_stbuf.st_dev == fil_stbuf.st_dev &&
1165             arc_stbuf.st_ino == fil_stbuf.st_ino)
1166             continue;
1167 #endif
1168         add_sp(&sp, newname, len+n+1);
1169     next:
1170         ;
1171     }
1172     closedir(dirp);
1173     finish_sp(&sp, v_filec, v_filev);
1174     if (*v_filec > 1 && sort_contents)
1175         qsort(*v_filev, *v_filec, sizeof(char *), sort_by_ascii);
1176     cleaning_files(v_filec, v_filev);
1177
1178     return TRUE;
1179 }
1180
1181 /* ------------------------------------------------------------------------ */
1182 void
1183 free_files(filec, filev)
1184     int             filec;
1185     char          **filev;
1186 {
1187     free_sp(filev);
1188 }
1189
1190 /* ------------------------------------------------------------------------ */
1191 /*                                                                          */
1192 /* ------------------------------------------------------------------------ */
1193 /* Build temporary file name and store to TEMPORARY_NAME */
1194 int
1195 build_temporary_name()
1196 {
1197 #ifdef TMP_FILENAME_TEMPLATE
1198     /* "/tmp/lhXXXXXX" etc. */
1199     if (extract_directory == NULL) {
1200         str_safe_copy(temporary_name, TMP_FILENAME_TEMPLATE,
1201                       sizeof(temporary_name));
1202     }
1203     else {
1204         xsnprintf(temporary_name, sizeof(temporary_name),
1205                   "%s/lhXXXXXX", extract_directory);
1206     }
1207 #else
1208     char *s;
1209
1210     str_safe_copy(temporary_name, archive_name, sizeof(temporary_name));
1211     s = strrchr(temporary_name, '/');
1212     if (s) {
1213         int len;
1214         len = s - temporary_name;
1215         if (len + strlen("lhXXXXXX") < sizeof(temporary_name))
1216             /* use directory at archive file */
1217             strcpy(s, "lhXXXXXX"); /* ok */
1218         else
1219             /* use current directory */
1220             str_safe_copy(temporary_name, "lhXXXXXX", sizeof(temporary_name));
1221     }
1222     else
1223         /* use current directory */
1224         str_safe_copy(temporary_name, "lhXXXXXX", sizeof(temporary_name));
1225 #endif
1226 #ifdef HAVE_MKSTEMP
1227     {
1228         int old_umask, fd;
1229
1230         old_umask = umask(077);
1231         fd = mkstemp(temporary_name);
1232         umask(old_umask);
1233         return fd;
1234     }
1235 #else
1236     {
1237         int flags;
1238
1239         mktemp(temporary_name);
1240         flags = O_CREAT|O_EXCL|O_RDWR;
1241 #ifdef O_BINARY
1242         flags |= O_BINARY;
1243 #endif
1244         return open(temporary_name, flags, 0600);
1245     }
1246 #endif
1247 }
1248
1249 /* ------------------------------------------------------------------------ */
1250 static void
1251 modify_filename_extention(buffer, ext, size)
1252     char           *buffer;
1253     char           *ext;
1254     size_t size;
1255 {
1256     register char  *p, *dot;
1257
1258     for (p = buffer, dot = (char *) 0; *p; p++) {
1259         if (*p == '.')
1260             dot = p;
1261         else if (*p == '/')
1262             dot = (char *) 0;
1263     }
1264
1265     if (dot)
1266         p = dot;
1267
1268     str_safe_copy(p, ext, size - (p - buffer));
1269 }
1270
1271 /* ------------------------------------------------------------------------ */
1272 /* build backup file name */
1273 void
1274 build_backup_name(buffer, original, size)
1275     char           *buffer;
1276     char           *original;
1277     size_t size;
1278 {
1279     str_safe_copy(buffer, original, size);
1280     modify_filename_extention(buffer, BACKUPNAME_EXTENTION, size);    /* ".bak" */
1281 }
1282
1283 /* ------------------------------------------------------------------------ */
1284 void
1285 build_standard_archive_name(buffer, original, size)
1286     char           *buffer;
1287     char           *original;
1288     size_t size;
1289 {
1290     str_safe_copy(buffer, original, size);
1291     modify_filename_extention(buffer, ARCHIVENAME_EXTENTION, size);   /* ".lzh" */
1292 }
1293
1294 /* ------------------------------------------------------------------------ */
1295 /*                                                                          */
1296 /* ------------------------------------------------------------------------ */
1297 boolean
1298 need_file(name)
1299     char           *name;
1300 {
1301     int             i;
1302
1303     if (cmd_filec == 0)
1304         return TRUE;
1305
1306     for (i = 0; i < cmd_filec; i++) {
1307         if (patmatch(cmd_filev[i], name, 0))
1308             return TRUE;
1309     }
1310
1311     return FALSE;
1312 }
1313
1314 FILE           *
1315 xfopen(name, mode)
1316     char           *name, *mode;
1317 {
1318     FILE           *fp;
1319
1320     if ((fp = fopen(name, mode)) == NULL)
1321         fatal_error("Cannot open file \"%s\"", name);
1322
1323     return fp;
1324 }
1325
1326 /* ------------------------------------------------------------------------ */
1327 /*                                                                          */
1328 /* ------------------------------------------------------------------------ */
1329 static          boolean
1330 open_old_archive_1(name, v_fp)
1331     char           *name;
1332     FILE          **v_fp;
1333 {
1334     FILE           *fp;
1335     struct stat     stbuf;
1336
1337     if (stat(name, &stbuf) >= 0 &&
1338         is_regularfile(&stbuf) &&
1339         (fp = fopen(name, READ_BINARY)) != NULL) {
1340         *v_fp = fp;
1341         archive_file_gid = stbuf.st_gid;
1342         archive_file_mode = stbuf.st_mode;
1343         return TRUE;
1344     }
1345
1346     *v_fp = NULL;
1347     archive_file_gid = -1;
1348     return FALSE;
1349 }
1350
1351 /* ------------------------------------------------------------------------ */
1352 FILE           *
1353 open_old_archive()
1354 {
1355     FILE           *fp = NULL;
1356     char           *p = NULL, *ext, *ext2;
1357     static char expanded_archive_name[FILENAME_LENGTH];
1358
1359     if (!strcmp(archive_name, "-")) {
1360         if (cmd == CMD_EXTRACT || cmd == CMD_LIST) {
1361 #if defined(__MINGW32__) || defined(__DJGPP__)
1362             setmode(fileno(stdin), O_BINARY);
1363 #endif
1364             return stdin;
1365         }
1366         else
1367             return NULL;
1368     }
1369
1370     ext2 = strrchr(archive_name, '.');
1371     if (ext2) {
1372         ext2++;
1373
1374         /* .com: DOS SFX
1375            .exe: DOS SFX
1376            .x:   HUMAN SFX
1377            .bak: Backup file
1378            .lha: Amiga(?) */
1379         p = xstrdup("lzh," ADDITIONAL_SUFFIXES);
1380         for (ext = strtok(p, ",");
1381              ext;
1382              ext = strtok(NULL, ",")) {
1383
1384             if (*ext == 0) continue;
1385
1386             if (strcasecmp(ext, ext2)) {
1387                 /* Try to open file just specified filename
1388                    with usual suffixes.
1389                    Return NULL if the file is not exist. */
1390
1391                 open_old_archive_1(archive_name, &fp);
1392                 goto ret;       /* found or not */
1393             }
1394         }
1395         free(p);
1396         p = NULL;
1397     }
1398
1399     /* Try to open file just specified filename */
1400     if (open_old_archive_1(archive_name, &fp))
1401         goto ret;               /* found */
1402
1403     /* Try to open file with implicit suffixes */
1404     p = xstrdup("lzh," ADDITIONAL_SUFFIXES);
1405     for (ext = strtok(p, ",");
1406          ext;
1407          ext = strtok(NULL, ",")) {
1408
1409         if (*ext == 0) continue;
1410
1411         xsnprintf(expanded_archive_name, sizeof(expanded_archive_name),
1412                   "%s.%s", archive_name, ext);
1413
1414         if (open_old_archive_1(expanded_archive_name, &fp)) {
1415             archive_name = expanded_archive_name;
1416             goto ret;           /* found */
1417         }
1418     }
1419
1420 ret:
1421     if (p) free(p);
1422     return fp;
1423 }
1424
1425 /* ------------------------------------------------------------------------ */
1426 int
1427 inquire(msg, name, selective)
1428     char           *msg, *name, *selective;
1429 {
1430     char            buffer[1024];
1431     char           *p;
1432
1433     for (;;) {
1434         fprintf(stderr, "%s %s ", name, msg);
1435         fflush(stderr);
1436
1437         fgets(buffer, 1024, stdin);
1438
1439         for (p = selective; *p; p++)
1440             if (buffer[0] == *p)
1441                 return p - selective;
1442     }
1443     /* NOTREACHED */
1444 }
1445
1446 /* ------------------------------------------------------------------------ */
1447 void
1448 write_archive_tail(nafp)
1449     FILE           *nafp;
1450 {
1451     putc(0x00, nafp);
1452 }
1453
1454 /* ------------------------------------------------------------------------ */
1455 #undef exit
1456
1457 void
1458 lha_exit(status)
1459     int status;
1460 {
1461     cleanup();
1462     exit(status);
1463 }