Lines Matching full:t
58 * As the include guards don't agree, the order of include is important.
269 tree_dir_next_posix(struct tree *t);
300 * directory couldn't be opened, for instance). This is returned
302 * fatal error, but it does imply that the relevant subtree won't be
625 struct tree *t = a->tree;
626 struct filesystem *cf = t->current_filesystem;
631 /* If we couldn't get a filesystem alignment,
632 * we use 4096 as default value but we won't use
661 "Couldn't allocate memory");
689 struct tree *t = a->tree;
699 if (t->entry_eof || t->entry_remaining_bytes <= 0) {
707 if (t->entry_fd < 0) {
716 if (t->current_filesystem->xfer_align != -1 &&
717 t->nlink == 1)
724 if ((t->flags & needsRestoreTimes) != 0 &&
725 t->restore_time.noatime == 0)
728 t->entry_fd = open_on_current_dir(t,
729 tree_current_access_path(t), flags);
730 __archive_ensure_cloexec_flag(t->entry_fd);
734 * if successful, set 1 to t->restore_time.noatime
739 if (t->entry_fd >= 0)
740 t->restore_time.noatime = 1;
745 if (t->entry_fd < 0) {
747 "Couldn't open %s", tree_current_path(t));
749 tree_enter_initial_dir(t);
752 tree_enter_initial_dir(t);
758 if (t->current_filesystem->allocation_ptr == NULL) {
765 t->entry_buff = t->current_filesystem->buff;
766 t->entry_buff_size = t->current_filesystem->buff_size;
768 buffbytes = t->entry_buff_size;
769 if ((int64_t)buffbytes > t->current_sparse->length)
770 buffbytes = t->current_sparse->length;
772 if (t->current_sparse->length == 0)
777 * TODO: Should we consider t->current_filesystem->xfer_align?
779 if (t->current_sparse->offset > t->entry_total) {
780 if (lseek(t->entry_fd,
781 (off_t)t->current_sparse->offset, SEEK_SET) < 0) {
787 sparse_bytes = t->current_sparse->offset - t->entry_total;
788 t->entry_remaining_bytes -= sparse_bytes;
789 t->entry_total += sparse_bytes;
796 bytes = read(t->entry_fd, t->entry_buff, buffbytes);
811 t->entry_eof = 1;
815 *buff = t->entry_buff;
817 *offset = t->entry_total;
818 t->entry_total += bytes;
819 t->entry_remaining_bytes -= bytes;
820 if (t->entry_remaining_bytes == 0) {
822 close_and_restore_time(t->entry_fd, t, &t->restore_time);
823 t->entry_fd = -1;
824 t->entry_eof = 1;
826 t->current_sparse->offset += bytes;
827 t->current_sparse->length -= bytes;
828 if (t->current_sparse->length == 0 && !t->entry_eof)
829 t->current_sparse++;
835 *offset = t->entry_total;
836 if (t->entry_fd >= 0) {
838 close_and_restore_time(t->entry_fd, t, &t->restore_time);
839 t->entry_fd = -1;
845 next_entry(struct archive_read_disk *a, struct tree *t,
860 t->descend = 0;
862 switch (tree_next(t)) {
864 archive_set_error(&a->archive, t->tree_errno,
866 tree_current_path(t));
868 tree_enter_initial_dir(t);
872 "%s: Couldn't visit directory",
873 tree_current_path(t));
874 tree_enter_initial_dir(t);
877 tree_enter_initial_dir(t);
883 lst = tree_current_lstat(t);
885 if (errno == ENOENT && t->depth > 0) {
890 "%s", tree_current_path(t));
893 " %s", tree_current_path(t));
898 tree_current_path(t));
899 tree_enter_initial_dir(t);
910 const char *bname = strrchr(tree_current_path(t), '/');
912 bname = tree_current_path(t);
920 archive_entry_copy_pathname(entry, tree_current_path(t));
942 switch(t->symlink_mode) {
945 t->symlink_mode = 'P';
950 descend = tree_current_is_dir(t);
955 st = tree_current_stat(t);
956 if (st != NULL && !tree_target_is_same_as_parent(t, st))
959 * in that case, don't follow the link. */
962 /* 'P': Don't descend through a symlink to dir. */
963 descend = tree_current_is_physical_dir(t);
964 /* 'P': Don't follow symlinks to files. */
974 tree_enter_initial_dir(t);
977 if (t->initial_filesystem_id == -1)
978 t->initial_filesystem_id = t->current_filesystem_id;
980 if (t->initial_filesystem_id != t->current_filesystem_id)
983 t->descend = descend;
1000 t->entry_fd = open_on_current_dir(t,
1001 tree_current_access_path(t),
1003 __archive_ensure_cloexec_flag(t->entry_fd);
1004 if (t->entry_fd >= 0) {
1005 r = ioctl(t->entry_fd,
1028 t->restore_time.mtime = archive_entry_mtime(entry);
1029 t->restore_time.mtime_nsec = archive_entry_mtime_nsec(entry);
1030 t->restore_time.atime = archive_entry_atime(entry);
1031 t->restore_time.atime_nsec = archive_entry_atime_nsec(entry);
1032 t->restore_time.filetype = archive_entry_filetype(entry);
1033 t->restore_time.noatime = t->current_filesystem->noatime;
1091 archive_entry_copy_sourcepath(entry, tree_current_access_path(t));
1093 t->entry_fd, st);
1124 struct tree *t;
1131 t = a->tree;
1132 if (t->entry_fd >= 0) {
1133 close_and_restore_time(t->entry_fd, t, &t->restore_time);
1134 t->entry_fd = -1;
1140 r = next_entry(a, t, entry);
1141 if (t->entry_fd >= 0) {
1142 close(t->entry_fd);
1143 t->entry_fd = -1;
1154 tree_enter_initial_dir(t);
1168 archive_entry_copy_sourcepath(entry, tree_current_path(t));
1169 t->entry_total = 0;
1171 t->nlink = archive_entry_nlink(entry);
1172 t->entry_remaining_bytes = archive_entry_size(entry);
1173 t->entry_eof = (t->entry_remaining_bytes == 0)? 1: 0;
1174 if (!t->entry_eof &&
1178 t->entry_remaining_bytes = 0;
1179 t->entry_eof = 1;
1197 struct tree *t = a->tree;
1201 t->sparse_count = archive_entry_sparse_reset(entry);
1202 if (t->sparse_count+1 > t->sparse_list_size) {
1203 free(t->sparse_list);
1204 t->sparse_list_size = t->sparse_count + 1;
1205 t->sparse_list = malloc(sizeof(t->sparse_list[0]) *
1206 t->sparse_list_size);
1207 if (t->sparse_list == NULL) {
1208 t->sparse_list_size = 0;
1210 "Can't allocate data");
1215 for (i = 0; i < t->sparse_count; i++) {
1217 t->sparse_list[i].offset = offset;
1218 t->sparse_list[i].length = length;
1221 t->sparse_list[i].offset = 0;
1222 t->sparse_list[i].length = archive_entry_size(entry);
1224 t->sparse_list[i].offset = archive_entry_size(entry);
1225 t->sparse_list[i].length = 0;
1227 t->current_sparse = t->sparse_list;
1265 struct tree *t = a->tree;
1271 return (t->visit_type == TREE_REGULAR && t->descend);
1282 struct tree *t = a->tree;
1297 * top level of a traverse.) But we can't necessarily assume t->st is
1298 * valid here (though t->lst is), which complicates the logic a
1301 if (tree_current_is_physical_dir(t)) {
1302 tree_push(t, t->basename, t->current_filesystem_id,
1303 t->lst.st_dev, t->lst.st_ino, &t->restore_time);
1304 if (t->stack->parent->parent != NULL)
1305 t->stack->flags |= isDir;
1307 t->stack->flags |= isDirLink;
1308 } else if (tree_current_is_dir(t)) {
1309 tree_push(t, t->basename, t->current_filesystem_id,
1310 t->st.st_dev, t->st.st_ino, &t->restore_time);
1311 t->stack->flags |= isDirLink;
1313 t->descend = 0;
1348 "Can't allocate memory");
1351 "Can't convert a path to a char string");
1374 "Can't allocate tar data");
1401 struct tree *t = a->tree;
1404 if (t->current_filesystem != NULL &&
1405 t->current_filesystem->dev == dev)
1408 for (i = 0; i < t->max_filesystem_id; i++) {
1409 if (t->filesystem_table[i].dev == dev) {
1411 t->current_filesystem_id = i;
1412 t->current_filesystem = &(t->filesystem_table[i]);
1420 fid = t->max_filesystem_id++;
1421 if (t->max_filesystem_id > t->allocated_filesystem) {
1425 s = t->max_filesystem_id * 2;
1426 p = realloc(t->filesystem_table,
1427 s * sizeof(*t->filesystem_table));
1430 "Can't allocate tar data");
1433 t->filesystem_table = (struct filesystem *)p;
1434 t->allocated_filesystem = s;
1436 t->current_filesystem_id = fid;
1437 t->current_filesystem = &(t->filesystem_table[fid]);
1438 t->current_filesystem->dev = dev;
1439 t->current_filesystem->allocation_ptr = NULL;
1440 t->current_filesystem->buff = NULL;
1480 get_xfer_size(struct tree *t, int fd, const char *path)
1482 t->current_filesystem->xfer_align = -1;
1485 t->current_filesystem->incr_xfer_size =
1487 t->current_filesystem->max_xfer_size =
1489 t->current_filesystem->min_xfer_size =
1491 t->current_filesystem->xfer_align =
1494 t->current_filesystem->incr_xfer_size =
1496 t->current_filesystem->max_xfer_size =
1498 t->current_filesystem->min_xfer_size =
1500 t->current_filesystem->xfer_align =
1504 if (t->current_filesystem->xfer_align == -1)
1511 get_xfer_size(struct tree *t, int fd, const char *path)
1513 (void)t; /* UNUSED */
1561 struct tree *t = a->tree;
1584 t->current_filesystem->synthetic = -1;
1585 t->current_filesystem->remote = -1;
1586 if (tree_current_is_symblic_link_target(t)) {
1592 int fd = openat(tree_current_dir_fd(t),
1593 tree_current_access_path(t), O_RDONLY | O_CLOEXEC);
1602 xr = get_xfer_size(t, fd, NULL);
1605 if (tree_enter_working_dir(t) != 0) {
1609 r = statfs(tree_current_access_path(t), &sfs);
1611 xr = get_xfer_size(t, -1, tree_current_access_path(t));
1614 r = fstatfs(tree_current_dir_fd(t), &sfs);
1616 xr = get_xfer_size(t, tree_current_dir_fd(t), NULL);
1623 set_statfs_transfer_size(t->current_filesystem, &sfs);
1626 t->current_filesystem->remote = 0;
1628 t->current_filesystem->remote = 1;
1637 t->current_filesystem->synthetic = 1;
1639 t->current_filesystem->synthetic = 0;
1644 t->current_filesystem->noatime = 1;
1647 t->current_filesystem->noatime = 0;
1652 t->current_filesystem->name_max = sfs.f_namemax;
1656 if (tree_current_is_symblic_link_target(t)) {
1657 if (tree_enter_working_dir(t) != 0) {
1661 nm = pathconf(tree_current_access_path(t), _PC_NAME_MAX);
1663 nm = fpathconf(tree_current_dir_fd(t), _PC_NAME_MAX);
1668 t->current_filesystem->name_max = NAME_MAX;
1670 t->current_filesystem->name_max = nm;
1672 if (t->current_filesystem->name_max == 0) {
1689 struct tree *t = a->tree;
1693 t->current_filesystem->synthetic = -1;
1694 if (tree_enter_working_dir(t) != 0) {
1698 if (tree_current_is_symblic_link_target(t)) {
1699 r = statvfs(tree_current_access_path(t), &svfs);
1701 xr = get_xfer_size(t, -1, tree_current_access_path(t));
1704 r = fstatvfs(tree_current_dir_fd(t), &svfs);
1706 xr = get_xfer_size(t, tree_current_dir_fd(t), NULL);
1710 xr = get_xfer_size(t, -1, ".");
1714 t->current_filesystem->remote = -1;
1720 set_statvfs_transfer_size(t->current_filesystem, &svfs);
1723 t->current_filesystem->remote = 0;
1725 t->current_filesystem->remote = 1;
1729 t->current_filesystem->noatime = 1;
1732 t->current_filesystem->noatime = 0;
1735 t->current_filesystem->name_max = svfs.f_namemax;
1758 struct tree *t = a->tree;
1765 if (tree_current_is_symblic_link_target(t)) {
1771 int fd = openat(tree_current_dir_fd(t),
1772 tree_current_access_path(t), O_RDONLY | O_CLOEXEC);
1784 xr = get_xfer_size(t, fd, NULL);
1787 if (tree_enter_working_dir(t) != 0) {
1792 vr = statvfs(tree_current_access_path(t), &svfs);
1794 r = statfs(tree_current_access_path(t), &sfs);
1796 xr = get_xfer_size(t, -1, tree_current_access_path(t));
1801 vr = fstatvfs(tree_current_dir_fd(t), &svfs);
1803 r = fstatfs(tree_current_dir_fd(t), &sfs);
1805 xr = get_xfer_size(t, tree_current_dir_fd(t), NULL);
1807 if (tree_enter_working_dir(t) != 0) {
1816 xr = get_xfer_size(t, -1, ".");
1820 t->current_filesystem->synthetic = -1;
1821 t->current_filesystem->remote = -1;
1827 set_statvfs_transfer_size(t->current_filesystem, &svfs);
1829 set_statfs_transfer_size(t->current_filesystem, &sfs);
1839 t->current_filesystem->remote = 1;
1840 t->current_filesystem->synthetic = 0;
1845 t->current_filesystem->remote = 0;
1846 t->current_filesystem->synthetic = 1;
1849 t->current_filesystem->remote = 0;
1850 t->current_filesystem->synthetic = 0;
1860 t->current_filesystem->noatime = 1;
1863 t->current_filesystem->noatime = 0;
1868 t->current_filesystem->name_max = svfs.f_namemax;
1870 t->current_filesystem->name_max = sfs.f_namelen;
1872 if (t->current_filesystem->name_max == 0) {
1890 struct tree *t = a->tree;
1894 t->current_filesystem->synthetic = -1;/* Not supported */
1895 t->current_filesystem->remote = -1;/* Not supported */
1896 if (tree_current_is_symblic_link_target(t)) {
1902 int fd = openat(tree_current_dir_fd(t),
1903 tree_current_access_path(t), O_RDONLY | O_CLOEXEC);
1912 xr = get_xfer_size(t, fd, NULL);
1915 if (tree_enter_working_dir(t) != 0) {
1919 r = statvfs(tree_current_access_path(t), &svfs);
1921 xr = get_xfer_size(t, -1, tree_current_access_path(t));
1925 r = fstatvfs(tree_current_dir_fd(t), &svfs);
1927 xr = get_xfer_size(t, tree_current_dir_fd(t), NULL);
1929 if (tree_enter_working_dir(t) != 0) {
1935 xr = get_xfer_size(t, -1, ".");
1939 t->current_filesystem->synthetic = -1;
1940 t->current_filesystem->remote = -1;
1945 set_statvfs_transfer_size(t->current_filesystem, &svfs);
1950 t->current_filesystem->noatime = 1;
1953 t->current_filesystem->noatime = 0;
1957 t->current_filesystem->name_max = svfs.f_namemax;
1958 if (t->current_filesystem->name_max == 0) {
1976 struct tree *t = a->tree;
1980 t->current_filesystem->synthetic = -1;/* Not supported */
1981 t->current_filesystem->remote = -1;/* Not supported */
1982 t->current_filesystem->noatime = 0;
1983 (void)get_xfer_size(t, -1, ".");/* Dummy call to avoid build error. */
1984 t->current_filesystem->xfer_align = -1;/* Unknown */
1985 t->current_filesystem->max_xfer_size = -1;
1986 t->current_filesystem->min_xfer_size = -1;
1987 t->current_filesystem->incr_xfer_size = -1;
1992 if (tree_current_is_symblic_link_target(t)) {
1993 if (tree_enter_working_dir(t) != 0) {
1997 nm = pathconf(tree_current_access_path(t), _PC_NAME_MAX);
1999 nm = fpathconf(tree_current_dir_fd(t), _PC_NAME_MAX);
2007 t->current_filesystem->name_max = NAME_MAX;
2011 t->current_filesystem->name_max = PATH_MAX;
2015 t->current_filesystem->name_max = nm;
2017 if (t->current_filesystem->name_max == 0) {
2029 close_and_restore_time(int fd, struct tree *t, struct restore_time *rt)
2032 (void)t; /* UNUSED */
2041 if ((t->flags & needsRestoreTimes) == 0 || rt->noatime) {
2071 if (futimesat(tree_current_dir_fd(t), rt->name, times) == 0)
2085 open_on_current_dir(struct tree *t, const char *path, int flags)
2088 return (openat(tree_current_dir_fd(t), path, flags));
2090 if (tree_enter_working_dir(t) != 0)
2109 /* We won't try F_DUPFD_CLOEXEC. */
2122 tree_push(struct tree *t, const char *path, int filesystem_id,
2130 te->next = t->stack;
2131 te->parent = t->current;
2134 t->stack = te;
2142 te->dirname_length = t->dirname_length;
2158 tree_append(struct tree *t, const char *name, size_t name_length)
2162 t->path.s[t->dirname_length] = '\0';
2163 t->path.length = t->dirname_length;
2169 size_needed = name_length + t->dirname_length + 2;
2170 archive_string_ensure(&t->path, size_needed);
2172 if (t->dirname_length > 0 && t->path.s[archive_strlen(&t->path)-1] != '/')
2173 archive_strappend_char(&t->path, '/');
2174 t->basename = t->path.s + archive_strlen(&t->path);
2175 archive_strncat(&t->path, name, name_length);
2176 t->restore_time.name = t->basename;
2185 struct tree *t;
2187 if ((t = calloc(1, sizeof(*t))) == NULL)
2189 archive_string_init(&t->path);
2190 archive_string_ensure(&t->path, 31);
2191 t->initial_symlink_mode = symlink_mode;
2192 return (tree_reopen(t, path, restore_time));
2196 tree_reopen(struct tree *t, const char *path, int restore_time)
2209 t->flags = (restore_time != 0)?needsRestoreTimes:0;
2210 t->flags |= onInitialDir;
2211 t->visit_type = 0;
2212 t->tree_errno = 0;
2213 t->dirname_length = 0;
2214 t->depth = 0;
2215 t->descend = 0;
2216 t->current = NULL;
2217 t->d = INVALID_DIR_HANDLE;
2218 t->symlink_mode = t->initial_symlink_mode;
2219 archive_string_empty(&t->path);
2220 t->entry_fd = -1;
2221 t->entry_eof = 0;
2222 t->entry_remaining_bytes = 0;
2223 t->initial_filesystem_id = -1;
2226 tree_push(t, path, 0, 0, 0, NULL);
2227 t->stack->flags = needsFirstVisit;
2228 t->maxOpenCount = t->openCount = 1;
2229 t->initial_dir_fd = open(".", O_RDONLY | O_CLOEXEC);
2237 if (t->initial_dir_fd < 0)
2238 t->initial_dir_fd = open(".", o_flag | O_CLOEXEC);
2240 __archive_ensure_cloexec_flag(t->initial_dir_fd);
2241 t->working_dir_fd = tree_dup(t->initial_dir_fd);
2242 return (t);
2246 tree_descent(struct tree *t)
2250 t->dirname_length = archive_strlen(&t->path);
2255 new_fd = open_on_current_dir(t, t->stack->name.s, flag);
2258 t->tree_errno = errno;
2261 t->depth++;
2263 if (t->stack->flags & isDirLink) {
2264 t->stack->symlink_parent_fd = t->working_dir_fd;
2265 t->openCount++;
2266 if (t->openCount > t->maxOpenCount)
2267 t->maxOpenCount = t->openCount;
2269 close(t->working_dir_fd);
2271 t->working_dir_fd = new_fd;
2272 t->flags &= ~onWorkingDir;
2281 tree_ascend(struct tree *t)
2286 te = t->stack;
2287 prev_dir_fd = t->working_dir_fd;
2291 new_fd = open_on_current_dir(t, "..", O_RDONLY | O_CLOEXEC);
2295 t->tree_errno = errno;
2299 t->working_dir_fd = new_fd;
2300 t->flags &= ~onWorkingDir;
2303 close_and_restore_time(prev_dir_fd, t, &te->restore_time);
2305 t->openCount--;
2308 t->depth--;
2317 tree_enter_initial_dir(struct tree *t)
2321 if ((t->flags & onInitialDir) == 0) {
2322 r = fchdir(t->initial_dir_fd);
2324 t->flags &= ~onWorkingDir;
2325 t->flags |= onInitialDir;
2335 tree_enter_working_dir(struct tree *t)
2344 if (t->depth > 0 && (t->flags & onWorkingDir) == 0) {
2345 r = fchdir(t->working_dir_fd);
2347 t->flags &= ~onInitialDir;
2348 t->flags |= onWorkingDir;
2355 tree_current_dir_fd(struct tree *t)
2357 return (t->working_dir_fd);
2364 tree_pop(struct tree *t)
2368 t->path.s[t->dirname_length] = '\0';
2369 t->path.length = t->dirname_length;
2370 if (t->stack == t->current && t->current != NULL)
2371 t->current = t->current->parent;
2372 te = t->stack;
2373 t->stack = te->next;
2374 t->dirname_length = te->dirname_length;
2375 t->basename = t->path.s + t->dirname_length;
2376 while (t->basename[0] == '/')
2377 t->basename++;
2386 tree_next(struct tree *t)
2390 while (t->stack != NULL) {
2392 if (t->d != INVALID_DIR_HANDLE) {
2393 r = tree_dir_next_posix(t);
2399 if (t->stack->flags & needsFirstVisit) {
2401 t->current = t->stack;
2402 tree_append(t, t->stack->name.s,
2403 archive_strlen(&(t->stack->name)));
2404 /* t->dirname_length = t->path_length; */
2405 /* tree_pop(t); */
2406 t->stack->flags &= ~needsFirstVisit;
2407 return (t->visit_type = TREE_REGULAR);
2408 } else if (t->stack->flags & needsDescent) {
2410 t->current = t->stack;
2411 tree_append(t, t->stack->name.s,
2412 archive_strlen(&(t->stack->name)));
2413 t->stack->flags &= ~needsDescent;
2414 r = tree_descent(t);
2416 tree_pop(t);
2417 t->visit_type = r;
2419 t->visit_type = TREE_POSTDESCENT;
2420 return (t->visit_type);
2421 } else if (t->stack->flags & needsOpen) {
2422 t->stack->flags &= ~needsOpen;
2423 r = tree_dir_next_posix(t);
2427 } else if (t->stack->flags & needsAscent) {
2429 r = tree_ascend(t);
2430 tree_pop(t);
2431 t->visit_type = r != 0 ? r : TREE_POSTASCENT;
2432 return (t->visit_type);
2435 tree_pop(t);
2436 t->flags &= ~hasLstat;
2437 t->flags &= ~hasStat;
2440 return (t->visit_type = 0);
2444 tree_dir_next_posix(struct tree *t)
2450 if (t->d == NULL) {
2456 t->d = fdopendir(tree_dup(t->working_dir_fd));
2458 if (tree_enter_working_dir(t) == 0) {
2459 t->d = opendir(".");
2461 __archive_ensure_cloexec_flag(dirfd(t->d));
2465 if (t->d == NULL) {
2466 r = tree_ascend(t); /* Undo "chdir" */
2467 tree_pop(t);
2468 t->tree_errno = errno;
2469 t->visit_type = r != 0 ? r : TREE_ERROR_DIR;
2470 return (t->visit_type);
2474 t->filesystem_table[t->current->filesystem_id].name_max + 1;
2475 if (t->dirent == NULL || t->dirent_allocated < dirent_size) {
2476 free(t->dirent);
2477 t->dirent = malloc(dirent_size);
2478 if (t->dirent == NULL) {
2479 closedir(t->d);
2480 t->d = INVALID_DIR_HANDLE;
2481 (void)tree_ascend(t);
2482 tree_pop(t);
2483 t->tree_errno = ENOMEM;
2484 t->visit_type = TREE_ERROR_DIR;
2485 return (t->visit_type);
2487 t->dirent_allocated = dirent_size;
2494 r = readdir_r(t->d, t->dirent, &t->de);
2505 if (r != 0 || t->de == NULL) {
2507 t->de = readdir(t->d);
2508 if (t->de == NULL) {
2511 closedir(t->d);
2512 t->d = INVALID_DIR_HANDLE;
2514 t->tree_errno = r;
2515 t->visit_type = TREE_ERROR_DIR;
2516 return (t->visit_type);
2520 name = t->de->d_name;
2521 namelen = D_NAMELEN(t->de);
2522 t->flags &= ~hasLstat;
2523 t->flags &= ~hasStat;
2528 tree_append(t, name, namelen);
2529 return (t->visit_type = TREE_REGULAR);
2538 tree_current_stat(struct tree *t)
2540 if (!(t->flags & hasStat)) {
2542 if (fstatat(tree_current_dir_fd(t),
2543 tree_current_access_path(t), &t->st, 0) != 0)
2545 if (tree_enter_working_dir(t) != 0)
2547 if (la_stat(tree_current_access_path(t), &t->st) != 0)
2550 t->flags |= hasStat;
2552 return (&t->st);
2559 tree_current_lstat(struct tree *t)
2561 if (!(t->flags & hasLstat)) {
2563 if (fstatat(tree_current_dir_fd(t),
2564 tree_current_access_path(t), &t->lst,
2567 if (tree_enter_working_dir(t) != 0)
2570 if (lstat(tree_current_access_path(t), &t->lst) != 0)
2572 if (la_stat(tree_current_access_path(t), &t->lst) != 0)
2576 t->flags |= hasLstat;
2578 return (&t->lst);
2585 tree_current_is_dir(struct tree *t)
2592 if (t->flags & hasLstat) {
2594 st = tree_current_lstat(t);
2604 * It's a link, but we don't know what it's a link to,
2609 st = tree_current_stat(t);
2610 /* If we can't stat it, it's not a dir. */
2623 tree_current_is_physical_dir(struct tree *t)
2628 * If stat() says it isn't a dir, then it's not a dir.
2631 if (t->flags & hasStat) {
2632 st = tree_current_stat(t);
2642 * stat() info wasn't available. So we use lstat(), which
2646 st = tree_current_lstat(t);
2647 /* If we can't stat it, it's not a dir. */
2658 tree_target_is_same_as_parent(struct tree *t, const struct stat *st)
2662 for (te = t->current->parent; te != NULL; te = te->parent) {
2675 tree_current_is_symblic_link_target(struct tree *t)
2679 lst = tree_current_lstat(t);
2680 st = tree_current_stat(t);
2682 (int64_t)st->st_dev == t->current_filesystem->dev &&
2690 tree_current_access_path(struct tree *t)
2692 return (t->basename);
2699 tree_current_path(struct tree *t)
2701 return (t->path.s);
2708 tree_close(struct tree *t)
2711 if (t == NULL)
2713 if (t->entry_fd >= 0) {
2714 close_and_restore_time(t->entry_fd, t, &t->restore_time);
2715 t->entry_fd = -1;
2718 if (t->d != INVALID_DIR_HANDLE) {
2719 closedir(t->d);
2720 t->d = INVALID_DIR_HANDLE;
2723 while (t->stack != NULL) {
2724 if (t->stack->flags & isDirLink)
2725 close(t->stack->symlink_parent_fd);
2726 tree_pop(t);
2728 if (t->working_dir_fd >= 0) {
2729 close(t->working_dir_fd);
2730 t->working_dir_fd = -1;
2732 if (t->initial_dir_fd >= 0) {
2733 close(t->initial_dir_fd);
2734 t->initial_dir_fd = -1;
2742 tree_free(struct tree *t)
2746 if (t == NULL)
2748 archive_string_free(&t->path);
2750 free(t->dirent);
2752 free(t->sparse_list);
2753 for (i = 0; i < t->max_filesystem_id; i++)
2754 free(t->filesystem_table[i].allocation_ptr);
2755 free(t->filesystem_table);
2756 free(t);