Цитата(alexx83 @ 21.12.2012, 09:02  ) | | Через CreateProcess вызываю так: |
Вроде, всё на месте))) Поясните тогда, пожалуйста:
| Цитата(alexx83 @ 20.12.2012, 22:45 ) | | При несанкционированном завершении родительского процесса, например через диспетчер задач, дочерний процесс остается висеть в памяти. |
Дочерний процесс в конце концов не завершается самостоятельно, или же просто Вам хочется, чтобы он умирал синхронно со смертью родительского?
| Цитата(alexx83 @ 20.12.2012, 22:45 ) | | Необходимо в идеальном случае замещать родительский процесс дочерним с сохранением взаимодействия с консолью в дочернем процессе. |
Почему тогда
| Цитата(alexx83 @ 21.12.2012, 09:02 ) | | WaitForSingleObject(pi.hProcess, INFINITE); |
Почему не завершать родительский процесс сразу (ну, или после WaitForInputIdle)? Дочерний процесс теряет способность взаимодействия с консолью?
| Цитата(alexx83 @ 21.12.2012, 12:25 ) | | Можете показать реализацию _execvpe? |
Могу, но кода много и он относится к MSVS C++ 6.0.
Добавлено через 1 минуту и 35 секунд
Файл Execvpe.c| Код |
/***
*execvpe.c - execute a file with given environ; search along PATH
*
* Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
* defines _execvpe() - execute a file with given environ
*
*******************************************************************************/
#include <cruntime.h>
#include <errno.h>
#include <stdlib.h>
#include <string.h>
#include <process.h>
#include <mbstring.h>
#include <tchar.h>
#include <dbgint.h>
#define SLASHCHAR _T('\\')
#define XSLASHCHAR _T('/')
#define SLASH _T("\\")
#define DELIMITER _T(";")
#ifdef _MBCS
/* note, the macro below assumes p is to pointer to a single-byte character
* or the 1st byte of a double-byte character, in a string.
*/
#define ISPSLASH(p) ( ((p) == _mbschr((p), SLASHCHAR)) || ((p) == \
_mbschr((p), XSLASHCHAR)) )
#else /* _MBCS */
#define ISSLASH(c) ( ((c) == SLASHCHAR) || ((c) == XSLASHCHAR) )
#endif /* _MBCS */
/***
*int _execvpe(filename, argvector, envvector) - execute a file
*
*Purpose:
* Executes a file with given arguments and environment.
* try to execute the file. start with the name itself (directory '.'),
* and if that doesn't work start prepending pathnames from the
* environment until one works or we run out. if the file is a pathname,
* don't go to the environment to get alternate paths. If a needed text
* file is busy, wait a little while and try again before despairing
* completely
*
*Entry:
* _TSCHAR *filename - file to execute
* _TSCHAR **argvector - vector of arguments
* _TSCHAR **envvector - vector of environment variables
*
*Exit:
* destroys the calling process (hopefully)
* if fails, returns -1
*
*Exceptions:
*
*******************************************************************************/
int __cdecl _texecvpe (
REG3 const _TSCHAR *filename,
const _TSCHAR * const *argvector,
const _TSCHAR * const *envptr
)
{
REG1 _TSCHAR *env;
_TSCHAR *bbuf = NULL;
REG2 _TSCHAR *buf;
_TSCHAR *pfin;
_ASSERTE(filename != NULL);
_ASSERTE(*filename != _T('\0'));
_ASSERTE(argvector != NULL);
_ASSERTE(*argvector != NULL);
_ASSERTE(**argvector != _T('\0'));
_texecve(filename,argvector,envptr);
if ( (errno != ENOENT)
|| (_tcschr(filename, SLASHCHAR) != NULL)
|| (_tcschr(filename, XSLASHCHAR) != NULL)
|| *filename && *(filename+1) == _T(':')
|| !(env=_tgetenv(_T("PATH"))) )
goto reterror;
/* allocate a buffer to hold alternate pathnames for the executable
*/
if ( (buf = bbuf = _malloc_crt(_MAX_PATH * sizeof(_TSCHAR))) == NULL )
goto reterror;
do {
/* copy a component into bbuf[], taking care not to overflow it
*/
/* UNDONE: make sure ';' isn't 2nd byte of DBCS char */
while ( (*env) && (*env != _T(';')) && (buf < bbuf+(_MAX_PATH-2)*sizeof(_TSCHAR)) )
*buf++ = *env++;
*buf = _T('\0');
pfin = --buf;
buf = bbuf;
#ifdef _MBCS
if (*pfin == SLASHCHAR) {
if (pfin != _mbsrchr(buf,SLASHCHAR))
/* *pfin is the second byte of a double-byte
* character
*/
strcat( buf, SLASH );
}
else if (*pfin != XSLASHCHAR)
strcat(buf, SLASH);
#else /* _MBCS */
if (*pfin != SLASHCHAR && *pfin != XSLASHCHAR)
_tcscat(buf, SLASH);
#endif /* _MBCS */
/* check that the final path will be of legal size. if so,
* build it. otherwise, return to the caller (return value
* and errno rename set from initial call to _execve()).
*/
if ( (_tcslen(buf) + _tcslen(filename)) < _MAX_PATH )
_tcscat(buf, filename);
else
break;
_texecve(buf, argvector, envptr);
if ( (errno != ENOENT)
#ifdef _MBCS
&& (!ISPSLASH(buf) || !ISPSLASH(buf+1)) )
#else /* _MBCS */
&& (!ISSLASH(*buf) || !ISSLASH(*(buf+1))) )
#endif /* _MBCS */
break;
} while ( *env && env++ );
reterror:
if (bbuf != NULL)
_free_crt(bbuf);
return(-1);
} |
Добавлено через 2 минуты и 29 секунд
Файл Execve.c| Код |
/***
*execve.c - execute a file with a given environment
*
* Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
* defines _execve() - execute a file
*
*******************************************************************************/
#define EXECVE
#include "spawnve.c" |
Добавлено через 3 минуты и 43 секунды
Файл Spawnve.c| Код |
/***
*spawnve.c - Low level routine eventually called by all _spawnXX routines
* also contains all code for _execve, called by _execXX routines
*
* Copyright (c) 1985-1997, Microsoft Corporation. All rights reserved.
*
*Purpose:
*
* This is the low level routine which is eventually invoked by all the
* _spawnXX routines.
*
* This is also the low-level routine which is eventually invoked by
* all of the _execXX routines.
*
*******************************************************************************/
#include <cruntime.h>
#include <io.h>
#include <process.h>
#include <errno.h>
#include <msdos.h>
#include <string.h>
#include <stdlib.h>
#include <internal.h>
#include <mbstring.h>
#include <tchar.h>
#include <dbgint.h>
#define SLASHCHAR _T('\\')
#define XSLASHCHAR _T('/')
#ifndef EXECVE
#ifdef WPRFLAG
static int __cdecl wcomexecmd(int mode, const wchar_t * name,
const wchar_t * const * argv, const wchar_t * const * envp);
#else /* WPRFLAG */
static int __cdecl comexecmd(int mode, const char * name,
const char * const * argv, const char * const * envp);
#endif /* WPRFLAG */
#else /* EXECVE */
#ifdef WPRFLAG
static int __cdecl wcomexecmd(const wchar_t * name,
const wchar_t * const * argv, const wchar_t * const * envp);
#else /* WPRFLAG */
static int __cdecl comexecmd(const char * name,
const char * const * argv, const char * const * envp);
#endif /* WPRFLAG */
#endif /* EXECVE */
/***
*static int comexecmd(mode, name, argv, envp) - do the exec
* or spawn after name fixup
*
*Purpose:
* Spawns a child process with given parameters and environment. Either
* overlays current process or loads in free memory while parent process
* waits. If the named file is a .cmd file, modifies the calling sequence
* and prepends the /c and filename arguments into the command string
*
* Exec doesn't take a mode; instead, the parent process goes away as
* the child process is brought in.
*
*Entry:
* int mode - mode to spawn (WAIT, NOWAIT, or OVERLAY)
* only WAIT and OVERLAY currently supported
*
* **** mode is only used in the spawnve() version ****
*
* _TSCHAR *name - pathname of file to spawn. Includes the extension
* _TSCHAR **argv - vector of parameter strings
* _TSCHAR **envp - vector of environment variables
*
*Exit:
* returns exit code of child process
* if fails, returns -1
*
*Exceptions:
* Returns a value of (-1) to indicate an error in exec'ing the child
* process. errno may be set to:
*
* E2BIG = failed in argument/environment processing (_cenvarg)
* argument list or environment too big;
* EACCESS = locking or sharing violation on file;
* EMFILE = too many files open;
* ENOENT = failed to find program name - no such file or directory;
* ENOEXEC = failed in exec - bad executable format;
* ENOMEM = failed in memory allocation (during malloc, or in
* setting up memory for executing child process).
*
*******************************************************************************/
#ifdef WPRFLAG
static int __cdecl wcomexecmd (
#else /* WPRFLAG */
static int __cdecl comexecmd (
#endif /* WPRFLAG */
#ifndef EXECVE
REG3 int mode,
#endif /* EXECVE */
REG2 const _TSCHAR *name,
const _TSCHAR * const *argv,
const _TSCHAR * const *envp
)
{
_TSCHAR *argblk;
_TSCHAR *envblk;
REG4 int rc;
#ifdef WPRFLAG
if (_wcenvarg(argv, envp, &argblk, &envblk, name) == -1)
#else /* WPRFLAG */
if (_cenvarg(argv, envp, &argblk, &envblk, name) == -1)
#endif /* WPRFLAG */
return -1;
#ifndef EXECVE
#ifdef WPRFLAG
rc = _wdospawn(mode, name, argblk, envblk);
#else /* WPRFLAG */
rc = _dospawn(mode, name, argblk, envblk);
#endif /* WPRFLAG */
#else /* EXECVE */
#ifdef WPRFLAG
rc = _wdospawn(_P_OVERLAY, name, argblk, envblk);
#else /* WPRFLAG */
rc = _dospawn(_P_OVERLAY, name, argblk, envblk);
#endif /* WPRFLAG */
#endif /* EXECVE */
/* free memory */
_free_crt(argblk);
_free_crt(envblk);
return rc;
}
/***
*int _spawnve(mode, name, argv, envp) - low level _spawnXX library function
*int _execve(name, argv, envp) - low level _execXX library function
*
*Purpose:
* spawns or execs a child process; takes a single pointer to an argument
* list as well as a pointer to the environment; unlike _spawnvpe,
* _spawnve does not search the PATH= list in processing the name
* parameter; mode specifies the parent's execution mode.
*
*Entry:
* int mode - parent process's execution mode:
* must be one of _P_OVERLAY, _P_WAIT, _P_NOWAIT;
* not used for _execve
* _TSCHAR *name - path name of program to spawn;
* _TSCHAR **argv - pointer to array of pointers to child's arguments;
* _TSCHAR **envp - pointer to array of pointers to child's environment
* settings.
*
*Exit:
* Returns : (int) a status value whose meaning is as follows:
* 0 = normal termination of child process;
* positive = exit code of child upon error termination
* (abort or exit(nonzero));
* -1 = child process was not spawned;
* errno indicates what kind of error:
* (E2BIG, EINVAL, ENOENT, ENOEXEC, ENOMEM).
*
*Exceptions:
* Returns a value of (-1) to indicate an error in spawning the child
* process. errno may be set to:
*
* E2BIG = failed in argument/environment processing (_cenvarg) -
* argument list or environment too big;
* EINVAL = invalid mode argument;
* ENOENT = failed to find program name - no such file or directory;
* ENOEXEC = failed in spawn - bad executable format;
* ENOMEM = failed in memory allocation (during malloc, or in
* setting up memory for spawning child process).
*
*******************************************************************************/
/* Extension array - ordered in search order from right to left.
ext_strings = array of extensions
*/
static _TSCHAR *ext_strings[] = { _T(".cmd"), _T(".bat"), _T(".exe"), _T(".com") };
enum {CMD, BAT, EXE, COM, EXTFIRST=CMD, EXTLAST=COM};
int __cdecl
#ifndef EXECVE
_tspawnve (
REG3 int mode,
#else /* EXECVE */
_texecve (
#endif /* EXECVE */
const _TSCHAR *name,
const _TSCHAR * const *argv,
const _TSCHAR * const *envp
)
{
_TSCHAR *ext; /* where the extension goes if we have to add one */
REG1 _TSCHAR *p;
_TSCHAR *q;
REG2 _TSCHAR *pathname = (_TSCHAR *)name;
REG4 int rc;
REG5 int i;
p = _tcsrchr(pathname, SLASHCHAR);
q = _tcsrchr(pathname, XSLASHCHAR);
/* ensure that pathname is an absolute or relative pathname. also,
* position p to point at the filename portion of pathname (i.e., just
* after the last occurence of a colon, slash or backslash character */
if (!q) {
if (!p)
if (!(p = _tcschr(pathname, _T(':')))) {
/* pathname is a filename only, force it to be
* a relative pathname. note that an extra byte
* is malloc-ed just in case pathname is NULL,
* to keep the heap from being trashed by
* strcpy */
if (!(pathname = _malloc_crt((_tcslen(pathname) + 3) * sizeof(_TSCHAR))))
return(-1);
_tcscpy(pathname, _T(".\\"));
_tcscat(pathname, name);
/* set p to point to the start of the filename
* (i.e., past the ".\\" prefix) */
p = pathname + 2;
}
/* else pathname has drive specifier prefix and p is
* is pointing to the ':' */
}
else if (!p || q > p) /* p == NULL or q > p */
p = q;
rc = -1; /* init to error value */
if (ext = _tcsrchr(p, _T('.'))) {
/* extension given; only do filename */
if (_taccess(pathname, 0) != -1) {
#ifndef EXECVE
#ifdef WPRFLAG
rc = wcomexecmd(mode, pathname, argv, envp);
#else /* WPRFLAG */
rc = comexecmd(mode, pathname, argv, envp);
#endif /* WPRFLAG */
#else /* EXECVE */
#ifdef WPRFLAG
rc = wcomexecmd(pathname, argv, envp);
#else /* WPRFLAG */
rc = comexecmd(pathname, argv, envp);
#endif /* WPRFLAG */
#endif /* EXECVE */
}
}
else {
/* no extension; try .cmd/.bat, then .com and .exe */
if (!(p = _malloc_crt((_tcslen(pathname) + 5) * sizeof(_TSCHAR))))
return(-1);
_tcscpy(p, pathname);
ext = p + _tcslen(pathname);
for (i = EXTLAST; i >= EXTFIRST; --i) {
_tcscpy(ext, ext_strings[i]);
if (_taccess(p, 0) != -1) {
#ifndef EXECVE
#ifdef WPRFLAG
rc = wcomexecmd(mode, p, argv, envp);
#else /* WPRFLAG */
rc = comexecmd(mode, p, argv, envp);
#endif /* WPRFLAG */
#else /* EXECVE */
#ifdef WPRFLAG
rc = wcomexecmd(p, argv, envp);
#else /* WPRFLAG */
rc = comexecmd(p, argv, envp);
#endif /* WPRFLAG */
#endif /* EXECVE */
break;
}
}
_free_crt(p);
}
if (pathname != name)
_free_crt(pathname);
return rc;
} |
Добавлено через 6 минут и 17 секунд
Остальное через 15 минут))) |
Я всё больше склоняюсь к мысли, что запускаемый экзешник - хитроватый...
