1 /*- 2 * Copyright (c) 2003-2007 Tim Kientzle 3 * All rights reserved. 4 * 5 * Redistribution and use in source and binary forms, with or without 6 * modification, are permitted provided that the following conditions 7 * are met: 8 * 1. Redistributions of source code must retain the above copyright 9 * notice, this list of conditions and the following disclaimer. 10 * 2. Redistributions in binary form must reproduce the above copyright 11 * notice, this list of conditions and the following disclaimer in the 12 * documentation and/or other materials provided with the distribution. 13 * 14 * THIS SOFTWARE IS PROVIDED BY THE AUTHOR(S) ``AS IS'' AND ANY EXPRESS OR 15 * IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES 16 * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. 17 * IN NO EVENT SHALL THE AUTHOR(S) BE LIABLE FOR ANY DIRECT, INDIRECT, 18 * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT 19 * NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, 20 * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY 21 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 22 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 23 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 24 */ 25 26 #include "archive_platform.h" 27 __FBSDID("$FreeBSD: src/lib/libarchive/archive_entry.c,v 1.55 2008/12/23 05:01:43 kientzle Exp $"); 28 29 #ifdef HAVE_SYS_STAT_H 30 #include <sys/stat.h> 31 #endif 32 #ifdef HAVE_SYS_TYPES_H 33 #include <sys/types.h> 34 #endif 35 #ifdef MAJOR_IN_MKDEV 36 #include <sys/mkdev.h> 37 #else 38 #ifdef MAJOR_IN_SYSMACROS 39 #include <sys/sysmacros.h> 40 #endif 41 #endif 42 #ifdef HAVE_LIMITS_H 43 #include <limits.h> 44 #endif 45 #ifdef HAVE_LINUX_FS_H 46 #include <linux/fs.h> /* for Linux file flags */ 47 #endif 48 /* 49 * Some Linux distributions have both linux/ext2_fs.h and ext2fs/ext2_fs.h. 50 * As the include guards don't agree, the order of include is important. 51 */ 52 #ifdef HAVE_LINUX_EXT2_FS_H 53 #include <linux/ext2_fs.h> /* for Linux file flags */ 54 #endif 55 #if defined(HAVE_EXT2FS_EXT2_FS_H) && !defined(__CYGWIN__) 56 #include <ext2fs/ext2_fs.h> /* for Linux file flags */ 57 #endif 58 #include <stddef.h> 59 #include <stdio.h> 60 #ifdef HAVE_STDLIB_H 61 #include <stdlib.h> 62 #endif 63 #ifdef HAVE_STRING_H 64 #include <string.h> 65 #endif 66 #ifdef HAVE_WCHAR_H 67 #include <wchar.h> 68 #endif 69 70 #include "archive.h" 71 #include "archive_entry.h" 72 #include "archive_private.h" 73 #include "archive_entry_private.h" 74 75 #undef max 76 #define max(a, b) ((a)>(b)?(a):(b)) 77 78 /* Play games to come up with a suitable makedev() definition. */ 79 #ifdef __QNXNTO__ 80 /* QNX. <sigh> */ 81 #include <sys/netmgr.h> 82 #define ae_makedev(maj, min) makedev(ND_LOCAL_NODE, (maj), (min)) 83 #elif defined makedev 84 /* There's a "makedev" macro. */ 85 #define ae_makedev(maj, min) makedev((maj), (min)) 86 #elif defined mkdev || ((defined _WIN32 || defined __WIN32__) && !defined(__CYGWIN__)) 87 /* Windows. <sigh> */ 88 #define ae_makedev(maj, min) mkdev((maj), (min)) 89 #else 90 /* There's a "makedev" function. */ 91 #define ae_makedev(maj, min) makedev((maj), (min)) 92 #endif 93 94 static void aes_clean(struct aes *); 95 static void aes_copy(struct aes *dest, struct aes *src); 96 static const char * aes_get_mbs(struct aes *); 97 static const wchar_t * aes_get_wcs(struct aes *); 98 static int aes_set_mbs(struct aes *, const char *mbs); 99 static int aes_copy_mbs(struct aes *, const char *mbs); 100 /* static void aes_set_wcs(struct aes *, const wchar_t *wcs); */ 101 static int aes_copy_wcs(struct aes *, const wchar_t *wcs); 102 static int aes_copy_wcs_len(struct aes *, const wchar_t *wcs, size_t); 103 104 static char * ae_fflagstostr(unsigned long bitset, unsigned long bitclear); 105 static const wchar_t *ae_wcstofflags(const wchar_t *stringp, 106 unsigned long *setp, unsigned long *clrp); 107 static const char *ae_strtofflags(const char *stringp, 108 unsigned long *setp, unsigned long *clrp); 109 static void append_entry_w(wchar_t **wp, const wchar_t *prefix, int tag, 110 const wchar_t *wname, int perm, int id); 111 static void append_id_w(wchar_t **wp, int id); 112 113 static int acl_special(struct archive_entry *entry, 114 int type, int permset, int tag); 115 static struct ae_acl *acl_new_entry(struct archive_entry *entry, 116 int type, int permset, int tag, int id); 117 static int isint_w(const wchar_t *start, const wchar_t *end, int *result); 118 static void next_field_w(const wchar_t **wp, const wchar_t **start, 119 const wchar_t **end, wchar_t *sep); 120 static int prefix_w(const wchar_t *start, const wchar_t *end, 121 const wchar_t *test); 122 static void 123 archive_entry_acl_add_entry_w_len(struct archive_entry *entry, int type, 124 int permset, int tag, int id, const wchar_t *name, size_t); 125 126 127 #ifndef HAVE_WCSCPY 128 static wchar_t * wcscpy(wchar_t *s1, const wchar_t *s2) 129 { 130 wchar_t *dest = s1; 131 while ((*s1 = *s2) != L'\0') 132 ++s1, ++s2; 133 return dest; 134 } 135 #endif 136 #ifndef HAVE_WCSLEN 137 static size_t wcslen(const wchar_t *s) 138 { 139 const wchar_t *p = s; 140 while (*p != L'\0') 141 ++p; 142 return p - s; 143 } 144 #endif 145 #ifndef HAVE_WMEMCMP 146 /* Good enough for simple equality testing, but not for sorting. */ 147 #define wmemcmp(a,b,i) memcmp((a), (b), (i) * sizeof(wchar_t)) 148 #endif 149 #ifndef HAVE_WMEMCPY 150 #define wmemcpy(a,b,i) (wchar_t *)memcpy((a), (b), (i) * sizeof(wchar_t)) 151 #endif 152 153 static void 154 aes_clean(struct aes *aes) 155 { 156 if (aes->aes_wcs) { 157 free((wchar_t *)(uintptr_t)aes->aes_wcs); 158 aes->aes_wcs = NULL; 159 } 160 archive_string_free(&(aes->aes_mbs)); 161 archive_string_free(&(aes->aes_utf8)); 162 aes->aes_set = 0; 163 } 164 165 static void 166 aes_copy(struct aes *dest, struct aes *src) 167 { 168 wchar_t *wp; 169 170 dest->aes_set = src->aes_set; 171 archive_string_copy(&(dest->aes_mbs), &(src->aes_mbs)); 172 archive_string_copy(&(dest->aes_utf8), &(src->aes_utf8)); 173 174 if (src->aes_wcs != NULL) { 175 wp = (wchar_t *)malloc((wcslen(src->aes_wcs) + 1) 176 * sizeof(wchar_t)); 177 if (wp == NULL) 178 __archive_errx(1, "No memory for aes_copy()"); 179 wcscpy(wp, src->aes_wcs); 180 dest->aes_wcs = wp; 181 } 182 } 183 184 static const char * 185 aes_get_utf8(struct aes *aes) 186 { 187 if (aes->aes_set & AES_SET_UTF8) 188 return (aes->aes_utf8.s); 189 if ((aes->aes_set & AES_SET_WCS) 190 && archive_strappend_w_utf8(&(aes->aes_utf8), aes->aes_wcs) != NULL) { 191 aes->aes_set |= AES_SET_UTF8; 192 return (aes->aes_utf8.s); 193 } 194 return (NULL); 195 } 196 197 static const char * 198 aes_get_mbs(struct aes *aes) 199 { 200 /* If we already have an MBS form, return that immediately. */ 201 if (aes->aes_set & AES_SET_MBS) 202 return (aes->aes_mbs.s); 203 /* If there's a WCS form, try converting with the native locale. */ 204 if ((aes->aes_set & AES_SET_WCS) 205 && archive_strappend_w_mbs(&(aes->aes_mbs), aes->aes_wcs) != NULL) { 206 aes->aes_set |= AES_SET_MBS; 207 return (aes->aes_mbs.s); 208 } 209 /* We'll use UTF-8 for MBS if all else fails. */ 210 return (aes_get_utf8(aes)); 211 } 212 213 static const wchar_t * 214 aes_get_wcs(struct aes *aes) 215 { 216 wchar_t *w; 217 int r; 218 219 /* Return WCS form if we already have it. */ 220 if (aes->aes_set & AES_SET_WCS) 221 return (aes->aes_wcs); 222 223 if (aes->aes_set & AES_SET_MBS) { 224 /* Try converting MBS to WCS using native locale. */ 225 /* 226 * No single byte will be more than one wide character, 227 * so this length estimate will always be big enough. 228 */ 229 size_t wcs_length = aes->aes_mbs.length; 230 231 w = (wchar_t *)malloc((wcs_length + 1) * sizeof(wchar_t)); 232 if (w == NULL) 233 __archive_errx(1, "No memory for aes_get_wcs()"); 234 r = mbstowcs(w, aes->aes_mbs.s, wcs_length); 235 if (r > 0) { 236 w[r] = 0; 237 aes->aes_set |= AES_SET_WCS; 238 return (aes->aes_wcs = w); 239 } 240 free(w); 241 } 242 243 if (aes->aes_set & AES_SET_UTF8) { 244 /* Try converting UTF8 to WCS. */ 245 aes->aes_wcs = __archive_string_utf8_w(&(aes->aes_utf8)); 246 if (aes->aes_wcs != NULL) 247 aes->aes_set |= AES_SET_WCS; 248 return (aes->aes_wcs); 249 } 250 return (NULL); 251 } 252 253 static int 254 aes_set_mbs(struct aes *aes, const char *mbs) 255 { 256 return (aes_copy_mbs(aes, mbs)); 257 } 258 259 static int 260 aes_copy_mbs(struct aes *aes, const char *mbs) 261 { 262 if (mbs == NULL) { 263 aes->aes_set = 0; 264 return (0); 265 } 266 aes->aes_set = AES_SET_MBS; /* Only MBS form is set now. */ 267 archive_strcpy(&(aes->aes_mbs), mbs); 268 archive_string_empty(&(aes->aes_utf8)); 269 if (aes->aes_wcs) { 270 free((wchar_t *)(uintptr_t)aes->aes_wcs); 271 aes->aes_wcs = NULL; 272 } 273 return (0); 274 } 275 276 /* 277 * The 'update' form tries to proactively update all forms of 278 * this string (WCS and MBS) and returns an error if any of 279 * them fail. This is used by the 'pax' handler, for instance, 280 * to detect and report character-conversion failures early while 281 * still allowing clients to get potentially useful values from 282 * the more tolerant lazy conversions. (get_mbs and get_wcs will 283 * strive to give the user something useful, so you can get hopefully 284 * usable values even if some of the character conversions are failing.) 285 */ 286 static int 287 aes_update_utf8(struct aes *aes, const char *utf8) 288 { 289 if (utf8 == NULL) { 290 aes->aes_set = 0; 291 return (1); /* Succeeded in clearing everything. */ 292 } 293 294 /* Save the UTF8 string. */ 295 archive_strcpy(&(aes->aes_utf8), utf8); 296 297 /* Empty the mbs and wcs strings. */ 298 archive_string_empty(&(aes->aes_mbs)); 299 if (aes->aes_wcs) { 300 free((wchar_t *)(uintptr_t)aes->aes_wcs); 301 aes->aes_wcs = NULL; 302 } 303 304 aes->aes_set = AES_SET_UTF8; /* Only UTF8 is set now. */ 305 306 /* TODO: We should just do a direct UTF-8 to MBS conversion 307 * here. That would be faster, use less space, and give the 308 * same information. (If a UTF-8 to MBS conversion succeeds, 309 * then UTF-8->WCS and Unicode->MBS conversions will both 310 * succeed.) */ 311 312 /* Try converting UTF8 to WCS, return false on failure. */ 313 aes->aes_wcs = __archive_string_utf8_w(&(aes->aes_utf8)); 314 if (aes->aes_wcs == NULL) 315 return (0); 316 aes->aes_set = AES_SET_UTF8 | AES_SET_WCS; /* Both UTF8 and WCS set. */ 317 318 /* Try converting WCS to MBS, return false on failure. */ 319 if (archive_strappend_w_mbs(&(aes->aes_mbs), aes->aes_wcs) == NULL) 320 return (0); 321 aes->aes_set = AES_SET_UTF8 | AES_SET_WCS | AES_SET_MBS; 322 323 /* All conversions succeeded. */ 324 return (1); 325 } 326 327 static int 328 aes_copy_wcs(struct aes *aes, const wchar_t *wcs) 329 { 330 return aes_copy_wcs_len(aes, wcs, wcs == NULL ? 0 : wcslen(wcs)); 331 } 332 333 static int 334 aes_copy_wcs_len(struct aes *aes, const wchar_t *wcs, size_t len) 335 { 336 wchar_t *w; 337 338 if (wcs == NULL) { 339 aes->aes_set = 0; 340 return (0); 341 } 342 aes->aes_set = AES_SET_WCS; /* Only WCS form set. */ 343 archive_string_empty(&(aes->aes_mbs)); 344 archive_string_empty(&(aes->aes_utf8)); 345 if (aes->aes_wcs) { 346 free((wchar_t *)(uintptr_t)aes->aes_wcs); 347 aes->aes_wcs = NULL; 348 } 349 w = (wchar_t *)malloc((len + 1) * sizeof(wchar_t)); 350 if (w == NULL) 351 __archive_errx(1, "No memory for aes_copy_wcs()"); 352 wmemcpy(w, wcs, len); 353 w[len] = L'\0'; 354 aes->aes_wcs = w; 355 return (0); 356 } 357 358 /**************************************************************************** 359 * 360 * Public Interface 361 * 362 ****************************************************************************/ 363 364 struct archive_entry * 365 archive_entry_clear(struct archive_entry *entry) 366 { 367 if (entry == NULL) 368 return (NULL); 369 aes_clean(&entry->ae_fflags_text); 370 aes_clean(&entry->ae_gname); 371 aes_clean(&entry->ae_hardlink); 372 aes_clean(&entry->ae_pathname); 373 aes_clean(&entry->ae_sourcepath); 374 aes_clean(&entry->ae_symlink); 375 aes_clean(&entry->ae_uname); 376 archive_entry_acl_clear(entry); 377 archive_entry_xattr_clear(entry); 378 free(entry->stat); 379 memset(entry, 0, sizeof(*entry)); 380 return entry; 381 } 382 383 struct archive_entry * 384 archive_entry_clone(struct archive_entry *entry) 385 { 386 struct archive_entry *entry2; 387 struct ae_acl *ap, *ap2; 388 struct ae_xattr *xp; 389 390 /* Allocate new structure and copy over all of the fields. */ 391 entry2 = (struct archive_entry *)malloc(sizeof(*entry2)); 392 if (entry2 == NULL) 393 return (NULL); 394 memset(entry2, 0, sizeof(*entry2)); 395 entry2->ae_stat = entry->ae_stat; 396 entry2->ae_fflags_set = entry->ae_fflags_set; 397 entry2->ae_fflags_clear = entry->ae_fflags_clear; 398 399 aes_copy(&entry2->ae_fflags_text, &entry->ae_fflags_text); 400 aes_copy(&entry2->ae_gname, &entry->ae_gname); 401 aes_copy(&entry2->ae_hardlink, &entry->ae_hardlink); 402 aes_copy(&entry2->ae_pathname, &entry->ae_pathname); 403 aes_copy(&entry2->ae_sourcepath, &entry->ae_sourcepath); 404 aes_copy(&entry2->ae_symlink, &entry->ae_symlink); 405 entry2->ae_set = entry->ae_set; 406 aes_copy(&entry2->ae_uname, &entry->ae_uname); 407 408 /* Copy ACL data over. */ 409 ap = entry->acl_head; 410 while (ap != NULL) { 411 ap2 = acl_new_entry(entry2, 412 ap->type, ap->permset, ap->tag, ap->id); 413 if (ap2 != NULL) 414 aes_copy(&ap2->name, &ap->name); 415 ap = ap->next; 416 } 417 418 /* Copy xattr data over. */ 419 xp = entry->xattr_head; 420 while (xp != NULL) { 421 archive_entry_xattr_add_entry(entry2, 422 xp->name, xp->value, xp->size); 423 xp = xp->next; 424 } 425 426 return (entry2); 427 } 428 429 void 430 archive_entry_free(struct archive_entry *entry) 431 { 432 archive_entry_clear(entry); 433 free(entry); 434 } 435 436 struct archive_entry * 437 archive_entry_new(void) 438 { 439 struct archive_entry *entry; 440 441 entry = (struct archive_entry *)malloc(sizeof(*entry)); 442 if (entry == NULL) 443 return (NULL); 444 memset(entry, 0, sizeof(*entry)); 445 return (entry); 446 } 447 448 /* 449 * Functions for reading fields from an archive_entry. 450 */ 451 452 time_t 453 archive_entry_atime(struct archive_entry *entry) 454 { 455 return (entry->ae_stat.aest_atime); 456 } 457 458 long 459 archive_entry_atime_nsec(struct archive_entry *entry) 460 { 461 return (entry->ae_stat.aest_atime_nsec); 462 } 463 464 int 465 archive_entry_atime_is_set(struct archive_entry *entry) 466 { 467 return (entry->ae_set & AE_SET_ATIME); 468 } 469 470 time_t 471 archive_entry_birthtime(struct archive_entry *entry) 472 { 473 return (entry->ae_stat.aest_birthtime); 474 } 475 476 long 477 archive_entry_birthtime_nsec(struct archive_entry *entry) 478 { 479 return (entry->ae_stat.aest_birthtime_nsec); 480 } 481 482 int 483 archive_entry_birthtime_is_set(struct archive_entry *entry) 484 { 485 return (entry->ae_set & AE_SET_BIRTHTIME); 486 } 487 488 time_t 489 archive_entry_ctime(struct archive_entry *entry) 490 { 491 return (entry->ae_stat.aest_ctime); 492 } 493 494 int 495 archive_entry_ctime_is_set(struct archive_entry *entry) 496 { 497 return (entry->ae_set & AE_SET_CTIME); 498 } 499 500 long 501 archive_entry_ctime_nsec(struct archive_entry *entry) 502 { 503 return (entry->ae_stat.aest_ctime_nsec); 504 } 505 506 dev_t 507 archive_entry_dev(struct archive_entry *entry) 508 { 509 if (entry->ae_stat.aest_dev_is_broken_down) 510 return ae_makedev(entry->ae_stat.aest_devmajor, 511 entry->ae_stat.aest_devminor); 512 else 513 return (entry->ae_stat.aest_dev); 514 } 515 516 dev_t 517 archive_entry_devmajor(struct archive_entry *entry) 518 { 519 if (entry->ae_stat.aest_dev_is_broken_down) 520 return (entry->ae_stat.aest_devmajor); 521 else 522 return major(entry->ae_stat.aest_dev); 523 } 524 525 dev_t 526 archive_entry_devminor(struct archive_entry *entry) 527 { 528 if (entry->ae_stat.aest_dev_is_broken_down) 529 return (entry->ae_stat.aest_devminor); 530 else 531 return minor(entry->ae_stat.aest_dev); 532 } 533 534 mode_t 535 archive_entry_filetype(struct archive_entry *entry) 536 { 537 return (AE_IFMT & entry->ae_stat.aest_mode); 538 } 539 540 void 541 archive_entry_fflags(struct archive_entry *entry, 542 unsigned long *set, unsigned long *clear) 543 { 544 *set = entry->ae_fflags_set; 545 *clear = entry->ae_fflags_clear; 546 } 547 548 /* 549 * Note: if text was provided, this just returns that text. If you 550 * really need the text to be rebuilt in a canonical form, set the 551 * text, ask for the bitmaps, then set the bitmaps. (Setting the 552 * bitmaps clears any stored text.) This design is deliberate: if 553 * we're editing archives, we don't want to discard flags just because 554 * they aren't supported on the current system. The bitmap<->text 555 * conversions are platform-specific (see below). 556 */ 557 const char * 558 archive_entry_fflags_text(struct archive_entry *entry) 559 { 560 const char *f; 561 char *p; 562 563 f = aes_get_mbs(&entry->ae_fflags_text); 564 if (f != NULL) 565 return (f); 566 567 if (entry->ae_fflags_set == 0 && entry->ae_fflags_clear == 0) 568 return (NULL); 569 570 p = ae_fflagstostr(entry->ae_fflags_set, entry->ae_fflags_clear); 571 if (p == NULL) 572 return (NULL); 573 574 aes_copy_mbs(&entry->ae_fflags_text, p); 575 free(p); 576 f = aes_get_mbs(&entry->ae_fflags_text); 577 return (f); 578 } 579 580 gid_t 581 archive_entry_gid(struct archive_entry *entry) 582 { 583 return (entry->ae_stat.aest_gid); 584 } 585 586 const char * 587 archive_entry_gname(struct archive_entry *entry) 588 { 589 return (aes_get_mbs(&entry->ae_gname)); 590 } 591 592 const wchar_t * 593 archive_entry_gname_w(struct archive_entry *entry) 594 { 595 return (aes_get_wcs(&entry->ae_gname)); 596 } 597 598 const char * 599 archive_entry_hardlink(struct archive_entry *entry) 600 { 601 if (entry->ae_set & AE_SET_HARDLINK) 602 return (aes_get_mbs(&entry->ae_hardlink)); 603 return (NULL); 604 } 605 606 const wchar_t * 607 archive_entry_hardlink_w(struct archive_entry *entry) 608 { 609 if (entry->ae_set & AE_SET_HARDLINK) 610 return (aes_get_wcs(&entry->ae_hardlink)); 611 return (NULL); 612 } 613 614 ino_t 615 archive_entry_ino(struct archive_entry *entry) 616 { 617 return (entry->ae_stat.aest_ino); 618 } 619 620 mode_t 621 archive_entry_mode(struct archive_entry *entry) 622 { 623 return (entry->ae_stat.aest_mode); 624 } 625 626 time_t 627 archive_entry_mtime(struct archive_entry *entry) 628 { 629 return (entry->ae_stat.aest_mtime); 630 } 631 632 long 633 archive_entry_mtime_nsec(struct archive_entry *entry) 634 { 635 return (entry->ae_stat.aest_mtime_nsec); 636 } 637 638 int 639 archive_entry_mtime_is_set(struct archive_entry *entry) 640 { 641 return (entry->ae_set & AE_SET_MTIME); 642 } 643 644 unsigned int 645 archive_entry_nlink(struct archive_entry *entry) 646 { 647 return (entry->ae_stat.aest_nlink); 648 } 649 650 const char * 651 archive_entry_pathname(struct archive_entry *entry) 652 { 653 return (aes_get_mbs(&entry->ae_pathname)); 654 } 655 656 const wchar_t * 657 archive_entry_pathname_w(struct archive_entry *entry) 658 { 659 return (aes_get_wcs(&entry->ae_pathname)); 660 } 661 662 dev_t 663 archive_entry_rdev(struct archive_entry *entry) 664 { 665 if (entry->ae_stat.aest_rdev_is_broken_down) 666 return ae_makedev(entry->ae_stat.aest_rdevmajor, 667 entry->ae_stat.aest_rdevminor); 668 else 669 return (entry->ae_stat.aest_rdev); 670 } 671 672 dev_t 673 archive_entry_rdevmajor(struct archive_entry *entry) 674 { 675 if (entry->ae_stat.aest_rdev_is_broken_down) 676 return (entry->ae_stat.aest_rdevmajor); 677 else 678 return major(entry->ae_stat.aest_rdev); 679 } 680 681 dev_t 682 archive_entry_rdevminor(struct archive_entry *entry) 683 { 684 if (entry->ae_stat.aest_rdev_is_broken_down) 685 return (entry->ae_stat.aest_rdevminor); 686 else 687 return minor(entry->ae_stat.aest_rdev); 688 } 689 690 int64_t 691 archive_entry_size(struct archive_entry *entry) 692 { 693 return (entry->ae_stat.aest_size); 694 } 695 696 int 697 archive_entry_size_is_set(struct archive_entry *entry) 698 { 699 return (entry->ae_set & AE_SET_SIZE); 700 } 701 702 const char * 703 archive_entry_sourcepath(struct archive_entry *entry) 704 { 705 return (aes_get_mbs(&entry->ae_sourcepath)); 706 } 707 708 const char * 709 archive_entry_symlink(struct archive_entry *entry) 710 { 711 if (entry->ae_set & AE_SET_SYMLINK) 712 return (aes_get_mbs(&entry->ae_symlink)); 713 return (NULL); 714 } 715 716 const wchar_t * 717 archive_entry_symlink_w(struct archive_entry *entry) 718 { 719 if (entry->ae_set & AE_SET_SYMLINK) 720 return (aes_get_wcs(&entry->ae_symlink)); 721 return (NULL); 722 } 723 724 uid_t 725 archive_entry_uid(struct archive_entry *entry) 726 { 727 return (entry->ae_stat.aest_uid); 728 } 729 730 const char * 731 archive_entry_uname(struct archive_entry *entry) 732 { 733 return (aes_get_mbs(&entry->ae_uname)); 734 } 735 736 const wchar_t * 737 archive_entry_uname_w(struct archive_entry *entry) 738 { 739 return (aes_get_wcs(&entry->ae_uname)); 740 } 741 742 /* 743 * Functions to set archive_entry properties. 744 */ 745 746 void 747 archive_entry_set_filetype(struct archive_entry *entry, unsigned int type) 748 { 749 entry->stat_valid = 0; 750 entry->ae_stat.aest_mode &= ~AE_IFMT; 751 entry->ae_stat.aest_mode |= AE_IFMT & type; 752 } 753 754 void 755 archive_entry_set_fflags(struct archive_entry *entry, 756 unsigned long set, unsigned long clear) 757 { 758 aes_clean(&entry->ae_fflags_text); 759 entry->ae_fflags_set = set; 760 entry->ae_fflags_clear = clear; 761 } 762 763 const char * 764 archive_entry_copy_fflags_text(struct archive_entry *entry, 765 const char *flags) 766 { 767 aes_copy_mbs(&entry->ae_fflags_text, flags); 768 return (ae_strtofflags(flags, 769 &entry->ae_fflags_set, &entry->ae_fflags_clear)); 770 } 771 772 const wchar_t * 773 archive_entry_copy_fflags_text_w(struct archive_entry *entry, 774 const wchar_t *flags) 775 { 776 aes_copy_wcs(&entry->ae_fflags_text, flags); 777 return (ae_wcstofflags(flags, 778 &entry->ae_fflags_set, &entry->ae_fflags_clear)); 779 } 780 781 void 782 archive_entry_set_gid(struct archive_entry *entry, gid_t g) 783 { 784 entry->stat_valid = 0; 785 entry->ae_stat.aest_gid = g; 786 } 787 788 void 789 archive_entry_set_gname(struct archive_entry *entry, const char *name) 790 { 791 aes_set_mbs(&entry->ae_gname, name); 792 } 793 794 void 795 archive_entry_copy_gname(struct archive_entry *entry, const char *name) 796 { 797 aes_copy_mbs(&entry->ae_gname, name); 798 } 799 800 void 801 archive_entry_copy_gname_w(struct archive_entry *entry, const wchar_t *name) 802 { 803 aes_copy_wcs(&entry->ae_gname, name); 804 } 805 806 int 807 archive_entry_update_gname_utf8(struct archive_entry *entry, const char *name) 808 { 809 return (aes_update_utf8(&entry->ae_gname, name)); 810 } 811 812 void 813 archive_entry_set_ino(struct archive_entry *entry, unsigned long ino) 814 { 815 entry->stat_valid = 0; 816 entry->ae_stat.aest_ino = ino; 817 } 818 819 void 820 archive_entry_set_hardlink(struct archive_entry *entry, const char *target) 821 { 822 aes_set_mbs(&entry->ae_hardlink, target); 823 if (target != NULL) 824 entry->ae_set |= AE_SET_HARDLINK; 825 else 826 entry->ae_set &= ~AE_SET_HARDLINK; 827 } 828 829 void 830 archive_entry_copy_hardlink(struct archive_entry *entry, const char *target) 831 { 832 aes_copy_mbs(&entry->ae_hardlink, target); 833 if (target != NULL) 834 entry->ae_set |= AE_SET_HARDLINK; 835 else 836 entry->ae_set &= ~AE_SET_HARDLINK; 837 } 838 839 void 840 archive_entry_copy_hardlink_w(struct archive_entry *entry, const wchar_t *target) 841 { 842 aes_copy_wcs(&entry->ae_hardlink, target); 843 if (target != NULL) 844 entry->ae_set |= AE_SET_HARDLINK; 845 else 846 entry->ae_set &= ~AE_SET_HARDLINK; 847 } 848 849 void 850 archive_entry_set_atime(struct archive_entry *entry, time_t t, long ns) 851 { 852 entry->stat_valid = 0; 853 entry->ae_set |= AE_SET_ATIME; 854 entry->ae_stat.aest_atime = t; 855 entry->ae_stat.aest_atime_nsec = ns; 856 } 857 858 void 859 archive_entry_unset_atime(struct archive_entry *entry) 860 { 861 archive_entry_set_atime(entry, 0, 0); 862 entry->ae_set &= ~AE_SET_ATIME; 863 } 864 865 void 866 archive_entry_set_birthtime(struct archive_entry *entry, time_t m, long ns) 867 { 868 entry->stat_valid = 0; 869 entry->ae_set |= AE_SET_BIRTHTIME; 870 entry->ae_stat.aest_birthtime = m; 871 entry->ae_stat.aest_birthtime_nsec = ns; 872 } 873 874 void 875 archive_entry_unset_birthtime(struct archive_entry *entry) 876 { 877 archive_entry_set_birthtime(entry, 0, 0); 878 entry->ae_set &= ~AE_SET_BIRTHTIME; 879 } 880 881 void 882 archive_entry_set_ctime(struct archive_entry *entry, time_t t, long ns) 883 { 884 entry->stat_valid = 0; 885 entry->ae_set |= AE_SET_CTIME; 886 entry->ae_stat.aest_ctime = t; 887 entry->ae_stat.aest_ctime_nsec = ns; 888 } 889 890 void 891 archive_entry_unset_ctime(struct archive_entry *entry) 892 { 893 archive_entry_set_ctime(entry, 0, 0); 894 entry->ae_set &= ~AE_SET_CTIME; 895 } 896 897 void 898 archive_entry_set_dev(struct archive_entry *entry, dev_t d) 899 { 900 entry->stat_valid = 0; 901 entry->ae_stat.aest_dev_is_broken_down = 0; 902 entry->ae_stat.aest_dev = d; 903 } 904 905 void 906 archive_entry_set_devmajor(struct archive_entry *entry, dev_t m) 907 { 908 entry->stat_valid = 0; 909 entry->ae_stat.aest_dev_is_broken_down = 1; 910 entry->ae_stat.aest_devmajor = m; 911 } 912 913 void 914 archive_entry_set_devminor(struct archive_entry *entry, dev_t m) 915 { 916 entry->stat_valid = 0; 917 entry->ae_stat.aest_dev_is_broken_down = 1; 918 entry->ae_stat.aest_devminor = m; 919 } 920 921 /* Set symlink if symlink is already set, else set hardlink. */ 922 void 923 archive_entry_set_link(struct archive_entry *entry, const char *target) 924 { 925 if (entry->ae_set & AE_SET_SYMLINK) 926 aes_set_mbs(&entry->ae_symlink, target); 927 else 928 aes_set_mbs(&entry->ae_hardlink, target); 929 } 930 931 /* Set symlink if symlink is already set, else set hardlink. */ 932 void 933 archive_entry_copy_link(struct archive_entry *entry, const char *target) 934 { 935 if (entry->ae_set & AE_SET_SYMLINK) 936 aes_copy_mbs(&entry->ae_symlink, target); 937 else 938 aes_copy_mbs(&entry->ae_hardlink, target); 939 } 940 941 /* Set symlink if symlink is already set, else set hardlink. */ 942 void 943 archive_entry_copy_link_w(struct archive_entry *entry, const wchar_t *target) 944 { 945 if (entry->ae_set & AE_SET_SYMLINK) 946 aes_copy_wcs(&entry->ae_symlink, target); 947 else 948 aes_copy_wcs(&entry->ae_hardlink, target); 949 } 950 951 int 952 archive_entry_update_link_utf8(struct archive_entry *entry, const char *target) 953 { 954 if (entry->ae_set & AE_SET_SYMLINK) 955 return (aes_update_utf8(&entry->ae_symlink, target)); 956 else 957 return (aes_update_utf8(&entry->ae_hardlink, target)); 958 } 959 960 void 961 archive_entry_set_mode(struct archive_entry *entry, mode_t m) 962 { 963 entry->stat_valid = 0; 964 entry->ae_stat.aest_mode = m; 965 } 966 967 void 968 archive_entry_set_mtime(struct archive_entry *entry, time_t m, long ns) 969 { 970 entry->stat_valid = 0; 971 entry->ae_set |= AE_SET_MTIME; 972 entry->ae_stat.aest_mtime = m; 973 entry->ae_stat.aest_mtime_nsec = ns; 974 } 975 976 void 977 archive_entry_unset_mtime(struct archive_entry *entry) 978 { 979 archive_entry_set_mtime(entry, 0, 0); 980 entry->ae_set &= ~AE_SET_MTIME; 981 } 982 983 void 984 archive_entry_set_nlink(struct archive_entry *entry, unsigned int nlink) 985 { 986 entry->stat_valid = 0; 987 entry->ae_stat.aest_nlink = nlink; 988 } 989 990 void 991 archive_entry_set_pathname(struct archive_entry *entry, const char *name) 992 { 993 aes_set_mbs(&entry->ae_pathname, name); 994 } 995 996 void 997 archive_entry_copy_pathname(struct archive_entry *entry, const char *name) 998 { 999 aes_copy_mbs(&entry->ae_pathname, name); 1000 } 1001 1002 void 1003 archive_entry_copy_pathname_w(struct archive_entry *entry, const wchar_t *name) 1004 { 1005 aes_copy_wcs(&entry->ae_pathname, name); 1006 } 1007 1008 int 1009 archive_entry_update_pathname_utf8(struct archive_entry *entry, const char *name) 1010 { 1011 return (aes_update_utf8(&entry->ae_pathname, name)); 1012 } 1013 1014 void 1015 archive_entry_set_perm(struct archive_entry *entry, mode_t p) 1016 { 1017 entry->stat_valid = 0; 1018 entry->ae_stat.aest_mode &= AE_IFMT; 1019 entry->ae_stat.aest_mode |= ~AE_IFMT & p; 1020 } 1021 1022 void 1023 archive_entry_set_rdev(struct archive_entry *entry, dev_t m) 1024 { 1025 entry->stat_valid = 0; 1026 entry->ae_stat.aest_rdev = m; 1027 entry->ae_stat.aest_rdev_is_broken_down = 0; 1028 } 1029 1030 void 1031 archive_entry_set_rdevmajor(struct archive_entry *entry, dev_t m) 1032 { 1033 entry->stat_valid = 0; 1034 entry->ae_stat.aest_rdev_is_broken_down = 1; 1035 entry->ae_stat.aest_rdevmajor = m; 1036 } 1037 1038 void 1039 archive_entry_set_rdevminor(struct archive_entry *entry, dev_t m) 1040 { 1041 entry->stat_valid = 0; 1042 entry->ae_stat.aest_rdev_is_broken_down = 1; 1043 entry->ae_stat.aest_rdevminor = m; 1044 } 1045 1046 void 1047 archive_entry_set_size(struct archive_entry *entry, int64_t s) 1048 { 1049 entry->stat_valid = 0; 1050 entry->ae_stat.aest_size = s; 1051 entry->ae_set |= AE_SET_SIZE; 1052 } 1053 1054 void 1055 archive_entry_unset_size(struct archive_entry *entry) 1056 { 1057 archive_entry_set_size(entry, 0); 1058 entry->ae_set &= ~AE_SET_SIZE; 1059 } 1060 1061 void 1062 archive_entry_copy_sourcepath(struct archive_entry *entry, const char *path) 1063 { 1064 aes_set_mbs(&entry->ae_sourcepath, path); 1065 } 1066 1067 void 1068 archive_entry_set_symlink(struct archive_entry *entry, const char *linkname) 1069 { 1070 aes_set_mbs(&entry->ae_symlink, linkname); 1071 if (linkname != NULL) 1072 entry->ae_set |= AE_SET_SYMLINK; 1073 else 1074 entry->ae_set &= ~AE_SET_SYMLINK; 1075 } 1076 1077 void 1078 archive_entry_copy_symlink(struct archive_entry *entry, const char *linkname) 1079 { 1080 aes_copy_mbs(&entry->ae_symlink, linkname); 1081 if (linkname != NULL) 1082 entry->ae_set |= AE_SET_SYMLINK; 1083 else 1084 entry->ae_set &= ~AE_SET_SYMLINK; 1085 } 1086 1087 void 1088 archive_entry_copy_symlink_w(struct archive_entry *entry, const wchar_t *linkname) 1089 { 1090 aes_copy_wcs(&entry->ae_symlink, linkname); 1091 if (linkname != NULL) 1092 entry->ae_set |= AE_SET_SYMLINK; 1093 else 1094 entry->ae_set &= ~AE_SET_SYMLINK; 1095 } 1096 1097 void 1098 archive_entry_set_uid(struct archive_entry *entry, uid_t u) 1099 { 1100 entry->stat_valid = 0; 1101 entry->ae_stat.aest_uid = u; 1102 } 1103 1104 void 1105 archive_entry_set_uname(struct archive_entry *entry, const char *name) 1106 { 1107 aes_set_mbs(&entry->ae_uname, name); 1108 } 1109 1110 void 1111 archive_entry_copy_uname(struct archive_entry *entry, const char *name) 1112 { 1113 aes_copy_mbs(&entry->ae_uname, name); 1114 } 1115 1116 void 1117 archive_entry_copy_uname_w(struct archive_entry *entry, const wchar_t *name) 1118 { 1119 aes_copy_wcs(&entry->ae_uname, name); 1120 } 1121 1122 int 1123 archive_entry_update_uname_utf8(struct archive_entry *entry, const char *name) 1124 { 1125 return (aes_update_utf8(&entry->ae_uname, name)); 1126 } 1127 1128 /* 1129 * ACL management. The following would, of course, be a lot simpler 1130 * if: 1) the last draft of POSIX.1e were a really thorough and 1131 * complete standard that addressed the needs of ACL archiving and 2) 1132 * everyone followed it faithfully. Alas, neither is true, so the 1133 * following is a lot more complex than might seem necessary to the 1134 * uninitiated. 1135 */ 1136 1137 void 1138 archive_entry_acl_clear(struct archive_entry *entry) 1139 { 1140 struct ae_acl *ap; 1141 1142 while (entry->acl_head != NULL) { 1143 ap = entry->acl_head->next; 1144 aes_clean(&entry->acl_head->name); 1145 free(entry->acl_head); 1146 entry->acl_head = ap; 1147 } 1148 if (entry->acl_text_w != NULL) { 1149 free(entry->acl_text_w); 1150 entry->acl_text_w = NULL; 1151 } 1152 entry->acl_p = NULL; 1153 entry->acl_state = 0; /* Not counting. */ 1154 } 1155 1156 /* 1157 * Add a single ACL entry to the internal list of ACL data. 1158 */ 1159 void 1160 archive_entry_acl_add_entry(struct archive_entry *entry, 1161 int type, int permset, int tag, int id, const char *name) 1162 { 1163 struct ae_acl *ap; 1164 1165 if (acl_special(entry, type, permset, tag) == 0) 1166 return; 1167 ap = acl_new_entry(entry, type, permset, tag, id); 1168 if (ap == NULL) { 1169 /* XXX Error XXX */ 1170 return; 1171 } 1172 if (name != NULL && *name != '\0') 1173 aes_copy_mbs(&ap->name, name); 1174 else 1175 aes_clean(&ap->name); 1176 } 1177 1178 /* 1179 * As above, but with a wide-character name. 1180 */ 1181 void 1182 archive_entry_acl_add_entry_w(struct archive_entry *entry, 1183 int type, int permset, int tag, int id, const wchar_t *name) 1184 { 1185 archive_entry_acl_add_entry_w_len(entry, type, permset, tag, id, name, wcslen(name)); 1186 } 1187 1188 void 1189 archive_entry_acl_add_entry_w_len(struct archive_entry *entry, 1190 int type, int permset, int tag, int id, const wchar_t *name, size_t len) 1191 { 1192 struct ae_acl *ap; 1193 1194 if (acl_special(entry, type, permset, tag) == 0) 1195 return; 1196 ap = acl_new_entry(entry, type, permset, tag, id); 1197 if (ap == NULL) { 1198 /* XXX Error XXX */ 1199 return; 1200 } 1201 if (name != NULL && *name != L'\0' && len > 0) 1202 aes_copy_wcs_len(&ap->name, name, len); 1203 else 1204 aes_clean(&ap->name); 1205 } 1206 1207 /* 1208 * If this ACL entry is part of the standard POSIX permissions set, 1209 * store the permissions in the stat structure and return zero. 1210 */ 1211 static int 1212 acl_special(struct archive_entry *entry, int type, int permset, int tag) 1213 { 1214 if (type == ARCHIVE_ENTRY_ACL_TYPE_ACCESS) { 1215 switch (tag) { 1216 case ARCHIVE_ENTRY_ACL_USER_OBJ: 1217 entry->ae_stat.aest_mode &= ~0700; 1218 entry->ae_stat.aest_mode |= (permset & 7) << 6; 1219 return (0); 1220 case ARCHIVE_ENTRY_ACL_GROUP_OBJ: 1221 entry->ae_stat.aest_mode &= ~0070; 1222 entry->ae_stat.aest_mode |= (permset & 7) << 3; 1223 return (0); 1224 case ARCHIVE_ENTRY_ACL_OTHER: 1225 entry->ae_stat.aest_mode &= ~0007; 1226 entry->ae_stat.aest_mode |= permset & 7; 1227 return (0); 1228 } 1229 } 1230 return (1); 1231 } 1232 1233 /* 1234 * Allocate and populate a new ACL entry with everything but the 1235 * name. 1236 */ 1237 static struct ae_acl * 1238 acl_new_entry(struct archive_entry *entry, 1239 int type, int permset, int tag, int id) 1240 { 1241 struct ae_acl *ap; 1242 1243 if (type != ARCHIVE_ENTRY_ACL_TYPE_ACCESS && 1244 type != ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) 1245 return (NULL); 1246 if (entry->acl_text_w != NULL) { 1247 free(entry->acl_text_w); 1248 entry->acl_text_w = NULL; 1249 } 1250 1251 /* XXX TODO: More sanity-checks on the arguments XXX */ 1252 1253 /* If there's a matching entry already in the list, overwrite it. */ 1254 for (ap = entry->acl_head; ap != NULL; ap = ap->next) { 1255 if (ap->type == type && ap->tag == tag && ap->id == id) { 1256 ap->permset = permset; 1257 return (ap); 1258 } 1259 } 1260 1261 /* Add a new entry to the list. */ 1262 ap = (struct ae_acl *)malloc(sizeof(*ap)); 1263 if (ap == NULL) 1264 return (NULL); 1265 memset(ap, 0, sizeof(*ap)); 1266 ap->next = entry->acl_head; 1267 entry->acl_head = ap; 1268 ap->type = type; 1269 ap->tag = tag; 1270 ap->id = id; 1271 ap->permset = permset; 1272 return (ap); 1273 } 1274 1275 /* 1276 * Return a count of entries matching "want_type". 1277 */ 1278 int 1279 archive_entry_acl_count(struct archive_entry *entry, int want_type) 1280 { 1281 int count; 1282 struct ae_acl *ap; 1283 1284 count = 0; 1285 ap = entry->acl_head; 1286 while (ap != NULL) { 1287 if ((ap->type & want_type) != 0) 1288 count++; 1289 ap = ap->next; 1290 } 1291 1292 if (count > 0 && ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)) 1293 count += 3; 1294 return (count); 1295 } 1296 1297 /* 1298 * Prepare for reading entries from the ACL data. Returns a count 1299 * of entries matching "want_type", or zero if there are no 1300 * non-extended ACL entries of that type. 1301 */ 1302 int 1303 archive_entry_acl_reset(struct archive_entry *entry, int want_type) 1304 { 1305 int count, cutoff; 1306 1307 count = archive_entry_acl_count(entry, want_type); 1308 1309 /* 1310 * If the only entries are the three standard ones, 1311 * then don't return any ACL data. (In this case, 1312 * client can just use chmod(2) to set permissions.) 1313 */ 1314 if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) 1315 cutoff = 3; 1316 else 1317 cutoff = 0; 1318 1319 if (count > cutoff) 1320 entry->acl_state = ARCHIVE_ENTRY_ACL_USER_OBJ; 1321 else 1322 entry->acl_state = 0; 1323 entry->acl_p = entry->acl_head; 1324 return (count); 1325 } 1326 1327 /* 1328 * Return the next ACL entry in the list. Fake entries for the 1329 * standard permissions and include them in the returned list. 1330 */ 1331 1332 int 1333 archive_entry_acl_next(struct archive_entry *entry, int want_type, int *type, 1334 int *permset, int *tag, int *id, const char **name) 1335 { 1336 *name = NULL; 1337 *id = -1; 1338 1339 /* 1340 * The acl_state is either zero (no entries available), -1 1341 * (reading from list), or an entry type (retrieve that type 1342 * from ae_stat.aest_mode). 1343 */ 1344 if (entry->acl_state == 0) 1345 return (ARCHIVE_WARN); 1346 1347 /* The first three access entries are special. */ 1348 if ((want_type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) { 1349 switch (entry->acl_state) { 1350 case ARCHIVE_ENTRY_ACL_USER_OBJ: 1351 *permset = (entry->ae_stat.aest_mode >> 6) & 7; 1352 *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS; 1353 *tag = ARCHIVE_ENTRY_ACL_USER_OBJ; 1354 entry->acl_state = ARCHIVE_ENTRY_ACL_GROUP_OBJ; 1355 return (ARCHIVE_OK); 1356 case ARCHIVE_ENTRY_ACL_GROUP_OBJ: 1357 *permset = (entry->ae_stat.aest_mode >> 3) & 7; 1358 *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS; 1359 *tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ; 1360 entry->acl_state = ARCHIVE_ENTRY_ACL_OTHER; 1361 return (ARCHIVE_OK); 1362 case ARCHIVE_ENTRY_ACL_OTHER: 1363 *permset = entry->ae_stat.aest_mode & 7; 1364 *type = ARCHIVE_ENTRY_ACL_TYPE_ACCESS; 1365 *tag = ARCHIVE_ENTRY_ACL_OTHER; 1366 entry->acl_state = -1; 1367 entry->acl_p = entry->acl_head; 1368 return (ARCHIVE_OK); 1369 default: 1370 break; 1371 } 1372 } 1373 1374 while (entry->acl_p != NULL && (entry->acl_p->type & want_type) == 0) 1375 entry->acl_p = entry->acl_p->next; 1376 if (entry->acl_p == NULL) { 1377 entry->acl_state = 0; 1378 *type = 0; 1379 *permset = 0; 1380 *tag = 0; 1381 *id = -1; 1382 *name = NULL; 1383 return (ARCHIVE_EOF); /* End of ACL entries. */ 1384 } 1385 *type = entry->acl_p->type; 1386 *permset = entry->acl_p->permset; 1387 *tag = entry->acl_p->tag; 1388 *id = entry->acl_p->id; 1389 *name = aes_get_mbs(&entry->acl_p->name); 1390 entry->acl_p = entry->acl_p->next; 1391 return (ARCHIVE_OK); 1392 } 1393 1394 /* 1395 * Generate a text version of the ACL. The flags parameter controls 1396 * the style of the generated ACL. 1397 */ 1398 const wchar_t * 1399 archive_entry_acl_text_w(struct archive_entry *entry, int flags) 1400 { 1401 int count; 1402 size_t length; 1403 const wchar_t *wname; 1404 const wchar_t *prefix; 1405 wchar_t separator; 1406 struct ae_acl *ap; 1407 int id; 1408 wchar_t *wp; 1409 1410 if (entry->acl_text_w != NULL) { 1411 free (entry->acl_text_w); 1412 entry->acl_text_w = NULL; 1413 } 1414 1415 separator = L','; 1416 count = 0; 1417 length = 0; 1418 ap = entry->acl_head; 1419 while (ap != NULL) { 1420 if ((ap->type & flags) != 0) { 1421 count++; 1422 if ((flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT) && 1423 (ap->type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT)) 1424 length += 8; /* "default:" */ 1425 length += 5; /* tag name */ 1426 length += 1; /* colon */ 1427 wname = aes_get_wcs(&ap->name); 1428 if (wname != NULL) 1429 length += wcslen(wname); 1430 else 1431 length += sizeof(uid_t) * 3 + 1; 1432 length ++; /* colon */ 1433 length += 3; /* rwx */ 1434 length += 1; /* colon */ 1435 length += max(sizeof(uid_t), sizeof(gid_t)) * 3 + 1; 1436 length ++; /* newline */ 1437 } 1438 ap = ap->next; 1439 } 1440 1441 if (count > 0 && ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0)) { 1442 length += 10; /* "user::rwx\n" */ 1443 length += 11; /* "group::rwx\n" */ 1444 length += 11; /* "other::rwx\n" */ 1445 } 1446 1447 if (count == 0) 1448 return (NULL); 1449 1450 /* Now, allocate the string and actually populate it. */ 1451 wp = entry->acl_text_w = (wchar_t *)malloc(length * sizeof(wchar_t)); 1452 if (wp == NULL) 1453 __archive_errx(1, "No memory to generate the text version of the ACL"); 1454 count = 0; 1455 if ((flags & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) { 1456 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_USER_OBJ, NULL, 1457 entry->ae_stat.aest_mode & 0700, -1); 1458 *wp++ = ','; 1459 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_GROUP_OBJ, NULL, 1460 entry->ae_stat.aest_mode & 0070, -1); 1461 *wp++ = ','; 1462 append_entry_w(&wp, NULL, ARCHIVE_ENTRY_ACL_OTHER, NULL, 1463 entry->ae_stat.aest_mode & 0007, -1); 1464 count += 3; 1465 1466 ap = entry->acl_head; 1467 while (ap != NULL) { 1468 if ((ap->type & ARCHIVE_ENTRY_ACL_TYPE_ACCESS) != 0) { 1469 wname = aes_get_wcs(&ap->name); 1470 *wp++ = separator; 1471 if (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID) 1472 id = ap->id; 1473 else 1474 id = -1; 1475 append_entry_w(&wp, NULL, ap->tag, wname, 1476 ap->permset, id); 1477 count++; 1478 } 1479 ap = ap->next; 1480 } 1481 } 1482 1483 1484 if ((flags & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0) { 1485 if (flags & ARCHIVE_ENTRY_ACL_STYLE_MARK_DEFAULT) 1486 prefix = L"default:"; 1487 else 1488 prefix = NULL; 1489 ap = entry->acl_head; 1490 count = 0; 1491 while (ap != NULL) { 1492 if ((ap->type & ARCHIVE_ENTRY_ACL_TYPE_DEFAULT) != 0) { 1493 wname = aes_get_wcs(&ap->name); 1494 if (count > 0) 1495 *wp++ = separator; 1496 if (flags & ARCHIVE_ENTRY_ACL_STYLE_EXTRA_ID) 1497 id = ap->id; 1498 else 1499 id = -1; 1500 append_entry_w(&wp, prefix, ap->tag, 1501 wname, ap->permset, id); 1502 count ++; 1503 } 1504 ap = ap->next; 1505 } 1506 } 1507 1508 return (entry->acl_text_w); 1509 } 1510 1511 static void 1512 append_id_w(wchar_t **wp, int id) 1513 { 1514 if (id < 0) 1515 id = 0; 1516 if (id > 9) 1517 append_id_w(wp, id / 10); 1518 *(*wp)++ = L"0123456789"[id % 10]; 1519 } 1520 1521 static void 1522 append_entry_w(wchar_t **wp, const wchar_t *prefix, int tag, 1523 const wchar_t *wname, int perm, int id) 1524 { 1525 if (prefix != NULL) { 1526 wcscpy(*wp, prefix); 1527 *wp += wcslen(*wp); 1528 } 1529 switch (tag) { 1530 case ARCHIVE_ENTRY_ACL_USER_OBJ: 1531 wname = NULL; 1532 id = -1; 1533 /* FALLTHROUGH */ 1534 case ARCHIVE_ENTRY_ACL_USER: 1535 wcscpy(*wp, L"user"); 1536 break; 1537 case ARCHIVE_ENTRY_ACL_GROUP_OBJ: 1538 wname = NULL; 1539 id = -1; 1540 /* FALLTHROUGH */ 1541 case ARCHIVE_ENTRY_ACL_GROUP: 1542 wcscpy(*wp, L"group"); 1543 break; 1544 case ARCHIVE_ENTRY_ACL_MASK: 1545 wcscpy(*wp, L"mask"); 1546 wname = NULL; 1547 id = -1; 1548 break; 1549 case ARCHIVE_ENTRY_ACL_OTHER: 1550 wcscpy(*wp, L"other"); 1551 wname = NULL; 1552 id = -1; 1553 break; 1554 } 1555 *wp += wcslen(*wp); 1556 *(*wp)++ = L':'; 1557 if (wname != NULL) { 1558 wcscpy(*wp, wname); 1559 *wp += wcslen(*wp); 1560 } else if (tag == ARCHIVE_ENTRY_ACL_USER 1561 || tag == ARCHIVE_ENTRY_ACL_GROUP) { 1562 append_id_w(wp, id); 1563 id = -1; 1564 } 1565 *(*wp)++ = L':'; 1566 *(*wp)++ = (perm & 0444) ? L'r' : L'-'; 1567 *(*wp)++ = (perm & 0222) ? L'w' : L'-'; 1568 *(*wp)++ = (perm & 0111) ? L'x' : L'-'; 1569 if (id != -1) { 1570 *(*wp)++ = L':'; 1571 append_id_w(wp, id); 1572 } 1573 **wp = L'\0'; 1574 } 1575 1576 /* 1577 * Parse a textual ACL. This automatically recognizes and supports 1578 * extensions described above. The 'type' argument is used to 1579 * indicate the type that should be used for any entries not 1580 * explicitly marked as "default:". 1581 */ 1582 int 1583 __archive_entry_acl_parse_w(struct archive_entry *entry, 1584 const wchar_t *text, int default_type) 1585 { 1586 struct { 1587 const wchar_t *start; 1588 const wchar_t *end; 1589 } field[4]; 1590 1591 int fields; 1592 int type, tag, permset, id; 1593 const wchar_t *p; 1594 wchar_t sep; 1595 1596 while (text != NULL && *text != L'\0') { 1597 /* 1598 * Parse the fields out of the next entry, 1599 * advance 'text' to start of next entry. 1600 */ 1601 fields = 0; 1602 do { 1603 const wchar_t *start, *end; 1604 next_field_w(&text, &start, &end, &sep); 1605 if (fields < 4) { 1606 field[fields].start = start; 1607 field[fields].end = end; 1608 } 1609 ++fields; 1610 } while (sep == L':'); 1611 1612 if (fields < 3) 1613 return (ARCHIVE_WARN); 1614 1615 /* Check for a numeric ID in field 1 or 3. */ 1616 id = -1; 1617 isint_w(field[1].start, field[1].end, &id); 1618 /* Field 3 is optional. */ 1619 if (id == -1 && fields > 3) 1620 isint_w(field[3].start, field[3].end, &id); 1621 1622 /* Parse the permissions from field 2. */ 1623 permset = 0; 1624 p = field[2].start; 1625 while (p < field[2].end) { 1626 switch (*p++) { 1627 case 'r': case 'R': 1628 permset |= ARCHIVE_ENTRY_ACL_READ; 1629 break; 1630 case 'w': case 'W': 1631 permset |= ARCHIVE_ENTRY_ACL_WRITE; 1632 break; 1633 case 'x': case 'X': 1634 permset |= ARCHIVE_ENTRY_ACL_EXECUTE; 1635 break; 1636 case '-': 1637 break; 1638 default: 1639 return (ARCHIVE_WARN); 1640 } 1641 } 1642 1643 /* 1644 * Solaris extension: "defaultuser::rwx" is the 1645 * default ACL corresponding to "user::rwx", etc. 1646 */ 1647 if (field[0].end-field[0].start > 7 1648 && wmemcmp(field[0].start, L"default", 7) == 0) { 1649 type = ARCHIVE_ENTRY_ACL_TYPE_DEFAULT; 1650 field[0].start += 7; 1651 } else 1652 type = default_type; 1653 1654 if (prefix_w(field[0].start, field[0].end, L"user")) { 1655 if (id != -1 || field[1].start < field[1].end) 1656 tag = ARCHIVE_ENTRY_ACL_USER; 1657 else 1658 tag = ARCHIVE_ENTRY_ACL_USER_OBJ; 1659 } else if (prefix_w(field[0].start, field[0].end, L"group")) { 1660 if (id != -1 || field[1].start < field[1].end) 1661 tag = ARCHIVE_ENTRY_ACL_GROUP; 1662 else 1663 tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ; 1664 } else if (prefix_w(field[0].start, field[0].end, L"other")) { 1665 if (id != -1 || field[1].start < field[1].end) 1666 return (ARCHIVE_WARN); 1667 tag = ARCHIVE_ENTRY_ACL_OTHER; 1668 } else if (prefix_w(field[0].start, field[0].end, L"mask")) { 1669 if (id != -1 || field[1].start < field[1].end) 1670 return (ARCHIVE_WARN); 1671 tag = ARCHIVE_ENTRY_ACL_MASK; 1672 } else 1673 return (ARCHIVE_WARN); 1674 1675 /* Add entry to the internal list. */ 1676 archive_entry_acl_add_entry_w_len(entry, type, permset, 1677 tag, id, field[1].start, field[1].end - field[1].start); 1678 } 1679 return (ARCHIVE_OK); 1680 } 1681 1682 /* 1683 * extended attribute handling 1684 */ 1685 1686 void 1687 archive_entry_xattr_clear(struct archive_entry *entry) 1688 { 1689 struct ae_xattr *xp; 1690 1691 while (entry->xattr_head != NULL) { 1692 xp = entry->xattr_head->next; 1693 free(entry->xattr_head->name); 1694 free(entry->xattr_head->value); 1695 free(entry->xattr_head); 1696 entry->xattr_head = xp; 1697 } 1698 1699 entry->xattr_head = NULL; 1700 } 1701 1702 void 1703 archive_entry_xattr_add_entry(struct archive_entry *entry, 1704 const char *name, const void *value, size_t size) 1705 { 1706 struct ae_xattr *xp; 1707 1708 for (xp = entry->xattr_head; xp != NULL; xp = xp->next) 1709 ; 1710 1711 if ((xp = (struct ae_xattr *)malloc(sizeof(struct ae_xattr))) == NULL) 1712 /* XXX Error XXX */ 1713 return; 1714 1715 xp->name = strdup(name); 1716 if ((xp->value = malloc(size)) != NULL) { 1717 memcpy(xp->value, value, size); 1718 xp->size = size; 1719 } else 1720 xp->size = 0; 1721 1722 xp->next = entry->xattr_head; 1723 entry->xattr_head = xp; 1724 } 1725 1726 1727 /* 1728 * returns number of the extended attribute entries 1729 */ 1730 int 1731 archive_entry_xattr_count(struct archive_entry *entry) 1732 { 1733 struct ae_xattr *xp; 1734 int count = 0; 1735 1736 for (xp = entry->xattr_head; xp != NULL; xp = xp->next) 1737 count++; 1738 1739 return count; 1740 } 1741 1742 int 1743 archive_entry_xattr_reset(struct archive_entry * entry) 1744 { 1745 entry->xattr_p = entry->xattr_head; 1746 1747 return archive_entry_xattr_count(entry); 1748 } 1749 1750 int 1751 archive_entry_xattr_next(struct archive_entry * entry, 1752 const char **name, const void **value, size_t *size) 1753 { 1754 if (entry->xattr_p) { 1755 *name = entry->xattr_p->name; 1756 *value = entry->xattr_p->value; 1757 *size = entry->xattr_p->size; 1758 1759 entry->xattr_p = entry->xattr_p->next; 1760 1761 return (ARCHIVE_OK); 1762 } else { 1763 *name = NULL; 1764 *value = NULL; 1765 *size = (size_t)0; 1766 return (ARCHIVE_WARN); 1767 } 1768 } 1769 1770 /* 1771 * end of xattr handling 1772 */ 1773 1774 /* 1775 * Parse a string to a positive decimal integer. Returns true if 1776 * the string is non-empty and consists only of decimal digits, 1777 * false otherwise. 1778 */ 1779 static int 1780 isint_w(const wchar_t *start, const wchar_t *end, int *result) 1781 { 1782 int n = 0; 1783 if (start >= end) 1784 return (0); 1785 while (start < end) { 1786 if (*start < '0' || *start > '9') 1787 return (0); 1788 if (n > (INT_MAX / 10)) 1789 n = INT_MAX; 1790 else { 1791 n *= 10; 1792 n += *start - '0'; 1793 } 1794 start++; 1795 } 1796 *result = n; 1797 return (1); 1798 } 1799 1800 /* 1801 * Match "[:whitespace:]*(.*)[:whitespace:]*[:,\n]". *wp is updated 1802 * to point to just after the separator. *start points to the first 1803 * character of the matched text and *end just after the last 1804 * character of the matched identifier. In particular *end - *start 1805 * is the length of the field body, not including leading or trailing 1806 * whitespace. 1807 */ 1808 static void 1809 next_field_w(const wchar_t **wp, const wchar_t **start, 1810 const wchar_t **end, wchar_t *sep) 1811 { 1812 /* Skip leading whitespace to find start of field. */ 1813 while (**wp == L' ' || **wp == L'\t' || **wp == L'\n') { 1814 (*wp)++; 1815 } 1816 *start = *wp; 1817 1818 /* Scan for the separator. */ 1819 while (**wp != L'\0' && **wp != L',' && **wp != L':' && 1820 **wp != L'\n') { 1821 (*wp)++; 1822 } 1823 *sep = **wp; 1824 1825 /* Trim trailing whitespace to locate end of field. */ 1826 *end = *wp - 1; 1827 while (**end == L' ' || **end == L'\t' || **end == L'\n') { 1828 (*end)--; 1829 } 1830 (*end)++; 1831 1832 /* Adjust scanner location. */ 1833 if (**wp != L'\0') 1834 (*wp)++; 1835 } 1836 1837 /* 1838 * Return true if the characters [start...end) are a prefix of 'test'. 1839 * This makes it easy to handle the obvious abbreviations: 'u' for 'user', etc. 1840 */ 1841 static int 1842 prefix_w(const wchar_t *start, const wchar_t *end, const wchar_t *test) 1843 { 1844 if (start == end) 1845 return (0); 1846 1847 if (*start++ != *test++) 1848 return (0); 1849 1850 while (start < end && *start++ == *test++) 1851 ; 1852 1853 if (start < end) 1854 return (0); 1855 1856 return (1); 1857 } 1858 1859 1860 /* 1861 * Following code is modified from UC Berkeley sources, and 1862 * is subject to the following copyright notice. 1863 */ 1864 1865 /*- 1866 * Copyright (c) 1993 1867 * The Regents of the University of California. All rights reserved. 1868 * 1869 * Redistribution and use in source and binary forms, with or without 1870 * modification, are permitted provided that the following conditions 1871 * are met: 1872 * 1. Redistributions of source code must retain the above copyright 1873 * notice, this list of conditions and the following disclaimer. 1874 * 2. Redistributions in binary form must reproduce the above copyright 1875 * notice, this list of conditions and the following disclaimer in the 1876 * documentation and/or other materials provided with the distribution. 1877 * 4. Neither the name of the University nor the names of its contributors 1878 * may be used to endorse or promote products derived from this software 1879 * without specific prior written permission. 1880 * 1881 * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND 1882 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE 1883 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE 1884 * ARE DISCLAIMED. IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE 1885 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL 1886 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS 1887 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) 1888 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT 1889 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY 1890 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF 1891 * SUCH DAMAGE. 1892 */ 1893 1894 static struct flag { 1895 const char *name; 1896 const wchar_t *wname; 1897 unsigned long set; 1898 unsigned long clear; 1899 } flags[] = { 1900 /* Preferred (shorter) names per flag first, all prefixed by "no" */ 1901 #ifdef SF_APPEND 1902 { "nosappnd", L"nosappnd", SF_APPEND, 0 }, 1903 { "nosappend", L"nosappend", SF_APPEND, 0 }, 1904 #endif 1905 #ifdef EXT2_APPEND_FL /* 'a' */ 1906 { "nosappnd", L"nosappnd", EXT2_APPEND_FL, 0 }, 1907 { "nosappend", L"nosappend", EXT2_APPEND_FL, 0 }, 1908 #endif 1909 #ifdef SF_ARCHIVED 1910 { "noarch", L"noarch", SF_ARCHIVED, 0 }, 1911 { "noarchived", L"noarchived", SF_ARCHIVED, 0 }, 1912 #endif 1913 #ifdef SF_IMMUTABLE 1914 { "noschg", L"noschg", SF_IMMUTABLE, 0 }, 1915 { "noschange", L"noschange", SF_IMMUTABLE, 0 }, 1916 { "nosimmutable", L"nosimmutable", SF_IMMUTABLE, 0 }, 1917 #endif 1918 #ifdef EXT2_IMMUTABLE_FL /* 'i' */ 1919 { "noschg", L"noschg", EXT2_IMMUTABLE_FL, 0 }, 1920 { "noschange", L"noschange", EXT2_IMMUTABLE_FL, 0 }, 1921 { "nosimmutable", L"nosimmutable", EXT2_IMMUTABLE_FL, 0 }, 1922 #endif 1923 #ifdef SF_NOUNLINK 1924 { "nosunlnk", L"nosunlnk", SF_NOUNLINK, 0 }, 1925 { "nosunlink", L"nosunlink", SF_NOUNLINK, 0 }, 1926 #endif 1927 #ifdef SF_SNAPSHOT 1928 { "nosnapshot", L"nosnapshot", SF_SNAPSHOT, 0 }, 1929 #endif 1930 #ifdef UF_APPEND 1931 { "nouappnd", L"nouappnd", UF_APPEND, 0 }, 1932 { "nouappend", L"nouappend", UF_APPEND, 0 }, 1933 #endif 1934 #ifdef UF_IMMUTABLE 1935 { "nouchg", L"nouchg", UF_IMMUTABLE, 0 }, 1936 { "nouchange", L"nouchange", UF_IMMUTABLE, 0 }, 1937 { "nouimmutable", L"nouimmutable", UF_IMMUTABLE, 0 }, 1938 #endif 1939 #ifdef UF_NODUMP 1940 { "nodump", L"nodump", 0, UF_NODUMP}, 1941 #endif 1942 #ifdef EXT2_NODUMP_FL /* 'd' */ 1943 { "nodump", L"nodump", 0, EXT2_NODUMP_FL}, 1944 #endif 1945 #ifdef UF_OPAQUE 1946 { "noopaque", L"noopaque", UF_OPAQUE, 0 }, 1947 #endif 1948 #ifdef UF_NOUNLINK 1949 { "nouunlnk", L"nouunlnk", UF_NOUNLINK, 0 }, 1950 { "nouunlink", L"nouunlink", UF_NOUNLINK, 0 }, 1951 #endif 1952 #ifdef EXT2_COMPR_FL /* 'c' */ 1953 { "nocompress", L"nocompress", EXT2_COMPR_FL, 0 }, 1954 #endif 1955 1956 #ifdef EXT2_NOATIME_FL /* 'A' */ 1957 { "noatime", L"noatime", 0, EXT2_NOATIME_FL}, 1958 #endif 1959 { NULL, NULL, 0, 0 } 1960 }; 1961 1962 /* 1963 * fflagstostr -- 1964 * Convert file flags to a comma-separated string. If no flags 1965 * are set, return the empty string. 1966 */ 1967 static char * 1968 ae_fflagstostr(unsigned long bitset, unsigned long bitclear) 1969 { 1970 char *string, *dp; 1971 const char *sp; 1972 unsigned long bits; 1973 struct flag *flag; 1974 size_t length; 1975 1976 bits = bitset | bitclear; 1977 length = 0; 1978 for (flag = flags; flag->name != NULL; flag++) 1979 if (bits & (flag->set | flag->clear)) { 1980 length += strlen(flag->name) + 1; 1981 bits &= ~(flag->set | flag->clear); 1982 } 1983 1984 if (length == 0) 1985 return (NULL); 1986 string = (char *)malloc(length); 1987 if (string == NULL) 1988 return (NULL); 1989 1990 dp = string; 1991 for (flag = flags; flag->name != NULL; flag++) { 1992 if (bitset & flag->set || bitclear & flag->clear) { 1993 sp = flag->name + 2; 1994 } else if (bitset & flag->clear || bitclear & flag->set) { 1995 sp = flag->name; 1996 } else 1997 continue; 1998 bitset &= ~(flag->set | flag->clear); 1999 bitclear &= ~(flag->set | flag->clear); 2000 if (dp > string) 2001 *dp++ = ','; 2002 while ((*dp++ = *sp++) != '\0') 2003 ; 2004 dp--; 2005 } 2006 2007 *dp = '\0'; 2008 return (string); 2009 } 2010 2011 /* 2012 * strtofflags -- 2013 * Take string of arguments and return file flags. This 2014 * version works a little differently than strtofflags(3). 2015 * In particular, it always tests every token, skipping any 2016 * unrecognized tokens. It returns a pointer to the first 2017 * unrecognized token, or NULL if every token was recognized. 2018 * This version is also const-correct and does not modify the 2019 * provided string. 2020 */ 2021 static const char * 2022 ae_strtofflags(const char *s, unsigned long *setp, unsigned long *clrp) 2023 { 2024 const char *start, *end; 2025 struct flag *flag; 2026 unsigned long set, clear; 2027 const char *failed; 2028 2029 set = clear = 0; 2030 start = s; 2031 failed = NULL; 2032 /* Find start of first token. */ 2033 while (*start == '\t' || *start == ' ' || *start == ',') 2034 start++; 2035 while (*start != '\0') { 2036 /* Locate end of token. */ 2037 end = start; 2038 while (*end != '\0' && *end != '\t' && 2039 *end != ' ' && *end != ',') 2040 end++; 2041 for (flag = flags; flag->name != NULL; flag++) { 2042 if (memcmp(start, flag->name, end - start) == 0) { 2043 /* Matched "noXXXX", so reverse the sense. */ 2044 clear |= flag->set; 2045 set |= flag->clear; 2046 break; 2047 } else if (memcmp(start, flag->name + 2, end - start) 2048 == 0) { 2049 /* Matched "XXXX", so don't reverse. */ 2050 set |= flag->set; 2051 clear |= flag->clear; 2052 break; 2053 } 2054 } 2055 /* Ignore unknown flag names. */ 2056 if (flag->name == NULL && failed == NULL) 2057 failed = start; 2058 2059 /* Find start of next token. */ 2060 start = end; 2061 while (*start == '\t' || *start == ' ' || *start == ',') 2062 start++; 2063 2064 } 2065 2066 if (setp) 2067 *setp = set; 2068 if (clrp) 2069 *clrp = clear; 2070 2071 /* Return location of first failure. */ 2072 return (failed); 2073 } 2074 2075 /* 2076 * wcstofflags -- 2077 * Take string of arguments and return file flags. This 2078 * version works a little differently than strtofflags(3). 2079 * In particular, it always tests every token, skipping any 2080 * unrecognized tokens. It returns a pointer to the first 2081 * unrecognized token, or NULL if every token was recognized. 2082 * This version is also const-correct and does not modify the 2083 * provided string. 2084 */ 2085 static const wchar_t * 2086 ae_wcstofflags(const wchar_t *s, unsigned long *setp, unsigned long *clrp) 2087 { 2088 const wchar_t *start, *end; 2089 struct flag *flag; 2090 unsigned long set, clear; 2091 const wchar_t *failed; 2092 2093 set = clear = 0; 2094 start = s; 2095 failed = NULL; 2096 /* Find start of first token. */ 2097 while (*start == L'\t' || *start == L' ' || *start == L',') 2098 start++; 2099 while (*start != L'\0') { 2100 /* Locate end of token. */ 2101 end = start; 2102 while (*end != L'\0' && *end != L'\t' && 2103 *end != L' ' && *end != L',') 2104 end++; 2105 for (flag = flags; flag->wname != NULL; flag++) { 2106 if (wmemcmp(start, flag->wname, end - start) == 0) { 2107 /* Matched "noXXXX", so reverse the sense. */ 2108 clear |= flag->set; 2109 set |= flag->clear; 2110 break; 2111 } else if (wmemcmp(start, flag->wname + 2, end - start) 2112 == 0) { 2113 /* Matched "XXXX", so don't reverse. */ 2114 set |= flag->set; 2115 clear |= flag->clear; 2116 break; 2117 } 2118 } 2119 /* Ignore unknown flag names. */ 2120 if (flag->wname == NULL && failed == NULL) 2121 failed = start; 2122 2123 /* Find start of next token. */ 2124 start = end; 2125 while (*start == L'\t' || *start == L' ' || *start == L',') 2126 start++; 2127 2128 } 2129 2130 if (setp) 2131 *setp = set; 2132 if (clrp) 2133 *clrp = clear; 2134 2135 /* Return location of first failure. */ 2136 return (failed); 2137 } 2138 2139 2140 #ifdef TEST 2141 #include <stdio.h> 2142 int 2143 main(int argc, char **argv) 2144 { 2145 struct archive_entry *entry = archive_entry_new(); 2146 unsigned long set, clear; 2147 const wchar_t *remainder; 2148 2149 remainder = archive_entry_copy_fflags_text_w(entry, L"nosappnd dump archive,,,,,,,"); 2150 archive_entry_fflags(entry, &set, &clear); 2151 2152 wprintf(L"set=0x%lX clear=0x%lX remainder='%ls'\n", set, clear, remainder); 2153 2154 wprintf(L"new flags='%s'\n", archive_entry_fflags_text(entry)); 2155 return (0); 2156 } 2157 #endif 2158