Changeset 2985 for trunk/src/lib/nt

Timestamp:

Nov 1, 2016, 7:26:35 PM (9 years ago)

Author:

bird

Message:

lib/nt: Got fts-nt halfways working, quite a few NT interface changes.

Location:

trunk/src/lib/nt

Files:

• fts-nt.c (modified) (46 diffs)
• fts-nt.h (modified) (8 diffs)
• kFsCache.c (modified) (1 diff)
• ntdir.c (modified) (6 diffs)
• ntdir.h (modified) (2 diffs)
• nthlp.h (modified) (1 diff)
• nthlpcore.c (modified) (4 diffs)
• nthlpfs.c (modified) (8 diffs)
• ntstat.c (modified) (17 diffs)
• ntstat.h (modified) (1 diff)
• ntstuff.h (modified) (5 diffs)
• ntunlink.c (modified) (2 diffs)

trunk/src/lib/nt/fts-nt.c

@@ +1 @@
+/* $Id: $ */
+/** @file
+ * Source for the NT port of BSD fts.c.
+ *
+ * @copyright   1990, 1993, 1994 The Regents of the University of California.  All rights reserved.
+ * @copyright   NT modifications Copyright (C) 2016 knut st. osmundsen <bird-klibc-spam-xiv@anduin.net>
+ * @licenses    BSD3
+ *
+ *
+ * Some hints about how the code works.
+ *
+ * The input directories & files are entered into a pseudo root directory and
+ * processed one after another, depth first.
+ *
+ * Directories are completely read into memory first and arranged as linked
+ * list anchored on FTS::fts_cur.  fts_read does a pop-like operation on that
+ * list, freeing the nodes after they've been completely processed.
+ * Subdirectories are returned twice by fts_read, the first time when it
+ * decends into it (FTS_D), and the second time as it ascends from it (FTS_DP).
+ *
+ * In parallel to fts_read, there's the fts_children API that fetches the
+ * directory content in a similar manner, but for the consumption of the API
+ * caller rather than FTS itself.  The result hangs on FTS::fts_child so it can
+ * be freed when the directory changes or used by fts_read when it is called
+ * upon to enumerate the directory.
+ *
+ *
+ * The NT port of the code does away with the directory changing in favor of
+ * using directory relative opens (present in NT since for ever, just not
+ * exposed thru Win32).  A new FTSENT member fts_dirfd has been added to make
+ * this possible for API users too.
+ *
+ * Note! When using Win32 APIs with path input relative to the current
+ *       directory, the internal DOS <-> NT path converter will expand it to a
+ *       full path and subject it to the 260 char limit.
+ *
+ * The richer NT directory enumeration API allows us to do away with all the
+ * stat() calls, and not have to do link counting and other interesting things
+ * to try speed things up.  (You typical stat() implementation on windows is
+ * actually a directory enum call with the name of the file as filter.)
+ */
+
 /*-
  * Copyright (c) 1990, 1993, 1994
@@ -36 +78 @@
 #endif
 
-#include <sys/cdefs.h>
-__FBSDID("$FreeBSD$");
-
-#include "namespace.h"
-#include <sys/param.h>
-#include <sys/mount.h>
-#include <sys/stat.h>
-
-#include <dirent.h>
+//#include <sys/cdefs.h>
+//__FBSDID("$FreeBSD$");
+
+//#include "namespace.h"
+//#include <sys/param.h>
+//#include <sys/mount.h>
+//#include <sys/stat.h>
+
+//#include <dirent.h>
 #include <errno.h>
-#include <fcntl.h>
-#include <fts.h>
+//#include <fcntl.h>
+#include "fts-nt.h"
 #include <stdlib.h>
 #include <string.h>
-#include <unistd.h>
-#include "un-namespace.h"
-
-#include "gen-private.h"
+//#include <unistd.h>
+//#include "un-namespace.h"
+//
+//#include "gen-private.h"
+#include <assert.h>
+#include "nthlp.h"
+#include "ntdir.h"
 
 static FTSENT   *fts_alloc(FTS *, char *, size_t);
@@ -63 +108 @@
 static int       fts_palloc(FTS *, size_t);
 static FTSENT   *fts_sort(FTS *, FTSENT *, size_t);
-static int       fts_stat(FTS *, FTSENT *, int, int);
+static int       fts_stat(FTS *, FTSENT *, int, HANDLE);
+static int   fts_process_stats(FTSENT *, BirdStat_T const *);
 static int       fts_safe_changedir(FTS *, FTSENT *, int, char *);
 static int       fts_ufslinks(FTS *, const FTSENT *);
@@ -80 +126 @@
 #define BREAD           3               /* fts_read */
 
+/* NT needs these: */
+#define MAXPATHLEN 260
+#define MAX(a, b)  ( (a) >= (b) ? (a) : (b) )
+
+#define AT_SYMLINK_NOFOLLOW 1
+#define fstatat(hDir, pszPath, pStat, fFlags) birdStatAt((hDir), (pszPath), (pStat), (fFlags) != 0)
+#define FTS_NT_DUMMY_SYMFD_VALUE        ((HANDLE)~(intptr_t)(2)) /* current process */
+#define fchdir(fd) todo_fchdir(fd)
+extern int todo_fchdir(fts_fd_t fd);
+
 /*
  * Internal representation of an FTS, including extra implementation
@@ -87 +143 @@
 struct _fts_private {
         FTS             ftsp_fts;
+#if 0 /* Not needed on NT, see comment on fts_ufslinks */
         struct statfs   ftsp_statfs;
         dev_t           ftsp_dev;
         int             ftsp_linksreliable;
+#endif
 };
 
+#if 0 /* Not needed on NT, see comment on fts_ufslinks */
 /*
  * The "FTS_NOSTAT" option can avoid a lot of calls to stat(2) if it
@@ -108 +167 @@
         0
 };
-
-FTS *
+#endif
+
+FTS * FTSCALL
 fts_open(char * const *argv, int options,
     int (*compar)(const FTSENT * const *, const FTSENT * const *))
@@ -159 +219 @@
         /* Allocate/initialize root(s). */
         for (root = NULL, nitems = 0; *argv != NULL; ++argv, ++nitems) {
+                /* NT: We need to do some small input transformations to make this and
+                       the API user code happy.  1. Lone drive letters get a dot
+                       appended so it won't matter if a slash is appended afterwards.
+                           2. DOS slashes are converted to UNIX ones. */
+                char *slash;
                 len = strlen(*argv);
-
-                p = fts_alloc(sp, *argv, len);
+                if (len == 2 && argv[0][1] == ':') {
+                        char tmp[4];
+                        tmp[0] = argv[0][0];
+                        tmp[1] = ':';
+                        tmp[2] = '.';
+                        tmp[3] = '\0';
+                        p = fts_alloc(sp, tmp, 3);
+                } else {
+                        p = fts_alloc(sp, *argv, len);
+                }
+#if 1 /* bird */
+                if (p != NULL) { /* likely */ } else { goto mem3; }
+#endif
+                slash = strchr(p->fts_name, '\\');
+                while (slash != NULL) {
+                        *slash++ = '/';
+                        slash = strchr(p->fts_name, '\\');
+                }
                 p->fts_level = FTS_ROOTLEVEL;
                 p->fts_parent = parent;
                 p->fts_accpath = p->fts_name;
-                p->fts_info = fts_stat(sp, p, ISSET(FTS_COMFOLLOW), -1);
+                p->fts_info = fts_stat(sp, p, ISSET(FTS_COMFOLLOW), INVALID_HANDLE_VALUE);
 
                 /* Command-line "." and ".." are real directories. */
@@ -201 +282 @@
         sp->fts_cur->fts_info = FTS_INIT;
 
-        /*
-         * If using chdir(2), grab a file descriptor pointing to dot to ensure
-         * that we can get back here; this could be avoided for some paths,
-         * but almost certainly not worth the effort.  Slashes, symbolic links,
-         * and ".." are all fairly nasty problems.  Note, if we can't get the
-         * descriptor we run anyway, just more slowly.
-         */
-        if (!ISSET(FTS_NOCHDIR) &&
-            (sp->fts_rfd = _open(".", O_RDONLY | O_CLOEXEC, 0)) < 0)
-                SET(FTS_NOCHDIR);
-
         return (sp);
 
@@ -221 +291 @@
 }
 
+
 static void
 fts_load(FTS *sp, FTSENT *p)
@@ -236 +307 @@
         len = p->fts_pathlen = p->fts_namelen;
         memmove(sp->fts_path, p->fts_name, len + 1);
+/** @todo check for ':' and '\\'? */
         if ((cp = strrchr(p->fts_name, '/')) && (cp != p->fts_name || cp[1])) {
                 len = strlen(++cp);
@@ -245 +317 @@
 }
 
-int
+int FTSCALL
 fts_close(FTS *sp)
 {
         FTSENT *freep, *p;
-        int saved_errno;
+        /*int saved_errno;*/
 
         /*
@@ -272 +344 @@
         free(sp->fts_path);
 
-        /* Return to original directory, save errno if necessary. */
-        if (!ISSET(FTS_NOCHDIR)) {
-                saved_errno = fchdir(sp->fts_rfd) ? errno : 0;
-                (void)_close(sp->fts_rfd);
-
-                /* Set errno and return. */
-                if (saved_errno != 0) {
-                        /* Free up the stream pointer. */
-                        free(sp);
-                        errno = saved_errno;
-                        return (-1);
-                }
-        }
-
         /* Free up the stream pointer. */
         free(sp);
@@ -299 +357 @@
             ? p->fts_pathlen - 1 : p->fts_pathlen)
 
