Changeset 3682 for trunk/src/lib/nt/ntunlink.c

Timestamp:

Aug 13, 2025, 1:34:19 AM (4 weeks ago)

Author:

bird

Message:

lib/nt,kmk: Fixed around rm/unlink semantics and general support for long file names in lib/nt.

File:

• trunk/src/lib/nt/ntunlink.c (modified) (17 diffs)

trunk/src/lib/nt/ntunlink.c

@@ -33 +33 @@
 *   Header Files                                                               *
 *******************************************************************************/
+#include <io.h>  /* for _get_osfhandle */
 #include "ntunlink.h"
 
 #include "ntstuff.h"
 #include "nthlp.h"
+#include "nthlpmisc.h"
 
 
@@ -82 +84 @@
 
 
-static int birdUnlinkInternal(HANDLE hRoot, const char *pszFile, const wchar_t *pwszFile, int fReadOnlyToo, int fFast)
+static int birdUnlinkInternal(HANDLE hRoot, const char *pszFile, const wchar_t *pwszFile, int fReadOnlyToo, int fFast, int fRmDir)
 {
     MY_UNICODE_STRING   NtPath;
@@ -108 +110 @@
         if (fFast)
         {
-            /* This uses FILE_DELETE_ON_CLOSE. Probably only suitable when in a hurry... */
-            MY_OBJECT_ATTRIBUTES ObjAttr;
-            MyInitializeObjectAttributes(&ObjAttr, &NtPath, OBJ_CASE_INSENSITIVE, hRoot, NULL /*pSecAttr*/);
-            rcNt = g_pfnNtDeleteFile(&ObjAttr);
-
-            /* In case some file system does things differently than NTFS. */
-            if (rcNt == STATUS_CANNOT_DELETE && fReadOnlyToo)
+            /*
+             * This uses FILE_DELETE_ON_CLOSE.
+             *
+             * It is only suitable if in a hurry and when 100% sure it is a regular file.
+             * It will follow symbolic links by default, so subject to races and abuse.
+             *
+             * If used on a directory and the directory isn't empty, it will return success
+             * instead of STATUS_CANNOT_DELETE.
+             *
+             * To stay out of trouble, we always use the OBJ_DONT_REPARSE flag here.  This
+             * is a relative new addition (windows 10, build unknown), so if it ain't
+             * supported or we encounter a reparse object we just fall back to the regular
+             * deletion code.
+             */
+            static int volatile s_iSupportsDontReparse = 0;
+            if (s_iSupportsDontReparse >= 0 && !fRmDir)
             {
-                birdMakeWritable(hRoot, &NtPath);
+                MY_OBJECT_ATTRIBUTES ObjAttr;
+                MyInitializeObjectAttributes(&ObjAttr, &NtPath, OBJ_DONT_REPARSE | OBJ_CASE_INSENSITIVE, hRoot, NULL /*pSecAttr*/);
                 rcNt = g_pfnNtDeleteFile(&ObjAttr);
+
+                /* In case some file system does things differently than NTFS. */
+                if (rcNt == STATUS_CANNOT_DELETE && fReadOnlyToo)
+                {
+                    birdMakeWritable(hRoot, &NtPath);
+                    rcNt = g_pfnNtDeleteFile(&ObjAttr);
+                }
+
+                /* Do fallback. */
+                if (rcNt == STATUS_REPARSE_POINT_ENCOUNTERED)
+                    fFast = 0;
+                else if (rcNt == STATUS_INVALID_PARAMETER)
+                {
+                    s_iSupportsDontReparse = -1;
+                    fFast = 0;
+                }
+            }
+            else
+            {
+                rcNt = STATUS_INVALID_PARAMETER;
+                fFast = 0;
             }
         }
-        else
+
+        if (!fFast)
         {
-            /* Use the set information stuff. Probably more reliable. */
+            /*
+             * Use the set information stuff. Here we can better control reparsing.
+             */
             HANDLE hFile;
             for (;;)
             {
+                MY_IO_STATUS_BLOCK Ios;
+
                 rcNt = birdOpenFileUniStr(hRoot,
                                           &NtPath,
@@ -132 +170 @@
                                           FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
                                           FILE_OPEN,
-                                          FILE_OPEN_FOR_BACKUP_INTENT | FILE_OPEN_REPARSE_POINT,
+                                          (!fRmDir ? FILE_NON_DIRECTORY_FILE : FILE_DIRECTORY_FILE)
+                                          | FILE_OPEN_FOR_BACKUP_INTENT | FILE_OPEN_REPARSE_POINT,
                                           OBJ_CASE_INSENSITIVE,
                                           &hFile);
+
+                /* Windows distinguishes between symlinks to directories and to files, so
+                   unlink(symlink-dir) will fail and we have to retry w/o the non-dir-file
+                   flag and make sure it didn't turn into a pure directory. */
+                if (   rcNt == STATUS_FILE_IS_A_DIRECTORY
+                    && !fRmDir)
+                {
+                    rcNt = birdOpenFileUniStr(hRoot,
+                                              &NtPath,
+                                              DELETE | FILE_READ_ATTRIBUTES | SYNCHRONIZE,
+                                              FILE_ATTRIBUTE_REPARSE_POINT,
+                                              FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE,
+                                              FILE_OPEN,
+                                              FILE_OPEN_FOR_BACKUP_INTENT | FILE_OPEN_REPARSE_POINT,
+                                              OBJ_CASE_INSENSITIVE,
+                                              &hFile);
+                    if (MY_NT_SUCCESS(rcNt))
+                    {
+                        MY_FILE_BASIC_INFORMATION BasicInfo;
+                        memset(&BasicInfo, 0, sizeof(BasicInfo));
+
+                        Ios.Information = -1;
+                        Ios.u.Status    = -1;
+
+                        rcNt = g_pfnNtQueryInformationFile(hFile, &Ios, &BasicInfo, sizeof(BasicInfo), MyFileBasicInformation);
+                        if (   !MY_NT_SUCCESS(rcNt)
+                            || !MY_NT_SUCCESS(Ios.u.Status)
+                            ||    (BasicInfo.FileAttributes & (FILE_ATTRIBUTE_REPARSE_POINT | FILE_ATTRIBUTE_DIRECTORY))
+                               == FILE_ATTRIBUTE_DIRECTORY)
+                        {
+                            birdCloseFile(hFile);
+                            rcNt = STATUS_FILE_IS_A_DIRECTORY;
+                            break;
+                        }
+                    }
+                }
+
                 if (MY_NT_SUCCESS(rcNt))
                 {
                     MY_FILE_DISPOSITION_INFORMATION DispInfo;
-                    MY_IO_STATUS_BLOCK              Ios;
-
                     DispInfo.DeleteFile = TRUE;
 
@@ -161 +235 @@
         if (MY_NT_SUCCESS(rcNt))
             rc = 0;
+        else if (rcNt == STATUS_SHARING_VIOLATION && fRmDir)
+            rc = birdSetErrnoToDirNotEmpty(); /* probably the case... */
         else
             rc = birdSetErrnoFromNt(rcNt);
@@ -168 +244 @@
 
 
+/*
+ * unlink:
+ */
+
 int birdUnlink(const char *pszFile)
 {
-    return birdUnlinkInternal(NULL /*hRoot*/, pszFile, NULL /*pwszFile*/, 0 /*fReadOnlyToo*/, 0 /*fFast*/);
+    return birdUnlinkInternal(NULL /*hRoot*/, pszFile, NULL /*pwszFile*/, 0 /*fReadOnlyToo*/, 0 /*fFast*/, 0 /*fRmDir*/);
 }
 
@@ -176 +256 @@
 int birdUnlinkW(const wchar_t *pwszFile)
 {
-    return birdUnlinkInternal(NULL /*hRoot*/, NULL /*pwszFile*/, pwszFile, 0 /*fReadOnlyToo*/, 0 /*fFast*/);
+    return birdUnlinkInternal(NULL /*hRoot*/, NULL /*pwszFile*/, pwszFile, 0 /*fReadOnlyToo*/, 0 /*fFast*/, 0 /*fRmDir*/);
 }
 
@@ -182 +262 @@
 int birdUnlinkEx(void *hRoot, const char *pszFile)
 {
-    return birdUnlinkInternal((HANDLE)hRoot, pszFile, NULL /*pwszFile*/, 0 /*fReadOnlyToo*/, 0 /*fFast*/);
+    return birdUnlinkInternal((HANDLE)hRoot, pszFile, NULL /*pwszFile*/, 0 /*fReadOnlyToo*/, 0 /*fFast*/, 0 /*fRmDir*/);
 }
 
@@ -188 +268 @@
 int birdUnlinkExW(void *hRoot, const wchar_t *pwszFile)
 {
-    return birdUnlinkInternal((HANDLE)hRoot, NULL /*pszFile*/, pwszFile, 0 /*fReadOnlyToo*/, 0 /*fFast*/);
+    return birdUnlinkInternal((HANDLE)hRoot, NULL /*pszFile*/, pwszFile, 0 /*fReadOnlyToo*/, 0 /*fFast*/, 0 /*fRmDir*/);
 }
 
@@ -194 +274 @@
 int birdUnlinkForced(const char *pszFile)
 {
-    return birdUnlinkInternal(NULL /*hRoot*/, pszFile, NULL /*pwszFile*/, 1 /*fReadOnlyToo*/, 0 /*fFast*/);
+    return birdUnlinkInternal(NULL /*hRoot*/, pszFile, NULL /*pwszFile*/, 1 /*fReadOnlyToo*/, 0 /*fFast*/, 0 /*fRmDir*/);
 }
 
@@ -200 +280 @@
 int birdUnlinkForcedW(const wchar_t *pwszFile)
 {
-    return birdUnlinkInternal(NULL /*hRoot*/, NULL /*pszFile*/, pwszFile, 1 /*fReadOnlyToo*/, 0 /*fFast*/);
+    return birdUnlinkInternal(NULL /*hRoot*/, NULL /*pszFile*/, pwszFile, 1 /*fReadOnlyToo*/, 0 /*fFast*/, 0 /*fRmDir*/);
 }
 
@@ -206 +286 @@
 int birdUnlinkForcedEx(void *hRoot, const char *pszFile)
 {
-    return birdUnlinkInternal((HANDLE)hRoot, pszFile, NULL /*pwszFile*/, 1 /*fReadOnlyToo*/, 0 /*fFast*/);
+    return birdUnlinkInternal((HANDLE)hRoot, pszFile, NULL /*pwszFile*/, 1 /*fReadOnlyToo*/, 0 /*fFast*/, 0 /*fRmDir*/);
 }
 
@@ -212 +292 @@
 int birdUnlinkForcedExW(void *hRoot, const wchar_t *pwszFile)
 {
-    return birdUnlinkInternal((HANDLE)hRoot, NULL /*pszFile*/, pwszFile, 1 /*fReadOnlyToo*/, 0 /*fFast*/);
+    return birdUnlinkInternal((HANDLE)hRoot, NULL /*pszFile*/, pwszFile, 1 /*fReadOnlyToo*/, 0 /*fFast*/, 0 /*fRmDir*/);
 }
 
@@ -218 +298 @@
 int birdUnlinkForcedFast(const char *pszFile)
 {
-    return birdUnlinkInternal(NULL /*hRoot*/, pszFile, NULL /*pwszFile*/, 1 /*fReadOnlyToo*/, 1 /*fFast*/);
+    return birdUnlinkInternal(NULL /*hRoot*/, pszFile, NULL /*pwszFile*/, 1 /*fReadOnlyToo*/, 1 /*fFast*/, 0 /*fRmDir*/);
 }
 
@@ -224 +304 @@
 int birdUnlinkForcedFastW(const wchar_t *pwszFile)
 {
-    return birdUnlinkInternal(NULL /*hRoot*/, NULL /*pszFile*/, pwszFile, 1 /*fReadOnlyToo*/, 1 /*fFast*/);
+    return birdUnlinkInternal(NULL /*hRoot*/, NULL /*pszFile*/, pwszFile, 1 /*fReadOnlyToo*/, 1 /*fFast*/, 0 /*fRmDir*/);
 }
 
@@ -230 +310 @@
 int birdUnlinkForcedFastEx(void *hRoot, const char *pszFile)
 {
-    return birdUnlinkInternal((HANDLE)hRoot, pszFile, NULL /*pwszFile*/, 1 /*fReadOnlyToo*/, 1 /*fFast*/);
+    return birdUnlinkInternal((HANDLE)hRoot, pszFile, NULL /*pwszFile*/, 1 /*fReadOnlyToo*/, 1 /*fFast*/, 0 /*fRmDir*/);
 }
 
@@ -236 +316 @@
 int birdUnlinkForcedFastExW(void *hRoot, const wchar_t *pwszFile)
 {
-    return birdUnlinkInternal((HANDLE)hRoot, NULL /*pszFile*/, pwszFile, 1 /*fReadOnlyToo*/, 1 /*fFast*/);
-}
-
+    return birdUnlinkInternal((HANDLE)hRoot, NULL /*pszFile*/, pwszFile, 1 /*fReadOnlyToo*/, 1 /*fFast*/, 0 /*fRmDir*/);
+}
+
+
+/*
+ * rmdir
+ */
+
+int birdRmDir(const char *pszFile)
+{
+    return birdUnlinkInternal(NULL /*hRoot*/, pszFile, NULL /*pwszFile*/, 0 /*fReadOnlyToo*/, 0 /*fFast*/, 1 /*fRmDir*/);
+}
+
+
+int birdRmDirW(const wchar_t *pwszFile)
+{
+    return birdUnlinkInternal(NULL /*hRoot*/, NULL /*pwszFile*/, pwszFile, 0 /*fReadOnlyToo*/, 0 /*fFast*/, 1 /*fRmDir*/);
+}
+
+
+int birdRmDirEx(void *hRoot, const char *pszFile)
+{
+    return birdUnlinkInternal((HANDLE)hRoot, pszFile, NULL /*pwszFile*/, 0 /*fReadOnlyToo*/, 0 /*fFast*/, 1 /*fRmDir*/);
+}
+
+
+int birdRmDirExW(void *hRoot, const wchar_t *pwszFile)
+{
+    return birdUnlinkInternal((HANDLE)hRoot, NULL /*pszFile*/, pwszFile, 0 /*fReadOnlyToo*/, 0 /*fFast*/, 1 /*fRmDir*/);
+}
+
+
+int birdRmDirForced(const char *pszFile)
+{
+    return birdUnlinkInternal(NULL /*hRoot*/, pszFile, NULL /*pwszFile*/, 1 /*fReadOnlyToo*/, 0 /*fFast*/, 1 /*fRmDir*/);
+}
+
+
+int birdRmDirForcedW(const wchar_t *pwszFile)
+{
+    return birdUnlinkInternal(NULL /*hRoot*/, NULL /*pszFile*/, pwszFile, 1 /*fReadOnlyToo*/, 0 /*fFast*/, 1 /*fRmDir*/);
+}
+
+
+int birdRmDirForcedEx(void *hRoot, const char *pszFile)
+{
+    return birdUnlinkInternal((HANDLE)hRoot, pszFile, NULL /*pwszFile*/, 1 /*fReadOnlyToo*/, 0 /*fFast*/, 1 /*fRmDir*/);
+}
+
+
+int birdRmDirForcedExW(void *hRoot, const wchar_t *pwszFile)
+{
+    return birdUnlinkInternal((HANDLE)hRoot, NULL /*pszFile*/, pwszFile, 1 /*fReadOnlyToo*/, 0 /*fFast*/, 1 /*fRmDir*/);
+}
+
+
+/**
+ * Implements unlinkat().
+ */
+int birdUnlinkAt(int fdDir, const char *pszPath, int fFlags)
+{
+    HANDLE hDirRoot;
+
+    /** @todo validate input. */
+    fFlags &= AT_REMOVEDIR;
+
+    /*
+     * Check the path its effectively a AT_FDCWD call.
+     */
+    if (fdDir != AT_FDCWD)
+    {
+        if (IS_SLASH(pszPath[0]))
+        {
+            if (IS_SLASH(pszPath[1]) && !IS_SLASH(pszPath[2]) && pszPath[2] != '\0')
+                fdDir = AT_FDCWD;
+        }
+        else if (IS_ALPHA(pszPath[0]) && pszPath[1] == ':')
+        {
+            if (IS_SLASH(pszPath[2]))
+                fdDir = AT_FDCWD;
+            else
+                /*
+                 * Drive letter relative path like "C:kernel32.dll".
+                 * We could try use fdDir as the CWD here if it refers to the same drive,
+                 * however that's can be implemented later...
+                 */
+                fdDir = AT_FDCWD;
+        }
+    }
+
+    /*
+     * Determine hDirRoot.
+     */
+    if (fdDir == AT_FDCWD)
+        hDirRoot = NULL;
+    else
+    {
+        hDirRoot = (HANDLE)_get_osfhandle(fdDir);
+        if (hDirRoot == INVALID_HANDLE_VALUE || hDirRoot == NULL)
+            return birdSetErrnoToBadFileNo();
+    }
+
+    return birdUnlinkInternal(hDirRoot, pszPath, NULL /*pwszFile*/, 1 /*fReadOnlyToo*/, 0 /*fFast*/, !!fFlags /*fRmDir*/);
+}
+