archive_read.c revision 348608
1/*- 2 * Copyright (c) 2003-2011 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/* 27 * This file contains the "essential" portions of the read API, that 28 * is, stuff that will probably always be used by any client that 29 * actually needs to read an archive. Optional pieces have been, as 30 * far as possible, separated out into separate files to avoid 31 * needlessly bloating statically-linked clients. 32 */ 33 34#include "archive_platform.h" 35__FBSDID("$FreeBSD: stable/10/contrib/libarchive/libarchive/archive_read.c 348608 2019-06-04 10:36:26Z mm $"); 36 37#ifdef HAVE_ERRNO_H 38#include <errno.h> 39#endif 40#include <stdio.h> 41#ifdef HAVE_STDLIB_H 42#include <stdlib.h> 43#endif 44#ifdef HAVE_STRING_H 45#include <string.h> 46#endif 47#ifdef HAVE_UNISTD_H 48#include <unistd.h> 49#endif 50 51#include "archive.h" 52#include "archive_entry.h" 53#include "archive_private.h" 54#include "archive_read_private.h" 55 56#define minimum(a, b) (a < b ? a : b) 57 58static int choose_filters(struct archive_read *); 59static int choose_format(struct archive_read *); 60static int close_filters(struct archive_read *); 61static struct archive_vtable *archive_read_vtable(void); 62static int64_t _archive_filter_bytes(struct archive *, int); 63static int _archive_filter_code(struct archive *, int); 64static const char *_archive_filter_name(struct archive *, int); 65static int _archive_filter_count(struct archive *); 66static int _archive_read_close(struct archive *); 67static int _archive_read_data_block(struct archive *, 68 const void **, size_t *, int64_t *); 69static int _archive_read_free(struct archive *); 70static int _archive_read_next_header(struct archive *, 71 struct archive_entry **); 72static int _archive_read_next_header2(struct archive *, 73 struct archive_entry *); 74static int64_t advance_file_pointer(struct archive_read_filter *, int64_t); 75 76static struct archive_vtable * 77archive_read_vtable(void) 78{ 79 static struct archive_vtable av; 80 static int inited = 0; 81 82 if (!inited) { 83 av.archive_filter_bytes = _archive_filter_bytes; 84 av.archive_filter_code = _archive_filter_code; 85 av.archive_filter_name = _archive_filter_name; 86 av.archive_filter_count = _archive_filter_count; 87 av.archive_read_data_block = _archive_read_data_block; 88 av.archive_read_next_header = _archive_read_next_header; 89 av.archive_read_next_header2 = _archive_read_next_header2; 90 av.archive_free = _archive_read_free; 91 av.archive_close = _archive_read_close; 92 inited = 1; 93 } 94 return (&av); 95} 96 97/* 98 * Allocate, initialize and return a struct archive object. 99 */ 100struct archive * 101archive_read_new(void) 102{ 103 struct archive_read *a; 104 105 a = (struct archive_read *)calloc(1, sizeof(*a)); 106 if (a == NULL) 107 return (NULL); 108 a->archive.magic = ARCHIVE_READ_MAGIC; 109 110 a->archive.state = ARCHIVE_STATE_NEW; 111 a->entry = archive_entry_new2(&a->archive); 112 a->archive.vtable = archive_read_vtable(); 113 114 a->passphrases.last = &a->passphrases.first; 115 116 return (&a->archive); 117} 118 119/* 120 * Record the do-not-extract-to file. This belongs in archive_read_extract.c. 121 */ 122void 123archive_read_extract_set_skip_file(struct archive *_a, la_int64_t d, 124 la_int64_t i) 125{ 126 struct archive_read *a = (struct archive_read *)_a; 127 128 if (ARCHIVE_OK != __archive_check_magic(_a, ARCHIVE_READ_MAGIC, 129 ARCHIVE_STATE_ANY, "archive_read_extract_set_skip_file")) 130 return; 131 a->skip_file_set = 1; 132 a->skip_file_dev = d; 133 a->skip_file_ino = i; 134} 135 136/* 137 * Open the archive 138 */ 139int 140archive_read_open(struct archive *a, void *client_data, 141 archive_open_callback *client_opener, archive_read_callback *client_reader, 142 archive_close_callback *client_closer) 143{ 144 /* Old archive_read_open() is just a thin shell around 145 * archive_read_open1. */ 146 archive_read_set_open_callback(a, client_opener); 147 archive_read_set_read_callback(a, client_reader); 148 archive_read_set_close_callback(a, client_closer); 149 archive_read_set_callback_data(a, client_data); 150 return archive_read_open1(a); 151} 152 153 154int 155archive_read_open2(struct archive *a, void *client_data, 156 archive_open_callback *client_opener, 157 archive_read_callback *client_reader, 158 archive_skip_callback *client_skipper, 159 archive_close_callback *client_closer) 160{ 161 /* Old archive_read_open2() is just a thin shell around 162 * archive_read_open1. */ 163 archive_read_set_callback_data(a, client_data); 164 archive_read_set_open_callback(a, client_opener); 165 archive_read_set_read_callback(a, client_reader); 166 archive_read_set_skip_callback(a, client_skipper); 167 archive_read_set_close_callback(a, client_closer); 168 return archive_read_open1(a); 169} 170 171static ssize_t 172client_read_proxy(struct archive_read_filter *self, const void **buff) 173{ 174 ssize_t r; 175 r = (self->archive->client.reader)(&self->archive->archive, 176 self->data, buff); 177 return (r); 178} 179 180static int64_t 181client_skip_proxy(struct archive_read_filter *self, int64_t request) 182{ 183 if (request < 0) 184 __archive_errx(1, "Negative skip requested."); 185 if (request == 0) 186 return 0; 187 188 if (self->archive->client.skipper != NULL) { 189 /* Seek requests over 1GiB are broken down into 190 * multiple seeks. This avoids overflows when the 191 * requests get passed through 32-bit arguments. */ 192 int64_t skip_limit = (int64_t)1 << 30; 193 int64_t total = 0; 194 for (;;) { 195 int64_t get, ask = request; 196 if (ask > skip_limit) 197 ask = skip_limit; 198 get = (self->archive->client.skipper) 199 (&self->archive->archive, self->data, ask); 200 total += get; 201 if (get == 0 || get == request) 202 return (total); 203 if (get > request) 204 return ARCHIVE_FATAL; 205 request -= get; 206 } 207 } else if (self->archive->client.seeker != NULL 208 && request > 64 * 1024) { 209 /* If the client provided a seeker but not a skipper, 210 * we can use the seeker to skip forward. 211 * 212 * Note: This isn't always a good idea. The client 213 * skipper is allowed to skip by less than requested 214 * if it needs to maintain block alignment. The 215 * seeker is not allowed to play such games, so using 216 * the seeker here may be a performance loss compared 217 * to just reading and discarding. That's why we 218 * only do this for skips of over 64k. 219 */ 220 int64_t before = self->position; 221 int64_t after = (self->archive->client.seeker) 222 (&self->archive->archive, self->data, request, SEEK_CUR); 223 if (after != before + request) 224 return ARCHIVE_FATAL; 225 return after - before; 226 } 227 return 0; 228} 229 230static int64_t 231client_seek_proxy(struct archive_read_filter *self, int64_t offset, int whence) 232{ 233 /* DO NOT use the skipper here! If we transparently handled 234 * forward seek here by using the skipper, that will break 235 * other libarchive code that assumes a successful forward 236 * seek means it can also seek backwards. 237 */ 238 if (self->archive->client.seeker == NULL) { 239 archive_set_error(&self->archive->archive, ARCHIVE_ERRNO_MISC, 240 "Current client reader does not support seeking a device"); 241 return (ARCHIVE_FAILED); 242 } 243 return (self->archive->client.seeker)(&self->archive->archive, 244 self->data, offset, whence); 245} 246 247static int 248client_close_proxy(struct archive_read_filter *self) 249{ 250 int r = ARCHIVE_OK, r2; 251 unsigned int i; 252 253 if (self->archive->client.closer == NULL) 254 return (r); 255 for (i = 0; i < self->archive->client.nodes; i++) 256 { 257 r2 = (self->archive->client.closer) 258 ((struct archive *)self->archive, 259 self->archive->client.dataset[i].data); 260 if (r > r2) 261 r = r2; 262 } 263 return (r); 264} 265 266static int 267client_open_proxy(struct archive_read_filter *self) 268{ 269 int r = ARCHIVE_OK; 270 if (self->archive->client.opener != NULL) 271 r = (self->archive->client.opener)( 272 (struct archive *)self->archive, self->data); 273 return (r); 274} 275 276static int 277client_switch_proxy(struct archive_read_filter *self, unsigned int iindex) 278{ 279 int r1 = ARCHIVE_OK, r2 = ARCHIVE_OK; 280 void *data2 = NULL; 281 282 /* Don't do anything if already in the specified data node */ 283 if (self->archive->client.cursor == iindex) 284 return (ARCHIVE_OK); 285 286 self->archive->client.cursor = iindex; 287 data2 = self->archive->client.dataset[self->archive->client.cursor].data; 288 if (self->archive->client.switcher != NULL) 289 { 290 r1 = r2 = (self->archive->client.switcher) 291 ((struct archive *)self->archive, self->data, data2); 292 self->data = data2; 293 } 294 else 295 { 296 /* Attempt to call close and open instead */ 297 if (self->archive->client.closer != NULL) 298 r1 = (self->archive->client.closer) 299 ((struct archive *)self->archive, self->data); 300 self->data = data2; 301 if (self->archive->client.opener != NULL) 302 r2 = (self->archive->client.opener) 303 ((struct archive *)self->archive, self->data); 304 } 305 return (r1 < r2) ? r1 : r2; 306} 307 308int 309archive_read_set_open_callback(struct archive *_a, 310 archive_open_callback *client_opener) 311{ 312 struct archive_read *a = (struct archive_read *)_a; 313 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 314 "archive_read_set_open_callback"); 315 a->client.opener = client_opener; 316 return ARCHIVE_OK; 317} 318 319int 320archive_read_set_read_callback(struct archive *_a, 321 archive_read_callback *client_reader) 322{ 323 struct archive_read *a = (struct archive_read *)_a; 324 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 325 "archive_read_set_read_callback"); 326 a->client.reader = client_reader; 327 return ARCHIVE_OK; 328} 329 330int 331archive_read_set_skip_callback(struct archive *_a, 332 archive_skip_callback *client_skipper) 333{ 334 struct archive_read *a = (struct archive_read *)_a; 335 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 336 "archive_read_set_skip_callback"); 337 a->client.skipper = client_skipper; 338 return ARCHIVE_OK; 339} 340 341int 342archive_read_set_seek_callback(struct archive *_a, 343 archive_seek_callback *client_seeker) 344{ 345 struct archive_read *a = (struct archive_read *)_a; 346 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 347 "archive_read_set_seek_callback"); 348 a->client.seeker = client_seeker; 349 return ARCHIVE_OK; 350} 351 352int 353archive_read_set_close_callback(struct archive *_a, 354 archive_close_callback *client_closer) 355{ 356 struct archive_read *a = (struct archive_read *)_a; 357 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 358 "archive_read_set_close_callback"); 359 a->client.closer = client_closer; 360 return ARCHIVE_OK; 361} 362 363int 364archive_read_set_switch_callback(struct archive *_a, 365 archive_switch_callback *client_switcher) 366{ 367 struct archive_read *a = (struct archive_read *)_a; 368 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 369 "archive_read_set_switch_callback"); 370 a->client.switcher = client_switcher; 371 return ARCHIVE_OK; 372} 373 374int 375archive_read_set_callback_data(struct archive *_a, void *client_data) 376{ 377 return archive_read_set_callback_data2(_a, client_data, 0); 378} 379 380int 381archive_read_set_callback_data2(struct archive *_a, void *client_data, 382 unsigned int iindex) 383{ 384 struct archive_read *a = (struct archive_read *)_a; 385 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 386 "archive_read_set_callback_data2"); 387 388 if (a->client.nodes == 0) 389 { 390 a->client.dataset = (struct archive_read_data_node *) 391 calloc(1, sizeof(*a->client.dataset)); 392 if (a->client.dataset == NULL) 393 { 394 archive_set_error(&a->archive, ENOMEM, 395 "No memory."); 396 return ARCHIVE_FATAL; 397 } 398 a->client.nodes = 1; 399 } 400 401 if (iindex > a->client.nodes - 1) 402 { 403 archive_set_error(&a->archive, EINVAL, 404 "Invalid index specified."); 405 return ARCHIVE_FATAL; 406 } 407 a->client.dataset[iindex].data = client_data; 408 a->client.dataset[iindex].begin_position = -1; 409 a->client.dataset[iindex].total_size = -1; 410 return ARCHIVE_OK; 411} 412 413int 414archive_read_add_callback_data(struct archive *_a, void *client_data, 415 unsigned int iindex) 416{ 417 struct archive_read *a = (struct archive_read *)_a; 418 void *p; 419 unsigned int i; 420 421 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 422 "archive_read_add_callback_data"); 423 if (iindex > a->client.nodes) { 424 archive_set_error(&a->archive, EINVAL, 425 "Invalid index specified."); 426 return ARCHIVE_FATAL; 427 } 428 p = realloc(a->client.dataset, sizeof(*a->client.dataset) 429 * (++(a->client.nodes))); 430 if (p == NULL) { 431 archive_set_error(&a->archive, ENOMEM, 432 "No memory."); 433 return ARCHIVE_FATAL; 434 } 435 a->client.dataset = (struct archive_read_data_node *)p; 436 for (i = a->client.nodes - 1; i > iindex && i > 0; i--) { 437 a->client.dataset[i].data = a->client.dataset[i-1].data; 438 a->client.dataset[i].begin_position = -1; 439 a->client.dataset[i].total_size = -1; 440 } 441 a->client.dataset[iindex].data = client_data; 442 a->client.dataset[iindex].begin_position = -1; 443 a->client.dataset[iindex].total_size = -1; 444 return ARCHIVE_OK; 445} 446 447int 448archive_read_append_callback_data(struct archive *_a, void *client_data) 449{ 450 struct archive_read *a = (struct archive_read *)_a; 451 return archive_read_add_callback_data(_a, client_data, a->client.nodes); 452} 453 454int 455archive_read_prepend_callback_data(struct archive *_a, void *client_data) 456{ 457 return archive_read_add_callback_data(_a, client_data, 0); 458} 459 460int 461archive_read_open1(struct archive *_a) 462{ 463 struct archive_read *a = (struct archive_read *)_a; 464 struct archive_read_filter *filter, *tmp; 465 int slot, e = ARCHIVE_OK; 466 unsigned int i; 467 468 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 469 "archive_read_open"); 470 archive_clear_error(&a->archive); 471 472 if (a->client.reader == NULL) { 473 archive_set_error(&a->archive, EINVAL, 474 "No reader function provided to archive_read_open"); 475 a->archive.state = ARCHIVE_STATE_FATAL; 476 return (ARCHIVE_FATAL); 477 } 478 479 /* Open data source. */ 480 if (a->client.opener != NULL) { 481 e = (a->client.opener)(&a->archive, a->client.dataset[0].data); 482 if (e != 0) { 483 /* If the open failed, call the closer to clean up. */ 484 if (a->client.closer) { 485 for (i = 0; i < a->client.nodes; i++) 486 (a->client.closer)(&a->archive, 487 a->client.dataset[i].data); 488 } 489 return (e); 490 } 491 } 492 493 filter = calloc(1, sizeof(*filter)); 494 if (filter == NULL) 495 return (ARCHIVE_FATAL); 496 filter->bidder = NULL; 497 filter->upstream = NULL; 498 filter->archive = a; 499 filter->data = a->client.dataset[0].data; 500 filter->open = client_open_proxy; 501 filter->read = client_read_proxy; 502 filter->skip = client_skip_proxy; 503 filter->seek = client_seek_proxy; 504 filter->close = client_close_proxy; 505 filter->sswitch = client_switch_proxy; 506 filter->name = "none"; 507 filter->code = ARCHIVE_FILTER_NONE; 508 509 a->client.dataset[0].begin_position = 0; 510 if (!a->filter || !a->bypass_filter_bidding) 511 { 512 a->filter = filter; 513 /* Build out the input pipeline. */ 514 e = choose_filters(a); 515 if (e < ARCHIVE_WARN) { 516 a->archive.state = ARCHIVE_STATE_FATAL; 517 return (ARCHIVE_FATAL); 518 } 519 } 520 else 521 { 522 /* Need to add "NONE" type filter at the end of the filter chain */ 523 tmp = a->filter; 524 while (tmp->upstream) 525 tmp = tmp->upstream; 526 tmp->upstream = filter; 527 } 528 529 if (!a->format) 530 { 531 slot = choose_format(a); 532 if (slot < 0) { 533 close_filters(a); 534 a->archive.state = ARCHIVE_STATE_FATAL; 535 return (ARCHIVE_FATAL); 536 } 537 a->format = &(a->formats[slot]); 538 } 539 540 a->archive.state = ARCHIVE_STATE_HEADER; 541 542 /* Ensure libarchive starts from the first node in a multivolume set */ 543 client_switch_proxy(a->filter, 0); 544 return (e); 545} 546 547/* 548 * Allow each registered stream transform to bid on whether 549 * it wants to handle this stream. Repeat until we've finished 550 * building the pipeline. 551 */ 552 553/* We won't build a filter pipeline with more stages than this. */ 554#define MAX_NUMBER_FILTERS 25 555 556static int 557choose_filters(struct archive_read *a) 558{ 559 int number_bidders, i, bid, best_bid, number_filters; 560 struct archive_read_filter_bidder *bidder, *best_bidder; 561 struct archive_read_filter *filter; 562 ssize_t avail; 563 int r; 564 565 for (number_filters = 0; number_filters < MAX_NUMBER_FILTERS; ++number_filters) { 566 number_bidders = sizeof(a->bidders) / sizeof(a->bidders[0]); 567 568 best_bid = 0; 569 best_bidder = NULL; 570 571 bidder = a->bidders; 572 for (i = 0; i < number_bidders; i++, bidder++) { 573 if (bidder->bid != NULL) { 574 bid = (bidder->bid)(bidder, a->filter); 575 if (bid > best_bid) { 576 best_bid = bid; 577 best_bidder = bidder; 578 } 579 } 580 } 581 582 /* If no bidder, we're done. */ 583 if (best_bidder == NULL) { 584 /* Verify the filter by asking it for some data. */ 585 __archive_read_filter_ahead(a->filter, 1, &avail); 586 if (avail < 0) { 587 __archive_read_free_filters(a); 588 return (ARCHIVE_FATAL); 589 } 590 a->archive.compression_name = a->filter->name; 591 a->archive.compression_code = a->filter->code; 592 return (ARCHIVE_OK); 593 } 594 595 filter 596 = (struct archive_read_filter *)calloc(1, sizeof(*filter)); 597 if (filter == NULL) 598 return (ARCHIVE_FATAL); 599 filter->bidder = best_bidder; 600 filter->archive = a; 601 filter->upstream = a->filter; 602 a->filter = filter; 603 r = (best_bidder->init)(a->filter); 604 if (r != ARCHIVE_OK) { 605 __archive_read_free_filters(a); 606 return (ARCHIVE_FATAL); 607 } 608 } 609 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 610 "Input requires too many filters for decoding"); 611 return (ARCHIVE_FATAL); 612} 613 614int 615__archive_read_header(struct archive_read *a, struct archive_entry *entry) 616{ 617 if (a->filter->read_header) 618 return a->filter->read_header(a->filter, entry); 619 else 620 return (ARCHIVE_OK); 621} 622 623/* 624 * Read header of next entry. 625 */ 626static int 627_archive_read_next_header2(struct archive *_a, struct archive_entry *entry) 628{ 629 struct archive_read *a = (struct archive_read *)_a; 630 int r1 = ARCHIVE_OK, r2; 631 632 archive_check_magic(_a, ARCHIVE_READ_MAGIC, 633 ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA, 634 "archive_read_next_header"); 635 636 archive_entry_clear(entry); 637 archive_clear_error(&a->archive); 638 639 /* 640 * If client didn't consume entire data, skip any remainder 641 * (This is especially important for GNU incremental directories.) 642 */ 643 if (a->archive.state == ARCHIVE_STATE_DATA) { 644 r1 = archive_read_data_skip(&a->archive); 645 if (r1 == ARCHIVE_EOF) 646 archive_set_error(&a->archive, EIO, 647 "Premature end-of-file."); 648 if (r1 == ARCHIVE_EOF || r1 == ARCHIVE_FATAL) { 649 a->archive.state = ARCHIVE_STATE_FATAL; 650 return (ARCHIVE_FATAL); 651 } 652 } 653 654 /* Record start-of-header offset in uncompressed stream. */ 655 a->header_position = a->filter->position; 656 657 ++_a->file_count; 658 r2 = (a->format->read_header)(a, entry); 659 660 /* 661 * EOF and FATAL are persistent at this layer. By 662 * modifying the state, we guarantee that future calls to 663 * read a header or read data will fail. 664 */ 665 switch (r2) { 666 case ARCHIVE_EOF: 667 a->archive.state = ARCHIVE_STATE_EOF; 668 --_a->file_count;/* Revert a file counter. */ 669 break; 670 case ARCHIVE_OK: 671 a->archive.state = ARCHIVE_STATE_DATA; 672 break; 673 case ARCHIVE_WARN: 674 a->archive.state = ARCHIVE_STATE_DATA; 675 break; 676 case ARCHIVE_RETRY: 677 break; 678 case ARCHIVE_FATAL: 679 a->archive.state = ARCHIVE_STATE_FATAL; 680 break; 681 } 682 683 __archive_reset_read_data(&a->archive); 684 685 a->data_start_node = a->client.cursor; 686 /* EOF always wins; otherwise return the worst error. */ 687 return (r2 < r1 || r2 == ARCHIVE_EOF) ? r2 : r1; 688} 689 690static int 691_archive_read_next_header(struct archive *_a, struct archive_entry **entryp) 692{ 693 int ret; 694 struct archive_read *a = (struct archive_read *)_a; 695 *entryp = NULL; 696 ret = _archive_read_next_header2(_a, a->entry); 697 *entryp = a->entry; 698 return ret; 699} 700 701/* 702 * Allow each registered format to bid on whether it wants to handle 703 * the next entry. Return index of winning bidder. 704 */ 705static int 706choose_format(struct archive_read *a) 707{ 708 int slots; 709 int i; 710 int bid, best_bid; 711 int best_bid_slot; 712 713 slots = sizeof(a->formats) / sizeof(a->formats[0]); 714 best_bid = -1; 715 best_bid_slot = -1; 716 717 /* Set up a->format for convenience of bidders. */ 718 a->format = &(a->formats[0]); 719 for (i = 0; i < slots; i++, a->format++) { 720 if (a->format->bid) { 721 bid = (a->format->bid)(a, best_bid); 722 if (bid == ARCHIVE_FATAL) 723 return (ARCHIVE_FATAL); 724 if (a->filter->position != 0) 725 __archive_read_seek(a, 0, SEEK_SET); 726 if ((bid > best_bid) || (best_bid_slot < 0)) { 727 best_bid = bid; 728 best_bid_slot = i; 729 } 730 } 731 } 732 733 /* 734 * There were no bidders; this is a serious programmer error 735 * and demands a quick and definitive abort. 736 */ 737 if (best_bid_slot < 0) { 738 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 739 "No formats registered"); 740 return (ARCHIVE_FATAL); 741 } 742 743 /* 744 * There were bidders, but no non-zero bids; this means we 745 * can't support this stream. 746 */ 747 if (best_bid < 1) { 748 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 749 "Unrecognized archive format"); 750 return (ARCHIVE_FATAL); 751 } 752 753 return (best_bid_slot); 754} 755 756/* 757 * Return the file offset (within the uncompressed data stream) where 758 * the last header started. 759 */ 760la_int64_t 761archive_read_header_position(struct archive *_a) 762{ 763 struct archive_read *a = (struct archive_read *)_a; 764 archive_check_magic(_a, ARCHIVE_READ_MAGIC, 765 ARCHIVE_STATE_ANY, "archive_read_header_position"); 766 return (a->header_position); 767} 768 769/* 770 * Returns 1 if the archive contains at least one encrypted entry. 771 * If the archive format not support encryption at all 772 * ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED is returned. 773 * If for any other reason (e.g. not enough data read so far) 774 * we cannot say whether there are encrypted entries, then 775 * ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW is returned. 776 * In general, this function will return values below zero when the 777 * reader is uncertain or totally incapable of encryption support. 778 * When this function returns 0 you can be sure that the reader 779 * supports encryption detection but no encrypted entries have 780 * been found yet. 781 * 782 * NOTE: If the metadata/header of an archive is also encrypted, you 783 * cannot rely on the number of encrypted entries. That is why this 784 * function does not return the number of encrypted entries but# 785 * just shows that there are some. 786 */ 787int 788archive_read_has_encrypted_entries(struct archive *_a) 789{ 790 struct archive_read *a = (struct archive_read *)_a; 791 int format_supports_encryption = archive_read_format_capabilities(_a) 792 & (ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_DATA | ARCHIVE_READ_FORMAT_CAPS_ENCRYPT_METADATA); 793 794 if (!_a || !format_supports_encryption) { 795 /* Format in general doesn't support encryption */ 796 return ARCHIVE_READ_FORMAT_ENCRYPTION_UNSUPPORTED; 797 } 798 799 /* A reader potentially has read enough data now. */ 800 if (a->format && a->format->has_encrypted_entries) { 801 return (a->format->has_encrypted_entries)(a); 802 } 803 804 /* For any other reason we cannot say how many entries are there. */ 805 return ARCHIVE_READ_FORMAT_ENCRYPTION_DONT_KNOW; 806} 807 808/* 809 * Returns a bitmask of capabilities that are supported by the archive format reader. 810 * If the reader has no special capabilities, ARCHIVE_READ_FORMAT_CAPS_NONE is returned. 811 */ 812int 813archive_read_format_capabilities(struct archive *_a) 814{ 815 struct archive_read *a = (struct archive_read *)_a; 816 if (a && a->format && a->format->format_capabilties) { 817 return (a->format->format_capabilties)(a); 818 } 819 return ARCHIVE_READ_FORMAT_CAPS_NONE; 820} 821 822/* 823 * Read data from an archive entry, using a read(2)-style interface. 824 * This is a convenience routine that just calls 825 * archive_read_data_block and copies the results into the client 826 * buffer, filling any gaps with zero bytes. Clients using this 827 * API can be completely ignorant of sparse-file issues; sparse files 828 * will simply be padded with nulls. 829 * 830 * DO NOT intermingle calls to this function and archive_read_data_block 831 * to read a single entry body. 832 */ 833la_ssize_t 834archive_read_data(struct archive *_a, void *buff, size_t s) 835{ 836 struct archive *a = (struct archive *)_a; 837 char *dest; 838 const void *read_buf; 839 size_t bytes_read; 840 size_t len; 841 int r; 842 843 bytes_read = 0; 844 dest = (char *)buff; 845 846 while (s > 0) { 847 if (a->read_data_remaining == 0) { 848 read_buf = a->read_data_block; 849 a->read_data_is_posix_read = 1; 850 a->read_data_requested = s; 851 r = archive_read_data_block(a, &read_buf, 852 &a->read_data_remaining, &a->read_data_offset); 853 a->read_data_block = read_buf; 854 if (r == ARCHIVE_EOF) 855 return (bytes_read); 856 /* 857 * Error codes are all negative, so the status 858 * return here cannot be confused with a valid 859 * byte count. (ARCHIVE_OK is zero.) 860 */ 861 if (r < ARCHIVE_OK) 862 return (r); 863 } 864 865 if (a->read_data_offset < a->read_data_output_offset) { 866 archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, 867 "Encountered out-of-order sparse blocks"); 868 return (ARCHIVE_RETRY); 869 } 870 871 /* Compute the amount of zero padding needed. */ 872 if (a->read_data_output_offset + (int64_t)s < 873 a->read_data_offset) { 874 len = s; 875 } else if (a->read_data_output_offset < 876 a->read_data_offset) { 877 len = (size_t)(a->read_data_offset - 878 a->read_data_output_offset); 879 } else 880 len = 0; 881 882 /* Add zeroes. */ 883 memset(dest, 0, len); 884 s -= len; 885 a->read_data_output_offset += len; 886 dest += len; 887 bytes_read += len; 888 889 /* Copy data if there is any space left. */ 890 if (s > 0) { 891 len = a->read_data_remaining; 892 if (len > s) 893 len = s; 894 if (len) 895 memcpy(dest, a->read_data_block, len); 896 s -= len; 897 a->read_data_block += len; 898 a->read_data_remaining -= len; 899 a->read_data_output_offset += len; 900 a->read_data_offset += len; 901 dest += len; 902 bytes_read += len; 903 } 904 } 905 a->read_data_is_posix_read = 0; 906 a->read_data_requested = 0; 907 return (bytes_read); 908} 909 910/* 911 * Reset the read_data_* variables, used for starting a new entry. 912 */ 913void __archive_reset_read_data(struct archive * a) 914{ 915 a->read_data_output_offset = 0; 916 a->read_data_remaining = 0; 917 a->read_data_is_posix_read = 0; 918 a->read_data_requested = 0; 919 920 /* extra resets, from rar.c */ 921 a->read_data_block = NULL; 922 a->read_data_offset = 0; 923} 924 925/* 926 * Skip over all remaining data in this entry. 927 */ 928int 929archive_read_data_skip(struct archive *_a) 930{ 931 struct archive_read *a = (struct archive_read *)_a; 932 int r; 933 const void *buff; 934 size_t size; 935 int64_t offset; 936 937 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA, 938 "archive_read_data_skip"); 939 940 if (a->format->read_data_skip != NULL) 941 r = (a->format->read_data_skip)(a); 942 else { 943 while ((r = archive_read_data_block(&a->archive, 944 &buff, &size, &offset)) 945 == ARCHIVE_OK) 946 ; 947 } 948 949 if (r == ARCHIVE_EOF) 950 r = ARCHIVE_OK; 951 952 a->archive.state = ARCHIVE_STATE_HEADER; 953 return (r); 954} 955 956la_int64_t 957archive_seek_data(struct archive *_a, int64_t offset, int whence) 958{ 959 struct archive_read *a = (struct archive_read *)_a; 960 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA, 961 "archive_seek_data_block"); 962 963 if (a->format->seek_data == NULL) { 964 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER, 965 "Internal error: " 966 "No format_seek_data_block function registered"); 967 return (ARCHIVE_FATAL); 968 } 969 970 return (a->format->seek_data)(a, offset, whence); 971} 972 973/* 974 * Read the next block of entry data from the archive. 975 * This is a zero-copy interface; the client receives a pointer, 976 * size, and file offset of the next available block of data. 977 * 978 * Returns ARCHIVE_OK if the operation is successful, ARCHIVE_EOF if 979 * the end of entry is encountered. 980 */ 981static int 982_archive_read_data_block(struct archive *_a, 983 const void **buff, size_t *size, int64_t *offset) 984{ 985 struct archive_read *a = (struct archive_read *)_a; 986 archive_check_magic(_a, ARCHIVE_READ_MAGIC, ARCHIVE_STATE_DATA, 987 "archive_read_data_block"); 988 989 if (a->format->read_data == NULL) { 990 archive_set_error(&a->archive, ARCHIVE_ERRNO_PROGRAMMER, 991 "Internal error: " 992 "No format->read_data function registered"); 993 return (ARCHIVE_FATAL); 994 } 995 996 return (a->format->read_data)(a, buff, size, offset); 997} 998 999static int 1000close_filters(struct archive_read *a) 1001{ 1002 struct archive_read_filter *f = a->filter; 1003 int r = ARCHIVE_OK; 1004 /* Close each filter in the pipeline. */ 1005 while (f != NULL) { 1006 struct archive_read_filter *t = f->upstream; 1007 if (!f->closed && f->close != NULL) { 1008 int r1 = (f->close)(f); 1009 f->closed = 1; 1010 if (r1 < r) 1011 r = r1; 1012 } 1013 free(f->buffer); 1014 f->buffer = NULL; 1015 f = t; 1016 } 1017 return r; 1018} 1019 1020void 1021__archive_read_free_filters(struct archive_read *a) 1022{ 1023 /* Make sure filters are closed and their buffers are freed */ 1024 close_filters(a); 1025 1026 while (a->filter != NULL) { 1027 struct archive_read_filter *t = a->filter->upstream; 1028 free(a->filter); 1029 a->filter = t; 1030 } 1031} 1032 1033/* 1034 * return the count of # of filters in use 1035 */ 1036static int 1037_archive_filter_count(struct archive *_a) 1038{ 1039 struct archive_read *a = (struct archive_read *)_a; 1040 struct archive_read_filter *p = a->filter; 1041 int count = 0; 1042 while(p) { 1043 count++; 1044 p = p->upstream; 1045 } 1046 return count; 1047} 1048 1049/* 1050 * Close the file and all I/O. 1051 */ 1052static int 1053_archive_read_close(struct archive *_a) 1054{ 1055 struct archive_read *a = (struct archive_read *)_a; 1056 int r = ARCHIVE_OK, r1 = ARCHIVE_OK; 1057 1058 archive_check_magic(&a->archive, ARCHIVE_READ_MAGIC, 1059 ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_close"); 1060 if (a->archive.state == ARCHIVE_STATE_CLOSED) 1061 return (ARCHIVE_OK); 1062 archive_clear_error(&a->archive); 1063 a->archive.state = ARCHIVE_STATE_CLOSED; 1064 1065 /* TODO: Clean up the formatters. */ 1066 1067 /* Release the filter objects. */ 1068 r1 = close_filters(a); 1069 if (r1 < r) 1070 r = r1; 1071 1072 return (r); 1073} 1074 1075/* 1076 * Release memory and other resources. 1077 */ 1078static int 1079_archive_read_free(struct archive *_a) 1080{ 1081 struct archive_read *a = (struct archive_read *)_a; 1082 struct archive_read_passphrase *p; 1083 int i, n; 1084 int slots; 1085 int r = ARCHIVE_OK; 1086 1087 if (_a == NULL) 1088 return (ARCHIVE_OK); 1089 archive_check_magic(_a, ARCHIVE_READ_MAGIC, 1090 ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_read_free"); 1091 if (a->archive.state != ARCHIVE_STATE_CLOSED 1092 && a->archive.state != ARCHIVE_STATE_FATAL) 1093 r = archive_read_close(&a->archive); 1094 1095 /* Call cleanup functions registered by optional components. */ 1096 if (a->cleanup_archive_extract != NULL) 1097 r = (a->cleanup_archive_extract)(a); 1098 1099 /* Cleanup format-specific data. */ 1100 slots = sizeof(a->formats) / sizeof(a->formats[0]); 1101 for (i = 0; i < slots; i++) { 1102 a->format = &(a->formats[i]); 1103 if (a->formats[i].cleanup) 1104 (a->formats[i].cleanup)(a); 1105 } 1106 1107 /* Free the filters */ 1108 __archive_read_free_filters(a); 1109 1110 /* Release the bidder objects. */ 1111 n = sizeof(a->bidders)/sizeof(a->bidders[0]); 1112 for (i = 0; i < n; i++) { 1113 if (a->bidders[i].free != NULL) { 1114 int r1 = (a->bidders[i].free)(&a->bidders[i]); 1115 if (r1 < r) 1116 r = r1; 1117 } 1118 } 1119 1120 /* Release passphrase list. */ 1121 p = a->passphrases.first; 1122 while (p != NULL) { 1123 struct archive_read_passphrase *np = p->next; 1124 1125 /* A passphrase should be cleaned. */ 1126 memset(p->passphrase, 0, strlen(p->passphrase)); 1127 free(p->passphrase); 1128 free(p); 1129 p = np; 1130 } 1131 1132 archive_string_free(&a->archive.error_string); 1133 archive_entry_free(a->entry); 1134 a->archive.magic = 0; 1135 __archive_clean(&a->archive); 1136 free(a->client.dataset); 1137 free(a); 1138 return (r); 1139} 1140 1141static struct archive_read_filter * 1142get_filter(struct archive *_a, int n) 1143{ 1144 struct archive_read *a = (struct archive_read *)_a; 1145 struct archive_read_filter *f = a->filter; 1146 /* We use n == -1 for 'the last filter', which is always the 1147 * client proxy. */ 1148 if (n == -1 && f != NULL) { 1149 struct archive_read_filter *last = f; 1150 f = f->upstream; 1151 while (f != NULL) { 1152 last = f; 1153 f = f->upstream; 1154 } 1155 return (last); 1156 } 1157 if (n < 0) 1158 return NULL; 1159 while (n > 0 && f != NULL) { 1160 f = f->upstream; 1161 --n; 1162 } 1163 return (f); 1164} 1165 1166static int 1167_archive_filter_code(struct archive *_a, int n) 1168{ 1169 struct archive_read_filter *f = get_filter(_a, n); 1170 return f == NULL ? -1 : f->code; 1171} 1172 1173static const char * 1174_archive_filter_name(struct archive *_a, int n) 1175{ 1176 struct archive_read_filter *f = get_filter(_a, n); 1177 return f != NULL ? f->name : NULL; 1178} 1179 1180static int64_t 1181_archive_filter_bytes(struct archive *_a, int n) 1182{ 1183 struct archive_read_filter *f = get_filter(_a, n); 1184 return f == NULL ? -1 : f->position; 1185} 1186 1187/* 1188 * Used internally by read format handlers to register their bid and 1189 * initialization functions. 1190 */ 1191int 1192__archive_read_register_format(struct archive_read *a, 1193 void *format_data, 1194 const char *name, 1195 int (*bid)(struct archive_read *, int), 1196 int (*options)(struct archive_read *, const char *, const char *), 1197 int (*read_header)(struct archive_read *, struct archive_entry *), 1198 int (*read_data)(struct archive_read *, const void **, size_t *, int64_t *), 1199 int (*read_data_skip)(struct archive_read *), 1200 int64_t (*seek_data)(struct archive_read *, int64_t, int), 1201 int (*cleanup)(struct archive_read *), 1202 int (*format_capabilities)(struct archive_read *), 1203 int (*has_encrypted_entries)(struct archive_read *)) 1204{ 1205 int i, number_slots; 1206 1207 archive_check_magic(&a->archive, 1208 ARCHIVE_READ_MAGIC, ARCHIVE_STATE_NEW, 1209 "__archive_read_register_format"); 1210 1211 number_slots = sizeof(a->formats) / sizeof(a->formats[0]); 1212 1213 for (i = 0; i < number_slots; i++) { 1214 if (a->formats[i].bid == bid) 1215 return (ARCHIVE_WARN); /* We've already installed */ 1216 if (a->formats[i].bid == NULL) { 1217 a->formats[i].bid = bid; 1218 a->formats[i].options = options; 1219 a->formats[i].read_header = read_header; 1220 a->formats[i].read_data = read_data; 1221 a->formats[i].read_data_skip = read_data_skip; 1222 a->formats[i].seek_data = seek_data; 1223 a->formats[i].cleanup = cleanup; 1224 a->formats[i].data = format_data; 1225 a->formats[i].name = name; 1226 a->formats[i].format_capabilties = format_capabilities; 1227 a->formats[i].has_encrypted_entries = has_encrypted_entries; 1228 return (ARCHIVE_OK); 1229 } 1230 } 1231 1232 archive_set_error(&a->archive, ENOMEM, 1233 "Not enough slots for format registration"); 1234 return (ARCHIVE_FATAL); 1235} 1236 1237/* 1238 * Used internally by decompression routines to register their bid and 1239 * initialization functions. 1240 */ 1241int 1242__archive_read_get_bidder(struct archive_read *a, 1243 struct archive_read_filter_bidder **bidder) 1244{ 1245 int i, number_slots; 1246 1247 number_slots = sizeof(a->bidders) / sizeof(a->bidders[0]); 1248 1249 for (i = 0; i < number_slots; i++) { 1250 if (a->bidders[i].bid == NULL) { 1251 memset(a->bidders + i, 0, sizeof(a->bidders[0])); 1252 *bidder = (a->bidders + i); 1253 return (ARCHIVE_OK); 1254 } 1255 } 1256 1257 archive_set_error(&a->archive, ENOMEM, 1258 "Not enough slots for filter registration"); 1259 return (ARCHIVE_FATAL); 1260} 1261 1262/* 1263 * The next section implements the peek/consume internal I/O 1264 * system used by archive readers. This system allows simple 1265 * read-ahead for consumers while preserving zero-copy operation 1266 * most of the time. 1267 * 1268 * The two key operations: 1269 * * The read-ahead function returns a pointer to a block of data 1270 * that satisfies a minimum request. 1271 * * The consume function advances the file pointer. 1272 * 1273 * In the ideal case, filters generate blocks of data 1274 * and __archive_read_ahead() just returns pointers directly into 1275 * those blocks. Then __archive_read_consume() just bumps those 1276 * pointers. Only if your request would span blocks does the I/O 1277 * layer use a copy buffer to provide you with a contiguous block of 1278 * data. 1279 * 1280 * A couple of useful idioms: 1281 * * "I just want some data." Ask for 1 byte and pay attention to 1282 * the "number of bytes available" from __archive_read_ahead(). 1283 * Consume whatever you actually use. 1284 * * "I want to output a large block of data." As above, ask for 1 byte, 1285 * emit all that's available (up to whatever limit you have), consume 1286 * it all, then repeat until you're done. This effectively means that 1287 * you're passing along the blocks that came from your provider. 1288 * * "I want to peek ahead by a large amount." Ask for 4k or so, then 1289 * double and repeat until you get an error or have enough. Note 1290 * that the I/O layer will likely end up expanding its copy buffer 1291 * to fit your request, so use this technique cautiously. This 1292 * technique is used, for example, by some of the format tasting 1293 * code that has uncertain look-ahead needs. 1294 */ 1295 1296/* 1297 * Looks ahead in the input stream: 1298 * * If 'avail' pointer is provided, that returns number of bytes available 1299 * in the current buffer, which may be much larger than requested. 1300 * * If end-of-file, *avail gets set to zero. 1301 * * If error, *avail gets error code. 1302 * * If request can be met, returns pointer to data. 1303 * * If minimum request cannot be met, returns NULL. 1304 * 1305 * Note: If you just want "some data", ask for 1 byte and pay attention 1306 * to *avail, which will have the actual amount available. If you 1307 * know exactly how many bytes you need, just ask for that and treat 1308 * a NULL return as an error. 1309 * 1310 * Important: This does NOT move the file pointer. See 1311 * __archive_read_consume() below. 1312 */ 1313const void * 1314__archive_read_ahead(struct archive_read *a, size_t min, ssize_t *avail) 1315{ 1316 return (__archive_read_filter_ahead(a->filter, min, avail)); 1317} 1318 1319const void * 1320__archive_read_filter_ahead(struct archive_read_filter *filter, 1321 size_t min, ssize_t *avail) 1322{ 1323 ssize_t bytes_read; 1324 size_t tocopy; 1325 1326 if (filter->fatal) { 1327 if (avail) 1328 *avail = ARCHIVE_FATAL; 1329 return (NULL); 1330 } 1331 1332 /* 1333 * Keep pulling more data until we can satisfy the request. 1334 */ 1335 for (;;) { 1336 1337 /* 1338 * If we can satisfy from the copy buffer (and the 1339 * copy buffer isn't empty), we're done. In particular, 1340 * note that min == 0 is a perfectly well-defined 1341 * request. 1342 */ 1343 if (filter->avail >= min && filter->avail > 0) { 1344 if (avail != NULL) 1345 *avail = filter->avail; 1346 return (filter->next); 1347 } 1348 1349 /* 1350 * We can satisfy directly from client buffer if everything 1351 * currently in the copy buffer is still in the client buffer. 1352 */ 1353 if (filter->client_total >= filter->client_avail + filter->avail 1354 && filter->client_avail + filter->avail >= min) { 1355 /* "Roll back" to client buffer. */ 1356 filter->client_avail += filter->avail; 1357 filter->client_next -= filter->avail; 1358 /* Copy buffer is now empty. */ 1359 filter->avail = 0; 1360 filter->next = filter->buffer; 1361 /* Return data from client buffer. */ 1362 if (avail != NULL) 1363 *avail = filter->client_avail; 1364 return (filter->client_next); 1365 } 1366 1367 /* Move data forward in copy buffer if necessary. */ 1368 if (filter->next > filter->buffer && 1369 filter->next + min > filter->buffer + filter->buffer_size) { 1370 if (filter->avail > 0) 1371 memmove(filter->buffer, filter->next, 1372 filter->avail); 1373 filter->next = filter->buffer; 1374 } 1375 1376 /* If we've used up the client data, get more. */ 1377 if (filter->client_avail <= 0) { 1378 if (filter->end_of_file) { 1379 if (avail != NULL) 1380 *avail = 0; 1381 return (NULL); 1382 } 1383 bytes_read = (filter->read)(filter, 1384 &filter->client_buff); 1385 if (bytes_read < 0) { /* Read error. */ 1386 filter->client_total = filter->client_avail = 0; 1387 filter->client_next = 1388 filter->client_buff = NULL; 1389 filter->fatal = 1; 1390 if (avail != NULL) 1391 *avail = ARCHIVE_FATAL; 1392 return (NULL); 1393 } 1394 if (bytes_read == 0) { 1395 /* Check for another client object first */ 1396 if (filter->archive->client.cursor != 1397 filter->archive->client.nodes - 1) { 1398 if (client_switch_proxy(filter, 1399 filter->archive->client.cursor + 1) 1400 == ARCHIVE_OK) 1401 continue; 1402 } 1403 /* Premature end-of-file. */ 1404 filter->client_total = filter->client_avail = 0; 1405 filter->client_next = 1406 filter->client_buff = NULL; 1407 filter->end_of_file = 1; 1408 /* Return whatever we do have. */ 1409 if (avail != NULL) 1410 *avail = filter->avail; 1411 return (NULL); 1412 } 1413 filter->client_total = bytes_read; 1414 filter->client_avail = filter->client_total; 1415 filter->client_next = filter->client_buff; 1416 } else { 1417 /* 1418 * We can't satisfy the request from the copy 1419 * buffer or the existing client data, so we 1420 * need to copy more client data over to the 1421 * copy buffer. 1422 */ 1423 1424 /* Ensure the buffer is big enough. */ 1425 if (min > filter->buffer_size) { 1426 size_t s, t; 1427 char *p; 1428 1429 /* Double the buffer; watch for overflow. */ 1430 s = t = filter->buffer_size; 1431 if (s == 0) 1432 s = min; 1433 while (s < min) { 1434 t *= 2; 1435 if (t <= s) { /* Integer overflow! */ 1436 archive_set_error( 1437 &filter->archive->archive, 1438 ENOMEM, 1439 "Unable to allocate copy" 1440 " buffer"); 1441 filter->fatal = 1; 1442 if (avail != NULL) 1443 *avail = ARCHIVE_FATAL; 1444 return (NULL); 1445 } 1446 s = t; 1447 } 1448 /* Now s >= min, so allocate a new buffer. */ 1449 p = (char *)malloc(s); 1450 if (p == NULL) { 1451 archive_set_error( 1452 &filter->archive->archive, 1453 ENOMEM, 1454 "Unable to allocate copy buffer"); 1455 filter->fatal = 1; 1456 if (avail != NULL) 1457 *avail = ARCHIVE_FATAL; 1458 return (NULL); 1459 } 1460 /* Move data into newly-enlarged buffer. */ 1461 if (filter->avail > 0) 1462 memmove(p, filter->next, filter->avail); 1463 free(filter->buffer); 1464 filter->next = filter->buffer = p; 1465 filter->buffer_size = s; 1466 } 1467 1468 /* We can add client data to copy buffer. */ 1469 /* First estimate: copy to fill rest of buffer. */ 1470 tocopy = (filter->buffer + filter->buffer_size) 1471 - (filter->next + filter->avail); 1472 /* Don't waste time buffering more than we need to. */ 1473 if (tocopy + filter->avail > min) 1474 tocopy = min - filter->avail; 1475 /* Don't copy more than is available. */ 1476 if (tocopy > filter->client_avail) 1477 tocopy = filter->client_avail; 1478 1479 memcpy(filter->next + filter->avail, 1480 filter->client_next, tocopy); 1481 /* Remove this data from client buffer. */ 1482 filter->client_next += tocopy; 1483 filter->client_avail -= tocopy; 1484 /* add it to copy buffer. */ 1485 filter->avail += tocopy; 1486 } 1487 } 1488} 1489 1490/* 1491 * Move the file pointer forward. 1492 */ 1493int64_t 1494__archive_read_consume(struct archive_read *a, int64_t request) 1495{ 1496 return (__archive_read_filter_consume(a->filter, request)); 1497} 1498 1499int64_t 1500__archive_read_filter_consume(struct archive_read_filter * filter, 1501 int64_t request) 1502{ 1503 int64_t skipped; 1504 1505 if (request < 0) 1506 return ARCHIVE_FATAL; 1507 if (request == 0) 1508 return 0; 1509 1510 skipped = advance_file_pointer(filter, request); 1511 if (skipped == request) 1512 return (skipped); 1513 /* We hit EOF before we satisfied the skip request. */ 1514 if (skipped < 0) /* Map error code to 0 for error message below. */ 1515 skipped = 0; 1516 archive_set_error(&filter->archive->archive, 1517 ARCHIVE_ERRNO_MISC, 1518 "Truncated input file (needed %jd bytes, only %jd available)", 1519 (intmax_t)request, (intmax_t)skipped); 1520 return (ARCHIVE_FATAL); 1521} 1522 1523/* 1524 * Advance the file pointer by the amount requested. 1525 * Returns the amount actually advanced, which may be less than the 1526 * request if EOF is encountered first. 1527 * Returns a negative value if there's an I/O error. 1528 */ 1529static int64_t 1530advance_file_pointer(struct archive_read_filter *filter, int64_t request) 1531{ 1532 int64_t bytes_skipped, total_bytes_skipped = 0; 1533 ssize_t bytes_read; 1534 size_t min; 1535 1536 if (filter->fatal) 1537 return (-1); 1538 1539 /* Use up the copy buffer first. */ 1540 if (filter->avail > 0) { 1541 min = (size_t)minimum(request, (int64_t)filter->avail); 1542 filter->next += min; 1543 filter->avail -= min; 1544 request -= min; 1545 filter->position += min; 1546 total_bytes_skipped += min; 1547 } 1548 1549 /* Then use up the client buffer. */ 1550 if (filter->client_avail > 0) { 1551 min = (size_t)minimum(request, (int64_t)filter->client_avail); 1552 filter->client_next += min; 1553 filter->client_avail -= min; 1554 request -= min; 1555 filter->position += min; 1556 total_bytes_skipped += min; 1557 } 1558 if (request == 0) 1559 return (total_bytes_skipped); 1560 1561 /* If there's an optimized skip function, use it. */ 1562 if (filter->skip != NULL) { 1563 bytes_skipped = (filter->skip)(filter, request); 1564 if (bytes_skipped < 0) { /* error */ 1565 filter->fatal = 1; 1566 return (bytes_skipped); 1567 } 1568 filter->position += bytes_skipped; 1569 total_bytes_skipped += bytes_skipped; 1570 request -= bytes_skipped; 1571 if (request == 0) 1572 return (total_bytes_skipped); 1573 } 1574 1575 /* Use ordinary reads as necessary to complete the request. */ 1576 for (;;) { 1577 bytes_read = (filter->read)(filter, &filter->client_buff); 1578 if (bytes_read < 0) { 1579 filter->client_buff = NULL; 1580 filter->fatal = 1; 1581 return (bytes_read); 1582 } 1583 1584 if (bytes_read == 0) { 1585 if (filter->archive->client.cursor != 1586 filter->archive->client.nodes - 1) { 1587 if (client_switch_proxy(filter, 1588 filter->archive->client.cursor + 1) 1589 == ARCHIVE_OK) 1590 continue; 1591 } 1592 filter->client_buff = NULL; 1593 filter->end_of_file = 1; 1594 return (total_bytes_skipped); 1595 } 1596 1597 if (bytes_read >= request) { 1598 filter->client_next = 1599 ((const char *)filter->client_buff) + request; 1600 filter->client_avail = (size_t)(bytes_read - request); 1601 filter->client_total = bytes_read; 1602 total_bytes_skipped += request; 1603 filter->position += request; 1604 return (total_bytes_skipped); 1605 } 1606 1607 filter->position += bytes_read; 1608 total_bytes_skipped += bytes_read; 1609 request -= bytes_read; 1610 } 1611} 1612 1613/** 1614 * Returns ARCHIVE_FAILED if seeking isn't supported. 1615 */ 1616int64_t 1617__archive_read_seek(struct archive_read *a, int64_t offset, int whence) 1618{ 1619 return __archive_read_filter_seek(a->filter, offset, whence); 1620} 1621 1622int64_t 1623__archive_read_filter_seek(struct archive_read_filter *filter, int64_t offset, 1624 int whence) 1625{ 1626 struct archive_read_client *client; 1627 int64_t r; 1628 unsigned int cursor; 1629 1630 if (filter->closed || filter->fatal) 1631 return (ARCHIVE_FATAL); 1632 if (filter->seek == NULL) 1633 return (ARCHIVE_FAILED); 1634 1635 client = &(filter->archive->client); 1636 switch (whence) { 1637 case SEEK_CUR: 1638 /* Adjust the offset and use SEEK_SET instead */ 1639 offset += filter->position; 1640 __LA_FALLTHROUGH; 1641 case SEEK_SET: 1642 cursor = 0; 1643 while (1) 1644 { 1645 if (client->dataset[cursor].begin_position < 0 || 1646 client->dataset[cursor].total_size < 0 || 1647 client->dataset[cursor].begin_position + 1648 client->dataset[cursor].total_size - 1 > offset || 1649 cursor + 1 >= client->nodes) 1650 break; 1651 r = client->dataset[cursor].begin_position + 1652 client->dataset[cursor].total_size; 1653 client->dataset[++cursor].begin_position = r; 1654 } 1655 while (1) { 1656 r = client_switch_proxy(filter, cursor); 1657 if (r != ARCHIVE_OK) 1658 return r; 1659 if ((r = client_seek_proxy(filter, 0, SEEK_END)) < 0) 1660 return r; 1661 client->dataset[cursor].total_size = r; 1662 if (client->dataset[cursor].begin_position + 1663 client->dataset[cursor].total_size - 1 > offset || 1664 cursor + 1 >= client->nodes) 1665 break; 1666 r = client->dataset[cursor].begin_position + 1667 client->dataset[cursor].total_size; 1668 client->dataset[++cursor].begin_position = r; 1669 } 1670 offset -= client->dataset[cursor].begin_position; 1671 if (offset < 0 1672 || offset > client->dataset[cursor].total_size) 1673 return ARCHIVE_FATAL; 1674 if ((r = client_seek_proxy(filter, offset, SEEK_SET)) < 0) 1675 return r; 1676 break; 1677 1678 case SEEK_END: 1679 cursor = 0; 1680 while (1) { 1681 if (client->dataset[cursor].begin_position < 0 || 1682 client->dataset[cursor].total_size < 0 || 1683 cursor + 1 >= client->nodes) 1684 break; 1685 r = client->dataset[cursor].begin_position + 1686 client->dataset[cursor].total_size; 1687 client->dataset[++cursor].begin_position = r; 1688 } 1689 while (1) { 1690 r = client_switch_proxy(filter, cursor); 1691 if (r != ARCHIVE_OK) 1692 return r; 1693 if ((r = client_seek_proxy(filter, 0, SEEK_END)) < 0) 1694 return r; 1695 client->dataset[cursor].total_size = r; 1696 r = client->dataset[cursor].begin_position + 1697 client->dataset[cursor].total_size; 1698 if (cursor + 1 >= client->nodes) 1699 break; 1700 client->dataset[++cursor].begin_position = r; 1701 } 1702 while (1) { 1703 if (r + offset >= 1704 client->dataset[cursor].begin_position) 1705 break; 1706 offset += client->dataset[cursor].total_size; 1707 if (cursor == 0) 1708 break; 1709 cursor--; 1710 r = client->dataset[cursor].begin_position + 1711 client->dataset[cursor].total_size; 1712 } 1713 offset = (r + offset) - client->dataset[cursor].begin_position; 1714 if ((r = client_switch_proxy(filter, cursor)) != ARCHIVE_OK) 1715 return r; 1716 r = client_seek_proxy(filter, offset, SEEK_SET); 1717 if (r < ARCHIVE_OK) 1718 return r; 1719 break; 1720 1721 default: 1722 return (ARCHIVE_FATAL); 1723 } 1724 r += client->dataset[cursor].begin_position; 1725 1726 if (r >= 0) { 1727 /* 1728 * Ouch. Clearing the buffer like this hurts, especially 1729 * at bid time. A lot of our efficiency at bid time comes 1730 * from having bidders reuse the data we've already read. 1731 * 1732 * TODO: If the seek request is in data we already 1733 * have, then don't call the seek callback. 1734 * 1735 * TODO: Zip seeks to end-of-file at bid time. If 1736 * other formats also start doing this, we may need to 1737 * find a way for clients to fudge the seek offset to 1738 * a block boundary. 1739 * 1740 * Hmmm... If whence was SEEK_END, we know the file 1741 * size is (r - offset). Can we use that to simplify 1742 * the TODO items above? 1743 */ 1744 filter->avail = filter->client_avail = 0; 1745 filter->next = filter->buffer; 1746 filter->position = r; 1747 filter->end_of_file = 0; 1748 } 1749 return r; 1750} 1751