../deps/uvwasi/src/uvwasi.c

Bug Summary

File:	out/../deps/uvwasi/src/uvwasi.c
Warning:	line 93, column 20 The left operand of '/' is a garbage value
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name uvwasi.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -pic-is-pie -mframe-pointer=all -fmath-errno -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/home/maurizio/node-v18.6.0/out -resource-dir /usr/local/lib/clang/16.0.0 -D V8_DEPRECATION_WARNINGS -D V8_IMMINENT_DEPRECATION_WARNINGS -D _GLIBCXX_USE_CXX11_ABI=1 -D NODE_OPENSSL_CONF_NAME=nodejs_conf -D NODE_OPENSSL_HAS_QUIC -D __STDC_FORMAT_MACROS -D OPENSSL_NO_PINSHARED -D OPENSSL_THREADS -D _GNU_SOURCE -D _POSIX_C_SOURCE=200112 -D _LARGEFILE_SOURCE -D _FILE_OFFSET_BITS=64 -I ../deps/uvwasi/include -I ../deps/uv/include -internal-isystem /usr/local/lib/clang/16.0.0/include -internal-isystem /usr/local/include -internal-isystem /usr/lib/gcc/x86_64-redhat-linux/8/../../../../x86_64-redhat-linux/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O3 -Wno-unused-parameter -fdebug-compilation-dir=/home/maurizio/node-v18.6.0/out -ferror-limit 19 -fvisibility hidden -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /tmp/scan-build-2022-08-22-142216-507842-1 -x c ../deps/uvwasi/src/uvwasi.c
1#include <stdlib.h>
2#include <string.h>

4#ifndef _WIN32
5# include <sched.h>
6# include <sys/types.h>
7# include <unistd.h>
8# include <dirent.h>
9# include <time.h>
10#else
11# include <io.h>
12#endif /* _WIN32 */

14#define UVWASI__READDIR_NUM_ENTRIES1 1

16#if !defined(_WIN32) && !defined(__ANDROID__)
17# define UVWASI_FD_READDIR_SUPPORTED1 1
18#endif

20#include "uvwasi.h"
21#include "uvwasi_alloc.h"
22#include "uv.h"
23#include "uv_mapping.h"
24#include "fd_table.h"
25#include "clocks.h"
26#include "path_resolver.h"
27#include "poll_oneoff.h"
28#include "wasi_rights.h"
29#include "wasi_serdes.h"
30#include "debug.h"

32/* IBMi PASE does not support posix_fadvise() */
33#ifdef __PASE__
34# undef POSIX_FADV_NORMAL0
35#endif

37#define VALIDATE_FSTFLAGS_OR_RETURN(flags)do { if ((flags) & ~((1 << 0) | (1 << 1) | (1
 << 2) | (1 << 3))) { return 28; } } while (0)                                    \
do {                                                                        \
  if ((flags) & ~(UVWASI_FILESTAT_SET_ATIM(1 << 0) |                                \
                  UVWASI_FILESTAT_SET_ATIM_NOW(1 << 1) |                            \
                  UVWASI_FILESTAT_SET_MTIM(1 << 2) |                                \
                  UVWASI_FILESTAT_SET_MTIM_NOW(1 << 3))) {                          \
    return UVWASI_EINVAL28;                                                   \
  }                                                                         \
} while (0)

47static uvwasi_errno_t uvwasi__get_filestat_set_times(
                                                  uvwasi_timestamp_t* st_atim,
                                                  uvwasi_timestamp_t* st_mtim,
                                                  uvwasi_fstflags_t fst_flags,
                                                  uv_file* fd,
                                                  char* path
                                                ) {
uvwasi_filestat_t stat;
uvwasi_timestamp_t now;
9
←
'now' declared without an initial value→
uvwasi_errno_t err;
uv_fs_t req;
int r;

/* Check if either value requires the current time. */
if ((fst_flags &
10
←
Assuming the condition is false→
    (UVWASI_FILESTAT_SET_ATIM_NOW(1 << 1) | UVWASI_FILESTAT_SET_MTIM_NOW(1 << 3))) != 0) {
  err = uvwasi__clock_gettime_realtime(&now);
  if (err != UVWASI_ESUCCESS0)
    return err;
}

/* Check if either value is omitted. libuv doesn't have an 'omitted' option,
   so get the current stats for the file. This approach isn't perfect, but it
   will do until libuv can get better support here. */
if ((fst_flags &
11
←
Assuming the condition is false→
13
←
Taking false branch→
     (UVWASI_FILESTAT_SET_ATIM(1 << 0) | UVWASI_FILESTAT_SET_ATIM_NOW(1 << 1))) == 0 ||
    (fst_flags &
12
←
Assuming the condition is false→
     (UVWASI_FILESTAT_SET_MTIM(1 << 2) | UVWASI_FILESTAT_SET_MTIM_NOW(1 << 3))) == 0) {

  if (fd != NULL((void*)0))
    r = uv_fs_fstat(NULL((void*)0), &req, *fd, NULL((void*)0));
  else
    r = uv_fs_lstat(NULL((void*)0), &req, path, NULL((void*)0));

  if (r != 0) {
    uv_fs_req_cleanup(&req);
    return uvwasi__translate_uv_error(r);
  }

  uvwasi__stat_to_filestat(&req.statbuf, &stat);
  uv_fs_req_cleanup(&req);
}

/* Choose the provided time or 'now' and convert WASI timestamps from
   nanoseconds to seconds due to libuv. */
if ((fst_flags & UVWASI_FILESTAT_SET_ATIM_NOW(1 << 1)) != 0)
14
←
Assuming the condition is true→
15
←
Taking true branch→
  *st_atim = now / NANOS_PER_SEC1000000000;
16
←
The left operand of '/' is a garbage value
else if ((fst_flags & UVWASI_FILESTAT_SET_ATIM(1 << 0)) != 0)
  *st_atim = *st_atim / NANOS_PER_SEC1000000000;
else
  *st_atim = stat.st_atim / NANOS_PER_SEC1000000000;

if ((fst_flags & UVWASI_FILESTAT_SET_MTIM_NOW(1 << 3)) != 0)
  *st_mtim = now / NANOS_PER_SEC1000000000;
else if ((fst_flags & UVWASI_FILESTAT_SET_MTIM(1 << 2)) != 0)
  *st_mtim = *st_mtim / NANOS_PER_SEC1000000000;
else
  *st_mtim = stat.st_mtim / NANOS_PER_SEC1000000000;

return UVWASI_ESUCCESS0;
107}

109static void* default_malloc(size_t size, void* mem_user_data) {
return malloc(size);
111}

113static void default_free(void* ptr, void* mem_user_data) {
free(ptr);
115}

117static void* default_calloc(size_t nmemb, size_t size, void* mem_user_data) {
return calloc(nmemb, size);
119}

121static void* default_realloc(void* ptr, size_t size, void* mem_user_data) {
return realloc(ptr, size);
123}

125void* uvwasi__malloc(const uvwasi_t* uvwasi, size_t size) {
return uvwasi->allocator->malloc(size, uvwasi->allocator->mem_user_data);
127}

129void uvwasi__free(const uvwasi_t* uvwasi, void* ptr) {
if (ptr == NULL((void*)0))
  return;

uvwasi->allocator->free(ptr, uvwasi->allocator->mem_user_data);
134}

136void* uvwasi__calloc(const uvwasi_t* uvwasi, size_t nmemb, size_t size) {
return uvwasi->allocator->calloc(nmemb,
                                 size,
                                 uvwasi->allocator->mem_user_data);
140}

142void* uvwasi__realloc(const uvwasi_t* uvwasi, void* ptr, size_t size) {
return uvwasi->allocator->realloc(ptr,
                                  size,
                                  uvwasi->allocator->mem_user_data);
146}

148static const uvwasi_mem_t default_allocator = {
NULL((void*)0),
default_malloc,
default_free,
default_calloc,
default_realloc,
154};


157static uvwasi_errno_t uvwasi__lseek(uv_file fd,
                                  uvwasi_filedelta_t offset,
                                  uvwasi_whence_t whence,
                                  uvwasi_filesize_t* newoffset) {
int real_whence;

if (whence == UVWASI_WHENCE_CUR1)
  real_whence = SEEK_CUR1;
else if (whence == UVWASI_WHENCE_END2)
  real_whence = SEEK_END2;
else if (whence == UVWASI_WHENCE_SET0)
  real_whence = SEEK_SET0;
else
  return UVWASI_EINVAL28;

172#ifdef _WIN32
int64_t r;

r = _lseeki64(fd, offset, real_whence);
if (-1L == r)
  return uvwasi__translate_uv_error(uv_translate_sys_error(errno(*__errno_location ())));
178#else
off_t r;

r = lseek(fd, offset, real_whence);
if ((off_t) -1 == r)
  return uvwasi__translate_uv_error(uv_translate_sys_error(errno(*__errno_location ())));
184#endif /* _WIN32 */

*newoffset = r;
return UVWASI_ESUCCESS0;
188}


191static uvwasi_errno_t uvwasi__setup_iovs(const uvwasi_t* uvwasi,
                                       uv_buf_t** buffers,
                                       const uvwasi_iovec_t* iovs,
                                       uvwasi_size_t iovs_len) {
uv_buf_t* bufs;
uvwasi_size_t i;

if ((iovs_len * sizeof(*bufs)) / (sizeof(*bufs)) != iovs_len)
  return UVWASI_ENOMEM48;

bufs = uvwasi__malloc(uvwasi, iovs_len * sizeof(*bufs));
if (bufs == NULL((void*)0))
  return UVWASI_ENOMEM48;

for (i = 0; i < iovs_len; ++i)
  bufs[i] = uv_buf_init(iovs[i].buf, iovs[i].buf_len);

*buffers = bufs;
return UVWASI_ESUCCESS0;
210}


213static uvwasi_errno_t uvwasi__setup_ciovs(const uvwasi_t* uvwasi,
                                        uv_buf_t** buffers,
                                        const uvwasi_ciovec_t* iovs,
                                        uvwasi_size_t iovs_len) {
uv_buf_t* bufs;
uvwasi_size_t i;

if ((iovs_len * sizeof(*bufs)) / (sizeof(*bufs)) != iovs_len)
  return UVWASI_ENOMEM48;

bufs = uvwasi__malloc(uvwasi, iovs_len * sizeof(*bufs));
if (bufs == NULL((void*)0))
  return UVWASI_ENOMEM48;

for (i = 0; i < iovs_len; ++i)
  bufs[i] = uv_buf_init((char*)iovs[i].buf, iovs[i].buf_len);

*buffers = bufs;
return UVWASI_ESUCCESS0;
232}


