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