contrib/libarchive/libarchive/archive_write_set_format_7zip.c

   1 /*-
   2  * Copyright (c) 2011-2012 Michihiro NAKAJIMA
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions
   7  * are met:
   8  * 1. Redistributions of source code must retain the above copyright
   9  *    notice, this list of conditions and the following disclaimer.
  10  * 2. Redistributions in binary form must reproduce the above copyright
  11  *    notice, this list of conditions and the following disclaimer in the
  12  *    documentation and/or other materials provided with the distribution.
  13  *
  14  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
  15  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  16  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
  17  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
  18  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
  19  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  20  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  21  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  22  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
  23  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  24  */
  25
  26 #include "archive_platform.h"
  27 __FBSDID("$FreeBSD$");
  28
  29 #ifdef HAVE_ERRNO_H
  30 #include <errno.h>
  31 #endif
  32 #include <stdlib.h>
  33 #ifdef HAVE_BZLIB_H
  34 #include <bzlib.h>
  35 #endif
  36 #if HAVE_LZMA_H
  37 #include <lzma.h>
  38 #endif
  39 #ifdef HAVE_ZLIB_H
  40 #include <zlib.h>
  41 #endif
  42
  43 #include "archive.h"
  44 #ifndef HAVE_ZLIB_H
  45 #include "archive_crc32.h"
  46 #endif
  47 #include "archive_endian.h"
  48 #include "archive_entry.h"
  49 #include "archive_entry_locale.h"
  50 #include "archive_ppmd7_private.h"
  51 #include "archive_private.h"
  52 #include "archive_rb.h"
  53 #include "archive_string.h"
  54 #include "archive_write_private.h"
  55
  56 /*
  57  * Codec ID
  58  */
  59 #define _7Z_COPY        0
  60 #define _7Z_LZMA1       0x030101
  61 #define _7Z_LZMA2       0x21
  62 #define _7Z_DEFLATE     0x040108
  63 #define _7Z_BZIP2       0x040202
  64 #define _7Z_PPMD        0x030401
  65
  66 /*
  67  * 7-Zip header property IDs.
  68  */
  69 #define kEnd                    0x00
  70 #define kHeader                 0x01
  71 #define kArchiveProperties      0x02
  72 #define kAdditionalStreamsInfo  0x03
  73 #define kMainStreamsInfo        0x04
  74 #define kFilesInfo              0x05
  75 #define kPackInfo               0x06
  76 #define kUnPackInfo             0x07
  77 #define kSubStreamsInfo         0x08
  78 #define kSize                   0x09
  79 #define kCRC                    0x0A
  80 #define kFolder                 0x0B
  81 #define kCodersUnPackSize       0x0C
  82 #define kNumUnPackStream        0x0D
  83 #define kEmptyStream            0x0E
  84 #define kEmptyFile              0x0F
  85 #define kAnti                   0x10
  86 #define kName                   0x11
  87 #define kCTime                  0x12
  88 #define kATime                  0x13
  89 #define kMTime                  0x14
  90 #define kAttributes             0x15
  91 #define kEncodedHeader          0x17
  92
  93 enum la_zaction {
  94         ARCHIVE_Z_FINISH,
  95         ARCHIVE_Z_RUN
  96 };
  97
  98 /*
  99  * A stream object of universal compressor.
 100  */
 101 struct la_zstream {
 102         const uint8_t           *next_in;
 103         size_t                   avail_in;
 104         uint64_t                 total_in;
 105
 106         uint8_t                 *next_out;
 107         size_t                   avail_out;
 108         uint64_t                 total_out;
 109
 110         uint32_t                 prop_size;
 111         uint8_t                 *props;
 112
 113         int                      valid;
 114         void                    *real_stream;
 115         int                      (*code) (struct archive *a,
 116                                     struct la_zstream *lastrm,
 117                                     enum la_zaction action);
 118         int                      (*end)(struct archive *a,
 119                                     struct la_zstream *lastrm);
 120 };
 121
 122 #define PPMD7_DEFAULT_ORDER     6
 123 #define PPMD7_DEFAULT_MEM_SIZE  (1 << 24)
 124
 125 struct ppmd_stream {
 126         int                      stat;
 127         CPpmd7                   ppmd7_context;
 128         CPpmd7z_RangeEnc         range_enc;
 129         IByteOut                 byteout;
 130         uint8_t                 *buff;
 131         uint8_t                 *buff_ptr;
 132         uint8_t                 *buff_end;
 133         size_t                   buff_bytes;
 134 };
 135
 136 struct coder {
 137         unsigned                 codec;
 138         size_t                   prop_size;
 139         uint8_t                 *props;
 140 };
 141
 142 struct file {
 143         struct archive_rb_node   rbnode;
 144
 145         struct file             *next;
 146         unsigned                 name_len;
 147         uint8_t                 *utf16name;/* UTF16-LE name. */
 148         uint64_t                 size;
 149         unsigned                 flg;
 150 #define MTIME_IS_SET    (1<<0)
 151 #define ATIME_IS_SET    (1<<1)
 152 #define CTIME_IS_SET    (1<<2)
 153 #define CRC32_IS_SET    (1<<3)
 154 #define HAS_STREAM      (1<<4)
 155
 156         struct {
 157                 time_t           time;
 158                 long             time_ns;
 159         }                        times[3];
 160 #define MTIME 0
 161 #define ATIME 1
 162 #define CTIME 2
 163
 164         mode_t                   mode;
 165         uint32_t                 crc32;
 166
 167         int                      dir:1;
 168 };
 169
 170 struct _7zip {
 171         int                      temp_fd;
 172         uint64_t                 temp_offset;
 173
 174         struct file             *cur_file;
 175         size_t                   total_number_entry;
 176         size_t                   total_number_nonempty_entry;
 177         size_t                   total_number_empty_entry;
 178         size_t                   total_number_dir_entry;
 179         size_t                   total_bytes_entry_name;
 180         size_t                   total_number_time_defined[3];
 181         uint64_t                 total_bytes_compressed;
 182         uint64_t                 total_bytes_uncompressed;
 183         uint64_t                 entry_bytes_remaining;
 184         uint32_t                 entry_crc32;
 185         uint32_t                 precode_crc32;
 186         uint32_t                 encoded_crc32;
 187         int                      crc32flg;
 188 #define PRECODE_CRC32   1
 189 #define ENCODED_CRC32   2
 190
 191         unsigned                 opt_compression;
 192         int                      opt_compression_level;
 193
 194         struct la_zstream        stream;
 195         struct coder             coder;
 196
 197         struct archive_string_conv *sconv;
 198
 199         /*
 200          * Compressed data buffer.
 201          */
 202         unsigned char            wbuff[512 * 20 * 6];
 203         size_t                   wbuff_remaining;
 204
 205         /*
 206          * The list of the file entries which has its contents is used to
 207          * manage struct file objects.
 208          * We use 'next' a menber of struct file to chain.
 209          */
 210         struct {
 211                 struct file     *first;
 212                 struct file     **last;
 213         }                        file_list, empty_list;
 214         struct archive_rb_tree   rbtree;/* for empty files */
 215 };
 216
 217 static int      _7z_options(struct archive_write *,
 218                     const char *, const char *);
 219 static int      _7z_write_header(struct archive_write *,
 220                     struct archive_entry *);
 221 static ssize_t  _7z_write_data(struct archive_write *,
 222                     const void *, size_t);
 223 static int      _7z_finish_entry(struct archive_write *);
 224 static int      _7z_close(struct archive_write *);
 225 static int      _7z_free(struct archive_write *);
 226 static int      file_cmp_node(const struct archive_rb_node *,
 227                     const struct archive_rb_node *);
 228 static int      file_cmp_key(const struct archive_rb_node *, const void *);
 229 static int      file_new(struct archive_write *a, struct archive_entry *,
 230                     struct file **);
 231 static void     file_free(struct file *);
 232 static void     file_register(struct _7zip *, struct file *);
 233 static void     file_register_empty(struct _7zip *, struct file *);
 234 static void     file_init_register(struct _7zip *);
 235 static void     file_init_register_empty(struct _7zip *);
 236 static void     file_free_register(struct _7zip *);
 237 static ssize_t  compress_out(struct archive_write *, const void *, size_t ,
 238                     enum la_zaction);
 239 static int      compression_init_encoder_copy(struct archive *,
 240                     struct la_zstream *);
 241 static int      compression_code_copy(struct archive *,
 242                     struct la_zstream *, enum la_zaction);
 243 static int      compression_end_copy(struct archive *, struct la_zstream *);
 244 static int      compression_init_encoder_deflate(struct archive *,
 245                     struct la_zstream *, int, int);
 246 #ifdef HAVE_ZLIB_H
 247 static int      compression_code_deflate(struct archive *,
 248                     struct la_zstream *, enum la_zaction);
 249 static int      compression_end_deflate(struct archive *, struct la_zstream *);
 250 #endif
 251 static int      compression_init_encoder_bzip2(struct archive *,
 252                     struct la_zstream *, int);
 253 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
 254 static int      compression_code_bzip2(struct archive *,
 255                     struct la_zstream *, enum la_zaction);
 256 static int      compression_end_bzip2(struct archive *, struct la_zstream *);
 257 #endif
 258 static int      compression_init_encoder_lzma1(struct archive *,
 259                     struct la_zstream *, int);
 260 static int      compression_init_encoder_lzma2(struct archive *,
 261                     struct la_zstream *, int);
 262 #if defined(HAVE_LZMA_H)
 263 static int      compression_code_lzma(struct archive *,
 264                     struct la_zstream *, enum la_zaction);
 265 static int      compression_end_lzma(struct archive *, struct la_zstream *);
 266 #endif
 267 static int      compression_init_encoder_ppmd(struct archive *,
 268                     struct la_zstream *, unsigned, uint32_t);
 269 static int      compression_code_ppmd(struct archive *,
 270                     struct la_zstream *, enum la_zaction);
 271 static int      compression_end_ppmd(struct archive *, struct la_zstream *);
 272 static int      _7z_compression_init_encoder(struct archive_write *, unsigned,
 273                     int);
 274 static int      compression_code(struct archive *,
 275                     struct la_zstream *, enum la_zaction);
 276 static int      compression_end(struct archive *,
 277                     struct la_zstream *);
 278 static int      enc_uint64(struct archive_write *, uint64_t);
 279 static int      make_header(struct archive_write *, uint64_t, uint64_t,
 280                     uint64_t, int, struct coder *);
 281 static int      make_streamsInfo(struct archive_write *, uint64_t, uint64_t,
 282                         uint64_t, int, struct coder *, int, uint32_t);
 283
 284 int
 285 archive_write_set_format_7zip(struct archive *_a)
 286 {
 287         static const struct archive_rb_tree_ops rb_ops = {
 288                 file_cmp_node, file_cmp_key
 289         };
 290         struct archive_write *a = (struct archive_write *)_a;
 291         struct _7zip *zip;
 292
 293         archive_check_magic(_a, ARCHIVE_WRITE_MAGIC,
 294             ARCHIVE_STATE_NEW, "archive_write_set_format_7zip");
 295
 296         /* If another format was already registered, unregister it. */
 297         if (a->format_free != NULL)
 298                 (a->format_free)(a);
 299
 300         zip = calloc(1, sizeof(*zip));
 301         if (zip == NULL) {
 302                 archive_set_error(&a->archive, ENOMEM,
 303                     "Can't allocate 7-Zip data");
 304                 return (ARCHIVE_FATAL);
 305         }
 306         zip->temp_fd = -1;
 307         __archive_rb_tree_init(&(zip->rbtree), &rb_ops);
 308         file_init_register(zip);
 309         file_init_register_empty(zip);
 310
 311         /* Set default compression type and its level. */
 312 #if HAVE_LZMA_H
 313         zip->opt_compression = _7Z_LZMA1;
 314 #elif defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
 315         zip->opt_compression = _7Z_BZIP2;
 316 #elif defined(HAVE_ZLIB_H)
 317         zip->opt_compression = _7Z_DEFLATE;
 318 #else
 319         zip->opt_compression = _7Z_COPY;
 320 #endif
 321         zip->opt_compression_level = 6;
 322
 323         a->format_data = zip;
 324
 325         a->format_name = "7zip";
 326         a->format_options = _7z_options;
 327         a->format_write_header = _7z_write_header;
 328         a->format_write_data = _7z_write_data;
 329         a->format_finish_entry = _7z_finish_entry;
 330         a->format_close = _7z_close;
 331         a->format_free = _7z_free;
 332         a->archive.archive_format = ARCHIVE_FORMAT_7ZIP;
 333         a->archive.archive_format_name = "7zip";
 334
 335         return (ARCHIVE_OK);
 336 }
 337
 338 static int
 339 _7z_options(struct archive_write *a, const char *key, const char *value)
 340 {
 341         struct _7zip *zip;
 342
 343         zip = (struct _7zip *)a->format_data;
 344
 345         if (strcmp(key, "compression") == 0) {
 346                 const char *name = NULL;
 347
 348                 if (value == NULL || strcmp(value, "copy") == 0 ||
 349                     strcmp(value, "COPY") == 0 ||
 350                     strcmp(value, "store") == 0 ||
 351                     strcmp(value, "STORE") == 0)
 352                         zip->opt_compression = _7Z_COPY;
 353                 else if (strcmp(value, "deflate") == 0 ||
 354                     strcmp(value, "DEFLATE") == 0)
 355 #if HAVE_ZLIB_H
 356                         zip->opt_compression = _7Z_DEFLATE;
 357 #else
 358                         name = "deflate";
 359 #endif
 360                 else if (strcmp(value, "bzip2") == 0 ||
 361                     strcmp(value, "BZIP2") == 0)
 362 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
 363                         zip->opt_compression = _7Z_BZIP2;
 364 #else
 365                         name = "bzip2";
 366 #endif
 367                 else if (strcmp(value, "lzma1") == 0 ||
 368                     strcmp(value, "LZMA1") == 0)
 369 #if HAVE_LZMA_H
 370                         zip->opt_compression = _7Z_LZMA1;
 371 #else
 372                         name = "lzma1";
 373 #endif
 374                 else if (strcmp(value, "lzma2") == 0 ||
 375                     strcmp(value, "LZMA2") == 0)
 376 #if HAVE_LZMA_H
 377                         zip->opt_compression = _7Z_LZMA2;
 378 #else
 379                         name = "lzma2";
 380 #endif
 381                 else if (strcmp(value, "ppmd") == 0 ||
 382                     strcmp(value, "PPMD") == 0 ||
 383                     strcmp(value, "PPMd") == 0)
 384                         zip->opt_compression = _7Z_PPMD;
 385                 else {
 386                         archive_set_error(&(a->archive),
 387                             ARCHIVE_ERRNO_MISC,
 388                             "Unkonwn compression name: `%s'",
 389                             value);
 390                         return (ARCHIVE_FAILED);
 391                 }
 392                 if (name != NULL) {
 393                         archive_set_error(&(a->archive),
 394                             ARCHIVE_ERRNO_MISC,
 395                             "`%s' compression not supported "
 396                             "on this platform",
 397                             name);
 398                         return (ARCHIVE_FAILED);
 399                 }
 400                 return (ARCHIVE_OK);
 401         }
 402         if (strcmp(key, "compression-level") == 0) {
 403                 if (value == NULL ||
 404                     !(value[0] >= '0' && value[0] <= '9') ||
 405                     value[1] != '\0') {
 406                         archive_set_error(&(a->archive),
 407                             ARCHIVE_ERRNO_MISC,
 408                             "Illeagal value `%s'",
 409                             value);
 410                         return (ARCHIVE_FAILED);
 411                 }
 412                 zip->opt_compression_level = value[0] - '0';
 413                 return (ARCHIVE_OK);
 414         }
 415
 416         /* Note: The "warn" return is just to inform the options
 417          * supervisor that we didn't handle it.  It will generate
 418          * a suitable error if no one used this option. */
 419         return (ARCHIVE_WARN);
 420 }
 421
 422 static int
 423 _7z_write_header(struct archive_write *a, struct archive_entry *entry)
 424 {
 425         struct _7zip *zip;
 426         struct file *file;
 427         int r;
 428
 429         zip = (struct _7zip *)a->format_data;
 430         zip->cur_file = NULL;
 431         zip->entry_bytes_remaining = 0;
 432
 433         if (zip->sconv == NULL) {
 434                 zip->sconv = archive_string_conversion_to_charset(
 435                     &a->archive, "UTF-16LE", 1);
 436                 if (zip->sconv == NULL)
 437                         return (ARCHIVE_FATAL);
 438         }
 439
 440         r = file_new(a, entry, &file);
 441         if (r < ARCHIVE_WARN) {
 442                 file_free(file);
 443                 return (r);
 444         }
 445
 446         if (file->flg & MTIME_IS_SET)
 447                 zip->total_number_time_defined[MTIME]++;
 448         if (file->flg & CTIME_IS_SET)
 449                 zip->total_number_time_defined[CTIME]++;
 450         if (file->flg & ATIME_IS_SET)
 451                 zip->total_number_time_defined[ATIME]++;
 452
 453         if (file->size == 0 && file->dir) {
 454                 if (!__archive_rb_tree_insert_node(&(zip->rbtree),
 455                     (struct archive_rb_node *)file))
 456                         file_free(file);
 457         }
 458         zip->total_number_entry++;
 459         zip->total_bytes_entry_name += file->name_len + 2;
 460         if (file->size == 0) {
 461                 /* Count up the number of empty files. */
 462                 zip->total_number_empty_entry++;
 463                 if (file->dir)
 464                         zip->total_number_dir_entry++;
 465                 else
 466                         file_register_empty(zip, file);
 467                 return (r);
 468         }
 469
 470         /*
 471          * Init compression.
 472          */
 473         if ((zip->total_number_entry - zip->total_number_empty_entry) == 1) {
 474                 r = _7z_compression_init_encoder(a, zip->opt_compression,
 475                         zip->opt_compression_level);
 476                 if (r < 0) {
 477                         file_free(file);
 478                         return (ARCHIVE_FATAL);
 479                 }
 480         }
 481
 482         /* Register a non-empty file. */
 483         file_register(zip, file);
 484
 485         /*
 486          * Set the current file to cur_file to read its contents.
 487          */
 488         zip->cur_file = file;
 489
 490
 491         /* Save a offset of current file in temporary file. */
 492         zip->entry_bytes_remaining = file->size;
 493         zip->entry_crc32 = 0;
 494
 495         /*
 496          * Store a symbolic link name as file contents.
 497          */
 498         if (archive_entry_filetype(entry) == AE_IFLNK) {
 499                 ssize_t bytes;
 500                 const void *p = (const void *)archive_entry_symlink(entry);
 501                 bytes = compress_out(a, p, (size_t)file->size, ARCHIVE_Z_RUN);
 502                 if (bytes < 0)
 503                         return ((int)bytes);
 504                 zip->entry_crc32 = crc32(zip->entry_crc32, p, bytes);
 505                 zip->entry_bytes_remaining -= bytes;
 506         }
 507
 508         return (r);
 509 }
 510
 511 /*
 512  * Write data to a temporary file.
 513  */
 514 static int
 515 write_to_temp(struct archive_write *a, const void *buff, size_t s)
 516 {
 517         struct _7zip *zip;
 518         const unsigned char *p;
 519         ssize_t ws;
 520
 521         zip = (struct _7zip *)a->format_data;
 522
 523         /*
 524          * Open a temporary file.
 525          */
 526         if (zip->temp_fd == -1) {
 527                 zip->temp_offset = 0;
 528                 zip->temp_fd = __archive_mktemp(NULL);
 529                 if (zip->temp_fd < 0) {
 530                         archive_set_error(&a->archive, errno,
 531                             "Couldn't create temporary file");
 532                         return (ARCHIVE_FATAL);
 533                 }
 534         }
 535
 536         p = (const unsigned char *)buff;
 537         while (s) {
 538                 ws = write(zip->temp_fd, p, s);
 539                 if (ws < 0) {
 540                         archive_set_error(&(a->archive), errno,
 541                             "fwrite function failed");
 542                         return (ARCHIVE_FATAL);
 543                 }
 544                 s -= ws;
 545                 p += ws;
 546                 zip->temp_offset += ws;
 547         }
 548         return (ARCHIVE_OK);
 549 }
 550
 551 static ssize_t
 552 compress_out(struct archive_write *a, const void *buff, size_t s,
 553     enum la_zaction run)
 554 {
 555         struct _7zip *zip = (struct _7zip *)a->format_data;
 556         int r;
 557
 558         if (run == ARCHIVE_Z_FINISH && zip->stream.total_in == 0 && s == 0)
 559                 return (0);
 560
 561         if ((zip->crc32flg & PRECODE_CRC32) && s)
 562                 zip->precode_crc32 = crc32(zip->precode_crc32, buff, s);
 563         zip->stream.next_in = (const unsigned char *)buff;
 564         zip->stream.avail_in = s;
 565         do {
 566                 /* Compress file data. */
 567                 r = compression_code(&(a->archive), &(zip->stream), run);
 568                 if (r != ARCHIVE_OK && r != ARCHIVE_EOF)
 569                         return (ARCHIVE_FATAL);
 570                 if (zip->stream.avail_out == 0) {
 571                         if (write_to_temp(a, zip->wbuff, sizeof(zip->wbuff))
 572                             != ARCHIVE_OK)
 573                                 return (ARCHIVE_FATAL);
 574                         zip->stream.next_out = zip->wbuff;
 575                         zip->stream.avail_out = sizeof(zip->wbuff);
 576                         if (zip->crc32flg & ENCODED_CRC32)
 577                                 zip->encoded_crc32 = crc32(zip->encoded_crc32,
 578                                     zip->wbuff, sizeof(zip->wbuff));
 579                 }
 580         } while (zip->stream.avail_in);
 581         if (run == ARCHIVE_Z_FINISH) {
 582                 uint64_t bytes = sizeof(zip->wbuff) - zip->stream.avail_out;
 583                 if (write_to_temp(a, zip->wbuff, (size_t)bytes) != ARCHIVE_OK)
 584                         return (ARCHIVE_FATAL);
 585                 if ((zip->crc32flg & ENCODED_CRC32) && bytes)
 586                         zip->encoded_crc32 = crc32(zip->encoded_crc32,
 587                             zip->wbuff, (unsigned)bytes);
 588         }
 589
 590         return (s);
 591 }
 592
 593 static ssize_t
 594 _7z_write_data(struct archive_write *a, const void *buff, size_t s)
 595 {
 596         struct _7zip *zip;
 597         ssize_t bytes;
 598
 599         zip = (struct _7zip *)a->format_data;
 600
 601         if (s > zip->entry_bytes_remaining)
 602                 s = (size_t)zip->entry_bytes_remaining;
 603         if (s == 0 || zip->cur_file == NULL)
 604                 return (0);
 605         bytes = compress_out(a, buff, s, ARCHIVE_Z_RUN);
 606         if (bytes < 0)
 607                 return (bytes);
 608         zip->entry_crc32 = crc32(zip->entry_crc32, buff, bytes);
 609         zip->entry_bytes_remaining -= bytes;
 610         return (bytes);
 611 }
 612
 613 static int
 614 _7z_finish_entry(struct archive_write *a)
 615 {
 616         struct _7zip *zip;
 617         size_t s;
 618         ssize_t r;
 619
 620         zip = (struct _7zip *)a->format_data;
 621         if (zip->cur_file == NULL)
 622                 return (ARCHIVE_OK);
 623
 624         while (zip->entry_bytes_remaining > 0) {
 625                 s = (size_t)zip->entry_bytes_remaining;
 626                 if (s > a->null_length)
 627                         s = a->null_length;
 628                 r = _7z_write_data(a, a->nulls, s);
 629                 if (r < 0)
 630                         return (r);
 631         }
 632         zip->total_bytes_compressed += zip->stream.total_in;
 633         zip->total_bytes_uncompressed += zip->stream.total_out;
 634         zip->cur_file->crc32 = zip->entry_crc32;
 635         zip->cur_file = NULL;
 636
 637         return (ARCHIVE_OK);
 638 }
 639
 640 static int
 641 flush_wbuff(struct archive_write *a)
 642 {
 643         struct _7zip *zip;
 644         int r;
 645         size_t s;
 646
 647         zip = (struct _7zip *)a->format_data;
 648         s = sizeof(zip->wbuff) - zip->wbuff_remaining;
 649         r = __archive_write_output(a, zip->wbuff, s);
 650         if (r != ARCHIVE_OK)
 651                 return (r);
 652         zip->wbuff_remaining = sizeof(zip->wbuff);
 653         return (r);
 654 }
 655
 656 static int
 657 copy_out(struct archive_write *a, uint64_t offset, uint64_t length)
 658 {
 659         struct _7zip *zip;
 660         int r;
 661
 662         zip = (struct _7zip *)a->format_data;
 663         if (zip->temp_offset > 0 &&
 664             lseek(zip->temp_fd, offset, SEEK_SET) < 0) {
 665                 archive_set_error(&(a->archive), errno, "lseek failed");
 666                 return (ARCHIVE_FATAL);
 667         }
 668         while (length) {
 669                 size_t rsize;
 670                 ssize_t rs;
 671                 unsigned char *wb;
 672
 673                 if (length > zip->wbuff_remaining)
 674                         rsize = zip->wbuff_remaining;
 675                 else
 676                         rsize = (size_t)length;
 677                 wb = zip->wbuff + (sizeof(zip->wbuff) - zip->wbuff_remaining);
 678                 rs = read(zip->temp_fd, wb, rsize);
 679                 if (rs < 0) {
 680                         archive_set_error(&(a->archive), errno,
 681                             "Can't read temporary file(%jd)",
 682                             (intmax_t)rs);
 683                         return (ARCHIVE_FATAL);
 684                 }
 685                 if (rs == 0) {
 686                         archive_set_error(&(a->archive), 0,
 687                             "Truncated 7-Zip archive");
 688                         return (ARCHIVE_FATAL);
 689                 }
 690                 zip->wbuff_remaining -= rs;
 691                 length -= rs;
 692                 if (zip->wbuff_remaining == 0) {
 693                         r = flush_wbuff(a);
 694                         if (r != ARCHIVE_OK)
 695                                 return (r);
 696                 }
 697         }
 698         return (ARCHIVE_OK);
 699 }
 700
 701 static int
 702 _7z_close(struct archive_write *a)
 703 {
 704         struct _7zip *zip;
 705         unsigned char *wb;
 706         uint64_t header_offset, header_size, header_unpacksize;
 707         uint64_t length;
 708         uint32_t header_crc32;
 709         int r;
 710
 711         zip = (struct _7zip *)a->format_data;
 712
 713         if (zip->total_number_entry > 0) {
 714                 struct archive_rb_node *n;
 715                 uint64_t data_offset, data_size, data_unpacksize;
 716                 unsigned header_compression;
 717
 718                 r = (int)compress_out(a, NULL, 0, ARCHIVE_Z_FINISH);
 719                 if (r < 0)
 720                         return (r);
 721                 data_offset = 0;
 722                 data_size = zip->stream.total_out;
 723                 data_unpacksize = zip->stream.total_in;
 724                 zip->coder.codec = zip->opt_compression;
 725                 zip->coder.prop_size = zip->stream.prop_size;
 726                 zip->coder.props = zip->stream.props;
 727                 zip->stream.prop_size = 0;
 728                 zip->stream.props = NULL;
 729                 zip->total_number_nonempty_entry =
 730                     zip->total_number_entry - zip->total_number_empty_entry;
 731
 732                 /* Connect an empty file list. */
 733                 if (zip->empty_list.first != NULL) {
 734                         *zip->file_list.last = zip->empty_list.first;
 735                         zip->file_list.last = zip->empty_list.last;
 736                 }
 737                 /* Connect a directory file list. */
 738                 ARCHIVE_RB_TREE_FOREACH(n, &(zip->rbtree)) {
 739                         file_register(zip, (struct file *)n);
 740                 }
 741
 742                 /*
 743                  * NOTE: 7z command supports just LZMA1, LZMA2 and COPY for
 744                  * the compression type for encoding the header.
 745                  */
 746 #if HAVE_LZMA_H
 747                 header_compression = _7Z_LZMA1;
 748                 /* If the stored file is only one, do not encode the header.
 749                  * This is the same way 7z command does. */
 750                 if (zip->total_number_entry == 1)
 751                         header_compression = _7Z_COPY;
 752 #else
 753                 header_compression = _7Z_COPY;
 754 #endif
 755                 r = _7z_compression_init_encoder(a, header_compression, 6);
 756                 if (r < 0)
 757                         return (r);
 758                 zip->crc32flg = PRECODE_CRC32;
 759                 zip->precode_crc32 = 0;
 760                 r = make_header(a, data_offset, data_size, data_unpacksize,
 761                         1, &(zip->coder));
 762                 if (r < 0)
 763                         return (r);
 764                 r = (int)compress_out(a, NULL, 0, ARCHIVE_Z_FINISH);
 765                 if (r < 0)
 766                         return (r);
 767                 header_offset = data_offset + data_size;
 768                 header_size = zip->stream.total_out;
 769                 header_crc32 = zip->precode_crc32;
 770                 header_unpacksize = zip->stream.total_in;
 771
 772                 if (header_compression != _7Z_COPY) {
 773                         /*
 774                          * Encode the header in order to reduce the size
 775                          * of the archive.
 776                          */
 777                         free(zip->coder.props);
 778                         zip->coder.codec = header_compression;
 779                         zip->coder.prop_size = zip->stream.prop_size;
 780                         zip->coder.props = zip->stream.props;
 781                         zip->stream.prop_size = 0;
 782                         zip->stream.props = NULL;
 783
 784                         r = _7z_compression_init_encoder(a, _7Z_COPY, 0);
 785                         if (r < 0)
 786                                 return (r);
 787                         zip->crc32flg = ENCODED_CRC32;
 788                         zip->encoded_crc32 = 0;
 789
 790                         /*
 791                          * Make EncodedHeader.
 792                          */
 793                         r = enc_uint64(a, kEncodedHeader);
 794                         if (r < 0)
 795                                 return (r);
 796                         r = make_streamsInfo(a, header_offset, header_size,
 797                               header_unpacksize, 1, &(zip->coder), 0,
 798                               header_crc32);
 799                         if (r < 0)
 800                                 return (r);
 801                         r = (int)compress_out(a, NULL, 0, ARCHIVE_Z_FINISH);
 802                         if (r < 0)
 803                                 return (r);
 804                         header_offset = header_offset + header_size;
 805                         header_size = zip->stream.total_out;
 806                         header_crc32 = zip->encoded_crc32;
 807                 }
 808                 zip->crc32flg = 0;
 809         } else {
 810                 header_offset = header_size = 0;
 811                 header_crc32 = 0;
 812         }
 813
 814         length = zip->temp_offset;
 815
 816         /*
 817          * Make the zip header on wbuff(write buffer).
 818          */
 819         wb = zip->wbuff;
 820         zip->wbuff_remaining = sizeof(zip->wbuff);
 821         memcpy(&wb[0], "7z\xBC\xAF\x27\x1C", 6);
 822         wb[6] = 0;/* Major version. */
 823         wb[7] = 3;/* Minor version. */
 824         archive_le64enc(&wb[12], header_offset);/* Next Header Offset */
 825         archive_le64enc(&wb[20], header_size);/* Next Header Size */
 826         archive_le32enc(&wb[28], header_crc32);/* Next Header CRC */
 827         archive_le32enc(&wb[8], crc32(0, &wb[12], 20));/* Start Header CRC */
 828         zip->wbuff_remaining -= 32;
 829
 830         /*
 831          * Read all file contents and an encoded header from the temporary
 832          * file and write out it.
 833          */
 834         r = copy_out(a, 0, length);
 835         if (r != ARCHIVE_OK)
 836                 return (r);
 837         r = flush_wbuff(a);
 838         return (r);
 839 }
 840
 841 /*
 842  * Encode 64 bits value into 7-Zip's encoded UINT64 value.
 843  */
 844 static int
 845 enc_uint64(struct archive_write *a, uint64_t val)
 846 {
 847         unsigned mask = 0x80;
 848         uint8_t numdata[9];
 849         int i;
 850
 851         numdata[0] = 0;
 852         for (i = 1; i < (int)sizeof(numdata); i++) {
 853                 if (val < mask) {
 854                         numdata[0] |= (uint8_t)val;
 855                         break;
 856                 }
 857                 numdata[i] = (uint8_t)val;
 858                 val >>= 8;
 859                 numdata[0] |= mask;
 860                 mask >>= 1;
 861         }
 862         return (compress_out(a, numdata, i, ARCHIVE_Z_RUN));
 863 }
 864
 865 static int
 866 make_substreamsInfo(struct archive_write *a, struct coder *coders)
 867 {
 868         struct _7zip *zip = (struct _7zip *)a->format_data;
 869         struct file *file;
 870         int r;
 871
 872         /*
 873          * Make SubStreamsInfo.
 874          */
 875         r = enc_uint64(a, kSubStreamsInfo);
 876         if (r < 0)
 877                 return (r);
 878
 879         if (zip->total_number_nonempty_entry > 1 && coders->codec != _7Z_COPY) {
 880                 /*
 881                  * Make NumUnPackStream.
 882                  */
 883                 r = enc_uint64(a, kNumUnPackStream);
 884                 if (r < 0)
 885                         return (r);
 886
 887                 /* Write numUnpackStreams */
 888                 r = enc_uint64(a, zip->total_number_nonempty_entry);
 889                 if (r < 0)
 890                         return (r);
 891
 892                 /*
 893                  * Make kSize.
 894                  */
 895                 r = enc_uint64(a, kSize);
 896                 if (r < 0)
 897                         return (r);
 898                 file = zip->file_list.first;
 899                 for (;file != NULL; file = file->next) {
 900                         if (file->next == NULL ||
 901                             file->next->size == 0)
 902                                 break;
 903                         r = enc_uint64(a, file->size);
 904                         if (r < 0)
 905                                 return (r);
 906                 }
 907         }
 908
 909         /*
 910          * Make CRC.
 911          */
 912         r = enc_uint64(a, kCRC);
 913         if (r < 0)
 914                 return (r);
 915
 916
 917         /* All are defined */
 918         r = enc_uint64(a, 1);
 919         if (r < 0)
 920                 return (r);
 921         file = zip->file_list.first;
 922         for (;file != NULL; file = file->next) {
 923                 uint8_t crc[4];
 924                 if (file->size == 0)
 925                         break;
 926                 archive_le32enc(crc, file->crc32);
 927                 r = compress_out(a, crc, 4, ARCHIVE_Z_RUN);
 928                 if (r < 0)
 929                         return (r);
 930         }
 931
 932         /* Write End. */
 933         r = enc_uint64(a, kEnd);
 934         if (r < 0)
 935                 return (r);
 936         return (ARCHIVE_OK);
 937 }
 938
 939 static int
 940 make_streamsInfo(struct archive_write *a, uint64_t offset, uint64_t pack_size,
 941     uint64_t unpack_size, int num_coder, struct coder *coders, int substrm,
 942     uint32_t header_crc)
 943 {
 944         struct _7zip *zip = (struct _7zip *)a->format_data;
 945         uint8_t codec_buff[8];
 946         int numFolders, fi;
 947         int codec_size;
 948         int i, r;
 949
 950         if (coders->codec == _7Z_COPY)
 951                 numFolders = zip->total_number_nonempty_entry;
 952         else
 953                 numFolders = 1;
 954
 955         /*
 956          * Make PackInfo.
 957          */
 958         r = enc_uint64(a, kPackInfo);
 959         if (r < 0)
 960                 return (r);
 961
 962         /* Write PackPos. */
 963         r = enc_uint64(a, offset);
 964         if (r < 0)
 965                 return (r);
 966
 967         /* Write NumPackStreams. */
 968         r = enc_uint64(a, numFolders);
 969         if (r < 0)
 970                 return (r);
 971
 972         /* Make Size. */
 973         r = enc_uint64(a, kSize);
 974         if (r < 0)
 975                 return (r);
 976
 977         if (numFolders > 1) {
 978                 struct file *file = zip->file_list.first;
 979                 for (;file != NULL; file = file->next) {
 980                         if (file->size == 0)
 981                                 break;
 982                         r = enc_uint64(a, file->size);
 983                         if (r < 0)
 984                                 return (r);
 985                 }
 986         } else {
 987                 /* Write size. */
 988                 r = enc_uint64(a, pack_size);
 989                 if (r < 0)
 990                         return (r);
 991         }
 992
 993         r = enc_uint64(a, kEnd);
 994         if (r < 0)
 995                 return (r);
 996
 997         /*
 998          * Make UnPackInfo.
 999          */
1000         r = enc_uint64(a, kUnPackInfo);
1001         if (r < 0)
1002                 return (r);
1003
1004         /*
1005          * Make Folder.
1006          */
1007         r = enc_uint64(a, kFolder);
1008         if (r < 0)
1009                 return (r);
1010
1011         /* Write NumFolders. */
1012         r = enc_uint64(a, numFolders);
1013         if (r < 0)
1014                 return (r);
1015
1016         /* Write External. */
1017         r = enc_uint64(a, 0);
1018         if (r < 0)
1019                 return (r);
1020
1021         for (fi = 0; fi < numFolders; fi++) {
1022                 /* Write NumCoders. */
1023                 r = enc_uint64(a, num_coder);
1024                 if (r < 0)
1025                         return (r);
1026
1027                 for (i = 0; i < num_coder; i++) {
1028                         unsigned codec_id = coders[i].codec;
1029
1030                         /* Write Codec flag. */
1031                         archive_be64enc(codec_buff, codec_id);
1032                         for (codec_size = 8; codec_size > 0; codec_size--) {
1033                                 if (codec_buff[8 - codec_size])
1034                                         break;
1035                         }
1036                         if (codec_size == 0)
1037                                 codec_size = 1;
1038                         if (coders[i].prop_size)
1039                                 r = enc_uint64(a, codec_size | 0x20);
1040                         else
1041                                 r = enc_uint64(a, codec_size);
1042                         if (r < 0)
1043                                 return (r);
1044
1045                         /* Write Codec ID. */
1046                         codec_size &= 0x0f;
1047                         r = compress_out(a, &codec_buff[8-codec_size],
1048                                 codec_size, ARCHIVE_Z_RUN);
1049                         if (r < 0)
1050                                 return (r);
1051
1052                         if (coders[i].prop_size) {
1053                                 /* Write Codec property size. */
1054                                 r = enc_uint64(a, coders[i].prop_size);
1055                                 if (r < 0)
1056                                         return (r);
1057
1058                                 /* Write Codec properties. */
1059                                 r = compress_out(a, coders[i].props,
1060                                         coders[i].prop_size, ARCHIVE_Z_RUN);
1061                                 if (r < 0)
1062                                         return (r);
1063                         }
1064                 }
1065         }
1066
1067         /*
1068          * Make CodersUnPackSize.
1069          */
1070         r = enc_uint64(a, kCodersUnPackSize);
1071         if (r < 0)
1072                 return (r);
1073
1074         if (numFolders > 1) {
1075                 struct file *file = zip->file_list.first;
1076                 for (;file != NULL; file = file->next) {
1077                         if (file->size == 0)
1078                                 break;
1079                         r = enc_uint64(a, file->size);
1080                         if (r < 0)
1081                                 return (r);
1082                 }
1083
1084         } else {
1085                 /* Write UnPackSize. */
1086                 r = enc_uint64(a, unpack_size);
1087                 if (r < 0)
1088                         return (r);
1089         }
1090
1091         if (!substrm) {
1092                 uint8_t crc[4];
1093                 /*
1094                  * Make CRC.
1095                  */
1096                 r = enc_uint64(a, kCRC);
1097                 if (r < 0)
1098                         return (r);
1099
1100                 /* All are defined */
1101                 r = enc_uint64(a, 1);
1102                 if (r < 0)
1103                         return (r);
1104                 archive_le32enc(crc, header_crc);
1105                 r = compress_out(a, crc, 4, ARCHIVE_Z_RUN);
1106                 if (r < 0)
1107                         return (r);
1108         }
1109
1110         /* Write End. */
1111         r = enc_uint64(a, kEnd);
1112         if (r < 0)
1113                 return (r);
1114
1115         if (substrm) {
1116                 /*
1117                  * Make SubStreamsInfo.
1118                  */
1119                 r = make_substreamsInfo(a, coders);
1120                 if (r < 0)
1121                         return (r);
1122         }
1123
1124
1125         /* Write End. */
1126         r = enc_uint64(a, kEnd);
1127         if (r < 0)
1128                 return (r);
1129
1130         return (ARCHIVE_OK);
1131 }
1132
1133
1134 #define EPOC_TIME ARCHIVE_LITERAL_ULL(116444736000000000)
1135 static uint64_t
1136 utcToFiletime(time_t t, long ns)
1137 {
1138         uint64_t fileTime;
1139
1140         fileTime = t;
1141         fileTime *= 10000000;
1142         fileTime += ns / 100;
1143         fileTime += EPOC_TIME;
1144         return (fileTime);
1145 }
1146
1147 static int
1148 make_time(struct archive_write *a, uint8_t type, unsigned flg, int ti)
1149 {
1150         uint8_t filetime[8];
1151         struct _7zip *zip = (struct _7zip *)a->format_data;
1152         struct file *file;
1153         int r;
1154         uint8_t b, mask;
1155
1156         /*
1157          * Make Time Bools.
1158          */
1159         if (zip->total_number_time_defined[ti] == zip->total_number_entry) {
1160                 /* Write Time Type. */
1161                 r = enc_uint64(a, type);
1162                 if (r < 0)
1163                         return (r);
1164                 /* Write EmptyStream Size. */
1165                 r = enc_uint64(a, 2 + zip->total_number_entry * 8);
1166                 if (r < 0)
1167                         return (r);
1168                 /* All are defined. */
1169                 r = enc_uint64(a, 1);
1170                 if (r < 0)
1171                         return (r);
1172         } else {
1173                 if (zip->total_number_time_defined[ti] == 0)
1174                         return (ARCHIVE_OK);
1175
1176                 /* Write Time Type. */
1177                 r = enc_uint64(a, type);
1178                 if (r < 0)
1179                         return (r);
1180                 /* Write EmptyStream Size. */
1181                 r = enc_uint64(a, 2 + ((zip->total_number_entry + 7) >> 3)
1182                         + zip->total_number_time_defined[ti] * 8);
1183                 if (r < 0)
1184                         return (r);
1185
1186                 /* All are not defined. */
1187                 r = enc_uint64(a, 0);
1188                 if (r < 0)
1189                         return (r);
1190
1191                 b = 0;
1192                 mask = 0x80;
1193                 file = zip->file_list.first;
1194                 for (;file != NULL; file = file->next) {
1195                         if (file->flg & flg)
1196                                 b |= mask;
1197                         mask >>= 1;
1198                         if (mask == 0) {
1199                                 r = compress_out(a, &b, 1, ARCHIVE_Z_RUN);
1200                                 if (r < 0)
1201                                         return (r);
1202                                 mask = 0x80;
1203                                 b = 0;
1204                         }
1205                 }
1206                 if (mask != 0x80) {
1207                         r = compress_out(a, &b, 1, ARCHIVE_Z_RUN);
1208                         if (r < 0)
1209                                 return (r);
1210                 }
1211         }
1212
1213         /* External. */
1214         r = enc_uint64(a, 0);
1215         if (r < 0)
1216                 return (r);
1217
1218
1219         /*
1220          * Make Times.
1221          */
1222         file = zip->file_list.first;
1223         for (;file != NULL; file = file->next) {
1224                 if ((file->flg & flg) == 0)
1225                         continue;
1226                 archive_le64enc(filetime, utcToFiletime(file->times[ti].time,
1227                         file->times[ti].time_ns));
1228                 r = compress_out(a, filetime, 8, ARCHIVE_Z_RUN);
1229                 if (r < 0)
1230                         return (r);
1231         }
1232
1233         return (ARCHIVE_OK);
1234 }
1235
1236 static int
1237 make_header(struct archive_write *a, uint64_t offset, uint64_t pack_size,
1238     uint64_t unpack_size, int codernum, struct coder *coders)
1239 {
1240         struct _7zip *zip = (struct _7zip *)a->format_data;
1241         struct file *file;
1242         int r;
1243         uint8_t b, mask;
1244
1245         /*
1246          * Make FilesInfo.
1247          */
1248         r = enc_uint64(a, kHeader);
1249         if (r < 0)
1250                 return (r);
1251
1252         /*
1253          * If there are empty files only, do not write MainStreamInfo.
1254          */
1255         if (zip->total_number_nonempty_entry) {
1256                 /*
1257                  * Make MainStreamInfo.
1258                  */
1259                 r = enc_uint64(a, kMainStreamsInfo);
1260                 if (r < 0)
1261                         return (r);
1262                 r = make_streamsInfo(a, offset, pack_size, unpack_size,
1263                       codernum, coders, 1, 0);
1264                 if (r < 0)
1265                         return (r);
1266         }
1267
1268         /*
1269          * Make FilesInfo.
1270          */
1271         r = enc_uint64(a, kFilesInfo);
1272         if (r < 0)
1273                 return (r);
1274
1275         /* Write numFiles. */
1276         r = enc_uint64(a, zip->total_number_entry);
1277         if (r < 0)
1278                 return (r);
1279
1280         if (zip->total_number_empty_entry > 0) {
1281                 /* Make EmptyStream. */
1282                 r = enc_uint64(a, kEmptyStream);
1283                 if (r < 0)
1284                         return (r);
1285
1286                 /* Write EmptyStream Size. */
1287                 r = enc_uint64(a, (zip->total_number_entry+7)>>3);
1288                 if (r < 0)
1289                         return (r);
1290
1291                 b = 0;
1292                 mask = 0x80;
1293                 file = zip->file_list.first;
1294                 for (;file != NULL; file = file->next) {
1295                         if (file->size == 0)
1296                                 b |= mask;
1297                         mask >>= 1;
1298                         if (mask == 0) {
1299                                 r = compress_out(a, &b, 1, ARCHIVE_Z_RUN);
1300                                 if (r < 0)
1301                                         return (r);
1302                                 mask = 0x80;
1303                                 b = 0;
1304                         }
1305                 }
1306                 if (mask != 0x80) {
1307                         r = compress_out(a, &b, 1, ARCHIVE_Z_RUN);
1308                         if (r < 0)
1309                                 return (r);
1310                 }
1311         }
1312
1313         if (zip->total_number_empty_entry > zip->total_number_dir_entry) {
1314                 /* Make EmptyFile. */
1315                 r = enc_uint64(a, kEmptyFile);
1316                 if (r < 0)
1317                         return (r);
1318
1319                 /* Write EmptyFile Size. */
1320                 r = enc_uint64(a, (zip->total_number_empty_entry + 7) >> 3);
1321                 if (r < 0)
1322                         return (r);
1323
1324                 b = 0;
1325                 mask = 0x80;
1326                 file = zip->file_list.first;
1327                 for (;file != NULL; file = file->next) {
1328                         if (file->size)
1329                                 continue;
1330                         if (!file->dir)
1331                                 b |= mask;
1332                         mask >>= 1;
1333                         if (mask == 0) {
1334                                 r = compress_out(a, &b, 1, ARCHIVE_Z_RUN);
1335                                 if (r < 0)
1336                                         return (r);
1337                                 mask = 0x80;
1338                                 b = 0;
1339                         }
1340                 }
1341                 if (mask != 0x80) {
1342                         r = compress_out(a, &b, 1, ARCHIVE_Z_RUN);
1343                         if (r < 0)
1344                                 return (r);
1345                 }
1346         }
1347
1348         /* Make Name. */
1349         r = enc_uint64(a, kName);
1350         if (r < 0)
1351                 return (r);
1352
1353         /* Write Nume size. */
1354         r = enc_uint64(a, zip->total_bytes_entry_name+1);
1355         if (r < 0)
1356                 return (r);
1357
1358         /* Write dmy byte. */
1359         r = enc_uint64(a, 0);
1360         if (r < 0)
1361                 return (r);
1362
1363         file = zip->file_list.first;
1364         for (;file != NULL; file = file->next) {
1365                 r = compress_out(a, file->utf16name, file->name_len+2,
1366                         ARCHIVE_Z_RUN);
1367                 if (r < 0)
1368                         return (r);
1369         }
1370
1371         /* Make MTime. */
1372         r = make_time(a, kMTime, MTIME_IS_SET, MTIME);
1373         if (r < 0)
1374                 return (r);
1375
1376         /* Make CTime. */
1377         r = make_time(a, kCTime, CTIME_IS_SET, CTIME);
1378         if (r < 0)
1379                 return (r);
1380
1381         /* Make ATime. */
1382         r = make_time(a, kATime, ATIME_IS_SET, ATIME);
1383         if (r < 0)
1384                 return (r);
1385
1386         /* Make Attributes. */
1387         r = enc_uint64(a, kAttributes);
1388         if (r < 0)
1389                 return (r);
1390
1391         /* Write Attributes size. */
1392         r = enc_uint64(a, 2 + zip->total_number_entry * 4);
1393         if (r < 0)
1394                 return (r);
1395
1396         /* Write "All Are Defined". */
1397         r = enc_uint64(a, 1);
1398         if (r < 0)
1399                 return (r);
1400
1401         /* Write dmy byte. */
1402         r = enc_uint64(a, 0);
1403         if (r < 0)
1404                 return (r);
1405
1406         file = zip->file_list.first;
1407         for (;file != NULL; file = file->next) {
1408                 /*
1409                  * High 16bits is unix mode.
1410                  * Low 16bits is Windows attributes.
1411                  */
1412                 uint32_t encattr, attr;
1413                 if (file->dir)
1414                         attr = 0x8010;
1415                 else
1416                         attr = 0x8020;
1417                 if ((file->mode & 0222) == 0)
1418                         attr |= 1;/* Read Only. */
1419                 attr |= ((uint32_t)file->mode) << 16;
1420                 archive_le32enc(&encattr, attr);
1421                 r = compress_out(a, &encattr, 4, ARCHIVE_Z_RUN);
1422                 if (r < 0)
1423                         return (r);
1424         }
1425
1426         /* Write End. */
1427         r = enc_uint64(a, kEnd);
1428         if (r < 0)
1429                 return (r);
1430
1431         /* Write End. */
1432         r = enc_uint64(a, kEnd);
1433         if (r < 0)
1434                 return (r);
1435
1436         return (ARCHIVE_OK);
1437 }
1438
1439
1440 static int
1441 _7z_free(struct archive_write *a)
1442 {
1443         struct _7zip *zip = (struct _7zip *)a->format_data;
1444
1445         file_free_register(zip);
1446         compression_end(&(a->archive), &(zip->stream));
1447         free(zip->coder.props);
1448         free(zip);
1449
1450         return (ARCHIVE_OK);
1451 }
1452
1453 static int
1454 file_cmp_node(const struct archive_rb_node *n1,
1455     const struct archive_rb_node *n2)
1456 {
1457         const struct file *f1 = (const struct file *)n1;
1458         const struct file *f2 = (const struct file *)n2;
1459
1460         if (f1->name_len == f2->name_len)
1461                 return (memcmp(f1->utf16name, f2->utf16name, f1->name_len));
1462         return (f1->name_len > f2->name_len)?1:-1;
1463 }
1464
1465 static int
1466 file_cmp_key(const struct archive_rb_node *n, const void *key)
1467 {
1468         const struct file *f = (const struct file *)n;
1469
1470         return (f->name_len - *(const char *)key);
1471 }
1472
1473 static int
1474 file_new(struct archive_write *a, struct archive_entry *entry,
1475     struct file **newfile)
1476 {
1477         struct _7zip *zip;
1478         struct file *file;
1479         const char *u16;
1480         size_t u16len;
1481         int ret = ARCHIVE_OK;
1482
1483         zip = (struct _7zip *)a->format_data;
1484         *newfile = NULL;
1485
1486         file = calloc(1, sizeof(*file));
1487         if (file == NULL) {
1488                 archive_set_error(&a->archive, ENOMEM,
1489                     "Can't allocate memory");
1490                 return (ARCHIVE_FATAL);
1491         }
1492
1493         if (0 > archive_entry_pathname_l(entry, &u16, &u16len, zip->sconv)) {
1494                 if (errno == ENOMEM) {
1495                         free(file);
1496                         archive_set_error(&a->archive, ENOMEM,
1497                             "Can't allocate memory for UTF-16LE");
1498                         return (ARCHIVE_FATAL);
1499                 }
1500                 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC,
1501                     "A filename cannot be converted to UTF-16LE;"
1502                     "You should disable making Joliet extension");
1503                 ret = ARCHIVE_WARN;
1504         }
1505         file->utf16name = malloc(u16len + 2);
1506         if (file->utf16name == NULL) {
1507                 free(file);
1508                 archive_set_error(&a->archive, ENOMEM,
1509                     "Can't allocate memory for Name");
1510                 return (ARCHIVE_FATAL);
1511         }
1512         memcpy(file->utf16name, u16, u16len);
1513         file->utf16name[u16len+0] = 0;
1514         file->utf16name[u16len+1] = 0;
1515         file->name_len = u16len;
1516         file->mode = archive_entry_mode(entry);
1517         if (archive_entry_filetype(entry) == AE_IFREG)
1518                 file->size = archive_entry_size(entry);
1519         else
1520                 archive_entry_set_size(entry, 0);
1521         if (archive_entry_filetype(entry) == AE_IFDIR)
1522                 file->dir = 1;
1523         else if (archive_entry_filetype(entry) == AE_IFLNK)
1524                 file->size = strlen(archive_entry_symlink(entry));
1525         if (archive_entry_mtime_is_set(entry)) {
1526                 file->flg |= MTIME_IS_SET;
1527                 file->times[MTIME].time = archive_entry_mtime(entry);
1528                 file->times[MTIME].time_ns = archive_entry_mtime_nsec(entry);
1529         }
1530         if (archive_entry_atime_is_set(entry)) {
1531                 file->flg |= ATIME_IS_SET;
1532                 file->times[ATIME].time = archive_entry_atime(entry);
1533                 file->times[ATIME].time_ns = archive_entry_atime_nsec(entry);
1534         }
1535         if (archive_entry_ctime_is_set(entry)) {
1536                 file->flg |= CTIME_IS_SET;
1537                 file->times[CTIME].time = archive_entry_ctime(entry);
1538                 file->times[CTIME].time_ns = archive_entry_ctime_nsec(entry);
1539         }
1540
1541         *newfile = file;
1542         return (ret);
1543 }
1544
1545 static void
1546 file_free(struct file *file)
1547 {
1548         free(file->utf16name);
1549         free(file);
1550 }
1551
1552 static void
1553 file_register(struct _7zip *zip, struct file *file)
1554 {
1555         file->next = NULL;
1556         *zip->file_list.last = file;
1557         zip->file_list.last = &(file->next);
1558 }
1559
1560 static void
1561 file_init_register(struct _7zip *zip)
1562 {
1563         zip->file_list.first = NULL;
1564         zip->file_list.last = &(zip->file_list.first);
1565 }
1566
1567 static void
1568 file_free_register(struct _7zip *zip)
1569 {
1570         struct file *file, *file_next;
1571
1572         file = zip->file_list.first;
1573         while (file != NULL) {
1574                 file_next = file->next;
1575                 file_free(file);
1576                 file = file_next;
1577         }
1578 }
1579
1580 static void
1581 file_register_empty(struct _7zip *zip, struct file *file)
1582 {
1583         file->next = NULL;
1584         *zip->empty_list.last = file;
1585         zip->empty_list.last = &(file->next);
1586 }
1587
1588 static void
1589 file_init_register_empty(struct _7zip *zip)
1590 {
1591         zip->empty_list.first = NULL;
1592         zip->empty_list.last = &(zip->empty_list.first);
1593 }
1594
1595 #if !defined(HAVE_ZLIB_H) || !defined(HAVE_BZLIB_H) ||\
1596          !defined(BZ_CONFIG_ERROR) || !defined(HAVE_LZMA_H)
1597 static int
1598 compression_unsupported_encoder(struct archive *a,
1599     struct la_zstream *lastrm, const char *name)
1600 {
1601
1602         archive_set_error(a, ARCHIVE_ERRNO_MISC,
1603             "%s compression not supported on this platform", name);
1604         lastrm->valid = 0;
1605         lastrm->real_stream = NULL;
1606         return (ARCHIVE_FAILED);
1607 }
1608 #endif
1609
1610 /*
1611  * _7_COPY compressor.
1612  */
1613 static int
1614 compression_init_encoder_copy(struct archive *a, struct la_zstream *lastrm)
1615 {
1616
1617         if (lastrm->valid)
1618                 compression_end(a, lastrm);
1619         lastrm->valid = 1;
1620         lastrm->code = compression_code_copy;
1621         lastrm->end = compression_end_copy;
1622         return (ARCHIVE_OK);
1623 }
1624
1625 static int
1626 compression_code_copy(struct archive *a,
1627     struct la_zstream *lastrm, enum la_zaction action)
1628 {
1629         size_t bytes;
1630
1631         (void)a; /* UNUSED */
1632         if (lastrm->avail_out > lastrm->avail_in)
1633                 bytes = lastrm->avail_in;
1634         else
1635                 bytes = lastrm->avail_out;
1636         if (bytes) {
1637                 memcpy(lastrm->next_out, lastrm->next_in, bytes);
1638                 lastrm->next_in += bytes;
1639                 lastrm->avail_in -= bytes;
1640                 lastrm->total_in += bytes;
1641                 lastrm->next_out += bytes;
1642                 lastrm->avail_out -= bytes;
1643                 lastrm->total_out += bytes;
1644         }
1645         if (action == ARCHIVE_Z_FINISH && lastrm->avail_in == 0)
1646                 return (ARCHIVE_EOF);
1647         return (ARCHIVE_OK);
1648 }
1649
1650 static int
1651 compression_end_copy(struct archive *a, struct la_zstream *lastrm)
1652 {
1653         (void)a; /* UNUSED */
1654         lastrm->valid = 0;
1655         return (ARCHIVE_OK);
1656 }
1657
1658 /*
1659  * _7_DEFLATE compressor.
1660  */
1661 #ifdef HAVE_ZLIB_H
1662 static int
1663 compression_init_encoder_deflate(struct archive *a,
1664     struct la_zstream *lastrm, int level, int withheader)
1665 {
1666         z_stream *strm;
1667
1668         if (lastrm->valid)
1669                 compression_end(a, lastrm);
1670         strm = calloc(1, sizeof(*strm));
1671         if (strm == NULL) {
1672                 archive_set_error(a, ENOMEM,
1673                     "Can't allocate memory for gzip stream");
1674                 return (ARCHIVE_FATAL);
1675         }
1676         /* zlib.h is not const-correct, so we need this one bit
1677          * of ugly hackery to convert a const * pointer to
1678          * a non-const pointer. */
1679         strm->next_in = (Bytef *)(uintptr_t)(const void *)lastrm->next_in;
1680         strm->avail_in = lastrm->avail_in;
1681         strm->total_in = (uLong)lastrm->total_in;
1682         strm->next_out = lastrm->next_out;
1683         strm->avail_out = lastrm->avail_out;
1684         strm->total_out = (uLong)lastrm->total_out;
1685         if (deflateInit2(strm, level, Z_DEFLATED,
1686             (withheader)?15:-15,
1687             8, Z_DEFAULT_STRATEGY) != Z_OK) {
1688                 free(strm);
1689                 lastrm->real_stream = NULL;
1690                 archive_set_error(a, ARCHIVE_ERRNO_MISC,
1691                     "Internal error initializing compression library");
1692                 return (ARCHIVE_FATAL);
1693         }
1694         lastrm->real_stream = strm;
1695         lastrm->valid = 1;
1696         lastrm->code = compression_code_deflate;
1697         lastrm->end = compression_end_deflate;
1698         return (ARCHIVE_OK);
1699 }
1700
1701 static int
1702 compression_code_deflate(struct archive *a,
1703     struct la_zstream *lastrm, enum la_zaction action)
1704 {
1705         z_stream *strm;
1706         int r;
1707
1708         strm = (z_stream *)lastrm->real_stream;
1709         /* zlib.h is not const-correct, so we need this one bit
1710          * of ugly hackery to convert a const * pointer to
1711          * a non-const pointer. */
1712         strm->next_in = (Bytef *)(uintptr_t)(const void *)lastrm->next_in;
1713         strm->avail_in = lastrm->avail_in;
1714         strm->total_in = (uLong)lastrm->total_in;
1715         strm->next_out = lastrm->next_out;
1716         strm->avail_out = lastrm->avail_out;
1717         strm->total_out = (uLong)lastrm->total_out;
1718         r = deflate(strm,
1719             (action == ARCHIVE_Z_FINISH)? Z_FINISH: Z_NO_FLUSH);
1720         lastrm->next_in = strm->next_in;
1721         lastrm->avail_in = strm->avail_in;
1722         lastrm->total_in = strm->total_in;
1723         lastrm->next_out = strm->next_out;
1724         lastrm->avail_out = strm->avail_out;
1725         lastrm->total_out = strm->total_out;
1726         switch (r) {
1727         case Z_OK:
1728                 return (ARCHIVE_OK);
1729         case Z_STREAM_END:
1730                 return (ARCHIVE_EOF);
1731         default:
1732                 archive_set_error(a, ARCHIVE_ERRNO_MISC,
1733                     "GZip compression failed:"
1734                     " deflate() call returned status %d", r);
1735                 return (ARCHIVE_FATAL);
1736         }
1737 }
1738
1739 static int
1740 compression_end_deflate(struct archive *a, struct la_zstream *lastrm)
1741 {
1742         z_stream *strm;
1743         int r;
1744
1745         strm = (z_stream *)lastrm->real_stream;
1746         r = deflateEnd(strm);
1747         free(strm);
1748         lastrm->real_stream = NULL;
1749         lastrm->valid = 0;
1750         if (r != Z_OK) {
1751                 archive_set_error(a, ARCHIVE_ERRNO_MISC,
1752                     "Failed to clean up compressor");
1753                 return (ARCHIVE_FATAL);
1754         }
1755         return (ARCHIVE_OK);
1756 }
1757 #else
1758 static int
1759 compression_init_encoder_deflate(struct archive *a,
1760     struct la_zstream *lastrm, int level, int withheader)
1761 {
1762
1763         (void) level; /* UNUSED */
1764         (void) withheader; /* UNUSED */
1765         if (lastrm->valid)
1766                 compression_end(a, lastrm);
1767         return (compression_unsupported_encoder(a, lastrm, "deflate"));
1768 }
1769 #endif
1770
1771 /*
1772  * _7_BZIP2 compressor.
1773  */
1774 #if defined(HAVE_BZLIB_H) && defined(BZ_CONFIG_ERROR)
1775 static int
1776 compression_init_encoder_bzip2(struct archive *a,
1777     struct la_zstream *lastrm, int level)
1778 {
1779         bz_stream *strm;
1780
1781         if (lastrm->valid)
1782                 compression_end(a, lastrm);
1783         strm = calloc(1, sizeof(*strm));
1784         if (strm == NULL) {
1785                 archive_set_error(a, ENOMEM,
1786                     "Can't allocate memory for bzip2 stream");
1787                 return (ARCHIVE_FATAL);
1788         }
1789         /* bzlib.h is not const-correct, so we need this one bit
1790          * of ugly hackery to convert a const * pointer to
1791          * a non-const pointer. */
1792         strm->next_in = (char *)(uintptr_t)(const void *)lastrm->next_in;
1793         strm->avail_in = lastrm->avail_in;
1794         strm->total_in_lo32 = (uint32_t)(lastrm->total_in & 0xffffffff);
1795         strm->total_in_hi32 = (uint32_t)(lastrm->total_in >> 32);
1796         strm->next_out = (char *)lastrm->next_out;
1797         strm->avail_out = lastrm->avail_out;
1798         strm->total_out_lo32 = (uint32_t)(lastrm->total_out & 0xffffffff);
1799         strm->total_out_hi32 = (uint32_t)(lastrm->total_out >> 32);
1800         if (BZ2_bzCompressInit(strm, level, 0, 30) != BZ_OK) {
1801                 free(strm);
1802                 lastrm->real_stream = NULL;
1803                 archive_set_error(a, ARCHIVE_ERRNO_MISC,
1804                     "Internal error initializing compression library");
1805                 return (ARCHIVE_FATAL);
1806         }
1807         lastrm->real_stream = strm;
1808         lastrm->valid = 1;
1809         lastrm->code = compression_code_bzip2;
1810         lastrm->end = compression_end_bzip2;
1811         return (ARCHIVE_OK);
1812 }
1813
1814 static int
1815 compression_code_bzip2(struct archive *a,
1816     struct la_zstream *lastrm, enum la_zaction action)
1817 {
1818         bz_stream *strm;
1819         int r;
1820
1821         strm = (bz_stream *)lastrm->real_stream;
1822         /* bzlib.h is not const-correct, so we need this one bit
1823          * of ugly hackery to convert a const * pointer to
1824          * a non-const pointer. */
1825         strm->next_in = (char *)(uintptr_t)(const void *)lastrm->next_in;
1826         strm->avail_in = lastrm->avail_in;
1827         strm->total_in_lo32 = (uint32_t)(lastrm->total_in & 0xffffffff);
1828         strm->total_in_hi32 = (uint32_t)(lastrm->total_in >> 32);
1829         strm->next_out = (char *)lastrm->next_out;
1830         strm->avail_out = lastrm->avail_out;
1831         strm->total_out_lo32 = (uint32_t)(lastrm->total_out & 0xffffffff);
1832         strm->total_out_hi32 = (uint32_t)(lastrm->total_out >> 32);
1833         r = BZ2_bzCompress(strm,
1834             (action == ARCHIVE_Z_FINISH)? BZ_FINISH: BZ_RUN);
1835         lastrm->next_in = (const unsigned char *)strm->next_in;
1836         lastrm->avail_in = strm->avail_in;
1837         lastrm->total_in =
1838             (((uint64_t)(uint32_t)strm->total_in_hi32) << 32)
1839             + (uint64_t)(uint32_t)strm->total_in_lo32;
1840         lastrm->next_out = (unsigned char *)strm->next_out;
1841         lastrm->avail_out = strm->avail_out;
1842         lastrm->total_out =
1843             (((uint64_t)(uint32_t)strm->total_out_hi32) << 32)
1844             + (uint64_t)(uint32_t)strm->total_out_lo32;
1845         switch (r) {
1846         case BZ_RUN_OK:     /* Non-finishing */
1847         case BZ_FINISH_OK:  /* Finishing: There's more work to do */
1848                 return (ARCHIVE_OK);
1849         case BZ_STREAM_END: /* Finishing: all done */
1850                 /* Only occurs in finishing case */
1851                 return (ARCHIVE_EOF);
1852         default:
1853                 /* Any other return value indicates an error */
1854                 archive_set_error(a, ARCHIVE_ERRNO_MISC,
1855                     "Bzip2 compression failed:"
1856                     " BZ2_bzCompress() call returned status %d", r);
1857                 return (ARCHIVE_FATAL);
1858         }
1859 }
1860
1861 static int
1862 compression_end_bzip2(struct archive *a, struct la_zstream *lastrm)
1863 {
1864         bz_stream *strm;
1865         int r;
1866
1867         strm = (bz_stream *)lastrm->real_stream;
1868         r = BZ2_bzCompressEnd(strm);
1869         free(strm);
1870         lastrm->real_stream = NULL;
1871         lastrm->valid = 0;
1872         if (r != BZ_OK) {
1873                 archive_set_error(a, ARCHIVE_ERRNO_MISC,
1874                     "Failed to clean up compressor");
1875                 return (ARCHIVE_FATAL);
1876         }
1877         return (ARCHIVE_OK);
1878 }
1879
1880 #else
1881 static int
1882 compression_init_encoder_bzip2(struct archive *a,
1883     struct la_zstream *lastrm, int level)
1884 {
1885
1886         (void) level; /* UNUSED */
1887         if (lastrm->valid)
1888                 compression_end(a, lastrm);
1889         return (compression_unsupported_encoder(a, lastrm, "bzip2"));
1890 }
1891 #endif
1892
1893 /*
1894  * _7_LZMA1, _7_LZMA2 compressor.
1895  */
1896 #if defined(HAVE_LZMA_H)
1897 static int
1898 compression_init_encoder_lzma(struct archive *a,
1899     struct la_zstream *lastrm, int level, uint64_t filter_id)
1900 {
1901         static const lzma_stream lzma_init_data = LZMA_STREAM_INIT;
1902         lzma_stream *strm;
1903         lzma_filter *lzmafilters;
1904         lzma_options_lzma lzma_opt;
1905         int r;
1906
1907         if (lastrm->valid)
1908                 compression_end(a, lastrm);
1909         strm = calloc(1, sizeof(*strm) + sizeof(*lzmafilters) * 2);
1910         if (strm == NULL) {
1911                 archive_set_error(a, ENOMEM,
1912                     "Can't allocate memory for lzma stream");
1913                 return (ARCHIVE_FATAL);
1914         }
1915         lzmafilters = (lzma_filter *)(strm+1);
1916         if (level > 6)
1917                 level = 6;
1918         if (lzma_lzma_preset(&lzma_opt, level)) {
1919                 free(strm);
1920                 lastrm->real_stream = NULL;
1921                 archive_set_error(a, ENOMEM,
1922                     "Internal error initializing compression library");
1923                 return (ARCHIVE_FATAL);
1924         }
1925         lzmafilters[0].id = filter_id;
1926         lzmafilters[0].options = &lzma_opt;
1927         lzmafilters[1].id = LZMA_VLI_UNKNOWN;/* Terminate */
1928
1929         r = lzma_properties_size(&(lastrm->prop_size), lzmafilters);
1930         if (r != LZMA_OK) {
1931                 free(strm);
1932                 lastrm->real_stream = NULL;
1933                 archive_set_error(a, ARCHIVE_ERRNO_MISC,
1934                     "lzma_properties_size failed");
1935                 return (ARCHIVE_FATAL);
1936         }
1937         if (lastrm->prop_size) {
1938                 lastrm->props = malloc(lastrm->prop_size);
1939                 if (lastrm->props == NULL) {
1940                         free(strm);
1941                         lastrm->real_stream = NULL;
1942                         archive_set_error(a, ENOMEM,
1943                             "Cannot allocate memory");
1944                         return (ARCHIVE_FATAL);
1945                 }
1946                 r = lzma_properties_encode(lzmafilters,  lastrm->props);
1947                 if (r != LZMA_OK) {
1948                         free(strm);
1949                         lastrm->real_stream = NULL;
1950                         archive_set_error(a, ARCHIVE_ERRNO_MISC,
1951                             "lzma_properties_encode failed");
1952                         return (ARCHIVE_FATAL);
1953                 }
1954         }
1955
1956         *strm = lzma_init_data;
1957         r = lzma_raw_encoder(strm, lzmafilters);
1958         switch (r) {
1959         case LZMA_OK:
1960                 lastrm->real_stream = strm;
1961                 lastrm->valid = 1;
1962                 lastrm->code = compression_code_lzma;
1963                 lastrm->end = compression_end_lzma;
1964                 r = ARCHIVE_OK;
1965                 break;
1966         case LZMA_MEM_ERROR:
1967                 free(strm);
1968                 lastrm->real_stream = NULL;
1969                 archive_set_error(a, ENOMEM,
1970                     "Internal error initializing compression library: "
1971                     "Cannot allocate memory");
1972                 r =  ARCHIVE_FATAL;
1973                 break;
1974         default:
1975                 free(strm);
1976                 lastrm->real_stream = NULL;
1977                 archive_set_error(a, ARCHIVE_ERRNO_MISC,
1978                     "Internal error initializing compression library: "
1979                     "It's a bug in liblzma");
1980                 r =  ARCHIVE_FATAL;
1981                 break;
1982         }
1983         return (r);
1984 }
1985
1986 static int
1987 compression_init_encoder_lzma1(struct archive *a,
1988     struct la_zstream *lastrm, int level)
1989 {
1990         return compression_init_encoder_lzma(a, lastrm, level,
1991                     LZMA_FILTER_LZMA1);
1992 }
1993
1994 static int
1995 compression_init_encoder_lzma2(struct archive *a,
1996     struct la_zstream *lastrm, int level)
1997 {
1998         return compression_init_encoder_lzma(a, lastrm, level,
1999                     LZMA_FILTER_LZMA2);
2000 }
2001
2002 static int
2003 compression_code_lzma(struct archive *a,
2004     struct la_zstream *lastrm, enum la_zaction action)
2005 {
2006         lzma_stream *strm;
2007         int r;
2008
2009         strm = (lzma_stream *)lastrm->real_stream;
2010         strm->next_in = lastrm->next_in;
2011         strm->avail_in = lastrm->avail_in;
2012         strm->total_in = lastrm->total_in;
2013         strm->next_out = lastrm->next_out;
2014         strm->avail_out = lastrm->avail_out;
2015         strm->total_out = lastrm->total_out;
2016         r = lzma_code(strm,
2017             (action == ARCHIVE_Z_FINISH)? LZMA_FINISH: LZMA_RUN);
2018         lastrm->next_in = strm->next_in;
2019         lastrm->avail_in = strm->avail_in;
2020         lastrm->total_in = strm->total_in;
2021         lastrm->next_out = strm->next_out;
2022         lastrm->avail_out = strm->avail_out;
2023         lastrm->total_out = strm->total_out;
2024         switch (r) {
2025         case LZMA_OK:
2026                 /* Non-finishing case */
2027                 return (ARCHIVE_OK);
2028         case LZMA_STREAM_END:
2029                 /* This return can only occur in finishing case. */
2030                 return (ARCHIVE_EOF);
2031         case LZMA_MEMLIMIT_ERROR:
2032                 archive_set_error(a, ENOMEM,
2033                     "lzma compression error:"
2034                     " %ju MiB would have been needed",
2035                     (uintmax_t)((lzma_memusage(strm) + 1024 * 1024 -1)
2036                         / (1024 * 1024)));
2037                 return (ARCHIVE_FATAL);
2038         default:
2039                 /* Any other return value indicates an error */
2040                 archive_set_error(a, ARCHIVE_ERRNO_MISC,
2041                     "lzma compression failed:"
2042                     " lzma_code() call returned status %d", r);
2043                 return (ARCHIVE_FATAL);
2044         }
2045 }
2046
2047 static int
2048 compression_end_lzma(struct archive *a, struct la_zstream *lastrm)
2049 {
2050         lzma_stream *strm;
2051
2052         (void)a; /* UNUSED */
2053         strm = (lzma_stream *)lastrm->real_stream;
2054         lzma_end(strm);
2055         free(strm);
2056         lastrm->valid = 0;
2057         lastrm->real_stream = NULL;
2058         return (ARCHIVE_OK);
2059 }
2060 #else
2061 static int
2062 compression_init_encoder_lzma1(struct archive *a,
2063     struct la_zstream *lastrm, int level)
2064 {
2065
2066         (void) level; /* UNUSED */
2067         if (lastrm->valid)
2068                 compression_end(a, lastrm);
2069         return (compression_unsupported_encoder(a, lastrm, "lzma"));
2070 }
2071 static int
2072 compression_init_encoder_lzma2(struct archive *a,
2073     struct la_zstream *lastrm, int level)
2074 {
2075
2076         (void) level; /* UNUSED */
2077         if (lastrm->valid)
2078                 compression_end(a, lastrm);
2079         return (compression_unsupported_encoder(a, lastrm, "lzma"));
2080 }
2081 #endif
2082
2083 /*
2084  * _7_PPMD compressor.
2085  */
2086 static void *
2087 ppmd_alloc(void *p, size_t size)
2088 {
2089         (void)p;
2090         return malloc(size);
2091 }
2092 static void
2093 ppmd_free(void *p, void *address)
2094 {
2095         (void)p;
2096         free(address);
2097 }
2098 static ISzAlloc g_szalloc = { ppmd_alloc, ppmd_free };
2099 static void
2100 ppmd_write(void *p, Byte b)
2101 {
2102         struct archive_write *a = ((IByteOut *)p)->a;
2103         struct _7zip *zip = (struct _7zip *)(a->format_data);
2104         struct la_zstream *lastrm = &(zip->stream);
2105         struct ppmd_stream *strm;
2106
2107         if (lastrm->avail_out) {
2108                 *lastrm->next_out++ = b;
2109                 lastrm->avail_out--;
2110                 lastrm->total_out++;
2111                 return;
2112         }
2113         strm = (struct ppmd_stream *)lastrm->real_stream;
2114         if (strm->buff_ptr < strm->buff_end) {
2115                 *strm->buff_ptr++ = b;
2116                 strm->buff_bytes++;
2117         }
2118 }
2119
2120 static int
2121 compression_init_encoder_ppmd(struct archive *a,
2122     struct la_zstream *lastrm, unsigned maxOrder, uint32_t msize)
2123 {
2124         struct ppmd_stream *strm;
2125         uint8_t *props;
2126         int r;
2127
2128         if (lastrm->valid)
2129                 compression_end(a, lastrm);
2130         strm = calloc(1, sizeof(*strm));
2131         if (strm == NULL) {
2132                 archive_set_error(a, ENOMEM,
2133                     "Can't allocate memory for PPMd");
2134                 return (ARCHIVE_FATAL);
2135         }
2136         strm->buff = malloc(32);
2137         if (strm->buff == NULL) {
2138                 free(strm);
2139                 archive_set_error(a, ENOMEM,
2140                     "Can't allocate memory for PPMd");
2141                 return (ARCHIVE_FATAL);
2142         }
2143         strm->buff_ptr = strm->buff;
2144         strm->buff_end = strm->buff + 32;
2145
2146         props = malloc(1+4);
2147         if (props == NULL) {
2148                 free(strm->buff);
2149                 free(strm);
2150                 archive_set_error(a, ENOMEM,
2151                     "Coludn't allocate memory for PPMd");
2152                 return (ARCHIVE_FATAL);
2153         }
2154         props[0] = maxOrder;
2155         archive_le32enc(props+1, msize);
2156         __archive_ppmd7_functions.Ppmd7_Construct(&strm->ppmd7_context);
2157         r = __archive_ppmd7_functions.Ppmd7_Alloc(
2158                 &strm->ppmd7_context, msize, &g_szalloc);
2159         if (r == 0) {
2160                 free(strm->buff);
2161                 free(strm);
2162                 free(props);
2163                 archive_set_error(a, ENOMEM,
2164                     "Coludn't allocate memory for PPMd");
2165                 return (ARCHIVE_FATAL);
2166         }
2167         __archive_ppmd7_functions.Ppmd7_Init(&(strm->ppmd7_context), maxOrder);
2168         strm->byteout.a = (struct archive_write *)a;
2169         strm->byteout.Write = ppmd_write;
2170         strm->range_enc.Stream = &(strm->byteout);
2171         __archive_ppmd7_functions.Ppmd7z_RangeEnc_Init(&(strm->range_enc));
2172         strm->stat = 0;
2173
2174         lastrm->real_stream = strm;
2175         lastrm->valid = 1;
2176         lastrm->code = compression_code_ppmd;
2177         lastrm->end = compression_end_ppmd;
2178         lastrm->prop_size = 5;
2179         lastrm->props = props;
2180         return (ARCHIVE_OK);
2181 }
2182
2183 static int
2184 compression_code_ppmd(struct archive *a,
2185     struct la_zstream *lastrm, enum la_zaction action)
2186 {
2187         struct ppmd_stream *strm;
2188
2189         (void)a; /* UNUSED */
2190
2191         strm = (struct ppmd_stream *)lastrm->real_stream;
2192
2193         /* Copy encoded data if there are remaining bytes from previous call. */
2194         if (strm->buff_bytes) {
2195                 uint8_t *p = strm->buff_ptr - strm->buff_bytes;
2196                 while (lastrm->avail_out && strm->buff_bytes) {
2197                         *lastrm->next_out++ = *p++;
2198                         lastrm->avail_out--;
2199                         lastrm->total_out++;
2200                         strm->buff_bytes--;
2201                 }
2202                 if (strm->buff_bytes)
2203                         return (ARCHIVE_OK);
2204                 if (strm->stat == 1)
2205                         return (ARCHIVE_EOF);
2206                 strm->buff_ptr = strm->buff;
2207         }
2208         while (lastrm->avail_in && lastrm->avail_out) {
2209                 __archive_ppmd7_functions.Ppmd7_EncodeSymbol(
2210                         &(strm->ppmd7_context), &(strm->range_enc),
2211                         *lastrm->next_in++);
2212                 lastrm->avail_in--;
2213                 lastrm->total_in++;
2214         }
2215         if (lastrm->avail_in == 0 && action == ARCHIVE_Z_FINISH) {
2216                 __archive_ppmd7_functions.Ppmd7z_RangeEnc_FlushData(
2217                         &(strm->range_enc));
2218                 strm->stat = 1;
2219                 /* Return EOF if there are no remaining bytes. */
2220                 if (strm->buff_bytes == 0)
2221                         return (ARCHIVE_EOF);
2222         }
2223         return (ARCHIVE_OK);
2224 }
2225
2226 static int
2227 compression_end_ppmd(struct archive *a, struct la_zstream *lastrm)
2228 {
2229         struct ppmd_stream *strm;
2230
2231         (void)a; /* UNUSED */
2232
2233         strm = (struct ppmd_stream *)lastrm->real_stream;
2234         __archive_ppmd7_functions.Ppmd7_Free(&strm->ppmd7_context, &g_szalloc);
2235         free(strm->buff);
2236         free(strm);
2237         lastrm->real_stream = NULL;
2238         lastrm->valid = 0;
2239         return (ARCHIVE_OK);
2240 }
2241
2242 /*
2243  * Universal compressor initializer.
2244  */
2245 static int
2246 _7z_compression_init_encoder(struct archive_write *a, unsigned compression,
2247     int compression_level)
2248 {
2249         struct _7zip *zip;
2250         int r;
2251
2252         zip = (struct _7zip *)a->format_data;
2253         switch (compression) {
2254         case _7Z_DEFLATE:
2255                 r = compression_init_encoder_deflate(
2256                     &(a->archive), &(zip->stream),
2257                     compression_level, 0);
2258                 break;
2259         case _7Z_BZIP2:
2260                 r = compression_init_encoder_bzip2(
2261                     &(a->archive), &(zip->stream),
2262                     compression_level);
2263                 break;
2264         case _7Z_LZMA1:
2265                 r = compression_init_encoder_lzma1(
2266                     &(a->archive), &(zip->stream),
2267                     compression_level);
2268                 break;
2269         case _7Z_LZMA2:
2270                 r = compression_init_encoder_lzma2(
2271                     &(a->archive), &(zip->stream),
2272                     compression_level);
2273                 break;
2274         case _7Z_PPMD:
2275                 r = compression_init_encoder_ppmd(
2276                     &(a->archive), &(zip->stream),
2277                     PPMD7_DEFAULT_ORDER, PPMD7_DEFAULT_MEM_SIZE);
2278                 break;
2279         case _7Z_COPY:
2280         default:
2281                 r = compression_init_encoder_copy(
2282                     &(a->archive), &(zip->stream));
2283                 break;
2284         }
2285         if (r == ARCHIVE_OK) {
2286                 zip->stream.total_in = 0;
2287                 zip->stream.next_out = zip->wbuff;
2288                 zip->stream.avail_out = sizeof(zip->wbuff);
2289                 zip->stream.total_out = 0;
2290         }
2291
2292         return (r);
2293 }
2294
2295 static int
2296 compression_code(struct archive *a, struct la_zstream *lastrm,
2297     enum la_zaction action)
2298 {
2299         if (lastrm->valid)
2300                 return (lastrm->code(a, lastrm, action));
2301         return (ARCHIVE_OK);
2302 }
2303
2304 static int
2305 compression_end(struct archive *a, struct la_zstream *lastrm)
2306 {
2307         if (lastrm->valid) {
2308                 lastrm->prop_size = 0;
2309                 free(lastrm->props);
2310                 lastrm->props = NULL;
2311                 return (lastrm->end(a, lastrm));
2312         }
2313         return (ARCHIVE_OK);
2314 }
2315
2316