235uvwasi_errno_t uvwasi_init(uvwasi_t* uvwasi, const uvwasi_options_t* options) {
uv_fs_t realpath_req;
uv_fs_t open_req;
uvwasi_errno_t err;
uvwasi_size_t args_size;
uvwasi_size_t size;
uvwasi_size_t offset;
uvwasi_size_t env_count;
uvwasi_size_t env_buf_size;
uvwasi_size_t i;
int r;

if (uvwasi == NULL((void*)0) || options == NULL((void*)0) || options->fd_table_size == 0)
  return UVWASI_EINVAL28;

uvwasi->allocator = options->allocator;
if (uvwasi->allocator == NULL((void*)0))
  uvwasi->allocator = &default_allocator;

uvwasi->argv_buf = NULL((void*)0);
uvwasi->argv = NULL((void*)0);
uvwasi->env_buf = NULL((void*)0);
uvwasi->env = NULL((void*)0);
uvwasi->fds = NULL((void*)0);

args_size = 0;
for (i = 0; i < options->argc; ++i)
  args_size += strlen(options->argv[i]) + 1;

uvwasi->argc = options->argc;
uvwasi->argv_buf_size = args_size;

if (args_size > 0) {
  uvwasi->argv_buf = uvwasi__malloc(uvwasi, args_size);
  if (uvwasi->argv_buf == NULL((void*)0)) {
    err = UVWASI_ENOMEM48;
    goto exit;
  }

  uvwasi->argv = uvwasi__calloc(uvwasi, options->argc, sizeof(char*));
  if (uvwasi->argv == NULL((void*)0)) {
    err = UVWASI_ENOMEM48;
    goto exit;
  }

  offset = 0;
  for (i = 0; i < options->argc; ++i) {
    size = strlen(options->argv[i]) + 1;
    memcpy(uvwasi->argv_buf + offset, options->argv[i], size);
    uvwasi->argv[i] = uvwasi->argv_buf + offset;
    offset += size;
  }
}

env_count = 0;
env_buf_size = 0;
if (options->envp != NULL((void*)0)) {
  while (options->envp[env_count] != NULL((void*)0)) {
    env_buf_size += strlen(options->envp[env_count]) + 1;
    env_count++;
  }
}

uvwasi->envc = env_count;
uvwasi->env_buf_size = env_buf_size;

if (env_buf_size > 0) {
  uvwasi->env_buf = uvwasi__malloc(uvwasi, env_buf_size);
  if (uvwasi->env_buf == NULL((void*)0)) {
    err = UVWASI_ENOMEM48;
    goto exit;
  }

  uvwasi->env = uvwasi__calloc(uvwasi, env_count, sizeof(char*));
  if (uvwasi->env == NULL((void*)0)) {
    err = UVWASI_ENOMEM48;
    goto exit;
  }

  offset = 0;
  for (i = 0; i < env_count; ++i) {
    size = strlen(options->envp[i]) + 1;
    memcpy(uvwasi->env_buf + offset, options->envp[i], size);
    uvwasi->env[i] = uvwasi->env_buf + offset;
    offset += size;
  }
}

for (i = 0; i < options->preopenc; ++i) {
  if (options->preopens[i].real_path == NULL((void*)0) ||
      options->preopens[i].mapped_path == NULL((void*)0)) {
    err = UVWASI_EINVAL28;
    goto exit;
  }
}

err = uvwasi_fd_table_init(uvwasi, options);
if (err != UVWASI_ESUCCESS0)
  goto exit;

for (i = 0; i < options->preopenc; ++i) {
  r = uv_fs_realpath(NULL((void*)0),
                     &realpath_req,
                     options->preopens[i].real_path,
                     NULL((void*)0));
  if (r != 0) {
    err = uvwasi__translate_uv_error(r);
    uv_fs_req_cleanup(&realpath_req);
    goto exit;
  }

  r = uv_fs_open(NULL((void*)0), &open_req, realpath_req.ptr, 0, 0666, NULL((void*)0));
  if (r < 0) {
    err = uvwasi__translate_uv_error(r);
    uv_fs_req_cleanup(&realpath_req);
    uv_fs_req_cleanup(&open_req);
    goto exit;
  }

  err = uvwasi_fd_table_insert_preopen(uvwasi,
                                       uvwasi->fds,
                                       open_req.result,
                                       options->preopens[i].mapped_path,
                                       realpath_req.ptr);
  uv_fs_req_cleanup(&realpath_req);
  uv_fs_req_cleanup(&open_req);

  if (err != UVWASI_ESUCCESS0)
    goto exit;
}

return UVWASI_ESUCCESS0;

368exit:
uvwasi_destroy(uvwasi);
return err;
371}


374void uvwasi_destroy(uvwasi_t* uvwasi) {
if (uvwasi == NULL((void*)0))
  return;

uvwasi_fd_table_free(uvwasi, uvwasi->fds);
uvwasi__free(uvwasi, uvwasi->argv_buf);
uvwasi__free(uvwasi, uvwasi->argv);
uvwasi__free(uvwasi, uvwasi->env_buf);
uvwasi__free(uvwasi, uvwasi->env);
uvwasi->fds = NULL((void*)0);
uvwasi->argv_buf = NULL((void*)0);
uvwasi->argv = NULL((void*)0);
uvwasi->env_buf = NULL((void*)0);
uvwasi->env = NULL((void*)0);
388}


391void uvwasi_options_init(uvwasi_options_t* options) {
if (options == NULL((void*)0))
  return;

options->in = 0;
options->out = 1;
options->err = 2;
options->fd_table_size = 3;
options->argc = 0;
options->argv = NULL((void*)0);
options->envp = NULL((void*)0);
options->preopenc = 0;
options->preopens = NULL((void*)0);
options->allocator = NULL((void*)0);
405}


408uvwasi_errno_t uvwasi_embedder_remap_fd(uvwasi_t* uvwasi,
                                      const uvwasi_fd_t fd,
                                      uv_file new_host_fd) {
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds, fd, &wrap, 0, 0);
if (err != UVWASI_ESUCCESS0)
  return err;

wrap->fd = new_host_fd;
uv_mutex_unlock(&wrap->mutex);
return UVWASI_ESUCCESS0;
424}


427uvwasi_errno_t uvwasi_args_get(uvwasi_t* uvwasi, char** argv, char* argv_buf) {
uvwasi_size_t i;

UVWASI_DEBUG("uvwasi_args_get(uvwasi=%p, argv=%p, argv_buf=%p)\n",
             uvwasi,
             argv,
             argv_buf);

if (uvwasi == NULL((void*)0) || argv == NULL((void*)0) || argv_buf == NULL((void*)0))
  return UVWASI_EINVAL28;

for (i = 0; i < uvwasi->argc; ++i) {
  argv[i] = argv_buf + (uvwasi->argv[i] - uvwasi->argv_buf);
}

memcpy(argv_buf, uvwasi->argv_buf, uvwasi->argv_buf_size);
return UVWASI_ESUCCESS0;
444}


447uvwasi_errno_t uvwasi_args_sizes_get(uvwasi_t* uvwasi,
                                   uvwasi_size_t* argc,
                                   uvwasi_size_t* argv_buf_size) {
UVWASI_DEBUG("uvwasi_args_sizes_get(uvwasi=%p, argc=%p, argv_buf_size=%p)\n",
             uvwasi,
             argc,
             argv_buf_size);

if (uvwasi == NULL((void*)0) || argc == NULL((void*)0) || argv_buf_size == NULL((void*)0))
  return UVWASI_EINVAL28;

*argc = uvwasi->argc;
*argv_buf_size = uvwasi->argv_buf_size;
return UVWASI_ESUCCESS0;
461}


464uvwasi_errno_t uvwasi_clock_res_get(uvwasi_t* uvwasi,
                                  uvwasi_clockid_t clock_id,
                                  uvwasi_timestamp_t* resolution) {
UVWASI_DEBUG("uvwasi_clock_res_get(uvwasi=%p, clock_id=%d, resolution=%p)\n",
             uvwasi,
             clock_id,
             resolution);

if (uvwasi == NULL((void*)0) || resolution == NULL((void*)0))
  return UVWASI_EINVAL28;

switch (clock_id) {
  case UVWASI_CLOCK_MONOTONIC1:
  case UVWASI_CLOCK_REALTIME0:
    *resolution = 1;  /* Nanosecond precision. */
    return UVWASI_ESUCCESS0;
  case UVWASI_CLOCK_PROCESS_CPUTIME_ID2:
    return uvwasi__clock_getres_process_cputime(resolution);
  case UVWASI_CLOCK_THREAD_CPUTIME_ID3:
    return uvwasi__clock_getres_thread_cputime(resolution);
  default:
    return UVWASI_EINVAL28;
}
487}


490uvwasi_errno_t uvwasi_clock_time_get(uvwasi_t* uvwasi,
                                   uvwasi_clockid_t clock_id,
                                   uvwasi_timestamp_t precision,
                                   uvwasi_timestamp_t* time) {
UVWASI_DEBUG("uvwasi_clock_time_get(uvwasi=%p, clock_id=%d, "
             "precision=%"PRIu64", time=%p)\n",
             uvwasi,
             clock_id,
             precision,
             time);

if (uvwasi == NULL((void*)0) || time == NULL((void*)0))
  return UVWASI_EINVAL28;

switch (clock_id) {
  case UVWASI_CLOCK_MONOTONIC1:
    *time = uv_hrtime();
    return UVWASI_ESUCCESS0;
  case UVWASI_CLOCK_REALTIME0:
    return uvwasi__clock_gettime_realtime(time);
  case UVWASI_CLOCK_PROCESS_CPUTIME_ID2:
    return uvwasi__clock_gettime_process_cputime(time);
  case UVWASI_CLOCK_THREAD_CPUTIME_ID3:
    return uvwasi__clock_gettime_thread_cputime(time);
  default:
    return UVWASI_EINVAL28;
}
517}


520uvwasi_errno_t uvwasi_environ_get(uvwasi_t* uvwasi,
                                char** environment,
                                char* environ_buf) {
uvwasi_size_t i;

UVWASI_DEBUG("uvwasi_environ_get(uvwasi=%p, environment=%p, "
             "environ_buf=%p)\n",
             uvwasi,
             environment,
             environ_buf);

if (uvwasi == NULL((void*)0) || environment == NULL((void*)0) || environ_buf == NULL((void*)0))
  return UVWASI_EINVAL28;

for (i = 0; i < uvwasi->envc; ++i) {
  environment[i] = environ_buf + (uvwasi->env[i] - uvwasi->env_buf);
}

memcpy(environ_buf, uvwasi->env_buf, uvwasi->env_buf_size);
return UVWASI_ESUCCESS0;
540}


543uvwasi_errno_t uvwasi_environ_sizes_get(uvwasi_t* uvwasi,
                                      uvwasi_size_t* environ_count,
                                      uvwasi_size_t* environ_buf_size) {
UVWASI_DEBUG("uvwasi_environ_sizes_get(uvwasi=%p, environ_count=%p, "
             "environ_buf_size=%p)\n",
             uvwasi,
             environ_count,
             environ_buf_size);

if (uvwasi == NULL((void*)0) || environ_count == NULL((void*)0) || environ_buf_size == NULL((void*)0))
  return UVWASI_EINVAL28;

*environ_count = uvwasi->envc;
*environ_buf_size = uvwasi->env_buf_size;
return UVWASI_ESUCCESS0;
558}


