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