process.c File Reference

#include <fcntl.h>
#include <io.h>
#include <process.h>
#include <stdarg.h>
#include "msvcrt.h"
#include <winnls.h>
#include "mtdll.h"
#include "wine/debug.h"

Include dependency graph for process.c:

Go to the source code of this file.

Classes
struct	popen_handle

Functions
	WINE_DEFAULT_DEBUG_CHANNEL (msvcrt)
static void	msvcrt_search_executable (const wchar_t *name, wchar_t *fullname, int use_path)
static intptr_t	msvcrt_spawn (int flags, const wchar_t *exe, wchar_t *cmdline, wchar_t *env, int use_path)
static wchar_t *	msvcrt_argvtos (const wchar_t *const *arg, wchar_t delim)
static wchar_t *	msvcrt_argvtos_aw (const char *const *arg, BOOL env)
static wchar_t *	msvcrt_valisttos (const wchar_t *arg0, va_list alist, wchar_t delim)
static wchar_t *	msvcrt_valisttos_aw (const char *arg0, va_list alist, wchar_t delim)
static wchar_t *	msvcrt_get_comspec (void)
intptr_t CDECL	_cwait (int *status, intptr_t pid, int action)
intptr_t WINAPIV	_wexecl (const wchar_t *name, const wchar_t *arg0,...)
intptr_t WINAPIV	_execl (const char *name, const char *arg0,...)
intptr_t WINAPIV	_wexecle (const wchar_t *name, const wchar_t *arg0,...)
intptr_t WINAPIV	_execle (const char *name, const char *arg0,...)
intptr_t WINAPIV	_wexeclp (const wchar_t *name, const wchar_t *arg0,...)
intptr_t WINAPIV	_execlp (const char *name, const char *arg0,...)
intptr_t WINAPIV	_wexeclpe (const wchar_t *name, const wchar_t *arg0,...)
intptr_t WINAPIV	_execlpe (const char *name, const char *arg0,...)
intptr_t CDECL	_wexecv (const wchar_t *name, const wchar_t *const *argv)
intptr_t CDECL	_execv (const char *name, const char *const *argv)
intptr_t CDECL	_wexecve (const wchar_t *name, const wchar_t *const *argv, const wchar_t *const *envv)
intptr_t CDECL	_execve (const char *name, const char *const *argv, const char *const *envv)
intptr_t CDECL	_wexecvpe (const wchar_t *name, const wchar_t *const *argv, const wchar_t *const *envv)
intptr_t CDECL	_execvpe (const char *name, const char *const *argv, const char *const *envv)
intptr_t CDECL	_wexecvp (const wchar_t *name, const wchar_t *const *argv)
intptr_t CDECL	_execvp (const char *name, const char *const *argv)
intptr_t WINAPIV	_wspawnl (int flags, const wchar_t *name, const wchar_t *arg0,...)
intptr_t WINAPIV	_spawnl (int flags, const char *name, const char *arg0,...)
intptr_t WINAPIV	_wspawnle (int flags, const wchar_t *name, const wchar_t *arg0,...)
intptr_t WINAPIV	_spawnle (int flags, const char *name, const char *arg0,...)
intptr_t WINAPIV	_wspawnlp (int flags, const wchar_t *name, const wchar_t *arg0,...)
intptr_t WINAPIV	_spawnlp (int flags, const char *name, const char *arg0,...)
intptr_t WINAPIV	_wspawnlpe (int flags, const wchar_t *name, const wchar_t *arg0,...)
intptr_t WINAPIV	_spawnlpe (int flags, const char *name, const char *arg0,...)
intptr_t CDECL	_spawnve (int flags, const char *name, const char *const *argv, const char *const *envv)
intptr_t CDECL	_wspawnve (int flags, const wchar_t *name, const wchar_t *const *argv, const wchar_t *const *envv)
intptr_t CDECL	_spawnv (int flags, const char *name, const char *const *argv)
intptr_t CDECL	_wspawnv (int flags, const wchar_t *name, const wchar_t *const *argv)
intptr_t CDECL	_spawnvpe (int flags, const char *name, const char *const *argv, const char *const *envv)
intptr_t CDECL	_wspawnvpe (int flags, const wchar_t *name, const wchar_t *const *argv, const wchar_t *const *envv)
intptr_t CDECL	_spawnvp (int flags, const char *name, const char *const *argv)
intptr_t CDECL	_wspawnvp (int flags, const wchar_t *name, const wchar_t *const *argv)
void	msvcrt_free_popen_data (void)
FILE *CDECL	_wpopen (const wchar_t *command, const wchar_t *mode)
FILE *CDECL	_popen (const char *command, const char *mode)
int CDECL	_pclose (FILE *file)
int CDECL	_wsystem (const wchar_t *cmd)
int CDECL	system (const char *cmd)
intptr_t CDECL	_loaddll (const char *dllname)
int CDECL	_unloaddll (intptr_t dll)
void *CDECL	_getdllprocaddr (intptr_t dll, const char *name, int ordinal)
int CDECL	_getpid (void)

Variables
static struct popen_handle *	popen_handles
static DWORD	popen_handles_size

Function Documentation

_cwait()

intptr_t CDECL _cwait	(	int *	status,
		intptr_t	pid,
		int	action
	)

Definition at line 362 of file process.c.

