ReceiveTempSMS
/
Sweden-Number
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
Sweden-Number/programs/cmd/wcmdmain.c

1417 lines
40 KiB
C
Raw Blame History

/*
* CMD - Wine-compatible command line interface.
*
* Copyright (C) 1999 - 2001 D A Pickles
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2.1 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, write to the Free Software
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
*/
/*
* FIXME:
* - Cannot handle parameters in quotes
* - Lots of functionality missing from builtins
*/
#include "config.h"
#include "wcmd.h"
const char * const inbuilt[] = {"ATTRIB", "CALL", "CD", "CHDIR", "CLS", "COPY", "CTTY",
"DATE", "DEL", "DIR", "ECHO", "ERASE", "FOR", "GOTO",
"HELP", "IF", "LABEL", "MD", "MKDIR", "MOVE", "PATH", "PAUSE",
"PROMPT", "REM", "REN", "RENAME", "RD", "RMDIR", "SET", "SHIFT",
"TIME", "TITLE", "TYPE", "VERIFY", "VER", "VOL",
"ENDLOCAL", "SETLOCAL", "PUSHD", "POPD", "EXIT" };
HINSTANCE hinst;
DWORD errorlevel;
int echo_mode = 1, verify_mode = 0;
static int opt_c, opt_k, opt_s;
const char nyi[] = "Not Yet Implemented\n\n";
const char newline[] = "\n";
const char version_string[] = "CMD Version " PACKAGE_VERSION "\n\n";
const char anykey[] = "Press Return key to continue: ";
char quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
BATCH_CONTEXT *context = NULL;
static HANDLE old_stdin = INVALID_HANDLE_VALUE, old_stdout = INVALID_HANDLE_VALUE;
static char *WCMD_expand_envvar(char *start);
/*****************************************************************************
* Main entry point. This is a console application so we have a main() not a
* winmain().
*/
int main (int argc, char *argv[])
{
char string[1024];
char* cmd=NULL;
DWORD count;
HANDLE h;
int opt_q;
opt_c=opt_k=opt_q=opt_s=0;
while (*argv!=NULL)
{
char c;
if ((*argv)[0]!='/' || (*argv)[1]=='\0') {
argv++;
continue;
}
c=(*argv)[1];
if (tolower(c)=='c') {
opt_c=1;
} else if (tolower(c)=='q') {
opt_q=1;
} else if (tolower(c)=='k') {
opt_k=1;
} else if (tolower(c)=='s') {
opt_s=1;
} else if (tolower(c)=='t' || tolower(c)=='x' || tolower(c)=='y') {
/* Ignored for compatibility with Windows */
}
if ((*argv)[2]==0)
argv++;
else /* handle `cmd /cnotepad.exe` and `cmd /x/c ...` */
*argv+=2;
if (opt_c || opt_k) /* break out of parsing immediately after c or k */
break;
}
if (opt_q) {
WCMD_echo("OFF");
}
if (opt_c || opt_k) {
int len,qcount;
char** arg;
char* p;
/* opt_s left unflagged if the command starts with and contains exactly
* one quoted string (exactly two quote characters). The quoted string
* must be an executable name that has whitespace and must not have the
* following characters: &<>()@^| */
/* Build the command to execute */
len = 0;
qcount = 0;
for (arg = argv; *arg; arg++)
{
int has_space,bcount;
char* a;
has_space=0;
bcount=0;
a=*arg;
if( !*a ) has_space=1;
while (*a!='\0') {
if (*a=='\\') {
bcount++;
} else {
if (*a==' ' || *a=='\t') {
has_space=1;
} else if (*a=='"') {
/* doubling of '\' preceding a '"',
* plus escaping of said '"'
*/
len+=2*bcount+1;
qcount++;
}
bcount=0;
}
a++;
}
len+=(a-*arg)+1 /* for the separating space */;
if (has_space)
{
len+=2; /* for the quotes */
qcount+=2;
}
}
if (qcount!=2)
opt_s=1;
/* check argv[0] for a space and invalid characters */
if (!opt_s) {
opt_s=1;
p=*argv;
while (*p!='\0') {
if (*p=='&' || *p=='<' || *p=='>' || *p=='(' || *p==')'
|| *p=='@' || *p=='^' || *p=='|') {
opt_s=1;
break;
}
if (*p==' ')
opt_s=0;
p++;
}
}
cmd = HeapAlloc(GetProcessHeap(), 0, len);
if (!cmd)
exit(1);
p = cmd;
for (arg = argv; *arg; arg++)
{
int has_space,has_quote;
char* a;
/* Check for quotes and spaces in this argument */
has_space=has_quote=0;
a=*arg;
if( !*a ) has_space=1;
while (*a!='\0') {
if (*a==' ' || *a=='\t') {
has_space=1;
if (has_quote)
break;
} else if (*a=='"') {
has_quote=1;
if (has_space)
break;
}
a++;
}
/* Now transfer it to the command line */
if (has_space)
*p++='"';
if (has_quote) {
int bcount;
char* a;
bcount=0;
a=*arg;
while (*a!='\0') {
if (*a=='\\') {
*p++=*a;
bcount++;
} else {
if (*a=='"') {
int i;
/* Double all the '\\' preceding this '"', plus one */
for (i=0;i<=bcount;i++)
*p++='\\';
*p++='"';
} else {
*p++=*a;
}
bcount=0;
}
a++;
}
} else {
strcpy(p,*arg);
p+=strlen(*arg);
}
if (has_space)
*p++='"';
*p++=' ';
}
if (p > cmd)
p--; /* remove last space */
*p = '\0';
/* strip first and last quote characters if opt_s; check for invalid
* executable is done later */
if (opt_s && *cmd=='\"')
WCMD_opt_s_strip_quotes(cmd);
}
if (opt_c) {
/* If we do a "wcmd /c command", we don't want to allocate a new
* console since the command returns immediately. Rather, we use
* the currently allocated input and output handles. This allows
* us to pipe to and read from the command interpreter.
*/
if (strchr(cmd,'|') != NULL)
WCMD_pipe(cmd);
else
WCMD_process_command(cmd);
HeapFree(GetProcessHeap(), 0, cmd);
return errorlevel;
}
SetConsoleMode(GetStdHandle(STD_INPUT_HANDLE), ENABLE_LINE_INPUT |
ENABLE_ECHO_INPUT | ENABLE_PROCESSED_INPUT);
SetConsoleTitle("Wine Command Prompt");
if (opt_k) {
WCMD_process_command(cmd);
HeapFree(GetProcessHeap(), 0, cmd);
}
/*
* If there is an AUTOEXEC.BAT file, try to execute it.
*/
GetFullPathName ("\\autoexec.bat", sizeof(string), string, NULL);
h = CreateFile (string, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
if (h != INVALID_HANDLE_VALUE) {
CloseHandle (h);
#if 0
WCMD_batch ((char *)"\\autoexec.bat", (char *)"\\autoexec.bat", 0, NULL, INVALID_HANDLE_VALUE);
#endif
}
/*
* Loop forever getting commands and executing them.
*/
WCMD_version ();
while (TRUE) {
WCMD_show_prompt ();
ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
if (count > 1) {
string[count-1] = '\0'; /* ReadFile output is not null-terminated! */
if (string[count-2] == '\r') string[count-2] = '\0'; /* Under Windoze we get CRLF! */
if (lstrlen (string) != 0) {
if (strchr(string,'|') != NULL) {
WCMD_pipe (string);
}
else {
WCMD_process_command (string);
}
}
}
}
}
/*****************************************************************************
* Process one command. If the command is EXIT this routine does not return.
* We will recurse through here executing batch files.
*/
void WCMD_process_command (char *command)
{
char *cmd, *p, *s, *t;
int status, i;
DWORD count, creationDisposition;
HANDLE h;
char *whichcmd;
SECURITY_ATTRIBUTES sa;
char *new_cmd;
/* Move copy of the command onto the heap so it can be expanded */
new_cmd = HeapAlloc( GetProcessHeap(), 0, MAXSTRING );
strcpy(new_cmd, command);
/* For commands in a context (batch program): */
/* Expand environment variables in a batch file %{0-9} first */
/* including support for any ~ modifiers */
/* Additionally: */
/* Expand the DATE, TIME, CD, RANDOM and ERRORLEVEL special */
/* names allowing environment variable overrides */
/* NOTE: To support the %PATH:xxx% syntax, also perform */
/* manual expansion of environment variables here */
p = new_cmd;
while ((p = strchr(p, '%'))) {
i = *(p+1) - '0';
/* Replace %~ modifications if in batch program */
if (context && *(p+1) == '~') {
WCMD_HandleTildaModifiers(&p, NULL);
p++;
/* Replace use of %0...%9 if in batch program*/
} else if (context && (i >= 0) && (i <= 9)) {
s = strdup (p+2);
t = WCMD_parameter (context -> command, i + context -> shift_count, NULL);
strcpy (p, t);
strcat (p, s);
free (s);
/* Replace use of %* if in batch program*/
} else if (context && *(p+1)=='*') {
char *startOfParms = NULL;
s = strdup (p+2);
t = WCMD_parameter (context -> command, 1, &startOfParms);
if (startOfParms != NULL) strcpy (p, startOfParms);
else *p = 0x00;
strcat (p, s);
free (s);
} else {
p = WCMD_expand_envvar(p);
}
}
cmd = new_cmd;
/* In a batch program, unknown variables are replace by nothing */
/* so remove any remaining %var% */
if (context) {
p = cmd;
while ((p = strchr(p, '%'))) {
s = strchr(p+1, '%');
if (!s) {
*p=0x00;
} else {
t = strdup(s+1);
strcpy(p, t);
free(t);
}
}
/* Show prompt before batch line IF echo is on and in batch program */
if (echo_mode && (cmd[0] != '@')) {
WCMD_show_prompt();
WCMD_output_asis ( cmd);
WCMD_output_asis ( "\n");
}
}
/*
* Changing default drive has to be handled as a special case.
*/
if ((cmd[1] == ':') && IsCharAlpha (cmd[0]) && (strlen(cmd) == 2)) {
status = SetCurrentDirectory (cmd);
if (!status) WCMD_print_error ();
HeapFree( GetProcessHeap(), 0, cmd );
return;
}
/* Don't issue newline WCMD_output (newline); @JED*/
sa.nLength = sizeof(sa);
sa.lpSecurityDescriptor = NULL;
sa.bInheritHandle = TRUE;
/*
* Redirect stdin and/or stdout if required.
*/
if ((p = strchr(cmd,'<')) != NULL) {
h = CreateFile (WCMD_parameter (++p, 0, NULL), GENERIC_READ, FILE_SHARE_READ, &sa, OPEN_EXISTING,
FILE_ATTRIBUTE_NORMAL, NULL);
if (h == INVALID_HANDLE_VALUE) {
WCMD_print_error ();
HeapFree( GetProcessHeap(), 0, cmd );
return;
}
old_stdin = GetStdHandle (STD_INPUT_HANDLE);
SetStdHandle (STD_INPUT_HANDLE, h);
}
if ((p = strchr(cmd,'>')) != NULL) {
*p++ = '\0';
if ('>' == *p) {
creationDisposition = OPEN_ALWAYS;
p++;
}
else {
creationDisposition = CREATE_ALWAYS;
}
h = CreateFile (WCMD_parameter (p, 0, NULL), GENERIC_WRITE, 0, &sa, creationDisposition,
FILE_ATTRIBUTE_NORMAL, NULL);
if (h == INVALID_HANDLE_VALUE) {
WCMD_print_error ();
HeapFree( GetProcessHeap(), 0, cmd );
return;
}
if (SetFilePointer (h, 0, NULL, FILE_END) ==
INVALID_SET_FILE_POINTER) {
WCMD_print_error ();
}
old_stdout = GetStdHandle (STD_OUTPUT_HANDLE);
SetStdHandle (STD_OUTPUT_HANDLE, h);
}
if ((p = strchr(cmd,'<')) != NULL) *p = '\0';
/*
* Strip leading whitespaces, and a '@' if supplied
*/
whichcmd = WCMD_strtrim_leading_spaces(cmd);
if (whichcmd[0] == '@') whichcmd++;
/*
* Check if the command entered is internal. If it is, pass the rest of the
* line down to the command. If not try to run a program.
*/
count = 0;
while (IsCharAlphaNumeric(whichcmd[count])) {
count++;
}
for (i=0; i<=WCMD_EXIT; i++) {
if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
whichcmd, count, inbuilt[i], -1) == 2) break;
}
p = WCMD_strtrim_leading_spaces (&whichcmd[count]);
WCMD_parse (p, quals, param1, param2);
switch (i) {
case WCMD_ATTRIB:
WCMD_setshow_attrib ();
break;
case WCMD_CALL:
WCMD_call (p);
break;
case WCMD_CD:
case WCMD_CHDIR:
WCMD_setshow_default ();
break;
case WCMD_CLS:
WCMD_clear_screen ();
break;
case WCMD_COPY:
WCMD_copy ();
break;
case WCMD_CTTY:
WCMD_change_tty ();
break;
case WCMD_DATE:
WCMD_setshow_date ();
break;
case WCMD_DEL:
case WCMD_ERASE:
WCMD_delete (0);
break;
case WCMD_DIR:
WCMD_directory ();
break;
case WCMD_ECHO:
WCMD_echo(&whichcmd[count]);
break;
case WCMD_FOR:
WCMD_for (p);
break;
case WCMD_GOTO:
WCMD_goto ();
break;
case WCMD_HELP:
WCMD_give_help (p);
break;
case WCMD_IF:
WCMD_if (p);
break;
case WCMD_LABEL:
WCMD_volume (1, p);
break;
case WCMD_MD:
case WCMD_MKDIR:
WCMD_create_dir ();
break;
case WCMD_MOVE:
WCMD_move ();
break;
case WCMD_PATH:
WCMD_setshow_path (p);
break;
case WCMD_PAUSE:
WCMD_pause ();
break;
case WCMD_PROMPT:
WCMD_setshow_prompt ();
break;
case WCMD_REM:
break;
case WCMD_REN:
case WCMD_RENAME:
WCMD_rename ();
break;
case WCMD_RD:
case WCMD_RMDIR:
WCMD_remove_dir ();
break;
case WCMD_SETLOCAL:
WCMD_setlocal(p);
break;
case WCMD_ENDLOCAL:
WCMD_endlocal();
break;
case WCMD_SET:
WCMD_setshow_env (p);
break;
case WCMD_SHIFT:
WCMD_shift ();
break;
case WCMD_TIME:
WCMD_setshow_time ();
break;
case WCMD_TITLE:
if (strlen(&whichcmd[count]) > 0)
WCMD_title(&whichcmd[count+1]);
break;
case WCMD_TYPE:
WCMD_type ();
break;
case WCMD_VER:
WCMD_version ();
break;
case WCMD_VERIFY:
WCMD_verify (p);
break;
case WCMD_VOL:
WCMD_volume (0, p);
break;
case WCMD_PUSHD:
WCMD_pushd();
break;
case WCMD_POPD:
WCMD_popd();
break;
case WCMD_EXIT:
WCMD_exit ();
break;
default:
WCMD_run_program (whichcmd, 0);
}
HeapFree( GetProcessHeap(), 0, cmd );
if (old_stdin != INVALID_HANDLE_VALUE) {
CloseHandle (GetStdHandle (STD_INPUT_HANDLE));
SetStdHandle (STD_INPUT_HANDLE, old_stdin);
old_stdin = INVALID_HANDLE_VALUE;
}
if (old_stdout != INVALID_HANDLE_VALUE) {
CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE));
SetStdHandle (STD_OUTPUT_HANDLE, old_stdout);
old_stdout = INVALID_HANDLE_VALUE;
}
}
static void init_msvcrt_io_block(STARTUPINFO* st)
{
STARTUPINFO st_p;
/* fetch the parent MSVCRT info block if any, so that the child can use the
* same handles as its grand-father
*/
st_p.cb = sizeof(STARTUPINFO);
GetStartupInfo(&st_p);
st->cbReserved2 = st_p.cbReserved2;
st->lpReserved2 = st_p.lpReserved2;
if (st_p.cbReserved2 && st_p.lpReserved2 &&
(old_stdin != INVALID_HANDLE_VALUE || old_stdout != INVALID_HANDLE_VALUE))
{
/* Override the entries for fd 0,1,2 if we happened
* to change those std handles (this depends on the way wcmd sets
* it's new input & output handles)
*/
size_t sz = max(sizeof(unsigned) + (sizeof(char) + sizeof(HANDLE)) * 3, st_p.cbReserved2);
BYTE* ptr = HeapAlloc(GetProcessHeap(), 0, sz);
if (ptr)
{
unsigned num = *(unsigned*)st_p.lpReserved2;
char* flags = (char*)(ptr + sizeof(unsigned));
HANDLE* handles = (HANDLE*)(flags + num * sizeof(char));
memcpy(ptr, st_p.lpReserved2, st_p.cbReserved2);
st->cbReserved2 = sz;
st->lpReserved2 = ptr;
#define WX_OPEN 0x01 /* see dlls/msvcrt/file.c */
if (num <= 0 || (flags[0] & WX_OPEN))
{
handles[0] = GetStdHandle(STD_INPUT_HANDLE);
flags[0] |= WX_OPEN;
}
if (num <= 1 || (flags[1] & WX_OPEN))
{
handles[1] = GetStdHandle(STD_OUTPUT_HANDLE);
flags[1] |= WX_OPEN;
}
if (num <= 2 || (flags[2] & WX_OPEN))
{
handles[2] = GetStdHandle(STD_ERROR_HANDLE);
flags[2] |= WX_OPEN;
}
#undef WX_OPEN
}
}
}
/******************************************************************************
* WCMD_run_program
*
* Execute a command line as an external program. Must allow recursion.
*
* Precedence:
* Manual testing under windows shows PATHEXT plays a key part in this,
* and the search algorithm and precedence appears to be as follows.
*
* Search locations:
* If directory supplied on command, just use that directory
* If extension supplied on command, look for that explicit name first
* Otherwise, search in each directory on the path
* Precedence:
* If extension supplied on command, look for that explicit name first
* Then look for supplied name .* (even if extension supplied, so
* 'garbage.exe' will match 'garbage.exe.cmd')
* If any found, cycle through PATHEXT looking for name.exe one by one
* Launching
* Once a match has been found, it is launched - Code currently uses
* findexecutable to acheive this which is left untouched.
*/
void WCMD_run_program (char *command, int called) {
char temp[MAX_PATH];
char pathtosearch[MAX_PATH];
char *pathposn;
char stemofsearch[MAX_PATH];
char *lastSlash;
char pathext[MAXSTRING];
BOOL extensionsupplied = FALSE;
BOOL launched = FALSE;
BOOL status;
WCMD_parse (command, quals, param1, param2); /* Quick way to get the filename */
if (!(*param1) && !(*param2))
return;
/* Calculate the search path and stem to search for */
if (strpbrk (param1, "/\\:") == NULL) { /* No explicit path given, search path */
strcpy(pathtosearch,".;");
status = GetEnvironmentVariable ("PATH", &pathtosearch[2], sizeof(pathtosearch)-2);
if ((status == 0) || (status > sizeof(pathtosearch))) {
lstrcpy (pathtosearch, ".");
}
if (strchr(param1, '.') != NULL) extensionsupplied = TRUE;
strcpy(stemofsearch, param1);
} else {
/* Convert eg. ..\fred to include a directory by removing file part */
GetFullPathName(param1, MAX_PATH, pathtosearch, NULL);
lastSlash = strrchr(pathtosearch, '\\');
if (lastSlash) *lastSlash = 0x00;
if (strchr(lastSlash, '.') != NULL) extensionsupplied = TRUE;
strcpy(stemofsearch, lastSlash+1);
}
/* Now extract PATHEXT */
status = GetEnvironmentVariable ("PATHEXT", pathext, sizeof(pathext));
if ((status == 0) || (status > sizeof(pathext))) {
lstrcpy (pathext, ".bat;.com;.cmd;.exe");
}
/* Loop through the search path, dir by dir */
pathposn = pathtosearch;
while (!launched && pathposn) {
char thisDir[MAX_PATH] = "";
char *pos = NULL;
BOOL found = FALSE;
/* Work on the first directory on the search path */
pos = strchr(pathposn, ';');
if (pos) {
strncpy(thisDir, pathposn, (pos-pathposn));
thisDir[(pos-pathposn)] = 0x00;
pathposn = pos+1;
} else {
strcpy(thisDir, pathposn);
pathposn = NULL;
}
/* Since you can have eg. ..\.. on the path, need to expand
to full information */
strcpy(temp, thisDir);
GetFullPathName(temp, MAX_PATH, thisDir, NULL);
/* 1. If extension supplied, see if that file exists */
strcat(thisDir, "\\");
strcat(thisDir, stemofsearch);
pos = &thisDir[strlen(thisDir)]; /* Pos = end of name */
if (GetFileAttributes(thisDir) != INVALID_FILE_ATTRIBUTES) {
found = TRUE;
}
/* 2. Any .* matches? */
if (!found) {
HANDLE h;
WIN32_FIND_DATA finddata;
strcat(thisDir,".*");
h = FindFirstFile(thisDir, &finddata);
FindClose(h);
if (h != INVALID_HANDLE_VALUE) {
char *thisExt = pathext;
/* 3. Yes - Try each path ext */
while (thisExt) {
char *nextExt = strchr(thisExt, ';');
if (nextExt) {
strncpy(pos, thisExt, (nextExt-thisExt));
pos[(nextExt-thisExt)] = 0x00;
thisExt = nextExt+1;
} else {
strcpy(pos, thisExt);
thisExt = NULL;
}
if (GetFileAttributes(thisDir) != INVALID_FILE_ATTRIBUTES) {
found = TRUE;
thisExt = NULL;
}
}
}
}
/* Once found, launch it */
if (found) {
STARTUPINFO st;
PROCESS_INFORMATION pe;
SHFILEINFO psfi;
DWORD console;
HINSTANCE hinst;
char *ext = strrchr( thisDir, '.' );
launched = TRUE;
/* Special case BAT and CMD */
if (ext && !strcasecmp(ext, ".bat")) {
WCMD_batch (thisDir, command, called, NULL, INVALID_HANDLE_VALUE);
return;
} else if (ext && !strcasecmp(ext, ".cmd")) {
WCMD_batch (thisDir, command, called, NULL, INVALID_HANDLE_VALUE);
return;
} else {
/* thisDir contains the file to be launched, but with what?
eg. a.exe will require a.exe to be launched, a.html may be iexplore */
hinst = FindExecutable (param1, NULL, temp);
if ((INT_PTR)hinst < 32)
console = 0;
else
console = SHGetFileInfo (temp, 0, &psfi, sizeof(psfi), SHGFI_EXETYPE);
ZeroMemory (&st, sizeof(STARTUPINFO));
st.cb = sizeof(STARTUPINFO);
init_msvcrt_io_block(&st);
/* Launch the process and if a CUI wait on it to complete */
status = CreateProcess (thisDir, command, NULL, NULL, TRUE,
0, NULL, NULL, &st, &pe);
if ((opt_c || opt_k) && !opt_s && !status
&& GetLastError()==ERROR_FILE_NOT_FOUND && command[0]=='\"') {
/* strip first and last quote characters and try again */
WCMD_opt_s_strip_quotes(command);
opt_s=1;
WCMD_run_program(command, called);
return;
}
if (!status) {
WCMD_print_error ();
/* If a command fails to launch, it sets errorlevel 9009 - which
does not seem to have any associated constant definition */
errorlevel = 9009;
return;
}
if (!console) errorlevel = 0;
else
{
if (!HIWORD(console)) WaitForSingleObject (pe.hProcess, INFINITE);
GetExitCodeProcess (pe.hProcess, &errorlevel);
if (errorlevel == STILL_ACTIVE) errorlevel = 0;
}
CloseHandle(pe.hProcess);
CloseHandle(pe.hThread);
return;
}
}
}
/* Not found anywhere - give up */
SetLastError(ERROR_FILE_NOT_FOUND);
WCMD_print_error ();
/* If a command fails to launch, it sets errorlevel 9009 - which
does not seem to have any associated constant definition */
errorlevel = 9009;
return;
}
/******************************************************************************
* WCMD_show_prompt
*
* Display the prompt on STDout
*
*/
void WCMD_show_prompt (void) {
int status;
char out_string[MAX_PATH], curdir[MAX_PATH], prompt_string[MAX_PATH];
char *p, *q;
status = GetEnvironmentVariable ("PROMPT", prompt_string, sizeof(prompt_string));
if ((status == 0) || (status > sizeof(prompt_string))) {
lstrcpy (prompt_string, "$P$G");
}
p = prompt_string;
q = out_string;
*q = '\0';
while (*p != '\0') {
if (*p != '$') {
*q++ = *p++;
*q = '\0';
}
else {
p++;
switch (toupper(*p)) {
case '$':
*q++ = '$';
break;
case 'B':
*q++ = '|';
break;
case 'D':
GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, q, MAX_PATH);
while (*q) q++;
break;
case 'E':
*q++ = '\E';
break;
case 'G':
*q++ = '>';
break;
case 'L':
*q++ = '<';
break;
case 'N':
status = GetCurrentDirectory (sizeof(curdir), curdir);
if (status) {
*q++ = curdir[0];
}
break;
case 'P':
status = GetCurrentDirectory (sizeof(curdir), curdir);
if (status) {
lstrcat (q, curdir);
while (*q) q++;
}
break;
case 'Q':
*q++ = '=';
break;
case 'T':
GetTimeFormat (LOCALE_USER_DEFAULT, 0, NULL, NULL, q, MAX_PATH);
while (*q) q++;
break;
case 'V':
lstrcat (q, version_string);
while (*q) q++;
break;
case '_':
*q++ = '\n';
break;
}
p++;
*q = '\0';
}
}
WCMD_output_asis (out_string);
}
/****************************************************************************
* WCMD_print_error
*
* Print the message for GetLastError
*/
void WCMD_print_error (void) {
LPVOID lpMsgBuf;
DWORD error_code;
int status;
error_code = GetLastError ();
status = FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
NULL, error_code, 0, (LPTSTR) &lpMsgBuf, 0, NULL);
if (!status) {
WCMD_output ("FIXME: Cannot display message for error %d, status %d\n",
error_code, GetLastError());
return;
}
WCMD_output_asis (lpMsgBuf);
LocalFree ((HLOCAL)lpMsgBuf);
WCMD_output_asis (newline);
return;
}
/*******************************************************************
* WCMD_parse - parse a command into parameters and qualifiers.
*
* On exit, all qualifiers are concatenated into q, the first string
* not beginning with "/" is in p1 and the
* second in p2. Any subsequent non-qualifier strings are lost.
* Parameters in quotes are handled.
*/
void WCMD_parse (char *s, char *q, char *p1, char *p2) {
int p = 0;
*q = *p1 = *p2 = '\0';
while (TRUE) {
switch (*s) {
case '/':
*q++ = *s++;
while ((*s != '\0') && (*s != ' ') && *s != '/') {
*q++ = toupper (*s++);
}
*q = '\0';
break;
case ' ':
case '\t':
s++;
break;
case '"':
s++;
while ((*s != '\0') && (*s != '"')) {
if (p == 0) *p1++ = *s++;
else if (p == 1) *p2++ = *s++;
else s++;
}
if (p == 0) *p1 = '\0';
if (p == 1) *p2 = '\0';
p++;
if (*s == '"') s++;
break;
case '\0':
return;
default:
while ((*s != '\0') && (*s != ' ') && (*s != '\t')) {
if (p == 0) *p1++ = *s++;
else if (p == 1) *p2++ = *s++;
else s++;
}
if (p == 0) *p1 = '\0';
if (p == 1) *p2 = '\0';
p++;
}
}
}
/*******************************************************************
* WCMD_output - send output to current standard output device.
*
*/
void WCMD_output (const char *format, ...) {
va_list ap;
char string[1024];
int ret;
va_start(ap,format);
ret = vsnprintf (string, sizeof( string), format, ap);
va_end(ap);
if( ret >= sizeof( string)) {
WCMD_output_asis("ERR: output truncated in WCMD_output\n" );
string[sizeof( string) -1] = '\0';
}
WCMD_output_asis(string);
}
static int line_count;
static int max_height;
static BOOL paged_mode;
void WCMD_enter_paged_mode(void)
{
CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &consoleInfo))
max_height = consoleInfo.dwSize.Y;
else
max_height = 25;
paged_mode = TRUE;
line_count = 5; /* keep 5 lines from previous output */
}
void WCMD_leave_paged_mode(void)
{
paged_mode = FALSE;
}
/*******************************************************************
* WCMD_output_asis - send output to current standard output device.
* without formatting eg. when message contains '%'
*/
void WCMD_output_asis (const char *message) {
DWORD count;
char* ptr;
char string[1024];
if (paged_mode) {
do {
if ((ptr = strchr(message, '\n')) != NULL) ptr++;
WriteFile (GetStdHandle(STD_OUTPUT_HANDLE), message,
(ptr) ? ptr - message : lstrlen(message), &count, NULL);
if (ptr) {
if (++line_count >= max_height - 1) {
line_count = 0;
WCMD_output_asis (anykey);
ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
}
}
} while ((message = ptr) != NULL);
} else {
WriteFile (GetStdHandle(STD_OUTPUT_HANDLE), message, lstrlen(message), &count, NULL);
}
}
/***************************************************************************
* WCMD_strtrim_leading_spaces
*
* Remove leading spaces from a string. Return a pointer to the first
* non-space character. Does not modify the input string
*/
char *WCMD_strtrim_leading_spaces (char *string) {
char *ptr;
ptr = string;
while (*ptr == ' ') ptr++;
return ptr;
}
/*************************************************************************
* WCMD_strtrim_trailing_spaces
*
* Remove trailing spaces from a string. This routine modifies the input
* string by placing a null after the last non-space character
*/
void WCMD_strtrim_trailing_spaces (char *string) {
char *ptr;
ptr = string + lstrlen (string) - 1;
while ((*ptr == ' ') && (ptr >= string)) {
*ptr = '\0';
ptr--;
}
}
/*************************************************************************
* WCMD_opt_s_strip_quotes
*
* Remove first and last quote characters, preserving all other text
*/
void WCMD_opt_s_strip_quotes(char *cmd) {
char *src = cmd + 1, *dest = cmd, *lastq = NULL;
while((*dest=*src) != '\0') {
if (*src=='\"')
lastq=dest;
dest++, src++;
}
if (lastq) {
dest=lastq++;
while ((*dest++=*lastq++) != 0)
;
}
}
/*************************************************************************
* WCMD_pipe
*
* Handle pipes within a command - the DOS way using temporary files.
*/
void WCMD_pipe (char *command) {
char *p;
char temp_path[MAX_PATH], temp_file[MAX_PATH], temp_file2[MAX_PATH], temp_cmd[1024];
GetTempPath (sizeof(temp_path), temp_path);
GetTempFileName (temp_path, "CMD", 0, temp_file);
p = strchr(command, '|');
*p++ = '\0';
wsprintf (temp_cmd, "%s > %s", command, temp_file);
WCMD_process_command (temp_cmd);
command = p;
while ((p = strchr(command, '|'))) {
*p++ = '\0';
GetTempFileName (temp_path, "CMD", 0, temp_file2);
wsprintf (temp_cmd, "%s < %s > %s", command, temp_file, temp_file2);
WCMD_process_command (temp_cmd);
DeleteFile (temp_file);
lstrcpy (temp_file, temp_file2);
command = p;
}
wsprintf (temp_cmd, "%s < %s", command, temp_file);
WCMD_process_command (temp_cmd);
DeleteFile (temp_file);
}
/*************************************************************************
* WCMD_expand_envvar
*
* Expands environment variables, allowing for character substitution
*/
static char *WCMD_expand_envvar(char *start) {
char *endOfVar = NULL, *s;
char *colonpos = NULL;
char thisVar[MAXSTRING];
char thisVarContents[MAXSTRING];
char savedchar = 0x00;
int len;
/* Find the end of the environment variable, and extract name */
endOfVar = strchr(start+1, '%');
if (endOfVar == NULL) {
/* FIXME: Some special conditions here depending opn whether
in batch, complex or not, and whether env var exists or not! */
return start+1;
}
strncpy(thisVar, start, (endOfVar - start)+1);
thisVar[(endOfVar - start)+1] = 0x00;
colonpos = strchr(thisVar+1, ':');
/* If there's complex substitution, just need %var% for now
to get the expanded data to play with */
if (colonpos) {
*colonpos = '%';
savedchar = *(colonpos+1);
*(colonpos+1) = 0x00;
}
/* Expand to contents, if unchanged, return */
/* Handle DATE, TIME, ERRORLEVEL and CD replacements allowing */
/* override if existing env var called that name */
if ((CompareString (LOCALE_USER_DEFAULT,
NORM_IGNORECASE | SORT_STRINGSORT,
thisVar, 12, "%ERRORLEVEL%", -1) == 2) &&
(GetEnvironmentVariable("ERRORLEVEL", thisVarContents, 1) == 0) &&
(GetLastError() == ERROR_ENVVAR_NOT_FOUND)) {
sprintf(thisVarContents, "%d", errorlevel);
len = strlen(thisVarContents);
} else if ((CompareString (LOCALE_USER_DEFAULT,
NORM_IGNORECASE | SORT_STRINGSORT,
thisVar, 6, "%DATE%", -1) == 2) &&
(GetEnvironmentVariable("DATE", thisVarContents, 1) == 0) &&
(GetLastError() == ERROR_ENVVAR_NOT_FOUND)) {
GetDateFormat(LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL,
NULL, thisVarContents, MAXSTRING);
len = strlen(thisVarContents);
} else if ((CompareString (LOCALE_USER_DEFAULT,
NORM_IGNORECASE | SORT_STRINGSORT,
thisVar, 6, "%TIME%", -1) == 2) &&
(GetEnvironmentVariable("TIME", thisVarContents, 1) == 0) &&
(GetLastError() == ERROR_ENVVAR_NOT_FOUND)) {
GetTimeFormat(LOCALE_USER_DEFAULT, TIME_NOSECONDS, NULL,
NULL, thisVarContents, MAXSTRING);
len = strlen(thisVarContents);
} else if ((CompareString (LOCALE_USER_DEFAULT,
NORM_IGNORECASE | SORT_STRINGSORT,
thisVar, 4, "%CD%", -1) == 2) &&
(GetEnvironmentVariable("CD", thisVarContents, 1) == 0) &&
(GetLastError() == ERROR_ENVVAR_NOT_FOUND)) {
GetCurrentDirectory (MAXSTRING, thisVarContents);
len = strlen(thisVarContents);
} else if ((CompareString (LOCALE_USER_DEFAULT,
NORM_IGNORECASE | SORT_STRINGSORT,
thisVar, 8, "%RANDOM%", -1) == 2) &&
(GetEnvironmentVariable("RANDOM", thisVarContents, 1) == 0) &&
(GetLastError() == ERROR_ENVVAR_NOT_FOUND)) {
sprintf(thisVarContents, "%d", rand() % 32768);
len = strlen(thisVarContents);
} else {
len = ExpandEnvironmentStrings(thisVar, thisVarContents,
sizeof(thisVarContents));
}
if (len == 0)
return endOfVar+1;
/* In a batch program, unknown env vars are replaced with nothing,
note syntax %garbage:1,3% results in anything after the ':'
except the %
From the command line, you just get back what you entered */
if (lstrcmpi(thisVar, thisVarContents) == 0) {
/* Restore the complex part after the compare */
if (colonpos) {
*colonpos = ':';
*(colonpos+1) = savedchar;
}
s = strdup (endOfVar + 1);
/* Command line - just ignore this */
if (context == NULL) return endOfVar+1;
/* Batch - replace unknown env var with nothing */
if (colonpos == NULL) {
strcpy (start, s);
} else {
len = strlen(thisVar);
thisVar[len-1] = 0x00;
/* If %:...% supplied, : is retained */
if (colonpos == thisVar+1) {
strcpy (start, colonpos);
} else {
strcpy (start, colonpos+1);
}
strcat (start, s);
}
free (s);
return start;
}
/* See if we need to do complex substitution (any ':'s), if not
then our work here is done */
if (colonpos == NULL) {
s = strdup (endOfVar + 1);
strcpy (start, thisVarContents);
strcat (start, s);
free(s);
return start;
}
/* Restore complex bit */
*colonpos = ':';
*(colonpos+1) = savedchar;
/*
Handle complex substitutions:
xxx=yyy (replace xxx with yyy)
*xxx=yyy (replace up to and including xxx with yyy)
~x (from x chars in)
~-x (from x chars from the end)
~x,y (from x chars in for y characters)
~x,-y (from x chars in until y characters from the end)
*/
/* ~ is substring manipulation */
if (savedchar == '~') {
int substrposition, substrlength;
char *commapos = strchr(colonpos+2, ',');
char *startCopy;
substrposition = atol(colonpos+2);
if (commapos) substrlength = atol(commapos+1);
s = strdup (endOfVar + 1);
/* Check bounds */
if (substrposition >= 0) {
startCopy = &thisVarContents[min(substrposition, len)];
} else {
startCopy = &thisVarContents[max(0, len+substrposition-1)];
}
if (commapos == NULL) {
strcpy (start, startCopy); /* Copy the lot */
} else if (substrlength < 0) {
int copybytes = (len+substrlength-1)-(startCopy-thisVarContents);
if (copybytes > len) copybytes = len;
else if (copybytes < 0) copybytes = 0;
strncpy (start, startCopy, copybytes); /* Copy the lot */
start[copybytes] = 0x00;
} else {
strncpy (start, startCopy, substrlength); /* Copy the lot */
start[substrlength] = 0x00;
}
strcat (start, s);
free(s);
return start;
/* search and replace manipulation */
} else {
char *equalspos = strstr(colonpos, "=");
char *replacewith = equalspos+1;
char *found = NULL;
char *searchIn;
char *searchFor;
s = strdup (endOfVar + 1);
if (equalspos == NULL) return start+1;
/* Null terminate both strings */
thisVar[strlen(thisVar)-1] = 0x00;
*equalspos = 0x00;
/* Since we need to be case insensitive, copy the 2 buffers */
searchIn = strdup(thisVarContents);
CharUpperBuff(searchIn, strlen(thisVarContents));
searchFor = strdup(colonpos+1);
CharUpperBuff(searchFor, strlen(colonpos+1));
/* Handle wildcard case */
if (*(colonpos+1) == '*') {
/* Search for string to replace */
found = strstr(searchIn, searchFor+1);
if (found) {
/* Do replacement */
strcpy(start, replacewith);
strcat(start, thisVarContents + (found-searchIn) + strlen(searchFor+1));
strcat(start, s);
free(s);
} else {
/* Copy as it */
strcpy(start, thisVarContents);
strcat(start, s);
}
} else {
/* Loop replacing all instances */
char *lastFound = searchIn;
char *outputposn = start;
*start = 0x00;
while ((found = strstr(lastFound, searchFor))) {
strncpy(outputposn,
thisVarContents + (lastFound-searchIn),
(found - lastFound));
outputposn = outputposn + (found - lastFound);
*outputposn = 0x00;
strcat(outputposn, replacewith);
outputposn = outputposn + strlen(replacewith);
lastFound = found + strlen(searchFor);
}
strcat(outputposn,
thisVarContents + (lastFound-searchIn));
strcat(outputposn, s);
}
free(searchIn);
free(searchFor);
return start;
}
return start+1;
}
Reference in New Issue View Git Blame Copy Permalink