| /*- |
| * Copyright (c) 2003-2007 Tim Kientzle |
| * Copyright (c) 2008 Joerg Sonnenberger |
| * Copyright (c) 2011-2012 Michihiro NAKAJIMA |
| * All rights reserved. |
| * |
| * Redistribution and use in source and binary forms, with or without |
| * modification, are permitted provided that the following conditions |
| * are met: |
| * 1. Redistributions of source code must retain the above copyright |
| * notice, this list of conditions and the following disclaimer. |
| * 2. Redistributions in binary form must reproduce the above copyright |
| * notice, this list of conditions and the following disclaimer in the |
| * documentation and/or other materials provided with the distribution. |
| * |
| * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR |
| * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES |
| * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. |
| * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, |
| * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT |
| * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF |
| * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| */ |
| |
| #include "archive_platform.h" |
| __FBSDID("$FreeBSD: head/lib/libarchive/archive_read_support_format_mtree.c 201165 2009-12-29 05:52:13Z kientzle $"); |
| |
| #ifdef HAVE_SYS_STAT_H |
| #include <sys/stat.h> |
| #endif |
| #ifdef HAVE_ERRNO_H |
| #include <errno.h> |
| #endif |
| #ifdef HAVE_FCNTL_H |
| #include <fcntl.h> |
| #endif |
| #include <stddef.h> |
| /* #include <stdint.h> */ /* See archive_platform.h */ |
| #ifdef HAVE_STDLIB_H |
| #include <stdlib.h> |
| #endif |
| #ifdef HAVE_STRING_H |
| #include <string.h> |
| #endif |
| #ifdef HAVE_CTYPE_H |
| #include <ctype.h> |
| #endif |
| |
| #include "archive.h" |
| #include "archive_entry.h" |
| #include "archive_private.h" |
| #include "archive_rb.h" |
| #include "archive_read_private.h" |
| #include "archive_string.h" |
| #include "archive_pack_dev.h" |
| |
| #ifndef O_BINARY |
| #define O_BINARY 0 |
| #endif |
| #ifndef O_CLOEXEC |
| #define O_CLOEXEC 0 |
| #endif |
| |
| #define MTREE_HAS_DEVICE 0x0001 |
| #define MTREE_HAS_FFLAGS 0x0002 |
| #define MTREE_HAS_GID 0x0004 |
| #define MTREE_HAS_GNAME 0x0008 |
| #define MTREE_HAS_MTIME 0x0010 |
| #define MTREE_HAS_NLINK 0x0020 |
| #define MTREE_HAS_PERM 0x0040 |
| #define MTREE_HAS_SIZE 0x0080 |
| #define MTREE_HAS_TYPE 0x0100 |
| #define MTREE_HAS_UID 0x0200 |
| #define MTREE_HAS_UNAME 0x0400 |
| |
| #define MTREE_HAS_OPTIONAL 0x0800 |
| #define MTREE_HAS_NOCHANGE 0x1000 /* FreeBSD specific */ |
| |
| #define MAX_LINE_LEN (1024 * 1024) |
| |
| struct mtree_option { |
| struct mtree_option *next; |
| char *value; |
| }; |
| |
| struct mtree_entry { |
| struct archive_rb_node rbnode; |
| struct mtree_entry *next_dup; |
| struct mtree_entry *next; |
| struct mtree_option *options; |
| char *name; |
| char full; |
| char used; |
| }; |
| |
| struct mtree { |
| struct archive_string line; |
| size_t buffsize; |
| char *buff; |
| int64_t offset; |
| int fd; |
| int archive_format; |
| const char *archive_format_name; |
| struct mtree_entry *entries; |
| struct mtree_entry *this_entry; |
| struct archive_rb_tree entry_rbtree; |
| struct archive_string current_dir; |
| struct archive_string contents_name; |
| |
| struct archive_entry_linkresolver *resolver; |
| struct archive_rb_tree rbtree; |
| |
| int64_t cur_size; |
| char checkfs; |
| }; |
| |
| static int bid_keycmp(const char *, const char *, ssize_t); |
| static int cleanup(struct archive_read *); |
| static int detect_form(struct archive_read *, int *); |
| static int mtree_bid(struct archive_read *, int); |
| static int parse_file(struct archive_read *, struct archive_entry *, |
| struct mtree *, struct mtree_entry *, int *); |
| static void parse_escapes(char *, struct mtree_entry *); |
| static int parse_line(struct archive_read *, struct archive_entry *, |
| struct mtree *, struct mtree_entry *, int *); |
| static int parse_keyword(struct archive_read *, struct mtree *, |
| struct archive_entry *, struct mtree_option *, int *); |
| static int read_data(struct archive_read *a, |
| const void **buff, size_t *size, int64_t *offset); |
| static ssize_t readline(struct archive_read *, struct mtree *, char **, ssize_t); |
| static int skip(struct archive_read *a); |
| static int read_header(struct archive_read *, |
| struct archive_entry *); |
| static int64_t mtree_atol(char **, int base); |
| |
| /* |
| * There's no standard for TIME_T_MAX/TIME_T_MIN. So we compute them |
| * here. TODO: Move this to configure time, but be careful |
| * about cross-compile environments. |
| */ |
| static int64_t |
| get_time_t_max(void) |
| { |
| #if defined(TIME_T_MAX) |
| return TIME_T_MAX; |
| #else |
| /* ISO C allows time_t to be a floating-point type, |
| but POSIX requires an integer type. The following |
| should work on any system that follows the POSIX |
| conventions. */ |
| if (((time_t)0) < ((time_t)-1)) { |
| /* Time_t is unsigned */ |
| return (~(time_t)0); |
| } else { |
| /* Time_t is signed. */ |
| /* Assume it's the same as int64_t or int32_t */ |
| if (sizeof(time_t) == sizeof(int64_t)) { |
| return (time_t)INT64_MAX; |
| } else { |
| return (time_t)INT32_MAX; |
| } |
| } |
| #endif |
| } |
| |
| static int64_t |
| get_time_t_min(void) |
| { |
| #if defined(TIME_T_MIN) |
| return TIME_T_MIN; |
| #else |
| if (((time_t)0) < ((time_t)-1)) { |
| /* Time_t is unsigned */ |
| return (time_t)0; |
| } else { |
| /* Time_t is signed. */ |
| if (sizeof(time_t) == sizeof(int64_t)) { |
| return (time_t)INT64_MIN; |
| } else { |
| return (time_t)INT32_MIN; |
| } |
| } |
| #endif |
| } |
| |
| static int |
| archive_read_format_mtree_options(struct archive_read *a, |
| const char *key, const char *val) |
| { |
| struct mtree *mtree; |
| |
| mtree = (struct mtree *)(a->format->data); |
| if (strcmp(key, "checkfs") == 0) { |
| /* Allows to read information missing from the mtree from the file system */ |
| if (val == NULL || val[0] == 0) { |
| mtree->checkfs = 0; |
| } else { |
| mtree->checkfs = 1; |
| } |
| return (ARCHIVE_OK); |
| } |
| |
| /* Note: The "warn" return is just to inform the options |
| * supervisor that we didn't handle it. It will generate |
| * a suitable error if no one used this option. */ |
| return (ARCHIVE_WARN); |
| } |
| |
| static void |
| free_options(struct mtree_option *head) |
| { |
| struct mtree_option *next; |
| |
| for (; head != NULL; head = next) { |
| next = head->next; |
| free(head->value); |
| free(head); |
| } |
| } |
| |
| static int |
| mtree_cmp_node(const struct archive_rb_node *n1, |
| const struct archive_rb_node *n2) |
| { |
| const struct mtree_entry *e1 = (const struct mtree_entry *)n1; |
| const struct mtree_entry *e2 = (const struct mtree_entry *)n2; |
| |
| return (strcmp(e1->name, e2->name)); |
| } |
| |
| static int |
| mtree_cmp_key(const struct archive_rb_node *n, const void *key) |
| { |
| const struct mtree_entry *e = (const struct mtree_entry *)n; |
| |
| return (strcmp(e->name, key)); |
| } |
| |
| int |
| archive_read_support_format_mtree(struct archive *_a) |
| { |
| static const struct archive_rb_tree_ops rb_ops = { |
| mtree_cmp_node, mtree_cmp_key, |
| }; |
| struct archive_read *a = (struct archive_read *)_a; |
| struct mtree *mtree; |
| int r; |
| |
| archive_check_magic(_a, ARCHIVE_READ_MAGIC, |
| ARCHIVE_STATE_NEW, "archive_read_support_format_mtree"); |
| |
| mtree = (struct mtree *)calloc(1, sizeof(*mtree)); |
| if (mtree == NULL) { |
| archive_set_error(&a->archive, ENOMEM, |
| "Can't allocate mtree data"); |
| return (ARCHIVE_FATAL); |
| } |
| mtree->checkfs = 0; |
| mtree->fd = -1; |
| |
| __archive_rb_tree_init(&mtree->rbtree, &rb_ops); |
| |
| r = __archive_read_register_format(a, mtree, "mtree", |
| mtree_bid, archive_read_format_mtree_options, read_header, read_data, skip, NULL, cleanup, NULL, NULL); |
| |
| if (r != ARCHIVE_OK) |
| free(mtree); |
| return (ARCHIVE_OK); |
| } |
| |
| static int |
| cleanup(struct archive_read *a) |
| { |
| struct mtree *mtree; |
| struct mtree_entry *p, *q; |
| |
| mtree = (struct mtree *)(a->format->data); |
| |
| p = mtree->entries; |
| while (p != NULL) { |
| q = p->next; |
| free(p->name); |
| free_options(p->options); |
| free(p); |
| p = q; |
| } |
| archive_string_free(&mtree->line); |
| archive_string_free(&mtree->current_dir); |
| archive_string_free(&mtree->contents_name); |
| archive_entry_linkresolver_free(mtree->resolver); |
| |
| free(mtree->buff); |
| free(mtree); |
| (a->format->data) = NULL; |
| return (ARCHIVE_OK); |
| } |
| |
| static ssize_t |
| get_line_size(const char *b, ssize_t avail, ssize_t *nlsize) |
| { |
| ssize_t len; |
| |
| len = 0; |
| while (len < avail) { |
| switch (*b) { |
| case '\0':/* Non-ascii character or control character. */ |
| if (nlsize != NULL) |
| *nlsize = 0; |
| return (-1); |
| case '\r': |
| if (avail-len > 1 && b[1] == '\n') { |
| if (nlsize != NULL) |
| *nlsize = 2; |
| return (len+2); |
| } |
| /* FALL THROUGH */ |
| case '\n': |
| if (nlsize != NULL) |
| *nlsize = 1; |
| return (len+1); |
| default: |
| b++; |
| len++; |
| break; |
| } |
| } |
| if (nlsize != NULL) |
| *nlsize = 0; |
| return (avail); |
| } |
| |
| /* |
| * <---------------- ravail ---------------------> |
| * <-- diff ------> <--- avail -----------------> |
| * <---- len -----------> |
| * | Previous lines | line being parsed nl extra | |
| * ^ |
| * b |
| * |
| */ |
| static ssize_t |
| next_line(struct archive_read *a, |
| const char **b, ssize_t *avail, ssize_t *ravail, ssize_t *nl) |
| { |
| ssize_t len; |
| int quit; |
| |
| quit = 0; |
| if (*avail == 0) { |
| *nl = 0; |
| len = 0; |
| } else |
| len = get_line_size(*b, *avail, nl); |
| /* |
| * Read bytes more while it does not reach the end of line. |
| */ |
| while (*nl == 0 && len == *avail && !quit) { |
| ssize_t diff = *ravail - *avail; |
| size_t nbytes_req = (*ravail+1023) & ~1023U; |
| ssize_t tested; |
| |
| /* |
| * Place an arbitrary limit on the line length. |
| * mtree is almost free-form input and without line length limits, |
| * it can consume a lot of memory. |
| */ |
| if (len >= MAX_LINE_LEN) |
| return (-1); |
| |
| /* Increase reading bytes if it is not enough to at least |
| * new two lines. */ |
| if (nbytes_req < (size_t)*ravail + 160) |
| nbytes_req <<= 1; |
| |
| *b = __archive_read_ahead(a, nbytes_req, avail); |
| if (*b == NULL) { |
| if (*ravail >= *avail) |
| return (0); |
| /* Reading bytes reaches the end of file. */ |
| *b = __archive_read_ahead(a, *avail, avail); |
| quit = 1; |
| } |
| *ravail = *avail; |
| *b += diff; |
| *avail -= diff; |
| tested = len;/* Skip some bytes we already determinated. */ |
| len = get_line_size(*b + len, *avail - len, nl); |
| if (len >= 0) |
| len += tested; |
| } |
| return (len); |
| } |
| |
| /* |
| * Compare characters with a mtree keyword. |
| * Returns the length of a mtree keyword if matched. |
| * Returns 0 if not matched. |
| */ |
| static int |
| bid_keycmp(const char *p, const char *key, ssize_t len) |
| { |
| int match_len = 0; |
| |
| while (len > 0 && *p && *key) { |
| if (*p == *key) { |
| --len; |
| ++p; |
| ++key; |
| ++match_len; |
| continue; |
| } |
| return (0);/* Not match */ |
| } |
| if (*key != '\0') |
| return (0);/* Not match */ |
| |
| /* A following character should be specified characters */ |
| if (p[0] == '=' || p[0] == ' ' || p[0] == '\t' || |
| p[0] == '\n' || p[0] == '\r' || |
| (p[0] == '\\' && (p[1] == '\n' || p[1] == '\r'))) |
| return (match_len); |
| return (0);/* Not match */ |
| } |
| |
| /* |
| * Test whether the characters 'p' has is mtree keyword. |
| * Returns the length of a detected keyword. |
| * Returns 0 if any keywords were not found. |
| */ |
| static int |
| bid_keyword(const char *p, ssize_t len) |
| { |
| static const char * const keys_c[] = { |
| "content", "contents", "cksum", NULL |
| }; |
| static const char * const keys_df[] = { |
| "device", "flags", NULL |
| }; |
| static const char * const keys_g[] = { |
| "gid", "gname", NULL |
| }; |
| static const char * const keys_il[] = { |
| "ignore", "inode", "link", NULL |
| }; |
| static const char * const keys_m[] = { |
| "md5", "md5digest", "mode", NULL |
| }; |
| static const char * const keys_no[] = { |
| "nlink", "nochange", "optional", NULL |
| }; |
| static const char * const keys_r[] = { |
| "resdevice", "rmd160", "rmd160digest", NULL |
| }; |
| static const char * const keys_s[] = { |
| "sha1", "sha1digest", |
| "sha256", "sha256digest", |
| "sha384", "sha384digest", |
| "sha512", "sha512digest", |
| "size", NULL |
| }; |
| static const char * const keys_t[] = { |
| "tags", "time", "type", NULL |
| }; |
| static const char * const keys_u[] = { |
| "uid", "uname", NULL |
| }; |
| const char * const *keys; |
| int i; |
| |
| switch (*p) { |
| case 'c': keys = keys_c; break; |
| case 'd': case 'f': keys = keys_df; break; |
| case 'g': keys = keys_g; break; |
| case 'i': case 'l': keys = keys_il; break; |
| case 'm': keys = keys_m; break; |
| case 'n': case 'o': keys = keys_no; break; |
| case 'r': keys = keys_r; break; |
| case 's': keys = keys_s; break; |
| case 't': keys = keys_t; break; |
| case 'u': keys = keys_u; break; |
| default: return (0);/* Unknown key */ |
| } |
| |
| for (i = 0; keys[i] != NULL; i++) { |
| int l = bid_keycmp(p, keys[i], len); |
| if (l > 0) |
| return (l); |
| } |
| return (0);/* Unknown key */ |
| } |
| |
| /* |
| * Test whether there is a set of mtree keywords. |
| * Returns the number of keyword. |
| * Returns -1 if we got incorrect sequence. |
| * This function expects a set of "<space characters>keyword=value". |
| * When "unset" is specified, expects a set of "<space characters>keyword". |
| */ |
| static int |
| bid_keyword_list(const char *p, ssize_t len, int unset, int last_is_path) |
| { |
| int l; |
| int keycnt = 0; |
| |
| while (len > 0 && *p) { |
| int blank = 0; |
| |
| /* Test whether there are blank characters in the line. */ |
| while (len >0 && (*p == ' ' || *p == '\t')) { |
| ++p; |
| --len; |
| blank = 1; |
| } |
| if (*p == '\n' || *p == '\r') |
| break; |
| if (p[0] == '\\' && (p[1] == '\n' || p[1] == '\r')) |
| break; |
| if (!blank && !last_is_path) /* No blank character. */ |
| return (-1); |
| if (last_is_path && len == 0) |
| return (keycnt); |
| |
| if (unset) { |
| l = bid_keycmp(p, "all", len); |
| if (l > 0) |
| return (1); |
| } |
| /* Test whether there is a correct key in the line. */ |
| l = bid_keyword(p, len); |
| if (l == 0) |
| return (-1);/* Unknown keyword was found. */ |
| p += l; |
| len -= l; |
| keycnt++; |
| |
| /* Skip value */ |
| if (*p == '=') { |
| int value = 0; |
| ++p; |
| --len; |
| while (len > 0 && *p != ' ' && *p != '\t') { |
| ++p; |
| --len; |
| value = 1; |
| } |
| /* A keyword should have a its value unless |
| * "/unset" operation. */ |
| if (!unset && value == 0) |
| return (-1); |
| } |
| } |
| return (keycnt); |
| } |
| |
| static int |
| bid_entry(const char *p, ssize_t len, ssize_t nl, int *last_is_path) |
| { |
| int f = 0; |
| static const unsigned char safe_char[256] = { |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 00 - 0F */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 10 - 1F */ |
| /* !"$%&'()*+,-./ EXCLUSION:( )(#) */ |
| 0, 1, 1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 20 - 2F */ |
| /* 0123456789:;<>? EXCLUSION:(=) */ |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 1, 1, /* 30 - 3F */ |
| /* @ABCDEFGHIJKLMNO */ |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 40 - 4F */ |
| /* PQRSTUVWXYZ[\]^_ */ |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 50 - 5F */ |
| /* `abcdefghijklmno */ |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, /* 60 - 6F */ |
| /* pqrstuvwxyz{|}~ */ |
| 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, /* 70 - 7F */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 80 - 8F */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* 90 - 9F */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* A0 - AF */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* B0 - BF */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* C0 - CF */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* D0 - DF */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* E0 - EF */ |
| 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, /* F0 - FF */ |
| }; |
| ssize_t ll; |
| const char *pp = p; |
| const char * const pp_end = pp + len; |
| |
| *last_is_path = 0; |
| /* |
| * Skip the path-name which is quoted. |
| */ |
| for (;pp < pp_end; ++pp) { |
| if (!safe_char[*(const unsigned char *)pp]) { |
| if (*pp != ' ' && *pp != '\t' && *pp != '\r' |
| && *pp != '\n') |
| f = 0; |
| break; |
| } |
| f = 1; |
| } |
| ll = pp_end - pp; |
| |
| /* If a path-name was not found at the first, try to check |
| * a mtree format(a.k.a form D) ``NetBSD's mtree -D'' creates, |
| * which places the path-name at the last. */ |
| if (f == 0) { |
| const char *pb = p + len - nl; |
| int name_len = 0; |
| int slash; |
| |
| /* The form D accepts only a single line for an entry. */ |
| if (pb-2 >= p && |
| pb[-1] == '\\' && (pb[-2] == ' ' || pb[-2] == '\t')) |
| return (-1); |
| if (pb-1 >= p && pb[-1] == '\\') |
| return (-1); |
| |
| slash = 0; |
| while (p <= --pb && *pb != ' ' && *pb != '\t') { |
| if (!safe_char[*(const unsigned char *)pb]) |
| return (-1); |
| name_len++; |
| /* The pathname should have a slash in this |
| * format. */ |
| if (*pb == '/') |
| slash = 1; |
| } |
| if (name_len == 0 || slash == 0) |
| return (-1); |
| /* If '/' is placed at the first in this field, this is not |
| * a valid filename. */ |
| if (pb[1] == '/') |
| return (-1); |
| ll = len - nl - name_len; |
| pp = p; |
| *last_is_path = 1; |
| } |
| |
| return (bid_keyword_list(pp, ll, 0, *last_is_path)); |
| } |
| |
| #define MAX_BID_ENTRY 3 |
| |
| static int |
| mtree_bid(struct archive_read *a, int best_bid) |
| { |
| const char *signature = "#mtree"; |
| const char *p; |
| |
| (void)best_bid; /* UNUSED */ |
| |
| /* Now let's look at the actual header and see if it matches. */ |
| p = __archive_read_ahead(a, strlen(signature), NULL); |
| if (p == NULL) |
| return (-1); |
| |
| if (memcmp(p, signature, strlen(signature)) == 0) |
| return (8 * (int)strlen(signature)); |
| |
| /* |
| * There is not a mtree signature. Let's try to detect mtree format. |
| */ |
| return (detect_form(a, NULL)); |
| } |
| |
| static int |
| detect_form(struct archive_read *a, int *is_form_d) |
| { |
| const char *p; |
| ssize_t avail, ravail; |
| ssize_t detected_bytes = 0, len, nl; |
| int entry_cnt = 0, multiline = 0; |
| int form_D = 0;/* The archive is generated by `NetBSD mtree -D' |
| * (In this source we call it `form D') . */ |
| |
| if (is_form_d != NULL) |
| *is_form_d = 0; |
| p = __archive_read_ahead(a, 1, &avail); |
| if (p == NULL) |
| return (-1); |
| ravail = avail; |
| for (;;) { |
| len = next_line(a, &p, &avail, &ravail, &nl); |
| /* The terminal character of the line should be |
| * a new line character, '\r\n' or '\n'. */ |
| if (len <= 0 || nl == 0) |
| break; |
| if (!multiline) { |
| /* Leading whitespace is never significant, |
| * ignore it. */ |
| while (len > 0 && (*p == ' ' || *p == '\t')) { |
| ++p; |
| --avail; |
| --len; |
| } |
| /* Skip comment or empty line. */ |
| if (p[0] == '#' || p[0] == '\n' || p[0] == '\r') { |
| p += len; |
| avail -= len; |
| continue; |
| } |
| } else { |
| /* A continuance line; the terminal |
| * character of previous line was '\' character. */ |
| if (bid_keyword_list(p, len, 0, 0) <= 0) |
| break; |
| if (multiline == 1) |
| detected_bytes += len; |
| if (p[len-nl-1] != '\\') { |
| if (multiline == 1 && |
| ++entry_cnt >= MAX_BID_ENTRY) |
| break; |
| multiline = 0; |
| } |
| p += len; |
| avail -= len; |
| continue; |
| } |
| if (p[0] != '/') { |
| int last_is_path, keywords; |
| |
| keywords = bid_entry(p, len, nl, &last_is_path); |
| if (keywords >= 0) { |
| detected_bytes += len; |
| if (form_D == 0) { |
| if (last_is_path) |
| form_D = 1; |
| else if (keywords > 0) |
| /* This line is not `form D'. */ |
| form_D = -1; |
| } else if (form_D == 1) { |
| if (!last_is_path && keywords > 0) |
| /* This this is not `form D' |
| * and We cannot accept mixed |
| * format. */ |
| break; |
| } |
| if (!last_is_path && p[len-nl-1] == '\\') |
| /* This line continues. */ |
| multiline = 1; |
| else { |
| /* We've got plenty of correct lines |
| * to assume that this file is a mtree |
| * format. */ |
| if (++entry_cnt >= MAX_BID_ENTRY) |
| break; |
| } |
| } else |
| break; |
| } else if (len > 4 && strncmp(p, "/set", 4) == 0) { |
| if (bid_keyword_list(p+4, len-4, 0, 0) <= 0) |
| break; |
| /* This line continues. */ |
| if (p[len-nl-1] == '\\') |
| multiline = 2; |
| } else if (len > 6 && strncmp(p, "/unset", 6) == 0) { |
| if (bid_keyword_list(p+6, len-6, 1, 0) <= 0) |
| break; |
| /* This line continues. */ |
| if (p[len-nl-1] == '\\') |
| multiline = 2; |
| } else |
| break; |
| |
| /* Test next line. */ |
| p += len; |
| avail -= len; |
| } |
| if (entry_cnt >= MAX_BID_ENTRY || (entry_cnt > 0 && len == 0)) { |
| if (is_form_d != NULL) { |
| if (form_D == 1) |
| *is_form_d = 1; |
| } |
| return (32); |
| } |
| |
| return (0); |
| } |
| |
| /* |
| * The extended mtree format permits multiple lines specifying |
| * attributes for each file. For those entries, only the last line |
| * is actually used. Practically speaking, that means we have |
| * to read the entire mtree file into memory up front. |
| * |
| * The parsing is done in two steps. First, it is decided if a line |
| * changes the global defaults and if it is, processed accordingly. |
| * Otherwise, the options of the line are merged with the current |
| * global options. |
| */ |
| static int |
| add_option(struct archive_read *a, struct mtree_option **global, |
| const char *value, size_t len) |
| { |
| struct mtree_option *opt; |
| |
| if ((opt = malloc(sizeof(*opt))) == NULL) { |
| archive_set_error(&a->archive, errno, "Can't allocate memory"); |
| return (ARCHIVE_FATAL); |
| } |
| if ((opt->value = malloc(len + 1)) == NULL) { |
| free(opt); |
| archive_set_error(&a->archive, errno, "Can't allocate memory"); |
| return (ARCHIVE_FATAL); |
| } |
| memcpy(opt->value, value, len); |
| opt->value[len] = '\0'; |
| opt->next = *global; |
| *global = opt; |
| return (ARCHIVE_OK); |
| } |
| |
| static void |
| remove_option(struct mtree_option **global, const char *value, size_t len) |
| { |
| struct mtree_option *iter, *last; |
| |
| last = NULL; |
| for (iter = *global; iter != NULL; last = iter, iter = iter->next) { |
| if (strncmp(iter->value, value, len) == 0 && |
| (iter->value[len] == '\0' || |
| iter->value[len] == '=')) |
| break; |
| } |
| if (iter == NULL) |
| return; |
| if (last == NULL) |
| *global = iter->next; |
| else |
| last->next = iter->next; |
| |
| free(iter->value); |
| free(iter); |
| } |
| |
| static int |
| process_global_set(struct archive_read *a, |
| struct mtree_option **global, const char *line) |
| { |
| const char *next, *eq; |
| size_t len; |
| int r; |
| |
| line += 4; |
| for (;;) { |
| next = line + strspn(line, " \t\r\n"); |
| if (*next == '\0') |
| return (ARCHIVE_OK); |
| line = next; |
| next = line + strcspn(line, " \t\r\n"); |
| eq = strchr(line, '='); |
| if (eq > next) |
| len = next - line; |
| else |
| len = eq - line; |
| |
| remove_option(global, line, len); |
| r = add_option(a, global, line, next - line); |
| if (r != ARCHIVE_OK) |
| return (r); |
| line = next; |
| } |
| } |
| |
| static int |
| process_global_unset(struct archive_read *a, |
| struct mtree_option **global, const char *line) |
| { |
| const char *next; |
| size_t len; |
| |
| line += 6; |
| if (strchr(line, '=') != NULL) { |
| archive_set_error(&a->archive, ARCHIVE_ERRNO_MISC, |
| "/unset shall not contain `='"); |
| return ARCHIVE_FATAL; |
| } |
| |
| for (;;) { |
| next = line + strspn(line, " \t\r\n"); |
| if (*next == '\0') |
| return (ARCHIVE_OK); |
| line = next; |
| len = strcspn(line, " \t\r\n"); |
| |
| if (len == 3 && strncmp(line, "all", 3) == 0) { |
| free_options(*global); |
| *global = NULL; |
| } else { |
| remove_option(global, line, len); |
| } |
| |
| line += len; |
| } |
| } |
| |
| static int |
| process_add_entry(struct archive_read *a, struct mtree *mtree, |
| struct mtree_option **global, const char *line, ssize_t line_len, |
| struct mtree_entry **last_entry, int is_form_d) |
| { |
| struct mtree_entry *entry; |
| struct mtree_option *iter; |
| const char *next, *eq, *name, *end; |
| size_t name_len, len; |
| int r, i; |
| |
| if ((entry = malloc(sizeof(*entry))) == NULL) { |
| archive_set_error(&a->archive, errno, "Can't allocate memory"); |
| return (ARCHIVE_FATAL); |
| } |
| entry->next = NULL; |
| entry->options = NULL; |
| entry->name = NULL; |
| entry->used = 0; |
| entry->full = 0; |
| |
| /* Add this entry to list. */ |
| if (*last_entry == NULL) |
| mtree->entries = entry; |
| else |
| (*last_entry)->next = entry; |
| *last_entry = entry; |
| |
| if (is_form_d) { |
| /* Filename is last item on line. */ |
| /* Adjust line_len to trim trailing whitespace */ |
| while (line_len > 0) { |
| char last_character = line[line_len - 1]; |
| if (last_character == '\r' |
| || last_character == '\n' |
| || last_character == '\t' |
| || last_character == ' ') { |
| line_len--; |
| } else { |
| break; |
| } |
| } |
| /* Name starts after the last whitespace separator */ |
| name = line; |
| for (i = 0; i < line_len; i++) { |
| if (line[i] == '\r' |
| || line[i] == '\n' |
| || line[i] == '\t' |
| || line[i] == ' ') { |
| name = line + i + 1; |
| } |
| } |
| name_len = line + line_len - name; |
| end = name; |
| } else { |
| /* Filename is first item on line */ |
| name_len = strcspn(line, " \t\r\n"); |
| name = line; |
| line += name_len; |
| end = line + line_len; |
| } |
| /* name/name_len is the name within the line. */ |
| /* line..end brackets the entire line except the name */ |
| |
| if ((entry->name = malloc(name_len + 1)) == NULL) { |
| archive_set_error(&a->archive, errno, "Can't allocate memory"); |
| return (ARCHIVE_FATAL); |
| } |
| |
| memcpy(entry->name, name, name_len); |
| entry->name[name_len] = '\0'; |
| parse_escapes(entry->name, entry); |
| |
| entry->next_dup = NULL; |
| if (entry->full) { |
| if (!__archive_rb_tree_insert_node(&mtree->rbtree, &entry->rbnode)) { |
| struct mtree_entry *alt; |
| alt = (struct mtree_entry *)__archive_rb_tree_find_node( |
| &mtree->rbtree, entry->name); |
| while (alt->next_dup) |
| alt = alt->next_dup; |
| alt->next_dup = entry; |
| } |
| } |
| |
| for (iter = *global; iter != NULL; iter = iter->next) { |
| r = add_option(a, &entry->options, iter->value, |
| strlen(iter->value)); |
| if (r != ARCHIVE_OK) |
| return (r); |
| } |
| |
| for (;;) { |
| next = line + strspn(line, " \t\r\n"); |
| if (*next == '\0') |
| return (ARCHIVE_OK); |
| if (next >= end) |
| return (ARCHIVE_OK); |
| line = next; |
| next = line + strcspn(line, " \t\r\n"); |
| eq = strchr(line, '='); |
| if (eq == NULL || eq > next) |
| len = next - line; |
| else |
| len = eq - line; |
| |
| remove_option(&entry->options, line, len); |
| r = add_option(a, &entry->options, line, next - line); |
| if (r != ARCHIVE_OK) |
| return (r); |
| line = next; |
| } |
| } |
| |
| static int |
| read_mtree(struct archive_read *a, struct mtree *mtree) |
| { |
| ssize_t len; |
| uintmax_t counter; |
| char *p, *s; |
| struct mtree_option *global; |
| struct mtree_entry *last_entry; |
| int r, is_form_d; |
| |
| mtree->archive_format = ARCHIVE_FORMAT_MTREE; |
| mtree->archive_format_name = "mtree"; |
| |
| global = NULL; |
| last_entry = NULL; |
| |
| (void)detect_form(a, &is_form_d); |
| |
| for (counter = 1; ; ++counter) { |
| r = ARCHIVE_OK; |
| len = readline(a, mtree, &p, 65536); |
| if (len == 0) { |
| mtree->this_entry = mtree->entries; |
| free_options(global); |
| return (ARCHIVE_OK); |
| } |
| if (len < 0) { |
| free_options(global); |
| return ((int)len); |
| } |
| /* Leading whitespace is never significant, ignore it. */ |
| while (*p == ' ' || *p == '\t') { |
| ++p; |
| --len; |
| } |
| /* Skip content lines and blank lines. */ |
| if (*p == '#') |
| continue; |
| if (*p == '\r' || *p == '\n' || *p == '\0') |
| continue; |
| /* Non-printable characters are not allowed */ |
| for (s = p;s < p + len - 1; s++) { |
| if (!isprint(*s)) { |
| r = ARCHIVE_FATAL; |
| break; |
| } |
| } |
| if (r != ARCHIVE_OK) |
| break; |
| if (*p != '/') { |
| r = process_add_entry(a, mtree, &global, p, len, |
| &last_entry, is_form_d); |
| } else if (len > 4 && strncmp(p, "/set", 4) == 0) { |
| if (p[4] != ' ' && p[4] != '\t') |
| break; |
| r = process_global_set(a, &global, p); |
| } else if (len > 6 && strncmp(p, "/unset", 6) == 0) { |
| if (p[6] != ' ' && p[6] != '\t') |
| break; |
| r = process_global_unset(a, &global, p); |
| } else |
| break; |
| |
| if (r != ARCHIVE_OK) { |
| free_options(global); |
| return r; |
| } |
| } |
| |
| archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, |
| "Can't parse line %ju", counter); |
| free_options(global); |
| return (ARCHIVE_FATAL); |
| } |
| |
| /* |
| * Read in the entire mtree file into memory on the first request. |
| * Then use the next unused file to satisfy each header request. |
| */ |
| static int |
| read_header(struct archive_read *a, struct archive_entry *entry) |
| { |
| struct mtree *mtree; |
| char *p; |
| int r, use_next; |
| |
| mtree = (struct mtree *)(a->format->data); |
| |
| if (mtree->fd >= 0) { |
| close(mtree->fd); |
| mtree->fd = -1; |
| } |
| |
| if (mtree->entries == NULL) { |
| mtree->resolver = archive_entry_linkresolver_new(); |
| if (mtree->resolver == NULL) |
| return ARCHIVE_FATAL; |
| archive_entry_linkresolver_set_strategy(mtree->resolver, |
| ARCHIVE_FORMAT_MTREE); |
| r = read_mtree(a, mtree); |
| if (r != ARCHIVE_OK) |
| return (r); |
| } |
| |
| a->archive.archive_format = mtree->archive_format; |
| a->archive.archive_format_name = mtree->archive_format_name; |
| |
| for (;;) { |
| if (mtree->this_entry == NULL) |
| return (ARCHIVE_EOF); |
| if (strcmp(mtree->this_entry->name, "..") == 0) { |
| mtree->this_entry->used = 1; |
| if (archive_strlen(&mtree->current_dir) > 0) { |
| /* Roll back current path. */ |
| p = mtree->current_dir.s |
| + mtree->current_dir.length - 1; |
| while (p >= mtree->current_dir.s && *p != '/') |
| --p; |
| if (p >= mtree->current_dir.s) |
| --p; |
| mtree->current_dir.length |
| = p - mtree->current_dir.s + 1; |
| } |
| } |
| if (!mtree->this_entry->used) { |
| use_next = 0; |
| r = parse_file(a, entry, mtree, mtree->this_entry, |
| &use_next); |
| if (use_next == 0) |
| return (r); |
| } |
| mtree->this_entry = mtree->this_entry->next; |
| } |
| } |
| |
| /* |
| * A single file can have multiple lines contribute specifications. |
| * Parse as many lines as necessary, then pull additional information |
| * from a backing file on disk as necessary. |
| */ |
| static int |
| parse_file(struct archive_read *a, struct archive_entry *entry, |
| struct mtree *mtree, struct mtree_entry *mentry, int *use_next) |
| { |
| const char *path; |
| struct stat st_storage, *st; |
| struct mtree_entry *mp; |
| struct archive_entry *sparse_entry; |
| int r = ARCHIVE_OK, r1, parsed_kws; |
| |
| mentry->used = 1; |
| |
| /* Initialize reasonable defaults. */ |
| archive_entry_set_filetype(entry, AE_IFREG); |
| archive_entry_set_size(entry, 0); |
| archive_string_empty(&mtree->contents_name); |
| |
| /* Parse options from this line. */ |
| parsed_kws = 0; |
| r = parse_line(a, entry, mtree, mentry, &parsed_kws); |
| |
| if (mentry->full) { |
| archive_entry_copy_pathname(entry, mentry->name); |
| /* |
| * "Full" entries are allowed to have multiple lines |
| * and those lines aren't required to be adjacent. We |
| * don't support multiple lines for "relative" entries |
| * nor do we make any attempt to merge data from |
| * separate "relative" and "full" entries. (Merging |
| * "relative" and "full" entries would require dealing |
| * with pathname canonicalization, which is a very |
| * tricky subject.) |
| */ |
| mp = (struct mtree_entry *)__archive_rb_tree_find_node( |
| &mtree->rbtree, mentry->name); |
| for (; mp; mp = mp->next_dup) { |
| if (mp->full && !mp->used) { |
| /* Later lines override earlier ones. */ |
| mp->used = 1; |
| r1 = parse_line(a, entry, mtree, mp, &parsed_kws); |
| if (r1 < r) |
| r = r1; |
| } |
| } |
| } else { |
| /* |
| * Relative entries require us to construct |
| * the full path and possibly update the |
| * current directory. |
| */ |
| size_t n = archive_strlen(&mtree->current_dir); |
| if (n > 0) |
| archive_strcat(&mtree->current_dir, "/"); |
| archive_strcat(&mtree->current_dir, mentry->name); |
| archive_entry_copy_pathname(entry, mtree->current_dir.s); |
| if (archive_entry_filetype(entry) != AE_IFDIR) |
| mtree->current_dir.length = n; |
| } |
| |
| if (mtree->checkfs) { |
| /* |
| * Try to open and stat the file to get the real size |
| * and other file info. It would be nice to avoid |
| * this here so that getting a listing of an mtree |
| * wouldn't require opening every referenced contents |
| * file. But then we wouldn't know the actual |
| * contents size, so I don't see a really viable way |
| * around this. (Also, we may want to someday pull |
| * other unspecified info from the contents file on |
| * disk.) |
| */ |
| mtree->fd = -1; |
| if (archive_strlen(&mtree->contents_name) > 0) |
| path = mtree->contents_name.s; |
| else |
| path = archive_entry_pathname(entry); |
| |
| if (archive_entry_filetype(entry) == AE_IFREG || |
| archive_entry_filetype(entry) == AE_IFDIR) { |
| mtree->fd = open(path, O_RDONLY | O_BINARY | O_CLOEXEC); |
| __archive_ensure_cloexec_flag(mtree->fd); |
| if (mtree->fd == -1 && |
| (errno != ENOENT || |
| archive_strlen(&mtree->contents_name) > 0)) { |
| archive_set_error(&a->archive, errno, |
| "Can't open %s", path); |
| r = ARCHIVE_WARN; |
| } |
| } |
| |
| st = &st_storage; |
| if (mtree->fd >= 0) { |
| if (fstat(mtree->fd, st) == -1) { |
| archive_set_error(&a->archive, errno, |
| "Could not fstat %s", path); |
| r = ARCHIVE_WARN; |
| /* If we can't stat it, don't keep it open. */ |
| close(mtree->fd); |
| mtree->fd = -1; |
| st = NULL; |
| } |
| } else if (lstat(path, st) == -1) { |
| st = NULL; |
| } |
| |
| /* |
| * Check for a mismatch between the type in the specification |
| * and the type of the contents object on disk. |
| */ |
| if (st != NULL) { |
| if (((st->st_mode & S_IFMT) == S_IFREG && |
| archive_entry_filetype(entry) == AE_IFREG) |
| #ifdef S_IFLNK |
| ||((st->st_mode & S_IFMT) == S_IFLNK && |
| archive_entry_filetype(entry) == AE_IFLNK) |
| #endif |
| #ifdef S_IFSOCK |
| ||((st->st_mode & S_IFSOCK) == S_IFSOCK && |
| archive_entry_filetype(entry) == AE_IFSOCK) |
| #endif |
| #ifdef S_IFCHR |
| ||((st->st_mode & S_IFMT) == S_IFCHR && |
| archive_entry_filetype(entry) == AE_IFCHR) |
| #endif |
| #ifdef S_IFBLK |
| ||((st->st_mode & S_IFMT) == S_IFBLK && |
| archive_entry_filetype(entry) == AE_IFBLK) |
| #endif |
| ||((st->st_mode & S_IFMT) == S_IFDIR && |
| archive_entry_filetype(entry) == AE_IFDIR) |
| #ifdef S_IFIFO |
| ||((st->st_mode & S_IFMT) == S_IFIFO && |
| archive_entry_filetype(entry) == AE_IFIFO) |
| #endif |
| ) { |
| /* Types match. */ |
| } else { |
| /* Types don't match; bail out gracefully. */ |
| if (mtree->fd >= 0) |
| close(mtree->fd); |
| mtree->fd = -1; |
| if (parsed_kws & MTREE_HAS_OPTIONAL) { |
| /* It's not an error for an optional |
| * entry to not match disk. */ |
| *use_next = 1; |
| } else if (r == ARCHIVE_OK) { |
| archive_set_error(&a->archive, |
| ARCHIVE_ERRNO_MISC, |
| "mtree specification has different" |
| " type for %s", |
| archive_entry_pathname(entry)); |
| r = ARCHIVE_WARN; |
| } |
| return (r); |
| } |
| } |
| |
| /* |
| * If there is a contents file on disk, pick some of the |
| * metadata from that file. For most of these, we only |
| * set it from the contents if it wasn't already parsed |
| * from the specification. |
| */ |
| if (st != NULL) { |
| if (((parsed_kws & MTREE_HAS_DEVICE) == 0 || |
| (parsed_kws & MTREE_HAS_NOCHANGE) != 0) && |
| (archive_entry_filetype(entry) == AE_IFCHR || |
| archive_entry_filetype(entry) == AE_IFBLK)) |
| archive_entry_set_rdev(entry, st->st_rdev); |
| if ((parsed_kws & (MTREE_HAS_GID | MTREE_HAS_GNAME)) |
| == 0 || |
| (parsed_kws & MTREE_HAS_NOCHANGE) != 0) |
| archive_entry_set_gid(entry, st->st_gid); |
| if ((parsed_kws & (MTREE_HAS_UID | MTREE_HAS_UNAME)) |
| == 0 || |
| (parsed_kws & MTREE_HAS_NOCHANGE) != 0) |
| archive_entry_set_uid(entry, st->st_uid); |
| if ((parsed_kws & MTREE_HAS_MTIME) == 0 || |
| (parsed_kws & MTREE_HAS_NOCHANGE) != 0) { |
| #if HAVE_STRUCT_STAT_ST_MTIMESPEC_TV_NSEC |
| archive_entry_set_mtime(entry, st->st_mtime, |
| st->st_mtimespec.tv_nsec); |
| #elif HAVE_STRUCT_STAT_ST_MTIM_TV_NSEC |
| archive_entry_set_mtime(entry, st->st_mtime, |
| st->st_mtim.tv_nsec); |
| #elif HAVE_STRUCT_STAT_ST_MTIME_N |
| archive_entry_set_mtime(entry, st->st_mtime, |
| st->st_mtime_n); |
| #elif HAVE_STRUCT_STAT_ST_UMTIME |
| archive_entry_set_mtime(entry, st->st_mtime, |
| st->st_umtime*1000); |
| #elif HAVE_STRUCT_STAT_ST_MTIME_USEC |
| archive_entry_set_mtime(entry, st->st_mtime, |
| st->st_mtime_usec*1000); |
| #else |
| archive_entry_set_mtime(entry, st->st_mtime, 0); |
| #endif |
| } |
| if ((parsed_kws & MTREE_HAS_NLINK) == 0 || |
| (parsed_kws & MTREE_HAS_NOCHANGE) != 0) |
| archive_entry_set_nlink(entry, st->st_nlink); |
| if ((parsed_kws & MTREE_HAS_PERM) == 0 || |
| (parsed_kws & MTREE_HAS_NOCHANGE) != 0) |
| archive_entry_set_perm(entry, st->st_mode); |
| if ((parsed_kws & MTREE_HAS_SIZE) == 0 || |
| (parsed_kws & MTREE_HAS_NOCHANGE) != 0) |
| archive_entry_set_size(entry, st->st_size); |
| archive_entry_set_ino(entry, st->st_ino); |
| archive_entry_set_dev(entry, st->st_dev); |
| |
| archive_entry_linkify(mtree->resolver, &entry, |
| &sparse_entry); |
| } else if (parsed_kws & MTREE_HAS_OPTIONAL) { |
| /* |
| * Couldn't open the entry, stat it or the on-disk type |
| * didn't match. If this entry is optional, just |
| * ignore it and read the next header entry. |
| */ |
| *use_next = 1; |
| return ARCHIVE_OK; |
| } |
| } |
| |
| mtree->cur_size = archive_entry_size(entry); |
| mtree->offset = 0; |
| |
| return r; |
| } |
| |
| /* |
| * Each line contains a sequence of keywords. |
| */ |
| static int |
| parse_line(struct archive_read *a, struct archive_entry *entry, |
| struct mtree *mtree, struct mtree_entry *mp, int *parsed_kws) |
| { |
| struct mtree_option *iter; |
| int r = ARCHIVE_OK, r1; |
| |
| for (iter = mp->options; iter != NULL; iter = iter->next) { |
| r1 = parse_keyword(a, mtree, entry, iter, parsed_kws); |
| if (r1 < r) |
| r = r1; |
| } |
| if (r == ARCHIVE_OK && (*parsed_kws & MTREE_HAS_TYPE) == 0) { |
| archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, |
| "Missing type keyword in mtree specification"); |
| return (ARCHIVE_WARN); |
| } |
| return (r); |
| } |
| |
| /* |
| * Device entries have one of the following forms: |
| * - raw dev_t |
| * - format,major,minor[,subdevice] |
| * When parsing succeeded, `pdev' will contain the appropriate dev_t value. |
| */ |
| |
| /* strsep() is not in C90, but strcspn() is. */ |
| /* Taken from http://unixpapa.com/incnote/string.html */ |
| static char * |
| la_strsep(char **sp, const char *sep) |
| { |
| char *p, *s; |
| if (sp == NULL || *sp == NULL || **sp == '\0') |
| return(NULL); |
| s = *sp; |
| p = s + strcspn(s, sep); |
| if (*p != '\0') |
| *p++ = '\0'; |
| *sp = p; |
| return(s); |
| } |
| |
| static int |
| parse_device(dev_t *pdev, struct archive *a, char *val) |
| { |
| #define MAX_PACK_ARGS 3 |
| unsigned long numbers[MAX_PACK_ARGS]; |
| char *p, *dev; |
| int argc; |
| pack_t *pack; |
| dev_t result; |
| const char *error = NULL; |
| |
| memset(pdev, 0, sizeof(*pdev)); |
| if ((dev = strchr(val, ',')) != NULL) { |
| /* |
| * Device's major/minor are given in a specified format. |
| * Decode and pack it accordingly. |
| */ |
| *dev++ = '\0'; |
| if ((pack = pack_find(val)) == NULL) { |
| archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, |
| "Unknown format `%s'", val); |
| return ARCHIVE_WARN; |
| } |
| argc = 0; |
| while ((p = la_strsep(&dev, ",")) != NULL) { |
| if (*p == '\0') { |
| archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, |
| "Missing number"); |
| return ARCHIVE_WARN; |
| } |
| if (argc >= MAX_PACK_ARGS) { |
| archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, |
| "Too many arguments"); |
| return ARCHIVE_WARN; |
| } |
| numbers[argc++] = (unsigned long)mtree_atol(&p, 0); |
| } |
| if (argc < 2) { |
| archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, |
| "Not enough arguments"); |
| return ARCHIVE_WARN; |
| } |
| result = (*pack)(argc, numbers, &error); |
| if (error != NULL) { |
| archive_set_error(a, ARCHIVE_ERRNO_FILE_FORMAT, |
| "%s", error); |
| return ARCHIVE_WARN; |
| } |
| } else { |
| /* file system raw value. */ |
| result = (dev_t)mtree_atol(&val, 0); |
| } |
| *pdev = result; |
| return ARCHIVE_OK; |
| #undef MAX_PACK_ARGS |
| } |
| |
| /* |
| * Parse a single keyword and its value. |
| */ |
| static int |
| parse_keyword(struct archive_read *a, struct mtree *mtree, |
| struct archive_entry *entry, struct mtree_option *opt, int *parsed_kws) |
| { |
| char *val, *key; |
| |
| key = opt->value; |
| |
| if (*key == '\0') |
| return (ARCHIVE_OK); |
| |
| if (strcmp(key, "nochange") == 0) { |
| *parsed_kws |= MTREE_HAS_NOCHANGE; |
| return (ARCHIVE_OK); |
| } |
| if (strcmp(key, "optional") == 0) { |
| *parsed_kws |= MTREE_HAS_OPTIONAL; |
| return (ARCHIVE_OK); |
| } |
| if (strcmp(key, "ignore") == 0) { |
| /* |
| * The mtree processing is not recursive, so |
| * recursion will only happen for explicitly listed |
| * entries. |
| */ |
| return (ARCHIVE_OK); |
| } |
| |
| val = strchr(key, '='); |
| if (val == NULL) { |
| archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, |
| "Malformed attribute \"%s\" (%d)", key, key[0]); |
| return (ARCHIVE_WARN); |
| } |
| |
| *val = '\0'; |
| ++val; |
| |
| switch (key[0]) { |
| case 'c': |
| if (strcmp(key, "content") == 0 |
| || strcmp(key, "contents") == 0) { |
| parse_escapes(val, NULL); |
| archive_strcpy(&mtree->contents_name, val); |
| break; |
| } |
| if (strcmp(key, "cksum") == 0) |
| break; |
| __LA_FALLTHROUGH; |
| case 'd': |
| if (strcmp(key, "device") == 0) { |
| /* stat(2) st_rdev field, e.g. the major/minor IDs |
| * of a char/block special file */ |
| int r; |
| dev_t dev; |
| |
| *parsed_kws |= MTREE_HAS_DEVICE; |
| r = parse_device(&dev, &a->archive, val); |
| if (r == ARCHIVE_OK) |
| archive_entry_set_rdev(entry, dev); |
| return r; |
| } |
| __LA_FALLTHROUGH; |
| case 'f': |
| if (strcmp(key, "flags") == 0) { |
| *parsed_kws |= MTREE_HAS_FFLAGS; |
| archive_entry_copy_fflags_text(entry, val); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 'g': |
| if (strcmp(key, "gid") == 0) { |
| *parsed_kws |= MTREE_HAS_GID; |
| archive_entry_set_gid(entry, mtree_atol(&val, 10)); |
| break; |
| } |
| if (strcmp(key, "gname") == 0) { |
| *parsed_kws |= MTREE_HAS_GNAME; |
| archive_entry_copy_gname(entry, val); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 'i': |
| if (strcmp(key, "inode") == 0) { |
| archive_entry_set_ino(entry, mtree_atol(&val, 10)); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 'l': |
| if (strcmp(key, "link") == 0) { |
| archive_entry_copy_symlink(entry, val); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 'm': |
| if (strcmp(key, "md5") == 0 || strcmp(key, "md5digest") == 0) |
| break; |
| if (strcmp(key, "mode") == 0) { |
| if (val[0] >= '0' && val[0] <= '7') { |
| *parsed_kws |= MTREE_HAS_PERM; |
| archive_entry_set_perm(entry, |
| (mode_t)mtree_atol(&val, 8)); |
| } else { |
| archive_set_error(&a->archive, |
| ARCHIVE_ERRNO_FILE_FORMAT, |
| "Symbolic or non-octal mode \"%s\" unsupported", val); |
| return ARCHIVE_WARN; |
| } |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 'n': |
| if (strcmp(key, "nlink") == 0) { |
| *parsed_kws |= MTREE_HAS_NLINK; |
| archive_entry_set_nlink(entry, |
| (unsigned int)mtree_atol(&val, 10)); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 'r': |
| if (strcmp(key, "resdevice") == 0) { |
| /* stat(2) st_dev field, e.g. the device ID where the |
| * inode resides */ |
| int r; |
| dev_t dev; |
| |
| r = parse_device(&dev, &a->archive, val); |
| if (r == ARCHIVE_OK) |
| archive_entry_set_dev(entry, dev); |
| return r; |
| } |
| if (strcmp(key, "rmd160") == 0 || |
| strcmp(key, "rmd160digest") == 0) |
| break; |
| __LA_FALLTHROUGH; |
| case 's': |
| if (strcmp(key, "sha1") == 0 || strcmp(key, "sha1digest") == 0) |
| break; |
| if (strcmp(key, "sha256") == 0 || |
| strcmp(key, "sha256digest") == 0) |
| break; |
| if (strcmp(key, "sha384") == 0 || |
| strcmp(key, "sha384digest") == 0) |
| break; |
| if (strcmp(key, "sha512") == 0 || |
| strcmp(key, "sha512digest") == 0) |
| break; |
| if (strcmp(key, "size") == 0) { |
| archive_entry_set_size(entry, mtree_atol(&val, 10)); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 't': |
| if (strcmp(key, "tags") == 0) { |
| /* |
| * Comma delimited list of tags. |
| * Ignore the tags for now, but the interface |
| * should be extended to allow inclusion/exclusion. |
| */ |
| break; |
| } |
| if (strcmp(key, "time") == 0) { |
| int64_t m; |
| int64_t my_time_t_max = get_time_t_max(); |
| int64_t my_time_t_min = get_time_t_min(); |
| long ns = 0; |
| |
| *parsed_kws |= MTREE_HAS_MTIME; |
| m = mtree_atol(&val, 10); |
| /* Replicate an old mtree bug: |
| * 123456789.1 represents 123456789 |
| * seconds and 1 nanosecond. */ |
| if (*val == '.') { |
| ++val; |
| ns = (long)mtree_atol(&val, 10); |
| if (ns < 0) |
| ns = 0; |
| else if (ns > 999999999) |
| ns = 999999999; |
| } |
| if (m > my_time_t_max) |
| m = my_time_t_max; |
| else if (m < my_time_t_min) |
| m = my_time_t_min; |
| archive_entry_set_mtime(entry, (time_t)m, ns); |
| break; |
| } |
| if (strcmp(key, "type") == 0) { |
| switch (val[0]) { |
| case 'b': |
| if (strcmp(val, "block") == 0) { |
| archive_entry_set_filetype(entry, AE_IFBLK); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 'c': |
| if (strcmp(val, "char") == 0) { |
| archive_entry_set_filetype(entry, |
| AE_IFCHR); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 'd': |
| if (strcmp(val, "dir") == 0) { |
| archive_entry_set_filetype(entry, |
| AE_IFDIR); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 'f': |
| if (strcmp(val, "fifo") == 0) { |
| archive_entry_set_filetype(entry, |
| AE_IFIFO); |
| break; |
| } |
| if (strcmp(val, "file") == 0) { |
| archive_entry_set_filetype(entry, |
| AE_IFREG); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 'l': |
| if (strcmp(val, "link") == 0) { |
| archive_entry_set_filetype(entry, |
| AE_IFLNK); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| default: |
| archive_set_error(&a->archive, |
| ARCHIVE_ERRNO_FILE_FORMAT, |
| "Unrecognized file type \"%s\"; " |
| "assuming \"file\"", val); |
| archive_entry_set_filetype(entry, AE_IFREG); |
| return (ARCHIVE_WARN); |
| } |
| *parsed_kws |= MTREE_HAS_TYPE; |
| break; |
| } |
| __LA_FALLTHROUGH; |
| case 'u': |
| if (strcmp(key, "uid") == 0) { |
| *parsed_kws |= MTREE_HAS_UID; |
| archive_entry_set_uid(entry, mtree_atol(&val, 10)); |
| break; |
| } |
| if (strcmp(key, "uname") == 0) { |
| *parsed_kws |= MTREE_HAS_UNAME; |
| archive_entry_copy_uname(entry, val); |
| break; |
| } |
| __LA_FALLTHROUGH; |
| default: |
| archive_set_error(&a->archive, ARCHIVE_ERRNO_FILE_FORMAT, |
| "Unrecognized key %s=%s", key, val); |
| return (ARCHIVE_WARN); |
| } |
| return (ARCHIVE_OK); |
| } |
| |
| static int |
| read_data(struct archive_read *a, const void **buff, size_t *size, |
| int64_t *offset) |
| { |
| size_t bytes_to_read; |
| ssize_t bytes_read; |
| struct mtree *mtree; |
| |
| mtree = (struct mtree *)(a->format->data); |
| if (mtree->fd < 0) { |
| *buff = NULL; |
| *offset = 0; |
| *size = 0; |
| return (ARCHIVE_EOF); |
| } |
| if (mtree->buff == NULL) { |
| mtree->buffsize = 64 * 1024; |
| mtree->buff = malloc(mtree->buffsize); |
| if (mtree->buff == NULL) { |
| archive_set_error(&a->archive, ENOMEM, |
| "Can't allocate memory"); |
| return (ARCHIVE_FATAL); |
| } |
| } |
| |
| *buff = mtree->buff; |
| *offset = mtree->offset; |
| if ((int64_t)mtree->buffsize > mtree->cur_size - mtree->offset) |
| bytes_to_read = (size_t)(mtree->cur_size - mtree->offset); |
| else |
| bytes_to_read = mtree->buffsize; |
| bytes_read = read(mtree->fd, mtree->buff, bytes_to_read); |
| if (bytes_read < 0) { |
| archive_set_error(&a->archive, errno, "Can't read"); |
| return (ARCHIVE_WARN); |
| } |
| if (bytes_read == 0) { |
| *size = 0; |
| return (ARCHIVE_EOF); |
| } |
| mtree->offset += bytes_read; |
| *size = bytes_read; |
| return (ARCHIVE_OK); |
| } |
| |
| /* Skip does nothing except possibly close the contents file. */ |
| static int |
| skip(struct archive_read *a) |
| { |
| struct mtree *mtree; |
| |
| mtree = (struct mtree *)(a->format->data); |
| if (mtree->fd >= 0) { |
| close(mtree->fd); |
| mtree->fd = -1; |
| } |
| return (ARCHIVE_OK); |
| } |
| |
| /* |
| * Since parsing backslash sequences always makes strings shorter, |
| * we can always do this conversion in-place. |
| */ |
| static void |
| parse_escapes(char *src, struct mtree_entry *mentry) |
| { |
| char *dest = src; |
| char c; |
| |
| if (mentry != NULL && strcmp(src, ".") == 0) |
| mentry->full = 1; |
| |
| while (*src != '\0') { |
| c = *src++; |
| if (c == '/' && mentry != NULL) |
| mentry->full = 1; |
| if (c == '\\') { |
| switch (src[0]) { |
| case '0': |
| if (src[1] < '0' || src[1] > '7') { |
| c = 0; |
| ++src; |
| break; |
| } |
| /* FALLTHROUGH */ |
| case '1': |
| case '2': |
| case '3': |
| if (src[1] >= '0' && src[1] <= '7' && |
| src[2] >= '0' && src[2] <= '7') { |
| c = (src[0] - '0') << 6; |
| c |= (src[1] - '0') << 3; |
| c |= (src[2] - '0'); |
| src += 3; |
| } |
| break; |
| case 'a': |
| c = '\a'; |
| ++src; |
| break; |
| case 'b': |
| c = '\b'; |
| ++src; |
| break; |
| case 'f': |
| c = '\f'; |
| ++src; |
| break; |
| case 'n': |
| c = '\n'; |
| ++src; |
| break; |
| case 'r': |
| c = '\r'; |
| ++src; |
| break; |
| case 's': |
| c = ' '; |
| ++src; |
| break; |
| case 't': |
| c = '\t'; |
| ++src; |
| break; |
| case 'v': |
| c = '\v'; |
| ++src; |
| break; |
| case '\\': |
| c = '\\'; |
| ++src; |
| break; |
| } |
| } |
| *dest++ = c; |
| } |
| *dest = '\0'; |
| } |
| |
| /* Parse a hex digit. */ |
| static int |
| parsedigit(char c) |
| { |
| if (c >= '0' && c <= '9') |
| return c - '0'; |
| else if (c >= 'a' && c <= 'f') |
| return c - 'a'; |
| else if (c >= 'A' && c <= 'F') |
| return c - 'A'; |
| else |
| return -1; |
| } |
| |
| /* |
| * Note that this implementation does not (and should not!) obey |
| * locale settings; you cannot simply substitute strtol here, since |
| * it does obey locale. |
| */ |
| static int64_t |
| mtree_atol(char **p, int base) |
| { |
| int64_t l, limit; |
| int digit, last_digit_limit; |
| |
| if (base == 0) { |
| if (**p != '0') |
| base = 10; |
| else if ((*p)[1] == 'x' || (*p)[1] == 'X') { |
| *p += 2; |
| base = 16; |
| } else { |
| base = 8; |
| } |
| } |
| |
| if (**p == '-') { |
| limit = INT64_MIN / base; |
| last_digit_limit = INT64_MIN % base; |
| ++(*p); |
| |
| l = 0; |
| digit = parsedigit(**p); |
| while (digit >= 0 && digit < base) { |
| if (l < limit || (l == limit && digit > last_digit_limit)) |
| return INT64_MIN; |
| l = (l * base) - digit; |
| digit = parsedigit(*++(*p)); |
| } |
| return l; |
| } else { |
| limit = INT64_MAX / base; |
| last_digit_limit = INT64_MAX % base; |
| |
| l = 0; |
| digit = parsedigit(**p); |
| while (digit >= 0 && digit < base) { |
| if (l > limit || (l == limit && digit > last_digit_limit)) |
| return INT64_MAX; |
| l = (l * base) + digit; |
| digit = parsedigit(*++(*p)); |
| } |
| return l; |
| } |
| } |
| |
| /* |
| * Returns length of line (including trailing newline) |
| * or negative on error. 'start' argument is updated to |
| * point to first character of line. |
| */ |
| static ssize_t |
| readline(struct archive_read *a, struct mtree *mtree, char **start, |
| ssize_t limit) |
| { |
| ssize_t bytes_read; |
| ssize_t total_size = 0; |
| ssize_t find_off = 0; |
| const void *t; |
| void *nl; |
| char *u; |
| |
| /* Accumulate line in a line buffer. */ |
| for (;;) { |
| /* Read some more. */ |
| t = __archive_read_ahead(a, 1, &bytes_read); |
| if (t == NULL) |
| return (0); |
| if (bytes_read < 0) |
| return (ARCHIVE_FATAL); |
| nl = memchr(t, '\n', bytes_read); |
| /* If we found '\n', trim the read to end exactly there. */ |
| if (nl != NULL) { |
| bytes_read = ((const char *)nl) - ((const char *)t) + 1; |
| } |
| if (total_size + bytes_read + 1 > limit) { |
| archive_set_error(&a->archive, |
| ARCHIVE_ERRNO_FILE_FORMAT, |
| "Line too long"); |
| return (ARCHIVE_FATAL); |
| } |
| if (archive_string_ensure(&mtree->line, |
| total_size + bytes_read + 1) == NULL) { |
| archive_set_error(&a->archive, ENOMEM, |
| "Can't allocate working buffer"); |
| return (ARCHIVE_FATAL); |
| } |
| /* Append new bytes to string. */ |
| memcpy(mtree->line.s + total_size, t, bytes_read); |
| __archive_read_consume(a, bytes_read); |
| total_size += bytes_read; |
| mtree->line.s[total_size] = '\0'; |
| |
| for (u = mtree->line.s + find_off; *u; ++u) { |
| if (u[0] == '\n') { |
| /* Ends with unescaped newline. */ |
| *start = mtree->line.s; |
| return total_size; |
| } else if (u[0] == '#') { |
| /* Ends with comment sequence #...\n */ |
| if (nl == NULL) { |
| /* But we've not found the \n yet */ |
| break; |
| } |
| } else if (u[0] == '\\') { |
| if (u[1] == '\n') { |
| /* Trim escaped newline. */ |
| total_size -= 2; |
| mtree->line.s[total_size] = '\0'; |
| break; |
| } else if (u[1] != '\0') { |
| /* Skip the two-char escape sequence */ |
| ++u; |
| } |
| } |
| } |
| find_off = u - mtree->line.s; |
| } |
| } |