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) 235
