1 /*- 2 * Copyright (c) 2003-2009 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_TYPES_H 30 /* Mac OSX requires sys/types.h before sys/acl.h. */ 31 #include <sys/types.h> 32 #endif 33 #ifdef HAVE_SYS_ACL_H 34 #include <sys/acl.h> 35 #endif 36 #ifdef HAVE_SYS_EXTATTR_H 37 #include <sys/extattr.h> 38 #endif 39 #ifdef HAVE_SYS_PARAM_H 40 #include <sys/param.h> 41 #endif 42 #ifdef HAVE_SYS_STAT_H 43 #include <sys/stat.h> 44 #endif 45 #ifdef HAVE_SYS_XATTR_H 46 #include <sys/xattr.h> 47 #endif 48 #ifdef HAVE_ACL_LIBACL_H 49 #include <acl/libacl.h> 50 #endif 51 #ifdef HAVE_ATTR_XATTR_H 52 #include <attr/xattr.h> 53 #endif 54 #ifdef HAVE_ERRNO_H 55 #include <errno.h> 56 #endif 57 #ifdef HAVE_LIMITS_H 58 #include <limits.h> 59 #endif 60 #ifdef HAVE_WINDOWS_H 61 #include <windows.h> 62 #endif 63 64 #include "archive.h" 65 #include "archive_entry.h" 66 #include "archive_private.h" 67 #include "archive_read_disk_private.h" 68 69 /* 70 * Linux and FreeBSD plug this obvious hole in POSIX.1e in 71 * different ways. 72 */ 73 #if HAVE_ACL_GET_PERM 74 #define ACL_GET_PERM acl_get_perm 75 #elif HAVE_ACL_GET_PERM_NP 76 #define ACL_GET_PERM acl_get_perm_np 77 #endif 78 79 static int setup_acls_posix1e(struct archive_read_disk *, 80 struct archive_entry *, int fd); 81 static int setup_xattrs(struct archive_read_disk *, 82 struct archive_entry *, int fd); 83 84 int 85 archive_read_disk_entry_from_file(struct archive *_a, 86 struct archive_entry *entry, 87 int fd, const struct stat *st) 88 { 89 struct archive_read_disk *a = (struct archive_read_disk *)_a; 90 const char *path, *name; 91 struct stat s; 92 int initial_fd = fd; 93 int r, r1; 94 95 archive_clear_error(_a); 96 path = archive_entry_sourcepath(entry); 97 if (path == NULL) 98 path = archive_entry_pathname(entry); 99 100 #ifdef EXT2_IOC_GETFLAGS 101 /* Linux requires an extra ioctl to pull the flags. Although 102 * this is an extra step, it has a nice side-effect: We get an 103 * open file descriptor which we can use in the subsequent lookups. */ 104 if ((S_ISREG(st->st_mode) || S_ISDIR(st->st_mode))) { 105 if (fd < 0) 106 fd = open(pathname, O_RDONLY | O_NONBLOCK | O_BINARY); 107 if (fd >= 0) { 108 unsigned long stflags; 109 int r = ioctl(fd, EXT2_IOC_GETFLAGS, &stflags); 110 if (r == 0 && stflags != 0) 111 archive_entry_set_fflags(entry, stflags, 0); 112 } 113 } 114 #endif 115 116 if (st == NULL) { 117 /* TODO: On Windows, use GetFileInfoByHandle() here. 118 * Using Windows stat() call is badly broken, but 119 * even the stat() wrapper has problems because 120 * 'struct stat' is broken on Windows. 121 */ 122 #if HAVE_FSTAT 123 if (fd >= 0) { 124 if (fstat(fd, &s) != 0) { 125 archive_set_error(&a->archive, errno, 126 "Can't fstat"); 127 return (ARCHIVE_FAILED); 128 } 129 } else 130 #endif 131 #if HAVE_LSTAT 132 if (!a->follow_symlinks) { 133 if (lstat(path, &s) != 0) { 134 archive_set_error(&a->archive, errno, 135 "Can't lstat %s", path); 136 return (ARCHIVE_FAILED); 137 } 138 } else 139 #endif 140 if (stat(path, &s) != 0) { 141 archive_set_error(&a->archive, errno, 142 "Can't lstat %s", path); 143 return (ARCHIVE_FAILED); 144 } 145 st = &s; 146 } 147 archive_entry_copy_stat(entry, st); 148 149 /* Lookup uname/gname */ 150 name = archive_read_disk_uname(_a, archive_entry_uid(entry)); 151 if (name != NULL) 152 archive_entry_copy_uname(entry, name); 153 name = archive_read_disk_gname(_a, archive_entry_gid(entry)); 154 if (name != NULL) 155 archive_entry_copy_gname(entry, name); 156 157 #ifdef HAVE_STRUCT_STAT_ST_FLAGS 158 /* On FreeBSD, we get flags for free with the stat. */ 159 /* TODO: Does this belong in copy_stat()? */ 160 if (st->st_flags != 0) 161 archive_entry_set_fflags(entry, st->st_flags, 0); 162 #endif 163 164 #ifdef HAVE_READLINK 165 if (S_ISLNK(st->st_mode)) { 166 char linkbuffer[PATH_MAX + 1]; 167 int lnklen = readlink(path, linkbuffer, PATH_MAX); 168 if (lnklen < 0) { 169 archive_set_error(&a->archive, errno, 170 "Couldn't read link data"); 171 return (ARCHIVE_FAILED); 172 } 173 linkbuffer[lnklen] = 0; 174 archive_entry_set_symlink(entry, linkbuffer); 175 } 176 #endif 177 178 r = setup_acls_posix1e(a, entry, fd); 179 r1 = setup_xattrs(a, entry, fd); 180 if (r1 < r) 181 r = r1; 182 /* If we opened the file earlier in this function, close it. */ 183 if (initial_fd != fd) 184 close(fd); 185 return (r); 186 } 187 188 #ifdef HAVE_POSIX_ACL 189 static void setup_acl_posix1e(struct archive_read_disk *a, 190 struct archive_entry *entry, acl_t acl, int archive_entry_acl_type); 191 192 static int 193 setup_acls_posix1e(struct archive_read_disk *a, 194 struct archive_entry *entry, int fd) 195 { 196 const char *accpath; 197 acl_t acl; 198 199 accpath = archive_entry_sourcepath(entry); 200 if (accpath == NULL) 201 accpath = archive_entry_pathname(entry); 202 203 archive_entry_acl_clear(entry); 204 205 /* Retrieve access ACL from file. */ 206 if (fd >= 0) 207 acl = acl_get_fd(fd); 208 #if HAVE_ACL_GET_LINK_NP 209 else if (!a->follow_symlinks) 210 acl = acl_get_link_np(accpath, ACL_TYPE_ACCESS); 211 #else 212 else if ((!a->follow_symlinks) 213 && (archive_entry_filetype(entry) == AE_IFLNK)) 214 /* We can't get the ACL of a symlink, so we assume it can't 215 have one. */ 216 acl = NULL; 217 #endif 218 else 219 acl = acl_get_file(accpath, ACL_TYPE_ACCESS); 220 if (acl != NULL) { 221 setup_acl_posix1e(a, entry, acl, 222 ARCHIVE_ENTRY_ACL_TYPE_ACCESS); 223 acl_free(acl); 224 } 225 226 /* Only directories can have default ACLs. */ 227 if (S_ISDIR(archive_entry_mode(entry))) { 228 acl = acl_get_file(accpath, ACL_TYPE_DEFAULT); 229 if (acl != NULL) { 230 setup_acl_posix1e(a, entry, acl, 231 ARCHIVE_ENTRY_ACL_TYPE_DEFAULT); 232 acl_free(acl); 233 } 234 } 235 return (ARCHIVE_OK); 236 } 237 238 /* 239 * Translate POSIX.1e ACL into libarchive internal structure. 240 */ 241 static void 242 setup_acl_posix1e(struct archive_read_disk *a, 243 struct archive_entry *entry, acl_t acl, int archive_entry_acl_type) 244 { 245 acl_tag_t acl_tag; 246 acl_entry_t acl_entry; 247 acl_permset_t acl_permset; 248 int s, ae_id, ae_tag, ae_perm; 249 const char *ae_name; 250 251 s = acl_get_entry(acl, ACL_FIRST_ENTRY, &acl_entry); 252 while (s == 1) { 253 ae_id = -1; 254 ae_name = NULL; 255 256 acl_get_tag_type(acl_entry, &acl_tag); 257 if (acl_tag == ACL_USER) { 258 ae_id = (int)*(uid_t *)acl_get_qualifier(acl_entry); 259 ae_name = archive_read_disk_uname(&a->archive, ae_id); 260 ae_tag = ARCHIVE_ENTRY_ACL_USER; 261 } else if (acl_tag == ACL_GROUP) { 262 ae_id = (int)*(gid_t *)acl_get_qualifier(acl_entry); 263 ae_name = archive_read_disk_gname(&a->archive, ae_id); 264 ae_tag = ARCHIVE_ENTRY_ACL_GROUP; 265 } else if (acl_tag == ACL_MASK) { 266 ae_tag = ARCHIVE_ENTRY_ACL_MASK; 267 } else if (acl_tag == ACL_USER_OBJ) { 268 ae_tag = ARCHIVE_ENTRY_ACL_USER_OBJ; 269 } else if (acl_tag == ACL_GROUP_OBJ) { 270 ae_tag = ARCHIVE_ENTRY_ACL_GROUP_OBJ; 271 } else if (acl_tag == ACL_OTHER) { 272 ae_tag = ARCHIVE_ENTRY_ACL_OTHER; 273 } else { 274 /* Skip types that libarchive can't support. */ 275 continue; 276 } 277 278 acl_get_permset(acl_entry, &acl_permset); 279 ae_perm = 0; 280 /* 281 * acl_get_perm() is spelled differently on different 282 * platforms; see above. 283 */ 284 if (ACL_GET_PERM(acl_permset, ACL_EXECUTE)) 285 ae_perm |= ARCHIVE_ENTRY_ACL_EXECUTE; 286 if (ACL_GET_PERM(acl_permset, ACL_READ)) 287 ae_perm |= ARCHIVE_ENTRY_ACL_READ; 288 if (ACL_GET_PERM(acl_permset, ACL_WRITE)) 289 ae_perm |= ARCHIVE_ENTRY_ACL_WRITE; 290 291 archive_entry_acl_add_entry(entry, 292 archive_entry_acl_type, ae_perm, ae_tag, 293 ae_id, ae_name); 294 295 s = acl_get_entry(acl, ACL_NEXT_ENTRY, &acl_entry); 296 } 297 } 298 #else 299 static int 300 setup_acls_posix1e(struct archive_read_disk *a, 301 struct archive_entry *entry, int fd) 302 { 303 (void)a; /* UNUSED */ 304 (void)entry; /* UNUSED */ 305 (void)fd; /* UNUSED */ 306 return (ARCHIVE_OK); 307 } 308 #endif 309 310 #if HAVE_LISTXATTR && HAVE_LLISTXATTR && HAVE_GETXATTR && HAVE_LGETXATTR 311 312 /* 313 * Linux extended attribute support. 314 * 315 * TODO: By using a stack-allocated buffer for the first 316 * call to getxattr(), we might be able to avoid the second 317 * call entirely. We only need the second call if the 318 * stack-allocated buffer is too small. But a modest buffer 319 * of 1024 bytes or so will often be big enough. Same applies 320 * to listxattr(). 321 */ 322 323 324 static int 325 setup_xattr(struct archive_read_disk *a, 326 struct archive_entry *entry, const char *name, int fd) 327 { 328 ssize_t size; 329 void *value = NULL; 330 const char *accpath; 331 332 (void)fd; /* UNUSED */ 333 334 accpath = archive_entry_sourcepath(entry); 335 if (accpath == NULL) 336 accpath = archive_entry_pathname(entry); 337 338 if (!a->follow_symlinks) 339 size = lgetxattr(accpath, name, NULL, 0); 340 else 341 size = getxattr(accpath, name, NULL, 0); 342 343 if (size == -1) { 344 archive_set_error(&a->archive, errno, 345 "Couldn't query extended attribute"); 346 return (ARCHIVE_WARN); 347 } 348 349 if (size > 0 && (value = malloc(size)) == NULL) { 350 archive_set_error(&a->archive, errno, "Out of memory"); 351 return (ARCHIVE_FATAL); 352 } 353 354 if (!a->follow_symlinks) 355 size = lgetxattr(accpath, name, value, size); 356 else 357 size = getxattr(accpath, name, value, size); 358 359 if (size == -1) { 360 archive_set_error(&a->archive, errno, 361 "Couldn't read extended attribute"); 362 return (ARCHIVE_WARN); 363 } 364 365 archive_entry_xattr_add_entry(entry, name, value, size); 366 367 free(value); 368 return (ARCHIVE_OK); 369 } 370 371 static int 372 setup_xattrs(struct archive_read_disk *a, 373 struct archive_entry *entry, int fd) 374 { 375 char *list, *p; 376 const char *path; 377 ssize_t list_size; 378 379 380 path = archive_entry_sourcepath(entry); 381 if (path == NULL) 382 path = archive_entry_pathname(entry); 383 384 if (!a->follow_symlinks) 385 list_size = llistxattr(path, NULL, 0); 386 else 387 list_size = listxattr(path, NULL, 0); 388 389 if (list_size == -1) { 390 if (errno == ENOTSUP) 391 return (ARCHIVE_OK); 392 archive_set_error(&a->archive, errno, 393 "Couldn't list extended attributes"); 394 return (ARCHIVE_WARN); 395 } 396 397 if (list_size == 0) 398 return (ARCHIVE_OK); 399 400 if ((list = malloc(list_size)) == NULL) { 401 archive_set_error(&a->archive, errno, "Out of memory"); 402 return (ARCHIVE_FATAL); 403 } 404 405 if (!a->follow_symlinks) 406 list_size = llistxattr(path, list, list_size); 407 else 408 list_size = listxattr(path, list, list_size); 409 410 if (list_size == -1) { 411 archive_set_error(&a->archive, errno, 412 "Couldn't retrieve extended attributes"); 413 free(list); 414 return (ARCHIVE_WARN); 415 } 416 417 for (p = list; (p - list) < list_size; p += strlen(p) + 1) { 418 if (strncmp(p, "system.", 7) == 0 || 419 strncmp(p, "xfsroot.", 8) == 0) 420 continue; 421 setup_xattr(a, entry, p, fd); 422 } 423 424 free(list); 425 return (ARCHIVE_OK); 426 } 427 428 #elif HAVE_EXTATTR_GET_FILE && HAVE_EXTATTR_LIST_FILE && \ 429 HAVE_DECL_EXTATTR_NAMESPACE_USER 430 431 /* 432 * FreeBSD extattr interface. 433 */ 434 435 /* TODO: Implement this. Follow the Linux model above, but 436 * with FreeBSD-specific system calls, of course. Be careful 437 * to not include the system extattrs that hold ACLs; we handle 438 * those separately. 439 */ 440 static int 441 setup_xattr(struct archive_read_disk *a, struct archive_entry *entry, 442 int namespace, const char *name, const char *fullname, int fd); 443 444 static int 445 setup_xattr(struct archive_read_disk *a, struct archive_entry *entry, 446 int namespace, const char *name, const char *fullname, int fd) 447 { 448 ssize_t size; 449 void *value = NULL; 450 const char *accpath; 451 452 (void)fd; /* UNUSED */ 453 454 accpath = archive_entry_sourcepath(entry); 455 if (accpath == NULL) 456 accpath = archive_entry_pathname(entry); 457 458 if (!a->follow_symlinks) 459 size = extattr_get_link(accpath, namespace, name, NULL, 0); 460 else 461 size = extattr_get_file(accpath, namespace, name, NULL, 0); 462 463 if (size == -1) { 464 archive_set_error(&a->archive, errno, 465 "Couldn't query extended attribute"); 466 return (ARCHIVE_WARN); 467 } 468 469 if (size > 0 && (value = malloc(size)) == NULL) { 470 archive_set_error(&a->archive, errno, "Out of memory"); 471 return (ARCHIVE_FATAL); 472 } 473 474 if (!a->follow_symlinks) 475 size = extattr_get_link(accpath, namespace, name, value, size); 476 else 477 size = extattr_get_file(accpath, namespace, name, value, size); 478 479 if (size == -1) { 480 archive_set_error(&a->archive, errno, 481 "Couldn't read extended attribute"); 482 return (ARCHIVE_WARN); 483 } 484 485 archive_entry_xattr_add_entry(entry, fullname, value, size); 486 487 free(value); 488 return (ARCHIVE_OK); 489 } 490 491 static int 492 setup_xattrs(struct archive_read_disk *a, 493 struct archive_entry *entry, int fd) 494 { 495 char buff[512]; 496 char *list, *p; 497 ssize_t list_size; 498 const char *path; 499 int namespace = EXTATTR_NAMESPACE_USER; 500 501 path = archive_entry_sourcepath(entry); 502 if (path == NULL) 503 path = archive_entry_pathname(entry); 504 505 if (!a->follow_symlinks) 506 list_size = extattr_list_link(path, namespace, NULL, 0); 507 else 508 list_size = extattr_list_file(path, namespace, NULL, 0); 509 510 if (list_size == -1 && errno == EOPNOTSUPP) 511 return (ARCHIVE_OK); 512 if (list_size == -1) { 513 archive_set_error(&a->archive, errno, 514 "Couldn't list extended attributes"); 515 return (ARCHIVE_WARN); 516 } 517 518 if (list_size == 0) 519 return (ARCHIVE_OK); 520 521 if ((list = malloc(list_size)) == NULL) { 522 archive_set_error(&a->archive, errno, "Out of memory"); 523 return (ARCHIVE_FATAL); 524 } 525 526 if (!a->follow_symlinks) 527 list_size = extattr_list_link(path, namespace, list, list_size); 528 else 529 list_size = extattr_list_file(path, namespace, list, list_size); 530 531 if (list_size == -1) { 532 archive_set_error(&a->archive, errno, 533 "Couldn't retrieve extended attributes"); 534 free(list); 535 return (ARCHIVE_WARN); 536 } 537 538 p = list; 539 while ((p - list) < list_size) { 540 size_t len = 255 & (int)*p; 541 char *name; 542 543 strcpy(buff, "user."); 544 name = buff + strlen(buff); 545 memcpy(name, p + 1, len); 546 name[len] = '\0'; 547 setup_xattr(a, entry, namespace, name, buff, fd); 548 p += 1 + len; 549 } 550 551 free(list); 552 return (ARCHIVE_OK); 553 } 554 555 #else 556 557 /* 558 * Generic (stub) extended attribute support. 559 */ 560 static int 561 setup_xattrs(struct archive_read_disk *a, 562 struct archive_entry *entry, int fd) 563 { 564 (void)a; /* UNUSED */ 565 (void)entry; /* UNUSED */ 566 (void)fd; /* UNUSED */ 567 return (ARCHIVE_OK); 568 } 569 570 #endif 571