summaryrefslogtreecommitdiff
path: root/win32/win32.c
diff options
context:
space:
mode:
Diffstat (limited to 'win32/win32.c')
-rw-r--r--win32/win32.c984
1 files changed, 984 insertions, 0 deletions
diff --git a/win32/win32.c b/win32/win32.c
new file mode 100644
index 0000000000..e9e5af2a5f
--- /dev/null
+++ b/win32/win32.c
@@ -0,0 +1,984 @@
+// WIN32.C
+
+// (c) 1995 Microsoft Corporation. All rights reserved.
+// Developed by hip communications inc., http://info.hip.com/info/
+// Portions (c) 1993 Intergraph Corporation. All rights reserved.
+
+// You may distribute under the terms of either the GNU General Public
+// License or the Artistic License, as specified in the README file.
+
+#define WIN32_LEAN_AND_MEAN
+#define WIN32IO_IS_STDIO
+#include <tchar.h>
+#include <windows.h>
+
+//#include "config.h"
+
+#define PERLIO_NOT_STDIO 0
+#if !defined(PERLIO_IS_STDIO) && !defined(USE_SFIO)
+#define PerlIO FILE
+#endif
+
+#include "EXTERN.h"
+#include "perl.h"
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <assert.h>
+#include <string.h>
+#include <stdarg.h>
+
+#define CROAK croak
+#define WARN warn
+
+extern WIN32_IOSUBSYSTEM win32stdio;
+__declspec(thread) PWIN32_IOSUBSYSTEM pIOSubSystem = &win32stdio;
+//__declspec(thread) PWIN32_IOSUBSYSTEM pIOSubSystem = NULL;
+
+BOOL ProbeEnv = FALSE;
+DWORD Win32System;
+char szShellPath[MAX_PATH+1];
+char szPerlLibRoot[MAX_PATH+1];
+HANDLE PerlDllHandle = INVALID_HANDLE_VALUE;
+
+#define IsWin95() (Win32System == VER_PLATFORM_WIN32_WINDOWS)
+#define IsWinNT() (Win32System == VER_PLATFORM_WIN32_NT)
+
+void *SetIOSubSystem(void *p)
+{
+ if (p) {
+ PWIN32_IOSUBSYSTEM pio = (PWIN32_IOSUBSYSTEM)p;
+
+ if (pio->signature_begin == 12345678L && pio->signature_end == 87654321L) {
+ PWIN32_IOSUBSYSTEM pold = pIOSubSystem;
+ pIOSubSystem = pio;
+ return pold;
+ }
+ }
+ else {
+ // re-assign our stuff
+// pIOSubSystem = &win32stdio;
+ pIOSubSystem = NULL;
+ }
+
+ return pIOSubSystem;
+}
+
+char *win32PerlLibPath(void)
+{
+
+ GetModuleFileName((PerlDllHandle == INVALID_HANDLE_VALUE)
+ ? GetModuleHandle(NULL) : PerlDllHandle,
+ szPerlLibRoot,
+ sizeof(szPerlLibRoot));
+
+ *(strrchr(szPerlLibRoot, '\\')) = '\0';
+ strcat(szPerlLibRoot,"\\LIB");
+ return (szPerlLibRoot);
+}
+
+BOOL HasRedirection(char *ptr)
+{
+ int inquote = 0;
+ char quote = '\0';
+
+ //
+ // Scan string looking for redirection (< or >) or pipe
+ // characters (|) that are not in a quoted string
+ //
+ while(*ptr)
+ {
+ switch(*ptr)
+ {
+ case '\'':
+ case '\"':
+ if(inquote)
+ {
+ if(quote == *ptr)
+ {
+ inquote = 0;
+ quote = '\0';
+ }
+ }
+ else
+ {
+ quote = *ptr;
+ inquote++;
+ }
+ break;
+
+ case '>':
+ case '<':
+ case '|':
+ if(!inquote)
+ return TRUE;
+
+ default:
+ break;
+ }
+ ++ptr;
+ }
+ return FALSE;
+}
+
+// since the current process environment is being updated in util.c
+// the library functions will get the correct environment
+PerlIO *my_popen(char *cmd, char *mode)
+{
+#ifdef FIXCMD
+#define fixcmd(x) {\
+ char *pspace = strchr((x),' ');\
+ if (pspace) {\
+ char *p = (x);\
+ while (p < pspace) {\
+ if (*p == '/') *p = '\\';\
+ p++;\
+ }\
+ }\
+ }
+#else
+#define fixcmd(x)
+#endif
+#ifndef PERLDLL
+ fixcmd(cmd);
+ return win32_popen(cmd, mode);
+#else
+/*
+ * There seems to be some problems for the _popen call in a DLL
+ * this trick at the moment seems to work but it is never test
+ * on NT yet
+ *
+ */
+# ifdef __cplusplus
+#define EXT_C_FUNC extern "C"
+# else
+#define EXT_C_FUNC extern
+# endif
+
+EXT_C_FUNC int __cdecl _set_osfhnd(int fh, long value);
+EXT_C_FUNC void __cdecl _lock_fhandle(int);
+EXT_C_FUNC void __cdecl _unlock_fhandle(int);
+
+ BOOL fSuccess;
+ PerlIO *pf; // to store the _popen return value
+ int tm = 0; /* flag indicating tDllExport or binary mode */
+ int fhNeeded, fhInherited, fhDup;
+ int ineeded, iinherited;
+ DWORD dwDup;
+ int phdls[2]; /* I/O handles for pipe */
+ HANDLE hPIn,
+ hPOut,
+ hPErr,
+ hSaveStdin,
+ hSaveStdout,
+ hSaveStderr,
+ hPNeeded, hPInherited, hPDuped;
+
+ /* first check for errors in the arguments
+ */
+
+ if ( (cmd == NULL) || (mode == NULL) || ((*mode != 'w') &&
+ (*mode != _T('r'))) )
+ goto error1;
+
+ if ( *(mode + 1) == _T('t') )
+ tm = _O_TEXT;
+ else if ( *(mode + 1) == _T('b') )
+ tm = _O_BINARY;
+ else tm = (*mode == 'w' ? _O_BINARY : _O_TEXT);
+
+
+ fixcmd(cmd);
+ if (&win32stdio != pIOSubSystem) return win32_popen(cmd, mode);
+
+#ifdef EFG
+ if ( _pipe( phdls, 1024, tm ) == -1 )
+#else
+ if ( win32_pipe( phdls, 1024, tm ) == -1 )
+#endif
+ goto error1;
+
+
+ /* save the current situation */
+
+ hSaveStdin = GetStdHandle(STD_INPUT_HANDLE);
+ hSaveStdout = GetStdHandle(STD_OUTPUT_HANDLE);
+ hSaveStderr = GetStdHandle(STD_ERROR_HANDLE);
+
+ if (*mode == _T('w')) {
+ ineeded = 1;
+ dwDup = STD_INPUT_HANDLE;
+ iinherited = 0;
+ }
+ else {
+ ineeded = 0;
+ dwDup = STD_OUTPUT_HANDLE;
+ iinherited = 1;
+ }
+
+
+ fhNeeded = phdls[ineeded];
+ fhInherited = phdls[iinherited];
+
+ fSuccess = DuplicateHandle(GetCurrentProcess(),
+ (HANDLE) stolen_get_osfhandle(fhNeeded),
+ GetCurrentProcess(),
+ &hPNeeded,
+ 0,
+ FALSE, /* not inherited */
+ DUPLICATE_SAME_ACCESS);
+
+ if (!fSuccess) goto error2;
+
+ fhDup = stolen_open_osfhandle((long) hPNeeded, tm);
+ win32_dup2(fhDup, fhNeeded);
+ win32_close(fhDup);
+
+#ifdef AAA
+ /* Close the Out pipe, child won't need it */
+ hPDuped = (HANDLE) stolen_get_osfhandle(fhNeeded);
+
+ _lock_fhandle(fhNeeded);
+ _set_osfhnd(fhNeeded, (long) hPNeeded); // put in ours duplicated one
+ _unlock_fhandle(fhNeeded);
+
+ CloseHandle(hPDuped); // close the handle first
+#endif
+
+ if (!SetStdHandle(dwDup, (HANDLE) stolen_get_osfhandle(fhInherited))) goto error2;
+
+ //
+ // make sure the child see the same stderr as the calling program
+ //
+ //
+ if (!SetStdHandle(STD_ERROR_HANDLE, (HANDLE) stolen_get_osfhandle(win32_fileno(win32_stderr())))) goto error2;
+
+ pf = win32_popen(cmd, mode); // ask _popen to do the job
+
+ /* restore to where we were */
+ SetStdHandle(STD_INPUT_HANDLE, hSaveStdin);
+ SetStdHandle(STD_OUTPUT_HANDLE, hSaveStdout);
+ SetStdHandle(STD_ERROR_HANDLE, hSaveStderr);
+
+ /* we don't need it any more, that's for the child */
+ win32_close(fhInherited);
+
+ if (NULL == pf) {
+ // something wrong
+ win32_close(fhNeeded);
+ goto error1;
+ }
+ else {
+
+ /*
+ * here we steal the file handle in pf and stuff ours in
+ *
+ */
+ win32_dup2(fhNeeded, win32_fileno(pf));
+ win32_close(fhNeeded);
+ }
+
+ return (pf);
+
+error2:
+ win32_close(fhNeeded);
+ win32_close(fhInherited);
+
+error1:
+ return (NULL);
+
+#endif
+}
+
+long my_pclose(PerlIO *fp)
+{
+ return win32_pclose(fp);
+}
+
+static void IdOS(void)
+{
+ OSVERSIONINFO osver;
+
+ memset(&osver, 0, sizeof(OSVERSIONINFO));
+ osver.dwOSVersionInfoSize = sizeof(OSVERSIONINFO);
+ GetVersionEx(&osver);
+ Win32System = osver.dwPlatformId;
+ return;
+}
+
+static char *GetShell(void)
+{
+ static char* szWin95ShellEntry = "Win95Shell";
+ static char* szWin95DefaultShell = "Cmd32.exe";
+ static char* szWinNTDefaultShell = "cmd.exe";
+
+ if (!ProbeEnv) {
+ IdOS(), ProbeEnv = TRUE;
+ if (IsWin95()) {
+ strcpy(szShellPath, szWin95DefaultShell);
+ }
+ else {
+ strcpy(szShellPath, szWinNTDefaultShell);
+ }
+ }
+
+ return szShellPath;
+}
+
+int do_aspawn(void* really, void** mark, void** arglast)
+{
+ char **argv;
+ char *strPtr;
+ char *cmd;
+ int status;
+ unsigned int length;
+ int index = 0;
+ SV *sv = (SV*)really;
+ SV** pSv = (SV**)mark;
+
+ New(1110, argv, (arglast - mark) + 3, char*);
+
+ if(sv != Nullsv)
+ {
+ cmd = SvPV(sv, length);
+ }
+ else
+ {
+ cmd = GetShell();
+ argv[index++] = "/c";
+ }
+
+ while(pSv <= (SV**)arglast)
+ {
+ sv = *pSv++;
+ strPtr = SvPV(sv, length);
+ if(strPtr != NULL && *strPtr != '\0')
+ argv[index++] = strPtr;
+ }
+ argv[index++] = 0;
+
+ status = win32_spawnvpe(P_WAIT, cmd, (const char* const*)argv, (const char* const*)environ);
+
+ Safefree(argv);
+
+ // set statusvalue the perl variable $?
+ return (statusvalue = status*256);
+}
+
+int do_spawn(char *cmd)
+{
+ char **a;
+ char *s;
+ char **argv;
+ int status = -1;
+ BOOL needToTry = TRUE;
+ char *shell, *cmd2;
+
+ /* save an extra exec if possible */
+ shell = GetShell();
+
+ /* see if there are shell metacharacters in it */
+ if(!HasRedirection(cmd))
+ {
+ New(1102,argv, strlen(cmd) / 2 + 2, char*);
+
+ New(1103,cmd2, strlen(cmd) + 1, char);
+ strcpy(cmd2, cmd);
+ a = argv;
+ for(s = cmd2; *s;)
+ {
+ while(*s && isspace(*s)) s++;
+ if(*s)
+ *(a++) = s;
+ while(*s && !isspace(*s)) s++;
+ if(*s)
+ *s++ = '\0';
+ }
+ *a = Nullch;
+ if(argv[0])
+ {
+ status = win32_spawnvpe(P_WAIT, argv[0], (const char* const*)argv, (const char* const*)environ);
+ if(status != -1 || errno == 0)
+ needToTry = FALSE;
+ }
+ Safefree(argv);
+ Safefree(cmd2);
+ }
+ if(needToTry)
+ {
+ status = win32_spawnle(P_WAIT, shell, shell, "/c", cmd, (char*)0, environ);
+ }
+
+ // set statusvalue the perl variable $?
+ return (statusvalue = status*256);
+}
+
+
+#define PATHLEN 1024
+
+// The idea here is to read all the directory names into a string table
+// (separated by nulls) and when one of the other dir functions is called
+// return the pointer to the current file name.
+DIR *opendir(char *filename)
+{
+ DIR *p;
+ long len;
+ long idx;
+ char scannamespc[PATHLEN];
+ char *scanname = scannamespc;
+ struct stat sbuf;
+ WIN32_FIND_DATA FindData;
+ HANDLE fh;
+// char root[_MAX_PATH];
+// char volname[_MAX_PATH];
+// DWORD serial, maxname, flags;
+// BOOL downcase;
+// char *dummy;
+
+ // check to see if filename is a directory
+ if(stat(filename, &sbuf) < 0 || sbuf.st_mode & _S_IFDIR == 0)
+ {
+ return NULL;
+ }
+
+ // get the file system characteristics
+// if(GetFullPathName(filename, MAX_PATH, root, &dummy))
+// {
+// if(dummy = strchr(root, '\\'))
+// *++dummy = '\0';
+// if(GetVolumeInformation(root, volname, MAX_PATH, &serial, &maxname, &flags, 0, 0))
+// {
+// downcase = !(flags & FS_CASE_IS_PRESERVED);
+// }
+// }
+// else
+// {
+// downcase = TRUE;
+// }
+
+ // Get us a DIR structure
+ Newz(1501, p, 1, DIR);
+ if(p == NULL)
+ return NULL;
+
+ // Create the search pattern
+ strcpy(scanname, filename);
+
+ if(index("/\\", *(scanname + strlen(scanname) - 1)) == NULL)
+ strcat(scanname, "/*");
+ else
+ strcat(scanname, "*");
+
+ // do the FindFirstFile call
+ fh = FindFirstFile(scanname, &FindData);
+ if(fh == INVALID_HANDLE_VALUE)
+ {
+ return NULL;
+ }
+
+ // now allocate the first part of the string table for the filenames that we find.
+ idx = strlen(FindData.cFileName)+1;
+ New(1502, p->start, idx, char);
+ if(p->start == NULL)
+ {
+ CROAK("opendir: malloc failed!\n");
+ }
+ strcpy(p->start, FindData.cFileName);
+// if(downcase)
+// strlwr(p->start);
+ p->nfiles++;
+
+ // loop finding all the files that match the wildcard
+ // (which should be all of them in this directory!).
+ // the variable idx should point one past the null terminator
+ // of the previous string found.
+ //
+ while(FindNextFile(fh, &FindData))
+ {
+ len = strlen(FindData.cFileName);
+ // bump the string table size by enough for the
+ // new name and it's null terminator
+ Renew(p->start, idx+len+1, char);
+ if(p->start == NULL)
+ {
+ CROAK("opendir: malloc failed!\n");
+ }
+ strcpy(&p->start[idx], FindData.cFileName);
+// if(downcase)
+// strlwr(&p->start[idx]);
+ p->nfiles++;
+ idx += len+1;
+ }
+ FindClose(fh);
+ p->size = idx;
+ p->curr = p->start;
+ return p;
+}
+
+
+// Readdir just returns the current string pointer and bumps the
+// string pointer to the nDllExport entry.
+struct direct *readdir(DIR *dirp)
+{
+ int len;
+ static int dummy = 0;
+
+ if(dirp->curr)
+ { // first set up the structure to return
+ len = strlen(dirp->curr);
+ strcpy(dirp->dirstr.d_name, dirp->curr);
+ dirp->dirstr.d_namlen = len;
+
+ // Fake an inode
+ dirp->dirstr.d_ino = dummy++;
+
+ // Now set up for the nDllExport call to readdir
+ dirp->curr += len + 1;
+ if(dirp->curr >= (dirp->start + dirp->size))
+ {
+ dirp->curr = NULL;
+ }
+
+ return &(dirp->dirstr);
+ }
+ else
+ return NULL;
+}
+
+// Telldir returns the current string pointer position
+long telldir(DIR *dirp)
+{
+ return (long) dirp->curr;
+}
+
+
+// Seekdir moves the string pointer to a previously saved position (Saved by telldir).
+void seekdir(DIR *dirp, long loc)
+{
+ dirp->curr = (char *)loc;
+}
+
+// Rewinddir resets the string pointer to the start
+void rewinddir(DIR *dirp)
+{
+ dirp->curr = dirp->start;
+}
+
+// free the memory allocated by opendir
+int closedir(DIR *dirp)
+{
+ Safefree(dirp->start);
+ Safefree(dirp);
+ return 1;
+}
+
+
+//
+// various stubs
+//
+
+
+// Ownership
+//
+// Just pretend that everyone is a superuser. NT will let us know if
+// we don\'t really have permission to do something.
+//
+
+#define ROOT_UID ((uid_t)0)
+#define ROOT_GID ((gid_t)0)
+
+uid_t getuid(void)
+{
+ return ROOT_UID;
+}
+
+uid_t geteuid(void)
+{
+ return ROOT_UID;
+}
+
+gid_t getgid(void)
+{
+ return ROOT_GID;
+}
+
+gid_t getegid(void)
+{
+ return ROOT_GID;
+}
+
+int setuid(uid_t uid)
+{
+ return (uid == ROOT_UID ? 0 : -1);
+}
+
+int setgid(gid_t gid)
+{
+ return (gid == ROOT_GID ? 0 : -1);
+}
+
+//
+// pretended kill
+//
+int kill(int pid, int sig)
+{
+ HANDLE hProcess= OpenProcess(PROCESS_ALL_ACCESS, TRUE, pid);
+
+ if (hProcess == NULL) {
+ CROAK("kill process failed!\n");
+ }
+ else {
+ if (!TerminateProcess(hProcess, sig)) CROAK("kill process failed!\n");
+ CloseHandle(hProcess);
+ }
+ return 0;
+}
+
+//
+// File system stuff
+//
+
+int ioctl(int i, unsigned int u, char *data)
+{
+ CROAK("ioctl not implemented!\n");
+ return -1;
+}
+
+unsigned int sleep(unsigned int t)
+{
+ Sleep(t*1000);
+ return 0;
+}
+
+
+#undef rename
+
+int myrename(char *OldFileName, char *newname)
+{
+ if(_access(newname, 0) != -1)
+ { // file exists
+ _unlink(newname);
+ }
+ return rename(OldFileName, newname);
+}
+
+
+int win32_stat(const char *path, struct stat *buffer)
+{
+ char t[MAX_PATH];
+ const char *p = path;
+ int l = strlen(path);
+
+ if (l > 1) {
+ switch(path[l - 1]) {
+ case '\\':
+ case '/':
+ if (path[l - 2] != ':') {
+ strncpy(t, path, l - 1);
+ t[l - 1] = 0;
+ p = t;
+ };
+ }
+ }
+
+ return stat(p, buffer);
+}
+
+#undef times
+int mytimes(struct tms *timebuf)
+{
+ clock_t t = clock();
+ timebuf->tms_utime = t;
+ timebuf->tms_stime = 0;
+ timebuf->tms_cutime = 0;
+ timebuf->tms_cstime = 0;
+
+ return 0;
+}
+
+#undef alarm
+unsigned int myalarm(unsigned int sec)
+{
+ // we warn the usuage of alarm function
+ if (sec != 0)
+ WARN("dummy function alarm called, program might not function as expected\n");
+ return 0;
+}
+
+//
+// redirected io subsystem for all XS modules
+//
+//
+
+DllExport int * win32_errno(void)
+{
+ return (pIOSubSystem->pfnerrno());
+}
+
+// the rest are the remapped stdio routines
+DllExport FILE *win32_stderr(void)
+{
+ return (pIOSubSystem->pfnstderr());
+}
+
+DllExport FILE *win32_stdin(void)
+{
+ return (pIOSubSystem->pfnstdin());
+}
+
+DllExport FILE *win32_stdout()
+{
+ return (pIOSubSystem->pfnstdout());
+}
+
+DllExport int win32_ferror(FILE *fp)
+{
+ return (pIOSubSystem->pfnferror(fp));
+}
+
+
+DllExport int win32_feof(FILE *fp)
+{
+ return (pIOSubSystem->pfnfeof(fp));
+}
+
+//
+// Since the errors returned by the socket error function
+// WSAGetLastError() are not known by the library routine strerror
+// we have to roll our own.
+//
+
+__declspec(thread) char strerror_buffer[512];
+
+DllExport char *win32_strerror(int e)
+{
+ extern int sys_nerr;
+ DWORD source = 0;
+
+ if(e < 0 || e > sys_nerr)
+ {
+ if(e < 0)
+ e = GetLastError();
+
+ if(FormatMessage(FORMAT_MESSAGE_FROM_SYSTEM, &source, e, 0, strerror_buffer, sizeof(strerror_buffer), NULL) == 0)
+ strcpy(strerror_buffer, "Unknown Error");
+
+ return strerror_buffer;
+ }
+
+ return pIOSubSystem->pfnstrerror(e);
+}
+
+DllExport int win32_fprintf(FILE *fp, const char *format, ...)
+{
+ va_list marker;
+ va_start(marker, format); /* Initialize variable arguments. */
+
+ return (pIOSubSystem->pfnvfprintf(fp, format, marker));
+}
+
+DllExport int win32_printf(const char *format, ...)
+{
+ va_list marker;
+ va_start(marker, format); /* Initialize variable arguments. */
+
+ return (pIOSubSystem->pfnvprintf(format, marker));
+}
+
+DllExport int win32_vfprintf(FILE *fp, const char *format, va_list args)
+{
+ return (pIOSubSystem->pfnvfprintf(fp, format, args));
+}
+
+DllExport size_t win32_fread(void *buf, size_t size, size_t count, FILE *fp)
+{
+ return pIOSubSystem->pfnfread(buf, size, count, fp);
+}
+
+DllExport size_t win32_fwrite(const void *buf, size_t size, size_t count, FILE *fp)
+{
+ return pIOSubSystem->pfnfwrite(buf, size, count, fp);
+}
+
+DllExport FILE *win32_fopen(const char *filename, const char *mode)
+{
+ if (stricmp(filename, "/dev/null")==0) return pIOSubSystem->pfnfopen("NUL", mode);
+ return pIOSubSystem->pfnfopen(filename, mode);
+}
+
+DllExport FILE *win32_fdopen( int handle, const char *mode)
+{
+ return pIOSubSystem->pfnfdopen(handle, mode);
+}
+
+DllExport FILE *win32_freopen( const char *path, const char *mode, FILE *stream)
+{
+ if (stricmp(path, "/dev/null")==0) return pIOSubSystem->pfnfreopen("NUL", mode, stream);
+ return pIOSubSystem->pfnfreopen(path, mode, stream);
+}
+
+DllExport int win32_fclose(FILE *pf)
+{
+ return pIOSubSystem->pfnfclose(pf);
+}
+
+DllExport int win32_fputs(const char *s,FILE *pf)
+{
+ return pIOSubSystem->pfnfputs(s, pf);
+}
+
+DllExport int win32_fputc(int c,FILE *pf)
+{
+ return pIOSubSystem->pfnfputc(c,pf);
+}
+
+DllExport int win32_ungetc(int c,FILE *pf)
+{
+ return pIOSubSystem->pfnungetc(c,pf);
+}
+
+DllExport int win32_getc(FILE *pf)
+{
+ return pIOSubSystem->pfngetc(pf);
+}
+
+DllExport int win32_fileno(FILE *pf)
+{
+ return pIOSubSystem->pfnfileno(pf);
+}
+
+DllExport void win32_clearerr(FILE *pf)
+{
+ pIOSubSystem->pfnclearerr(pf);
+ return;
+}
+
+DllExport int win32_fflush(FILE *pf)
+{
+ return pIOSubSystem->pfnfflush(pf);
+}
+
+DllExport long win32_ftell(FILE *pf)
+{
+ return pIOSubSystem->pfnftell(pf);
+}
+
+DllExport int win32_fseek(FILE *pf,long offset,int origin)
+{
+ return pIOSubSystem->pfnfseek(pf, offset, origin);
+}
+
+DllExport int win32_fgetpos(FILE *pf,fpos_t *p)
+{
+ return pIOSubSystem->pfnfgetpos(pf, p);
+}
+
+DllExport int win32_fsetpos(FILE *pf,const fpos_t *p)
+{
+ return pIOSubSystem->pfnfsetpos(pf, p);
+}
+
+DllExport void win32_rewind(FILE *pf)
+{
+ pIOSubSystem->pfnrewind(pf);
+ return;
+}
+
+DllExport FILE* win32_tmpfile(void)
+{
+ return pIOSubSystem->pfntmpfile();
+}
+
+DllExport void win32_abort(void)
+{
+ pIOSubSystem->pfnabort();
+ return;
+}
+
+DllExport int win32_fstat(int fd,struct stat *bufptr)
+{
+ return pIOSubSystem->pfnfstat(fd,bufptr);
+}
+
+DllExport int win32_pipe(int *pfd, unsigned int size, int mode)
+{
+ return pIOSubSystem->pfnpipe(pfd, size, mode);
+}
+
+DllExport FILE* win32_popen(const char *command, const char *mode)
+{
+ return pIOSubSystem->pfnpopen(command, mode);
+}
+
+DllExport int win32_pclose(FILE *pf)
+{
+ return pIOSubSystem->pfnpclose(pf);
+}
+
+DllExport int win32_setmode(int fd, int mode)
+{
+ return pIOSubSystem->pfnsetmode(fd, mode);
+}
+
+DllExport int win32_open(const char *path, int flag, ...)
+{
+ va_list ap;
+ int pmode;
+
+ va_start(ap, flag);
+ pmode = va_arg(ap, int);
+ va_end(ap);
+
+ if (stricmp(path, "/dev/null")==0) return pIOSubSystem->pfnopen("NUL", flag, pmode);
+ return pIOSubSystem->pfnopen(path,flag,pmode);
+}
+
+DllExport int win32_close(int fd)
+{
+ return pIOSubSystem->pfnclose(fd);
+}
+
+DllExport int win32_dup(int fd)
+{
+ return pIOSubSystem->pfndup(fd);
+}
+
+DllExport int win32_dup2(int fd1,int fd2)
+{
+ return pIOSubSystem->pfndup2(fd1,fd2);
+}
+
+DllExport int win32_read(int fd, char *buf, unsigned int cnt)
+{
+ return pIOSubSystem->pfnread(fd, buf, cnt);
+}
+
+DllExport int win32_write(int fd, const char *buf, unsigned int cnt)
+{
+ return pIOSubSystem->pfnwrite(fd, buf, cnt);
+}
+
+DllExport int win32_spawnvpe(int mode, const char *cmdname, const char *const *argv, const char *const *envp)
+{
+ return pIOSubSystem->pfnspawnvpe(mode, cmdname, argv, envp);
+}
+
+DllExport int win32_spawnle(int mode, const char *cmdname, const char *arglist,...)
+{
+ const char* const* envp;
+ const char* const* argp;
+
+ argp = &arglist;
+ while (*argp++) ;
+
+ return pIOSubSystem->pfnspawnvpe(mode, cmdname, &arglist, argp);
+}
+
+int stolen_open_osfhandle(long handle, int flags)
+{
+ return pIOSubSystem->pfn_open_osfhandle(handle, flags);
+}
+
+long stolen_get_osfhandle(int fd)
+{
+ return pIOSubSystem->pfn_get_osfhandle(fd);
+}
View Lorry Controller Status