mirror of
https://github.com/reactos/wine.git
synced 2024-12-05 10:17:57 +00:00
1119 lines
26 KiB
C
1119 lines
26 KiB
C
/*
|
|
* WCMD - Wine-compatible command line interface - built-in functions.
|
|
*
|
|
* Copyright (C) 1999 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
|
|
*/
|
|
|
|
/*
|
|
* NOTES:
|
|
* On entry to each function, global variables quals, param1, param2 contain
|
|
* the qualifiers (uppercased and concatenated) and parameters entered, with
|
|
* environment-variable and batch parameter substitution already done.
|
|
*/
|
|
|
|
/*
|
|
* FIXME:
|
|
* - No support for pipes, shell parameters
|
|
* - Lots of functionality missing from builtins
|
|
* - Messages etc need international support
|
|
*/
|
|
|
|
#define WIN32_LEAN_AND_MEAN
|
|
|
|
#include "wcmd.h"
|
|
|
|
void WCMD_execute (char *orig_command, char *parameter, char *substitution);
|
|
|
|
struct env_stack
|
|
{
|
|
struct env_stack *next;
|
|
WCHAR *strings;
|
|
};
|
|
|
|
struct env_stack *saved_environment;
|
|
|
|
extern HINSTANCE hinst;
|
|
extern char *inbuilt[];
|
|
extern int echo_mode, verify_mode;
|
|
extern char quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
|
|
extern BATCH_CONTEXT *context;
|
|
extern DWORD errorlevel;
|
|
|
|
|
|
|
|
/****************************************************************************
|
|
* WCMD_clear_screen
|
|
*
|
|
* Clear the terminal screen.
|
|
*/
|
|
|
|
void WCMD_clear_screen (void) {
|
|
|
|
/* Emulate by filling the screen from the top left to bottom right with
|
|
spaces, then moving the cursor to the top left afterwards */
|
|
CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
|
|
HANDLE hStdOut = GetStdHandle(STD_OUTPUT_HANDLE);
|
|
|
|
if (GetConsoleScreenBufferInfo(hStdOut, &consoleInfo))
|
|
{
|
|
COORD topLeft;
|
|
DWORD screenSize;
|
|
|
|
screenSize = consoleInfo.dwSize.X * (consoleInfo.dwSize.Y + 1);
|
|
|
|
topLeft.X = 0;
|
|
topLeft.Y = 0;
|
|
FillConsoleOutputCharacter(hStdOut, ' ', screenSize, topLeft, &screenSize);
|
|
SetConsoleCursorPosition(hStdOut, topLeft);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_change_tty
|
|
*
|
|
* Change the default i/o device (ie redirect STDin/STDout).
|
|
*/
|
|
|
|
void WCMD_change_tty (void) {
|
|
|
|
WCMD_output (nyi);
|
|
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_copy
|
|
*
|
|
* Copy a file or wildcarded set.
|
|
* FIXME: No wildcard support
|
|
*/
|
|
|
|
void WCMD_copy (void) {
|
|
|
|
DWORD count;
|
|
WIN32_FIND_DATA fd;
|
|
HANDLE hff;
|
|
BOOL force, status;
|
|
static const char overwrite[] = "Overwrite file (Y/N)?";
|
|
char string[8], outpath[MAX_PATH], inpath[MAX_PATH], *infile;
|
|
|
|
if ((strchr(param1,'*') != NULL) && (strchr(param1,'%') != NULL)) {
|
|
WCMD_output ("Wildcards not yet supported\n");
|
|
return;
|
|
}
|
|
|
|
/* If no destination supplied, assume current directory */
|
|
if (param2[0] == 0x00) {
|
|
strcpy(param2, ".");
|
|
}
|
|
|
|
GetFullPathName (param2, sizeof(outpath), outpath, NULL);
|
|
hff = FindFirstFile (outpath, &fd);
|
|
if (hff != INVALID_HANDLE_VALUE) {
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
GetFullPathName (param1, sizeof(inpath), inpath, &infile);
|
|
strcat (outpath, "\\");
|
|
strcat (outpath, infile);
|
|
}
|
|
FindClose (hff);
|
|
}
|
|
|
|
force = (strstr (quals, "/Y") != NULL);
|
|
if (!force) {
|
|
hff = FindFirstFile (outpath, &fd);
|
|
if (hff != INVALID_HANDLE_VALUE) {
|
|
FindClose (hff);
|
|
WCMD_output (overwrite);
|
|
ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
|
|
if (toupper(string[0]) == 'Y') force = TRUE;
|
|
}
|
|
else force = TRUE;
|
|
}
|
|
if (force) {
|
|
status = CopyFile (param1, outpath, FALSE);
|
|
if (!status) WCMD_print_error ();
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_create_dir
|
|
*
|
|
* Create a directory.
|
|
*
|
|
* this works recursivly. so mkdir dir1\dir2\dir3 will create dir1 and dir2 if
|
|
* they do not already exist.
|
|
*/
|
|
|
|
BOOL create_full_path(CHAR* path)
|
|
{
|
|
int len;
|
|
CHAR *new_path;
|
|
BOOL ret = TRUE;
|
|
|
|
new_path = HeapAlloc(GetProcessHeap(),0,strlen(path)+1);
|
|
strcpy(new_path,path);
|
|
|
|
while ((len = strlen(new_path)) && new_path[len - 1] == '\\')
|
|
new_path[len - 1] = 0;
|
|
|
|
while (!CreateDirectory(new_path,NULL))
|
|
{
|
|
CHAR *slash;
|
|
DWORD last_error = GetLastError();
|
|
if (last_error == ERROR_ALREADY_EXISTS)
|
|
break;
|
|
|
|
if (last_error != ERROR_PATH_NOT_FOUND)
|
|
{
|
|
ret = FALSE;
|
|
break;
|
|
}
|
|
|
|
if (!(slash = strrchr(new_path,'\\')) && ! (slash = strrchr(new_path,'/')))
|
|
{
|
|
ret = FALSE;
|
|
break;
|
|
}
|
|
|
|
len = slash - new_path;
|
|
new_path[len] = 0;
|
|
if (!create_full_path(new_path))
|
|
{
|
|
ret = FALSE;
|
|
break;
|
|
}
|
|
new_path[len] = '\\';
|
|
}
|
|
HeapFree(GetProcessHeap(),0,new_path);
|
|
return ret;
|
|
}
|
|
|
|
void WCMD_create_dir (void) {
|
|
|
|
if (!create_full_path(param1)) WCMD_print_error ();
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_delete
|
|
*
|
|
* Delete a file or wildcarded set.
|
|
*
|
|
*/
|
|
|
|
void WCMD_delete (int recurse) {
|
|
|
|
WIN32_FIND_DATA fd;
|
|
HANDLE hff;
|
|
char fpath[MAX_PATH];
|
|
char *p;
|
|
|
|
hff = FindFirstFile (param1, &fd);
|
|
if (hff == INVALID_HANDLE_VALUE) {
|
|
WCMD_output ("%s :File Not Found\n",param1);
|
|
return;
|
|
}
|
|
if ((strchr(param1,'*') == NULL) && (strchr(param1,'?') == NULL)
|
|
&& (!recurse) && (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
|
|
strcat (param1, "\\*");
|
|
FindClose(hff);
|
|
WCMD_delete (1);
|
|
return;
|
|
}
|
|
if ((strchr(param1,'*') != NULL) || (strchr(param1,'?') != NULL)) {
|
|
strcpy (fpath, param1);
|
|
do {
|
|
p = strrchr (fpath, '\\');
|
|
if (p != NULL) {
|
|
*++p = '\0';
|
|
strcat (fpath, fd.cFileName);
|
|
}
|
|
else strcpy (fpath, fd.cFileName);
|
|
if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
|
|
if (!DeleteFile (fpath)) WCMD_print_error ();
|
|
}
|
|
} while (FindNextFile(hff, &fd) != 0);
|
|
FindClose (hff);
|
|
}
|
|
else {
|
|
if (!DeleteFile (param1)) WCMD_print_error ();
|
|
FindClose (hff);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_echo
|
|
*
|
|
* Echo input to the screen (or not). We don't try to emulate the bugs
|
|
* in DOS (try typing "ECHO ON AGAIN" for an example).
|
|
*/
|
|
|
|
void WCMD_echo (const char *command) {
|
|
|
|
static const char eon[] = "Echo is ON\n", eoff[] = "Echo is OFF\n";
|
|
int count;
|
|
|
|
if ((command[0] == '.') && (command[1] == 0)) {
|
|
WCMD_output (newline);
|
|
return;
|
|
}
|
|
if (command[0]==' ')
|
|
command++;
|
|
count = strlen(command);
|
|
if (count == 0) {
|
|
if (echo_mode) WCMD_output (eon);
|
|
else WCMD_output (eoff);
|
|
return;
|
|
}
|
|
if (lstrcmpi(command, "ON") == 0) {
|
|
echo_mode = 1;
|
|
return;
|
|
}
|
|
if (lstrcmpi(command, "OFF") == 0) {
|
|
echo_mode = 0;
|
|
return;
|
|
}
|
|
WCMD_output_asis (command);
|
|
WCMD_output (newline);
|
|
|
|
}
|
|
|
|
/**************************************************************************
|
|
* WCMD_for
|
|
*
|
|
* Batch file loop processing.
|
|
* FIXME: We don't exhaustively check syntax. Any command which works in MessDOS
|
|
* will probably work here, but the reverse is not necessarily the case...
|
|
*/
|
|
|
|
void WCMD_for (char *p) {
|
|
|
|
WIN32_FIND_DATA fd;
|
|
HANDLE hff;
|
|
char *cmd, *item;
|
|
char set[MAX_PATH], param[MAX_PATH];
|
|
int i;
|
|
|
|
if (lstrcmpi (WCMD_parameter (p, 1, NULL), "in")
|
|
|| lstrcmpi (WCMD_parameter (p, 3, NULL), "do")
|
|
|| (param1[0] != '%')) {
|
|
WCMD_output ("Syntax error\n");
|
|
return;
|
|
}
|
|
lstrcpyn (set, WCMD_parameter (p, 2, NULL), sizeof(set));
|
|
WCMD_parameter (p, 4, &cmd);
|
|
lstrcpy (param, param1);
|
|
|
|
/*
|
|
* If the parameter within the set has a wildcard then search for matching files
|
|
* otherwise do a literal substitution.
|
|
*/
|
|
|
|
i = 0;
|
|
while (*(item = WCMD_parameter (set, i, NULL))) {
|
|
if (strpbrk (item, "*?")) {
|
|
hff = FindFirstFile (item, &fd);
|
|
if (hff == INVALID_HANDLE_VALUE) {
|
|
return;
|
|
}
|
|
do {
|
|
WCMD_execute (cmd, param, fd.cFileName);
|
|
} while (FindNextFile(hff, &fd) != 0);
|
|
FindClose (hff);
|
|
}
|
|
else {
|
|
WCMD_execute (cmd, param, item);
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* WCMD_Execute
|
|
*
|
|
* Execute a command after substituting variable text for the supplied parameter
|
|
*/
|
|
|
|
void WCMD_execute (char *orig_cmd, char *param, char *subst) {
|
|
|
|
char *new_cmd, *p, *s, *dup;
|
|
int size;
|
|
|
|
size = lstrlen (orig_cmd);
|
|
new_cmd = (char *) LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, size);
|
|
dup = s = strdup (orig_cmd);
|
|
|
|
while ((p = strstr (s, param))) {
|
|
*p = '\0';
|
|
size += lstrlen (subst);
|
|
new_cmd = (char *) LocalReAlloc ((HANDLE)new_cmd, size, 0);
|
|
strcat (new_cmd, s);
|
|
strcat (new_cmd, subst);
|
|
s = p + lstrlen (param);
|
|
}
|
|
strcat (new_cmd, s);
|
|
WCMD_process_command (new_cmd);
|
|
free (dup);
|
|
LocalFree ((HANDLE)new_cmd);
|
|
}
|
|
|
|
|
|
/**************************************************************************
|
|
* WCMD_give_help
|
|
*
|
|
* Simple on-line help. Help text is stored in the resource file.
|
|
*/
|
|
|
|
void WCMD_give_help (char *command) {
|
|
|
|
int i;
|
|
char buffer[2048];
|
|
|
|
command = WCMD_strtrim_leading_spaces(command);
|
|
if (lstrlen(command) == 0) {
|
|
LoadString (hinst, 1000, buffer, sizeof(buffer));
|
|
WCMD_output_asis (buffer);
|
|
}
|
|
else {
|
|
for (i=0; i<=WCMD_EXIT; i++) {
|
|
if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
|
|
param1, -1, inbuilt[i], -1) == 2) {
|
|
LoadString (hinst, i, buffer, sizeof(buffer));
|
|
WCMD_output_asis (buffer);
|
|
return;
|
|
}
|
|
}
|
|
WCMD_output ("No help available for %s\n", param1);
|
|
}
|
|
return;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_go_to
|
|
*
|
|
* Batch file jump instruction. Not the most efficient algorithm ;-)
|
|
* Prints error message if the specified label cannot be found - the file pointer is
|
|
* then at EOF, effectively stopping the batch file.
|
|
* FIXME: DOS is supposed to allow labels with spaces - we don't.
|
|
*/
|
|
|
|
void WCMD_goto (void) {
|
|
|
|
char string[MAX_PATH];
|
|
|
|
if (context != NULL) {
|
|
SetFilePointer (context -> h, 0, NULL, FILE_BEGIN);
|
|
while (WCMD_fgets (string, sizeof(string), context -> h)) {
|
|
if ((string[0] == ':') && (strcmp (&string[1], param1) == 0)) return;
|
|
}
|
|
WCMD_output ("Target to GOTO not found\n");
|
|
}
|
|
return;
|
|
}
|
|
|
|
|
|
/****************************************************************************
|
|
* WCMD_if
|
|
*
|
|
* Batch file conditional.
|
|
* FIXME: Much more syntax checking needed!
|
|
*/
|
|
|
|
void WCMD_if (char *p) {
|
|
|
|
int negate = 0, test = 0;
|
|
char condition[MAX_PATH], *command, *s;
|
|
|
|
if (!lstrcmpi (param1, "not")) {
|
|
negate = 1;
|
|
lstrcpy (condition, param2);
|
|
}
|
|
else {
|
|
lstrcpy (condition, param1);
|
|
}
|
|
if (!lstrcmpi (condition, "errorlevel")) {
|
|
if (errorlevel >= atoi(WCMD_parameter (p, 1+negate, NULL))) test = 1;
|
|
return;
|
|
WCMD_parameter (p, 2+negate, &command);
|
|
}
|
|
else if (!lstrcmpi (condition, "exist")) {
|
|
if (GetFileAttributesA(WCMD_parameter (p, 1+negate, NULL)) != INVALID_FILE_ATTRIBUTES) {
|
|
test = 1;
|
|
}
|
|
WCMD_parameter (p, 2+negate, &command);
|
|
}
|
|
else if ((s = strstr (p, "=="))) {
|
|
s += 2;
|
|
if (!lstrcmpi (condition, WCMD_parameter (s, 0, NULL))) test = 1;
|
|
WCMD_parameter (s, 1, &command);
|
|
}
|
|
else {
|
|
WCMD_output ("Syntax error\n");
|
|
return;
|
|
}
|
|
if (test != negate) {
|
|
command = strdup (command);
|
|
WCMD_process_command (command);
|
|
free (command);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_move
|
|
*
|
|
* Move a file, directory tree or wildcarded set of files.
|
|
* FIXME: Needs input and output files to be fully specified.
|
|
*/
|
|
|
|
void WCMD_move (void) {
|
|
|
|
int status;
|
|
char outpath[MAX_PATH], inpath[MAX_PATH], *infile;
|
|
WIN32_FIND_DATA fd;
|
|
HANDLE hff;
|
|
|
|
if ((strchr(param1,'*') != NULL) || (strchr(param1,'%') != NULL)) {
|
|
WCMD_output ("Wildcards not yet supported\n");
|
|
return;
|
|
}
|
|
|
|
/* If no destination supplied, assume current directory */
|
|
if (param2[0] == 0x00) {
|
|
strcpy(param2, ".");
|
|
}
|
|
|
|
/* If 2nd parm is directory, then use original filename */
|
|
GetFullPathName (param2, sizeof(outpath), outpath, NULL);
|
|
hff = FindFirstFile (outpath, &fd);
|
|
if (hff != INVALID_HANDLE_VALUE) {
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY) {
|
|
GetFullPathName (param1, sizeof(inpath), inpath, &infile);
|
|
strcat (outpath, "\\");
|
|
strcat (outpath, infile);
|
|
}
|
|
FindClose (hff);
|
|
}
|
|
|
|
status = MoveFile (param1, outpath);
|
|
if (!status) WCMD_print_error ();
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_pause
|
|
*
|
|
* Wait for keyboard input.
|
|
*/
|
|
|
|
void WCMD_pause (void) {
|
|
|
|
DWORD count;
|
|
char string[32];
|
|
|
|
WCMD_output (anykey);
|
|
ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_remove_dir
|
|
*
|
|
* Delete a directory.
|
|
*/
|
|
|
|
void WCMD_remove_dir (void) {
|
|
|
|
if (!RemoveDirectory (param1)) WCMD_print_error ();
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_rename
|
|
*
|
|
* Rename a file.
|
|
* FIXME: Needs input and output files to be fully specified.
|
|
*/
|
|
|
|
void WCMD_rename (void) {
|
|
|
|
int status;
|
|
|
|
if ((strchr(param1,'*') != NULL) || (strchr(param1,'%') != NULL)) {
|
|
WCMD_output ("Wildcards not yet supported\n");
|
|
return;
|
|
}
|
|
status = MoveFile (param1, param2);
|
|
if (!status) WCMD_print_error ();
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* WCMD_dupenv
|
|
*
|
|
* Make a copy of the environment.
|
|
*/
|
|
static WCHAR *WCMD_dupenv( const WCHAR *env )
|
|
{
|
|
WCHAR *env_copy;
|
|
int len;
|
|
|
|
if( !env )
|
|
return NULL;
|
|
|
|
len = 0;
|
|
while ( env[len] )
|
|
len += (lstrlenW(&env[len]) + 1);
|
|
|
|
env_copy = LocalAlloc (LMEM_FIXED, (len+1) * sizeof (WCHAR) );
|
|
if (!env_copy)
|
|
{
|
|
WCMD_output ("out of memory\n");
|
|
return env_copy;
|
|
}
|
|
memcpy (env_copy, env, len*sizeof (WCHAR));
|
|
env_copy[len] = 0;
|
|
|
|
return env_copy;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* WCMD_setlocal
|
|
*
|
|
* setlocal pushes the environment onto a stack
|
|
* Save the environment as unicode so we don't screw anything up.
|
|
*/
|
|
void WCMD_setlocal (const char *s) {
|
|
WCHAR *env;
|
|
struct env_stack *env_copy;
|
|
|
|
/* DISABLEEXTENSIONS ignored */
|
|
|
|
env_copy = LocalAlloc (LMEM_FIXED, sizeof (struct env_stack));
|
|
if( !env_copy )
|
|
{
|
|
WCMD_output ("out of memory\n");
|
|
return;
|
|
}
|
|
|
|
env = GetEnvironmentStringsW ();
|
|
|
|
env_copy->strings = WCMD_dupenv (env);
|
|
if (env_copy->strings)
|
|
{
|
|
env_copy->next = saved_environment;
|
|
saved_environment = env_copy;
|
|
}
|
|
else
|
|
LocalFree (env_copy);
|
|
|
|
FreeEnvironmentStringsW (env);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* WCMD_strchrW
|
|
*/
|
|
static inline WCHAR *WCMD_strchrW(WCHAR *str, WCHAR ch)
|
|
{
|
|
while(*str)
|
|
{
|
|
if(*str == ch)
|
|
return str;
|
|
str++;
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* WCMD_endlocal
|
|
*
|
|
* endlocal pops the environment off a stack
|
|
*/
|
|
void WCMD_endlocal (void) {
|
|
WCHAR *env, *old, *p;
|
|
struct env_stack *temp;
|
|
int len, n;
|
|
|
|
if (!saved_environment)
|
|
return;
|
|
|
|
/* pop the old environment from the stack */
|
|
temp = saved_environment;
|
|
saved_environment = temp->next;
|
|
|
|
/* delete the current environment, totally */
|
|
env = GetEnvironmentStringsW ();
|
|
old = WCMD_dupenv (GetEnvironmentStringsW ());
|
|
len = 0;
|
|
while (old[len]) {
|
|
n = lstrlenW(&old[len]) + 1;
|
|
p = WCMD_strchrW(&old[len], '=');
|
|
if (p)
|
|
{
|
|
*p++ = 0;
|
|
SetEnvironmentVariableW (&old[len], NULL);
|
|
}
|
|
len += n;
|
|
}
|
|
LocalFree (old);
|
|
FreeEnvironmentStringsW (env);
|
|
|
|
/* restore old environment */
|
|
env = temp->strings;
|
|
len = 0;
|
|
while (env[len]) {
|
|
n = lstrlenW(&env[len]) + 1;
|
|
p = WCMD_strchrW(&env[len], '=');
|
|
if (p)
|
|
{
|
|
*p++ = 0;
|
|
SetEnvironmentVariableW (&env[len], p);
|
|
}
|
|
len += n;
|
|
}
|
|
LocalFree (env);
|
|
LocalFree (temp);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* WCMD_setshow_attrib
|
|
*
|
|
* Display and optionally sets DOS attributes on a file or directory
|
|
*
|
|
* FIXME: Wine currently uses the Unix stat() function to get file attributes.
|
|
* As a result only the Readonly flag is correctly reported, the Archive bit
|
|
* is always set and the rest are not implemented. We do the Right Thing anyway.
|
|
*
|
|
* FIXME: No SET functionality.
|
|
*
|
|
*/
|
|
|
|
void WCMD_setshow_attrib (void) {
|
|
|
|
DWORD count;
|
|
HANDLE hff;
|
|
WIN32_FIND_DATA fd;
|
|
char flags[9] = {" "};
|
|
|
|
if (param1[0] == '-') {
|
|
WCMD_output (nyi);
|
|
return;
|
|
}
|
|
|
|
if (lstrlen(param1) == 0) {
|
|
GetCurrentDirectory (sizeof(param1), param1);
|
|
strcat (param1, "\\*");
|
|
}
|
|
|
|
hff = FindFirstFile (param1, &fd);
|
|
if (hff == INVALID_HANDLE_VALUE) {
|
|
WCMD_output ("%s: File Not Found\n",param1);
|
|
}
|
|
else {
|
|
do {
|
|
if (!(fd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) {
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_HIDDEN) {
|
|
flags[0] = 'H';
|
|
}
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_SYSTEM) {
|
|
flags[1] = 'S';
|
|
}
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_ARCHIVE) {
|
|
flags[2] = 'A';
|
|
}
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_READONLY) {
|
|
flags[3] = 'R';
|
|
}
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_TEMPORARY) {
|
|
flags[4] = 'T';
|
|
}
|
|
if (fd.dwFileAttributes & FILE_ATTRIBUTE_COMPRESSED) {
|
|
flags[5] = 'C';
|
|
}
|
|
WCMD_output ("%s %s\n", flags, fd.cFileName);
|
|
for (count=0; count < 8; count++) flags[count] = ' ';
|
|
}
|
|
} while (FindNextFile(hff, &fd) != 0);
|
|
}
|
|
FindClose (hff);
|
|
}
|
|
|
|
/*****************************************************************************
|
|
* WCMD_setshow_default
|
|
*
|
|
* Set/Show the current default directory
|
|
*/
|
|
|
|
void WCMD_setshow_default (void) {
|
|
|
|
BOOL status;
|
|
char string[1024];
|
|
|
|
if (strlen(param1) == 0) {
|
|
GetCurrentDirectory (sizeof(string), string);
|
|
strcat (string, "\n");
|
|
WCMD_output (string);
|
|
}
|
|
else {
|
|
status = SetCurrentDirectory (param1);
|
|
if (!status) {
|
|
WCMD_print_error ();
|
|
return;
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_setshow_date
|
|
*
|
|
* Set/Show the system date
|
|
* FIXME: Can't change date yet
|
|
*/
|
|
|
|
void WCMD_setshow_date (void) {
|
|
|
|
char curdate[64], buffer[64];
|
|
DWORD count;
|
|
|
|
if (lstrlen(param1) == 0) {
|
|
if (GetDateFormat (LOCALE_USER_DEFAULT, 0, NULL, NULL,
|
|
curdate, sizeof(curdate))) {
|
|
WCMD_output ("Current Date is %s\nEnter new date: ", curdate);
|
|
ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer, sizeof(buffer), &count, NULL);
|
|
if (count > 2) {
|
|
WCMD_output (nyi);
|
|
}
|
|
}
|
|
else WCMD_print_error ();
|
|
}
|
|
else {
|
|
WCMD_output (nyi);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_compare
|
|
*/
|
|
static int WCMD_compare( const void *a, const void *b )
|
|
{
|
|
int r;
|
|
const char * const *str_a = a, * const *str_b = b;
|
|
r = CompareString( LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
|
|
*str_a, -1, *str_b, -1 );
|
|
if( r == CSTR_LESS_THAN ) return -1;
|
|
if( r == CSTR_GREATER_THAN ) return 1;
|
|
return 0;
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_setshow_sortenv
|
|
*
|
|
* sort variables into order for display
|
|
*/
|
|
static void WCMD_setshow_sortenv(const char *s)
|
|
{
|
|
UINT count=0, len=0, i;
|
|
const char **str;
|
|
|
|
/* count the number of strings, and the total length */
|
|
while ( s[len] ) {
|
|
len += (lstrlen(&s[len]) + 1);
|
|
count++;
|
|
}
|
|
|
|
/* add the strings to an array */
|
|
str = LocalAlloc (LMEM_FIXED | LMEM_ZEROINIT, count * sizeof (char*) );
|
|
if( !str )
|
|
return;
|
|
str[0] = s;
|
|
for( i=1; i<count; i++ )
|
|
str[i] = str[i-1] + lstrlen(str[i-1]) + 1;
|
|
|
|
/* sort the array */
|
|
qsort( str, count, sizeof (char*), WCMD_compare );
|
|
|
|
/* print it */
|
|
for( i=0; i<count; i++ ) {
|
|
WCMD_output_asis(str[i]);
|
|
WCMD_output_asis("\n");
|
|
}
|
|
|
|
LocalFree( str );
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_setshow_env
|
|
*
|
|
* Set/Show the environment variables
|
|
*/
|
|
|
|
void WCMD_setshow_env (char *s) {
|
|
|
|
LPVOID env;
|
|
char *p;
|
|
int status;
|
|
char buffer[1048];
|
|
|
|
if (strlen(param1) == 0) {
|
|
env = GetEnvironmentStrings ();
|
|
WCMD_setshow_sortenv( env );
|
|
}
|
|
else {
|
|
p = strchr (s, '=');
|
|
if (p == NULL) {
|
|
|
|
/* FIXME: Emulate Win98 for now, ie "SET C" looks ONLY for an
|
|
environment variable C, whereas on NT it shows ALL variables
|
|
starting with C.
|
|
*/
|
|
status = GetEnvironmentVariable(s, buffer, sizeof(buffer));
|
|
if (status) {
|
|
WCMD_output_asis( s);
|
|
WCMD_output_asis( "=");
|
|
WCMD_output_asis( buffer);
|
|
WCMD_output_asis( "\n");
|
|
} else {
|
|
WCMD_output ("Environment variable %s not defined\n", s);
|
|
}
|
|
return;
|
|
}
|
|
*p++ = '\0';
|
|
|
|
if (strlen(p) == 0) p = NULL;
|
|
status = SetEnvironmentVariable (s, p);
|
|
if ((!status) & (GetLastError() != ERROR_ENVVAR_NOT_FOUND)) WCMD_print_error();
|
|
}
|
|
/* WCMD_output (newline); @JED*/
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_setshow_path
|
|
*
|
|
* Set/Show the path environment variable
|
|
*/
|
|
|
|
void WCMD_setshow_path (char *command) {
|
|
|
|
char string[1024];
|
|
DWORD status;
|
|
|
|
if (strlen(param1) == 0) {
|
|
status = GetEnvironmentVariable ("PATH", string, sizeof(string));
|
|
if (status != 0) {
|
|
WCMD_output_asis ( "PATH=");
|
|
WCMD_output_asis ( string);
|
|
WCMD_output_asis ( "\n");
|
|
}
|
|
else {
|
|
WCMD_output ("PATH not found\n");
|
|
}
|
|
}
|
|
else {
|
|
status = SetEnvironmentVariable ("PATH", command);
|
|
if (!status) WCMD_print_error();
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_setshow_prompt
|
|
*
|
|
* Set or show the command prompt.
|
|
*/
|
|
|
|
void WCMD_setshow_prompt (void) {
|
|
|
|
char *s;
|
|
|
|
if (strlen(param1) == 0) {
|
|
SetEnvironmentVariable ("PROMPT", NULL);
|
|
}
|
|
else {
|
|
s = param1;
|
|
while ((*s == '=') || (*s == ' ')) s++;
|
|
if (strlen(s) == 0) {
|
|
SetEnvironmentVariable ("PROMPT", NULL);
|
|
}
|
|
else SetEnvironmentVariable ("PROMPT", s);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_setshow_time
|
|
*
|
|
* Set/Show the system time
|
|
* FIXME: Can't change time yet
|
|
*/
|
|
|
|
void WCMD_setshow_time (void) {
|
|
|
|
char curtime[64], buffer[64];
|
|
DWORD count;
|
|
SYSTEMTIME st;
|
|
|
|
if (strlen(param1) == 0) {
|
|
GetLocalTime(&st);
|
|
if (GetTimeFormat (LOCALE_USER_DEFAULT, 0, &st, NULL,
|
|
curtime, sizeof(curtime))) {
|
|
WCMD_output ("Current Time is %s\nEnter new time: ", curtime);
|
|
ReadFile (GetStdHandle(STD_INPUT_HANDLE), buffer, sizeof(buffer), &count, NULL);
|
|
if (count > 2) {
|
|
WCMD_output (nyi);
|
|
}
|
|
}
|
|
else WCMD_print_error ();
|
|
}
|
|
else {
|
|
WCMD_output (nyi);
|
|
}
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_shift
|
|
*
|
|
* Shift batch parameters.
|
|
*/
|
|
|
|
void WCMD_shift (void) {
|
|
|
|
if (context != NULL) context -> shift_count++;
|
|
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_title
|
|
*
|
|
* Set the console title
|
|
*/
|
|
void WCMD_title (char *command) {
|
|
SetConsoleTitle(command);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_type
|
|
*
|
|
* Copy a file to standard output.
|
|
*/
|
|
|
|
void WCMD_type (void) {
|
|
|
|
HANDLE h;
|
|
char buffer[512];
|
|
DWORD count;
|
|
|
|
h = CreateFile (param1, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
|
|
FILE_ATTRIBUTE_NORMAL, NULL);
|
|
if (h == INVALID_HANDLE_VALUE) {
|
|
WCMD_print_error ();
|
|
return;
|
|
}
|
|
while (ReadFile (h, buffer, sizeof(buffer), &count, NULL)) {
|
|
if (count == 0) break; /* ReadFile reports success on EOF! */
|
|
buffer[count] = 0;
|
|
WCMD_output_asis (buffer);
|
|
}
|
|
CloseHandle (h);
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_verify
|
|
*
|
|
* Display verify flag.
|
|
* FIXME: We don't actually do anything with the verify flag other than toggle
|
|
* it...
|
|
*/
|
|
|
|
void WCMD_verify (char *command) {
|
|
|
|
static const char von[] = "Verify is ON\n", voff[] = "Verify is OFF\n";
|
|
int count;
|
|
|
|
count = strlen(command);
|
|
if (count == 0) {
|
|
if (verify_mode) WCMD_output (von);
|
|
else WCMD_output (voff);
|
|
return;
|
|
}
|
|
if (lstrcmpi(command, "ON") == 0) {
|
|
verify_mode = 1;
|
|
return;
|
|
}
|
|
else if (lstrcmpi(command, "OFF") == 0) {
|
|
verify_mode = 0;
|
|
return;
|
|
}
|
|
else WCMD_output ("Verify must be ON or OFF\n");
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_version
|
|
*
|
|
* Display version info.
|
|
*/
|
|
|
|
void WCMD_version (void) {
|
|
|
|
WCMD_output (version_string);
|
|
|
|
}
|
|
|
|
/****************************************************************************
|
|
* WCMD_volume
|
|
*
|
|
* Display volume info and/or set volume label. Returns 0 if error.
|
|
*/
|
|
|
|
int WCMD_volume (int mode, char *path) {
|
|
|
|
DWORD count, serial;
|
|
char string[MAX_PATH], label[MAX_PATH], curdir[MAX_PATH];
|
|
BOOL status;
|
|
|
|
if (lstrlen(path) == 0) {
|
|
status = GetCurrentDirectory (sizeof(curdir), curdir);
|
|
if (!status) {
|
|
WCMD_print_error ();
|
|
return 0;
|
|
}
|
|
status = GetVolumeInformation (NULL, label, sizeof(label), &serial, NULL,
|
|
NULL, NULL, 0);
|
|
}
|
|
else {
|
|
if ((path[1] != ':') || (lstrlen(path) != 2)) {
|
|
WCMD_output_asis("Syntax Error\n\n");
|
|
return 0;
|
|
}
|
|
wsprintf (curdir, "%s\\", path);
|
|
status = GetVolumeInformation (curdir, label, sizeof(label), &serial, NULL,
|
|
NULL, NULL, 0);
|
|
}
|
|
if (!status) {
|
|
WCMD_print_error ();
|
|
return 0;
|
|
}
|
|
WCMD_output ("Volume in drive %c is %s\nVolume Serial Number is %04x-%04x\n\n",
|
|
curdir[0], label, HIWORD(serial), LOWORD(serial));
|
|
if (mode) {
|
|
WCMD_output ("Volume label (11 characters, ENTER for none)?");
|
|
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(path) != 0) {
|
|
if (!SetVolumeLabel (curdir, string)) WCMD_print_error ();
|
|
}
|
|
else {
|
|
if (!SetVolumeLabel (NULL, string)) WCMD_print_error ();
|
|
}
|
|
}
|
|
return 1;
|
|
}
|