src/header.c

   1 /* ------------------------------------------------------------------------ */
   2 /* LHa for UNIX                                                             */
   3 /*              header.c -- header manipulate functions                     */
   4 /*                                                                          */
   5 /*      Modified                Nobutaka Watazaki                           */
   6 /*                                                                          */
   7 /*  Original                                                Y.Tagawa        */
   8 /*  modified                                    1991.12.16  M.Oki           */
   9 /*  Ver. 1.10  Symbolic Link added              1993.10.01  N.Watazaki      */
  10 /*  Ver. 1.13b Symbolic Link Bug Fix            1994.08.22  N.Watazaki      */
  11 /*  Ver. 1.14  Source All chagned               1995.01.14  N.Watazaki      */
  12 /*  Ver. 1.14i bug fixed                        2000.10.06  t.okamoto       */
  13 /*  Ver. 1.14i Contributed UTF-8 convertion for Mac OS X                    */
  14 /*                                              2002.06.29  Hiroto Sakai    */
  15 /*  Ver. 1.14i autoconfiscated & rewritten      2003.02.23  Koji Arai       */
  16 /* ------------------------------------------------------------------------ */
  17 #include "lha.h"
  18
  19 #define DUMP_HEADER 1           /* for debugging */
  20
  21 #if !STRCHR_8BIT_CLEAN
  22 /* should use 8 bit clean version */
  23 #undef strchr
  24 #undef strrchr
  25 #define strchr  xstrchr
  26 #define strrchr  xstrrchr
  27 #endif
  28
  29 static char    *get_ptr;
  30 static char    *start_ptr;
  31 static off_t   storage_size;
  32 #define setup_get(PTR, SIZE)  (start_ptr = get_ptr = (PTR), storage_size = (SIZE))
  33
  34 #if DUMP_HEADER
  35 #define get_byte()      dump_get_byte()
  36 #define skip_bytes(len) dump_skip_bytes(len)
  37 #else
  38 #define get_byte()      _get_byte()
  39 #define skip_bytes(len) _skip_bytes(len)
  40 #endif
  41 #define put_ptr         get_ptr
  42 #define setup_put(PTR)  (put_ptr = (PTR))
  43 #define put_byte(c)     (*put_ptr++ = (char)(c))
  44
  45 int optional_archive_kanji_code = NONE;
  46 int optional_system_kanji_code = NONE;
  47 char *optional_archive_delim = NULL;
  48 char *optional_system_delim = NULL;
  49 int optional_filename_case = NONE;
  50
  51 #ifdef MULTIBYTE_FILENAME
  52 int default_system_kanji_code = MULTIBYTE_FILENAME;
  53 #else
  54 int default_system_kanji_code = NONE;
  55 #endif
  56
  57 int
  58 calc_sum(p, len)
  59     void *p;
  60     int len;
  61 {
  62     int sum = 0;
  63     unsigned char *pc = (unsigned char*)p;
  64
  65     while (len--) sum += *pc++;
  66
  67     return sum & 0xff;
  68 }
  69
  70 static void
  71 _skip_bytes(len)
  72 {
  73     if (len < 0) {
  74       error("Invalid header: %d", len);
  75       exit(1);
  76     }
  77     get_ptr += len;
  78 }
  79
  80 static int
  81 _get_byte()
  82 {
  83   if (get_ptr < start_ptr || get_ptr - start_ptr >= storage_size) {
  84       error("Invalid header");
  85       exit(1);
  86   }
  87
  88   return (*get_ptr++ & 0xff);
  89 }
  90
  91 #if DUMP_HEADER
  92 static int
  93 dump_get_byte()
  94 {
  95     int c;
  96
  97     if (verbose_listing && verbose > 1)
  98         printf("%02d %2d: ", get_ptr - start_ptr, 1);
  99     c = _get_byte();
 100     if (verbose_listing && verbose > 1) {
 101         if (isprint(c))
 102             printf("%d(0x%02x) '%c'\n", c, c, c);
 103         else
 104             printf("%d(0x%02x)\n", c, c);
 105     }
 106     return c;
 107 }
 108
 109 static void
 110 dump_skip_bytes(len)
 111     int len;
 112 {
 113     if (len == 0) return;
 114     if (verbose_listing && verbose > 1) {
 115         printf("%02d %2d: ", get_ptr - start_ptr, len);
 116         if (len < 0) {
 117           error("Invalid header: %d", len);
 118           exit(1);
 119         }
 120         while (len--)
 121             printf("0x%02x ", _get_byte());
 122         printf("... ignored\n");
 123     }
 124     else
 125         _skip_bytes(len);
 126 }
 127 #endif
 128
 129 static int
 130 get_word()
 131 {
 132     int b0, b1;
 133     int w;
 134
 135 #if DUMP_HEADER
 136     if (verbose_listing && verbose > 1)
 137         printf("%02d %2d: ", get_ptr - start_ptr, 2);
 138 #endif
 139     b0 = _get_byte();
 140     b1 = _get_byte();
 141     w = (b1 << 8) + b0;
 142 #if DUMP_HEADER
 143     if (verbose_listing && verbose > 1)
 144         printf("%d(0x%04x)\n", w, w);
 145 #endif
 146     return w;
 147 }
 148
 149 static void
 150 put_word(v)
 151     unsigned int    v;
 152 {
 153     put_byte(v);
 154     put_byte(v >> 8);
 155 }
 156
 157 static long
 158 get_longword()
 159 {
 160     long b0, b1, b2, b3;
 161     long l;
 162
 163 #if DUMP_HEADER
 164     if (verbose_listing && verbose > 1)
 165         printf("%02d %2d: ", get_ptr - start_ptr, 4);
 166 #endif
 167     b0 = _get_byte();
 168     b1 = _get_byte();
 169     b2 = _get_byte();
 170     b3 = _get_byte();
 171     l = (b3 << 24) + (b2 << 16) + (b1 << 8) + b0;
 172 #if DUMP_HEADER
 173     if (verbose_listing && verbose > 1)
 174         printf("%ld(0x%08lx)\n", l, l);
 175 #endif
 176     return l;
 177 }
 178
 179 static void
 180 put_longword(long v)
 181 {
 182     put_byte(v);
 183     put_byte(v >> 8);
 184     put_byte(v >> 16);
 185     put_byte(v >> 24);
 186 }
 187
 188 #ifdef HAVE_UINT64_T
 189 static uint64_t
 190 get_longlongword()
 191 {
 192     uint64_t b0, b1, b2, b3, b4, b5, b6, b7;
 193     uint64_t l;
 194
 195 #if DUMP_HEADER
 196     if (verbose_listing && verbose > 1)
 197         printf("%02d %2d: ", get_ptr - start_ptr, 4);
 198 #endif
 199     b0 = _get_byte();
 200     b1 = _get_byte();
 201     b2 = _get_byte();
 202     b3 = _get_byte();
 203     b4 = _get_byte();
 204     b5 = _get_byte();
 205     b6 = _get_byte();
 206     b7 = _get_byte();
 207
 208     l = (b7 << 24) + (b6 << 16) + (b5 << 8) + b4;
 209     l <<= 32;
 210     l |= (b3 << 24) + (b2 << 16) + (b1 << 8) + b0;
 211 #if DUMP_HEADER
 212     if (verbose_listing && verbose > 1)
 213         printf("%lld(%#016llx)\n", l, l);
 214 #endif
 215     return l;
 216 }
 217
 218 static void
 219 put_longlongword(uint64_t v)
 220 {
 221     put_byte(v);
 222     put_byte(v >> 8);
 223     put_byte(v >> 16);
 224     put_byte(v >> 24);
 225     put_byte(v >> 32);
 226     put_byte(v >> 40);
 227     put_byte(v >> 48);
 228     put_byte(v >> 56);
 229 }
 230 #endif
 231
 232 static int
 233 get_bytes(buf, len, size)
 234     char *buf;
 235     int len, size;
 236 {
 237     int i;
 238
 239 #if DUMP_HEADER
 240     if (verbose_listing && verbose > 1)
 241         printf("%02d %2d: \"", get_ptr - start_ptr, len);
 242     if (len < 0) {
 243       error("Invalid header: %d", len);
 244       exit(1);
 245     }
 246
 247     for (i = 0; i < len; i++) {
 248         if (i < size) buf[i] = get_ptr[i];
 249
 250         if (verbose_listing && verbose > 1) {
 251             if (isprint(buf[i]))
 252                 printf("%c", buf[i]);
 253             else
 254                 printf("\\x%02x", (unsigned char)buf[i]);
 255         }
 256     }
 257
 258     if (verbose_listing && verbose > 1)
 259         printf("\"\n");
 260 #else
 261     if (len < 0) {
 262       error("Invalid header: %d", len);
 263       exit(1);
 264     }
 265     for (i = 0; i < len && i < size; i++)
 266         buf[i] = get_ptr[i];
 267 #endif
 268
 269     get_ptr += len;
 270     return i;
 271 }
 272
 273 static void
 274 put_bytes(buf, len)
 275     char *buf;
 276     int len;
 277 {
 278     int i;
 279     for (i = 0; i < len; i++)
 280         put_byte(buf[i]);
 281 }
 282
 283 /* added by Koji Arai */
 284 void
 285 convert_filename(name, len, size,
 286                  from_code, to_code,
 287                  from_delim, to_delim,
 288                  case_to)
 289     char *name;
 290     int len;                    /* length of name */
 291     int size;                   /* size of name buffer */
 292     int from_code, to_code, case_to;
 293     char *from_delim, *to_delim;
 294
 295 {
 296     int i;
 297 #ifdef MULTIBYTE_FILENAME
 298     char tmp[FILENAME_LENGTH];
 299     int to_code_save = NONE;
 300
 301     if (from_code == CODE_CAP) {
 302         len = cap_to_sjis(tmp, name, sizeof(tmp));
 303         strncpy(name, tmp, size);
 304         name[size-1] = 0;
 305         len = strlen(name);
 306         from_code = CODE_SJIS;
 307     }
 308
 309     if (to_code == CODE_CAP) {
 310         to_code_save = CODE_CAP;
 311         to_code = CODE_SJIS;
 312     }
 313 #endif
 314
 315     /* special case: if `name' has small lettter, not convert case. */
 316     if (from_code == CODE_SJIS && case_to == TO_LOWER) {
 317         for (i = 0; i < len; i++) {
 318 #ifdef MULTIBYTE_FILENAME
 319             if (SJIS_FIRST_P(name[i]) && SJIS_SECOND_P(name[i+1]))
 320                 i++;
 321             else
 322 #endif
 323             if (islower(name[i])) {
 324                 case_to = NONE;
 325                 break;
 326             }
 327         }
 328     }
 329
 330 #ifdef MULTIBYTE_FILENAME
 331     if (from_code == CODE_SJIS && to_code == CODE_UTF8) {
 332         for (i = 0; i < len; i++) {
 333             if (SJIS_FIRST_P(name[i]) && SJIS_SECOND_P(name[i+1]))
 334                 i++;
 335             else {
 336                 /* FIXME: provisionally fix for the Mac OS CoreFoundation */
 337                 if (strchr(from_delim, name[i]))
 338                     name[i] = '/';
 339             }
 340         }
 341         sjis_to_utf8(tmp, name, sizeof(tmp));
 342         strncpy(name, tmp, size);
 343         name[size-1] = 0;
 344         len = strlen(name);
 345         for (i = 0; i < len; i++)
 346             if (name[i] == '/')  name[i] = LHA_PATHSEP;
 347         from_code = CODE_UTF8;
 348     }
 349     else if (from_code == CODE_UTF8 && to_code == CODE_SJIS) {
 350         for (i = 0; i < len; i++)
 351             /* FIXME: provisionally fix for the Mac OS CoreFoundation */
 352             if ((unsigned char)name[i] == LHA_PATHSEP)  name[i] = '/';
 353         utf8_to_sjis(tmp, name, sizeof(tmp));
 354         strncpy(name, tmp, size);
 355         name[size-1] = 0;
 356         len = strlen(name);
 357         for (i = 0; i < len; i++)
 358             if (name[i] == '/')  name[i] = LHA_PATHSEP;
 359         from_code = CODE_SJIS;
 360     }
 361 #endif
 362
 363     for (i = 0; i < len; i ++) {
 364 #ifdef MULTIBYTE_FILENAME
 365         if (from_code == CODE_EUC &&
 366             (unsigned char)name[i] == 0x8e) {
 367             if (to_code != CODE_SJIS) {
 368                 i++;
 369                 continue;
 370             }
 371
 372             /* X0201 KANA */
 373             memmove(name + i, name + i + 1, len - i);
 374             len--;
 375             continue;
 376         }
 377         if (from_code == CODE_SJIS && X0201_KANA_P(name[i])) {
 378             if (to_code != CODE_EUC) {
 379                 continue;
 380             }
 381
 382             if (len == size - 1) /* check overflow */
 383                 len--;
 384             memmove(name+i+1, name+i, len-i);
 385             name[i] = 0x8e;
 386             i++;
 387             len++;
 388             continue;
 389         }
 390         if (from_code == CODE_EUC && (name[i] & 0x80) && (name[i+1] & 0x80)) {
 391             int c1, c2;
 392             if (to_code != CODE_SJIS) {
 393                 i++;
 394                 continue;
 395             }
 396
 397             c1 = (unsigned char)name[i];
 398             c2 = (unsigned char)name[i+1];
 399             euc2sjis(&c1, &c2);
 400             name[i] = c1;
 401             name[i+1] = c2;
 402             i++;
 403             continue;
 404         }
 405         if (from_code == CODE_SJIS &&
 406             SJIS_FIRST_P(name[i]) &&
 407             SJIS_SECOND_P(name[i+1])) {
 408             int c1, c2;
 409
 410             if (to_code != CODE_EUC) {
 411                 i++;
 412                 continue;
 413             }
 414
 415             c1 = (unsigned char)name[i];
 416             c2 = (unsigned char)name[i+1];
 417             sjis2euc(&c1, &c2);
 418             name[i] = c1;
 419             name[i+1] = c2;
 420             i++;
 421             continue;
 422         }
 423 #endif /* MULTIBYTE_FILENAME */
 424         {
 425             char *ptr;
 426
 427             /* transpose from_delim to to_delim */
 428
 429             if ((ptr = strchr(from_delim, name[i])) != NULL) {
 430                 name[i] = to_delim[ptr - from_delim];
 431                 continue;
 432             }
 433         }
 434
 435         if (case_to == TO_UPPER && islower(name[i])) {
 436             name[i] = toupper(name[i]);
 437             continue;
 438         }
 439         if (case_to == TO_LOWER && isupper(name[i])) {
 440             name[i] = tolower(name[i]);
 441             continue;
 442         }
 443     }
 444
 445 #ifdef MULTIBYTE_FILENAME
 446     if (to_code_save == CODE_CAP) {
 447         len = sjis_to_cap(tmp, name, sizeof(tmp));
 448         strncpy(name, tmp, size);
 449         name[size-1] = 0;
 450         len = strlen(name);
 451     }
 452 #endif /* MULTIBYTE_FILENAME */
 453 }
 454
 455 /*
 456  * Generic (MS-DOS style) time stamp format (localtime):
 457  *
 458  *  31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16
 459  * |<---- year-1980 --->|<- month ->|<--- day ---->|
 460  *
 461  *  15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0
 462  * |<--- hour --->|<---- minute --->|<- second/2 ->|
 463  *
 464  */
 465
 466 static time_t
 467 generic_to_unix_stamp(t)
 468     long t;
 469 {
 470     struct tm tm;
 471
 472 #define subbits(n, off, len) (((n) >> (off)) & ((1 << (len))-1))
 473
 474     tm.tm_sec  = subbits(t,  0, 5) * 2;
 475     tm.tm_min  = subbits(t,  5, 6);
 476     tm.tm_hour = subbits(t, 11, 5);
 477     tm.tm_mday = subbits(t, 16, 5);
 478     tm.tm_mon  = subbits(t, 21, 4) - 1;
 479     tm.tm_year = subbits(t, 25, 7) + 80;
 480     tm.tm_isdst = -1;
 481
 482 #if HAVE_MKTIME
 483     return mktime(&tm);
 484 #else
 485     return timelocal(&tm);
 486 #endif
 487 }
 488
 489 static long
 490 unix_to_generic_stamp(t)
 491     time_t t;
 492 {
 493     struct tm *tm = localtime(&t);
 494
 495     tm->tm_year -= 80;
 496     tm->tm_mon += 1;
 497
 498     return ((long)(tm->tm_year << 25) +
 499             (tm->tm_mon  << 21) +
 500             (tm->tm_mday << 16) +
 501             (tm->tm_hour << 11) +
 502             (tm->tm_min  << 5) +
 503             (tm->tm_sec / 2));
 504 }
 505
 506 static unsigned long
 507 wintime_to_unix_stamp()
 508 {
 509 #if HAVE_UINT64_T
 510     uint64_t t;
 511     uint64_t epoch = ((uint64_t)0x019db1de << 32) + 0xd53e8000;
 512                      /* 0x019db1ded53e8000ULL: 1970-01-01 00:00:00 (UTC) */
 513
 514     t = (unsigned long)get_longword();
 515     t |= (uint64_t)(unsigned long)get_longword() << 32;
 516     t = (t - epoch) / 10000000;
 517     return t;
 518 #else
 519     int i, borrow;
 520     unsigned long t, q, x;
 521     unsigned long wintime[8];
 522     unsigned long epoch[8] = {0x01,0x9d,0xb1,0xde, 0xd5,0x3e,0x80,0x00};
 523                                 /* 1970-01-01 00:00:00 (UTC) */
 524     /* wintime -= epoch */
 525     borrow = 0;
 526     for (i = 7; i >= 0; i--) {
 527         wintime[i] = (unsigned)get_byte() - epoch[i] - borrow;
 528         borrow = (wintime[i] > 0xff) ? 1 : 0;
 529         wintime[i] &= 0xff;
 530     }
 531
 532     /* q = wintime / 10000000 */
 533     t = q = 0;
 534     x = 10000000;               /* x: 24bit */
 535     for (i = 0; i < 8; i++) {
 536         t = (t << 8) + wintime[i]; /* 24bit + 8bit. t must be 32bit variable */
 537         q <<= 8;                   /* q must be 32bit (time_t) */
 538         q += t / x;
 539         t %= x;     /* 24bit */
 540     }
 541     return q;
 542 #endif
 543 }
 544
 545 /*
 546  * extended header
 547  *
 548  *             size  field name
 549  *  --------------------------------
 550  *  base header:         :
 551  *           2 or 4  next-header size  [*1]
 552  *  --------------------------------------
 553  *  ext header:   1  ext-type            ^
 554  *                ?  contents            | [*1] next-header size
 555  *           2 or 4  next-header size    v
 556  *  --------------------------------------
 557  *
 558  *  on level 1, 2 header:
 559  *    size field is 2 bytes
 560  *  on level 3 header:
 561  *    size field is 4 bytes
 562  */
 563
 564 static ssize_t
 565 get_extended_header(fp, hdr, header_size, hcrc)
 566     FILE *fp;
 567     LzHeader *hdr;
 568     size_t header_size;
 569     unsigned int *hcrc;
 570 {
 571     char data[LZHEADER_STORAGE];
 572     int name_length;
 573     char dirname[FILENAME_LENGTH];
 574     int dir_length = 0;
 575     int i;
 576     ssize_t whole_size = header_size;
 577     int ext_type;
 578     int n = 1 + hdr->size_field_length; /* `ext-type' + `next-header size' */
 579
 580     if (hdr->header_level == 0)
 581         return 0;
 582
 583     name_length = strlen(hdr->name);
 584
 585     while (header_size) {
 586 #if DUMP_HEADER
 587         if (verbose_listing && verbose > 1)
 588             printf("---\n");
 589 #endif
 590         setup_get(data, sizeof(data));
 591         if (sizeof(data) < header_size) {
 592             error("header size (%ld) too large.", header_size);
 593             exit(1);
 594         }
 595
 596         if (fread(data, header_size, 1, fp) == 0) {
 597             error("Invalid header (LHa file ?)");
 598             return -1;
 599         }
 600
 601         ext_type = get_byte();
 602         switch (ext_type) {
 603         case 0:
 604 #if DUMP_HEADER
 605             if (verbose_listing && verbose > 1) printf("     < header crc >\n");
 606 #endif
 607             /* header crc (CRC-16) */
 608             hdr->header_crc = get_word();
 609             /* clear buffer for CRC calculation. */
 610             data[1] = data[2] = 0;
 611             skip_bytes(header_size - n - 2);
 612             break;
 613         case 1:
 614 #if DUMP_HEADER
 615             if (verbose_listing && verbose > 1) printf("     < filename >\n");
 616 #endif
 617             /* filename */
 618             name_length =
 619                 get_bytes(hdr->name, header_size-n, sizeof(hdr->name)-1);
 620             hdr->name[name_length] = 0;
 621             break;
 622         case 2:
 623 #if DUMP_HEADER
 624             if (verbose_listing && verbose > 1) printf("     < directory >\n");
 625 #endif
 626             /* directory */
 627             dir_length = get_bytes(dirname, header_size-n, sizeof(dirname)-1);
 628             dirname[dir_length] = 0;
 629             break;
 630         case 0x40:
 631 #if DUMP_HEADER
 632             if (verbose_listing && verbose > 1) printf("     < MS-DOS attribute >\n");
 633 #endif
 634             /* MS-DOS attribute */
 635             hdr->attribute = get_word();
 636             break;
 637         case 0x41:
 638 #if DUMP_HEADER
 639             if (verbose_listing && verbose > 1) printf("     < Windows time stamp (FILETIME) >\n");
 640 #endif
 641             /* Windows time stamp (FILETIME structure) */
 642             /* it is time in 100 nano seconds since 1601-01-01 00:00:00 */
 643
 644             skip_bytes(8); /* create time is ignored */
 645
 646             /* set last modified time */
 647             if (hdr->header_level >= 2)
 648                 skip_bytes(8);  /* time_t has been already set */
 649             else
 650                 hdr->unix_last_modified_stamp = wintime_to_unix_stamp();
 651
 652             skip_bytes(8); /* last access time is ignored */
 653
 654             break;
 655         case 0x42:
 656 #if DUMP_HEADER
 657             if (verbose_listing && verbose > 1) printf("     < 64bits file size header >\n");
 658 #endif
 659 #ifdef HAVE_UINT64_T
 660             /* 64bits file size header (UNLHA32 extension) */
 661             hdr->packed_size = get_longlongword();
 662             hdr->original_size = get_longlongword();
 663 #else
 664             skip_bytes(8);
 665             skip_bytes(8);
 666 #endif
 667
 668             break;
 669         case 0x50:
 670 #if DUMP_HEADER
 671             if (verbose_listing && verbose > 1) printf("     < UNIX permission >\n");
 672 #endif
 673             /* UNIX permission */
 674             hdr->unix_mode = get_word();
 675             break;
 676         case 0x51:
 677 #if DUMP_HEADER
 678             if (verbose_listing && verbose > 1) printf("     < UNIX gid and uid >\n");
 679 #endif
 680             /* UNIX gid and uid */
 681             hdr->unix_gid = get_word();
 682             hdr->unix_uid = get_word();
 683             break;
 684         case 0x52:
 685 #if DUMP_HEADER
 686             if (verbose_listing && verbose > 1) printf("     < UNIX group name >\n");
 687 #endif
 688             /* UNIX group name */
 689             i = get_bytes(hdr->group, header_size-n, sizeof(hdr->group)-1);
 690             hdr->group[i] = '\0';
 691             break;
 692         case 0x53:
 693 #if DUMP_HEADER
 694             if (verbose_listing && verbose > 1) printf("     < UNIX user name >\n");
 695 #endif
 696             /* UNIX user name */
 697             i = get_bytes(hdr->user, header_size-n, sizeof(hdr->user)-1);
 698             hdr->user[i] = '\0';
 699             break;
 700         case 0x54:
 701 #if DUMP_HEADER
 702             if (verbose_listing && verbose > 1) printf("     < UNIX last modifed time (time_t) >\n");
 703 #endif
 704             /* UNIX last modified time */
 705             hdr->unix_last_modified_stamp = (time_t) get_longword();
 706             break;
 707         default:
 708             /* other headers */
 709             /* 0x39: multi-disk header
 710                0x3f: uncompressed comment
 711                0x42: 64bit large file size
 712                0x48-0x4f(?): reserved for authenticity verification
 713                0x7d: encapsulation
 714                0x7e: extended attribute - platform information
 715                0x7f: extended attribute - permission, owner-id and timestamp
 716                      (level 3 on OS/2)
 717                0xc4: compressed comment (dict size: 4096)
 718                0xc5: compressed comment (dict size: 8192)
 719                0xc6: compressed comment (dict size: 16384)
 720                0xc7: compressed comment (dict size: 32768)
 721                0xc8: compressed comment (dict size: 65536)
 722                0xd0-0xdf(?): operating systemm specific information
 723                0xfc: encapsulation (another opinion)
 724                0xfe: extended attribute - platform information(another opinion)
 725                0xff: extended attribute - permission, owner-id and timestamp
 726                      (level 3 on UNLHA32) */
 727             if (verbose)
 728                 warning("unknown extended header 0x%02x", ext_type);
 729             skip_bytes(header_size - n);
 730             break;
 731         }
 732
 733         if (hcrc)
 734             *hcrc = calccrc(*hcrc, data, header_size);
 735
 736         if (hdr->size_field_length == 2)
 737             whole_size += header_size = get_word();
 738         else
 739             whole_size += header_size = get_longword();
 740     }
 741
 742     /* concatenate dirname and filename */
 743     if (dir_length) {
 744         if (name_length + dir_length >= sizeof(hdr->name)) {
 745             warning("the length of pathname \"%s%s\" is too long.",
 746                     dirname, hdr->name);
 747             name_length = sizeof(hdr->name) - dir_length - 1;
 748             hdr->name[name_length] = 0;
 749         }
 750         strcat(dirname, hdr->name); /* ok */
 751         strcpy(hdr->name, dirname); /* ok */
 752         name_length += dir_length;
 753     }
 754
 755     return whole_size;
 756 }
 757
 758 #define I_HEADER_SIZE           0               /* level 0,1,2   */
 759 #define I_HEADER_CHECKSUM       1               /* level 0,1     */
 760 #define I_METHOD                2               /* level 0,1,2,3 */
 761 #define I_PACKED_SIZE           7               /* level 0,1,2,3 */
 762 #define I_ATTRIBUTE             19              /* level 0,1,2,3 */
 763 #define I_HEADER_LEVEL          20              /* level 0,1,2,3 */
 764
 765 #define COMMON_HEADER_SIZE      21      /* size of common part */
 766
 767 #define I_GENERIC_HEADER_SIZE 24 /* + name_length */
 768 #define I_LEVEL0_HEADER_SIZE  36 /* + name_length (unix extended) */
 769 #define I_LEVEL1_HEADER_SIZE  27 /* + name_length */
 770 #define I_LEVEL2_HEADER_SIZE  26 /* + padding */
 771 #define I_LEVEL3_HEADER_SIZE  32
 772
 773 /*
 774  * level 0 header
 775  *
 776  *
 777  * offset  size  field name
 778  * ----------------------------------
 779  *     0      1  header size    [*1]
 780  *     1      1  header sum
 781  *            ---------------------------------------
 782  *     2      5  method ID                         ^
 783  *     7      4  packed size    [*2]               |
 784  *    11      4  original size                     |
 785  *    15      2  time                              |
 786  *    17      2  date                              |
 787  *    19      1  attribute                         | [*1] header size (X+Y+22)
 788  *    20      1  level (0x00 fixed)                |
 789  *    21      1  name length                       |
 790  *    22      X  pathname                          |
 791  * X +22      2  file crc (CRC-16)                 |
 792  * X +24      Y  ext-header(old style)             v
 793  * -------------------------------------------------
 794  * X+Y+24        data                              ^
 795  *                 :                               | [*2] packed size
 796  *                 :                               v
 797  * -------------------------------------------------
 798  *
 799  * ext-header(old style)
 800  *     0      1  ext-type ('U')
 801  *     1      1  minor version
 802  *     2      4  UNIX time
 803  *     6      2  mode
 804  *     8      2  uid
 805  *    10      2  gid
 806  *
 807  * attribute (MS-DOS)
 808  *    bit1  read only
 809  *    bit2  hidden
 810  *    bit3  system
 811  *    bit4  volume label
 812  *    bit5  directory
 813  *    bit6  archive bit (need to backup)
 814  *
 815  */
 816 static int
 817 get_header_level0(fp, hdr, data)
 818     FILE *fp;
 819     LzHeader *hdr;
 820     char *data;
 821 {
 822     size_t header_size;
 823     ssize_t remain_size;
 824     ssize_t extend_size;
 825     int checksum;
 826     int name_length;
 827     int i;
 828
 829     hdr->size_field_length = 2; /* in bytes */
 830     hdr->header_size = header_size = get_byte();
 831     checksum = get_byte();
 832
 833     /* The data variable has been already read as COMMON_HEADER_SIZE bytes.
 834        So we must read the remaining header size by the header_size. */
 835     remain_size = header_size + 2 - COMMON_HEADER_SIZE;
 836     if (remain_size <= 0) {
 837         error("Invalid header size (LHarc file ?)");
 838         return FALSE;
 839     }
 840     if (fread(data + COMMON_HEADER_SIZE, remain_size, 1, fp) == 0) {
 841         error("Invalid header (LHarc file ?)");
 842         return FALSE;   /* finish */
 843     }
 844
 845     if (calc_sum(data + I_METHOD, header_size) != checksum) {
 846         error("Checksum error (LHarc file?)");
 847         return FALSE;
 848     }
 849
 850     get_bytes(hdr->method, 5, sizeof(hdr->method));
 851     hdr->packed_size = (unsigned long)get_longword();
 852     hdr->original_size = (unsigned long)get_longword();
 853     hdr->unix_last_modified_stamp = generic_to_unix_stamp(get_longword());
 854     hdr->attribute = get_byte(); /* MS-DOS attribute */
 855     hdr->header_level = get_byte();
 856     name_length = get_byte();
 857     i = get_bytes(hdr->name, name_length, sizeof(hdr->name)-1);
 858     hdr->name[i] = '\0';
 859
 860     /* defaults for other type */
 861     hdr->unix_mode = UNIX_FILE_REGULAR | UNIX_RW_RW_RW;
 862     hdr->unix_gid = 0;
 863     hdr->unix_uid = 0;
 864
 865     extend_size = header_size+2 - name_length - 24;
 866
 867     if (extend_size < 0) {
 868         if (extend_size == -2) {
 869             /* CRC field is not given */
 870             hdr->extend_type = EXTEND_GENERIC;
 871             hdr->has_crc = FALSE;
 872
 873             return TRUE;
 874         }
 875
 876         error("Unkonwn header (lha file?)");
 877         exit(1);
 878     }
 879
 880     hdr->has_crc = TRUE;
 881     hdr->crc = get_word();
 882
 883     if (extend_size == 0)
 884         return TRUE;
 885
 886     hdr->extend_type = get_byte();
 887     extend_size--;
 888
 889     if (hdr->extend_type == EXTEND_UNIX) {
 890         if (extend_size >= 11) {
 891             hdr->minor_version = get_byte();
 892             hdr->unix_last_modified_stamp = (time_t) get_longword();
 893             hdr->unix_mode = get_word();
 894             hdr->unix_uid = get_word();
 895             hdr->unix_gid = get_word();
 896             extend_size -= 11;
 897         } else {
 898             hdr->extend_type = EXTEND_GENERIC;
 899         }
 900     }
 901     if (extend_size > 0)
 902         skip_bytes(extend_size);
 903
 904     hdr->header_size += 2;
 905     return TRUE;
 906 }
 907
 908 /*
 909  * level 1 header
 910  *
 911  *
 912  * offset   size  field name
 913  * -----------------------------------
 914  *     0       1  header size   [*1]
 915  *     1       1  header sum
 916  *             -------------------------------------
 917  *     2       5  method ID                        ^
 918  *     7       4  skip size     [*2]               |
 919  *    11       4  original size                    |
 920  *    15       2  time                             |
 921  *    17       2  date                             |
 922  *    19       1  attribute (0x20 fixed)           | [*1] header size (X+Y+25)
 923  *    20       1  level (0x01 fixed)               |
 924  *    21       1  name length                      |
 925  *    22       X  filename                         |
 926  * X+ 22       2  file crc (CRC-16)                |
 927  * X+ 24       1  OS ID                            |
 928  * X +25       Y  ???                              |
 929  * X+Y+25      2  next-header size                 v
 930  * -------------------------------------------------
 931  * X+Y+27      Z  ext-header                       ^
 932  *                 :                               |
 933  * -----------------------------------             | [*2] skip size
 934  * X+Y+Z+27       data                             |
 935  *                 :                               v
 936  * -------------------------------------------------
 937  *
 938  */
 939 static int
 940 get_header_level1(fp, hdr, data)
 941     FILE *fp;
 942     LzHeader *hdr;
 943     char *data;
 944 {
 945     size_t header_size;
 946     ssize_t remain_size;
 947     ssize_t extend_size;
 948     int checksum;
 949     int name_length;
 950     int i, dummy;
 951
 952     hdr->size_field_length = 2; /* in bytes */
 953     hdr->header_size = header_size = get_byte();
 954     checksum = get_byte();
 955
 956     /* The data variable has been already read as COMMON_HEADER_SIZE bytes.
 957        So we must read the remaining header size by the header_size. */
 958     remain_size = header_size + 2 - COMMON_HEADER_SIZE;
 959     if (remain_size <= 0) {
 960         error("Invalid header size (LHarc file ?)");
 961         return FALSE;
 962     }
 963     if (fread(data + COMMON_HEADER_SIZE, remain_size, 1, fp) == 0) {
 964         error("Invalid header (LHarc file ?)");
 965         return FALSE;   /* finish */
 966     }
 967
 968     if (calc_sum(data + I_METHOD, header_size) != checksum) {
 969         error("Checksum error (LHarc file?)");
 970         return FALSE;
 971     }
 972
 973     get_bytes(hdr->method, 5, sizeof(hdr->method));
 974     hdr->packed_size = (unsigned long)get_longword(); /* skip size */
 975     hdr->original_size = (unsigned long)get_longword();
 976     hdr->unix_last_modified_stamp = generic_to_unix_stamp(get_longword());
 977     hdr->attribute = get_byte(); /* 0x20 fixed */
 978     hdr->header_level = get_byte();
 979
 980     name_length = get_byte();
 981     i = get_bytes(hdr->name, name_length, sizeof(hdr->name)-1);
 982     hdr->name[i] = '\0';
 983
 984     /* defaults for other type */
 985     hdr->unix_mode = UNIX_FILE_REGULAR | UNIX_RW_RW_RW;
 986     hdr->unix_gid = 0;
 987     hdr->unix_uid = 0;
 988
 989     hdr->has_crc = TRUE;
 990     hdr->crc = get_word();
 991     hdr->extend_type = get_byte();
 992
 993     dummy = header_size+2 - name_length - I_LEVEL1_HEADER_SIZE;
 994     if (dummy > 0)
 995         skip_bytes(dummy); /* skip old style extend header */
 996
 997     extend_size = get_word();
 998     extend_size = get_extended_header(fp, hdr, extend_size, 0);
 999     if (extend_size == -1)
1000         return FALSE;
1001
1002     /* On level 1 header, size fields should be adjusted. */
1003     /* the `packed_size' field contains the extended header size. */
1004     /* the `header_size' field does not. */
1005     hdr->packed_size -= extend_size;
1006     hdr->header_size += extend_size + 2;
1007
1008     return TRUE;
1009 }
1010
1011 /*
1012  * level 2 header
1013  *
1014  *
1015  * offset   size  field name
1016  * --------------------------------------------------
1017  *     0       2  total header size [*1]           ^
1018  *             -----------------------             |
1019  *     2       5  method ID                        |
1020  *     7       4  packed size       [*2]           |
1021  *    11       4  original size                    |
1022  *    15       4  time                             |
1023  *    19       1  RESERVED (0x20 fixed)            | [*1] total header size
1024  *    20       1  level (0x02 fixed)               |      (X+26+(1))
1025  *    21       2  file crc (CRC-16)                |
1026  *    23       1  OS ID                            |
1027  *    24       2  next-header size                 |
1028  * -----------------------------------             |
1029  *    26       X  ext-header                       |
1030  *                 :                               |
1031  * -----------------------------------             |
1032  * X +26      (1) padding                          v
1033  * -------------------------------------------------
1034  * X +26+(1)      data                             ^
1035  *                 :                               | [*2] packed size
1036  *                 :                               v
1037  * -------------------------------------------------
1038  *
1039  */
1040 static int
1041 get_header_level2(fp, hdr, data)
1042     FILE *fp;
1043     LzHeader *hdr;
1044     char *data;
1045 {
1046     size_t header_size;
1047     ssize_t extend_size;
1048     int padding;
1049     unsigned int hcrc;
1050
1051     hdr->size_field_length = 2; /* in bytes */
1052     hdr->header_size = header_size = get_word();
1053
1054     if (fread(data + COMMON_HEADER_SIZE,
1055               I_LEVEL2_HEADER_SIZE - COMMON_HEADER_SIZE, 1, fp) == 0) {
1056         error("Invalid header (LHarc file ?)");
1057         return FALSE;   /* finish */
1058     }
1059
1060     get_bytes(hdr->method, 5, sizeof(hdr->method));
1061     hdr->packed_size = (unsigned long)get_longword();
1062     hdr->original_size = (unsigned long)get_longword();
1063     hdr->unix_last_modified_stamp = get_longword();
1064     hdr->attribute = get_byte(); /* reserved */
1065     hdr->header_level = get_byte();
1066
1067     /* defaults for other type */
1068     hdr->unix_mode = UNIX_FILE_REGULAR | UNIX_RW_RW_RW;
1069     hdr->unix_gid = 0;
1070     hdr->unix_uid = 0;
1071
1072     hdr->has_crc = TRUE;
1073     hdr->crc = get_word();
1074     hdr->extend_type = get_byte();
1075     extend_size = get_word();
1076
1077     INITIALIZE_CRC(hcrc);
1078     hcrc = calccrc(hcrc, data, get_ptr - data);
1079
1080     extend_size = get_extended_header(fp, hdr, extend_size, &hcrc);
1081     if (extend_size == -1)
1082         return FALSE;
1083
1084     padding = header_size - I_LEVEL2_HEADER_SIZE - extend_size;
1085     while (padding--)           /* padding should be 0 or 1 */
1086         hcrc = UPDATE_CRC(hcrc, fgetc(fp));
1087
1088     if (hdr->header_crc != hcrc)
1089         error("header CRC error");
1090
1091     return TRUE;
1092 }
1093
1094 /*
1095  * level 3 header
1096  *
1097  *
1098  * offset   size  field name
1099  * --------------------------------------------------
1100  *     0       2  size field length (4 fixed)      ^
1101  *     2       5  method ID                        |
1102  *     7       4  packed size       [*2]           |
1103  *    11       4  original size                    |
1104  *    15       4  time                             |
1105  *    19       1  RESERVED (0x20 fixed)            | [*1] total header size
1106  *    20       1  level (0x03 fixed)               |      (X+32)
1107  *    21       2  file crc (CRC-16)                |
1108  *    23       1  OS ID                            |
1109  *    24       4  total header size [*1]           |
1110  *    28       4  next-header size                 |
1111  * -----------------------------------             |
1112  *    32       X  ext-header                       |
1113  *                 :                               v
1114  * -------------------------------------------------
1115  * X +32          data                             ^
1116  *                 :                               | [*2] packed size
1117  *                 :                               v
1118  * -------------------------------------------------
1119  *
1120  */
1121 static int
1122 get_header_level3(fp, hdr, data)
1123     FILE *fp;
1124     LzHeader *hdr;
1125     char *data;
1126 {
1127     size_t header_size;
1128     ssize_t extend_size;
1129     int padding;
1130     unsigned int hcrc;
1131
1132     hdr->size_field_length = get_word();
1133
1134     if (fread(data + COMMON_HEADER_SIZE,
1135               I_LEVEL3_HEADER_SIZE - COMMON_HEADER_SIZE, 1, fp) == 0) {
1136         error("Invalid header (LHarc file ?)");
1137         return FALSE;   /* finish */
1138     }
1139
1140     get_bytes(hdr->method, 5, sizeof(hdr->method));
1141     hdr->packed_size = (unsigned long)get_longword();
1142     hdr->original_size = (unsigned long)get_longword();
1143     hdr->unix_last_modified_stamp = get_longword();
1144     hdr->attribute = get_byte(); /* reserved */
1145     hdr->header_level = get_byte();
1146
1147     /* defaults for other type */
1148     hdr->unix_mode = UNIX_FILE_REGULAR | UNIX_RW_RW_RW;
1149     hdr->unix_gid = 0;
1150     hdr->unix_uid = 0;
1151
1152     hdr->has_crc = TRUE;
1153     hdr->crc = get_word();
1154     hdr->extend_type = get_byte();
1155     hdr->header_size = header_size = get_longword();
1156     extend_size = get_longword();
1157
1158     INITIALIZE_CRC(hcrc);
1159     hcrc = calccrc(hcrc, data, get_ptr - data);
1160
1161     extend_size = get_extended_header(fp, hdr, extend_size, &hcrc);
1162     if (extend_size == -1)
1163         return FALSE;
1164
1165     padding = header_size - I_LEVEL3_HEADER_SIZE - extend_size;
1166     while (padding--)           /* padding should be 0 */
1167         hcrc = UPDATE_CRC(hcrc, fgetc(fp));
1168
1169     if (hdr->header_crc != hcrc)
1170         error("header CRC error");
1171
1172     return TRUE;
1173 }
1174
1175 boolean
1176 get_header(fp, hdr)
1177     FILE *fp;
1178     LzHeader *hdr;
1179 {
1180     char data[LZHEADER_STORAGE];
1181
1182     int archive_kanji_code = CODE_SJIS;
1183     int system_kanji_code = default_system_kanji_code;
1184     char *archive_delim = "\377\\"; /* `\' is for level 0 header and
1185                                        broken archive. */
1186     char *system_delim = "//";
1187     int filename_case = NONE;
1188     int end_mark;
1189
1190     memset(hdr, 0, sizeof(LzHeader));
1191
1192     setup_get(data, sizeof(data));
1193
1194     if ((end_mark = getc(fp)) == EOF || end_mark == 0) {
1195         return FALSE;           /* finish */
1196     }
1197     data[0] = end_mark;
1198
1199     if (fread(data + 1, COMMON_HEADER_SIZE - 1, 1, fp) == 0) {
1200         error("Invalid header (LHarc file ?)");
1201         return FALSE;           /* finish */
1202     }
1203
1204     switch (data[I_HEADER_LEVEL]) {
1205     case 0:
1206         if (get_header_level0(fp, hdr, data) == FALSE)
1207             return FALSE;
1208         break;
1209     case 1:
1210         if (get_header_level1(fp, hdr, data) == FALSE)
1211             return FALSE;
1212         break;
1213     case 2:
1214         if (get_header_level2(fp, hdr, data) == FALSE)
1215             return FALSE;
1216         break;
1217     case 3:
1218         if (get_header_level3(fp, hdr, data) == FALSE)
1219             return FALSE;
1220         break;
1221     default:
1222         error("Unknown level header (level %d)", data[I_HEADER_LEVEL]);
1223         return FALSE;
1224     }
1225
1226     /* filename conversion */
1227     switch (hdr->extend_type) {
1228     case EXTEND_MSDOS:
1229         filename_case = convertcase ? TO_LOWER : NONE;
1230         break;
1231     case EXTEND_HUMAN:
1232     case EXTEND_OS68K:
1233     case EXTEND_XOSK:
1234     case EXTEND_UNIX:
1235     case EXTEND_JAVA:
1236         filename_case = NONE;
1237         break;
1238
1239     case EXTEND_MACOS:
1240         archive_delim = "\377/:\\";
1241                           /* `\' is for level 0 header and broken archive. */
1242         system_delim = "/://";
1243         filename_case = NONE;
1244         break;
1245
1246     default:
1247         filename_case = convertcase ? TO_LOWER : NONE;
1248         break;
1249     }
1250
1251     if (optional_archive_kanji_code)
1252         archive_kanji_code = optional_archive_kanji_code;
1253     if (optional_system_kanji_code)
1254         system_kanji_code = optional_system_kanji_code;
1255     if (optional_archive_delim)
1256         archive_delim = optional_archive_delim;
1257     if (optional_system_delim)
1258         system_delim = optional_system_delim;
1259     if (optional_filename_case)
1260         filename_case = optional_filename_case;
1261
1262     /* kanji code and delimiter conversion */
1263     convert_filename(hdr->name, strlen(hdr->name), sizeof(hdr->name),
1264                      archive_kanji_code,
1265                      system_kanji_code,
1266                      archive_delim, system_delim, filename_case);
1267
1268     if ((hdr->unix_mode & UNIX_FILE_SYMLINK) == UNIX_FILE_SYMLINK) {
1269         char *p;
1270         /* split symbolic link */
1271         p = strchr(hdr->name, '|');
1272         if (p) {
1273             /* hdr->name is symbolic link name */
1274             /* hdr->realname is real name */
1275             *p = 0;
1276             strcpy(hdr->realname, p+1); /* ok */
1277         }
1278         else
1279             error("unknown symlink name \"%s\"", hdr->name);
1280     }
1281
1282     return TRUE;
1283 }
1284
1285 /* skip SFX header */
1286 int
1287 seek_lha_header(fp)
1288     FILE *fp;
1289 {
1290     unsigned char   buffer[64 * 1024]; /* max seek size */
1291     unsigned char  *p;
1292     int             n;
1293
1294     n = fread(buffer, 1, sizeof(buffer), fp);
1295
1296     for (p = buffer; p < buffer + n; p++) {
1297         if (! (p[I_METHOD]=='-' &&
1298                (p[I_METHOD+1]=='l' || p[I_METHOD+1]=='p') &&
1299                p[I_METHOD+4]=='-'))
1300             continue;
1301         /* found "-[lp]??-" keyword (as METHOD type string) */
1302
1303         /* level 0 or 1 header */
1304         if ((p[I_HEADER_LEVEL] == 0 || p[I_HEADER_LEVEL] == 1)
1305             && p[I_HEADER_SIZE] > 20
1306             && p[I_HEADER_CHECKSUM] == calc_sum(p+2, p[I_HEADER_SIZE])) {
1307             if (fseeko(fp, (p - buffer) - n, SEEK_CUR) == -1)
1308                 fatal_error("cannot seek header");
1309             return 0;
1310         }
1311
1312         /* level 2 header */
1313         if (p[I_HEADER_LEVEL] == 2
1314             && p[I_HEADER_SIZE] >= 24
1315             && p[I_ATTRIBUTE] == 0x20) {
1316             if (fseeko(fp, (p - buffer) - n, SEEK_CUR) == -1)
1317                 fatal_error("cannot seek header");
1318             return 0;
1319         }
1320     }
1321
1322     if (fseeko(fp, -n, SEEK_CUR) == -1)
1323         fatal_error("cannot seek header");
1324     return -1;
1325 }
1326
1327
1328 /* remove leading `xxxx/..' */
1329 static char *
1330 remove_leading_dots(char *path)
1331 {
1332     char *first = path;
1333     char *ptr = 0;
1334
1335     if (strcmp(first, "..") == 0) {
1336         warning("Removing leading `..' from member name.");
1337         return first+1;         /* change to "." */
1338     }
1339
1340     if (strstr(first, "..") == 0)
1341         return first;
1342
1343     while (path && *path) {
1344
1345         if (strcmp(path, "..") == 0)
1346             ptr = path = path+2;
1347         else if (strncmp(path, "../", 3) == 0)
1348             ptr = path = path+3;
1349         else
1350             path = strchr(path, '/');
1351
1352         if (path && *path == '/') {
1353             path++;
1354         }
1355     }
1356
1357     if (ptr) {
1358         warning("Removing leading `%.*s' from member name.", ptr-first, first);
1359         return ptr;
1360     }
1361
1362     return first;
1363 }
1364
1365 static int
1366 copy_path_element(char *dst, const char *src, int size)
1367 {
1368     int i;
1369
1370     if (size < 1) return 0;
1371
1372     for (i = 0; i < size; i++) {
1373         dst[i] = src[i];
1374         if (dst[i] == '\0')
1375             return i;
1376         if (dst[i] == '/') {
1377             dst[++i] = 0;
1378             return i;
1379         }
1380     }
1381
1382     dst[--i] = 0;
1383
1384     return i;
1385 }
1386
1387 /*
1388   canonicalize path
1389
1390   remove leading "xxx/../"
1391   remove "./", "././", "././ ... ./"
1392   remove duplicated "/"
1393 */
1394 static int
1395 canon_path(char *newpath, char *path, size_t size)
1396 {
1397     char *p = newpath;
1398
1399     path = remove_leading_dots(path);
1400
1401     while (*path) {
1402         if (path[0] == '.' && path[1] == '/')
1403             path += 2;
1404         else {
1405             int len;
1406             len = copy_path_element(newpath, path, size);
1407
1408             path += len;
1409             newpath += len;
1410             size -= len;
1411             if (size <= 1)
1412                 break;
1413         }
1414
1415         /* remove duplicated '/' */
1416         while (*path == '/') path++;
1417     }
1418
1419     /* When newpath is empty, set "." */
1420     if (newpath == p) {
1421         strcpy(newpath, ".");
1422         newpath++;
1423     }
1424
1425     return newpath - p;         /* string length */
1426 }
1427
1428 void
1429 init_header(name, v_stat, hdr)
1430     char           *name;
1431     struct stat    *v_stat;
1432     LzHeader       *hdr;
1433 {
1434     int             len;
1435
1436     memset(hdr, 0, sizeof(LzHeader));
1437
1438     /* the `method' member is rewrote by the encoding function.
1439        but need set for empty files */
1440     memcpy(hdr->method, LZHUFF0_METHOD, METHOD_TYPE_STORAGE);
1441
1442     hdr->packed_size = 0;
1443     hdr->original_size = v_stat->st_size;
1444     hdr->attribute = GENERIC_ATTRIBUTE;
1445     hdr->header_level = header_level;
1446
1447     len = canon_path(hdr->name, name, sizeof(hdr->name));
1448
1449     hdr->crc = 0x0000;
1450     hdr->extend_type = EXTEND_UNIX;
1451     hdr->unix_last_modified_stamp = v_stat->st_mtime;
1452     /* since 00:00:00 JAN.1.1970 */
1453 #ifdef NOT_COMPATIBLE_MODE
1454     /* Please need your modification in this space. */
1455 #ifdef __DJGPP__
1456     hdr->unix_mode = 0;
1457     if (S_ISREG(v_stat->st_mode))
1458             hdr->unix_mode = hdr->unix_mode | UNIX_FILE_REGULAR;
1459     if (S_ISDIR(v_stat->st_mode))
1460             hdr->unix_mode = hdr->unix_mode | UNIX_FILE_DIRECTORY;
1461     if (S_ISLNK(v_stat->st_mode))
1462             hdr->unix_mode = hdr->unix_mode | UNIX_FILE_SYMLINK;
1463     if (v_stat->st_mode & S_IRUSR)
1464             hdr->unix_mode = hdr->unix_mode | UNIX_OWNER_READ_PERM;
1465     if (v_stat->st_mode & S_IRGRP)
1466             hdr->unix_mode = hdr->unix_mode | UNIX_GROUP_READ_PERM;
1467     if (v_stat->st_mode & S_IROTH)
1468             hdr->unix_mode = hdr->unix_mode | UNIX_OTHER_READ_PERM;
1469     if (v_stat->st_mode & S_IWUSR)
1470             hdr->unix_mode = hdr->unix_mode | UNIX_OWNER_WRITE_PERM;
1471     if (v_stat->st_mode & S_IWGRP)
1472             hdr->unix_mode = hdr->unix_mode | UNIX_GROUP_WRITE_PERM;
1473     if (v_stat->st_mode & S_IWOTH)
1474             hdr->unix_mode = hdr->unix_mode | UNIX_OTHER_WRITE_PERM;
1475     if (v_stat->st_mode & S_IXUSR)
1476             hdr->unix_mode = hdr->unix_mode | UNIX_OWNER_EXEC_PERM;
1477     if (v_stat->st_mode & S_IXGRP)
1478             hdr->unix_mode = hdr->unix_mode | UNIX_GROUP_EXEC_PERM;
1479     if (v_stat->st_mode & S_IXOTH)
1480             hdr->unix_mode = hdr->unix_mode | UNIX_OTHER_EXEC_PERM;
1481     if (v_stat->st_mode & S_ISUID)
1482             hdr->unix_mode = hdr->unix_mode | UNIX_SETUID;
1483     if (v_stat->st_mode & S_ISGID)
1484             hdr->unix_mode = hdr->unix_mode | UNIX_SETGID;
1485 #endif /* __DJGPP__ */
1486 #else
1487     hdr->unix_mode = v_stat->st_mode;
1488 #endif
1489
1490     hdr->unix_uid = v_stat->st_uid;
1491     hdr->unix_gid = v_stat->st_gid;
1492
1493 #if INCLUDE_OWNER_NAME_IN_HEADER
1494 #if HAVE_GETPWUID
1495     {
1496         struct passwd *ent = getpwuid(hdr->unix_uid);
1497
1498         if (ent) {
1499             strncpy(hdr->user, ent->pw_name, sizeof(hdr->user));
1500             if (hdr->user[sizeof(hdr->user)-1])
1501                 hdr->user[sizeof(hdr->user)-1] = 0;
1502         }
1503     }
1504 #endif
1505 #if HAVE_GETGRGID
1506     {
1507         struct group *ent = getgrgid(hdr->unix_gid);
1508
1509         if (ent) {
1510             strncpy(hdr->group, ent->gr_name, sizeof(hdr->group));
1511             if (hdr->group[sizeof(hdr->group)-1])
1512                 hdr->group[sizeof(hdr->group)-1] = 0;
1513         }
1514     }
1515 #endif
1516 #endif /* INCLUDE_OWNER_NAME_IN_HEADER */
1517     if (is_directory(v_stat)) {
1518         memcpy(hdr->method, LZHDIRS_METHOD, METHOD_TYPE_STORAGE);
1519         hdr->attribute = GENERIC_DIRECTORY_ATTRIBUTE;
1520         hdr->original_size = 0;
1521         if (len > 0 && hdr->name[len - 1] != '/') {
1522             if (len < sizeof(hdr->name)-1)
1523                 strcpy(&hdr->name[len++], "/"); /* ok */
1524             else
1525                 warning("the length of dirname \"%s\" is too long.",
1526                         hdr->name);
1527         }
1528     }
1529
1530 #ifdef S_IFLNK
1531     if (is_symlink(v_stat)) {
1532         memcpy(hdr->method, LZHDIRS_METHOD, METHOD_TYPE_STORAGE);
1533         hdr->attribute = GENERIC_DIRECTORY_ATTRIBUTE;
1534         hdr->original_size = 0;
1535         readlink(name, hdr->realname, sizeof(hdr->realname));
1536     }
1537 #endif
1538 }
1539
1540 static void
1541 write_unix_info(hdr)
1542     LzHeader *hdr;
1543 {
1544     /* UNIX specific informations */
1545
1546     put_word(5);            /* size */
1547     put_byte(0x50);         /* permission */
1548     put_word(hdr->unix_mode);
1549
1550     put_word(7);            /* size */
1551     put_byte(0x51);         /* gid and uid */
1552     put_word(hdr->unix_gid);
1553     put_word(hdr->unix_uid);
1554
1555     if (hdr->group[0]) {
1556         int len = strlen(hdr->group);
1557         put_word(len + 3);  /* size */
1558         put_byte(0x52);     /* group name */
1559         put_bytes(hdr->group, len);
1560     }
1561
1562     if (hdr->user[0]) {
1563         int len = strlen(hdr->user);
1564         put_word(len + 3);  /* size */
1565         put_byte(0x53);     /* user name */
1566         put_bytes(hdr->user, len);
1567     }
1568
1569     if (hdr->header_level == 1) {
1570         put_word(7);        /* size */
1571         put_byte(0x54);     /* time stamp */
1572         put_longword(hdr->unix_last_modified_stamp);
1573     }
1574 }
1575
1576 static size_t
1577 write_header_level0(data, hdr, pathname)
1578     LzHeader *hdr;
1579     char *data, *pathname;
1580 {
1581     int limit;
1582     int name_length;
1583     size_t header_size;
1584
1585     setup_put(data);
1586     memset(data, 0, LZHEADER_STORAGE);
1587
1588     put_byte(0x00);             /* header size */
1589     put_byte(0x00);             /* check sum */
1590     put_bytes(hdr->method, 5);
1591     put_longword(hdr->packed_size);
1592     put_longword(hdr->original_size);
1593     put_longword(unix_to_generic_stamp(hdr->unix_last_modified_stamp));
1594     put_byte(hdr->attribute);
1595     put_byte(hdr->header_level); /* level 0 */
1596
1597     /* write pathname (level 0 header contains the directory part) */
1598     name_length = strlen(pathname);
1599     if (generic_format)
1600         limit = 255 - I_GENERIC_HEADER_SIZE + 2;
1601     else
1602         limit = 255 - I_LEVEL0_HEADER_SIZE + 2;
1603
1604     if (name_length > limit) {
1605         warning("the length of pathname \"%s\" is too long.", pathname);
1606         name_length = limit;
1607     }
1608     put_byte(name_length);
1609     put_bytes(pathname, name_length);
1610     put_word(hdr->crc);
1611
1612     if (generic_format) {
1613         header_size = I_GENERIC_HEADER_SIZE + name_length - 2;
1614         data[I_HEADER_SIZE] = header_size;
1615         data[I_HEADER_CHECKSUM] = calc_sum(data + I_METHOD, header_size);
1616     } else {
1617         /* write old-style extend header */
1618         put_byte(EXTEND_UNIX);
1619         put_byte(CURRENT_UNIX_MINOR_VERSION);
1620         put_longword(hdr->unix_last_modified_stamp);
1621         put_word(hdr->unix_mode);
1622         put_word(hdr->unix_uid);
1623         put_word(hdr->unix_gid);
1624
1625         /* size of extended header is 12 */
1626         header_size = I_LEVEL0_HEADER_SIZE + name_length - 2;
1627         data[I_HEADER_SIZE] = header_size;
1628         data[I_HEADER_CHECKSUM] = calc_sum(data + I_METHOD, header_size);
1629     }
1630
1631     return header_size + 2;
1632 }
1633
1634 static size_t
1635 write_header_level1(data, hdr, pathname)
1636     LzHeader *hdr;
1637     char *data, *pathname;
1638 {
1639     int name_length, dir_length, limit;
1640     char *basename, *dirname;
1641     size_t header_size;
1642     char *extend_header_top;
1643     size_t extend_header_size;
1644
1645     basename = strrchr(pathname, LHA_PATHSEP);
1646     if (basename) {
1647         basename++;
1648         name_length = strlen(basename);
1649         dirname = pathname;
1650         dir_length = basename - dirname;
1651     }
1652     else {
1653         basename = pathname;
1654         name_length = strlen(basename);
1655         dirname = "";
1656         dir_length = 0;
1657     }
1658
1659     setup_put(data);
1660     memset(data, 0, LZHEADER_STORAGE);
1661
1662     put_byte(0x00);             /* header size */
1663     put_byte(0x00);             /* check sum */
1664     put_bytes(hdr->method, 5);
1665     put_longword(hdr->packed_size);
1666     put_longword(hdr->original_size);
1667     put_longword(unix_to_generic_stamp(hdr->unix_last_modified_stamp));
1668     put_byte(0x20);
1669     put_byte(hdr->header_level); /* level 1 */
1670
1671     /* level 1 header: write filename (basename only) */
1672     limit = 255 - I_LEVEL1_HEADER_SIZE + 2;
1673     if (name_length > limit) {
1674         put_byte(0);            /* name length */
1675     }
1676     else {
1677         put_byte(name_length);
1678         put_bytes(basename, name_length);
1679     }
1680
1681     put_word(hdr->crc);
1682
1683     if (generic_format)
1684         put_byte(0x00);
1685     else
1686         put_byte(EXTEND_UNIX);
1687
1688     /* write extend header from here. */
1689
1690     extend_header_top = put_ptr+2; /* +2 for the field `next header size' */
1691     header_size = extend_header_top - data - 2;
1692
1693     /* write filename and dirname */
1694
1695     if (name_length > limit) {
1696         put_word(name_length + 3); /* size */
1697         put_byte(0x01);         /* filename */
1698         put_bytes(basename, name_length);
1699     }
1700
1701     if (dir_length > 0) {
1702         put_word(dir_length + 3); /* size */
1703         put_byte(0x02);         /* dirname */
1704         put_bytes(dirname, dir_length);
1705     }
1706
1707     if (!generic_format)
1708         write_unix_info(hdr);
1709
1710     put_word(0x0000);           /* next header size */
1711
1712     extend_header_size = put_ptr - extend_header_top;
1713     /* On level 1 header, the packed size field is contains the ext-header */
1714     hdr->packed_size += put_ptr - extend_header_top;
1715
1716     /* put `skip size' */
1717     setup_put(data + I_PACKED_SIZE);
1718     put_longword(hdr->packed_size);
1719
1720     data[I_HEADER_SIZE] = header_size;
1721     data[I_HEADER_CHECKSUM] = calc_sum(data + I_METHOD, header_size);
1722
1723     return header_size + extend_header_size + 2;
1724 }
1725
1726 static size_t
1727 write_header_level2(data, hdr, pathname)
1728     LzHeader *hdr;
1729     char *data, *pathname;
1730 {
1731     int name_length, dir_length;
1732     char *basename, *dirname;
1733     size_t header_size;
1734     char *extend_header_top;
1735     char *headercrc_ptr;
1736     unsigned int hcrc;
1737
1738     basename = strrchr(pathname, LHA_PATHSEP);
1739     if (basename) {
1740         basename++;
1741         name_length = strlen(basename);
1742         dirname = pathname;
1743         dir_length = basename - dirname;
1744     }
1745     else {
1746         basename = pathname;
1747         name_length = strlen(basename);
1748         dirname = "";
1749         dir_length = 0;
1750     }
1751
1752     setup_put(data);
1753     memset(data, 0, LZHEADER_STORAGE);
1754
1755     put_word(0x0000);           /* header size */
1756     put_bytes(hdr->method, 5);
1757     put_longword(hdr->packed_size);
1758     put_longword(hdr->original_size);
1759     put_longword(hdr->unix_last_modified_stamp);
1760     put_byte(0x20);
1761     put_byte(hdr->header_level); /* level 2 */
1762
1763     put_word(hdr->crc);
1764
1765     if (generic_format)
1766         put_byte(0x00);
1767     else
1768         put_byte(EXTEND_UNIX);
1769
1770     /* write extend header from here. */
1771
1772     extend_header_top = put_ptr+2; /* +2 for the field `next header size' */
1773
1774     /* write common header */
1775     put_word(5);
1776     put_byte(0x00);
1777     headercrc_ptr = put_ptr;
1778     put_word(0x0000);           /* header CRC */
1779
1780     /* write filename and dirname */
1781     /* must have this header, even if the name_length is 0. */
1782     put_word(name_length + 3);  /* size */
1783     put_byte(0x01);             /* filename */
1784     put_bytes(basename, name_length);
1785
1786     if (dir_length > 0) {
1787         put_word(dir_length + 3); /* size */
1788         put_byte(0x02);         /* dirname */
1789         put_bytes(dirname, dir_length);
1790     }
1791
1792     if (!generic_format)
1793         write_unix_info(hdr);
1794
1795     put_word(0x0000);           /* next header size */
1796
1797     header_size = put_ptr - data;
1798     if ((header_size & 0xff) == 0) {
1799         /* cannot put zero at the first byte on level 2 header. */
1800         /* adjust header size. */
1801         put_byte(0);            /* padding */
1802         header_size++;
1803     }
1804
1805     /* put header size */
1806     setup_put(data + I_HEADER_SIZE);
1807     put_word(header_size);
1808
1809     /* put header CRC in extended header */
1810     INITIALIZE_CRC(hcrc);
1811     hcrc = calccrc(hcrc, data, (unsigned int) header_size);
1812     setup_put(headercrc_ptr);
1813     put_word(hcrc);
1814
1815     return header_size;
1816 }
1817
1818 void
1819 write_header(fp, hdr)
1820     FILE           *fp;
1821     LzHeader       *hdr;
1822 {
1823     size_t header_size;
1824     char data[LZHEADER_STORAGE];
1825
1826     int archive_kanji_code = CODE_SJIS;
1827     int system_kanji_code = default_system_kanji_code;
1828     char *archive_delim = "\377";
1829     char *system_delim = "/";
1830     int filename_case = NONE;
1831     char pathname[FILENAME_LENGTH];
1832
1833     if (optional_archive_kanji_code)
1834         archive_kanji_code = optional_archive_kanji_code;
1835     if (optional_system_kanji_code)
1836         system_kanji_code = optional_system_kanji_code;
1837
1838     if (generic_format && convertcase)
1839         filename_case = TO_UPPER;
1840
1841     if (hdr->header_level == 0) {
1842         archive_delim = "\\";
1843     }
1844
1845     if ((hdr->unix_mode & UNIX_FILE_SYMLINK) == UNIX_FILE_SYMLINK) {
1846         char *p;
1847         p = strchr(hdr->name, '|');
1848         if (p) {
1849             error("symlink name \"%s\" contains '|' char. change it into '_'",
1850                   hdr->name);
1851             *p = '_';
1852         }
1853         if (xsnprintf(pathname, sizeof(pathname),
1854                       "%s|%s", hdr->name, hdr->realname) == -1)
1855             error("file name is too long (%s -> %s)", hdr->name, hdr->realname);
1856     }
1857     else {
1858         strncpy(pathname, hdr->name, sizeof(pathname));
1859         pathname[sizeof(pathname)-1] = 0;
1860     }
1861
1862     convert_filename(pathname, strlen(pathname), sizeof(pathname),
1863                      system_kanji_code,
1864                      archive_kanji_code,
1865                      system_delim, archive_delim, filename_case);
1866
1867     switch (hdr->header_level) {
1868     case 0:
1869         header_size = write_header_level0(data, hdr, pathname);
1870         break;
1871     case 1:
1872         header_size = write_header_level1(data, hdr, pathname);
1873         break;
1874     case 2:
1875         header_size = write_header_level2(data, hdr, pathname);
1876         break;
1877     default:
1878         error("Unknown level header (level %d)", hdr->header_level);
1879         exit(1);
1880     }
1881
1882     if (fwrite(data, header_size, 1, fp) == 0)
1883         fatal_error("Cannot write to temporary file");
1884 }
1885
1886 #if MULTIBYTE_FILENAME
1887
1888 #if defined(__APPLE__)  /* Added by Hiroto Sakai */
1889
1890 #include <CoreFoundation/CFString.h>
1891 #include <CoreFoundation/CFStringEncodingExt.h>
1892
1893 /* this is not need for Mac OS X v 10.2 later */
1894 enum {
1895   kCFStringEncodingAllowLossyConversion = 1,
1896   kCFStringEncodingBasicDirectionLeftToRight = (1 << 1),
1897   kCFStringEncodingBasicDirectionRightToLeft = (1 << 2),
1898   kCFStringEncodingSubstituteCombinings = (1 << 3),
1899   kCFStringEncodingComposeCombinings = (1 << 4),
1900   kCFStringEncodingIgnoreCombinings = (1 << 5),
1901   kCFStringEncodingUseCanonical = (1 << 6),
1902   kCFStringEncodingUseHFSPlusCanonical = (1 << 7),
1903   kCFStringEncodingPrependBOM = (1 << 8),
1904   kCFStringEncodingDisableCorporateArea = (1 << 9),
1905   kCFStringEncodingASCIICompatibleConversion = (1 << 10),
1906 };
1907
1908 static int
1909 ConvertEncodingToUTF8(const char* inCStr,
1910                       char* outUTF8Buffer,
1911                       int outUTF8BufferLength,
1912                       unsigned long scriptEncoding,
1913                       unsigned long flags)
1914 {
1915     unsigned long unicodeChars;
1916     unsigned long srcCharsUsed;
1917     unsigned long usedByteLen = 0;
1918     UniChar uniStr[512];
1919     unsigned long cfResult;
1920
1921     cfResult = CFStringEncodingBytesToUnicode(scriptEncoding,
1922                                               flags,
1923                                               (char *)inCStr,
1924                                               strlen(inCStr),
1925                                               &srcCharsUsed,
1926                                               uniStr,
1927                                               512,
1928                                               &unicodeChars);
1929     if (cfResult == 0) {
1930         cfResult = CFStringEncodingUnicodeToBytes(kCFStringEncodingUTF8,
1931                                                   flags,
1932                                                   uniStr,
1933                                                   unicodeChars,
1934                                                   &srcCharsUsed,
1935                                                   (char*)outUTF8Buffer,
1936                                                   outUTF8BufferLength - 1,
1937                                                   &usedByteLen);
1938         outUTF8Buffer[usedByteLen] = '\0';
1939     }
1940
1941     return cfResult;
1942 }
1943
1944 static int
1945 ConvertUTF8ToEncoding(const char* inUTF8Buf,
1946                       int inUTF8BufLength,
1947                       char* outCStrBuffer,
1948                       int outCStrBufferLength,
1949                       unsigned long scriptEncoding,
1950                       unsigned long flags)
1951 {
1952     unsigned long unicodeChars;
1953     unsigned long srcCharsUsed;
1954     unsigned long usedByteLen = 0;
1955     UniChar uniStr[256];
1956     unsigned long cfResult;
1957
1958     cfResult = CFStringEncodingBytesToUnicode(kCFStringEncodingUTF8,
1959                                               flags,
1960                                               (char*)inUTF8Buf,
1961                                               inUTF8BufLength,
1962                                               &srcCharsUsed,
1963                                               uniStr,
1964                                               255,
1965                                               &unicodeChars);
1966     if (cfResult == 0) {
1967         cfResult = CFStringEncodingUnicodeToBytes(scriptEncoding,
1968                                                   flags,
1969                                                   uniStr,
1970                                                   unicodeChars,
1971                                                   &srcCharsUsed,
1972                                                   (char*)outCStrBuffer,
1973                                                   outCStrBufferLength - 1,
1974                                                   &usedByteLen);
1975         outCStrBuffer[usedByteLen] = '\0';
1976     }
1977
1978     return cfResult;
1979 }
1980
1981 #elif HAVE_ICONV
1982 #include <iconv.h>
1983
1984 static int
1985 ConvertEncodingByIconv(const char *src, char *dst, int dstsize,
1986                        const char *srcEnc, const char *dstEnc)
1987 {
1988     iconv_t ic;
1989     static char szTmpBuf[2048];
1990     char *src_p;
1991     char *dst_p;
1992     size_t sLen;
1993     size_t iLen;
1994
1995     dst_p = &szTmpBuf[0];
1996     iLen = (size_t)sizeof(szTmpBuf)-1;
1997     src_p = (char *)src;
1998     sLen = (size_t)strlen(src);
1999     memset(szTmpBuf, 0, sizeof(szTmpBuf));
2000     memset(dst, 0, dstsize);
2001
2002     ic = iconv_open(dstEnc, srcEnc);
2003     if (ic == (iconv_t)-1) {
2004         error("iconv_open() failure: %s", strerror(errno));
2005         return -1;
2006     }
2007
2008     if (iconv(ic, &src_p, &sLen, &dst_p, &iLen) == (size_t)-1) {
2009         error("iconv() failure: %s", strerror(errno));
2010         iconv_close(ic);
2011         return -1;
2012     }
2013
2014     strncpy(dst, szTmpBuf, dstsize);
2015
2016     iconv_close(ic);
2017
2018     return 0;
2019 }
2020 #endif /* defined(__APPLE__) */
2021
2022 char *
2023 sjis_to_utf8(char *dst, const char *src, size_t dstsize)
2024 {
2025 #if defined(__APPLE__)
2026   dst[0] = '\0';
2027   if (ConvertEncodingToUTF8(src, dst, dstsize,
2028                             kCFStringEncodingDOSJapanese,
2029                             kCFStringEncodingUseHFSPlusCanonical) == 0)
2030       return dst;
2031 #elif HAVE_ICONV
2032   if (ConvertEncodingByIconv(src, dst, dstsize, "SJIS", "UTF-8") != -1)
2033       return dst;
2034 #else
2035   error("not support utf-8 conversion");
2036 #endif
2037
2038   if (dstsize < 1) return dst;
2039   dst[dstsize-1] = 0;
2040   return strncpy(dst, src, dstsize-1);
2041 }
2042
2043 char *
2044 utf8_to_sjis(char *dst, const char *src, size_t dstsize)
2045 {
2046 #if defined(__APPLE__)
2047   int srclen;
2048
2049   dst[0] = '\0';
2050   srclen = strlen(src);
2051   if (ConvertUTF8ToEncoding(src, srclen, dst, dstsize,
2052                             kCFStringEncodingDOSJapanese,
2053                             kCFStringEncodingUseHFSPlusCanonical) == 0)
2054       return dst;
2055 #elif HAVE_ICONV
2056   if (ConvertEncodingByIconv(src, dst, dstsize, "UTF-8", "SJIS") != -1)
2057       return dst;
2058 #else
2059   error("not support utf-8 conversion");
2060 #endif
2061
2062   if (dstsize < 1) return dst;
2063   dst[dstsize-1] = 0;
2064   return strncpy(dst, src, dstsize-1);
2065 }
2066
2067 /*
2068  * SJIS <-> EUC 変換関数
2069  * 「日本語情報処理」   ソフトバンク(株)
2070  *  より抜粋(by Koji Arai)
2071  */
2072 void
2073 euc2sjis(int *p1, int *p2)
2074 {
2075     unsigned char c1 = *p1 & 0x7f;
2076     unsigned char c2 = *p2 & 0x7f;
2077     int rowoff = c1 < 0x5f ? 0x70 : 0xb0;
2078     int celoff = c1 % 2 ? (c2 > 0x5f ? 0x20 : 0x1f) : 0x7e;
2079     *p1 = ((c1 + 1) >> 1) + rowoff;
2080     *p2 += celoff - 0x80;
2081 }
2082
2083 void
2084 sjis2euc(int *p1, int *p2)
2085 {
2086     unsigned char c1 = *p1;
2087     unsigned char c2 = *p2;
2088     int adjust = c2 < 0x9f;
2089     int rowoff = c1 < 0xa0 ? 0x70 : 0xb0;
2090     int celoff = adjust ? (c2 > 0x7f ? 0x20 : 0x1f) : 0x7e;
2091     *p1 = ((c1 - rowoff) << 1) - adjust;
2092     *p2 -= celoff;
2093
2094     *p1 |= 0x80;
2095     *p2 |= 0x80;
2096 }
2097
2098 static int
2099 hex2int(int c)
2100 {
2101     switch (c) {
2102     case '0': case '1': case '2': case '3': case '4':
2103     case '5': case '6': case '7': case '8': case '9':
2104         return c - '0';
2105
2106     case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
2107         return c - 'a' + 10;
2108
2109     case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
2110         return c - 'A' + 10;
2111     default:
2112         return -1;
2113     }
2114 }
2115
2116 static int
2117 int2hex(int c)
2118 {
2119     switch (c) {
2120     case 0: case 1: case 2: case 3: case 4:
2121     case 5: case 6: case 7: case 8: case 9:
2122         return c + '0';
2123
2124     case 10: case 11: case 12: case 13: case 14: case 15:
2125         return c + 'a' - 10;
2126
2127     default:
2128         return -1;
2129     }
2130 }
2131
2132 int
2133 cap_to_sjis(char *dst, const char *src, size_t dstsize)
2134 {
2135     int i, j;
2136     size_t len = strlen(src);
2137     int a, b;
2138
2139     for (i = j = 0; i < len && i < dstsize; i++) {
2140         if (src[i] != ':') {
2141             dst[j++] = src[i];
2142             continue;
2143         }
2144
2145         i++;
2146         a = hex2int((unsigned char)src[i]);
2147         b = hex2int((unsigned char)src[i+1]);
2148
2149         if (a == -1 || b == -1) {
2150             /* leave as it */
2151             dst[j++] = ':';
2152             strncpy(dst+j, src+i, dstsize-j);
2153             dst[dstsize-1] = 0;
2154             return strlen(dst);
2155         }
2156
2157         i++;
2158
2159         dst[j++] = a * 16 + b;
2160     }
2161     dst[j] = 0;
2162     return j;
2163 }
2164
2165 int
2166 sjis_to_cap(char *dst, const char *src, size_t dstsize)
2167 {
2168     int i, j;
2169     size_t len = strlen(src);
2170     int a, b;
2171
2172     for (i = j = 0; i < len && i < dstsize; i++) {
2173         if (src[i] == ':') {
2174             strncpy(dst+j, ":3a", dstsize-j);
2175             dst[dstsize-1] = 0;
2176             j = strlen(dst);
2177             continue;
2178         }
2179         if (isprint(src[i])) {
2180             dst[j++] = src[i];
2181             continue;
2182         }
2183
2184         if (j + 3 >= dstsize) {
2185             dst[j] = 0;
2186             return j;
2187         }
2188
2189         a = int2hex((unsigned char)src[i] / 16);
2190         b = int2hex((unsigned char)src[i] % 16);
2191
2192         dst[j++] = ':';
2193         dst[j++] = a;
2194         dst[j++] = b;
2195     }
2196     dst[j] = 0;
2197     return j;
2198 }
2199 #endif /* MULTIBYTE_FILENAME */