[PATCH v7 3/5] server: Handle hardlinks and casefolding when renaming the same file.

[Gabriel Ivăncescu]

From: Gabriel Ivăncescu

Based on code and suggestions by Jinoh Kang.

Signed-off-by: Gabriel Ivăncescu 
---
 dlls/kernel32/tests/file.c |   2 -
 server/fd.c                | 109 ++++++++++++++++++++++++++++++++++++-
 2 files changed, 108 insertions(+), 3 deletions(-)

diff --git a/dlls/kernel32/tests/file.c b/dlls/kernel32/tests/file.c
index b78360287af..edd76b40c0d 100644
--- a/dlls/kernel32/tests/file.c
+++ b/dlls/kernel32/tests/file.c
@@ -2182,9 +2182,7 @@ static void test_MoveFileA(void)
     }
     FindClose(hfind);
     ret = GetFileAttributesA(source);
-    todo_wine
     ok(ret == INVALID_FILE_ATTRIBUTES && GetLastError() == ERROR_FILE_NOT_FOUND, "GetFileAttributesA: error %ld\n", GetLastError());
-    if(ret != INVALID_FILE_ATTRIBUTES) DeleteFileA(source);
     ret = DeleteFileA(dest);
     ok(ret, "DeleteFileA: error %ld\n", GetLastError());

diff --git a/server/fd.c b/server/fd.c
index e1b969a0439..5fc994cf2dd 100644
--- a/server/fd.c
+++ b/server/fd.c
@@ -2535,6 +2535,107 @@ static void set_fd_disposition( struct fd *fd, unsigned int flags )
         ((fd->options & FILE_DELETE_ON_CLOSE) ? FILE_DISPOSITION_DELETE : 0);
 }

+/* rename the same file, dealing with casefolding and possibly different hardlinks to it */
+static void rename_same_file( const char *src, const char *dst, int is_dir )
+{
+    static const char tmpname_fmt[] = ".wine-rename-tmp-%08x";
+    static unsigned tmp_value;
+
+    char *dirname, tmpname[sizeof(tmpname_fmt) + 4 /* remaining of %08x */];
+    const char *srcname, *dstname = strrchr( dst, '/' ) + 1;
+    struct stat st, st2;
+    int dirfd, res = 0;
+    unsigned i;
+
+    /* first, if not a dir, check the directories they reside in */
+    if (!is_dir)
+    {
+        if (!(dirname = memdup( dst, dstname - dst )))
+            return;
+        dirname[dstname - dst - 1] = '\0';
+        if ((res = stat( dirname, &st )))
+            file_set_error();
+        free( dirname );
+        if (res)
+            return;
+    }
+
+    srcname = strrchr( src, '/' ) + 1;
+    if (!(dirname = memdup( src, srcname - src )))
+        return;
+    dirname[srcname - src - 1] = '\0';
+    if ((dirfd = open( dirname, O_RDONLY | O_NONBLOCK )) == -1)
+        file_set_error();
+    free( dirname );
+    if (dirfd == -1)
+        return;
+
+    if (!is_dir)
+    {
+        if (fstat( dirfd, &st2 ))
+        {
+            file_set_error();
+            goto ret;
+        }
+
+        /* if different directories, it must be a hardlink, so simply remove the source */
+        if (st.st_dev != st2.st_dev || st.st_ino != st2.st_ino)
+        {
+            if (unlinkat( dirfd, srcname, 0 ))
+                file_set_error();
+            goto ret;
+        }
+    }
+
+    /* same dentry means a no-op */
+    if (!strcmp( srcname, dstname )) goto ret;
+
+    /* This is more complicated now, because in case of a casefold (+F) directory, the destination may very well be the same dentry,
+     * even if the name doesn't match (if it differs just by case), in which case unlinking it is wrong and can be dangerous. Instead,
+     * we first rename the source to a temporary filename in the same directory. If this is a casefold dir, this will also remove the
+     * destination, otherwise the destination still exists. We then create a hardlink from the destination to our temporary name, and
+     * finally, unlink the temporary. This still works if the directory is case sensitive, so it's not a problem in either case. */
+    tmp_value += (current_time >> 16) + current_time;
+    for (i = 0; i < 0x8000; i++, tmp_value += 7777)
+    {
+        snprintf( tmpname, sizeof(tmpname), tmpname_fmt, tmp_value );
+        if (fstatat( dirfd, tmpname, &st, 0 ))  /* tmpname doesn't exist */
+            break;
+    }
+    if (i >= 0x8000)
+    {
+        set_error( STATUS_UNSUCCESSFUL );
+        goto ret;
+    }
+
+    if (renameat( dirfd, srcname, dirfd, tmpname ))
+    {
+        file_set_error();
+        goto ret;
+    }
+
+    if (!is_dir)
+    {
+        /* we can't just do rename(2) here; renaming a file to its hardlink is no-op */
+        if (linkat( dirfd, tmpname, dirfd, dstname, 0 ) && errno != EEXIST)
+        {
+            file_set_error();
+            /* revert the temporary rename */
+            renameat( dirfd, tmpname, dirfd, srcname );
+            goto ret;
+        }
+
+        if (unlinkat( dirfd, tmpname, 0 ))
+            file_set_error();
+    }
+    /* directories can't have hardlinks, so just rename it to the destination */
+    else if (renameat( dirfd, tmpname, dirfd, dstname ))
+        file_set_error();
+
+ret:
+    close( dirfd );
+}
+
 /* set new name for the fd */
 static void set_fd_name( struct fd *fd, struct fd *root, const char *nameptr, data_size_t len,
                          struct unicode_str nt_name, int create_link, unsigned int flags )
@@ -2560,6 +2661,11 @@ static void set_fd_name( struct fd *fd, struct fd *root, const char *nameptr, da
         set_error( STATUS_OBJECT_PATH_SYNTAX_BAD );
         return;
     }
+
+    /* strip trailing slashes */
+    while (len > 1 && nameptr[len - 1] == '/')
+        len--;
+
     if (!(name = mem_alloc( len + 1 ))) return;
     memcpy( name, nameptr, len );
     name[len] = 0;
@@ -2587,7 +2693,8 @@ static void set_fd_name( struct fd *fd, struct fd *root, const char *nameptr, da
     {
         if (!fstat( fd->unix_fd, &st2 ) && st.st_ino == st2.st_ino && st.st_dev == st2.st_dev)
         {
-            if (create_link && !replace) set_error( STATUS_OBJECT_NAME_COLLISION );
+            if (!create_link) rename_same_file( fd->unix_name, name, S_ISDIR( st.st_mode ) );
+            else if (!replace) set_error( STATUS_OBJECT_NAME_COLLISION );
             free( name );
             return;
         }