678 lines
18 KiB
C
678 lines
18 KiB
C
/*++
|
|
|
|
Copyright (c) 1988-1999 Microsoft Corporation
|
|
|
|
Module Name:
|
|
|
|
start.c
|
|
|
|
Abstract:
|
|
|
|
Start command support
|
|
|
|
--*/
|
|
|
|
#include "cmd.h"
|
|
|
|
extern UINT CurrentCP;
|
|
extern unsigned DosErr;
|
|
extern TCHAR CurDrvDir[] ;
|
|
extern TCHAR SwitChar, PathChar;
|
|
extern TCHAR ComExt[], ComSpecStr[];
|
|
extern struct envdata * penvOrig;
|
|
extern int LastRetCode;
|
|
|
|
WORD
|
|
GetProcessSubsystemType(
|
|
HANDLE hProcess
|
|
);
|
|
|
|
STATUS
|
|
getparam(
|
|
IN BOOL LeadingSwitChar,
|
|
IN OUT TCHAR **chptr,
|
|
OUT TCHAR *param,
|
|
IN int maxlen )
|
|
|
|
/*++
|
|
|
|
Routine Description:
|
|
|
|
Copy the token starting at the current position to an output buffer.
|
|
Terminate the copy on end-of-quotes, unquoted whitespace, unquoted
|
|
switch character, or end-of-line
|
|
|
|
Arguments:
|
|
|
|
LeadingSwitChar - TRUE => we should terminate on unquoted switch character
|
|
|
|
chptr - address of pointer to token. This is advanced over the parsed
|
|
token
|
|
|
|
param - destination of copy. String is NUL terminated
|
|
|
|
maxlen - size of destination buffer
|
|
|
|
Return Value:
|
|
|
|
Return: STATUS of copy. Only failure is buffer exceeded.
|
|
|
|
--*/
|
|
|
|
|
|
{
|
|
|
|
TCHAR *ch2;
|
|
int count = 0;
|
|
|
|
BOOL QuoteFound = FALSE;
|
|
|
|
ch2 = param;
|
|
|
|
//
|
|
// get characters until a space, tab, slash, or end of line
|
|
//
|
|
|
|
while (TRUE) {
|
|
|
|
//
|
|
// If we're at the end of string, then there's no more token
|
|
//
|
|
|
|
if (**chptr == NULLC) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// If we're not quoting and we're at a whitespace or switch char
|
|
// then there's no more token
|
|
//
|
|
|
|
if (!QuoteFound &&
|
|
(_istspace( **chptr ) || (LeadingSwitChar && **chptr == SwitChar))) {
|
|
break;
|
|
}
|
|
|
|
//
|
|
// If there's still room in the buffer, copy in the character and note
|
|
// if it's a quote or not
|
|
//
|
|
|
|
if (count < maxlen) {
|
|
*ch2++ = (**chptr);
|
|
if (**chptr == QUOTE) {
|
|
QuoteFound = !QuoteFound;
|
|
}
|
|
}
|
|
|
|
//
|
|
// Advance over this character
|
|
//
|
|
|
|
(*chptr)++;
|
|
count++;
|
|
}
|
|
|
|
//
|
|
// If we've exceeded the buffer, display the error and return failure
|
|
//
|
|
|
|
if (count > maxlen) {
|
|
**chptr = NULLC;
|
|
*chptr = *chptr - count - 1;
|
|
PutStdErr(MSG_START_INVALID_PARAMETER, ONEARG, *chptr);
|
|
return(FAILURE);
|
|
} else {
|
|
*ch2 = NULLC;
|
|
return(SUCCESS);
|
|
}
|
|
}
|
|
|
|
/*
|
|
|
|
Start /MIN /MAX "title" /P:x,y /S:dx,dy /D:directory /I cmd args
|
|
|
|
*/
|
|
|
|
|
|
|
|
int
|
|
Start(
|
|
IN PTCHAR pszCmdLine
|
|
)
|
|
{
|
|
|
|
|
|
STARTUPINFO StartupInfo;
|
|
PROCESS_INFORMATION ChildProcessInfo;
|
|
|
|
#ifndef UNICODE
|
|
WCHAR TitleW[MAXTOKLEN];
|
|
CCHAR TitleA[MAXTOKLEN];
|
|
#endif
|
|
TCHAR szTitle[MAXTOKLEN];
|
|
TCHAR szDirCur[MAX_PATH];
|
|
|
|
TCHAR szT[MAXTOKLEN];
|
|
|
|
TCHAR szPgmArgs[MAXTOKLEN];
|
|
TCHAR szParam[MAXTOKLEN];
|
|
TCHAR szPgm[MAXTOKLEN];
|
|
TCHAR szPgmSave[MAXTOKLEN];
|
|
TCHAR szTemp[MAXTOKLEN];
|
|
TCHAR szPgmQuoted[MAXTOKLEN];
|
|
|
|
HDESK hdesk;
|
|
HWINSTA hwinsta;
|
|
LPTSTR p;
|
|
LPTSTR lpDesktop;
|
|
DWORD cbDesktop = 0;
|
|
DWORD cbWinsta = 0;
|
|
|
|
TCHAR flags;
|
|
BOOLEAN fNeedCmd;
|
|
BOOLEAN fNeedExpl;
|
|
BOOLEAN fKSwitch = FALSE;
|
|
BOOLEAN fCSwitch = FALSE;
|
|
|
|
PTCHAR pszCmdCur = NULL;
|
|
PTCHAR pszDirCur = NULL;
|
|
PTCHAR pszPgmArgs = NULL;
|
|
PTCHAR pszEnv = NULL;
|
|
TCHAR pszFakePgm[] = TEXT("cmd.exe");
|
|
ULONG status;
|
|
struct cmdnode cmdnd;
|
|
DWORD CreationFlags;
|
|
BOOL SafeFromControlC = FALSE;
|
|
BOOL WaitForProcess = FALSE;
|
|
BOOL b;
|
|
DWORD uPgmLength;
|
|
int retc;
|
|
|
|
szPgm[0] = NULLC;
|
|
szPgmArgs[0] = NULLC;
|
|
|
|
pszDirCur = NULL;
|
|
CreationFlags = CREATE_NEW_CONSOLE;
|
|
|
|
|
|
StartupInfo.cb = sizeof( StartupInfo );
|
|
StartupInfo.lpReserved = NULL;
|
|
StartupInfo.lpDesktop = NULL;
|
|
StartupInfo.lpTitle = NULL;
|
|
StartupInfo.dwX = 0;
|
|
StartupInfo.dwY = 0;
|
|
StartupInfo.dwXSize = 0;
|
|
StartupInfo.dwYSize = 0;
|
|
StartupInfo.dwFlags = 0;
|
|
StartupInfo.wShowWindow = SW_SHOWNORMAL;
|
|
StartupInfo.cbReserved2 = 0;
|
|
StartupInfo.lpReserved2 = NULL;
|
|
StartupInfo.hStdInput = GetStdHandle( STD_INPUT_HANDLE );
|
|
StartupInfo.hStdOutput = GetStdHandle( STD_OUTPUT_HANDLE );
|
|
StartupInfo.hStdError = GetStdHandle( STD_ERROR_HANDLE );
|
|
|
|
pszCmdCur = pszCmdLine;
|
|
|
|
//
|
|
// If there isn't a command line then make
|
|
// up the default
|
|
//
|
|
|
|
if (pszCmdCur == NULL) {
|
|
|
|
pszCmdCur = pszFakePgm;
|
|
|
|
}
|
|
|
|
while( *pszCmdCur != NULLC) {
|
|
|
|
pszCmdCur = EatWS( pszCmdCur, NULL );
|
|
|
|
if ((*pszCmdCur == QUOTE) && (StartupInfo.lpTitle == NULL)) {
|
|
|
|
//
|
|
// "Title" Parse off the quoted text, strip off quotes and set the
|
|
// title for the child window.
|
|
//
|
|
|
|
if (getparam( TRUE, &pszCmdCur, szTitle, sizeof( szTitle )) == FAILURE) {
|
|
return FAILURE;
|
|
}
|
|
mystrcpy( szTitle, StripQuotes( szTitle ));
|
|
StartupInfo.lpTitle = szTitle;
|
|
|
|
} else if (*pszCmdCur == SwitChar) {
|
|
|
|
pszCmdCur++;
|
|
|
|
if (getparam( TRUE, &pszCmdCur, szParam, MAXTOKLEN) == FAILURE) {
|
|
return(FAILURE);
|
|
}
|
|
|
|
if (!_tcsicmp( szParam, TEXT("ABOVENORMAL"))) {
|
|
CreationFlags |= ABOVE_NORMAL_PRIORITY_CLASS;
|
|
} else
|
|
if (!_tcsicmp( szParam, TEXT("BELOWNORMAL"))) {
|
|
CreationFlags |= BELOW_NORMAL_PRIORITY_CLASS;
|
|
} else
|
|
if (!_tcsicmp( szParam, TEXT("B"))) {
|
|
WaitForProcess = FALSE;
|
|
SafeFromControlC = TRUE;
|
|
CreationFlags &= ~CREATE_NEW_CONSOLE;
|
|
CreationFlags |= CREATE_NEW_PROCESS_GROUP;
|
|
} else
|
|
if (_totupper(szParam[0]) == TEXT('D')) {
|
|
|
|
//
|
|
// /Dpath or /D"path" or /D path or /D "path"
|
|
//
|
|
|
|
if (mystrlen( szParam + 1 ) > 0) {
|
|
|
|
//
|
|
// /Dpath or /D"path"
|
|
//
|
|
|
|
pszDirCur = szParam + 1;
|
|
} else {
|
|
|
|
//
|
|
// /D path or /D "path"
|
|
//
|
|
|
|
pszCmdCur = EatWS( pszCmdCur, NULL );
|
|
if (getparam( TRUE, &pszCmdCur, szParam, MAXTOKLEN) == FAILURE) {
|
|
return FAILURE;
|
|
}
|
|
|
|
pszDirCur = szParam;
|
|
}
|
|
|
|
//
|
|
// remove quotes if necessary
|
|
//
|
|
|
|
mystrcpy( szDirCur, StripQuotes( pszDirCur ));
|
|
pszDirCur = szDirCur;
|
|
|
|
if (mystrlen( pszDirCur ) > MAX_PATH) {
|
|
PutStdErr( MSG_START_INVALID_PARAMETER, ONEARG, pszDirCur);
|
|
return FAILURE;
|
|
}
|
|
} else
|
|
if (_tcsicmp(szParam, TEXT("HIGH")) == 0) {
|
|
CreationFlags |= HIGH_PRIORITY_CLASS;
|
|
} else
|
|
if (_totupper(szParam[0]) == TEXT('I')) {
|
|
|
|
//
|
|
// penvOrig was save at init time after path
|
|
// and compsec were setup.
|
|
// If penvOrig did not get allocated then
|
|
// use the default.
|
|
//
|
|
if (penvOrig) {
|
|
pszEnv = penvOrig->handle;
|
|
}
|
|
} else
|
|
if (_totupper(szParam[0]) == QMARK) {
|
|
|
|
BeginHelpPause();
|
|
PutStdOut(MSG_HELP_START, NOARGS);
|
|
if (fEnableExtensions)
|
|
PutStdOut(MSG_HELP_START_X, NOARGS);
|
|
EndHelpPause();
|
|
|
|
return( FAILURE );
|
|
} else
|
|
if (_tcsicmp(szParam, TEXT("LOW")) == 0) {
|
|
CreationFlags |= IDLE_PRIORITY_CLASS;
|
|
} else
|
|
if (_tcsicmp(szParam, TEXT("MIN")) == 0) {
|
|
|
|
StartupInfo.dwFlags |= STARTF_USESHOWWINDOW;
|
|
StartupInfo.wShowWindow &= ~SW_SHOWNORMAL;
|
|
StartupInfo.wShowWindow |= SW_SHOWMINNOACTIVE;
|
|
|
|
} else
|
|
if (_tcsicmp(szParam, TEXT("MAX")) == 0) {
|
|
|
|
StartupInfo.dwFlags |= STARTF_USESHOWWINDOW;
|
|
StartupInfo.wShowWindow &= ~SW_SHOWNORMAL;
|
|
StartupInfo.wShowWindow |= SW_SHOWMAXIMIZED;
|
|
|
|
} else
|
|
if (_tcsicmp(szParam, TEXT("NORMAL")) == 0) {
|
|
CreationFlags |= NORMAL_PRIORITY_CLASS;
|
|
} else
|
|
if (_tcsicmp(szParam, TEXT("REALTIME")) == 0) {
|
|
CreationFlags |= REALTIME_PRIORITY_CLASS;
|
|
} else
|
|
if (_tcsicmp(szParam, TEXT("SEPARATE")) == 0) {
|
|
#ifndef WIN95_CMD
|
|
CreationFlags |= CREATE_SEPARATE_WOW_VDM;
|
|
#endif // WIN95_CMD
|
|
} else
|
|
if (_tcsicmp(szParam, TEXT("SHARED")) == 0) {
|
|
#ifndef WIN95_CMD
|
|
CreationFlags |= CREATE_SHARED_WOW_VDM;
|
|
#endif // WIN95_CMD
|
|
} else
|
|
if ( _tcsicmp(szParam, TEXT("WAIT")) == 0 ||
|
|
_tcsicmp(szParam, TEXT("W")) == 0 ) {
|
|
WaitForProcess = TRUE;
|
|
} else {
|
|
#ifdef FE_SB // KKBUGFIX
|
|
mystrcpy(szT, TEXT("/"));
|
|
#else
|
|
mystrcpy(szT, TEXT("\\"));
|
|
#endif
|
|
mystrcat(szT, szParam );
|
|
PutStdErr(MSG_INVALID_SWITCH, ONEARG, szT);
|
|
return( FAILURE );
|
|
}
|
|
} else {
|
|
|
|
if ((getparam(FALSE,&pszCmdCur,szPgm,MAXTOKLEN)) == FAILURE) {
|
|
return( FAILURE );
|
|
}
|
|
|
|
//
|
|
// if there are argument get them.
|
|
//
|
|
if (*pszCmdCur) {
|
|
|
|
mystrcpy(szPgmArgs, pszCmdCur);
|
|
pszPgmArgs = szPgmArgs;
|
|
|
|
}
|
|
|
|
//
|
|
// there rest was args to pgm so move to eol
|
|
//
|
|
pszCmdCur = mystrchr(pszCmdCur, NULLC);
|
|
|
|
}
|
|
|
|
} // while
|
|
|
|
|
|
//
|
|
// If a program was not picked up do so now.
|
|
//
|
|
if (*szPgm == NULLC) {
|
|
mystrcpy(szPgm, pszFakePgm);
|
|
}
|
|
|
|
//
|
|
// Need both quoted and unquoted versions of program name
|
|
//
|
|
|
|
if (szPgm[0] != QUOTE && _tcschr(szPgm, SPACE)) {
|
|
szPgmQuoted[0] = QUOTE;
|
|
mystrcpy(&szPgmQuoted[1], StripQuotes(szPgm));
|
|
mystrcat(szPgmQuoted, TEXT("\""));
|
|
}
|
|
else {
|
|
mystrcpy(szPgmQuoted, szPgm);
|
|
mystrcpy(szPgm, StripQuotes(szPgm));
|
|
}
|
|
|
|
#ifndef UNICODE
|
|
#ifndef WIN95_CMD
|
|
// convert the title from OEM to ANSI
|
|
|
|
if (StartupInfo.lpTitle) {
|
|
MultiByteToWideChar(CP_OEMCP,
|
|
0,
|
|
StartupInfo.lpTitle,
|
|
_tcslen(StartupInfo.lpTitle)+1,
|
|
TitleW,
|
|
MAXTOKLEN);
|
|
|
|
WideCharToMultiByte(CP_ACP,
|
|
0,
|
|
TitleW,
|
|
wcslen(TitleW)+1,
|
|
TitleA,
|
|
MAXTOKLEN,
|
|
NULL,
|
|
NULL);
|
|
StartupInfo.lpTitle = TitleA;
|
|
}
|
|
#endif // WIN95_CMD
|
|
#endif // UNICODE
|
|
|
|
//
|
|
// see of a cmd.exe is needed to run a batch or internal command
|
|
//
|
|
|
|
fNeedCmd = FALSE;
|
|
fNeedExpl = FALSE;
|
|
|
|
//
|
|
// is it an internal command?
|
|
//
|
|
if (FindCmd(CMDMAX, szPgm, &flags) != -1) {
|
|
fNeedCmd = TRUE;
|
|
} else {
|
|
// Save szPgm since SearchForExecutable may override it.
|
|
mystrcpy(szPgmSave, szPgm);
|
|
|
|
//
|
|
// Try to find it as a batch or exe file
|
|
//
|
|
cmdnd.cmdline = szPgm;
|
|
|
|
status = SearchForExecutable(&cmdnd, szPgm);
|
|
if ( (status == SFE_NOTFND) || ( status == SFE_FAIL ) ) {
|
|
//
|
|
// If we can find it, let Explorer have a shot.
|
|
//
|
|
fNeedExpl = TRUE;
|
|
mystrcpy(szPgm, szPgmSave);
|
|
|
|
} else if (status == SFE_ISBAT || status == SFE_ISDIR) {
|
|
|
|
if (status == SFE_ISBAT)
|
|
fNeedCmd = TRUE;
|
|
else
|
|
fNeedExpl = TRUE;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
if (!fNeedExpl) {
|
|
if (fNeedCmd) {
|
|
TCHAR *Cmd = GetEnvVar( ComSpecStr );
|
|
|
|
if (Cmd == NULL) {
|
|
PutStdErr( MSG_INVALID_COMSPEC, NOARGS );
|
|
return FAILURE;
|
|
}
|
|
|
|
//
|
|
// if a cmd.exe is need then szPgm need to be inserted before
|
|
// the start of szPgms along with a /K parameter.
|
|
// szPgm has to recieve the full path name of cmd.exe from
|
|
// the compsec environment variable.
|
|
//
|
|
|
|
mystrcpy(szT, TEXT(" /K "));
|
|
mystrcat(szT, szPgmQuoted);
|
|
|
|
//
|
|
// Get the location of the cmd processor from the environment
|
|
//
|
|
|
|
mystrcpy( szPgm, Cmd );
|
|
|
|
mystrcpy( szPgmQuoted, szPgm );
|
|
|
|
//
|
|
// is there a command parameter at all
|
|
//
|
|
|
|
if (_tcsicmp(szT, TEXT(" /K ")) != 0) {
|
|
|
|
//
|
|
// If we have any arguments to add do so
|
|
//
|
|
if (*szPgmArgs) {
|
|
|
|
if ((mystrlen(szPgmArgs) + mystrlen(szT)) < MAXTOKLEN) {
|
|
|
|
mystrcat(szT, TEXT(" "));
|
|
mystrcat(szT, szPgmArgs);
|
|
|
|
} else {
|
|
|
|
PutStdErr( MSG_CMD_FILE_NOT_FOUND, ONEARG, szPgmArgs);
|
|
}
|
|
}
|
|
}
|
|
pszPgmArgs = szT;
|
|
}
|
|
|
|
// Prepare for CreateProcess :
|
|
// ImageName = <full path and command name ONLY>
|
|
// CmdLine = <command name with NO FULL PATH> + <args as entered>
|
|
|
|
mystrcpy(szTemp, szPgmQuoted);
|
|
mystrcat(szTemp, TEXT(" "));
|
|
mystrcat(szTemp, pszPgmArgs);
|
|
pszPgmArgs = szTemp;
|
|
}
|
|
|
|
if (SafeFromControlC) {
|
|
SetConsoleCtrlHandler(NULL,TRUE);
|
|
}
|
|
|
|
// Pass current Desktop to a new process.
|
|
|
|
hwinsta = GetProcessWindowStation();
|
|
GetUserObjectInformation( hwinsta, UOI_NAME, NULL, 0, &cbWinsta );
|
|
|
|
hdesk = GetThreadDesktop ( GetCurrentThreadId() );
|
|
GetUserObjectInformation (hdesk, UOI_NAME, NULL, 0, &cbDesktop);
|
|
|
|
if ((lpDesktop = HeapAlloc (GetProcessHeap(), HEAP_ZERO_MEMORY, cbDesktop + cbWinsta + 32) ) != NULL ) {
|
|
p = lpDesktop;
|
|
if ( GetUserObjectInformation (hwinsta, UOI_NAME, p, cbWinsta, &cbWinsta) ) {
|
|
if (cbWinsta > 0) {
|
|
p += ((cbWinsta/sizeof(TCHAR))-1);
|
|
*p++ = L'\\';
|
|
}
|
|
if ( GetUserObjectInformation (hdesk, UOI_NAME, p, cbDesktop, &cbDesktop) ) {
|
|
StartupInfo.lpDesktop = lpDesktop;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fNeedExpl) {
|
|
b = FALSE;
|
|
} else {
|
|
b = CreateProcess( szPgm, // was NULL, wrong.
|
|
pszPgmArgs,
|
|
NULL,
|
|
(LPSECURITY_ATTRIBUTES) NULL,
|
|
TRUE, // bInherit
|
|
#ifdef UNICODE
|
|
CREATE_UNICODE_ENVIRONMENT |
|
|
#endif // UNICODE
|
|
CreationFlags,
|
|
// CreationFlags
|
|
pszEnv, // Environment
|
|
pszDirCur, // Current directory
|
|
&StartupInfo, // Startup Info Struct
|
|
&ChildProcessInfo // ProcessInfo Struct
|
|
);
|
|
}
|
|
|
|
if (SafeFromControlC) {
|
|
SetConsoleCtrlHandler(NULL,FALSE);
|
|
}
|
|
HeapFree (GetProcessHeap(), 0, lpDesktop);
|
|
|
|
if (!b) {
|
|
DosErr = GetLastError();
|
|
|
|
if ( fNeedExpl ||
|
|
(fEnableExtensions && DosErr == ERROR_BAD_EXE_FORMAT)) {
|
|
SHELLEXECUTEINFO sei;
|
|
BOOL b;
|
|
|
|
memset(&sei, 0, sizeof(sei));
|
|
//
|
|
// Use the DDEWAIT flag so apps can finish their DDE conversation
|
|
// before ShellExecuteEx returns. Otherwise, apps like Word will
|
|
// complain when they try to exit, confusing the user.
|
|
//
|
|
sei.cbSize = sizeof(sei);
|
|
sei.fMask = SEE_MASK_HASTITLE |
|
|
SEE_MASK_NO_CONSOLE |
|
|
SEE_MASK_FLAG_DDEWAIT |
|
|
SEE_MASK_NOCLOSEPROCESS;
|
|
if (CreationFlags & CREATE_NEW_CONSOLE) {
|
|
sei.fMask &= ~SEE_MASK_NO_CONSOLE;
|
|
}
|
|
sei.lpFile = szPgm;
|
|
sei.lpClass = StartupInfo.lpTitle;
|
|
sei.lpParameters = szPgmArgs;
|
|
sei.lpDirectory = pszDirCur;
|
|
sei.nShow = StartupInfo.wShowWindow;
|
|
|
|
try {
|
|
b = ShellExecuteEx( &sei );
|
|
if (b) {
|
|
leave;
|
|
}
|
|
|
|
if (!sei.hInstApp) {
|
|
DosErr = ERROR_NOT_ENOUGH_MEMORY;
|
|
} else if ((DWORD_PTR)sei.hInstApp == HINSTANCE_ERROR) {
|
|
DosErr = ERROR_FILE_NOT_FOUND;
|
|
} else {
|
|
DosErr = HandleToUlong(sei.hInstApp);
|
|
}
|
|
|
|
} except (DosErr = GetExceptionCode( ), EXCEPTION_EXECUTE_HANDLER) {
|
|
b = FALSE;
|
|
}
|
|
|
|
if (b) {
|
|
//
|
|
// Successfully invoked correct application via
|
|
// file association. Code below will check to see
|
|
// if application is a GUI app and if so turn it into
|
|
// an ASYNC exec.
|
|
|
|
ChildProcessInfo.hProcess = sei.hProcess;
|
|
goto shellexecsuccess;
|
|
}
|
|
}
|
|
|
|
ExecError( szPgm ) ;
|
|
return(FAILURE) ;
|
|
}
|
|
|
|
CloseHandle(ChildProcessInfo.hThread);
|
|
shellexecsuccess:
|
|
if (ChildProcessInfo.hProcess != NULL) {
|
|
if (WaitForProcess) {
|
|
//
|
|
// Wait for process to terminate, otherwise things become very
|
|
// messy and confusing to the user (with 2 processes sharing
|
|
// the console).
|
|
//
|
|
LastRetCode = WaitProc((ChildProcessInfo.hProcess) );
|
|
} else {
|
|
CloseHandle( ChildProcessInfo.hProcess );
|
|
}
|
|
}
|
|
|
|
return(SUCCESS);
|
|
}
|