{
  HANDLE hPid = (HANDLE)pid;
  int doserrno;
 
  if (!WaitForSingleObject(hPid, INFINITE))
  {
    if (status)
    {
      DWORD stat;
      GetExitCodeProcess(hPid, &stat);
      *status = (int)stat;
    }
    return pid;
  }
  doserrno = GetLastError();
 
  if (doserrno == ERROR_INVALID_HANDLE)
  {
    *_errno() =  ECHILD;
    *__doserrno() = doserrno;
  }
  else
    msvcrt_set_errno(doserrno);
 
  return status ? *status = -1 : -1;
}

_execl()

intptr_t WINAPIV _execl	(	const char *	name,
		const char *	arg0,
			...
	)

Definition at line 417 of file process.c.

{
  va_list ap;
  wchar_t *nameW, *args;
  intptr_t ret;
 
  if (!(nameW = wstrdupa_utf8(name))) return -1;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos_aw(arg0, ap, ' ');
  va_end(ap);
 
  ret = msvcrt_spawn(_P_OVERLAY, nameW, args, NULL, 0);
 
  free(nameW);
  free(args);
  return ret;
}

_execle()

intptr_t WINAPIV _execle	(	const char *	name,
		const char *	arg0,
			...
	)

Definition at line 468 of file process.c.

{
  va_list ap;
  wchar_t *nameW, *args, *envs = NULL;
  const char * const *envp;
  intptr_t ret;
 
  if (!(nameW = wstrdupa_utf8(name))) return -1;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos_aw(arg0, ap, ' ');
  va_end(ap);
 
  va_start(ap, arg0);
  while (va_arg( ap, char * ) != NULL) /*nothing*/;
  envp = va_arg( ap, const char * const * );
  if (envp) envs = msvcrt_argvtos_aw(envp, TRUE);
  va_end(ap);
 
  ret = msvcrt_spawn(_P_OVERLAY, nameW, args, envs, 0);
 
  free(nameW);
  free(args);
  free(envs);
  return ret;
}

_execlp()

intptr_t WINAPIV _execlp	(	const char *	name,
		const char *	arg0,
			...
	)

Definition at line 522 of file process.c.

{
  va_list ap;
  wchar_t *nameW, *args;
  intptr_t ret;
 
  if (!(nameW = wstrdupa_utf8(name))) return -1;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos_aw(arg0, ap, ' ');
  va_end(ap);
 
  ret = msvcrt_spawn(_P_OVERLAY, nameW, args, NULL, 1);
 
  free(nameW);
  free(args);
  return ret;
}

_execlpe()

intptr_t WINAPIV _execlpe	(	const char *	name,
		const char *	arg0,
			...
	)

Definition at line 573 of file process.c.

{
  va_list ap;
  wchar_t *nameW, *args, *envs = NULL;
  const char * const *envp;
  intptr_t ret;
 
  if (!(nameW = wstrdupa_utf8(name))) return -1;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos_aw(arg0, ap, ' ');
  va_end(ap);
 
  va_start(ap, arg0);
  while (va_arg( ap, char * ) != NULL) /*nothing*/;
  envp = va_arg( ap, const char * const * );
  if (envp) envs = msvcrt_argvtos_aw(envp, TRUE);
  va_end(ap);
 
  ret = msvcrt_spawn(_P_OVERLAY, nameW, args, envs, 1);
 
  free(nameW);
  free(args);
  free(envs);
  return ret;
}

_execv()

intptr_t CDECL _execv	(	const char *	name,
		const char *const *	argv
	)

Definition at line 616 of file process.c.

{
  return _spawnve(_P_OVERLAY, name, argv, NULL);
}

_execve()

intptr_t CDECL _execve	(	const char *	name,
		const char *const *	argv,
		const char *const *	envv
	)

Definition at line 637 of file process.c.

{
  return _spawnve(_P_OVERLAY, name, argv, envv);
}

_execvp()

intptr_t CDECL _execvp	(	const char *	name,
		const char *const *	argv
	)

Definition at line 679 of file process.c.

{
  return _execvpe(name, argv, NULL);
}

_execvpe()

intptr_t CDECL _execvpe	(	const char *	name,
		const char *const *	argv,
		const char *const *	envv
	)

Definition at line 658 of file process.c.

{
  return _spawnvpe(_P_OVERLAY, name, argv, envv);
}

Referenced by _execvp().

_getdllprocaddr()

void *CDECL _getdllprocaddr	(	intptr_t	dll,
		const char *	name,
		int	ordinal
	)

Definition at line 1346 of file process.c.

{
    if (name)
    {
        if (ordinal != -1) return NULL;
        return GetProcAddress( (HMODULE)dll, name );
    }
    if (HIWORD(ordinal)) return NULL;
    return GetProcAddress( (HMODULE)dll, (LPCSTR)(ULONG_PTR)ordinal );
}

_getpid()

int CDECL _getpid

(

void

)

Definition at line 1360 of file process.c.

{
    return GetCurrentProcessId();
}

_loaddll()

intptr_t CDECL _loaddll

(

const char *

dllname

)

Definition at line 1317 of file process.c.

{
    wchar_t *dllnameW = NULL;
    intptr_t ret;
 
    if (dllname && !(dllnameW = wstrdupa_utf8(dllname))) return 0;
    ret = (intptr_t)LoadLibraryW(dllnameW);
    free(dllnameW);
    return ret;
}

