1 /*- 2 * Copyright (c) 2007 Kai Wang 3 * Copyright (c) 2007 Tim Kientzle 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 * in this position and unchanged. 12 * 2. Redistributions in binary form must reproduce the above copyright 13 * notice, this list of conditions and the following disclaimer in the 14 * documentation and/or other materials provided with the distribution. 15 * 16 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 17 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 18 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 19 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 20 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 21 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 22 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 23 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 24 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 25 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 26 */ 27 28 #include "archive_platform.h" 29 __FBSDID("$FreeBSD: src/lib/libarchive/archive_read_support_format_ar.c,v 1.12 2008/12/17 19:02:42 kientzle Exp $"); 30 31 #ifdef HAVE_SYS_STAT_H 32 #include <sys/stat.h> 33 #endif 34 #ifdef HAVE_ERRNO_H 35 #include <errno.h> 36 #endif 37 #ifdef HAVE_STDLIB_H 38 #include <stdlib.h> 39 #endif 40 #ifdef HAVE_STRING_H 41 #include <string.h> 42 #endif 43 44 #include "archive.h" 45 #include "archive_entry.h" 46 #include "archive_private.h" 47 #include "archive_read_private.h" 48 49 struct ar { 50 off_t entry_bytes_remaining; 51 off_t entry_offset; 52 off_t entry_padding; 53 char *strtab; 54 size_t strtab_size; 55 }; 56 57 /* 58 * Define structure of the "ar" header. 59 */ 60 #define AR_name_offset 0 61 #define AR_name_size 16 62 #define AR_date_offset 16 63 #define AR_date_size 12 64 #define AR_uid_offset 28 65 #define AR_uid_size 6 66 #define AR_gid_offset 34 67 #define AR_gid_size 6 68 #define AR_mode_offset 40 69 #define AR_mode_size 8 70 #define AR_size_offset 48 71 #define AR_size_size 10 72 #define AR_fmag_offset 58 73 #define AR_fmag_size 2 74 75 static int archive_read_format_ar_bid(struct archive_read *a); 76 static int archive_read_format_ar_cleanup(struct archive_read *a); 77 static int archive_read_format_ar_read_data(struct archive_read *a, 78 const void **buff, size_t *size, off_t *offset); 79 static int archive_read_format_ar_skip(struct archive_read *a); 80 static int archive_read_format_ar_read_header(struct archive_read *a, 81 struct archive_entry *e); 82 static uint64_t ar_atol8(const char *p, unsigned char_cnt); 83 static uint64_t ar_atol10(const char *p, unsigned char_cnt); 84 static int ar_parse_gnu_filename_table(struct archive_read *a); 85 static int ar_parse_common_header(struct ar *ar, struct archive_entry *, 86 const char *h); 87 88 int 89 archive_read_support_format_ar(struct archive *_a) 90 { 91 struct archive_read *a = (struct archive_read *)_a; 92 struct ar *ar; 93 int r; 94 95 ar = (struct ar *)malloc(sizeof(*ar)); 96 if (ar == NULL) { 97 archive_set_error(&a->archive, ENOMEM, 98 "Can't allocate ar data"); 99 return (ARCHIVE_FATAL); 100 } 101 memset(ar, 0, sizeof(*ar)); 102 ar->strtab = NULL; 103 104 r = __archive_read_register_format(a, 105 ar, 106 "ar", 107 archive_read_format_ar_bid, 108 NULL, 109 archive_read_format_ar_read_header, 110 archive_read_format_ar_read_data, 111 archive_read_format_ar_skip, 112 archive_read_format_ar_cleanup); 113 114 if (r != ARCHIVE_OK) { 115 free(ar); 116 return (r); 117 } 118 return (ARCHIVE_OK); 119 } 120 121 static int 122 archive_read_format_ar_cleanup(struct archive_read *a) 123 { 124 struct ar *ar; 125 126 ar = (struct ar *)(a->format->data); 127 if (ar->strtab) 128 free(ar->strtab); 129 free(ar); 130 (a->format->data) = NULL; 131 return (ARCHIVE_OK); 132 } 133 134 static int 135 archive_read_format_ar_bid(struct archive_read *a) 136 { 137 struct ar *ar; 138 const void *h; 139 140 if (a->archive.archive_format != 0 && 141 (a->archive.archive_format & ARCHIVE_FORMAT_BASE_MASK) != 142 ARCHIVE_FORMAT_AR) 143 return(0); 144 145 ar = (struct ar *)(a->format->data); 146 147 /* 148 * Verify the 8-byte file signature. 149 * TODO: Do we need to check more than this? 150 */ 151 if ((h = __archive_read_ahead(a, 8, NULL)) == NULL) 152 return (-1); 153 if (strncmp((const char*)h, "!<arch>\n", 8) == 0) { 154 return (64); 155 } 156 return (-1); 157 } 158 159 static int 160 archive_read_format_ar_read_header(struct archive_read *a, 161 struct archive_entry *entry) 162 { 163 char filename[AR_name_size + 1]; 164 struct ar *ar; 165 uint64_t number; /* Used to hold parsed numbers before validation. */ 166 ssize_t bytes_read; 167 size_t bsd_name_length, entry_size; 168 char *p, *st; 169 const void *b; 170 const char *h; 171 int r; 172 173 ar = (struct ar*)(a->format->data); 174 175 if (a->archive.file_position == 0) { 176 /* 177 * We are now at the beginning of the archive, 178 * so we need first consume the ar global header. 179 */ 180 __archive_read_consume(a, 8); 181 /* Set a default format code for now. */ 182 a->archive.archive_format = ARCHIVE_FORMAT_AR; 183 } 184 185 /* Read the header for the next file entry. */ 186 if ((b = __archive_read_ahead(a, 60, &bytes_read)) == NULL) 187 /* Broken header. */ 188 return (ARCHIVE_EOF); 189 __archive_read_consume(a, 60); 190 h = (const char *)b; 191 192 /* Verify the magic signature on the file header. */ 193 if (strncmp(h + AR_fmag_offset, "`\n", 2) != 0) { 194 archive_set_error(&a->archive, EINVAL, 195 "Incorrect file header signature"); 196 return (ARCHIVE_WARN); 197 } 198 199 /* Copy filename into work buffer. */ 200 strncpy(filename, h + AR_name_offset, AR_name_size); 201 filename[AR_name_size] = '\0'; 202 203 /* 204 * Guess the format variant based on the filename. 205 */ 206 if (a->archive.archive_format == ARCHIVE_FORMAT_AR) { 207 /* We don't already know the variant, so let's guess. */ 208 /* 209 * Biggest clue is presence of '/': GNU starts special 210 * filenames with '/', appends '/' as terminator to 211 * non-special names, so anything with '/' should be 212 * GNU except for BSD long filenames. 213 */ 214 if (strncmp(filename, "#1/", 3) == 0) 215 a->archive.archive_format = ARCHIVE_FORMAT_AR_BSD; 216 else if (strchr(filename, '/') != NULL) 217 a->archive.archive_format = ARCHIVE_FORMAT_AR_GNU; 218 else if (strncmp(filename, "__.SYMDEF", 9) == 0) 219 a->archive.archive_format = ARCHIVE_FORMAT_AR_BSD; 220 /* 221 * XXX Do GNU/SVR4 'ar' programs ever omit trailing '/' 222 * if name exactly fills 16-byte field? If so, we 223 * can't assume entries without '/' are BSD. XXX 224 */ 225 } 226 227 /* Update format name from the code. */ 228 if (a->archive.archive_format == ARCHIVE_FORMAT_AR_GNU) 229 a->archive.archive_format_name = "ar (GNU/SVR4)"; 230 else if (a->archive.archive_format == ARCHIVE_FORMAT_AR_BSD) 231 a->archive.archive_format_name = "ar (BSD)"; 232 else 233 a->archive.archive_format_name = "ar"; 234 235 /* 236 * Remove trailing spaces from the filename. GNU and BSD 237 * variants both pad filename area out with spaces. 238 * This will only be wrong if GNU/SVR4 'ar' implementations 239 * omit trailing '/' for 16-char filenames and we have 240 * a 16-char filename that ends in ' '. 241 */ 242 p = filename + AR_name_size - 1; 243 while (p >= filename && *p == ' ') { 244 *p = '\0'; 245 p--; 246 } 247 248 /* 249 * Remove trailing slash unless first character is '/'. 250 * (BSD entries never end in '/', so this will only trim 251 * GNU-format entries. GNU special entries start with '/' 252 * and are not terminated in '/', so we don't trim anything 253 * that starts with '/'.) 254 */ 255 if (filename[0] != '/' && *p == '/') 256 *p = '\0'; 257 258 /* 259 * '//' is the GNU filename table. 260 * Later entries can refer to names in this table. 261 */ 262 if (strcmp(filename, "//") == 0) { 263 /* This must come before any call to _read_ahead. */ 264 ar_parse_common_header(ar, entry, h); 265 archive_entry_copy_pathname(entry, filename); 266 archive_entry_set_filetype(entry, AE_IFREG); 267 /* Get the size of the filename table. */ 268 number = ar_atol10(h + AR_size_offset, AR_size_size); 269 if (number > SIZE_MAX) { 270 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 271 "Filename table too large"); 272 return (ARCHIVE_FATAL); 273 } 274 entry_size = (size_t)number; 275 if (entry_size == 0) { 276 archive_set_error(&a->archive, EINVAL, 277 "Invalid string table"); 278 return (ARCHIVE_WARN); 279 } 280 if (ar->strtab != NULL) { 281 archive_set_error(&a->archive, EINVAL, 282 "More than one string tables exist"); 283 return (ARCHIVE_WARN); 284 } 285 286 /* Read the filename table into memory. */ 287 st = malloc(entry_size); 288 if (st == NULL) { 289 archive_set_error(&a->archive, ENOMEM, 290 "Can't allocate filename table buffer"); 291 return (ARCHIVE_FATAL); 292 } 293 ar->strtab = st; 294 ar->strtab_size = entry_size; 295 if ((b = __archive_read_ahead(a, entry_size, NULL)) == NULL) 296 return (ARCHIVE_FATAL); 297 memcpy(st, b, entry_size); 298 __archive_read_consume(a, entry_size); 299 /* All contents are consumed. */ 300 ar->entry_bytes_remaining = 0; 301 archive_entry_set_size(entry, ar->entry_bytes_remaining); 302 303 /* Parse the filename table. */ 304 return (ar_parse_gnu_filename_table(a)); 305 } 306 307 /* 308 * GNU variant handles long filenames by storing /<number> 309 * to indicate a name stored in the filename table. 310 * XXX TODO: Verify that it's all digits... Don't be fooled 311 * by "/9xyz" XXX 312 */ 313 if (filename[0] == '/' && filename[1] >= '0' && filename[1] <= '9') { 314 number = ar_atol10(h + AR_name_offset + 1, AR_name_size - 1); 315 /* 316 * If we can't look up the real name, warn and return 317 * the entry with the wrong name. 318 */ 319 if (ar->strtab == NULL || number > ar->strtab_size) { 320 archive_set_error(&a->archive, EINVAL, 321 "Can't find long filename for entry"); 322 archive_entry_copy_pathname(entry, filename); 323 /* Parse the time, owner, mode, size fields. */ 324 ar_parse_common_header(ar, entry, h); 325 return (ARCHIVE_WARN); 326 } 327 328 archive_entry_copy_pathname(entry, &ar->strtab[(size_t)number]); 329 /* Parse the time, owner, mode, size fields. */ 330 return (ar_parse_common_header(ar, entry, h)); 331 } 332 333 /* 334 * BSD handles long filenames by storing "#1/" followed by the 335 * length of filename as a decimal number, then prepends the 336 * the filename to the file contents. 337 */ 338 if (strncmp(filename, "#1/", 3) == 0) { 339 /* Parse the time, owner, mode, size fields. */ 340 /* This must occur before _read_ahead is called again. */ 341 ar_parse_common_header(ar, entry, h); 342 343 /* Parse the size of the name, adjust the file size. */ 344 number = ar_atol10(h + AR_name_offset + 3, AR_name_size - 3); 345 bsd_name_length = (size_t)number; 346 /* Guard against the filename + trailing NUL 347 * overflowing a size_t and against the filename size 348 * being larger than the entire entry. */ 349 if (number > (uint64_t)(bsd_name_length + 1) 350 || (off_t)bsd_name_length > ar->entry_bytes_remaining) { 351 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 352 "Bad input file size"); 353 return (ARCHIVE_FATAL); 354 } 355 ar->entry_bytes_remaining -= bsd_name_length; 356 /* Adjust file size reported to client. */ 357 archive_entry_set_size(entry, ar->entry_bytes_remaining); 358 359 /* Read the long name into memory. */ 360 if ((b = __archive_read_ahead(a, bsd_name_length, NULL)) == NULL) { 361 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 362 "Truncated input file"); 363 return (ARCHIVE_FATAL); 364 } 365 __archive_read_consume(a, bsd_name_length); 366 367 /* Store it in the entry. */ 368 p = (char *)malloc(bsd_name_length + 1); 369 if (p == NULL) { 370 archive_set_error(&a->archive, ENOMEM, 371 "Can't allocate fname buffer"); 372 return (ARCHIVE_FATAL); 373 } 374 strncpy(p, b, bsd_name_length); 375 p[bsd_name_length] = '\0'; 376 archive_entry_copy_pathname(entry, p); 377 free(p); 378 return (ARCHIVE_OK); 379 } 380 381 /* 382 * "/" is the SVR4/GNU archive symbol table. 383 */ 384 if (strcmp(filename, "/") == 0) { 385 archive_entry_copy_pathname(entry, "/"); 386 /* Parse the time, owner, mode, size fields. */ 387 r = ar_parse_common_header(ar, entry, h); 388 /* Force the file type to a regular file. */ 389 archive_entry_set_filetype(entry, AE_IFREG); 390 return (r); 391 } 392 393 /* 394 * "__.SYMDEF" is a BSD archive symbol table. 395 */ 396 if (strcmp(filename, "__.SYMDEF") == 0) { 397 archive_entry_copy_pathname(entry, filename); 398 /* Parse the time, owner, mode, size fields. */ 399 return (ar_parse_common_header(ar, entry, h)); 400 } 401 402 /* 403 * Otherwise, this is a standard entry. The filename 404 * has already been trimmed as much as possible, based 405 * on our current knowledge of the format. 406 */ 407 archive_entry_copy_pathname(entry, filename); 408 return (ar_parse_common_header(ar, entry, h)); 409 } 410 411 static int 412 ar_parse_common_header(struct ar *ar, struct archive_entry *entry, 413 const char *h) 414 { 415 uint64_t n; 416 417 /* Copy remaining header */ 418 archive_entry_set_mtime(entry, 419 (time_t)ar_atol10(h + AR_date_offset, AR_date_size), 0L); 420 archive_entry_set_uid(entry, 421 (uid_t)ar_atol10(h + AR_uid_offset, AR_uid_size)); 422 archive_entry_set_gid(entry, 423 (gid_t)ar_atol10(h + AR_gid_offset, AR_gid_size)); 424 archive_entry_set_mode(entry, 425 (mode_t)ar_atol8(h + AR_mode_offset, AR_mode_size)); 426 n = ar_atol10(h + AR_size_offset, AR_size_size); 427 428 ar->entry_offset = 0; 429 ar->entry_padding = n % 2; 430 archive_entry_set_size(entry, n); 431 ar->entry_bytes_remaining = n; 432 return (ARCHIVE_OK); 433 } 434 435 static int 436 archive_read_format_ar_read_data(struct archive_read *a, 437 const void **buff, size_t *size, off_t *offset) 438 { 439 ssize_t bytes_read; 440 struct ar *ar; 441 442 ar = (struct ar *)(a->format->data); 443 444 if (ar->entry_bytes_remaining > 0) { 445 *buff = __archive_read_ahead(a, 1, &bytes_read); 446 if (bytes_read == 0) { 447 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 448 "Truncated ar archive"); 449 return (ARCHIVE_FATAL); 450 } 451 if (bytes_read < 0) 452 return (ARCHIVE_FATAL); 453 if (bytes_read > ar->entry_bytes_remaining) 454 bytes_read = (ssize_t)ar->entry_bytes_remaining; 455 *size = bytes_read; 456 *offset = ar->entry_offset; 457 ar->entry_offset += bytes_read; 458 ar->entry_bytes_remaining -= bytes_read; 459 __archive_read_consume(a, (size_t)bytes_read); 460 return (ARCHIVE_OK); 461 } else { 462 while (ar->entry_padding > 0) { 463 *buff = __archive_read_ahead(a, 1, &bytes_read); 464 if (bytes_read <= 0) 465 return (ARCHIVE_FATAL); 466 if (bytes_read > ar->entry_padding) 467 bytes_read = (ssize_t)ar->entry_padding; 468 __archive_read_consume(a, (size_t)bytes_read); 469 ar->entry_padding -= bytes_read; 470 } 471 *buff = NULL; 472 *size = 0; 473 *offset = ar->entry_offset; 474 return (ARCHIVE_EOF); 475 } 476 } 477 478 static int 479 archive_read_format_ar_skip(struct archive_read *a) 480 { 481 off_t bytes_skipped; 482 struct ar* ar; 483 484 ar = (struct ar *)(a->format->data); 485 486 bytes_skipped = __archive_read_skip(a, 487 ar->entry_bytes_remaining + ar->entry_padding); 488 if (bytes_skipped < 0) 489 return (ARCHIVE_FATAL); 490 491 ar->entry_bytes_remaining = 0; 492 ar->entry_padding = 0; 493 494 return (ARCHIVE_OK); 495 } 496 497 static int 498 ar_parse_gnu_filename_table(struct archive_read *a) 499 { 500 struct ar *ar; 501 char *p; 502 size_t size; 503 504 ar = (struct ar*)(a->format->data); 505 size = ar->strtab_size; 506 507 for (p = ar->strtab; p < ar->strtab + size - 1; ++p) { 508 if (*p == '/') { 509 *p++ = '\0'; 510 if (*p != '\n') 511 goto bad_string_table; 512 *p = '\0'; 513 } 514 } 515 /* 516 * GNU ar always pads the table to an even size. 517 * The pad character is either '\n' or '`'. 518 */ 519 if (p != ar->strtab + size && *p != '\n' && *p != '`') 520 goto bad_string_table; 521 522 /* Enforce zero termination. */ 523 ar->strtab[size - 1] = '\0'; 524 525 return (ARCHIVE_OK); 526 527 bad_string_table: 528 archive_set_error(&a->archive, EINVAL, 529 "Invalid string table"); 530 free(ar->strtab); 531 ar->strtab = NULL; 532 return (ARCHIVE_WARN); 533 } 534 535 static uint64_t 536 ar_atol8(const char *p, unsigned char_cnt) 537 { 538 uint64_t l, limit, last_digit_limit; 539 unsigned int digit, base; 540 541 base = 8; 542 limit = UINT64_MAX / base; 543 last_digit_limit = UINT64_MAX % base; 544 545 while ((*p == ' ' || *p == '\t') && char_cnt-- > 0) 546 p++; 547 548 l = 0; 549 digit = *p - '0'; 550 while (*p >= '0' && digit < base && char_cnt-- > 0) { 551 if (l>limit || (l == limit && digit > last_digit_limit)) { 552 l = UINT64_MAX; /* Truncate on overflow. */ 553 break; 554 } 555 l = (l * base) + digit; 556 digit = *++p - '0'; 557 } 558 return (l); 559 } 560 561 static uint64_t 562 ar_atol10(const char *p, unsigned char_cnt) 563 { 564 uint64_t l, limit, last_digit_limit; 565 unsigned int base, digit; 566 567 base = 10; 568 limit = UINT64_MAX / base; 569 last_digit_limit = UINT64_MAX % base; 570 571 while ((*p == ' ' || *p == '\t') && char_cnt-- > 0) 572 p++; 573 l = 0; 574 digit = *p - '0'; 575 while (*p >= '0' && digit < base && char_cnt-- > 0) { 576 if (l > limit || (l == limit && digit > last_digit_limit)) { 577 l = UINT64_MAX; /* Truncate on overflow. */ 578 break; 579 } 580 l = (l * base) + digit; 581 digit = *++p - '0'; 582 } 583 return (l); 584 } 585