1 /*- 2 * Copyright (c) 2003-2007 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: src/lib/libarchive/archive_write.c,v 1.27 2008/03/14 23:09:02 kientzle Exp $"); 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 a 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_LIMITS_H 41 #include <limits.h> 42 #endif 43 #include <stdio.h> 44 #ifdef HAVE_STDLIB_H 45 #include <stdlib.h> 46 #endif 47 #ifdef HAVE_STRING_H 48 #include <string.h> 49 #endif 50 #include <time.h> 51 #ifdef HAVE_UNISTD_H 52 #include <unistd.h> 53 #endif 54 55 #include "archive.h" 56 #include "archive_entry.h" 57 #include "archive_private.h" 58 #include "archive_write_private.h" 59 60 static struct archive_vtable *archive_write_vtable(void); 61 62 static int _archive_write_close(struct archive *); 63 static int _archive_write_finish(struct archive *); 64 static int _archive_write_header(struct archive *, struct archive_entry *); 65 static int _archive_write_finish_entry(struct archive *); 66 static ssize_t _archive_write_data(struct archive *, const void *, size_t); 67 68 static struct archive_vtable * 69 archive_write_vtable(void) 70 { 71 static struct archive_vtable av; 72 static int inited = 0; 73 74 if (!inited) { 75 av.archive_write_close = _archive_write_close; 76 av.archive_write_finish = _archive_write_finish; 77 av.archive_write_header = _archive_write_header; 78 av.archive_write_finish_entry = _archive_write_finish_entry; 79 av.archive_write_data = _archive_write_data; 80 } 81 return (&av); 82 } 83 84 /* 85 * Allocate, initialize and return an archive object. 86 */ 87 struct archive * 88 archive_write_new(void) 89 { 90 struct archive_write *a; 91 unsigned char *nulls; 92 93 a = (struct archive_write *)malloc(sizeof(*a)); 94 if (a == NULL) 95 return (NULL); 96 memset(a, 0, sizeof(*a)); 97 a->archive.magic = ARCHIVE_WRITE_MAGIC; 98 a->archive.state = ARCHIVE_STATE_NEW; 99 a->archive.vtable = archive_write_vtable(); 100 /* 101 * The value 10240 here matches the traditional tar default, 102 * but is otherwise arbitrary. 103 * TODO: Set the default block size from the format selected. 104 */ 105 a->bytes_per_block = 10240; 106 a->bytes_in_last_block = -1; /* Default */ 107 108 /* Initialize a block of nulls for padding purposes. */ 109 a->null_length = 1024; 110 nulls = (unsigned char *)malloc(a->null_length); 111 if (nulls == NULL) { 112 free(a); 113 return (NULL); 114 } 115 memset(nulls, 0, a->null_length); 116 a->nulls = nulls; 117 /* 118 * Set default compression, but don't set a default format. 119 * Were we to set a default format here, we would force every 120 * client to link in support for that format, even if they didn't 121 * ever use it. 122 */ 123 archive_write_set_compression_none(&a->archive); 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 /* 180 * dev/ino of a file to be rejected. Used to prevent adding 181 * an archive to itself recursively. 182 */ 183 int 184 archive_write_set_skip_file(struct archive *_a, dev_t d, ino_t i) 185 { 186 struct archive_write *a = (struct archive_write *)_a; 187 __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 188 ARCHIVE_STATE_ANY, "archive_write_set_skip_file"); 189 a->skip_file_dev = d; 190 a->skip_file_ino = i; 191 return (ARCHIVE_OK); 192 } 193 194 195 /* 196 * Open the archive using the current settings. 197 */ 198 int 199 archive_write_open(struct archive *_a, void *client_data, 200 archive_open_callback *opener, archive_write_callback *writer, 201 archive_close_callback *closer) 202 { 203 struct archive_write *a = (struct archive_write *)_a; 204 int ret; 205 206 ret = ARCHIVE_OK; 207 __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 208 ARCHIVE_STATE_NEW, "archive_write_open"); 209 archive_clear_error(&a->archive); 210 a->archive.state = ARCHIVE_STATE_HEADER; 211 a->client_data = client_data; 212 a->client_writer = writer; 213 a->client_opener = opener; 214 a->client_closer = closer; 215 ret = (a->compressor.init)(a); 216 if (a->format_init && ret == ARCHIVE_OK) 217 ret = (a->format_init)(a); 218 return (ret); 219 } 220 221 222 /* 223 * Close out the archive. 224 * 225 * Be careful: user might just call write_new and then write_finish. 226 * Don't assume we actually wrote anything or performed any non-trivial 227 * initialization. 228 */ 229 static int 230 _archive_write_close(struct archive *_a) 231 { 232 struct archive_write *a = (struct archive_write *)_a; 233 int r = ARCHIVE_OK, r1 = ARCHIVE_OK; 234 235 __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 236 ARCHIVE_STATE_ANY, "archive_write_close"); 237 238 /* Finish the last entry. */ 239 if (a->archive.state & ARCHIVE_STATE_DATA) 240 r = ((a->format_finish_entry)(a)); 241 242 /* Finish off the archive. */ 243 if (a->format_finish != NULL) { 244 r1 = (a->format_finish)(a); 245 if (r1 < r) 246 r = r1; 247 } 248 249 /* Release format resources. */ 250 if (a->format_destroy != NULL) { 251 r1 = (a->format_destroy)(a); 252 if (r1 < r) 253 r = r1; 254 } 255 256 /* Finish the compression and close the stream. */ 257 if (a->compressor.finish != NULL) { 258 r1 = (a->compressor.finish)(a); 259 if (r1 < r) 260 r = r1; 261 } 262 263 /* Close out the client stream. */ 264 if (a->client_closer != NULL) { 265 r1 = (a->client_closer)(&a->archive, a->client_data); 266 if (r1 < r) 267 r = r1; 268 } 269 270 a->archive.state = ARCHIVE_STATE_CLOSED; 271 return (r); 272 } 273 274 /* 275 * Destroy the archive structure. 276 */ 277 static int 278 _archive_write_finish(struct archive *_a) 279 { 280 struct archive_write *a = (struct archive_write *)_a; 281 int r = ARCHIVE_OK; 282 283 __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 284 ARCHIVE_STATE_ANY, "archive_write_finish"); 285 if (a->archive.state != ARCHIVE_STATE_CLOSED) 286 r = archive_write_close(&a->archive); 287 288 /* Release various dynamic buffers. */ 289 free((void *)(uintptr_t)(const void *)a->nulls); 290 archive_string_free(&a->archive.error_string); 291 a->archive.magic = 0; 292 free(a); 293 return (r); 294 } 295 296 /* 297 * Write the appropriate header. 298 */ 299 static int 300 _archive_write_header(struct archive *_a, struct archive_entry *entry) 301 { 302 struct archive_write *a = (struct archive_write *)_a; 303 int ret, r2; 304 305 __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 306 ARCHIVE_STATE_DATA | ARCHIVE_STATE_HEADER, "archive_write_header"); 307 archive_clear_error(&a->archive); 308 309 /* In particular, "retry" and "fatal" get returned immediately. */ 310 ret = archive_write_finish_entry(&a->archive); 311 if (ret < ARCHIVE_OK && ret != ARCHIVE_WARN) 312 return (ret); 313 314 if (a->skip_file_dev != 0 && 315 archive_entry_dev(entry) == a->skip_file_dev && 316 a->skip_file_ino != 0 && 317 archive_entry_ino(entry) == a->skip_file_ino) { 318 archive_set_error(&a->archive, 0, 319 "Can't add archive to itself"); 320 return (ARCHIVE_FAILED); 321 } 322 323 /* Format and write header. */ 324 r2 = ((a->format_write_header)(a, entry)); 325 if (r2 < ret) 326 ret = r2; 327 328 a->archive.state = ARCHIVE_STATE_DATA; 329 return (ret); 330 } 331 332 static int 333 _archive_write_finish_entry(struct archive *_a) 334 { 335 struct archive_write *a = (struct archive_write *)_a; 336 int ret = ARCHIVE_OK; 337 338 __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 339 ARCHIVE_STATE_HEADER | ARCHIVE_STATE_DATA, 340 "archive_write_finish_entry"); 341 if (a->archive.state & ARCHIVE_STATE_DATA) 342 ret = (a->format_finish_entry)(a); 343 a->archive.state = ARCHIVE_STATE_HEADER; 344 return (ret); 345 } 346 347 /* 348 * Note that the compressor is responsible for blocking. 349 */ 350 static ssize_t 351 _archive_write_data(struct archive *_a, const void *buff, size_t s) 352 { 353 struct archive_write *a = (struct archive_write *)_a; 354 __archive_check_magic(&a->archive, ARCHIVE_WRITE_MAGIC, 355 ARCHIVE_STATE_DATA, "archive_write_data"); 356 archive_clear_error(&a->archive); 357 return ((a->format_write_data)(a, buff, s)); 358 } 359