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