file: allow read_file_info on file descriptors

6 files changed, 269 insertions, 124 deletions

diff --git a/erts/emulator/nifs/common/prim_file_nif.c b/erts/emulator/nifs/common/prim_file_nif.c
index 9e9a14844e..5c5e9a2d30 100644
--- a/erts/emulator/nifs/common/prim_file_nif.c
+++ b/erts/emulator/nifs/common/prim_file_nif.c
@@ -162,6 +162,7 @@ WRAP_FILE_HANDLE_EXPORT(allocate_nif)
 WRAP_FILE_HANDLE_EXPORT(advise_nif)
 WRAP_FILE_HANDLE_EXPORT(get_handle_nif)
 WRAP_FILE_HANDLE_EXPORT(ipread_s32bu_p32bu_nif)
+WRAP_FILE_HANDLE_EXPORT(read_handle_info_nif)
 
 static ErlNifFunc nif_funcs[] = {
     /* File handle ops */
@@ -176,6 +177,7 @@ static ErlNifFunc nif_funcs[] = {
     {"truncate_nif", 1, truncate_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
     {"allocate_nif", 3, allocate_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
     {"advise_nif", 4, advise_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
+    {"read_handle_info_nif", 1, read_handle_info_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
 
     /* Filesystem ops */
     {"make_hard_link_nif", 2, make_hard_link_nif, ERL_NIF_DIRTY_JOB_IO_BOUND},
@@ -896,6 +898,26 @@ static ERL_NIF_TERM get_handle_nif_impl(efile_data_t *d, ErlNifEnv *env, int arg
     return efile_get_handle(env, d);
 }
 
+static ERL_NIF_TERM build_file_info(ErlNifEnv *env, efile_fileinfo_t *info) {
+    /* #file_info as declared in file.hrl */
+    return enif_make_tuple(env, 14,
+        am_file_info,
+        enif_make_uint64(env, info->size),
+        efile_filetype_to_atom(info->type),
+        efile_access_to_atom(info->access),
+        enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info->a_time)),
+        enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info->m_time)),
+        enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info->c_time)),
+        enif_make_uint(env, info->mode),
+        enif_make_uint(env, info->links),
+        enif_make_uint(env, info->major_device),
+        enif_make_uint(env, info->minor_device),
+        enif_make_uint(env, info->inode),
+        enif_make_uint(env, info->uid),
+        enif_make_uint(env, info->gid)
+    );
+}
+
 static ERL_NIF_TERM read_info_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
     posix_errno_t posix_errno;
 
@@ -914,23 +936,20 @@ static ERL_NIF_TERM read_info_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM a
         return posix_error_to_tuple(env, posix_errno);
     }
 
-    /* #file_info as declared in file.hrl */
-    return enif_make_tuple(env, 14,
-        am_file_info,
-        enif_make_uint64(env, info.size),
-        efile_filetype_to_atom(info.type),
-        efile_access_to_atom(info.access),
-        enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info.a_time)),
-        enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info.m_time)),
-        enif_make_int64(env, MAX(EFILE_MIN_FILETIME, info.c_time)),
-        enif_make_uint(env, info.mode),
-        enif_make_uint(env, info.links),
-        enif_make_uint(env, info.major_device),
-        enif_make_uint(env, info.minor_device),
-        enif_make_uint(env, info.inode),
-        enif_make_uint(env, info.uid),
-        enif_make_uint(env, info.gid)
-    );
+    return build_file_info(env, &info);
+}
+
+static ERL_NIF_TERM read_handle_info_nif_impl(efile_data_t *d, ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
+    posix_errno_t posix_errno;
+    efile_fileinfo_t info = {0};
+
+    ASSERT(argc == 0);
+
+    if((posix_errno = efile_read_handle_info(d, &info))) {
+        return posix_error_to_tuple(env, posix_errno);
+    }
+
+    return build_file_info(env, &info);
 }
 
 static ERL_NIF_TERM set_permissions_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
diff --git a/erts/emulator/nifs/common/prim_file_nif.h b/erts/emulator/nifs/common/prim_file_nif.h
index 020714a03b..28c1ea9d00 100644
--- a/erts/emulator/nifs/common/prim_file_nif.h
+++ b/erts/emulator/nifs/common/prim_file_nif.h
@@ -170,6 +170,7 @@ int efile_close(efile_data_t *d, posix_errno_t *error);
 /* **** **** **** **** **** **** **** **** **** **** **** **** **** **** **** */
 
 posix_errno_t efile_read_info(const efile_path_t *path, int follow_link, efile_fileinfo_t *result);