_pclose()

int CDECL _pclose

(

FILE *

file

)

Definition at line 1212 of file process.c.

{
  HANDLE h;
  DWORD i;
 
  if (!MSVCRT_CHECK_PMT(file != NULL)) return -1;
 
  _lock(_POPEN_LOCK);
  for(i=0; i<popen_handles_size; i++)
  {
    if (popen_handles[i].f == file)
      break;
  }
  if(i == popen_handles_size)
  {
    _unlock(_POPEN_LOCK);
    *_errno() = EBADF;
    return -1;
  }
 
  h = popen_handles[i].proc;
  popen_handles[i].f = NULL;
  _unlock(_POPEN_LOCK);
 
  fclose(file);
  if(WaitForSingleObject(h, INFINITE)==WAIT_FAILED || !GetExitCodeProcess(h, &i))
  {
    msvcrt_set_errno(GetLastError());
    CloseHandle(h);
    return -1;
  }
 
  CloseHandle(h);
  return i;
}

_popen()

FILE *CDECL _popen	(	const char *	command,
		const char *	mode
	)

Definition at line 1185 of file process.c.

{
  FILE *ret;
  wchar_t *cmdW, *modeW;
 
  TRACE("(command=%s, mode=%s)\n", debugstr_a(command), debugstr_a(mode));
 
  if (!command || !mode)
    return NULL;
 
  if (!(cmdW = wstrdupa_utf8(command))) return NULL;
  if (!(modeW = msvcrt_wstrdupa(mode)))
  {
    free(cmdW);
    return NULL;
  }
 
  ret = _wpopen(cmdW, modeW);
 
  free(cmdW);
  free(modeW);
  return ret;
}

_spawnl()

intptr_t WINAPIV _spawnl	(	int	flags,
		const char *	name,
		const char *	arg0,
			...
	)

Definition at line 711 of file process.c.

{
  va_list ap;
  wchar_t *nameW, *args;
  intptr_t ret;
 
  if (!(nameW = wstrdupa_utf8(name))) return -1;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos_aw(arg0, ap, ' ');
  va_end(ap);
 
  ret = msvcrt_spawn(flags, nameW, args, NULL, 0);
 
  free(nameW);
  free(args);
  return ret;
}

_spawnle()

intptr_t WINAPIV _spawnle	(	int	flags,
		const char *	name,
		const char *	arg0,
			...
	)

Definition at line 762 of file process.c.

{
  va_list ap;
  wchar_t *nameW, *args, *envs = NULL;
  const char * const *envp;
  intptr_t ret;
 
  if (!(nameW = wstrdupa_utf8(name))) return -1;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos_aw(arg0, ap, ' ');
  va_end(ap);
 
  va_start(ap, arg0);
  while (va_arg( ap, char * ) != NULL) /*nothing*/;
  envp = va_arg( ap, const char * const * );
  if (envp) envs = msvcrt_argvtos_aw(envp, TRUE);
  va_end(ap);
 
  ret = msvcrt_spawn(flags, nameW, args, envs, 0);
 
  free(nameW);
  free(args);
  free(envs);
  return ret;
}

_spawnlp()

intptr_t WINAPIV _spawnlp	(	int	flags,
		const char *	name,
		const char *	arg0,
			...
	)

Definition at line 816 of file process.c.

{
  va_list ap;
  wchar_t *nameW, *args;
  intptr_t ret;
 
  if (!(nameW = wstrdupa_utf8(name))) return -1;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos_aw(arg0, ap, ' ');
  va_end(ap);
 
  ret = msvcrt_spawn(flags, nameW, args, NULL, 1);
 
  free(nameW);
  free(args);
  return ret;
}

_spawnlpe()

intptr_t WINAPIV _spawnlpe	(	int	flags,
		const char *	name,
		const char *	arg0,
			...
	)

Definition at line 867 of file process.c.

{
  va_list ap;
  wchar_t *nameW, *args, *envs = NULL;
  const char * const *envp;
  intptr_t ret;
 
  if (!(nameW = wstrdupa_utf8(name))) return -1;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos_aw(arg0, ap, ' ');
  va_end(ap);
 
  va_start(ap, arg0);
  while (va_arg( ap, char * ) != NULL) /*nothing*/;
  envp = va_arg( ap, const char * const * );
  if (envp) envs = msvcrt_argvtos_aw(envp, TRUE);
  va_end(ap);
 
  ret = msvcrt_spawn(flags, nameW, args, envs, 1);
 
  free(nameW);
  free(args);
  free(envs);
  return ret;
}

_spawnv()

intptr_t CDECL _spawnv	(	int	flags,
		const char *	name,
		const char *const *	argv
	)

Definition at line 946 of file process.c.

{
  return _spawnve(flags, name, argv, NULL);
}

_spawnve()

intptr_t CDECL _spawnve	(	int	flags,
		const char *	name,
		const char *const *	argv,
		const char *const *	envv
	)

Definition at line 900 of file process.c.

{
  wchar_t *nameW, *args, *envs;
  intptr_t ret;
 
  if (!(nameW = wstrdupa_utf8(name))) return -1;
 
  args = msvcrt_argvtos_aw(argv, FALSE);
  envs = msvcrt_argvtos_aw(envv, TRUE);
 
  ret = msvcrt_spawn(flags, nameW, args, envs, 0);
 
  free(nameW);
  free(args);
  free(envs);
  return ret;
}

