Leaked source code of windows server 2003
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
 
 
 
 
 
 

643 lines
18 KiB

/*++
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 * OriginalEnvironment;
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;
TCHAR szTitle[MAX_PATH];
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 ) / sizeof( TCHAR )) == 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')) {
//
// OriginalEnvironment was save at init time after path
// and compsec were setup.
// If OriginalEnvironment did not get allocated then
// use the default.
//
if (OriginalEnvironment) {
pszEnv = GetCapturedEnvironmentStrings( OriginalEnvironment );
}
} 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,sizeof( szPgm ) / sizeof( TCHAR ))) == 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));
}
//
// 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_FAIL) {
ExecError( szPgm ) ;
return FAILURE;
}
if (status == SFE_NOTFND) {
//
// 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) {
CloseHandle(ChildProcessInfo.hThread);
} else {
DosErr = GetLastError();
if ( fNeedExpl ||
(fEnableExtensions && DosErr == ERROR_BAD_EXE_FORMAT)) {
SHELLEXECUTEINFO sei;
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) {
ChildProcessInfo.hProcess = sei.hProcess;
} else 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) {
ExecError( szPgm ) ;
return(FAILURE) ;
}
}
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);
}