1 files changed, 151 insertions, 78 deletions

diff --git a/erts/emulator/nifs/win32/win_prim_file.c b/erts/emulator/nifs/win32/win_prim_file.c
index e7d3924240..839ac3ea6e 100644
--- a/erts/emulator/nifs/win32/win_prim_file.c
+++ b/erts/emulator/nifs/win32/win_prim_file.c
@@ -270,6 +270,17 @@ static int normalize_path_result(ErlNifBinary *path) {
 }
 
 /* @brief Checks whether all the given attributes are set on the object at the
+ * given handle. Note that it assumes false on errors. */
+static int handle_has_file_attributes(HANDLE handle, DWORD mask) {
+    BY_HANDLE_FILE_INFORMATION native_file_info;
+    if(!GetFileInformationByHandle(handle, &native_file_info)) {
+        return 0;
+    }
+
+    return !!((native_file_info.dwFileAttributes & mask) == mask);
+}
+
+/* @brief Checks whether all the given attributes are set on the object at the
  * given path. Note that it assumes false on errors. */
 static int has_file_attributes(const efile_path_t *path, DWORD mask) {
     DWORD attributes = GetFileAttributesW((WCHAR*)path->data);
@@ -412,10 +423,15 @@ posix_errno_t efile_open(const efile_path_t *path, enum efile_modes_t modes,
 
     ASSERT_PATH_FORMAT(path);
 
+    attributes = 0;
     access_flags = 0;
     open_mode = 0;
 
-    if(modes & EFILE_MODE_READ && !(modes & EFILE_MODE_WRITE)) {
+    if(modes & EFILE_MODE_DIRECTORY) {
+        attributes = FILE_FLAG_BACKUP_SEMANTICS;
+        access_flags = GENERIC_READ;
+        open_mode = OPEN_EXISTING;
+    } else if(modes & EFILE_MODE_READ && !(modes & EFILE_MODE_WRITE)) {
         access_flags = GENERIC_READ;
         open_mode = OPEN_EXISTING;
     } else if(modes & EFILE_MODE_WRITE && !(modes & EFILE_MODE_READ)) {
@@ -438,9 +454,9 @@ posix_errno_t efile_open(const efile_path_t *path, enum efile_modes_t modes,
     }
 
     if(modes & EFILE_MODE_SYNC) {
-        attributes = FILE_FLAG_WRITE_THROUGH;
+        attributes |= FILE_FLAG_WRITE_THROUGH;
     } else {
-        attributes = FILE_ATTRIBUTE_NORMAL;
+        attributes |= FILE_ATTRIBUTE_NORMAL;
     }
 
     handle = CreateFileW((WCHAR*)path->data, access_flags,
@@ -449,6 +465,12 @@ posix_errno_t efile_open(const efile_path_t *path, enum efile_modes_t modes,
     if(handle != INVALID_HANDLE_VALUE) {
         efile_win_t *w;
 
+        /* Directory mode specified, but path is not a directory. */
+        if((modes & EFILE_MODE_DIRECTORY) && !handle_has_file_attributes(handle, FILE_ATTRIBUTE_DIRECTORY)) {
+            CloseHandle(handle);
+            return ENOTDIR;
+        }
+
         w = (efile_win_t*)enif_alloc_resource(nif_type, sizeof(efile_win_t));
         w->handle = handle;
 
@@ -461,7 +483,7 @@ posix_errno_t efile_open(const efile_path_t *path, enum efile_modes_t modes,
 
         /* Rewrite all failures on directories to EISDIR to match the old
          * driver. */
-        if(has_file_attributes(path, FILE_ATTRIBUTE_DIRECTORY)) {
+        if(!(modes & EFILE_MODE_DIRECTORY) && has_file_attributes(path, FILE_ATTRIBUTE_DIRECTORY)) {
             return EISDIR;
         }
 
@@ -751,6 +773,71 @@ static int is_name_surrogate(const efile_path_t *path) {
      return result;
 }
 
+static void build_file_info(BY_HANDLE_FILE_INFORMATION *native_file_info, const efile_path_t *path, int is_link, efile_fileinfo_t *result) {
+    DWORD attributes;
+
+    attributes = native_file_info->dwFileAttributes;
+
+    if(is_link) {
+        result->type = EFILE_FILETYPE_SYMLINK;
+        /* This should be _S_IFLNK, but the old driver always set
+         * non-directories to _S_IFREG. */
+        result->mode |= _S_IFREG;
+    } else if(attributes & FILE_ATTRIBUTE_DIRECTORY) {
+        result->type = EFILE_FILETYPE_DIRECTORY;
+        result->mode |= _S_IFDIR | _S_IEXEC;
+    } else {
+        if(is_executable_file(path)) {
+            result->mode |= _S_IEXEC;
+        }
+
+        result->type = EFILE_FILETYPE_REGULAR;
+        result->mode |= _S_IFREG;
+    }
+
+    if(!(attributes & FILE_ATTRIBUTE_READONLY)) {
+        result->access = EFILE_ACCESS_READ | EFILE_ACCESS_WRITE;
+        result->mode |= _S_IREAD | _S_IWRITE;
+    } else {
+        result->access = EFILE_ACCESS_READ;
+        result->mode |= _S_IREAD;
+    }
+
+    /* Propagate user mode-bits to group/other fields */
+    result->mode |= (result->mode & 0700) >> 3;
+    result->mode |= (result->mode & 0700) >> 6;
+
+    result->size =
+        ((Uint64)native_file_info->nFileSizeHigh << 32ull) |
+        (Uint64)native_file_info->nFileSizeLow;
+    result->links = MAX(1, native_file_info->nNumberOfLinks);
+
+    result->major_device = get_drive_number(path);
+    result->minor_device = 0;
+    result->inode = 0;
+    result->uid = 0;
+    result->gid = 0;
+}
+
+static void build_file_info_times(BY_HANDLE_FILE_INFORMATION *native_file_info, efile_fileinfo_t *result) {
+    FILETIME_TO_EPOCH(result->m_time, native_file_info->ftLastWriteTime);
+    FILETIME_TO_EPOCH(result->a_time, native_file_info->ftLastAccessTime);
+    FILETIME_TO_EPOCH(result->c_time, native_file_info->ftCreationTime);
+
+    if(result->m_time == -EPOCH_DIFFERENCE) {
+        /* Default to 1970 just like the old driver. */
+        result->m_time = 0;
+    }
+
+    if(result->a_time == -EPOCH_DIFFERENCE) {
+        result->a_time = result->m_time;
+    }
+
+    if(result->c_time == -EPOCH_DIFFERENCE) {
+        result->c_time = result->m_time;
+    }
+}
+
 posix_errno_t efile_read_info(const efile_path_t *path, int follow_links, efile_fileinfo_t *result) {
     BY_HANDLE_FILE_INFORMATION native_file_info;
     DWORD attributes;
@@ -770,23 +857,41 @@ posix_errno_t efile_read_info(const efile_path_t *path, int follow_links, efile_
             return windows_to_posix_errno(last_error);
         }
 
-        attributes = FILE_ATTRIBUTE_DIRECTORY;
+        native_file_info.dwFileAttributes = FILE_ATTRIBUTE_DIRECTORY;
     } else if(is_path_root(path)) {
         /* Local (or mounted) roots can be queried with GetFileAttributesW but
          * lack support for GetFileInformationByHandle, so we'll skip that
          * part. */
+        native_file_info.dwFileAttributes = attributes;
     } else {
         HANDLE handle;
+        DWORD last_error;
+        DWORD flags;
 
         if(attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
             is_link = is_name_surrogate(path);
         }
 
+        flags = FILE_FLAG_BACKUP_SEMANTICS;
+        if(!follow_links && is_link) {
+            flags |= FILE_FLAG_OPEN_REPARSE_POINT;
+        }
+
+        handle = CreateFileW((const WCHAR*)path->data, GENERIC_READ,
+            FILE_SHARE_FLAGS, NULL, OPEN_EXISTING, flags, NULL);
+        last_error = GetLastError();
+
+        if(handle == INVALID_HANDLE_VALUE) {
+            return windows_to_posix_errno(last_error);
+        }
+
         if(follow_links && is_link) {
             posix_errno_t posix_errno;
             efile_path_t resolved_path;
 
-            posix_errno = internal_read_link(path, &resolved_path);
+            posix_errno = internal_read_link(handle, &resolved_path);
+
+            CloseHandle(handle);
 
             if(posix_errno != 0) {
                 return posix_errno;
@@ -795,74 +900,43 @@ posix_errno_t efile_read_info(const efile_path_t *path, int follow_links, efile_
             return efile_read_info(&resolved_path, 0, result);
         }
 
-        handle = CreateFileW((const WCHAR*)path->data, GENERIC_READ,
-            FILE_SHARE_FLAGS, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS,
-            NULL);
-
-        /* The old driver never cared whether this succeeded. */
-        if(handle != INVALID_HANDLE_VALUE) {
-            GetFileInformationByHandle(handle, &native_file_info);
-            CloseHandle(handle);
-        }
+        GetFileInformationByHandle(handle, &native_file_info);
+        CloseHandle(handle);
 
-        FILETIME_TO_EPOCH(result->m_time, native_file_info.ftLastWriteTime);
-        FILETIME_TO_EPOCH(result->a_time, native_file_info.ftLastAccessTime);
-        FILETIME_TO_EPOCH(result->c_time, native_file_info.ftCreationTime);
+        build_file_info_times(&native_file_info, result);
+    }
 
-        if(result->m_time == -EPOCH_DIFFERENCE) {
-            /* Default to 1970 just like the old driver. */
-            result->m_time = 0;
-        }
+    build_file_info(&native_file_info, path, is_link, result);
 
-        if(result->a_time == -EPOCH_DIFFERENCE) {
-            result->a_time = result->m_time;
-        }
+    return 0;
+}
 
-        if(result->c_time == -EPOCH_DIFFERENCE) {
-            result->c_time = result->m_time;
-        }
-    }
+posix_errno_t efile_read_handle_info(efile_data_t *d, efile_fileinfo_t *result) {
+    efile_win_t *w = (efile_win_t*)d;
+    HANDLE handle;
+    BY_HANDLE_FILE_INFORMATION native_file_info;
+    posix_errno_t posix_errno;
+    efile_path_t path;
+    int length;
 
-    if(is_link) {
-        result->type = EFILE_FILETYPE_SYMLINK;
-        /* This should be _S_IFLNK, but the old driver always set
-         * non-directories to _S_IFREG. */
-        result->mode |= _S_IFREG;
-    } else if(attributes & FILE_ATTRIBUTE_DIRECTORY) {
-        result->type = EFILE_FILETYPE_DIRECTORY;
-        result->mode |= _S_IFDIR | _S_IEXEC;
-    } else {
-        if(is_executable_file(path)) {
-            result->mode |= _S_IEXEC;
-        }
+    sys_memset(&native_file_info, 0, sizeof(native_file_info));
 
-        result->type = EFILE_FILETYPE_REGULAR;
-        result->mode |= _S_IFREG;
+    posix_errno = internal_read_link(w->handle, &path);
+    if(posix_errno != 0) {
+        return posix_errno;
     }
 
-    if(!(attributes & FILE_ATTRIBUTE_READONLY)) {
-        result->access = EFILE_ACCESS_READ | EFILE_ACCESS_WRITE;
-        result->mode |= _S_IREAD | _S_IWRITE;
+    if(GetFileInformationByHandle(w->handle, &native_file_info)) {
+        build_file_info_times(&native_file_info, result);
+    } else if(is_path_root(&path)) {
+        /* GetFileInformationByHandle is not supported on path roots, so
+         * fall back to efile_read_info. */
+        return efile_read_info(&path, 0, result);
     } else {
-        result->access = EFILE_ACCESS_READ;
-        result->mode |= _S_IREAD;
+        return windows_to_posix_errno(GetLastError());
     }
 
-    /* Propagate user mode-bits to group/other fields */
-    result->mode |= (result->mode & 0700) >> 3;
-    result->mode |= (result->mode & 0700) >> 6;
-
-    result->size =
-        ((Uint64)native_file_info.nFileSizeHigh << 32ull) |
-        (Uint64)native_file_info.nFileSizeLow;
-
-    result->links = MAX(1, native_file_info.nNumberOfLinks);
-
-    result->major_device = get_drive_number(path);
-    result->minor_device = 0;
-    result->inode = 0;
-    result->uid = 0;
-    result->gid = 0;
+    build_file_info(&native_file_info, &path, 0, result);
 
     return 0;
 }
@@ -941,31 +1015,20 @@ posix_errno_t efile_set_time(const efile_path_t *path, Sint64 a_time, Sint64 m_t
     return windows_to_posix_errno(last_error);
 }
 
-static posix_errno_t internal_read_link(const efile_path_t *path, efile_path_t *result) {
+static posix_errno_t internal_read_link(HANDLE link_handle, efile_path_t *result) {
     DWORD required_length, actual_length;
-    HANDLE link_handle;
     DWORD last_error;
 
-    link_handle = CreateFileW((WCHAR*)path->data, GENERIC_READ,
-        FILE_SHARE_FLAGS, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL);
-    last_error = GetLastError();
-
-    if(link_handle == INVALID_HANDLE_VALUE) {
-        return windows_to_posix_errno(last_error);
-    }
-
     required_length = GetFinalPathNameByHandleW(link_handle, NULL, 0, 0);
     last_error = GetLastError();
 
     if(required_length <= 0) {
-        CloseHandle(link_handle);
         return windows_to_posix_errno(last_error);
     }
 
     /* Unlike many other path functions (eg. GetFullPathNameW), this one
      * includes the NUL terminator in its required length. */
     if(!enif_alloc_binary(required_length * sizeof(WCHAR), result)) {
-        CloseHandle(link_handle);
         return ENOMEM;
     }
 
@@ -973,8 +1036,6 @@ static posix_errno_t internal_read_link(const efile_path_t *path, efile_path_t *
         (WCHAR*)result->data, required_length, 0);
     last_error = GetLastError();
 
-    CloseHandle(link_handle);
-
     if(actual_length == 0 || actual_length >= required_length) {
         enif_release_binary(result);
         return windows_to_posix_errno(last_error);
@@ -992,6 +1053,8 @@ posix_errno_t efile_read_link(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_
     posix_errno_t posix_errno;
     ErlNifBinary result_bin;
     DWORD attributes;
+    HANDLE handle;
+    DWORD last_error;
 
     ASSERT_PATH_FORMAT(path);
 
@@ -1007,7 +1070,17 @@ posix_errno_t efile_read_link(ErlNifEnv *env, const efile_path_t *path, ERL_NIF_
         return EINVAL;
     }
 
-    posix_errno = internal_read_link(path, &result_bin);
+    handle = CreateFileW((WCHAR*)path->data, GENERIC_READ,
+        FILE_SHARE_FLAGS, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS,
+        NULL);
+    last_error = GetLastError();
+
+    if(handle == INVALID_HANDLE_VALUE) {
+        return windows_to_posix_errno(last_error);
+    }
+    posix_errno = internal_read_link(handle, &result_bin);
+
+    CloseHandle(handle);
 
     if(posix_errno == 0) {
         if(!normalize_path_result(&result_bin)) {