shfile.c@ 2784

Last change on this file since 2784 was 2681, checked in by bird, 12 years ago
shfile.c: Fixed windows problem with stat() failing if the directory ends with a slash.\
Property svn:eol-style set to `LF` Property svn:keywords set to `Id`
File size: 58.7 KB

Line
1	/* $Id: shfile.c 2681 2013-04-14 18:41:58Z bird $ */
2	/** @file
3	*
4	* File management.
5	*
6	* Copyright (c) 2007-2010 knut st. osmundsen <[email protected]>
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	/*******************************************************************************
28	* Header Files *
29	*******************************************************************************/
30	#include "shfile.h"
31	#include "shinstance.h" /* TRACE2 */
32	#include <stdlib.h>
33	#include <stdio.h>
34	#include <string.h>
35	#include <assert.h>
36
37	#if K_OS == K_OS_WINDOWS
38	# include <limits.h>
39	# ifndef PIPE_BUF
40	# define PIPE_BUF 512
41	# endif
42	# include <ntstatus.h>
43	# define WIN32_NO_STATUS
44	# include <Windows.h>
45	# if !defined(_WIN32_WINNT)
46	# define _WIN32_WINNT 0x0502 /* Windows Server 2003 */
47	# endif
48	# include <winternl.h> //NTSTATUS
49	#else
50	# include <unistd.h>
51	# include <fcntl.h>
52	# include <dirent.h>
53	#endif
54
55
56	/*******************************************************************************
57	* Defined Constants And Macros *
58	*******************************************************************************/
59	/** @def SHFILE_IN_USE
60	* Whether the file descriptor table stuff is actually in use or not.
61	*/
62	#if K_OS == K_OS_WINDOWS \
63	\|\| K_OS == K_OS_OPENBSD /* because of ugly pthread library pipe hacks */ \
64	\|\| !defined(SH_FORKED_MODE)
65	# define SHFILE_IN_USE
66	#endif
67	/** The max file table size. */
68	#define SHFILE_MAX 1024
69	/** The file table growth rate. */
70	#define SHFILE_GROW 64
71	/** The min native unix file descriptor. */
72	#define SHFILE_UNIX_MIN_FD 32
73	/** The path buffer size we use. */
74	#define SHFILE_MAX_PATH 4096
75
76	/** Set errno and return. Doing a trace in debug build. */
77	#define RETURN_ERROR(rc, err, msg) \
78	do { \
79	TRACE2((NULL, "%s: " ## msg ## " - returning %d / %d\n", __FUNCTION__, (rc), (err))); \
80	errno = (err); \
81	return (rc); \
82	} while (0)
83
84	#if K_OS == K_OS_WINDOWS
85	/* See msdos.h for description. */
86	# define FOPEN 0x01
87	# define FEOFLAG 0x02
88	# define FCRLF 0x04
89	# define FPIPE 0x08
90	# define FNOINHERIT 0x10
91	# define FAPPEND 0x20
92	# define FDEV 0x40
93	# define FTEXT 0x80
94
95	# define MY_ObjectBasicInformation 0
96	# define MY_FileNamesInformation 12
97
98	typedef struct
99	{
100	ULONG Attributes;
101	ACCESS_MASK GrantedAccess;
102	ULONG HandleCount;
103	ULONG PointerCount;
104	ULONG PagedPoolUsage;
105	ULONG NonPagedPoolUsage;
106	ULONG Reserved[3];
107	ULONG NameInformationLength;
108	ULONG TypeInformationLength;
109	ULONG SecurityDescriptorLength;
110	LARGE_INTEGER CreateTime;
111	} MY_OBJECT_BASIC_INFORMATION;
112
113	#if 0
114	typedef struct
115	{
116	union
117	{
118	LONG Status;
119	PVOID Pointer;
120	};
121	ULONG_PTR Information;
122	} MY_IO_STATUS_BLOCK;
123	#else
124	typedef IO_STATUS_BLOCK MY_IO_STATUS_BLOCK;
125	#endif
126	typedef MY_IO_STATUS_BLOCK *PMY_IO_STATUS_BLOCK;
127
128	typedef struct
129	{
130	ULONG NextEntryOffset;
131	ULONG FileIndex;
132	ULONG FileNameLength;
133	WCHAR FileName[1];
134	} MY_FILE_NAMES_INFORMATION, *PMY_FILE_NAMES_INFORMATION;
135
136	typedef NTSTATUS (NTAPI * PFN_NtQueryObject)(HANDLE, int, void , size_t, size_t );
137	typedef NTSTATUS (NTAPI * PFN_NtQueryDirectoryFile)(HANDLE, HANDLE, void , void , PMY_IO_STATUS_BLOCK, void *,
138	ULONG, int, int, PUNICODE_STRING, int);
139	typedef NTSTATUS (NTAPI * PFN_RtlUnicodeStringToAnsiString)(PANSI_STRING, PCUNICODE_STRING, int);
140
141
142	#endif /* K_OS_WINDOWS */
143
144
145	/*******************************************************************************
146	* Global Variables *
147	*******************************************************************************/
148	#if K_OS == K_OS_WINDOWS
149	static int g_shfile_globals_initialized = 0;
150	static PFN_NtQueryObject g_pfnNtQueryObject = NULL;
151	static PFN_NtQueryDirectoryFile g_pfnNtQueryDirectoryFile = NULL;
152	static PFN_RtlUnicodeStringToAnsiString g_pfnRtlUnicodeStringToAnsiString = NULL;
153	#endif /* K_OS_WINDOWS */
154
155
156	#ifdef SHFILE_IN_USE
157
158	/**
159	* Close the specified native handle.
160	*
161	* @param native The native file handle.
162	* @param flags The flags in case they might come in handy later.
163	*/
164	static void shfile_native_close(intptr_t native, unsigned flags)
165	{
166	# if K_OS == K_OS_WINDOWS
167	BOOL fRc = CloseHandle((HANDLE)native);
168	assert(fRc); (void)fRc;
169	# else
170	int s = errno;
171	close(native);
172	errno = s;
173	# endif
174	(void)flags;
175	}
176
177	/**
178	* Grows the descriptor table, making sure that it can hold @a fdMin,
179	*
180	* @returns The max(fdMin, fdFirstNew) on success, -1 on failure.
181	* @param pfdtab The table to grow.
182	* @param fdMin Grow to include this index.
183	*/
184	static int shfile_grow_tab_locked(shfdtab *pfdtab, int fdMin)
185	{
186	/*
187	* Grow the descriptor table.
188	*/
189	int fdRet = -1;
190	shfile *new_tab;
191	int new_size = pfdtab->size + SHFILE_GROW;
192	while (new_size < fdMin)
193	new_size += SHFILE_GROW;
194	new_tab = sh_realloc(shthread_get_shell(), pfdtab->tab, new_size * sizeof(shfile));
195	if (new_tab)
196	{
197	int i;
198	for (i = pfdtab->size; i < new_size; i++)
199	{
200	new_tab[i].fd = -1;
201	new_tab[i].oflags = 0;
202	new_tab[i].shflags = 0;
203	new_tab[i].native = -1;
204	}
205
206	fdRet = pfdtab->size;
207	if (fdRet < fdMin)
208	fdRet = fdMin;
209
210	pfdtab->tab = new_tab;
211	pfdtab->size = new_size;
212	}
213
214	return fdRet;
215	}
216
217	/**
218	* Inserts the file into the descriptor table.
219	*
220	* If we're out of memory and cannot extend the table, we'll close the
221	* file, set errno to EMFILE and return -1.
222	*
223	* @returns The file descriptor number. -1 and errno on failure.
224	* @param pfdtab The file descriptor table.
225	* @param native The native file handle.
226	* @param oflags The flags the it was opened/created with.
227	* @param shflags The shell file flags.
228	* @param fdMin The minimum file descriptor number, pass -1 if any is ok.
229	* @param who Who we're doing this for (for logging purposes).
230	*/
231	static int shfile_insert(shfdtab pfdtab, intptr_t native, unsigned oflags, unsigned shflags, int fdMin, const char who)
232	{
233	shmtxtmp tmp;
234	int fd;
235	int i;
236
237	/*
238	* Fend of bad stuff.
239	*/
240	if (fdMin >= SHFILE_MAX)
241	{
242	errno = EMFILE;
243	return -1;
244	}
245	# if K_OS != K_OS_WINDOWS
246	if (fcntl((int)native, F_SETFD, fcntl((int)native, F_GETFD, 0) \| FD_CLOEXEC) == -1)
247	{
248	int e = errno;
249	close((int)native);
250	errno = e;
251	return -1;
252	}
253	# endif
254
255	shmtx_enter(&pfdtab->mtx, &tmp);
256
257	/*
258	* Search for a fitting unused location.
259	*/
260	fd = -1;
261	for (i = fdMin >= 0 ? fdMin : 0; (unsigned)i < pfdtab->size; i++)
262	if (pfdtab->tab[i].fd == -1)
263	{
264	fd = i;
265	break;
266	}
267	if (fd == -1)
268	fd = shfile_grow_tab_locked(pfdtab, fdMin);
269
270	/*
271	* Fill in the entry if we've found one.
272	*/
273	if (fd != -1)
274	{
275	pfdtab->tab[fd].fd = fd;
276	pfdtab->tab[fd].oflags = oflags;
277	pfdtab->tab[fd].shflags = shflags;
278	pfdtab->tab[fd].native = native;
279	}
280	else
281	shfile_native_close(native, oflags);
282
283	shmtx_leave(&pfdtab->mtx, &tmp);
284
285	if (fd == -1)
286	errno = EMFILE;
287	(void)who;
288	return fd;
289	}
290
291	# if K_OS != K_OS_WINDOWS
292	/**
293	* Makes a copy of the native file, closes the original, and inserts the copy
294	* into the descriptor table.
295	*
296	* If we're out of memory and cannot extend the table, we'll close the
297	* file, set errno to EMFILE and return -1.
298	*
299	* @returns The file descriptor number. -1 and errno on failure.
300	* @param pfdtab The file descriptor table.
301	* @param pnative The native file handle on input, -1 on output.
302	* @param oflags The flags the it was opened/created with.
303	* @param shflags The shell file flags.
304	* @param fdMin The minimum file descriptor number, pass -1 if any is ok.
305	* @param who Who we're doing this for (for logging purposes).
306	*/
307	static int shfile_copy_insert_and_close(shfdtab pfdtab, int pnative, unsigned oflags, unsigned shflags, int fdMin, const char *who)
308	{
309	int fd = -1;
310	int s = errno;
311	int native_copy = fcntl(*pnative, F_DUPFD, SHFILE_UNIX_MIN_FD);
312	close(*pnative);
313	*pnative = -1;
314	errno = s;
315
316	if (native_copy != -1)
317	fd = shfile_insert(pfdtab, native_copy, oflags, shflags, fdMin, who);
318	return fd;
319	}
320	# endif /* !K_OS_WINDOWS */
321
322	/**
323	* Gets a file descriptor and lock the file descriptor table.
324	*
325	* @returns Pointer to the file and table ownership on success,
326	* NULL and errno set to EBADF on failure.
327	* @param pfdtab The file descriptor table.
328	* @param fd The file descriptor number.
329	* @param ptmp See shmtx_enter.
330	*/
331	static shfile shfile_get(shfdtab pfdtab, int fd, shmtxtmp *ptmp)
332	{
333	shfile *file = NULL;
334	if ( fd >= 0
335	&& (unsigned)fd < pfdtab->size)
336	{
337	shmtx_enter(&pfdtab->mtx, ptmp);
338	if ((unsigned)fd < pfdtab->size
339	&& pfdtab->tab[fd].fd != -1)
340	file = &pfdtab->tab[fd];
341	else
342	shmtx_leave(&pfdtab->mtx, ptmp);
343	}
344	if (!file)
345	errno = EBADF;
346	return file;
347	}
348
349	/**
350	* Puts back a file descriptor and releases the table ownership.
351	*
352	* @param pfdtab The file descriptor table.
353	* @param file The file.
354	* @param ptmp See shmtx_leave.
355	*/
356	static void shfile_put(shfdtab pfdtab, shfile file, shmtxtmp *ptmp)
357	{
358	shmtx_leave(&pfdtab->mtx, ptmp);
359	assert(file);
360	(void)file;
361	}
362
363	/**
364	* Constructs a path from the current directory and the passed in path.
365	*
366	* @returns 0 on success, -1 and errno set to ENAMETOOLONG or EINVAL on failure.
367	*
368	* @param pfdtab The file descriptor table
369	* @param path The path the caller supplied.
370	* @param buf Where to put the path. This is assumed to be SHFILE_MAX_PATH
371	* chars in size.
372	*/
373	int shfile_make_path(shfdtab pfdtab, const char path, char *buf)
374	{
375	size_t path_len = strlen(path);
376	if (path_len == 0)
377	{
378	errno = EINVAL;
379	return -1;
380	}
381	if (path_len >= SHFILE_MAX_PATH)
382	{
383	errno = ENAMETOOLONG;
384	return -1;
385	}
386	if ( *path == '/'
387	# if K_OS == K_OS_WINDOWS \|\| K_OS == K_OS_OS2
388	\|\| *path == '\\'
389	\|\| ( *path
390	&& path[1] == ':'
391	&& ( (path >= 'A' && path <= 'Z')
392	\|\| (path >= 'a' && path <= 'z')))
393	# endif
394	)
395	{
396	memcpy(buf, path, path_len + 1);
397	}
398	else
399	{
400	size_t cwd_len;
401	shmtxtmp tmp;
402
403	shmtx_enter(&pfdtab->mtx, &tmp);
404
405	cwd_len = strlen(pfdtab->cwd);
406	memcpy(buf, pfdtab->cwd, cwd_len);
407
408	shmtx_leave(&pfdtab->mtx, &tmp);
409
410	if (cwd_len + path_len + 1 >= SHFILE_MAX_PATH)
411	{
412	errno = ENAMETOOLONG;
413	return -1;
414	}
415	if ( !cwd_len
416	\|\| buf[cwd_len - 1] != '/')
417	buf[cwd_len++] = '/';
418	memcpy(buf + cwd_len, path, path_len + 1);
419	}
420
421	# if K_OS == K_OS_WINDOWS \|\| K_OS == K_OS_OS2
422	if (!strcmp(buf, "/dev/null"))
423	strcpy(buf, "NUL");
424	# endif
425	return 0;
426	}
427
428	# if K_OS == K_OS_WINDOWS
429
430	/**
431	* Adjusts the file name if it ends with a trailing directory slash.
432	*
433	* Windows APIs doesn't like trailing slashes.
434	*
435	* @returns 1 if it has a directory slash, 0 if not.
436	*
437	* @param abspath The path to adjust (SHFILE_MAX_PATH).
438	*/
439	static int shfile_trailing_slash_hack(char *abspath)
440	{
441	/*
442	* Anything worth adjust here?
443	*/
444	size_t path_len = strlen(abspath);
445	if ( path_len == 0
446	\|\| ( abspath[path_len - 1] != '/'
447	# if K_OS == K_OS_WINDOWS \|\| K_OS == K_OS_OS2
448	&& abspath[path_len - 1] != '\\'
449	# endif
450	)
451	)
452	return 0;
453
454	/*
455	* Ok, make the adjustment.
456	*/
457	if (path_len + 2 <= SHFILE_MAX_PATH)
458	{
459	/* Add a '.' to the end. */
460	abspath[path_len++] = '.';
461	abspath[path_len] = '\0';
462	}
463	else
464	{
465	/* No space for a dot, remove the slash if it's alone or just remove
466	one and add a dot like above. */
467	if ( abspath[path_len - 2] != '/'
468	# if K_OS == K_OS_WINDOWS \|\| K_OS == K_OS_OS2
469	&& abspath[path_len - 2] != '\\'
470	# endif
471	)
472	abspath[--path_len] = '\0';
473	else
474	abspath[path_len - 1] = '.';
475	}
476
477	return 1;
478	}
479
480
481	/**
482	* Converts a DOS(/Windows) error code to errno,
483	* assigning it to errno.
484	*
485	* @returns -1
486	* @param err The DOS error.
487	*/
488	static int shfile_dos2errno(int err)
489	{
490	switch (err)
491	{
492	case ERROR_BAD_ENVIRONMENT: errno = E2BIG; break;
493	case ERROR_ACCESS_DENIED: errno = EACCES; break;
494	case ERROR_CURRENT_DIRECTORY: errno = EACCES; break;
495	case ERROR_LOCK_VIOLATION: errno = EACCES; break;
496	case ERROR_NETWORK_ACCESS_DENIED: errno = EACCES; break;
497	case ERROR_CANNOT_MAKE: errno = EACCES; break;
498	case ERROR_FAIL_I24: errno = EACCES; break;
499	case ERROR_DRIVE_LOCKED: errno = EACCES; break;
500	case ERROR_SEEK_ON_DEVICE: errno = EACCES; break;
501	case ERROR_NOT_LOCKED: errno = EACCES; break;
502	case ERROR_LOCK_FAILED: errno = EACCES; break;
503	case ERROR_NO_PROC_SLOTS: errno = EAGAIN; break;
504	case ERROR_MAX_THRDS_REACHED: errno = EAGAIN; break;
505	case ERROR_NESTING_NOT_ALLOWED: errno = EAGAIN; break;
506	case ERROR_INVALID_HANDLE: errno = EBADF; break;
507	case ERROR_INVALID_TARGET_HANDLE: errno = EBADF; break;
508	case ERROR_DIRECT_ACCESS_HANDLE: errno = EBADF; break;
509	case ERROR_WAIT_NO_CHILDREN: errno = ECHILD; break;
510	case ERROR_CHILD_NOT_COMPLETE: errno = ECHILD; break;
511	case ERROR_FILE_EXISTS: errno = EEXIST; break;
512	case ERROR_ALREADY_EXISTS: errno = EEXIST; break;
513	case ERROR_INVALID_FUNCTION: errno = EINVAL; break;
514	case ERROR_INVALID_ACCESS: errno = EINVAL; break;
515	case ERROR_INVALID_DATA: errno = EINVAL; break;
516	case ERROR_INVALID_PARAMETER: errno = EINVAL; break;
517	case ERROR_NEGATIVE_SEEK: errno = EINVAL; break;
518	case ERROR_TOO_MANY_OPEN_FILES: errno = EMFILE; break;
519	case ERROR_FILE_NOT_FOUND: errno = ENOENT; break;
520	case ERROR_PATH_NOT_FOUND: errno = ENOENT; break;
521	case ERROR_INVALID_DRIVE: errno = ENOENT; break;
522	case ERROR_NO_MORE_FILES: errno = ENOENT; break;
523	case ERROR_BAD_NETPATH: errno = ENOENT; break;
524	case ERROR_BAD_NET_NAME: errno = ENOENT; break;
525	case ERROR_BAD_PATHNAME: errno = ENOENT; break;
526	case ERROR_FILENAME_EXCED_RANGE: errno = ENOENT; break;
527	case ERROR_BAD_FORMAT: errno = ENOEXEC; break;
528	case ERROR_ARENA_TRASHED: errno = ENOMEM; break;
529	case ERROR_NOT_ENOUGH_MEMORY: errno = ENOMEM; break;
530	case ERROR_INVALID_BLOCK: errno = ENOMEM; break;
531	case ERROR_NOT_ENOUGH_QUOTA: errno = ENOMEM; break;
532	case ERROR_DISK_FULL: errno = ENOSPC; break;
533	case ERROR_DIR_NOT_EMPTY: errno = ENOTEMPTY; break;
534	case ERROR_BROKEN_PIPE: errno = EPIPE; break;
535	case ERROR_NOT_SAME_DEVICE: errno = EXDEV; break;
536	default: errno = EINVAL; break;
537	}
538	return -1;
539	}
540
541	/**
542	* Converts an NT status code to errno,
543	* assigning it to errno.
544	*
545	* @returns -1
546	* @param rcNt The NT status code.
547	*/
548	static int shfile_nt2errno(NTSTATUS rcNt)
549	{
550	switch (rcNt)
551	{
552	default: errno = EINVAL; break;
553	}
554	return -1;
555	}
556
557	DWORD shfile_query_handle_access_mask(HANDLE h, PACCESS_MASK pMask)
558	{
559	MY_OBJECT_BASIC_INFORMATION BasicInfo;
560	NTSTATUS rcNt;
561
562	if (!g_pfnNtQueryObject)
563	return ERROR_NOT_SUPPORTED;
564
565	rcNt = g_pfnNtQueryObject(h, MY_ObjectBasicInformation, &BasicInfo, sizeof(BasicInfo), NULL);
566	if (rcNt >= 0)
567	{
568	*pMask = BasicInfo.GrantedAccess;
569	return NO_ERROR;
570	}
571	if (rcNt != STATUS_INVALID_HANDLE)
572	return ERROR_GEN_FAILURE;
573	return ERROR_INVALID_HANDLE;
574	}
575
576	# endif /* K_OS == K_OS_WINDOWS */
577
578	#endif /* SHFILE_IN_USE */
579
580	/**
581	* Converts DOS slashes to UNIX slashes if necessary.
582	*
583	* @param pszPath The path to fix.
584	*/
585	static void shfile_fix_slashes(char *pszPath)
586	{
587	#if K_OS == K_OS_WINDOWS \|\| K_OS == K_OS_OS2
588	while ((pszPath = strchr(pszPath, '\\')))
589	*pszPath++ = '/';
590	#else
591	(void)pszPath;
592	#endif
593	}
594
595	/**
596	* Initializes the global variables in this file.
597	*/
598	static void shfile_init_globals(void)
599	{
600	#if K_OS == K_OS_WINDOWS
601	if (!g_shfile_globals_initialized)
602	{
603	HMODULE hNtDll = GetModuleHandle("NTDLL");
604	g_pfnNtQueryObject = (PFN_NtQueryObject) GetProcAddress(hNtDll, "NtQueryObject");
605	g_pfnNtQueryDirectoryFile = (PFN_NtQueryDirectoryFile)GetProcAddress(hNtDll, "NtQueryDirectoryFile");
606	g_pfnRtlUnicodeStringToAnsiString = (PFN_RtlUnicodeStringToAnsiString)GetProcAddress(hNtDll, "RtlUnicodeStringToAnsiString");
607	if ( !g_pfnRtlUnicodeStringToAnsiString
608	\|\| !g_pfnNtQueryDirectoryFile)
609	{
610	/* fatal error */
611	}
612	g_shfile_globals_initialized = 1;
613	}
614	#endif
615	}
616
617	/**
618	* Initializes a file descriptor table.
619	*
620	* @returns 0 on success, -1 and errno on failure.
621	* @param pfdtab The table to initialize.
622	* @param inherit File descriptor table to inherit from. If not specified
623	* we will inherit from the current process as it were.
624	*/
625	int shfile_init(shfdtab pfdtab, shfdtab inherit)
626	{
627	int rc;
628
629	shfile_init_globals();
630
631	pfdtab->cwd = NULL;
632	pfdtab->size = 0;
633	pfdtab->tab = NULL;
634	rc = shmtx_init(&pfdtab->mtx);
635	if (!rc)
636	{
637	#ifdef SHFILE_IN_USE
638	/* Get CWD with unix slashes. */
639	char buf[SHFILE_MAX_PATH];
640	if (getcwd(buf, sizeof(buf)))
641	{
642	shfile_fix_slashes(buf);
643
644	pfdtab->cwd = sh_strdup(NULL, buf);
645	if (!inherit)
646	{
647	# if K_OS == K_OS_WINDOWS
648	static const struct
649	{
650	DWORD dwStdHandle;
651	unsigned fFlags;
652	} aStdHandles[3] =
653	{
654	{ STD_INPUT_HANDLE, _O_RDONLY },
655	{ STD_OUTPUT_HANDLE, _O_WRONLY },
656	{ STD_ERROR_HANDLE, _O_WRONLY }
657	};
658	int i;
659	STARTUPINFO Info;
660	ACCESS_MASK Mask;
661	DWORD dwErr;
662
663	rc = 0;
664
665	/* Try pick up the Visual C++ CRT file descriptor info. */
666	__try {
667	GetStartupInfo(&Info);
668	} __except (EXCEPTION_EXECUTE_HANDLER) {
669	memset(&Info, 0, sizeof(Info));
670	}
671
672	if ( Info.cbReserved2 > sizeof(int)
673	&& (uintptr_t)Info.lpReserved2 >= 0x1000
674	&& (i = (int )Info.lpReserved2) >= 1
675	&& i <= 2048
676	&& ( Info.cbReserved2 == i * 5 + 4
677	//\|\| Info.cbReserved2 == i * 5 + 1 - check the cygwin sources.
678	\|\| Info.cbReserved2 == i * 9 + 4))
679	{
680	uint8_t paf = (uint8_t )Info.lpReserved2 + sizeof(int);
681	int dwPerH = 1 + (Info.cbReserved2 == i * 9 + 4);
682	DWORD ph = (DWORD )(paf + i) + dwPerH * i;
683	HANDLE aStdHandles2[3];
684	int j;
685
686	//if (Info.cbReserved2 == i * 5 + 1) - check the cygwin sources.
687	// i--;
688
689	for (j = 0; j < 3; j++)
690	aStdHandles2[j] = GetStdHandle(aStdHandles[j].dwStdHandle);
691
692	while (i-- > 0)
693	{
694	ph -= dwPerH;
695
696	if ( (paf[i] & (FOPEN \| FNOINHERIT)) == FOPEN
697	&& *ph != (uint32_t)INVALID_HANDLE_VALUE)
698	{
699	HANDLE h = (HANDLE)(intptr_t)*ph;
700	int fd2;
701	int fFlags;
702	int fFlags2;
703
704	if ( h == aStdHandles2[j = 0]
705	\|\| h == aStdHandles2[j = 1]
706	\|\| h == aStdHandles2[j = 2])
707	fFlags = aStdHandles[j].fFlags;
708	else
709	{
710	dwErr = shfile_query_handle_access_mask(h, &Mask);
711	if (dwErr == ERROR_INVALID_HANDLE)
712	continue;
713	else if (dwErr == NO_ERROR)
714	{
715	fFlags = 0;
716	if ( (Mask & (GENERIC_READ \| FILE_READ_DATA))
717	&& (Mask & (GENERIC_WRITE \| FILE_WRITE_DATA \| FILE_APPEND_DATA)))
718	fFlags \|= O_RDWR;
719	else if (Mask & (GENERIC_READ \| FILE_READ_DATA))
720	fFlags \|= O_RDONLY;
721	else if (Mask & (GENERIC_WRITE \| FILE_WRITE_DATA \| FILE_APPEND_DATA))
722	fFlags \|= O_WRONLY;
723	else
724	fFlags \|= O_RDWR;
725	if ((Mask & (FILE_WRITE_DATA \| FILE_APPEND_DATA)) == FILE_APPEND_DATA)
726	fFlags \|= O_APPEND;
727	}
728	else
729	fFlags = O_RDWR;
730	}
731
732	if (paf[i] & FPIPE)
733	fFlags2 = SHFILE_FLAGS_PIPE;
734	else if (paf[i] & FDEV)
735	fFlags2 = SHFILE_FLAGS_TTY;
736	else
737	fFlags2 = 0;
738
739	fd2 = shfile_insert(pfdtab, (intptr_t)h, fFlags, fFlags2, i, "shtab_init");
740	assert(fd2 == i); (void)fd2;
741	if (fd2 != i)
742	rc = -1;
743	}
744	}
745	}
746
747	/* Check the three standard handles. */
748	for (i = 0; i < 3; i++)
749	if ( (unsigned)i >= pfdtab->size
750	\|\| pfdtab->tab[i].fd == -1)
751	{
752	HANDLE hFile = GetStdHandle(aStdHandles[i].dwStdHandle);
753	if (hFile != INVALID_HANDLE_VALUE)
754	{
755	DWORD dwType = GetFileType(hFile);
756	unsigned fFlags = aStdHandles[i].fFlags;
757	unsigned fFlags2;
758	int fd2;
759	if (dwType == FILE_TYPE_CHAR)
760	fFlags2 = SHFILE_FLAGS_TTY;
761	else if (dwType == FILE_TYPE_PIPE)
762	fFlags2 = SHFILE_FLAGS_PIPE;
763	else
764	fFlags2 = SHFILE_FLAGS_FILE;
765	fd2 = shfile_insert(pfdtab, (intptr_t)hFile, fFlags, fFlags2, i, "shtab_init");
766	assert(fd2 == i); (void)fd2;
767	if (fd2 != i)
768	rc = -1;
769	}
770	}
771	# else
772	/*
773	* Annoying...
774	*/
775	int fd;
776
777	for (fd = 0; fd < 10; fd++)
778	{
779	int oflags = fcntl(fd, F_GETFL, 0);
780	if (oflags != -1)
781	{
782	int cox = fcntl(fd, F_GETFD, 0);
783	struct stat st;
784	if ( cox != -1
785	&& fstat(fd, &st) != -1)
786	{
787	int native;
788	int fd2;
789	int fFlags2 = 0;
790	if (cox & FD_CLOEXEC)
791	fFlags2 \|= SHFILE_FLAGS_CLOSE_ON_EXEC;
792	if (S_ISREG(st.st_mode))
793	fFlags2 \|= SHFILE_FLAGS_FILE;
794	else if (S_ISDIR(st.st_mode))
795	fFlags2 \|= SHFILE_FLAGS_DIR;
796	else if (S_ISCHR(st.st_mode))
797	fFlags2 \|= SHFILE_FLAGS_TTY;
798	else if (S_ISFIFO(st.st_mode))
799	fFlags2 \|= SHFILE_FLAGS_PIPE;
800	else
801	fFlags2 \|= SHFILE_FLAGS_TTY;
802
803	native = fcntl(fd, F_DUPFD, SHFILE_UNIX_MIN_FD);
804	if (native == -1)
805	native = fd;
806	fd2 = shfile_insert(pfdtab, native, oflags, fFlags2, fd, "shtab_init");
807	assert(fd2 == fd); (void)fd2;
808	if (fd2 != fd)
809	rc = -1;
810	if (native != fd)
811	close(fd);
812	}
813	}
814	}
815
816	# endif
817	}
818	else
819	{
820	/** @todo */
821	errno = ENOSYS;
822	rc = -1;
823	}
824	}
825	else
826	rc = -1;
827	#endif
828	}
829	return rc;
830	}
831
832	#if K_OS == K_OS_WINDOWS && defined(SHFILE_IN_USE)
833
834	/**
835	* Changes the inheritability of a file descriptro, taking console handles into
836	* account.
837	*
838	* @note This MAY change the native handle for the entry.
839	*
840	* @returns The native handle.
841	* @param pfd The file descriptor to change.
842	* @param set If set, make child processes inherit the handle, if clear
843	* make them not inherit it.
844	*/
845	static HANDLE shfile_set_inherit_win(shfile *pfd, int set)
846	{
847	HANDLE hFile = (HANDLE)pfd->native;
848	if (!SetHandleInformation(hFile, HANDLE_FLAG_INHERIT, set ? HANDLE_FLAG_INHERIT : 0))
849	{
850	/* SetHandleInformation doesn't work for console handles,
851	so we have to duplicate the handle to change the
852	inheritability. */
853	DWORD err = GetLastError();
854	if ( err == ERROR_INVALID_PARAMETER
855	&& DuplicateHandle(GetCurrentProcess(),
856	hFile,
857	GetCurrentProcess(),
858	&hFile,
859	0,
860	set ? TRUE : FALSE /* bInheritHandle */,
861	DUPLICATE_SAME_ACCESS))
862	{
863	TRACE2((NULL, "shfile_set_inherit_win: %p -> %p (set=%d)\n", pfd->native, hFile, set));
864	if (!CloseHandle((HANDLE)pfd->native))
865	assert(0);
866	pfd->native = (intptr_t)hFile;
867	}
868	else
869	{
870	err = GetLastError();
871	assert(0);
872	hFile = (HANDLE)pfd->native;
873	}
874	}
875	return hFile;
876	}
877
878	/**
879	* Helper for shfork.
880	*
881	* @param pfdtab The file descriptor table.
882	* @param set Whether to make all handles inheritable (1) or
883	* to restore them to the rigth state (0).
884	* @param hndls Where to store the three standard handles.
885	*/
886	void shfile_fork_win(shfdtab pfdtab, int set, intptr_t hndls)
887	{
888	shmtxtmp tmp;
889	unsigned i;
890
891	shmtx_enter(&pfdtab->mtx, &tmp);
892	TRACE2((NULL, "shfile_fork_win: set=%d\n", set));
893
894	i = pfdtab->size;
895	while (i-- > 0)
896	{
897	if (pfdtab->tab[i].fd == i)
898	{
899	shfile_set_inherit_win(&pfdtab->tab[i], set);
900	if (set)
901	TRACE2((NULL, " #%d: native=%#x oflags=%#x shflags=%#x\n",
902	i, pfdtab->tab[i].native, pfdtab->tab[i].oflags, pfdtab->tab[i].shflags));
903	}
904	}
905
906	if (hndls)
907	{
908	for (i = 0; i < 3; i++)
909	{
910	if ( pfdtab->size > i
911	&& pfdtab->tab[i].fd == i)
912	hndls[i] = pfdtab->tab[i].native;
913	else
914	hndls[i] = (intptr_t)INVALID_HANDLE_VALUE;
915	TRACE2((NULL, "shfile_fork_win: i=%d size=%d fd=%d native=%d hndls[%d]=%p\n",
916	i, pfdtab->size, pfdtab->tab[i].fd, pfdtab->tab[i].native, i, hndls[i]));
917	}
918	}
919
920	shmtx_leave(&pfdtab->mtx, &tmp);
921	}
922
923	/**
924	* Helper for sh_execve.
925	*
926	* This is called before and after CreateProcess. On the first call it
927	* will mark the non-close-on-exec handles as inheritable and produce
928	* the startup info for the CRT. On the second call, after CreateProcess,
929	* it will restore the handle inheritability properties.
930	*
931	* @returns Pointer to CRT data if prepare is 1, NULL if prepare is 0.
932	* @param pfdtab The file descriptor table.
933	* @param prepare Which call, 1 if before and 0 if after.
934	* @param sizep Where to store the size of the returned data.
935	* @param hndls Where to store the three standard handles.
936	*/
937	void shfile_exec_win(shfdtab pfdtab, int prepare, unsigned short sizep, intptr_t hndls)
938	{
939	void *pvRet;
940	shmtxtmp tmp;
941	unsigned count;
942	unsigned i;
943
944	shmtx_enter(&pfdtab->mtx, &tmp);
945	TRACE2((NULL, "shfile_exec_win: prepare=%p\n", prepare));
946
947	count = pfdtab->size < (0x10000-4) / (1 + sizeof(HANDLE))
948	? pfdtab->size
949	: (0x10000-4) / (1 + sizeof(HANDLE));
950	while (count > 3 && pfdtab->tab[count - 1].fd == -1)
951	count--;
952
953	if (prepare)
954	{
955	size_t cbData = sizeof(int) + count * (1 + sizeof(HANDLE));
956	uint8_t *pbData = sh_malloc(shthread_get_shell(), cbData);
957	uint8_t *paf = pbData + sizeof(int);
958	HANDLE pah = (HANDLE )(paf + count);
959
960	(int )pbData = count;
961
962	i = count;
963	while (i-- > 0)
964	{
965	if ( pfdtab->tab[i].fd == i
966	&& !(pfdtab->tab[i].shflags & SHFILE_FLAGS_CLOSE_ON_EXEC))
967	{
968	HANDLE hFile = shfile_set_inherit_win(&pfdtab->tab[i], 1);
969	TRACE2((NULL, " #%d: native=%#x oflags=%#x shflags=%#x\n",
970	i, hFile, pfdtab->tab[i].oflags, pfdtab->tab[i].shflags));
971	paf[i] = FOPEN;
972	if (pfdtab->tab[i].oflags & _O_APPEND)
973	paf[i] \|= FAPPEND;
974	if (pfdtab->tab[i].oflags & _O_TEXT)
975	paf[i] \|= FTEXT;
976	switch (pfdtab->tab[i].shflags & SHFILE_FLAGS_TYPE_MASK)
977	{
978	case SHFILE_FLAGS_TTY: paf[i] \|= FDEV; break;
979	case SHFILE_FLAGS_PIPE: paf[i] \|= FPIPE; break;
980	}
981	pah[i] = hFile;
982	}
983	else
984	{
985	paf[i] = 0;
986	pah[i] = INVALID_HANDLE_VALUE;
987	}
988	}
989
990	for (i = 0; i < 3; i++)
991	{
992	if ( i < count
993	&& pfdtab->tab[i].fd == i)
994	hndls[i] = pfdtab->tab[i].native;
995	else
996	hndls[i] = (intptr_t)INVALID_HANDLE_VALUE;
997	TRACE2((NULL, "shfile_exec_win: i=%d count=%d fd=%d native=%d hndls[%d]=\n",
998	i, count, pfdtab->tab[i].fd, pfdtab->tab[i].native, i, hndls[i]));
999	}
1000
1001	*sizep = (unsigned short)cbData;
1002	pvRet = pbData;
1003	}
1004	else
1005	{
1006	assert(!hndls);
1007	assert(!sizep);
1008	i = count;
1009	while (i-- > 0)
1010	{
1011	if ( pfdtab->tab[i].fd == i
1012	&& !(pfdtab->tab[i].shflags & SHFILE_FLAGS_CLOSE_ON_EXEC))
1013	shfile_set_inherit_win(&pfdtab->tab[i], 0);
1014	}
1015	pvRet = NULL;
1016	}
1017
1018	shmtx_leave(&pfdtab->mtx, &tmp);
1019	return pvRet;
1020	}
1021
1022	#endif /* K_OS_WINDOWS */
1023
1024	#if K_OS != K_OS_WINDOWS
1025	/**
1026	* Prepare file handles for inherting before a execve call.
1027	*
1028	* This is only used in the normal mode, so we've forked and need not worry
1029	* about cleaning anything up after us. Nor do we need think about locking.
1030	*
1031	* @returns 0 on success, -1 on failure.
1032	*/
1033	int shfile_exec_unix(shfdtab *pfdtab)
1034	{
1035	int rc = 0;
1036	# ifdef SHFILE_IN_USE
1037	unsigned fd;
1038
1039	for (fd = 0; fd < pfdtab->size; fd++)
1040	{
1041	if ( pfdtab->tab[fd].fd != -1
1042	&& !(pfdtab->tab[fd].shflags & SHFILE_FLAGS_CLOSE_ON_EXEC) )
1043	{
1044	TRACE2((NULL, "shfile_exec_unix: %d => %d\n", pfdtab->tab[fd].native, fd));
1045	if (dup2(pfdtab->tab[fd].native, fd) < 0)
1046	{
1047	/* fatal_error(NULL, "shfile_exec_unix: failed to move %d to %d", pfdtab->tab[fd].fd, fd); */
1048	rc = -1;
1049	}
1050	}
1051	}
1052	# endif
1053	return rc;
1054	}
1055	#endif /* !K_OS_WINDOWS */
1056
1057	/**
1058	* open().
1059	*/
1060	int shfile_open(shfdtab pfdtab, const char name, unsigned flags, mode_t mode)
1061	{
1062	int fd;
1063	#ifdef SHFILE_IN_USE
1064	char absname[SHFILE_MAX_PATH];
1065	# if K_OS == K_OS_WINDOWS
1066	HANDLE hFile;
1067	DWORD dwDesiredAccess;
1068	DWORD dwShareMode;
1069	DWORD dwCreationDisposition;
1070	DWORD dwFlagsAndAttributes;
1071	SECURITY_ATTRIBUTES SecurityAttributes;
1072
1073	# ifndef _O_ACCMODE
1074	# define _O_ACCMODE (_O_RDONLY\|_O_WRONLY\|_O_RDWR)
1075	# endif
1076	switch (flags & (_O_ACCMODE \| _O_APPEND))
1077	{
1078	case _O_RDONLY: dwDesiredAccess = GENERIC_READ; break;
1079	case _O_RDONLY \| _O_APPEND: dwDesiredAccess = GENERIC_READ; break;
1080	case _O_WRONLY: dwDesiredAccess = GENERIC_WRITE; break;
1081	case _O_WRONLY \| _O_APPEND: dwDesiredAccess = (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA); break;
1082	case _O_RDWR: dwDesiredAccess = GENERIC_READ \| GENERIC_WRITE; break;
1083	case _O_RDWR \| _O_APPEND: dwDesiredAccess = GENERIC_READ \| (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA); break;
1084
1085	default:
1086	RETURN_ERROR(-1, EINVAL, "invalid mode");
1087	}
1088
1089	dwShareMode = FILE_SHARE_DELETE \| FILE_SHARE_READ \| FILE_SHARE_WRITE;
1090
1091	SecurityAttributes.nLength = sizeof(SecurityAttributes);
1092	SecurityAttributes.lpSecurityDescriptor = NULL;
1093	SecurityAttributes.bInheritHandle = FALSE;
1094
1095	if (flags & _O_CREAT)
1096	{
1097	if ((flags & (_O_EXCL \| _O_TRUNC)) == (_O_EXCL \| _O_TRUNC))
1098	RETURN_ERROR(-1, EINVAL, "_O_EXCL \| _O_TRUNC");
1099
1100	if (flags & _O_TRUNC)
1101	dwCreationDisposition = CREATE_ALWAYS; /* not 100%, but close enough */
1102	else if (flags & _O_EXCL)
1103	dwCreationDisposition = CREATE_NEW;
1104	else
1105	dwCreationDisposition = OPEN_ALWAYS;
1106	}
1107	else if (flags & _O_TRUNC)
1108	dwCreationDisposition = TRUNCATE_EXISTING;
1109	else
1110	dwCreationDisposition = OPEN_EXISTING;
1111
1112	if (!(flags & _O_CREAT) \|\| (mode & 0222))
1113	dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL;
1114	else
1115	dwFlagsAndAttributes = FILE_ATTRIBUTE_READONLY;
1116
1117	fd = shfile_make_path(pfdtab, name, &absname[0]);
1118	if (!fd)
1119	{
1120	SetLastError(0);
1121	hFile = CreateFileA(absname,
1122	dwDesiredAccess,
1123	dwShareMode,
1124	&SecurityAttributes,
1125	dwCreationDisposition,
1126	dwFlagsAndAttributes,
1127	NULL /* hTemplateFile */);
1128	if (hFile != INVALID_HANDLE_VALUE)
1129	fd = shfile_insert(pfdtab, (intptr_t)hFile, flags, 0, -1, "shfile_open");
1130	else
1131	fd = shfile_dos2errno(GetLastError());
1132	}
1133
1134	# else /* K_OS != K_OS_WINDOWS */
1135	fd = shfile_make_path(pfdtab, name, &absname[0]);
1136	if (!fd)
1137	{
1138	fd = open(absname, flags, mode);
1139	if (fd != -1)
1140	fd = shfile_copy_insert_and_close(pfdtab, &fd, flags, 0, -1, "shfile_open");
1141	}
1142
1143	# endif /* K_OS != K_OS_WINDOWS */
1144
1145	#else
1146	fd = open(name, flags, mode);
1147	#endif
1148
1149	TRACE2((NULL, "shfile_open(%p:{%s}, %#x, 0%o) -> %d [%d]\n", name, name, flags, mode, fd, errno));
1150	return fd;
1151	}
1152
1153	int shfile_pipe(shfdtab *pfdtab, int fds[2])
1154	{
1155	int rc = -1;
1156	#ifdef SHFILE_IN_USE
1157	# if K_OS == K_OS_WINDOWS
1158	HANDLE hRead = INVALID_HANDLE_VALUE;
1159	HANDLE hWrite = INVALID_HANDLE_VALUE;
1160	SECURITY_ATTRIBUTES SecurityAttributes;
1161
1162	SecurityAttributes.nLength = sizeof(SecurityAttributes);
1163	SecurityAttributes.lpSecurityDescriptor = NULL;
1164	SecurityAttributes.bInheritHandle = FALSE;
1165
1166	fds[1] = fds[0] = -1;
1167	if (CreatePipe(&hRead, &hWrite, &SecurityAttributes, 4096))
1168	{
1169	fds[0] = shfile_insert(pfdtab, (intptr_t)hRead, O_RDONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe");
1170	if (fds[0] != -1)
1171	{
1172	fds[1] = shfile_insert(pfdtab, (intptr_t)hWrite, O_WRONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe");
1173	if (fds[1] != -1)
1174	rc = 0;
1175	}
1176
1177	# else
1178	int native_fds[2];
1179
1180	fds[1] = fds[0] = -1;
1181	if (!pipe(native_fds))
1182	{
1183	fds[0] = shfile_copy_insert_and_close(pfdtab, &native_fds[0], O_RDONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe");
1184	if (fds[0] != -1)
1185	{
1186	fds[1] = shfile_copy_insert_and_close(pfdtab, &native_fds[1], O_WRONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe");
1187	if (fds[1] != -1)
1188	rc = 0;
1189	}
1190	# endif
1191	if (fds[1] == -1)
1192	{
1193	int s = errno;
1194	if (fds[0] != -1)
1195	{
1196	shmtxtmp tmp;
1197	shmtx_enter(&pfdtab->mtx, &tmp);
1198	rc = fds[0];
1199	pfdtab->tab[rc].fd = -1;
1200	pfdtab->tab[rc].oflags = 0;
1201	pfdtab->tab[rc].shflags = 0;
1202	pfdtab->tab[rc].native = -1;
1203	shmtx_leave(&pfdtab->mtx, &tmp);
1204	}
1205
1206	# if K_OS == K_OS_WINDOWS
1207	CloseHandle(hRead);
1208	CloseHandle(hWrite);
1209	# else
1210	close(native_fds[0]);
1211	close(native_fds[1]);
1212	# endif
1213	fds[0] = fds[1] = -1;
1214	errno = s;
1215	rc = -1;
1216	}
1217	}
1218	else
1219	{
1220	# if K_OS == K_OS_WINDOWS
1221	errno = shfile_dos2errno(GetLastError());
1222	# endif
1223	rc = -1;
1224	}
1225
1226	#else
1227	rc = pipe(fds);
1228	#endif
1229
1230	TRACE2((NULL, "shfile_pipe() -> %d{%d,%d} [%d]\n", rc, fds[0], fds[1], errno));
1231	return rc;
1232	}
1233
1234	/**
1235	* dup().
1236	*/
1237	int shfile_dup(shfdtab *pfdtab, int fd)
1238	{
1239	return shfile_fcntl(pfdtab,fd, F_DUPFD, 0);
1240	}
1241
1242	/**
1243	* Move the file descriptor, closing any existing descriptor at @a fdto.
1244	*
1245	* @returns fdto on success, -1 and errno on failure.
1246	* @param pfdtab The file descriptor table.
1247	* @param fdfrom The descriptor to move.
1248	* @param fdto Where to move it.
1249	*/
1250	int shfile_movefd(shfdtab *pfdtab, int fdfrom, int fdto)
1251	{
1252	#ifdef SHFILE_IN_USE
1253	int rc;
1254	shmtxtmp tmp;
1255	shfile *file = shfile_get(pfdtab, fdfrom, &tmp);
1256	if (file)
1257	{
1258	/* prepare the new entry */
1259	if (fdto >= (int)pfdtab->size)
1260	shfile_grow_tab_locked(pfdtab, fdto);
1261	if (fdto < (int)pfdtab->size)
1262	{
1263	if (pfdtab->tab[fdto].fd != -1)
1264	shfile_native_close(pfdtab->tab[fdto].native, pfdtab->tab[fdto].oflags);
1265
1266	/* setup the target. */
1267	pfdtab->tab[fdto].fd = fdto;
1268	pfdtab->tab[fdto].oflags = file->oflags;
1269	pfdtab->tab[fdto].shflags = file->shflags;
1270	pfdtab->tab[fdto].native = file->native;
1271
1272	/* close the source. */
1273	file->fd = -1;
1274	file->oflags = 0;
1275	file->shflags = 0;
1276	file->native = -1;
1277
1278	rc = fdto;
1279	}
1280	else
1281	{
1282	errno = EMFILE;
1283	rc = -1;
1284	}
1285
1286	shfile_put(pfdtab, file, &tmp);
1287	}
1288	else
1289	rc = -1;
1290	return rc;
1291
1292	#else
1293	int fdnew = dup2(fdfrom, fdto);
1294	if (fdnew >= 0)
1295	close(fdfrom);
1296	return fdnew;
1297	#endif
1298	}
1299
1300	/**
1301	* Move the file descriptor to somewhere at @a fdMin or above.
1302	*
1303	* @returns the new file descriptor success, -1 and errno on failure.
1304	* @param pfdtab The file descriptor table.
1305	* @param fdfrom The descriptor to move.
1306	* @param fdMin The minimum descriptor.
1307	*/
1308	int shfile_movefd_above(shfdtab *pfdtab, int fdfrom, int fdMin)
1309	{
1310	#ifdef SHFILE_IN_USE
1311	int fdto;
1312	shmtxtmp tmp;
1313	shfile *file = shfile_get(pfdtab, fdfrom, &tmp);
1314	if (file)
1315	{
1316	/* find a new place */
1317	int i;
1318	fdto = -1;
1319	for (i = fdMin; (unsigned)i < pfdtab->size; i++)
1320	if (pfdtab->tab[i].fd == -1)
1321	{
1322	fdto = i;
1323	break;
1324	}
1325	if (fdto == -1)
1326	fdto = shfile_grow_tab_locked(pfdtab, fdMin);
1327	if (fdto != -1)
1328	{
1329	/* setup the target. */
1330	pfdtab->tab[fdto].fd = fdto;
1331	pfdtab->tab[fdto].oflags = file->oflags;
1332	pfdtab->tab[fdto].shflags = file->shflags;
1333	pfdtab->tab[fdto].native = file->native;
1334
1335	/* close the source. */
1336	file->fd = -1;
1337	file->oflags = 0;
1338	file->shflags = 0;
1339	file->native = -1;
1340	}
1341	else
1342	{
1343	errno = EMFILE;
1344	fdto = -1;
1345	}
1346
1347	shfile_put(pfdtab, file, &tmp);
1348	}
1349	else
1350	fdto = -1;
1351	return fdto;
1352
1353	#else
1354	int fdnew = fcntl(fdfrom, F_DUPFD, fdMin);
1355	if (fdnew >= 0)
1356	close(fdfrom);
1357	return fdnew;
1358	#endif
1359	}
1360
1361	/**
1362	* close().
1363	*/
1364	int shfile_close(shfdtab *pfdtab, unsigned fd)
1365	{
1366	int rc;
1367	#ifdef SHFILE_IN_USE
1368	shmtxtmp tmp;
1369	shfile *file = shfile_get(pfdtab, fd, &tmp);
1370	if (file)
1371	{
1372	shfile_native_close(file->native, file->oflags);
1373
1374	file->fd = -1;
1375	file->oflags = 0;
1376	file->shflags = 0;
1377	file->native = -1;
1378
1379	shfile_put(pfdtab, file, &tmp);
1380	rc = 0;
1381	}
1382	else
1383	rc = -1;
1384
1385	#else
1386	rc = close(fd);
1387	#endif
1388
1389	TRACE2((NULL, "shfile_close(%d) -> %d [%d]\n", fd, rc, errno));
1390	return rc;
1391	}
1392
1393	/**
1394	* read().
1395	*/
1396	long shfile_read(shfdtab pfdtab, int fd, void buf, size_t len)
1397	{
1398	long rc;
1399	#ifdef SHFILE_IN_USE
1400	shmtxtmp tmp;
1401	shfile *file = shfile_get(pfdtab, fd, &tmp);
1402	if (file)
1403	{
1404	# if K_OS == K_OS_WINDOWS
1405	DWORD dwRead = 0;
1406	if (ReadFile((HANDLE)file->native, buf, (DWORD)len, &dwRead, NULL))
1407	rc = dwRead;
1408	else
1409	rc = shfile_dos2errno(GetLastError());
1410	# else
1411	rc = read(file->native, buf, len);
1412	# endif
1413
1414	shfile_put(pfdtab, file, &tmp);
1415	}
1416	else
1417	rc = -1;
1418
1419	#else
1420	rc = read(fd, buf, len);
1421	#endif
1422	return rc;
1423	}
1424
1425	/**
1426	* write().
1427	*/
1428	long shfile_write(shfdtab pfdtab, int fd, const void buf, size_t len)
1429	{
1430	long rc;
1431	#ifdef SHFILE_IN_USE
1432	shmtxtmp tmp;
1433	shfile *file = shfile_get(pfdtab, fd, &tmp);
1434	if (file)
1435	{
1436	# if K_OS == K_OS_WINDOWS
1437	DWORD dwWritten = 0;
1438	if (WriteFile((HANDLE)file->native, buf, (DWORD)len, &dwWritten, NULL))
1439	rc = dwWritten;
1440	else
1441	rc = shfile_dos2errno(GetLastError());
1442	# else
1443	rc = write(file->native, buf, len);
1444	# endif
1445
1446	shfile_put(pfdtab, file, &tmp);
1447	}
1448	else
1449	rc = -1;
1450
1451	# ifdef DEBUG
1452	if (fd != shthread_get_shell()->tracefd)
1453	TRACE2((NULL, "shfile_write(%d,,%d) -> %d [%d]\n", fd, len, rc, errno));
1454	# endif
1455
1456	#else
1457	if (fd != shthread_get_shell()->tracefd)
1458	{
1459	int iSavedErrno = errno;
1460	struct stat s;
1461	int x;
1462	x = fstat(fd, &s);
1463	TRACE2((NULL, "shfile_write(%d) - %lu bytes (%d) - pos %lu - before; %o\n",
1464	fd, (long)s.st_size, x, (long)lseek(fd, 0, SEEK_CUR), s.st_mode ));
1465	errno = iSavedErrno;
1466	}
1467
1468	rc = write(fd, buf, len);
1469	#endif
1470	return rc;
1471	}
1472
1473	/**
1474	* lseek().
1475	*/
1476	long shfile_lseek(shfdtab *pfdtab, int fd, long off, int whench)
1477	{
1478	long rc;
1479	#ifdef SHFILE_IN_USE
1480	shmtxtmp tmp;
1481	shfile *file = shfile_get(pfdtab, fd, &tmp);
1482	if (file)
1483	{
1484	# if K_OS == K_OS_WINDOWS
1485	assert(SEEK_SET == FILE_BEGIN);
1486	assert(SEEK_CUR == FILE_CURRENT);
1487	assert(SEEK_END == FILE_END);
1488	rc = SetFilePointer((HANDLE)file->native, off, NULL, whench);
1489	if (rc == INVALID_SET_FILE_POINTER)
1490	rc = shfile_dos2errno(GetLastError());
1491	# else
1492	rc = lseek(file->native, off, whench);
1493	# endif
1494
1495	shfile_put(pfdtab, file, &tmp);
1496	}
1497	else
1498	rc = -1;
1499
1500	#else
1501	rc = lseek(fd, off, whench);
1502	#endif
1503
1504	return rc;
1505	}
1506
1507	int shfile_fcntl(shfdtab *pfdtab, int fd, int cmd, int arg)
1508	{
1509	int rc;
1510	#ifdef SHFILE_IN_USE
1511	shmtxtmp tmp;
1512	shfile *file = shfile_get(pfdtab, fd, &tmp);
1513	if (file)
1514	{
1515	switch (cmd)
1516	{
1517	case F_GETFL:
1518	rc = file->oflags;
1519	break;
1520
1521	case F_SETFL:
1522	{
1523	unsigned mask = O_NONBLOCK \| O_APPEND \| O_BINARY \| O_TEXT;
1524	# ifdef O_DIRECT
1525	mask \|= O_DIRECT;
1526	# endif
1527	# ifdef O_ASYNC
1528	mask \|= O_ASYNC;
1529	# endif
1530	# ifdef O_SYNC
1531	mask \|= O_SYNC;
1532	# endif
1533	if ((file->oflags & mask) == (arg & mask))
1534	rc = 0;
1535	else
1536	{
1537	# if K_OS == K_OS_WINDOWS
1538	assert(0);
1539	errno = EINVAL;
1540	rc = -1;
1541	# else
1542	rc = fcntl(file->native, F_SETFL, arg);
1543	if (rc != -1)
1544	file->oflags = (file->oflags & ~mask) \| (arg & mask);
1545	# endif
1546	}
1547	break;
1548	}
1549
1550	case F_DUPFD:
1551	{
1552	# if K_OS == K_OS_WINDOWS
1553	HANDLE hNew = INVALID_HANDLE_VALUE;
1554	if (DuplicateHandle(GetCurrentProcess(),
1555	(HANDLE)file->native,
1556	GetCurrentProcess(),
1557	&hNew,
1558	0,
1559	FALSE /* bInheritHandle */,
1560	DUPLICATE_SAME_ACCESS))
1561	rc = shfile_insert(pfdtab, (intptr_t)hNew, file->oflags, file->shflags, arg, "shfile_fcntl");
1562	else
1563	rc = shfile_dos2errno(GetLastError());
1564	# else
1565	int nativeNew = fcntl(file->native, F_DUPFD, SHFILE_UNIX_MIN_FD);
1566	if (nativeNew != -1)
1567	rc = shfile_insert(pfdtab, nativeNew, file->oflags, file->shflags, arg, "shfile_fcntl");
1568	else
1569	rc = -1;
1570	# endif
1571	break;
1572	}
1573
1574	default:
1575	errno = -EINVAL;
1576	rc = -1;
1577	break;
1578	}
1579
1580	shfile_put(pfdtab, file, &tmp);
1581	}
1582	else
1583	rc = -1;
1584
1585	#else
1586	rc = fcntl(fd, cmd, arg);
1587	#endif
1588
1589	switch (cmd)
1590	{
1591	case F_GETFL: TRACE2((NULL, "shfile_fcntl(%d,F_GETFL,ignored=%d) -> %d [%d]\n", fd, arg, rc, errno)); break;
1592	case F_SETFL: TRACE2((NULL, "shfile_fcntl(%d,F_SETFL,newflags=%#x) -> %d [%d]\n", fd, arg, rc, errno)); break;
1593	case F_DUPFD: TRACE2((NULL, "shfile_fcntl(%d,F_DUPFD,minfd=%d) -> %d [%d]\n", fd, arg, rc, errno)); break;
1594	default: TRACE2((NULL, "shfile_fcntl(%d,%d,%d) -> %d [%d]\n", fd, cmd, arg, rc, errno)); break;
1595	}
1596	return rc;
1597	}
1598
1599	int shfile_stat(shfdtab pfdtab, const char path, struct stat *pst)
1600	{
1601	#ifdef SHFILE_IN_USE
1602	char abspath[SHFILE_MAX_PATH];
1603	int rc;
1604	rc = shfile_make_path(pfdtab, path, &abspath[0]);
1605	if (!rc)
1606	{
1607	# if K_OS == K_OS_WINDOWS
1608	int dir_slash = shfile_trailing_slash_hack(abspath);
1609	rc = stat(abspath, pst); /** @todo re-implement stat. */
1610	if (!rc && dir_slash && !S_ISDIR(pst->st_mode))
1611	{
1612	rc = -1;
1613	errno = ENOTDIR;
1614	}
1615	# else
1616	rc = stat(abspath, pst);
1617	# endif
1618	}
1619	TRACE2((NULL, "shfile_stat(,%s,) -> %d [%d]\n", path, rc, errno));
1620	return rc;
1621	#else
1622	return stat(path, pst);
1623	#endif
1624	}
1625
1626	int shfile_lstat(shfdtab pfdtab, const char path, struct stat *pst)
1627	{
1628	int rc;
1629	#ifdef SHFILE_IN_USE
1630	char abspath[SHFILE_MAX_PATH];
1631
1632	rc = shfile_make_path(pfdtab, path, &abspath[0]);
1633	if (!rc)
1634	{
1635	# if K_OS == K_OS_WINDOWS
1636	int dir_slash = shfile_trailing_slash_hack(abspath);
1637	rc = stat(abspath, pst); /** @todo re-implement stat. */
1638	if (!rc && dir_slash && !S_ISDIR(pst->st_mode))
1639	{
1640	rc = -1;
1641	errno = ENOTDIR;
1642	}
1643	# else
1644	rc = lstat(abspath, pst);
1645	# endif
1646	}
1647	#else
1648	rc = stat(path, pst);
1649	#endif
1650	TRACE2((NULL, "shfile_stat(,%s,) -> %d [%d]\n", path, rc, errno));
1651	return rc;
1652	}
1653
1654	/**
1655	* chdir().
1656	*/
1657	int shfile_chdir(shfdtab pfdtab, const char path)
1658	{
1659	int rc;
1660	#ifdef SHFILE_IN_USE
1661	shinstance *psh = shthread_get_shell();
1662	char abspath[SHFILE_MAX_PATH];
1663
1664	rc = shfile_make_path(pfdtab, path, &abspath[0]);
1665	if (!rc)
1666	{
1667	char *abspath_copy = sh_strdup(psh, abspath);
1668	char *free_me = abspath_copy;
1669	rc = chdir(abspath);
1670	if (!rc)
1671	{
1672	shmtxtmp tmp;
1673	shmtx_enter(&pfdtab->mtx, &tmp);
1674
1675	shfile_fix_slashes(abspath_copy);
1676	free_me = pfdtab->cwd;
1677	pfdtab->cwd = abspath_copy;
1678
1679	shmtx_leave(&pfdtab->mtx, &tmp);
1680	}
1681	sh_free(psh, free_me);
1682	}
1683	else
1684	rc = -1;
1685	#else
1686	rc = chdir(path);
1687	#endif
1688
1689	TRACE2((NULL, "shfile_chdir(,%s) -> %d [%d]\n", path, rc, errno));
1690	return rc;
1691	}
1692
1693	/**
1694	* getcwd().
1695	*/
1696	char shfile_getcwd(shfdtab pfdtab, char *buf, int size)
1697	{
1698	char *ret;
1699	#ifdef SHFILE_IN_USE
1700
1701	ret = NULL;
1702	if (buf && !size)
1703	errno = -EINVAL;
1704	else
1705	{
1706	size_t cwd_size;
1707	shmtxtmp tmp;
1708	shmtx_enter(&pfdtab->mtx, &tmp);
1709
1710	cwd_size = strlen(pfdtab->cwd) + 1;
1711	if (buf)
1712	{
1713	if (cwd_size <= (size_t)size)
1714	ret = memcpy(buf, pfdtab->cwd, cwd_size);
1715	else
1716	errno = ERANGE;
1717	}
1718	else
1719	{
1720	if ((size_t)size < cwd_size)
1721	size = (int)cwd_size;
1722	ret = sh_malloc(shthread_get_shell(), size);
1723	if (ret)
1724	ret = memcpy(ret, pfdtab->cwd, cwd_size);
1725	else
1726	errno = ENOMEM;
1727	}
1728
1729	shmtx_leave(&pfdtab->mtx, &tmp);
1730	}
1731	#else
1732	ret = getcwd(buf, size);
1733	#endif
1734
1735	TRACE2((NULL, "shfile_getcwd(,%p,%d) -> %s [%d]\n", buf, size, ret, errno));
1736	return ret;
1737	}
1738
1739	/**
1740	* access().
1741	*/
1742	int shfile_access(shfdtab pfdtab, const char path, int type)
1743	{
1744	int rc;
1745	#ifdef SHFILE_IN_USE
1746	char abspath[SHFILE_MAX_PATH];
1747
1748	rc = shfile_make_path(pfdtab, path, &abspath[0]);
1749	if (!rc)
1750	{
1751	# ifdef _MSC_VER
1752	if (type & X_OK)
1753	type = (type & ~X_OK) \| R_OK;
1754	# endif
1755	rc = access(abspath, type);
1756	}
1757	#else
1758	# ifdef _MSC_VER
1759	if (type & X_OK)
1760	type = (type & ~X_OK) \| R_OK;
1761	# endif
1762	rc = access(path, type);
1763	#endif
1764
1765	TRACE2((NULL, "shfile_access(,%s,%#x) -> %d [%d]\n", path, type, rc, errno));
1766	return rc;
1767	}
1768
1769	/**
1770	* isatty()
1771	*/
1772	int shfile_isatty(shfdtab *pfdtab, int fd)
1773	{
1774	int rc;
1775	#ifdef SHFILE_IN_USE
1776	shmtxtmp tmp;
1777	shfile *file = shfile_get(pfdtab, fd, &tmp);
1778	if (file)
1779	{
1780	# if K_OS == K_OS_WINDOWS
1781	rc = (file->shflags & SHFILE_FLAGS_TYPE_MASK) == SHFILE_FLAGS_TTY;
1782	# else
1783	rc = isatty(file->native);
1784	# endif
1785	shfile_put(pfdtab, file, &tmp);
1786	}
1787	else
1788	rc = 0;
1789	#else
1790	rc = isatty(fd);
1791	#endif
1792
1793	TRACE2((NULL, "isatty(%d) -> %d [%d]\n", fd, rc, errno));
1794	return rc;
1795	}
1796
1797	/**
1798	* fcntl F_SETFD / FD_CLOEXEC.
1799	*/
1800	int shfile_cloexec(shfdtab *pfdtab, int fd, int closeit)
1801	{
1802	int rc;
1803	#ifdef SHFILE_IN_USE
1804	shmtxtmp tmp;
1805	shfile *file = shfile_get(pfdtab, fd, &tmp);
1806	if (file)
1807	{
1808	if (closeit)
1809	file->shflags \|= SHFILE_FLAGS_CLOSE_ON_EXEC;
1810	else
1811	file->shflags &= ~SHFILE_FLAGS_CLOSE_ON_EXEC;
1812	shfile_put(pfdtab, file, &tmp);
1813	rc = 0;
1814	}
1815	else
1816	rc = -1;
1817	#else
1818	rc = fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0)
1819	\| (closeit ? FD_CLOEXEC : 0));
1820	#endif
1821
1822	TRACE2((NULL, "shfile_cloexec(%d, %d) -> %d [%d]\n", fd, closeit, rc, errno));
1823	return rc;
1824	}
1825
1826
1827	int shfile_ioctl(shfdtab pfdtab, int fd, unsigned long request, void buf)
1828	{
1829	int rc;
1830	#ifdef SHFILE_IN_USE
1831	shmtxtmp tmp;
1832	shfile *file = shfile_get(pfdtab, fd, &tmp);
1833	if (file)
1834	{
1835	# if K_OS == K_OS_WINDOWS
1836	rc = -1;
1837	errno = ENOSYS;
1838	# else
1839	rc = ioctl(file->native, request, buf);
1840	# endif
1841	shfile_put(pfdtab, file, &tmp);
1842	}
1843	else
1844	rc = -1;
1845	#else
1846	rc = ioctl(fd, request, buf);
1847	#endif
1848
1849	TRACE2((NULL, "ioctl(%d, %#x, %p) -> %d\n", fd, request, buf, rc));
1850	return rc;
1851	}
1852
1853
1854	mode_t shfile_get_umask(shfdtab *pfdtab)
1855	{
1856	/** @todo */
1857	return 022;
1858	}
1859
1860	void shfile_set_umask(shfdtab *pfdtab, mode_t mask)
1861	{
1862	/** @todo */
1863	(void)mask;
1864	}
1865
1866
1867
1868	shdir shfile_opendir(shfdtab pfdtab, const char *dir)
1869	{
1870	#if defined(SHFILE_IN_USE) && K_OS == K_OS_WINDOWS
1871	shdir *pdir = NULL;
1872
1873	TRACE2((NULL, "shfile_opendir: dir='%s'\n", dir));
1874	shfile_init_globals();
1875	if (g_pfnNtQueryDirectoryFile)
1876	{
1877	char abspath[SHFILE_MAX_PATH];
1878	if (shfile_make_path(pfdtab, dir, &abspath[0]) == 0)
1879	{
1880	HANDLE hFile;
1881	SECURITY_ATTRIBUTES SecurityAttributes;
1882
1883	SecurityAttributes.nLength = sizeof(SecurityAttributes);
1884	SecurityAttributes.lpSecurityDescriptor = NULL;
1885	SecurityAttributes.bInheritHandle = FALSE;
1886
1887	hFile = CreateFileA(abspath,
1888	GENERIC_READ,
1889	FILE_SHARE_DELETE \| FILE_SHARE_READ \| FILE_SHARE_WRITE,
1890	&SecurityAttributes,
1891	OPEN_EXISTING,
1892	FILE_ATTRIBUTE_DIRECTORY \| FILE_FLAG_BACKUP_SEMANTICS,
1893	NULL /* hTemplateFile */);
1894	if (hFile != INVALID_HANDLE_VALUE)
1895	{
1896	pdir = (shdir )sh_malloc(shthread_get_shell(), sizeof(pdir));
1897	if (pdir)
1898	{
1899	pdir->pfdtab = pfdtab;
1900	pdir->native = hFile;
1901	pdir->off = ~(size_t)0;
1902	}
1903	else
1904	CloseHandle(hFile);
1905	}
1906	else
1907	{
1908	errno = shfile_dos2errno(GetLastError());
1909	TRACE2((NULL, "shfile_opendir: CreateFileA(%s) -> %d/%d\n", abspath, GetLastError(), errno));
1910	}
1911	}
1912	}
1913	else
1914	errno = ENOSYS;
1915	return pdir;
1916	#else
1917	TRACE2((NULL, "shfile_opendir: dir='%s'\n", dir));
1918	return (shdir *)opendir(dir);
1919	#endif
1920	}
1921
1922	shdirent shfile_readdir(struct shdir pdir)
1923	{
1924	#if defined(SHFILE_IN_USE) && K_OS == K_OS_WINDOWS
1925	if (pdir)
1926	{
1927	NTSTATUS rcNt;
1928
1929	if ( pdir->off == ~(size_t)0
1930	\|\| pdir->off + sizeof(MY_FILE_NAMES_INFORMATION) >= pdir->cb)
1931	{
1932	MY_IO_STATUS_BLOCK Ios;
1933
1934	memset(&Ios, 0, sizeof(Ios));
1935	rcNt = g_pfnNtQueryDirectoryFile(pdir->native,
1936	NULL /Event/,
1937	NULL /ApcRoutine/,
1938	NULL /ApcContext/,
1939	&Ios,
1940	&pdir->buf[0],
1941	sizeof(pdir->buf),
1942	MY_FileNamesInformation,
1943	FALSE /ReturnSingleEntry/,
1944	NULL /FileName/,
1945	pdir->off == ~(size_t)0 /RestartScan/);
1946	if (rcNt >= 0 && rcNt != STATUS_PENDING)
1947	{
1948	pdir->cb = Ios.Information;
1949	pdir->off = 0;
1950	}
1951	else if (rcNt == STATUS_NO_MORE_FILES)
1952	errno = 0; /* wrong? */
1953	else
1954	shfile_nt2errno(rcNt);
1955	}
1956
1957	if ( pdir->off != ~(size_t)0
1958	&& pdir->off + sizeof(MY_FILE_NAMES_INFORMATION) <= pdir->cb)
1959	{
1960	PMY_FILE_NAMES_INFORMATION pcur = (PMY_FILE_NAMES_INFORMATION)&pdir->buf[pdir->off];
1961	ANSI_STRING astr;
1962	UNICODE_STRING ustr;
1963
1964	astr.Length = astr.MaximumLength = sizeof(pdir->ent.name);
1965	astr.Buffer = &pdir->ent.name[0];
1966
1967	ustr.Length = ustr.MaximumLength = pcur->FileNameLength < ~(USHORT)0 ? (USHORT)pcur->FileNameLength : ~(USHORT)0;
1968	ustr.Buffer = &pcur->FileName[0];
1969
1970	rcNt = g_pfnRtlUnicodeStringToAnsiString(&astr, &ustr, 0/AllocateDestinationString/);
1971	if (rcNt < 0)
1972	sprintf(pdir->ent.name, "conversion-failed-%08x-rcNt=%08x-len=%u",
1973	pcur->FileIndex, rcNt, pcur->FileNameLength);
1974	if (pcur->NextEntryOffset)
1975	pdir->off += pcur->NextEntryOffset;
1976	else
1977	pdir->off = pdir->cb;
1978	return &pdir->ent;
1979	}
1980	}
1981	else
1982	errno = EINVAL;
1983	return NULL;
1984	#else
1985	struct dirent pde = readdir((DIR )pdir);
1986	return pde ? (shdirent *)&pde->d_name[0] : NULL;
1987	#endif
1988	}
1989
1990	void shfile_closedir(struct shdir *pdir)
1991	{
1992	#if defined(SHFILE_IN_USE) && K_OS == K_OS_WINDOWS
1993	if (pdir)
1994	{
1995	CloseHandle(pdir->native);
1996	pdir->pfdtab = NULL;
1997	pdir->native = INVALID_HANDLE_VALUE;
1998	sh_free(shthread_get_shell(), pdir);
1999	}
2000	else
2001	errno = EINVAL;
2002	#else
2003	closedir((DIR *)pdir);
2004	#endif
2005	}
2006

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

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

Download in other formats: