archive_write_set_format_cpio_binary.c revision 311041
1/*- 2 * Copyright (c) 2003-2007 Tim Kientzle 3 * Copyright (c) 2011-2012 Michihiro NAKAJIMA 4 * All rights reserved. 5 * 6 * Redistribution and use in source and binary forms, with or without 7 * modification, are permitted provided that the following conditions 8 * are met: 9 * 1. Redistributions of source code must retain the above copyright 10 * notice, this list of conditions and the following disclaimer. 11 * 2. Redistributions in binary form must reproduce the above copyright 12 * notice, this list of conditions and the following disclaimer in the 13 * documentation and/or other materials provided with the distribution. 14 * 15 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 16 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 17 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 18 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 19 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 20 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 21 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27#include "archive_platform.h" 28__FBSDID("$FreeBSD: stable/11/contrib/libarchive/libarchive/archive_write_set_format_cpio.c 311041 2017-01-02 01:41:31Z mm $"); 29 30#ifdef HAVE_ERRNO_H 31#include <errno.h> 32#endif 33#include <stdio.h> 34#ifdef HAVE_STDLIB_H 35#include <stdlib.h> 36#endif 37#ifdef HAVE_STRING_H 38#include <string.h> 39#endif 40 41#include "archive.h" 42#include "archive_entry.h" 43#include "archive_entry_locale.h" 44#include "archive_private.h" 45#include "archive_write_private.h" 46 47static ssize_t archive_write_cpio_data(struct archive_write *, 48 const void *buff, size_t s); 49static int archive_write_cpio_close(struct archive_write *); 50static int archive_write_cpio_free(struct archive_write *); 51static int archive_write_cpio_finish_entry(struct archive_write *); 52static int archive_write_cpio_header(struct archive_write *, 53 struct archive_entry *); 54static int archive_write_cpio_options(struct archive_write *, 55 const char *, const char *); 56static int format_octal(int64_t, void *, int); 57static int64_t format_octal_recursive(int64_t, char *, int); 58static int write_header(struct archive_write *, struct archive_entry *); 59 60struct cpio { 61 uint64_t entry_bytes_remaining; 62 63 int64_t ino_next; 64 65 struct { int64_t old; int new;} *ino_list; 66 size_t ino_list_size; 67 size_t ino_list_next; 68 69 struct archive_string_conv *opt_sconv; 70 struct archive_string_conv *sconv_default; 71 int init_default_conversion; 72}; 73 74#define c_magic_offset 0 75#define c_magic_size 6 76#define c_dev_offset 6 77#define c_dev_size 6 78#define c_ino_offset 12 79#define c_ino_size 6 80#define c_mode_offset 18 81#define c_mode_size 6 82#define c_uid_offset 24 83#define c_uid_size 6 84#define c_gid_offset 30 85#define c_gid_size 6 86#define c_nlink_offset 36 87#define c_nlink_size 6 88#define c_rdev_offset 42 89#define c_rdev_size 6 90#define c_mtime_offset 48 91#define c_mtime_size 11 92#define c_namesize_offset 59 93#define c_namesize_size 6 94#define c_filesize_offset 65 95#define c_filesize_size 11 96 97/* 98 * Set output format to 'cpio' format. 99 */ 100int 101archive_write_set_format_cpio(struct archive *_a) 102{ 103 struct archive_write *a = (struct archive_write *)_a; 104 struct cpio *cpio; 105 106 archive_check_magic(_a, ARCHIVE_WRITE_MAGIC, 107 ARCHIVE_STATE_NEW, "archive_write_set_format_cpio"); 108 109 /* If someone else was already registered, unregister them. */ 110 if (a->format_free != NULL) 111 (a->format_free)(a); 112 113 cpio = (struct cpio *)calloc(1, sizeof(*cpio)); 114 if (cpio == NULL) { 115 archive_set_error(&a->archive, ENOMEM, "Can't allocate cpio data"); 116 return (ARCHIVE_FATAL); 117 } 118 a->format_data = cpio; 119 a->format_name = "cpio"; 120 a->format_options = archive_write_cpio_options; 121 a->format_write_header = archive_write_cpio_header; 122 a->format_write_data = archive_write_cpio_data; 123 a->format_finish_entry = archive_write_cpio_finish_entry; 124 a->format_close = archive_write_cpio_close; 125 a->format_free = archive_write_cpio_free; 126 a->archive.archive_format = ARCHIVE_FORMAT_CPIO_POSIX; 127 a->archive.archive_format_name = "POSIX cpio"; 128 return (ARCHIVE_OK); 129} 130 131static int 132archive_write_cpio_options(struct archive_write *a, const char *key, 133 const char *val) 134{ 135 struct cpio *cpio = (struct cpio *)a->format_data; 136 int ret = ARCHIVE_FAILED; 137 138 if (strcmp(key, "hdrcharset") == 0) { 139 if (val == NULL || val[0] == 0) 140 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 141 "%s: hdrcharset option needs a character-set name", 142 a->format_name); 143 else { 144 cpio->opt_sconv = archive_string_conversion_to_charset( 145 &a->archive, val, 0); 146 if (cpio->opt_sconv != NULL) 147 ret = ARCHIVE_OK; 148 else 149 ret = ARCHIVE_FATAL; 150 } 151 return (ret); 152 } 153 154 /* Note: The "warn" return is just to inform the options 155 * supervisor that we didn't handle it. It will generate 156 * a suitable error if no one used this option. */ 157 return (ARCHIVE_WARN); 158} 159 160/* 161 * Ino values are as long as 64 bits on some systems; cpio format 162 * only allows 18 bits and relies on the ino values to identify hardlinked 163 * files. So, we can't merely "hash" the ino numbers since collisions 164 * would corrupt the archive. Instead, we generate synthetic ino values 165 * to store in the archive and maintain a map of original ino values to 166 * synthetic ones so we can preserve hardlink information. 167 * 168 * TODO: Make this more efficient. It's not as bad as it looks (most 169 * files don't have any hardlinks and we don't do any work here for those), 170 * but it wouldn't be hard to do better. 171 * 172 * TODO: Work with dev/ino pairs here instead of just ino values. 173 */ 174static int 175synthesize_ino_value(struct cpio *cpio, struct archive_entry *entry) 176{ 177 int64_t ino = archive_entry_ino64(entry); 178 int ino_new; 179 size_t i; 180 181 /* 182 * If no index number was given, don't assign one. In 183 * particular, this handles the end-of-archive marker 184 * correctly by giving it a zero index value. (This is also 185 * why we start our synthetic index numbers with one below.) 186 */ 187 if (ino == 0) 188 return (0); 189 190 /* Don't store a mapping if we don't need to. */ 191 if (archive_entry_nlink(entry) < 2) { 192 return (int)(++cpio->ino_next); 193 } 194 195 /* Look up old ino; if we have it, this is a hardlink 196 * and we reuse the same value. */ 197 for (i = 0; i < cpio->ino_list_next; ++i) { 198 if (cpio->ino_list[i].old == ino) 199 return (cpio->ino_list[i].new); 200 } 201 202 /* Assign a new index number. */ 203 ino_new = (int)(++cpio->ino_next); 204 205 /* Ensure space for the new mapping. */ 206 if (cpio->ino_list_size <= cpio->ino_list_next) { 207 size_t newsize = cpio->ino_list_size < 512 208 ? 512 : cpio->ino_list_size * 2; 209 void *newlist = realloc(cpio->ino_list, 210 sizeof(cpio->ino_list[0]) * newsize); 211 if (newlist == NULL) 212 return (-1); 213 214 cpio->ino_list_size = newsize; 215 cpio->ino_list = newlist; 216 } 217 218 /* Record and return the new value. */ 219 cpio->ino_list[cpio->ino_list_next].old = ino; 220 cpio->ino_list[cpio->ino_list_next].new = ino_new; 221 ++cpio->ino_list_next; 222 return (ino_new); 223} 224 225 226static struct archive_string_conv * 227get_sconv(struct archive_write *a) 228{ 229 struct cpio *cpio; 230 struct archive_string_conv *sconv; 231 232 cpio = (struct cpio *)a->format_data; 233 sconv = cpio->opt_sconv; 234 if (sconv == NULL) { 235 if (!cpio->init_default_conversion) { 236 cpio->sconv_default = 237 archive_string_default_conversion_for_write( 238 &(a->archive)); 239 cpio->init_default_conversion = 1; 240 } 241 sconv = cpio->sconv_default; 242 } 243 return (sconv); 244} 245 246static int 247archive_write_cpio_header(struct archive_write *a, struct archive_entry *entry) 248{ 249 const char *path; 250 size_t len; 251 252 if (archive_entry_filetype(entry) == 0) { 253 archive_set_error(&a->archive, -1, "Filetype required"); 254 return (ARCHIVE_FAILED); 255 } 256 257 if (archive_entry_pathname_l(entry, &path, &len, get_sconv(a)) != 0 258 && errno == ENOMEM) { 259 archive_set_error(&a->archive, ENOMEM, 260 "Can't allocate memory for Pathname"); 261 return (ARCHIVE_FATAL); 262 } 263 if (len == 0 || path == NULL || path[0] == '\0') { 264 archive_set_error(&a->archive, -1, "Pathname required"); 265 return (ARCHIVE_FAILED); 266 } 267 268 if (!archive_entry_size_is_set(entry) || archive_entry_size(entry) < 0) { 269 archive_set_error(&a->archive, -1, "Size required"); 270 return (ARCHIVE_FAILED); 271 } 272 return write_header(a, entry); 273} 274 275static int 276write_header(struct archive_write *a, struct archive_entry *entry) 277{ 278 struct cpio *cpio; 279 const char *p, *path; 280 int pathlength, ret, ret_final; 281 int64_t ino; 282 char h[76]; 283 struct archive_string_conv *sconv; 284 struct archive_entry *entry_main; 285 size_t len; 286 287 cpio = (struct cpio *)a->format_data; 288 ret_final = ARCHIVE_OK; 289 sconv = get_sconv(a); 290 291#if defined(_WIN32) && !defined(__CYGWIN__) 292 /* Make sure the path separators in pathname, hardlink and symlink 293 * are all slash '/', not the Windows path separator '\'. */ 294 entry_main = __la_win_entry_in_posix_pathseparator(entry); 295 if (entry_main == NULL) { 296 archive_set_error(&a->archive, ENOMEM, 297 "Can't allocate ustar data"); 298 return(ARCHIVE_FATAL); 299 } 300 if (entry != entry_main) 301 entry = entry_main; 302 else 303 entry_main = NULL; 304#else 305 entry_main = NULL; 306#endif 307 308 ret = archive_entry_pathname_l(entry, &path, &len, sconv); 309 if (ret != 0) { 310 if (errno == ENOMEM) { 311 archive_set_error(&a->archive, ENOMEM, 312 "Can't allocate memory for Pathname"); 313 ret_final = ARCHIVE_FATAL; 314 goto exit_write_header; 315 } 316 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 317 "Can't translate pathname '%s' to %s", 318 archive_entry_pathname(entry), 319 archive_string_conversion_charset_name(sconv)); 320 ret_final = ARCHIVE_WARN; 321 } 322 /* Include trailing null. */ 323 pathlength = (int)len + 1; 324 325 memset(h, 0, sizeof(h)); 326 format_octal(070707, h + c_magic_offset, c_magic_size); 327 format_octal(archive_entry_dev(entry), h + c_dev_offset, c_dev_size); 328 329 ino = synthesize_ino_value(cpio, entry); 330 if (ino < 0) { 331 archive_set_error(&a->archive, ENOMEM, 332 "No memory for ino translation table"); 333 ret_final = ARCHIVE_FATAL; 334 goto exit_write_header; 335 } else if (ino > 0777777) { 336 archive_set_error(&a->archive, ERANGE, 337 "Too many files for this cpio format"); 338 ret_final = ARCHIVE_FATAL; 339 goto exit_write_header; 340 } 341 format_octal(ino & 0777777, h + c_ino_offset, c_ino_size); 342 343 /* TODO: Set ret_final to ARCHIVE_WARN if any of these overflow. */ 344 format_octal(archive_entry_mode(entry), h + c_mode_offset, c_mode_size); 345 format_octal(archive_entry_uid(entry), h + c_uid_offset, c_uid_size); 346 format_octal(archive_entry_gid(entry), h + c_gid_offset, c_gid_size); 347 format_octal(archive_entry_nlink(entry), h + c_nlink_offset, c_nlink_size); 348 if (archive_entry_filetype(entry) == AE_IFBLK 349 || archive_entry_filetype(entry) == AE_IFCHR) 350 format_octal(archive_entry_dev(entry), h + c_rdev_offset, c_rdev_size); 351 else 352 format_octal(0, h + c_rdev_offset, c_rdev_size); 353 format_octal(archive_entry_mtime(entry), h + c_mtime_offset, c_mtime_size); 354 format_octal(pathlength, h + c_namesize_offset, c_namesize_size); 355 356 /* Non-regular files don't store bodies. */ 357 if (archive_entry_filetype(entry) != AE_IFREG) 358 archive_entry_set_size(entry, 0); 359 360 /* Symlinks get the link written as the body of the entry. */ 361 ret = archive_entry_symlink_l(entry, &p, &len, sconv); 362 if (ret != 0) { 363 if (errno == ENOMEM) { 364 archive_set_error(&a->archive, ENOMEM, 365 "Can't allocate memory for Linkname"); 366 ret_final = ARCHIVE_FATAL; 367 goto exit_write_header; 368 } 369 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 370 "Can't translate linkname '%s' to %s", 371 archive_entry_symlink(entry), 372 archive_string_conversion_charset_name(sconv)); 373 ret_final = ARCHIVE_WARN; 374 } 375 if (len > 0 && p != NULL && *p != '\0') 376 ret = format_octal(strlen(p), h + c_filesize_offset, 377 c_filesize_size); 378 else 379 ret = format_octal(archive_entry_size(entry), 380 h + c_filesize_offset, c_filesize_size); 381 if (ret) { 382 archive_set_error(&a->archive, ERANGE, 383 "File is too large for cpio format."); 384 ret_final = ARCHIVE_FAILED; 385 goto exit_write_header; 386 } 387 388 ret = __archive_write_output(a, h, sizeof(h)); 389 if (ret != ARCHIVE_OK) { 390 ret_final = ARCHIVE_FATAL; 391 goto exit_write_header; 392 } 393 394 ret = __archive_write_output(a, path, pathlength); 395 if (ret != ARCHIVE_OK) { 396 ret_final = ARCHIVE_FATAL; 397 goto exit_write_header; 398 } 399 400 cpio->entry_bytes_remaining = archive_entry_size(entry); 401 402 /* Write the symlink now. */ 403 if (p != NULL && *p != '\0') { 404 ret = __archive_write_output(a, p, strlen(p)); 405 if (ret != ARCHIVE_OK) { 406 ret_final = ARCHIVE_FATAL; 407 goto exit_write_header; 408 } 409 } 410exit_write_header: 411 if (entry_main) 412 archive_entry_free(entry_main); 413 return (ret_final); 414} 415 416static ssize_t 417archive_write_cpio_data(struct archive_write *a, const void *buff, size_t s) 418{ 419 struct cpio *cpio; 420 int ret; 421 422 cpio = (struct cpio *)a->format_data; 423 if (s > cpio->entry_bytes_remaining) 424 s = (size_t)cpio->entry_bytes_remaining; 425 426 ret = __archive_write_output(a, buff, s); 427 cpio->entry_bytes_remaining -= s; 428 if (ret >= 0) 429 return (s); 430 else 431 return (ret); 432} 433 434/* 435 * Format a number into the specified field. 436 */ 437static int 438format_octal(int64_t v, void *p, int digits) 439{ 440 int64_t max; 441 int ret; 442 443 max = (((int64_t)1) << (digits * 3)) - 1; 444 if (v >= 0 && v <= max) { 445 format_octal_recursive(v, (char *)p, digits); 446 ret = 0; 447 } else { 448 format_octal_recursive(max, (char *)p, digits); 449 ret = -1; 450 } 451 return (ret); 452} 453 454static int64_t 455format_octal_recursive(int64_t v, char *p, int s) 456{ 457 if (s == 0) 458 return (v); 459 v = format_octal_recursive(v, p+1, s-1); 460 *p = '0' + ((char)v & 7); 461 return (v >> 3); 462} 463 464static int 465archive_write_cpio_close(struct archive_write *a) 466{ 467 int er; 468 struct archive_entry *trailer; 469 470 trailer = archive_entry_new2(NULL); 471 /* nlink = 1 here for GNU cpio compat. */ 472 archive_entry_set_nlink(trailer, 1); 473 archive_entry_set_size(trailer, 0); 474 archive_entry_set_pathname(trailer, "TRAILER!!!"); 475 er = write_header(a, trailer); 476 archive_entry_free(trailer); 477 return (er); 478} 479 480static int 481archive_write_cpio_free(struct archive_write *a) 482{ 483 struct cpio *cpio; 484 485 cpio = (struct cpio *)a->format_data; 486 free(cpio->ino_list); 487 free(cpio); 488 a->format_data = NULL; 489 return (ARCHIVE_OK); 490} 491 492static int 493archive_write_cpio_finish_entry(struct archive_write *a) 494{ 495 struct cpio *cpio; 496 497 cpio = (struct cpio *)a->format_data; 498 return (__archive_write_nulls(a, 499 (size_t)cpio->entry_bytes_remaining)); 500} 501