+posix_errno_t efile_read_handle_info(efile_data_t *d, efile_fileinfo_t *result);
 
 /** @brief Sets the file times to the given values. Refer to efile_fileinfo_t
  * for a description of each. */
diff --git a/erts/emulator/nifs/unix/unix_prim_file.c b/erts/emulator/nifs/unix/unix_prim_file.c
index 20021b9358..176a9318b2 100644
--- a/erts/emulator/nifs/unix/unix_prim_file.c
+++ b/erts/emulator/nifs/unix/unix_prim_file.c
@@ -627,6 +627,33 @@ int efile_truncate(efile_data_t *d) {
     return 1;
 }
 
+static void build_file_info(struct stat *data, efile_fileinfo_t *result) {
+    if(S_ISCHR(data->st_mode) || S_ISBLK(data->st_mode)) {
+        result->type = EFILE_FILETYPE_DEVICE;
+    } else if(S_ISDIR(data->st_mode)) {
+        result->type = EFILE_FILETYPE_DIRECTORY;
+    } else if(S_ISREG(data->st_mode)) {
+        result->type = EFILE_FILETYPE_REGULAR;
+    } else if(S_ISLNK(data->st_mode)) {
+        result->type = EFILE_FILETYPE_SYMLINK;
+    } else {
+        result->type = EFILE_FILETYPE_OTHER;
+    }
+
+    result->a_time = (Sint64)data->st_atime;
+    result->m_time = (Sint64)data->st_mtime;
+    result->c_time = (Sint64)data->st_ctime;
+    result->size = data->st_size;
+
+    result->major_device = data->st_dev;
+    result->minor_device = data->st_rdev;
+    result->links = data->st_nlink;
+    result->inode = data->st_ino;
+    result->mode = data->st_mode;
+    result->uid = data->st_uid;
+    result->gid = data->st_gid;
+}
+
 posix_errno_t efile_read_info(const efile_path_t *path, int follow_links, efile_fileinfo_t *result) {
     struct stat data;
 
@@ -640,30 +667,7 @@ posix_errno_t efile_read_info(const efile_path_t *path, int follow_links, efile_
         }
     }
 
-    if(S_ISCHR(data.st_mode) || S_ISBLK(data.st_mode)) {
-        result->type = EFILE_FILETYPE_DEVICE;
-    } else if(S_ISDIR(data.st_mode)) {
-        result->type = EFILE_FILETYPE_DIRECTORY;
-    } else if(S_ISREG(data.st_mode)) {
-        result->type = EFILE_FILETYPE_REGULAR;
-    } else if(S_ISLNK(data.st_mode)) {
-        result->type = EFILE_FILETYPE_SYMLINK;
-    } else {
-        result->type = EFILE_FILETYPE_OTHER;
-    }
-
-    result->a_time = (Sint64)data.st_atime;
-    result->m_time = (Sint64)data.st_mtime;
-    result->c_time = (Sint64)data.st_ctime;
-    result->size = data.st_size;
-
-    result->major_device = data.st_dev;
-    result->minor_device = data.st_rdev;
-    result->links = data.st_nlink;
-    result->inode = data.st_ino;
-    result->mode = data.st_mode;
-    result->uid = data.st_uid;
-    result->gid = data.st_gid;
+    build_file_info(&data, result);
 
 #ifndef NO_ACCESS
     result->access = EFILE_ACCESS_NONE;
@@ -682,6 +686,56 @@ posix_errno_t efile_read_info(const efile_path_t *path, int follow_links, efile_
     return 0;
 }
 
