1 /*-
2  * Copyright (c) 2009 Michihiro NAKAJIMA
3  * Copyright (c) 2003-2007 Tim Kientzle
4  * All rights reserved.
5  *
6  * Redistribution and use in source and binary forms, with or without
7  * modification, are permitted provided that the following conditions
8  * are met:
9  * 1. Redistributions of source code must retain the above copyright
10  *    notice, this list of conditions and the following disclaimer.
11  * 2. Redistributions in binary form must reproduce the above copyright
12  *    notice, this list of conditions and the following disclaimer in the
13  *    documentation and/or other materials provided with the distribution.
14  *
15  * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR
16  * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
17  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
18  * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT,
19  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
20  * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
21  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
22  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
23  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
24  * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
25  */
26 
27 #include "archive_platform.h"
28 __FBSDID("$FreeBSD: src/lib/libarchive/archive_util.c,v 1.19 2008/10/21 12:10:30 des Exp $");
29 
30 #ifdef HAVE_SYS_TYPES_H
31 #include <sys/types.h>
32 #endif
33 #ifdef HAVE_STDLIB_H
34 #include <stdlib.h>
35 #endif
36 #ifdef HAVE_STRING_H
37 #include <string.h>
38 #endif
39 
40 #include "archive.h"
41 #include "archive_private.h"
42 #include "archive_string.h"
43 
44 #if ARCHIVE_VERSION_NUMBER < 3000000
45 /* These disappear in libarchive 3.0 */
46 /* Deprecated. */
47 int
48 archive_api_feature(void)
49 {
50 	return (ARCHIVE_API_FEATURE);
51 }
52 
53 /* Deprecated. */
54 int
55 archive_api_version(void)
56 {
57 	return (ARCHIVE_API_VERSION);
58 }
59 
60 /* Deprecated synonym for archive_version_number() */
61 int
62 archive_version_stamp(void)
63 {
64 	return (archive_version_number());
65 }
66 
67 /* Deprecated synonym for archive_version_string() */
68 const char *
69 archive_version(void)
70 {
71 	return (archive_version_string());
72 }
73 #endif
74 
75 int
76 archive_version_number(void)
77 {
78 	return (ARCHIVE_VERSION_NUMBER);
79 }
80 
81 const char *
82 archive_version_string(void)
83 {
84 	return (ARCHIVE_VERSION_STRING);
85 }
86 
87 int
88 archive_errno(struct archive *a)
89 {
90 	return (a->archive_error_number);
91 }
92 
93 const char *
94 archive_error_string(struct archive *a)
95 {
96 
97 	if (a->error != NULL  &&  *a->error != '\0')
98 		return (a->error);
99 	else
100 		return ("(Empty error message)");
101 }
102 
103 
104 int
105 archive_format(struct archive *a)
106 {
107 	return (a->archive_format);
108 }
109 
110 const char *
111 archive_format_name(struct archive *a)
112 {
113 	return (a->archive_format_name);
114 }
115 
116 
117 int
118 archive_compression(struct archive *a)
119 {
120 	return (a->compression_code);
121 }
122 
123 const char *
124 archive_compression_name(struct archive *a)
125 {
126 	return (a->compression_name);
127 }
128 
129 
130 /*
131  * Return a count of the number of compressed bytes processed.
132  */
133 int64_t
134 archive_position_compressed(struct archive *a)
135 {
136 	return (a->raw_position);
137 }
138 
139 /*
140  * Return a count of the number of uncompressed bytes processed.
141  */
142 int64_t
143 archive_position_uncompressed(struct archive *a)
144 {
145 	return (a->file_position);
146 }
147 
148 void
149 archive_clear_error(struct archive *a)
150 {
151 	archive_string_empty(&a->error_string);
152 	a->error = NULL;
153 }
154 
155 void
156 archive_set_error(struct archive *a, int error_number, const char *fmt, ...)
157 {
158 	va_list ap;
159 
160 	a->archive_error_number = error_number;
161 	if (fmt == NULL) {
162 		a->error = NULL;
163 		return;
164 	}
165 
166 	va_start(ap, fmt);
167 	archive_string_vsprintf(&(a->error_string), fmt, ap);
168 	va_end(ap);
169 	a->error = a->error_string.s;
170 }
171 
172 void
173 archive_copy_error(struct archive *dest, struct archive *src)
174 {
175 	dest->archive_error_number = src->archive_error_number;
176 
177 	archive_string_copy(&dest->error_string, &src->error_string);
178 	dest->error = dest->error_string.s;
179 }
180 
181 void
182 __archive_errx(int retvalue, const char *msg)
183 {
184 	static const char *msg1 = "Fatal Internal Error in libarchive: ";
185 	write(2, msg1, strlen(msg1));
186 	write(2, msg, strlen(msg));
187 	write(2, "\n", 1);
188 	exit(retvalue);
189 }
190 
191 /*
192  * Parse option strings
193  *  Detail of option format.
194  *    - The option can accept:
195  *     "opt-name", "!opt-name", "opt-name=value".
196  *
197  *    - The option entries are separated by comma.
198  *        e.g  "compression=9,opt=XXX,opt-b=ZZZ"
199  *
200  *    - The name of option string consist of '-' and alphabet
201  *      but character '-' cannot be used for the first character.
202  *      (Regular expression is [a-z][-a-z]+)
203  *
204  *    - For a specfic format/filter, using the format name with ':'.
205  *        e.g  "zip:compression=9"
206  *        (This "compression=9" option entry is for "zip" format only)
207  *
208  *      If another entries follow it, those are not for
209  *      the specfic format/filter.
210  *        e.g  handle "zip:compression=9,opt=XXX,opt-b=ZZZ"
211  *          "zip" format/filter handler will get "compression=9"
212  *          all format/filter handler will get "opt=XXX"
213  *          all format/filter handler will get "opt-b=ZZZ"
214  *
215  *    - Whitespace and tab are bypassed.
216  *
217  */
218 int
219 __archive_parse_options(const char *p, const char *fn, int keysize, char *key,
220     int valsize, char *val)
221 {
222 	const char *p_org;
223 	int apply;
224 	int kidx, vidx;
225 	int negative;
226 	enum {
227 		/* Requested for initialization. */
228 		INIT,
229 		/* Finding format/filter-name and option-name. */
230 		F_BOTH,
231 		/* Finding option-name only.
232 		 * (already detected format/filter-name) */
233 		F_NAME,
234 		/* Getting option-value. */
235 		G_VALUE,
236 	} state;
237 
238 	p_org = p;
239 	state = INIT;
240 	kidx = vidx = negative = 0;
241 	apply = 1;
242 	while (*p) {
243 		switch (state) {
244 		case INIT:
245 			kidx = vidx = 0;
246 			negative = 0;
247 			apply = 1;
248 			state = F_BOTH;
249 			break;
250 		case F_BOTH:
251 		case F_NAME:
252 			if ((*p >= 'a' && *p <= 'z') ||
253 			    (*p >= '0' && *p <= '9') || *p == '-') {
254 				if (kidx == 0 && !(*p >= 'a' && *p <= 'z'))
255 					/* Illegal sequence. */
256 					return (-1);
257 				if (kidx >= keysize -1)
258 					/* Too many characters. */
259 					return (-1);
260 				key[kidx++] = *p++;
261 			} else if (*p == '!') {
262 				if (kidx != 0)
263 					/* Illegal sequence. */
264 					return (-1);
265 				negative = 1;
266 				++p;
267 			} else if (*p == ',') {
268 				if (kidx == 0)
269 					/* Illegal sequence. */
270 					return (-1);
271 				if (!negative)
272 					val[vidx++] = '1';
273 				/* We have got boolean option data. */
274 				++p;
275 				if (apply)
276 					goto complete;
277 				else
278 					/* This option does not apply to the
279 					 * format which the fn variable
280 					 * indicate. */
281 					state = INIT;
282 			} else if (*p == ':') {
283 				/* obuf data is format name */
284 				if (state == F_NAME)
285 					/* We already found it. */
286 					return (-1);
287 				if (kidx == 0)
288 					/* Illegal sequence. */
289 					return (-1);
290 				if (negative)
291 					/* We cannot accept "!format-name:". */
292 					return (-1);
293 				key[kidx] = '\0';
294 				if (strcmp(fn, key) != 0)
295 					/* This option does not apply to the
296 					 * format which the fn variable
297 					 * indicate. */
298 					apply = 0;
299 				kidx = 0;
300 				++p;
301 				state = F_NAME;
302 			} else if (*p == '=') {
303 				if (kidx == 0)
304 					/* Illegal sequence. */
305 					return (-1);
306 				if (negative)
307 					/* We cannot accept "!opt-name=value". */
308 					return (-1);
309 				++p;
310 				state = G_VALUE;
311 			} else if (*p == ' ') {
312 				/* Pass the space character */
313 				++p;
314 			} else {
315 				/* Illegal character. */
316 				return (-1);
317 			}
318 			break;
319 		case G_VALUE:
320 			if (*p == ',') {
321 				if (vidx == 0)
322 					/* Illegal sequence. */
323 					return (-1);
324 				/* We have got option data. */
325 				++p;
326 				if (apply)
327 					goto complete;
328 				else
329 					/* This option does not apply to the
330 					 * format which the fn variable
331 					 * indicate. */
332 					state = INIT;
333 			} else if (*p == ' ') {
334 				/* Pass the space character */
335 				++p;
336 			} else {
337 				if (vidx >= valsize -1)
338 					/* Too many characters. */
339 					return (-1);
340 				val[vidx++] = *p++;
341 			}
342 			break;
343 		}
344 	}
345 
346 	switch (state) {
347 	case F_BOTH:
348 	case F_NAME:
349 		if (kidx != 0) {
350 			if (!negative)
351 				val[vidx++] = '1';
352 			/* We have got boolean option. */
353 			if (apply)
354 				/* This option apply to the format which the
355 				 * fn variable indicate. */
356 				goto complete;
357 		}
358 		break;
359 	case G_VALUE:
360 		if (vidx == 0)
361 			/* Illegal sequence. */
362 			return (-1);
363 		/* We have got option value. */
364 		if (apply)
365 			/* This option apply to the format which the fn
366 			 * variable indicate. */
367 			goto complete;
368 		break;
369 	case INIT:/* nothing */
370 		break;
371 	}
372 
373 	/* End of Option string. */
374 	return (0);
375 
376 complete:
377 	key[kidx] = '\0';
378 	val[vidx] = '\0';
379 	/* Return a size which we've consumed for detecting option */
380 	return ((int)(p - p_org));
381 }
382