1 /*- 2 * Copyright (c) 2003-2010 Tim Kientzle 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: head/lib/libarchive/archive_write.c 201099 2009-12-28 03:03:00Z kientzle $"); 28 29 /* 30 * This file contains the "essential" portions of the write API, that 31 * is, stuff that will essentially always be used by any client that 32 * actually needs to write an archive. Optional pieces have been, as 33 * far as possible, separated out into separate files to reduce 34 * needlessly bloating statically-linked clients. 35 */ 36 37 #ifdef HAVE_SYS_WAIT_H 38 #include <sys/wait.h> 39 #endif 40 #ifdef HAVE_ERRNO_H 41 #include <errno.h> 42 #endif 43 #ifdef HAVE_LIMITS_H 44 #include <limits.h> 45 #endif 46 #include <stdio.h> 47 #ifdef HAVE_STDLIB_H 48 #include <stdlib.h> 49 #endif 50 #ifdef HAVE_STRING_H 51 #include <string.h> 52 #endif 53 #include <time.h> 54 #ifdef HAVE_UNISTD_H 55 #include <unistd.h> 56 #endif 57 58 #include "archive.h" 59 #include "archive_entry.h" 60 #include "archive_private.h" 61 #include "archive_write_private.h" 62 63 static struct archive_vtable *archive_write_vtable(void); 64 65 static int _archive_filter_code(struct archive *, int); 66 static const char *_archive_filter_name(struct archive *, int); 67 static int64_t _archive_filter_bytes(struct archive *, int); 68 static int _archive_write_filter_count(struct archive *); 69 static int _archive_write_close(struct archive *); 70 static int _archive_write_free(struct archive *); 71 static int _archive_write_header(struct archive *, struct archive_entry *); 72 static int _archive_write_finish_entry(struct archive *); 73 static ssize_t _archive_write_data(struct archive *, const void *, size_t); 74 75 struct archive_none { 76 size_t buffer_size; 77 size_t avail; 78 char *buffer; 79 char *next; 80 }; 81 82 static struct archive_vtable * 83 archive_write_vtable(void) 84 { 85 static struct archive_vtable av; 86 static int inited = 0; 87 88 if (!inited) { 89 av.archive_close = _archive_write_close; 90 av.archive_filter_bytes = _archive_filter_bytes; 91 av.archive_filter_code = _archive_filter_code; 92 av.archive_filter_name = _archive_filter_name; 93 av.archive_filter_count = _archive_write_filter_count; 94 av.archive_free = _archive_write_free; 95 av.archive_write_header = _archive_write_header; 96 av.archive_write_finish_entry = _archive_write_finish_entry; 97 av.archive_write_data = _archive_write_data; 98 inited = 1; 99 } 100 return (&av); 101 } 102 103 /* 104 * Allocate, initialize and return an archive object. 105 */ 106 struct archive * 107 archive_write_new(void) 108 { 109 struct archive_write *a; 110 unsigned char *nulls; 111 112 a = (struct archive_write *)calloc(1, sizeof(*a)); 113 if (a == NULL) 114 return (NULL); 115 a->archive.magic = ARCHIVE_WRITE_MAGIC; 116 a->archive.state = ARCHIVE_STATE_NEW; 117 a->archive.vtable = archive_write_vtable(); 118 /* 119 * The value 10240 here matches the traditional tar default, 120 * but is otherwise arbitrary. 121 * TODO: Set the default block size from the format selected. 122 */ 123 a->bytes_per_block = 10240; 124 a->bytes_in_last_block = -1; /* Default */ 125 126 /* Initialize a block of nulls for padding purposes. */ 127 a->null_length = 1024; 128 nulls = (unsigned char *)calloc(1, a->null_length); 129 if (nulls == NULL) { 130 free(a); 131 return (NULL); 132 } 133 a->nulls = nulls; 134 return (&a->archive); 135 } 136 137 /* 138 * Set the block size. Returns 0 if successful. 139 */ 140 int 141 archive_write_set_bytes_per_block(struct archive *_a, int bytes_per_block) 142 { 143 struct archive_write *a = (struct archive_write *)_a; 144 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 145 ARCHIVE_STATE_NEW, "archive_write_set_bytes_per_block"); 146 a->bytes_per_block = bytes_per_block; 147 return (ARCHIVE_OK); 148 } 149 150 /* 151 * Get the current block size. -1 if it has never been set. 152 */ 153 int 154 archive_write_get_bytes_per_block(struct archive *_a) 155 { 156 struct archive_write *a = (struct archive_write *)_a; 157 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 158 ARCHIVE_STATE_ANY, "archive_write_get_bytes_per_block"); 159 return (a->bytes_per_block); 160 } 161 162 /* 163 * Set the size for the last block. 164 * Returns 0 if successful. 165 */ 166 int 167 archive_write_set_bytes_in_last_block(struct archive *_a, int bytes) 168 { 169 struct archive_write *a = (struct archive_write *)_a; 170 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 171 ARCHIVE_STATE_ANY, "archive_write_set_bytes_in_last_block"); 172 a->bytes_in_last_block = bytes; 173 return (ARCHIVE_OK); 174 } 175 176 /* 177 * Return the value set above. -1 indicates it has not been set. 178 */ 179 int 180 archive_write_get_bytes_in_last_block(struct archive *_a) 181 { 182 struct archive_write *a = (struct archive_write *)_a; 183 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 184 ARCHIVE_STATE_ANY, "archive_write_get_bytes_in_last_block"); 185 return (a->bytes_in_last_block); 186 } 187 188 /* 189 * dev/ino of a file to be rejected. Used to prevent adding 190 * an archive to itself recursively. 191 */ 192 int 193 archive_write_set_skip_file(struct archive *_a, la_int64_t d, la_int64_t i) 194 { 195 struct archive_write *a = (struct archive_write *)_a; 196 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 197 ARCHIVE_STATE_ANY, "archive_write_set_skip_file"); 198 a->skip_file_set = 1; 199 a->skip_file_dev = d; 200 a->skip_file_ino = i; 201 return (ARCHIVE_OK); 202 } 203 204 /* 205 * Allocate and return the next filter structure. 206 */ 207 struct archive_write_filter * 208 __archive_write_allocate_filter(struct archive *_a) 209 { 210 struct archive_write *a = (struct archive_write *)_a; 211 struct archive_write_filter *f; 212 213 f = calloc(1, sizeof(*f)); 214 f->archive = _a; 215 f->state = ARCHIVE_WRITE_FILTER_STATE_NEW; 216 if (a->filter_first == NULL) 217 a->filter_first = f; 218 else 219 a->filter_last->next_filter = f; 220 a->filter_last = f; 221 return f; 222 } 223 224 /* 225 * Write data to a particular filter. 226 */ 227 int 228 __archive_write_filter(struct archive_write_filter *f, 229 const void *buff, size_t length) 230 { 231 int r; 232 /* Never write to non-open filters */ 233 if (f->state != ARCHIVE_WRITE_FILTER_STATE_OPEN) 234 return(ARCHIVE_FATAL); 235 if (length == 0) 236 return(ARCHIVE_OK); 237 if (f->write == NULL) 238 /* If unset, a fatal error has already occurred, so this filter 239 * didn't open. We cannot write anything. */ 240 return(ARCHIVE_FATAL); 241 r = (f->write)(f, buff, length); 242 f->bytes_written += length; 243 return (r); 244 } 245 246 /* 247 * Recursive function for opening the filter chain 248 * Last filter is opened first 249 */ 250 static int 251 __archive_write_open_filter(struct archive_write_filter *f) 252 { 253 int ret; 254 255 ret = ARCHIVE_OK; 256 if (f->next_filter != NULL) 257 ret = __archive_write_open_filter(f->next_filter); 258 if (ret != ARCHIVE_OK) 259 return (ret); 260 if (f->state != ARCHIVE_WRITE_FILTER_STATE_NEW) 261 return (ARCHIVE_FATAL); 262 if (f->open == NULL) { 263 f->state = ARCHIVE_WRITE_FILTER_STATE_OPEN; 264 return (ARCHIVE_OK); 265 } 266 ret = (f->open)(f); 267 if (ret == ARCHIVE_OK) 268 f->state = ARCHIVE_WRITE_FILTER_STATE_OPEN; 269 else 270 f->state = ARCHIVE_WRITE_FILTER_STATE_FATAL; 271 return (ret); 272 } 273 274 /* 275 * Open all filters 276 */ 277 static int 278 __archive_write_filters_open(struct archive_write *a) 279 { 280 return (__archive_write_open_filter(a->filter_first)); 281 } 282 283 /* 284 * Close all filtes 285 */ 286 static int 287 __archive_write_filters_close(struct archive_write *a) 288 { 289 struct archive_write_filter *f; 290 int ret, ret1; 291 ret = ARCHIVE_OK; 292 for (f = a->filter_first; f != NULL; f = f->next_filter) { 293 /* Do not close filters that are not open */ 294 if (f->state == ARCHIVE_WRITE_FILTER_STATE_OPEN) { 295 if (f->close != NULL) { 296 ret1 = (f->close)(f); 297 if (ret1 < ret) 298 ret = ret1; 299 if (ret1 == ARCHIVE_OK) { 300 f->state = 301 ARCHIVE_WRITE_FILTER_STATE_CLOSED; 302 } else { 303 f->state = 304 ARCHIVE_WRITE_FILTER_STATE_FATAL; 305 } 306 } else 307 f->state = ARCHIVE_WRITE_FILTER_STATE_CLOSED; 308 } 309 } 310 return (ret); 311 } 312 313 int 314 __archive_write_output(struct archive_write *a, const void *buff, size_t length) 315 { 316 return (__archive_write_filter(a->filter_first, buff, length)); 317 } 318 319 int 320 __archive_write_nulls(struct archive_write *a, size_t length) 321 { 322 if (length == 0) 323 return (ARCHIVE_OK); 324 325 while (length > 0) { 326 size_t to_write = length < a->null_length ? length : a->null_length; 327 int r = __archive_write_output(a, a->nulls, to_write); 328 if (r < ARCHIVE_OK) 329 return (r); 330 length -= to_write; 331 } 332 return (ARCHIVE_OK); 333 } 334 335 static int 336 archive_write_client_open(struct archive_write_filter *f) 337 { 338 struct archive_write *a = (struct archive_write *)f->archive; 339 struct archive_none *state; 340 void *buffer; 341 size_t buffer_size; 342 int ret; 343 344 f->bytes_per_block = archive_write_get_bytes_per_block(f->archive); 345 f->bytes_in_last_block = 346 archive_write_get_bytes_in_last_block(f->archive); 347 buffer_size = f->bytes_per_block; 348 349 state = (struct archive_none *)calloc(1, sizeof(*state)); 350 buffer = (char *)malloc(buffer_size); 351 if (state == NULL || buffer == NULL) { 352 free(state); 353 free(buffer); 354 archive_set_error(f->archive, ENOMEM, 355 "Can't allocate data for output buffering"); 356 return (ARCHIVE_FATAL); 357 } 358 359 state->buffer_size = buffer_size; 360 state->buffer = buffer; 361 state->next = state->buffer; 362 state->avail = state->buffer_size; 363 f->data = state; 364 365 if (a->client_opener == NULL) 366 return (ARCHIVE_OK); 367 ret = a->client_opener(f->archive, a->client_data); 368 if (ret != ARCHIVE_OK) { 369 free(state->buffer); 370 free(state); 371 f->data = NULL; 372 } 373 return (ret); 374 } 375 376 static int 377 archive_write_client_write(struct archive_write_filter *f, 378 const void *_buff, size_t length) 379 { 380 struct archive_write *a = (struct archive_write *)f->archive; 381 struct archive_none *state = (struct archive_none *)f->data; 382 const char *buff = (const char *)_buff; 383 ssize_t remaining, to_copy; 384 ssize_t bytes_written; 385 386 remaining = length; 387 388 /* 389 * If there is no buffer for blocking, just pass the data 390 * straight through to the client write callback. In 391 * particular, this supports "no write delay" operation for 392 * special applications. Just set the block size to zero. 393 */ 394 if (state->buffer_size == 0) { 395 while (remaining > 0) { 396 bytes_written = (a->client_writer)(&a->archive, 397 a->client_data, buff, remaining); 398 if (bytes_written <= 0) 399 return (ARCHIVE_FATAL); 400 remaining -= bytes_written; 401 buff += bytes_written; 402 } 403 return (ARCHIVE_OK); 404 } 405 406 /* If the copy buffer isn't empty, try to fill it. */ 407 if (state->avail < state->buffer_size) { 408 /* If buffer is not empty... */ 409 /* ... copy data into buffer ... */ 410 to_copy = ((size_t)remaining > state->avail) ? 411 state->avail : (size_t)remaining; 412 memcpy(state->next, buff, to_copy); 413 state->next += to_copy; 414 state->avail -= to_copy; 415 buff += to_copy; 416 remaining -= to_copy; 417 /* ... if it's full, write it out. */ 418 if (state->avail == 0) { 419 char *p = state->buffer; 420 size_t to_write = state->buffer_size; 421 while (to_write > 0) { 422 bytes_written = (a->client_writer)(&a->archive, 423 a->client_data, p, to_write); 424 if (bytes_written <= 0) 425 return (ARCHIVE_FATAL); 426 if ((size_t)bytes_written > to_write) { 427 archive_set_error(&(a->archive), 428 -1, "write overrun"); 429 return (ARCHIVE_FATAL); 430 } 431 p += bytes_written; 432 to_write -= bytes_written; 433 } 434 state->next = state->buffer; 435 state->avail = state->buffer_size; 436 } 437 } 438 439 while ((size_t)remaining >= state->buffer_size) { 440 /* Write out full blocks directly to client. */ 441 bytes_written = (a->client_writer)(&a->archive, 442 a->client_data, buff, state->buffer_size); 443 if (bytes_written <= 0) 444 return (ARCHIVE_FATAL); 445 buff += bytes_written; 446 remaining -= bytes_written; 447 } 448 449 if (remaining > 0) { 450 /* Copy last bit into copy buffer. */ 451 memcpy(state->next, buff, remaining); 452 state->next += remaining; 453 state->avail -= remaining; 454 } 455 return (ARCHIVE_OK); 456 } 457 458 static int 459 archive_write_client_close(struct archive_write_filter *f) 460 { 461 struct archive_write *a = (struct archive_write *)f->archive; 462 struct archive_none *state = (struct archive_none *)f->data; 463 ssize_t block_length; 464 ssize_t target_block_length; 465 ssize_t bytes_written; 466 int ret = ARCHIVE_OK; 467 468 /* If there's pending data, pad and write the last block */ 469 if (state->next != state->buffer) { 470 block_length = state->buffer_size - state->avail; 471 472 /* Tricky calculation to determine size of last block */ 473 if (a->bytes_in_last_block <= 0) 474 /* Default or Zero: pad to full block */ 475 target_block_length = a->bytes_per_block; 476 else 477 /* Round to next multiple of bytes_in_last_block. */ 478 target_block_length = a->bytes_in_last_block * 479 ( (block_length + a->bytes_in_last_block - 1) / 480 a->bytes_in_last_block); 481 if (target_block_length > a->bytes_per_block) 482 target_block_length = a->bytes_per_block; 483 if (block_length < target_block_length) { 484 memset(state->next, 0, 485 target_block_length - block_length); 486 block_length = target_block_length; 487 } 488 bytes_written = (a->client_writer)(&a->archive, 489 a->client_data, state->buffer, block_length); 490 ret = bytes_written <= 0 ? ARCHIVE_FATAL : ARCHIVE_OK; 491 } 492 if (a->client_closer) 493 (*a->client_closer)(&a->archive, a->client_data); 494 free(state->buffer); 495 free(state); 496 a->client_data = NULL; 497 /* Clear passphrase. */ 498 if (a->passphrase != NULL) { 499 memset(a->passphrase, 0, strlen(a->passphrase)); 500 free(a->passphrase); 501 a->passphrase = NULL; 502 } 503 /* Clear the close handler myself not to be called again. */ 504 f->state = ARCHIVE_WRITE_FILTER_STATE_CLOSED; 505 return (ret); 506 } 507 508 /* 509 * Open the archive using the current settings. 510 */ 511 int 512 archive_write_open(struct archive *_a, void *client_data, 513 archive_open_callback *opener, archive_write_callback *writer, 514 archive_close_callback *closer) 515 { 516 struct archive_write *a = (struct archive_write *)_a; 517 struct archive_write_filter *client_filter; 518 int ret, r1; 519 520 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 521 ARCHIVE_STATE_NEW, "archive_write_open"); 522 archive_clear_error(&a->archive); 523 524 a->client_writer = writer; 525 a->client_opener = opener; 526 a->client_closer = closer; 527 a->client_data = client_data; 528 529 client_filter = __archive_write_allocate_filter(_a); 530 client_filter->open = archive_write_client_open; 531 client_filter->write = archive_write_client_write; 532 client_filter->close = archive_write_client_close; 533 534 ret = __archive_write_filters_open(a); 535 if (ret < ARCHIVE_WARN) { 536 r1 = __archive_write_filters_close(a); 537 __archive_write_filters_free(_a); 538 return (r1 < ret ? r1 : ret); 539 } 540 541 a->archive.state = ARCHIVE_STATE_HEADER; 542 if (a->format_init) 543 ret = (a->format_init)(a); 544 return (ret); 545 } 546 547 /* 548 * Close out the archive. 549 */ 550 static int 551 _archive_write_close(struct archive *_a) 552 { 553 struct archive_write *a = (struct archive_write *)_a; 554 int r = ARCHIVE_OK, r1 = ARCHIVE_OK; 555 556 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 557 ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, 558 "archive_write_close"); 559 if (a->archive.state == ARCHIVE_STATE_NEW 560 || a->archive.state == ARCHIVE_STATE_CLOSED) 561 return (ARCHIVE_OK); /* Okay to close() when not open. */ 562 563 archive_clear_error(&a->archive); 564 565 /* Finish the last entry if a finish callback is specified */ 566 if (a->archive.state == ARCHIVE_STATE_DATA 567 && a->format_finish_entry != NULL) 568 r = ((a->format_finish_entry)(a)); 569 570 /* Finish off the archive. */ 571 /* TODO: have format closers invoke compression close. */ 572 if (a->format_close != NULL) { 573 r1 = (a->format_close)(a); 574 if (r1 < r) 575 r = r1; 576 } 577 578 /* Finish the compression and close the stream. */ 579 r1 = __archive_write_filters_close(a); 580 if (r1 < r) 581 r = r1; 582 583 if (a->archive.state != ARCHIVE_STATE_FATAL) 584 a->archive.state = ARCHIVE_STATE_CLOSED; 585 return (r); 586 } 587 588 static int 589 _archive_write_filter_count(struct archive *_a) 590 { 591 struct archive_write *a = (struct archive_write *)_a; 592 struct archive_write_filter *p = a->filter_first; 593 int count = 0; 594 while(p) { 595 count++; 596 p = p->next_filter; 597 } 598 return count; 599 } 600 601 void 602 __archive_write_filters_free(struct archive *_a) 603 { 604 struct archive_write *a = (struct archive_write *)_a; 605 int r = ARCHIVE_OK, r1; 606 607 while (a->filter_first != NULL) { 608 struct archive_write_filter *next 609 = a->filter_first->next_filter; 610 if (a->filter_first->free != NULL) { 611 r1 = (*a->filter_first->free)(a->filter_first); 612 if (r > r1) 613 r = r1; 614 } 615 free(a->filter_first); 616 a->filter_first = next; 617 } 618 a->filter_last = NULL; 619 } 620 621 /* 622 * Destroy the archive structure. 623 * 624 * Be careful: user might just call write_new and then write_free. 625 * Don't assume we actually wrote anything or performed any non-trivial 626 * initialization. 627 */ 628 static int 629 _archive_write_free(struct archive *_a) 630 { 631 struct archive_write *a = (struct archive_write *)_a; 632 int r = ARCHIVE_OK, r1; 633 634 if (_a == NULL) 635 return (ARCHIVE_OK); 636 /* It is okay to call free() in state FATAL. */ 637 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 638 ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_write_free"); 639 if (a->archive.state != ARCHIVE_STATE_FATAL) 640 r = archive_write_close(&a->archive); 641 642 /* Release format resources. */ 643 if (a->format_free != NULL) { 644 r1 = (a->format_free)(a); 645 if (r1 < r) 646 r = r1; 647 } 648 649 __archive_write_filters_free(_a); 650 651 /* Release various dynamic buffers. */ 652 free((void *)(uintptr_t)(const void *)a->nulls); 653 archive_string_free(&a->archive.error_string); 654 if (a->passphrase != NULL) { 655 /* A passphrase should be cleaned. */ 656 memset(a->passphrase, 0, strlen(a->passphrase)); 657 free(a->passphrase); 658 } 659 a->archive.magic = 0; 660 __archive_clean(&a->archive); 661 free(a); 662 return (r); 663 } 664 665 /* 666 * Write the appropriate header. 667 */ 668 static int 669 _archive_write_header(struct archive *_a, struct archive_entry *entry) 670 { 671 struct archive_write *a = (struct archive_write *)_a; 672 int ret, r2; 673 674 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 675 ARCHIVE_STATE_DATA | ARCHIVE_STATE_HEADER, "archive_write_header"); 676 archive_clear_error(&a->archive); 677 678 if (a->format_write_header == NULL) { 679 archive_set_error(&(a->archive), -1, 680 "Format must be set before you can write to an archive."); 681 a->archive.state = ARCHIVE_STATE_FATAL; 682 return (ARCHIVE_FATAL); 683 } 684 685 /* In particular, "retry" and "fatal" get returned immediately. */ 686 ret = archive_write_finish_entry(&a->archive); 687 if (ret == ARCHIVE_FATAL) { 688 a->archive.state = ARCHIVE_STATE_FATAL; 689 return (ARCHIVE_FATAL); 690 } 691 if (ret < ARCHIVE_OK && ret != ARCHIVE_WARN) 692 return (ret); 693 694 if (a->skip_file_set && 695 archive_entry_dev_is_set(entry) && 696 archive_entry_ino_is_set(entry) && 697 archive_entry_dev(entry) == (dev_t)a->skip_file_dev && 698 archive_entry_ino64(entry) == a->skip_file_ino) { 699 archive_set_error(&a->archive, 0, 700 "Can't add archive to itself"); 701 return (ARCHIVE_FAILED); 702 } 703 704 /* Format and write header. */ 705 r2 = ((a->format_write_header)(a, entry)); 706 if (r2 == ARCHIVE_FAILED) { 707 return (ARCHIVE_FAILED); 708 } 709 if (r2 == ARCHIVE_FATAL) { 710 a->archive.state = ARCHIVE_STATE_FATAL; 711 return (ARCHIVE_FATAL); 712 } 713 if (r2 < ret) 714 ret = r2; 715 716 a->archive.state = ARCHIVE_STATE_DATA; 717 return (ret); 718 } 719 720 static int 721 _archive_write_finish_entry(struct archive *_a) 722 { 723 struct archive_write *a = (struct archive_write *)_a; 724 int ret = ARCHIVE_OK; 725 726 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 727 ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA, 728 "archive_write_finish_entry"); 729 if (a->archive.state & ARCHIVE_STATE_DATA 730 && a->format_finish_entry != NULL) 731 ret = (a->format_finish_entry)(a); 732 a->archive.state = ARCHIVE_STATE_HEADER; 733 return (ret); 734 } 735 736 /* 737 * Note that the compressor is responsible for blocking. 738 */ 739 static ssize_t 740 _archive_write_data(struct archive *_a, const void *buff, size_t s) 741 { 742 struct archive_write *a = (struct archive_write *)_a; 743 const size_t max_write = INT_MAX; 744 745 archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 746 ARCHIVE_STATE_DATA, "archive_write_data"); 747 /* In particular, this catches attempts to pass negative values. */ 748 if (s > max_write) 749 s = max_write; 750 archive_clear_error(&a->archive); 751 return ((a->format_write_data)(a, buff, s)); 752 } 753 754 static struct archive_write_filter * 755 filter_lookup(struct archive *_a, int n) 756 { 757 struct archive_write *a = (struct archive_write *)_a; 758 struct archive_write_filter *f = a->filter_first; 759 if (n == -1) 760 return a->filter_last; 761 if (n < 0) 762 return NULL; 763 while (n > 0 && f != NULL) { 764 f = f->next_filter; 765 --n; 766 } 767 return f; 768 } 769 770 static int 771 _archive_filter_code(struct archive *_a, int n) 772 { 773 struct archive_write_filter *f = filter_lookup(_a, n); 774 return f == NULL ? -1 : f->code; 775 } 776 777 static const char * 778 _archive_filter_name(struct archive *_a, int n) 779 { 780 struct archive_write_filter *f = filter_lookup(_a, n); 781 return f != NULL ? f->name : NULL; 782 } 783 784 static int64_t 785 _archive_filter_bytes(struct archive *_a, int n) 786 { 787 struct archive_write_filter *f = filter_lookup(_a, n); 788 return f == NULL ? -1 : f->bytes_written; 789 } 790