WIP: removePathForcibly

OUTSTANDING ISSUES:
- No Windows support

System/Directory/Internal/C_utimensat.hsc

@@ -15,6 +15,7 @@ module System.Directory.Internal.C_utimensat where
 import Prelude ()
 import System.Directory.Internal.Prelude
 import Data.Time.Clock.POSIX (POSIXTime)
+import qualified System.Posix as Posix
 
 data CTimeSpec = CTimeSpec EpochTime CLong
 
@@ -29,9 +30,6 @@ instance Storable CTimeSpec where
       nsec <- #{peek struct timespec, tv_nsec} p
       return (CTimeSpec sec nsec)
 
-c_AT_FDCWD :: CInt
-c_AT_FDCWD = (#const AT_FDCWD)
-
 utimeOmit :: CTimeSpec
 utimeOmit = CTimeSpec (CTime 0) (#const UTIME_OMIT)
 
@@ -42,6 +40,6 @@ toCTimeSpec t = CTimeSpec (CTime sec) (truncate $ 10 ^ (9 :: Int) * frac)
     (sec', frac') = properFraction (toRational t)
 
 foreign import capi "sys/stat.h utimensat" c_utimensat
-  :: CInt -> CString -> Ptr CTimeSpec -> CInt -> IO CInt
+  :: Posix.Fd -> CString -> Ptr CTimeSpec -> CInt -> IO CInt
 
 #endif

System/Directory/Internal/Common.hs

@@ -215,6 +215,10 @@ simplifyWindows path
     subpathIsAbsolute = any isPathSeparator (take 1 (unpack subpath))
     hasTrailingPathSep = hasTrailingPathSeparator subpath
 
+-- | Whether to follow symbolic links when opening files.
+data FollowMode = FollowLinks | NoFollow
+                deriving (Bounded, Enum, Eq, Ord, Read, Show)
+
 data FileType = File
               | SymbolicLink -- ^ POSIX: either file or directory link; Windows: file link
               | Directory

System/Directory/Internal/Posix.hsc

@@ -1,9 +1,14 @@
+{-# LANGUAGE CApiFFI #-}
 module System.Directory.Internal.Posix where
 #include <HsDirectoryConfig.h>
 #if !defined(mingw32_HOST_OS)
+#include <fcntl.h>
 #ifdef HAVE_LIMITS_H
 # include <limits.h>
 #endif
+#ifdef HAVE_SYS_STAT_H
+# include <sys/stat.h>
+#endif
 import Prelude ()
 import System.Directory.Internal.Prelude
 #ifdef HAVE_UTIMENSAT
@@ -17,16 +22,36 @@ import System.OsPath ((</>), isRelative, splitSearchPath)
 import System.OsString.Internal.Types (OsString(OsString, getOsString))
 import qualified Data.Time.Clock.POSIX as POSIXTime
 import qualified System.OsPath.Internal as OsPath
+import qualified System.Posix.Directory.Fd as Posix
 import qualified System.Posix.Directory.PosixPath as Posix
 import qualified System.Posix.Env.PosixString as Posix
+import qualified System.Posix.Files as Posix (FileStatus(..))
 import qualified System.Posix.Files.PosixString as Posix
+import qualified System.Posix.Internals as Posix (CStat)
+import qualified System.Posix.IO.PosixString as Posix
 import qualified System.Posix.PosixPath.FilePath as Posix
 import qualified System.Posix.Types as Posix
 import qualified System.Posix.User.ByteString as Posix
 
 createDirectoryInternal :: OsPath -> IO ()
 createDirectoryInternal (OsString path) = Posix.createDirectory path 0o777
 
+c_AT_FDCWD :: Posix.Fd
+c_AT_FDCWD = Posix.Fd (#const AT_FDCWD)
+
+foreign import ccall "unistd.h unlinkat" c_unlinkat
+  :: Posix.Fd -> CString -> CInt -> IO CInt
+
+removePathAt :: FileType -> Maybe FileRef -> OsPath -> IO ()
+removePathAt fType dirRef (OsString path) =
+  Posix.withFilePath path $ \ pPath -> do
+    Posix.throwErrnoPathIfMinus1_ "unlinkat" path
+      (c_unlinkat (fromMaybe c_AT_FDCWD dirRef) pPath flag)
+    pure ()
+  where
+    flag | fileTypeIsDirectory fType = (#const AT_REMOVEDIR)
+         | otherwise                 = 0
+
 removePathInternal :: Bool -> OsPath -> IO ()
 removePathInternal True  = Posix.removeDirectory . getOsString
 removePathInternal False = Posix.removeLink . getOsString
@@ -36,8 +61,8 @@ renamePathInternal (OsString p1) (OsString p2) = Posix.rename p1 p2
 
 -- On POSIX, the removability of a file is only affected by the attributes of
 -- the containing directory.
-filesAlwaysRemovable :: Bool
-filesAlwaysRemovable = True
+filesAreAlwaysRemovable :: Bool
+filesAreAlwaysRemovable = True
 
 -- | On POSIX, equivalent to 'simplifyPosix'.
 simplify :: OsPath -> OsPath
@@ -101,9 +126,13 @@ exeExtensionInternal :: OsString
 exeExtensionInternal = exeExtension
 
 getDirectoryContentsInternal :: OsPath -> IO [OsPath]
-getDirectoryContentsInternal (OsString path) =
+getDirectoryContentsInternal path =
+  withFileRef Nothing path getDirectoryContentsRef
+
+getDirectoryContentsRef :: FileRef -> IO [OsPath]
+getDirectoryContentsRef fileRef =
   bracket
-    (Posix.openDirStream path)
+    (Posix.unsafeOpenDirStreamFd =<< Posix.dup fileRef)
     Posix.closeDirStream
     start
   where
@@ -151,11 +180,68 @@ createSymbolicLink _ (OsString p1) (OsString p2) =
 readSymbolicLink :: OsPath -> IO OsPath
 readSymbolicLink = (OsString <$>) . Posix.readSymbolicLink . getOsString
 
+defaultFlags :: Posix.OpenFileFlags
+defaultFlags =
+  Posix.defaultFileFlags
+  { Posix.noctty = True
+  , Posix.nonBlock = True
+  , Posix.cloexec = True
+  }
+
+type FileRef = Posix.Fd
+
+withFileRef :: Maybe FileRef -> OsPath -> (FileRef -> IO r) -> IO r
+withFileRef dirRef (OsString name) =
+  bracket
+    (Posix.openFdAt dirRef name Posix.ReadOnly defaultFlags)
+    Posix.closeFd
+
+data Subref = NotSubdir -- ^ Not a directory (perhaps regular file or symlink).
+            | SubdirRef FileRef deriving (Show) -- ^ Is a subdirectory.
+
+openSubref :: Maybe FileRef -> OsPath -> IO Subref
+openSubref dirRef (OsString name) = do
+  let flags = defaultFlags { Posix.nofollow = True, Posix.directory = True }
+  result <- tryIOError (Posix.openFdAt dirRef name Posix.ReadOnly flags)
+  case result of
+    Left err -> do
+      errno <- getErrno
+      if errno == eLOOP || errno == eNOTDIR
+        then pure NotSubdir
+        else throwIO err
+    Right ref -> pure (SubdirRef ref)
+
+closeSubref :: Subref -> IO ()
+closeSubref  NotSubdir      = pure ()
+closeSubref (SubdirRef ref) = Posix.closeFd ref
+
+withSubref :: Maybe FileRef -> OsPath -> (Subref -> IO r) -> IO r
+withSubref dirRef name action =
+  bracket (openSubref dirRef name) closeSubref action
+
 type Metadata = Posix.FileStatus
 
+foreign import capi "sys/stat.h fstatat" c_fstatat
+  :: Posix.Fd -> CString -> Ptr Posix.CStat -> CInt -> IO CInt
+
+c_AT_SYMLINK_NOFOLLOW :: CInt
+c_AT_SYMLINK_NOFOLLOW = (#const AT_SYMLINK_NOFOLLOW)
+
+getSymbolicLinkMetadataAt :: Maybe FileRef -> OsPath -> IO Metadata
+getSymbolicLinkMetadataAt dirRef (OsString path) =
+  Posix.withFilePath path $ \ pPath -> do
+    stat <- mallocForeignPtrBytes (#const sizeof(struct stat))
+    withForeignPtr stat $ \ pStat -> do
+      Posix.throwErrnoPathIfMinus1_ "fstatat" path $ do
+        c_fstatat (fromMaybe c_AT_FDCWD dirRef) pPath pStat c_AT_SYMLINK_NOFOLLOW
+    pure (Posix.FileStatus stat)
+
 getSymbolicLinkMetadata :: OsPath -> IO Metadata
 getSymbolicLinkMetadata = Posix.getSymbolicLinkStatus . getOsString
 
+getFileRefMetadata :: FileRef -> IO Metadata
+getFileRefMetadata = Posix.getFdStatus
+
 getFileMetadata :: OsPath -> IO Metadata
 getFileMetadata = Posix.getFileStatus . getOsString
 
@@ -197,6 +283,20 @@ setWriteMode :: Bool -> Mode -> Mode
 setWriteMode False m = m .&. complement allWriteMode
 setWriteMode True  m = m .|. allWriteMode
 
+foreign import capi "sys/stat.h fchmodat" c_fchmodat
+  :: Posix.Fd -> CString -> Posix.FileMode -> CInt -> IO CInt
+
+setFileModeAtNoFollow :: Maybe FileRef -> OsPath -> Posix.FileMode -> IO ()
+setFileModeAtNoFollow dirRef (OsString path) mode = do
+  Posix.withFilePath path $ \ pPath ->
+    Posix.throwErrnoPathIfMinus1_ "fchmodat" path
+      (c_fchmodat (fromMaybe c_AT_FDCWD dirRef) pPath mode c_AT_SYMLINK_NOFOLLOW)
+
+forceRemovable :: Maybe FileRef -> OsPath -> Metadata -> IO ()
+forceRemovable dirRef path metadata = do
+  let mode = modeFromMetadata metadata .|. Posix.ownerModes
+  setFileModeAtNoFollow dirRef path mode
+
 setFileMode :: OsPath -> Mode -> IO ()
 setFileMode = Posix.setFileMode . getOsString
 

System/Directory/Internal/Prelude.hs

@@ -80,11 +80,13 @@ import Foreign
   , allocaArray
   , allocaBytes
   , allocaBytesAligned
+  , mallocForeignPtrBytes
   , maybeWith
   , nullPtr
   , plusPtr
   , with
   , withArray
+  , withForeignPtr
   )
 import Foreign.C
   ( CInt(..)
@@ -96,6 +98,9 @@ import Foreign.C
   , CUShort(..)
   , CWString
   , CWchar(..)
+  , eLOOP
+  , eNOTDIR
+  , getErrno
   , throwErrnoIfMinus1Retry_
   , throwErrnoIfMinus1_
   , throwErrnoIfNull
@@ -145,5 +150,5 @@ import System.IO.Error
   , tryIOError
   , userError
   )
-import System.Posix.Types (EpochTime)
+import System.Posix.Types (CMode, EpochTime)
 import System.Timeout (timeout)

System/Directory/Internal/Windows.hsc

@@ -63,8 +63,8 @@ renamePathInternal opath npath =
 
 -- On Windows, the removability of a file may be affected by the attributes of
 -- the file itself.
-filesAlwaysRemovable :: Bool
-filesAlwaysRemovable = False
+filesAreAlwaysRemovable :: Bool
+filesAreAlwaysRemovable = False
 
 copyFileWithMetadataInternal :: (Metadata -> OsPath -> IO ())
                              -> (Metadata -> OsPath -> IO ())

System/Directory/OsPath.hs

@@ -460,33 +460,37 @@ removeContentsRecursive path =
 removePathForcibly :: OsPath -> IO ()
 removePathForcibly path =
   (`ioeAddLocation` "removePathForcibly") `modifyIOError` do
-    ignoreDoesNotExistError $ do
-      m <- getSymbolicLinkMetadata path
-      case fileTypeFromMetadata m of
-        DirectoryLink -> do
-          makeRemovable path
-          removeDirectory path
-        Directory -> do
-          makeRemovable path
-          names <- listDirectory path
-          sequenceWithIOErrors_ $
-            [ removePathForcibly (path </> name) | name <- names ] ++
-            [ removeDirectory path ]
-        _ -> do
-          unless filesAlwaysRemovable (makeRemovable path)
-          removeFile path
+    ignoreDoesNotExistError (removeForcibly Nothing path)
+
   where
 
+    removeForcibly :: Maybe FileRef -> OsPath -> IO ()
+    removeForcibly dirRef name = do
+      forceRemovableIfPossible dirRef name
+      withSubref dirRef name $ \ subref -> do
+        case subref of
+          NotSubdir -> do
+            removePathAt File dirRef name -- TODO: What about windows dir links?
+          SubdirRef subdirRef -> do
+            names <-
+              -- This filter is very important! Otherwise it will
+              -- recurse into the parent directory and do bad things.
+              filter (not . isSpecialDir) <$>
+                getDirectoryContentsRef subdirRef
+            sequenceWithIOErrors_ $
+              (removeForcibly (Just subdirRef) <$> names) <>
+              [removePathAt Directory dirRef name]
+
     ignoreDoesNotExistError :: IO () -> IO ()
     ignoreDoesNotExistError action =
       () <$ tryIOErrorType isDoesNotExistError action
 
-    makeRemovable :: OsPath -> IO ()
-    makeRemovable p = (`catchIOError` \ _ -> pure ()) $ do
-      perms <- getPermissions p
-      setPermissions path perms{ readable = True
-                               , searchable = True
-                               , writable = True }
+    forceRemovableIfPossible :: Maybe FileRef -> OsPath -> IO ()
+    forceRemovableIfPossible dirRef name = do
+      metadata <- getSymbolicLinkMetadataAt dirRef name
+      when (fileTypeIsDirectory (fileTypeFromMetadata metadata)
+            || not filesAreAlwaysRemovable) $ do
+        forceRemovable dirRef path metadata `catchIOError` \ _ -> pure ()
 
 {- |'removeFile' /file/ removes the directory entry for an existing file
 /file/, where /file/ is not itself a directory. The
@@ -1100,6 +1104,15 @@ findFilesWithLazy f dirs path
 exeExtension :: OsString
 exeExtension = exeExtensionInternal
 
+curDir :: OsPath
+curDir = os "."
+
+parDir :: OsPath
+parDir = os ".."
+
+isSpecialDir :: OsPath -> Bool
+isSpecialDir = (`elem` [curDir, parDir])
+
 -- | Similar to 'listDirectory', but always includes the special entries (@.@
 -- and @..@).  (This applies to Windows as well.)
 --
@@ -1140,8 +1153,7 @@ getDirectoryContents path =
 --   @[ENOTDIR]@
 --
 listDirectory :: OsPath -> IO [OsPath]
-listDirectory path = filter f <$> getDirectoryContents path
-  where f filename = filename /= os "." && filename /= os ".."
+listDirectory path = filter (not . isSpecialDir) <$> getDirectoryContents path
 
 -- | Obtain the current working directory as an absolute path.
 --