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 /* ------------------------------------------------------------------------ */
  14 #include "lha.h"
  15
  16 #if !STRCHR_8BIT_CLEAN
  17 /* should use 8 bit clean version */
  18 #undef strchr
  19 #undef strrchr
  20 #define strchr  xstrchr
  21 #define strrchr  xstrrchr
  22 #endif
  23
  24 /* ------------------------------------------------------------------------ */
  25 static char    *get_ptr;
  26 #define setup_get(PTR)  (get_ptr = (PTR))
  27 #define get_byte()              (*get_ptr++ & 0xff)
  28 #define put_ptr                 get_ptr
  29 #define setup_put(PTR)  (put_ptr = (PTR))
  30 #define put_byte(c)             (*put_ptr++ = (char)(c))
  31
  32 int optional_archive_kanji_code = NONE;
  33 int optional_system_kanji_code = NONE;
  34 char *optional_archive_delim = NULL;
  35 char *optional_system_delim = NULL;
  36 int optional_filename_case = NONE;
  37
  38 #ifdef MULTIBYTE_FILENAME
  39 int default_system_kanji_code = MULTIBYTE_FILENAME;
  40 #else
  41 int default_system_kanji_code = NONE;
  42 #endif
  43
  44 /* ------------------------------------------------------------------------ */
  45 int
  46 calc_sum(p, len)
  47         register char  *p;
  48         register int    len;
  49 {
  50         register int    sum;
  51
  52         for (sum = 0; len; len--)
  53                 sum += *p++;
  54
  55         return sum & 0xff;
  56 }
  57
  58 /* ------------------------------------------------------------------------ */
  59 static unsigned short
  60 get_word()
  61 {
  62         int             b0, b1;
  63
  64         b0 = get_byte();
  65         b1 = get_byte();
  66         return (b1 << 8) + b0;
  67 }
  68
  69 /* ------------------------------------------------------------------------ */
  70 static void
  71 put_word(v)
  72         unsigned int    v;
  73 {
  74         put_byte(v);
  75         put_byte(v >> 8);
  76 }
  77
  78 /* ------------------------------------------------------------------------ */
  79 static long
  80 get_longword()
  81 {
  82         long            b0, b1, b2, b3;
  83
  84         b0 = get_byte();
  85         b1 = get_byte();
  86         b2 = get_byte();
  87         b3 = get_byte();
  88         return (b3 << 24) + (b2 << 16) + (b1 << 8) + b0;
  89 }
  90
  91 /* ------------------------------------------------------------------------ */
  92 static void
  93 put_longword(v)
  94         long            v;
  95 {
  96         put_byte(v);
  97         put_byte(v >> 8);
  98         put_byte(v >> 16);
  99         put_byte(v >> 24);
 100 }
 101
 102 static int
 103 get_bytes(buf, len, size)
 104     char *buf;
 105     int len, size;
 106 {
 107     int i;
 108     for (i = 0; i < len && i < size; i++)
 109         buf[i] = get_ptr[i];
 110     get_ptr += len;
 111     return i;
 112 }
 113
 114 static void
 115 put_bytes(buf, len)
 116     char *buf;
 117     int len;
 118 {
 119     int i;
 120     for (i = 0; i < len; i++)
 121         put_byte(buf[i]);
 122 }
 123
 124 /* added by Koji Arai */
 125 void
 126 convert_filename(name, len, size,
 127                  from_code, to_code,
 128                  from_delim, to_delim,
 129                  case_to)
 130     char *name;
 131     int len;
 132     int size;
 133     int from_code, to_code, case_to;
 134     char *from_delim, *to_delim;
 135
 136 {
 137     int i;
 138 #ifdef MULTIBYTE_FILENAME
 139     char tmp[FILENAME_LENGTH];
 140
 141     if (from_code == CODE_SJIS && to_code == CODE_UTF8) {
 142         for (i = 0; i < len; i++)
 143             /* FIXME: provisionally fix for the Mac OS CoreFoundation */
 144             if ((unsigned char)name[i] == LHA_PATHSEP)  name[i] = '/';
 145         sjis_to_utf8(tmp, name, sizeof(tmp));
 146         strncpy(name, tmp, size);
 147         name[size-1] = 0;
 148         len = strlen(name);
 149         for (i = 0; i < len; i++)
 150             if (name[i] == '/')  name[i] = LHA_PATHSEP;
 151         from_code = CODE_UTF8;
 152     }
 153     else if (from_code == CODE_UTF8 && to_code == CODE_SJIS) {
 154         for (i = 0; i < len; i++)
 155             /* FIXME: provisionally fix for the Mac OS CoreFoundation */
 156             if ((unsigned char)name[i] == LHA_PATHSEP)  name[i] = '/';
 157         utf8_to_sjis(tmp, name, sizeof(tmp));
 158         strncpy(name, tmp, size);
 159         name[size-1] = 0;
 160         len = strlen(name);
 161         for (i = 0; i < len; i++)
 162             if (name[i] == '/')  name[i] = LHA_PATHSEP;
 163         from_code = CODE_SJIS;
 164     }
 165 #endif
 166
 167     for (i = 0; i < len; i ++) {
 168 #ifdef MULTIBYTE_FILENAME
 169         if (from_code == CODE_EUC &&
 170             (unsigned char)name[i] == 0x8e) {
 171             if (to_code != CODE_SJIS) {
 172                 i++;
 173                 continue;
 174             }
 175
 176             /* X0201 KANA */
 177             memmove(name + i, name + i + 1, len - i);
 178             len--;
 179             continue;
 180         }
 181         if (from_code == CODE_SJIS && X0201_KANA_P(name[i])) {
 182             if (to_code != CODE_EUC) {
 183                 continue;
 184             }
 185
 186             if (len == size - 1) /* check overflow */
 187                 len--;
 188             memmove(name+i+1, name+i, len-i);
 189             name[i] = 0x8e;
 190             i++;
 191             len++;
 192             continue;
 193         }
 194         if (from_code == CODE_EUC && (name[i] & 0x80) && (name[i+1] & 0x80)) {
 195             int c1, c2;
 196             if (to_code != CODE_SJIS) {
 197                 i++;
 198                 continue;
 199             }
 200
 201             c1 = (unsigned char)name[i];
 202             c2 = (unsigned char)name[i+1];
 203             euc2sjis(&c1, &c2);
 204             name[i] = c1;
 205             name[i+1] = c2;
 206             i++;
 207             continue;
 208         }
 209         if (from_code == CODE_SJIS &&
 210             SJC_FIRST_P(name[i]) &&
 211             SJC_SECOND_P(name[i+1])) {
 212             int c1, c2;
 213
 214             if (to_code != CODE_EUC) {
 215                 i++;
 216                 continue;
 217             }
 218
 219             c1 = (unsigned char)name[i];
 220             c2 = (unsigned char)name[i+1];
 221             sjis2euc(&c1, &c2);
 222             name[i] = c1;
 223             name[i+1] = c2;
 224             i++;
 225             continue;
 226         }
 227 #endif /* MULTIBYTE_FILENAME */
 228         {
 229             char *ptr;
 230
 231             /* transpose from_delim to to_delim */
 232
 233             if ((ptr = strchr(from_delim, name[i])) != NULL) {
 234                 name[i] = to_delim[ptr - from_delim];
 235                 continue;
 236             }
 237         }
 238
 239         if (case_to == TO_UPPER && islower(name[i])) {
 240             name[i] = toupper(name[i]);
 241             continue;
 242         }
 243         if (case_to == TO_LOWER && isupper(name[i])) {
 244             name[i] = tolower(name[i]);
 245             continue;
 246         }
 247     }
 248 }
 249
 250 /* ------------------------------------------------------------------------ */
 251 /*                                                                                                                                                      */
 252 /* Generic stamp format:                                                                                                        */
 253 /*                                                                                                                                                      */
 254 /* 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16                                                      */
 255 /* |<-------- year ------->|<- month ->|<-- day -->|                                            */
 256 /*                                                                                                                                                      */
 257 /* 15 14 13 12 11 10  9  8  7  6  5  4  3  2  1  0                                                      */
 258 /* |<--- hour --->|<---- minute --->|<- second*2 ->|                                            */
 259 /*                                                                                                                                                      */
 260 /* ------------------------------------------------------------------------ */
 261
 262 /*
 263  * NOTE : If you don't have `gettimeofday(2)', or your gettimeofday(2)
 264  * returns bogus timezone information, try FTIME, MKTIME, TIMELOCAL or TZSET.
 265  */
 266
 267 /* choose one */
 268 #if defined(HAVE_MKTIME)
 269 #ifdef HAVE_TIMELOCAL
 270 #undef HAVE_TIMELOCAL
 271 #endif
 272 #endif                          /* defined(HAVE_MKTIME) */
 273
 274 #if defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL)
 275 #ifdef HAVE_TZSET
 276 #undef HAVE_TZSET
 277 #endif
 278 #endif                          /* defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL) */
 279
 280 #if defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL) || defined(HAVE_TZSET)
 281 #ifdef HAVE_FTIME
 282 #undef HAVE_FTIME
 283 #endif
 284 #endif
 285
 286 #if defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL) || defined(HAVE_TZSET) || defined(HAVE_FTIME)
 287 #ifdef HAVE_GETTIMEOFDAY
 288 #undef HAVE_GETTIMEOFDAY
 289 #endif
 290 #else
 291 #ifndef HAVE_GETTIMEOFDAY
 292 #define HAVE_GETTIMEOFDAY               /* use gettimeofday() */
 293 #endif
 294 #endif
 295
 296 #ifdef HAVE_FTIME
 297 #include <sys/timeb.h>
 298 #endif
 299
 300 /*
 301  * You may define as : #define TIMEZONE_HOOK            \ extern long
 302  * timezone ;   \ extern void tzset();
 303  */
 304 #ifdef TIMEZONE_HOOK
 305 TIMEZONE_HOOK
 306 /* Which do you like better, `TIMEZONE_HOOK' or `TIMEZONE_HOOK;' ? */
 307 #endif
 308
 309 #if defined(HAVE_TZSET) && defined(_MINIX)
 310 extern long     timezone;               /* not defined in time.h */
 311 #endif
 312
 313 /* ------------------------------------------------------------------------ */
 314 #if defined(HAVE_FTIME) || defined(HAVE_GETTIMEOFDAY) || defined(HAVE_TZSET)
 315 static long
 316 gettz()
 317 #ifdef HAVE_TZSET
 318 {
 319         tzset();
 320         return timezone;
 321 }
 322 #endif
 323
 324 /* ------------------------------------------------------------------------ */
 325 #if !defined(HAVE_TZSET) && defined(HAVE_FTIME)
 326 {
 327         struct timeb    buf;
 328
 329         ftime(&buf);
 330         return buf.timezone * 60L;
 331 }
 332 #endif
 333
 334 /* ------------------------------------------------------------------------ */
 335 #if !defined(HAVE_TZSET) && !defined(HAVE_FTIME)        /* maybe defined(HAVE_GETTIMEOFDAY) */
 336 {
 337 #ifdef HAVE_STRUCT_TM_TM_GMTOFF
 338         time_t tt;
 339
 340         time(&tt);
 341         return -localtime(&tt)->tm_gmtoff;
 342 #else /* HAVE_STRUCT_TM_TM_GMTOFF */
 343         struct timeval  tp;
 344         struct timezone tzp;
 345         gettimeofday(&tp, &tzp);/* specific to 4.3BSD */
 346         /*
 347          * return (tzp.tz_minuteswest * 60L + (tzp.tz_dsttime != 0 ? 60L *
 348          * 60L : 0));
 349          */
 350         return (tzp.tz_minuteswest * 60L);
 351 #endif /* HAVE_STRUCT_TM_TM_GMTOFF */
 352 }
 353 #endif
 354 #endif                          /* defined(HAVE_FTIME) || defined(HAVE_GETTIMEOFDAY) ||
 355                      * defined(HAVE_TZSET) */
 356
 357 /* ------------------------------------------------------------------------ */
 358 static          time_t
 359 generic_to_unix_stamp(t)
 360         long            t;
 361 #if defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL)
 362 {
 363         struct tm       dostm;
 364
 365         /*
 366          * special case:  if MSDOS format date and time were zero, then we
 367          * set time to be zero here too.
 368          */
 369         if (t == 0)
 370                 return (time_t) 0;
 371
 372         dostm.tm_sec = (t & 0x1f) * 2;
 373         dostm.tm_min = t >> 5 & 0x3f;
 374         dostm.tm_hour = t >> 11 & 0x1f;
 375         dostm.tm_mday = t >> 16 & 0x1f;
 376         dostm.tm_mon = (t >> (16+5) & 0x0f) - 1;        /* 0..11 */
 377         dostm.tm_year = (t >> (16+9) & 0x7f) + 80;
 378 #if 0
 379         dostm.tm_isdst = 0;     /* correct? */
 380 #endif
 381         dostm.tm_isdst = -1;    /* correct? */
 382 #ifdef HAVE_MKTIME
 383         return (time_t) mktime(&dostm);
 384 #else                           /* maybe defined(HAVE_TIMELOCAL) */
 385         return (time_t) timelocal(&dostm);
 386 #endif
 387 }
 388
 389 #else                           /* defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL) */
 390 {
 391         int             year, month, day, hour, min, sec;
 392         long            longtime;
 393         static unsigned int dsboy[12] = {0, 31, 59, 90, 120, 151,
 394         181, 212, 243, 273, 304, 334};
 395         unsigned int    days;
 396
 397         /*
 398          * special case:  if MSDOS format date and time were zero, then we
 399          * set time to be zero here too.
 400          */
 401         if (t == 0)
 402                 return (time_t) 0;
 403
 404         year = ((int) (t >> 16 + 9) & 0x7f) + 1980;
 405         month = (int) (t >> 16 + 5) & 0x0f;     /* 1..12 means Jan..Dec */
 406         day = (int) (t >> 16) & 0x1f;   /* 1..31 means 1st,...31st */
 407
 408         hour = ((int) t >> 11) & 0x1f;
 409         min = ((int) t >> 5) & 0x3f;
 410         sec = ((int) t & 0x1f) * 2;
 411
 412         /* Calculate days since 1970.01.01 */
 413         days = (365 * (year - 1970) +   /* days due to whole years */
 414                 (year - 1970 + 1) / 4 + /* days due to leap years */
 415                 dsboy[month - 1] +      /* days since beginning of this year */
 416                 day - 1);       /* days since beginning of month */
 417
 418         if ((year % 4 == 0) &&
 419                 (year % 100 != 0 || year % 400 == 0) &&         /* 1999.5.24 t.oka */
 420             (month >= 3))       /* if this is a leap year and month */
 421                 days++;         /* is March or later, add a day */
 422
 423         /* Knowing the days, we can find seconds */
 424         longtime = (((days * 24) + hour) * 60 + min) * 60 + sec;
 425         longtime += gettz();    /* adjust for timezone */
 426
 427         /* LONGTIME is now the time in seconds, since 1970/01/01 00:00:00.  */
 428         return (time_t) longtime;
 429 }
 430 #endif                          /* defined(HAVE_MKTIME) || defined(HAVE_TIMELOCAL) */
 431
 432 /* ------------------------------------------------------------------------ */
 433 static long
 434 unix_to_generic_stamp(t)
 435         time_t          t;
 436 {
 437         struct tm      *tm = localtime(&t);
 438
 439         return ((((long) (tm->tm_year - 80)) << 25) +
 440                 (((long) (tm->tm_mon + 1)) << 21) +
 441                 (((long) tm->tm_mday) << 16) +
 442                 (long) ((tm->tm_hour << 11) +
 443                         (tm->tm_min << 5) +
 444                         (tm->tm_sec / 2)));
 445 }
 446
 447 /* ------------------------------------------------------------------------ */
 448 /* build header functions                                                                                                       */
 449 /* ------------------------------------------------------------------------ */
 450
 451 /*
 452  * extended header
 453  *
 454  *             size  field name
 455  *  --------------------------------
 456  *  base header:         :
 457  *                2  next-header size  [*1]
 458  *  --------------------------------------
 459  *  ext header:   1  ext-type            ^
 460  *                ?  contents            | [*1] next-header size
 461  *                2  next-header size    v
 462  *  --------------------------------------
 463  *
 464  */
 465 static int
 466 get_extended_header(fp, hdr, header_size)
 467     FILE *fp;
 468     LzHeader *hdr;
 469     int header_size;
 470 {
 471     char data[LZHEADER_STRAGE];
 472     int name_length;
 473     char dirname[FILENAME_LENGTH];
 474     int dir_length = 0;
 475     int i;
 476     int whole_size = header_size;
 477
 478     if (hdr->header_level == 0)
 479         return 0;
 480
 481     name_length = strlen(hdr->name);
 482
 483     for (; header_size != 0; whole_size += header_size = get_word()) {
 484         setup_get(data);
 485         if (sizeof(data) < header_size) {
 486             error("header size too large.");
 487             exit(1);
 488         }
 489
 490         if (fread(data, header_size, 1, fp) == 0) {
 491             error("Invalid header (LHa file ?)");
 492             return -1;
 493         }
 494         switch (get_byte()) {
 495         case 0:
 496             /* header crc */
 497             setup_get(get_ptr + header_size - 3); /* FIXME: ignored? */
 498             break;
 499         case 1:
 500             /* filename */
 501             name_length =
 502                 get_bytes(hdr->name, header_size-3, sizeof(hdr->name)-1);
 503             hdr->name[name_length] = 0;
 504             break;
 505         case 2:
 506             /* directory */
 507             dir_length = get_bytes(dirname, header_size-3, sizeof(dirname)-1);
 508             dirname[dir_length] = 0;
 509             break;
 510         case 0x40:
 511             /* MS-DOS attribute */
 512             if (hdr->extend_type == EXTEND_MSDOS ||
 513                 hdr->extend_type == EXTEND_HUMAN ||
 514                 hdr->extend_type == EXTEND_GENERIC)
 515                 hdr->attribute = get_word();
 516             break;
 517         case 0x50:
 518             /* UNIX permission */
 519             if (hdr->extend_type == EXTEND_UNIX)
 520                 hdr->unix_mode = get_word();
 521             break;
 522         case 0x51:
 523             /* UNIX gid and uid */
 524             if (hdr->extend_type == EXTEND_UNIX) {
 525                 hdr->unix_gid = get_word();
 526                 hdr->unix_uid = get_word();
 527             }
 528             break;
 529         case 0x52:
 530             /* UNIX group name */
 531             if (hdr->extend_type == EXTEND_UNIX) {
 532                 i = get_bytes(hdr->group, header_size-3, sizeof(hdr->group)-1);
 533                 hdr->group[i] = '\0';
 534             }
 535             break;
 536         case 0x53:
 537             /* UNIX user name */
 538             if (hdr->extend_type == EXTEND_UNIX) {
 539                 i = get_bytes(hdr->user, header_size-3, sizeof(hdr->user)-1);
 540                 hdr->user[i] = '\0';
 541             }
 542             break;
 543         case 0x54:
 544             /* UNIX last modified time */
 545             if (hdr->extend_type == EXTEND_UNIX)
 546                 hdr->unix_last_modified_stamp = (time_t) get_longword();
 547             break;
 548         default:
 549             /* other headers */
 550             setup_get(get_ptr + header_size - 3);
 551             break;
 552         }
 553     }
 554
 555     if (dir_length) {
 556         if (name_length + dir_length >= sizeof(hdr->name)) {
 557             warning("the length of pathname \"%s%s\" is too long.",
 558                     dirname, hdr->name);
 559             name_length = sizeof(hdr->name) - dir_length - 1;
 560             hdr->name[name_length] = 0;
 561         }
 562         strcat(dirname, hdr->name);
 563         strcpy(hdr->name, dirname);
 564         name_length += dir_length;
 565     }
 566
 567     return whole_size;
 568 }
 569
 570 /*
 571  * level 0 header
 572  *
 573  *
 574  * offset  size  field name
 575  * ----------------------------------
 576  *     0      1  header size    [*1]
 577  *     1      1  header sum
 578  *            ---------------------------------------
 579  *     2      5  method ID                         ^
 580  *     7      4  packed size    [*2]               |
 581  *    11      4  original size                     |
 582  *    15      2  time                              |
 583  *    17      2  date                              |
 584  *    19      1  attribute                         | [*1] header size (X+Y+22)
 585  *    20      1  level (0x00 fixed)                |
 586  *    21      1  name length                       |
 587  *    22      X  pathname                          |
 588  * X +22      2  file crc                          |
 589  * X +24      Y  ext-header(old style)             v
 590  * -------------------------------------------------
 591  * X+Y+24   [*2] data
 592  *            :
 593  *
 594  * ext-header(old style)
 595  *     0      1  ext-type ('U')
 596  *     1      1  minor version
 597  *     2      4  UNIX time
 598  *     6      2  mode
 599  *     8      2  uid
 600  *    10      2  gid
 601  *
 602  */
 603 static int
 604 get_header_level0(fp, hdr, data)
 605     FILE *fp;
 606     LzHeader *hdr;
 607     char *data;
 608 {
 609     int header_size;
 610     int checksum;
 611     int name_length;
 612     int i;
 613     int extend_size;
 614
 615     hdr->header_size = header_size = get_byte();
 616     checksum = get_byte();
 617
 618     if (fread(data+I_NAME_LENGTH, header_size+2-I_NAME_LENGTH, 1, fp) == 0) {
 619         error("Invalid header (LHarc file ?)");
 620         return FALSE;   /* finish */
 621     }
 622
 623     if (calc_sum(data + I_METHOD, header_size) != checksum) {
 624         error("Checksum error (LHarc file?)");
 625         return FALSE;
 626     }
 627
 628     get_bytes(hdr->method, 5, sizeof(hdr->method));
 629     hdr->packed_size = get_longword();
 630     hdr->original_size = get_longword();
 631     hdr->unix_last_modified_stamp = generic_to_unix_stamp(get_longword());
 632     hdr->attribute = get_byte(); /* MS-DOS attribute */
 633     hdr->header_level = get_byte();
 634     name_length = get_byte();
 635     i = get_bytes(hdr->name, name_length, sizeof(hdr->name)-1);
 636     hdr->name[i] = '\0';
 637
 638     /* defaults for other type */
 639     hdr->unix_mode = UNIX_FILE_REGULAR | UNIX_RW_RW_RW;
 640     hdr->unix_gid = 0;
 641     hdr->unix_uid = 0;
 642
 643     extend_size = header_size+2 - name_length - 24;
 644
 645     if (extend_size < 0) {
 646         if (extend_size == -2) {
 647             /* CRC field does not given */
 648             hdr->extend_type = EXTEND_GENERIC;
 649             hdr->has_crc = FALSE;
 650
 651             return TRUE;
 652         }
 653
 654         error("Unkonwn header (lha file?)");
 655         exit(1);
 656     }
 657
 658     hdr->has_crc = TRUE;
 659     hdr->crc = get_word();
 660
 661     if (extend_size == 0)
 662         return TRUE;
 663
 664     hdr->extend_type = get_byte();
 665     extend_size--;
 666
 667     if (hdr->extend_type == EXTEND_UNIX) {
 668         if (extend_size >= 11) {
 669             hdr->minor_version = get_byte();
 670             hdr->unix_last_modified_stamp = (time_t) get_longword();
 671             hdr->unix_mode = get_word();
 672             hdr->unix_uid = get_word();
 673             hdr->unix_gid = get_word();
 674             extend_size -= 11;
 675         } else {
 676             hdr->extend_type = EXTEND_GENERIC;
 677         }
 678     }
 679     if (extend_size > 0)
 680         setup_get(get_ptr + extend_size);
 681
 682     return TRUE;
 683 }
 684
 685 /*
 686  * level 1 header
 687  *
 688  *
 689  * offset   size  field name
 690  * -----------------------------------
 691  *     0       1  header size   [*1]
 692  *     1       1  header sum
 693  *             -------------------------------------
 694  *     2       5  method ID                        ^
 695  *     7       4  skip size     [*2]               |
 696  *    11       4  original size                    |
 697  *    15       2  time                             |
 698  *    17       2  date                             |
 699  *    19       1  attribute (0x20 fixed)           | [*1] header size (X+Y+25)
 700  *    20       1  level (0x01 fixed)               |
 701  *    21       1  name length                      |
 702  *    22       X  filename                         |
 703  * X+ 22       2  file crc                         |
 704  * X+ 24       1  OS ID                            |
 705  * X +25       Y  ???                              |
 706  * X+Y+25      2  next-header size                 v
 707  * -------------------------------------------------
 708  * X+Y+27      Z  ext-header                       ^
 709  *                 :                               |
 710  * -----------------------------------             | [*2] skip size
 711  * X+Y+Z+27       data                             |
 712  *                 :                               v
 713  * -------------------------------------------------
 714  *
 715  */
 716 static int
 717 get_header_level1(fp, hdr, data)
 718     FILE *fp;
 719     LzHeader *hdr;
 720     char *data;
 721 {
 722     int header_size, extend_size;
 723     int checksum;
 724     int name_length;
 725     int i, dummy;
 726
 727     hdr->header_size = header_size = get_byte();
 728     checksum = get_byte();
 729
 730     if (fread(data+I_NAME_LENGTH, header_size+2-I_NAME_LENGTH, 1, fp) == 0) {
 731         error("Invalid header (LHarc file ?)");
 732         return FALSE;   /* finish */
 733     }
 734
 735     if (calc_sum(data + I_METHOD, header_size) != checksum) {
 736         error("Checksum error (LHarc file?)");
 737         return FALSE;
 738     }
 739
 740     get_bytes(hdr->method, 5, sizeof(hdr->method));
 741     hdr->packed_size = get_longword(); /* skip size */
 742     hdr->original_size = get_longword();
 743     hdr->unix_last_modified_stamp = generic_to_unix_stamp(get_longword());
 744     hdr->attribute = get_byte(); /* 0x20 fixed */
 745     hdr->header_level = get_byte();
 746
 747     name_length = get_byte();
 748     i = get_bytes(hdr->name, name_length, sizeof(hdr->name)-1);
 749     hdr->name[i] = '\0';
 750
 751     /* defaults for other type */
 752     hdr->unix_mode = UNIX_FILE_REGULAR | UNIX_RW_RW_RW;
 753     hdr->unix_gid = 0;
 754     hdr->unix_uid = 0;
 755
 756     hdr->has_crc = TRUE;
 757     hdr->crc = get_word();
 758     hdr->extend_type = get_byte();
 759
 760     dummy = header_size+2 - name_length - 27;
 761     if (dummy > 0)
 762         setup_get(get_ptr + dummy); /* skip old style extend header */
 763
 764     extend_size = get_word();
 765     extend_size = get_extended_header(fp, hdr, extend_size);
 766     if (extend_size == -1)
 767         return FALSE;
 768
 769     /* On level 1 header, size fields should be adjusted. */
 770     /* the `packed_size' field contains the extended header size. */
 771     /* the `header_size' field does not. */
 772     hdr->packed_size -= extend_size;
 773     hdr->header_size += extend_size;
 774
 775     return TRUE;
 776 }
 777
 778 /*
 779  * level 2 header
 780  *
 781  *
 782  * offset   size  field name
 783  * --------------------------------------------------
 784  *     0       2  total header size [*1]           ^
 785  *             -----------------------             |
 786  *     2       5  method ID                        |
 787  *     7       4  packed size       [*2]           |
 788  *    11       4  original size                    |
 789  *    15       4  time                             |
 790  *    19       1  RESERVED                         | [*1] total header size
 791  *    20       1  level (0x02 fixed)               |      (X+26+(1))
 792  *    21       2  file crc                         |
 793  *    23       1  OS ID                            |
 794  *    24       2  next-header size                 |
 795  * -----------------------------------             |
 796  *    26       X  ext-header                       |
 797  *                 :                               |
 798  * -----------------------------------             |
 799  * X +26      (1) padding                          v
 800  * -------------------------------------------------
 801  * X +26+(1)      data                             ^
 802  *                 :                               | [*2] packed size
 803  *                 :                               v
 804  * -------------------------------------------------
 805  *
 806  */
 807 static int
 808 get_header_level2(fp, hdr, data)
 809     FILE *fp;
 810     LzHeader *hdr;
 811     char *data;
 812 {
 813     int header_size, extend_size;
 814     int padding;
 815
 816     hdr->header_size = header_size = get_word();
 817
 818     if (fread(data + I_NAME_LENGTH, 26 - I_NAME_LENGTH, 1, fp) == 0) {
 819         error("Invalid header (LHarc file ?)");
 820         return FALSE;   /* finish */
 821     }
 822
 823     get_bytes(hdr->method, 5, sizeof(hdr->method));
 824     hdr->packed_size = get_longword();
 825     hdr->original_size = get_longword();
 826     hdr->unix_last_modified_stamp = get_longword();
 827     hdr->attribute = get_byte(); /* reserved */
 828     hdr->header_level = get_byte();
 829
 830     /* defaults for other type */
 831     hdr->unix_mode = UNIX_FILE_REGULAR | UNIX_RW_RW_RW;
 832     hdr->unix_gid = 0;
 833     hdr->unix_uid = 0;
 834
 835     hdr->has_crc = TRUE;
 836     hdr->crc = get_word();
 837     hdr->extend_type = get_byte();
 838     extend_size = get_word();
 839
 840     extend_size = get_extended_header(fp, hdr, extend_size);
 841     if (extend_size == -1)
 842         return FALSE;
 843
 844     padding = header_size - 26 - extend_size;
 845     while (padding--)           /* padding should be 0 or 1 */
 846         fgetc(fp);
 847
 848     /* FIXME: no collate the header CRC */
 849
 850     return TRUE;
 851 }
 852
 853 boolean
 854 get_header(fp, hdr)
 855     FILE *fp;
 856     LzHeader *hdr;
 857 {
 858     char data[LZHEADER_STRAGE];
 859
 860     int archive_kanji_code = CODE_SJIS;
 861     int system_kanji_code = default_system_kanji_code;
 862     char *archive_delim = "\377\\"; /* `\' is for level 0 header and
 863                                        broken archive. */
 864     char *system_delim = "//";
 865     int filename_case = NONE;
 866     int end_mark;
 867
 868     memset(hdr, 0, sizeof(LzHeader));
 869
 870     setup_get(data);
 871
 872     if ((end_mark = getc(fp)) == EOF || end_mark == 0) {
 873         return FALSE;           /* finish */
 874     }
 875     data[0] = end_mark;
 876
 877     if (fread(data + 1, I_NAME_LENGTH - 1, 1, fp) == 0) {
 878         error("Invalid header (LHarc file ?)");
 879         return FALSE;           /* finish */
 880     }
 881
 882     switch (data[I_HEADER_LEVEL]) {
 883     case 0:
 884         if (get_header_level0(fp, hdr, data) == FALSE)
 885             return FALSE;
 886         break;
 887     case 1:
 888         if (get_header_level1(fp, hdr, data) == FALSE)
 889             return FALSE;
 890         break;
 891     case 2:
 892         if (get_header_level2(fp, hdr, data) == FALSE)
 893             return FALSE;
 894         break;
 895     default:
 896         error("Unknown level header (level %d)", data[I_HEADER_LEVEL]);
 897         return FALSE;
 898     }
 899
 900     /* filename conversion */
 901     switch (hdr->extend_type) {
 902     case EXTEND_MSDOS:
 903         filename_case = noconvertcase ? NONE : TO_LOWER;
 904         break;
 905     case EXTEND_HUMAN:
 906     case EXTEND_OS68K:
 907     case EXTEND_XOSK:
 908     case EXTEND_UNIX:
 909         filename_case = NONE;
 910         break;
 911
 912     case EXTEND_MACOS:
 913         archive_delim = "\377/:\\";
 914                           /* `\' is for level 0 header and broken archive. */
 915         system_delim = "/://";
 916         filename_case = NONE;
 917         break;
 918
 919     default:
 920         filename_case = noconvertcase ? NONE : TO_LOWER;
 921         /* FIXME: if small letter is included in filename,
 922            the generic_to_unix_filename() do not case conversion,
 923            but this code does not consider it. */
 924         break;
 925     }
 926
 927     if (optional_archive_kanji_code)
 928         archive_kanji_code = optional_archive_kanji_code;
 929     if (optional_system_kanji_code)
 930         system_kanji_code = optional_system_kanji_code;
 931     if (optional_archive_delim)
 932         archive_delim = optional_archive_delim;
 933     if (optional_system_delim)
 934         system_delim = optional_system_delim;
 935     if (optional_filename_case)
 936         filename_case = optional_filename_case;
 937
 938     /* kanji code and delimiter conversion */
 939     convert_filename(hdr->name, strlen(hdr->name), sizeof(hdr->name),
 940                      archive_kanji_code,
 941                      system_kanji_code,
 942                      archive_delim, system_delim, filename_case);
 943
 944     return TRUE;
 945 }
 946
 947 /* ------------------------------------------------------------------------ */
 948 void
 949 init_header(name, v_stat, hdr)
 950         char           *name;
 951         struct stat    *v_stat;
 952         LzHeader       *hdr;
 953 {
 954         int             len;
 955
 956     memset(hdr, 0, sizeof(LzHeader));
 957
 958         if (compress_method == LZHUFF5_METHOD_NUM)  /* Changed N.Watazaki */
 959                 memcpy(hdr->method, LZHUFF5_METHOD, METHOD_TYPE_STRAGE);
 960         else if (compress_method)
 961                 memcpy(hdr->method, LZHUFF1_METHOD, METHOD_TYPE_STRAGE);
 962         else
 963                 memcpy(hdr->method, LZHUFF0_METHOD, METHOD_TYPE_STRAGE);
 964
 965         hdr->packed_size = 0;
 966         hdr->original_size = v_stat->st_size;
 967         hdr->attribute = GENERIC_ATTRIBUTE;
 968         hdr->header_level = header_level;
 969         strcpy(hdr->name, name);
 970         len = strlen(name);
 971         hdr->crc = 0x0000;
 972         hdr->extend_type = EXTEND_UNIX;
 973         hdr->unix_last_modified_stamp = v_stat->st_mtime;
 974         /* since 00:00:00 JAN.1.1970 */
 975 #ifdef NOT_COMPATIBLE_MODE
 976         /* Please need your modification in this space. */
 977 #else
 978         hdr->unix_mode = v_stat->st_mode;
 979 #endif
 980
 981         hdr->unix_uid = v_stat->st_uid;
 982         hdr->unix_gid = v_stat->st_gid;
 983
 984 #if INCLUDE_OWNER_NAME_IN_HEADER
 985 #if HAVE_GETPWUID
 986     {
 987         struct passwd *ent = getpwuid(hdr->unix_uid);
 988
 989         if (ent) {
 990             strncpy(hdr->user, ent->pw_name, sizeof(hdr->user));
 991             if (hdr->user[sizeof(hdr->user)-1])
 992                 hdr->user[sizeof(hdr->user)-1] = 0;
 993         }
 994     }
 995 #endif
 996 #if HAVE_GETGRGID
 997     {
 998         struct group *ent = getgrgid(hdr->unix_gid);
 999
1000         if (ent) {
1001             strncpy(hdr->group, ent->gr_name, sizeof(hdr->group));
1002             if (hdr->group[sizeof(hdr->group)-1])
1003                 hdr->group[sizeof(hdr->group)-1] = 0;
1004         }
1005     }
1006 #endif
1007 #endif /* INCLUDE_OWNER_NAME_IN_HEADER */
1008         if (is_directory(v_stat)) {
1009                 memcpy(hdr->method, LZHDIRS_METHOD, METHOD_TYPE_STRAGE);
1010                 hdr->attribute = GENERIC_DIRECTORY_ATTRIBUTE;
1011                 hdr->original_size = 0;
1012                 if (len > 0 && hdr->name[len - 1] != '/')
1013                         strcpy(&hdr->name[len++], "/");
1014         }
1015
1016 #ifdef S_IFLNK
1017         if (is_symlink(v_stat)) {
1018                 char    lkname[FILENAME_LENGTH];
1019                 int             len;
1020                 memcpy(hdr->method, LZHDIRS_METHOD, METHOD_TYPE_STRAGE);
1021                 hdr->attribute = GENERIC_DIRECTORY_ATTRIBUTE;
1022                 hdr->original_size = 0;
1023                 len = readlink(name, lkname, sizeof(lkname));
1024                 if (xsnprintf(hdr->name, sizeof(hdr->name),
1025                       "%s|%.*s", hdr->name, len, lkname) == -1)
1026             error("file name is too long (%s -> %.*s)", hdr->name, len, lkname);
1027         }
1028 #endif
1029 }
1030
1031 /* ------------------------------------------------------------------------ */
1032 /* Write unix extended header or generic header. */
1033
1034 static int
1035 write_header_level0(data, hdr, lzname)
1036     LzHeader *hdr;
1037     char *data, *lzname;
1038 {
1039     int limit;
1040     int name_length;
1041     int header_size;
1042
1043     setup_put(data);
1044     memset(data, 0, LZHEADER_STRAGE);
1045
1046     put_byte(0x00);             /* header size */
1047     put_byte(0x00);             /* check sum */
1048     put_bytes(hdr->method, 5);
1049     put_longword(hdr->packed_size);
1050     put_longword(hdr->original_size);
1051     put_longword(unix_to_generic_stamp(hdr->unix_last_modified_stamp));
1052     put_byte(hdr->attribute);
1053     put_byte(hdr->header_level); /* level 0 */
1054
1055     /* level 0 header: write pathname (contain the directory part) */
1056     name_length = strlen(lzname);
1057     if (generic_format)
1058         limit = 255 - I_GENERIC_HEADER_BOTTOM + 2;
1059     else
1060         limit = 255 - I_UNIX_EXTEND_BOTTOM + 2;
1061
1062     if (name_length > limit) {
1063         warning("the length of pathname \"%s\" is too long.", lzname);
1064         name_length = limit;
1065     }
1066     put_byte(name_length);
1067     put_bytes(lzname, name_length);
1068     put_word(hdr->crc);
1069
1070     if (generic_format) {
1071         header_size = I_GENERIC_HEADER_BOTTOM + name_length - 2;
1072         data[I_HEADER_SIZE] = header_size;
1073         data[I_HEADER_CHECKSUM] = calc_sum(data + I_METHOD, header_size);
1074     } else {
1075         /* write old-style extend header */
1076         put_byte(EXTEND_UNIX);
1077         put_byte(CURRENT_UNIX_MINOR_VERSION);
1078         put_longword(hdr->unix_last_modified_stamp);
1079         put_word(hdr->unix_mode);
1080         put_word(hdr->unix_uid);
1081         put_word(hdr->unix_gid);
1082
1083         /* size of extended header is 12 */
1084         header_size = I_UNIX_EXTEND_BOTTOM + name_length - 2;
1085         data[I_HEADER_SIZE] = header_size;
1086         data[I_HEADER_CHECKSUM] = calc_sum(data + I_METHOD, header_size);
1087     }
1088
1089     return header_size + 2;
1090 }
1091
1092 static int
1093 write_header_level1(data, hdr, lzname)
1094     LzHeader *hdr;
1095     char *data, *lzname;
1096 {
1097     int name_length, dir_length, limit;
1098     char *basename, *dirname;
1099     int header_size;
1100     char *extend_header_top;
1101     int extend_header_size;
1102
1103     basename = strrchr(lzname, LHA_PATHSEP);
1104     if (basename) {
1105         basename++;
1106         name_length = strlen(basename);
1107         dirname = lzname;
1108         dir_length = basename - dirname;
1109     }
1110     else {
1111         basename = lzname;
1112         name_length = strlen(basename);
1113         dirname = "";
1114         dir_length = 0;
1115     }
1116
1117     setup_put(data);
1118     memset(data, 0, LZHEADER_STRAGE);
1119
1120     put_byte(0x00);             /* header size */
1121     put_byte(0x00);             /* check sum */
1122     put_bytes(hdr->method, 5);
1123     put_longword(hdr->packed_size);
1124     put_longword(hdr->original_size);
1125     put_longword(unix_to_generic_stamp(hdr->unix_last_modified_stamp));
1126     put_byte(0x20);
1127     put_byte(hdr->header_level); /* level 1 */
1128
1129     /* level 1 header: write filename (basename only) */
1130     limit = 255 - 27 + 2;
1131     if (name_length > limit) {
1132         put_byte(0);            /* name length */
1133     }
1134     else {
1135         put_byte(name_length);
1136         put_bytes(basename, name_length);
1137     }
1138
1139     put_word(hdr->crc);
1140
1141     if (generic_format)
1142         put_byte(0x00);
1143     else
1144         put_byte(EXTEND_UNIX);
1145
1146     /* write extend header from here. */
1147
1148     extend_header_top = put_ptr+2; /* +2 for the field `next header size' */
1149     header_size = extend_header_top - data - 2;
1150
1151     /* write filename and dirname */
1152
1153     if (name_length > limit) {
1154         put_word(name_length + 3); /* size */
1155         put_byte(0x01);         /* filename */
1156         put_bytes(basename, name_length);
1157     }
1158
1159     if (dir_length > 0) {
1160         put_word(dir_length + 3); /* size */
1161         put_byte(0x02);         /* dirname */
1162         put_bytes(dirname, dir_length);
1163     }
1164
1165     if (!generic_format) {
1166         /* UNIX specific informations */
1167
1168         put_word(5);            /* size */
1169         put_byte(0x50);         /* permission */
1170         put_word(hdr->unix_mode);
1171
1172         put_word(7);            /* size */
1173         put_byte(0x51);         /* gid and uid */
1174         put_word(hdr->unix_gid);
1175         put_word(hdr->unix_uid);
1176
1177         if (hdr->group[0]) {
1178             int len = strlen(hdr->group);
1179             put_word(len + 3);  /* size */
1180             put_byte(0x52);     /* group name */
1181             put_bytes(hdr->group, len);
1182         }
1183
1184         if (hdr->user[0]) {
1185             int len = strlen(hdr->user);
1186             put_word(len + 3);  /* size */
1187             put_byte(0x53);     /* user name */
1188             put_bytes(hdr->user, len);
1189         }
1190
1191         if (hdr->header_level == 1) {
1192             put_word(7);        /* size */
1193             put_byte(0x54);     /* time stamp */
1194             put_longword(hdr->unix_last_modified_stamp);
1195         }
1196     }       /* if generic .. */
1197
1198     put_word(0x0000);           /* next header size */
1199
1200     extend_header_size = put_ptr - extend_header_top;
1201     /* On level 1 header, the packed size field is contains the ext-header */
1202     hdr->packed_size += put_ptr - extend_header_top;
1203
1204     /* put `skip size' */
1205     setup_put(data + I_PACKED_SIZE);
1206     put_longword(hdr->packed_size);
1207
1208     data[I_HEADER_SIZE] = header_size;
1209     data[I_HEADER_CHECKSUM] = calc_sum(data + I_METHOD, header_size);
1210
1211     return header_size + extend_header_size + 2;
1212 }
1213
1214 static int
1215 write_header_level2(data, hdr, lzname)
1216     LzHeader *hdr;
1217     char *data, *lzname;
1218 {
1219     int name_length, dir_length;
1220     char *basename, *dirname;
1221     int header_size;
1222     char *extend_header_top;
1223     char *headercrc_ptr;
1224     unsigned short  hcrc;
1225
1226     basename = strrchr(lzname, LHA_PATHSEP);
1227     if (basename) {
1228         basename++;
1229         name_length = strlen(basename);
1230         dirname = lzname;
1231         dir_length = basename - dirname;
1232     }
1233     else {
1234         basename = lzname;
1235         name_length = strlen(basename);
1236         dirname = "";
1237         dir_length = 0;
1238     }
1239
1240     setup_put(data);
1241     memset(data, 0, LZHEADER_STRAGE);
1242
1243     put_word(0x0000);           /* header size */
1244     put_bytes(hdr->method, 5);
1245     put_longword(hdr->packed_size);
1246     put_longword(hdr->original_size);
1247     put_longword(hdr->unix_last_modified_stamp);
1248     put_byte(0x20);
1249     put_byte(hdr->header_level); /* level 2 */
1250
1251     put_word(hdr->crc);
1252
1253     if (generic_format)
1254         put_byte(0x00);
1255     else
1256         put_byte(EXTEND_UNIX);
1257
1258     /* write extend header from here. */
1259
1260     extend_header_top = put_ptr+2; /* +2 for the field `next header size' */
1261
1262     /* write common header */
1263     put_word(5);
1264     put_byte(0x00);
1265     headercrc_ptr = put_ptr;
1266     put_word(0x0000);           /* header CRC */
1267
1268     /* write filename and dirname */
1269     /* must have this header, even if the name_length is 0. */
1270     put_word(name_length + 3);  /* size */
1271     put_byte(0x01);             /* filename */
1272     put_bytes(basename, name_length);
1273
1274     if (dir_length > 0) {
1275         put_word(dir_length + 3); /* size */
1276         put_byte(0x02);         /* dirname */
1277         put_bytes(dirname, dir_length);
1278     }
1279
1280     if (!generic_format) {
1281         /* UNIX specific informations */
1282
1283         put_word(5);            /* size */
1284         put_byte(0x50);         /* permission */
1285         put_word(hdr->unix_mode);
1286
1287         put_word(7);            /* size */
1288         put_byte(0x51);         /* gid and uid */
1289         put_word(hdr->unix_gid);
1290         put_word(hdr->unix_uid);
1291
1292         if (hdr->group[0]) {
1293             int len = strlen(hdr->group);
1294             put_word(len + 3);  /* size */
1295             put_byte(0x52);     /* group name */
1296             put_bytes(hdr->group, len);
1297         }
1298
1299         if (hdr->user[0]) {
1300             int len = strlen(hdr->user);
1301             put_word(len + 3);  /* size */
1302             put_byte(0x53);     /* user name */
1303             put_bytes(hdr->user, len);
1304         }
1305
1306         if (hdr->header_level == 1) {
1307             put_word(7);        /* size */
1308             put_byte(0x54);     /* time stamp */
1309             put_longword(hdr->unix_last_modified_stamp);
1310         }
1311     }       /* if generic .. */
1312
1313     put_word(0x0000);           /* next header size */
1314
1315     header_size = put_ptr - data;
1316     if ((header_size & 0xff) == 0) {
1317         /* cannot put zero at the first byte on level 2 header. */
1318         /* adjust header size. */
1319         put_byte(0);            /* padding */
1320         header_size++;
1321     }
1322
1323     /* put hader size */
1324     setup_put(data + I_HEADER_SIZE);
1325     put_word(header_size);
1326
1327     /* put hader CRC in extended header */
1328     hcrc = calc_header_crc(data, (unsigned int) header_size);
1329     setup_put(headercrc_ptr);
1330     put_word(hcrc);
1331
1332     return header_size;
1333 }
1334
1335 void
1336 write_header(fp, hdr)
1337     FILE           *fp;
1338     LzHeader       *hdr;
1339 {
1340     int header_size;
1341     char data[LZHEADER_STRAGE];
1342
1343     int archive_kanji_code = CODE_SJIS;
1344     int system_kanji_code = default_system_kanji_code;
1345     char *archive_delim = "\377";
1346     char *system_delim = "/";
1347     int filename_case = NONE;
1348     char pathname[FILENAME_LENGTH];
1349
1350     if (optional_archive_kanji_code)
1351         archive_kanji_code = optional_archive_kanji_code;
1352     if (optional_system_kanji_code)
1353         system_kanji_code = optional_system_kanji_code;
1354
1355     if (generic_format)
1356         filename_case = TO_UPPER;
1357
1358     if (hdr->header_level == HEADER_LEVEL0) {
1359         archive_delim = "\\";
1360     }
1361
1362     strncpy(pathname, hdr->name, sizeof(pathname));
1363     pathname[sizeof(pathname)-1] = 0;
1364     convert_filename(pathname, strlen(pathname), sizeof(pathname),
1365                      system_kanji_code,
1366                      archive_kanji_code,
1367                      system_delim, archive_delim, filename_case);
1368
1369     switch (hdr->header_level) {
1370     case 0:
1371         header_size = write_header_level0(data, hdr, pathname);
1372         break;
1373     case 1:
1374         header_size = write_header_level1(data, hdr, pathname);
1375         break;
1376     case 2:
1377         header_size = write_header_level2(data, hdr, pathname);
1378         break;
1379     default:
1380         error("Unknown level header (level %d)", hdr->header_level);
1381         exit(1);
1382     }
1383
1384     if (fwrite(data, header_size, 1, fp) == 0)
1385         fatal_error("Cannot write to temporary file");
1386 }
1387
1388 #if MULTIBYTE_FILENAME
1389
1390 #if defined(__APPLE__)
1391
1392 #include <CoreFoundation/CFString.h>
1393 #include <CoreFoundation/CFStringEncodingExt.h>
1394
1395 /* this is not need for Mac OS X v 10.2 later */
1396 enum {
1397   kCFStringEncodingAllowLossyConversion = 1,
1398   kCFStringEncodingBasicDirectionLeftToRight = (1 << 1),
1399   kCFStringEncodingBasicDirectionRightToLeft = (1 << 2),
1400   kCFStringEncodingSubstituteCombinings = (1 << 3),
1401   kCFStringEncodingComposeCombinings = (1 << 4),
1402   kCFStringEncodingIgnoreCombinings = (1 << 5),
1403   kCFStringEncodingUseCanonical = (1 << 6),
1404   kCFStringEncodingUseHFSPlusCanonical = (1 << 7),
1405   kCFStringEncodingPrependBOM = (1 << 8),
1406   kCFStringEncodingDisableCorporateArea = (1 << 9),
1407   kCFStringEncodingASCIICompatibleConversion = (1 << 10),
1408 };
1409
1410 static int
1411 ConvertEncodingToUTF8(const char* inCStr,
1412                       char* outUTF8Buffer,
1413                       int outUTF8BufferLength,
1414                       unsigned long scriptEncoding,
1415                       unsigned long flags)
1416 {
1417     unsigned long unicodeChars;
1418     unsigned long srcCharsUsed;
1419     unsigned long usedByteLen = 0;
1420     UniChar uniStr[512];
1421     unsigned long cfResult;
1422
1423     cfResult = CFStringEncodingBytesToUnicode(scriptEncoding,
1424                                               flags,
1425                                               (char *)inCStr,
1426                                               strlen(inCStr),
1427                                               &srcCharsUsed,
1428                                               uniStr,
1429                                               512,
1430                                               &unicodeChars);
1431     if (cfResult == 0) {
1432         cfResult = CFStringEncodingUnicodeToBytes(kCFStringEncodingUTF8,
1433                                                   flags,
1434                                                   uniStr,
1435                                                   unicodeChars,
1436                                                   &srcCharsUsed,
1437                                                   (char*)outUTF8Buffer,
1438                                                   outUTF8BufferLength - 1,
1439                                                   &usedByteLen);
1440         outUTF8Buffer[usedByteLen] = '\0';
1441     }
1442
1443     return cfResult;
1444 }
1445
1446 static int
1447 ConvertUTF8ToEncoding(const char* inUTF8Buf,
1448                       int inUTF8BufLength,
1449                       char* outCStrBuffer,
1450                       int outCStrBufferLength,
1451                       unsigned long scriptEncoding,
1452                       unsigned long flags)
1453 {
1454     unsigned long unicodeChars;
1455     unsigned long srcCharsUsed;
1456     unsigned long usedByteLen = 0;
1457     UniChar uniStr[256];
1458     unsigned long cfResult;
1459
1460     cfResult = CFStringEncodingBytesToUnicode(kCFStringEncodingUTF8,
1461                                               flags,
1462                                               (char*)inUTF8Buf,
1463                                               inUTF8BufLength,
1464                                               &srcCharsUsed,
1465                                               uniStr,
1466                                               255,
1467                                               &unicodeChars);
1468     if (cfResult == 0) {
1469         cfResult = CFStringEncodingUnicodeToBytes(scriptEncoding,
1470                                                   flags,
1471                                                   uniStr,
1472                                                   unicodeChars,
1473                                                   &srcCharsUsed,
1474                                                   (char*)outCStrBuffer,
1475                                                   outCStrBufferLength - 1,
1476                                                   &usedByteLen);
1477         outCStrBuffer[usedByteLen] = '\0';
1478     }
1479
1480     return cfResult;
1481 }
1482
1483 #elif HAVE_ICONV
1484 #include <iconv.h>
1485
1486 static int
1487 ConvertEncodingByIconv(const char *src, char *dst, int dstsize,
1488                        const char *srcEnc, const char *dstEnc)
1489 {
1490     iconv_t ic;
1491     static char szTmpBuf[2048];
1492     char *src_p;
1493     char *dst_p;
1494     size_t sLen;
1495     size_t iLen;
1496
1497     dst_p = &szTmpBuf[0];
1498     iLen = (size_t)sizeof(szTmpBuf)-1;
1499     src_p = (char *)src;
1500     sLen = (size_t)strlen(src);
1501     memset(szTmpBuf, 0, sizeof(szTmpBuf));
1502     memset(dst, 0, dstsize);
1503
1504     ic = iconv_open(dstEnc, srcEnc);
1505     if (ic == (iconv_t)-1) {
1506         error("iconv_open() failure: %s", strerror(errno));
1507         return -1;
1508     }
1509
1510     if (iconv(ic, &src_p, &sLen, &dst_p, &iLen) == (size_t)-1) {
1511         error("iconv() failure: %s", strerror(errno));
1512         iconv_close(ic);
1513         return -1;
1514     }
1515
1516     strncpy(dst, szTmpBuf, dstsize);
1517
1518     iconv_close(ic);
1519
1520     return 0;
1521 }
1522 #endif /* defined(__APPLE__) */
1523
1524 char *
1525 sjis_to_utf8(char *dst, const char *src, size_t dstsize)
1526 {
1527 #if defined(__APPLE__)
1528   dst[0] = '\0';
1529   if (ConvertEncodingToUTF8(src, dst, dstsize,
1530                             kCFStringEncodingDOSJapanese,
1531                             kCFStringEncodingUseHFSPlusCanonical) == 0)
1532       return dst;
1533 #elif HAVE_ICONV
1534   if (ConvertEncodingByIconv(src, dst, dstsize, "SJIS", "UTF-8") != -1)
1535       return dst;
1536 #else
1537   error("not support utf-8 conversion");
1538 #endif
1539
1540   if (dstsize < 1) return dst;
1541   dst[dstsize-1] = 0;
1542   return strncpy(dst, src, dstsize-1);
1543 }
1544
1545 char *
1546 utf8_to_sjis(char *dst, const char *src, size_t dstsize)
1547 {
1548 #if defined(__APPLE__)
1549   int srclen;
1550
1551   dst[0] = '\0';
1552   srclen = strlen(src);
1553   if (ConvertUTF8ToEncoding(src, srclen, dst, dstsize,
1554                             kCFStringEncodingDOSJapanese,
1555                             kCFStringEncodingUseHFSPlusCanonical) == 0)
1556       return dst;
1557 #elif HAVE_ICONV
1558   if (ConvertEncodingByIconv(src, dst, dstsize, "UTF-8", "SJIS") != -1)
1559       return dst;
1560 #else
1561   error("not support utf-8 conversion");
1562 #endif
1563
1564   if (dstsize < 1) return dst;
1565   dst[dstsize-1] = 0;
1566   return strncpy(dst, src, dstsize-1);
1567 }
1568
1569 /*
1570  * SJIS <-> EUC ÊÑ´¹´Ø¿ô
1571  * ¡ÖÆüËÜ¸ì¾ðÊó½èÍý¡×   ¥½¥Õ¥È¥Ð¥ó¥¯(³ô)
1572  *      ¤è¤êÈ´¿è(by Koji Arai)
1573  */
1574 void
1575 euc2sjis(int *p1, int *p2)
1576 {
1577     unsigned char c1 = *p1 & 0x7f;
1578     unsigned char c2 = *p2 & 0x7f;
1579     int rowoff = c1 < 0x5f ? 0x70 : 0xb0;
1580     int celoff = c1 % 2 ? (c2 > 0x5f ? 0x20 : 0x1f) : 0x7e;
1581     *p1 = ((c1 + 1) >> 1) + rowoff;
1582     *p2 += celoff - 0x80;
1583 }
1584
1585 void
1586 sjis2euc(int *p1, int *p2)
1587 {
1588     unsigned char c1 = *p1;
1589     unsigned char c2 = *p2;
1590     int adjust = c2 < 0x9f;
1591     int rowoff = c1 < 0xa0 ? 0x70 : 0xb0;
1592     int celoff = adjust ? (c2 > 0x7f ? 0x20 : 0x1f) : 0x7e;
1593     *p1 = ((c1 - rowoff) << 1) - adjust;
1594     *p2 -= celoff;
1595
1596     *p1 |= 0x80;
1597     *p2 |= 0x80;
1598 }
1599 #endif /* MULTIBYTE_FILENAME */
1600
1601 /* Local Variables: */
1602 /* mode:c */
1603 /* tab-width:4 */
1604 /* compile-command:"gcc -c header.c" */
1605 /* End: */
1606 /* vi: set tabstop=4: */