Referenced by _execv(), _execve(), and _spawnv().

_spawnvp()

intptr_t CDECL _spawnvp	(	int	flags,
		const char *	name,
		const char *const *	argv
	)

Definition at line 1013 of file process.c.

{
  return _spawnvpe(flags, name, argv, NULL);
}

_spawnvpe()

intptr_t CDECL _spawnvpe	(	int	flags,
		const char *	name,
		const char *const *	argv,
		const char *const *	envv
	)

Definition at line 967 of file process.c.

{
  wchar_t *nameW, *args, *envs;
  intptr_t ret;
 
  if (!(nameW = wstrdupa_utf8(name))) return -1;
 
  args = msvcrt_argvtos_aw(argv, FALSE);
  envs = msvcrt_argvtos_aw(envv, TRUE);
 
  ret = msvcrt_spawn(flags, nameW, args, envs, 1);
 
  free(nameW);
  free(args);
  free(envs);
  return ret;
}

Referenced by _execvpe(), and _spawnvp().

_unloaddll()

int CDECL _unloaddll

(

intptr_t

dll

)

Definition at line 1331 of file process.c.

{
  if (FreeLibrary((HMODULE)dll))
    return 0;
  else
  {
    int err = GetLastError();
    msvcrt_set_errno(err);
    return err;
  }
}

_wexecl()

intptr_t WINAPIV _wexecl	(	const wchar_t *	name,
		const wchar_t *	arg0,
			...
	)

This file has no copyright assigned and is placed in the Public Domain. This file is part of the Wine project.

Definition at line 395 of file process.c.

{
  va_list ap;
  wchar_t *args;
  intptr_t ret;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos(arg0, ap, ' ');
  va_end(ap);
 
  ret = msvcrt_spawn(_P_OVERLAY, name, args, NULL, 0);
 
  free(args);
  return ret;
}

_wexecle()

intptr_t WINAPIV _wexecle	(	const wchar_t *	name,
		const wchar_t *	arg0,
			...
	)

Definition at line 441 of file process.c.

{
  va_list ap;
  wchar_t *args, *envs = NULL;
  const wchar_t * const *envp;
  intptr_t ret;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos(arg0, ap, ' ');
  va_end(ap);
 
  va_start(ap, arg0);
  while (va_arg( ap, wchar_t * ) != NULL) /*nothing*/;
  envp = va_arg( ap, const wchar_t * const * );
  if (envp) envs = msvcrt_argvtos(envp, 0);
  va_end(ap);
 
  ret = msvcrt_spawn(_P_OVERLAY, name, args, envs, 0);
 
  free(args);
  free(envs);
  return ret;
}

_wexeclp()

intptr_t WINAPIV _wexeclp	(	const wchar_t *	name,
		const wchar_t *	arg0,
			...
	)

Definition at line 500 of file process.c.

{
  va_list ap;
  wchar_t *args;
  intptr_t ret;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos(arg0, ap, ' ');
  va_end(ap);
 
  ret = msvcrt_spawn(_P_OVERLAY, name, args, NULL, 1);
 
  free(args);
  return ret;
}

_wexeclpe()

intptr_t WINAPIV _wexeclpe	(	const wchar_t *	name,
		const wchar_t *	arg0,
			...
	)

Definition at line 546 of file process.c.

{
  va_list ap;
  wchar_t *args, *envs = NULL;
  const wchar_t * const *envp;
  intptr_t ret;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos(arg0, ap, ' ');
  va_end(ap);
 
  va_start(ap, arg0);
  while (va_arg( ap, wchar_t * ) != NULL) /*nothing*/;
  envp = va_arg( ap, const wchar_t * const * );
  if (envp) envs = msvcrt_argvtos(envp, 0);
  va_end(ap);
 
  ret = msvcrt_spawn(_P_OVERLAY, name, args, envs, 1);
 
  free(args);
  free(envs);
  return ret;
}

_wexecv()

intptr_t CDECL _wexecv	(	const wchar_t *	name,
		const wchar_t *const *	argv
	)

Definition at line 605 of file process.c.

{
  return _wspawnve(_P_OVERLAY, name, argv, NULL);
}

_wexecve()

intptr_t CDECL _wexecve	(	const wchar_t *	name,
		const wchar_t *const *	argv,
		const wchar_t *const *	envv
	)

Definition at line 626 of file process.c.

{
  return _wspawnve(_P_OVERLAY, name, argv, envv);
}

_wexecvp()

intptr_t CDECL _wexecvp	(	const wchar_t *	name,
		const wchar_t *const *	argv
	)

Definition at line 668 of file process.c.

{
  return _wexecvpe(name, argv, NULL);
}

_wexecvpe()

intptr_t CDECL _wexecvpe	(	const wchar_t *	name,
		const wchar_t *const *	argv,
		const wchar_t *const *	envv
	)

Definition at line 647 of file process.c.

{
  return _wspawnvpe(_P_OVERLAY, name, argv, envv);
}

Referenced by _wexecvp().

_wpopen()

FILE *CDECL _wpopen	(	const wchar_t *	command,
		const wchar_t *	mode
	)

Definition at line 1044 of file process.c.

