shfile.c@ 2296

Last change on this file since 2296 was 2296, checked in by bird, 16 years ago
kash: avoid file steams in the trace code.
Property svn:eol-style set to `LF` Property svn:keywords set to `Id`
File size: 31.8 KB

Line
1	/* $Id: shfile.c 2296 2009-03-01 01:54:30Z bird $ */
2	/** @file
3	*
4	* File management.
5	*
6	* Copyright (c) 2007-2009 knut st. osmundsen <bird-kBuild-spamix@anduin.net>
7	*
8	*
9	* This file is part of kBuild.
10	*
11	* kBuild is free software; you can redistribute it and/or modify
12	* it under the terms of the GNU General Public License as published by
13	* the Free Software Foundation; either version 2 of the License, or
14	* (at your option) any later version.
15	*
16	* kBuild is distributed in the hope that it will be useful,
17	* but WITHOUT ANY WARRANTY; without even the implied warranty of
18	* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
19	* GNU General Public License for more details.
20	*
21	* You should have received a copy of the GNU General Public License
22	* along with kBuild; if not, write to the Free Software
23	* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
24	*
25	*/
26
27	#include "shfile.h"
28	#include "shinstance.h" /* TRACE2 */
29	#include <stdlib.h>
30	#include <stdio.h>
31	#include <assert.h>
32
33	#if K_OS == K_OS_WINDOWS
34	# include <limits.h>
35	# ifndef PIPE_BUF
36	# define PIPE_BUF 512
37	# endif
38	# include <Windows.h>
39	#else
40	# include <unistd.h>
41	# include <fcntl.h>
42	# include <dirent.h>
43	#endif
44
45	#if defined(DEBUG) && defined(TRACE_VIA_STDIO)
46	extern FILE *tracefile;
47	#endif
48
49
50	/*******************************************************************************
51	* Defined Constants And Macros *
52	*******************************************************************************/
53	/** @def SHFILE_IN_USE
54	* Whether the file descriptor table stuff is actually in use or not.
55	*/
56	#if !defined(SH_PURE_STUB_MODE) \
57	&& ( K_OS == K_OS_WINDOWS \
58	\|\| ( !defined(SH_STUB_MODE) \
59	&& !defined(SH_FORKED_MODE)) \
60	)
61	# define SHFILE_IN_USE
62	#endif
63	/** The max file table size. */
64	#define SHFILE_MAX 1024
65	/** The file table growth rate. */
66	#define SHFILE_GROW 64
67	/** The min native unix file descriptor. */
68	#define SHFILE_UNIX_MIN_FD 32
69	/** The path buffer size we use. */
70	#define SHFILE_MAX_PATH 4096
71
72	/** Set errno and return. Doing a trace in debug build. */
73	#define RETURN_ERROR(rc, err, msg) \
74	do { \
75	TRACE2((NULL, "%s: " ## msg ## " - returning %d / %d\n", __FUNCTION__, (rc), (err))); \
76	errno = (err); \
77	return (rc); \
78	} while (0)
79
80
81	#ifdef SHFILE_IN_USE
82
83	/**
84	* Close the specified native handle.
85	*
86	* @param native The native file handle.
87	* @param flags The flags in case they might come in handy later.
88	*/
89	static void shfile_native_close(intptr_t native, unsigned flags)
90	{
91	#if K_OS == K_OS_WINDOWS
92	BOOL fRc = CloseHandle((HANDLE)native);
93	assert(fRc); (void)fRc;
94	#else
95	int s = errno;
96	close(native);
97	errno = s;
98	#endif
99	(void)flags;
100	}
101
102	/**
103	* Inserts the file into the descriptor table.
104	*
105	* If we're out of memory and cannot extend the table, we'll close the
106	* file, set errno to EMFILE and return -1.
107	*
108	* @returns The file descriptor number. -1 and errno on failure.
109	* @param pfdtab The file descriptor table.
110	* @param native The native file handle.
111	* @param flags The flags the it was created with.
112	* @param fdMin The minimum file descriptor number, pass -1 if any is ok.
113	* @param who Who we're doing this for (for logging purposes).
114	*/
115	static int shfile_insert(shfdtab pfdtab, intptr_t native, unsigned flags, int fdMin, const char who)
116	{
117	shmtxtmp tmp;
118	int fd;
119	int i;
120
121	/*
122	* Fend of bad stuff.
123	*/
124	if (fdMin >= SHFILE_MAX)
125	{
126	errno = EMFILE;
127	return -1;
128	}
129
130	shmtx_enter(&pfdtab->mtx, &tmp);
131
132	/*
133	* Search for a fitting unused location.
134	*/
135	fd = -1;
136	for (i = 0; (unsigned)i < pfdtab->size; i++)
137	if ( i >= fdMin
138	&& pfdtab->tab[i].fd == -1)
139	{
140	fd = i;
141	break;
142	}
143	if (fd == -1)
144	{
145	/*
146	* Grow the descriptor table.
147	*/
148	shfile *new_tab;
149	int new_size = pfdtab->size + SHFILE_GROW;
150	while (new_size < fdMin)
151	new_size += SHFILE_GROW;
152	new_tab = sh_realloc(shthread_get_shell(), pfdtab->tab, new_size * sizeof(shfile));
153	if (new_tab)
154	{
155	for (i = pfdtab->size; i < new_size; i++)
156	{
157	new_tab[i].fd = -1;
158	new_tab[i].flags = 0;
159	new_tab[i].native = -1;
160	}
161
162	fd = pfdtab->size;
163	if (fd < fdMin)
164	fd = fdMin;
165
166	pfdtab->tab = new_tab;
167	pfdtab->size = new_size;
168	}
169	}
170
171	/*
172	* Fill in the entry if we've found one.
173	*/
174	if (fd != -1)
175	{
176	pfdtab->tab[fd].fd = fd;
177	pfdtab->tab[fd].flags = flags;
178	pfdtab->tab[fd].cloexec = 0;
179	pfdtab->tab[fd].native = native;
180	}
181	else
182	shfile_native_close(native, flags);
183
184	shmtx_leave(&pfdtab->mtx, &tmp);
185
186	if (fd == -1)
187	errno = EMFILE;
188	(void)who;
189	return fd;
190	}
191
192	/**
193	* Gets a file descriptor and lock the file descriptor table.
194	*
195	* @returns Pointer to the file and table ownership on success,
196	* NULL and errno set to EBADF on failure.
197	* @param pfdtab The file descriptor table.
198	* @param fd The file descriptor number.
199	* @param ptmp See shmtx_enter.
200	*/
201	static shfile shfile_get(shfdtab pfdtab, int fd, shmtxtmp *ptmp)
202	{
203	shfile *file = NULL;
204	if ( fd >= 0
205	&& (unsigned)fd < pfdtab->size)
206	{
207	shmtx_enter(&pfdtab->mtx, ptmp);
208	if ((unsigned)fd < pfdtab->size
209	&& pfdtab->tab[fd].fd != -1)
210	file = &pfdtab->tab[fd];
211	else
212	shmtx_leave(&pfdtab->mtx, ptmp);
213	}
214	if (!file)
215	errno = EBADF;
216	return file;
217	}
218
219	/**
220	* Puts back a file descriptor and releases the table ownership.
221	*
222	* @param pfdtab The file descriptor table.
223	* @param file The file.
224	* @param ptmp See shmtx_leave.
225	*/
226	static void shfile_put(shfdtab pfdtab, shfile file, shmtxtmp *ptmp)
227	{
228	shmtx_leave(&pfdtab->mtx, ptmp);
229	assert(file);
230	(void)file;
231	}
232
233	/**
234	* Constructs a path from the current directory and the passed in path.
235	*
236	* @returns 0 on success, -1 and errno set to ENAMETOOLONG or EINVAL on failure.
237	*
238	* @param pfdtab The file descriptor table
239	* @param path The path the caller supplied.
240	* @param buf Where to put the path. This is assumed to be SHFILE_MAX_PATH
241	* chars in size.
242	*/
243	int shfile_make_path(shfdtab pfdtab, const char path, char *buf)
244	{
245	size_t path_len = strlen(path);
246	if (path_len == 0)
247	{
248	errno = EINVAL;
249	return -1;
250	}
251	if (path_len >= SHFILE_MAX_PATH)
252	{
253	errno = ENAMETOOLONG;
254	return -1;
255	}
256	if ( *path == '/'
257	#if K_OS == K_OS_WINDOWS \|\| K_OS == K_OS_OS2
258	\|\| *path == '\\'
259	\|\| ( *path
260	&& path[1] == ':'
261	&& ( (path >= 'A' && path <= 'Z')
262	\|\| (path >= 'a' && path <= 'z')))
263	#endif
264	)
265	{
266	memcpy(buf, path, path_len + 1);
267	}
268	else
269	{
270	size_t cwd_len;
271	shmtxtmp tmp;
272
273	shmtx_enter(&pfdtab->mtx, &tmp);
274
275	cwd_len = strlen(pfdtab->cwd);
276	memcpy(buf, pfdtab->cwd, cwd_len);
277
278	shmtx_leave(&pfdtab->mtx, &tmp);
279
280	if (cwd_len + path_len + 1 >= SHFILE_MAX_PATH)
281	{
282	errno = ENAMETOOLONG;
283	return -1;
284	}
285	if ( !cwd_len
286	\|\| buf[cwd_len - 1] != '/')
287	buf[cwd_len++] = '/';
288	memcpy(buf + cwd_len, path, path_len + 1);
289	}
290
291	#if K_OS == K_OS_WINDOWS \|\| K_OS == K_OS_OS2
292	if (!strcmp(buf, "/dev/null"))
293	strcpy(buf, "NUL");
294	#endif
295	return 0;
296	}
297
298	# if K_OS == K_OS_WINDOWS
299	/**
300	* Converts a DOS(/Windows) error code to errno,
301	* assigning it to errno.
302	*
303	* @returns -1
304	* @param err The DOS error.
305	*/
306	static int shfile_dos2errno(int err)
307	{
308	switch (err)
309	{
310	case ERROR_BAD_ENVIRONMENT: errno = E2BIG; break;
311	case ERROR_ACCESS_DENIED: errno = EACCES; break;
312	case ERROR_CURRENT_DIRECTORY: errno = EACCES; break;
313	case ERROR_LOCK_VIOLATION: errno = EACCES; break;
314	case ERROR_NETWORK_ACCESS_DENIED: errno = EACCES; break;
315	case ERROR_CANNOT_MAKE: errno = EACCES; break;
316	case ERROR_FAIL_I24: errno = EACCES; break;
317	case ERROR_DRIVE_LOCKED: errno = EACCES; break;
318	case ERROR_SEEK_ON_DEVICE: errno = EACCES; break;
319	case ERROR_NOT_LOCKED: errno = EACCES; break;
320	case ERROR_LOCK_FAILED: errno = EACCES; break;
321	case ERROR_NO_PROC_SLOTS: errno = EAGAIN; break;
322	case ERROR_MAX_THRDS_REACHED: errno = EAGAIN; break;
323	case ERROR_NESTING_NOT_ALLOWED: errno = EAGAIN; break;
324	case ERROR_INVALID_HANDLE: errno = EBADF; break;
325	case ERROR_INVALID_TARGET_HANDLE: errno = EBADF; break;
326	case ERROR_DIRECT_ACCESS_HANDLE: errno = EBADF; break;
327	case ERROR_WAIT_NO_CHILDREN: errno = ECHILD; break;
328	case ERROR_CHILD_NOT_COMPLETE: errno = ECHILD; break;
329	case ERROR_FILE_EXISTS: errno = EEXIST; break;
330	case ERROR_ALREADY_EXISTS: errno = EEXIST; break;
331	case ERROR_INVALID_FUNCTION: errno = EINVAL; break;
332	case ERROR_INVALID_ACCESS: errno = EINVAL; break;
333	case ERROR_INVALID_DATA: errno = EINVAL; break;
334	case ERROR_INVALID_PARAMETER: errno = EINVAL; break;
335	case ERROR_NEGATIVE_SEEK: errno = EINVAL; break;
336	case ERROR_TOO_MANY_OPEN_FILES: errno = EMFILE; break;
337	case ERROR_FILE_NOT_FOUND: errno = ENOENT; break;
338	case ERROR_PATH_NOT_FOUND: errno = ENOENT; break;
339	case ERROR_INVALID_DRIVE: errno = ENOENT; break;
340	case ERROR_NO_MORE_FILES: errno = ENOENT; break;
341	case ERROR_BAD_NETPATH: errno = ENOENT; break;
342	case ERROR_BAD_NET_NAME: errno = ENOENT; break;
343	case ERROR_BAD_PATHNAME: errno = ENOENT; break;
344	case ERROR_FILENAME_EXCED_RANGE: errno = ENOENT; break;
345	case ERROR_BAD_FORMAT: errno = ENOEXEC; break;
346	case ERROR_ARENA_TRASHED: errno = ENOMEM; break;
347	case ERROR_NOT_ENOUGH_MEMORY: errno = ENOMEM; break;
348	case ERROR_INVALID_BLOCK: errno = ENOMEM; break;
349	case ERROR_NOT_ENOUGH_QUOTA: errno = ENOMEM; break;
350	case ERROR_DISK_FULL: errno = ENOSPC; break;
351	case ERROR_DIR_NOT_EMPTY: errno = ENOTEMPTY; break;
352	case ERROR_BROKEN_PIPE: errno = EPIPE; break;
353	case ERROR_NOT_SAME_DEVICE: errno = EXDEV; break;
354	default: errno = EINVAL; break;
355	}
356	return -1;
357	}
358	# endif /* K_OS == K_OS_WINDOWS */
359
360	#endif /* SHFILE_IN_USE */
361
362	/**
363	* Initializes a file descriptor table.
364	*
365	* @returns 0 on success, -1 and errno on failure.
366	* @param pfdtab The table to initialize.
367	* @param inherit File descriptor table to inherit from. If not specified
368	* we will inherit from the current process as it were.
369	*/
370	int shfile_init(shfdtab pfdtab, shfdtab inherit)
371	{
372	int rc;
373
374	pfdtab->cwd = NULL;
375	pfdtab->size = 0;
376	pfdtab->tab = NULL;
377	rc = shmtx_init(&pfdtab->mtx);
378	if (!rc)
379	{
380	#ifdef SHFILE_IN_USE
381	char buf[SHFILE_MAX_PATH];
382	if (getcwd(buf, sizeof(buf)))
383	{
384	pfdtab->cwd = sh_strdup(NULL, buf);
385	if (!inherit)
386	{
387	# if K_OS == K_OS_WINDOWS
388	static const struct
389	{
390	DWORD dwStdHandle;
391	unsigned flags;
392	} aStdHandles[3] =
393	{
394	{ STD_INPUT_HANDLE, _O_RDONLY },
395	{ STD_OUTPUT_HANDLE, _O_WRONLY },
396	{ STD_ERROR_HANDLE, _O_WRONLY }
397	};
398	unsigned i;
399	STARTUPINFO Info;
400
401	rc = 0;
402
403	/* Try pick up the Visual C++ CRT file descriptor info. */
404	__try {
405	GetStartupInfo(&Info);
406	} __except (EXCEPTION_EXECUTE_HANDLER) {
407	memset(&Info, 0, sizeof(Info));
408	}
409	if ( Info.cbReserved2 <= sizeof(int)
410	&& (uintptr_t)Info.lpReserved2 >= 0x1000
411	&& (int )Info.lpReserved2 * (sizeof(int) + sizeof(intptr_t)) + 4 <= Info.cbReserved2
412	&& (int )Info.lpReserved2 <= 2048
413	&& (int )Info.lpReserved2 >= 1)
414	{
415	unsigned c = (int )Info.lpReserved2;
416	char aosfile = (char )Info.lpReserved2 + sizeof(int);
417	intptr_t aosfhnd = (intptr_t )(aosfile + c);
418
419	/** @todo process */
420
421	}
422
423	/* Check the three standard handles. */
424	for (i = 0; i < 3; i++)
425	{
426	HANDLE hFile = GetStdHandle(aStdHandles[i].dwStdHandle);
427	if ( hFile != INVALID_HANDLE_VALUE
428	&& ( (unsigned)i >= pfdtab->size
429	\|\| pfdtab->tab[i].fd == -1))
430	{
431	int fd2 = shfile_insert(pfdtab, (intptr_t)hFile, aStdHandles[i].flags, i, "shtab_init");
432	assert(fd2 == i); (void)fd2;
433	if (fd2 != i)
434	rc = -1;
435	}
436	}
437	# else
438	# endif
439	}
440	else
441	{
442	/** @todo */
443	errno = ENOSYS;
444	rc = -1;
445	}
446	}
447	else
448	rc = -1;
449	#endif
450	}
451	return rc;
452	}
453
454	#if K_OS == K_OS_WINDOWS && defined(SHFILE_IN_USE) //&& defined(SH_FORKED_MODE)
455	/**
456	* Helper for shfork.
457	*
458	* @param pfdtab The file descriptor table.
459	* @param set Whether to make all handles inheritable (1) or
460	* to restore them to the rigth state (0).
461	* @param hndls Where to store the three standard handles.
462	*/
463	void shfile_fork_win(shfdtab pfdtab, int set, intptr_t hndls)
464	{
465	shmtxtmp tmp;
466	unsigned i;
467
468	shmtx_enter(&pfdtab->mtx, &tmp);
469	TRACE2((NULL, "shfile_fork_win:\n"));
470
471	i = pfdtab->size;
472	while (i-- > 0)
473	{
474	if (pfdtab->tab[i].fd == i)
475	{
476	HANDLE hFile = (HANDLE)pfdtab->tab[i].native;
477	DWORD fFlag = (set \|\| !pfdtab->tab[i].cloexec)
478	? HANDLE_FLAG_INHERIT : 0;
479	if (set)
480	TRACE2((NULL, " #%d: native=%#x flags=%#x cloexec=%d fFlag=%#x\n",
481	i, pfdtab->tab[i].flags, hFile, pfdtab->tab[i].cloexec, fFlag));
482
483	if (!SetHandleInformation(hFile, HANDLE_FLAG_INHERIT, fFlag))
484	{
485	DWORD err = GetLastError();
486	assert(0);
487	}
488	}
489	}
490
491	if (hndls)
492	{
493	for (i = 0; i < 3; i++)
494	{
495	if ( pfdtab->size > i
496	&& pfdtab->tab[i].fd == 0)
497	hndls[i] = pfdtab->tab[i].native;
498	else
499	hndls[i] = (intptr_t)INVALID_HANDLE_VALUE;
500	}
501	}
502
503	shmtx_leave(&pfdtab->mtx, &tmp);
504	}
505	#endif
506
507
508	/**
509	* open().
510	*/
511	int shfile_open(shfdtab pfdtab, const char name, unsigned flags, mode_t mode)
512	{
513	int fd;
514	#ifdef SHFILE_IN_USE
515	char absname[SHFILE_MAX_PATH];
516	# if K_OS == K_OS_WINDOWS
517	HANDLE hFile;
518	DWORD dwDesiredAccess;
519	DWORD dwShareMode;
520	DWORD dwCreationDisposition;
521	DWORD dwFlagsAndAttributes;
522	SECURITY_ATTRIBUTES SecurityAttributes;
523
524	# ifndef _O_ACCMODE
525	# define _O_ACCMODE (_O_RDONLY\|_O_WRONLY\|_O_RDWR)
526	# endif
527	switch (flags & (_O_ACCMODE \| _O_APPEND))
528	{
529	case _O_RDONLY: dwDesiredAccess = GENERIC_READ; break;
530	case _O_RDONLY \| _O_APPEND: dwDesiredAccess = GENERIC_READ; break;
531	case _O_WRONLY: dwDesiredAccess = GENERIC_WRITE; break;
532	case _O_WRONLY \| _O_APPEND: dwDesiredAccess = (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA); break;
533	case _O_RDWR: dwDesiredAccess = GENERIC_READ \| GENERIC_WRITE; break;
534	case _O_RDWR \| _O_APPEND: dwDesiredAccess = GENERIC_READ \| (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA); break;
535
536	default:
537	RETURN_ERROR(-1, EINVAL, "invalid mode");
538	}
539
540	dwShareMode = FILE_SHARE_DELETE \| FILE_SHARE_READ \| FILE_SHARE_WRITE;
541
542	SecurityAttributes.nLength = sizeof(SecurityAttributes);
543	SecurityAttributes.lpSecurityDescriptor = NULL;
544	SecurityAttributes.bInheritHandle = (flags & _O_NOINHERIT) == 0;
545
546	if (flags & _O_CREAT)
547	{
548	if ((flags & (_O_EXCL \| _O_TRUNC)) == (_O_EXCL \| _O_TRUNC))
549	RETURN_ERROR(-1, EINVAL, "_O_EXCL \| _O_TRUNC");
550
551	if (flags & _O_TRUNC)
552	dwCreationDisposition = CREATE_ALWAYS; /* not 100%, but close enough */
553	else if (flags & _O_EXCL)
554	dwCreationDisposition = CREATE_NEW;
555	else
556	dwCreationDisposition = OPEN_ALWAYS;
557	}
558	else if (flags & _O_TRUNC)
559	dwCreationDisposition = TRUNCATE_EXISTING;
560	else
561	dwCreationDisposition = OPEN_EXISTING;
562
563	if (!(flags & _O_CREAT) \|\| (mode & 0222))
564	dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
565	else
566	dwFlagsAndAttributes = FILE_ATTRIBUTE_READONLY;
567
568	fd = shfile_make_path(pfdtab, name, &absname[0]);
569	if (!fd)
570	{
571	SetLastError(0);
572	hFile = CreateFileA(absname,
573	dwDesiredAccess,
574	dwShareMode,
575	&SecurityAttributes,
576	dwCreationDisposition,
577	dwFlagsAndAttributes,
578	NULL /* hTemplateFile */);
579	if (hFile != INVALID_HANDLE_VALUE)
580	fd = shfile_insert(pfdtab, (intptr_t)hFile, flags, -1, "shfile_open");
581	else
582	fd = shfile_dos2errno(GetLastError());
583	}
584
585	# else /* K_OS != K_OS_WINDOWS */
586	fd = shfile_make_path(pfdtab, name, &absname[0]);
587	if (!fd)
588	{
589	fd = open(absname, flag, mode);
590	if (fd != -1)
591	{
592	int native = fcntl(fd, F_DUPFD, SHFILE_UNIX_MIN_FD);
593	int s = errno;
594	close(fd);
595	errno = s;
596	if (native != -1)
597	fd = shfile_insert(pfdtab, native, flags, -1, "shfile_open");
598	else
599	fd = -1;
600	}
601	}
602
603	# endif /* K_OS != K_OS_WINDOWS */
604
605	#elif defined(SH_PURE_STUB_MODE)
606	fd = -1;
607	errno = ENOSYS;
608
609	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
610	fd = open(name, flags, mode);
611	#endif
612
613	#if defined(DEBUG) && defined(TRACE_VIA_STDIO)
614	if (tracefile)
615	#endif
616	TRACE2((NULL, "shfile_open(%p:{%s}, %#x, 0%o) -> %d [%d]\n", name, name, flags, mode, fd, errno));
617	return fd;
618	}
619
620	int shfile_pipe(shfdtab *pfdtab, int fds[2])
621	{
622	int rc;
623	int s;
624	#ifdef SHFILE_IN_USE
625	# if K_OS == K_OS_WINDOWS
626	HANDLE hRead = INVALID_HANDLE_VALUE;
627	HANDLE hWrite = INVALID_HANDLE_VALUE;
628	SECURITY_ATTRIBUTES SecurityAttributes;
629
630	SecurityAttributes.nLength = sizeof(SecurityAttributes);
631	SecurityAttributes.lpSecurityDescriptor = NULL;
632	SecurityAttributes.bInheritHandle = TRUE;
633
634	if (!CreatePipe(&hRead, &hWrite, &SecurityAttributes, 4096))
635	{
636	fds[0] = shfile_insert(pfdtab, (intptr_t)hRead, O_RDONLY, -1, "shfile_pipe");
637	if (fds[0] != -1)
638	{
639	fds[1] = shfile_insert(pfdtab, (intptr_t)hWrite, O_WRONLY, -1, "shfile_pipe");
640	if (fds[1] != -1)
641	rc = 0;
642	}
643
644	# else
645	int native_fds[2];
646	if (!pipe(native_fds))
647	{
648	fds[1] = -1;
649	fds[0] = shfile_insert(pfdtab, native_fds[0], O_RDONLY, -1, "shfile_pipe");
650	if (fds[0] != -1)
651	{
652	fds[1] = shfile_insert(pfdtab, native_fds[1], O_WRONLY, -1, "shfile_pipe");
653	if (fds[1] != -1)
654	rc = 0;
655	}
656	# endif
657	s = errno;
658	if (fds[1] == -1)
659	{
660	if (fds[0] != -1)
661	{
662	shmtxtmp tmp;
663	shmtx_enter(&pfdtab->mtx, &tmp);
664	rc = fds[0];
665	pfdtab->tab[rc].fd = -1;
666	pfdtab->tab[rc].flags = 0;
667	pfdtab->tab[rc].native = -1;
668	shmtx_leave(&pfdtab->mtx, &tmp);
669	}
670
671	# if K_OS == K_OS_WINDOWS
672	CloseHandle(hRead);
673	CloseHandle(hWrite);
674	# else
675	close(native_fds[0]);
676	close(native_fds[1]);
677	# endif
678	fds[0] = fds[1] = -1;
679	errno = s;
680	rc = -1;
681	}
682	}
683
684	#elif defined(SH_PURE_STUB_MODE)
685	rc = -1;
686	errno = ENOSYS;
687
688	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
689	# ifdef _MSC_VER
690	rc = _pipe(fds, PIPE_BUF, O_BINARY);
691	# else
692	rc = pipe(fds);
693	# endif
694	#endif
695
696	TRACE2((NULL, "shfile_pipe() -> %d{%d,%d} [%d]\n", rc, fds[0], fds[1], errno));
697	return rc;
698	}
699
700	int shfile_dup(shfdtab *pfdtab, int fd)
701	{
702	int rc;
703	#ifdef SH_PURE_STUB_MODE
704	rc = -1;
705
706	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
707	rc = dup(fd);
708
709	#else
710	#endif
711
712	TRACE2((NULL, "shfile_dup(%d) -> %d [%d]\n", fd, rc, errno));
713	return rc;
714	}
715
716	/**
717	* close().
718	*/
719	int shfile_close(shfdtab *pfdtab, unsigned fd)
720	{
721	int rc;
722	#ifdef SHFILE_IN_USE
723	shmtxtmp tmp;
724	shfile *file = shfile_get(pfdtab, fd, &tmp);
725	if (file)
726	{
727	shfile_native_close(file->native, file->flags);
728
729	file->fd = -1;
730	file->flags = 0;
731	file->native = -1;
732
733	shfile_put(pfdtab, file, &tmp);
734	rc = 0;
735	}
736	else
737	rc = -1;
738
739	#elif defined(SH_PURE_STUB_MODE)
740	rc = -1;
741
742	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
743	rc = close(fd);
744	#endif
745
746	TRACE2((NULL, "shfile_close(%d) -> %d [%d]\n", fd, rc, errno));
747	return rc;
748	}
749
750	/**
751	* read().
752	*/
753	long shfile_read(shfdtab pfdtab, int fd, void buf, size_t len)
754	{
755	long rc;
756	#ifdef SHFILE_IN_USE
757	shmtxtmp tmp;
758	shfile *file = shfile_get(pfdtab, fd, &tmp);
759	if (file)
760	{
761	# if K_OS == K_OS_WINDOWS
762	DWORD dwRead = 0;
763	if (ReadFile((HANDLE)file->native, buf, (DWORD)len, &dwRead, NULL))
764	rc = dwRead;
765	else
766	rc = shfile_dos2errno(GetLastError());
767	# else
768	rc = read(file->native, buf, len);
769	# endif
770
771	shfile_put(pfdtab, file, &tmp);
772	}
773	else
774	rc = -1;
775
776	#elif defined(SH_PURE_STUB_MODE)
777	rc = -1;
778
779	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
780	# ifdef _MSC_VER
781	rc = read(fd, buf, (unsigned)len);
782	# else
783	rc = read(fd, buf, len);
784	# endif
785	#endif
786	return rc;
787	}
788
789	/**
790	* write().
791	*/
792	long shfile_write(shfdtab pfdtab, int fd, const void buf, size_t len)
793	{
794	long rc;
795	#ifdef SHFILE_IN_USE
796	shmtxtmp tmp;
797	shfile *file = shfile_get(pfdtab, fd, &tmp);
798	if (file)
799	{
800	# if K_OS == K_OS_WINDOWS
801	DWORD dwWritten = 0;
802	if (WriteFile((HANDLE)file->native, buf, (DWORD)len, &dwWritten, NULL))
803	rc = dwWritten;
804	else
805	rc = shfile_dos2errno(GetLastError());
806	# else
807	rc = write(file->native, buf, len);
808	# endif
809
810	shfile_put(pfdtab, file, &tmp);
811	}
812	else
813	rc = -1;
814
815	#elif defined(SH_PURE_STUB_MODE)
816	rc = -1;
817
818	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
819	# ifdef _MSC_VER
820	rc = write(fd, buf, (unsigned)len);
821	# else
822	rc = write(fd, buf, len);
823	# endif
824	#endif
825	return rc;
826	}
827
828	/**
829	* lseek().
830	*/
831	long shfile_lseek(shfdtab *pfdtab, int fd, long off, int whench)
832	{
833	long rc;
834	#ifdef SHFILE_IN_USE
835	shmtxtmp tmp;
836	shfile *file = shfile_get(pfdtab, fd, &tmp);
837	if (file)
838	{
839	# if K_OS == K_OS_WINDOWS
840	assert(SEEK_SET == FILE_BEGIN);
841	assert(SEEK_CUR == FILE_CURRENT);
842	assert(SEEK_END == FILE_END);
843	rc = SetFilePointer((HANDLE)file->native, off, NULL, whench);
844	if (rc == INVALID_SET_FILE_POINTER)
845	rc = shfile_dos2errno(GetLastError());
846	# else
847	rc = lseek(file->native, off, whench);
848	# endif
849
850	shfile_put(pfdtab, file, &tmp);
851	}
852	else
853	rc = -1;
854
855	#elif defined(SH_PURE_STUB_MODE)
856	rc = -1;
857
858	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
859	rc = lseek(fd, off, whench);
860	#endif
861
862	return rc;
863	}
864
865	int shfile_fcntl(shfdtab *pfdtab, int fd, int cmd, int arg)
866	{
867	int rc;
868	#ifdef SHFILE_IN_USE
869	shmtxtmp tmp;
870	shfile *file = shfile_get(pfdtab, fd, &tmp);
871	if (file)
872	{
873	switch (cmd)
874	{
875	case F_GETFL:
876	rc = file->flags;
877	break;
878
879	case F_SETFL:
880	{
881	unsigned mask = O_NONBLOCK \| O_APPEND \| O_BINARY \| O_TEXT;
882	# ifdef O_DIRECT
883	mask \|= O_DIRECT;
884	# endif
885	# ifdef O_ASYNC
886	mask \|= O_ASYNC;
887	# endif
888	# ifdef O_SYNC
889	mask \|= O_SYNC;
890	# endif
891	if ((file->flags & mask) == (arg & mask))
892	rc = 0;
893	else
894	{
895	# if K_OS == K_OS_WINDOWS
896	assert(0);
897	errno = EINVAL;
898	rc = -1;
899	# else
900	rc = fcntl(file->native, F_SETFL, arg);
901	if (rc != -1)
902	file->flags = (file->flags & ~mask) \| (arg & mask);
903	# endif
904	}
905	break;
906	}
907
908	case F_DUPFD:
909	{
910	# if K_OS == K_OS_WINDOWS
911	HANDLE hNew = INVALID_HANDLE_VALUE;
912	if (DuplicateHandle(GetCurrentProcess(),
913	(HANDLE)file->native,
914	GetCurrentProcess(),
915	&hNew,
916	0,
917	TRUE /* bInheritHandle */,
918	DUPLICATE_SAME_ACCESS))
919	rc = shfile_insert(pfdtab, (intptr_t)hNew, file->flags, arg, "shfile_fcntl");
920	else
921	rc = shfile_dos2errno(GetLastError());
922	# else
923	int nativeNew = fcntl(file->native F_DUPFD, SHFILE_UNIX_MIN_FD);
924	if (nativeNew != -1)
925	rc = shfile_insert(pfdtab, nativeNew, file->flags, arg, "shfile_fcntl");
926	# endif
927	break;
928	}
929
930	default:
931	errno = -EINVAL;
932	rc = -1;
933	break;
934	}
935
936	shfile_put(pfdtab, file, &tmp);
937	}
938	else
939	rc = -1;
940
941	#elif defined(SH_PURE_STUB_MODE)
942	rc = -1;
943
944	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
945	# ifdef _MSC_VER
946	switch (cmd)
947	{
948	/* Just enough F_GETFL/F_SETFL to get along with. */
949	case F_GETFL:
950	errno = 0;
951	rc = _isatty(fd);
952	if (errno == EBADF)
953	rc = -1;
954	break;
955
956	case F_SETFL:
957	errno = 0;
958	rc = _isatty(fd);
959	if (errno != EBADF)
960	{
961	if (!arg)
962	rc = 0;
963	else
964	{
965	errno = EINVAL;
966	rc = -1;
967	}
968	}
969	else
970	rc = -1;
971	break;
972
973	case F_DUPFD:
974	{
975	/* the brute force approach. */
976	int i = 0;
977	int fds[256];
978	for (i = 0; i < 256; i++)
979	{
980	fds[i] = -1;
981	rc = _dup(fd);
982	if (rc >= arg)
983	break;
984	fds[i] = rc;
985	}
986	while (i-- > 0)
987	close(fds[i]);
988	if (rc < arg)
989	{
990	errno = EMFILE;
991	rc = -1;
992	}
993	break;
994	}
995	}
996	# else
997	rc = fcntl(fd, cmd, arg);
998	# endif
999	#endif
1000
1001	#ifdef DEBUG
1002	# ifdef TRACE_VIA_STDIO
1003	if (tracefile)
1004	# endif
1005	switch (cmd)
1006	{
1007	case F_GETFL:
1008	TRACE2((NULL, "shfile_fcntl(%d,F_GETFL,ignored=%d) -> %d [%d]\n", fd, arg, rc, errno));
1009	break;
1010	case F_SETFL:
1011	TRACE2((NULL, "shfile_fcntl(%d,F_SETFL,newflags=%#x) -> %d [%d]\n", fd, arg, rc, errno));
1012	break;
1013	case F_DUPFD:
1014	TRACE2((NULL, "shfile_fcntl(%d,F_DUPFS,minfd=%d) -> %d [%d]\n", fd, arg, rc, errno));
1015	break;
1016	default:
1017	TRACE2((NULL, "shfile_fcntl(%d,%d,%d) -> %d [%d]\n", fd, cmd, arg, rc, errno));
1018	break;
1019	}
1020	#endif
1021	return rc;
1022	}
1023
1024	int shfile_stat(shfdtab pfdtab, const char path, struct stat *pst)
1025	{
1026	#ifdef SH_PURE_STUB_MODE
1027	return -1;
1028
1029	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1030	return stat(path, pst);
1031
1032	#else
1033	#endif
1034	}
1035
1036	int shfile_lstat(shfdtab pfdtab, const char link, struct stat *pst)
1037	{
1038	#ifdef SH_PURE_STUB_MODE
1039	return -1;
1040
1041	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1042	# ifdef _MSC_VER
1043	return stat(link, pst);
1044	# else
1045	return lstat(link, pst);
1046	# endif
1047
1048	#else
1049	#endif
1050	}
1051
1052	int shfile_chdir(shfdtab pfdtab, const char path)
1053	{
1054	#ifdef SH_PURE_STUB_MODE
1055	return -1;
1056
1057	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1058	# ifdef _MSC_VER //???
1059	return chdir(path);
1060	# else
1061	return chdir(path);
1062	# endif
1063
1064	#else
1065	#endif
1066	}
1067
1068	char shfile_getcwd(shfdtab pfdtab, char *buf, int len)
1069	{
1070	#ifdef SH_PURE_STUB_MODE
1071	return NULL;
1072
1073	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1074	return getcwd(buf, len);
1075
1076	#else
1077	#endif
1078	}
1079
1080	int shfile_access(shfdtab pfdtab, const char path, int type)
1081	{
1082	#ifdef SH_PURE_STUB_MODE
1083	return -1;
1084
1085	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1086	# ifdef _MSC_VER
1087	type &= ~X_OK;
1088	return access(path, type);
1089	# else
1090	return access(path, type);
1091	# endif
1092
1093	#else
1094	#endif
1095	}
1096
1097	int shfile_isatty(shfdtab *pfdtab, int fd)
1098	{
1099	int rc;
1100
1101	#ifdef SH_PURE_STUB_MODE
1102	rc = 0;
1103	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1104	rc = isatty(fd);
1105	#else
1106	#endif
1107
1108	TRACE2((NULL, "isatty(%d) -> %d [%d]\n", fd, rc, errno));
1109	return rc;
1110	}
1111
1112
1113	int shfile_cloexec(shfdtab *pfdtab, int fd, int closeit)
1114	{
1115	int rc;
1116
1117	#ifdef SH_PURE_STUB_MODE
1118	rc = -1;
1119
1120	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1121	# ifdef _MSC_VER
1122	errno = ENOSYS;
1123	rc = -1;
1124	# else
1125	rc = fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0)
1126	\| (closeit ? FD_CLOEXEC : 0));
1127	# endif
1128
1129	#else
1130	#endif
1131
1132	TRACE2((NULL, "shfile_cloexec(%d, %d) -> %d [%d]\n", fd, closeit, rc, errno));
1133	return rc;
1134	}
1135
1136
1137	int shfile_ioctl(shfdtab pfdtab, int fd, unsigned long request, void buf)
1138	{
1139	int rc;
1140
1141	#ifdef SH_PURE_STUB_MODE
1142	rc = -1;
1143
1144	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1145	# ifdef _MSC_VER
1146	errno = ENOSYS;
1147	rc = -1;
1148	# else
1149	rc = ioctl(fd, request, buf);
1150	# endif
1151
1152	#else
1153	#endif
1154
1155	TRACE2((NULL, "ioctl(%d, %#x, %p) -> %d\n", fd, request, buf, rc));
1156	return rc;
1157	}
1158
1159
1160	mode_t shfile_get_umask(shfdtab *pfdtab)
1161	{
1162	#ifdef SH_PURE_STUB_MODE
1163	return 022;
1164
1165	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1166	return 022;
1167
1168	#else
1169	#endif
1170	}
1171
1172	void shfile_set_umask(shfdtab *pfdtab, mode_t mask)
1173	{
1174	(void)mask;
1175	}
1176
1177
1178	shdir shfile_opendir(shfdtab pfdtab, const char *dir)
1179	{
1180	#ifdef SH_PURE_STUB_MODE
1181	return NULL;
1182
1183	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1184	# ifdef _MSC_VER
1185	errno = ENOSYS;
1186	return NULL;
1187	# else
1188	return (shdir *)opendir(dir);
1189	# endif
1190
1191	#else
1192	#endif
1193	}
1194
1195	shdirent shfile_readdir(struct shdir pdir)
1196	{
1197	#ifdef SH_PURE_STUB_MODE
1198	return NULL;
1199
1200	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1201	# ifdef _MSC_VER
1202	errno = ENOSYS;
1203	return NULL;
1204	# else
1205	struct dirent pde = readdir((DIR )pdir);
1206	return pde ? (shdirent *)&pde->d_name[0] : NULL;
1207	# endif
1208
1209	#else
1210	#endif
1211	}
1212
1213	void shfile_closedir(struct shdir *pdir)
1214	{
1215	#ifdef SH_PURE_STUB_MODE
1216	return NULL;
1217
1218	#elif defined(SH_STUB_MODE) \|\| defined(SH_FORKED_MODE)
1219	# ifdef _MSC_VER
1220	errno = ENOSYS;
1221	# else
1222	closedir((DIR *)pdir);
1223	# endif
1224
1225	#else
1226	#endif
1227	}

Note: See TracBrowser for help on using the repository browser.

source: kBuild/trunk/src/kash/shfile.c@ 2296

Download in other formats: