/* --- functions --- */
static gpointer
_g_module_open (const gchar *file_name,
gboolean bind_lazy,
gboolean bind_local)
{
HINSTANCE handle;
wchar_t *wfilename;
DWORD old_mode;
BOOL success;
#ifdef G_WITH_CYGWIN
gchar tmp[MAX_PATH];
cygwin_conv_to_win32_path(file_name, tmp);
file_name = tmp;
#endif
wfilename = g_utf8_to_utf16 (file_name, -1, NULL, NULL, NULL);
/* suppress error dialog */
success = SetThreadErrorMode (SEM_NOOPENFILEERRORBOX | SEM_FAILCRITICALERRORS, &old_mode);
if (!success)
set_error ("");
handle = LoadLibraryW (wfilename);
if (success)
SetThreadErrorMode (old_mode, NULL);
g_free (wfilename);
if (!handle)
set_error ("'%s': ", file_name);
return handle;
}
static void
ctime_now(const char* path)
{
HANDLE hp;
SYSTEMTIME st;
FILETIME ct;
WIN32_FIND_DATA ff;
struct stat fs;
int oerrno;
char tmp[MAX_PATH];
if (sysstat(path, &fs) || (fs.st_mode & S_IWUSR) || syschmod(path, (fs.st_mode | S_IWUSR) & S_IPERM))
fs.st_mode = 0;
cygwin_conv_to_win32_path(path, tmp);
hp = CreateFile(tmp, GENERIC_WRITE, FILE_SHARE_WRITE, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (hp && hp != INVALID_HANDLE_VALUE)
{
GetSystemTime(&st);
SystemTimeToFileTime(&st, &ct);
SetFileTime(hp, &ct, 0, 0);
CloseHandle(hp);
}
if (fs.st_mode)
syschmod(path, fs.st_mode & S_IPERM);
errno = oerrno;
}
/*=======================================================================
cygwin_path_to_windows
Converts a unix path to native windows format, reversing directory
separators, etc. The caller must free the string returned.
========================================================================*/
char *cygwin_path_to_windows (const char *unix_path)
{
char *result = malloc (PATH_MAX);
#ifdef WIN64
cygwin_conv_path (CCP_POSIX_TO_WIN_A, unix_path, result, PATH_MAX -1 );
#else
cygwin_conv_to_win32_path (unix_path, result);
#endif
return result;
}
std::string FixWindowsPath(const std::string &in)
{
#if defined(__CYGWIN__)
char tmp[1024];
cygwin_conv_to_win32_path(in.c_str(), tmp);
return std::string(tmp);
#else
return in;
#endif
}
const wxString ecUtils::PosixToNativePath(const wxString & posix)
{
#ifdef __CYGWIN__
if (posix.IsEmpty())
return posix;
else
{
wxString native;
cygwin_conv_to_win32_path(posix.c_str(), native.GetWriteBuf(MAXPATHLEN + 1));
native.UngetWriteBuf();
return native;
}
#else
return posix;
#endif
}
/* --- functions --- */
static gpointer
_g_module_open (const gchar *file_name,
gboolean bind_lazy)
{
HINSTANCE handle;
#ifdef G_WITH_CYGWIN
gchar tmp[MAX_PATH];
cygwin_conv_to_win32_path(file_name, tmp);
file_name = tmp;
#endif
handle = LoadLibrary (file_name);
if (!handle)
set_error ();
return handle;
}
void validate(boost::any& v,
const std::vector<std::string>& values,
input_path*, int)
{
std::string path
= boost::program_options::validators::get_single_string(values);
char result[MAX_PATH + 1];
#if defined(BOOST_WINDOWS_PATH)
cygwin_conv_to_win32_path(path.c_str(), result);
#elif defined(BOOST_POSIX_PATH)
cygwin_conv_to_posix_path(path.c_str(), result);
#else
# error "Boost filesystem path type doesn't seem to be set."
#endif
v = input_path(result);
}
void *ILDynLibraryOpen(const char *name)
{
void *libHandle;
char *newName = 0;
#if defined(IL_WIN32_CYGWIN) && defined(HAVE_SYS_CYGWIN_H) && \
defined(HAVE_CYGWIN_CONV_TO_WIN32_PATH)
/* Use Cygwin to expand the path */
{
char buf[4096];
if(cygwin_conv_to_win32_path(name, buf) == 0)
{
newName = ILDupString(buf);
if(!newName)
{
return 0;
}
}
}
#endif
/* Attempt to load the library */
libHandle = (void *)LoadLibrary((newName ? newName : name));
if(libHandle == 0)
{
#ifdef IL_DYNLIB_DEBUG
fprintf(stderr, "%s: could not load dynamic library\n",
(newName ? newName : name));
#endif
if(newName)
{
ILFree(newName);
}
return 0;
}
if(newName)
{
ILFree(newName);
}
return libHandle;
}
/* Copy cygwin environment variables to the Windows environment if they're not
* already there. */
static void setup_win_environ(void)
{
char **envp = environ;
char *var, *val;
char curval[2];
char *winpathlist;
char winpath[MAX_PATH+1];
while (envp && *envp) {
var = strdup(*envp++);
val = strchr(var, '=');
*val++ = '\0';
if (GetEnvironmentVariable(var, curval, 2) == 0
&& GetLastError() == ERROR_ENVVAR_NOT_FOUND) {
/* Convert POSIX to Win32 where necessary */
if (!strcmp(var, "PATH") ||
!strcmp(var, "LD_LIBRARY_PATH")) {
winpathlist = (char *)
malloc(cygwin_posix_to_win32_path_list_buf_size(val)+1);
if (winpathlist) {
cygwin_posix_to_win32_path_list(val, winpathlist);
//std::cout << "A: setting " << var << " to " << winpathlist << "\n";
SetEnvironmentVariable(var, winpathlist);
free(winpathlist);
}
} else if (!strcmp(var, "HOME") ||
!strcmp(var, "TMPDIR") ||
!strcmp(var, "TMP") ||
!strcmp(var, "TEMP")) {
//std::cout << "B: setting " << var << " to " << winpath << "\n";
cygwin_conv_to_win32_path(val, winpath);
SetEnvironmentVariable(var, winpath);
} else {
//std::cout << "C: setting " << var << " to " << val << "\n";
//std::cout.flush();
SetEnvironmentVariable(var, val);
}
}
free(var);
}
}
/* --- functions --- */
static gpointer
_g_module_open (const gchar *file_name,
gboolean bind_lazy,
gboolean bind_local)
{
HINSTANCE handle;
wchar_t *wfilename;
#ifdef G_WITH_CYGWIN
gchar tmp[MAX_PATH];
cygwin_conv_to_win32_path(file_name, tmp);
file_name = tmp;
#endif
wfilename = g_utf8_to_utf16 (file_name, -1, NULL, NULL, NULL);
handle = LoadLibraryW (wfilename);
g_free (wfilename);
if (!handle)
set_error ("'%s': ", file_name);
return handle;
}
static void
var_edit_shift(
string *out,
VAR_EDITS *edits )
{
/* Handle upshifting, downshifting and slash translation now */
char *p;
for ( p = out->value; *p; ++p)
{
if (edits->upshift)
{
*p = toupper( *p );
}
else if ( edits->downshift )
{
*p = tolower( *p );
}
if ( edits->to_slashes )
{
if ( *p == '\\')
*p = '/';
}
# ifdef OS_CYGWIN
if ( edits->to_windows )
{
char result[MAX_PATH + 1];
cygwin_conv_to_win32_path(out->value, result);
assert(strlen(result) <= MAX_PATH);
string_free( out );
string_copy( out, result );
}
# endif
}
out->size = p - out->value;
}
/* Start a new process.
PROGRAM is a path to the program to execute.
ARGS is a standard NULL-terminated array of arguments,
to be passed to the inferior as ``argv''.
Returns the new PID on success, -1 on failure. Registers the new
process with the process list. */
static int
win32_create_inferior (char *program, char **program_args)
{
#ifndef USE_WIN32API
char real_path[MAXPATHLEN];
char *orig_path, *new_path, *path_ptr;
#endif
BOOL ret;
DWORD flags;
char *args;
int argslen;
int argc;
PROCESS_INFORMATION pi;
DWORD err;
/* win32_wait needs to know we're not attaching. */
attaching = 0;
if (!program)
error ("No executable specified, specify executable to debug.\n");
flags = DEBUG_PROCESS | DEBUG_ONLY_THIS_PROCESS;
#ifndef USE_WIN32API
orig_path = NULL;
path_ptr = getenv ("PATH");
if (path_ptr)
{
orig_path = alloca (strlen (path_ptr) + 1);
new_path = alloca (cygwin_posix_to_win32_path_list_buf_size (path_ptr));
strcpy (orig_path, path_ptr);
cygwin_posix_to_win32_path_list (path_ptr, new_path);
setenv ("PATH", new_path, 1);
}
cygwin_conv_to_win32_path (program, real_path);
program = real_path;
#endif
argslen = 1;
for (argc = 1; program_args[argc]; argc++)
argslen += strlen (program_args[argc]) + 1;
args = alloca (argslen);
args[0] = '\0';
for (argc = 1; program_args[argc]; argc++)
{
/* FIXME: Can we do better about quoting? How does Cygwin
handle this? */
strcat (args, " ");
strcat (args, program_args[argc]);
}
OUTMSG2 (("Command line is \"%s\"\n", args));
#ifdef CREATE_NEW_PROCESS_GROUP
flags |= CREATE_NEW_PROCESS_GROUP;
#endif
ret = create_process (program, args, flags, &pi);
err = GetLastError ();
if (!ret && err == ERROR_FILE_NOT_FOUND)
{
char *exename = alloca (strlen (program) + 5);
strcat (strcpy (exename, program), ".exe");
ret = create_process (exename, args, flags, &pi);
err = GetLastError ();
}
#ifndef USE_WIN32API
if (orig_path)
setenv ("PATH", orig_path, 1);
#endif
if (!ret)
{
error ("Error creating process \"%s%s\", (error %d): %s\n",
program, args, (int) err, strwinerror (err));
}
else
{
OUTMSG2 (("Process created: %s\n", (char *) args));
}
#ifndef _WIN32_WCE
/* On Windows CE this handle can't be closed. The OS reuses
it in the debug events, while the 9x/NT versions of Windows
probably use a DuplicateHandle'd one. */
CloseHandle (pi.hThread);
#endif
do_initial_child_stuff (pi.hProcess, pi.dwProcessId, 0);
return current_process_id;
}
static wBOOL CALLBACK
winAboutDlgProc (HWND hwndDialog, UINT message,
WPARAM wParam, LPARAM lParam)
{
static winPrivScreenPtr s_pScreenPriv = NULL;
static winScreenInfo *s_pScreenInfo = NULL;
static ScreenPtr s_pScreen = NULL;
#if CYGDEBUG
winDebug ("winAboutDlgProc\n");
#endif
/* Branch on message type */
switch (message)
{
case WM_INITDIALOG:
#if CYGDEBUG
winDebug ("winAboutDlgProc - WM_INITDIALOG\n");
#endif
/* Store pointers to private structures for future use */
s_pScreenPriv = (winPrivScreenPtr) lParam;
s_pScreenInfo = s_pScreenPriv->pScreenInfo;
s_pScreen = s_pScreenInfo->pScreen;
winInitDialog (hwndDialog);
/* Override the URL buttons */
winOverrideURLButton (hwndDialog, ID_ABOUT_CHANGELOG);
winOverrideURLButton (hwndDialog, ID_ABOUT_WEBSITE);
winOverrideURLButton (hwndDialog, ID_ABOUT_UG);
winOverrideURLButton (hwndDialog, ID_ABOUT_FAQ);
return TRUE;
case WM_DRAWITEM:
/* Draw the URL buttons as needed */
winDrawURLWindow (lParam);
return TRUE;
case WM_MOUSEMOVE:
case WM_NCMOUSEMOVE:
/* Show the cursor if it is hidden */
if (g_fSoftwareCursor && !g_fCursor)
{
g_fCursor = TRUE;
ShowCursor (TRUE);
}
return TRUE;
case WM_COMMAND:
switch (LOWORD (wParam))
{
case IDOK:
case IDCANCEL:
ErrorF ("winAboutDlgProc - WM_COMMAND - IDOK or IDCANCEL\n");
DestroyWindow (g_hDlgAbout);
g_hDlgAbout = NULL;
/* Fix to make sure keyboard focus isn't trapped */
PostMessage (s_pScreenPriv->hwndScreen, WM_NULL, 0, 0);
/* Restore window procedures for URL buttons */
winUnoverrideURLButton (hwndDialog, ID_ABOUT_CHANGELOG);
winUnoverrideURLButton (hwndDialog, ID_ABOUT_WEBSITE);
winUnoverrideURLButton (hwndDialog, ID_ABOUT_UG);
winUnoverrideURLButton (hwndDialog, ID_ABOUT_FAQ);
return TRUE;
case ID_ABOUT_CHANGELOG:
{
int iReturn;
#ifdef __CYGWIN__
const char * pszCygPath = "/usr/X11R6/share/doc/"
"xorg-x11-xwin/changelog.html";
char pszWinPath[MAX_PATH + 1];
/* Convert the POSIX path to a Win32 path */
cygwin_conv_to_win32_path (pszCygPath, pszWinPath);
#else
const char * pszWinPath = "http://x.cygwin.com/"
"devel/server/changelog.html";
#endif
iReturn = (int)ShellExecute (NULL,
"open",
pszWinPath,
NULL,
NULL,
SW_MAXIMIZE);
if (iReturn < 32)
{
ErrorF ("winAboutDlgProc - WM_COMMAND - ID_ABOUT_CHANGELOG - "
"ShellExecute failed: %d\n",
iReturn);
}
}
return TRUE;
case ID_ABOUT_WEBSITE:
{
const char * pszPath = __VENDORDWEBSUPPORT__;
int iReturn;
iReturn = (int)ShellExecute (NULL,
"open",
pszPath,
NULL,
NULL,
SW_MAXIMIZE);
if (iReturn < 32)
{
ErrorF ("winAboutDlgProc - WM_COMMAND - ID_ABOUT_WEBSITE - "
"ShellExecute failed: %d\n",
iReturn);
}
}
return TRUE;
case ID_ABOUT_UG:
{
const char * pszPath = "http://x.cygwin.com/docs/ug/";
int iReturn;
iReturn = (int)ShellExecute (NULL,
"open",
pszPath,
NULL,
NULL,
SW_MAXIMIZE);
if (iReturn < 32)
{
ErrorF ("winAboutDlgProc - WM_COMMAND - ID_ABOUT_UG - "
"ShellExecute failed: %d\n",
iReturn);
}
}
return TRUE;
case ID_ABOUT_FAQ:
{
const char * pszPath = "http://x.cygwin.com/docs/faq/";
int iReturn;
iReturn = (int)ShellExecute (NULL,
"open",
pszPath,
NULL,
NULL,
SW_MAXIMIZE);
if (iReturn < 32)
{
ErrorF ("winAboutDlgProc - WM_COMMAND - ID_ABOUT_FAQ - "
"ShellExecute failed: %d\n",
iReturn);
}
}
return TRUE;
}
break;
case WM_CLOSE:
ErrorF ("winAboutDlgProc - WM_CLOSE\n");
DestroyWindow (g_hDlgAbout);
g_hDlgAbout = NULL;
/* Fix to make sure keyboard focus isn't trapped */
PostMessage (s_pScreenPriv->hwndScreen, WM_NULL, 0, 0);
/* Restore window procedures for URL buttons */
winUnoverrideURLButton (hwndDialog, ID_ABOUT_CHANGELOG);
winUnoverrideURLButton (hwndDialog, ID_ABOUT_WEBSITE);
winUnoverrideURLButton (hwndDialog, ID_ABOUT_UG);
winUnoverrideURLButton (hwndDialog, ID_ABOUT_FAQ);
return TRUE;
}
return FALSE;
}
/*
* private static bool StartProcess(String filename, String arguments,
* String workingDir,
* String[] argv, int flags,
* int windowStyle, String[] envVars,
* String verb, IntPtr errorDialogParent,
* out IntPtr processHandle,
* out int processID,
* out IntPtr stdinHandle,
* out IntPtr stdoutHandle,
* out IntPtr stderrHandle);
*/
ILBool _IL_Process_StartProcess(ILExecThread *_thread,
ILString *filename,
ILString *arguments,
ILString *workingDir,
System_Array *argv,
ILInt32 flags,
ILInt32 windowStyle,
System_Array *envVars,
ILString *verb,
ILNativeInt errorDialogParent,
ILNativeInt *processHandle,
ILInt32 *processID,
ILNativeInt *stdinHandle,
ILNativeInt *stdoutHandle,
ILNativeInt *stderrHandle)
{
#ifdef IL_WIN32_PLATFORM
#ifdef IL_WIN32_CYGWIN
#define GET_OSF(fd) ((HANDLE)(get_osfhandle((fd))))
#define MAKE_PIPE(fds) (pipe((fds)))
#else
#define GET_OSF(fd) ((HANDLE)(_get_osfhandle((fd))))
#define MAKE_PIPE(fds) (_pipe((fds), 0, _O_BINARY))
#endif
const char *fname;
const char *workdir = 0;
char *args;
STARTUPINFO startupInfo;
PROCESS_INFORMATION processInfo;
char *env = 0;
ILBool result;
int pipefds[2];
int cleanups[8];
int numCleanups = 0;
int closeAfterFork[8];
int numCloseAfterFork = 0;
int index;
#if defined(HAVE_SYS_CYGWIN_H) && defined(HAVE_CYGWIN_CONV_TO_WIN32_PATH)
char cygFname[4096];
char cygWorkdir[4096];
#endif
/* Clear errno, because we will check for it when something fails */
ILSysIOSetErrno(0);
/* Convert the parameters into something that the OS can understand */
fname = ILStringToAnsi(_thread, filename);
if(!fname)
{
return 0;
}
#if defined(HAVE_SYS_CYGWIN_H) && defined(HAVE_CYGWIN_CONV_TO_WIN32_PATH)
/* Use the Cygwin-supplied function to convert the path
that CreateProcess() will understand */
if(cygwin_conv_to_win32_path(fname, cygFname) == 0)
{
fname = cygFname;
}
#endif
if(((System_String *) workingDir)->length)
{
workdir = ILStringToAnsi(_thread, workingDir);
if(!workdir)
{
return 0;
}
#if defined(HAVE_SYS_CYGWIN_H) && defined(HAVE_CYGWIN_CONV_TO_WIN32_PATH)
/* Use convert workdir for CreateProcess() under cygwin */
if(cygwin_conv_to_win32_path(workdir, cygWorkdir) == 0)
{
workdir = cygWorkdir;
}
#endif
}
args = ILStringToAnsi(_thread, arguments);
if(!args)
{
return 0;
}
ILMemZero(&startupInfo, sizeof(startupInfo));
startupInfo.cb = sizeof(STARTUPINFO);
startupInfo.dwFlags = STARTF_USESHOWWINDOW;
startupInfo.wShowWindow = (WORD)windowStyle;
/* Redirect stdin, stdout, and stderr if necessary */
*stdinHandle = (ILNativeInt)(ILSysIOHandle_Invalid);
*stdoutHandle = (ILNativeInt)(ILSysIOHandle_Invalid);
*stderrHandle = (ILNativeInt)(ILSysIOHandle_Invalid);
if((flags & (ProcessStart_RedirectStdin |
ProcessStart_RedirectStdout |
ProcessStart_RedirectStderr)) != 0)
{
startupInfo.dwFlags |= STARTF_USESTDHANDLES;
if((flags & ProcessStart_RedirectStdin) != 0)
{
MAKE_PIPE(pipefds);
*stdinHandle = (ILNativeInt)(pipefds[1]);
SetHandleInformation(GET_OSF(pipefds[1]),
HANDLE_FLAG_INHERIT, 0);
startupInfo.hStdInput = GET_OSF(pipefds[0]);
cleanups[numCleanups++] = pipefds[0];
cleanups[numCleanups++] = pipefds[1];
closeAfterFork[numCloseAfterFork++] = pipefds[0];
}
else
{
startupInfo.hStdInput = GET_OSF(0);
}
if((flags & ProcessStart_RedirectStdout) != 0)
{
MAKE_PIPE(pipefds);
*stdoutHandle = (ILNativeInt)(pipefds[0]);
SetHandleInformation(GET_OSF(pipefds[0]),
HANDLE_FLAG_INHERIT, 0);
startupInfo.hStdOutput = GET_OSF(pipefds[1]);
cleanups[numCleanups++] = pipefds[0];
cleanups[numCleanups++] = pipefds[1];
closeAfterFork[numCloseAfterFork++] = pipefds[1];
}
else
{
startupInfo.hStdOutput = GET_OSF(1);
}
if((flags & ProcessStart_RedirectStderr) != 0)
{
MAKE_PIPE(pipefds);
*stderrHandle = (ILNativeInt)(pipefds[0]);
SetHandleInformation(GET_OSF(pipefds[0]),
HANDLE_FLAG_INHERIT, 0);
startupInfo.hStdError = GET_OSF(pipefds[1]);
cleanups[numCleanups++] = pipefds[0];
cleanups[numCleanups++] = pipefds[1];
closeAfterFork[numCloseAfterFork++] = pipefds[1];
}
else
{
startupInfo.hStdError = GET_OSF(2);
}
}
/* TODO: shell execution, environment variables, and ExecOverTop */
/* Launch the process */
*processID = -1;
*processHandle = 0;
result = 0;
if(CreateProcess(fname, args, NULL, NULL, TRUE, 0, env, workdir,
&startupInfo, &processInfo))
{
*processHandle = (ILNativeInt)(processInfo.hProcess);
*processID = (ILInt32)(processInfo.dwProcessId);
result = 1;
}
else
{
/* TODO: it could be useful to report error details using GetLastError().
We can't do ILSysIOSetErrno(GetLastError()), because errno is related
to IO function, while GetLastError() is windows-specific error code */
ILSysIOSetErrno(ENOENT);
}
/* Clean up and exit */
if(env)
{
ILFree(env);
}
if(result)
{
for(index = 0; index < numCloseAfterFork; ++index)
{
close(closeAfterFork[index]);
}
}
else
{
for(index = 0; index < numCleanups; ++index)
{
close(cleanups[index]);
}
}
return result;
#elif defined(HAVE_FORK) && defined(HAVE_EXECV) && (defined(HAVE_WAITPID) || defined(HAVE_WAIT))
#define IL_USING_FORK 1
const char *fname;
const char *workdir = 0;
char **args;
char **newEnviron = 0;
int varNum = 0;
int stdinFds[2] = {-1, -1};
int stdoutFds[2] = {-1, -1};
int stderrFds[2] = {-1, -1};
ILBool result = 0;
int pid;
ILInt32 argc;
const char *ansi;
int pipefds[2];
#define FreeStringList(list,size) \
do { \
if((list)) \
{ \
int __posn = (int)(size); \
while(__posn > 0) \
{ \
--__posn; \
ILFree((list)[__posn]); \
} \
ILFree((list)); \
} \
} while (0)
/* Convert the parameters into something that the OS can understand */
fname = ILStringToAnsi(_thread, filename);
if(!fname)
{
return 0;
}
if(((System_String *) workingDir)->length)
{
workdir = ILStringToAnsi(_thread, workingDir);
if(!workdir)
{
return 0;
}
}
args = (char **)ILCalloc(ArrayLength(argv) + 1, sizeof(char *));
if(!args)
{
ILExecThreadThrowOutOfMemory(_thread);
return 0;
}
argc = 0;
while(argc < ArrayLength(argv))
{
ansi = ILStringToAnsi
(_thread, ((ILString **)ArrayToBuffer(argv))[argc]);
if(!ansi)
{
FreeStringList(args, argc);
return 0;
}
args[argc] = (char *)ILMalloc(strlen(ansi) + 1);
if(!(args[argc]))
{
FreeStringList(args, argc);
return 0;
}
strcpy(args[argc], ansi);
++argc;
}
args[argc] = 0;
/* Convert the environment */
if(envVars)
{
newEnviron = (char **)ILCalloc(ArrayLength(envVars) + 1, sizeof(char *));
if(!newEnviron)
{
ILExecThreadThrowOutOfMemory(_thread);
FreeStringList(args, argc);
return 0;
}
while(varNum < (int)(ArrayLength(envVars)))
{
ansi = ILStringToAnsi
(_thread, ((ILString **)ArrayToBuffer(envVars))[varNum]);
if(!ansi)
{
FreeStringList(args, argc);
FreeStringList(newEnviron, varNum);
return 0;
}
newEnviron[varNum] = (char *)ILMalloc(strlen(ansi) + 1);
if(!(newEnviron[varNum]))
{
FreeStringList(args, argc);
FreeStringList(newEnviron, varNum);
return 0;
}
strcpy(newEnviron[varNum], ansi);
++varNum;
}
newEnviron[varNum] = 0;
}
/* Redirect stdin, stdout, and stderr as necessary */
*stdinHandle = (ILNativeInt)(ILSysIOHandle_Invalid);
*stdoutHandle = (ILNativeInt)(ILSysIOHandle_Invalid);
*stderrHandle = (ILNativeInt)(ILSysIOHandle_Invalid);
if((flags & ProcessStart_RedirectStdin) != 0)
{
if(pipe(stdinFds) < 0)
{
return 0;
}
#if HAVE_FCNTL
fcntl(stdinFds[1], F_SETFD, 1);
#endif
*stdinHandle = (ILNativeInt)(stdinFds[1]);
}
if((flags & ProcessStart_RedirectStdout) != 0)
{
if(pipe(stdoutFds) < 0)
{
if((flags & ProcessStart_RedirectStdin) != 0)
{
close(stdinFds[0]);
close(stdinFds[1]);
}
return 0;
}
#if HAVE_FCNTL
fcntl(stdoutFds[0], F_SETFD, 1);
#endif
*stdoutHandle = (ILNativeInt)(stdoutFds[0]);
}
if((flags & ProcessStart_RedirectStderr) != 0)
{
if(pipe(stderrFds) < 0)
{
if((flags & ProcessStart_RedirectStdin) != 0)
{
close(stdinFds[0]);
close(stdinFds[1]);
}
if((flags & ProcessStart_RedirectStdout) != 0)
{
close(stdoutFds[0]);
close(stdoutFds[1]);
}
return 0;
}
#if HAVE_FCNTL
fcntl(stderrFds[0], F_SETFD, 1);
#endif
*stderrHandle = (ILNativeInt)(stderrFds[0]);
}
/* Open the pipe for returning errno */
if(pipe(pipefds) < 0)
{
return 0;
}
/* Fork and execute the process */
*processID = -1;
*processHandle = 0;
pid = fork();
if(pid == 0)
{
/* We are in the child process */
if((flags & ProcessStart_RedirectStdin) != 0)
{
dup2(stdinFds[0], 0);
close(stdinFds[0]);
}
if((flags & ProcessStart_RedirectStdout) != 0)
{
dup2(stdoutFds[1], 1);
close(stdoutFds[1]);
}
if((flags & ProcessStart_RedirectStderr) != 0)
{
dup2(stderrFds[1], 2);
close(stderrFds[1]);
}
if(newEnviron)
{
extern char **environ;
environ = newEnviron;
}
close(pipefds[0]);
#ifdef HAVE_FCNTL
fcntl(pipefds[1],F_SETFD,1);
#endif
if(workdir)
{
if(ILChangeDir(workdir) != IL_ERRNO_Success)
{
/* Send errno to parent process */
write(pipefds[1],&errno, sizeof(errno));
exit(1);
}
}
execvp(fname, args);
write(pipefds[1],&errno, sizeof(errno));
exit(1);
}
else if(pid > 0)
{
/* We are in the parent process */
if((flags & ProcessStart_RedirectStdin) != 0)
{
close(stdinFds[0]);
}
if((flags & ProcessStart_RedirectStdout) != 0)
{
close(stdoutFds[1]);
}
if((flags & ProcessStart_RedirectStderr) != 0)
{
close(stderrFds[1]);
}
*processID = (ILInt32)pid;
close(pipefds[1]);
errno = 0;
read(pipefds[0],&errno,sizeof(errno));
close(pipefds[0]);
result = (errno == 0);
}
else
{
/* An error occurred during the fork */
if((flags & ProcessStart_RedirectStdin) != 0)
{
close(stdinFds[0]);
close(stdinFds[1]);
}
if((flags & ProcessStart_RedirectStdout) != 0)
{
close(stdoutFds[0]);
close(stdoutFds[1]);
}
if((flags & ProcessStart_RedirectStderr) != 0)
{
close(stderrFds[0]);
close(stderrFds[1]);
}
close(pipefds[0]);
close(pipefds[1]);
}
/* Clean up and exit */
FreeStringList(args, argc);
FreeStringList(newEnviron, varNum);
return result;
#else
/* Don't know how to spawn processes on this platform */
return 0;
#endif
}
int csync_rs_patch(const char *filename)
{
FILE *basis_file = 0, *delta_file = 0, *new_file = 0;
int backup_errno;
rs_stats_t stats;
rs_result result;
char *errstr = "?";
char tmpfname[MAXPATHLEN], newfname[MAXPATHLEN];
csync_debug(3, "Csync2 / Librsync: csync_rs_patch('%s')\n", filename);
csync_debug(3, "Receiving delta_file from peer..\n");
delta_file = open_temp_file(tmpfname, prefixsubst(filename));
if ( !delta_file ) { errstr="creating delta temp file"; goto io_error; }
if (unlink(tmpfname) < 0) { errstr="removing delta temp file"; goto io_error; }
if ( csync_recv_file(delta_file) ) goto error;
csync_debug(3, "Opening to be patched file on local host..\n");
basis_file = fopen(prefixsubst(filename), "rb");
if ( !basis_file ) {
basis_file = open_temp_file(tmpfname, prefixsubst(filename));
if ( !basis_file ) { errstr="opening data file for reading"; goto io_error; }
if (unlink(tmpfname) < 0) { errstr="removing data temp file"; goto io_error; }
}
csync_debug(3, "Opening temp file for new data on local host..\n");
new_file = open_temp_file(newfname, prefixsubst(filename));
if ( !new_file ) { errstr="creating new data temp file"; goto io_error; }
csync_debug(3, "Running rs_patch_file() from librsync..\n");
result = rs_patch_file(basis_file, delta_file, new_file, &stats);
if (result != RS_DONE) {
csync_debug(0, "Internal error from rsync library!\n");
goto error;
}
csync_debug(3, "Renaming tmp file to data file..\n");
fclose(basis_file);
#ifdef __CYGWIN__
/* TODO: needed? */
// This creates the file using the native windows API, bypassing
// the cygwin wrappers and so making sure that we do not mess up the
// permissions..
{
char winfilename[MAX_PATH];
HANDLE winfh;
cygwin_conv_to_win32_path(prefixsubst(filename), winfilename);
winfh = CreateFile(TEXT(winfilename),
GENERIC_WRITE, // open for writing
0, // do not share
NULL, // default security
CREATE_ALWAYS, // overwrite existing
FILE_ATTRIBUTE_NORMAL | // normal file
FILE_FLAG_OVERLAPPED, // asynchronous I/O
NULL); // no attr. template
if (winfh == INVALID_HANDLE_VALUE) {
csync_debug(0, "Win32 I/O Error %d in rsync-patch: %s\n",
(int)GetLastError(), winfilename);
errno = EACCES;
goto error;
}
CloseHandle(winfh);
}
#endif
if (rename(newfname, prefixsubst(filename)) < 0) { errstr="renaming tmp file to to be patched file"; goto io_error; }
csync_debug(3, "File has been patched successfully.\n");
fclose(delta_file);
fclose(new_file);
return 0;
io_error:
csync_debug(0, "I/O Error '%s' while %s in rsync-patch: %s\n",
strerror(errno), errstr, prefixsubst(filename));
error:;
backup_errno = errno;
if ( delta_file ) fclose(delta_file);
if ( basis_file ) fclose(basis_file);
if ( new_file ) fclose(new_file);
errno = backup_errno;
return -1;
}
csLibraryHandle csLoadLibrary (const char* iName)
{
csLibraryHandle handle;
DWORD errorCode;
CS_ALLOC_STACK_ARRAY (char, dllPath, strlen (iName) + 5);
strcpy (dllPath, iName);
char* dot = strrchr (dllPath, '.');
if ((!dot) || (strcasecmp (dot, ".dll") != 0))
{
if (dot && (strcasecmp (dot, ".csplugin") == 0))
{
strcpy (dot, ".dll");
}
else
{
strcat (dllPath, ".dll");
}
}
handle = LoadLibraryEx (dllPath, 0, LOADLIBEX_FLAGS);
errorCode = GetLastError();
#ifdef __CYGWIN__
// A load attempt might fail if the DLL depends implicitly upon some other
// DLLs which reside in the Cygwin /bin directory. To deal with this case, we
// add the Cygwin /bin directory to the PATH environment variable and retry.
if (handle == 0)
{
char *OLD_PATH = new char[4096];
char *DLLDIR = new char[1024];
GetEnvironmentVariable("PATH", OLD_PATH, 4096);
if (cygwin_conv_to_win32_path ("/bin/",DLLDIR))
{
ErrorMessages.Push(
"LoadLibraryEx() '/bin/' Cygwin/Win32 path conversion failed.");
delete[] DLLDIR;
delete[] OLD_PATH;
return 0;
}
SetEnvironmentVariable("PATH", DLLDIR);
handle = LoadLibraryEx (dllPath, 0, LOADLIBEX_FLAGS);
errorCode = GetLastError();
SetEnvironmentVariable("PATH", OLD_PATH);
delete[] DLLDIR;
delete[] OLD_PATH;
}
#endif
if (handle == 0)
{
char *buf = cswinGetErrorMessage (errorCode);
csString s;
s << "LoadLibraryEx(" << dllPath << ") error " << (int)errorCode << ": "
<< buf;
ErrorMessages.Push (s);
delete[] buf;
return 0;
}
typedef const char* (*pfnGetPluginCompiler)();
pfnGetPluginCompiler get_plugin_compiler =
(pfnGetPluginCompiler) csGetLibrarySymbol (handle, "plugin_compiler");
if (!get_plugin_compiler)
{
csString s;
s << dllPath << ": DLL does not export \"plugin_compiler\".";
ErrorMessages.Push (s);
FreeLibrary ((HMODULE)handle);
return 0;
}
const char* plugin_compiler = get_plugin_compiler();
if (strcmp(plugin_compiler, CS_COMPILER_NAME) != 0)
{
csString s;
s << dllPath << ": plugin compiler does not match application compiler: "
<< plugin_compiler << " != " CS_COMPILER_NAME;
ErrorMessages.Push (s);
FreeLibrary ((HMODULE)handle);
return 0;
}
return handle;
}