{
    wchar_t *comspec, *fullcmd, fullname[MAX_PATH];
    int textmode, fds[2], fd_parent, fd_child;
    struct popen_handle *container;
    PROCESS_INFORMATION pi;
    BOOL read_pipe = TRUE;
    const wchar_t *p;
    unsigned int len;
    STARTUPINFOW si;
    FILE *ret;
    DWORD i;
    BOOL r;
 
    TRACE("(command=%s, mode=%s)\n", debugstr_w(command), debugstr_w(mode));
 
    if (!command || !mode)
        return NULL;
 
    _get_fmode(&textmode);
    textmode &= _O_BINARY | _O_TEXT;
    textmode |= _O_NOINHERIT;
    for (p = mode; *p; p++)
    {
        switch (*p)
        {
        case 'W':
        case 'w':
            read_pipe = FALSE;
            break;
        case 'B':
        case 'b':
            textmode |= _O_BINARY;
            textmode &= ~_O_TEXT;
            break;
        case 'T':
        case 't':
            textmode |= _O_TEXT;
            textmode &= ~_O_BINARY;
            break;
        }
    }
    if (_pipe(fds, 0, textmode) == -1)
        return NULL;
 
    if (read_pipe)
    {
        fd_parent = fds[0];
        fd_child = _dup(fds[1]);
        _close(fds[1]);
    }
    else
    {
        fd_parent = fds[1];
        fd_child = _dup(fds[0]);
        _close(fds[0]);
    }
    if (fd_child == -1)
    {
        _close(fd_parent);
        return NULL;
    }
    ret = _wfdopen(fd_parent, mode);
    if (!ret)
    {
        _close(fd_child);
        return NULL;
    }
 
    _lock(_POPEN_LOCK);
    for (i = 0; i < popen_handles_size; i++)
    {
        if (!popen_handles[i].f)
            break;
    }
    if (i == popen_handles_size)
    {
        i = (popen_handles_size ? popen_handles_size * 2 : 8);
        container = realloc(popen_handles, i * sizeof(*container));
        if (!container) goto error;
 
        popen_handles = container;
        container = popen_handles + popen_handles_size;
        memset(container, 0, (i - popen_handles_size) * sizeof(*container));
        popen_handles_size = i;
    }
    else container = popen_handles + i;
 
    if (!(comspec = msvcrt_get_comspec())) goto error;
    len = wcslen(comspec) + wcslen(command) + 5;
 
    if (!(fullcmd = HeapAlloc(GetProcessHeap(), 0, len * sizeof(wchar_t))))
    {
        HeapFree(GetProcessHeap(), 0, comspec);
        goto error;
    }
 
    wcscpy(fullcmd, comspec);
    wcscat(fullcmd, L" /c ");
    wcscat(fullcmd, command);
    msvcrt_search_executable(comspec, fullname, 1);
 
    memset(&si, 0, sizeof(si));
    si.cb = sizeof(si);
    si.dwFlags = STARTF_USESTDHANDLES;
    if (read_pipe)
    {
        si.hStdInput = (HANDLE)_get_osfhandle(STDIN_FILENO);
        si.hStdOutput = (HANDLE)_get_osfhandle(fd_child);
    }
    else
    {
        si.hStdInput = (HANDLE)_get_osfhandle(fd_child);
        si.hStdOutput = (HANDLE)_get_osfhandle(STDOUT_FILENO);
    }
    si.hStdError = (HANDLE)_get_osfhandle(STDERR_FILENO);
    r = CreateProcessW(fullname, fullcmd, NULL, NULL, TRUE, 0, NULL, NULL, &si, &pi);
    HeapFree(GetProcessHeap(), 0, comspec);
    HeapFree(GetProcessHeap(), 0, fullcmd);
    if (!r)
    {
        msvcrt_set_errno(GetLastError());
        goto error;
    }
    CloseHandle(pi.hThread);
    _close(fd_child);
    container->proc = pi.hProcess;
    container->f = ret;
    _unlock(_POPEN_LOCK);
    return ret;
 
error:
    _unlock(_POPEN_LOCK);
    _close(fd_child);
    fclose(ret);
    return NULL;
}

Referenced by _popen().

_wspawnl()

intptr_t WINAPIV _wspawnl	(	int	flags,
		const wchar_t *	name,
		const wchar_t *	arg0,
			...
	)

Definition at line 689 of file process.c.

{
  va_list ap;
  wchar_t *args;
  intptr_t ret;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos(arg0, ap, ' ');
  va_end(ap);
 
  ret = msvcrt_spawn(flags, name, args, NULL, 0);
 
  free(args);
  return ret;
}

_wspawnle()

intptr_t WINAPIV _wspawnle	(	int	flags,
		const wchar_t *	name,
		const wchar_t *	arg0,
			...
	)

Definition at line 735 of file process.c.

{
  va_list ap;
  wchar_t *args, *envs = NULL;
  const wchar_t * const *envp;
  intptr_t ret;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos(arg0, ap, ' ');
  va_end(ap);
 
  va_start(ap, arg0);
  while (va_arg( ap, wchar_t * ) != NULL) /*nothing*/;
  envp = va_arg( ap, const wchar_t * const * );
  if (envp) envs = msvcrt_argvtos(envp, 0);
  va_end(ap);
 
  ret = msvcrt_spawn(flags, name, args, envs, 0);
 
  free(args);
  free(envs);
  return ret;
}