-FTSENT *
+static void
+fts_free_entry(FTSENT *tmp)
+{
+    if (tmp != NULL) {
+                if (tmp->fts_dirfd != INVALID_HANDLE_VALUE) {
+                        birdCloseFile(tmp->fts_dirfd);
+                        tmp->fts_dirfd = INVALID_HANDLE_VALUE;
+                }
+                free(tmp);
+    }
+}
+
+FTSENT * FTSCALL
 fts_read(FTS *sp)
 {
@@ -305 +375 @@
         int instr;
         char *t;
-        int saved_errno;
 
         /* If finished or unrecoverable error, return NULL. */
@@ -320 +389 @@
         /* Any type of file may be re-visited; re-stat and re-turn. */
         if (instr == FTS_AGAIN) {
-                p->fts_info = fts_stat(sp, p, 0, -1);
+                p->fts_info = fts_stat(sp, p, 0, INVALID_HANDLE_VALUE);
                 return (p);
         }
@@ -329 +398 @@
          * keep a pointer to current location.  If unable to get that
          * pointer, follow fails.
+         *
+         * NT: Since we don't change directory, we just set fts_symfd to a
+         *     placeholder value handle value here in case a API client
+         *     checks it. Ditto FTS_SYMFOLLOW.
          */
         if (instr == FTS_FOLLOW &&
             (p->fts_info == FTS_SL || p->fts_info == FTS_SLNONE)) {
-                p->fts_info = fts_stat(sp, p, 1, -1);
-                if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
-                        if ((p->fts_symfd = _open(".", O_RDONLY | O_CLOEXEC,
-                            0)) < 0) {
-                                p->fts_errno = errno;
-                                p->fts_info = FTS_ERR;
-                        } else
-                                p->fts_flags |= FTS_SYMFOLLOW;
+                p->fts_info = fts_stat(sp, p, 1, INVALID_HANDLE_VALUE);
+                if (p->fts_info == FTS_D /*&& !ISSET(FTS_NOCHDIR)*/) {
+                        p->fts_symfd = FTS_NT_DUMMY_SYMFD_VALUE;
+                        p->fts_flags |= FTS_SYMFOLLOW;
                 }
                 return (p);
@@ -349 +418 @@
                 if (instr == FTS_SKIP ||
                     (ISSET(FTS_XDEV) && p->fts_dev != sp->fts_dev)) {
-                        if (p->fts_flags & FTS_SYMFOLLOW)
-                                (void)_close(p->fts_symfd);
+                        if (p->fts_flags & FTS_SYMFOLLOW) {
+                                p->fts_symfd = INVALID_HANDLE_VALUE;
+                        }
                         if (sp->fts_child) {
                                 fts_lfree(sp->fts_child);
@@ -405 +475 @@
                  */
                 if (p->fts_level == FTS_ROOTLEVEL) {
-                        if (FCHDIR(sp, sp->fts_rfd)) {
+                        /*NT: No fchdir: if (FCHDIR(sp, sp->fts_rfd)) {
                                 SET(FTS_STOP);
                                 return (NULL);
-                        }
-                        free(tmp);
+                        } */
+                        fts_free_entry(tmp);
                         fts_load(sp, p);
                         return (sp->fts_cur = p);
@@ -420 +490 @@
                  */
                 if (p->fts_instr == FTS_SKIP) {
-                        free(tmp);
+                        fts_free_entry(tmp);
                         goto next;
                 }
                 if (p->fts_instr == FTS_FOLLOW) {
-                        p->fts_info = fts_stat(sp, p, 1, -1);
-                        if (p->fts_info == FTS_D && !ISSET(FTS_NOCHDIR)) {
-                                if ((p->fts_symfd =
-                                    _open(".", O_RDONLY | O_CLOEXEC, 0)) < 0) {
-                                        p->fts_errno = errno;
-                                        p->fts_info = FTS_ERR;
-                                } else
-                                        p->fts_flags |= FTS_SYMFOLLOW;
+                        p->fts_info = fts_stat(sp, p, 1, INVALID_HANDLE_VALUE);
+                        /* NT: See above regarding fts_symfd. */
+                        if (p->fts_info == FTS_D /*&& !ISSET(FTS_NOCHDIR)*/) {
+                                p->fts_symfd = FTS_NT_DUMMY_SYMFD_VALUE;
+                                p->fts_flags |= FTS_SYMFOLLOW;
                         }
                         p->fts_instr = FTS_NOINSTR;
                 }
 
-                free(tmp);
+                fts_free_entry(tmp);
 
 name:           t = sp->fts_path + NAPPEND(p->fts_parent);
@@ -452 +519 @@
                  * can distinguish between error and EOF.
                  */
-                free(tmp);
-                free(p);
+                fts_free_entry(tmp);
+                fts_free_entry(p);
                 errno = 0;
                 return (sp->fts_cur = NULL);
@@ -465 +532 @@
          * a symlink, go back through the file descriptor.  Otherwise, cd up
          * one directory.
-         */
-        if (p->fts_level == FTS_ROOTLEVEL) {
-                if (FCHDIR(sp, sp->fts_rfd)) {
-                        SET(FTS_STOP);
-                        return (NULL);
-                }
-        } else if (p->fts_flags & FTS_SYMFOLLOW) {
-                if (FCHDIR(sp, p->fts_symfd)) {
-                        saved_errno = errno;
-                        (void)_close(p->fts_symfd);
-                        errno = saved_errno;
-                        SET(FTS_STOP);
-                        return (NULL);
-                }
-                (void)_close(p->fts_symfd);
-        } else if (!(p->fts_flags & FTS_DONTCHDIR) &&
-            fts_safe_changedir(sp, p->fts_parent, -1, "..")) {
-                SET(FTS_STOP);
-                return (NULL);
-        }
-        free(tmp);
+         *
+         * NT: We're doing no fchdir, but we need to close the directory handle
+         *     and clear fts_symfd now.
+         */
+        if (p->fts_flags & FTS_SYMFOLLOW) {
+                p->fts_symfd = INVALID_HANDLE_VALUE;
+        }
+    if (p->fts_dirfd != INVALID_HANDLE_VALUE) {
+                birdCloseFile(p->fts_dirfd);
+                p->fts_dirfd = INVALID_HANDLE_VALUE;
+    }
+    fts_free_entry(tmp);
         p->fts_info = p->fts_errno ? FTS_ERR : FTS_DP;
         return (sp->fts_cur = p);
@@ -497 +555 @@
  */
 /* ARGSUSED */
-int
+int FTSCALL
 fts_set(FTS *sp, FTSENT *p, int instr)
 {
@@ -509 +567 @@
 }
 
-FTSENT *
+#if 0
+FTSENT * FTSCALL
 fts_children(FTS *sp, int instr)
 {
@@ -579 +638 @@
         return (sp->fts_child);
 }
+#endif /* PORTME */
 
 #ifndef fts_get_clientptr
@@ -585 +645 @@
 
 void *
-(fts_get_clientptr)(FTS *sp)
+(FTSCALL fts_get_clientptr)(FTS *sp)
 {
 
@@ -596 +656 @@
 
 FTS *
-(fts_get_stream)(FTSENT *p)
+(FTSCALL fts_get_stream)(FTSENT *p)
 {
         return (fts_get_stream(p));
 }
 
-void
+void FTSCALL
 fts_set_clientptr(FTS *sp, void *clientptr)
 {
@@ -621 +681 @@
  * directories and for any files after the subdirectories in the directory have
  * been found, cutting the stat calls by about 2/3.
+ *
+ * NT: We do not do any link counting or stat avoiding, which invalidates the
+ *     above warnings.  This function is very simple for us.
  */
 static FTSENT *
 fts_build(FTS *sp, int type)
 {
-        struct dirent *dp;
+        BirdDirEntry_T *dp;
         FTSENT *p, *head;
         FTSENT *cur, *tail;
@@ -631 +694 @@
         void *oldaddr;
         char *cp;
-        int cderrno, descend, oflag, saved_errno, nostat, doadjust;
+        int saved_errno, doadjust;
         long level;
-        long nlinks;    /* has to be signed because -1 is a magic value */
         size_t dnamlen, len, maxlen, nitems;
+        unsigned fDirOpenFlags;
 
         /* Set current node pointer. */
@@ -642 +705 @@
          * Open the directory for reading.  If this fails, we're done.
          * If being called from fts_read, set the fts_info field.
-         */
-#ifdef FTS_WHITEOUT
-        if (ISSET(FTS_WHITEOUT))
-                oflag = DTF_NODUP | DTF_REWIND;
-        else
-                oflag = DTF_HIDEW | DTF_NODUP | DTF_REWIND;
-#else
-#define __opendir2(path, flag) opendir(path)
-#endif
-        if ((dirp = __opendir2(cur->fts_accpath, oflag)) == NULL) {
+         *
+         * NT: We do a two stage open so we can keep the directory handle around
+         *     after we've enumerated the directory.  The dir handle is used by
+         *     us here and by the API users to more efficiently and safely open
+         *     members of the directory.
+         */
+        fDirOpenFlags = BIRDDIR_F_EXTRA_INFO | BIRDDIR_F_KEEP_HANDLE;
+    if (cur->fts_dirfd == INVALID_HANDLE_VALUE) {
+                if (cur->fts_parent->fts_dirfd != INVALID_HANDLE_VALUE) {
+                        /* (This works fine for symlinks too, since we follow them.) */
+                        cur->fts_dirfd = birdOpenFileEx(cur->fts_parent->fts_dirfd,
+                                                                                        cur->fts_name,
+                                                                                        FILE_READ_DATA | SYNCHRONIZE,
+                                                                                        FILE_ATTRIBUTE_NORMAL,
+                                                                                        FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                                                                                        FILE_OPEN,
+                                                                                        FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
+                                                                                        OBJ_CASE_INSENSITIVE);
+                } else {
+                        cur->fts_dirfd = birdOpenFile(cur->fts_accpath,
+                                                                                  FILE_READ_DATA | SYNCHRONIZE,
+                                                                                  FILE_ATTRIBUTE_NORMAL,
+                                                                                  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                                                                                  FILE_OPEN,
+                                                                                  FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
+                                                                                  OBJ_CASE_INSENSITIVE);
+                }
+    } else {
+                fDirOpenFlags |= BIRDDIR_F_RESTART_SCAN;
+        }
+        dirp = birdDirOpenFromHandle(cur->fts_dirfd, NULL, fDirOpenFlags);
+        if (dirp == NULL) {
                 if (type == BREAD) {
                         cur->fts_info = FTS_DNR;
@@ -658 +743 @@
                 return (NULL);
         }
-
-        /*
-         * Nlinks is the number of possible entries of type directory in the
-         * directory if we're cheating on stat calls, 0 if we're not doing
-         * any stat calls at all, -1 if we're doing stats on everything.
-         */
-        if (type == BNAMES) {
-                nlinks = 0;
-                /* Be quiet about nostat, GCC. */
-                nostat = 0;
-        } else if (ISSET(FTS_NOSTAT) && ISSET(FTS_PHYSICAL)) {
-                if (fts_ufslinks(sp, cur))
-                        nlinks = cur->fts_nlink - (ISSET(FTS_SEEDOT) ? 0 : 2);
-                else
-                        nlinks = -1;
-                nostat = 1;
-        } else {
-                nlinks = -1;
-                nostat = 0;
-        }
-
-#ifdef notdef
-        (void)printf("nlinks == %d (cur: %d)\n", nlinks, cur->fts_nlink);
-        (void)printf("NOSTAT %d PHYSICAL %d SEEDOT %d\n",
-            ISSET(FTS_NOSTAT), ISSET(FTS_PHYSICAL), ISSET(FTS_SEEDOT));
-#endif
-        /*
-         * If we're going to need to stat anything or we want to descend
-         * and stay in the directory, chdir.  If this fails we keep going,
-         * but set a flag so we don't chdir after the post-order visit.
-         * We won't be able to stat anything, but we can still return the
-         * names themselves.  Note, that since fts_read won't be able to
-         * chdir into the directory, it will have to return different path
-         * names than before, i.e. "a/b" instead of "b".  Since the node
-         * has already been visited in pre-order, have to wait until the
-         * post-order visit to return the error.  There is a special case
-         * here, if there was nothing to stat then it's not an error to
-         * not be able to stat.  This is all fairly nasty.  If a program
-         * needed sorted entries or stat information, they had better be
-         * checking FTS_NS on the returned nodes.
-         */
-        cderrno = 0;
-        if (nlinks || type == BREAD) {
-                if (fts_safe_changedir(sp, cur, _dirfd(dirp), NULL)) {
-                        if (nlinks && type == BREAD)
-                                cur->fts_errno = errno;
-                        cur->fts_flags |= FTS_DONTCHDIR;
-                        descend = 0;
-                        cderrno = errno;
-                } else
-                        descend = 1;
-        } else
-                descend = 0;
 
         /*
@@ -723 +755 @@
          */
         len = NAPPEND(cur);
-        if (ISSET(FTS_NOCHDIR)) {
-                cp = sp->fts_path + len;
-                *cp++ = '/';
-        } else {
-                /* GCC, you're too verbose. */
-                cp = NULL;
-        }
+        cp = sp->fts_path + len;
+        *cp++ = '/';
         len++;
         maxlen = sp->fts_pathlen - len;
@@ -737 +764 @@
         /* Read the directory, attaching each entry to the `link' pointer. */
         doadjust = 0;
-        for (head = tail = NULL, nitems = 0; dirp && (dp = readdir(dirp));) {
+        for (head = tail = NULL, nitems = 0; dirp && (dp = birdDirRead(dirp));) {
                 dnamlen = dp->d_namlen;
                 if (!ISSET(FTS_SEEDOT) && ISDOT(dp->d_name))
@@ -756 +783 @@
                                         free(p);
                                 fts_lfree(head);
-                                (void)closedir(dirp);
+                                birdDirClose(dirp);
+                                birdCloseFile(cur->fts_dirfd);
+                                cur->fts_dirfd = INVALID_HANDLE_VALUE;
                                 cur->fts_info = FTS_ERR;
                                 SET(FTS_STOP);
@@ -774 +803 @@
                 p->fts_parent = sp->fts_cur;
                 p->fts_pathlen = len + dnamlen;
-
-#ifdef FTS_WHITEOUT
-                if (dp->d_type == DT_WHT)
-                        p->fts_flags |= FTS_ISW;
-#endif
-
-                if (cderrno) {
-                        if (nlinks) {
-                                p->fts_info = FTS_NS;
-                                p->fts_errno = cderrno;
-                        } else
-                                p->fts_info = FTS_NSOK;
-                        p->fts_accpath = cur->fts_accpath;
-                } else if (nlinks == 0
-#ifdef DT_DIR
-                    || (nostat &&
-                    dp->d_type != DT_DIR && dp->d_type != DT_UNKNOWN)
-#endif
-                    ) {
-                        p->fts_accpath =
-                            ISSET(FTS_NOCHDIR) ? p->fts_path : p->fts_name;
-                        p->fts_info = FTS_NSOK;
-                } else {
-                        /* Build a file name for fts_stat to stat. */
-                        if (ISSET(FTS_NOCHDIR)) {
-                                p->fts_accpath = p->fts_path;
-                                memmove(cp, p->fts_name, p->fts_namelen + 1);
-                                p->fts_info = fts_stat(sp, p, 0, _dirfd(dirp));
-                        } else {
-                                p->fts_accpath = p->fts_name;
-                                p->fts_info = fts_stat(sp, p, 0, -1);
-                        }
-
-                        /* Decrement link count if applicable. */
-                        if (nlinks > 0 && (p->fts_info == FTS_D ||
-                            p->fts_info == FTS_DC || p->fts_info == FTS_DOT))
-                                --nlinks;
-                }
+                p->fts_accpath = p->fts_path;
+                p->fts_stat = dp->d_stat;
+                p->fts_info = fts_process_stats(p, &dp->d_stat);
 
                 /* We walk in directory order so "ls -f" doesn't get upset. */
@@ -823 +817 @@
                 ++nitems;
         }
-        if (dirp)
-                (void)closedir(dirp);
+
+        birdDirClose(dirp);
 
         /*
@@ -834 +828 @@
 
         /*
-         * If not changing directories, reset the path back to original
-         * state.
-         */
-        if (ISSET(FTS_NOCHDIR))
-                sp->fts_path[cur->fts_pathlen] = '\0';
-
-        /*
-         * If descended after called from fts_children or after called from
-         * fts_read and nothing found, get back.  At the root level we use
-         * the saved fd; if one of fts_open()'s arguments is a relative path
-         * to an empty directory, we wind up here with no other way back.  If
-         * can't get back, we're done.
-         */
-        if (descend && (type == BCHILD || !nitems) &&
-            (cur->fts_level == FTS_ROOTLEVEL ?
-            FCHDIR(sp, sp->fts_rfd) :
-            fts_safe_changedir(sp, cur->fts_parent, -1, ".."))) {
-                cur->fts_info = FTS_ERR;
-                SET(FTS_STOP);
-                return (NULL);
-        }
+         * Reset the path back to original state.
+         */
+        sp->fts_path[cur->fts_pathlen] = '\0';
 
         /* If didn't find anything, return NULL. */
@@ -869 +845 @@
 }
 
+
+/**
+ * @note Only used on NT with input arguments, FTS_AGAIN, and links that needs
+ *       following.  On link information is generally retrieved during directory
+ *       enumeration on NT, in line with it's DOS/OS2/FAT API heritage.
+ */
 static int
-fts_stat(FTS *sp, FTSENT *p, int follow, int dfd)
-{
-        FTSENT *t;
-        dev_t dev;
-        ino_t ino;
-        struct stat *sbp, sb;
+fts_stat(FTS *sp, FTSENT *p, int follow, HANDLE dfd)
+{
         int saved_errno;
         const char *path;
 
-        if (dfd == -1)
-                path = p->fts_accpath, dfd = AT_FDCWD;
-        else
+        if (dfd == INVALID_HANDLE_VALUE) {
+                path = p->fts_accpath;
+        } else {
                 path = p->fts_name;
-
-        /* If user needs stat info, stat buffer already allocated. */
-        sbp = ISSET(FTS_NOSTAT) ? &sb : p->fts_statp;
-
-#ifdef FTS_WHITEOUT
-        /* Check for whiteout. */
-        if (p->fts_flags & FTS_ISW) {
-                if (sbp != &sb) {
-                        memset(sbp, '\0', sizeof(*sbp));
-                        sbp->st_mode = S_IFWHT;
-                }
-                return (FTS_W);
-        }
-#endif
+        }
 
         /*
@@ -904 +869 @@
          */
         if (ISSET(FTS_LOGICAL) || follow) {
-                if (fstatat(dfd, path, sbp, 0)) {
+                if (fstatat(dfd, path, &p->fts_stat, 0)) {
                         saved_errno = errno;
-                        if (fstatat(dfd, path, sbp, AT_SYMLINK_NOFOLLOW)) {
+                        if (fstatat(dfd, path, &p->fts_stat, AT_SYMLINK_NOFOLLOW)) {
                                 p->fts_errno = saved_errno;
                                 goto err;
                         }
                         errno = 0;
-                        if (S_ISLNK(sbp->st_mode))
+                        if (S_ISLNK(p->fts_stat.st_mode))
                                 return (FTS_SLNONE);
                 }
-        } else if (fstatat(dfd, path, sbp, AT_SYMLINK_NOFOLLOW)) {
+        } else if (fstatat(dfd, path, &p->fts_stat, AT_SYMLINK_NOFOLLOW)) {
                 p->fts_errno = errno;
-err:            memset(sbp, 0, sizeof(struct stat));
+err:            memset(&p->fts_stat, 0, sizeof(struct stat));
                 return (FTS_NS);
         }
-
+        return fts_process_stats(p, &p->fts_stat);
+}
+
+/* Shared between fts_stat and fts_build. */
+static int 
+fts_process_stats(FTSENT *p, BirdStat_T const *sbp)
+{
         if (S_ISDIR(sbp->st_mode)) {
+                FTSENT *t;
+                fts_dev_t dev;
+                fts_ino_t ino;
+
                 /*
                  * Set the device/inode.  Used to find cycles and check for
@@ -984 +959 @@
          */
         if (nitems > sp->fts_nitems) {
+                void *ptr;
                 sp->fts_nitems = nitems + 40;
-                if ((sp->fts_array = reallocf(sp->fts_array,
-                    sp->fts_nitems * sizeof(FTSENT *))) == NULL) {
+                ptr = realloc(sp->fts_array, sp->fts_nitems * sizeof(FTSENT *));
+                if (ptr != NULL) {
+                        sp->fts_array = ptr;
+                } else {
+                        free(sp->fts_array);
+                        sp->fts_array = NULL;
                         sp->fts_nitems = 0;
                         return (head);
@@ -1012 +992 @@
 
         /*
-         * The file name is a variable length array and no stat structure is
-         * necessary if the user has set the nostat bit.  Allocate the FTSENT
-         * structure, the file name and the stat structure in one chunk, but
-         * be careful that the stat structure is reasonably aligned.
-         */
-        if (ISSET(FTS_NOSTAT))
-                len = sizeof(FTSENT) + namelen + 1;
-        else
-                len = sizeof(struct ftsent_withstat) + namelen + 1;
-
+         * The file name is a variable length array.  Allocate the FTSENT
+         * structure and the file name.
+         */
+        len = sizeof(FTSENT) + namelen + 1;
         if ((p = malloc(len)) == NULL)
                 return (NULL);
 
-        if (ISSET(FTS_NOSTAT)) {
-                p->fts_name = (char *)(p + 1);
-                p->fts_statp = NULL;
-        } else {
-                p->fts_name = (char *)((struct ftsent_withstat *)p + 1);
-                p->fts_statp = &((struct ftsent_withstat *)p)->statbuf;
-        }
+        p->fts_name = (char *)(p + 1);
+        p->fts_statp = &p->fts_stat;
 
         /* Copy the name and guarantee NUL termination. */
@@ -1044 +1013 @@
         p->fts_pointer = NULL;
         p->fts_fts = sp;
+        p->fts_symfd = INVALID_HANDLE_VALUE;
+        p->fts_dirfd = INVALID_HANDLE_VALUE;
         return (p);
 }
@@ -1055 +1026 @@
         while ((p = head)) {
                 head = head->fts_link;
+                assert(p->fts_dirfd == INVALID_HANDLE_VALUE);
                 free(p);
         }
@@ -1068 +1040 @@
 fts_palloc(FTS *sp, size_t more)
 {
+        void *ptr;
 
         sp->fts_pathlen += more + 256;
-        sp->fts_path = reallocf(sp->fts_path, sp->fts_pathlen);
-        return (sp->fts_path == NULL);
+        ptr = realloc(sp->fts_path, sp->fts_pathlen);
+        if (ptr) {
+                /*likely */
+        } else {
+                free(sp->fts_path);
+        }
+        sp->fts_path = ptr;
+        return (ptr == NULL);
 }
 
@@ -1121 +1100 @@
 fts_safe_changedir(FTS *sp, FTSENT *p, int fd, char *path)
 {
+#if 0
         int ret, oerrno, newfd;
         struct stat sb;
 
         newfd = fd;
+#endif
         if (ISSET(FTS_NOCHDIR))
                 return (0);
+        assert(0);
+        return -1;
+#if 0
         if (fd < 0 && (newfd = _open(path, O_RDONLY | O_DIRECTORY |
             O_CLOEXEC, 0)) < 0)
@@ -1146 +1130 @@
         errno = oerrno;
         return (ret);
+#endif
 }
 
 /*
  * Check if the filesystem for "ent" has UFS-style links.
+ *
+ * bird: NT does not, which is why they need this check.
+ *       See comment on r129052 (2004-05-08 15:09:02Z).
  */
 static int
 fts_ufslinks(FTS *sp, const FTSENT *ent)
 {
+#if 0
         struct _fts_private *priv;
         const char **cpp;
@@ -1180 +1169 @@
         }
         return (priv->ftsp_linksreliable);
-}
+#else
+        (void)sp; (void)ent;
+        return 0;
+#endif
+}
+

trunk/src/lib/nt/fts-nt.h

@@ +1 @@
+/* $Id: $ */
+/** @file
+ * Header for the NT port of BSD fts.h.
+ *
+ * @copyright   Copyright (c) 1989, 1993 The Regents of the University of California.  All rights reserved.
+ * @copyright   NT modifications Copyright (C) 2016 knut st. osmundsen <bird-klibc-spam-xiv@anduin.net>
+ * @licenses    BSD3
+ */
+
 /*
  * Copyright (c) 1989, 1993
@@ -29 +38 @@
  *      @(#)fts.h       8.3 (Berkeley) 8/14/94
  * $FreeBSD$
+ *
  */
 
-#ifndef _FTS_H_
-#define _FTS_H_
+#ifndef INCLUDED_FTS_NT_H
+#define INCLUDED_FTS_NT_H
 
-#include <sys/_types.h>
+#include <sys/types.h>
+#include <stdint.h>
+#include "ntstat.h" /* ensure correct stat structure */
+
+typedef uint64_t fts_dev_t;
+typedef uint64_t fts_ino_t;
+typedef uint32_t fts_nlink_t;
+#ifdef _WINNT_
+typedef HANDLE fts_fd_t;
+#else
+typedef void * fts_fd_t;
+#endif
+#define FTSCALL __cdecl
 
 typedef struct {
@@ -40 +62 @@
         struct _ftsent *fts_child;      /* linked list of children */
         struct _ftsent **fts_array;     /* sort array */
-        __dev_t fts_dev;                /* starting device # */
+        fts_dev_t fts_dev;              /* starting device # */
         char *fts_path;                 /* path for this descent */
-        int fts_rfd;                    /* fd for root */
-        __size_t fts_pathlen;           /* sizeof(path) */
-        __size_t fts_nitems;            /* elements in the sort array */
-        int (*fts_compar)               /* compare function */
+        size_t fts_pathlen;             /* sizeof(path) */
+        size_t fts_nitems;              /* elements in the sort array */
+        int (FTSCALL *fts_compar)       /* compare function */
             (const struct _ftsent * const *, const struct _ftsent * const *);
 
@@ -55 +76 @@
 #define FTS_SEEDOT      0x020           /* return dot and dot-dot */
 #define FTS_XDEV        0x040           /* don't cross devices */
+#if 0 /* No whiteout on NT. */
 #define FTS_WHITEOUT    0x080           /* return whiteout information */
+#endif
 #define FTS_OPTIONMASK  0x0ff           /* valid user option mask */
 
@@ -68 +91 @@
         struct _ftsent *fts_parent;     /* parent directory */
         struct _ftsent *fts_link;       /* next file in directory */
-        long long fts_number;           /* local numeric value */
+        int64_t fts_number;             /* local numeric value */
 #define fts_bignum      fts_number      /* XXX non-std, should go away */
         void *fts_pointer;              /* local address value */
@@ -74 +97 @@
         char *fts_path;                 /* root path */
         int fts_errno;                  /* errno for this node */
-        int fts_symfd;                  /* fd for symlink */
-        __size_t fts_pathlen;           /* strlen(fts_path) */
-        __size_t fts_namelen;           /* strlen(fts_name) */
+        fts_fd_t fts_symfd;             /* NT: Normally -1; -2 we followed this symlinked dir */
+        fts_fd_t fts_dirfd;             /* NT: Handle to the directory */
+        size_t fts_pathlen;             /* strlen(fts_path) */
+        size_t fts_namelen;             /* strlen(fts_name) */
 
-        __ino_t fts_ino;                /* inode */
-        __dev_t fts_dev;                /* device */
-        __nlink_t fts_nlink;            /* link count */
+        fts_ino_t fts_ino;              /* inode */
+        fts_dev_t fts_dev;              /* device */
+        fts_nlink_t fts_nlink;          /* link count */
 
 #define FTS_ROOTPARENTLEVEL     -1
@@ -99 +123 @@
 #define FTS_SL          12              /* symbolic link */
 #define FTS_SLNONE      13              /* symbolic link without target */
-#define FTS_W           14              /* whiteout object */
+//#define       FTS_W           14              /* whiteout object */
         int fts_info;                   /* user status for FTSENT structure */
 
@@ -116 +140 @@
         char *fts_name;                 /* file name */
         FTS *fts_fts;                   /* back pointer to main FTS */
+        BirdStat_T fts_stat;            /* NT: We always got stat info. */
 } FTSENT;
 
-#include <sys/cdefs.h>
 
-__BEGIN_DECLS
-FTSENT  *fts_children(FTS *, int);
-int      fts_close(FTS *);
-void    *fts_get_clientptr(FTS *);
+#ifdef __cplusplus
+extern "C" {
+#endif
+FTSENT  *FTSCALL fts_children(FTS *, int);
+int      FTSCALL fts_close(FTS *);
+void    *FTSCALL fts_get_clientptr(FTS *);
 #define  fts_get_clientptr(fts) ((fts)->fts_clientptr)
-FTS     *fts_get_stream(FTSENT *);
+FTS     *FTSCALL fts_get_stream(FTSENT *);
 #define  fts_get_stream(ftsent) ((ftsent)->fts_fts)
-FTS     *fts_open(char * const *, int,
-            int (*)(const FTSENT * const *, const FTSENT * const *));
-FTSENT  *fts_read(FTS *);
-int      fts_set(FTS *, FTSENT *, int);
-void     fts_set_clientptr(FTS *, void *);
-__END_DECLS
+FTS     *FTSCALL fts_open(char * const *, int,
+            int (FTSCALL*)(const FTSENT * const *, const FTSENT * const *));
+FTSENT  *FTSCALL fts_read(FTS *);
+int      FTSCALL fts_set(FTS *, FTSENT *, int);
+void     FTSCALL fts_set_clientptr(FTS *, void *);
+#ifdef __cplusplus
+}
+#endif
 
-#endif /* !_FTS_H_ */
+#endif /* !INCLUDED_FTS_NT_H */
+

trunk/src/lib/nt/kFsCache.c

@@ -2171 +2171 @@
         HANDLE      hDir;
         MY_NTSTATUS rcNt;
-        rcNt = birdOpenFileUniStr(&NtPath,
+        rcNt = birdOpenFileUniStr(NULL /*hRoot*/,
+                                  &NtPath,
                                   FILE_READ_DATA  | FILE_LIST_DIRECTORY | FILE_READ_ATTRIBUTES | SYNCHRONIZE,
                                   FILE_ATTRIBUTE_NORMAL,

trunk/src/lib/nt/ntdir.c

@@ -5 +5 @@
 
 /*
- * Copyright (c) 2005-2013 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
+ * Copyright (c) 2005-2016 knut st. osmundsen <bird-kBuild-spamx@anduin.net>
  *
  * Permission is hereby granted, free of charge, to any person obtaining a
@@ -36 +36 @@
 #include <errno.h>
 #include <malloc.h>
+#include <assert.h>
 
 #include "ntstuff.h"
@@ -43 +44 @@
 
 /**
+ * Implements opendir.
+ */
+BirdDir_T *birdDirOpen(const char *pszPath)
+{
+    HANDLE hDir = birdOpenFile(pszPath,
+                               FILE_READ_DATA | SYNCHRONIZE,
+                               FILE_ATTRIBUTE_NORMAL,
+                               FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                               FILE_OPEN,
+                               FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
+                               OBJ_CASE_INSENSITIVE);
+    if (hDir != INVALID_HANDLE_VALUE)
+    {
+        BirdDir_T *pDir = birdDirOpenFromHandle((void *)hDir, NULL, BIRDDIR_F_CLOSE_HANDLE);
+        if (pDir)
+            return pDir;
+        birdCloseFile(hDir);
+    }
+    return NULL;
+}
+
+
+/**
+ * Alternative opendir, with extra stat() info returned by readdir().
+ */
+BirdDir_T *birdDirOpenExtraInfo(const char *pszPath)
+{
+    HANDLE hDir = birdOpenFile(pszPath,
+                               FILE_READ_DATA | SYNCHRONIZE,
+                               FILE_ATTRIBUTE_NORMAL,
+                               FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                               FILE_OPEN,
+                               FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
+                               OBJ_CASE_INSENSITIVE);
+    if (hDir != INVALID_HANDLE_VALUE)
+    {
+        BirdDir_T *pDir = birdDirOpenFromHandle((void *)hDir, NULL, BIRDDIR_F_CLOSE_HANDLE | BIRDDIR_F_EXTRA_INFO);
+        if (pDir)
+            return pDir;
+        birdCloseFile(hDir);
+    }
+    return NULL;
+}
+
+
+BirdDir_T *birdDirOpenExW(void *hRoot, const wchar_t *pwszPath, const wchar_t *pwszFilter, unsigned fFlags)
+{
+    HANDLE hDir = birdOpenFileExW((HANDLE)hRoot,
+                                  pwszPath,
+                                  FILE_READ_DATA | SYNCHRONIZE,
+                                  FILE_ATTRIBUTE_NORMAL,
+                                  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                                  FILE_OPEN,
+                                  FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
+                                  OBJ_CASE_INSENSITIVE);
+    if (hDir != INVALID_HANDLE_VALUE)
+    {
+        BirdDir_T *pDir = birdDirOpenFromHandle((void *)hDir, pwszFilter, fFlags | BIRDDIR_F_CLOSE_HANDLE);
+        if (pDir)
+            return pDir;
+        birdCloseFile(hDir);
+    }
+    return NULL;
+}
+
+
+/**
  * Internal worker for birdStatModTimeOnly.
  */
-static BirdDir_T *birdDirOpenInternal(const char *pszPath, const char *pszFilter, int fMinimalInfo)
-{
-    HANDLE hFile = birdOpenFile(pszPath,
-                                FILE_READ_DATA | SYNCHRONIZE,
-                                FILE_ATTRIBUTE_NORMAL,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                                FILE_OPEN,
-                                FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
-                                OBJ_CASE_INSENSITIVE);
-    if (hFile != INVALID_HANDLE_VALUE)
+BirdDir_T *birdDirOpenFromHandle(void *pvHandle, const void *pvReserved, unsigned fFlags)
+{
+    if (!pvReserved)
     {
         /*
-         * Allocate a handle.
+         * Allocate and initialize the directory enum handle.
          */
         BirdDir_T *pDir = (BirdDir_T *)birdMemAlloc(sizeof(*pDir));
         if (pDir)
         {
-            pDir->uMagic     = BIRD_DIR_MAGIC;
-            pDir->pvHandle   = (void *)hFile;
-            pDir->uDev       = 0;
-            pDir->offPos     = 0;
-            pDir->fHaveData  = 0;
-            pDir->fFirst     = 1;
-            pDir->iInfoClass = fMinimalInfo ? MyFileNamesInformation : MyFileIdFullDirectoryInformation;
-            pDir->offBuf     = 0;
-            pDir->cbBuf      = 0;
-            pDir->pabBuf     = NULL;
+            pDir->uMagic        = BIRD_DIR_MAGIC;
+            pDir->fFlags        = fFlags;
+            pDir->pvHandle      = pvHandle;
+            pDir->uDev          = 0;
+            pDir->offPos        = 0;
+            pDir->fHaveData     = 0;
+            pDir->fFirst        = 1;
+            pDir->iInfoClass    = fFlags & BIRDDIR_F_EXTRA_INFO ? MyFileIdFullDirectoryInformation : MyFileNamesInformation;
+            pDir->offBuf        = 0;
+            pDir->cbBuf         = 0;
+            pDir->pabBuf        = NULL;
             return pDir;
         }
-
-        birdCloseFile(hFile);
-        birdSetErrnoToNoMem();
-    }
-
+    }
+    else
+        assert(pvReserved == NULL);
+    birdSetErrnoToNoMem();
     return NULL;
-}
-
-
-/**
- * Implements opendir.
- */
-BirdDir_T *birdDirOpen(const char *pszPath)
-{
-    return birdDirOpenInternal(pszPath, NULL, 1 /*fMinimalInfo*/);
-}
-
-
-/**
- * Alternative opendir, with extra stat() info returned by readdir().
- */
-BirdDir_T *birdDirOpenExtraInfo(const char *pszPath)
-{
-    return birdDirOpenInternal(pszPath, NULL, 0 /*fMinimalInfo*/);
 }
 
@@ -158 +201 @@
                                      FALSE,     /* fReturnSingleEntry */
                                      NULL,      /* Filter / restart pos. */
-                                     FALSE);    /* fRestartScan */
+                                     pDir->fFlags & BIRDDIR_F_RESTART_SCAN ? TRUE : FALSE); /* fRestartScan */
     if (!MY_NT_SUCCESS(rcNt))
     {
@@ -173 +216 @@
     pDir->offBuf    = 0;
     pDir->fHaveData = 1;
+    pDir->fFlags    &= ~BIRDDIR_F_RESTART_SCAN;
 
     return 0;
@@ -355 +399 @@
 
     pDir->uMagic++;
-    birdCloseFile((HANDLE)pDir->pvHandle);
+    if (pDir->fFlags & BIRDDIR_F_CLOSE_HANDLE)
+        birdCloseFile((HANDLE)pDir->pvHandle);
     pDir->pvHandle = (void *)INVALID_HANDLE_VALUE;
     birdMemFree(pDir->pabBuf);

trunk/src/lib/nt/ntdir.h

@@ -65 +65 @@
 /** @}  */
 
+/** @name BIRDDIR_F_XXX - birdDirOpenFromHandle & BirdDir_T::fFlags
+ * @{ */
+/** birdDirClose should also close pvHandle.  */
+#define BIRDDIR_F_CLOSE_HANDLE  1U
+/** birdDirClose should not close the handle.  */
+#define BIRDDIR_F_KEEP_HANDLE   0U
+/** Provide extra info (stat). */
+#define BIRDDIR_F_EXTRA_INFO    2U
+/** Whether to restart the scan. */
+#define BIRDDIR_F_RESTART_SCAN  4U
+/** @} */
+
 typedef struct BirdDir
 {
     /** Magic value. */
     unsigned            uMagic;
+    /** Flags. */
+    unsigned            fFlags;
     /** The directory handle. */
     void               *pvHandle;
@@ -98 +112 @@
 BirdDir_T      *birdDirOpen(const char *pszPath);
 BirdDir_T      *birdDirOpenExtraInfo(const char *pszPath);
+BirdDir_T      *birdDirOpenExW(void *hRoot, const wchar_t *pwszPath, const wchar_t *pwszFilter, unsigned fFlags);
+BirdDir_T      *birdDirOpenFromHandle(void *hDir, const void *pvReserved, unsigned fFlags);
 BirdDirEntry_T *birdDirRead(BirdDir_T *pDir);
 long            birdDirTell(BirdDir_T *pDir);

trunk/src/lib/nt/nthlp.h

@@ -55 +55 @@
 
 
-HANDLE      birdOpenFile(const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs, ULONG fShareAccess,
-                         ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs);
-HANDLE      birdOpenParentDir(const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs, ULONG fShareAccess,
-                              ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs,
+HANDLE      birdOpenFile(const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                         ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs);
+HANDLE      birdOpenFileW(const wchar_t *pwszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                          ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs);
+HANDLE      birdOpenFileEx(HANDLE hRoot, const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                           ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs);
+HANDLE      birdOpenFileExW(HANDLE hRoot, const wchar_t *pwszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                            ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs);
+HANDLE      birdOpenParentDir(HANDLE hRoot, const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                              ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs,
                               MY_UNICODE_STRING *pNameUniStr);
-MY_NTSTATUS birdOpenFileUniStr(MY_UNICODE_STRING *pNtPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+HANDLE      birdOpenParentDirW(HANDLE hRoot, const wchar_t *pwszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                               ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs,
+                               MY_UNICODE_STRING *pNameUniStr);
+MY_NTSTATUS birdOpenFileUniStr(HANDLE hRoot, MY_UNICODE_STRING *pNtPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
                                ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs,
                                HANDLE *phFile);
+HANDLE      birdOpenCurrentDirectory(void);
 void        birdCloseFile(HANDLE hFile);
 int         birdDosToNtPath(const char *pszPath, MY_UNICODE_STRING *pNtPath);

trunk/src/lib/nt/nthlpcore.c

@@ -46 +46 @@
                                         PLARGE_INTEGER, ULONG, ULONG, ULONG, ULONG, PVOID, ULONG);
 MY_NTSTATUS (WINAPI *g_pfnNtDeleteFile)(MY_OBJECT_ATTRIBUTES *);
+MY_NTSTATUS (WINAPI *g_pfnNtDuplicateObject)(HANDLE hSrcProc, HANDLE hSrc, HANDLE hDstProc, HANDLE *phRet,
+                                             MY_ACCESS_MASK fDesiredAccess, ULONG fAttribs, ULONG fOptions);
 MY_NTSTATUS (WINAPI *g_pfnNtReadFile)(HANDLE hFile, HANDLE hEvent, MY_IO_APC_ROUTINE *pfnApc, PVOID pvApcCtx,
                                       MY_IO_STATUS_BLOCK *, PVOID pvBuf, ULONG cbToRead, PLARGE_INTEGER poffFile,
@@ -63 +65 @@
 UCHAR       (WINAPI *g_pfnRtlUpperChar)(UCHAR uch);
 ULONG       (WINAPI *g_pfnRtlNtStatusToDosError)(MY_NTSTATUS rcNt);
+VOID        (WINAPI *g_pfnRtlAcquirePebLock)(VOID);
+VOID        (WINAPI *g_pfnRtlReleasePebLock)(VOID);
 
 
@@ -74 +78 @@
     { (FARPROC *)&g_pfnNtCreateFile,                    "NtCreateFile" },
     { (FARPROC *)&g_pfnNtDeleteFile,                    "NtDeleteFile" },
+    { (FARPROC *)&g_pfnNtDuplicateObject,               "NtDuplicateObject" },
     { (FARPROC *)&g_pfnNtReadFile,                      "NtReadFile" },
     { (FARPROC *)&g_pfnNtQueryInformationFile,          "NtQueryInformationFile" },
@@ -87 +92 @@
     { (FARPROC *)&g_pfnRtlUpperChar,                    "RtlUpperChar" },
     { (FARPROC *)&g_pfnRtlNtStatusToDosError,           "RtlNtStatusToDosError" },
+    { (FARPROC *)&g_pfnRtlAcquirePebLock,               "RtlAcquirePebLock" },
+    { (FARPROC *)&g_pfnRtlReleasePebLock,               "RtlReleasePebLock" },
 };
 /** Set to 1 if we've successfully resolved the imports, otherwise 0. */

trunk/src/lib/nt/nthlpfs.c

@@ -34 +34 @@
 *******************************************************************************/
 #include "nthlp.h"
+#include <stddef.h>
+#include <string.h>
+#include <wchar.h>
+#include <errno.h>
 
 
@@ -61 +65 @@
 
 
+static int birdHasTrailingSlashW(const wchar_t *pwszPath)
+{
+    wchar_t wc, wc2;
+
+    /* Skip leading slashes. */
+    while ((wc = *pwszPath) == '/' || wc == '\\')
+        pwszPath++;
+    if (wc == '\0')
+        return 0;
+
+    /* Find the last char. */
+    while ((wc2 = *++pwszPath) != '\0')
+        wc = wc2;
+
+    return wc == '/' || wc == '\\' || wc == ':';
+}
+
+
 static int birdIsPathDirSpec(const char *pszPath)
 {
@@ -75 +97 @@
 
     return ch == '/' || ch == '\\' || ch == ':';
+}
+
+
+static int birdIsPathDirSpecW(const wchar_t *pwszPath)
+{
+    wchar_t wc, wc2;
+
+    /* Check for empty string. */
+    wc = *pwszPath;
+    if (wc == '\0')
+        return 0;
+
+    /* Find the last char. */
+    while ((wc2 = *++pwszPath) != '\0')
+        wc = wc2;
+
+    return wc == '/' || wc == '\\' || wc == ':';
 }
 
@@ -119 +158 @@
 
 
+int birdDosToNtPathW(const wchar_t *pwszPath, MY_UNICODE_STRING *pNtPath)
+{
+    birdResolveImports();
+
+    pNtPath->Length = pNtPath->MaximumLength = 0;
+    pNtPath->Buffer = NULL;
+
+    /*
+     * Convert the wide DOS path to an NT path.
+     */
+    if (g_pfnRtlDosPathNameToNtPathName_U(pwszPath, pNtPath, NULL, FALSE))
+        return 0;
+    return birdSetErrnoFromNt(STATUS_NO_MEMORY);
+}
+
+
+/**
+ * Converts UNIX slashes to DOS ones and trims trailing ones.
+ *
+ * @returns 0
+ * @param   pNtPath     The relative NT path to fix up.
+ */
+static int birdFixRelativeNtPathSlashesAndReturn0(MY_UNICODE_STRING *pNtPath)
+{
+    size_t   cwcLeft  = pNtPath->Length / sizeof(wchar_t);
+    wchar_t *pwcStart = pNtPath->Buffer;
+    wchar_t *pwcHit;
+
+    /* Convert slashes. */
+    while ((pwcHit = wmemchr(pwcStart,  '/', cwcLeft)) != NULL)
+    {
+        *pwcHit = '\\';
+        cwcLeft -= pwcHit - pwcStart;
+        pwcHit = pwcStart;
+    }
+
+    /* Strip trailing slashes (NT doesn't like them). */
+    while (   pNtPath->Length >= sizeof(wchar_t)
+           && pNtPath->Buffer[(pNtPath->Length - sizeof(wchar_t)) / sizeof(wchar_t)] == '\\')
+    {
+        pNtPath->Length -= sizeof(wchar_t);
+        pNtPath->Buffer[pNtPath->Length / sizeof(wchar_t)] = '\0';
+    }
+
+    /* If it was all trailing slashes we convert it to a dot path. */
+    if (   pNtPath->Length == 0
+        && pNtPath->MaximumLength >= sizeof(wchar_t) * 2)
+    {
+        pNtPath->Length = sizeof(wchar_t);
+        pNtPath->Buffer[0] = '.';
+        pNtPath->Buffer[1] = '\0';
+    }
+
+    return 0;
+}
+
+
+/**
+ * Similar to birdDosToNtPath, but it does call RtlDosPathNameToNtPathName_U.
+ *
+ * @returns 0 on success, -1 + errno on failure.
+ * @param   pszPath     The relative path.
+ * @param   pNtPath     Where to return the NT path.  Call birdFreeNtPath when done.
+ */
+int birdDosToRelativeNtPath(const char *pszPath, MY_UNICODE_STRING *pNtPath)
+{
+    MY_NTSTATUS         rcNt;
+    MY_ANSI_STRING      Src;
+
+    birdResolveImports();
+
+    /*
+     * Just convert to wide char.
+     */
+    pNtPath->Length   = pNtPath->MaximumLength = 0;
+    pNtPath->Buffer   = NULL;
+
+    Src.Buffer        = (PCHAR)pszPath;
+    Src.MaximumLength = Src.Length = (USHORT)strlen(pszPath);
+
+    rcNt = g_pfnRtlAnsiStringToUnicodeString(pNtPath, &Src, TRUE /* Allocate */);
+    if (MY_NT_SUCCESS(rcNt))
+        return birdFixRelativeNtPathSlashesAndReturn0(pNtPath);
+    return birdSetErrnoFromNt(rcNt);
+}
+
+
+/**
+ * Similar to birdDosToNtPathW, but it does call RtlDosPathNameToNtPathName_U.
+ *
+ * @returns 0 on success, -1 + errno on failure.
+ * @param   pwszPath    The relative path.
+ * @param   pNtPath     Where to return the NT path.  Call birdFreeNtPath when done.
+ */
+int birdDosToRelativeNtPathW(const wchar_t *pwszPath, MY_UNICODE_STRING *pNtPath)
+{
+    size_t cwcPath = wcslen(pwszPath);
+    if (cwcPath < 0xfffe)
+    {
+        pNtPath->Length = (USHORT)(cwcPath * sizeof(wchar_t));
+        pNtPath->MaximumLength = pNtPath->Length + sizeof(wchar_t);
+        pNtPath->Buffer = HeapAlloc(GetProcessHeap(), 0, pNtPath->MaximumLength);
+        if (pNtPath->Buffer)
+        {
+            memcpy(pNtPath->Buffer, pwszPath, pNtPath->MaximumLength);
+            return birdFixRelativeNtPathSlashesAndReturn0(pNtPath);
+        }
+        errno = ENOMEM;
+    }
+    else
+        errno = ENAMETOOLONG;
+    return -1;
+}
+
+
+/**
+ * Frees a string returned by birdDosToNtPath, birdDosToNtPathW or
+ * birdDosToRelativeNtPath.
+ *
+ * @param   pNtPath             The the NT path to free.
+ */
 void birdFreeNtPath(MY_UNICODE_STRING *pNtPath)
 {
@@ -128 +288 @@
 
 
-MY_NTSTATUS birdOpenFileUniStr(MY_UNICODE_STRING *pNtPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+MY_NTSTATUS birdOpenFileUniStr(HANDLE hRoot, MY_UNICODE_STRING *pNtPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
                                ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs,
                                HANDLE *phFile)
@@ -144 +304 @@
     Ios.Information = -1;
     Ios.u.Status = 0;
-    MyInitializeObjectAttributes(&ObjAttr, pNtPath, fObjAttribs, NULL /*hRoot*/, NULL /*pSecAttr*/);
+    MyInitializeObjectAttributes(&ObjAttr, pNtPath, fObjAttribs, hRoot, NULL /*pSecAttr*/);
 
     rcNt = g_pfnNtCreateFile(phFile,
@@ -185 +345 @@
 
 
-HANDLE birdOpenFile(const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs, ULONG fShareAccess,
-                    ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs)
+HANDLE birdOpenFile(const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                    ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs)
 {
     MY_UNICODE_STRING   NtPath;
@@ -198 +358 @@
 
     /*
-     * Call the NT API directly.
+     * Convert the path and call birdOpenFileUniStr to do the real work.
      */
     if (birdDosToNtPath(pszPath, &NtPath) == 0)
     {
         HANDLE hFile;
-        rcNt = birdOpenFileUniStr(&NtPath, fDesiredAccess, fFileAttribs, fShareAccess,
+        rcNt = birdOpenFileUniStr(NULL /*hRoot*/, &NtPath, fDesiredAccess, fFileAttribs, fShareAccess,
                                   fCreateDisposition, fCreateOptions, fObjAttribs, &hFile);
+        birdFreeNtPath(&NtPath);
+        if (MY_NT_SUCCESS(rcNt))
+            return hFile;
+        birdSetErrnoFromNt(rcNt);
+    }
+
+    return INVALID_HANDLE_VALUE;
+}
+
+
+HANDLE birdOpenFileW(const wchar_t *pwszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                     ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs)
+{
+    MY_UNICODE_STRING   NtPath;
+    MY_NTSTATUS         rcNt;
+
+    /*
+     * Adjust inputs.
+     */
+    if (birdIsPathDirSpecW(pwszPath))
+        fCreateOptions |= FILE_DIRECTORY_FILE;
+
+    /*
+     * Convert the path and call birdOpenFileUniStr to do the real work.
+     */
+    if (birdDosToNtPathW(pwszPath, &NtPath) == 0)
+    {
+        HANDLE hFile;
+        rcNt = birdOpenFileUniStr(NULL /*hRoot*/, &NtPath, fDesiredAccess, fFileAttribs, fShareAccess,
+                                  fCreateDisposition, fCreateOptions, fObjAttribs, &hFile);
+        birdFreeNtPath(&NtPath);
+        if (MY_NT_SUCCESS(rcNt))
+            return hFile;
+        birdSetErrnoFromNt(rcNt);
+    }
+
+    return INVALID_HANDLE_VALUE;
+}
+
+
+HANDLE birdOpenFileEx(HANDLE hRoot, const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                      ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs)
+{
+    MY_UNICODE_STRING   NtPath;
+    MY_NTSTATUS         rcNt;
+
+    /*
+     * Adjust inputs.
+     */
+    if (birdIsPathDirSpec(pszPath))
+        fCreateOptions |= FILE_DIRECTORY_FILE;
+
+    /*
+     * Convert the path and call birdOpenFileUniStr to do the real work.
+     */
+    if (hRoot == INVALID_HANDLE_VALUE)
+        hRoot = NULL;
+    if ((hRoot != NULL ? birdDosToRelativeNtPath(pszPath, &NtPath) : birdDosToNtPath(pszPath, &NtPath)) == 0)
+    {
+        HANDLE hFile;
+        rcNt = birdOpenFileUniStr(hRoot, &NtPath, fDesiredAccess, fFileAttribs, fShareAccess,
+                                  fCreateDisposition, fCreateOptions, fObjAttribs, &hFile);
+        birdFreeNtPath(&NtPath);
+        if (MY_NT_SUCCESS(rcNt))
+            return hFile;
+        birdSetErrnoFromNt(rcNt);
+    }
+
+    return INVALID_HANDLE_VALUE;
+}
+
+
+HANDLE birdOpenFileExW(HANDLE hRoot, const wchar_t *pwszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                       ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs)
+{
+    MY_UNICODE_STRING   NtPath;
+    MY_NTSTATUS         rcNt;
+
+    /*
+     * Adjust inputs.
+     */
+    if (birdIsPathDirSpecW(pwszPath))
+        fCreateOptions |= FILE_DIRECTORY_FILE;
+
+    /*
+     * Convert the path (could save ourselves this if pwszPath is perfect) and
+     * call birdOpenFileUniStr to do the real work.
+     */
+    if (hRoot == INVALID_HANDLE_VALUE)
+        hRoot = NULL;
+    if ((hRoot != NULL ? birdDosToRelativeNtPathW(pwszPath, &NtPath) : birdDosToNtPathW(pwszPath, &NtPath)) == 0)
+    {
+        HANDLE hFile;
+        rcNt = birdOpenFileUniStr(hRoot, &NtPath, fDesiredAccess, fFileAttribs, fShareAccess,
+                                  fCreateDisposition, fCreateOptions, fObjAttribs, &hFile);
+        birdFreeNtPath(&NtPath);
+        if (MY_NT_SUCCESS(rcNt))
+            return hFile;
+        birdSetErrnoFromNt(rcNt);
+    }
+
+    return INVALID_HANDLE_VALUE;
+}
+
+
+static HANDLE birdOpenParentDirCommon(HANDLE hRoot, MY_UNICODE_STRING *pNtPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                                      ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs,
+                                      MY_UNICODE_STRING *pNameUniStr)
+{
+    MY_NTSTATUS rcNt;
+
+    /*
+     * Strip the path down to the directory.
+     */
+    USHORT offName = pNtPath->Length / sizeof(WCHAR);
+    USHORT cwcName = offName;
+    WCHAR  wc = 0;
+    while (   offName > 0
+           && (wc = pNtPath->Buffer[offName - 1]) != '\\'
+           && wc != '/'
+           && wc != ':')
+        offName--;
+    if (   offName > 0
+        || (hRoot != NULL && cwcName > 0))
+    {
+        cwcName -= offName;
+
+        /* Make a copy of the file name, if requested. */
+        rcNt = STATUS_SUCCESS;
+        if (pNameUniStr)
+        {
+            pNameUniStr->Length        = cwcName * sizeof(WCHAR);
+            pNameUniStr->MaximumLength = pNameUniStr->Length + sizeof(WCHAR);
+            pNameUniStr->Buffer        = (WCHAR *)HeapAlloc(GetProcessHeap(), 0, pNameUniStr->MaximumLength);
+            if (pNameUniStr->Buffer)
+            {
+                memcpy(pNameUniStr->Buffer, &pNtPath->Buffer[offName], pNameUniStr->Length);
+                pNameUniStr->Buffer[cwcName] = '\0';
+            }
+            else
+                rcNt = STATUS_NO_MEMORY;
+        }
+
+        /* Chop, chop. */
+        // Bad idea, breaks \\?\c:\pagefile.sys. //while (   offName > 0
+        // Bad idea, breaks \\?\c:\pagefile.sys. //       && (   (wc = pNtPath->Buffer[offName - 1]) == '\\'
+        // Bad idea, breaks \\?\c:\pagefile.sys. //           || wc == '/'))
+        // Bad idea, breaks \\?\c:\pagefile.sys. //    offName--;
+        if (offName == 0)
+            pNtPath->Buffer[offName++] = '.'; /* Hack for dir handle + dir entry name. */
+        pNtPath->Length = offName * sizeof(WCHAR);
+        pNtPath->Buffer[offName] = '\0';
         if (MY_NT_SUCCESS(rcNt))
         {
-            birdFreeNtPath(&NtPath);
-            return hFile;
-        }
-
-        birdFreeNtPath(&NtPath);
-        birdSetErrnoFromNt(rcNt);
-    }
-
-    return INVALID_HANDLE_VALUE;
-}
-
-
-HANDLE birdOpenParentDir(const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs, ULONG fShareAccess,
-                         ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs,
-                         MY_UNICODE_STRING *pNameUniStr)
-{
-    MY_UNICODE_STRING   NtPath;
-    MY_NTSTATUS         rcNt;
-
-    /*
-     * Adjust inputs.
-     */
-    fCreateOptions |= FILE_DIRECTORY_FILE;
-
-    /*
-     * Convert the path and split off the filename.
-     */
-    if (birdDosToNtPath(pszPath, &NtPath) == 0)
-    {
-        USHORT offName = NtPath.Length / sizeof(WCHAR);
-        USHORT cwcName = offName;
-        WCHAR  wc = 0;
-
-        while (   offName > 0
-               && (wc = NtPath.Buffer[offName - 1]) != '\\'
-               && wc != '/'
-               && wc != ':')
-            offName--;
-        if (offName > 0)
-        {
-            cwcName -= offName;
-
-            /* Make a copy of the file name, if requested. */
-            rcNt = STATUS_SUCCESS;
-            if (pNameUniStr)
-            {
-                pNameUniStr->Length        = cwcName * sizeof(WCHAR);
-                pNameUniStr->MaximumLength = pNameUniStr->Length + sizeof(WCHAR);
-                pNameUniStr->Buffer        = (WCHAR *)HeapAlloc(GetProcessHeap(), 0, pNameUniStr->MaximumLength);
-                if (pNameUniStr->Buffer)
-                {
-                    memcpy(pNameUniStr->Buffer, &NtPath.Buffer[offName],pNameUniStr->Length);
-                    pNameUniStr->Buffer[cwcName] = '\0';
-                }
-                else
-                    rcNt = STATUS_NO_MEMORY;
-            }
-
-            /* Chop, chop. */
-            // Bad idea, breaks \\?\c:\pagefile.sys. //while (   offName > 0
-            // Bad idea, breaks \\?\c:\pagefile.sys. //       && (   (wc = NtPath.Buffer[offName - 1]) == '\\'
-            // Bad idea, breaks \\?\c:\pagefile.sys. //           || wc == '/'))
-            // Bad idea, breaks \\?\c:\pagefile.sys. //    offName--;
-            NtPath.Length = offName * sizeof(WCHAR);
-            NtPath.Buffer[offName] = '\0';
+            /*
+             * Finally, try open the directory.
+             */
+            HANDLE hFile;
+            fCreateOptions |= FILE_DIRECTORY_FILE;
+            rcNt = birdOpenFileUniStr(hRoot, pNtPath, fDesiredAccess, fFileAttribs, fShareAccess,
+                                      fCreateDisposition, fCreateOptions, fObjAttribs, &hFile);
             if (MY_NT_SUCCESS(rcNt))
             {
-                /*
-                 * Finally, try open the directory.
-                 */
-                HANDLE hFile;
-                rcNt = birdOpenFileUniStr(&NtPath, fDesiredAccess, fFileAttribs, fShareAccess,
-                                          fCreateDisposition, fCreateOptions, fObjAttribs, &hFile);
-                if (MY_NT_SUCCESS(rcNt))
-                {
-                    birdFreeNtPath(&NtPath);
-                    return hFile;
-                }
+                birdFreeNtPath(pNtPath);
+                return hFile;
             }
-
-            if (pNameUniStr)
-                birdFreeNtPath(pNameUniStr);
         }
 
-        birdFreeNtPath(&NtPath);
-        birdSetErrnoFromNt(rcNt);
-    }
-
+        if (pNameUniStr)
+            birdFreeNtPath(pNameUniStr);
+    }
+    else
+        rcNt = STATUS_INVALID_PARAMETER;
+
+    birdFreeNtPath(pNtPath);
+    birdSetErrnoFromNt(rcNt);
     return INVALID_HANDLE_VALUE;
+}
+
+
+HANDLE birdOpenParentDir(HANDLE hRoot, const char *pszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                         ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs,
+                         MY_UNICODE_STRING *pNameUniStr)
+{
+    /*
+     * Convert the path and join up with the UTF-16 version (it'll free NtPath).
+     */
+    MY_UNICODE_STRING NtPath;
+    if (hRoot == INVALID_HANDLE_VALUE)
+        hRoot = NULL;
+    if (  hRoot == NULL
+        ? birdDosToNtPath(pszPath, &NtPath) == 0
+        : birdDosToRelativeNtPath(pszPath, &NtPath) == 0)
+        return birdOpenParentDirCommon(hRoot, &NtPath, fDesiredAccess, fFileAttribs, fShareAccess,
+                                       fCreateDisposition, fCreateOptions, fObjAttribs, pNameUniStr);
+    return INVALID_HANDLE_VALUE;
+}
+
+
+HANDLE birdOpenParentDirW(HANDLE hRoot, const wchar_t *pwszPath, ACCESS_MASK fDesiredAccess, ULONG fFileAttribs,
+                          ULONG fShareAccess, ULONG fCreateDisposition, ULONG fCreateOptions, ULONG fObjAttribs,
+                          MY_UNICODE_STRING *pNameUniStr)
+{
+    /*
+     * Convert the path and join up with the ansi version (it'll free NtPath).
+     */
+    MY_UNICODE_STRING NtPath;
+    if (hRoot == INVALID_HANDLE_VALUE)
+        hRoot = NULL;
+    if (  hRoot == NULL
+        ? birdDosToNtPathW(pwszPath, &NtPath) == 0
+        : birdDosToRelativeNtPathW(pwszPath, &NtPath) == 0)
+        return birdOpenParentDirCommon(hRoot, &NtPath, fDesiredAccess, fFileAttribs, fShareAccess,
+                                       fCreateDisposition, fCreateOptions, fObjAttribs, pNameUniStr);
+    return INVALID_HANDLE_VALUE;
+}
+
+
+/**
+ * Returns a handle to the current working directory of the process.
+ *
+ * @returns CWD handle with FILE_TRAVERSE and SYNCHRONIZE access.  May return
+ *          INVALID_HANDLE_VALUE w/ errno for invalid CWD.
+ */
+HANDLE birdOpenCurrentDirectory(void)
+{
+    PMY_RTL_USER_PROCESS_PARAMETERS pProcParams;
+    MY_NTSTATUS rcNt;
+    HANDLE hRet = INVALID_HANDLE_VALUE;
+
+    birdResolveImports();
+
+    /*
+     * We'll try get this from the PEB.
+     */
+    g_pfnRtlAcquirePebLock();
+    pProcParams = (PMY_RTL_USER_PROCESS_PARAMETERS)MY_NT_CURRENT_PEB()->ProcessParameters;
+    if (pProcParams != NULL)
+        rcNt = g_pfnNtDuplicateObject(MY_NT_CURRENT_PROCESS, pProcParams->CurrentDirectory.Handle,
+                                      MY_NT_CURRENT_PROCESS, &hRet,
+                                      FILE_TRAVERSE | SYNCHRONIZE,
+                                      0 /*fAttribs*/,
+                                      0 /*fOptions*/);
+    else
+        rcNt = STATUS_INVALID_PARAMETER;
+    g_pfnRtlReleasePebLock();
+    if (MY_NT_SUCCESS(rcNt))
+        return hRet;
+
+    /*
+     * Fallback goes thru birdOpenFileW.
+     */
+    return birdOpenFileW(L".",
+                         FILE_TRAVERSE | SYNCHRONIZE,
+                         FILE_ATTRIBUTE_NORMAL,
+                         FILE_SHARE_READ | FILE_SHARE_WRITE,
+                         FILE_OPEN,
+                         FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
+                         OBJ_CASE_INSENSITIVE);
 }
 

trunk/src/lib/nt/ntstat.c

@@ -93 +93 @@
 
 
-static int birdIsFileExecutableW(WCHAR const *pwcName, ULONG cwcName)
+/**
+ * @a pwcName could be the full path.
+ */
+static int birdIsFileExecutableW(WCHAR const *pwcName, size_t cwcName)
 {
     char            szExt[8];
@@ -128 +131 @@
 
 static unsigned short birdFileInfoToMode(HANDLE hFile, ULONG fAttribs, const char *pszName,
-                                         MY_FILE_NAME_INFORMATION *pNameInfo, __int16 *pfIsDirSymlink)
+                                         const wchar_t *pwszName, size_t cbNameW, __int16 *pfIsDirSymlink)
 {
     unsigned short fMode;
@@ -169 +172 @@
         || (pszName
             ? birdIsFileExecutable(pszName)
-            : birdIsFileExecutableW(pNameInfo->FileName, pNameInfo->FileNameLength)) )
+            : birdIsFileExecutableW(pwszName, cbNameW)) )
         fMode |= S_IXOTH | S_IXGRP | S_IXUSR;
 
@@ -186 +189 @@
 void birdStatFillFromFileIdFullDirInfo(BirdStat_T *pStat, MY_FILE_ID_FULL_DIR_INFORMATION const *pBuf, const char *pszPath)
 {
-    pStat->st_mode          = birdFileInfoToMode(INVALID_HANDLE_VALUE, pBuf->FileAttributes, pszPath,
-                                                 NULL, &pStat->st_dirsymlink);
+    pStat->st_mode          = birdFileInfoToMode(INVALID_HANDLE_VALUE, pBuf->FileAttributes,
+                                                 pszPath, pBuf->FileName, pBuf->FileNameLength, &pStat->st_dirsymlink);
     pStat->st_padding0[0]   = 0;
     pStat->st_padding0[1]   = 0;
@@ -218 +221 @@
 void birdStatFillFromFileIdBothDirInfo(BirdStat_T *pStat, MY_FILE_ID_BOTH_DIR_INFORMATION const *pBuf, const char *pszPath)
 {
-    pStat->st_mode          = birdFileInfoToMode(INVALID_HANDLE_VALUE, pBuf->FileAttributes, pszPath,
-                                                 NULL, &pStat->st_dirsymlink);
+    pStat->st_mode          = birdFileInfoToMode(INVALID_HANDLE_VALUE, pBuf->FileAttributes,
+                                                 pszPath, pBuf->FileName, pBuf->FileNameLength, &pStat->st_dirsymlink);
     pStat->st_padding0[0]   = 0;
     pStat->st_padding0[1]   = 0;
@@ -250 +253 @@
 void birdStatFillFromFileBothDirInfo(BirdStat_T *pStat, MY_FILE_BOTH_DIR_INFORMATION const *pBuf, const char *pszPath)
 {
-    pStat->st_mode          = birdFileInfoToMode(INVALID_HANDLE_VALUE, pBuf->FileAttributes, pszPath,
-                                                 NULL, &pStat->st_dirsymlink);
+    pStat->st_mode          = birdFileInfoToMode(INVALID_HANDLE_VALUE, pBuf->FileAttributes,
+                                                 pszPath, pBuf->FileName, pBuf->FileNameLength, &pStat->st_dirsymlink);
     pStat->st_padding0[0]   = 0;
     pStat->st_padding0[1]   = 0;
@@ -272 +275 @@
 
 
-int birdStatHandle(HANDLE hFile, BirdStat_T *pStat, const char *pszPath)
+int birdStatHandle2(HANDLE hFile, BirdStat_T *pStat, const char *pszPath, const wchar_t *pwszPath)
 {
     int                      rc;
@@ -290 +293 @@
         {
             pStat->st_mode          = birdFileInfoToMode(hFile, pAll->BasicInformation.FileAttributes, pszPath,
-                                                         &pAll->NameInformation, &pStat->st_dirsymlink);
+                                                         pAll->NameInformation.FileNamepAll->NameInformation.FileNameLength,
+                                                         &pStat->st_dirsymlink);
             pStat->st_padding0[0]   = 0;
             pStat->st_padding0[1]   = 0;
@@ -352 +356 @@
     if (MY_NT_SUCCESS(rcNt))
         rcNt = Ios.u.Status;
-    if (MY_NT_SUCCESS(rcNt) && !pszPath)
+    if (MY_NT_SUCCESS(rcNt) && !pszPath && !pwszPath)
     {
         cbNameInfo = 0x10020;
@@ -364 +368 @@
     {
         pStat->st_mode          = birdFileInfoToMode(hFile, BasicInfo.FileAttributes, pszPath,
-                                                     pNameInfo, &pStat->st_dirsymlink);
+                                                     pNameInfo ? pNameInfo->FileName : pwszPath,
+                                                     pNameInfo ? pNameInfo->FileNameLength
+                                                     : pwszPath ? wcslen(pwszPath) * sizeof(wchar_t) : 0,
+                                                     &pStat->st_dirsymlink);
         pStat->st_padding0[0]   = 0;
         pStat->st_padding0[1]   = 0;
@@ -413 +420 @@
 
 
+int birdStatHandle(HANDLE hFile, BirdStat_T *pStat, const char *pszPath)
+{
+    return birdStatHandle2(hFile, pStat, pszPath, NULL);
+}
+
+
 /**
  * Generates a device number from the volume information.
@@ -460 +473 @@
 
 
-static int birdStatInternal(const char *pszPath, BirdStat_T *pStat, int fFollow)
+static int birdStatInternal(HANDLE hRoot, const char *pszPath, BirdStat_T *pStat, int fFollow)
 {
     int rc;
-    HANDLE hFile = birdOpenFile(pszPath,
-                                FILE_READ_ATTRIBUTES,
-                                FILE_ATTRIBUTE_NORMAL,
-                                FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
-                                FILE_OPEN,
-                                FILE_OPEN_FOR_BACKUP_INTENT | (fFollow ? 0 : FILE_OPEN_REPARSE_POINT),
-                                OBJ_CASE_INSENSITIVE);
+    HANDLE hFile = birdOpenFileEx(hRoot, pszPath,
+                                  FILE_READ_ATTRIBUTES,
+                                  FILE_ATTRIBUTE_NORMAL,
+                                  FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                                  FILE_OPEN,
+                                  FILE_OPEN_FOR_BACKUP_INTENT | (fFollow ? 0 : FILE_OPEN_REPARSE_POINT),
+                                  OBJ_CASE_INSENSITIVE);
     if (hFile != INVALID_HANDLE_VALUE)
     {
-        rc = birdStatHandle(hFile, pStat, pszPath);
+        rc = birdStatHandle2(hFile, pStat, pszPath, NULL);
         birdCloseFile(hFile);
 
@@ -500 +513 @@
         {
             MY_UNICODE_STRING NameUniStr;
-            hFile = birdOpenParentDir(pszPath,
+            hFile = birdOpenParentDir(hRoot, pszPath,
                                       FILE_READ_DATA | SYNCHRONIZE,
                                       FILE_ATTRIBUTE_NORMAL,
@@ -552 +565 @@
 
 
+static int birdStatInternalW(HANDLE hRoot, const wchar_t *pwszPath, BirdStat_T *pStat, int fFollow)
+{
+    int rc;
+    HANDLE hFile = birdOpenFileExW(hRoot, pwszPath,
+                                   FILE_READ_ATTRIBUTES,
+                                   FILE_ATTRIBUTE_NORMAL,
+                                   FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                                   FILE_OPEN,
+                                   FILE_OPEN_FOR_BACKUP_INTENT | (fFollow ? 0 : FILE_OPEN_REPARSE_POINT),
+                                   OBJ_CASE_INSENSITIVE);
+    if (hFile != INVALID_HANDLE_VALUE)
+    {
+        rc = birdStatHandle2(hFile, pStat, NULL, pwszPath);
+        birdCloseFile(hFile);
+    }
+    else
+    {
+        /*
+         * On things like pagefile.sys we may get sharing violation.  We fall
+         * back on directory enumeration for dealing with that.
+         */
+        if (   errno == ETXTBSY
+            && wcschr(pwszPath, '*') == NULL /* Serious paranoia... */
+            && wcschr(pwszPath, '?') == NULL)
+        {
+            MY_UNICODE_STRING NameUniStr;
+            hFile = birdOpenParentDirW(hRoot, pwszPath,
+                                       FILE_READ_DATA | SYNCHRONIZE,
+                                       FILE_ATTRIBUTE_NORMAL,
+                                       FILE_SHARE_READ | FILE_SHARE_WRITE | FILE_SHARE_DELETE,
+                                       FILE_OPEN,
+                                       FILE_DIRECTORY_FILE | FILE_OPEN_FOR_BACKUP_INTENT | FILE_SYNCHRONOUS_IO_NONALERT,
+                                       OBJ_CASE_INSENSITIVE,
+                                       &NameUniStr);
+            if (hFile != INVALID_HANDLE_VALUE)
+            {
+                MY_FILE_ID_FULL_DIR_INFORMATION *pBuf;
+                ULONG               cbBuf = sizeof(*pBuf) + NameUniStr.MaximumLength + 1024;
+                MY_IO_STATUS_BLOCK  Ios;
+                MY_NTSTATUS         rcNt;
+
+                pBuf = (MY_FILE_ID_FULL_DIR_INFORMATION *)alloca(cbBuf);
+                Ios.u.Status    = -1;
+                Ios.Information = -1;
+                rcNt = g_pfnNtQueryDirectoryFile(hFile, NULL, NULL, NULL, &Ios, pBuf, cbBuf,
+                                                 MyFileIdFullDirectoryInformation, FALSE, &NameUniStr, TRUE);
+                if (MY_NT_SUCCESS(rcNt))
+                    rcNt = Ios.u.Status;
+                if (MY_NT_SUCCESS(rcNt))
+                {
+                    /*
+                     * Convert the data.
+                     */
+                    birdStatFillFromFileIdFullDirInfo(pStat, pBuf, NULL);
+
+                    /* Get the serial number, reusing the buffer from above. */
+                    rcNt = birdQueryVolumeDeviceNumber(hFile, (MY_FILE_FS_VOLUME_INFORMATION *)pBuf, cbBuf, &pStat->st_dev);
+                    if (MY_NT_SUCCESS(rcNt))
+                        rc = 0;
+                    else
+                        rc = birdSetErrnoFromNt(rcNt);
+                }
+
+                birdFreeNtPath(&NameUniStr);
+                birdCloseFile(hFile);
+
+                if (MY_NT_SUCCESS(rcNt))
+                    return 0;
+                birdSetErrnoFromNt(rcNt);
+            }
+        }
+        rc = -1;
+    }
+
+    return rc;
+}
+
+
 /**
  * Implements UNIX fstat().
@@ -570 +661 @@
         {
             case FILE_TYPE_DISK:
-                rc = birdStatHandle(hFile, pStat, NULL);
+                rc = birdStatHandle2(hFile, pStat, NULL, NULL);
                 break;
 
@@ -657 +748 @@
 int birdStatFollowLink(const char *pszPath, BirdStat_T *pStat)
 {
-    return birdStatInternal(pszPath, pStat, 1 /*fFollow*/);
+    return birdStatInternal(NULL, pszPath, pStat, 1 /*fFollow*/);
+}
+
+
+/**
+ * Implements UNIX stat().
+ */
+int birdStatFollowLinkW(const wchar_t *pwszPath, BirdStat_T *pStat)
+{
+    return birdStatInternalW(NULL, pwszPath, pStat, 1 /*fFollow*/);
 }
 
@@ -666 +766 @@
 int birdStatOnLink(const char *pszPath, BirdStat_T *pStat)
 {
-    return birdStatInternal(pszPath, pStat, 0 /*fFollow*/);
+    return birdStatInternal(NULL, pszPath, pStat, 0 /*fFollow*/);
+}
+
+
+/**
+ * Implements UNIX lstat().
+ */
+int birdStatOnLinkW(const wchar_t *pwszPath, BirdStat_T *pStat)
+{
+    return birdStatInternalW(NULL, pwszPath, pStat, 0 /*fFollow*/);
+}
+
+
+/**
+ * Implements an API like UNIX fstatat().
+ *
+ * @returns 0 on success, -1 and errno on failure.
+ * @param   hRoot               NT handle pwszPath is relative to.
+ * @param   pszPath             The path.
+ * @param   pStat               Where to return stats.
+ * @param   fFollowLink         Whether to follow links.
+ */
+int birdStatAt(HANDLE hRoot, const char *pszPath, BirdStat_T *pStat, int fFollowLink)
+{
+    return birdStatInternal(hRoot, pszPath, pStat, fFollowLink != 0);
+}
+
+
+/**
+ * Implements an API like UNIX fstatat().
+ *
+ * @returns 0 on success, -1 and errno on failure.
+ * @param   hRoot               NT handle pwszPath is relative to.
+ * @param   pwszPath            The path.
+ * @param   pStat               Where to return stats.
+ * @param   fFollowLink         Whether to follow links.
+ */
+int birdStatAtW(HANDLE hRoot, const wchar_t *pwszPath, BirdStat_T *pStat, int fFollowLink)
+{
+    return birdStatInternalW(hRoot, pwszPath, pStat, fFollowLink != 0);
 }
 

trunk/src/lib/nt/ntstat.h

@@ -77 +77 @@
 
 int birdStatFollowLink(const char *pszPath, BirdStat_T *pStat);
+int birdStatFollowLinkW(const wchar_t *pwszPath, BirdStat_T *pStat);
 int birdStatOnLink(const char *pszPath, BirdStat_T *pStat);
+int birdStatOnLinkW(const wchar_t *pwszPath, BirdStat_T *pStat);
+int birdStatAt(void *hRoot, const char *pszPath, BirdStat_T *pStat, int fFollowLink);
+int birdStatAtW(void *hRoot, const wchar_t *pwszPath, BirdStat_T *pStat, int fFollowLink);
 int birdStatOnFd(int fd, BirdStat_T *pStat);
 int birdStatOnFdJustSize(int fd, __int64 *pcbFile);

trunk/src/lib/nt/ntstuff.h

@@ -40 +40 @@
 #include <ntstatus.h>
 #undef timeval
+
+#include <k/kTypes.h>
 
 
@@ -467 +469 @@
 #endif
 
+#ifndef DUPLICATE_CLOSE_SOURCE /* For the misnomer NtDuplicateObject. */
+# define DUPLICATE_CLOSE_SOURCE             0x00000001U
+# define DUPLICATE_SAME_ACCESS              0x00000002U
+#endif
+#ifndef DUPLICATE_SAME_ATTRIBUTES
+# define DUPLICATE_SAME_ATTRIBUTES          0x00000004U
+#endif
+
 
 /** @name NT status codes and associated macros.
@@ -480 +490 @@
 /** @}  */
 
+/** The pseudohandle for the current process. */
+#define MY_NT_CURRENT_PROCESS               ((HANDLE)~(uintptr_t)0)
+/** The pseudohandle for the current thread. */
+#define MY_NT_CURRENT_THREAD                ((HANDLE)~(uintptr_t)1)
+
+typedef struct MY_CLIENT_ID
+{
+    HANDLE UniqueProcess;
+    HANDLE UniqueThread;
+} MY_CLIENT_ID;
+
+/** Partial TEB.   */
+typedef struct MY_PARTIAL_TEB
+{
+    NT_TIB          NtTib;
+    PVOID           EnvironmentPointer;
+    MY_CLIENT_ID    ClientId;
+    PVOID           ActiveRpcHandle;
+    PVOID           ThreadLocalStoragePointer;
+    PPEB            ProcessEnvironmentBlock;
+    KU32            LastErrorValue;
+    KU32            CountOfOwnedCriticalSections;
+    PVOID           CsrClientThread;
+    PVOID           Win32ThreadInfo;
+} MY_PARTIAL_TEB;
+
+/** Internal macro for reading uintptr_t sized TEB members. */
+#if K_ARCH == K_ARCH_AMD64
+# define MY_NT_READ_TEB_WORKER(a_offTebMember) ( __readgsqword(a_offTebMember) )
+#elif K_ARCH == K_ARCH_X86
+# define MY_NT_READ_TEB_WORKER(a_offTebMember) ( __readfsdword(a_offTebMember) )
+#else
+# else "Port me!"
+#endif
+/** Get the PEB pointer.
+ * @remark Needs stddef.h. */
+#define MY_NT_CURRENT_PEB()  ( (PPEB)MY_NT_READ_TEB_WORKER(offsetof(MY_PARTIAL_TEB, ProcessEnvironmentBlock)) )
+/** Get the TEB pointer.
+ * @remark Needs stddef.h. */
+#define MY_NT_CURRENT_TEB()  ( (PTEB)MY_NT_READ_TEB_WORKER(offsetof(NT_TIB, Self)) )
+
 
 /*******************************************************************************
@@ -488 +539 @@
                                                 PLARGE_INTEGER, ULONG, ULONG, ULONG, ULONG, PVOID, ULONG);
 extern MY_NTSTATUS (WINAPI * g_pfnNtDeleteFile)(MY_OBJECT_ATTRIBUTES *);
+extern MY_NTSTATUS (WINAPI * g_pfnNtDuplicateObject)(HANDLE hSrcProc, HANDLE hSrc, HANDLE hDstProc, HANDLE *phRet,
+                                                     MY_ACCESS_MASK fDesiredAccess, ULONG fAttribs, ULONG fOptions);
 extern MY_NTSTATUS (WINAPI * g_pfnNtReadFile)(HANDLE hFile, HANDLE hEvent, MY_IO_APC_ROUTINE *pfnApc, PVOID pvApcCtx,
                                               MY_IO_STATUS_BLOCK *, PVOID pvBuf, ULONG cbToRead, PLARGE_INTEGER poffFile,
@@ -509 +562 @@
 extern UCHAR       (WINAPI * g_pfnRtlUpperChar)(UCHAR uch);
 extern ULONG       (WINAPI * g_pfnRtlNtStatusToDosError)(MY_NTSTATUS rcNt);
+extern VOID        (WINAPI * g_pfnRtlAcquirePebLock)(VOID);
+extern VOID        (WINAPI * g_pfnRtlReleasePebLock)(VOID);
 
 

trunk/src/lib/nt/ntunlink.c

@@ -46 +46 @@
     HANDLE      hFile;
 
-    rcNt = birdOpenFileUniStr(pNtPath,
+    rcNt = birdOpenFileUniStr(NULL /*hRoot*/,
+                              pNtPath,
                               FILE_WRITE_ATTRIBUTES | FILE_READ_ATTRIBUTES | SYNCHRONIZE,
                               FILE_ATTRIBUTE_NORMAL,
@@ -112 +113 @@
             for (;;)
             {
-                rcNt = birdOpenFileUniStr(&NtPath,
+                rcNt = birdOpenFileUniStr(NULL /*hRoot*/,
+                                          &NtPath,
                                           DELETE,
                                           FILE_ATTRIBUTE_NORMAL,