// Copyright transferred from Raider Solutions, Inc to
// Kern Sibbald and John Walker by express permission.
//
-// Copyright (C) 2004 Kern Sibbald and John Walker
+// 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
#include <stdio.h>
#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_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 == '/') {
} 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;
}
}
}
-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
void
srandom(unsigned int seed)
{
- srand(seed);
+ srand(seed);
}
// /////////////////////////////////////////////////////////////////
// convert from Windows concept of time to Unix concept of 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;
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;
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)
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) {
"Cannot open file for stat (%s):%s\n", tmpbuf, err);
LocalFree((void *)err);
rval = -1;
- errno = GetLastError();
+ errno = b_errno_win32;
goto error;
}
"GetfileInformationByHandle(%s): %s\n", tmpbuf, err);
LocalFree((void *)err);
rval = -1;
- errno = GetLastError();
+ errno = b_errno_win32;
goto error;
}
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)
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);
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 */
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;
}
int
execvp(const char *, char *[]) {
+ errno = ENOSYS;
return -1;
}
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;
}
ch2 = *s2;
s1++;
s2++;
- if (ch1 == 0 || tolower(ch1) != tolower(ch2)) break;
+ if (ch1 == 0 || tolower(ch1) != tolower(ch2)) break;
}
- return(ch1 - ch2);
+ return (ch1 - ch2);
}
int
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;
}
// 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[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);
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
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
case _PC_NAME_MAX :
return 255;
}
-
+ errno = ENOSYS;
return -1;
}
int err = WSAStartup(wVersionRequested, &wsaData);
- if (err != 0)
- {
+ if (err != 0) {
printf("Can not start Windows Sockets\n");
+ errno = ENOSYS;
return -1;
}
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;
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];
BOOL CreateChildProcess(VOID);
VOID WriteToPipe(VOID);
VOID ReadFromPipe(VOID);
-VOID ErrorExit(LPTSTR);
+VOID ErrorExit(LPCSTR);
VOID ErrMsg(LPTSTR, BOOL);
/**
int inquote = 0;
for (const char *cp = cmdline; *cp; cp++)
{
- if (*cp == '"') {
- inquote = !inquote;
- }
- if (!inquote && isspace(*cp))
- break;
+ if (*cp == '"') {
+ inquote = !inquote;
+ }
+ if (!inquote && isspace(*cp))
+ break;
}
-
+
int len = cp - cmdline;
char *rval = (char *)malloc(len+1);
return rval;
}
-/*
- * Check to see if filename has the batch file extention.
- */
-int
-isBatchFile(const char *fname)
-{
- const char *ext = strrchr(fname, '.');
-
- if (ext) {
- int rval = strncasecmp(ext, ".bat", 4);
- return !rval;
- }
- return 0;
-}
/**
* OK, so it would seem CreateProcess only handles true executables:
CreateChildProcess(const char *cmdline, HANDLE in, HANDLE out, HANDLE err)
{
PROCESS_INFORMATION piProcInfo;
- STARTUPINFO siStartInfo;
+ STARTUPINFOA siStartInfo;
BOOL bFuncRetn = FALSE;
// Set up members of the PROCESS_INFORMATION structure.
siStartInfo.hStdError = GetStdHandle(STD_ERROR_HANDLE);
// Create the child process.
- char cmdLine[1024];
- char exeFile[1024];
- // retrive the first compont of the command line which should be the
- // executable
- const char *exeName = getArgv0(cmdline);
-
- if (isBatchFile(exeName)) {
- const char *comspec = getenv("COMSPEC");
- if (comspec == NULL) // should never happen
- return INVALID_HANDLE_VALUE;
-
- free((void *)exeName);
- strcpy(exeFile, comspec);
- strcpy(cmdLine, comspec);
- strcat(cmdLine, " /c ");
- strcat(cmdLine, cmdline);
- }
- else
- {
- // check to see if absolute path was passed to us already?
- // allow for case when absolute path is in quotes "C:/...."
- int driveCheck = exeName[0] == '"' ? 2 : 1;
- if (exeName[driveCheck] != ':'
- || (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;
-
- }
- else
- cygwin_conv_to_win32_path(exeName, exeFile);
-
- // exeFile now has absolute path to program to execute.
- free((void *)exeName);
-
- // copy original command line to pass to create process
- strcpy(cmdLine, cmdline);
- }
+ char exeFile[256];
+
+ const char *comspec = getenv("COMSPEC");
+
+ if (comspec == NULL) // should never happen
+ return INVALID_HANDLE_VALUE;
+
+ char *cmdLine = (char *)alloca(strlen(cmdline) + strlen(comspec) + 16);
+
+ strcpy(exeFile, comspec);
+ strcpy(cmdLine, comspec);
+ strcat(cmdLine, " /c ");
+ strcat(cmdLine, cmdline);
+
// try to execute program
- bFuncRetn = CreateProcess(exeFile,
+ bFuncRetn = CreateProcessA(exeFile,
cmdLine, // command line
NULL, // process security attributes
NULL, // primary thread security attributes
void
-ErrorExit (LPTSTR lpszMessage)
+ErrorExit (LPCSTR lpszMessage)
{
d_msg(__FILE__, __LINE__, 0, "%s", lpszMessage);
}
}
CloseHandle(hChildStdoutRd);
- hChildStdoutRd = INVALID_HANDLE_VALUE;
+ hChildStdoutRd = INVALID_HANDLE_VALUE;
}
if (mode_write) {
}
CloseHandle(hChildStdinWr);
- hChildStdinWr = INVALID_HANDLE_VALUE;
+ hChildStdinWr = INVALID_HANDLE_VALUE;
}
// spawn program with redirected handles as appropriate
bpipe->worker_pid = (pid_t)
CloseIfValid(hChildStdinWrDup);
free((void *) bpipe);
-
+ errno = b_errno_win32; /* do GetLastError() for error code */
return NULL;
}
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);
-
- 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);
- }
+ int rval = 0;
+ int32_t remaining_wait = bpipe->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
fflush(bpipe->wfd);
if (fclose(bpipe->wfd) != 0) {
stat = 0;
- }
+ }
bpipe->wfd = NULL;
}
return stat;
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;
}
int
open(const char *file, int flags, int mode)
{
- return _open(file, flags|_O_BINARY, mode);
+ 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)
{
#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)
{
- return (off_t)_lseeki64(fd, offset, whence);
+ return _lseeki64(fd, offset, whence);
}
int
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;
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;
}
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;
}
lseek(int fd, off_t offset, int whence)
{
DWORD method = 0;
+ DWORD val;
switch (whence) {
case SEEK_SET :
method = FILE_BEGIN;
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;
}
projects / bacula / bacula / blobdiff