_wspawnlp()

intptr_t WINAPIV _wspawnlp	(	int	flags,
		const wchar_t *	name,
		const wchar_t *	arg0,
			...
	)

Definition at line 794 of file process.c.

{
  va_list ap;
  wchar_t *args;
  intptr_t ret;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos(arg0, ap, ' ');
  va_end(ap);
 
  ret = msvcrt_spawn(flags, name, args, NULL, 1);
 
  free(args);
  return ret;
}

_wspawnlpe()

intptr_t WINAPIV _wspawnlpe	(	int	flags,
		const wchar_t *	name,
		const wchar_t *	arg0,
			...
	)

Definition at line 840 of file process.c.

{
  va_list ap;
  wchar_t *args, *envs = NULL;
  const wchar_t * const *envp;
  intptr_t ret;
 
  va_start(ap, arg0);
  args = msvcrt_valisttos(arg0, ap, ' ');
  va_end(ap);
 
  va_start(ap, arg0);
  while (va_arg( ap, wchar_t * ) != NULL) /*nothing*/;
  envp = va_arg( ap, const wchar_t * const * );
  if (envp) envs = msvcrt_argvtos(envp, 0);
  va_end(ap);
 
  ret = msvcrt_spawn(flags, name, args, envs, 1);
 
  free(args);
  free(envs);
  return ret;
}

_wspawnv()

intptr_t CDECL _wspawnv	(	int	flags,
		const wchar_t *	name,
		const wchar_t *const *	argv
	)

Definition at line 956 of file process.c.

{
  return _wspawnve(flags, name, argv, NULL);
}

_wspawnve()

intptr_t CDECL _wspawnve	(	int	flags,
		const wchar_t *	name,
		const wchar_t *const *	argv,
		const wchar_t *const *	envv
	)

Definition at line 924 of file process.c.

{
  wchar_t *args, *envs;
  intptr_t ret;
 
  args = msvcrt_argvtos(argv, ' ');
  envs = msvcrt_argvtos(envv, 0);
 
  ret = msvcrt_spawn(flags, name, args, envs, 0);
 
  free(args);
  free(envs);
  return ret;
}

Referenced by _wexecv(), _wexecve(), and _wspawnv().

_wspawnvp()

intptr_t CDECL _wspawnvp	(	int	flags,
		const wchar_t *	name,
		const wchar_t *const *	argv
	)

Definition at line 1023 of file process.c.

{
  return _wspawnvpe(flags, name, argv, NULL);
}

_wspawnvpe()

intptr_t CDECL _wspawnvpe	(	int	flags,
		const wchar_t *	name,
		const wchar_t *const *	argv,
		const wchar_t *const *	envv
	)

Definition at line 991 of file process.c.

{
  wchar_t *args, *envs;
  intptr_t ret;
 
  args = msvcrt_argvtos(argv, ' ');
  envs = msvcrt_argvtos(envv, 0);
 
  ret = msvcrt_spawn(flags, name, args, envs, 1);
 
  free(args);
  free(envs);
  return ret;
}

Referenced by _wexecvpe(), and _wspawnvp().

_wsystem()

int CDECL _wsystem

(

const wchar_t *

cmd

)

Definition at line 1254 of file process.c.

{
  int res;
  wchar_t *comspec, *fullcmd;
  unsigned int len;
 
  comspec = msvcrt_get_comspec();
 
  if (cmd == NULL)
  {
    if (comspec == NULL)
    {
        *_errno() = ENOENT;
        return 0;
    }
    HeapFree(GetProcessHeap(), 0, comspec);
    return 1;
  }
 
  if (comspec == NULL)
    return -1;
 
  len = wcslen(comspec) + wcslen(cmd) + 5;
 
  if (!(fullcmd = HeapAlloc(GetProcessHeap(), 0, len * sizeof(wchar_t))))
  {
    HeapFree(GetProcessHeap(), 0, comspec);
    return -1;
  }
  wcscpy(fullcmd, comspec);
  wcscat(fullcmd, L" /c ");
  wcscat(fullcmd, cmd);
 
  res = msvcrt_spawn(_P_WAIT, comspec, fullcmd, NULL, 1);
 
  HeapFree(GetProcessHeap(), 0, comspec);
  HeapFree(GetProcessHeap(), 0, fullcmd);
  return res;
}

Referenced by system().

msvcrt_argvtos()

static wchar_t * msvcrt_argvtos ( const wchar_t *const *  arg, wchar_t  delim  )

static

Definition at line 191 of file process.c.

{
  const wchar_t* const* a;
  int size;
  wchar_t* p;
  wchar_t* ret;
 
  if (!arg)
  {
      /* Return NULL for an empty environment list */
      return NULL;
  }
 
  /* get length */
  a = arg;
  size = 0;
  while (*a)
  {
    size += wcslen(*a) + 1;
    a++;
  }
 
  ret = malloc((size + 1) * sizeof(wchar_t));
  if (!ret)
    return NULL;
 
  /* fill string */
  a = arg;
  p = ret;
  while (*a)
  {
    int len = wcslen(*a);
    memcpy(p,*a,len * sizeof(wchar_t));
    p += len;
    *p++ = delim;
    a++;
  }
  if (delim && p > ret) p[-1] = 0;
  else *p = 0;
  return ret;
}

