native_client_sdk/src/libraries/nacl_io/kernel_wrap_win.cc

   1 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
   2 // Use of this source code is governed by a BSD-style license that can be
   3 // found in the LICENSE file.
   4
   5 // The entire file is wrapped in this #if. We do this so this .cc file can be
   6 // compiled, even on a non-Windows build.
   7 #if defined(WIN32)
   8
   9 #include "nacl_io/kernel_wrap.h"
  10 #include <errno.h>
  11 #include <fcntl.h>
  12 #include <stdarg.h>
  13 #include <stdlib.h>
  14 #include <string.h>
  15 #include <sys/types.h>  // This must be included before <sys/stat.h>.
  16 #include <sys/stat.h>
  17 #include "nacl_io/kernel_intercept.h"
  18
  19 #include <windows.h>
  20
  21 namespace {
  22
  23 template <typename SrcStat, typename DstStat>
  24 void CopyStat(const SrcStat* src, DstStat* dst) {
  25   memset(dst, 0, sizeof(DstStat));
  26   dst->st_dev = src->st_dev;
  27   dst->st_ino = src->st_ino;
  28   dst->st_mode = src->st_mode;
  29   dst->st_nlink = src->st_nlink;
  30   dst->st_uid = src->st_uid;
  31   dst->st_gid = src->st_gid;
  32   dst->st_rdev = src->st_rdev;
  33   dst->st_size = src->st_size;
  34   dst->st_atime = src->st_atime;
  35   dst->st_mtime = src->st_mtime;
  36   dst->st_ctime = src->st_ctime;
  37 }
  38
  39 }  // namespace
  40
  41 EXTERN_C_BEGIN
  42
  43 // This needs to be included because it is defined in read.c, which we wish to
  44 // override. Define with dummy values for now... though this seems like it will
  45 // break ftelli64/fgetpos/fstream.
  46 char _lookuptrailbytes[256] = {0};
  47
  48 int _access(const char* path, int amode) {
  49   return ki_access(path, amode);
  50 }
  51
  52 int _chdir(const char* path) {
  53   return ki_chdir(path);
  54 }
  55
  56 int _chmod(const char* path, mode_t mode) {
  57   return ki_chmod(path, mode);
  58 }
  59
  60 int _close(int fd) {
  61   return ki_close(fd);
  62 }
  63
  64 int _close_nolock(int fd) {
  65   return ki_close(fd);
  66 }
  67
  68 int _dup(int oldfd) {
  69   return ki_dup(oldfd);
  70 }
  71
  72 int _dup2(int oldfd, int newfd) {
  73   return ki_dup2(oldfd, newfd);
  74 }
  75
  76 int _fstat32(int fd, struct _stat32* buf) {
  77   struct stat ki_buf;
  78   int res = ki_fstat(fd, &ki_buf);
  79   CopyStat(&ki_buf, buf);
  80   return res;
  81 }
  82
  83 int _fstat64(int fd, struct _stat64* buf) {
  84   struct stat ki_buf;
  85   int res = ki_fstat(fd, &ki_buf);
  86   CopyStat(&ki_buf, buf);
  87   return res;
  88 }
  89
  90 int _fstat32i64(int fd, struct _stat32i64* buf) {
  91   struct stat ki_buf;
  92   int res = ki_fstat(fd, &ki_buf);
  93   CopyStat(&ki_buf, buf);
  94   return res;
  95 }
  96
  97 int _fstat64i32(int fd, struct _stat64i32* buf) {
  98   struct stat ki_buf;
  99   int res = ki_fstat(fd, &ki_buf);
 100   CopyStat(&ki_buf, buf);
 101   return res;
 102 }
 103
 104 char* _getcwd(char* buf, int size) {
 105   // If size is 0, allocate as much as we need.
 106   if (size == 0) {
 107     char stack_buf[MAX_PATH + 1];
 108     if (!ki_getcwd(stack_buf, MAX_PATH))
 109       return NULL;
 110     size = strlen(stack_buf) + 1;
 111   }
 112   // Allocate the buffer if needed
 113   if (buf == NULL) {
 114     buf = static_cast<char*>(malloc(size));
 115   }
 116   return ki_getcwd(buf, size);
 117 }
 118
 119 int _isatty(int fd) {
 120   return ki_isatty(fd);
 121 }
 122
 123 off_t _lseek(int fd, off_t offset, int whence) {
 124   return ki_lseek(fd, offset, whence);
 125 }
 126
 127 int _mkdir(const char* path) {
 128   return ki_mkdir(path, 0777);
 129 }
 130
 131 int _open(const char* path, int oflag, ...) {
 132   va_list list;
 133   int pmode = 0;
 134   if (oflag & _O_CREAT) {
 135     va_start(list, oflag);
 136     pmode = va_arg(list, int);
 137     va_end(list);
 138   }
 139   return ki_open(path, oflag, (mode_t) pmode);
 140 }
 141
 142 int _sopen(const char* path, int oflag, int shflag) {
 143   return ki_open(path, oflag);
 144 }
 145
 146 errno_t _sopen_s(int* pfh, const char* path, int oflag, int shflag, int pmode) {
 147   *pfh = ki_open(path, oflag);
 148   return (*pfh < 0) ? errno : 0;
 149 }
 150
 151 int _read(int fd, void* buf, size_t nbyte) {
 152   if (!ki_is_initialized())
 153     return 0;
 154
 155   return ki_read(fd, buf, nbyte);
 156 }
 157
 158 int _read_nolock(int fd, void* buf, size_t nbyte) {
 159   if (!ki_is_initialized())
 160     return 0;
 161
 162   return ki_read(fd, buf, nbyte);
 163 }
 164
 165 int _rmdir(const char* path) {
 166   return ki_rmdir(path);
 167 }
 168
 169 int setenv(const char* name, const char* value, int overwrite) {
 170   if (0 == overwrite && NULL != getenv(name)) {
 171     return 0;
 172   }
 173   errno_t result = _putenv_s(name, value);
 174   if (result != 0) {
 175     errno = result;
 176     return -1;
 177   } else {
 178     return 0;
 179   }
 180 }
 181
 182 int _stat32(const char* path, struct _stat32* buf) {
 183   struct stat ki_buf;
 184   int res = ki_stat(path, &ki_buf);
 185   CopyStat(&ki_buf, buf);
 186   return res;
 187 }
 188
 189 int _stat64(const char* path, struct _stat64* buf) {
 190   struct stat ki_buf;
 191   int res = ki_stat(path, &ki_buf);
 192   CopyStat(&ki_buf, buf);
 193   return res;
 194 }
 195
 196 int _stat64i32(const char* path, struct _stat64i32* buf) {
 197   struct stat ki_buf;
 198   int res = ki_stat(path, &ki_buf);
 199   CopyStat(&ki_buf, buf);
 200   return res;
 201 }
 202
 203 int _stat32i64(const char* path, struct _stat32i64* buf) {
 204   struct stat ki_buf;
 205   int res = ki_stat(path, &ki_buf);
 206   CopyStat(&ki_buf, buf);
 207   return res;
 208 }
 209
 210 int _unlink(const char* path) {
 211   return ki_unlink(path);
 212 }
 213
 214 int _utime(const char* filename, const struct utimbuf* times) {
 215   return ki_utime(filename, times);
 216 }
 217
 218 int _write(int fd, const void* buf, size_t nbyte) {
 219   if (!ki_is_initialized())
 220     return 0;
 221
 222   return ki_write(fd, buf, nbyte);
 223 }
 224
 225 // Do nothing for Windows, we replace the library at link time.
 226 void kernel_wrap_init() {
 227 }
 228
 229 void kernel_wrap_uninit() {
 230 }
 231
 232 EXTERN_C_END
 233
 234 #endif   // defined(WIN32)