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 21namespace { 22 23template <typename SrcStat, typename DstStat> 24void 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 41EXTERN_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. 46char _lookuptrailbytes[256] = {0}; 47 48int _access(const char* path, int amode) { 49 return ki_access(path, amode); 50} 51 52int _chdir(const char* path) { 53 return ki_chdir(path); 54} 55 56int _chmod(const char* path, mode_t mode) { 57 return ki_chmod(path, mode); 58} 59 60int _close(int fd) { 61 return ki_close(fd); 62} 63 64int _close_nolock(int fd) { 65 return ki_close(fd); 66} 67 68int _dup(int oldfd) { 69 return ki_dup(oldfd); 70} 71 72int _dup2(int oldfd, int newfd) { 73 return ki_dup2(oldfd, newfd); 74} 75 76int _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 83int _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 90int _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 97int _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 104char* _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 119int _isatty(int fd) { 120 return ki_isatty(fd); 121} 122 123off_t _lseek(int fd, off_t offset, int whence) { 124 return ki_lseek(fd, offset, whence); 125} 126 127int _mkdir(const char* path) { 128 return ki_mkdir(path, 0777); 129} 130 131int _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 142int _sopen(const char* path, int oflag, int shflag) { 143 return ki_open(path, oflag); 144} 145 146errno_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 151int _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 158int _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 165int _rmdir(const char* path) { 166 return ki_rmdir(path); 167} 168 169int 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 182int _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 189int _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 196int _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 203int _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 210int _unlink(const char* path) { 211 return ki_unlink(path); 212} 213 214int _utime(const char* filename, const struct utimbuf* times) { 215 return ki_utime(filename, times); 216} 217 218int _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. 226void kernel_wrap_init() { 227} 228 229void kernel_wrap_uninit() { 230} 231 232EXTERN_C_END 233 234#endif // defined(WIN32) 235