Referenced by _wexecle(), _wexeclpe(), _wspawnle(), _wspawnlpe(), _wspawnve(), and _wspawnvpe().

msvcrt_argvtos_aw()

static wchar_t * msvcrt_argvtos_aw ( const char *const *  arg, BOOL  env  )

static

Definition at line 236 of file process.c.

{
  UINT cp = env ? CP_ACP : get_aw_cp();
  const char * const *a;
  unsigned int len;
  wchar_t *p, *ret;
 
  if (!arg)
  {
      /* Return NULL for an empty environment list */
      return NULL;
  }
 
  /* get length */
  a = arg;
  len = 0;
  while (*a)
  {
    len += MultiByteToWideChar(cp, 0, *a, -1, NULL, 0);
    a++;
  }
 
  ret = malloc((len + 1) * sizeof(wchar_t));
  if (!ret)
    return NULL;
 
  /* fill string */
  a = arg;
  p = ret;
  while (*a)
  {
    p += MultiByteToWideChar(cp, 0, *a, strlen(*a), p, len - (p - ret));
    *p++ = env ? 0 : ' ';
    a++;
  }
  if (!env && p > ret) p[-1] = 0;
  else *p = 0;
  return ret;
}

Referenced by _execle(), _execlpe(), _spawnle(), _spawnlpe(), _spawnve(), and _spawnvpe().

msvcrt_free_popen_data()

void msvcrt_free_popen_data

(

void

)

Definition at line 1034 of file process.c.

{
    free(popen_handles);
}

msvcrt_get_comspec()

static wchar_t * msvcrt_get_comspec ( void  )

static

Definition at line 346 of file process.c.

{
  wchar_t *ret;
  unsigned int len;
 
  if (!(len = GetEnvironmentVariableW(L"COMSPEC", NULL, 0))) len = 4;
  if ((ret = HeapAlloc(GetProcessHeap(), 0, len * sizeof(wchar_t))))
  {
    if (!GetEnvironmentVariableW(L"COMSPEC", ret, len)) wcscpy(ret, L"cmd");
  }
  return ret;
}

Referenced by _wpopen(), and _wsystem().

msvcrt_search_executable()

static void msvcrt_search_executable ( const wchar_t *  name, wchar_t *  fullname, int  use_path  )

static

Definition at line 42 of file process.c.

{
  static const wchar_t suffix[][5] =
    {L".com", L".exe", L".bat", L".cmd"};
 
  wchar_t buffer[MAX_PATH];
  const wchar_t *env, *p, *end;
  unsigned int i, name_len, path_len;
  int extension = 1;
 
  *fullname = '\0';
#ifndef __REACTOS__
  msvcrt_set_errno(ERROR_FILE_NOT_FOUND);
#endif
 
  end = name + MAX_PATH - 1;
  for(p = name; p < end; p++)
      if(!*p) break;
  name_len = p - name;
 
  /* FIXME extra-long names are silently truncated */
  memcpy(buffer, name, name_len * sizeof(wchar_t));
  buffer[name_len] = '\0';
 
  /* try current dir first */
  if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
  {
    wcscpy(fullname, buffer);
    return;
  }
 
  for (p--; p >= name; p--)
    if (*p == '\\' || *p == '/' || *p == ':' || *p == '.') break;
 
  /* if there's no extension, try some well-known extensions */
  if ((p < name || *p != '.') && name_len <= MAX_PATH - 5)
  {
    for (i = 0; i < 4; i++)
    {
      memcpy(buffer + name_len, suffix[i], 5 * sizeof(wchar_t));
      if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
      {
        wcscpy(fullname, buffer);
        return;
      }
    }
    extension = 0;
  }
 
  if (!use_path || !(env = _wgetenv(L"PATH"))) return;
 
  /* now try search path */
  do
  {
    p = env;
    while (*p && *p != ';') p++;
    if (p == env) return;
 
    path_len = p - env;
    if (path_len + name_len <= MAX_PATH - 2)
    {
      memcpy(buffer, env, path_len * sizeof(wchar_t));
      if (buffer[path_len] != '/' && buffer[path_len] != '\\')
      {
        buffer[path_len++] = '\\';
        buffer[path_len] = '\0';
      }
      else buffer[path_len] = '\0';
 
      wcscat(buffer, name);
      if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
      {
        wcscpy(fullname, buffer);
        return;
      }
    }
    /* again, if there's no extension, try some well-known extensions */
    if (!extension && path_len + name_len <= MAX_PATH - 5)
    {
      for (i = 0; i < 4; i++)
      {
        memcpy(buffer + path_len + name_len, suffix[i], 5 * sizeof(wchar_t));
        if (GetFileAttributesW(buffer) != INVALID_FILE_ATTRIBUTES)
        {
          wcscpy(fullname, buffer);
          return;
        }
      }
    }
    env = *p ? p + 1 : p;
  } while(1);
}

Referenced by _wpopen(), and msvcrt_spawn().

msvcrt_spawn()

static intptr_t msvcrt_spawn ( int  flags, const wchar_t *  exe, wchar_t *  cmdline, wchar_t *  env, int  use_path  )

static

Definition at line 135 of file process.c.

