archive_read_support_format_mtree.c revision 358088
1/*- 2 * Copyright (c) 2003-2007 Tim Kientzle 3 * Copyright (c) 2008 Joerg Sonnenberger 4 * Copyright (c) 2011-2012 Michihiro NAKAJIMA 5 * All rights reserved. 6 * 7 * Redistribution and use in source and binary forms, with or without 8 * modification, are permitted provided that the following conditions 9 * are met: 10 * 1. Redistributions of source code must retain the above copyright 11 * notice, this list of conditions and the following disclaimer. 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: stable/11/contrib/libarchive/libarchive/archive_read_support_format_mtree.c 358088 2020-02-19 01:50:47Z mm $"); 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_FCNTL_H 38#include <fcntl.h> 39#endif 40#include <stddef.h> 41/* #include <stdint.h> */ /* See archive_platform.h */ 42#ifdef HAVE_STDLIB_H 43#include <stdlib.h> 44#endif 45#ifdef HAVE_STRING_H 46#include <string.h> 47#endif 48#ifdef HAVE_CTYPE_H 49#include <ctype.h> 50#endif 51 52#include "archive.h" 53#include "archive_entry.h" 54#include "archive_private.h" 55#include "archive_rb.h" 56#include "archive_read_private.h" 57#include "archive_string.h" 58#include "archive_pack_dev.h" 59 60#ifndef O_BINARY 61#define O_BINARY 0 62#endif 63#ifndef O_CLOEXEC 64#define O_CLOEXEC 0 65#endif 66 67#define MTREE_HAS_DEVICE 0x0001 68#define MTREE_HAS_FFLAGS 0x0002 69#define MTREE_HAS_GID 0x0004 70#define MTREE_HAS_GNAME 0x0008 71#define MTREE_HAS_MTIME 0x0010 72#define MTREE_HAS_NLINK 0x0020 73#define MTREE_HAS_PERM 0x0040 74#define MTREE_HAS_SIZE 0x0080 75#define MTREE_HAS_TYPE 0x0100 76#define MTREE_HAS_UID 0x0200 77#define MTREE_HAS_UNAME 0x0400 78 79#define MTREE_HAS_OPTIONAL 0x0800 80#define MTREE_HAS_NOCHANGE 0x1000 /* FreeBSD specific */ 81 82#define MAX_LINE_LEN (1024 * 1024) 83 84struct mtree_option { 85 struct mtree_option *next; 86 char *value; 87}; 88 89struct mtree_entry { 90 struct archive_rb_node rbnode; 91 struct mtree_entry *next_dup; 92 struct mtree_entry *next; 93 struct mtree_option *options; 94 char *name; 95 char full; 96 char used; 97}; 98 99struct mtree { 100 struct archive_string line; 101 size_t buffsize; 102 char *buff; 103 int64_t offset; 104 int fd; 105 int archive_format; 106 const char *archive_format_name; 107 struct mtree_entry *entries; 108 struct mtree_entry *this_entry; 109 struct archive_rb_tree entry_rbtree; 110 struct archive_string current_dir; 111 struct archive_string contents_name; 112 113 struct archive_entry_linkresolver *resolver; 114 struct archive_rb_tree rbtree; 115 116 int64_t cur_size; 117 char checkfs; 118}; 119 120static int bid_keycmp(const char *, const char *, ssize_t); 121static int cleanup(struct archive_read *); 122static int detect_form(struct archive_read *, int *); 123static int mtree_bid(struct archive_read *, int); 124static int parse_file(struct archive_read *, struct archive_entry *, 125 struct mtree *, struct mtree_entry *, int *); 126static void parse_escapes(char *, struct mtree_entry *); 127static int parse_line(struct archive_read *, struct archive_entry *, 128 struct mtree *, struct mtree_entry *, int *); 129static int parse_keyword(struct archive_read *, struct mtree *, 130 struct archive_entry *, struct mtree_option *, int *); 131static int read_data(struct archive_read *a, 132 const void **buff, size_t *size, int64_t *offset); 133static ssize_t readline(struct archive_read *, struct mtree *, char **, ssize_t); 134static int skip(struct archive_read *a); 135static int read_header(struct archive_read *, 136 struct archive_entry *); 137static int64_t mtree_atol(char **, int base); 138 139/* 140 * There's no standard for TIME_T_MAX/TIME_T_MIN. So we compute them 141 * here. TODO: Move this to configure time, but be careful 142 * about cross-compile environments. 143 */ 144static int64_t 145get_time_t_max(void) 146{ 147#if defined(TIME_T_MAX) 148 return TIME_T_MAX; 149#else 150 /* ISO C allows time_t to be a floating-point type, 151 but POSIX requires an integer type. The following 152 should work on any system that follows the POSIX 153 conventions. */ 154 if (((time_t)0) < ((time_t)-1)) { 155 /* Time_t is unsigned */ 156 return (~(time_t)0); 157 } else { 158 /* Time_t is signed. */ 159 /* Assume it's the same as int64_t or int32_t */ 160 if (sizeof(time_t) == sizeof(int64_t)) { 161 return (time_t)INT64_MAX; 162 } else { 163 return (time_t)INT32_MAX; 164 } 165 } 166#endif 167} 168 169static int64_t 170get_time_t_min(void) 171{ 172#if defined(TIME_T_MIN) 173 return TIME_T_MIN; 174#else 175 if (((time_t)0) < ((time_t)-1)) { 176 /* Time_t is unsigned */ 177 return (time_t)0; 178 } else { 179 /* Time_t is signed. */ 180 if (sizeof(time_t) == sizeof(int64_t)) { 181 return (time_t)INT64_MIN; 182 } else { 183 return (time_t)INT32_MIN; 184 } 185 } 186#endif 187} 188 189static int 190archive_read_format_mtree_options(struct archive_read *a, 191 const char *key, const char *val) 192{ 193 struct mtree *mtree; 194 195 mtree = (struct mtree *)(a->format->data); 196 if (strcmp(key, "checkfs") == 0) { 197 /* Allows to read information missing from the mtree from the file system */ 198 if (val == NULL || val[0] == 0) { 199 mtree->checkfs = 0; 200 } else { 201 mtree->checkfs = 1; 202 } 203 return (ARCHIVE_OK); 204 } 205 206 /* Note: The "warn" return is just to inform the options 207 * supervisor that we didn't handle it. It will generate 208 * a suitable error if no one used this option. */ 209 return (ARCHIVE_WARN); 210} 211 212static void 213free_options(struct mtree_option *head) 214{ 215 struct mtree_option *next; 216 217 for (; head != NULL; head = next) { 218 next = head->next; 219 free(head->value); 220 free(head); 221 } 222} 223 224static int 225mtree_cmp_node(const struct archive_rb_node *n1, 226 const struct archive_rb_node *n2) 227{ 228 const struct mtree_entry *e1 = (const struct mtree_entry *)n1; 229 const struct mtree_entry *e2 = (const struct mtree_entry *)n2; 230 231 return (strcmp(e1->name, e2->name)); 232} 233 234static int 235mtree_cmp_key(const struct archive_rb_node *n, const void *key) 236{ 237 const struct mtree_entry *e = (const struct mtree_entry *)n; 238 239 return (strcmp(e->name, key)); 240} 241 242int 243archive_read_support_format_mtree(struct archive *_a) 244{ 245 static const struct archive_rb_tree_ops rb_ops = { 246 mtree_cmp_node, mtree_cmp_key, 247 }; 248 struct archive_read *a = (struct archive_read *)_a; 249 struct mtree *mtree; 250 int r; 251 252 archive_check_magic(_a, ARCHIVE_READ_MAGIC, 253 ARCHIVE_STATE_NEW, "archive_read_support_format_mtree"); 254 255 mtree = (struct mtree *)calloc(1, sizeof(*mtree)); 256 if (mtree == NULL) { 257 archive_set_error(&a->archive, ENOMEM, 258 "Can't allocate mtree data"); 259 return (ARCHIVE_FATAL); 260 } 261 mtree->checkfs = 0; 262 mtree->fd = -1; 263 264 __archive_rb_tree_init(&mtree->rbtree, &rb_ops); 265 266 r = __archive_read_register_format(a, mtree, "mtree", 267 mtree_bid, archive_read_format_mtree_options, read_header, read_data, skip, NULL, cleanup, NULL, NULL); 268 269 if (r != ARCHIVE_OK) 270 free(mtree); 271 return (ARCHIVE_OK); 272} 273 274static int 275cleanup(struct archive_read *a) 276{ 277 struct mtree *mtree; 278 struct mtree_entry *p, *q; 279 280 mtree = (struct mtree *)(a->format->data); 281 282 p = mtree->entries; 283 while (p != NULL) { 284 q = p->next; 285 free(p->name); 286 free_options(p->options); 287 free(p); 288 p = q; 289 } 290 archive_string_free(&mtree->line); 291 archive_string_free(&mtree->current_dir); 292 archive_string_free(&mtree->contents_name); 293 archive_entry_linkresolver_free(mtree->resolver); 294 295 free(mtree->buff); 296 free(mtree); 297 (a->format->data) = NULL; 298 return (ARCHIVE_OK); 299} 300 301static ssize_t 302get_line_size(const char *b, ssize_t avail, ssize_t *nlsize) 303{ 304 ssize_t len; 305 306 len = 0; 307 while (len < avail) { 308 switch (*b) { 309 case '\0':/* Non-ascii character or control character. */ 310 if (nlsize != NULL) 311 *nlsize = 0; 312 return (-1); 313 case '\r': 314 if (avail-len > 1 && b[1] == '\n') { 315 if (nlsize != NULL) 316 *nlsize = 2; 317 return (len+2); 318 } 319 /* FALL THROUGH */ 320 case '\n': 321 if (nlsize != NULL) 322 *nlsize = 1; 323 return (len+1); 324 default: 325 b++; 326 len++; 327 break; 328 } 329 } 330 if (nlsize != NULL) 331 *nlsize = 0; 332 return (avail); 333} 334 335/* 336 * <---------------- ravail ---------------------> 337 * <-- diff ------> <--- avail -----------------> 338 * <---- len -----------> 339 * | Previous lines | line being parsed nl extra | 340 * ^ 341 * b 342 * 343 */ 344static ssize_t 345next_line(struct archive_read *a, 346 const char **b, ssize_t *avail, ssize_t *ravail, ssize_t *nl) 347{ 348 ssize_t len; 349 int quit; 350 351 quit = 0; 352 if (*avail == 0) { 353 *nl = 0; 354 len = 0; 355 } else 356 len = get_line_size(*b, *avail, nl); 357 /* 358 * Read bytes more while it does not reach the end of line. 359 */ 360 while (*nl == 0 && len == *avail && !quit) { 361 ssize_t diff = *ravail - *avail; 362 size_t nbytes_req = (*ravail+1023) & ~1023U; 363 ssize_t tested; 364 365 /* 366 * Place an arbitrary limit on the line length. 367 * mtree is almost free-form input and without line length limits, 368 * it can consume a lot of memory. 369 */ 370 if (len >= MAX_LINE_LEN) 371 return (-1); 372 373 /* Increase reading bytes if it is not enough to at least 374 * new two lines. */ 375 if (nbytes_req < (size_t)*ravail + 160) 376 nbytes_req <<= 1; 377 378 *b = __archive_read_ahead(a, nbytes_req, avail); 379 if (*b == NULL) { 380 if (*ravail >= *avail) 381 return (0); 382 /* Reading bytes reaches the end of file. */ 383 *b = __archive_read_ahead(a, *avail, avail); 384 quit = 1; 385 } 386 *ravail = *avail; 387 *b += diff; 388 *avail -= diff; 389 tested = len;/* Skip some bytes we already determinated. */ 390 len = get_line_size(*b + len, *avail - len, nl); 391 if (len >= 0) 392 len += tested; 393 } 394 return (len); 395} 396 397/* 398 * Compare characters with a mtree keyword. 399 * Returns the length of a mtree keyword if matched. 400 * Returns 0 if not matched. 401 */ 402static int 403bid_keycmp(const char *p, const char *key, ssize_t len) 404{ 405 int match_len = 0; 406 407 while (len > 0 && *p && *key) { 408 if (*p == *key) { 409 --len; 410 ++p; 411 ++key; 412 ++match_len; 413 continue; 414 } 415 return (0);/* Not match */ 416 } 417 if (*key != '\0') 418 return (0);/* Not match */ 419 420 /* A following character should be specified characters */ 421 if (p[0] == '=' || p[0] == ' ' || p[0] == '\t' || 422 p[0] == '\n' || p[0] == '\r' || 423 (p[0] == '\\' && (p[1] == '\n' || p[1] == '\r'))) 424 return (match_len); 425 return (0);/* Not match */ 426} 427 428/* 429 * Test whether the characters 'p' has is mtree keyword. 430 * Returns the length of a detected keyword. 431 * Returns 0 if any keywords were not found. 432 */ 433static int 434bid_keyword(const char *p, ssize_t len) 435{ 436 static const char * const keys_c[] = { 437 "content", "contents", "cksum", NULL 438 }; 439 static const char * const keys_df[] = { 440 "device", "flags", NULL 441 }; 442 static const char * const keys_g[] = { 443 "gid", "gname", NULL 444 }; 445 static const char * const keys_il[] = { 446 "ignore", "inode", "link", NULL 447 }; 448 static const char * const keys_m[] = { 449 "md5", "md5digest", "mode", NULL 450 }; 451 static const char * const keys_no[] = { 452 "nlink", "nochange", "optional", NULL 453 }; 454 static const char * const keys_r[] = { 455 "resdevice", "rmd160", "rmd160digest", NULL 456 }; 457 static const char * const keys_s[] = { 458 "sha1", "sha1digest", 459 "sha256", "sha256digest", 460 "sha384", "sha384digest", 461 "sha512", "sha512digest", 462 "size", NULL 463 }; 464 static const char * const keys_t[] = { 465 "tags", "time", "type", NULL 466 }; 467 static const char * const keys_u[] = { 468 "uid", "uname", NULL 469 }; 470 const char * const *keys; 471 int i; 472 473 switch (*p) { 474 case 'c': keys = keys_c; break; 475 case 'd': case 'f': keys = keys_df; break; 476 case 'g': keys = keys_g; break; 477 case 'i': case 'l': keys = keys_il; break; 478 case 'm': keys = keys_m; break; 479 case 'n': case 'o': keys = keys_no; break; 480 case 'r': keys = keys_r; break; 481 case 's': keys = keys_s; break; 482 case 't': keys = keys_t; break; 483 case 'u': keys = keys_u; break; 484 default: return (0);/* Unknown key */ 485 } 486 487 for (i = 0; keys[i] != NULL; i++) { 488 int l = bid_keycmp(p, keys[i], len); 489 if (l > 0) 490 return (l); 491 } 492 return (0);/* Unknown key */ 493} 494 495/* 496 * Test whether there is a set of mtree keywords. 497 * Returns the number of keyword. 498 * Returns -1 if we got incorrect sequence. 499 * This function expects a set of "<space characters>keyword=value". 500 * When "unset" is specified, expects a set of "<space characters>keyword". 501 */ 502static int 503bid_keyword_list(const char *p, ssize_t len, int unset, int last_is_path) 504{ 505 int l; 506 int keycnt = 0; 507 508 while (len > 0 && *p) { 509 int blank = 0; 510 511 /* Test whether there are blank characters in the line. */ 512 while (len >0 && (*p == ' ' || *p == '\t')) { 513 ++p; 514 --len; 515 blank = 1; 516 } 517 if (*p == '\n' || *p == '\r') 518 break; 519 if (p[0] == '\\' && (p[1] == '\n' || p[1] == '\r')) 520 break; 521 if (!blank && !last_is_path) /* No blank character. */ 522 return (-1); 523 if (last_is_path && len == 0) 524 return (keycnt); 525 526 if (unset) { 527 l = bid_keycmp(p, "all", len); 528 if (l > 0) 529 return (1); 530 } 531 /* Test whether there is a correct key in the line. */ 532 l = bid_keyword(p, len); 533 if (l == 0) 534 return (-1);/* Unknown keyword was found. */ 535 p += l; 536 len -= l; 537 keycnt++; 538 539 /* Skip value */ 540 if (*p == '=') { 541 int value = 0; 542 ++p; 543 --len; 544 while (len > 0 && *p != ' ' && *p != '\t') { 545 ++p; 546 --len; 547 value = 1; 548 } 549 /* A keyword should have a its value unless 550 * "/unset" operation. */ 551 if (!unset && value == 0) 552 return (-1); 553 } 554 } 555 return (keycnt); 556} 557 558static int 559bid_entry(const char *p, ssize_t len, ssize_t nl, int *last_is_path) 560{ 561 int f = 0; 562 static const unsigned char safe_char[256] = { 563 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 00 - 0F */ 564 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 - 1F */ 565 /* !"$%&'()*+,-./ EXCLUSION:( )(#) */ 566 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 20 - 2F */ 567 /* 0123456789:;<>? EXCLUSION:(=) */ 568 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, /* 30 - 3F */ 569 /* @ABCDEFGHIJKLMNO */ 570 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 40 - 4F */ 571 /* PQRSTUVWXYZ[\]^_ */ 572 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 50 - 5F */ 573 /* `abcdefghijklmno */ 574 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 60 - 6F */ 575 /* pqrstuvwxyz{|}~ */ 576 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, /* 70 - 7F */ 577 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 - 8F */ 578 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 90 - 9F */ 579 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* A0 - AF */ 580 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* B0 - BF */ 581 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* C0 - CF */ 582 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* D0 - DF */ 583 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* E0 - EF */ 584 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* F0 - FF */ 585 }; 586 ssize_t ll; 587 const char *pp = p; 588 const char * const pp_end = pp + len; 589 590 *last_is_path = 0; 591 /* 592 * Skip the path-name which is quoted. 593 */ 594 for (;pp < pp_end; ++pp) { 595 if (!safe_char[*(const unsigned char *)pp]) { 596 if (*pp != ' ' && *pp != '\t' && *pp != '\r' 597 && *pp != '\n') 598 f = 0; 599 break; 600 } 601 f = 1; 602 } 603 ll = pp_end - pp; 604 605 /* If a path-name was not found at the first, try to check 606 * a mtree format(a.k.a form D) ``NetBSD's mtree -D'' creates, 607 * which places the path-name at the last. */ 608 if (f == 0) { 609 const char *pb = p + len - nl; 610 int name_len = 0; 611 int slash; 612 613 /* The form D accepts only a single line for an entry. */ 614 if (pb-2 >= p && 615 pb[-1] == '\\' && (pb[-2] == ' ' || pb[-2] == '\t')) 616 return (-1); 617 if (pb-1 >= p && pb[-1] == '\\') 618 return (-1); 619 620 slash = 0; 621 while (p <= --pb && *pb != ' ' && *pb != '\t') { 622 if (!safe_char[*(const unsigned char *)pb]) 623 return (-1); 624 name_len++; 625 /* The pathname should have a slash in this 626 * format. */ 627 if (*pb == '/') 628 slash = 1; 629 } 630 if (name_len == 0 || slash == 0) 631 return (-1); 632 /* If '/' is placed at the first in this field, this is not 633 * a valid filename. */ 634 if (pb[1] == '/') 635 return (-1); 636 ll = len - nl - name_len; 637 pp = p; 638 *last_is_path = 1; 639 } 640 641 return (bid_keyword_list(pp, ll, 0, *last_is_path)); 642} 643 644#define MAX_BID_ENTRY 3 645 646static int 647mtree_bid(struct archive_read *a, int best_bid) 648{ 649 const char *signature = "#mtree"; 650 const char *p; 651 652 (void)best_bid; /* UNUSED */ 653 654 /* Now let's look at the actual header and see if it matches. */ 655 p = __archive_read_ahead(a, strlen(signature), NULL); 656 if (p == NULL) 657 return (-1); 658 659 if (memcmp(p, signature, strlen(signature)) == 0) 660 return (8 * (int)strlen(signature)); 661 662 /* 663 * There is not a mtree signature. Let's try to detect mtree format. 664 */ 665 return (detect_form(a, NULL)); 666} 667 668static int 669detect_form(struct archive_read *a, int *is_form_d) 670{ 671 const char *p; 672 ssize_t avail, ravail; 673 ssize_t detected_bytes = 0, len, nl; 674 int entry_cnt = 0, multiline = 0; 675 int form_D = 0;/* The archive is generated by `NetBSD mtree -D' 676 * (In this source we call it `form D') . */ 677 678 if (is_form_d != NULL) 679 *is_form_d = 0; 680 p = __archive_read_ahead(a, 1, &avail); 681 if (p == NULL) 682 return (-1); 683 ravail = avail; 684 for (;;) { 685 len = next_line(a, &p, &avail, &ravail, &nl); 686 /* The terminal character of the line should be 687 * a new line character, '\r\n' or '\n'. */ 688 if (len <= 0 || nl == 0) 689 break; 690 if (!multiline) { 691 /* Leading whitespace is never significant, 692 * ignore it. */ 693 while (len > 0 && (*p == ' ' || *p == '\t')) { 694 ++p; 695 --avail; 696 --len; 697 } 698 /* Skip comment or empty line. */ 699 if (p[0] == '#' || p[0] == '\n' || p[0] == '\r') { 700 p += len; 701 avail -= len; 702 continue; 703 } 704 } else { 705 /* A continuance line; the terminal 706 * character of previous line was '\' character. */ 707 if (bid_keyword_list(p, len, 0, 0) <= 0) 708 break; 709 if (multiline == 1) 710 detected_bytes += len; 711 if (p[len-nl-1] != '\\') { 712 if (multiline == 1 && 713 ++entry_cnt >= MAX_BID_ENTRY) 714 break; 715 multiline = 0; 716 } 717 p += len; 718 avail -= len; 719 continue; 720 } 721 if (p[0] != '/') { 722 int last_is_path, keywords; 723 724 keywords = bid_entry(p, len, nl, &last_is_path); 725 if (keywords >= 0) { 726 detected_bytes += len; 727 if (form_D == 0) { 728 if (last_is_path) 729 form_D = 1; 730 else if (keywords > 0) 731 /* This line is not `form D'. */ 732 form_D = -1; 733 } else if (form_D == 1) { 734 if (!last_is_path && keywords > 0) 735 /* This this is not `form D' 736 * and We cannot accept mixed 737 * format. */ 738 break; 739 } 740 if (!last_is_path && p[len-nl-1] == '\\') 741 /* This line continues. */ 742 multiline = 1; 743 else { 744 /* We've got plenty of correct lines 745 * to assume that this file is a mtree 746 * format. */ 747 if (++entry_cnt >= MAX_BID_ENTRY) 748 break; 749 } 750 } else 751 break; 752 } else if (len > 4 && strncmp(p, "/set", 4) == 0) { 753 if (bid_keyword_list(p+4, len-4, 0, 0) <= 0) 754 break; 755 /* This line continues. */ 756 if (p[len-nl-1] == '\\') 757 multiline = 2; 758 } else if (len > 6 && strncmp(p, "/unset", 6) == 0) { 759 if (bid_keyword_list(p+6, len-6, 1, 0) <= 0) 760 break; 761 /* This line continues. */ 762 if (p[len-nl-1] == '\\') 763 multiline = 2; 764 } else 765 break; 766 767 /* Test next line. */ 768 p += len; 769 avail -= len; 770 } 771 if (entry_cnt >= MAX_BID_ENTRY || (entry_cnt > 0 && len == 0)) { 772 if (is_form_d != NULL) { 773 if (form_D == 1) 774 *is_form_d = 1; 775 } 776 return (32); 777 } 778 779 return (0); 780} 781 782/* 783 * The extended mtree format permits multiple lines specifying 784 * attributes for each file. For those entries, only the last line 785 * is actually used. Practically speaking, that means we have 786 * to read the entire mtree file into memory up front. 787 * 788 * The parsing is done in two steps. First, it is decided if a line 789 * changes the global defaults and if it is, processed accordingly. 790 * Otherwise, the options of the line are merged with the current 791 * global options. 792 */ 793static int 794add_option(struct archive_read *a, struct mtree_option **global, 795 const char *value, size_t len) 796{ 797 struct mtree_option *opt; 798 799 if ((opt = malloc(sizeof(*opt))) == NULL) { 800 archive_set_error(&a->archive, errno, "Can't allocate memory"); 801 return (ARCHIVE_FATAL); 802 } 803 if ((opt->value = malloc(len + 1)) == NULL) { 804 free(opt); 805 archive_set_error(&a->archive, errno, "Can't allocate memory"); 806 return (ARCHIVE_FATAL); 807 } 808 memcpy(opt->value, value, len); 809 opt->value[len] = '\0'; 810 opt->next = *global; 811 *global = opt; 812 return (ARCHIVE_OK); 813} 814 815static void 816remove_option(struct mtree_option **global, const char *value, size_t len) 817{ 818 struct mtree_option *iter, *last; 819 820 last = NULL; 821 for (iter = *global; iter != NULL; last = iter, iter = iter->next) { 822 if (strncmp(iter->value, value, len) == 0 && 823 (iter->value[len] == '\0' || 824 iter->value[len] == '=')) 825 break; 826 } 827 if (iter == NULL) 828 return; 829 if (last == NULL) 830 *global = iter->next; 831 else 832 last->next = iter->next; 833 834 free(iter->value); 835 free(iter); 836} 837 838static int 839process_global_set(struct archive_read *a, 840 struct mtree_option **global, const char *line) 841{ 842 const char *next, *eq; 843 size_t len; 844 int r; 845 846 line += 4; 847 for (;;) { 848 next = line + strspn(line, " \t\r\n"); 849 if (*next == '\0') 850 return (ARCHIVE_OK); 851 line = next; 852 next = line + strcspn(line, " \t\r\n"); 853 eq = strchr(line, '='); 854 if (eq > next) 855 len = next - line; 856 else 857 len = eq - line; 858 859 remove_option(global, line, len); 860 r = add_option(a, global, line, next - line); 861 if (r != ARCHIVE_OK) 862 return (r); 863 line = next; 864 } 865} 866 867static int 868process_global_unset(struct archive_read *a, 869 struct mtree_option **global, const char *line) 870{ 871 const char *next; 872 size_t len; 873 874 line += 6; 875 if (strchr(line, '=') != NULL) { 876 archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, 877 "/unset shall not contain `='"); 878 return ARCHIVE_FATAL; 879 } 880 881 for (;;) { 882 next = line + strspn(line, " \t\r\n"); 883 if (*next == '\0') 884 return (ARCHIVE_OK); 885 line = next; 886 len = strcspn(line, " \t\r\n"); 887 888 if (len == 3 && strncmp(line, "all", 3) == 0) { 889 free_options(*global); 890 *global = NULL; 891 } else { 892 remove_option(global, line, len); 893 } 894 895 line += len; 896 } 897} 898 899static int 900process_add_entry(struct archive_read *a, struct mtree *mtree, 901 struct mtree_option **global, const char *line, ssize_t line_len, 902 struct mtree_entry **last_entry, int is_form_d) 903{ 904 struct mtree_entry *entry; 905 struct mtree_option *iter; 906 const char *next, *eq, *name, *end; 907 size_t name_len, len; 908 int r, i; 909 910 if ((entry = malloc(sizeof(*entry))) == NULL) { 911 archive_set_error(&a->archive, errno, "Can't allocate memory"); 912 return (ARCHIVE_FATAL); 913 } 914 entry->next = NULL; 915 entry->options = NULL; 916 entry->name = NULL; 917 entry->used = 0; 918 entry->full = 0; 919 920 /* Add this entry to list. */ 921 if (*last_entry == NULL) 922 mtree->entries = entry; 923 else 924 (*last_entry)->next = entry; 925 *last_entry = entry; 926 927 if (is_form_d) { 928 /* Filename is last item on line. */ 929 /* Adjust line_len to trim trailing whitespace */ 930 while (line_len > 0) { 931 char last_character = line[line_len - 1]; 932 if (last_character == '\r' 933 || last_character == '\n' 934 || last_character == '\t' 935 || last_character == ' ') { 936 line_len--; 937 } else { 938 break; 939 } 940 } 941 /* Name starts after the last whitespace separator */ 942 name = line; 943 for (i = 0; i < line_len; i++) { 944 if (line[i] == '\r' 945 || line[i] == '\n' 946 || line[i] == '\t' 947 || line[i] == ' ') { 948 name = line + i + 1; 949 } 950 } 951 name_len = line + line_len - name; 952 end = name; 953 } else { 954 /* Filename is first item on line */ 955 name_len = strcspn(line, " \t\r\n"); 956 name = line; 957 line += name_len; 958 end = line + line_len; 959 } 960 /* name/name_len is the name within the line. */ 961 /* line..end brackets the entire line except the name */ 962 963 if ((entry->name = malloc(name_len + 1)) == NULL) { 964 archive_set_error(&a->archive, errno, "Can't allocate memory"); 965 return (ARCHIVE_FATAL); 966 } 967 968 memcpy(entry->name, name, name_len); 969 entry->name[name_len] = '\0'; 970 parse_escapes(entry->name, entry); 971 972 entry->next_dup = NULL; 973 if (entry->full) { 974 if (!__archive_rb_tree_insert_node(&mtree->rbtree, &entry->rbnode)) { 975 struct mtree_entry *alt; 976 alt = (struct mtree_entry *)__archive_rb_tree_find_node( 977 &mtree->rbtree, entry->name); 978 while (alt->next_dup) 979 alt = alt->next_dup; 980 alt->next_dup = entry; 981 } 982 } 983 984 for (iter = *global; iter != NULL; iter = iter->next) { 985 r = add_option(a, &entry->options, iter->value, 986 strlen(iter->value)); 987 if (r != ARCHIVE_OK) 988 return (r); 989 } 990 991 for (;;) { 992 next = line + strspn(line, " \t\r\n"); 993 if (*next == '\0') 994 return (ARCHIVE_OK); 995 if (next >= end) 996 return (ARCHIVE_OK); 997 line = next; 998 next = line + strcspn(line, " \t\r\n"); 999 eq = strchr(line, '='); 1000 if (eq == NULL || eq > next) 1001 len = next - line; 1002 else 1003 len = eq - line; 1004 1005 remove_option(&entry->options, line, len); 1006 r = add_option(a, &entry->options, line, next - line); 1007 if (r != ARCHIVE_OK) 1008 return (r); 1009 line = next; 1010 } 1011} 1012 1013static int 1014read_mtree(struct archive_read *a, struct mtree *mtree) 1015{ 1016 ssize_t len; 1017 uintmax_t counter; 1018 char *p, *s; 1019 struct mtree_option *global; 1020 struct mtree_entry *last_entry; 1021 int r, is_form_d; 1022 1023 mtree->archive_format = ARCHIVE_FORMAT_MTREE; 1024 mtree->archive_format_name = "mtree"; 1025 1026 global = NULL; 1027 last_entry = NULL; 1028 1029 (void)detect_form(a, &is_form_d); 1030 1031 for (counter = 1; ; ++counter) { 1032 r = ARCHIVE_OK; 1033 len = readline(a, mtree, &p, 65536); 1034 if (len == 0) { 1035 mtree->this_entry = mtree->entries; 1036 free_options(global); 1037 return (ARCHIVE_OK); 1038 } 1039 if (len < 0) { 1040 free_options(global); 1041 return ((int)len); 1042 } 1043 /* Leading whitespace is never significant, ignore it. */ 1044 while (*p == ' ' || *p == '\t') { 1045 ++p; 1046 --len; 1047 } 1048 /* Skip content lines and blank lines. */ 1049 if (*p == '#') 1050 continue; 1051 if (*p == '\r' || *p == '\n' || *p == '\0') 1052 continue; 1053 /* Non-printable characters are not allowed */ 1054 for (s = p;s < p + len - 1; s++) { 1055 if (!isprint(*s)) { 1056 r = ARCHIVE_FATAL; 1057 break; 1058 } 1059 } 1060 if (r != ARCHIVE_OK) 1061 break; 1062 if (*p != '/') { 1063 r = process_add_entry(a, mtree, &global, p, len, 1064 &last_entry, is_form_d); 1065 } else if (len > 4 && strncmp(p, "/set", 4) == 0) { 1066 if (p[4] != ' ' && p[4] != '\t') 1067 break; 1068 r = process_global_set(a, &global, p); 1069 } else if (len > 6 && strncmp(p, "/unset", 6) == 0) { 1070 if (p[6] != ' ' && p[6] != '\t') 1071 break; 1072 r = process_global_unset(a, &global, p); 1073 } else 1074 break; 1075 1076 if (r != ARCHIVE_OK) { 1077 free_options(global); 1078 return r; 1079 } 1080 } 1081 1082 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1083 "Can't parse line %ju", counter); 1084 free_options(global); 1085 return (ARCHIVE_FATAL); 1086} 1087 1088/* 1089 * Read in the entire mtree file into memory on the first request. 1090 * Then use the next unused file to satisfy each header request. 1091 */ 1092static int 1093read_header(struct archive_read *a, struct archive_entry *entry) 1094{ 1095 struct mtree *mtree; 1096 char *p; 1097 int r, use_next; 1098 1099 mtree = (struct mtree *)(a->format->data); 1100 1101 if (mtree->fd >= 0) { 1102 close(mtree->fd); 1103 mtree->fd = -1; 1104 } 1105 1106 if (mtree->entries == NULL) { 1107 mtree->resolver = archive_entry_linkresolver_new(); 1108 if (mtree->resolver == NULL) 1109 return ARCHIVE_FATAL; 1110 archive_entry_linkresolver_set_strategy(mtree->resolver, 1111 ARCHIVE_FORMAT_MTREE); 1112 r = read_mtree(a, mtree); 1113 if (r != ARCHIVE_OK) 1114 return (r); 1115 } 1116 1117 a->archive.archive_format = mtree->archive_format; 1118 a->archive.archive_format_name = mtree->archive_format_name; 1119 1120 for (;;) { 1121 if (mtree->this_entry == NULL) 1122 return (ARCHIVE_EOF); 1123 if (strcmp(mtree->this_entry->name, "..") == 0) { 1124 mtree->this_entry->used = 1; 1125 if (archive_strlen(&mtree->current_dir) > 0) { 1126 /* Roll back current path. */ 1127 p = mtree->current_dir.s 1128 + mtree->current_dir.length - 1; 1129 while (p >= mtree->current_dir.s && *p != '/') 1130 --p; 1131 if (p >= mtree->current_dir.s) 1132 --p; 1133 mtree->current_dir.length 1134 = p - mtree->current_dir.s + 1; 1135 } 1136 } 1137 if (!mtree->this_entry->used) { 1138 use_next = 0; 1139 r = parse_file(a, entry, mtree, mtree->this_entry, 1140 &use_next); 1141 if (use_next == 0) 1142 return (r); 1143 } 1144 mtree->this_entry = mtree->this_entry->next; 1145 } 1146} 1147 1148/* 1149 * A single file can have multiple lines contribute specifications. 1150 * Parse as many lines as necessary, then pull additional information 1151 * from a backing file on disk as necessary. 1152 */ 1153static int 1154parse_file(struct archive_read *a, struct archive_entry *entry, 1155 struct mtree *mtree, struct mtree_entry *mentry, int *use_next) 1156{ 1157 const char *path; 1158 struct stat st_storage, *st; 1159 struct mtree_entry *mp; 1160 struct archive_entry *sparse_entry; 1161 int r = ARCHIVE_OK, r1, parsed_kws; 1162 1163 mentry->used = 1; 1164 1165 /* Initialize reasonable defaults. */ 1166 archive_entry_set_filetype(entry, AE_IFREG); 1167 archive_entry_set_size(entry, 0); 1168 archive_string_empty(&mtree->contents_name); 1169 1170 /* Parse options from this line. */ 1171 parsed_kws = 0; 1172 r = parse_line(a, entry, mtree, mentry, &parsed_kws); 1173 1174 if (mentry->full) { 1175 archive_entry_copy_pathname(entry, mentry->name); 1176 /* 1177 * "Full" entries are allowed to have multiple lines 1178 * and those lines aren't required to be adjacent. We 1179 * don't support multiple lines for "relative" entries 1180 * nor do we make any attempt to merge data from 1181 * separate "relative" and "full" entries. (Merging 1182 * "relative" and "full" entries would require dealing 1183 * with pathname canonicalization, which is a very 1184 * tricky subject.) 1185 */ 1186 mp = (struct mtree_entry *)__archive_rb_tree_find_node( 1187 &mtree->rbtree, mentry->name); 1188 for (; mp; mp = mp->next_dup) { 1189 if (mp->full && !mp->used) { 1190 /* Later lines override earlier ones. */ 1191 mp->used = 1; 1192 r1 = parse_line(a, entry, mtree, mp, &parsed_kws); 1193 if (r1 < r) 1194 r = r1; 1195 } 1196 } 1197 } else { 1198 /* 1199 * Relative entries require us to construct 1200 * the full path and possibly update the 1201 * current directory. 1202 */ 1203 size_t n = archive_strlen(&mtree->current_dir); 1204 if (n > 0) 1205 archive_strcat(&mtree->current_dir, "/"); 1206 archive_strcat(&mtree->current_dir, mentry->name); 1207 archive_entry_copy_pathname(entry, mtree->current_dir.s); 1208 if (archive_entry_filetype(entry) != AE_IFDIR) 1209 mtree->current_dir.length = n; 1210 } 1211 1212 if (mtree->checkfs) { 1213 /* 1214 * Try to open and stat the file to get the real size 1215 * and other file info. It would be nice to avoid 1216 * this here so that getting a listing of an mtree 1217 * wouldn't require opening every referenced contents 1218 * file. But then we wouldn't know the actual 1219 * contents size, so I don't see a really viable way 1220 * around this. (Also, we may want to someday pull 1221 * other unspecified info from the contents file on 1222 * disk.) 1223 */ 1224 mtree->fd = -1; 1225 if (archive_strlen(&mtree->contents_name) > 0) 1226 path = mtree->contents_name.s; 1227 else 1228 path = archive_entry_pathname(entry); 1229 1230 if (archive_entry_filetype(entry) == AE_IFREG || 1231 archive_entry_filetype(entry) == AE_IFDIR) { 1232 mtree->fd = open(path, O_RDONLY | O_BINARY | O_CLOEXEC); 1233 __archive_ensure_cloexec_flag(mtree->fd); 1234 if (mtree->fd == -1 && 1235 (errno != ENOENT || 1236 archive_strlen(&mtree->contents_name) > 0)) { 1237 archive_set_error(&a->archive, errno, 1238 "Can't open %s", path); 1239 r = ARCHIVE_WARN; 1240 } 1241 } 1242 1243 st = &st_storage; 1244 if (mtree->fd >= 0) { 1245 if (fstat(mtree->fd, st) == -1) { 1246 archive_set_error(&a->archive, errno, 1247 "Could not fstat %s", path); 1248 r = ARCHIVE_WARN; 1249 /* If we can't stat it, don't keep it open. */ 1250 close(mtree->fd); 1251 mtree->fd = -1; 1252 st = NULL; 1253 } 1254 } else if (lstat(path, st) == -1) { 1255 st = NULL; 1256 } 1257 1258 /* 1259 * Check for a mismatch between the type in the specification 1260 * and the type of the contents object on disk. 1261 */ 1262 if (st != NULL) { 1263 if (((st->st_mode & S_IFMT) == S_IFREG && 1264 archive_entry_filetype(entry) == AE_IFREG) 1265#ifdef S_IFLNK 1266 ||((st->st_mode & S_IFMT) == S_IFLNK && 1267 archive_entry_filetype(entry) == AE_IFLNK) 1268#endif 1269#ifdef S_IFSOCK 1270 ||((st->st_mode & S_IFSOCK) == S_IFSOCK && 1271 archive_entry_filetype(entry) == AE_IFSOCK) 1272#endif 1273#ifdef S_IFCHR 1274 ||((st->st_mode & S_IFMT) == S_IFCHR && 1275 archive_entry_filetype(entry) == AE_IFCHR) 1276#endif 1277#ifdef S_IFBLK 1278 ||((st->st_mode & S_IFMT) == S_IFBLK && 1279 archive_entry_filetype(entry) == AE_IFBLK) 1280#endif 1281 ||((st->st_mode & S_IFMT) == S_IFDIR && 1282 archive_entry_filetype(entry) == AE_IFDIR) 1283#ifdef S_IFIFO 1284 ||((st->st_mode & S_IFMT) == S_IFIFO && 1285 archive_entry_filetype(entry) == AE_IFIFO) 1286#endif 1287 ) { 1288 /* Types match. */ 1289 } else { 1290 /* Types don't match; bail out gracefully. */ 1291 if (mtree->fd >= 0) 1292 close(mtree->fd); 1293 mtree->fd = -1; 1294 if (parsed_kws & MTREE_HAS_OPTIONAL) { 1295 /* It's not an error for an optional 1296 * entry to not match disk. */ 1297 *use_next = 1; 1298 } else if (r == ARCHIVE_OK) { 1299 archive_set_error(&a->archive, 1300 ARCHIVE_ERRNO_MISC, 1301 "mtree specification has different" 1302 " type for %s", 1303 archive_entry_pathname(entry)); 1304 r = ARCHIVE_WARN; 1305 } 1306 return (r); 1307 } 1308 } 1309 1310 /* 1311 * If there is a contents file on disk, pick some of the 1312 * metadata from that file. For most of these, we only 1313 * set it from the contents if it wasn't already parsed 1314 * from the specification. 1315 */ 1316 if (st != NULL) { 1317 if (((parsed_kws & MTREE_HAS_DEVICE) == 0 || 1318 (parsed_kws & MTREE_HAS_NOCHANGE) != 0) && 1319 (archive_entry_filetype(entry) == AE_IFCHR || 1320 archive_entry_filetype(entry) == AE_IFBLK)) 1321 archive_entry_set_rdev(entry, st->st_rdev); 1322 if ((parsed_kws & (MTREE_HAS_GID | MTREE_HAS_GNAME)) 1323 == 0 || 1324 (parsed_kws & MTREE_HAS_NOCHANGE) != 0) 1325 archive_entry_set_gid(entry, st->st_gid); 1326 if ((parsed_kws & (MTREE_HAS_UID | MTREE_HAS_UNAME)) 1327 == 0 || 1328 (parsed_kws & MTREE_HAS_NOCHANGE) != 0) 1329 archive_entry_set_uid(entry, st->st_uid); 1330 if ((parsed_kws & MTREE_HAS_MTIME) == 0 || 1331 (parsed_kws & MTREE_HAS_NOCHANGE) != 0) { 1332#if HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC 1333 archive_entry_set_mtime(entry, st->st_mtime, 1334 st->st_mtimespec.tv_nsec); 1335#elif HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC 1336 archive_entry_set_mtime(entry, st->st_mtime, 1337 st->st_mtim.tv_nsec); 1338#elif HAVE_STRUCT_STAT_ST_MTIME_N 1339 archive_entry_set_mtime(entry, st->st_mtime, 1340 st->st_mtime_n); 1341#elif HAVE_STRUCT_STAT_ST_UMTIME 1342 archive_entry_set_mtime(entry, st->st_mtime, 1343 st->st_umtime*1000); 1344#elif HAVE_STRUCT_STAT_ST_MTIME_USEC 1345 archive_entry_set_mtime(entry, st->st_mtime, 1346 st->st_mtime_usec*1000); 1347#else 1348 archive_entry_set_mtime(entry, st->st_mtime, 0); 1349#endif 1350 } 1351 if ((parsed_kws & MTREE_HAS_NLINK) == 0 || 1352 (parsed_kws & MTREE_HAS_NOCHANGE) != 0) 1353 archive_entry_set_nlink(entry, st->st_nlink); 1354 if ((parsed_kws & MTREE_HAS_PERM) == 0 || 1355 (parsed_kws & MTREE_HAS_NOCHANGE) != 0) 1356 archive_entry_set_perm(entry, st->st_mode); 1357 if ((parsed_kws & MTREE_HAS_SIZE) == 0 || 1358 (parsed_kws & MTREE_HAS_NOCHANGE) != 0) 1359 archive_entry_set_size(entry, st->st_size); 1360 archive_entry_set_ino(entry, st->st_ino); 1361 archive_entry_set_dev(entry, st->st_dev); 1362 1363 archive_entry_linkify(mtree->resolver, &entry, 1364 &sparse_entry); 1365 } else if (parsed_kws & MTREE_HAS_OPTIONAL) { 1366 /* 1367 * Couldn't open the entry, stat it or the on-disk type 1368 * didn't match. If this entry is optional, just 1369 * ignore it and read the next header entry. 1370 */ 1371 *use_next = 1; 1372 return ARCHIVE_OK; 1373 } 1374 } 1375 1376 mtree->cur_size = archive_entry_size(entry); 1377 mtree->offset = 0; 1378 1379 return r; 1380} 1381 1382/* 1383 * Each line contains a sequence of keywords. 1384 */ 1385static int 1386parse_line(struct archive_read *a, struct archive_entry *entry, 1387 struct mtree *mtree, struct mtree_entry *mp, int *parsed_kws) 1388{ 1389 struct mtree_option *iter; 1390 int r = ARCHIVE_OK, r1; 1391 1392 for (iter = mp->options; iter != NULL; iter = iter->next) { 1393 r1 = parse_keyword(a, mtree, entry, iter, parsed_kws); 1394 if (r1 < r) 1395 r = r1; 1396 } 1397 if (r == ARCHIVE_OK && (*parsed_kws & MTREE_HAS_TYPE) == 0) { 1398 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1399 "Missing type keyword in mtree specification"); 1400 return (ARCHIVE_WARN); 1401 } 1402 return (r); 1403} 1404 1405/* 1406 * Device entries have one of the following forms: 1407 * - raw dev_t 1408 * - format,major,minor[,subdevice] 1409 * When parsing succeeded, `pdev' will contain the appropriate dev_t value. 1410 */ 1411 1412/* strsep() is not in C90, but strcspn() is. */ 1413/* Taken from http://unixpapa.com/incnote/string.html */ 1414static char * 1415la_strsep(char **sp, const char *sep) 1416{ 1417 char *p, *s; 1418 if (sp == NULL || *sp == NULL || **sp == '\0') 1419 return(NULL); 1420 s = *sp; 1421 p = s + strcspn(s, sep); 1422 if (*p != '\0') 1423 *p++ = '\0'; 1424 *sp = p; 1425 return(s); 1426} 1427 1428static int 1429parse_device(dev_t *pdev, struct archive *a, char *val) 1430{ 1431#define MAX_PACK_ARGS 3 1432 unsigned long numbers[MAX_PACK_ARGS]; 1433 char *p, *dev; 1434 int argc; 1435 pack_t *pack; 1436 dev_t result; 1437 const char *error = NULL; 1438 1439 memset(pdev, 0, sizeof(*pdev)); 1440 if ((dev = strchr(val, ',')) != NULL) { 1441 /* 1442 * Device's major/minor are given in a specified format. 1443 * Decode and pack it accordingly. 1444 */ 1445 *dev++ = '\0'; 1446 if ((pack = pack_find(val)) == NULL) { 1447 archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, 1448 "Unknown format `%s'", val); 1449 return ARCHIVE_WARN; 1450 } 1451 argc = 0; 1452 while ((p = la_strsep(&dev, ",")) != NULL) { 1453 if (*p == '\0') { 1454 archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, 1455 "Missing number"); 1456 return ARCHIVE_WARN; 1457 } 1458 if (argc >= MAX_PACK_ARGS) { 1459 archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, 1460 "Too many arguments"); 1461 return ARCHIVE_WARN; 1462 } 1463 numbers[argc++] = (unsigned long)mtree_atol(&p, 0); 1464 } 1465 if (argc < 2) { 1466 archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, 1467 "Not enough arguments"); 1468 return ARCHIVE_WARN; 1469 } 1470 result = (*pack)(argc, numbers, &error); 1471 if (error != NULL) { 1472 archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, 1473 "%s", error); 1474 return ARCHIVE_WARN; 1475 } 1476 } else { 1477 /* file system raw value. */ 1478 result = (dev_t)mtree_atol(&val, 0); 1479 } 1480 *pdev = result; 1481 return ARCHIVE_OK; 1482#undef MAX_PACK_ARGS 1483} 1484 1485/* 1486 * Parse a single keyword and its value. 1487 */ 1488static int 1489parse_keyword(struct archive_read *a, struct mtree *mtree, 1490 struct archive_entry *entry, struct mtree_option *opt, int *parsed_kws) 1491{ 1492 char *val, *key; 1493 1494 key = opt->value; 1495 1496 if (*key == '\0') 1497 return (ARCHIVE_OK); 1498 1499 if (strcmp(key, "nochange") == 0) { 1500 *parsed_kws |= MTREE_HAS_NOCHANGE; 1501 return (ARCHIVE_OK); 1502 } 1503 if (strcmp(key, "optional") == 0) { 1504 *parsed_kws |= MTREE_HAS_OPTIONAL; 1505 return (ARCHIVE_OK); 1506 } 1507 if (strcmp(key, "ignore") == 0) { 1508 /* 1509 * The mtree processing is not recursive, so 1510 * recursion will only happen for explicitly listed 1511 * entries. 1512 */ 1513 return (ARCHIVE_OK); 1514 } 1515 1516 val = strchr(key, '='); 1517 if (val == NULL) { 1518 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1519 "Malformed attribute \"%s\" (%d)", key, key[0]); 1520 return (ARCHIVE_WARN); 1521 } 1522 1523 *val = '\0'; 1524 ++val; 1525 1526 switch (key[0]) { 1527 case 'c': 1528 if (strcmp(key, "content") == 0 1529 || strcmp(key, "contents") == 0) { 1530 parse_escapes(val, NULL); 1531 archive_strcpy(&mtree->contents_name, val); 1532 break; 1533 } 1534 if (strcmp(key, "cksum") == 0) 1535 break; 1536 __LA_FALLTHROUGH; 1537 case 'd': 1538 if (strcmp(key, "device") == 0) { 1539 /* stat(2) st_rdev field, e.g. the major/minor IDs 1540 * of a char/block special file */ 1541 int r; 1542 dev_t dev; 1543 1544 *parsed_kws |= MTREE_HAS_DEVICE; 1545 r = parse_device(&dev, &a->archive, val); 1546 if (r == ARCHIVE_OK) 1547 archive_entry_set_rdev(entry, dev); 1548 return r; 1549 } 1550 __LA_FALLTHROUGH; 1551 case 'f': 1552 if (strcmp(key, "flags") == 0) { 1553 *parsed_kws |= MTREE_HAS_FFLAGS; 1554 archive_entry_copy_fflags_text(entry, val); 1555 break; 1556 } 1557 __LA_FALLTHROUGH; 1558 case 'g': 1559 if (strcmp(key, "gid") == 0) { 1560 *parsed_kws |= MTREE_HAS_GID; 1561 archive_entry_set_gid(entry, mtree_atol(&val, 10)); 1562 break; 1563 } 1564 if (strcmp(key, "gname") == 0) { 1565 *parsed_kws |= MTREE_HAS_GNAME; 1566 archive_entry_copy_gname(entry, val); 1567 break; 1568 } 1569 __LA_FALLTHROUGH; 1570 case 'i': 1571 if (strcmp(key, "inode") == 0) { 1572 archive_entry_set_ino(entry, mtree_atol(&val, 10)); 1573 break; 1574 } 1575 __LA_FALLTHROUGH; 1576 case 'l': 1577 if (strcmp(key, "link") == 0) { 1578 archive_entry_copy_symlink(entry, val); 1579 break; 1580 } 1581 __LA_FALLTHROUGH; 1582 case 'm': 1583 if (strcmp(key, "md5") == 0 || strcmp(key, "md5digest") == 0) 1584 break; 1585 if (strcmp(key, "mode") == 0) { 1586 if (val[0] >= '0' && val[0] <= '7') { 1587 *parsed_kws |= MTREE_HAS_PERM; 1588 archive_entry_set_perm(entry, 1589 (mode_t)mtree_atol(&val, 8)); 1590 } else { 1591 archive_set_error(&a->archive, 1592 ARCHIVE_ERRNO_FILE_FORMAT, 1593 "Symbolic or non-octal mode \"%s\" unsupported", val); 1594 return ARCHIVE_WARN; 1595 } 1596 break; 1597 } 1598 __LA_FALLTHROUGH; 1599 case 'n': 1600 if (strcmp(key, "nlink") == 0) { 1601 *parsed_kws |= MTREE_HAS_NLINK; 1602 archive_entry_set_nlink(entry, 1603 (unsigned int)mtree_atol(&val, 10)); 1604 break; 1605 } 1606 __LA_FALLTHROUGH; 1607 case 'r': 1608 if (strcmp(key, "resdevice") == 0) { 1609 /* stat(2) st_dev field, e.g. the device ID where the 1610 * inode resides */ 1611 int r; 1612 dev_t dev; 1613 1614 r = parse_device(&dev, &a->archive, val); 1615 if (r == ARCHIVE_OK) 1616 archive_entry_set_dev(entry, dev); 1617 return r; 1618 } 1619 if (strcmp(key, "rmd160") == 0 || 1620 strcmp(key, "rmd160digest") == 0) 1621 break; 1622 __LA_FALLTHROUGH; 1623 case 's': 1624 if (strcmp(key, "sha1") == 0 || strcmp(key, "sha1digest") == 0) 1625 break; 1626 if (strcmp(key, "sha256") == 0 || 1627 strcmp(key, "sha256digest") == 0) 1628 break; 1629 if (strcmp(key, "sha384") == 0 || 1630 strcmp(key, "sha384digest") == 0) 1631 break; 1632 if (strcmp(key, "sha512") == 0 || 1633 strcmp(key, "sha512digest") == 0) 1634 break; 1635 if (strcmp(key, "size") == 0) { 1636 archive_entry_set_size(entry, mtree_atol(&val, 10)); 1637 break; 1638 } 1639 __LA_FALLTHROUGH; 1640 case 't': 1641 if (strcmp(key, "tags") == 0) { 1642 /* 1643 * Comma delimited list of tags. 1644 * Ignore the tags for now, but the interface 1645 * should be extended to allow inclusion/exclusion. 1646 */ 1647 break; 1648 } 1649 if (strcmp(key, "time") == 0) { 1650 int64_t m; 1651 int64_t my_time_t_max = get_time_t_max(); 1652 int64_t my_time_t_min = get_time_t_min(); 1653 long ns = 0; 1654 1655 *parsed_kws |= MTREE_HAS_MTIME; 1656 m = mtree_atol(&val, 10); 1657 /* Replicate an old mtree bug: 1658 * 123456789.1 represents 123456789 1659 * seconds and 1 nanosecond. */ 1660 if (*val == '.') { 1661 ++val; 1662 ns = (long)mtree_atol(&val, 10); 1663 if (ns < 0) 1664 ns = 0; 1665 else if (ns > 999999999) 1666 ns = 999999999; 1667 } 1668 if (m > my_time_t_max) 1669 m = my_time_t_max; 1670 else if (m < my_time_t_min) 1671 m = my_time_t_min; 1672 archive_entry_set_mtime(entry, (time_t)m, ns); 1673 break; 1674 } 1675 if (strcmp(key, "type") == 0) { 1676 switch (val[0]) { 1677 case 'b': 1678 if (strcmp(val, "block") == 0) { 1679 archive_entry_set_filetype(entry, AE_IFBLK); 1680 break; 1681 } 1682 __LA_FALLTHROUGH; 1683 case 'c': 1684 if (strcmp(val, "char") == 0) { 1685 archive_entry_set_filetype(entry, 1686 AE_IFCHR); 1687 break; 1688 } 1689 __LA_FALLTHROUGH; 1690 case 'd': 1691 if (strcmp(val, "dir") == 0) { 1692 archive_entry_set_filetype(entry, 1693 AE_IFDIR); 1694 break; 1695 } 1696 __LA_FALLTHROUGH; 1697 case 'f': 1698 if (strcmp(val, "fifo") == 0) { 1699 archive_entry_set_filetype(entry, 1700 AE_IFIFO); 1701 break; 1702 } 1703 if (strcmp(val, "file") == 0) { 1704 archive_entry_set_filetype(entry, 1705 AE_IFREG); 1706 break; 1707 } 1708 __LA_FALLTHROUGH; 1709 case 'l': 1710 if (strcmp(val, "link") == 0) { 1711 archive_entry_set_filetype(entry, 1712 AE_IFLNK); 1713 break; 1714 } 1715 __LA_FALLTHROUGH; 1716 default: 1717 archive_set_error(&a->archive, 1718 ARCHIVE_ERRNO_FILE_FORMAT, 1719 "Unrecognized file type \"%s\"; " 1720 "assuming \"file\"", val); 1721 archive_entry_set_filetype(entry, AE_IFREG); 1722 return (ARCHIVE_WARN); 1723 } 1724 *parsed_kws |= MTREE_HAS_TYPE; 1725 break; 1726 } 1727 __LA_FALLTHROUGH; 1728 case 'u': 1729 if (strcmp(key, "uid") == 0) { 1730 *parsed_kws |= MTREE_HAS_UID; 1731 archive_entry_set_uid(entry, mtree_atol(&val, 10)); 1732 break; 1733 } 1734 if (strcmp(key, "uname") == 0) { 1735 *parsed_kws |= MTREE_HAS_UNAME; 1736 archive_entry_copy_uname(entry, val); 1737 break; 1738 } 1739 __LA_FALLTHROUGH; 1740 default: 1741 archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, 1742 "Unrecognized key %s=%s", key, val); 1743 return (ARCHIVE_WARN); 1744 } 1745 return (ARCHIVE_OK); 1746} 1747 1748static int 1749read_data(struct archive_read *a, const void **buff, size_t *size, 1750 int64_t *offset) 1751{ 1752 size_t bytes_to_read; 1753 ssize_t bytes_read; 1754 struct mtree *mtree; 1755 1756 mtree = (struct mtree *)(a->format->data); 1757 if (mtree->fd < 0) { 1758 *buff = NULL; 1759 *offset = 0; 1760 *size = 0; 1761 return (ARCHIVE_EOF); 1762 } 1763 if (mtree->buff == NULL) { 1764 mtree->buffsize = 64 * 1024; 1765 mtree->buff = malloc(mtree->buffsize); 1766 if (mtree->buff == NULL) { 1767 archive_set_error(&a->archive, ENOMEM, 1768 "Can't allocate memory"); 1769 return (ARCHIVE_FATAL); 1770 } 1771 } 1772 1773 *buff = mtree->buff; 1774 *offset = mtree->offset; 1775 if ((int64_t)mtree->buffsize > mtree->cur_size - mtree->offset) 1776 bytes_to_read = (size_t)(mtree->cur_size - mtree->offset); 1777 else 1778 bytes_to_read = mtree->buffsize; 1779 bytes_read = read(mtree->fd, mtree->buff, bytes_to_read); 1780 if (bytes_read < 0) { 1781 archive_set_error(&a->archive, errno, "Can't read"); 1782 return (ARCHIVE_WARN); 1783 } 1784 if (bytes_read == 0) { 1785 *size = 0; 1786 return (ARCHIVE_EOF); 1787 } 1788 mtree->offset += bytes_read; 1789 *size = bytes_read; 1790 return (ARCHIVE_OK); 1791} 1792 1793/* Skip does nothing except possibly close the contents file. */ 1794static int 1795skip(struct archive_read *a) 1796{ 1797 struct mtree *mtree; 1798 1799 mtree = (struct mtree *)(a->format->data); 1800 if (mtree->fd >= 0) { 1801 close(mtree->fd); 1802 mtree->fd = -1; 1803 } 1804 return (ARCHIVE_OK); 1805} 1806 1807/* 1808 * Since parsing backslash sequences always makes strings shorter, 1809 * we can always do this conversion in-place. 1810 */ 1811static void 1812parse_escapes(char *src, struct mtree_entry *mentry) 1813{ 1814 char *dest = src; 1815 char c; 1816 1817 if (mentry != NULL && strcmp(src, ".") == 0) 1818 mentry->full = 1; 1819 1820 while (*src != '\0') { 1821 c = *src++; 1822 if (c == '/' && mentry != NULL) 1823 mentry->full = 1; 1824 if (c == '\\') { 1825 switch (src[0]) { 1826 case '0': 1827 if (src[1] < '0' || src[1] > '7') { 1828 c = 0; 1829 ++src; 1830 break; 1831 } 1832 /* FALLTHROUGH */ 1833 case '1': 1834 case '2': 1835 case '3': 1836 if (src[1] >= '0' && src[1] <= '7' && 1837 src[2] >= '0' && src[2] <= '7') { 1838 c = (src[0] - '0') << 6; 1839 c |= (src[1] - '0') << 3; 1840 c |= (src[2] - '0'); 1841 src += 3; 1842 } 1843 break; 1844 case 'a': 1845 c = '\a'; 1846 ++src; 1847 break; 1848 case 'b': 1849 c = '\b'; 1850 ++src; 1851 break; 1852 case 'f': 1853 c = '\f'; 1854 ++src; 1855 break; 1856 case 'n': 1857 c = '\n'; 1858 ++src; 1859 break; 1860 case 'r': 1861 c = '\r'; 1862 ++src; 1863 break; 1864 case 's': 1865 c = ' '; 1866 ++src; 1867 break; 1868 case 't': 1869 c = '\t'; 1870 ++src; 1871 break; 1872 case 'v': 1873 c = '\v'; 1874 ++src; 1875 break; 1876 case '\\': 1877 c = '\\'; 1878 ++src; 1879 break; 1880 } 1881 } 1882 *dest++ = c; 1883 } 1884 *dest = '\0'; 1885} 1886 1887/* Parse a hex digit. */ 1888static int 1889parsedigit(char c) 1890{ 1891 if (c >= '0' && c <= '9') 1892 return c - '0'; 1893 else if (c >= 'a' && c <= 'f') 1894 return c - 'a'; 1895 else if (c >= 'A' && c <= 'F') 1896 return c - 'A'; 1897 else 1898 return -1; 1899} 1900 1901/* 1902 * Note that this implementation does not (and should not!) obey 1903 * locale settings; you cannot simply substitute strtol here, since 1904 * it does obey locale. 1905 */ 1906static int64_t 1907mtree_atol(char **p, int base) 1908{ 1909 int64_t l, limit; 1910 int digit, last_digit_limit; 1911 1912 if (base == 0) { 1913 if (**p != '0') 1914 base = 10; 1915 else if ((*p)[1] == 'x' || (*p)[1] == 'X') { 1916 *p += 2; 1917 base = 16; 1918 } else { 1919 base = 8; 1920 } 1921 } 1922 1923 if (**p == '-') { 1924 limit = INT64_MIN / base; 1925 last_digit_limit = INT64_MIN % base; 1926 ++(*p); 1927 1928 l = 0; 1929 digit = parsedigit(**p); 1930 while (digit >= 0 && digit < base) { 1931 if (l < limit || (l == limit && digit > last_digit_limit)) 1932 return INT64_MIN; 1933 l = (l * base) - digit; 1934 digit = parsedigit(*++(*p)); 1935 } 1936 return l; 1937 } else { 1938 limit = INT64_MAX / base; 1939 last_digit_limit = INT64_MAX % base; 1940 1941 l = 0; 1942 digit = parsedigit(**p); 1943 while (digit >= 0 && digit < base) { 1944 if (l > limit || (l == limit && digit > last_digit_limit)) 1945 return INT64_MAX; 1946 l = (l * base) + digit; 1947 digit = parsedigit(*++(*p)); 1948 } 1949 return l; 1950 } 1951} 1952 1953/* 1954 * Returns length of line (including trailing newline) 1955 * or negative on error. 'start' argument is updated to 1956 * point to first character of line. 1957 */ 1958static ssize_t 1959readline(struct archive_read *a, struct mtree *mtree, char **start, 1960 ssize_t limit) 1961{ 1962 ssize_t bytes_read; 1963 ssize_t total_size = 0; 1964 ssize_t find_off = 0; 1965 const void *t; 1966 void *nl; 1967 char *u; 1968 1969 /* Accumulate line in a line buffer. */ 1970 for (;;) { 1971 /* Read some more. */ 1972 t = __archive_read_ahead(a, 1, &bytes_read); 1973 if (t == NULL) 1974 return (0); 1975 if (bytes_read < 0) 1976 return (ARCHIVE_FATAL); 1977 nl = memchr(t, '\n', bytes_read); 1978 /* If we found '\n', trim the read to end exactly there. */ 1979 if (nl != NULL) { 1980 bytes_read = ((const char *)nl) - ((const char *)t) + 1; 1981 } 1982 if (total_size + bytes_read + 1 > limit) { 1983 archive_set_error(&a->archive, 1984 ARCHIVE_ERRNO_FILE_FORMAT, 1985 "Line too long"); 1986 return (ARCHIVE_FATAL); 1987 } 1988 if (archive_string_ensure(&mtree->line, 1989 total_size + bytes_read + 1) == NULL) { 1990 archive_set_error(&a->archive, ENOMEM, 1991 "Can't allocate working buffer"); 1992 return (ARCHIVE_FATAL); 1993 } 1994 /* Append new bytes to string. */ 1995 memcpy(mtree->line.s + total_size, t, bytes_read); 1996 __archive_read_consume(a, bytes_read); 1997 total_size += bytes_read; 1998 mtree->line.s[total_size] = '\0'; 1999 2000 for (u = mtree->line.s + find_off; *u; ++u) { 2001 if (u[0] == '\n') { 2002 /* Ends with unescaped newline. */ 2003 *start = mtree->line.s; 2004 return total_size; 2005 } else if (u[0] == '#') { 2006 /* Ends with comment sequence #...\n */ 2007 if (nl == NULL) { 2008 /* But we've not found the \n yet */ 2009 break; 2010 } 2011 } else if (u[0] == '\\') { 2012 if (u[1] == '\n') { 2013 /* Trim escaped newline. */ 2014 total_size -= 2; 2015 mtree->line.s[total_size] = '\0'; 2016 break; 2017 } else if (u[1] != '\0') { 2018 /* Skip the two-char escape sequence */ 2019 ++u; 2020 } 2021 } 2022 } 2023 find_off = u - mtree->line.s; 2024 } 2025} 2026