static ERL_NIF_TERM read_info_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
posix_errno_t posix_errno;
efile_fileinfo_t info = {0};
efile_path_t path;
int follow_links;
if(argc != 2 || !enif_get_int(env, argv[1], &follow_links)) {
return enif_make_badarg(env);
}
if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
return posix_error_to_tuple(env, posix_errno);
} else if((posix_errno = efile_read_info(&path, follow_links, &info))) {
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)
);
}
static ERL_NIF_TERM read_file_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
posix_errno_t posix_errno;
efile_fileinfo_t info = {0};
efile_path_t path;
efile_data_t *d;
ErlNifBinary result;
if(argc != 1) {
return enif_make_badarg(env);
}
if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
return posix_error_to_tuple(env, posix_errno);
} else if((posix_errno = efile_read_info(&path, 1, &info))) {
return posix_error_to_tuple(env, posix_errno);
} else if((posix_errno = efile_open(&path, EFILE_MODE_READ, efile_resource_type, &d))) {
return posix_error_to_tuple(env, posix_errno);
}
posix_errno = read_file(d, info.size, &result);
enif_release_resource(d);
if(posix_errno) {
return posix_error_to_tuple(env, posix_errno);
}
return enif_make_tuple2(env, am_ok, enif_make_binary(env, &result));
}
static ERL_NIF_TERM read_file_nif(ErlNifEnv *env, int argc, const ERL_NIF_TERM argv[]) {
posix_errno_t posix_errno, ignored;
efile_fileinfo_t info = {0};
efile_path_t path;
efile_data_t *d;
ErlNifBinary result;
ASSERT(argc == 1);
if((posix_errno = efile_marshal_path(env, argv[0], &path))) {
return posix_error_to_tuple(env, posix_errno);
} else if((posix_errno = efile_read_info(&path, 1, &info))) {
return posix_error_to_tuple(env, posix_errno);
} else if((posix_errno = efile_open(&path, EFILE_MODE_READ, efile_resource_type, &d))) {
return posix_error_to_tuple(env, posix_errno);
}
posix_errno = read_file(d, info.size, &result);
erts_atomic32_set_acqb(&d->state, EFILE_STATE_CLOSED);
efile_close(d, &ignored);
if(posix_errno) {
return posix_error_to_tuple(env, posix_errno);
}
return enif_make_tuple2(env, am_ok, enif_make_binary(env, &result));
}
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;
int is_link;
sys_memset(&native_file_info, 0, sizeof(native_file_info));
is_link = 0;
attributes = GetFileAttributesW((WCHAR*)path->data);
if(attributes == INVALID_FILE_ATTRIBUTES) {
DWORD last_error = GetLastError();
/* Querying a network share root fails with ERROR_BAD_NETPATH, so we'll
* fake it as a directory just like local roots. */
if(!is_path_root(path) || last_error != ERROR_BAD_NETPATH) {
return windows_to_posix_errno(last_error);
}
attributes = 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. */
} else {
HANDLE handle;
if(attributes & FILE_ATTRIBUTE_REPARSE_POINT) {
is_link = is_name_surrogate(path);
}
if(follow_links && is_link) {
posix_errno_t posix_errno;
efile_path_t resolved_path;
posix_errno = internal_read_link(path, &resolved_path);
if(posix_errno != 0) {
return posix_errno;
}
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);
}
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;
}
}
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;
return 0;
}