{
  STARTUPINFOW si;
  PROCESS_INFORMATION pi;
  wchar_t fullname[MAX_PATH];
  DWORD create_flags = CREATE_UNICODE_ENVIRONMENT;
 
  TRACE("%x %s %s %s %d\n", flags, debugstr_w(exe), debugstr_w(cmdline), debugstr_w(env), use_path);
 
  if ((unsigned)flags > _P_DETACH)
  {
    *_errno() = EINVAL;
    return -1;
  }
 
  msvcrt_search_executable(exe, fullname, use_path);
 
  memset(&si, 0, sizeof(si));
  si.cb = sizeof(si);
  msvcrt_create_io_inherit_block(&si.cbReserved2, &si.lpReserved2);
  if (flags == _P_DETACH) create_flags |= DETACHED_PROCESS;
  if (!CreateProcessW(fullname, cmdline, NULL, NULL, TRUE,
                      create_flags, env, NULL, &si, &pi))
  {
    msvcrt_set_errno(GetLastError());
    free(si.lpReserved2);
    return -1;
  }
 
  free(si.lpReserved2);
  switch(flags)
  {
  case _P_WAIT:
    WaitForSingleObject(pi.hProcess, INFINITE);
    GetExitCodeProcess(pi.hProcess,&pi.dwProcessId);
    CloseHandle(pi.hProcess);
    CloseHandle(pi.hThread);
    return pi.dwProcessId;
  case _P_DETACH:
    CloseHandle(pi.hProcess);
    pi.hProcess = 0;
    /* fall through */
  case _P_NOWAIT:
  case _P_NOWAITO:
    CloseHandle(pi.hThread);
    return (intptr_t)pi.hProcess;
  case  _P_OVERLAY:
    _exit(0);
  }
  return -1; /* can't reach here */
}

Referenced by _execl(), _execle(), _execlp(), _execlpe(), _spawnl(), _spawnle(), _spawnlp(), _spawnlpe(), _spawnve(), _spawnvpe(), _wexecl(), _wexecle(), _wexeclp(), _wexeclpe(), _wspawnl(), _wspawnle(), _wspawnlp(), _wspawnlpe(), _wspawnve(), _wspawnvpe(), and _wsystem().

msvcrt_valisttos()

static wchar_t * msvcrt_valisttos ( const wchar_t *  arg0, va_list  alist, wchar_t  delim  )

static

Definition at line 279 of file process.c.

{
    unsigned int size = 0, pos = 0;
    const wchar_t *arg;
    wchar_t *new, *ret = NULL;
 
    for (arg = arg0; arg; arg = va_arg( alist, wchar_t * ))
    {
        unsigned int len = wcslen( arg ) + 1;
        if (pos + len >= size)
        {
            size = max( 256, size * 2 );
            size = max( size, pos + len + 1 );
            if (!(new = realloc( ret, size * sizeof(wchar_t) )))
            {
                free( ret );
                return NULL;
            }
            ret = new;
        }
        wcscpy( ret + pos, arg );
        pos += len;
        ret[pos - 1] = delim;
    }
    if (pos)
    {
        if (delim) ret[pos - 1] = 0;
        else ret[pos] = 0;
    }
    return ret;
}

Referenced by _wexecl(), _wexecle(), _wexeclp(), _wexeclpe(), _wspawnl(), _wspawnle(), _wspawnlp(), and _wspawnlpe().

msvcrt_valisttos_aw()

static wchar_t * msvcrt_valisttos_aw ( const char *  arg0, va_list  alist, wchar_t  delim  )

static

Definition at line 314 of file process.c.

{
    unsigned int size = 0, pos = 0;
    const char *arg;
    wchar_t *new, *ret = NULL;
 
    for (arg = arg0; arg; arg = va_arg( alist, char * ))
    {
        unsigned int len = convert_acp_utf8_to_wcs( arg, NULL, 0 );
        if (pos + len >= size)
        {
            size = max( 256, size * 2 );
            size = max( size, pos + len + 1 );
            if (!(new = realloc( ret, size * sizeof(wchar_t) )))
            {
                free( ret );
                return NULL;
            }
            ret = new;
        }
        pos += convert_acp_utf8_to_wcs( arg, ret + pos, size - pos );
        ret[pos - 1] = delim;
    }
    if (pos)
    {
        if (delim) ret[pos - 1] = 0;
        else ret[pos] = 0;
    }
    return ret;
}

Referenced by _execl(), _execle(), _execlp(), _execlpe(), _spawnl(), _spawnle(), _spawnlp(), and _spawnlpe().

system()

int CDECL system

(

const char *

cmd

)

Definition at line 1297 of file process.c.

{
  int res = -1;
  wchar_t *cmdW;
 
  if (cmd == NULL)
    return _wsystem(NULL);
 
  if ((cmdW = wstrdupa_utf8(cmd)))
  {
    res = _wsystem(cmdW);
    free(cmdW);
  }
  return res;
}

WINE_DEFAULT_DEBUG_CHANNEL()

WINE_DEFAULT_DEBUG_CHANNEL

(

msvcrt

)

Variable Documentation

popen_handles

struct popen_handle * popen_handles

static

Referenced by _pclose(), _wpopen(), and msvcrt_free_popen_data().

popen_handles_size

DWORD popen_handles_size

static

Definition at line 1032 of file process.c.

Referenced by _pclose(), and _wpopen().