X-Git-Url: https://git.sur5r.net/?a=blobdiff_plain;f=bacula%2Fsrc%2Fwin32%2Fcompat%2Fcompat.cpp;h=96c21319601df516948bf35a5e43098ab0e8d7ed;hb=03996a10212efd150de1a8509830f87e10b9bd7f;hp=ae453305648c30d3ba58705489f0a3bb3843d945;hpb=8a7a790185ea19f2ba6374e6203420b5c0cea2ce;p=bacula%2Fbacula diff --git a/bacula/src/win32/compat/compat.cpp b/bacula/src/win32/compat/compat.cpp index ae45330564..96c2131960 100644 --- a/bacula/src/win32/compat/compat.cpp +++ b/bacula/src/win32/compat/compat.cpp @@ -1,9 +1,12 @@ -// -*- Mode: C++ -*- +// -*- Mode: C++ -*- // compat.cpp -- compatibilty layer to make bacula-fd run // natively under windows // -// Copyright (C)2004 Raider Solutions, Inc -// +// Copyright transferred from Raider Solutions, Inc to +// Kern Sibbald and John Walker by express permission. +// +// Copyright (C) 2004-2005 Kern Sibbald +// // This program 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 @@ -21,30 +24,41 @@ // // Author : Christopher S. Hull // Created On : Sat Jan 31 15:55:00 2004 -// Last Modified By: Christopher S. Hull -// Last Modified On: Tue Feb 24 11:27:33 2004 -// Update Count : 665 // $Id$ #include #include "compat.h" +#ifdef WIN32_VSS +#include "vss.h" +#endif #include "pthread.h" +#include "../../lib/winapi.h" + +/* to allow the usage of the original version in this file here */ +#undef fputs + +#define b_errno_win32 (1<<29) #define USE_WIN32_COMPAT_IO 1 extern void d_msg(const char *file, int line, int level, const char *fmt,...); extern DWORD g_platform_id; -// from CYGWIN (should be diff between Jan 1 1601 and Jan 1 1970 +// from MicroSoft SDK (KES) is the diff between Jan 1 1601 and Jan 1 1970 +#ifdef HAVE_MINGW +#define WIN32_FILETIME_ADJUST 0x19DB1DED53E8000UL //Not sure it works +#else #define WIN32_FILETIME_ADJUST 0x19DB1DED53E8000I64 +#endif #define WIN32_FILETIME_SCALE 10000000 // 100ns/second extern "C" void -cygwin_conv_to_win32_path(const char *name, char *win32_name) +cygwin_conv_to_win32_path(const char *name, char *win32_name, DWORD dwSize) { const char *fname = name; + char *tname = win32_name; while (*name) { /* Check for Unix separator and convert to Win32 */ if (*name == '/') { @@ -64,6 +78,37 @@ cygwin_conv_to_win32_path(const char *name, char *win32_name) } else { *win32_name = 0; } + +#ifdef WIN32_VSS + /* here we convert to VSS specific file name */ + char szFile[MAX_PATH_UNICODE]; + strncpy (szFile, tname, MAX_PATH_UNICODE-1); + g_VSSClient.GetShadowPath(szFile,tname,dwSize); +#endif +} + +int +wchar_2_UTF8(char *pszUTF, const WCHAR *pszUCS, int cchChar) +{ + /* the return value is the number of bytes written to the buffer. + The number includes the byte for the null terminator. */ + + if (p_WideCharToMultiByte) + return p_WideCharToMultiByte(CP_UTF8,0,pszUCS,-1,pszUTF,cchChar,NULL,NULL); + else + return NULL; +} + +int +UTF8_2_wchar(WCHAR *pszUCS, const char *pszUTF, int cchWideChar) +{ + /* the return value is the number of wide characters written to the buffer. */ + /* convert null terminated string from utf-8 to ucs2*/ + + if (p_MultiByteToWideChar) + return p_MultiByteToWideChar(CP_UTF8, 0, pszUTF, -1, pszUCS,cchWideChar); + else + return NULL; } @@ -92,30 +137,32 @@ wchar_win32_path(const char *name, WCHAR *win32_name) } } -int -umask(int) +int umask(int) { - return 0; + return 0; } -int -chmod(const char *, mode_t) +int chmod(const char *, mode_t) { - return 0; + return 0; } -int -chown(const char *k, uid_t, gid_t) +int chown(const char *k, uid_t, gid_t) { - return 0; + return 0; } -int -lchown(const char *k, uid_t, gid_t) +int lchown(const char *k, uid_t, gid_t) { - return 0; + return 0; } +#ifdef needed +bool fstype(const char *fname, char *fs, int fslen) +{ + return true; /* accept anything */ +} +#endif long int @@ -127,7 +174,7 @@ random(void) void srandom(unsigned int seed) { - srand(seed); + srand(seed); } // ///////////////////////////////////////////////////////////////// // convert from Windows concept of time to Unix concept of time @@ -139,7 +186,11 @@ cvt_utime_to_ftime(const time_t &time, FILETIME &wintime) mstime *= WIN32_FILETIME_SCALE; mstime += WIN32_FILETIME_ADJUST; + #ifdef HAVE_MINGW + wintime.dwLowDateTime = (DWORD)(mstime & 0xffffffffUL); + #else wintime.dwLowDateTime = (DWORD)(mstime & 0xffffffffI64); + #endif wintime.dwHighDateTime = (DWORD) ((mstime>>32)& 0xffffffffUL); } @@ -159,27 +210,38 @@ cvt_ftime_to_utime(const FILETIME &time) static const char * errorString(void) { - LPVOID lpMsgBuf; - - FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | - FORMAT_MESSAGE_FROM_SYSTEM | - FORMAT_MESSAGE_IGNORE_INSERTS, - NULL, - GetLastError(), - MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default lang - (LPTSTR) &lpMsgBuf, - 0, - NULL); - - return (const char *) lpMsgBuf; + LPVOID lpMsgBuf; + + FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | + FORMAT_MESSAGE_FROM_SYSTEM | + FORMAT_MESSAGE_IGNORE_INSERTS, + NULL, + GetLastError(), + MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), // Default lang + (LPTSTR) &lpMsgBuf, + 0, + NULL); + + return (const char *) lpMsgBuf; } +#ifndef HAVE_MINGW + static int statDir(const char *file, struct stat *sb) { - WIN32_FIND_DATA info; // window's file info - - if (file[1] == ':' && file[2] == 0) { + WIN32_FIND_DATAW info_w; // window's file info + WIN32_FIND_DATAA info_a; // window's file info + + // cache some common vars to make code more transparent + DWORD* pdwFileAttributes; + DWORD* pnFileSizeHigh; + DWORD* pnFileSizeLow; + FILETIME* pftLastAccessTime; + FILETIME* pftLastWriteTime; + FILETIME* pftCreationTime; + + if (file[1] == ':' && file[2] == 0) { d_msg(__FILE__, __LINE__, 99, "faking ROOT attrs(%s).\n", file); sb->st_mode = S_IFDIR; sb->st_mode |= S_IREAD|S_IEXEC|S_IWRITE; @@ -188,34 +250,60 @@ statDir(const char *file, struct stat *sb) time(&sb->st_atime); return 0; } - HANDLE h = FindFirstFile(file, &info); + + HANDLE h = INVALID_HANDLE_VALUE; + + // use unicode or ascii + if (p_FindFirstFileW) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, file, MAX_PATH_UNICODE); + + h = p_FindFirstFileW(szBuf, &info_w); + + pdwFileAttributes = &info_w.dwFileAttributes; + pnFileSizeHigh = &info_w.nFileSizeHigh; + pnFileSizeLow = &info_w.nFileSizeLow; + pftLastAccessTime = &info_w.ftLastAccessTime; + pftLastWriteTime = &info_w.ftLastWriteTime; + pftCreationTime = &info_w.ftCreationTime; + } + else if (p_FindFirstFileA) { + h = p_FindFirstFileA(file, &info_a); + + pdwFileAttributes = &info_a.dwFileAttributes; + pnFileSizeHigh = &info_a.nFileSizeHigh; + pnFileSizeLow = &info_a.nFileSizeLow; + pftLastAccessTime = &info_a.ftLastAccessTime; + pftLastWriteTime = &info_a.ftLastWriteTime; + pftCreationTime = &info_a.ftCreationTime; + } if (h == INVALID_HANDLE_VALUE) { const char *err = errorString(); d_msg(__FILE__, __LINE__, 99, "FindFirstFile(%s):%s\n", file, err); LocalFree((void *)err); - errno = GetLastError(); + errno = b_errno_win32; return -1; } sb->st_mode = 0777; /* start with everything */ - if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) + if (*pdwFileAttributes & FILE_ATTRIBUTE_READONLY) sb->st_mode &= ~(S_IRUSR|S_IRGRP|S_IROTH); - if (info.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) + if (*pdwFileAttributes & FILE_ATTRIBUTE_SYSTEM) sb->st_mode &= ~S_IRWXO; /* remove everything for other */ - if (info.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) + if (*pdwFileAttributes & FILE_ATTRIBUTE_HIDDEN) sb->st_mode |= S_ISVTX; /* use sticky bit -> hidden */ sb->st_mode |= S_IFDIR; - sb->st_size = info.nFileSizeHigh; + sb->st_size = *pnFileSizeHigh; sb->st_size <<= 32; - sb->st_size |= info.nFileSizeLow; + sb->st_size |= *pnFileSizeLow; sb->st_blksize = 4096; sb->st_blocks = (uint32_t)(sb->st_size + 4095)/4096; - sb->st_atime = cvt_ftime_to_utime(info.ftLastAccessTime); - sb->st_mtime = cvt_ftime_to_utime(info.ftLastWriteTime); - sb->st_ctime = cvt_ftime_to_utime(info.ftLastWriteTime); + sb->st_atime = cvt_ftime_to_utime(*pftLastAccessTime); + sb->st_mtime = cvt_ftime_to_utime(*pftLastWriteTime); + sb->st_ctime = cvt_ftime_to_utime(*pftCreationTime); FindClose(h); return 0; @@ -228,23 +316,33 @@ stat2(const char *file, struct stat *sb) HANDLE h; int rval = 0; char tmpbuf[1024]; - cygwin_conv_to_win32_path(file, tmpbuf); + cygwin_conv_to_win32_path(file, tmpbuf, 1024); - DWORD attr = GetFileAttributes(tmpbuf); + DWORD attr = -1; + + if (p_GetFileAttributesW) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, tmpbuf, MAX_PATH_UNICODE); + + attr = p_GetFileAttributesW(szBuf); + } + else if (p_GetFileAttributesA) { + attr = p_GetFileAttributesA(tmpbuf); + } if (attr == -1) { const char *err = errorString(); d_msg(__FILE__, __LINE__, 99, "GetFileAttrubtes(%s): %s\n", tmpbuf, err); LocalFree((void *)err); - errno = GetLastError(); + errno = b_errno_win32; return -1; } - - if (attr & FILE_ATTRIBUTE_DIRECTORY) + + if (attr & FILE_ATTRIBUTE_DIRECTORY) return statDir(tmpbuf, sb); - h = CreateFile(tmpbuf, GENERIC_READ, + h = CreateFileA(tmpbuf, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, NULL); if (h == INVALID_HANDLE_VALUE) { @@ -253,25 +351,28 @@ stat2(const char *file, struct stat *sb) "Cannot open file for stat (%s):%s\n", tmpbuf, err); LocalFree((void *)err); rval = -1; - errno = GetLastError(); + errno = b_errno_win32; goto error; } - + if (!GetFileInformationByHandle(h, &info)) { const char *err = errorString(); d_msg(__FILE__, __LINE__, 99, "GetfileInformationByHandle(%s): %s\n", tmpbuf, err); LocalFree((void *)err); rval = -1; - errno = GetLastError(); + errno = b_errno_win32; goto error; } - + sb->st_dev = info.dwVolumeSerialNumber; sb->st_ino = info.nFileIndexHigh; sb->st_ino <<= 32; sb->st_ino |= info.nFileIndexLow; sb->st_nlink = (short)info.nNumberOfLinks; + if (sb->st_nlink > 1) { + d_msg(__FILE__, __LINE__, 99, "st_nlink=%d\n", sb->st_nlink); + } sb->st_mode = 0777; /* start with everything */ if (info.dwFileAttributes & FILE_ATTRIBUTE_READONLY) @@ -289,7 +390,7 @@ stat2(const char *file, struct stat *sb) sb->st_blocks = (uint32_t)(sb->st_size + 4095)/4096; sb->st_atime = cvt_ftime_to_utime(info.ftLastAccessTime); sb->st_mtime = cvt_ftime_to_utime(info.ftLastWriteTime); - sb->st_ctime = cvt_ftime_to_utime(info.ftLastWriteTime); + sb->st_ctime = cvt_ftime_to_utime(info.ftCreationTime); error: CloseHandle(h); @@ -321,10 +422,21 @@ stat(const char *file, struct stat *sb) if (!GetFileAttributesExW((WCHAR *)buf, GetFileExInfoStandard, &data)) return stat2(file, sb); #else - if (!GetFileAttributesEx(file, GetFileExInfoStandard, &data)) - return stat2(file, sb); + + if (p_GetFileAttributesExW) { + WCHAR buf[MAX_PATH_UNICODE]; + UTF8_2_wchar(buf, file, MAX_PATH_UNICODE); + if (!p_GetFileAttributesExW(buf, GetFileExInfoStandard, &data)) + return stat2(file, sb); + } else if (p_GetFileAttributesExA) { + if (!p_GetFileAttributesExA(file, GetFileExInfoStandard, &data)) + return stat2(file, sb); + } + else + return stat2(file, sb); + #endif - + sb->st_mode = 0777; /* start with everything */ if (data.dwFileAttributes & FILE_ATTRIBUTE_READONLY) sb->st_mode &= ~(S_IRUSR|S_IRGRP|S_IROTH); @@ -346,10 +458,12 @@ stat(const char *file, struct stat *sb) sb->st_blocks = (uint32_t)(sb->st_size + 4095)/4096; sb->st_atime = cvt_ftime_to_utime(data.ftLastAccessTime); sb->st_mtime = cvt_ftime_to_utime(data.ftLastWriteTime); - sb->st_ctime = cvt_ftime_to_utime(data.ftLastWriteTime); + sb->st_ctime = cvt_ftime_to_utime(data.ftCreationTime); return 0; } +#endif //HAVE_MINGW + int lstat(const char *file, struct stat *sb) { @@ -360,7 +474,7 @@ void sleep(int sec) { Sleep(sec * 1000); -} +} int geteuid(void) @@ -370,6 +484,7 @@ geteuid(void) int execvp(const char *, char *[]) { + errno = ENOSYS; return -1; } @@ -377,33 +492,38 @@ execvp(const char *, char *[]) { int fork(void) { + errno = ENOSYS; return -1; } int pipe(int[]) { + errno = ENOSYS; return -1; } int waitpid(int, int*, int) { + errno = ENOSYS; return -1; } int readlink(const char *, char *, int) { + errno = ENOSYS; return -1; } +#ifndef HAVE_MINGW int strcasecmp(const char *s1, const char *s2) { register int ch1, ch2; - + if (s1==s2) return 0; /* strings are equal if same object. */ else if (!s1) @@ -417,30 +537,32 @@ strcasecmp(const char *s1, const char *s2) s1++; s2++; } while (ch1 != 0 && tolower(ch1) == tolower(ch2)); - + return(ch1 - ch2); } +#endif //HAVE_MINGW int strncasecmp(const char *s1, const char *s2, int len) { register int ch1, ch2; - + if (s1==s2) return 0; /* strings are equal if same object. */ else if (!s1) return -1; else if (!s2) return 1; - do + while (len--) { ch1 = *s1; ch2 = *s2; s1++; s2++; - } while (len-- && ch1 != 0 && tolower(ch1) == tolower(ch2)); - - return(ch1 - ch2); + if (ch1 == 0 || tolower(ch1) != tolower(ch2)) break; + } + + return (ch1 - ch2); } int @@ -450,23 +572,32 @@ gettimeofday(struct timeval *tv, struct timezone *) FILETIME tmp; GetSystemTime(&now); - if (tv == NULL) return -1; - if (!SystemTimeToFileTime(&now, &tmp)) return -1; + if (tv == NULL) { + errno = EINVAL; + return -1; + } + if (!SystemTimeToFileTime(&now, &tmp)) { + errno = b_errno_win32; + return -1; + } int64_t _100nsec = tmp.dwHighDateTime; _100nsec <<= 32; _100nsec |= tmp.dwLowDateTime; _100nsec -= WIN32_FILETIME_ADJUST; - + tv->tv_sec =(long) (_100nsec / 10000000); tv->tv_usec = (long) ((_100nsec % 10000000)/10); return 0; - + } int -syslog(int, const char *, const char *) +syslog(int type, const char *fmt, const char *msg) { +/*#ifndef HAVE_CONSOLE + MessageBox(NULL, msg, "Bacula", MB_OK); +#endif*/ return 0; } @@ -482,29 +613,36 @@ getgrgid(uid_t) return NULL; } - // implement opendir/readdir/closedir on top of window's API + typedef struct _dir { - WIN32_FIND_DATA data; // window's file info + WIN32_FIND_DATAA data_a; // window's file info (ansii version) + WIN32_FIND_DATAW data_w; // window's file info (wchar version) const char *spec; // the directory we're traversing HANDLE dirh; // the search handle - BOOL valid; // the info in data field is valid + BOOL valid_a; // the info in data_a field is valid + BOOL valid_w; // the info in data_w field is valid UINT32 offset; // pseudo offset for d_off } _dir; DIR * opendir(const char *path) { - int max_len = strlen(path) + 16; + /* enough space for VSS !*/ + int max_len = strlen(path) + MAX_PATH; _dir *rval = NULL; - if (path == NULL) return NULL; - + if (path == NULL) { + errno = ENOENT; + return NULL; + } + rval = (_dir *)malloc(sizeof(_dir)); + memset (rval, 0, sizeof (_dir)); if (rval == NULL) return NULL; char *tspec = (char *)malloc(max_len); - if (tspec == NULL) goto err1; - + if (tspec == NULL) return NULL; + if (g_platform_id != VER_PLATFORM_WIN32_WINDOWS) { // allow path to be 32767 bytes tspec[0] = '\\'; @@ -512,14 +650,30 @@ opendir(const char *path) tspec[2] = '?'; tspec[3] = '\\'; tspec[4] = 0; - cygwin_conv_to_win32_path(path, tspec+4); + cygwin_conv_to_win32_path(path, tspec+4, max_len-4); } else { - cygwin_conv_to_win32_path(path, tspec); + cygwin_conv_to_win32_path(path, tspec, max_len); } + strncat(tspec, "\\*", max_len); rval->spec = tspec; - rval->dirh = FindFirstFile(rval->spec, &rval->data); + // convert to WCHAR + if (p_FindFirstFileW) { + WCHAR wcBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(wcBuf,rval->spec, MAX_PATH_UNICODE); + rval->dirh = p_FindFirstFileW(wcBuf, &rval->data_w); + + if (rval->dirh != INVALID_HANDLE_VALUE) + rval->valid_w = 1; + } else if (p_FindFirstFileA) { + rval->dirh = p_FindFirstFileA(rval->spec, &rval->data_a); + + if (rval->dirh != INVALID_HANDLE_VALUE) + rval->valid_a = 1; + } else goto err; + + d_msg(__FILE__, __LINE__, 99, "opendir(%s)\n\tspec=%s,\n\tFindFirstFile returns %d\n", path, rval->spec, rval->dirh); @@ -527,17 +681,24 @@ opendir(const char *path) rval->offset = 0; if (rval->dirh == INVALID_HANDLE_VALUE) goto err; - rval->valid = 1; - d_msg(__FILE__, __LINE__, - 99, "\tFirstFile=%s\n", rval->data.cFileName); + + if (rval->valid_w) + d_msg(__FILE__, __LINE__, + 99, "\tFirstFile=%s\n", rval->data_w.cFileName); + + if (rval->valid_a) + d_msg(__FILE__, __LINE__, + 99, "\tFirstFile=%s\n", rval->data_a.cFileName); + return (DIR *)rval; + err: free((void *)rval->spec); -err1: free(rval); + errno = b_errno_win32; return NULL; } - + int closedir(DIR *dirp) { @@ -576,49 +737,81 @@ copyin(struct dirent &dp, const char *fname) *cp = 0; return dp.d_reclen; } + int readdir_r(DIR *dirp, struct dirent *entry, struct dirent **result) { - _dir *dp = (_dir *)dirp; - if (dp->valid) { - entry->d_off = dp->offset; - dp->offset += copyin(*entry, dp->data.cFileName); - *result = entry; /* return entry address */ - d_msg(__FILE__, __LINE__, - 99, "readdir_r(%p, { d_name=\"%s\", d_reclen=%d, d_off=%d\n", - dirp, entry->d_name, entry->d_reclen, entry->d_off); + if (dp->valid_w || dp->valid_a) { + entry->d_off = dp->offset; + + // copy unicode + if (dp->valid_w) { + char szBuf[MAX_PATH_UTF8]; + wchar_2_UTF8(szBuf,dp->data_w.cFileName); + dp->offset += copyin(*entry, szBuf); + } else if (dp->valid_a) { // copy ansi (only 1 will be valid) + dp->offset += copyin(*entry, dp->data_a.cFileName); + } + + *result = entry; /* return entry address */ + d_msg(__FILE__, __LINE__, + 99, "readdir_r(%p, { d_name=\"%s\", d_reclen=%d, d_off=%d\n", + dirp, entry->d_name, entry->d_reclen, entry->d_off); } else { // d_msg(__FILE__, __LINE__, 99, "readdir_r !valid\n"); + errno = b_errno_win32; return -1; } - dp->valid = FindNextFile(dp->dirh, &dp->data); + + // get next file, try unicode first + if (p_FindNextFileW) + dp->valid_w = p_FindNextFileW(dp->dirh, &dp->data_w); + else if (p_FindNextFileA) + dp->valid_a = p_FindNextFileA(dp->dirh, &dp->data_a); + else { + dp->valid_a = FALSE; + dp->valid_w = FALSE; + } + return 0; } - +/* + * Dotted IP address to network address + * + * Returns 1 if OK + * 0 on error + */ int inet_aton(const char *a, struct in_addr *inp) { + const char *cp = a; + uint32_t acc = 0, tmp = 0; + int dotc = 0; - const char *cp = a; - uint32_t acc = 0, tmp = 0; - int dotc = 0; - if (!isdigit(*a)) return 0; - while (*cp) { - if (isdigit(*cp)) - tmp = (tmp * 10) + (*cp -'0'); - else if (*cp == '.') { - if (tmp > 255) return 0; - acc = (acc << 8) + tmp; - dotc++; - } - else return 0; - } - - if (dotc != 3) return 0; - inp->s_addr = acc; - return 1; + if (!isdigit(*cp)) { /* first char must be digit */ + return 0; /* error */ + } + do { + if (isdigit(*cp)) { + tmp = (tmp * 10) + (*cp -'0'); + } else if (*cp == '.' || *cp == 0) { + if (tmp > 255) { + return 0; /* error */ + } + acc = (acc << 8) + tmp; + dotc++; + tmp = 0; + } else { + return 0; /* error */ + } + } while (*cp++ != 0); + if (dotc != 4) { /* want 3 .'s plus EOS */ + return 0; /* error */ + } + inp->s_addr = htonl(acc); /* store addr in network format */ + return 1; } int @@ -653,7 +846,7 @@ pathconf(const char *path, int name) case _PC_NAME_MAX : return 255; } - + errno = ENOSYS; return -1; } @@ -662,13 +855,13 @@ WSA_Init(void) { WORD wVersionRequested = MAKEWORD( 1, 1); WSADATA wsaData; - + int err = WSAStartup(wVersionRequested, &wsaData); - - - if (err != 0) - { + + + if (err != 0) { printf("Can not start Windows Sockets\n"); + errno = ENOSYS; return -1; } @@ -679,14 +872,50 @@ WSA_Init(void) int win32_chdir(const char *dir) { - if (0 == SetCurrentDirectory(dir)) return -1; - return 0; + if (p_SetCurrentDirectoryW) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, dir, MAX_PATH_UNICODE); + + if (0 == p_SetCurrentDirectoryW(szBuf)) { + errno = b_errno_win32; + return -1; + } + } + else if (p_SetCurrentDirectoryA) { + if (0 == p_SetCurrentDirectoryA(dir)) { + errno = b_errno_win32; + return -1; + } + } + else return -1; + + return 0; +} + +int +win32_mkdir(const char *dir) +{ + if (p_wmkdir){ + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, dir, MAX_PATH_UNICODE); + return p_wmkdir(szBuf); + } + + return _mkdir(dir); } + char * win32_getcwd(char *buf, int maxlen) { - int n = GetCurrentDirectory(maxlen, buf); + int n=0; + + if (p_GetCurrentDirectoryW) { + WCHAR szBuf[MAX_PATH_UNICODE]; + n = p_GetCurrentDirectoryW(maxlen, szBuf); + n = wchar_2_UTF8 (buf, szBuf, maxlen)-1; + } else if (p_GetCurrentDirectoryA) + n = p_GetCurrentDirectoryA(maxlen, buf); if (n == 0 || n > maxlen) return NULL; @@ -695,10 +924,75 @@ win32_getcwd(char *buf, int maxlen) buf[n] = '\\'; buf[n+1] = 0; } - return buf; } +int +win32_fputs(const char *string, FILE *stream) +{ + /* we use _cwprintf (console printf) + so we can be sure that unicode support works on win32. + this works under nt and 98 (95 and me not tested) + */ + + if (p_MultiByteToWideChar && (stream == stdout) && p_cwprintf) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, string, MAX_PATH_UNICODE); + return p_cwprintf (szBuf); + } + + return fputs(string, stream); +} + +char* +win32_cgets (char* buffer, int len) +{ + /* we use console gets / getws to be able to read unicode + from the win32 console */ + + /* nt and unicode conversion */ + if ((g_platform_id == VER_PLATFORM_WIN32_NT) && p_WideCharToMultiByte && p_cgetws) { + WCHAR szBuf[260]; + szBuf[0] = min (255, len); /* max len, must be smaller than buffer */ + if (p_cgetws(szBuf) && wchar_2_UTF8(buffer, &szBuf[2], len)) + return buffer; + } + + /* win 9x and unicode conversion */ + if ((g_platform_id == VER_PLATFORM_WIN32_WINDOWS) && p_WideCharToMultiByte && p_MultiByteToWideChar) { + char szBuf[260]; + szBuf[0] = min(255, len); /* max len, must be smaller than buffer */ + if (_cgets(szBuf)) { + WCHAR wszBuf[260]; + p_MultiByteToWideChar(CP_OEMCP, 0, &szBuf[2], -1, wszBuf,260); + + if (wchar_2_UTF8(buffer, wszBuf, len)) + return buffer; + } + } + + /* fallback */ + if (fgets(buffer, len, stdin)) + return buffer; + else + return NULL; +} + +int +win32_unlink(const char *filename) +{ + int nRetCode; + if (p_wunlink) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, filename, MAX_PATH_UNICODE); + nRetCode = _wunlink(szBuf); + } else { + nRetCode = _unlink(filename); + } + return nRetCode; +} + + #include "mswinver.h" char WIN_VERSION_LONG[64]; @@ -743,7 +1037,7 @@ winver::winver(void) snprintf(WIN_VERSION, sizeof(WIN_VERSION), "%s %d.%d.%d", platform, osvinfo.dwMajorVersion, osvinfo.dwMinorVersion, osvinfo.dwBuildNumber); -#if 1 +#if 0 HANDLE h = CreateFile("G:\\foobar", GENERIC_WRITE, 0, NULL, CREATE_ALWAYS, 0, NULL); CloseHandle(h); #endif @@ -756,26 +1050,40 @@ winver::winver(void) close_bpipe(b); #endif } - -BOOL CreateChildProcess(VOID); -VOID WriteToPipe(VOID); -VOID ReadFromPipe(VOID); -VOID ErrorExit(LPTSTR); -VOID ErrMsg(LPTSTR, BOOL); - +BOOL CreateChildProcess(VOID); +VOID WriteToPipe(VOID); +VOID ReadFromPipe(VOID); +VOID ErrorExit(LPCSTR); +VOID ErrMsg(LPTSTR, BOOL); + +/** + * Check for a quoted path, if an absolute path name is given and it contains + * spaces it will need to be quoted. i.e. "c:/Program Files/foo/bar.exe" + * CreateProcess() says the best way to ensure proper results with executables + * with spaces in path or filename is to quote the string. + */ const char * getArgv0(const char *cmdline) { - const char *cp = cmdline; - while (*cp && !isspace(*cp)) cp++; + int inquote = 0; + for (const char *cp = cmdline; *cp; cp++) + { + if (*cp == '"') { + inquote = !inquote; + } + if (!inquote && isspace(*cp)) + break; + } + int len = cp - cmdline; char *rval = (char *)malloc(len+1); cp = cmdline; char *rp = rval; + while (len--) *rp++ = *cp++; @@ -783,19 +1091,26 @@ getArgv0(const char *cmdline) return rval; } + +/** + * OK, so it would seem CreateProcess only handles true executables: + * .com or .exe files. + * So test to see whether we're getting a .bat file and if so grab + * $COMSPEC value and pass batch file to it. + */ HANDLE -CreateChildProcess(const char *cmdline, HANDLE in, HANDLE out, HANDLE err) -{ - PROCESS_INFORMATION piProcInfo; - STARTUPINFO siStartInfo; - BOOL bFuncRetn = FALSE; - - // Set up members of the PROCESS_INFORMATION structure. - +CreateChildProcess(const char *cmdline, HANDLE in, HANDLE out, HANDLE err) +{ + PROCESS_INFORMATION piProcInfo; + STARTUPINFOA siStartInfo; + BOOL bFuncRetn = FALSE; + + // Set up members of the PROCESS_INFORMATION structure. + ZeroMemory( &piProcInfo, sizeof(PROCESS_INFORMATION) ); - - // Set up members of the STARTUPINFO structure. - + + // Set up members of the STARTUPINFO structure. + ZeroMemory( &siStartInfo, sizeof(STARTUPINFO) ); siStartInfo.cb = sizeof(STARTUPINFO); // setup new process to use supplied handles for stdin,stdout,stderr @@ -807,7 +1122,7 @@ CreateChildProcess(const char *cmdline, HANDLE in, HANDLE out, HANDLE err) siStartInfo.hStdInput = in; else siStartInfo.hStdInput = GetStdHandle(STD_INPUT_HANDLE); - + if (out != INVALID_HANDLE_VALUE) siStartInfo.hStdOutput = out; else @@ -816,69 +1131,56 @@ CreateChildProcess(const char *cmdline, HANDLE in, HANDLE out, HANDLE err) siStartInfo.hStdError = err; else siStartInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE); - // Create the child process. + // Create the child process. + + char exeFile[256]; + + const char *comspec = getenv("COMSPEC"); - char cmdLine[1024]; - char exeFile[1024]; - // retrive the first compont of the command line which should be the - // executable - const char *exeName = getArgv0(cmdline); - // check to see if absolute path was passed to us already? - if (exeName[1] != ':' - || (strchr(cmdline, '/') == NULL - && strchr(cmdline, '\\') == NULL)) - { - // only command name so perform search of PATH to find - char *file; - DWORD rval = SearchPath(NULL, - exeName, - ".exe", - sizeof(exeFile), - exeFile, - &file); - if (rval == 0) - return INVALID_HANDLE_VALUE; - if (rval > sizeof(exeFile)) - return INVALID_HANDLE_VALUE; + if (comspec == NULL) // should never happen + return INVALID_HANDLE_VALUE; - } - else - strcpy(exeFile, exeName); + char *cmdLine = (char *)alloca(strlen(cmdline) + strlen(comspec) + 16); + + strcpy(exeFile, comspec); + strcpy(cmdLine, comspec); + strcat(cmdLine, " /c "); + strcat(cmdLine, cmdline); - // exeFile now has absolute path to program to execute. - free((void *)exeName); - // copy original command line to pass to create process - strcpy(cmdLine, cmdline); // try to execute program - bFuncRetn = CreateProcess(exeFile, - cmdLine, // command line - NULL, // process security attributes - NULL, // primary thread security attributes - TRUE, // handles are inherited - 0, // creation flags - NULL, // use parent's environment - NULL, // use parent's current directory - &siStartInfo, // STARTUPINFO pointer + bFuncRetn = CreateProcessA(exeFile, + cmdLine, // command line + NULL, // process security attributes + NULL, // primary thread security attributes + TRUE, // handles are inherited + 0, // creation flags + NULL, // use parent's environment + NULL, // use parent's current directory + &siStartInfo, // STARTUPINFO pointer &piProcInfo); // receives PROCESS_INFORMATION - + if (bFuncRetn == 0) { ErrorExit("CreateProcess failed\n"); + const char *err = errorString(); + d_msg(__FILE__, __LINE__, 99, + "CreateProcess(%s, %s, ...)=%s\n", exeFile, cmdLine, err); + LocalFree((void *)err); return INVALID_HANDLE_VALUE; } // we don't need a handle on the process primary thread so we close // this now. CloseHandle(piProcInfo.hThread); - + return piProcInfo.hProcess; } - + void -ErrorExit (LPTSTR lpszMessage) -{ +ErrorExit (LPCSTR lpszMessage) +{ d_msg(__FILE__, __LINE__, 0, "%s", lpszMessage); -} - +} + /* typedef struct s_bpipe { @@ -898,44 +1200,45 @@ CloseIfValid(HANDLE handle) CloseHandle(handle); } +#ifndef HAVE_MINGW BPIPE * open_bpipe(char *prog, int wait, const char *mode) { - HANDLE hChildStdinRd, hChildStdinWr, hChildStdinWrDup, - hChildStdoutRd, hChildStdoutWr, hChildStdoutRdDup, + HANDLE hChildStdinRd, hChildStdinWr, hChildStdinWrDup, + hChildStdoutRd, hChildStdoutWr, hChildStdoutRdDup, hInputFile; - - SECURITY_ATTRIBUTES saAttr; - BOOL fSuccess; + SECURITY_ATTRIBUTES saAttr; + + BOOL fSuccess; - hChildStdinRd = hChildStdinWr = hChildStdinWrDup = - hChildStdoutRd = hChildStdoutWr = hChildStdoutRdDup = + hChildStdinRd = hChildStdinWr = hChildStdinWrDup = + hChildStdoutRd = hChildStdoutWr = hChildStdoutRdDup = hInputFile = INVALID_HANDLE_VALUE; - + BPIPE *bpipe = (BPIPE *)malloc(sizeof(BPIPE)); memset((void *)bpipe, 0, sizeof(BPIPE)); int mode_read = (mode[0] == 'r'); int mode_write = (mode[0] == 'w' || mode[1] == 'w'); - - - // Set the bInheritHandle flag so pipe handles are inherited. - - saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); - saAttr.bInheritHandle = TRUE; - saAttr.lpSecurityDescriptor = NULL; - + + + // Set the bInheritHandle flag so pipe handles are inherited. + + saAttr.nLength = sizeof(SECURITY_ATTRIBUTES); + saAttr.bInheritHandle = TRUE; + saAttr.lpSecurityDescriptor = NULL; + if (mode_read) { - - // Create a pipe for the child process's STDOUT. + + // Create a pipe for the child process's STDOUT. if (! CreatePipe(&hChildStdoutRd, &hChildStdoutWr, &saAttr, 0)) { ErrorExit("Stdout pipe creation failed\n"); goto cleanup; } - // Create noninheritable read handle and close the inheritable read - // handle. - + // Create noninheritable read handle and close the inheritable read + // handle. + fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdoutRd, GetCurrentProcess(), &hChildStdoutRdDup , 0, FALSE, @@ -944,136 +1247,155 @@ open_bpipe(char *prog, int wait, const char *mode) ErrorExit("DuplicateHandle failed"); goto cleanup; } - + CloseHandle(hChildStdoutRd); + hChildStdoutRd = INVALID_HANDLE_VALUE; } - + if (mode_write) { - - // Create a pipe for the child process's STDIN. - - if (! CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) { + + // Create a pipe for the child process's STDIN. + + if (!CreatePipe(&hChildStdinRd, &hChildStdinWr, &saAttr, 0)) { ErrorExit("Stdin pipe creation failed\n"); goto cleanup; } - - // Duplicate the write handle to the pipe so it is not inherited. - fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr, + + // Duplicate the write handle to the pipe so it is not inherited. + fSuccess = DuplicateHandle(GetCurrentProcess(), hChildStdinWr, GetCurrentProcess(), &hChildStdinWrDup, - 0, - FALSE, // not inherited - DUPLICATE_SAME_ACCESS); + 0, + FALSE, // not inherited + DUPLICATE_SAME_ACCESS); if (!fSuccess) { ErrorExit("DuplicateHandle failed"); goto cleanup; } - - CloseHandle(hChildStdinWr); + + CloseHandle(hChildStdinWr); + hChildStdinWr = INVALID_HANDLE_VALUE; } // spawn program with redirected handles as appropriate bpipe->worker_pid = (pid_t) - CreateChildProcess(prog, // commandline - hChildStdinRd, // stdin HANDLE - hChildStdoutWr, // stdout HANDLE - hChildStdoutWr);// stderr HANDLE - + CreateChildProcess(prog, // commandline + hChildStdinRd, // stdin HANDLE + hChildStdoutWr, // stdout HANDLE + hChildStdoutWr); // stderr HANDLE + if ((HANDLE) bpipe->worker_pid == INVALID_HANDLE_VALUE) goto cleanup; - + bpipe->wait = wait; bpipe->worker_stime = time(NULL); - + if (mode_read) { CloseHandle(hChildStdoutWr); // close our write side so when // process terminates we can // detect eof. // ugly but convert WIN32 HANDLE to FILE* int rfd = _open_osfhandle((long)hChildStdoutRdDup, O_RDONLY); - bpipe->rfd = _fdopen(rfd, "r"); + if (rfd >= 0) { + bpipe->rfd = _fdopen(rfd, "r"); + } } if (mode_write) { CloseHandle(hChildStdinRd); // close our read side so as not // to interfre with child's copy // ugly but convert WIN32 HANDLE to FILE* int wfd = _open_osfhandle((long)hChildStdinWrDup, O_WRONLY); - bpipe->wfd = _fdopen(wfd, "w"); + if (wfd >= 0) { + bpipe->wfd = _fdopen(wfd, "w"); + } } - + if (wait > 0) { bpipe->timer_id = start_child_timer(bpipe->worker_pid, wait); } - + return bpipe; - + cleanup: - + CloseIfValid(hChildStdoutRd); CloseIfValid(hChildStdoutRdDup); CloseIfValid(hChildStdinWr); CloseIfValid(hChildStdinWrDup); - + free((void *) bpipe); - + errno = b_errno_win32; /* do GetLastError() for error code */ return NULL; } +#endif //HAVE_MINGW + int kill(int pid, int signal) { - int rval = 0; - if (!TerminateProcess((HANDLE)pid, (UINT) signal)) - rval = -1; - CloseHandle((HANDLE)pid); - return rval; + int rval = 0; + if (!TerminateProcess((HANDLE)pid, (UINT) signal)) { + rval = -1; + errno = b_errno_win32; + } + CloseHandle((HANDLE)pid); + return rval; } +#ifndef HAVE_MINGW + int close_bpipe(BPIPE *bpipe) { - int rval = 0; - if (bpipe->rfd) fclose(bpipe->rfd); - if (bpipe->wfd) fclose(bpipe->wfd); + int rval = 0; + int32_t remaining_wait = bpipe->wait; - if (bpipe->wait) { - int remaining_wait = bpipe->wait; - do - { - DWORD exitCode; - if (!GetExitCodeProcess((HANDLE)bpipe->worker_pid, &exitCode)) - { - const char *err = errorString(); - rval = GetLastError(); - d_msg(__FILE__, __LINE__, 0, - "GetExitCode error %s\n", err); - LocalFree((void *)err); - break; - } - - if (exitCode == STILL_ACTIVE) { - bmicrosleep(1, 0); /* wait one second */ - remaining_wait--; - } - else break; - } while(remaining_wait); - } - - if (bpipe->timer_id) { - stop_child_timer(bpipe->timer_id); - } - free((void *)bpipe); - return rval; + if (remaining_wait == 0) { /* wait indefinitely */ + remaining_wait = INT32_MAX; + } + for ( ;; ) { + DWORD exitCode; + if (!GetExitCodeProcess((HANDLE)bpipe->worker_pid, &exitCode)) { + const char *err = errorString(); + rval = b_errno_win32; + d_msg(__FILE__, __LINE__, 0, + "GetExitCode error %s\n", err); + LocalFree((void *)err); + break; + } + if (exitCode == STILL_ACTIVE) { + if (remaining_wait <= 0) { + rval = ETIME; /* timed out */ + break; + } + bmicrosleep(1, 0); /* wait one second */ + remaining_wait--; + } else if (exitCode != 0) { + /* Truncate exit code as it doesn't seem to be correct */ + rval = (exitCode & 0xFF) | b_errno_exit; + break; + } else { + break; /* Shouldn't get here */ + } + } + + if (bpipe->timer_id) { + stop_child_timer(bpipe->timer_id); + } + if (bpipe->rfd) fclose(bpipe->rfd); + if (bpipe->wfd) fclose(bpipe->wfd); + free((void *)bpipe); + return rval; } int close_wpipe(BPIPE *bpipe) { int stat = 1; - + if (bpipe->wfd) { fflush(bpipe->wfd); if (fclose(bpipe->wfd) != 0) { stat = 0; - } + } bpipe->wfd = NULL; } return stat; @@ -1087,31 +1409,48 @@ utime(const char *fname, struct utimbuf *times) FILETIME acc, mod; char tmpbuf[1024]; - cygwin_conv_to_win32_path(fname, tmpbuf); + cygwin_conv_to_win32_path(fname, tmpbuf, 1024); cvt_utime_to_ftime(times->actime, acc); cvt_utime_to_ftime(times->modtime, mod); - HANDLE h = CreateFile(tmpbuf, - FILE_WRITE_ATTRIBUTES, - FILE_SHARE_WRITE, - NULL, - OPEN_EXISTING, - 0, - NULL); + HANDLE h = INVALID_HANDLE_VALUE; + + if (p_CreateFileW) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, tmpbuf, MAX_PATH_UNICODE); + + h = p_CreateFileW(szBuf, + FILE_WRITE_ATTRIBUTES, + FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + } else if (p_CreateFileA) { + h = p_CreateFileA(tmpbuf, + FILE_WRITE_ATTRIBUTES, + FILE_SHARE_WRITE, + NULL, + OPEN_EXISTING, + 0, + NULL); + } if (h == INVALID_HANDLE_VALUE) { const char *err = errorString(); d_msg(__FILE__, __LINE__, 99, - "Cannot open file for utime(%s,...):%s\n", tmpbuf, err); + "Cannot open file \"%s\" for utime(): ERR=%s", tmpbuf, err); LocalFree((void *)err); + errno = b_errno_win32; return -1; } int rval = SetFileTime(h, NULL, &acc, &mod) ? 0 : -1; - CloseHandle(h); - + if (rval == -1) { + errno = b_errno_win32; + } return rval; } @@ -1120,27 +1459,42 @@ utime(const char *fname, struct utimbuf *times) int open(const char *file, int flags, int mode) { - return _open(file, flags, mode|_O_BINARY); + if (p_wopen) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, file, MAX_PATH_UNICODE); + return p_wopen(szBuf, flags|_O_BINARY, mode); + } + + return _open(file, flags|_O_BINARY, mode); } +/* + * Note, this works only for a file. If you want + * to close a socket, use closesocket(). + * Bacula has been modified in src/lib/bnet.c + * to use closesocket(). + */ int close(int fd) { return _close(fd); } +#ifndef HAVE_WXCONSOLE ssize_t -read(int fd, void *buf, size_t len) +read(int fd, void *buf, ssize_t len) { - return _read(fd, buf, len); + return _read(fd, buf, (size_t)len); } ssize_t -write(int fd, const void *buf, size_t len) +write(int fd, const void *buf, ssize_t len) { - return _write(fd, buf, len); + return _write(fd, buf, (size_t)len); } +#endif + off_t lseek(int fd, off_t offset, int whence) @@ -1161,31 +1515,39 @@ open(const char *file, int flags, int mode) DWORD shareMode = 0; DWORD create = 0; DWORD msflags = 0; - HANDLE foo; + HANDLE foo = INVALID_HANDLE_VALUE; const char *remap = file; if (flags & O_WRONLY) access = GENERIC_WRITE; else if (flags & O_RDWR) access = GENERIC_READ|GENERIC_WRITE; else access = GENERIC_READ; - + if (flags & O_CREAT) create = CREATE_NEW; else create = OPEN_EXISTING; - + if (flags & O_TRUNC) create = TRUNCATE_EXISTING; - + if (!(flags & O_EXCL)) shareMode = FILE_SHARE_DELETE|FILE_SHARE_READ|FILE_SHARE_WRITE; - - if (flags & O_APPEND) - { + + if (flags & O_APPEND) { printf("open...APPEND not implemented yet."); exit(-1); } - - foo = CreateFile(file, access, shareMode, NULL, create, msflags, NULL); - if (INVALID_HANDLE_VALUE == foo) - return(int) -1; + if (p_CreateFileW) { + WCHAR szBuf[MAX_PATH_UNICODE]; + UTF8_2_wchar(szBuf, file, MAX_PATH_UNICODE); + + foo = p_CreateFileW(szBuf, access, shareMode, NULL, create, msflags, NULL); + } + else if (p_CreateFileA) + foo = CreateFile(file, access, shareMode, NULL, create, msflags, NULL); + + if (INVALID_HANDLE_VALUE == foo) { + errno = b_errno_win32; + return(int) -1; + } return (int)foo; } @@ -1194,31 +1556,35 @@ open(const char *file, int flags, int mode) int close(int fd) { - if (!CloseHandle((HANDLE)fd)) + if (!CloseHandle((HANDLE)fd)) { + errno = b_errno_win32; return -1; + } return 0; } ssize_t -write(int fd, const void *data, size_t len) +write(int fd, const void *data, ssize_t len) { BOOL status; DWORD bwrite; status = WriteFile((HANDLE)fd, data, len, &bwrite, NULL); if (status) return bwrite; + errno = b_errno_win32; return -1; } ssize_t -read(int fd, void *data, size_t len) +read(int fd, void *data, ssize_t len) { BOOL status; DWORD bread; status = ReadFile((HANDLE)fd, data, len, &bread, NULL); if (status) return bread; + errno = b_errno_win32; return -1; } @@ -1226,6 +1592,7 @@ off_t lseek(int fd, off_t offset, int whence) { DWORD method = 0; + DWORD val; switch (whence) { case SEEK_SET : method = FILE_BEGIN; @@ -1237,17 +1604,31 @@ lseek(int fd, off_t offset, int whence) method = FILE_END; break; default: + errno = EINVAL; return -1; } - - return SetFilePointer((HANDLE)fd, (DWORD)offset, NULL, method); + + if ((val=SetFilePointer((HANDLE)fd, (DWORD)offset, NULL, method)) == INVALID_SET_FILE_POINTER) { + errno = b_errno_win32; + return -1; + } + /* ***FIXME*** I doubt this works right */ + return val; } int dup2(int, int) { + errno = ENOSYS; return -1; } #endif + +#endif //HAVE_MINGW + +#ifdef HAVE_MINGW +/* syslog function, added by Nicolas Boichat */ +void closelog() {} +#endif //HAVE_MINGW