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
 867     memset(hdr, 0, sizeof(LzHeader));
 868
 869     setup_get(data);
 870
 871     switch (fread(data, 1, I_NAME_LENGTH, fp)) {
 872     case I_NAME_LENGTH:
 873         break;
 874     case 0:
 875         return FALSE;           /* end of file */
 876     case 1:
 877         if (data[0] == '\0')    /* end mark */
 878             return FALSE;
 879         /* fall through */
 880     default:
 881         error("Invalid header (LHarc file ?)");
 882         return FALSE;   /* finish */
 883     }
 884
 885     switch (data[I_HEADER_LEVEL]) {
 886     case 0:
 887         if (get_header_level0(fp, hdr, data) == FALSE)
 888             return FALSE;
 889         break;
 890     case 1:
 891         if (get_header_level1(fp, hdr, data) == FALSE)
 892             return FALSE;
 893         break;
 894     case 2:
 895         if (get_header_level2(fp, hdr, data) == FALSE)
 896             return FALSE;
 897         break;
 898     default:
 899         error("Unknown level header (level %d)", data[I_HEADER_LEVEL]);
 900         return FALSE;
 901     }
 902
 903     /* filename conversion */
 904     switch (hdr->extend_type) {
 905     case EXTEND_MSDOS:
 906         filename_case = noconvertcase ? NONE : TO_LOWER;
 907         break;
 908     case EXTEND_HUMAN:
 909     case EXTEND_OS68K:
 910     case EXTEND_XOSK:
 911     case EXTEND_UNIX:
 912         filename_case = NONE;
 913         break;
 914
 915     case EXTEND_MACOS:
 916         archive_delim = "\377/:\\";
 917                           /* `\' is for level 0 header and broken archive. */
 918         system_delim = "/://";
 919         filename_case = NONE;
 920         break;
 921
 922     default:
 923         filename_case = noconvertcase ? NONE : TO_LOWER;
 924         /* FIXME: if small letter is included in filename,
 925            the generic_to_unix_filename() do not case conversion,
 926            but this code does not consider it. */
 927         break;
 928     }
 929
 930     if (optional_archive_kanji_code)
 931         archive_kanji_code = optional_archive_kanji_code;
 932     if (optional_system_kanji_code)
 933         system_kanji_code = optional_system_kanji_code;
 934     if (optional_archive_delim)
 935         archive_delim = optional_archive_delim;
 936     if (optional_system_delim)
 937         system_delim = optional_system_delim;
 938     if (optional_filename_case)
 939         filename_case = optional_filename_case;
 940
 941     /* kanji code and delimiter conversion */
 942     convert_filename(hdr->name, strlen(hdr->name), sizeof(hdr->name),
 943                      archive_kanji_code,
 944                      system_kanji_code,
 945                      archive_delim, system_delim, filename_case);
 946
 947     return TRUE;
 948 }
 949
 950 /* ------------------------------------------------------------------------ */
 951 void
 952 init_header(name, v_stat, hdr)
 953         char           *name;
 954         struct stat    *v_stat;
 955         LzHeader       *hdr;
 956 {
 957         int             len;
 958
 959     memset(hdr, 0, sizeof(LzHeader));
 960
 961         if (compress_method == LZHUFF5_METHOD_NUM)  /* Changed N.Watazaki */
 962                 memcpy(hdr->method, LZHUFF5_METHOD, METHOD_TYPE_STRAGE);
 963         else if (compress_method)
 964                 memcpy(hdr->method, LZHUFF1_METHOD, METHOD_TYPE_STRAGE);
 965         else
 966                 memcpy(hdr->method, LZHUFF0_METHOD, METHOD_TYPE_STRAGE);
 967
 968         hdr->packed_size = 0;
 969         hdr->original_size = v_stat->st_size;
 970         hdr->attribute = GENERIC_ATTRIBUTE;
 971         hdr->header_level = header_level;
 972         strcpy(hdr->name, name);
 973         len = strlen(name);
 974         hdr->crc = 0x0000;
 975         hdr->extend_type = EXTEND_UNIX;
 976         hdr->unix_last_modified_stamp = v_stat->st_mtime;
 977         /* since 00:00:00 JAN.1.1970 */
 978 #ifdef NOT_COMPATIBLE_MODE
 979         /* Please need your modification in this space. */
 980 #else
 981         hdr->unix_mode = v_stat->st_mode;
 982 #endif
 983
 984         hdr->unix_uid = v_stat->st_uid;
 985         hdr->unix_gid = v_stat->st_gid;
 986
 987 #if INCLUDE_OWNER_NAME_IN_HEADER
 988 #if HAVE_GETPWUID
 989     {
 990         struct passwd *ent = getpwuid(hdr->unix_uid);
 991
 992         if (ent) {
 993             strncpy(hdr->user, ent->pw_name, sizeof(hdr->user));
 994             if (hdr->user[sizeof(hdr->user)-1])
 995                 hdr->user[sizeof(hdr->user)-1] = 0;
 996         }
 997     }
 998 #endif
 999 #if HAVE_GETGRGID
1000     {
1001         struct group *ent = getgrgid(hdr->unix_gid);
1002
1003         if (ent) {
1004             strncpy(hdr->group, ent->gr_name, sizeof(hdr->group));
1005             if (hdr->group[sizeof(hdr->group)-1])
1006                 hdr->group[sizeof(hdr->group)-1] = 0;
1007         }
1008     }
1009 #endif
1010 #endif /* INCLUDE_OWNER_NAME_IN_HEADER */
1011         if (is_directory(v_stat)) {
1012                 memcpy(hdr->method, LZHDIRS_METHOD, METHOD_TYPE_STRAGE);
1013                 hdr->attribute = GENERIC_DIRECTORY_ATTRIBUTE;
1014                 hdr->original_size = 0;
1015                 if (len > 0 && hdr->name[len - 1] != '/')
1016                         strcpy(&hdr->name[len++], "/");
1017         }
1018
1019 #ifdef S_IFLNK
1020         if (is_symlink(v_stat)) {
1021                 char    lkname[FILENAME_LENGTH];
1022                 int             len;
1023                 memcpy(hdr->method, LZHDIRS_METHOD, METHOD_TYPE_STRAGE);
1024                 hdr->attribute = GENERIC_DIRECTORY_ATTRIBUTE;
1025                 hdr->original_size = 0;
1026                 len = readlink(name, lkname, sizeof(lkname));
1027                 if (xsnprintf(hdr->name, sizeof(hdr->name),
1028                       "%s|%.*s", hdr->name, len, lkname) == -1)
1029             error("file name is too long (%s -> %.*s)", hdr->name, len, lkname);
1030         }
1031 #endif
1032 }
1033
1034 /* ------------------------------------------------------------------------ */
1035 /* Write unix extended header or generic header. */
1036
1037 static int
1038 write_header_level0(data, hdr, lzname)
1039     LzHeader *hdr;
1040     char *data, *lzname;
1041 {
1042     int limit;
1043     int name_length;
1044     int header_size;
1045
1046     setup_put(data);
1047     memset(data, 0, LZHEADER_STRAGE);
1048
1049     put_byte(0x00);             /* header size */
1050     put_byte(0x00);             /* check sum */
1051     put_bytes(hdr->method, 5);
1052     put_longword(hdr->packed_size);
1053     put_longword(hdr->original_size);
1054     put_longword(unix_to_generic_stamp(hdr->unix_last_modified_stamp));
1055     put_byte(hdr->attribute);
1056     put_byte(hdr->header_level); /* level 0 */
1057
1058     /* level 0 header: write pathname (contain the directory part) */
1059     name_length = strlen(lzname);
1060     if (generic_format)
1061         limit = 255 - I_GENERIC_HEADER_BOTTOM + 2;
1062     else
1063         limit = 255 - I_UNIX_EXTEND_BOTTOM + 2;
1064
1065     if (name_length > limit) {
1066         warning("the length of pathname \"%s\" is too long.", lzname);
1067         name_length = limit;
1068     }
1069     put_byte(name_length);
1070     put_bytes(lzname, name_length);
1071     put_word(hdr->crc);
1072
1073     if (generic_format) {
1074         header_size = I_GENERIC_HEADER_BOTTOM + name_length - 2;
1075         data[I_HEADER_SIZE] = header_size;
1076         data[I_HEADER_CHECKSUM] = calc_sum(data + I_METHOD, header_size);
1077     } else {
1078         /* write old-style extend header */
1079         put_byte(EXTEND_UNIX);
1080         put_byte(CURRENT_UNIX_MINOR_VERSION);
1081         put_longword(hdr->unix_last_modified_stamp);
1082         put_word(hdr->unix_mode);
1083         put_word(hdr->unix_uid);
1084         put_word(hdr->unix_gid);
1085
1086         /* size of extended header is 12 */
1087         header_size = I_UNIX_EXTEND_BOTTOM + name_length - 2;
1088         data[I_HEADER_SIZE] = header_size;
1089         data[I_HEADER_CHECKSUM] = calc_sum(data + I_METHOD, header_size);
1090     }
1091
1092     return header_size + 2;
1093 }
1094
1095 static int
1096 write_header_level1(data, hdr, lzname)
1097     LzHeader *hdr;
1098     char *data, *lzname;
1099 {
1100     int name_length, dir_length, limit;
1101     char *basename, *dirname;
1102     int header_size;
1103     char *extend_header_top;
1104     int extend_header_size;
1105
1106     basename = strrchr(lzname, LHA_PATHSEP);
1107     if (basename) {
1108         basename++;
1109         name_length = strlen(basename);
1110         dirname = lzname;
1111         dir_length = basename - dirname;
1112     }
1113     else {
1114         basename = lzname;
1115         name_length = strlen(basename);
1116         dirname = "";
1117         dir_length = 0;
1118     }
1119
1120     setup_put(data);
1121     memset(data, 0, LZHEADER_STRAGE);
1122
1123     put_byte(0x00);             /* header size */
1124     put_byte(0x00);             /* check sum */
1125     put_bytes(hdr->method, 5);
1126     put_longword(hdr->packed_size);
1127     put_longword(hdr->original_size);
1128     put_longword(unix_to_generic_stamp(hdr->unix_last_modified_stamp));
1129     put_byte(0x20);
1130     put_byte(hdr->header_level); /* level 1 */
1131
1132     /* level 1 header: write filename (basename only) */
1133     limit = 255 - 27 + 2;
1134     if (name_length > limit) {
1135         put_byte(0);            /* name length */
1136     }
1137     else {
1138         put_byte(name_length);
1139         put_bytes(basename, name_length);
1140     }
1141
1142     put_word(hdr->crc);
1143
1144     if (generic_format)
1145         put_byte(0x00);
1146     else
1147         put_byte(EXTEND_UNIX);
1148
1149     /* write extend header from here. */
1150
1151     extend_header_top = put_ptr+2; /* +2 for the field `next header size' */
1152     header_size = extend_header_top - data - 2;
1153
1154     /* write filename and dirname */
1155
1156     if (name_length > limit) {
1157         put_word(name_length + 3); /* size */
1158         put_byte(0x01);         /* filename */
1159         put_bytes(basename, name_length);
1160     }
1161
1162     if (dir_length > 0) {
1163         put_word(dir_length + 3); /* size */
1164         put_byte(0x02);         /* dirname */
1165         put_bytes(dirname, dir_length);
1166     }
1167
1168     if (!generic_format) {
1169         /* UNIX specific informations */
1170
1171         put_word(5);            /* size */
1172         put_byte(0x50);         /* permission */
1173         put_word(hdr->unix_mode);
1174
1175         put_word(7);            /* size */
1176         put_byte(0x51);         /* gid and uid */
1177         put_word(hdr->unix_gid);
1178         put_word(hdr->unix_uid);
1179
1180         if (hdr->group[0]) {
1181             int len = strlen(hdr->group);
1182             put_word(len + 3);  /* size */
1183             put_byte(0x52);     /* group name */
1184             put_bytes(hdr->group, len);
1185         }
1186
1187         if (hdr->user[0]) {
1188             int len = strlen(hdr->user);
1189             put_word(len + 3);  /* size */
1190             put_byte(0x53);     /* user name */
1191             put_bytes(hdr->user, len);
1192         }
1193
1194         if (hdr->header_level == 1) {
1195             put_word(7);        /* size */
1196             put_byte(0x54);     /* time stamp */
1197             put_longword(hdr->unix_last_modified_stamp);
1198         }
1199     }       /* if generic .. */
1200
1201     put_word(0x0000);           /* next header size */
1202
1203     extend_header_size = put_ptr - extend_header_top;
1204     /* On level 1 header, the packed size field is contains the ext-header */
1205     hdr->packed_size += put_ptr - extend_header_top;
1206
1207     /* put `skip size' */
1208     setup_put(data + I_PACKED_SIZE);
1209     put_longword(hdr->packed_size);
1210
1211     data[I_HEADER_SIZE] = header_size;
1212     data[I_HEADER_CHECKSUM] = calc_sum(data + I_METHOD, header_size);
1213
1214     return header_size + extend_header_size + 2;
1215 }
1216
1217 static int
1218 write_header_level2(data, hdr, lzname)
1219     LzHeader *hdr;
1220     char *data, *lzname;
1221 {
1222     int name_length, dir_length;
1223     char *basename, *dirname;
1224     int header_size;
1225     char *extend_header_top;
1226     char *headercrc_ptr;
1227     unsigned short  hcrc;
1228
1229     basename = strrchr(lzname, LHA_PATHSEP);
1230     if (basename) {
1231         basename++;
1232         name_length = strlen(basename);
1233         dirname = lzname;
1234         dir_length = basename - dirname;
1235     }
1236     else {
1237         basename = lzname;
1238         name_length = strlen(basename);
1239         dirname = "";
1240         dir_length = 0;
1241     }
1242
1243     setup_put(data);
1244     memset(data, 0, LZHEADER_STRAGE);
1245
1246     put_word(0x0000);           /* header size */
1247     put_bytes(hdr->method, 5);
1248     put_longword(hdr->packed_size);
1249     put_longword(hdr->original_size);
1250     put_longword(hdr->unix_last_modified_stamp);
1251     put_byte(0x20);
1252     put_byte(hdr->header_level); /* level 2 */
1253
1254     put_word(hdr->crc);
1255
1256     if (generic_format)
1257         put_byte(0x00);
1258     else
1259         put_byte(EXTEND_UNIX);
1260
1261     /* write extend header from here. */
1262
1263     extend_header_top = put_ptr+2; /* +2 for the field `next header size' */
1264
1265     /* write common header */
1266     put_word(5);
1267     put_byte(0x00);
1268     headercrc_ptr = put_ptr;
1269     put_word(0x0000);           /* header CRC */
1270
1271     /* write filename and dirname */
1272     /* must have this header, even if the name_length is 0. */
1273     put_word(name_length + 3);  /* size */
1274     put_byte(0x01);             /* filename */
1275     put_bytes(basename, name_length);
1276
1277     if (dir_length > 0) {
1278         put_word(dir_length + 3); /* size */
1279         put_byte(0x02);         /* dirname */
1280         put_bytes(dirname, dir_length);
1281     }
1282
1283     if (!generic_format) {
1284         /* UNIX specific informations */
1285
1286         put_word(5);            /* size */
1287         put_byte(0x50);         /* permission */
1288         put_word(hdr->unix_mode);
1289
1290         put_word(7);            /* size */
1291         put_byte(0x51);         /* gid and uid */
1292         put_word(hdr->unix_gid);
1293         put_word(hdr->unix_uid);
1294
1295         if (hdr->group[0]) {
1296             int len = strlen(hdr->group);
1297             put_word(len + 3);  /* size */
1298             put_byte(0x52);     /* group name */
1299             put_bytes(hdr->group, len);
1300         }
1301
1302         if (hdr->user[0]) {
1303             int len = strlen(hdr->user);
1304             put_word(len + 3);  /* size */
1305             put_byte(0x53);     /* user name */
1306             put_bytes(hdr->user, len);
1307         }
1308
1309         if (hdr->header_level == 1) {
1310             put_word(7);        /* size */
1311             put_byte(0x54);     /* time stamp */
1312             put_longword(hdr->unix_last_modified_stamp);
1313         }
1314     }       /* if generic .. */
1315
1316     put_word(0x0000);           /* next header size */
1317
1318     header_size = put_ptr - data;
1319     if ((header_size & 0xff) == 0) {
1320         /* cannot put zero at the first byte on level 2 header. */
1321         /* adjust header size. */
1322         put_byte(0);            /* padding */
1323         header_size++;
1324     }
1325
1326     /* put hader size */
1327     setup_put(data + I_HEADER_SIZE);
1328     put_word(header_size);
1329
1330     /* put hader CRC in extended header */
1331     hcrc = calc_header_crc(data, (unsigned int) header_size);
1332     setup_put(headercrc_ptr);
1333     put_word(hcrc);
1334
1335     return header_size;
1336 }
1337
1338 void
1339 write_header(fp, hdr)
1340     FILE           *fp;
1341     LzHeader       *hdr;
1342 {
1343     int header_size;
1344     char data[LZHEADER_STRAGE];
1345
1346     int archive_kanji_code = CODE_SJIS;
1347     int system_kanji_code = default_system_kanji_code;
1348     char *archive_delim = "\377";
1349     char *system_delim = "/";
1350     int filename_case = NONE;
1351     char pathname[FILENAME_LENGTH];
1352
1353     if (optional_archive_kanji_code)
1354         archive_kanji_code = optional_archive_kanji_code;
1355     if (optional_system_kanji_code)
1356         system_kanji_code = optional_system_kanji_code;
1357
1358     if (generic_format)
1359         filename_case = TO_UPPER;
1360
1361     if (hdr->header_level == HEADER_LEVEL0) {
1362         archive_delim = "\\";
1363     }
1364
1365     strncpy(pathname, hdr->name, sizeof(pathname));
1366     pathname[sizeof(pathname)-1] = 0;
1367     convert_filename(pathname, strlen(pathname), sizeof(pathname),
1368                      system_kanji_code,
1369                      archive_kanji_code,
1370                      system_delim, archive_delim, filename_case);
1371
1372     switch (hdr->header_level) {
1373     case 0:
1374         header_size = write_header_level0(data, hdr, pathname);
1375         break;
1376     case 1:
1377         header_size = write_header_level1(data, hdr, pathname);
1378         break;
1379     case 2:
1380         header_size = write_header_level2(data, hdr, pathname);
1381         break;
1382     default:
1383         error("Unknown level header (level %d)", hdr->header_level);
1384         exit(1);
1385     }
1386
1387     if (fwrite(data, header_size, 1, fp) == 0)
1388         fatal_error("Cannot write to temporary file");
1389 }
1390
1391 #if MULTIBYTE_FILENAME
1392
1393 #if defined(__APPLE__)
1394
1395 #include <CoreFoundation/CFString.h>
1396 #include <CoreFoundation/CFStringEncodingExt.h>
1397
1398 /* this is not need for Mac OS X v 10.2 later */
1399 enum {
1400   kCFStringEncodingAllowLossyConversion = 1,
1401   kCFStringEncodingBasicDirectionLeftToRight = (1 << 1),
1402   kCFStringEncodingBasicDirectionRightToLeft = (1 << 2),
1403   kCFStringEncodingSubstituteCombinings = (1 << 3),
1404   kCFStringEncodingComposeCombinings = (1 << 4),
1405   kCFStringEncodingIgnoreCombinings = (1 << 5),
1406   kCFStringEncodingUseCanonical = (1 << 6),
1407   kCFStringEncodingUseHFSPlusCanonical = (1 << 7),
1408   kCFStringEncodingPrependBOM = (1 << 8),
1409   kCFStringEncodingDisableCorporateArea = (1 << 9),
1410   kCFStringEncodingASCIICompatibleConversion = (1 << 10),
1411 };
1412
1413 static int
1414 ConvertEncodingToUTF8(const char* inCStr,
1415                       char* outUTF8Buffer,
1416                       int outUTF8BufferLength,
1417                       unsigned long scriptEncoding,
1418                       unsigned long flags)
1419 {
1420     unsigned long unicodeChars;
1421     unsigned long srcCharsUsed;
1422     unsigned long usedByteLen = 0;
1423     UniChar uniStr[512];
1424     unsigned long cfResult;
1425
1426     cfResult = CFStringEncodingBytesToUnicode(scriptEncoding,
1427                                               flags,
1428                                               (char *)inCStr,
1429                                               strlen(inCStr),
1430                                               &srcCharsUsed,
1431                                               uniStr,
1432                                               512,
1433                                               &unicodeChars);
1434     if (cfResult == 0) {
1435         cfResult = CFStringEncodingUnicodeToBytes(kCFStringEncodingUTF8,
1436                                                   flags,
1437                                                   uniStr,
1438                                                   unicodeChars,
1439                                                   &srcCharsUsed,
1440                                                   (char*)outUTF8Buffer,
1441                                                   outUTF8BufferLength - 1,
1442                                                   &usedByteLen);
1443         outUTF8Buffer[usedByteLen] = '\0';
1444     }
1445
1446     return cfResult;
1447 }
1448
1449 static int
1450 ConvertUTF8ToEncoding(const char* inUTF8Buf,
1451                       int inUTF8BufLength,
1452                       char* outCStrBuffer,
1453                       int outCStrBufferLength,
1454                       unsigned long scriptEncoding,
1455                       unsigned long flags)
1456 {
1457     unsigned long unicodeChars;
1458     unsigned long srcCharsUsed;
1459     unsigned long usedByteLen = 0;
1460     UniChar uniStr[256];
1461     unsigned long cfResult;
1462
1463     cfResult = CFStringEncodingBytesToUnicode(kCFStringEncodingUTF8,
1464                                               flags,
1465                                               (char*)inUTF8Buf,
1466                                               inUTF8BufLength,
1467                                               &srcCharsUsed,
1468                                               uniStr,
1469                                               255,
1470                                               &unicodeChars);
1471     if (cfResult == 0) {
1472         cfResult = CFStringEncodingUnicodeToBytes(scriptEncoding,
1473                                                   flags,
1474                                                   uniStr,
1475                                                   unicodeChars,
1476                                                   &srcCharsUsed,
1477                                                   (char*)outCStrBuffer,
1478                                                   outCStrBufferLength - 1,
1479                                                   &usedByteLen);
1480         outCStrBuffer[usedByteLen] = '\0';
1481     }
1482
1483     return cfResult;
1484 }
1485
1486 #elif HAVE_ICONV
1487 #include <iconv.h>
1488
1489 static int
1490 ConvertEncodingByIconv(const char *src, char *dst, int dstsize,
1491                        const char *srcEnc, const char *dstEnc)
1492 {
1493     iconv_t ic;
1494     static char szTmpBuf[2048];
1495     char *src_p;
1496     char *dst_p;
1497     size_t sLen;
1498     size_t iLen;
1499
1500     dst_p = &szTmpBuf[0];
1501     iLen = (size_t)sizeof(szTmpBuf)-1;
1502     src_p = (char *)src;
1503     sLen = (size_t)strlen(src);
1504     memset(szTmpBuf, 0, sizeof(szTmpBuf));
1505     memset(dst, 0, dstsize);
1506
1507     ic = iconv_open(dstEnc, srcEnc);
1508     if (ic == (iconv_t)-1) {
1509         error("iconv_open() failure: %s", strerror(errno));
1510         return -1;
1511     }
1512
1513     if (iconv(ic, &src_p, &sLen, &dst_p, &iLen) == (size_t)-1) {
1514         error("iconv() failure: %s", strerror(errno));
1515         iconv_close(ic);
1516         return -1;
1517     }
1518
1519     strncpy(dst, szTmpBuf, dstsize);
1520
1521     iconv_close(ic);
1522
1523     return 0;
1524 }
1525 #endif /* defined(__APPLE__) */
1526
1527 char *
1528 sjis_to_utf8(char *dst, const char *src, size_t dstsize)
1529 {
1530 #if defined(__APPLE__)
1531   dst[0] = '\0';
1532   if (ConvertEncodingToUTF8(src, dst, dstsize,
1533                             kCFStringEncodingDOSJapanese,
1534                             kCFStringEncodingUseHFSPlusCanonical) == 0)
1535       return dst;
1536 #elif HAVE_ICONV
1537   if (ConvertEncodingByIconv(src, dst, dstsize, "SJIS", "UTF-8") != -1)
1538       return dst;
1539 #else
1540   error("not support utf-8 conversion");
1541 #endif
1542
1543   if (dstsize < 1) return dst;
1544   dst[dstsize-1] = 0;
1545   return strncpy(dst, src, dstsize-1);
1546 }
1547
1548 char *
1549 utf8_to_sjis(char *dst, const char *src, size_t dstsize)
1550 {
1551 #if defined(__APPLE__)
1552   int srclen;
1553
1554   dst[0] = '\0';
1555   srclen = strlen(src);
1556   if (ConvertUTF8ToEncoding(src, srclen, dst, dstsize,
1557                             kCFStringEncodingDOSJapanese,
1558                             kCFStringEncodingUseHFSPlusCanonical) == 0)
1559       return dst;
1560 #elif HAVE_ICONV
1561   if (ConvertEncodingByIconv(src, dst, dstsize, "UTF-8", "SJIS") != -1)
1562       return dst;
1563 #else
1564   error("not support utf-8 conversion");
1565 #endif
1566
1567   if (dstsize < 1) return dst;
1568   dst[dstsize-1] = 0;
1569   return strncpy(dst, src, dstsize-1);
1570 }
1571
1572 /*
1573  * SJIS <-> EUC ÊÑ´¹´Ø¿ô
1574  * ¡ÖÆüËÜ¸ì¾ðÊó½èÍý¡×   ¥½¥Õ¥È¥Ð¥ó¥¯(³ô)
1575  *      ¤è¤êÈ´¿è(by Koji Arai)
1576  */
1577 void
1578 euc2sjis(int *p1, int *p2)
1579 {
1580     unsigned char c1 = *p1 & 0x7f;
1581     unsigned char c2 = *p2 & 0x7f;
1582     int rowoff = c1 < 0x5f ? 0x70 : 0xb0;
1583     int celoff = c1 % 2 ? (c2 > 0x5f ? 0x20 : 0x1f) : 0x7e;
1584     *p1 = ((c1 + 1) >> 1) + rowoff;
1585     *p2 += celoff - 0x80;
1586 }
1587
1588 void
1589 sjis2euc(int *p1, int *p2)
1590 {
1591     unsigned char c1 = *p1;
1592     unsigned char c2 = *p2;
1593     int adjust = c2 < 0x9f;
1594     int rowoff = c1 < 0xa0 ? 0x70 : 0xb0;
1595     int celoff = adjust ? (c2 > 0x7f ? 0x20 : 0x1f) : 0x7e;
1596     *p1 = ((c1 - rowoff) << 1) - adjust;
1597     *p2 -= celoff;
1598
1599     *p1 |= 0x80;
1600     *p2 |= 0x80;
1601 }
1602 #endif /* MULTIBYTE_FILENAME */
1603
1604 /* Local Variables: */
1605 /* mode:c */
1606 /* tab-width:4 */
1607 /* compile-command:"gcc -c header.c" */
1608 /* End: */
1609 /* vi: set tabstop=4: */