X-Git-Url: http://git.shadowcat.co.uk/gitweb/gitweb.cgi?a=blobdiff_plain;f=win32%2Fwin32.c;h=4ccae52d84add5804ff3f3f641c7aa7e7ee70377;hb=ac135a7ce12541cdf86286479bfa24c2847dec48;hp=43e9b5e876a2d9eef5b700bdda866aeaa4130546;hpb=273cf8d1f309172b4416e78e4a8e80c12d941254;p=p5sagit%2Fp5-mst-13.2.git diff --git a/win32/win32.c b/win32/win32.c index 43e9b5e..4ccae52 100644 --- a/win32/win32.c +++ b/win32/win32.c @@ -15,6 +15,11 @@ #define Win32_Winsock #endif #include +#ifndef __MINGW32__ /* GCC/Mingw32-2.95.2 forgot the WINAPI on CommandLineToArgvW() */ +# include +#else + LPWSTR* WINAPI CommandLineToArgvW(LPCWSTR lpCommandLine, int * pNumArgs); +#endif #include #include @@ -57,7 +62,12 @@ int _CRT_glob = 0; #endif #if defined(__MINGW32__) -# define _stat stat +/* Mingw32 is missing some prototypes */ +FILE * _wfopen(LPCWSTR wszFileName, LPCWSTR wszMode); +FILE * _wfdopen(int nFd, LPCWSTR wszMode); +FILE * _freopen(LPCWSTR wszFileName, LPCWSTR wszMode, FILE * pOldStream); +int _flushall(); +int _fcloseall(); #endif #if defined(__BORLANDC__) @@ -123,6 +133,30 @@ IsWinNT(void) return (win32_os_id() == VER_PLATFORM_WIN32_NT); } +EXTERN_C void +set_w32_module_name(void) +{ + char* ptr; + GetModuleFileName((HMODULE)((w32_perldll_handle == INVALID_HANDLE_VALUE) + ? GetModuleHandle(NULL) + : w32_perldll_handle), + w32_module_name, sizeof(w32_module_name)); + + /* try to get full path to binary (which may be mangled when perl is + * run from a 16-bit app) */ + /*PerlIO_printf(Perl_debug_log, "Before %s\n", w32_module_name);*/ + (void)win32_longpath(w32_module_name); + /*PerlIO_printf(Perl_debug_log, "After %s\n", w32_module_name);*/ + + /* normalize to forward slashes */ + ptr = w32_module_name; + while (*ptr) { + if (*ptr == '\\') + *ptr = '/'; + ++ptr; + } +} + /* *svp (if non-NULL) is expected to be POK (valid allocated SvPVX(*svp)) */ static char* get_regstr_from(HKEY hkey, const char *valuename, SV **svp) @@ -185,24 +219,7 @@ get_emd_part(SV **prev_pathp, char *trailing_path, ...) baselen = strlen(base); if (!*w32_module_name) { - GetModuleFileName((HMODULE)((w32_perldll_handle == INVALID_HANDLE_VALUE) - ? GetModuleHandle(NULL) - : w32_perldll_handle), - w32_module_name, sizeof(w32_module_name)); - - /* try to get full path to binary (which may be mangled when perl is - * run from a 16-bit app) */ - /*PerlIO_printf(Perl_debug_log, "Before %s\n", w32_module_name);*/ - (void)win32_longpath(w32_module_name); - /*PerlIO_printf(Perl_debug_log, "After %s\n", w32_module_name);*/ - - /* normalize to forward slashes */ - ptr = w32_module_name; - while (*ptr) { - if (*ptr == '\\') - *ptr = '/'; - ++ptr; - } + set_w32_module_name(); } strcpy(mod_name, w32_module_name); ptr = strrchr(mod_name, '/'); @@ -671,7 +688,7 @@ win32_opendir(char *filename) WIN32_FIND_DATAW wFindData; HANDLE fh; char buffer[MAX_PATH*2]; - WCHAR wbuffer[MAX_PATH]; + WCHAR wbuffer[MAX_PATH+1]; char* ptr; len = strlen(filename); @@ -942,9 +959,9 @@ remove_dead_process(long child) if (child >= 0) { dTHXo; CloseHandle(w32_child_handles[child]); - Copy(&w32_child_handles[child+1], &w32_child_handles[child], + Move(&w32_child_handles[child+1], &w32_child_handles[child], (w32_num_children-child-1), HANDLE); - Copy(&w32_child_pids[child+1], &w32_child_pids[child], + Move(&w32_child_pids[child+1], &w32_child_pids[child], (w32_num_children-child-1), DWORD); w32_num_children--; } @@ -969,9 +986,9 @@ remove_dead_pseudo_process(long child) if (child >= 0) { dTHXo; CloseHandle(w32_pseudo_child_handles[child]); - Copy(&w32_pseudo_child_handles[child+1], &w32_pseudo_child_handles[child], + Move(&w32_pseudo_child_handles[child+1], &w32_pseudo_child_handles[child], (w32_num_pseudo_children-child-1), HANDLE); - Copy(&w32_pseudo_child_pids[child+1], &w32_pseudo_child_pids[child], + Move(&w32_pseudo_child_pids[child+1], &w32_pseudo_child_pids[child], (w32_num_pseudo_children-child-1), DWORD); w32_num_pseudo_children--; } @@ -988,6 +1005,8 @@ win32_kill(int pid, int sig) /* it is a pseudo-forked child */ long child = find_pseudo_pid(-pid); if (child >= 0) { + if (!sig) + return 0; hProcess = w32_pseudo_child_handles[child]; if (TerminateThread(hProcess, sig)) { remove_dead_pseudo_process(child); @@ -1000,6 +1019,8 @@ win32_kill(int pid, int sig) { long child = find_pid(pid); if (child >= 0) { + if (!sig) + return 0; hProcess = w32_child_handles[child]; if (TerminateProcess(hProcess, sig)) { remove_dead_process(child); @@ -1008,9 +1029,13 @@ win32_kill(int pid, int sig) } else { hProcess = OpenProcess(PROCESS_ALL_ACCESS, TRUE, pid); - if (hProcess && TerminateProcess(hProcess, sig)) { - CloseHandle(hProcess); - return 0; + if (hProcess) { + if (!sig) + return 0; + if (TerminateProcess(hProcess, sig)) { + CloseHandle(hProcess); + return 0; + } } } } @@ -1030,13 +1055,14 @@ win32_sleep(unsigned int t) } DllExport int -win32_stat(const char *path, struct stat *buffer) +win32_stat(const char *path, struct stat *sbuf) { dTHXo; - char t[MAX_PATH+1]; + char buffer[MAX_PATH+1]; int l = strlen(path); int res; - WCHAR wbuffer[MAX_PATH]; + WCHAR wbuffer[MAX_PATH+1]; + WCHAR* pwbuffer; HANDLE handle; int nlink = 1; @@ -1045,17 +1071,20 @@ win32_stat(const char *path, struct stat *buffer) /* FindFirstFile() and stat() are buggy with a trailing * backslash, so change it to a forward slash :-( */ case '\\': - strncpy(t, path, l-1); - t[l - 1] = '/'; - t[l] = '\0'; - path = t; + strncpy(buffer, path, l-1); + buffer[l - 1] = '/'; + buffer[l] = '\0'; + path = buffer; break; /* FindFirstFile() is buggy with "x:", so add a dot :-( */ case ':': if (l == 2 && isALPHA(path[0])) { - t[0] = path[0]; t[1] = ':'; t[2] = '.'; t[3] = '\0'; + buffer[0] = path[0]; + buffer[1] = ':'; + buffer[2] = '.'; + buffer[3] = '\0'; l = 3; - path = t; + path = buffer; } break; } @@ -1066,11 +1095,12 @@ win32_stat(const char *path, struct stat *buffer) /* This also gives us an opportunity to determine the number of links. */ if (USING_WIDE()) { A2WHELPER(path, wbuffer, sizeof(wbuffer)); - wcscpy(wbuffer, PerlDir_mapW(wbuffer)); - handle = CreateFileW(wbuffer, 0, 0, NULL, OPEN_EXISTING, 0, NULL); + pwbuffer = PerlDir_mapW(wbuffer); + handle = CreateFileW(pwbuffer, 0, 0, NULL, OPEN_EXISTING, 0, NULL); } else { path = PerlDir_mapA(path); + l = strlen(path); handle = CreateFileA(path, 0, 0, NULL, OPEN_EXISTING, 0, NULL); } if (handle != INVALID_HANDLE_VALUE) { @@ -1080,34 +1110,34 @@ win32_stat(const char *path, struct stat *buffer) CloseHandle(handle); } - /* wbuffer or path will be mapped correctly above */ + /* pwbuffer or path will be mapped correctly above */ if (USING_WIDE()) { - res = _wstat(wbuffer, (struct _stat *)buffer); + res = _wstat(pwbuffer, (struct _stat *)sbuf); } else { - res = stat(path, buffer); + res = stat(path, sbuf); } - buffer->st_nlink = nlink; + sbuf->st_nlink = nlink; if (res < 0) { /* CRT is buggy on sharenames, so make sure it really isn't. * XXX using GetFileAttributesEx() will enable us to set - * buffer->st_*time (but note that's not available on the + * sbuf->st_*time (but note that's not available on the * Windows of 1995) */ DWORD r; if (USING_WIDE()) { - r = GetFileAttributesW(wbuffer); + r = GetFileAttributesW(pwbuffer); } else { r = GetFileAttributesA(path); } if (r != 0xffffffff && (r & FILE_ATTRIBUTE_DIRECTORY)) { - /* buffer may still contain old garbage since stat() failed */ - Zero(buffer, 1, struct stat); - buffer->st_mode = S_IFDIR | S_IREAD; + /* sbuf may still contain old garbage since stat() failed */ + Zero(sbuf, 1, struct stat); + sbuf->st_mode = S_IFDIR | S_IREAD; errno = 0; if (!(r & FILE_ATTRIBUTE_READONLY)) - buffer->st_mode |= S_IWRITE | S_IEXEC; + sbuf->st_mode |= S_IWRITE | S_IEXEC; return 0; } } @@ -1117,28 +1147,32 @@ win32_stat(const char *path, struct stat *buffer) { /* The drive can be inaccessible, some _stat()s are buggy */ if (USING_WIDE() - ? !GetVolumeInformationW(wbuffer,NULL,0,NULL,NULL,NULL,NULL,0) + ? !GetVolumeInformationW(pwbuffer,NULL,0,NULL,NULL,NULL,NULL,0) : !GetVolumeInformationA(path,NULL,0,NULL,NULL,NULL,NULL,0)) { errno = ENOENT; return -1; } } #ifdef __BORLANDC__ - if (S_ISDIR(buffer->st_mode)) - buffer->st_mode |= S_IWRITE | S_IEXEC; - else if (S_ISREG(buffer->st_mode)) { + if (S_ISDIR(sbuf->st_mode)) + sbuf->st_mode |= S_IWRITE | S_IEXEC; + else if (S_ISREG(sbuf->st_mode)) { + int perms; if (l >= 4 && path[l-4] == '.') { const char *e = path + l - 3; if (strnicmp(e,"exe",3) && strnicmp(e,"bat",3) && strnicmp(e,"com",3) && (IsWin95() || strnicmp(e,"cmd",3))) - buffer->st_mode &= ~S_IEXEC; + sbuf->st_mode &= ~S_IEXEC; else - buffer->st_mode |= S_IEXEC; + sbuf->st_mode |= S_IEXEC; } else - buffer->st_mode &= ~S_IEXEC; + sbuf->st_mode &= ~S_IEXEC; + /* Propagate permissions to _group_ and _others_ */ + perms = sbuf->st_mode & (S_IREAD|S_IWRITE|S_IEXEC); + sbuf->st_mode |= (perms>>3) | (perms>>6); } #endif } @@ -1228,7 +1262,7 @@ DllExport char * win32_getenv(const char *name) { dTHXo; - WCHAR wBuffer[MAX_PATH]; + WCHAR wBuffer[MAX_PATH+1]; DWORD needlen; SV *curitem = Nullsv; @@ -1392,23 +1426,28 @@ win32_unlink(const char *filename) DWORD attrs; if (USING_WIDE()) { - WCHAR wBuffer[MAX_PATH]; + WCHAR wBuffer[MAX_PATH+1]; + WCHAR* pwBuffer; A2WHELPER(filename, wBuffer, sizeof(wBuffer)); - wcscpy(wBuffer, PerlDir_mapW(wBuffer)); - attrs = GetFileAttributesW(wBuffer); + pwBuffer = PerlDir_mapW(wBuffer); + attrs = GetFileAttributesW(pwBuffer); + if (attrs == 0xFFFFFFFF) + goto fail; if (attrs & FILE_ATTRIBUTE_READONLY) { - (void)SetFileAttributesW(wBuffer, attrs & ~FILE_ATTRIBUTE_READONLY); - ret = _wunlink(wBuffer); + (void)SetFileAttributesW(pwBuffer, attrs & ~FILE_ATTRIBUTE_READONLY); + ret = _wunlink(pwBuffer); if (ret == -1) - (void)SetFileAttributesW(wBuffer, attrs); + (void)SetFileAttributesW(pwBuffer, attrs); } else - ret = _wunlink(wBuffer); + ret = _wunlink(pwBuffer); } else { filename = PerlDir_mapA(filename); attrs = GetFileAttributesA(filename); + if (attrs == 0xFFFFFFFF) + goto fail; if (attrs & FILE_ATTRIBUTE_READONLY) { (void)SetFileAttributesA(filename, attrs & ~FILE_ATTRIBUTE_READONLY); ret = unlink(filename); @@ -1419,6 +1458,9 @@ win32_unlink(const char *filename) ret = unlink(filename); } return ret; +fail: + errno = ENOENT; + return -1; } DllExport int @@ -1430,13 +1472,14 @@ win32_utime(const char *filename, struct utimbuf *times) FILETIME ftAccess; FILETIME ftWrite; struct utimbuf TimeBuffer; - WCHAR wbuffer[MAX_PATH]; + WCHAR wbuffer[MAX_PATH+1]; + WCHAR* pwbuffer; int rc; if (USING_WIDE()) { A2WHELPER(filename, wbuffer, sizeof(wbuffer)); - wcscpy(wbuffer, PerlDir_mapW(wbuffer)); - rc = _wutime(wbuffer, (struct _utimbuf*)times); + pwbuffer = PerlDir_mapW(wbuffer); + rc = _wutime(pwbuffer, (struct _utimbuf*)times); } else { filename = PerlDir_mapA(filename); @@ -1454,7 +1497,7 @@ win32_utime(const char *filename, struct utimbuf *times) /* This will (and should) still fail on readonly files */ if (USING_WIDE()) { - handle = CreateFileW(wbuffer, GENERIC_READ | GENERIC_WRITE, + handle = CreateFileW(pwbuffer, GENERIC_READ | GENERIC_WRITE, FILE_SHARE_READ | FILE_SHARE_DELETE, NULL, OPEN_EXISTING, FILE_FLAG_BACKUP_SEMANTICS, NULL); } @@ -1683,6 +1726,8 @@ FAILED: return -1; } +#ifndef PERL_OBJECT + static UINT timerid = 0; static VOID CALLBACK TimerProc(HWND win, UINT msg, UINT id, DWORD time) @@ -1692,10 +1737,12 @@ static VOID CALLBACK TimerProc(HWND win, UINT msg, UINT id, DWORD time) timerid=0; sighandler(14); } +#endif /* !PERL_OBJECT */ DllExport unsigned int win32_alarm(unsigned int sec) { +#ifndef PERL_OBJECT /* * the 'obvious' implentation is SetTimer() with a callback * which does whatever receiving SIGALRM would do @@ -1720,6 +1767,7 @@ win32_alarm(unsigned int sec) timerid=0; } } +#endif /* !PERL_OBJECT */ return 0; } @@ -1740,53 +1788,71 @@ win32_crypt(const char *txt, const char *salt) #endif } -#ifdef USE_FIXED_OSFHANDLE +/* C doesn't like repeat struct definitions */ + +#if defined(USE_FIXED_OSFHANDLE) || defined(PERL_MSVCRT_READFIX) -EXTERN_C int __cdecl _alloc_osfhnd(void); -EXTERN_C int __cdecl _set_osfhnd(int fh, long value); -EXTERN_C void __cdecl _lock_fhandle(int); -EXTERN_C void __cdecl _unlock_fhandle(int); -EXTERN_C void __cdecl _unlock(int); +#ifndef _CRTIMP +#define _CRTIMP __declspec(dllimport) +#endif -#if (_MSC_VER >= 1000) -typedef struct { +/* + * Control structure for lowio file handles + */ +typedef struct { long osfhnd; /* underlying OS file HANDLE */ char osfile; /* attributes of file (e.g., open in text mode?) */ char pipech; /* one char buffer for handles opened on pipes */ -#if defined (_MT) && !defined (DLL_FOR_WIN32S) int lockinitflag; CRITICAL_SECTION lock; -#endif /* defined (_MT) && !defined (DLL_FOR_WIN32S) */ -} ioinfo; +} ioinfo; -EXTERN_C ioinfo * __pioinfo[]; -#define IOINFO_L2E 5 -#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E) -#define _pioinfo(i) (__pioinfo[i >> IOINFO_L2E] + (i & (IOINFO_ARRAY_ELTS - 1))) -#define _osfile(i) (_pioinfo(i)->osfile) +/* + * Array of arrays of control structures for lowio files. + */ +EXTERN_C _CRTIMP ioinfo* __pioinfo[]; -#else /* (_MSC_VER >= 1000) */ -extern char _osfile[]; -#endif /* (_MSC_VER >= 1000) */ +/* + * Definition of IOINFO_L2E, the log base 2 of the number of elements in each + * array of ioinfo structs. + */ +#define IOINFO_L2E 5 + +/* + * Definition of IOINFO_ARRAY_ELTS, the number of elements in ioinfo array + */ +#define IOINFO_ARRAY_ELTS (1 << IOINFO_L2E) + +/* + * Access macros for getting at an ioinfo struct and its fields from a + * file handle + */ +#define _pioinfo(i) (__pioinfo[(i) >> IOINFO_L2E] + ((i) & (IOINFO_ARRAY_ELTS - 1))) +#define _osfhnd(i) (_pioinfo(i)->osfhnd) +#define _osfile(i) (_pioinfo(i)->osfile) +#define _pipech(i) (_pioinfo(i)->pipech) + +#endif + +#ifdef USE_FIXED_OSFHANDLE #define FOPEN 0x01 /* file handle open */ +#define FNOINHERIT 0x10 /* file handle opened O_NOINHERIT */ #define FAPPEND 0x20 /* file handle opened O_APPEND */ #define FDEV 0x40 /* file handle refers to device */ #define FTEXT 0x80 /* file handle is in text mode */ -#define _STREAM_LOCKS 26 /* Table of stream locks */ -#define _LAST_STREAM_LOCK (_STREAM_LOCKS+_NSTREAM_-1) /* Last stream lock */ -#define _FH_LOCKS (_LAST_STREAM_LOCK+1) /* Table of fh locks */ - /*** *int my_open_osfhandle(long osfhandle, int flags) - open C Runtime file handle * *Purpose: * This function allocates a free C Runtime file handle and associates * it with the Win32 HANDLE specified by the first parameter. This is a -* temperary fix for WIN95's brain damage GetFileType() error on socket -* we just bypass that call for socket +* temperary fix for WIN95's brain damage GetFileType() error on socket +* we just bypass that call for socket +* +* This works with MSVC++ 4.0+ or GCC/Mingw32 * *Entry: * long osfhandle - Win32 HANDLE to associate with C Runtime file handle. @@ -1800,6 +1866,31 @@ extern char _osfile[]; * *******************************************************************************/ +/* + * we fake up some parts of the CRT that aren't exported by MSVCRT.dll + * this lets sockets work on Win9X with GCC and should fix the problems + * with perl95.exe + * -- BKS, 1-23-2000 +*/ + +/* since we are not doing a dup2(), this works fine */ + +#define _set_osfhnd(fh, osfh) (void)(_osfhnd(fh) = osfh) + +/* create an ioinfo entry, kill its handle, and steal the entry */ + +static int +_alloc_osfhnd(void) +{ + HANDLE hF = CreateFile("NUL", 0, 0, NULL, OPEN_ALWAYS, 0, NULL); + int fh = _open_osfhandle((long)hF, 0); + CloseHandle(hF); + if (fh == -1) + return fh; + EnterCriticalSection(&(_pioinfo(fh)->lock)); + return fh; +} + static int my_open_osfhandle(long osfhandle, int flags) { @@ -1815,6 +1906,9 @@ my_open_osfhandle(long osfhandle, int flags) if (flags & O_TEXT) fileflags |= FTEXT; + if (flags & O_NOINHERIT) + fileflags |= FNOINHERIT; + /* attempt to allocate a C Runtime file handle */ if ((fh = _alloc_osfhnd()) == -1) { errno = EMFILE; /* too many open files */ @@ -1827,18 +1921,12 @@ my_open_osfhandle(long osfhandle, int flags) fileflags |= FOPEN; /* mark as open */ -#if (_MSC_VER >= 1000) _osfile(fh) = fileflags; /* set osfile entry */ - _unlock_fhandle(fh); -#else - _osfile[fh] = fileflags; /* set osfile entry */ - _unlock(fh+_FH_LOCKS); /* unlock handle */ -#endif + LeaveCriticalSection(&_pioinfo(fh)->lock); return fh; /* return handle */ } -#define _open_osfhandle my_open_osfhandle #endif /* USE_FIXED_OSFHANDLE */ /* simulate flock by locking a range on the file */ @@ -2048,7 +2136,8 @@ DllExport FILE * win32_fopen(const char *filename, const char *mode) { dTHXo; - WCHAR wMode[MODE_SIZE], wBuffer[MAX_PATH]; + WCHAR wMode[MODE_SIZE], wBuffer[MAX_PATH+1]; + FILE *f; if (!*filename) return NULL; @@ -2059,9 +2148,14 @@ win32_fopen(const char *filename, const char *mode) if (USING_WIDE()) { A2WHELPER(mode, wMode, sizeof(wMode)); A2WHELPER(filename, wBuffer, sizeof(wBuffer)); - return _wfopen(PerlDir_mapW(wBuffer), wMode); + f = _wfopen(PerlDir_mapW(wBuffer), wMode); } - return fopen(PerlDir_mapA(filename), mode); + else + f = fopen(PerlDir_mapA(filename), mode); + /* avoid buffering headaches for child processes */ + if (f && *mode == 'a') + win32_fseek(f, 0, SEEK_END); + return f; } #ifndef USE_SOCKETS_AS_HANDLES @@ -2074,18 +2168,24 @@ win32_fdopen(int handle, const char *mode) { dTHXo; WCHAR wMode[MODE_SIZE]; + FILE *f; if (USING_WIDE()) { A2WHELPER(mode, wMode, sizeof(wMode)); - return _wfdopen(handle, wMode); + f = _wfdopen(handle, wMode); } - return fdopen(handle, (char *) mode); + else + f = fdopen(handle, (char *) mode); + /* avoid buffering headaches for child processes */ + if (f && *mode == 'a') + win32_fseek(f, 0, SEEK_END); + return f; } DllExport FILE * win32_freopen(const char *path, const char *mode, FILE *stream) { dTHXo; - WCHAR wMode[MODE_SIZE], wBuffer[MAX_PATH]; + WCHAR wMode[MODE_SIZE], wBuffer[MAX_PATH+1]; if (stricmp(path, "/dev/null")==0) path = "NUL"; @@ -2391,11 +2491,11 @@ win32_link(const char *oldname, const char *newname) { dTHXo; BOOL (__stdcall *pfnCreateHardLinkW)(LPCWSTR,LPCWSTR,LPSECURITY_ATTRIBUTES); - WCHAR wOldName[MAX_PATH]; - WCHAR wNewName[MAX_PATH]; + WCHAR wOldName[MAX_PATH+1]; + WCHAR wNewName[MAX_PATH+1]; if (IsWin95()) - Perl_die(aTHX_ PL_no_func, "link"); + Perl_croak(aTHX_ PL_no_func, "link"); pfnCreateHardLinkW = (BOOL (__stdcall *)(LPCWSTR, LPCWSTR, LPSECURITY_ATTRIBUTES)) @@ -2417,26 +2517,31 @@ win32_link(const char *oldname, const char *newname) DllExport int win32_rename(const char *oname, const char *newname) { - WCHAR wOldName[MAX_PATH]; - WCHAR wNewName[MAX_PATH]; - char szOldName[MAX_PATH]; + WCHAR wOldName[MAX_PATH+1]; + WCHAR wNewName[MAX_PATH+1]; + char szOldName[MAX_PATH+1]; + char szNewName[MAX_PATH+1]; BOOL bResult; + dTHXo; + /* XXX despite what the documentation says about MoveFileEx(), * it doesn't work under Windows95! */ if (IsWinNT()) { - dTHXo; + DWORD dwFlags = MOVEFILE_COPY_ALLOWED; if (USING_WIDE()) { A2WHELPER(oname, wOldName, sizeof(wOldName)); A2WHELPER(newname, wNewName, sizeof(wNewName)); + if (wcsicmp(wNewName, wOldName)) + dwFlags |= MOVEFILE_REPLACE_EXISTING; wcscpy(wOldName, PerlDir_mapW(wOldName)); - bResult = MoveFileExW(wOldName,PerlDir_mapW(wNewName), - MOVEFILE_COPY_ALLOWED|MOVEFILE_REPLACE_EXISTING); + bResult = MoveFileExW(wOldName,PerlDir_mapW(wNewName), dwFlags); } else { - strcpy(szOldName, PerlDir_mapA(szOldName)); - bResult = MoveFileExA(szOldName,PerlDir_mapA(newname), - MOVEFILE_COPY_ALLOWED|MOVEFILE_REPLACE_EXISTING); + if (stricmp(newname, oname)) + dwFlags |= MOVEFILE_REPLACE_EXISTING; + strcpy(szOldName, PerlDir_mapA(oname)); + bResult = MoveFileExA(szOldName,PerlDir_mapA(newname), dwFlags); } if (!bResult) { DWORD err = GetLastError(); @@ -2461,14 +2566,17 @@ win32_rename(const char *oname, const char *newname) } else { int retval = 0; - char tmpname[MAX_PATH+1]; + char szTmpName[MAX_PATH+1]; char dname[MAX_PATH+1]; char *endname = Nullch; STRLEN tmplen = 0; DWORD from_attr, to_attr; + strcpy(szOldName, PerlDir_mapA(oname)); + strcpy(szNewName, PerlDir_mapA(newname)); + /* if oname doesn't exist, do nothing */ - from_attr = GetFileAttributes(oname); + from_attr = GetFileAttributes(szOldName); if (from_attr == 0xFFFFFFFF) { errno = ENOENT; return -1; @@ -2478,7 +2586,7 @@ win32_rename(const char *oname, const char *newname) * don't delete it in case oname happens to be the same file * (but perhaps accessed via a different path) */ - to_attr = GetFileAttributes(newname); + to_attr = GetFileAttributes(szNewName); if (to_attr != 0xFFFFFFFF) { /* if newname is a directory, we fail * XXX could overcome this with yet more convoluted logic */ @@ -2486,29 +2594,29 @@ win32_rename(const char *oname, const char *newname) errno = EACCES; return -1; } - tmplen = strlen(newname); - strcpy(tmpname,newname); - endname = tmpname+tmplen; - for (; endname > tmpname ; --endname) { + tmplen = strlen(szNewName); + strcpy(szTmpName,szNewName); + endname = szTmpName+tmplen; + for (; endname > szTmpName ; --endname) { if (*endname == '/' || *endname == '\\') { *endname = '\0'; break; } } - if (endname > tmpname) - endname = strcpy(dname,tmpname); + if (endname > szTmpName) + endname = strcpy(dname,szTmpName); else endname = "."; /* get a temporary filename in same directory * XXX is this really the best we can do? */ - if (!GetTempFileName((LPCTSTR)endname, "plr", 0, tmpname)) { + if (!GetTempFileName((LPCTSTR)endname, "plr", 0, szTmpName)) { errno = ENOENT; return -1; } - DeleteFile(tmpname); + DeleteFile(szTmpName); - retval = rename(newname, tmpname); + retval = rename(szNewName, szTmpName); if (retval != 0) { errno = EACCES; return retval; @@ -2516,16 +2624,16 @@ win32_rename(const char *oname, const char *newname) } /* rename oname to newname */ - retval = rename(oname, newname); + retval = rename(szOldName, szNewName); /* if we created a temporary file before ... */ if (endname != Nullch) { /* ...and rename succeeded, delete temporary file/directory */ if (retval == 0) - DeleteFile(tmpname); + DeleteFile(szTmpName); /* else restore it to what it was */ else - (void)rename(tmpname, newname); + (void)rename(szTmpName, szNewName); } return retval; } @@ -2555,7 +2663,7 @@ win32_open(const char *path, int flag, ...) dTHXo; va_list ap; int pmode; - WCHAR wBuffer[MAX_PATH]; + WCHAR wBuffer[MAX_PATH+1]; va_start(ap, flag); pmode = va_arg(ap, int); @@ -2595,10 +2703,210 @@ win32_dup2(int fd1,int fd2) return dup2(fd1,fd2); } +#ifdef PERL_MSVCRT_READFIX + +#define LF 10 /* line feed */ +#define CR 13 /* carriage return */ +#define CTRLZ 26 /* ctrl-z means eof for text */ +#define FOPEN 0x01 /* file handle open */ +#define FEOFLAG 0x02 /* end of file has been encountered */ +#define FCRLF 0x04 /* CR-LF across read buffer (in text mode) */ +#define FPIPE 0x08 /* file handle refers to a pipe */ +#define FAPPEND 0x20 /* file handle opened O_APPEND */ +#define FDEV 0x40 /* file handle refers to device */ +#define FTEXT 0x80 /* file handle is in text mode */ +#define MAX_DESCRIPTOR_COUNT (64*32) /* this is the maximun that MSVCRT can handle */ + +int __cdecl +_fixed_read(int fh, void *buf, unsigned cnt) +{ + int bytes_read; /* number of bytes read */ + char *buffer; /* buffer to read to */ + int os_read; /* bytes read on OS call */ + char *p, *q; /* pointers into buffer */ + char peekchr; /* peek-ahead character */ + ULONG filepos; /* file position after seek */ + ULONG dosretval; /* o.s. return value */ + + /* validate handle */ + if (((unsigned)fh >= (unsigned)MAX_DESCRIPTOR_COUNT) || + !(_osfile(fh) & FOPEN)) + { + /* out of range -- return error */ + errno = EBADF; + _doserrno = 0; /* not o.s. error */ + return -1; + } + + /* + * If lockinitflag is FALSE, assume fd is device + * lockinitflag is set to TRUE by open. + */ + if (_pioinfo(fh)->lockinitflag) + EnterCriticalSection(&(_pioinfo(fh)->lock)); /* lock file */ + + bytes_read = 0; /* nothing read yet */ + buffer = (char*)buf; + + if (cnt == 0 || (_osfile(fh) & FEOFLAG)) { + /* nothing to read or at EOF, so return 0 read */ + goto functionexit; + } + + if ((_osfile(fh) & (FPIPE|FDEV)) && _pipech(fh) != LF) { + /* a pipe/device and pipe lookahead non-empty: read the lookahead + * char */ + *buffer++ = _pipech(fh); + ++bytes_read; + --cnt; + _pipech(fh) = LF; /* mark as empty */ + } + + /* read the data */ + + if (!ReadFile((HANDLE)_osfhnd(fh), buffer, cnt, (LPDWORD)&os_read, NULL)) + { + /* ReadFile has reported an error. recognize two special cases. + * + * 1. map ERROR_ACCESS_DENIED to EBADF + * + * 2. just return 0 if ERROR_BROKEN_PIPE has occurred. it + * means the handle is a read-handle on a pipe for which + * all write-handles have been closed and all data has been + * read. */ + + if ((dosretval = GetLastError()) == ERROR_ACCESS_DENIED) { + /* wrong read/write mode should return EBADF, not EACCES */ + errno = EBADF; + _doserrno = dosretval; + bytes_read = -1; + goto functionexit; + } + else if (dosretval == ERROR_BROKEN_PIPE) { + bytes_read = 0; + goto functionexit; + } + else { + bytes_read = -1; + goto functionexit; + } + } + + bytes_read += os_read; /* update bytes read */ + + if (_osfile(fh) & FTEXT) { + /* now must translate CR-LFs to LFs in the buffer */ + + /* set CRLF flag to indicate LF at beginning of buffer */ + /* if ((os_read != 0) && (*(char *)buf == LF)) */ + /* _osfile(fh) |= FCRLF; */ + /* else */ + /* _osfile(fh) &= ~FCRLF; */ + + _osfile(fh) &= ~FCRLF; + + /* convert chars in the buffer: p is src, q is dest */ + p = q = (char*)buf; + while (p < (char *)buf + bytes_read) { + if (*p == CTRLZ) { + /* if fh is not a device, set ctrl-z flag */ + if (!(_osfile(fh) & FDEV)) + _osfile(fh) |= FEOFLAG; + break; /* stop translating */ + } + else if (*p != CR) + *q++ = *p++; + else { + /* *p is CR, so must check next char for LF */ + if (p < (char *)buf + bytes_read - 1) { + if (*(p+1) == LF) { + p += 2; + *q++ = LF; /* convert CR-LF to LF */ + } + else + *q++ = *p++; /* store char normally */ + } + else { + /* This is the hard part. We found a CR at end of + buffer. We must peek ahead to see if next char + is an LF. */ + ++p; + + dosretval = 0; + if (!ReadFile((HANDLE)_osfhnd(fh), &peekchr, 1, + (LPDWORD)&os_read, NULL)) + dosretval = GetLastError(); + + if (dosretval != 0 || os_read == 0) { + /* couldn't read ahead, store CR */ + *q++ = CR; + } + else { + /* peekchr now has the extra character -- we now + have several possibilities: + 1. disk file and char is not LF; just seek back + and copy CR + 2. disk file and char is LF; store LF, don't seek back + 3. pipe/device and char is LF; store LF. + 4. pipe/device and char isn't LF, store CR and + put char in pipe lookahead buffer. */ + if (_osfile(fh) & (FDEV|FPIPE)) { + /* non-seekable device */ + if (peekchr == LF) + *q++ = LF; + else { + *q++ = CR; + _pipech(fh) = peekchr; + } + } + else { + /* disk file */ + if (peekchr == LF) { + /* nothing read yet; must make some + progress */ + *q++ = LF; + /* turn on this flag for tell routine */ + _osfile(fh) |= FCRLF; + } + else { + HANDLE osHandle; /* o.s. handle value */ + /* seek back */ + if ((osHandle = (HANDLE)_get_osfhandle(fh)) != (HANDLE)-1) + { + if ((filepos = SetFilePointer(osHandle, -1, NULL, FILE_CURRENT)) == -1) + dosretval = GetLastError(); + } + if (peekchr != LF) + *q++ = CR; + } + } + } + } + } + } + + /* we now change bytes_read to reflect the true number of chars + in the buffer */ + bytes_read = q - (char *)buf; + } + +functionexit: + if (_pioinfo(fh)->lockinitflag) + LeaveCriticalSection(&(_pioinfo(fh)->lock)); /* unlock file */ + + return bytes_read; +} + +#endif /* PERL_MSVCRT_READFIX */ + DllExport int win32_read(int fd, void *buf, unsigned int cnt) { +#ifdef PERL_MSVCRT_READFIX + return _fixed_read(fd, buf, cnt); +#else return read(fd, buf, cnt); +#endif } DllExport int @@ -2612,7 +2920,7 @@ win32_mkdir(const char *dir, int mode) { dTHXo; if (USING_WIDE()) { - WCHAR wBuffer[MAX_PATH]; + WCHAR wBuffer[MAX_PATH+1]; A2WHELPER(dir, wBuffer, sizeof(wBuffer)); return _wmkdir(PerlDir_mapW(wBuffer)); } @@ -2624,7 +2932,7 @@ win32_rmdir(const char *dir) { dTHXo; if (USING_WIDE()) { - WCHAR wBuffer[MAX_PATH]; + WCHAR wBuffer[MAX_PATH+1]; A2WHELPER(dir, wBuffer, sizeof(wBuffer)); return _wrmdir(PerlDir_mapW(wBuffer)); } @@ -2636,7 +2944,7 @@ win32_chdir(const char *dir) { dTHXo; if (USING_WIDE()) { - WCHAR wBuffer[MAX_PATH]; + WCHAR wBuffer[MAX_PATH+1]; A2WHELPER(dir, wBuffer, sizeof(wBuffer)); return _wchdir(wBuffer); } @@ -2648,7 +2956,7 @@ win32_access(const char *path, int mode) { dTHXo; if (USING_WIDE()) { - WCHAR wBuffer[MAX_PATH]; + WCHAR wBuffer[MAX_PATH+1]; A2WHELPER(path, wBuffer, sizeof(wBuffer)); return _waccess(PerlDir_mapW(wBuffer), mode); } @@ -2660,7 +2968,7 @@ win32_chmod(const char *path, int mode) { dTHXo; if (USING_WIDE()) { - WCHAR wBuffer[MAX_PATH]; + WCHAR wBuffer[MAX_PATH+1]; A2WHELPER(path, wBuffer, sizeof(wBuffer)); return _wchmod(PerlDir_mapW(wBuffer), mode); } @@ -2846,6 +3154,7 @@ win32_spawnvp(int mode, const char *cmdname, const char *const *argv) int ret; void* env; char* dir; + child_IO_table tbl; STARTUPINFO StartupInfo; PROCESS_INFORMATION ProcessInformation; DWORD create = 0; @@ -2874,9 +3183,10 @@ win32_spawnvp(int mode, const char *cmdname, const char *const *argv) } memset(&StartupInfo,0,sizeof(StartupInfo)); StartupInfo.cb = sizeof(StartupInfo); - StartupInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE); - StartupInfo.hStdOutput = GetStdHandle(STD_OUTPUT_HANDLE); - StartupInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE); + PerlEnv_get_child_IO(&tbl); + StartupInfo.hStdInput = tbl.childStdIn; + StartupInfo.hStdOutput = tbl.childStdOut; + StartupInfo.hStdError = tbl.childStdErr; if (StartupInfo.hStdInput != INVALID_HANDLE_VALUE && StartupInfo.hStdOutput != INVALID_HANDLE_VALUE && StartupInfo.hStdError != INVALID_HANDLE_VALUE) @@ -3148,6 +3458,10 @@ win32_free(void *block) int win32_open_osfhandle(long handle, int flags) { +#ifdef USE_FIXED_OSFHANDLE + if (IsWin95()) + return my_open_osfhandle(handle, flags); +#endif return _open_osfhandle(handle, flags); } @@ -3163,7 +3477,7 @@ win32_dynaload(const char* filename) dTHXo; HMODULE hModule; if (USING_WIDE()) { - WCHAR wfilename[MAX_PATH]; + WCHAR wfilename[MAX_PATH+1]; A2WHELPER(filename, wfilename, sizeof(wfilename)); hModule = LoadLibraryExW(PerlDir_mapW(wfilename), NULL, LOAD_WITH_ALTERED_SEARCH_PATH); } @@ -3597,15 +3911,15 @@ XS(w32_CopyFile) if (items != 3) Perl_croak(aTHX_ "usage: Win32::CopyFile($from, $to, $overwrite)"); if (USING_WIDE()) { - WCHAR wSourceFile[MAX_PATH]; - WCHAR wDestFile[MAX_PATH]; + WCHAR wSourceFile[MAX_PATH+1]; + WCHAR wDestFile[MAX_PATH+1]; A2WHELPER(SvPV_nolen(ST(0)), wSourceFile, sizeof(wSourceFile)); wcscpy(wSourceFile, PerlDir_mapW(wSourceFile)); A2WHELPER(SvPV_nolen(ST(1)), wDestFile, sizeof(wDestFile)); bResult = CopyFileW(wSourceFile, PerlDir_mapW(wDestFile), !SvTRUE(ST(2))); } else { - char szSourceFile[MAX_PATH]; + char szSourceFile[MAX_PATH+1]; strcpy(szSourceFile, PerlDir_mapA(SvPV_nolen(ST(0)))); bResult = CopyFileA(szSourceFile, PerlDir_mapA(SvPV_nolen(ST(1))), !SvTRUE(ST(2))); } @@ -3683,6 +3997,15 @@ Perl_win32_init(int *argcp, char ***argvp) MALLOC_INIT; } +void +win32_get_child_IO(child_IO_table* ptbl) +{ + ptbl->childStdIn = GetStdHandle(STD_INPUT_HANDLE); + ptbl->childStdOut = GetStdHandle(STD_OUTPUT_HANDLE); + ptbl->childStdErr = GetStdHandle(STD_ERROR_HANDLE); +} + + #ifdef USE_ITHREADS # ifdef PERL_OBJECT @@ -3706,3 +4029,37 @@ Perl_sys_intern_dup(pTHX_ struct interp_intern *src, struct interp_intern *dst) } #endif +#ifdef PERL_OBJECT +# undef this +# define this pPerl +#endif + +static void +win32_free_argvw(pTHXo_ void *ptr) +{ + char** argv = (char**)ptr; + while(*argv) { + Safefree(*argv); + *argv++ = Nullch; + } +} + +void +win32_argv2utf8(int argc, char** argv) +{ + dTHXo; + char* psz; + int length, wargc; + LPWSTR* lpwStr = CommandLineToArgvW(GetCommandLineW(), &wargc); + if (lpwStr && argc) { + while (argc--) { + length = WideCharToMultiByte(CP_UTF8, 0, lpwStr[--wargc], -1, NULL, 0, NULL, NULL); + Newz(0, psz, length, char); + WideCharToMultiByte(CP_UTF8, 0, lpwStr[wargc], -1, psz, length, NULL, NULL); + argv[argc] = psz; + } + call_atexit(win32_free_argvw, argv); + } + GlobalFree((HGLOBAL)lpwStr); +} +