/*-

 * 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

#include "archive.h"

#include "archive_entry.h"

#include "archive_private.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	MTREE_HASHTABLE_SIZE 1024

struct mtree_option {

	struct mtree_option *next;

	char *value;

};

struct mtree_entry {

	struct mtree_entry *next;

	struct mtree_option *options;

	char *name;

	char full;

	char used;

	unsigned int name_hash;

	struct mtree_entry *hashtable_next;

};

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 mtree_entry	*entry_hashtable[MTREE_HASHTABLE_SIZE];

	struct archive_string	 current_dir;

	struct archive_string	 contents_name;

	struct archive_entry_linkresolver *resolver;

	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 unsigned int	hash(const char *);

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);

	}

}

int

archive_read_support_format_mtree(struct archive *_a)

{

	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->fd = -1;

	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;

		/* 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, *ht_iter;

	struct mtree_option *iter;

	const char *next, *eq, *name, *end;

	size_t name_len, len;

	int r, i;

	unsigned int ht_idx;

	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;