diff options
Diffstat (limited to 'src/kash/shfile.c')
| -rw-r--r-- | src/kash/shfile.c | 2656 |
1 files changed, 2656 insertions, 0 deletions
diff --git a/src/kash/shfile.c b/src/kash/shfile.c new file mode 100644 index 0000000..78f5332 --- /dev/null +++ b/src/kash/shfile.c @@ -0,0 +1,2656 @@ +/* $Id: shfile.c 3542 2022-01-29 01:36:00Z bird $ */ +/** @file + * + * File management. + * + * Copyright (c) 2007-2010 knut st. osmundsen <bird-kBuild-spamx@anduin.net> + * + * + * This file is part of kBuild. + * + * kBuild is free software; you can redistribute it and/or modify + * it under the terms of the GNU General Public License as published by + * the Free Software Foundation; either version 2 of the License, or + * (at your option) any later version. + * + * kBuild is distributed in the hope that it will be useful, + * but WITHOUT ANY WARRANTY; without even the implied warranty of + * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the + * GNU General Public License for more details. + * + * You should have received a copy of the GNU General Public License + * along with kBuild; if not, write to the Free Software + * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA + * + */ + +/******************************************************************************* +* Header Files * +*******************************************************************************/ +#include "shfile.h" +#include "shinstance.h" /* TRACE2 */ +#include <stdlib.h> +#include <stdio.h> +#include <string.h> + +#if K_OS == K_OS_WINDOWS +# include <ntstatus.h> +# define WIN32_NO_STATUS +# include <Windows.h> +# if !defined(_WIN32_WINNT) +# define _WIN32_WINNT 0x0502 /* Windows Server 2003 */ +# endif +# include <winternl.h> //NTSTATUS +#else +# include <unistd.h> +# include <fcntl.h> +# include <dirent.h> +#endif + + +/******************************************************************************* +* Defined Constants And Macros * +*******************************************************************************/ +/** @def SHFILE_IN_USE + * Whether the file descriptor table stuff is actually in use or not. + */ +#if K_OS == K_OS_WINDOWS \ + || K_OS == K_OS_OPENBSD /* because of ugly pthread library pipe hacks */ \ + || !defined(SH_FORKED_MODE) +# define SHFILE_IN_USE +#endif +/** The max file table size. */ +#define SHFILE_MAX 1024 +/** The file table growth rate. */ +#define SHFILE_GROW 64 +/** The min native unix file descriptor. */ +#define SHFILE_UNIX_MIN_FD 32 +/** The path buffer size we use. */ +#define SHFILE_MAX_PATH 4096 + +/** Set errno and return. Doing a trace in debug build. */ +#define RETURN_ERROR(rc, err, msg) \ + do { \ + TRACE2((NULL, "%s: " ## msg ## " - returning %d / %d\n", __FUNCTION__, (rc), (err))); \ + errno = (err); \ + return (rc); \ + } while (0) + +#if K_OS == K_OS_WINDOWS + /* See msdos.h for description. */ +# define FOPEN 0x01 +# define FEOFLAG 0x02 +# define FCRLF 0x04 +# define FPIPE 0x08 +# define FNOINHERIT 0x10 +# define FAPPEND 0x20 +# define FDEV 0x40 +# define FTEXT 0x80 + +# define MY_ObjectBasicInformation 0 +# define MY_FileNamesInformation 12 + +typedef struct +{ + ULONG Attributes; + ACCESS_MASK GrantedAccess; + ULONG HandleCount; + ULONG PointerCount; + ULONG PagedPoolUsage; + ULONG NonPagedPoolUsage; + ULONG Reserved[3]; + ULONG NameInformationLength; + ULONG TypeInformationLength; + ULONG SecurityDescriptorLength; + LARGE_INTEGER CreateTime; +} MY_OBJECT_BASIC_INFORMATION; + +#if 0 +typedef struct +{ + union + { + LONG Status; + PVOID Pointer; + }; + ULONG_PTR Information; +} MY_IO_STATUS_BLOCK; +#else +typedef IO_STATUS_BLOCK MY_IO_STATUS_BLOCK; +#endif +typedef MY_IO_STATUS_BLOCK *PMY_IO_STATUS_BLOCK; + +typedef struct +{ + ULONG NextEntryOffset; + ULONG FileIndex; + ULONG FileNameLength; + WCHAR FileName[1]; +} MY_FILE_NAMES_INFORMATION, *PMY_FILE_NAMES_INFORMATION; + +typedef NTSTATUS (NTAPI * PFN_NtQueryObject)(HANDLE, int, void *, size_t, size_t *); +typedef NTSTATUS (NTAPI * PFN_NtQueryDirectoryFile)(HANDLE, HANDLE, void *, void *, PMY_IO_STATUS_BLOCK, void *, + ULONG, int, int, PUNICODE_STRING, int); +typedef NTSTATUS (NTAPI * PFN_RtlUnicodeStringToAnsiString)(PANSI_STRING, PCUNICODE_STRING, int); + + +#endif /* K_OS_WINDOWS */ + + +/********************************************************************************************************************************* +* Global Variables * +*********************************************************************************************************************************/ +#if K_OS == K_OS_WINDOWS +static int g_shfile_globals_initialized = 0; +static PFN_NtQueryObject g_pfnNtQueryObject = NULL; +static PFN_NtQueryDirectoryFile g_pfnNtQueryDirectoryFile = NULL; +static PFN_RtlUnicodeStringToAnsiString g_pfnRtlUnicodeStringToAnsiString = NULL; +# ifdef KASH_ASYNC_CLOSE_HANDLE +/** Data for the asynchronous CloseHandle machinery. */ +static struct shfileasyncclose +{ + /** Mutex protecting the asynchronous CloseHandle stuff. */ + shmtx mtx; + /** Handle to event that the closer-threads are waiting on. */ + HANDLE evt_workers; + /** The ring buffer read index (for closer-threads). */ + unsigned volatile idx_read; + /** The ring buffer write index (for shfile_native_close). + * When idx_read and idx_write are the same, the ring buffer is empty. */ + unsigned volatile idx_write; + /** Number of handles currently being pending closure (handles + current + * CloseHandle calls). */ + unsigned volatile num_pending; + /** Set if the threads should terminate. */ + KBOOL volatile terminate_threads; + /** Set if one or more shell threads have requested evt_sync to be signalled + * when there are no more pending requests. */ + KBOOL volatile signal_sync; + /** Number of threads that have been spawned. */ + KU8 num_threads; + /** Handle to event that the shell threads are waiting on to sync. */ + HANDLE evt_sync; + /** Ring buffer containing handles to be closed. */ + HANDLE handles[32]; + /** Worker threads doing the asynchronous closing. */ + HANDLE threads[8]; +} g_shfile_async_close; +# endif +#endif /* K_OS_WINDOWS */ + + +/********************************************************************************************************************************* +* Internal Functions * +*********************************************************************************************************************************/ +#ifdef SHFILE_IN_USE +# if K_OS == K_OS_WINDOWS +static HANDLE shfile_set_inherit_win(shfile *pfd, int set); +# endif +#endif + + +#ifdef SHFILE_IN_USE + +# ifdef DEBUG +# if K_OS == K_OS_WINDOWS +static KU64 shfile_nano_ts(void) +{ + static KBOOL volatile s_has_factor = K_FALSE; + static double volatile s_factor; + double factor; + LARGE_INTEGER now; + if (s_has_factor) + factor = s_factor; + else + { + QueryPerformanceFrequency(&now); + s_factor = factor = (double)1000000000.0 / now.QuadPart; + s_has_factor = K_TRUE; + } + QueryPerformanceCounter(&now); + return (KU64)(now.QuadPart * factor); +} +# endif /* K_OS_WINDOWS */ +# endif /* DEBUG */ + +# if K_OS == K_OS_WINDOWS && defined(KASH_ASYNC_CLOSE_HANDLE) +/** + * The closer thread function. + */ +static unsigned __stdcall shfile_async_close_handle_thread(void *ignored) +{ + KBOOL decrement_pending = K_FALSE; + shthread_set_name("Async CloseHandle"); + while (!g_shfile_async_close.terminate_threads) + { + HANDLE toclose; + unsigned idx; + shmtxtmp tmp; + + /* + * Grab a handle if there is one: + */ + shmtx_enter(&g_shfile_async_close.mtx, &tmp); + + if (decrement_pending) + { + kHlpAssert(g_shfile_async_close.num_pending > 0); + g_shfile_async_close.num_pending -= 1; + } + + idx = g_shfile_async_close.idx_read % K_ELEMENTS(g_shfile_async_close.handles); + if (idx != g_shfile_async_close.idx_write % K_ELEMENTS(g_shfile_async_close.handles)) + { + kHlpAssert(g_shfile_async_close.num_pending > 0); + toclose = g_shfile_async_close.handles[idx]; + kHlpAssert(toclose); + g_shfile_async_close.handles[idx] = NULL; + g_shfile_async_close.idx_read = (idx + 1) % K_ELEMENTS(g_shfile_async_close.handles); + } + else + { + /* Signal waiters if requested and we've reached zero pending requests. */ + if (g_shfile_async_close.signal_sync && g_shfile_async_close.num_pending == 0) + { + BOOL rc = SetEvent(g_shfile_async_close.evt_sync); + kHlpAssert(rc); + g_shfile_async_close.signal_sync = FALSE; + } + toclose = NULL; + } + shmtx_leave(&g_shfile_async_close.mtx, &tmp); + + /* Do the closing if we have something to close, otherwise wait for work to arrive. */ + if (toclose != NULL) + { + BOOL rc = CloseHandle(toclose); + kHlpAssert(rc); + decrement_pending = K_TRUE; + } + else + { + DWORD dwRet = WaitForSingleObject(g_shfile_async_close.evt_workers, 10000 /*ms*/); + kHlpAssert(dwRet == WAIT_OBJECT_0 || dwRet == WAIT_TIMEOUT); + decrement_pending = K_FALSE; + } + } + + K_NOREF(ignored); + return 0; +} + +/** + * Try submit a handle for automatic closing. + * + * @returns K_TRUE if submitted successfully, K_FALSE if not. + */ +static KBOOL shfile_async_close_submit(HANDLE toclose) +{ + KBOOL ret; + unsigned idx; + unsigned idx_next; + unsigned idx_read; + unsigned num_pending = 0; + unsigned num_threads = 0; + shmtxtmp tmp; + shmtx_enter(&g_shfile_async_close.mtx, &tmp); + + /* Get the write index and check that there is a free slot in the buffer: */ + idx = g_shfile_async_close.idx_write % K_ELEMENTS(g_shfile_async_close.handles); + idx_next = (idx + 1) % K_ELEMENTS(g_shfile_async_close.handles); + idx_read = g_shfile_async_close.idx_read % K_ELEMENTS(g_shfile_async_close.handles); + if (idx_next != idx_read) + { + /* Write the handle to the ring buffer: */ + kHlpAssert(g_shfile_async_close.handles[idx] == NULL); + g_shfile_async_close.handles[idx] = toclose; + g_shfile_async_close.idx_write = idx_next; + + num_pending = g_shfile_async_close.num_pending + 1; + g_shfile_async_close.num_pending = num_pending; + + ret = SetEvent(g_shfile_async_close.evt_workers); + kHlpAssert(ret); + if (ret) + { + /* If we have more pending requests than threads, create a new thread. */ + num_threads = g_shfile_async_close.num_threads; + if (num_pending > num_threads && num_threads < K_ELEMENTS(g_shfile_async_close.threads)) + { + int const savederrno = errno; + unsigned tid = 0; + intptr_t hThread = _beginthreadex(NULL /*security*/, 0 /*stack_size*/, shfile_async_close_handle_thread, + NULL /*arg*/, 0 /*initflags*/, &tid); + kHlpAssert(hThread != -1); + if (hThread != -1) + { + g_shfile_async_close.threads[num_threads] = (HANDLE)hThread; + g_shfile_async_close.num_threads = ++num_threads; + } + else + { + TRACE2((NULL, "shfile_async_close_submit: _beginthreadex failed: %d\n", errno)); + if (num_threads == 0) + ret = K_FALSE; + } + errno = savederrno; + } + } + else + TRACE2((NULL, "shfile_async_close_submit: SetEvent(%p) failed: %u\n", g_shfile_async_close.evt_workers, GetLastError())); + + /* cleanup on failure. */ + if (ret) + { /* likely */ } + else + { + g_shfile_async_close.handles[idx] = NULL; + g_shfile_async_close.idx_write = idx; + g_shfile_async_close.num_pending = num_pending - 1; + } + } + else + ret = K_FALSE; + + shmtx_leave(&g_shfile_async_close.mtx, &tmp); + TRACE2((NULL, "shfile_async_close_submit: toclose=%p idx=%d #pending=%u #thread=%u -> %d\n", + toclose, idx, num_pending, num_threads, ret)); + return ret; +} + +/** + * Wait for all pending CloseHandle calls to complete. + */ +void shfile_async_close_sync(void) +{ + shmtxtmp tmp; + shmtx_enter(&g_shfile_async_close.mtx, &tmp); + + if (g_shfile_async_close.num_pending > 0) + { + DWORD dwRet; + +/** @todo help out? */ + if (!g_shfile_async_close.signal_sync) + { + BOOL rc = ResetEvent(g_shfile_async_close.evt_sync); + kHlpAssert(rc); K_NOREF(rc); + + g_shfile_async_close.signal_sync = K_TRUE; + } + + shmtx_leave(&g_shfile_async_close.mtx, &tmp); + + TRACE2((NULL, "shfile_async_close_sync: Calling WaitForSingleObject...\n")); + dwRet = WaitForSingleObject(g_shfile_async_close.evt_sync, 10000 /*ms*/); + kHlpAssert(dwRet == WAIT_OBJECT_0); + kHlpAssert(g_shfile_async_close.num_pending == 0); + TRACE2((NULL, "shfile_async_close_sync: WaitForSingleObject returned %u...\n", dwRet)); + } + else + shmtx_leave(&g_shfile_async_close.mtx, &tmp); +} + +# endif /* K_OS == K_OS_WINDOWS && defined(KASH_ASYNC_CLOSE_HANDLE) */ + +/** + * Close the specified native handle. + * + * @param native The native file handle. + * @param file The file table entry if available. + * @param inheritable The inheritability of the handle on windows, K_FALSE elsewhere. + */ +static void shfile_native_close(intptr_t native, shfile *file, KBOOL inheritable) +{ +# if K_OS == K_OS_WINDOWS +# ifdef KASH_ASYNC_CLOSE_HANDLE + /* + * CloseHandle may take several milliseconds on NTFS after we've appended + * a few bytes to a file. When a script uses lots of 'echo line-text >> file' + * we end up executing very slowly, even if 'echo' is builtin and the statement + * requires no subshells to be spawned. + * + * So, detect problematic handles and do CloseHandle asynchronously. When + * executing a child process, we probably will have to make sure the CloseHandle + * operation has completed before we do ResumeThread on the child to make 100% + * sure we can't have any sharing conflicts or end up with incorrect CRT stat() + * results. Sharing conflicts are not a problem for builtin commands, and for + * stat we do not use the CRT code but ntstat.c/h and it seems to work fine + * (might be a tiny bit slower, so (TODO) might be worth reducing what we ask for). + * + * If child processes are spawned using handle inheritance and the handle in + * question is inheritable, we will have to fix the inheriability before pushing + * on the async-close queue. This shouldn't have the CloseHandle issues. + */ + if ( file + && (file->shflags & (SHFILE_FLAGS_DIRTY | SHFILE_FLAGS_TYPE_MASK)) + == (SHFILE_FLAGS_DIRTY | SHFILE_FLAGS_FILE)) + { + if (inheritable) + native = (intptr_t)shfile_set_inherit_win(file, 0); + if (shfile_async_close_submit((HANDLE)native)) + return; + } + + /* + * Otherwise close it right here: + */ +# endif + { +# ifdef DEBUG + KU64 ns = shfile_nano_ts(); + BOOL fRc = CloseHandle((HANDLE)native); + kHlpAssert(fRc); K_NOREF(fRc); + ns = shfile_nano_ts() - ns; + if (ns > 1000000) + TRACE2((NULL, "shfile_native_close: %u ns %p oflags=%#x %s\n", + ns, native, file ? file->oflags : 0, file ? file->dbgname : NULL)); +# else + BOOL fRc = CloseHandle((HANDLE)native); + kHlpAssert(fRc); K_NOREF(fRc); +# endif + } + +# else /* K_OS != K_OS_WINDOWS */ + int s = errno; + close(native); + errno = s; +# endif /* K_OS != K_OS_WINDOWS */ + K_NOREF(file); +} + +/** + * Grows the descriptor table, making sure that it can hold @a fdMin, + * + * @returns The max(fdMin, fdFirstNew) on success, -1 on failure. + * @param pfdtab The table to grow. + * @param fdMin Grow to include this index. + */ +static int shfile_grow_tab_locked(shfdtab *pfdtab, int fdMin) +{ + /* + * Grow the descriptor table. + */ + int fdRet = -1; + shfile *new_tab; + int new_size = pfdtab->size + SHFILE_GROW; + while (new_size < fdMin) + new_size += SHFILE_GROW; + TRACE2((NULL, "shfile_grow_tab_locked: old %p / %d entries; new size: %d\n", pfdtab->tab, pfdtab->size, new_size)); + new_tab = sh_realloc(shthread_get_shell(), pfdtab->tab, new_size * sizeof(shfile)); + if (new_tab) + { + int i; + for (i = pfdtab->size; i < new_size; i++) + { + new_tab[i].fd = -1; + new_tab[i].oflags = 0; + new_tab[i].shflags = 0; + new_tab[i].native = -1; +# ifdef DEBUG + new_tab[i].dbgname = NULL; +# endif + } + + fdRet = pfdtab->size; + if (fdRet < fdMin) + fdRet = fdMin; + + pfdtab->tab = new_tab; + pfdtab->size = new_size; + + TRACE2((NULL, "shfile_grow_tab_locked: new %p / %d entries\n", pfdtab->tab, pfdtab->size)); + } + + return fdRet; +} + +/** + * Inserts the file into the descriptor table. + * + * If we're out of memory and cannot extend the table, we'll close the + * file, set errno to EMFILE and return -1. + * + * @returns The file descriptor number. -1 and errno on failure. + * @param pfdtab The file descriptor table. + * @param native The native file handle. + * @param oflags The flags the it was opened/created with. + * @param shflags The shell file flags. + * @param fdMin The minimum file descriptor number, pass -1 if any is ok. + * @param who Who we're doing this for (for logging purposes). + * @param dbgname The filename, if applicable/available. + */ +static int shfile_insert(shfdtab *pfdtab, intptr_t native, unsigned oflags, unsigned shflags, int fdMin, + const char *who, const char *dbgname) +{ + shmtxtmp tmp; + int fd; + int i; + + /* + * Fend of bad stuff. + */ + if (fdMin >= SHFILE_MAX) + { + TRACE2((NULL, "shfile_insert: fdMin=%d is out of bounds; native=%p %s\n", fdMin, native, dbgname)); + shfile_native_close(native, NULL, K_FALSE); + errno = EMFILE; + return -1; + } +# if K_OS != K_OS_WINDOWS + if (fcntl((int)native, F_SETFD, fcntl((int)native, F_GETFD, 0) | FD_CLOEXEC) == -1) + { + int e = errno; + TRACE2((NULL, "shfile_insert: F_SETFD failed %d; native=%p %s\n", e, native, dbgname)); + close((int)native); + errno = e; + return -1; + } +# endif + + shmtx_enter(&pfdtab->mtx, &tmp); + + /* + * Search for a fitting unused location. + */ + fd = -1; + for (i = fdMin >= 0 ? fdMin : 0; (unsigned)i < pfdtab->size; i++) + if (pfdtab->tab[i].fd == -1) + { + fd = i; + break; + } + if (fd == -1) + fd = shfile_grow_tab_locked(pfdtab, fdMin); + + /* + * Fill in the entry if we've found one. + */ + if (fd != -1) + { + pfdtab->tab[fd].fd = fd; + pfdtab->tab[fd].oflags = oflags; + pfdtab->tab[fd].shflags = shflags; + pfdtab->tab[fd].native = native; +#ifdef DEBUG + pfdtab->tab[fd].dbgname = dbgname ? sh_strdup(NULL, dbgname) : NULL; +#endif + TRACE2((NULL, "shfile_insert: #%d: native=%p oflags=%#x shflags=%#x %s\n", fd, native, oflags, shflags, dbgname)); + } + else + shfile_native_close(native, NULL, K_FALSE); + + shmtx_leave(&pfdtab->mtx, &tmp); + + if (fd == -1) + errno = EMFILE; + (void)who; + return fd; +} + +# if K_OS != K_OS_WINDOWS +/** + * Makes a copy of the native file, closes the original, and inserts the copy + * into the descriptor table. + * + * If we're out of memory and cannot extend the table, we'll close the + * file, set errno to EMFILE and return -1. + * + * @returns The file descriptor number. -1 and errno on failure. + * @param pfdtab The file descriptor table. + * @param pnative The native file handle on input, -1 on output. + * @param oflags The flags the it was opened/created with. + * @param shflags The shell file flags. + * @param fdMin The minimum file descriptor number, pass -1 if any is ok. + * @param who Who we're doing this for (for logging purposes). + * @param dbgname The filename, if applicable/available. + */ +static int shfile_copy_insert_and_close(shfdtab *pfdtab, int *pnative, unsigned oflags, unsigned shflags, int fdMin, + const char *who, const char *dbgname) +{ + int fd = -1; + int s = errno; + int native_copy = fcntl(*pnative, F_DUPFD, SHFILE_UNIX_MIN_FD); + close(*pnative); + *pnative = -1; + errno = s; + + if (native_copy != -1) + fd = shfile_insert(pfdtab, native_copy, oflags, shflags, fdMin, who, dbgname); + return fd; +} +# endif /* !K_OS_WINDOWS */ + +/** + * Gets a file descriptor and lock the file descriptor table. + * + * @returns Pointer to the file and table ownership on success, + * NULL and errno set to EBADF on failure. + * @param pfdtab The file descriptor table. + * @param fd The file descriptor number. + * @param ptmp See shmtx_enter. + */ +static shfile *shfile_get(shfdtab *pfdtab, int fd, shmtxtmp *ptmp) +{ + shfile *file = NULL; + if ( fd >= 0 + && (unsigned)fd < pfdtab->size) + { + shmtx_enter(&pfdtab->mtx, ptmp); + if ((unsigned)fd < pfdtab->size + && pfdtab->tab[fd].fd != -1) + file = &pfdtab->tab[fd]; + else + shmtx_leave(&pfdtab->mtx, ptmp); + } + if (!file) + errno = EBADF; + return file; +} + +/** + * Puts back a file descriptor and releases the table ownership. + * + * @param pfdtab The file descriptor table. + * @param file The file. + * @param ptmp See shmtx_leave. + */ +static void shfile_put(shfdtab *pfdtab, shfile *file, shmtxtmp *ptmp) +{ + shmtx_leave(&pfdtab->mtx, ptmp); + kHlpAssert(file); + (void)file; +} + +/** + * Constructs a path from the current directory and the passed in path. + * + * @returns 0 on success, -1 and errno set to ENAMETOOLONG or EINVAL on failure. + * + * @param pfdtab The file descriptor table + * @param path The path the caller supplied. + * @param buf Where to put the path. This is assumed to be SHFILE_MAX_PATH + * chars in size. + */ +int shfile_make_path(shfdtab *pfdtab, const char *path, char *buf) +{ + size_t path_len = strlen(path); + if (path_len == 0) + { + errno = EINVAL; + return -1; + } + if (path_len >= SHFILE_MAX_PATH) + { + errno = ENAMETOOLONG; + return -1; + } + if ( *path == '/' +# if K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2 + || *path == '\\' + || ( *path + && path[1] == ':' + && ( (*path >= 'A' && *path <= 'Z') + || (*path >= 'a' && *path <= 'z'))) +# endif + ) + { + memcpy(buf, path, path_len + 1); + } + else + { + size_t cwd_len; + shmtxtmp tmp; + + shmtx_enter(&pfdtab->mtx, &tmp); + + cwd_len = strlen(pfdtab->cwd); + memcpy(buf, pfdtab->cwd, cwd_len); + + shmtx_leave(&pfdtab->mtx, &tmp); + + if (cwd_len + path_len + 1 >= SHFILE_MAX_PATH) + { + errno = ENAMETOOLONG; + return -1; + } + if ( !cwd_len + || buf[cwd_len - 1] != '/') + buf[cwd_len++] = '/'; + memcpy(buf + cwd_len, path, path_len + 1); + } + +# if K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2 + if (!strcmp(buf, "/dev/null")) + strcpy(buf, "NUL"); +# endif + return 0; +} + +# if K_OS == K_OS_WINDOWS + +/** + * Adjusts the file name if it ends with a trailing directory slash. + * + * Windows APIs doesn't like trailing slashes. + * + * @returns 1 if it has a directory slash, 0 if not. + * + * @param abspath The path to adjust (SHFILE_MAX_PATH). + */ +static int shfile_trailing_slash_hack(char *abspath) +{ + /* + * Anything worth adjust here? + */ + size_t path_len = strlen(abspath); + if ( path_len == 0 + || ( abspath[path_len - 1] != '/' +# if K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2 + && abspath[path_len - 1] != '\\' +# endif + ) + ) + return 0; + + /* + * Ok, make the adjustment. + */ + if (path_len + 2 <= SHFILE_MAX_PATH) + { + /* Add a '.' to the end. */ + abspath[path_len++] = '.'; + abspath[path_len] = '\0'; + } + else + { + /* No space for a dot, remove the slash if it's alone or just remove + one and add a dot like above. */ + if ( abspath[path_len - 2] != '/' +# if K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2 + && abspath[path_len - 2] != '\\' +# endif + ) + abspath[--path_len] = '\0'; + else + abspath[path_len - 1] = '.'; + } + + return 1; +} + + +/** + * Converts a DOS(/Windows) error code to errno, + * assigning it to errno. + * + * @returns -1 + * @param err The DOS error. + */ +static int shfile_dos2errno(int err) +{ + switch (err) + { + case ERROR_BAD_ENVIRONMENT: errno = E2BIG; break; + case ERROR_ACCESS_DENIED: errno = EACCES; break; + case ERROR_CURRENT_DIRECTORY: errno = EACCES; break; + case ERROR_LOCK_VIOLATION: errno = EACCES; break; + case ERROR_NETWORK_ACCESS_DENIED: errno = EACCES; break; + case ERROR_CANNOT_MAKE: errno = EACCES; break; + case ERROR_FAIL_I24: errno = EACCES; break; + case ERROR_DRIVE_LOCKED: errno = EACCES; break; + case ERROR_SEEK_ON_DEVICE: errno = EACCES; break; + case ERROR_NOT_LOCKED: errno = EACCES; break; + case ERROR_LOCK_FAILED: errno = EACCES; break; + case ERROR_NO_PROC_SLOTS: errno = EAGAIN; break; + case ERROR_MAX_THRDS_REACHED: errno = EAGAIN; break; + case ERROR_NESTING_NOT_ALLOWED: errno = EAGAIN; break; + case ERROR_INVALID_HANDLE: errno = EBADF; break; + case ERROR_INVALID_TARGET_HANDLE: errno = EBADF; break; + case ERROR_DIRECT_ACCESS_HANDLE: errno = EBADF; break; + case ERROR_WAIT_NO_CHILDREN: errno = ECHILD; break; + case ERROR_CHILD_NOT_COMPLETE: errno = ECHILD; break; + case ERROR_FILE_EXISTS: errno = EEXIST; break; + case ERROR_ALREADY_EXISTS: errno = EEXIST; break; + case ERROR_INVALID_FUNCTION: errno = EINVAL; break; + case ERROR_INVALID_ACCESS: errno = EINVAL; break; + case ERROR_INVALID_DATA: errno = EINVAL; break; + case ERROR_INVALID_PARAMETER: errno = EINVAL; break; + case ERROR_NEGATIVE_SEEK: errno = EINVAL; break; + case ERROR_TOO_MANY_OPEN_FILES: errno = EMFILE; break; + case ERROR_FILE_NOT_FOUND: errno = ENOENT; break; + case ERROR_PATH_NOT_FOUND: errno = ENOENT; break; + case ERROR_INVALID_DRIVE: errno = ENOENT; break; + case ERROR_NO_MORE_FILES: errno = ENOENT; break; + case ERROR_BAD_NETPATH: errno = ENOENT; break; + case ERROR_BAD_NET_NAME: errno = ENOENT; break; + case ERROR_BAD_PATHNAME: errno = ENOENT; break; + case ERROR_FILENAME_EXCED_RANGE: errno = ENOENT; break; + case ERROR_BAD_FORMAT: errno = ENOEXEC; break; + case ERROR_ARENA_TRASHED: errno = ENOMEM; break; + case ERROR_NOT_ENOUGH_MEMORY: errno = ENOMEM; break; + case ERROR_INVALID_BLOCK: errno = ENOMEM; break; + case ERROR_NOT_ENOUGH_QUOTA: errno = ENOMEM; break; + case ERROR_DISK_FULL: errno = ENOSPC; break; + case ERROR_DIR_NOT_EMPTY: errno = ENOTEMPTY; break; + case ERROR_BROKEN_PIPE: errno = EPIPE; break; + case ERROR_NOT_SAME_DEVICE: errno = EXDEV; break; + default: errno = EINVAL; break; + } + return -1; +} + +/** + * Converts an NT status code to errno, + * assigning it to errno. + * + * @returns -1 + * @param rcNt The NT status code. + */ +static int shfile_nt2errno(NTSTATUS rcNt) +{ + switch (rcNt) + { + default: errno = EINVAL; break; + } + return -1; +} + +DWORD shfile_query_handle_access_mask(HANDLE h, PACCESS_MASK pMask) +{ + MY_OBJECT_BASIC_INFORMATION BasicInfo; + NTSTATUS rcNt; + + if (!g_pfnNtQueryObject) + return ERROR_NOT_SUPPORTED; + + rcNt = g_pfnNtQueryObject(h, MY_ObjectBasicInformation, &BasicInfo, sizeof(BasicInfo), NULL); + if (rcNt >= 0) + { + *pMask = BasicInfo.GrantedAccess; + return NO_ERROR; + } + if (rcNt != STATUS_INVALID_HANDLE) + return ERROR_GEN_FAILURE; + return ERROR_INVALID_HANDLE; +} + +# endif /* K_OS == K_OS_WINDOWS */ + +#endif /* SHFILE_IN_USE */ + +/** + * Converts DOS slashes to UNIX slashes if necessary. + * + * @param pszPath The path to fix. + */ +K_INLINE void shfile_fix_slashes(char *pszPath) +{ +#if K_OS == K_OS_WINDOWS || K_OS == K_OS_OS2 + while ((pszPath = strchr(pszPath, '\\'))) + *pszPath++ = '/'; +#else + (void)pszPath; +#endif +} + +/** + * Initializes the global variables in this file. + */ +static void shfile_init_globals(void) +{ +#if K_OS == K_OS_WINDOWS + if (!g_shfile_globals_initialized) + { + HMODULE hNtDll = GetModuleHandle("NTDLL"); + g_pfnNtQueryObject = (PFN_NtQueryObject) GetProcAddress(hNtDll, "NtQueryObject"); + g_pfnNtQueryDirectoryFile = (PFN_NtQueryDirectoryFile)GetProcAddress(hNtDll, "NtQueryDirectoryFile"); + g_pfnRtlUnicodeStringToAnsiString = (PFN_RtlUnicodeStringToAnsiString)GetProcAddress(hNtDll, "RtlUnicodeStringToAnsiString"); + if ( !g_pfnRtlUnicodeStringToAnsiString + || !g_pfnNtQueryDirectoryFile) + { + /* fatal error */ + } + +# ifdef KASH_ASYNC_CLOSE_HANDLE + /* + * Init the async CloseHandle state. + */ + shmtx_init(&g_shfile_async_close.mtx); + g_shfile_async_close.evt_workers = CreateEventW(NULL, FALSE /*fManualReset*/, FALSE /*fInitialState*/, NULL /*pwszName*/); + g_shfile_async_close.evt_sync = CreateEventW(NULL, TRUE /*fManualReset*/, FALSE /*fInitialState*/, NULL /*pwszName*/); + if ( !g_shfile_async_close.evt_workers + || !g_shfile_async_close.evt_sync) + { + fprintf(stderr, "fatal error: CreateEventW failed: %u\n", GetLastError()); + _exit(19); + } + g_shfile_async_close.idx_read = 0; + g_shfile_async_close.idx_write = 0; + g_shfile_async_close.num_pending = 0; + g_shfile_async_close.terminate_threads = K_FALSE; + g_shfile_async_close.signal_sync = K_FALSE; + g_shfile_async_close.num_threads = 0; + { + unsigned i = K_ELEMENTS(g_shfile_async_close.handles); + while (i-- > 0) + g_shfile_async_close.handles[i] = NULL; + i = K_ELEMENTS(g_shfile_async_close.threads); + while (i-- > 0) + g_shfile_async_close.threads[i] = NULL; + } +# endif + + g_shfile_globals_initialized = 1; + } +#endif +} + +/** + * Initializes a file descriptor table. + * + * @returns 0 on success, -1 and errno on failure. + * @param pfdtab The table to initialize. + * @param inherit File descriptor table to inherit from. If not specified + * we will inherit from the current process as it were. + */ +int shfile_init(shfdtab *pfdtab, shfdtab *inherit) +{ + int rc; + + shfile_init_globals(); + + pfdtab->cwd = NULL; + pfdtab->size = 0; + pfdtab->tab = NULL; + rc = shmtx_init(&pfdtab->mtx); + if (!rc) + { +#ifdef SHFILE_IN_USE + /* Get CWD with unix slashes. */ + if (!inherit) + { + char buf[SHFILE_MAX_PATH]; + if (getcwd(buf, sizeof(buf))) + { + shfile_fix_slashes(buf); + pfdtab->cwd = sh_strdup(NULL, buf); + } + if (pfdtab->cwd) + { +# if K_OS == K_OS_WINDOWS + static const struct + { + DWORD dwStdHandle; + unsigned fFlags; + } aStdHandles[3] = + { + { STD_INPUT_HANDLE, _O_RDONLY }, + { STD_OUTPUT_HANDLE, _O_WRONLY }, + { STD_ERROR_HANDLE, _O_WRONLY } + }; + int i; + STARTUPINFO Info; + ACCESS_MASK Mask; + DWORD dwErr; + + rc = 0; + + /* Try pick up the Visual C++ CRT file descriptor info. */ + __try { + GetStartupInfo(&Info); + } __except (EXCEPTION_EXECUTE_HANDLER) { + memset(&Info, 0, sizeof(Info)); + } + + if ( Info.cbReserved2 > sizeof(int) + && (uintptr_t)Info.lpReserved2 >= 0x1000 + && (i = *(int *)Info.lpReserved2) >= 1 + && i <= 2048 + && ( Info.cbReserved2 == i * 5 + 4 + //|| Info.cbReserved2 == i * 5 + 1 - check the cygwin sources. + || Info.cbReserved2 == i * 9 + 4)) + { + uint8_t *paf = (uint8_t *)Info.lpReserved2 + sizeof(int); + int dwPerH = 1 + (Info.cbReserved2 == i * 9 + 4); + DWORD *ph = (DWORD *)(paf + i) + dwPerH * i; + HANDLE aStdHandles2[3]; + int j; + + //if (Info.cbReserved2 == i * 5 + 1) - check the cygwin sources. + // i--; + + for (j = 0; j < 3; j++) + aStdHandles2[j] = GetStdHandle(aStdHandles[j].dwStdHandle); + + while (i-- > 0) + { + ph -= dwPerH; + + if ( (paf[i] & (FOPEN | FNOINHERIT)) == FOPEN + && *ph != (uint32_t)INVALID_HANDLE_VALUE + && *ph != 0) + { + HANDLE h = (HANDLE)(intptr_t)*ph; + int fd2; + int fFlags; + int fFlags2; + + if ( h == aStdHandles2[j = 0] + || h == aStdHandles2[j = 1] + || h == aStdHandles2[j = 2]) + fFlags = aStdHandles[j].fFlags; + else + { + dwErr = shfile_query_handle_access_mask(h, &Mask); + if (dwErr == ERROR_INVALID_HANDLE) + continue; + if (dwErr == NO_ERROR) + { + fFlags = 0; + if ( (Mask & (GENERIC_READ | FILE_READ_DATA)) + && (Mask & (GENERIC_WRITE | FILE_WRITE_DATA | FILE_APPEND_DATA))) + fFlags |= O_RDWR; + else if (Mask & (GENERIC_READ | FILE_READ_DATA)) + fFlags |= O_RDONLY; + else if (Mask & (GENERIC_WRITE | FILE_WRITE_DATA | FILE_APPEND_DATA)) + fFlags |= O_WRONLY; + else + fFlags |= O_RDWR; + if ((Mask & (FILE_WRITE_DATA | FILE_APPEND_DATA)) == FILE_APPEND_DATA) + fFlags |= O_APPEND; + } + else + fFlags = O_RDWR; + } + + if (paf[i] & FPIPE) + fFlags2 = SHFILE_FLAGS_PIPE; + else if (paf[i] & FDEV) + fFlags2 = SHFILE_FLAGS_TTY; + else + fFlags2 = 0; + + fd2 = shfile_insert(pfdtab, (intptr_t)h, fFlags, fFlags2, i, "shtab_init", NULL); + kHlpAssert(fd2 == i); (void)fd2; + if (fd2 != i) + rc = -1; + } + } + } + + /* Check the three standard handles. */ + for (i = 0; i < 3; i++) + if ( (unsigned)i >= pfdtab->size + || pfdtab->tab[i].fd == -1) + { + HANDLE hFile = GetStdHandle(aStdHandles[i].dwStdHandle); + if ( hFile != INVALID_HANDLE_VALUE + && hFile != NULL) + { + DWORD dwType = GetFileType(hFile); + unsigned fFlags = aStdHandles[i].fFlags; + unsigned fFlags2; + int fd2; + if (dwType == FILE_TYPE_CHAR) + fFlags2 = SHFILE_FLAGS_TTY; + else if (dwType == FILE_TYPE_PIPE) + fFlags2 = SHFILE_FLAGS_PIPE; + else + fFlags2 = SHFILE_FLAGS_FILE; + fd2 = shfile_insert(pfdtab, (intptr_t)hFile, fFlags, fFlags2, i, "shtab_init", NULL); + kHlpAssert(fd2 == i); (void)fd2; + if (fd2 != i) + rc = -1; + } + } +# else + /* + * Annoying... + */ + int fd; + + for (fd = 0; fd < 10; fd++) + { + int oflags = fcntl(fd, F_GETFL, 0); + if (oflags != -1) + { + int cox = fcntl(fd, F_GETFD, 0); + struct stat st; + if ( cox != -1 + && fstat(fd, &st) != -1) + { + int native; + int fd2; + int fFlags2 = 0; + if (cox & FD_CLOEXEC) + fFlags2 |= SHFILE_FLAGS_CLOSE_ON_EXEC; + if (S_ISREG(st.st_mode)) + fFlags2 |= SHFILE_FLAGS_FILE; + else if (S_ISDIR(st.st_mode)) + fFlags2 |= SHFILE_FLAGS_DIR; + else if (S_ISCHR(st.st_mode)) + fFlags2 |= SHFILE_FLAGS_TTY; + else if (S_ISFIFO(st.st_mode)) + fFlags2 |= SHFILE_FLAGS_PIPE; + else + fFlags2 |= SHFILE_FLAGS_TTY; + + native = fcntl(fd, F_DUPFD, SHFILE_UNIX_MIN_FD); + if (native == -1) + native = fd; + fd2 = shfile_insert(pfdtab, native, oflags, fFlags2, fd, "shtab_init", NULL); + kHlpAssert(fd2 == fd); (void)fd2; + if (fd2 != fd) + rc = -1; + if (native != fd) + close(fd); + } + } + } + +# endif + } + else + rc = -1; + } + else + { + /* + * Inherit from parent shell's file table. + */ + shfile const *src; + shfile *dst; + shmtxtmp tmp; + unsigned fdcount; + unsigned fd; + + shmtx_enter(&inherit->mtx, &tmp); + + /* allocate table and cwd: */ + fdcount = inherit->size; + pfdtab->tab = dst = (shfile *)(fdcount ? sh_calloc(NULL, sizeof(pfdtab->tab[0]), fdcount) : NULL); + pfdtab->cwd = sh_strdup(NULL, inherit->cwd); + if ( pfdtab->cwd + && (pfdtab->tab || fdcount == 0)) + { + /* duplicate table entries: */ + for (fd = 0, src = inherit->tab; fd < fdcount; fd++, src++, dst++) + if (src->fd == -1) + dst->native = dst->fd = -1; + else + { +# if K_OS == K_OS_WINDOWS +# ifdef SH_FORKED_MODE + KBOOL const cox = !!(src->shflags & SHFILE_FLAGS_CLOSE_ON_EXEC); +# else + KBOOL const cox = K_TRUE; +# endif +# endif + *dst = *src; +# ifdef DEBUG + if (src->dbgname) + dst->dbgname = sh_strdup(NULL, src->dbgname); +# endif +# if K_OS == K_OS_WINDOWS + if (DuplicateHandle(GetCurrentProcess(), + (HANDLE)src->native, + GetCurrentProcess(), + (HANDLE *)&dst->native, + 0, + FALSE /* bInheritHandle */, + DUPLICATE_SAME_ACCESS)) + TRACE2((NULL, "shfile_init: %d (%#x, %#x) %p (was %p)\n", + dst->fd, dst->oflags, dst->shflags, dst->native, src->native)); + else + { + dst->native = (intptr_t)INVALID_HANDLE_VALUE; + rc = shfile_dos2errno(GetLastError()); + TRACE2((NULL, "shfile_init: %d (%#x, %#x) %p - failed %d / %u!\n", + dst->fd, dst->oflags, dst->shflags, src->native, rc, GetLastError())); + break; + } + +# elif K_OS == K_OS_LINUX /* 2.6.27 / glibc 2.9 */ || K_OS == K_OS_FREEBSD /* 10.0 */ || K_OS == K_OS_NETBSD /* 6.0 */ + dst->native = dup3(src->native, -1, cox ? O_CLOEXEC : 0); +# else + if (cox) + { +# ifndef SH_FORKED_MODE + shmtxtmp tmp2; + shmtx_enter(&global_exec_something, &tmp) +# endif + dst->native = dup2(src->native, -1); + if (dst->native >= 0) + rc = fcntl(dst->native, F_SETFD, FD_CLOEXEC); +# ifndef SH_FORKED_MODE + shmtx_leave(&global_exec_something, &tmp) +# endif + if (rc != 0) + break; + } + else + dst->native = dup2(src->native, -1); + if (dst->native < 0) + { + rc = -1; + break; + } +# endif + } + } + else + rc = -1; + pfdtab->size = fd; + shmtx_leave(&inherit->mtx, &tmp); + } /* inherit != NULL */ +#endif + } + return rc; +} + +/** + * Deletes the file descriptor table. + * + * Safe to call more than once. + */ +void shfile_uninit(shfdtab *pfdtab, int tracefd) +{ + if (!pfdtab) + return; + + if (pfdtab->tab) + { + unsigned left = pfdtab->size; + struct shfile *pfd = pfdtab->tab; + unsigned tracefdfound = 0; + while (left-- > 0) + { + if (pfd->fd != -1) + { + if (pfd->fd != tracefd) + { +#if K_OS == K_OS_WINDOWS + BOOL rc = CloseHandle((HANDLE)pfd->native); + kHlpAssert(rc == TRUE); K_NOREF(rc); +#else + int rc = close((int)pfd->native); + kHlpAssert(rc == 0); K_NOREF(rc); +#endif + pfd->fd = -1; + pfd->native = -1; + } + else + tracefdfound++; /* there is only the one */ + } + pfd++; + } + + if (!tracefdfound) + { /* likely */ } + else + return; + + sh_free(NULL, pfdtab->tab); + pfdtab->tab = NULL; + } + + shmtx_delete(&pfdtab->mtx); + + sh_free(NULL, pfdtab->cwd); + pfdtab->cwd = NULL; +} + +#if K_OS == K_OS_WINDOWS && defined(SHFILE_IN_USE) + +/** + * Changes the inheritability of a file descriptor, taking console handles into + * account. + * + * @note This MAY change the native handle for the entry. + * + * @returns The native handle. + * @param pfd The file descriptor to change. + * @param set If set, make child processes inherit the handle, if clear + * make them not inherit it. + */ +static HANDLE shfile_set_inherit_win(shfile *pfd, int set) +{ + HANDLE hFile = (HANDLE)pfd->native; + if (!SetHandleInformation(hFile, HANDLE_FLAG_INHERIT, set ? HANDLE_FLAG_INHERIT : 0)) + { + /* SetHandleInformation doesn't work for console handles, + so we have to duplicate the handle to change the + inheritability. */ + DWORD err = GetLastError(); + if ( err == ERROR_INVALID_PARAMETER + && DuplicateHandle(GetCurrentProcess(), + hFile, + GetCurrentProcess(), + &hFile, + 0, + set ? TRUE : FALSE /* bInheritHandle */, + DUPLICATE_SAME_ACCESS)) + { + TRACE2((NULL, "shfile_set_inherit_win: %p -> %p (set=%d)\n", pfd->native, hFile, set)); + if (!CloseHandle((HANDLE)pfd->native)) + kHlpAssert(0); + pfd->native = (intptr_t)hFile; + } + else + { + err = GetLastError(); + kHlpAssert(0); + hFile = (HANDLE)pfd->native; + } + } + return hFile; +} + +# ifdef SH_FORKED_MODE +/** + * Helper for shfork. + * + * @param pfdtab The file descriptor table. + * @param set Whether to make all handles inheritable (1) or + * to restore them to the rigth state (0). + * @param hndls Where to store the three standard handles. + */ +void shfile_fork_win(shfdtab *pfdtab, int set, intptr_t *hndls) +{ + shmtxtmp tmp; + unsigned i; + + shmtx_enter(&pfdtab->mtx, &tmp); + TRACE2((NULL, "shfile_fork_win: set=%d\n", set)); + + i = pfdtab->size; + while (i-- > 0) + { + if (pfdtab->tab[i].fd == i) + { + shfile_set_inherit_win(&pfdtab->tab[i], set); + if (set) + TRACE2((NULL, " #%d: native=%#x oflags=%#x shflags=%#x\n", + i, pfdtab->tab[i].native, pfdtab->tab[i].oflags, pfdtab->tab[i].shflags)); + } + } + + if (hndls) + { + for (i = 0; i < 3; i++) + { + if ( pfdtab->size > i + && pfdtab->tab[i].fd == i) + hndls[i] = pfdtab->tab[i].native; + else + hndls[i] = (intptr_t)INVALID_HANDLE_VALUE; + TRACE2((NULL, "shfile_fork_win: i=%d size=%d fd=%d native=%d hndls[%d]=%p\n", + i, pfdtab->size, pfdtab->tab[i].fd, pfdtab->tab[i].native, i, hndls[i])); + } + } + + shmtx_leave(&pfdtab->mtx, &tmp); +} +# endif /* SH_FORKED_MODE */ + +/** shfile_exec_win helper that make sure there are no _O_APPEND handles. */ +static KBOOL shfile_exec_win_no_append(shfdtab *pfdtab, unsigned count) +{ + unsigned i; + for (i = 0; i < count; i++) + if ( (pfdtab->tab[i].oflags & _O_APPEND) + && (pfdtab->tab[i].oflags & (_O_WRONLY | _O_RDWR))) + return K_FALSE; + return K_TRUE; +} + +/** + * Helper for sh_execve. + * + * This is called before and after CreateProcess. On the first call it + * will mark the non-close-on-exec handles as inheritable and produce + * the startup info for the CRT. On the second call, after CreateProcess, + * it will restore the handle inheritability properties. + * + * @returns 0 on success, non-zero on failure. + * @param pfdtab The file descriptor table. + * @param prepare Which call, 1 if before, 0 if after and success, -1 if after on failure. + * @param info The info structure. + */ +int shfile_exec_win(shfdtab *pfdtab, int prepare, shfdexecwin *info) +{ + STARTUPINFOA *strtinfo = (STARTUPINFOA *)info->strtinfo; + int rc = 0; + shmtxtmp tmp; + unsigned count; + unsigned i; + + shmtx_enter(&pfdtab->mtx, &tmp); + TRACE2((NULL, "shfile_exec_win: prepare=%p\n", prepare)); + + count = pfdtab->size < (0x10000-4) / (1 + sizeof(HANDLE)) + ? pfdtab->size + : (0x10000-4) / (1 + sizeof(HANDLE)); + while ( count > 3 + && ( pfdtab->tab[count - 1].fd == -1 + || (pfdtab->tab[count - 1].shflags & SHFILE_FLAGS_CLOSE_ON_EXEC))) + count--; + + if (prepare > 0) + { + if (count <= 3 && shfile_exec_win_no_append(pfdtab, count)) + { + info->inherithandles = 0; + info->startsuspended = 1; + strtinfo->cbReserved2 = 0; + strtinfo->lpReserved2 = NULL; + } + else + { + size_t cbData = sizeof(int) + count * (1 + sizeof(HANDLE)); + uint8_t *pbData = sh_malloc(shthread_get_shell(), cbData); + uint8_t *paf = pbData + sizeof(int); + HANDLE *pah = (HANDLE *)(paf + count); + + info->inherithandles = 1; +# ifdef KASH_ASYNC_CLOSE_HANDLE + info->startsuspended = g_shfile_async_close.num_pending > 0; +# else + info->startsuspended = 0; +# endif + strtinfo->cbReserved2 = (unsigned short)cbData; + strtinfo->lpReserved2 = pbData; + +# ifndef SH_FORKED_MODE + shmtx_leave(&pfdtab->mtx, &tmp); /* should be harmless as this isn't really necessary at all. */ + shmtx_enter(&g_sh_exec_inherit_mtx, &info->tmp); + shmtx_enter(&pfdtab->mtx, &tmp); +# endif + + *(int *)pbData = count; + + i = count; + while (i-- > 0) + { + if ( pfdtab->tab[i].fd == i + && !(pfdtab->tab[i].shflags & SHFILE_FLAGS_CLOSE_ON_EXEC)) + { + HANDLE hFile = shfile_set_inherit_win(&pfdtab->tab[i], 1); + TRACE2((NULL, " #%d: native=%#x oflags=%#x shflags=%#x\n", + i, hFile, pfdtab->tab[i].oflags, pfdtab->tab[i].shflags)); + paf[i] = FOPEN; + if (pfdtab->tab[i].oflags & _O_APPEND) + paf[i] |= FAPPEND; + if (pfdtab->tab[i].oflags & _O_TEXT) + paf[i] |= FTEXT; + switch (pfdtab->tab[i].shflags & SHFILE_FLAGS_TYPE_MASK) + { + case SHFILE_FLAGS_TTY: paf[i] |= FDEV; break; + case SHFILE_FLAGS_PIPE: paf[i] |= FPIPE; break; + } + pah[i] = hFile; + } + else + { + paf[i] = 0; + pah[i] = INVALID_HANDLE_VALUE; + } + } + } + + for (i = 0; i < 3; i++) + { + if ( i < count + && pfdtab->tab[i].fd == i) + { + info->replacehandles[i] = 1; + info->handles[i] = pfdtab->tab[i].native; + } + else + { + info->replacehandles[i] = 0; + info->handles[i] = (intptr_t)INVALID_HANDLE_VALUE; + } + TRACE2((NULL, "shfile_exec_win: i=%d count=%d fd=%d native=%d hndls[%d]=\n", + i, count, pfdtab->tab[i].fd, pfdtab->tab[i].native, i, info->handles[i])); + } + } + else + { + shfile *file = pfdtab->tab; + + sh_free(NULL, strtinfo->lpReserved2); + strtinfo->lpReserved2 = NULL; + + i = count; + if (prepare == 0) + for (i = 0; i < count; i++, file++) + { + if ( file->fd == i + && !(file->shflags & SHFILE_FLAGS_TRACE)) + { + shfile_native_close(file->native, file, info->inherithandles); + + file->fd = -1; + file->oflags = 0; + file->shflags = 0; + file->native = -1; +# ifdef DEBUG + sh_free(NULL, file->dbgname); + file->dbgname = NULL; +# endif + } + } + else if (info->inherithandles) + for (i = 0; i < count; i++, file++) + if ( file->fd == i + && !(file->shflags & SHFILE_FLAGS_CLOSE_ON_EXEC)) + shfile_set_inherit_win(file, 0); + +# ifndef SH_FORKED_MODE + if (info->inherithandles) + shmtx_leave(&g_sh_exec_inherit_mtx, &info->tmp); +# endif + } + + shmtx_leave(&pfdtab->mtx, &tmp); + return rc; +} + +#endif /* K_OS_WINDOWS */ + +#if K_OS != K_OS_WINDOWS +/** + * Prepare file handles for inherting before a execve call. + * + * This is only used in the normal mode, so we've forked and need not worry + * about cleaning anything up after us. Nor do we need think about locking. + * + * @returns 0 on success, -1 on failure. + */ +int shfile_exec_unix(shfdtab *pfdtab) +{ + int rc = 0; +# ifdef SHFILE_IN_USE + unsigned fd; + + for (fd = 0; fd < pfdtab->size; fd++) + { + if ( pfdtab->tab[fd].fd != -1 + && !(pfdtab->tab[fd].shflags & SHFILE_FLAGS_CLOSE_ON_EXEC) ) + { + TRACE2((NULL, "shfile_exec_unix: %d => %d\n", pfdtab->tab[fd].native, fd)); + if (dup2(pfdtab->tab[fd].native, fd) < 0) + { + /* fatal_error(NULL, "shfile_exec_unix: failed to move %d to %d", pfdtab->tab[fd].fd, fd); */ + rc = -1; + } + } + } +# endif + return rc; +} +#endif /* !K_OS_WINDOWS */ + +/** + * open(). + */ +int shfile_open(shfdtab *pfdtab, const char *name, unsigned flags, mode_t mode) +{ + int fd; +#ifdef SHFILE_IN_USE + char absname[SHFILE_MAX_PATH]; +# if K_OS == K_OS_WINDOWS + HANDLE hFile; + DWORD dwDesiredAccess; + DWORD dwShareMode; + DWORD dwCreationDisposition; + DWORD dwFlagsAndAttributes; + SECURITY_ATTRIBUTES SecurityAttributes; + +# ifndef _O_ACCMODE +# define _O_ACCMODE (_O_RDONLY|_O_WRONLY|_O_RDWR) +# endif + switch (flags & (_O_ACCMODE | _O_APPEND)) + { + case _O_RDONLY: dwDesiredAccess = GENERIC_READ; break; + case _O_RDONLY | _O_APPEND: dwDesiredAccess = GENERIC_READ; break; + case _O_WRONLY: dwDesiredAccess = GENERIC_WRITE; break; + case _O_WRONLY | _O_APPEND: dwDesiredAccess = (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA); break; + case _O_RDWR: dwDesiredAccess = GENERIC_READ | GENERIC_WRITE; break; + case _O_RDWR | _O_APPEND: dwDesiredAccess = GENERIC_READ | (FILE_GENERIC_WRITE & ~FILE_WRITE_DATA); break; + + default: + RETURN_ERROR(-1, EINVAL, "invalid mode"); + } + + dwShareMode = FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE; + + SecurityAttributes.nLength = sizeof(SecurityAttributes); + SecurityAttributes.lpSecurityDescriptor = NULL; + SecurityAttributes.bInheritHandle = FALSE; + + if (flags & _O_CREAT) + { + if ((flags & (_O_EXCL | _O_TRUNC)) == (_O_EXCL | _O_TRUNC)) + RETURN_ERROR(-1, EINVAL, "_O_EXCL | _O_TRUNC"); + + if (flags & _O_TRUNC) + dwCreationDisposition = CREATE_ALWAYS; /* not 100%, but close enough */ + else if (flags & _O_EXCL) + dwCreationDisposition = CREATE_NEW; + else + dwCreationDisposition = OPEN_ALWAYS; + } + else if (flags & _O_TRUNC) + dwCreationDisposition = TRUNCATE_EXISTING; + else + dwCreationDisposition = OPEN_EXISTING; + + if (!(flags & _O_CREAT) || (mode & 0222)) + dwFlagsAndAttributes = FILE_ATTRIBUTE_NORMAL; + else + dwFlagsAndAttributes = FILE_ATTRIBUTE_READONLY; + + fd = shfile_make_path(pfdtab, name, &absname[0]); + if (!fd) + { +# ifdef DEBUG + KU64 ns = shfile_nano_ts(); +# endif + SetLastError(0); + hFile = CreateFileA(absname, + dwDesiredAccess, + dwShareMode, + &SecurityAttributes, + dwCreationDisposition, + dwFlagsAndAttributes, + NULL /* hTemplateFile */); +# ifdef DEBUG + ns = shfile_nano_ts() - ns; + if (ns > 1000000) + TRACE2((NULL, "shfile_open: %u ns hFile=%p (%d) %s\n", ns, hFile, GetLastError(), absname)); +# endif + if (hFile != INVALID_HANDLE_VALUE) + fd = shfile_insert(pfdtab, (intptr_t)hFile, flags, 0, -1, "shfile_open", absname); + else + fd = shfile_dos2errno(GetLastError()); + } + +# else /* K_OS != K_OS_WINDOWS */ + fd = shfile_make_path(pfdtab, name, &absname[0]); + if (!fd) + { + fd = open(absname, flags, mode); + if (fd != -1) + fd = shfile_copy_insert_and_close(pfdtab, &fd, flags, 0, -1, "shfile_open", absname); + } + +# endif /* K_OS != K_OS_WINDOWS */ + +#else + fd = open(name, flags, mode); +#endif + + TRACE2((NULL, "shfile_open(%p:{%s}, %#x, 0%o) -> %d [%d]\n", name, name, flags, mode, fd, errno)); + return fd; +} + +int shfile_pipe(shfdtab *pfdtab, int fds[2]) +{ + int rc = -1; +#ifdef SHFILE_IN_USE +# if K_OS == K_OS_WINDOWS + HANDLE hRead = INVALID_HANDLE_VALUE; + HANDLE hWrite = INVALID_HANDLE_VALUE; + SECURITY_ATTRIBUTES SecurityAttributes; + + SecurityAttributes.nLength = sizeof(SecurityAttributes); + SecurityAttributes.lpSecurityDescriptor = NULL; + SecurityAttributes.bInheritHandle = FALSE; + + fds[1] = fds[0] = -1; + if (CreatePipe(&hRead, &hWrite, &SecurityAttributes, SHFILE_PIPE_SIZE)) + { + fds[0] = shfile_insert(pfdtab, (intptr_t)hRead, O_RDONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe", "pipe-rd"); + if (fds[0] != -1) + { + fds[1] = shfile_insert(pfdtab, (intptr_t)hWrite, O_WRONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe", "pipe-wr"); + if (fds[1] != -1) + rc = 0; + } + +# else + int native_fds[2]; + + fds[1] = fds[0] = -1; + if (!pipe(native_fds)) + { + fds[0] = shfile_copy_insert_and_close(pfdtab, &native_fds[0], O_RDONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe", "pipe-rd"); + if (fds[0] != -1) + { + fds[1] = shfile_copy_insert_and_close(pfdtab, &native_fds[1], O_WRONLY, SHFILE_FLAGS_PIPE, -1, "shfile_pipe", "pipe-wr"); + if (fds[1] != -1) + rc = 0; + } +# endif + if (fds[1] == -1) + { + int s = errno; + if (fds[0] != -1) + { + shmtxtmp tmp; + shmtx_enter(&pfdtab->mtx, &tmp); + rc = fds[0]; + pfdtab->tab[rc].fd = -1; + pfdtab->tab[rc].oflags = 0; + pfdtab->tab[rc].shflags = 0; + pfdtab->tab[rc].native = -1; + shmtx_leave(&pfdtab->mtx, &tmp); + } + +# if K_OS == K_OS_WINDOWS + CloseHandle(hRead); + CloseHandle(hWrite); +# else + close(native_fds[0]); + close(native_fds[1]); +# endif + fds[0] = fds[1] = -1; + errno = s; + rc = -1; + } + } + else + { +# if K_OS == K_OS_WINDOWS + errno = shfile_dos2errno(GetLastError()); +# endif + rc = -1; + } + +#else + rc = pipe(fds); +#endif + + TRACE2((NULL, "shfile_pipe() -> %d{%d,%d} [%d]\n", rc, fds[0], fds[1], errno)); + return rc; +} + +/** + * dup(). + */ +int shfile_dup(shfdtab *pfdtab, int fd) +{ + return shfile_fcntl(pfdtab,fd, F_DUPFD, 0); +} + +/** + * Move the file descriptor, closing any existing descriptor at @a fdto. + * + * @returns fdto on success, -1 and errno on failure. + * @param pfdtab The file descriptor table. + * @param fdfrom The descriptor to move. + * @param fdto Where to move it. + */ +int shfile_movefd(shfdtab *pfdtab, int fdfrom, int fdto) +{ +#ifdef SHFILE_IN_USE + int rc; + shmtxtmp tmp; + shfile *file = shfile_get(pfdtab, fdfrom, &tmp); + if (file) + { + /* prepare the new entry */ + if ((unsigned)fdto >= pfdtab->size) + shfile_grow_tab_locked(pfdtab, fdto); + if ((unsigned)fdto < pfdtab->size) + { + if (pfdtab->tab[fdto].fd != -1) + shfile_native_close(pfdtab->tab[fdto].native, &pfdtab->tab[fdto], K_FALSE); + + /* setup the target. */ + pfdtab->tab[fdto].fd = fdto; + pfdtab->tab[fdto].oflags = file->oflags; + pfdtab->tab[fdto].shflags = file->shflags; + pfdtab->tab[fdto].native = file->native; +# ifdef DEBUG + pfdtab->tab[fdto].dbgname = file->dbgname; +# endif + + /* close the source. */ + file->fd = -1; + file->oflags = 0; + file->shflags = 0; + file->native = -1; +# ifdef DEBUG + file->dbgname = NULL; +# endif + + rc = fdto; + } + else + { + errno = EMFILE; + rc = -1; + } + + shfile_put(pfdtab, file, &tmp); + } + else + rc = -1; + return rc; + +#else + int fdnew = dup2(fdfrom, fdto); + if (fdnew >= 0) + close(fdfrom); + return fdnew; +#endif +} + +/** + * Move the file descriptor to somewhere at @a fdMin or above. + * + * @returns the new file descriptor success, -1 and errno on failure. + * @param pfdtab The file descriptor table. + * @param fdfrom The descriptor to move. + * @param fdMin The minimum descriptor. + */ +int shfile_movefd_above(shfdtab *pfdtab, int fdfrom, int fdMin) +{ +#ifdef SHFILE_IN_USE + int fdto; + shmtxtmp tmp; + shfile *file = shfile_get(pfdtab, fdfrom, &tmp); + if (file) + { + /* find a new place */ + int i; + fdto = -1; + for (i = fdMin; (unsigned)i < pfdtab->size; i++) + if (pfdtab->tab[i].fd == -1) + { + fdto = i; + break; + } + if (fdto == -1) + fdto = shfile_grow_tab_locked(pfdtab, fdMin); + if (fdto != -1) + { + /* setup the target. */ + pfdtab->tab[fdto].fd = fdto; + pfdtab->tab[fdto].oflags = file->oflags; + pfdtab->tab[fdto].shflags = file->shflags; + pfdtab->tab[fdto].native = file->native; +# ifdef DEBUG + pfdtab->tab[fdto].dbgname = file->dbgname; +# endif + + /* close the source. */ + file->fd = -1; + file->oflags = 0; + file->shflags = 0; + file->native = -1; +# ifdef DEBUG + file->dbgname = NULL; +# endif + } + else + { + errno = EMFILE; + fdto = -1; + } + + shfile_put(pfdtab, file, &tmp); + } + else + fdto = -1; + return fdto; + +#else + int fdnew = fcntl(fdfrom, F_DUPFD, fdMin); + if (fdnew >= 0) + close(fdfrom); + return fdnew; +#endif +} + +/** + * close(). + */ +int shfile_close(shfdtab *pfdtab, unsigned fd) +{ + int rc; +#ifdef SHFILE_IN_USE + shmtxtmp tmp; + shfile *file = shfile_get(pfdtab, fd, &tmp); + if (file) + { + shfile_native_close(file->native, file, K_FALSE); + + file->fd = -1; + file->oflags = 0; + file->shflags = 0; + file->native = -1; +# ifdef DEBUG + sh_free(NULL, file->dbgname); + file->dbgname = NULL; +# endif + + shfile_put(pfdtab, file, &tmp); + rc = 0; + } + else + rc = -1; + +#else + rc = close(fd); +#endif + + TRACE2((NULL, "shfile_close(%d) -> %d [%d]\n", fd, rc, errno)); + return rc; +} + +/** + * read(). + */ +long shfile_read(shfdtab *pfdtab, int fd, void *buf, size_t len) +{ + long rc; +#ifdef SHFILE_IN_USE + shmtxtmp tmp; + shfile *file = shfile_get(pfdtab, fd, &tmp); + if (file) + { +# if K_OS == K_OS_WINDOWS + DWORD dwRead = 0; + if (ReadFile((HANDLE)file->native, buf, (DWORD)len, &dwRead, NULL)) + rc = dwRead; + else + rc = shfile_dos2errno(GetLastError()); +# else + rc = read(file->native, buf, len); +# endif + + shfile_put(pfdtab, file, &tmp); + } + else + rc = -1; + +#else + rc = read(fd, buf, len); +#endif + return rc; +} + +/** + * write(). + */ +long shfile_write(shfdtab *pfdtab, int fd, const void *buf, size_t len) +{ + long rc; +#ifdef SHFILE_IN_USE + shmtxtmp tmp; + shfile *file = shfile_get(pfdtab, fd, &tmp); + if (file) + { +# if K_OS == K_OS_WINDOWS + DWORD dwWritten = 0; + if (WriteFile((HANDLE)file->native, buf, (DWORD)len, &dwWritten, NULL)) + rc = dwWritten; + else + rc = shfile_dos2errno(GetLastError()); +# else + rc = write(file->native, buf, len); +# endif + + file->shflags |= SHFILE_FLAGS_DIRTY; /* there should be no concurrent access, so this is safe. */ + shfile_put(pfdtab, file, &tmp); + } + else + rc = -1; + +# ifdef DEBUG + if (fd != shthread_get_shell()->tracefd) + TRACE2((NULL, "shfile_write(%d,,%d) -> %d [%d]\n", fd, len, rc, errno)); +# endif + +#else + if (fd != shthread_get_shell()->tracefd) + { + int iSavedErrno = errno; + struct stat s; + int x; + x = fstat(fd, &s); + TRACE2((NULL, "shfile_write(%d) - %lu bytes (%d) - pos %lu - before; %o\n", + fd, (long)s.st_size, x, (long)lseek(fd, 0, SEEK_CUR), s.st_mode )); + K_NOREF(x); + errno = iSavedErrno; + } + + rc = write(fd, buf, len); +#endif + return rc; +} + +/** + * lseek(). + */ +long shfile_lseek(shfdtab *pfdtab, int fd, long off, int whench) +{ + long rc; +#ifdef SHFILE_IN_USE + shmtxtmp tmp; + shfile *file = shfile_get(pfdtab, fd, &tmp); + if (file) + { +# if K_OS == K_OS_WINDOWS + kHlpAssert(SEEK_SET == FILE_BEGIN); + kHlpAssert(SEEK_CUR == FILE_CURRENT); + kHlpAssert(SEEK_END == FILE_END); + rc = SetFilePointer((HANDLE)file->native, off, NULL, whench); + if (rc == INVALID_SET_FILE_POINTER) + rc = shfile_dos2errno(GetLastError()); +# else + rc = lseek(file->native, off, whench); +# endif + + shfile_put(pfdtab, file, &tmp); + } + else + rc = -1; + +#else + rc = lseek(fd, off, whench); +#endif + + return rc; +} + +int shfile_fcntl(shfdtab *pfdtab, int fd, int cmd, int arg) +{ + int rc; +#ifdef SHFILE_IN_USE + shmtxtmp tmp; + shfile *file = shfile_get(pfdtab, fd, &tmp); + if (file) + { + switch (cmd) + { + case F_GETFL: + rc = file->oflags; + break; + + case F_SETFL: + { + unsigned mask = O_NONBLOCK | O_APPEND | O_BINARY | O_TEXT; +# ifdef O_DIRECT + mask |= O_DIRECT; +# endif +# ifdef O_ASYNC + mask |= O_ASYNC; +# endif +# ifdef O_SYNC + mask |= O_SYNC; +# endif + if ((file->oflags & mask) == (arg & mask)) + rc = 0; + else + { +# if K_OS == K_OS_WINDOWS + kHlpAssert(0); + errno = EINVAL; + rc = -1; +# else + rc = fcntl(file->native, F_SETFL, arg); + if (rc != -1) + file->oflags = (file->oflags & ~mask) | (arg & mask); +# endif + } + break; + } + + case F_DUPFD: + { +# if K_OS == K_OS_WINDOWS + HANDLE hNew = INVALID_HANDLE_VALUE; + if (DuplicateHandle(GetCurrentProcess(), + (HANDLE)file->native, + GetCurrentProcess(), + &hNew, + 0, + FALSE /* bInheritHandle */, + DUPLICATE_SAME_ACCESS)) + rc = shfile_insert(pfdtab, (intptr_t)hNew, file->oflags, file->shflags, arg, + "shfile_fcntl", SHFILE_DBGNAME(file->dbgname)); + else + rc = shfile_dos2errno(GetLastError()); +# else + int nativeNew = fcntl(file->native, F_DUPFD, SHFILE_UNIX_MIN_FD); + if (nativeNew != -1) + rc = shfile_insert(pfdtab, nativeNew, file->oflags, file->shflags, arg, + "shfile_fcntl", SHFILE_DBGNAME(file->dbgname)); + else + rc = -1; +# endif + break; + } + + default: + errno = -EINVAL; + rc = -1; + break; + } + + shfile_put(pfdtab, file, &tmp); + } + else + rc = -1; + +#else + rc = fcntl(fd, cmd, arg); +#endif + + switch (cmd) + { + case F_GETFL: TRACE2((NULL, "shfile_fcntl(%d,F_GETFL,ignored=%d) -> %d [%d]\n", fd, arg, rc, errno)); break; + case F_SETFL: TRACE2((NULL, "shfile_fcntl(%d,F_SETFL,newflags=%#x) -> %d [%d]\n", fd, arg, rc, errno)); break; + case F_DUPFD: TRACE2((NULL, "shfile_fcntl(%d,F_DUPFD,minfd=%d) -> %d [%d]\n", fd, arg, rc, errno)); break; + default: TRACE2((NULL, "shfile_fcntl(%d,%d,%d) -> %d [%d]\n", fd, cmd, arg, rc, errno)); break; + } + return rc; +} + +int shfile_stat(shfdtab *pfdtab, const char *path, struct stat *pst) +{ +#ifdef SHFILE_IN_USE + char abspath[SHFILE_MAX_PATH]; + int rc; + rc = shfile_make_path(pfdtab, path, &abspath[0]); + if (!rc) + { +# if K_OS == K_OS_WINDOWS +# if 1 + rc = birdStatFollowLink(abspath, pst); +# else + int dir_slash = shfile_trailing_slash_hack(abspath); + rc = stat(abspath, pst); /** @todo re-implement stat. */ + if (!rc && dir_slash && !S_ISDIR(pst->st_mode)) + { + rc = -1; + errno = ENOTDIR; + + } +# endif +# else + rc = stat(abspath, pst); +# endif + } + TRACE2((NULL, "shfile_stat(,%s,) -> %d [%d] st_size=%llu st_mode=%o\n", + path, rc, errno, (unsigned long long)pst->st_size, pst->st_mode)); + return rc; +#else + return stat(path, pst); +#endif +} + +/** + * @retval 1 if regular file. + * @retval 0 if found but not a regular file. + * @retval -1 and errno on failure + */ +int shfile_stat_isreg(shfdtab *pfdtab, const char *path) +{ +#if defined(SHFILE_IN_USE) && K_OS == K_OS_WINDOWS + char abspath[SHFILE_MAX_PATH]; + KU16 mode = 0; + int rc = shfile_make_path(pfdtab, path, &abspath[0]); + if (!rc) + { + rc = birdStatModeOnly(abspath, &mode, 0 /*fFollowLink*/); + if (rc >= 0) + rc = S_ISREG(mode) ? 1 : 0; + } + TRACE2((NULL, "shfile_stat_isreg(,%s,) -> %d [%d] st_mode=%o\n", path, rc, errno, mode)); + return rc; +#else + struct stat st; + int rc = shfile_stat(pfdtab, path, &st); + if (rc >= 0) + rc = S_ISREG(st.st_mode) ? 1 : 0; + return rc; +#endif +} + +/** + * Same as shfile_stat, but without the data structure. + */ +int shfile_stat_exists(shfdtab *pfdtab, const char *path) +{ +#if defined(SHFILE_IN_USE) && K_OS == K_OS_WINDOWS + char abspath[SHFILE_MAX_PATH]; + KU16 mode = 0; + int rc = shfile_make_path(pfdtab, path, &abspath[0]); + if (!rc) + rc = birdStatModeOnly(abspath, &mode, 0 /*fFollowLink*/); + TRACE2((NULL, "shfile_stat_exists(,%s,) -> %d [%d] st_mode=%o\n", path, rc, errno, mode)); + return rc; +#else + struct stat ignored; + return shfile_stat(pfdtab, path, &ignored); +#endif +} + +int shfile_lstat(shfdtab *pfdtab, const char *path, struct stat *pst) +{ + int rc; +#ifdef SHFILE_IN_USE + char abspath[SHFILE_MAX_PATH]; + + rc = shfile_make_path(pfdtab, path, &abspath[0]); + if (!rc) + { +# if K_OS == K_OS_WINDOWS +# if 1 + rc = birdStatOnLink(abspath, pst); +# else + int dir_slash = shfile_trailing_slash_hack(abspath); + rc = stat(abspath, pst); /** @todo re-implement stat. */ + if (!rc && dir_slash && !S_ISDIR(pst->st_mode)) + { + rc = -1; + errno = ENOTDIR; + } +# endif +# else + rc = lstat(abspath, pst); +# endif + } +#else + rc = stat(path, pst); +#endif + TRACE2((NULL, "shfile_lstat(,%s,) -> %d [%d] st_size=%llu st_mode=%o\n", + path, rc, errno, (unsigned long long)pst->st_size, pst->st_mode)); + return rc; +} + +/** + * chdir(). + */ +int shfile_chdir(shfdtab *pfdtab, const char *path) +{ + int rc; +#ifdef SHFILE_IN_USE + shinstance *psh = shthread_get_shell(); + char abspath[SHFILE_MAX_PATH]; + + rc = shfile_make_path(pfdtab, path, &abspath[0]); + if (!rc) + { + char *abspath_copy = sh_strdup(psh, abspath); + char *free_me = abspath_copy; + rc = chdir(abspath); + if (!rc) + { + shmtxtmp tmp; + shmtx_enter(&pfdtab->mtx, &tmp); + + shfile_fix_slashes(abspath_copy); + free_me = pfdtab->cwd; + pfdtab->cwd = abspath_copy; + + shmtx_leave(&pfdtab->mtx, &tmp); + } + sh_free(psh, free_me); + } + else + rc = -1; +#else + rc = chdir(path); +#endif + + TRACE2((NULL, "shfile_chdir(,%s) -> %d [%d]\n", path, rc, errno)); + return rc; +} + +/** + * getcwd(). + */ +char *shfile_getcwd(shfdtab *pfdtab, char *buf, int size) +{ + char *ret; +#ifdef SHFILE_IN_USE + + ret = NULL; + if (buf && !size) + errno = -EINVAL; + else + { + size_t cwd_size; + shmtxtmp tmp; + shmtx_enter(&pfdtab->mtx, &tmp); + + cwd_size = strlen(pfdtab->cwd) + 1; + if (buf) + { + if (cwd_size <= (size_t)size) + ret = memcpy(buf, pfdtab->cwd, cwd_size); + else + errno = ERANGE; + } + else + { + if ((size_t)size < cwd_size) + size = (int)cwd_size; + ret = sh_malloc(shthread_get_shell(), size); + if (ret) + ret = memcpy(ret, pfdtab->cwd, cwd_size); + else + errno = ENOMEM; + } + + shmtx_leave(&pfdtab->mtx, &tmp); + } +#else + ret = getcwd(buf, size); +#endif + + TRACE2((NULL, "shfile_getcwd(,%p,%d) -> %s [%d]\n", buf, size, ret, errno)); + return ret; +} + +/** + * access(). + */ +int shfile_access(shfdtab *pfdtab, const char *path, int type) +{ + int rc; +#ifdef SHFILE_IN_USE + char abspath[SHFILE_MAX_PATH]; + + rc = shfile_make_path(pfdtab, path, &abspath[0]); + if (!rc) + { +# ifdef _MSC_VER + if (type & X_OK) + type = (type & ~X_OK) | R_OK; +# endif + rc = access(abspath, type); + } +#else +# ifdef _MSC_VER + if (type & X_OK) + type = (type & ~X_OK) | R_OK; +# endif + rc = access(path, type); +#endif + + TRACE2((NULL, "shfile_access(,%s,%#x) -> %d [%d]\n", path, type, rc, errno)); + return rc; +} + +/** + * isatty() + */ +int shfile_isatty(shfdtab *pfdtab, int fd) +{ + int rc; +#ifdef SHFILE_IN_USE + shmtxtmp tmp; + shfile *file = shfile_get(pfdtab, fd, &tmp); + if (file) + { +# if K_OS == K_OS_WINDOWS + rc = (file->shflags & SHFILE_FLAGS_TYPE_MASK) == SHFILE_FLAGS_TTY; +# else + rc = isatty(file->native); +# endif + shfile_put(pfdtab, file, &tmp); + } + else + rc = 0; +#else + rc = isatty(fd); +#endif + + TRACE2((NULL, "isatty(%d) -> %d [%d]\n", fd, rc, errno)); + return rc; +} + +/** + * fcntl F_SETFD / FD_CLOEXEC. + */ +int shfile_cloexec(shfdtab *pfdtab, int fd, int closeit) +{ + int rc; +#ifdef SHFILE_IN_USE + shmtxtmp tmp; + shfile *file = shfile_get(pfdtab, fd, &tmp); + if (file) + { + if (closeit) + file->shflags |= SHFILE_FLAGS_CLOSE_ON_EXEC; + else + file->shflags &= ~SHFILE_FLAGS_CLOSE_ON_EXEC; + shfile_put(pfdtab, file, &tmp); + rc = 0; + } + else + rc = -1; +#else + rc = fcntl(fd, F_SETFD, fcntl(fd, F_GETFD, 0) + | (closeit ? FD_CLOEXEC : 0)); +#endif + + TRACE2((NULL, "shfile_cloexec(%d, %d) -> %d [%d]\n", fd, closeit, rc, errno)); + return rc; +} + +/** + * Sets the SHFILE_FLAGS_TRACE flag. + */ +int shfile_set_trace(shfdtab *pfdtab, int fd) +{ + int rc; +#ifdef SHFILE_IN_USE + shmtxtmp tmp; + shfile *file = shfile_get(pfdtab, fd, &tmp); + if (file) + { + file->shflags |= SHFILE_FLAGS_TRACE; + shfile_put(pfdtab, file, &tmp); + rc = 0; + } + else + rc = -1; +#else + rc = 0; +#endif + + TRACE2((NULL, "shfile_set_trace(%d) -> %d\n", fd, rc)); + return rc; +} + + +int shfile_ioctl(shfdtab *pfdtab, int fd, unsigned long request, void *buf) +{ + int rc; +#ifdef SHFILE_IN_USE + shmtxtmp tmp; + shfile *file = shfile_get(pfdtab, fd, &tmp); + if (file) + { +# if K_OS == K_OS_WINDOWS + rc = -1; + errno = ENOSYS; +# else + rc = ioctl(file->native, request, buf); +# endif + shfile_put(pfdtab, file, &tmp); + } + else + rc = -1; +#else + rc = ioctl(fd, request, buf); +#endif + + TRACE2((NULL, "ioctl(%d, %#x, %p) -> %d\n", fd, request, buf, rc)); + return rc; +} + + +mode_t shfile_get_umask(shfdtab *pfdtab) +{ + /** @todo */ + return 022; +} + +void shfile_set_umask(shfdtab *pfdtab, mode_t mask) +{ + /** @todo */ + (void)mask; +} + + + +shdir *shfile_opendir(shfdtab *pfdtab, const char *dir) +{ +#if defined(SHFILE_IN_USE) && K_OS == K_OS_WINDOWS + shdir *pdir = NULL; + + TRACE2((NULL, "shfile_opendir: dir='%s'\n", dir)); + shfile_init_globals(); + if (g_pfnNtQueryDirectoryFile) + { + char abspath[SHFILE_MAX_PATH]; + if (shfile_make_path(pfdtab, dir, &abspath[0]) == 0) + { + HANDLE hFile; + SECURITY_ATTRIBUTES SecurityAttributes; + + SecurityAttributes.nLength = sizeof(SecurityAttributes); + SecurityAttributes.lpSecurityDescriptor = NULL; + SecurityAttributes.bInheritHandle = FALSE; + + hFile = CreateFileA(abspath, + GENERIC_READ, + FILE_SHARE_DELETE | FILE_SHARE_READ | FILE_SHARE_WRITE, + &SecurityAttributes, + OPEN_EXISTING, + FILE_ATTRIBUTE_DIRECTORY | FILE_FLAG_BACKUP_SEMANTICS, + NULL /* hTemplateFile */); + if (hFile != INVALID_HANDLE_VALUE) + { + pdir = (shdir *)sh_malloc(shthread_get_shell(), sizeof(*pdir)); + if (pdir) + { + pdir->pfdtab = pfdtab; + pdir->native = hFile; + pdir->off = ~(size_t)0; + } + else + CloseHandle(hFile); + } + else + { + errno = shfile_dos2errno(GetLastError()); + TRACE2((NULL, "shfile_opendir: CreateFileA(%s) -> %d/%d\n", abspath, GetLastError(), errno)); + } + } + } + else + errno = ENOSYS; + return pdir; +#else + TRACE2((NULL, "shfile_opendir: dir='%s'\n", dir)); + return (shdir *)opendir(dir); +#endif +} + +shdirent *shfile_readdir(struct shdir *pdir) +{ +#if defined(SHFILE_IN_USE) && K_OS == K_OS_WINDOWS + if (pdir) + { + NTSTATUS rcNt; + + if ( pdir->off == ~(size_t)0 + || pdir->off + sizeof(MY_FILE_NAMES_INFORMATION) >= pdir->cb) + { + MY_IO_STATUS_BLOCK Ios; + + memset(&Ios, 0, sizeof(Ios)); + rcNt = g_pfnNtQueryDirectoryFile(pdir->native, + NULL /*Event*/, + NULL /*ApcRoutine*/, + NULL /*ApcContext*/, + &Ios, + &pdir->buf[0], + sizeof(pdir->buf), + MY_FileNamesInformation, + FALSE /*ReturnSingleEntry*/, + NULL /*FileName*/, + pdir->off == ~(size_t)0 /*RestartScan*/); + if (rcNt >= 0 && rcNt != STATUS_PENDING) + { + pdir->cb = Ios.Information; + pdir->off = 0; + } + else if (rcNt == STATUS_NO_MORE_FILES) + errno = 0; /* wrong? */ + else + shfile_nt2errno(rcNt); + } + + if ( pdir->off != ~(size_t)0 + && pdir->off + sizeof(MY_FILE_NAMES_INFORMATION) <= pdir->cb) + { + PMY_FILE_NAMES_INFORMATION pcur = (PMY_FILE_NAMES_INFORMATION)&pdir->buf[pdir->off]; + ANSI_STRING astr; + UNICODE_STRING ustr; + + astr.Length = astr.MaximumLength = sizeof(pdir->ent.name); + astr.Buffer = &pdir->ent.name[0]; + + ustr.Length = ustr.MaximumLength = pcur->FileNameLength < ~(USHORT)0 ? (USHORT)pcur->FileNameLength : ~(USHORT)0; + ustr.Buffer = &pcur->FileName[0]; + + rcNt = g_pfnRtlUnicodeStringToAnsiString(&astr, &ustr, 0/*AllocateDestinationString*/); + if (rcNt < 0) + sprintf(pdir->ent.name, "conversion-failed-%08x-rcNt=%08x-len=%u", + pcur->FileIndex, rcNt, pcur->FileNameLength); + if (pcur->NextEntryOffset) + pdir->off += pcur->NextEntryOffset; + else + pdir->off = pdir->cb; + return &pdir->ent; + } + } + else + errno = EINVAL; + return NULL; +#else + struct dirent *pde = readdir((DIR *)pdir); + return pde ? (shdirent *)&pde->d_name[0] : NULL; +#endif +} + +void shfile_closedir(struct shdir *pdir) +{ +#if defined(SHFILE_IN_USE) && K_OS == K_OS_WINDOWS + if (pdir) + { + CloseHandle(pdir->native); + pdir->pfdtab = NULL; + pdir->native = INVALID_HANDLE_VALUE; + sh_free(shthread_get_shell(), pdir); + } + else + errno = EINVAL; +#else + closedir((DIR *)pdir); +#endif +} + |