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$"); 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 int 104 archive_file_count(struct archive *a) 105 { 106 return (a->file_count); 107 } 108 109 int 110 archive_format(struct archive *a) 111 { 112 return (a->archive_format); 113 } 114 115 const char * 116 archive_format_name(struct archive *a) 117 { 118 return (a->archive_format_name); 119 } 120 121 122 int 123 archive_compression(struct archive *a) 124 { 125 return (a->compression_code); 126 } 127 128 const char * 129 archive_compression_name(struct archive *a) 130 { 131 return (a->compression_name); 132 } 133 134 135 /* 136 * Return a count of the number of compressed bytes processed. 137 */ 138 int64_t 139 archive_position_compressed(struct archive *a) 140 { 141 return (a->raw_position); 142 } 143 144 /* 145 * Return a count of the number of uncompressed bytes processed. 146 */ 147 int64_t 148 archive_position_uncompressed(struct archive *a) 149 { 150 return (a->file_position); 151 } 152 153 void 154 archive_clear_error(struct archive *a) 155 { 156 archive_string_empty(&a->error_string); 157 a->error = NULL; 158 a->archive_error_number = 0; 159 } 160 161 void 162 archive_set_error(struct archive *a, int error_number, const char *fmt, ...) 163 { 164 va_list ap; 165 166 a->archive_error_number = error_number; 167 if (fmt == NULL) { 168 a->error = NULL; 169 return; 170 } 171 172 va_start(ap, fmt); 173 archive_string_vsprintf(&(a->error_string), fmt, ap); 174 va_end(ap); 175 a->error = a->error_string.s; 176 } 177 178 void 179 archive_copy_error(struct archive *dest, struct archive *src) 180 { 181 dest->archive_error_number = src->archive_error_number; 182 183 archive_string_copy(&dest->error_string, &src->error_string); 184 dest->error = dest->error_string.s; 185 } 186 187 void 188 __archive_errx(int retvalue, const char *msg) 189 { 190 static const char *msg1 = "Fatal Internal Error in libarchive: "; 191 size_t s; 192 193 s = write(2, msg1, strlen(msg1)); 194 (void)s; /* UNUSED */ 195 s = write(2, msg, strlen(msg)); 196 (void)s; /* UNUSED */ 197 s = write(2, "\n", 1); 198 (void)s; /* UNUSED */ 199 exit(retvalue); 200 } 201 202 /* 203 * Parse option strings 204 * Detail of option format. 205 * - The option can accept: 206 * "opt-name", "!opt-name", "opt-name=value". 207 * 208 * - The option entries are separated by comma. 209 * e.g "compression=9,opt=XXX,opt-b=ZZZ" 210 * 211 * - The name of option string consist of '-' and alphabet 212 * but character '-' cannot be used for the first character. 213 * (Regular expression is [a-z][-a-z]+) 214 * 215 * - For a specfic format/filter, using the format name with ':'. 216 * e.g "zip:compression=9" 217 * (This "compression=9" option entry is for "zip" format only) 218 * 219 * If another entries follow it, those are not for 220 * the specfic format/filter. 221 * e.g handle "zip:compression=9,opt=XXX,opt-b=ZZZ" 222 * "zip" format/filter handler will get "compression=9" 223 * all format/filter handler will get "opt=XXX" 224 * all format/filter handler will get "opt-b=ZZZ" 225 * 226 * - Whitespace and tab are bypassed. 227 * 228 */ 229 int 230 __archive_parse_options(const char *p, const char *fn, int keysize, char *key, 231 int valsize, char *val) 232 { 233 const char *p_org; 234 int apply; 235 int kidx, vidx; 236 int negative; 237 enum { 238 /* Requested for initialization. */ 239 INIT, 240 /* Finding format/filter-name and option-name. */ 241 F_BOTH, 242 /* Finding option-name only. 243 * (already detected format/filter-name) */ 244 F_NAME, 245 /* Getting option-value. */ 246 G_VALUE, 247 } state; 248 249 p_org = p; 250 state = INIT; 251 kidx = vidx = negative = 0; 252 apply = 1; 253 while (*p) { 254 switch (state) { 255 case INIT: 256 kidx = vidx = 0; 257 negative = 0; 258 apply = 1; 259 state = F_BOTH; 260 break; 261 case F_BOTH: 262 case F_NAME: 263 if ((*p >= 'a' && *p <= 'z') || 264 (*p >= '0' && *p <= '9') || *p == '-') { 265 if (kidx == 0 && !(*p >= 'a' && *p <= 'z')) 266 /* Illegal sequence. */ 267 return (-1); 268 if (kidx >= keysize -1) 269 /* Too many characters. */ 270 return (-1); 271 key[kidx++] = *p++; 272 } else if (*p == '!') { 273 if (kidx != 0) 274 /* Illegal sequence. */ 275 return (-1); 276 negative = 1; 277 ++p; 278 } else if (*p == ',') { 279 if (kidx == 0) 280 /* Illegal sequence. */ 281 return (-1); 282 if (!negative) 283 val[vidx++] = '1'; 284 /* We have got boolean option data. */ 285 ++p; 286 if (apply) 287 goto complete; 288 else 289 /* This option does not apply to the 290 * format which the fn variable 291 * indicate. */ 292 state = INIT; 293 } else if (*p == ':') { 294 /* obuf data is format name */ 295 if (state == F_NAME) 296 /* We already found it. */ 297 return (-1); 298 if (kidx == 0) 299 /* Illegal sequence. */ 300 return (-1); 301 if (negative) 302 /* We cannot accept "!format-name:". */ 303 return (-1); 304 key[kidx] = '\0'; 305 if (strcmp(fn, key) != 0) 306 /* This option does not apply to the 307 * format which the fn variable 308 * indicate. */ 309 apply = 0; 310 kidx = 0; 311 ++p; 312 state = F_NAME; 313 } else if (*p == '=') { 314 if (kidx == 0) 315 /* Illegal sequence. */ 316 return (-1); 317 if (negative) 318 /* We cannot accept "!opt-name=value". */ 319 return (-1); 320 ++p; 321 state = G_VALUE; 322 } else if (*p == ' ') { 323 /* Pass the space character */ 324 ++p; 325 } else { 326 /* Illegal character. */ 327 return (-1); 328 } 329 break; 330 case G_VALUE: 331 if (*p == ',') { 332 if (vidx == 0) 333 /* Illegal sequence. */ 334 return (-1); 335 /* We have got option data. */ 336 ++p; 337 if (apply) 338 goto complete; 339 else 340 /* This option does not apply to the 341 * format which the fn variable 342 * indicate. */ 343 state = INIT; 344 } else if (*p == ' ') { 345 /* Pass the space character */ 346 ++p; 347 } else { 348 if (vidx >= valsize -1) 349 /* Too many characters. */ 350 return (-1); 351 val[vidx++] = *p++; 352 } 353 break; 354 } 355 } 356 357 switch (state) { 358 case F_BOTH: 359 case F_NAME: 360 if (kidx != 0) { 361 if (!negative) 362 val[vidx++] = '1'; 363 /* We have got boolean option. */ 364 if (apply) 365 /* This option apply to the format which the 366 * fn variable indicate. */ 367 goto complete; 368 } 369 break; 370 case G_VALUE: 371 if (vidx == 0) 372 /* Illegal sequence. */ 373 return (-1); 374 /* We have got option value. */ 375 if (apply) 376 /* This option apply to the format which the fn 377 * variable indicate. */ 378 goto complete; 379 break; 380 case INIT:/* nothing */ 381 break; 382 } 383 384 /* End of Option string. */ 385 return (0); 386 387 complete: 388 key[kidx] = '\0'; 389 val[vidx] = '\0'; 390 /* Return a size which we've consumed for detecting option */ 391 return ((int)(p - p_org)); 392 } 393