archive_write.c revision 328827
1151497Sru/*- 2151497Sru * Copyright (c) 2003-2010 Tim Kientzle 3151497Sru * All rights reserved. 4151497Sru * 5151497Sru * Redistribution and use in source and binary forms, with or without 6151497Sru * modification, are permitted provided that the following conditions 7151497Sru * are met: 8151497Sru * 1. Redistributions of source code must retain the above copyright 9151497Sru * notice, this list of conditions and the following disclaimer. 10151497Sru * 2. Redistributions in binary form must reproduce the above copyright 11151497Sru * notice, this list of conditions and the following disclaimer in the 12151497Sru * documentation and/or other materials provided with the distribution. 13151497Sru * 14151497Sru * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 15151497Sru * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16151497Sru * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17151497Sru * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 18151497Sru * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 19151497Sru * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20151497Sru * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 21151497Sru * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22151497Sru * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23151497Sru * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24151497Sru */ 25151497Sru 26151497Sru#include "archive_platform.h" 27151497Sru__FBSDID("$FreeBSD: stable/11/contrib/libarchive/libarchive/archive_write.c 328827 2018-02-03 02:17:04Z mm $"); 28151497Sru 29151497Sru/* 30151497Sru * This file contains the "essential" portions of the write API, that 31151497Sru * is, stuff that will essentially always be used by any client that 32151497Sru * actually needs to write an archive. Optional pieces have been, as 33151497Sru * far as possible, separated out into separate files to reduce 34151497Sru * needlessly bloating statically-linked clients. 35151497Sru */ 36151497Sru 37151497Sru#ifdef HAVE_SYS_WAIT_H 38151497Sru#include <sys/wait.h> 39151497Sru#endif 40151497Sru#ifdef HAVE_ERRNO_H 41151497Sru#include <errno.h> 42151497Sru#endif 43151497Sru#ifdef HAVE_LIMITS_H 44151497Sru#include <limits.h> 45151497Sru#endif 46151497Sru#include <stdio.h> 47151497Sru#ifdef HAVE_STDLIB_H 48151497Sru#include <stdlib.h> 49151497Sru#endif 50151497Sru#ifdef HAVE_STRING_H 51151497Sru#include <string.h> 52151497Sru#endif 53151497Sru#include <time.h> 54151497Sru#ifdef HAVE_UNISTD_H 55151497Sru#include <unistd.h> 56151497Sru#endif 57151497Sru 58151497Sru#include "archive.h" 59151497Sru#include "archive_entry.h" 60151497Sru#include "archive_private.h" 61151497Sru#include "archive_write_private.h" 62151497Sru 63151497Srustatic struct archive_vtable *archive_write_vtable(void); 64151497Sru 65151497Srustatic int _archive_filter_code(struct archive *, int); 66151497Srustatic const char *_archive_filter_name(struct archive *, int); 67151497Srustatic int64_t _archive_filter_bytes(struct archive *, int); 68151497Srustatic int _archive_write_filter_count(struct archive *); 69151497Srustatic int _archive_write_close(struct archive *); 70151497Srustatic int _archive_write_free(struct archive *); 71151497Srustatic int _archive_write_header(struct archive *, struct archive_entry *); 72151497Srustatic int _archive_write_finish_entry(struct archive *); 73151497Srustatic ssize_t _archive_write_data(struct archive *, const void *, size_t); 74151497Sru 75151497Srustruct archive_none { 76151497Sru size_t buffer_size; 77151497Sru size_t avail; 78151497Sru char *buffer; 79151497Sru char *next; 80151497Sru}; 81151497Sru 82151497Srustatic struct archive_vtable * 83151497Sruarchive_write_vtable(void) 84151497Sru{ 85151497Sru static struct archive_vtable av; 86151497Sru static int inited = 0; 87151497Sru 88151497Sru if (!inited) { 89151497Sru av.archive_close = _archive_write_close; 90151497Sru av.archive_filter_bytes = _archive_filter_bytes; 91151497Sru av.archive_filter_code = _archive_filter_code; 92151497Sru av.archive_filter_name = _archive_filter_name; 93151497Sru av.archive_filter_count = _archive_write_filter_count; 94151497Sru av.archive_free = _archive_write_free; 95151497Sru av.archive_write_header = _archive_write_header; 96151497Sru av.archive_write_finish_entry = _archive_write_finish_entry; 97151497Sru av.archive_write_data = _archive_write_data; 98151497Sru inited = 1; 99151497Sru } 100151497Sru return (&av); 101151497Sru} 102151497Sru 103151497Sru/* 104151497Sru * Allocate, initialize and return an archive object. 105151497Sru */ 106151497Srustruct archive * 107151497Sruarchive_write_new(void) 108151497Sru{ 109151497Sru struct archive_write *a; 110151497Sru unsigned char *nulls; 111151497Sru 112151497Sru a = (struct archive_write *)calloc(1, sizeof(*a)); 113151497Sru if (a == NULL) 114151497Sru return (NULL); 115151497Sru a->archive.magic = ARCHIVE_WRITE_MAGIC; 116151497Sru a->archive.state = ARCHIVE_STATE_NEW; 117151497Sru a->archive.vtable = archive_write_vtable(); 118151497Sru /* 119151497Sru * The value 10240 here matches the traditional tar default, 120151497Sru * but is otherwise arbitrary. 121151497Sru * TODO: Set the default block size from the format selected. 122151497Sru */ 123151497Sru a->bytes_per_block = 10240; 124151497Sru a->bytes_in_last_block = -1; /* Default */ 125151497Sru 126151497Sru /* Initialize a block of nulls for padding purposes. */ 127151497Sru a->null_length = 1024; 128151497Sru nulls = (unsigned char *)calloc(1, a->null_length); 129151497Sru if (nulls == NULL) { 130151497Sru free(a); 131151497Sru return (NULL); 132151497Sru } 133151497Sru a->nulls = nulls; 134151497Sru return (&a->archive); 135151497Sru} 136151497Sru 137151497Sru/* 138151497Sru * Set the block size. Returns 0 if successful. 139151497Sru */ 140151497Sruint 141151497Sruarchive_write_set_bytes_per_block(struct archive *_a, int bytes_per_block) 142151497Sru{ 143151497Sru struct archive_write *a = (struct archive_write *)_a; 144151497Sru archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 145151497Sru ARCHIVE_STATE_NEW, "archive_write_set_bytes_per_block"); 146151497Sru a->bytes_per_block = bytes_per_block; 147151497Sru return (ARCHIVE_OK); 148151497Sru} 149151497Sru 150151497Sru/* 151151497Sru * Get the current block size. -1 if it has never been set. 152151497Sru */ 153151497Sruint 154151497Sruarchive_write_get_bytes_per_block(struct archive *_a) 155151497Sru{ 156151497Sru struct archive_write *a = (struct archive_write *)_a; 157151497Sru archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 158151497Sru ARCHIVE_STATE_ANY, "archive_write_get_bytes_per_block"); 159151497Sru return (a->bytes_per_block); 160151497Sru} 161151497Sru 162151497Sru/* 163151497Sru * Set the size for the last block. 164151497Sru * Returns 0 if successful. 165151497Sru */ 166151497Sruint 167151497Sruarchive_write_set_bytes_in_last_block(struct archive *_a, int bytes) 168151497Sru{ 169151497Sru struct archive_write *a = (struct archive_write *)_a; 170151497Sru archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 171151497Sru ARCHIVE_STATE_ANY, "archive_write_set_bytes_in_last_block"); 172151497Sru a->bytes_in_last_block = bytes; 173151497Sru return (ARCHIVE_OK); 174151497Sru} 175151497Sru 176151497Sru/* 177151497Sru * Return the value set above. -1 indicates it has not been set. 178151497Sru */ 179151497Sruint 180151497Sruarchive_write_get_bytes_in_last_block(struct archive *_a) 181151497Sru{ 182151497Sru struct archive_write *a = (struct archive_write *)_a; 183151497Sru archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 184151497Sru ARCHIVE_STATE_ANY, "archive_write_get_bytes_in_last_block"); 185151497Sru return (a->bytes_in_last_block); 186151497Sru} 187151497Sru 188151497Sru/* 189151497Sru * dev/ino of a file to be rejected. Used to prevent adding 190151497Sru * an archive to itself recursively. 191151497Sru */ 192151497Sruint 193151497Sruarchive_write_set_skip_file(struct archive *_a, la_int64_t d, la_int64_t i) 194151497Sru{ 195151497Sru struct archive_write *a = (struct archive_write *)_a; 196151497Sru archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 197151497Sru ARCHIVE_STATE_ANY, "archive_write_set_skip_file"); 198151497Sru a->skip_file_set = 1; 199151497Sru a->skip_file_dev = d; 200151497Sru a->skip_file_ino = i; 201151497Sru return (ARCHIVE_OK); 202151497Sru} 203151497Sru 204151497Sru/* 205151497Sru * Allocate and return the next filter structure. 206151497Sru */ 207151497Srustruct archive_write_filter * 208151497Sru__archive_write_allocate_filter(struct archive *_a) 209151497Sru{ 210151497Sru struct archive_write *a = (struct archive_write *)_a; 211151497Sru struct archive_write_filter *f; 212151497Sru 213151497Sru f = calloc(1, sizeof(*f)); 214151497Sru f->archive = _a; 215151497Sru if (a->filter_first == NULL) 216151497Sru a->filter_first = f; 217151497Sru else 218151497Sru a->filter_last->next_filter = f; 219151497Sru a->filter_last = f; 220151497Sru return f; 221151497Sru} 222151497Sru 223151497Sru/* 224151497Sru * Write data to a particular filter. 225151497Sru */ 226151497Sruint 227151497Sru__archive_write_filter(struct archive_write_filter *f, 228151497Sru const void *buff, size_t length) 229151497Sru{ 230151497Sru int r; 231151497Sru if (length == 0) 232151497Sru return(ARCHIVE_OK); 233151497Sru if (f->write == NULL) 234151497Sru /* If unset, a fatal error has already occurred, so this filter 235151497Sru * didn't open. We cannot write anything. */ 236151497Sru return(ARCHIVE_FATAL); 237151497Sru r = (f->write)(f, buff, length); 238151497Sru f->bytes_written += length; 239151497Sru return (r); 240151497Sru} 241151497Sru 242151497Sru/* 243151497Sru * Open a filter. 244151497Sru */ 245151497Sruint 246151497Sru__archive_write_open_filter(struct archive_write_filter *f) 247151497Sru{ 248151497Sru if (f->open == NULL) 249151497Sru return (ARCHIVE_OK); 250151497Sru return (f->open)(f); 251151497Sru} 252151497Sru 253151497Sru/* 254151497Sru * Close a filter. 255151497Sru */ 256151497Sruint 257151497Sru__archive_write_close_filter(struct archive_write_filter *f) 258151497Sru{ 259151497Sru if (f->close != NULL) 260151497Sru return (f->close)(f); 261151497Sru if (f->next_filter != NULL) 262151497Sru return (__archive_write_close_filter(f->next_filter)); 263151497Sru return (ARCHIVE_OK); 264151497Sru} 265151497Sru 266151497Sruint 267151497Sru__archive_write_output(struct archive_write *a, const void *buff, size_t length) 268151497Sru{ 269151497Sru return (__archive_write_filter(a->filter_first, buff, length)); 270151497Sru} 271151497Sru 272151497Sruint 273151497Sru__archive_write_nulls(struct archive_write *a, size_t length) 274151497Sru{ 275151497Sru if (length == 0) 276151497Sru return (ARCHIVE_OK); 277151497Sru 278151497Sru while (length > 0) { 279151497Sru size_t to_write = length < a->null_length ? length : a->null_length; 280151497Sru int r = __archive_write_output(a, a->nulls, to_write); 281151497Sru if (r < ARCHIVE_OK) 282151497Sru return (r); 283151497Sru length -= to_write; 284151497Sru } 285151497Sru return (ARCHIVE_OK); 286151497Sru} 287151497Sru 288151497Srustatic int 289151497Sruarchive_write_client_open(struct archive_write_filter *f) 290151497Sru{ 291151497Sru struct archive_write *a = (struct archive_write *)f->archive; 292151497Sru struct archive_none *state; 293151497Sru void *buffer; 294151497Sru size_t buffer_size; 295151497Sru 296151497Sru f->bytes_per_block = archive_write_get_bytes_per_block(f->archive); 297151497Sru f->bytes_in_last_block = 298151497Sru archive_write_get_bytes_in_last_block(f->archive); 299151497Sru buffer_size = f->bytes_per_block; 300151497Sru 301151497Sru state = (struct archive_none *)calloc(1, sizeof(*state)); 302151497Sru buffer = (char *)malloc(buffer_size); 303151497Sru if (state == NULL || buffer == NULL) { 304151497Sru free(state); 305151497Sru free(buffer); 306151497Sru archive_set_error(f->archive, ENOMEM, 307151497Sru "Can't allocate data for output buffering"); 308151497Sru return (ARCHIVE_FATAL); 309151497Sru } 310151497Sru 311151497Sru state->buffer_size = buffer_size; 312151497Sru state->buffer = buffer; 313151497Sru state->next = state->buffer; 314151497Sru state->avail = state->buffer_size; 315151497Sru f->data = state; 316151497Sru 317151497Sru if (a->client_opener == NULL) 318151497Sru return (ARCHIVE_OK); 319151497Sru return (a->client_opener(f->archive, a->client_data)); 320151497Sru} 321151497Sru 322151497Srustatic int 323151497Sruarchive_write_client_write(struct archive_write_filter *f, 324151497Sru const void *_buff, size_t length) 325151497Sru{ 326151497Sru struct archive_write *a = (struct archive_write *)f->archive; 327151497Sru struct archive_none *state = (struct archive_none *)f->data; 328151497Sru const char *buff = (const char *)_buff; 329151497Sru ssize_t remaining, to_copy; 330151497Sru ssize_t bytes_written; 331151497Sru 332151497Sru remaining = length; 333151497Sru 334151497Sru /* 335151497Sru * If there is no buffer for blocking, just pass the data 336151497Sru * straight through to the client write callback. In 337151497Sru * particular, this supports "no write delay" operation for 338151497Sru * special applications. Just set the block size to zero. 339151497Sru */ 340151497Sru if (state->buffer_size == 0) { 341151497Sru while (remaining > 0) { 342151497Sru bytes_written = (a->client_writer)(&a->archive, 343151497Sru a->client_data, buff, remaining); 344151497Sru if (bytes_written <= 0) 345151497Sru return (ARCHIVE_FATAL); 346151497Sru remaining -= bytes_written; 347151497Sru buff += bytes_written; 348151497Sru } 349151497Sru return (ARCHIVE_OK); 350151497Sru } 351151497Sru 352151497Sru /* If the copy buffer isn't empty, try to fill it. */ 353151497Sru if (state->avail < state->buffer_size) { 354151497Sru /* If buffer is not empty... */ 355151497Sru /* ... copy data into buffer ... */ 356151497Sru to_copy = ((size_t)remaining > state->avail) ? 357151497Sru state->avail : (size_t)remaining; 358151497Sru memcpy(state->next, buff, to_copy); 359151497Sru state->next += to_copy; 360151497Sru state->avail -= to_copy; 361151497Sru buff += to_copy; 362151497Sru remaining -= to_copy; 363151497Sru /* ... if it's full, write it out. */ 364151497Sru if (state->avail == 0) { 365151497Sru char *p = state->buffer; 366151497Sru size_t to_write = state->buffer_size; 367151497Sru while (to_write > 0) { 368151497Sru bytes_written = (a->client_writer)(&a->archive, 369151497Sru a->client_data, p, to_write); 370151497Sru if (bytes_written <= 0) 371151497Sru return (ARCHIVE_FATAL); 372151497Sru if ((size_t)bytes_written > to_write) { 373151497Sru archive_set_error(&(a->archive), 374151497Sru -1, "write overrun"); 375151497Sru return (ARCHIVE_FATAL); 376151497Sru } 377151497Sru p += bytes_written; 378151497Sru to_write -= bytes_written; 379151497Sru } 380151497Sru state->next = state->buffer; 381151497Sru state->avail = state->buffer_size; 382151497Sru } 383151497Sru } 384151497Sru 385151497Sru while ((size_t)remaining >= state->buffer_size) { 386151497Sru /* Write out full blocks directly to client. */ 387151497Sru bytes_written = (a->client_writer)(&a->archive, 388151497Sru a->client_data, buff, state->buffer_size); 389151497Sru if (bytes_written <= 0) 390151497Sru return (ARCHIVE_FATAL); 391151497Sru buff += bytes_written; 392151497Sru remaining -= bytes_written; 393151497Sru } 394151497Sru 395151497Sru if (remaining > 0) { 396151497Sru /* Copy last bit into copy buffer. */ 397151497Sru memcpy(state->next, buff, remaining); 398151497Sru state->next += remaining; 399151497Sru state->avail -= remaining; 400151497Sru } 401151497Sru return (ARCHIVE_OK); 402151497Sru} 403151497Sru 404151497Srustatic int 405151497Sruarchive_write_client_close(struct archive_write_filter *f) 406151497Sru{ 407151497Sru struct archive_write *a = (struct archive_write *)f->archive; 408151497Sru struct archive_none *state = (struct archive_none *)f->data; 409151497Sru ssize_t block_length; 410151497Sru ssize_t target_block_length; 411151497Sru ssize_t bytes_written; 412151497Sru int ret = ARCHIVE_OK; 413151497Sru 414151497Sru /* If there's pending data, pad and write the last block */ 415151497Sru if (state->next != state->buffer) { 416151497Sru block_length = state->buffer_size - state->avail; 417151497Sru 418151497Sru /* Tricky calculation to determine size of last block */ 419151497Sru if (a->bytes_in_last_block <= 0) 420151497Sru /* Default or Zero: pad to full block */ 421151497Sru target_block_length = a->bytes_per_block; 422151497Sru else 423151497Sru /* Round to next multiple of bytes_in_last_block. */ 424151497Sru target_block_length = a->bytes_in_last_block * 425151497Sru ( (block_length + a->bytes_in_last_block - 1) / 426151497Sru a->bytes_in_last_block); 427151497Sru if (target_block_length > a->bytes_per_block) 428151497Sru target_block_length = a->bytes_per_block; 429151497Sru if (block_length < target_block_length) { 430151497Sru memset(state->next, 0, 431151497Sru target_block_length - block_length); 432151497Sru block_length = target_block_length; 433151497Sru } 434151497Sru bytes_written = (a->client_writer)(&a->archive, 435151497Sru a->client_data, state->buffer, block_length); 436151497Sru ret = bytes_written <= 0 ? ARCHIVE_FATAL : ARCHIVE_OK; 437151497Sru } 438151497Sru if (a->client_closer) 439151497Sru (*a->client_closer)(&a->archive, a->client_data); 440151497Sru free(state->buffer); 441151497Sru free(state); 442151497Sru /* Clear the close handler myself not to be called again. */ 443151497Sru f->close = NULL; 444151497Sru a->client_data = NULL; 445151497Sru /* Clear passphrase. */ 446151497Sru if (a->passphrase != NULL) { 447151497Sru memset(a->passphrase, 0, strlen(a->passphrase)); 448151497Sru free(a->passphrase); 449151497Sru a->passphrase = NULL; 450151497Sru } 451151497Sru return (ret); 452151497Sru} 453151497Sru 454151497Sru/* 455151497Sru * Open the archive using the current settings. 456151497Sru */ 457151497Sruint 458151497Sruarchive_write_open(struct archive *_a, void *client_data, 459151497Sru archive_open_callback *opener, archive_write_callback *writer, 460151497Sru archive_close_callback *closer) 461151497Sru{ 462151497Sru struct archive_write *a = (struct archive_write *)_a; 463151497Sru struct archive_write_filter *client_filter; 464151497Sru int ret, r1; 465151497Sru 466151497Sru archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 467151497Sru ARCHIVE_STATE_NEW, "archive_write_open"); 468151497Sru archive_clear_error(&a->archive); 469151497Sru 470151497Sru a->client_writer = writer; 471151497Sru a->client_opener = opener; 472151497Sru a->client_closer = closer; 473151497Sru a->client_data = client_data; 474151497Sru 475151497Sru client_filter = __archive_write_allocate_filter(_a); 476151497Sru client_filter->open = archive_write_client_open; 477151497Sru client_filter->write = archive_write_client_write; 478151497Sru client_filter->close = archive_write_client_close; 479151497Sru 480151497Sru ret = __archive_write_open_filter(a->filter_first); 481151497Sru if (ret < ARCHIVE_WARN) { 482151497Sru r1 = __archive_write_close_filter(a->filter_first); 483151497Sru return (r1 < ret ? r1 : ret); 484151497Sru } 485151497Sru 486151497Sru a->archive.state = ARCHIVE_STATE_HEADER; 487151497Sru if (a->format_init) 488151497Sru ret = (a->format_init)(a); 489151497Sru return (ret); 490151497Sru} 491151497Sru 492151497Sru/* 493151497Sru * Close out the archive. 494151497Sru */ 495151497Srustatic int 496151497Sru_archive_write_close(struct archive *_a) 497151497Sru{ 498151497Sru struct archive_write *a = (struct archive_write *)_a; 499151497Sru int r = ARCHIVE_OK, r1 = ARCHIVE_OK; 500151497Sru 501151497Sru archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 502151497Sru ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, 503151497Sru "archive_write_close"); 504151497Sru if (a->archive.state == ARCHIVE_STATE_NEW 505151497Sru || a->archive.state == ARCHIVE_STATE_CLOSED) 506151497Sru return (ARCHIVE_OK); /* Okay to close() when not open. */ 507151497Sru 508151497Sru archive_clear_error(&a->archive); 509151497Sru 510151497Sru /* Finish the last entry if a finish callback is specified */ 511151497Sru if (a->archive.state == ARCHIVE_STATE_DATA 512151497Sru && a->format_finish_entry != NULL) 513151497Sru r = ((a->format_finish_entry)(a)); 514151497Sru 515151497Sru /* Finish off the archive. */ 516151497Sru /* TODO: have format closers invoke compression close. */ 517151497Sru if (a->format_close != NULL) { 518151497Sru r1 = (a->format_close)(a); 519151497Sru if (r1 < r) 520151497Sru r = r1; 521151497Sru } 522151497Sru 523151497Sru /* Finish the compression and close the stream. */ 524151497Sru r1 = __archive_write_close_filter(a->filter_first); 525151497Sru if (r1 < r) 526151497Sru r = r1; 527151497Sru 528151497Sru if (a->archive.state != ARCHIVE_STATE_FATAL) 529151497Sru a->archive.state = ARCHIVE_STATE_CLOSED; 530151497Sru return (r); 531151497Sru} 532151497Sru 533151497Srustatic int 534151497Sru_archive_write_filter_count(struct archive *_a) 535151497Sru{ 536151497Sru struct archive_write *a = (struct archive_write *)_a; 537151497Sru struct archive_write_filter *p = a->filter_first; 538151497Sru int count = 0; 539151497Sru while(p) { 540151497Sru count++; 541151497Sru p = p->next_filter; 542151497Sru } 543151497Sru return count; 544151497Sru} 545151497Sru 546151497Sruvoid 547151497Sru__archive_write_filters_free(struct archive *_a) 548151497Sru{ 549151497Sru struct archive_write *a = (struct archive_write *)_a; 550151497Sru int r = ARCHIVE_OK, r1; 551151497Sru 552151497Sru while (a->filter_first != NULL) { 553151497Sru struct archive_write_filter *next 554151497Sru = a->filter_first->next_filter; 555151497Sru if (a->filter_first->free != NULL) { 556151497Sru r1 = (*a->filter_first->free)(a->filter_first); 557151497Sru if (r > r1) 558151497Sru r = r1; 559151497Sru } 560151497Sru free(a->filter_first); 561151497Sru a->filter_first = next; 562151497Sru } 563151497Sru a->filter_last = NULL; 564151497Sru} 565151497Sru 566151497Sru/* 567151497Sru * Destroy the archive structure. 568151497Sru * 569151497Sru * Be careful: user might just call write_new and then write_free. 570151497Sru * Don't assume we actually wrote anything or performed any non-trivial 571151497Sru * initialization. 572151497Sru */ 573151497Srustatic int 574151497Sru_archive_write_free(struct archive *_a) 575151497Sru{ 576151497Sru struct archive_write *a = (struct archive_write *)_a; 577151497Sru int r = ARCHIVE_OK, r1; 578151497Sru 579151497Sru if (_a == NULL) 580151497Sru return (ARCHIVE_OK); 581151497Sru /* It is okay to call free() in state FATAL. */ 582151497Sru archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 583151497Sru ARCHIVE_STATE_ANY | ARCHIVE_STATE_FATAL, "archive_write_free"); 584151497Sru if (a->archive.state != ARCHIVE_STATE_FATAL) 585151497Sru r = archive_write_close(&a->archive); 586151497Sru 587151497Sru /* Release format resources. */ 588151497Sru if (a->format_free != NULL) { 589151497Sru r1 = (a->format_free)(a); 590151497Sru if (r1 < r) 591151497Sru r = r1; 592151497Sru } 593151497Sru 594151497Sru __archive_write_filters_free(_a); 595151497Sru 596151497Sru /* Release various dynamic buffers. */ 597151497Sru free((void *)(uintptr_t)(const void *)a->nulls); 598151497Sru archive_string_free(&a->archive.error_string); 599151497Sru if (a->passphrase != NULL) { 600151497Sru /* A passphrase should be cleaned. */ 601151497Sru memset(a->passphrase, 0, strlen(a->passphrase)); 602151497Sru free(a->passphrase); 603151497Sru } 604151497Sru a->archive.magic = 0; 605151497Sru __archive_clean(&a->archive); 606151497Sru free(a); 607151497Sru return (r); 608151497Sru} 609151497Sru 610151497Sru/* 611151497Sru * Write the appropriate header. 612151497Sru */ 613151497Srustatic int 614151497Sru_archive_write_header(struct archive *_a, struct archive_entry *entry) 615151497Sru{ 616151497Sru struct archive_write *a = (struct archive_write *)_a; 617151497Sru int ret, r2; 618151497Sru 619151497Sru archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 620151497Sru ARCHIVE_STATE_DATA | ARCHIVE_STATE_HEADER, "archive_write_header"); 621151497Sru archive_clear_error(&a->archive); 622151497Sru 623151497Sru if (a->format_write_header == NULL) { 624151497Sru archive_set_error(&(a->archive), -1, 625151497Sru "Format must be set before you can write to an archive."); 626151497Sru a->archive.state = ARCHIVE_STATE_FATAL; 627151497Sru return (ARCHIVE_FATAL); 628151497Sru } 629151497Sru 630151497Sru /* In particular, "retry" and "fatal" get returned immediately. */ 631151497Sru ret = archive_write_finish_entry(&a->archive); 632151497Sru if (ret == ARCHIVE_FATAL) { 633151497Sru a->archive.state = ARCHIVE_STATE_FATAL; 634151497Sru return (ARCHIVE_FATAL); 635151497Sru } 636151497Sru if (ret < ARCHIVE_OK && ret != ARCHIVE_WARN) 637151497Sru return (ret); 638151497Sru 639151497Sru if (a->skip_file_set && 640151497Sru archive_entry_dev_is_set(entry) && 641151497Sru archive_entry_ino_is_set(entry) && 642151497Sru archive_entry_dev(entry) == (dev_t)a->skip_file_dev && 643151497Sru archive_entry_ino64(entry) == a->skip_file_ino) { 644151497Sru archive_set_error(&a->archive, 0, 645151497Sru "Can't add archive to itself"); 646151497Sru return (ARCHIVE_FAILED); 647151497Sru } 648151497Sru 649151497Sru /* Format and write header. */ 650151497Sru r2 = ((a->format_write_header)(a, entry)); 651151497Sru if (r2 == ARCHIVE_FAILED) { 652151497Sru return (ARCHIVE_FAILED); 653151497Sru } 654151497Sru if (r2 == ARCHIVE_FATAL) { 655151497Sru a->archive.state = ARCHIVE_STATE_FATAL; 656151497Sru return (ARCHIVE_FATAL); 657151497Sru } 658151497Sru if (r2 < ret) 659151497Sru ret = r2; 660151497Sru 661151497Sru a->archive.state = ARCHIVE_STATE_DATA; 662151497Sru return (ret); 663151497Sru} 664151497Sru 665151497Srustatic int 666151497Sru_archive_write_finish_entry(struct archive *_a) 667151497Sru{ 668151497Sru struct archive_write *a = (struct archive_write *)_a; 669151497Sru int ret = ARCHIVE_OK; 670151497Sru 671151497Sru archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 672151497Sru ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA, 673151497Sru "archive_write_finish_entry"); 674151497Sru if (a->archive.state & ARCHIVE_STATE_DATA 675151497Sru && a->format_finish_entry != NULL) 676151497Sru ret = (a->format_finish_entry)(a); 677151497Sru a->archive.state = ARCHIVE_STATE_HEADER; 678151497Sru return (ret); 679151497Sru} 680151497Sru 681151497Sru/* 682151497Sru * Note that the compressor is responsible for blocking. 683151497Sru */ 684151497Srustatic ssize_t 685151497Sru_archive_write_data(struct archive *_a, const void *buff, size_t s) 686151497Sru{ 687151497Sru struct archive_write *a = (struct archive_write *)_a; 688151497Sru const size_t max_write = INT_MAX; 689151497Sru 690151497Sru archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 691151497Sru ARCHIVE_STATE_DATA, "archive_write_data"); 692151497Sru /* In particular, this catches attempts to pass negative values. */ 693151497Sru if (s > max_write) 694151497Sru s = max_write; 695151497Sru archive_clear_error(&a->archive); 696151497Sru return ((a->format_write_data)(a, buff, s)); 697151497Sru} 698151497Sru 699151497Srustatic struct archive_write_filter * 700151497Srufilter_lookup(struct archive *_a, int n) 701151497Sru{ 702151497Sru struct archive_write *a = (struct archive_write *)_a; 703151497Sru struct archive_write_filter *f = a->filter_first; 704151497Sru if (n == -1) 705151497Sru return a->filter_last; 706151497Sru if (n < 0) 707151497Sru return NULL; 708151497Sru while (n > 0 && f != NULL) { 709151497Sru f = f->next_filter; 710151497Sru --n; 711151497Sru } 712151497Sru return f; 713151497Sru} 714151497Sru 715151497Srustatic int 716151497Sru_archive_filter_code(struct archive *_a, int n) 717151497Sru{ 718151497Sru struct archive_write_filter *f = filter_lookup(_a, n); 719151497Sru return f == NULL ? -1 : f->code; 720151497Sru} 721151497Sru 722151497Srustatic const char * 723151497Sru_archive_filter_name(struct archive *_a, int n) 724151497Sru{ 725151497Sru struct archive_write_filter *f = filter_lookup(_a, n); 726151497Sru return f != NULL ? f->name : NULL; 727151497Sru} 728151497Sru 729151497Srustatic int64_t 730151497Sru_archive_filter_bytes(struct archive *_a, int n) 731151497Sru{ 732151497Sru struct archive_write_filter *f = filter_lookup(_a, n); 733151497Sru return f == NULL ? -1 : f->bytes_written; 734151497Sru} 735151497Sru