561uvwasi_errno_t uvwasi_fd_advise(uvwasi_t* uvwasi,
                              uvwasi_fd_t fd,
                              uvwasi_filesize_t offset,
                              uvwasi_filesize_t len,
                              uvwasi_advice_t advice) {
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;
568#ifdef POSIX_FADV_NORMAL0
int mapped_advice;
int r;
571#endif /* POSIX_FADV_NORMAL */

UVWASI_DEBUG("uvwasi_fd_advise(uvwasi=%p, fd=%d, offset=%"PRIu64", "
             "len=%"PRIu64", advice=%d)\n",
             uvwasi,
             fd,
             offset,
             len,
             advice);

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

switch (advice) {
  case UVWASI_ADVICE_DONTNEED4:
586#ifdef POSIX_FADV_NORMAL0
    mapped_advice = POSIX_FADV_DONTNEED4;
588#endif /* POSIX_FADV_NORMAL */
    break;
  case UVWASI_ADVICE_NOREUSE5:
591#ifdef POSIX_FADV_NORMAL0
    mapped_advice = POSIX_FADV_NOREUSE5;
593#endif /* POSIX_FADV_NORMAL */
    break;
  case UVWASI_ADVICE_NORMAL0:
596#ifdef POSIX_FADV_NORMAL0
    mapped_advice = POSIX_FADV_NORMAL0;
598#endif /* POSIX_FADV_NORMAL */
    break;
  case UVWASI_ADVICE_RANDOM2:
601#ifdef POSIX_FADV_NORMAL0
    mapped_advice = POSIX_FADV_RANDOM1;
603#endif /* POSIX_FADV_NORMAL */
    break;
  case UVWASI_ADVICE_SEQUENTIAL1:
606#ifdef POSIX_FADV_NORMAL0
    mapped_advice = POSIX_FADV_SEQUENTIAL2;
608#endif /* POSIX_FADV_NORMAL */
    break;
  case UVWASI_ADVICE_WILLNEED3:
611#ifdef POSIX_FADV_NORMAL0
    mapped_advice = POSIX_FADV_WILLNEED3;
613#endif /* POSIX_FADV_NORMAL */
    break;
  default:
    return UVWASI_EINVAL28;
}

err = uvwasi_fd_table_get(uvwasi->fds, fd, &wrap, UVWASI_RIGHT_FD_ADVISE(1 << 7), 0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = UVWASI_ESUCCESS0;

625#ifdef POSIX_FADV_NORMAL0
r = posix_fadvise(wrap->fd, offset, len, mapped_advice);
if (r != 0)
  err = uvwasi__translate_uv_error(uv_translate_sys_error(r));
629#endif /* POSIX_FADV_NORMAL */
uv_mutex_unlock(&wrap->mutex);
return err;
632}


635uvwasi_errno_t uvwasi_fd_allocate(uvwasi_t* uvwasi,
                                uvwasi_fd_t fd,
                                uvwasi_filesize_t offset,
                                uvwasi_filesize_t len) {
639#if !defined(__POSIX__)
uv_fs_t req;
uint64_t st_size;
642#endif /* !__POSIX__ */
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;
int r;

UVWASI_DEBUG("uvwasi_fd_allocate(uvwasi=%p, fd=%d, offset=%"PRIu64", "
             "len=%"PRIu64")\n",
             uvwasi,
             fd,
             offset,
             len);

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_FD_ALLOCATE(1 << 8),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

/* Try to use posix_fallocate(). If that's not an option, fall back to the
   race condition prone combination of fstat() + ftruncate(). */
667#if defined(__POSIX__)
r = posix_fallocate(wrap->fd, offset, len);
if (r != 0) {
  err = uvwasi__translate_uv_error(uv_translate_sys_error(r));
  goto exit;
}
673#else
r = uv_fs_fstat(NULL((void*)0), &req, wrap->fd, NULL((void*)0));
st_size = req.statbuf.st_size;
uv_fs_req_cleanup(&req);
if (r != 0) {
  err = uvwasi__translate_uv_error(r);
  goto exit;
}

if (st_size < offset + len) {
  r = uv_fs_ftruncate(NULL((void*)0), &req, wrap->fd, offset + len, NULL((void*)0));
  if (r != 0) {
    err = uvwasi__translate_uv_error(r);
    goto exit;
  }
}
689#endif /* __POSIX__ */

err = UVWASI_ESUCCESS0;
692exit:
uv_mutex_unlock(&wrap->mutex);
return err;
695}


698uvwasi_errno_t uvwasi_fd_close(uvwasi_t* uvwasi, uvwasi_fd_t fd) {
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;
uv_fs_t req;
int r;

UVWASI_DEBUG("uvwasi_fd_close(uvwasi=%p, fd=%d)\n", uvwasi, fd);

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

uvwasi_fd_table_lock(uvwasi->fds);

err = uvwasi_fd_table_get_nolock(uvwasi->fds, fd, &wrap, 0, 0);
if (err != UVWASI_ESUCCESS0)
  goto exit;

r = uv_fs_close(NULL((void*)0), &req, wrap->fd, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uv_fs_req_cleanup(&req);

if (r != 0) {
  err = uvwasi__translate_uv_error(r);
  goto exit;
}

err = uvwasi_fd_table_remove_nolock(uvwasi, uvwasi->fds, fd);

726exit:
uvwasi_fd_table_unlock(uvwasi->fds);
return err;
729}


732uvwasi_errno_t uvwasi_fd_datasync(uvwasi_t* uvwasi, uvwasi_fd_t fd) {
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;
uv_fs_t req;
int r;

UVWASI_DEBUG("uvwasi_fd_datasync(uvwasi=%p, fd=%d)\n", uvwasi, fd);

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_FD_DATASYNC(1 << 0),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

r = uv_fs_fdatasync(NULL((void*)0), &req, wrap->fd, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uv_fs_req_cleanup(&req);

if (r != 0)
  return uvwasi__translate_uv_error(r);

return UVWASI_ESUCCESS0;
759}


762uvwasi_errno_t uvwasi_fd_fdstat_get(uvwasi_t* uvwasi,
                                  uvwasi_fd_t fd,
                                  uvwasi_fdstat_t* buf) {
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;
767#ifndef _WIN32
int r;
769#endif

UVWASI_DEBUG("uvwasi_fd_fdstat_get(uvwasi=%p, fd=%d, buf=%p)\n",
             uvwasi,
             fd,
             buf);

if (uvwasi == NULL((void*)0) || buf == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds, fd, &wrap, 0, 0);
if (err != UVWASI_ESUCCESS0)
  return err;

buf->fs_filetype = wrap->type;
buf->fs_rights_base = wrap->rights_base;
buf->fs_rights_inheriting = wrap->rights_inheriting;
786#ifdef _WIN32
buf->fs_flags = 0;  /* TODO(cjihrig): Missing Windows support. */
788#else
r = fcntl(wrap->fd, F_GETFL3);
if (r < 0) {
  err = uvwasi__translate_uv_error(uv_translate_sys_error(errno(*__errno_location ())));
  uv_mutex_unlock(&wrap->mutex);
  return err;
}
buf->fs_flags = r;
796#endif /* _WIN32 */

uv_mutex_unlock(&wrap->mutex);
return UVWASI_ESUCCESS0;
800}


803uvwasi_errno_t uvwasi_fd_fdstat_set_flags(uvwasi_t* uvwasi,
                                        uvwasi_fd_t fd,
                                        uvwasi_fdflags_t flags) {
806#ifdef _WIN32
UVWASI_DEBUG("uvwasi_fd_fdstat_set_flags(uvwasi=%p, fd=%d, flags=%d)\n",
             uvwasi,
             fd,
             flags);

/* TODO(cjihrig): Windows is not supported. */
return UVWASI_ENOSYS52;
814#else
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;
int mapped_flags;
int r;

UVWASI_DEBUG("uvwasi_fd_fdstat_set_flags(uvwasi=%p, fd=%d, flags=%d)\n",
             uvwasi,
             fd,
             flags);

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_FD_FDSTAT_SET_FLAGS(1 << 3),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

mapped_flags = 0;

if ((flags & UVWASI_FDFLAG_APPEND(1 << 0)) == UVWASI_FDFLAG_APPEND(1 << 0))
  mapped_flags |= O_APPEND02000;

if ((flags & UVWASI_FDFLAG_DSYNC(1 << 1)) == UVWASI_FDFLAG_DSYNC(1 << 1))
842#ifdef O_DSYNC010000
  mapped_flags |= O_DSYNC010000;
844#else
  mapped_flags |= O_SYNC04010000;
846#endif /* O_DSYNC */

if ((flags & UVWASI_FDFLAG_NONBLOCK(1 << 2)) == UVWASI_FDFLAG_NONBLOCK(1 << 2))
  mapped_flags |= O_NONBLOCK04000;

if ((flags & UVWASI_FDFLAG_RSYNC(1 << 3)) == UVWASI_FDFLAG_RSYNC(1 << 3))
852#ifdef O_RSYNC04010000
  mapped_flags |= O_RSYNC04010000;
854#else
  mapped_flags |= O_SYNC04010000;
856#endif /* O_RSYNC */

if ((flags & UVWASI_FDFLAG_SYNC(1 << 4)) == UVWASI_FDFLAG_SYNC(1 << 4))
  mapped_flags |= O_SYNC04010000;

r = fcntl(wrap->fd, F_SETFL4, mapped_flags);
if (r < 0)
  err = uvwasi__translate_uv_error(uv_translate_sys_error(errno(*__errno_location ())));
else
  err = UVWASI_ESUCCESS0;

uv_mutex_unlock(&wrap->mutex);
return err;
869#endif /* _WIN32 */
870}


873uvwasi_errno_t uvwasi_fd_fdstat_set_rights(uvwasi_t* uvwasi,
                                         uvwasi_fd_t fd,
                                         uvwasi_rights_t fs_rights_base,
                                         uvwasi_rights_t fs_rights_inheriting
                                        ) {
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;

UVWASI_DEBUG("uvwasi_fd_fdstat_set_rights(uvwasi=%p, fd=%d, "
             "fs_rights_base=%"PRIu64", fs_rights_inheriting=%"PRIu64")\n",
             uvwasi,
             fd,
             fs_rights_base,
             fs_rights_inheriting);

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds, fd, &wrap, 0, 0);
if (err != UVWASI_ESUCCESS0)
  return err;

/* Check for attempts to add new permissions. */
if ((fs_rights_base | wrap->rights_base) > wrap->rights_base) {
  err = UVWASI_ENOTCAPABLE76;
  goto exit;
}

if ((fs_rights_inheriting | wrap->rights_inheriting) >
    wrap->rights_inheriting) {
  err = UVWASI_ENOTCAPABLE76;
  goto exit;
}

wrap->rights_base = fs_rights_base;
wrap->rights_inheriting = fs_rights_inheriting;
err = UVWASI_ESUCCESS0;
910exit:
uv_mutex_unlock(&wrap->mutex);
return err;
913}


916uvwasi_errno_t uvwasi_fd_filestat_get(uvwasi_t* uvwasi,
                                    uvwasi_fd_t fd,
                                    uvwasi_filestat_t* buf) {
struct uvwasi_fd_wrap_t* wrap;
uv_fs_t req;
uvwasi_errno_t err;
int r;

UVWASI_DEBUG("uvwasi_fd_filestat_get(uvwasi=%p, fd=%d, buf=%p)\n",
             uvwasi,
             fd,
             buf);

if (uvwasi == NULL((void*)0) || buf == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_FD_FILESTAT_GET(1 << 21),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

r = uv_fs_fstat(NULL((void*)0), &req, wrap->fd, NULL((void*)0));
if (r != 0) {
  err = uvwasi__translate_uv_error(r);
  goto exit;
}

uvwasi__stat_to_filestat(&req.statbuf, buf);
err = UVWASI_ESUCCESS0;
948exit:
uv_mutex_unlock(&wrap->mutex);
uv_fs_req_cleanup(&req);
return err;
952}


955uvwasi_errno_t uvwasi_fd_filestat_set_size(uvwasi_t* uvwasi,
                                         uvwasi_fd_t fd,
                                         uvwasi_filesize_t st_size) {
/* TODO(cjihrig): uv_fs_ftruncate() takes an int64_t. st_size is uint64_t. */
struct uvwasi_fd_wrap_t* wrap;
uv_fs_t req;
uvwasi_errno_t err;
int r;

UVWASI_DEBUG("uvwasi_fd_filestat_set_size(uvwasi=%p, fd=%d, "
             "st_size=%"PRIu64")\n",
             uvwasi,
             fd,
             st_size);

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_FD_FILESTAT_SET_SIZE(1 << 22),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

r = uv_fs_ftruncate(NULL((void*)0), &req, wrap->fd, st_size, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uv_fs_req_cleanup(&req);

if (r != 0)
  return uvwasi__translate_uv_error(r);

return UVWASI_ESUCCESS0;
989}


992uvwasi_errno_t uvwasi_fd_filestat_set_times(uvwasi_t* uvwasi,
                                          uvwasi_fd_t fd,
                                          uvwasi_timestamp_t st_atim,
                                          uvwasi_timestamp_t st_mtim,
                                          uvwasi_fstflags_t fst_flags) {
struct uvwasi_fd_wrap_t* wrap;
uvwasi_timestamp_t atim;
uvwasi_timestamp_t mtim;
uv_fs_t req;
uvwasi_errno_t err;
int r;

UVWASI_DEBUG("uvwasi_fd_filestat_set_times(uvwasi=%p, fd=%d, "
             "st_atim=%"PRIu64", st_mtim=%"PRIu64", fst_flags=%d)\n",
             uvwasi,
             fd,
             st_atim,
             st_mtim,
             fst_flags);

if (uvwasi == NULL((void*)0))
1
Assuming 'uvwasi' is not equal to NULL→
2
←
Taking false branch→
  return UVWASI_EINVAL28;

VALIDATE_FSTFLAGS_OR_RETURN(fst_flags)do { if ((fst_flags) & ~((1 << 0) | (1 << 1) |
 (1 << 2) | (1 << 3))) { return 28; } } while (0);
3
←
Assuming the condition is false→
4
←
Taking false branch→
5
←
Loop condition is false.  Exiting loop→

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_FD_FILESTAT_SET_TIMES(1 << 23),
                          0);
if (err != UVWASI_ESUCCESS0)
6
←
Assuming 'err' is equal to UVWASI_ESUCCESS→
7
←
Taking false branch→
  return err;

atim = st_atim;
mtim = st_mtim;
err = uvwasi__get_filestat_set_times(&atim,
8
←
Calling 'uvwasi__get_filestat_set_times'→
                                     &mtim,
                                     fst_flags,
                                     &wrap->fd,
                                     NULL((void*)0));
if (err != UVWASI_ESUCCESS0) {
  uv_mutex_unlock(&wrap->mutex);
  return err;
}

/* libuv does not currently support nanosecond precision. */
r = uv_fs_futime(NULL((void*)0), &req, wrap->fd, atim, mtim, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uv_fs_req_cleanup(&req);

if (r != 0)
  return uvwasi__translate_uv_error(r);

return UVWASI_ESUCCESS0;
1046}


1049uvwasi_errno_t uvwasi_fd_pread(uvwasi_t* uvwasi,
                             uvwasi_fd_t fd,
                             const uvwasi_iovec_t* iovs,
                             uvwasi_size_t iovs_len,
                             uvwasi_filesize_t offset,
                             uvwasi_size_t* nread) {
struct uvwasi_fd_wrap_t* wrap;
uv_buf_t* bufs;
uv_fs_t req;
uvwasi_errno_t err;
size_t uvread;
int r;

UVWASI_DEBUG("uvwasi_fd_pread(uvwasi=%p, fd=%d, iovs=%p, iovs_len=%d, "
             "offset=%"PRIu64", nread=%p)\n",
             uvwasi,
             fd,
             iovs,
             iovs_len,
             offset,
             nread);

if (uvwasi == NULL((void*)0) || iovs == NULL((void*)0) || nread == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_FD_READ(1 << 1) | UVWASI_RIGHT_FD_SEEK(1 << 2),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__setup_iovs(uvwasi, &bufs, iovs, iovs_len);
if (err != UVWASI_ESUCCESS0) {
  uv_mutex_unlock(&wrap->mutex);
  return err;
}

r = uv_fs_read(NULL((void*)0), &req, wrap->fd, bufs, iovs_len, offset, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uvread = req.result;
uv_fs_req_cleanup(&req);
uvwasi__free(uvwasi, bufs);

if (r < 0)
  return uvwasi__translate_uv_error(r);

*nread = (uvwasi_size_t) uvread;
return UVWASI_ESUCCESS0;
1099}


1102uvwasi_errno_t uvwasi_fd_prestat_get(uvwasi_t* uvwasi,
                                   uvwasi_fd_t fd,
                                   uvwasi_prestat_t* buf) {
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;

UVWASI_DEBUG("uvwasi_fd_prestat_get(uvwasi=%p, fd=%d, buf=%p)\n",
             uvwasi,
             fd,
             buf);

if (uvwasi == NULL((void*)0) || buf == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds, fd, &wrap, 0, 0);
if (err != UVWASI_ESUCCESS0)
  return err;
if (wrap->preopen != 1) {
  err = UVWASI_EINVAL28;
  goto exit;
}

buf->pr_type = UVWASI_PREOPENTYPE_DIR0;
buf->u.dir.pr_name_len = strlen(wrap->path) + 1;
err = UVWASI_ESUCCESS0;
1127exit:
uv_mutex_unlock(&wrap->mutex);
return err;
1130}


1133uvwasi_errno_t uvwasi_fd_prestat_dir_name(uvwasi_t* uvwasi,
                                        uvwasi_fd_t fd,
                                        char* path,
                                        uvwasi_size_t path_len) {
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;
size_t size;

UVWASI_DEBUG("uvwasi_fd_prestat_dir_name(uvwasi=%p, fd=%d, path=%p, "
             "path_len=%d)\n",
             uvwasi,
             fd,
             path,
             path_len);

if (uvwasi == NULL((void*)0) || path == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds, fd, &wrap, 0, 0);
if (err != UVWASI_ESUCCESS0)
  return err;
if (wrap->preopen != 1) {
  err = UVWASI_EBADF8;
  goto exit;
}

size = strlen(wrap->path) + 1;
if (size > (size_t) path_len) {
  err = UVWASI_ENOBUFS42;
  goto exit;
}

memcpy(path, wrap->path, size);
err = UVWASI_ESUCCESS0;
1167exit:
uv_mutex_unlock(&wrap->mutex);
return err;
1170}


1173uvwasi_errno_t uvwasi_fd_pwrite(uvwasi_t* uvwasi,
                              uvwasi_fd_t fd,
                              const uvwasi_ciovec_t* iovs,
                              uvwasi_size_t iovs_len,
                              uvwasi_filesize_t offset,
                              uvwasi_size_t* nwritten) {
struct uvwasi_fd_wrap_t* wrap;
uv_buf_t* bufs;
uv_fs_t req;
uvwasi_errno_t err;
size_t uvwritten;
int r;

UVWASI_DEBUG("uvwasi_fd_pwrite(uvwasi=%p, fd=%d, iovs=%p, iovs_len=%d, "
             "offset=%"PRIu64", nwritten=%p)\n",
             uvwasi,
             fd,
             iovs,
             iovs_len,
             offset,
             nwritten);

if (uvwasi == NULL((void*)0) || iovs == NULL((void*)0) || nwritten == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_FD_WRITE(1 << 6) | UVWASI_RIGHT_FD_SEEK(1 << 2),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__setup_ciovs(uvwasi, &bufs, iovs, iovs_len);
if (err != UVWASI_ESUCCESS0) {
  uv_mutex_unlock(&wrap->mutex);
  return err;
}

r = uv_fs_write(NULL((void*)0), &req, wrap->fd, bufs, iovs_len, offset, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uvwritten = req.result;
uv_fs_req_cleanup(&req);
uvwasi__free(uvwasi, bufs);

if (r < 0)
  return uvwasi__translate_uv_error(r);

*nwritten = (uvwasi_size_t) uvwritten;
return UVWASI_ESUCCESS0;
1223}


1226uvwasi_errno_t uvwasi_fd_read(uvwasi_t* uvwasi,
                            uvwasi_fd_t fd,
                            const uvwasi_iovec_t* iovs,
                            uvwasi_size_t iovs_len,
                            uvwasi_size_t* nread) {
struct uvwasi_fd_wrap_t* wrap;
uv_buf_t* bufs;
uv_fs_t req;
uvwasi_errno_t err;
size_t uvread;
int r;

UVWASI_DEBUG("uvwasi_fd_read(uvwasi=%p, fd=%d, iovs=%p, iovs_len=%d, "
             "nread=%p)\n",
             uvwasi,
             fd,
             iovs,
             iovs_len,
             nread);

if (uvwasi == NULL((void*)0) || iovs == NULL((void*)0) || nread == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds, fd, &wrap, UVWASI_RIGHT_FD_READ(1 << 1), 0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__setup_iovs(uvwasi, &bufs, iovs, iovs_len);
if (err != UVWASI_ESUCCESS0) {
  uv_mutex_unlock(&wrap->mutex);
  return err;
}

r = uv_fs_read(NULL((void*)0), &req, wrap->fd, bufs, iovs_len, -1, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uvread = req.result;
uv_fs_req_cleanup(&req);
uvwasi__free(uvwasi, bufs);

if (r < 0)
  return uvwasi__translate_uv_error(r);

*nread = (uvwasi_size_t) uvread;
return UVWASI_ESUCCESS0;
1270}


1273uvwasi_errno_t uvwasi_fd_readdir(uvwasi_t* uvwasi,
                               uvwasi_fd_t fd,
                               void* buf,
                               uvwasi_size_t buf_len,
                               uvwasi_dircookie_t cookie,
                               uvwasi_size_t* bufused) {
1279#if defined(UVWASI_FD_READDIR_SUPPORTED1)
/* TODO(cjihrig): Avoid opening and closing the directory on each call. */
struct uvwasi_fd_wrap_t* wrap;
uvwasi_dirent_t dirent;
uv_dirent_t dirents[UVWASI__READDIR_NUM_ENTRIES1];
uv_dir_t* dir;
uv_fs_t req;
uvwasi_errno_t err;
size_t name_len;
size_t available;
size_t size_to_cp;
long tell;
int i;
int r;
1293#endif /* defined(UVWASI_FD_READDIR_SUPPORTED) */

UVWASI_DEBUG("uvwasi_fd_readdir(uvwasi=%p, fd=%d, buf=%p, buf_len=%d, "
             "cookie=%"PRIu64", bufused=%p)\n",
             uvwasi,
             fd,
             buf,
             buf_len,
             cookie,
             bufused);

if (uvwasi == NULL((void*)0) || buf == NULL((void*)0) || bufused == NULL((void*)0))
  return UVWASI_EINVAL28;

1307#if defined(UVWASI_FD_READDIR_SUPPORTED1)
err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_FD_READDIR(1 << 14),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

/* Open the directory. */
r = uv_fs_opendir(NULL((void*)0), &req, wrap->real_path, NULL((void*)0));
if (r != 0) {
  uv_mutex_unlock(&wrap->mutex);
  return uvwasi__translate_uv_error(r);
}

/* Setup for reading the directory. */
dir = req.ptr;
dir->dirents = dirents;
dir->nentries = UVWASI__READDIR_NUM_ENTRIES1;
uv_fs_req_cleanup(&req);

/* Seek to the proper location in the directory. */
if (cookie != UVWASI_DIRCOOKIE_START0)
  seekdir(dir->dir, cookie);

/* Read the directory entries into the provided buffer. */
err = UVWASI_ESUCCESS0;
*bufused = 0;
while (0 != (r = uv_fs_readdir(NULL((void*)0), &req, dir, NULL((void*)0)))) {
  if (r < 0) {
    err = uvwasi__translate_uv_error(r);
    uv_fs_req_cleanup(&req);
    goto exit;
  }

  available = 0;

  for (i = 0; i < r; i++) {
    tell = telldir(dir->dir);
    if (tell < 0) {
      err = uvwasi__translate_uv_error(uv_translate_sys_error(errno(*__errno_location ())));
      uv_fs_req_cleanup(&req);
      goto exit;
    }

    name_len = strlen(dirents[i].name);
    dirent.d_next = (uvwasi_dircookie_t) tell;
    /* TODO(cjihrig): libuv doesn't provide d_ino, and d_type is not
                      supported on all platforms. Use stat()? */
    dirent.d_ino = 0;
    dirent.d_namlen = name_len;

    switch (dirents[i].type) {
      case UV_DIRENT_FILE:
        dirent.d_type = UVWASI_FILETYPE_REGULAR_FILE4;
        break;
      case UV_DIRENT_DIR:
        dirent.d_type = UVWASI_FILETYPE_DIRECTORY3;
        break;
      case UV_DIRENT_SOCKET:
        dirent.d_type = UVWASI_FILETYPE_SOCKET_STREAM6;
        break;
      case UV_DIRENT_LINK:
        dirent.d_type = UVWASI_FILETYPE_SYMBOLIC_LINK7;
        break;
      case UV_DIRENT_CHAR:
        dirent.d_type = UVWASI_FILETYPE_CHARACTER_DEVICE2;
        break;
      case UV_DIRENT_BLOCK:
        dirent.d_type = UVWASI_FILETYPE_BLOCK_DEVICE1;
        break;
      case UV_DIRENT_FIFO:
      case UV_DIRENT_UNKNOWN:
      default:
        dirent.d_type = UVWASI_FILETYPE_UNKNOWN0;
        break;
    }

    /* Write dirent to the buffer if it will fit. */
    if (UVWASI_SERDES_SIZE_dirent_t24 + *bufused > buf_len)
      break;

    uvwasi_serdes_write_dirent_t(buf, *bufused, &dirent);
    *bufused += UVWASI_SERDES_SIZE_dirent_t24;
    available = buf_len - *bufused;

    /* Write as much of the entry name to the buffer as possible. */
    size_to_cp = name_len > available ? available : name_len;
    memcpy((char*)buf + *bufused, dirents[i].name, size_to_cp);
    *bufused += size_to_cp;
    available = buf_len - *bufused;
  }

  uv_fs_req_cleanup(&req);

  if (available == 0)
    break;
}

1407exit:
/* Close the directory. */
r = uv_fs_closedir(NULL((void*)0), &req, dir, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uv_fs_req_cleanup(&req);
if (r != 0)
  return uvwasi__translate_uv_error(r);

return err;
1416#else
/* TODO(cjihrig): Need a solution for Windows and Android. */
return UVWASI_ENOSYS52;
1419#endif /* defined(UVWASI_FD_READDIR_SUPPORTED) */
1420}


1423uvwasi_errno_t uvwasi_fd_renumber(uvwasi_t* uvwasi,
                                uvwasi_fd_t from,
                                uvwasi_fd_t to) {
UVWASI_DEBUG("uvwasi_fd_renumber(uvwasi=%p, from=%d, to=%d)\n",
             uvwasi,
             from,
             to);

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

return uvwasi_fd_table_renumber(uvwasi, uvwasi->fds, to, from);
1435}


1438uvwasi_errno_t uvwasi_fd_seek(uvwasi_t* uvwasi,
                            uvwasi_fd_t fd,
                            uvwasi_filedelta_t offset,
                            uvwasi_whence_t whence,
                            uvwasi_filesize_t* newoffset) {
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;

UVWASI_DEBUG("uvwasi_fd_seek(uvwasi=%p, fd=%d, offset=%"PRId64", "
             "whence=%d, newoffset=%p)\n",
             uvwasi,
             fd,
             offset,
             whence,
             newoffset);

if (uvwasi == NULL((void*)0) || newoffset == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds, fd, &wrap, UVWASI_RIGHT_FD_SEEK(1 << 2), 0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__lseek(wrap->fd, offset, whence, newoffset);
uv_mutex_unlock(&wrap->mutex);
return err;
1464}


1467uvwasi_errno_t uvwasi_fd_sync(uvwasi_t* uvwasi, uvwasi_fd_t fd) {
struct uvwasi_fd_wrap_t* wrap;
uv_fs_t req;
uvwasi_errno_t err;
int r;

UVWASI_DEBUG("uvwasi_fd_sync(uvwasi=%p, fd=%d)\n", uvwasi, fd);

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_FD_SYNC(1 << 4),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

r = uv_fs_fsync(NULL((void*)0), &req, wrap->fd, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uv_fs_req_cleanup(&req);

if (r != 0)
  return uvwasi__translate_uv_error(r);

return UVWASI_ESUCCESS0;
1494}


1497uvwasi_errno_t uvwasi_fd_tell(uvwasi_t* uvwasi,
                            uvwasi_fd_t fd,
                            uvwasi_filesize_t* offset) {
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;

UVWASI_DEBUG("uvwasi_fd_tell(uvwasi=%p, fd=%d, offset=%p)\n",
             uvwasi,
             fd,
             offset);

if (uvwasi == NULL((void*)0) || offset == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds, fd, &wrap, UVWASI_RIGHT_FD_TELL(1 << 5), 0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__lseek(wrap->fd, 0, UVWASI_WHENCE_CUR1, offset);
uv_mutex_unlock(&wrap->mutex);
return err;
1518}


1521uvwasi_errno_t uvwasi_fd_write(uvwasi_t* uvwasi,
                             uvwasi_fd_t fd,
                             const uvwasi_ciovec_t* iovs,
                             uvwasi_size_t iovs_len,
                             uvwasi_size_t* nwritten) {
struct uvwasi_fd_wrap_t* wrap;
uv_buf_t* bufs;
uv_fs_t req;
uvwasi_errno_t err;
size_t uvwritten;
int r;

UVWASI_DEBUG("uvwasi_fd_write(uvwasi=%p, fd=%d, iovs=%p, iovs_len=%d, "
             "nwritten=%p)\n",
             uvwasi,
             fd,
             iovs,
             iovs_len,
             nwritten);

if (uvwasi == NULL((void*)0) || iovs == NULL((void*)0) || nwritten == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds, fd, &wrap, UVWASI_RIGHT_FD_WRITE(1 << 6), 0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__setup_ciovs(uvwasi, &bufs, iovs, iovs_len);
if (err != UVWASI_ESUCCESS0) {
  uv_mutex_unlock(&wrap->mutex);
  return err;
}

r = uv_fs_write(NULL((void*)0), &req, wrap->fd, bufs, iovs_len, -1, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uvwritten = req.result;
uv_fs_req_cleanup(&req);
uvwasi__free(uvwasi, bufs);

if (r < 0)
  return uvwasi__translate_uv_error(r);

*nwritten = (uvwasi_size_t) uvwritten;
return UVWASI_ESUCCESS0;
1565}


1568uvwasi_errno_t uvwasi_path_create_directory(uvwasi_t* uvwasi,
                                          uvwasi_fd_t fd,
                                          const char* path,
                                          uvwasi_size_t path_len) {
char* resolved_path;
struct uvwasi_fd_wrap_t* wrap;
uv_fs_t req;
uvwasi_errno_t err;
int r;

UVWASI_DEBUG("uvwasi_path_create_directory(uvwasi=%p, fd=%d, path='%s', "
             "path_len=%d)\n",
             uvwasi,
             fd,
             path,
             path_len);

if (uvwasi == NULL((void*)0) || path == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_PATH_CREATE_DIRECTORY(1 << 9),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__resolve_path(uvwasi, wrap, path, path_len, &resolved_path, 0);
if (err != UVWASI_ESUCCESS0)
  goto exit;

r = uv_fs_mkdir(NULL((void*)0), &req, resolved_path, 0777, NULL((void*)0));
uv_fs_req_cleanup(&req);
uvwasi__free(uvwasi, resolved_path);

if (r != 0) {
  err = uvwasi__translate_uv_error(r);
  goto exit;
}

err = UVWASI_ESUCCESS0;
1610exit:
uv_mutex_unlock(&wrap->mutex);
return err;
1613}


1616uvwasi_errno_t uvwasi_path_filestat_get(uvwasi_t* uvwasi,
                                      uvwasi_fd_t fd,
                                      uvwasi_lookupflags_t flags,
                                      const char* path,
                                      uvwasi_size_t path_len,
                                      uvwasi_filestat_t* buf) {
char* resolved_path;
struct uvwasi_fd_wrap_t* wrap;
uv_fs_t req;
uvwasi_errno_t err;
int r;

UVWASI_DEBUG("uvwasi_path_filestat_get(uvwasi=%p, fd=%d, flags=%d, "
             "path='%s', path_len=%d, buf=%p)\n",
             uvwasi,
             fd,
             flags,
             path,
             path_len,
             buf);

if (uvwasi == NULL((void*)0) || path == NULL((void*)0) || buf == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_PATH_FILESTAT_GET(1 << 18),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__resolve_path(uvwasi,
                           wrap,
                           path,
                           path_len,
                           &resolved_path,
                           flags);
if (err != UVWASI_ESUCCESS0)
  goto exit;

r = uv_fs_lstat(NULL((void*)0), &req, resolved_path, NULL((void*)0));
uvwasi__free(uvwasi, resolved_path);
if (r != 0) {
  uv_fs_req_cleanup(&req);
  err = uvwasi__translate_uv_error(r);
  goto exit;
}

uvwasi__stat_to_filestat(&req.statbuf, buf);
uv_fs_req_cleanup(&req);
err = UVWASI_ESUCCESS0;
1668exit:
uv_mutex_unlock(&wrap->mutex);
return err;
1671}


1674uvwasi_errno_t uvwasi_path_filestat_set_times(uvwasi_t* uvwasi,
                                            uvwasi_fd_t fd,
                                            uvwasi_lookupflags_t flags,
                                            const char* path,
                                            uvwasi_size_t path_len,
                                            uvwasi_timestamp_t st_atim,
                                            uvwasi_timestamp_t st_mtim,
                                            uvwasi_fstflags_t fst_flags) {
char* resolved_path;
struct uvwasi_fd_wrap_t* wrap;
uvwasi_timestamp_t atim;
uvwasi_timestamp_t mtim;
uv_fs_t req;
uvwasi_errno_t err;
int r;

UVWASI_DEBUG("uvwasi_path_filestat_set_times(uvwasi=%p, fd=%d, "
             "flags=%d, path='%s', path_len=%d, "
             "st_atim=%"PRIu64", st_mtim=%"PRIu64", fst_flags=%d)\n",
             uvwasi,
             fd,
             flags,
             path,
             path_len,
             st_atim,
             st_mtim,
             fst_flags);

if (uvwasi == NULL((void*)0) || path == NULL((void*)0))
  return UVWASI_EINVAL28;

VALIDATE_FSTFLAGS_OR_RETURN(fst_flags)do { if ((fst_flags) & ~((1 << 0) | (1 << 1) |
 (1 << 2) | (1 << 3))) { return 28; } } while (0);

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_PATH_FILESTAT_SET_TIMES(1 << 20),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__resolve_path(uvwasi,
                           wrap,
                           path,
                           path_len,
                           &resolved_path,
                           flags);
if (err != UVWASI_ESUCCESS0)
  goto exit;

atim = st_atim;
mtim = st_mtim;
err = uvwasi__get_filestat_set_times(&atim,
                                     &mtim,
                                     fst_flags,
                                     NULL((void*)0),
                                     resolved_path);
if (err != UVWASI_ESUCCESS0) {
  uvwasi__free(uvwasi, resolved_path);
  goto exit;
}

/* libuv does not currently support nanosecond precision. */
r = uv_fs_lutime(NULL((void*)0), &req, resolved_path, atim, mtim, NULL((void*)0));
uvwasi__free(uvwasi, resolved_path);
uv_fs_req_cleanup(&req);

if (r != 0) {
  err = uvwasi__translate_uv_error(r);
  goto exit;
}

err = UVWASI_ESUCCESS0;
1747exit:
uv_mutex_unlock(&wrap->mutex);
return err;
1750}


1753uvwasi_errno_t uvwasi_path_link(uvwasi_t* uvwasi,
                              uvwasi_fd_t old_fd,
                              uvwasi_lookupflags_t old_flags,
                              const char* old_path,
                              uvwasi_size_t old_path_len,
                              uvwasi_fd_t new_fd,
                              const char* new_path,
                              uvwasi_size_t new_path_len) {
char* resolved_old_path;
char* resolved_new_path;
struct uvwasi_fd_wrap_t* old_wrap;
struct uvwasi_fd_wrap_t* new_wrap;
uvwasi_errno_t err;
uv_fs_t req;
int r;

UVWASI_DEBUG("uvwasi_path_link(uvwasi=%p, old_fd=%d, old_flags=%d, "
             "old_path='%s', old_path_len=%d, new_fd=%d, new_path='%s', "
             "new_path_len=%d)\n",
             uvwasi,
             old_fd,
             old_flags,
             old_path,
             old_path_len,
             new_fd,
             new_path,
             new_path_len);

if (uvwasi == NULL((void*)0) || old_path == NULL((void*)0) || new_path == NULL((void*)0))
  return UVWASI_EINVAL28;

uvwasi_fd_table_lock(uvwasi->fds);

if (old_fd == new_fd) {
  err = uvwasi_fd_table_get_nolock(uvwasi->fds,
                                   old_fd,
                                   &old_wrap,
                                   UVWASI_RIGHT_PATH_LINK_SOURCE(1 << 11) |
                                   UVWASI_RIGHT_PATH_LINK_TARGET(1 << 12),
                                   0);
  new_wrap = old_wrap;
} else {
  err = uvwasi_fd_table_get_nolock(uvwasi->fds,
                                   old_fd,
                                   &old_wrap,
                                   UVWASI_RIGHT_PATH_LINK_SOURCE(1 << 11),
                                   0);
  if (err != UVWASI_ESUCCESS0) {
    uvwasi_fd_table_unlock(uvwasi->fds);
    return err;
  }

  err = uvwasi_fd_table_get_nolock(uvwasi->fds,
                                   new_fd,
                                   &new_wrap,
                                   UVWASI_RIGHT_PATH_LINK_TARGET(1 << 12),
                                   0);
  if (err != UVWASI_ESUCCESS0)
    uv_mutex_unlock(&old_wrap->mutex);
}

uvwasi_fd_table_unlock(uvwasi->fds);

if (err != UVWASI_ESUCCESS0)
  return err;

resolved_old_path = NULL((void*)0);
resolved_new_path = NULL((void*)0);

err = uvwasi__resolve_path(uvwasi,
                           old_wrap,
                           old_path,
                           old_path_len,
                           &resolved_old_path,
                           old_flags);
if (err != UVWASI_ESUCCESS0)
  goto exit;

err = uvwasi__resolve_path(uvwasi,
                           new_wrap,
                           new_path,
                           new_path_len,
                           &resolved_new_path,
                           0);
if (err != UVWASI_ESUCCESS0)
  goto exit;

r = uv_fs_link(NULL((void*)0), &req, resolved_old_path, resolved_new_path, NULL((void*)0));
uv_fs_req_cleanup(&req);
if (r != 0) {
  err = uvwasi__translate_uv_error(r);
  goto exit;
}

err = UVWASI_ESUCCESS0;
1848exit:
uv_mutex_unlock(&new_wrap->mutex);
if (old_fd != new_fd)
  uv_mutex_unlock(&old_wrap->mutex);

uvwasi__free(uvwasi, resolved_old_path);
uvwasi__free(uvwasi, resolved_new_path);
return err;
1856}


1859uvwasi_errno_t uvwasi_path_open(uvwasi_t* uvwasi,
                              uvwasi_fd_t dirfd,
                              uvwasi_lookupflags_t dirflags,
                              const char* path,
                              uvwasi_size_t path_len,
                              uvwasi_oflags_t o_flags,
                              uvwasi_rights_t fs_rights_base,
                              uvwasi_rights_t fs_rights_inheriting,
                              uvwasi_fdflags_t fs_flags,
                              uvwasi_fd_t* fd) {
char* resolved_path;
uvwasi_rights_t needed_inheriting;
uvwasi_rights_t needed_base;
uvwasi_rights_t max_base;
uvwasi_rights_t max_inheriting;
struct uvwasi_fd_wrap_t* dirfd_wrap;
struct uvwasi_fd_wrap_t *wrap;
uvwasi_filetype_t filetype;
uvwasi_errno_t err;
uv_fs_t req;
int flags;
int read;
int write;
int r;

UVWASI_DEBUG("uvwasi_path_open(uvwasi=%p, dirfd=%d, dirflags=%d, path='%s', "
             "path_len=%d, o_flags=%d, fs_rights_base=%"PRIu64", "
             "fs_rights_inheriting=%"PRIu64", fs_flags=%d, fd=%p)\n",
             uvwasi,
             dirfd,
             dirflags,
             path,
             path_len,
             o_flags,
             fs_rights_base,
             fs_rights_inheriting,
             fs_flags,
             fd);

if (uvwasi == NULL((void*)0) || path == NULL((void*)0) || fd == NULL((void*)0))
  return UVWASI_EINVAL28;

read = 0 != (fs_rights_base & (UVWASI_RIGHT_FD_READ(1 << 1) |
                               UVWASI_RIGHT_FD_READDIR(1 << 14)));
write = 0 != (fs_rights_base & (UVWASI_RIGHT_FD_DATASYNC(1 << 0) |
                                UVWASI_RIGHT_FD_WRITE(1 << 6) |
                                UVWASI_RIGHT_FD_ALLOCATE(1 << 8) |
                                UVWASI_RIGHT_FD_FILESTAT_SET_SIZE(1 << 22)));
flags = write ? read ? UV_FS_O_RDWR02 : UV_FS_O_WRONLY01 : UV_FS_O_RDONLY00;
needed_base = UVWASI_RIGHT_PATH_OPEN(1 << 13);
needed_inheriting = fs_rights_base | fs_rights_inheriting;

if ((o_flags & UVWASI_O_CREAT(1 << 0)) != 0) {
  flags |= UV_FS_O_CREAT0100;
  needed_base |= UVWASI_RIGHT_PATH_CREATE_FILE(1 << 10);
}
if ((o_flags & UVWASI_O_DIRECTORY(1 << 1)) != 0)
  flags |= UV_FS_O_DIRECTORY0200000;
if ((o_flags & UVWASI_O_EXCL(1 << 2)) != 0)
  flags |= UV_FS_O_EXCL0200;
if ((o_flags & UVWASI_O_TRUNC(1 << 3)) != 0) {
  flags |= UV_FS_O_TRUNC01000;
  needed_base |= UVWASI_RIGHT_PATH_FILESTAT_SET_SIZE(1 << 19);
}

if ((fs_flags & UVWASI_FDFLAG_APPEND(1 << 0)) != 0)
  flags |= UV_FS_O_APPEND02000;
if ((fs_flags & UVWASI_FDFLAG_DSYNC(1 << 1)) != 0) {
  flags |= UV_FS_O_DSYNC010000;
  needed_inheriting |= UVWASI_RIGHT_FD_DATASYNC(1 << 0);
}
if ((fs_flags & UVWASI_FDFLAG_NONBLOCK(1 << 2)) != 0)
  flags |= UV_FS_O_NONBLOCK04000;
if ((fs_flags & UVWASI_FDFLAG_RSYNC(1 << 3)) != 0) {
1933#ifdef O_RSYNC04010000
  flags |= O_RSYNC04010000; /* libuv has no UV_FS_O_RSYNC. */
1935#else
  flags |= UV_FS_O_SYNC04010000;
1937#endif
  needed_inheriting |= UVWASI_RIGHT_FD_SYNC(1 << 4);
}
if ((fs_flags & UVWASI_FDFLAG_SYNC(1 << 4)) != 0) {
  flags |= UV_FS_O_SYNC04010000;
  needed_inheriting |= UVWASI_RIGHT_FD_SYNC(1 << 4);
}
if (write && (flags & (UV_FS_O_APPEND02000 | UV_FS_O_TRUNC01000)) == 0)
  needed_inheriting |= UVWASI_RIGHT_FD_SEEK(1 << 2);

err = uvwasi_fd_table_get(uvwasi->fds,
                          dirfd,
                          &dirfd_wrap,
                          needed_base,
                          needed_inheriting);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__resolve_path(uvwasi,
                           dirfd_wrap,
                           path,
                           path_len,
                           &resolved_path,
                           dirflags);
if (err != UVWASI_ESUCCESS0) {
  uv_mutex_unlock(&dirfd_wrap->mutex);
  return err;
}

r = uv_fs_open(NULL((void*)0), &req, resolved_path, flags, 0666, NULL((void*)0));
uv_mutex_unlock(&dirfd_wrap->mutex);
uv_fs_req_cleanup(&req);

if (r < 0) {
  uvwasi__free(uvwasi, resolved_path);
  return uvwasi__translate_uv_error(r);
}

/* Not all platforms support UV_FS_O_DIRECTORY, so get the file type and check
   it here. */
err = uvwasi__get_filetype_by_fd(r, &filetype);
if (err != UVWASI_ESUCCESS0)
  goto close_file_and_error_exit;

if ((o_flags & UVWASI_O_DIRECTORY(1 << 1)) != 0 &&
    filetype != UVWASI_FILETYPE_DIRECTORY3) {
  err = UVWASI_ENOTDIR54;
  goto close_file_and_error_exit;
}

err = uvwasi__get_rights(r, flags, filetype, &max_base, &max_inheriting);
if (err != UVWASI_ESUCCESS0)
  goto close_file_and_error_exit;

err = uvwasi_fd_table_insert(uvwasi,
                             uvwasi->fds,
                             r,
                             resolved_path,
                             resolved_path,
                             filetype,
                             fs_rights_base & max_base,
                             fs_rights_inheriting & max_inheriting,
                             0,
                             &wrap);
if (err != UVWASI_ESUCCESS0)
  goto close_file_and_error_exit;

*fd = wrap->id;
uv_mutex_unlock(&wrap->mutex);
uvwasi__free(uvwasi, resolved_path);
return UVWASI_ESUCCESS0;

2009close_file_and_error_exit:
uv_fs_close(NULL((void*)0), &req, r, NULL((void*)0));
uv_fs_req_cleanup(&req);
uvwasi__free(uvwasi, resolved_path);
return err;
2014}


2017uvwasi_errno_t uvwasi_path_readlink(uvwasi_t* uvwasi,
                                  uvwasi_fd_t fd,
                                  const char* path,
                                  uvwasi_size_t path_len,
                                  char* buf,
                                  uvwasi_size_t buf_len,
                                  uvwasi_size_t* bufused) {
char* resolved_path;
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;
uv_fs_t req;
size_t len;
int r;

UVWASI_DEBUG("uvwasi_path_readlink(uvwasi=%p, fd=%d, path='%s', path_len=%d, "
             "buf=%p, buf_len=%d, bufused=%p)\n",
             uvwasi,
             fd,
             path,
             path_len,
             buf,
             buf_len,
             bufused);

if (uvwasi == NULL((void*)0) || path == NULL((void*)0) || buf == NULL((void*)0) || bufused == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_PATH_READLINK(1 << 15),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__resolve_path(uvwasi, wrap, path, path_len, &resolved_path, 0);
if (err != UVWASI_ESUCCESS0) {
  uv_mutex_unlock(&wrap->mutex);
  return err;
}

r = uv_fs_readlink(NULL((void*)0), &req, resolved_path, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uvwasi__free(uvwasi, resolved_path);
if (r != 0) {
  uv_fs_req_cleanup(&req);
  return uvwasi__translate_uv_error(r);
}

len = strnlen(req.ptr, buf_len);
if (len >= buf_len) {
  uv_fs_req_cleanup(&req);
  return UVWASI_ENOBUFS42;
}

memcpy(buf, req.ptr, len);
buf[len] = '\0';
*bufused = len + 1;
uv_fs_req_cleanup(&req);
return UVWASI_ESUCCESS0;
2077}


2080uvwasi_errno_t uvwasi_path_remove_directory(uvwasi_t* uvwasi,
                                          uvwasi_fd_t fd,
                                          const char* path,
                                          uvwasi_size_t path_len) {
char* resolved_path;
struct uvwasi_fd_wrap_t* wrap;
uv_fs_t req;
uvwasi_errno_t err;
int r;

UVWASI_DEBUG("uvwasi_path_remove_directory(uvwasi=%p, fd=%d, path='%s', "
             "path_len=%d)\n",
             uvwasi,
             fd,
             path,
             path_len);

if (uvwasi == NULL((void*)0) || path == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_PATH_REMOVE_DIRECTORY(1 << 25),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__resolve_path(uvwasi, wrap, path, path_len, &resolved_path, 0);
if (err != UVWASI_ESUCCESS0) {
  uv_mutex_unlock(&wrap->mutex);
  return err;
}

r = uv_fs_rmdir(NULL((void*)0), &req, resolved_path, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uvwasi__free(uvwasi, resolved_path);
uv_fs_req_cleanup(&req);

if (r != 0)
  return uvwasi__translate_uv_error(r);

return UVWASI_ESUCCESS0;
2123}


2126uvwasi_errno_t uvwasi_path_rename(uvwasi_t* uvwasi,
                                uvwasi_fd_t old_fd,
                                const char* old_path,
                                uvwasi_size_t old_path_len,
                                uvwasi_fd_t new_fd,
                                const char* new_path,
                                uvwasi_size_t new_path_len) {
char* resolved_old_path;
char* resolved_new_path;
struct uvwasi_fd_wrap_t* old_wrap;
struct uvwasi_fd_wrap_t* new_wrap;
uvwasi_errno_t err;
uv_fs_t req;
int r;

UVWASI_DEBUG("uvwasi_path_rename(uvwasi=%p, old_fd=%d, old_path='%s', "
             "old_path_len=%d, new_fd=%d, new_path='%s', new_path_len=%d)\n",
             uvwasi,
             old_fd,
             old_path,
             old_path_len,
             new_fd,
             new_path,
             new_path_len);

if (uvwasi == NULL((void*)0) || old_path == NULL((void*)0) || new_path == NULL((void*)0))
  return UVWASI_EINVAL28;

uvwasi_fd_table_lock(uvwasi->fds);

if (old_fd == new_fd) {
  err = uvwasi_fd_table_get_nolock(uvwasi->fds,
                                   old_fd,
                                   &old_wrap,
                                   UVWASI_RIGHT_PATH_RENAME_SOURCE(1 << 16) |
                                   UVWASI_RIGHT_PATH_RENAME_TARGET(1 << 17),
                                   0);
  new_wrap = old_wrap;
} else {
  err = uvwasi_fd_table_get_nolock(uvwasi->fds,
                                   old_fd,
                                   &old_wrap,
                                   UVWASI_RIGHT_PATH_RENAME_SOURCE(1 << 16),
                                   0);
  if (err != UVWASI_ESUCCESS0) {
    uvwasi_fd_table_unlock(uvwasi->fds);
    return err;
  }

  err = uvwasi_fd_table_get_nolock(uvwasi->fds,
                                   new_fd,
                                   &new_wrap,
                                   UVWASI_RIGHT_PATH_RENAME_TARGET(1 << 17),
                                   0);
  if (err != UVWASI_ESUCCESS0)
    uv_mutex_unlock(&old_wrap->mutex);
}

uvwasi_fd_table_unlock(uvwasi->fds);

if (err != UVWASI_ESUCCESS0)
  return err;

resolved_old_path = NULL((void*)0);
resolved_new_path = NULL((void*)0);

err = uvwasi__resolve_path(uvwasi,
                           old_wrap,
                           old_path,
                           old_path_len,
                           &resolved_old_path,
                           0);
if (err != UVWASI_ESUCCESS0)
  goto exit;

err = uvwasi__resolve_path(uvwasi,
                           new_wrap,
                           new_path,
                           new_path_len,
                           &resolved_new_path,
                           0);
if (err != UVWASI_ESUCCESS0)
  goto exit;

r = uv_fs_rename(NULL((void*)0), &req, resolved_old_path, resolved_new_path, NULL((void*)0));
uv_fs_req_cleanup(&req);
if (r != 0) {
  err = uvwasi__translate_uv_error(r);
  goto exit;
}

err = UVWASI_ESUCCESS0;
2218exit:
uv_mutex_unlock(&new_wrap->mutex);
if (old_fd != new_fd)
  uv_mutex_unlock(&old_wrap->mutex);

uvwasi__free(uvwasi, resolved_old_path);
uvwasi__free(uvwasi, resolved_new_path);
return err;
2226}


2229uvwasi_errno_t uvwasi_path_symlink(uvwasi_t* uvwasi,
                                 const char* old_path,
                                 uvwasi_size_t old_path_len,
                                 uvwasi_fd_t fd,
                                 const char* new_path,
                                 uvwasi_size_t new_path_len) {
char* resolved_new_path;
struct uvwasi_fd_wrap_t* wrap;
uvwasi_errno_t err;
uv_fs_t req;
int r;

UVWASI_DEBUG("uvwasi_path_symlink(uvwasi=%p, old_path='%s', old_path_len=%d, "
             "fd=%d, new_path='%s', new_path_len=%d)\n",
             uvwasi,
             old_path,
             old_path_len,
             fd,
             new_path,
             new_path_len);

if (uvwasi == NULL((void*)0) || old_path == NULL((void*)0) || new_path == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_PATH_SYMLINK(1 << 24),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__resolve_path(uvwasi,
                           wrap,
                           new_path,
                           new_path_len,
                           &resolved_new_path,
                           0);
if (err != UVWASI_ESUCCESS0) {
  uv_mutex_unlock(&wrap->mutex);
  return err;
}

/* Windows support may require setting the flags option. */
r = uv_fs_symlink(NULL((void*)0), &req, old_path, resolved_new_path, 0, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uvwasi__free(uvwasi, resolved_new_path);
uv_fs_req_cleanup(&req);
if (r != 0)
  return uvwasi__translate_uv_error(r);

return UVWASI_ESUCCESS0;
2281}


2284uvwasi_errno_t uvwasi_path_unlink_file(uvwasi_t* uvwasi,
                                     uvwasi_fd_t fd,
                                     const char* path,
                                     uvwasi_size_t path_len) {
char* resolved_path;
struct uvwasi_fd_wrap_t* wrap;
uv_fs_t req;
uvwasi_errno_t err;
int r;

UVWASI_DEBUG("uvwasi_path_unlink_file(uvwasi=%p, fd=%d, path='%s', "
             "path_len=%d)\n",
             uvwasi,
             fd,
             path,
             path_len);

if (uvwasi == NULL((void*)0) || path == NULL((void*)0))
  return UVWASI_EINVAL28;

err = uvwasi_fd_table_get(uvwasi->fds,
                          fd,
                          &wrap,
                          UVWASI_RIGHT_PATH_UNLINK_FILE(1 << 26),
                          0);
if (err != UVWASI_ESUCCESS0)
  return err;

err = uvwasi__resolve_path(uvwasi, wrap, path, path_len, &resolved_path, 0);
if (err != UVWASI_ESUCCESS0) {
  uv_mutex_unlock(&wrap->mutex);
  return err;
}

r = uv_fs_unlink(NULL((void*)0), &req, resolved_path, NULL((void*)0));
uv_mutex_unlock(&wrap->mutex);
uvwasi__free(uvwasi, resolved_path);
uv_fs_req_cleanup(&req);

if (r != 0)
  return uvwasi__translate_uv_error(r);

return UVWASI_ESUCCESS0;
2327}


2330uvwasi_errno_t uvwasi_poll_oneoff(uvwasi_t* uvwasi,
                                const uvwasi_subscription_t* in,
                                uvwasi_event_t* out,
                                uvwasi_size_t nsubscriptions,
                                uvwasi_size_t* nevents) {
struct uvwasi_poll_oneoff_state_t state;
struct uvwasi__poll_fdevent_t* fdevent;
uvwasi_userdata_t timer_userdata;
uvwasi_timestamp_t min_timeout;
uvwasi_timestamp_t cur_timeout;
uvwasi_timestamp_t now;
uvwasi_subscription_t sub;
uvwasi_event_t* event;
uvwasi_errno_t err;
int has_timeout;
uvwasi_size_t i;

UVWASI_DEBUG("uvwasi_poll_oneoff(uvwasi=%p, in=%p, out=%p, "
             "nsubscriptions=%d, nevents=%p)\n",
             uvwasi,
             in,
             out,
             nsubscriptions,
             nevents);

if (uvwasi == NULL((void*)0) || in == NULL((void*)0) || out == NULL((void*)0) ||
    nsubscriptions == 0 || nevents == NULL((void*)0)) {
  return UVWASI_EINVAL28;
}

*nevents = 0;
err = uvwasi__poll_oneoff_state_init(uvwasi, &state, nsubscriptions);
if (err != UVWASI_ESUCCESS0)
  return err;

timer_userdata = 0;
has_timeout = 0;
min_timeout = 0;

for (i = 0; i < nsubscriptions; i++) {
  sub = in[i];

  switch (sub.type) {
    case UVWASI_EVENTTYPE_CLOCK0:
      if (sub.u.clock.flags == UVWASI_SUBSCRIPTION_CLOCK_ABSTIME(1 << 0)) {
        /* Convert absolute time to relative delay. */
        err = uvwasi__clock_gettime_realtime(&now);
        if (err != UVWASI_ESUCCESS0)
          goto exit;

        cur_timeout = sub.u.clock.timeout - now;
      } else {
        cur_timeout = sub.u.clock.timeout;
      }

      if (has_timeout == 0 || cur_timeout < min_timeout) {
        min_timeout = cur_timeout;
        timer_userdata = sub.userdata;
        has_timeout = 1;
      }

      break;
    case UVWASI_EVENTTYPE_FD_READ1:
    case UVWASI_EVENTTYPE_FD_WRITE2:
      err = uvwasi__poll_oneoff_state_add_fdevent(&state, &sub);
      if (err != UVWASI_ESUCCESS0)
        goto exit;

      break;
    default:
      err = UVWASI_EINVAL28;
      goto exit;
  }
}

if (has_timeout == 1) {
  err = uvwasi__poll_oneoff_state_set_timer(&state, min_timeout);
  if (err != UVWASI_ESUCCESS0)
    goto exit;
}

/* Handle poll() errors, then timeouts, then happy path. */
err = uvwasi__poll_oneoff_run(&state);
if (err != UVWASI_ESUCCESS0) {
  goto exit;
} else if (state.result == 0) {
  event = &out[0];
  event->userdata = timer_userdata;
  event->error = UVWASI_ESUCCESS0;
  event->type = UVWASI_EVENTTYPE_CLOCK0;
  *nevents = 1;
} else {
  for (i = 0; i < state.fdevent_cnt; i++) {
    fdevent = &state.fdevents[i];
    event = &out[*nevents];

    event->userdata = fdevent->userdata;
    event->error = fdevent->error;
    event->type = fdevent->type;
    event->u.fd_readwrite.nbytes = 0;
    event->u.fd_readwrite.flags = 0;

    if (fdevent->error != UVWASI_ESUCCESS0)
      ;
    else if ((fdevent->revents & UV_DISCONNECT) != 0)
      event->u.fd_readwrite.flags = UVWASI_EVENT_FD_READWRITE_HANGUP(1 << 0);
    else if ((fdevent->revents & (UV_READABLE | UV_WRITABLE)) != 0)
      ; /* TODO(cjihrig): Set nbytes if type is UVWASI_EVENTTYPE_FD_READ. */
    else
      continue;

    *nevents = *nevents + 1;
  }
}

err = UVWASI_ESUCCESS0;

2447exit:
uvwasi__poll_oneoff_state_cleanup(&state);
return err;
2450}


2453uvwasi_errno_t uvwasi_proc_exit(uvwasi_t* uvwasi, uvwasi_exitcode_t rval) {
UVWASI_DEBUG("uvwasi_proc_exit(uvwasi=%p, rval=%d)\n", uvwasi, rval);
exit(rval);
return UVWASI_ESUCCESS0; /* This doesn't happen. */
2457}


2460uvwasi_errno_t uvwasi_proc_raise(uvwasi_t* uvwasi, uvwasi_signal_t sig) {
int r;

UVWASI_DEBUG("uvwasi_proc_raise(uvwasi=%p, sig=%d)\n", uvwasi, sig);

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

r = uvwasi__translate_to_uv_signal(sig);
if (r == -1)
  return UVWASI_ENOSYS52;

r = uv_kill(uv_os_getpid(), r);
if (r != 0)
  return uvwasi__translate_uv_error(r);

return UVWASI_ESUCCESS0;
2477}


2480uvwasi_errno_t uvwasi_random_get(uvwasi_t* uvwasi,
                               void* buf,
                               uvwasi_size_t buf_len) {
int r;

UVWASI_DEBUG("uvwasi_random_get(uvwasi=%p, buf=%p, buf_len=%d)\n",
             uvwasi,
             buf,
             buf_len);

if (uvwasi == NULL((void*)0) || buf == NULL((void*)0))
  return UVWASI_EINVAL28;

r = uv_random(NULL((void*)0), NULL((void*)0), buf, buf_len, 0, NULL((void*)0));
if (r != 0)
  return uvwasi__translate_uv_error(r);

return UVWASI_ESUCCESS0;
2498}


2501uvwasi_errno_t uvwasi_sched_yield(uvwasi_t* uvwasi) {
UVWASI_DEBUG("uvwasi_sched_yield(uvwasi=%p)\n", uvwasi);

if (uvwasi == NULL((void*)0))
  return UVWASI_EINVAL28;

2507#ifndef _WIN32
if (0 != sched_yield())
  return uvwasi__translate_uv_error(uv_translate_sys_error(errno(*__errno_location ())));
2510#else
SwitchToThread();
2512#endif /* _WIN32 */

return UVWASI_ESUCCESS0;
2515}


2518uvwasi_errno_t uvwasi_sock_recv(uvwasi_t* uvwasi,
                              uvwasi_fd_t sock,
                              const uvwasi_iovec_t* ri_data,
                              uvwasi_size_t ri_data_len,
                              uvwasi_riflags_t ri_flags,
                              uvwasi_size_t* ro_datalen,
                              uvwasi_roflags_t* ro_flags) {
/* TODO(cjihrig): Waiting to implement, pending
                  https://github.com/WebAssembly/WASI/issues/4 */
UVWASI_DEBUG("uvwasi_sock_recv(uvwasi=%p, unimplemented)\n", uvwasi);
return UVWASI_ENOTSUP58;
2529}


2532uvwasi_errno_t uvwasi_sock_send(uvwasi_t* uvwasi,
                              uvwasi_fd_t sock,
                              const uvwasi_ciovec_t* si_data,
                              uvwasi_size_t si_data_len,
                              uvwasi_siflags_t si_flags,
                              uvwasi_size_t* so_datalen) {
/* TODO(cjihrig): Waiting to implement, pending
                  https://github.com/WebAssembly/WASI/issues/4 */
UVWASI_DEBUG("uvwasi_sock_send(uvwasi=%p, unimplemented)\n", uvwasi);
return UVWASI_ENOTSUP58;
2542}


2545uvwasi_errno_t uvwasi_sock_shutdown(uvwasi_t* uvwasi,
                                  uvwasi_fd_t sock,
                                  uvwasi_sdflags_t how) {
/* TODO(cjihrig): Waiting to implement, pending
                  https://github.com/WebAssembly/WASI/issues/4 */
UVWASI_DEBUG("uvwasi_sock_shutdown(uvwasi=%p, unimplemented)\n", uvwasi);
return UVWASI_ENOTSUP58;
2552}


2555const char* uvwasi_embedder_err_code_to_string(uvwasi_errno_t code) {
switch (code) {
2557#define V(errcode) case errcode: return #errcode;
  V(UVWASI_E2BIG1)
  V(UVWASI_EACCES2)
  V(UVWASI_EADDRINUSE3)
  V(UVWASI_EADDRNOTAVAIL4)
  V(UVWASI_EAFNOSUPPORT5)
  V(UVWASI_EAGAIN6)
  V(UVWASI_EALREADY7)
  V(UVWASI_EBADF8)
  V(UVWASI_EBADMSG9)
  V(UVWASI_EBUSY10)
  V(UVWASI_ECANCELED11)
  V(UVWASI_ECHILD12)
  V(UVWASI_ECONNABORTED13)
  V(UVWASI_ECONNREFUSED14)
  V(UVWASI_ECONNRESET15)
  V(UVWASI_EDEADLK16)
  V(UVWASI_EDESTADDRREQ17)
  V(UVWASI_EDOM18)
  V(UVWASI_EDQUOT19)
  V(UVWASI_EEXIST20)
  V(UVWASI_EFAULT21)
  V(UVWASI_EFBIG22)
  V(UVWASI_EHOSTUNREACH23)
  V(UVWASI_EIDRM24)
  V(UVWASI_EILSEQ25)
  V(UVWASI_EINPROGRESS26)
  V(UVWASI_EINTR27)
  V(UVWASI_EINVAL28)
  V(UVWASI_EIO29)
  V(UVWASI_EISCONN30)
  V(UVWASI_EISDIR31)
  V(UVWASI_ELOOP32)
  V(UVWASI_EMFILE33)
  V(UVWASI_EMLINK34)
  V(UVWASI_EMSGSIZE35)
  V(UVWASI_EMULTIHOP36)
  V(UVWASI_ENAMETOOLONG37)
  V(UVWASI_ENETDOWN38)
  V(UVWASI_ENETRESET39)
  V(UVWASI_ENETUNREACH40)
  V(UVWASI_ENFILE41)
  V(UVWASI_ENOBUFS42)
  V(UVWASI_ENODEV43)
  V(UVWASI_ENOENT44)
  V(UVWASI_ENOEXEC45)
  V(UVWASI_ENOLCK46)
  V(UVWASI_ENOLINK47)
  V(UVWASI_ENOMEM48)
  V(UVWASI_ENOMSG49)
  V(UVWASI_ENOPROTOOPT50)
  V(UVWASI_ENOSPC51)
  V(UVWASI_ENOSYS52)
  V(UVWASI_ENOTCONN53)
  V(UVWASI_ENOTDIR54)
  V(UVWASI_ENOTEMPTY55)
  V(UVWASI_ENOTRECOVERABLE56)
  V(UVWASI_ENOTSOCK57)
  V(UVWASI_ENOTSUP58)
  V(UVWASI_ENOTTY59)
  V(UVWASI_ENXIO60)
  V(UVWASI_EOVERFLOW61)
  V(UVWASI_EOWNERDEAD62)
  V(UVWASI_EPERM63)
  V(UVWASI_EPIPE64)
  V(UVWASI_EPROTO65)
  V(UVWASI_EPROTONOSUPPORT66)
  V(UVWASI_EPROTOTYPE67)
  V(UVWASI_ERANGE68)
  V(UVWASI_EROFS69)
  V(UVWASI_ESPIPE70)
  V(UVWASI_ESRCH71)
  V(UVWASI_ESTALE72)
  V(UVWASI_ETIMEDOUT73)
  V(UVWASI_ETXTBSY74)
  V(UVWASI_EXDEV75)
  V(UVWASI_ENOTCAPABLE76)
  V(UVWASI_ESUCCESS0)
2635#undef V
  default:
    return "UVWASI_UNKNOWN_ERROR";
}
2639}