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