1/*
2 * Copyright 2011, Ingo Weinhold, ingo_weinhold@gmx.de.
3 * Distributed under the terms of the MIT License.
4 */
5
6
7#include <stdarg.h>
8#include <fcntl.h>
9
10#include "symbol_visibility.h"
11
12#include "remapped_functions.h"
13
14
15extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
16fchmod(int fd, mode_t mode)
17{
18	HIDDEN_FUNCTION(fchmod);
19
20	return _haiku_build_fchmod(fd, mode);
21}
22
23
24extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
25fchmodat(int fd, const char* path, mode_t mode, int flag)
26{
27	HIDDEN_FUNCTION(fchmodat);
28
29	return _haiku_build_fchmodat(fd, path, mode, flag);
30}
31
32
33extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
34fstat(int fd, struct stat* st)
35{
36	HIDDEN_FUNCTION(fstat);
37
38	return _haiku_build_fstat(fd, st);
39}
40
41
42extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
43fstatat(int fd, const char* path, struct stat* st, int flag)
44{
45	HIDDEN_FUNCTION(fstatat);
46
47	return _haiku_build_fstatat(fd, path, st, flag);
48}
49
50
51extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
52mkdirat(int fd, const char* path, mode_t mode)
53{
54	HIDDEN_FUNCTION(mkdirat);
55
56	return _haiku_build_mkdirat(fd, path, mode);
57}
58
59
60extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
61mkfifoat(int fd, const char* path, mode_t mode)
62{
63	HIDDEN_FUNCTION(mkfifoat);
64
65	return _haiku_build_mkfifoat(fd, path, mode);
66}
67
68
69extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
70utimensat(int fd, const char* path, const struct timespec times[2], int flag)
71{
72	HIDDEN_FUNCTION(utimensat);
73
74	return _haiku_build_utimensat(fd, path, times, flag);
75}
76
77
78extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
79futimens(int fd, const struct timespec times[2])
80{
81	HIDDEN_FUNCTION(futimens);
82
83	return _haiku_build_futimens(fd, times);
84}
85
86
87extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
88faccessat(int fd, const char* path, int accessMode, int flag)
89{
90	HIDDEN_FUNCTION(faccessat);
91
92	return _haiku_build_faccessat(fd, path, accessMode, flag);
93}
94
95
96extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
97fchdir(int fd)
98{
99	HIDDEN_FUNCTION(fchdir);
100
101	return _haiku_build_fchdir(fd);
102}
103
104
105extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
106close(int fd)
107{
108	HIDDEN_FUNCTION(close);
109
110	return _haiku_build_close(fd);
111}
112
113
114extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
115dup(int fd)
116{
117	HIDDEN_FUNCTION(dup);
118
119	return _haiku_build_dup(fd);
120}
121
122
123extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
124dup2(int fd1, int fd2)
125{
126	HIDDEN_FUNCTION(dup2);
127
128	return _haiku_build_dup2(fd1, fd2);
129}
130
131
132extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
133linkat(int toFD, const char* toPath, int pathFD, const char* path, int flag)
134{
135	HIDDEN_FUNCTION(linkat);
136
137	return _haiku_build_linkat(toFD, toPath, pathFD, path, flag);
138}
139
140
141extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
142unlinkat(int fd, const char* path, int flag)
143{
144	HIDDEN_FUNCTION(unlinkat);
145
146	return _haiku_build_unlinkat(fd, path, flag);
147}
148
149
150extern "C" ssize_t HIDDEN_FUNCTION_ATTRIBUTE
151readlinkat(int fd, const char* path, char* buffer, size_t bufferSize)
152{
153	HIDDEN_FUNCTION(readlinkat);
154
155	return _haiku_build_readlinkat(fd, path, buffer, bufferSize);
156}
157
158
159extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
160symlinkat(const char* toPath, int fd, const char* symlinkPath)
161{
162	HIDDEN_FUNCTION(symlinkat);
163
164	return _haiku_build_symlinkat(toPath, fd, symlinkPath);
165}
166
167
168extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
169ftruncate(int fd, off_t newSize)
170{
171	HIDDEN_FUNCTION(ftruncate);
172
173	return _haiku_build_ftruncate(fd, newSize);
174}
175
176
177extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
178fchown(int fd, uid_t owner, gid_t group)
179{
180	HIDDEN_FUNCTION(fchown);
181
182	return _haiku_build_fchown(fd, owner, group);
183}
184
185
186extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
187fchownat(int fd, const char* path, uid_t owner, gid_t group, int flag)
188{
189	HIDDEN_FUNCTION(fchownat);
190
191	return _haiku_build_fchownat(fd, path, owner, group, flag);
192}
193
194
195extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
196mknodat(int fd, const char* name, mode_t mode, dev_t dev)
197{
198	HIDDEN_FUNCTION(mknodat);
199
200	return _haiku_build_mknodat(fd, name, mode, dev);
201}
202
203
204extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
205creat(const char* path, mode_t mode)
206{
207	HIDDEN_FUNCTION(creat);
208
209	return _haiku_build_creat(path, mode);
210}
211
212
213extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
214open(const char* path, int openMode, ...)
215{
216	HIDDEN_FUNCTION(open);
217
218	mode_t permissions = 0;
219	if ((openMode & O_CREAT) != 0) {
220		va_list args;
221		va_start(args, openMode);
222		mode_t mask = umask(0);
223		umask(mask);
224		permissions = va_arg(args, int);
225		va_end(args);
226	}
227
228	return _haiku_build_open(path, openMode, permissions);
229}
230
231
232extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
233openat(int fd, const char* path, int openMode, ...)
234{
235	HIDDEN_FUNCTION(openat);
236
237	mode_t permissions = 0;
238	if ((openMode & O_CREAT) != 0) {
239		va_list args;
240		va_start(args, openMode);
241		mode_t mask = umask(0);
242		umask(mask);
243		permissions = va_arg(args, int);
244		va_end(args);
245	}
246
247	return _haiku_build_openat(fd, path, openMode, permissions);
248}
249
250
251extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
252fcntl(int fd, int op, ...)
253{
254	HIDDEN_FUNCTION(fcntl);
255
256	va_list args;
257	va_start(args, op);
258	int argument = va_arg(args, int);
259	va_end(args);
260
261	return _haiku_build_fcntl(fd, op, argument);
262}
263
264
265extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
266renameat(int fromFD, const char* from, int toFD, const char* to)
267{
268	HIDDEN_FUNCTION(renameat);
269
270	return _haiku_build_renameat(fromFD, from, toFD, to);
271}
272
273
274#if defined(HAIKU_HOST_USE_XATTR) && defined(HAIKU_HOST_PLATFORM_HAIKU)
275// fs_attr_* functions only need to be remapped on Haiku
276
277
278extern "C" addr_t HIDDEN_FUNCTION_ATTRIBUTE
279fs_open_attr_dir(const char *path)
280{
281	HIDDEN_FUNCTION(fs_open_attr_dir);
282
283	return (addr_t)_haiku_build_fs_open_attr_dir(path);
284}
285
286
287extern "C" addr_t HIDDEN_FUNCTION_ATTRIBUTE
288fs_lopen_attr_dir(const char *path)
289{
290	HIDDEN_FUNCTION(fs_lopen_attr_dir);
291
292	return (addr_t)_haiku_build_fs_lopen_attr_dir(path);
293}
294
295
296extern "C" addr_t HIDDEN_FUNCTION_ATTRIBUTE
297fs_fopen_attr_dir(int fd)
298{
299	HIDDEN_FUNCTION(fs_fopen_attr_dir);
300
301	return (addr_t)_haiku_build_fs_fopen_attr_dir(fd);
302}
303
304
305extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
306fs_close_attr_dir(void *dir)
307{
308	HIDDEN_FUNCTION(fs_close_attr_dir);
309
310	return _haiku_build_fs_close_attr_dir(dir);
311}
312
313
314extern "C" addr_t HIDDEN_FUNCTION_ATTRIBUTE
315fs_read_attr_dir(void *dir)
316{
317	HIDDEN_FUNCTION(fs_read_attr_dir);
318
319	return (addr_t)_haiku_build_fs_read_attr_dir(dir);
320}
321
322
323extern "C" void HIDDEN_FUNCTION_ATTRIBUTE
324fs_rewind_attr_dir(void *dir)
325{
326	HIDDEN_FUNCTION(fs_rewind_attr_dir);
327
328	_haiku_build_fs_rewind_attr_dir(dir);
329}
330
331
332extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
333fs_fopen_attr(int fd, const char *attribute, uint32 type, int openMode)
334{
335	HIDDEN_FUNCTION(fs_fopen_attr);
336
337	return _haiku_build_fs_fopen_attr(fd, attribute, type, openMode);
338}
339
340
341extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
342fs_close_attr(int fd)
343{
344	HIDDEN_FUNCTION(fs_close_attr);
345
346	return _haiku_build_fs_close_attr(fd);
347}
348
349
350extern "C" ssize_t HIDDEN_FUNCTION_ATTRIBUTE
351fs_read_attr(int fd, const char* attribute, uint32 type, off_t pos,
352	void *buffer, size_t readBytes)
353{
354	HIDDEN_FUNCTION(fs_read_attr);
355
356	return _haiku_build_fs_read_attr(fd, attribute, type, pos, buffer,
357		readBytes);
358}
359
360
361extern "C" ssize_t HIDDEN_FUNCTION_ATTRIBUTE
362fs_write_attr(int fd, const char* attribute, uint32 type, off_t pos,
363	const void *buffer, size_t writeBytes)
364{
365	HIDDEN_FUNCTION(fs_write_attr);
366
367	return _haiku_build_fs_write_attr(fd, attribute, type, pos, buffer,
368		writeBytes);
369}
370
371
372extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
373fs_remove_attr(int fd, const char* attribute)
374{
375	HIDDEN_FUNCTION(fs_remove_attr);
376
377	return _haiku_build_fs_remove_attr(fd, attribute);
378}
379
380
381extern "C" int HIDDEN_FUNCTION_ATTRIBUTE
382fs_stat_attr(int fd, const char *attribute, struct attr_info *attrInfo)
383{
384	HIDDEN_FUNCTION(fs_stat_attr);
385
386	return _haiku_build_fs_stat_attr(fd, attribute, attrInfo);
387}
388
389#endif // defined(HAIKU_HOST_USE_XATTR) && defined(HAIKU_HOST_PLATFORM_HAIKU)
390