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 22 * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT 23 * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF 24 * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. 25 */ 26 27/*- 28 * This is a new directory-walking system that addresses a number 29 * of problems I've had with fts(3). In particular, it has no 30 * pathname-length limits (other than the size of 'int'), handles 31 * deep logical traversals, uses considerably less memory, and has 32 * an opaque interface (easier to modify in the future). 33 * 34 * Internally, it keeps a single list of "tree_entry" items that 35 * represent filesystem objects that require further attention. 36 * Non-directories are not kept in memory: they are pulled from 37 * readdir(), returned to the client, then freed as soon as possible. 38 * Any directory entry to be traversed gets pushed onto the stack. 39 * 40 * There is surprisingly little information that needs to be kept for 41 * each item on the stack. Just the name, depth (represented here as the 42 * string length of the parent directory's pathname), and some markers 43 * indicating how to get back to the parent (via chdir("..") for a 44 * regular dir or via fchdir(2) for a symlink). 45 */ 46#include "bsdtar_platform.h" 47__FBSDID("$FreeBSD: src/usr.bin/tar/tree.c,v 1.9 2008/11/27 05:49:52 kientzle Exp $"); 48 49#ifdef HAVE_SYS_STAT_H 50#include <sys/stat.h> 51#endif 52#ifdef HAVE_DIRECT_H 53#include <direct.h> 54#endif 55#ifdef HAVE_DIRENT_H 56#include <dirent.h> 57#endif 58#ifdef HAVE_ERRNO_H 59#include <errno.h> 60#endif 61#ifdef HAVE_FCNTL_H 62#include <fcntl.h> 63#endif 64#ifdef HAVE_STDLIB_H 65#include <stdlib.h> 66#endif 67#ifdef HAVE_STRING_H 68#include <string.h> 69#endif 70#ifdef HAVE_UNISTD_H 71#include <unistd.h> 72#endif 73#if defined(HAVE_WINDOWS_H) && !defined(__CYGWIN__) 74#include <windows.h> 75#endif 76 77#include "tree.h" 78 79/* 80 * TODO: 81 * 1) Loop checking. 82 * 3) Arbitrary logical traversals by closing/reopening intermediate fds. 83 */ 84 85struct tree_entry { 86 int depth; 87 struct tree_entry *next; 88 struct tree_entry *parent; 89 char *name; 90 size_t dirname_length; 91 dev_t dev; 92 ino_t ino; 93 int flags; 94 /* How to return back to the parent of a symlink. */ 95#ifdef HAVE_FCHDIR 96 int symlink_parent_fd; 97#elif defined(_WIN32) && !defined(__CYGWIN__) 98 char *symlink_parent_path; 99#else 100#error fchdir function required. 101#endif 102}; 103 104/* Definitions for tree_entry.flags bitmap. */ 105#define isDir 1 /* This entry is a regular directory. */ 106#define isDirLink 2 /* This entry is a symbolic link to a directory. */ 107#define needsFirstVisit 4 /* This is an initial entry. */ 108#define needsDescent 8 /* This entry needs to be previsited. */ 109#define needsOpen 16 /* This is a directory that needs to be opened. */ 110#define needsAscent 32 /* This entry needs to be postvisited. */ 111 112/* 113 * On Windows, "first visit" is handled as a pattern to be handed to 114 * _findfirst(). This is consistent with Windows conventions that 115 * file patterns are handled within the application. On Posix, 116 * "first visit" is just returned to the client. 117 */ 118 119/* 120 * Local data for this package. 121 */ 122struct tree { 123 struct tree_entry *stack; 124 struct tree_entry *current; 125#if defined(HAVE_WINDOWS_H) && !defined(__CYGWIN__) 126 HANDLE d; 127 BY_HANDLE_FILE_INFORMATION fileInfo; 128#define INVALID_DIR_HANDLE INVALID_HANDLE_VALUE 129 WIN32_FIND_DATA _findData; 130 WIN32_FIND_DATA *findData; 131#else 132 DIR *d; 133#define INVALID_DIR_HANDLE NULL 134 struct dirent *de; 135#endif 136 int flags; 137 int visit_type; 138 int tree_errno; /* Error code from last failed operation. */ 139 140 /* Dynamically-sized buffer for holding path */ 141 char *buff; 142 size_t buff_length; 143 144 const char *basename; /* Last path element */ 145 size_t dirname_length; /* Leading dir length */ 146 size_t path_length; /* Total path length */ 147 148 int depth; 149 int openCount; 150 int maxOpenCount; 151 152 struct stat lst; 153 struct stat st; 154}; 155 156/* Definitions for tree.flags bitmap. */ 157#define hasStat 16 /* The st entry is valid. */ 158#define hasLstat 32 /* The lst entry is valid. */ 159#define hasFileInfo 64 /* The Windows fileInfo entry is valid. */ 160 161#if defined(_WIN32) && !defined(__CYGWIN__) 162static int 163tree_dir_next_windows(struct tree *t, const char *pattern); 164#else 165static int 166tree_dir_next_posix(struct tree *t); 167#endif 168 169#ifdef HAVE_DIRENT_D_NAMLEN 170/* BSD extension; avoids need for a strlen() call. */ 171#define D_NAMELEN(dp) (dp)->d_namlen 172#else 173#define D_NAMELEN(dp) (strlen((dp)->d_name)) 174#endif 175 176#include <stdio.h> 177void 178tree_dump(struct tree *t, FILE *out) 179{ 180 char buff[300]; 181 struct tree_entry *te; 182 183 fprintf(out, "\tdepth: %d\n", t->depth); 184 fprintf(out, "\tbuff: %s\n", t->buff); 185 fprintf(out, "\tpwd: %s\n", getcwd(buff, sizeof(buff))); 186 fprintf(out, "\tbasename: %s\n", t->basename); 187 fprintf(out, "\tstack:\n"); 188 for (te = t->stack; te != NULL; te = te->next) { 189 fprintf(out, "\t\t%s%d:\"%s\" %s%s%s%s%s%s\n", 190 t->current == te ? "*" : " ", 191 te->depth, 192 te->name, 193 te->flags & needsFirstVisit ? "V" : "", 194 te->flags & needsDescent ? "D" : "", 195 te->flags & needsOpen ? "O" : "", 196 te->flags & needsAscent ? "A" : "", 197 te->flags & isDirLink ? "L" : "", 198 (t->current == te && t->d) ? "+" : "" 199 ); 200 } 201} 202 203/* 204 * Add a directory path to the current stack. 205 */ 206static void 207tree_push(struct tree *t, const char *path) 208{ 209 struct tree_entry *te; 210 211 te = malloc(sizeof(*te)); 212 memset(te, 0, sizeof(*te)); 213 te->next = t->stack; 214 te->parent = t->current; 215 if (te->parent) 216 te->depth = te->parent->depth + 1; 217 t->stack = te; 218#ifdef HAVE_FCHDIR 219 te->symlink_parent_fd = -1; 220 te->name = strdup(path); 221#elif defined(_WIN32) && !defined(__CYGWIN__) 222 te->symlink_parent_path = NULL; 223 te->name = strdup(path); 224#endif 225 te->flags = needsDescent | needsOpen | needsAscent; 226 te->dirname_length = t->dirname_length; 227} 228 229/* 230 * Append a name to the current dir path. 231 */ 232static void 233tree_append(struct tree *t, const char *name, size_t name_length) 234{ 235 char *p; 236 size_t size_needed; 237 238 if (t->buff != NULL) 239 t->buff[t->dirname_length] = '\0'; 240 /* Strip trailing '/' from name, unless entire name is "/". */ 241 while (name_length > 1 && name[name_length - 1] == '/') 242 name_length--; 243 244 /* Resize pathname buffer as needed. */ 245 size_needed = name_length + 1 + t->dirname_length; 246 if (t->buff_length < size_needed) { 247 if (t->buff_length < 1024) 248 t->buff_length = 1024; 249 while (t->buff_length < size_needed) 250 t->buff_length *= 2; 251 t->buff = realloc(t->buff, t->buff_length); 252 } 253 if (t->buff == NULL) 254 abort(); 255 p = t->buff + t->dirname_length; 256 t->path_length = t->dirname_length + name_length; 257 /* Add a separating '/' if it's needed. */ 258 if (t->dirname_length > 0 && p[-1] != '/') { 259 *p++ = '/'; 260 t->path_length ++; 261 } 262#if HAVE_STRNCPY_S 263 strncpy_s(p, t->buff_length - (p - t->buff), name, name_length); 264#else 265 strncpy(p, name, name_length); 266#endif 267 p[name_length] = '\0'; 268 t->basename = p; 269} 270 271/* 272 * Open a directory tree for traversal. 273 */ 274struct tree * 275tree_open(const char *path) 276{ 277#ifdef HAVE_FCHDIR 278 struct tree *t; 279 280 t = malloc(sizeof(*t)); 281 memset(t, 0, sizeof(*t)); 282 /* First item is set up a lot like a symlink traversal. */ 283 tree_push(t, path); 284 t->stack->flags = needsFirstVisit | isDirLink | needsAscent; 285 t->stack->symlink_parent_fd = open(".", O_RDONLY); 286 t->openCount++; 287 t->d = INVALID_DIR_HANDLE; 288 return (t); 289#elif defined(_WIN32) && !defined(__CYGWIN__) 290 struct tree *t; 291 char *cwd = _getcwd(NULL, 0); 292 char *pathname = strdup(path), *p, *base; 293 294 if (pathname == NULL) 295 abort(); 296 for (p = pathname; *p != '\0'; ++p) { 297 if (*p == '\\') 298 *p = '/'; 299 } 300 base = pathname; 301 302 t = malloc(sizeof(*t)); 303 memset(t, 0, sizeof(*t)); 304 /* First item is set up a lot like a symlink traversal. */ 305 /* printf("Looking for wildcard in %s\n", path); */ 306 /* TODO: wildcard detection here screws up on \\?\c:\ UNC names */ 307 if (strchr(base, '*') || strchr(base, '?')) { 308 // It has a wildcard in it... 309 // Separate the last element. 310 p = strrchr(base, '/'); 311 if (p != NULL) { 312 *p = '\0'; 313 chdir(base); 314 tree_append(t, base, p - base); 315 t->dirname_length = t->path_length; 316 base = p + 1; 317 } 318 } 319 tree_push(t, base); 320 free(pathname); 321 t->stack->flags = needsFirstVisit | isDirLink | needsAscent; 322 t->stack->symlink_parent_path = cwd; 323 t->d = INVALID_DIR_HANDLE; 324 return (t); 325#endif 326} 327 328/* 329 * We've finished a directory; ascend back to the parent. 330 */ 331static int 332tree_ascend(struct tree *t) 333{ 334 struct tree_entry *te; 335 int r = 0; 336 337 te = t->stack; 338 t->depth--; 339 if (te->flags & isDirLink) { 340#ifdef HAVE_FCHDIR 341 if (fchdir(te->symlink_parent_fd) != 0) { 342 t->tree_errno = errno; 343 r = TREE_ERROR_FATAL; 344 } 345 close(te->symlink_parent_fd); 346#elif defined(_WIN32) && !defined(__CYGWIN__) 347 if (SetCurrentDirectory(te->symlink_parent_path) == 0) { 348 t->tree_errno = errno; 349 r = TREE_ERROR_FATAL; 350 } 351 free(te->symlink_parent_path); 352 te->symlink_parent_path = NULL; 353#endif 354 t->openCount--; 355 } else { 356#if defined(_WIN32) && !defined(__CYGWIN__) 357 if (SetCurrentDirectory("..") == 0) { 358#else 359 if (chdir("..") != 0) { 360#endif 361 t->tree_errno = errno; 362 r = TREE_ERROR_FATAL; 363 } 364 } 365 return (r); 366} 367 368/* 369 * Pop the working stack. 370 */ 371static void 372tree_pop(struct tree *t) 373{ 374 struct tree_entry *te; 375 376 if (t->buff) 377 t->buff[t->dirname_length] = '\0'; 378 if (t->stack == t->current && t->current != NULL) 379 t->current = t->current->parent; 380 te = t->stack; 381 t->stack = te->next; 382 t->dirname_length = te->dirname_length; 383 if (t->buff) { 384 t->basename = t->buff + t->dirname_length; 385 while (t->basename[0] == '/') 386 t->basename++; 387 } 388 free(te->name); 389 free(te); 390} 391 392/* 393 * Get the next item in the tree traversal. 394 */ 395int 396tree_next(struct tree *t) 397{ 398 int r; 399 400 /* If we're called again after a fatal error, that's an API 401 * violation. Just crash now. */ 402 if (t->visit_type == TREE_ERROR_FATAL) { 403 fprintf(stderr, "Unable to continue traversing" 404 " directory heirarchy after a fatal error."); 405 abort(); 406 } 407 408 while (t->stack != NULL) { 409 /* If there's an open dir, get the next entry from there. */ 410 if (t->d != INVALID_DIR_HANDLE) { 411#if defined(_WIN32) && !defined(__CYGWIN__) 412 r = tree_dir_next_windows(t, NULL); 413#else 414 r = tree_dir_next_posix(t); 415#endif 416 if (r == 0) 417 continue; 418 return (r); 419 } 420 421 if (t->stack->flags & needsFirstVisit) { 422#if defined(_WIN32) && !defined(__CYGWIN__) 423 char *d = t->stack->name; 424 t->stack->flags &= ~needsFirstVisit; 425 if (strchr(d, '*') || strchr(d, '?')) { 426 r = tree_dir_next_windows(t, d); 427 if (r == 0) 428 continue; 429 return (r); 430 } 431 // Not a pattern, handle it as-is... 432#endif 433 /* Top stack item needs a regular visit. */ 434 t->current = t->stack; 435 tree_append(t, t->stack->name, strlen(t->stack->name)); 436 //t->dirname_length = t->path_length; 437 //tree_pop(t); 438 t->stack->flags &= ~needsFirstVisit; 439 return (t->visit_type = TREE_REGULAR); 440 } else if (t->stack->flags & needsDescent) { 441 /* Top stack item is dir to descend into. */ 442 t->current = t->stack; 443 tree_append(t, t->stack->name, strlen(t->stack->name)); 444 t->stack->flags &= ~needsDescent; 445 /* If it is a link, set up fd for the ascent. */ 446 if (t->stack->flags & isDirLink) { 447#ifdef HAVE_FCHDIR 448 t->stack->symlink_parent_fd = open(".", O_RDONLY); 449 t->openCount++; 450 if (t->openCount > t->maxOpenCount) 451 t->maxOpenCount = t->openCount; 452#elif defined(_WIN32) && !defined(__CYGWIN__) 453 t->stack->symlink_parent_path = _getcwd(NULL, 0); 454#endif 455 } 456 t->dirname_length = t->path_length; 457#if defined(_WIN32) && !defined(__CYGWIN__) 458 if (t->path_length == 259 || !SetCurrentDirectory(t->stack->name) != 0) 459#else 460 if (chdir(t->stack->name) != 0) 461#endif 462 { 463 /* chdir() failed; return error */ 464 tree_pop(t); 465 t->tree_errno = errno; 466 return (t->visit_type = TREE_ERROR_DIR); 467 } 468 t->depth++; 469 return (t->visit_type = TREE_POSTDESCENT); 470 } else if (t->stack->flags & needsOpen) { 471 t->stack->flags &= ~needsOpen; 472#if defined(_WIN32) && !defined(__CYGWIN__) 473 r = tree_dir_next_windows(t, "*"); 474#else 475 r = tree_dir_next_posix(t); 476#endif 477 if (r == 0) 478 continue; 479 return (r); 480 } else if (t->stack->flags & needsAscent) { 481 /* Top stack item is dir and we're done with it. */ 482 r = tree_ascend(t); 483 tree_pop(t); 484 t->visit_type = r != 0 ? r : TREE_POSTASCENT; 485 return (t->visit_type); 486 } else { 487 /* Top item on stack is dead. */ 488 tree_pop(t); 489 t->flags &= ~hasLstat; 490 t->flags &= ~hasStat; 491 } 492 } 493 return (t->visit_type = 0); 494} 495 496#if defined(_WIN32) && !defined(__CYGWIN__) 497static int 498tree_dir_next_windows(struct tree *t, const char *pattern) 499{ 500 const char *name; 501 size_t namelen; 502 int r; 503 504 for (;;) { 505 if (pattern != NULL) { 506 t->d = FindFirstFile(pattern, &t->_findData); 507 if (t->d == INVALID_DIR_HANDLE) { 508 r = tree_ascend(t); /* Undo "chdir" */ 509 tree_pop(t); 510 t->tree_errno = errno; 511 t->visit_type = r != 0 ? r : TREE_ERROR_DIR; 512 return (t->visit_type); 513 } 514 t->findData = &t->_findData; 515 pattern = NULL; 516 } else if (!FindNextFile(t->d, &t->_findData)) { 517 FindClose(t->d); 518 t->d = INVALID_DIR_HANDLE; 519 t->findData = NULL; 520 return (0); 521 } 522 name = t->findData->cFileName; 523 namelen = strlen(name); 524 t->flags &= ~hasLstat; 525 t->flags &= ~hasStat; 526 if (name[0] == '.' && name[1] == '\0') 527 continue; 528 if (name[0] == '.' && name[1] == '.' && name[2] == '\0') 529 continue; 530 tree_append(t, name, namelen); 531 return (t->visit_type = TREE_REGULAR); 532 } 533} 534#else 535static int 536tree_dir_next_posix(struct tree *t) 537{ 538 int r; 539 const char *name; 540 size_t namelen; 541 542 if (t->d == NULL) { 543 if ((t->d = opendir(".")) == NULL) { 544 r = tree_ascend(t); /* Undo "chdir" */ 545 tree_pop(t); 546 t->tree_errno = errno; 547 t->visit_type = r != 0 ? r : TREE_ERROR_DIR; 548 return (t->visit_type); 549 } 550 } 551 for (;;) { 552 t->de = readdir(t->d); 553 if (t->de == NULL) { 554 closedir(t->d); 555 t->d = INVALID_DIR_HANDLE; 556 return (0); 557 } 558 name = t->de->d_name; 559 namelen = D_NAMELEN(t->de); 560 t->flags &= ~hasLstat; 561 t->flags &= ~hasStat; 562 if (name[0] == '.' && name[1] == '\0') 563 continue; 564 if (name[0] == '.' && name[1] == '.' && name[2] == '\0') 565 continue; 566 tree_append(t, name, namelen); 567 return (t->visit_type = TREE_REGULAR); 568 } 569} 570#endif 571 572/* 573 * Return error code. 574 */ 575int 576tree_errno(struct tree *t) 577{ 578 return (t->tree_errno); 579} 580 581/* 582 * Called by the client to mark the directory just returned from 583 * tree_next() as needing to be visited. 584 */ 585void 586tree_descend(struct tree *t) 587{ 588 if (t->visit_type != TREE_REGULAR) 589 return; 590 591 if (tree_current_is_physical_dir(t)) { 592 tree_push(t, t->basename); 593 t->stack->flags |= isDir; 594 } else if (tree_current_is_dir(t)) { 595 tree_push(t, t->basename); 596 t->stack->flags |= isDirLink; 597 } 598} 599 600/* 601 * Get the stat() data for the entry just returned from tree_next(). 602 */ 603const struct stat * 604tree_current_stat(struct tree *t) 605{ 606 if (!(t->flags & hasStat)) { 607 if (stat(tree_current_access_path(t), &t->st) != 0) 608 return NULL; 609 t->flags |= hasStat; 610 } 611 return (&t->st); 612} 613 614#if defined(HAVE_WINDOWS_H) && !defined(__CYGWIN__) 615const BY_HANDLE_FILE_INFORMATION * 616tree_current_file_information(struct tree *t) 617{ 618 if (!(t->flags & hasFileInfo)) { 619 HANDLE h = CreateFile(tree_current_access_path(t), 620 0, 0, NULL, 621 OPEN_EXISTING, 622 FILE_FLAG_BACKUP_SEMANTICS | FILE_FLAG_OPEN_REPARSE_POINT, 623 NULL); 624 if (h == INVALID_HANDLE_VALUE) 625 return NULL; 626 if (!GetFileInformationByHandle(h, &t->fileInfo)) { 627 CloseHandle(h); 628 return NULL; 629 } 630 CloseHandle(h); 631 t->flags |= hasFileInfo; 632 } 633 return (&t->fileInfo); 634} 635#endif 636/* 637 * Get the lstat() data for the entry just returned from tree_next(). 638 */ 639const struct stat * 640tree_current_lstat(struct tree *t) 641{ 642#if defined(_WIN32) && !defined(__CYGWIN__) 643 return (tree_current_stat(t)); 644#else 645 if (!(t->flags & hasLstat)) { 646 if (lstat(tree_current_access_path(t), &t->lst) != 0) 647 return NULL; 648 t->flags |= hasLstat; 649 } 650 return (&t->lst); 651#endif 652} 653 654/* 655 * Test whether current entry is a dir or link to a dir. 656 */ 657int 658tree_current_is_dir(struct tree *t) 659{ 660#if defined(_WIN32) && !defined(__CYGWIN__) 661 if (t->findData) 662 return (t->findData->dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY); 663 if (tree_current_file_information(t)) 664 return (t->fileInfo.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY); 665 return (0); 666#else 667 const struct stat *st; 668 /* 669 * If we already have lstat() info, then try some 670 * cheap tests to determine if this is a dir. 671 */ 672 if (t->flags & hasLstat) { 673 /* If lstat() says it's a dir, it must be a dir. */ 674 if (S_ISDIR(tree_current_lstat(t)->st_mode)) 675 return 1; 676 /* Not a dir; might be a link to a dir. */ 677 /* If it's not a link, then it's not a link to a dir. */ 678 if (!S_ISLNK(tree_current_lstat(t)->st_mode)) 679 return 0; 680 /* 681 * It's a link, but we don't know what it's a link to, 682 * so we'll have to use stat(). 683 */ 684 } 685 686 st = tree_current_stat(t); 687 /* If we can't stat it, it's not a dir. */ 688 if (st == NULL) 689 return 0; 690 /* Use the definitive test. Hopefully this is cached. */ 691 return (S_ISDIR(st->st_mode)); 692#endif 693} 694 695/* 696 * Test whether current entry is a physical directory. Usually, we 697 * already have at least one of stat() or lstat() in memory, so we 698 * use tricks to try to avoid an extra trip to the disk. 699 */ 700int 701tree_current_is_physical_dir(struct tree *t) 702{ 703#if defined(_WIN32) && !defined(__CYGWIN__) 704 if (tree_current_is_physical_link(t)) 705 return (0); 706 return (tree_current_is_dir(t)); 707#else 708 const struct stat *st; 709 710 /* 711 * If stat() says it isn't a dir, then it's not a dir. 712 * If stat() data is cached, this check is free, so do it first. 713 */ 714 if ((t->flags & hasStat) 715 && (!S_ISDIR(tree_current_stat(t)->st_mode))) 716 return 0; 717 718 /* 719 * Either stat() said it was a dir (in which case, we have 720 * to determine whether it's really a link to a dir) or 721 * stat() info wasn't available. So we use lstat(), which 722 * hopefully is already cached. 723 */ 724 725 st = tree_current_lstat(t); 726 /* If we can't stat it, it's not a dir. */ 727 if (st == NULL) 728 return 0; 729 /* Use the definitive test. Hopefully this is cached. */ 730 return (S_ISDIR(st->st_mode)); 731#endif 732} 733 734/* 735 * Test whether current entry is a symbolic link. 736 */ 737int 738tree_current_is_physical_link(struct tree *t) 739{ 740#if defined(_WIN32) && !defined(__CYGWIN__) 741#ifndef IO_REPARSE_TAG_SYMLINK 742/* Old SDKs do not provide IO_REPARSE_TAG_SYMLINK */ 743#define IO_REPARSE_TAG_SYMLINK 0xA000000CL 744#endif 745 if (t->findData) 746 return ((t->findData->dwFileAttributes & FILE_ATTRIBUTE_REPARSE_POINT) 747 && (t->findData->dwReserved0 == IO_REPARSE_TAG_SYMLINK)); 748 return (0); 749#else 750 const struct stat *st = tree_current_lstat(t); 751 if (st == NULL) 752 return 0; 753 return (S_ISLNK(st->st_mode)); 754#endif 755} 756 757/* 758 * Return the access path for the entry just returned from tree_next(). 759 */ 760const char * 761tree_current_access_path(struct tree *t) 762{ 763 return (t->basename); 764} 765 766/* 767 * Return the full path for the entry just returned from tree_next(). 768 */ 769const char * 770tree_current_path(struct tree *t) 771{ 772 return (t->buff); 773} 774 775/* 776 * Return the length of the path for the entry just returned from tree_next(). 777 */ 778size_t 779tree_current_pathlen(struct tree *t) 780{ 781 return (t->path_length); 782} 783 784/* 785 * Return the nesting depth of the entry just returned from tree_next(). 786 */ 787int 788tree_current_depth(struct tree *t) 789{ 790 return (t->depth); 791} 792 793/* 794 * Terminate the traversal and release any resources. 795 */ 796void 797tree_close(struct tree *t) 798{ 799 /* Release anything remaining in the stack. */ 800 while (t->stack != NULL) 801 tree_pop(t); 802 free(t->buff); 803 /* TODO: Ensure that premature close() resets cwd */ 804#if 0 805#ifdef HAVE_FCHDIR 806 if (t->initialDirFd >= 0) { 807 int s = fchdir(t->initialDirFd); 808 (void)s; /* UNUSED */ 809 close(t->initialDirFd); 810 t->initialDirFd = -1; 811 } 812#elif defined(_WIN32) && !defined(__CYGWIN__) 813 if (t->initialDir != NULL) { 814 SetCurrentDir(t->initialDir); 815 free(t->initialDir); 816 t->initialDir = NULL; 817 } 818#endif 819#endif 820 free(t); 821} 822