+static int check_access(struct stat *st) {
+    int ret = EFILE_ACCESS_NONE;
+
+    if(st->st_uid == getuid()) {
+        if(st->st_mode & S_IRUSR) {
+            ret |= EFILE_ACCESS_READ;
+        }
+        if(st->st_mode & S_IWUSR) {
+            ret |= EFILE_ACCESS_WRITE;
+        }
+        return ret;
+    }
+
+    if(st->st_gid == getgid()) {
+        if(st->st_mode & S_IRGRP) {
+            ret |= EFILE_ACCESS_READ;
+        }
+        if(st->st_mode & S_IWGRP) {
+            ret |= EFILE_ACCESS_WRITE;
+        }
+        return ret;
+    }
+
+    if(st->st_mode & S_IROTH) {
+        ret |= EFILE_ACCESS_READ;
+    }
+    if(st->st_mode & S_IWOTH) {
+        ret |= EFILE_ACCESS_WRITE;
+    }
+    return ret;
+}
+
+posix_errno_t efile_read_handle_info(efile_data_t *d, efile_fileinfo_t *result) {
+    struct stat data;
+    efile_unix_t *u = (efile_unix_t*)d;
+
+#ifdef HAVE_FSTAT
+    if(fstat(u->fd, &data) < 0) {
+        return errno;
+    }
+
+    build_file_info(&data, result);
+    result->access = check_access(&data);
+
+    return 0;
+#else
+    return ENOTSUP;
+#endif
+}
+
 posix_errno_t efile_set_permissions(const efile_path_t *path, Uint32 permissions) {
     const mode_t MUTABLE_MODES = (S_ISUID | S_ISGID | S_IRWXU | S_IRWXG | S_IRWXO);
     mode_t new_modes = permissions & MUTABLE_MODES;
diff --git a/erts/emulator/nifs/win32/win_prim_file.c b/erts/emulator/nifs/win32/win_prim_file.c
index 13306104c0..839ac3ea6e 100644
--- a/erts/emulator/nifs/win32/win_prim_file.c
+++ b/erts/emulator/nifs/win32/win_prim_file.c
@@ -773,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;
@@ -792,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;
@@ -817,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;
 }
@@ -963,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;
     }
 
@@ -995,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);
@@ -1014,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);
 
@@ -1029,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)) {
diff --git a/erts/preloaded/ebin/prim_file.beam b/erts/preloaded/ebin/prim_file.beam
index a2c5f2f336..0152a6091f 100644
--- a/erts/preloaded/ebin/prim_file.beam
+++ b/erts/preloaded/ebin/prim_file.beam
diff --git a/erts/preloaded/src/prim_file.erl b/erts/preloaded/src/prim_file.erl
index 1aa5d85c64..1982424191 100644
--- a/erts/preloaded/src/prim_file.erl
+++ b/erts/preloaded/src/prim_file.erl
@@ -34,6 +34,7 @@
 -export([read_link/1, read_link_all/1,
          read_link_info/1, read_link_info/2,
          read_file_info/1, read_file_info/2,
+         read_handle_info/1, read_handle_info/2,
          write_file_info/2, write_file_info/3]).
 
 -export([list_dir/1, list_dir_all/1]).
@@ -497,6 +498,8 @@ get_handle_nif(_FileRef) ->
     erlang:nif_error(undef).
 delayed_close_nif(_FileRef) ->
     erlang:nif_error(undef).
+read_handle_info_nif(_FileRef) ->
+    erlang:nif_error(undef).
 
 %%
 %% Quality-of-life helpers
@@ -598,20 +601,37 @@ read_link_info(Name, Opts) ->
 read_info_1(Name, FollowLinks, TimeType) ->
     try
         case read_info_nif(encode_path(Name), FollowLinks) of
-            {error, Reason} ->
-                {error, Reason};
-            FileInfo ->
-                CTime = from_posix_seconds(FileInfo#file_info.ctime, TimeType),
-                MTime = from_posix_seconds(FileInfo#file_info.mtime, TimeType),
-                ATime = from_posix_seconds(FileInfo#file_info.atime, TimeType),
-                {ok, FileInfo#file_info{ ctime = CTime,
-                                         mtime = MTime,
-                                         atime = ATime }}
+            {error, Reason} -> {error, Reason};
+            FileInfo -> {ok, adjust_times(FileInfo, TimeType)}
+        end
+    catch
+        error:_ -> {error, badarg}
+    end.
+
+read_handle_info(Fd) ->
+  read_handle_info_1(Fd, local).
+read_handle_info(Fd, Opts) ->
+  read_handle_info_1(Fd, proplist_get_value(time, Opts, local)).
+
+read_handle_info_1(Fd, TimeType) ->
+    try
+        #{ handle := FRef } = get_fd_data(Fd),
+        case read_handle_info_nif(FRef) of
+            {error, Reason} -> {error, Reason};
+            FileInfo -> {ok, adjust_times(FileInfo, TimeType)}
         end
     catch
         error:_ -> {error, badarg}
     end.
 
+adjust_times(FileInfo, TimeType) ->
+    CTime = from_posix_seconds(FileInfo#file_info.ctime, TimeType),
+    MTime = from_posix_seconds(FileInfo#file_info.mtime, TimeType),
+    ATime = from_posix_seconds(FileInfo#file_info.atime, TimeType),
+    FileInfo#file_info{ ctime = CTime,
+                        mtime = MTime,
+                        atime = ATime }.
+
 write_file_info(Filename, Info) ->
     write_file_info_1(Filename, Info, local).
 write_file_info(Filename, Info, Opts) ->