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