Skip the allocation of a new console on "wcmd /c <command>" execution,
[wine] / programs / wcmd / wcmdmain.c
1 /*
2  * WCMD - Wine-compatible command line interface.
3  *
4  * Copyright (C) 1999 - 2001 D A Pickles
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Lesser General Public
8  * License as published by the Free Software Foundation; either
9  * version 2.1 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Lesser General Public License for more details.
15  *
16  * You should have received a copy of the GNU Lesser General Public
17  * License along with this library; if not, write to the Free Software
18  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
19  */
20
21 /*
22  * FIXME:
23  * - Cannot handle parameters in quotes
24  * - Lots of functionality missing from builtins
25  */
26
27 #include "wcmd.h"
28
29 char *inbuilt[] = {"ATTRIB", "CALL", "CD", "CHDIR", "CLS", "COPY", "CTTY",
30                 "DATE", "DEL", "DIR", "ECHO", "ERASE", "FOR", "GOTO",
31                 "HELP", "IF", "LABEL", "MD", "MKDIR", "MOVE", "PATH", "PAUSE",
32                 "PROMPT", "REM", "REN", "RENAME", "RD", "RMDIR", "SET", "SHIFT",
33                 "TIME", "TITLE", "TYPE", "VERIFY", "VER", "VOL", "EXIT"  };
34
35 HINSTANCE hinst;
36 DWORD errorlevel;
37 int echo_mode = 1, verify_mode = 0;
38 char nyi[] = "Not Yet Implemented\n\n";
39 char newline[] = "\n";
40 char version_string[] = "WCMD Version 0.17\n\n";
41 char anykey[] = "Press any key to continue: ";
42 char quals[MAX_PATH], param1[MAX_PATH], param2[MAX_PATH];
43 BATCH_CONTEXT *context = NULL;
44
45 /*****************************************************************************
46  * Main entry point. This is a console application so we have a main() not a
47  * winmain().
48  */
49
50 int main (int argc, char *argv[]) {
51
52 char string[1024], args[MAX_PATH], param[MAX_PATH];
53 int status, i;
54 DWORD count;
55 HANDLE h;
56
57   args[0] = param[0] = '\0';
58   if (argc > 1) {
59     for (i=1; i<argc; i++) {
60       if (argv[i][0] == '/') {
61         strcat (args, argv[i]);
62       }
63       else {
64         strcat (param, argv[i]);
65         strcat (param, " ");
66       }
67     }
68   }
69
70   /* If we do a "wcmd /c command", we don't want to allocate a new
71    * console since the command returns immediately. Rather, we use
72    * the surrently allocated input and output handles. This allows
73    * us to pipe to and read from the command interpreter.
74    */
75   if (strstr(args, "/c") != NULL) {
76     WCMD_process_command (param);
77     return 0;
78   }
79
80 /*
81  *      Allocate a console and set it up.
82  */
83
84   status = FreeConsole ();
85   if (!status) WCMD_print_error();
86   status = AllocConsole();
87   if (!status) WCMD_print_error();
88   SetConsoleMode (GetStdHandle(STD_INPUT_HANDLE), ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT |
89         ENABLE_PROCESSED_INPUT);
90   SetConsoleTitle("Wine Command Prompt");
91
92 /*
93  *      Execute any command-line options.
94  */
95
96   if (strstr(args, "/q") != NULL) {
97     WCMD_echo ("OFF");
98   }
99
100   if (strstr(args, "/k") != NULL) {
101     WCMD_process_command (param);
102   }
103
104 /*
105  *      If there is an AUTOEXEC.BAT file, try to execute it.
106  */
107
108   GetFullPathName ("\\autoexec.bat", sizeof(string), string, NULL);
109   h = CreateFile (string, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
110   if (h != INVALID_HANDLE_VALUE) {
111     CloseHandle (h);
112 #if 0
113     WCMD_batch (string, " ");
114 #endif
115   }
116
117 /*
118  *      Loop forever getting commands and executing them.
119  */
120
121   WCMD_version ();
122   while (TRUE) {
123     WCMD_show_prompt ();
124     ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
125     if (count > 1) {
126       string[count-1] = '\0';           /* ReadFile output is not null-terminated! */
127       if (string[count-2] == '\r') string[count-2] = '\0'; /* Under Windoze we get CRLF! */
128       if (lstrlen (string) != 0) {
129         if (strchr(string,'|') != NULL) {
130           WCMD_pipe (string);
131         }
132         else {
133           WCMD_process_command (string);
134         }
135       }
136     }
137   }
138 }
139
140
141 /*****************************************************************************
142  * Process one command. If the command is EXIT this routine does not return.
143  * We will recurse through here executing batch files.
144  */
145
146
147 void WCMD_process_command (char *command) {
148
149 char cmd[1024];
150 char *p;
151 int status, i;
152 DWORD count;
153 HANDLE old_stdin = 0, old_stdout = 0, h;
154 char *whichcmd;
155
156
157 /*
158  *      Expand up environment variables.
159  */
160
161     status = ExpandEnvironmentStrings (command, cmd, sizeof(cmd));
162     if (!status) {
163       WCMD_print_error ();
164       return;
165     }
166
167 /*
168  *      Changing default drive has to be handled as a special case.
169  */
170
171     if ((cmd[1] == ':') && IsCharAlpha (cmd[0]) && (strlen(cmd) == 2)) {
172       status = SetCurrentDirectory (cmd);
173       if (!status) WCMD_print_error ();
174       return;
175     }
176
177     /* Dont issue newline WCMD_output (newline);           @JED*/
178
179 /*
180  *      Redirect stdin and/or stdout if required.
181  */
182
183     if ((p = strchr(cmd,'<')) != NULL) {
184       h = CreateFile (WCMD_parameter (++p, 0, NULL), GENERIC_READ, 0, NULL, OPEN_EXISTING,
185                 FILE_ATTRIBUTE_NORMAL, NULL);
186       if (h == INVALID_HANDLE_VALUE) {
187         WCMD_print_error ();
188         return;
189       }
190       old_stdin = GetStdHandle (STD_INPUT_HANDLE);
191       SetStdHandle (STD_INPUT_HANDLE, h);
192     }
193     if ((p = strchr(cmd,'>')) != NULL) {
194       h = CreateFile (WCMD_parameter (++p, 0, NULL), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
195                 FILE_ATTRIBUTE_NORMAL, NULL);
196       if (h == INVALID_HANDLE_VALUE) {
197         WCMD_print_error ();
198         return;
199       }
200       old_stdout = GetStdHandle (STD_OUTPUT_HANDLE);
201       SetStdHandle (STD_OUTPUT_HANDLE, h);
202       *--p = '\0';
203     }
204     if ((p = strchr(cmd,'<')) != NULL) *p = '\0';
205
206 /*
207  * Strip leading whitespaces, and a '@' if supplied
208  */
209     whichcmd = WCMD_strtrim_leading_spaces(cmd);
210     if (whichcmd[0] == '@') whichcmd++;
211
212 /*
213  *      Check if the command entered is internal. If it is, pass the rest of the
214  *      line down to the command. If not try to run a program.
215  */
216
217     count = 0;
218     while (IsCharAlphaNumeric(whichcmd[count])) {
219       count++;
220     }
221     for (i=0; i<=WCMD_EXIT; i++) {
222       if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
223           whichcmd, count, inbuilt[i], -1) == 2) break;
224     }
225     p = WCMD_strtrim_leading_spaces (&whichcmd[count]);
226     WCMD_parse (p, quals, param1, param2);
227     switch (i) {
228
229       case WCMD_ATTRIB:
230         WCMD_setshow_attrib ();
231         break;
232       case WCMD_CALL:
233         WCMD_batch (param1, p, 1);
234         break;
235       case WCMD_CD:
236       case WCMD_CHDIR:
237         WCMD_setshow_default ();
238         break;
239       case WCMD_CLS:
240         WCMD_clear_screen ();
241         break;
242       case WCMD_COPY:
243         WCMD_copy ();
244         break;
245       case WCMD_CTTY:
246         WCMD_change_tty ();
247         break;
248       case WCMD_DATE:
249         WCMD_setshow_date ();
250         break;
251       case WCMD_DEL:
252       case WCMD_ERASE:
253         WCMD_delete (0);
254         break;
255       case WCMD_DIR:
256         WCMD_directory ();
257         break;
258       case WCMD_ECHO:
259         /* Use the unstripped version of the following data - step over the space */
260         /* but only if a parameter follows                                        */
261         if (strlen(&whichcmd[count]) > 0)
262           WCMD_echo(&whichcmd[count+1]);
263         else
264           WCMD_echo(&whichcmd[count]);
265         break;
266       case WCMD_FOR:
267         WCMD_for (p);
268         break;
269       case WCMD_GOTO:
270         WCMD_goto ();
271         break;
272       case WCMD_HELP:
273         WCMD_give_help (p);
274         break;
275       case WCMD_IF:
276         WCMD_if (p);
277         break;
278       case WCMD_LABEL:
279         WCMD_volume (1, p);
280         break;
281       case WCMD_MD:
282       case WCMD_MKDIR:
283         WCMD_create_dir ();
284         break;
285       case WCMD_MOVE:
286         WCMD_move ();
287         break;
288       case WCMD_PATH:
289         WCMD_setshow_path ();
290         break;
291       case WCMD_PAUSE:
292         WCMD_pause ();
293         break;
294       case WCMD_PROMPT:
295         WCMD_setshow_prompt ();
296         break;
297       case WCMD_REM:
298         break;
299       case WCMD_REN:
300       case WCMD_RENAME:
301         WCMD_rename ();
302         break;
303       case WCMD_RD:
304       case WCMD_RMDIR:
305         WCMD_remove_dir ();
306         break;
307       case WCMD_SET:
308         WCMD_setshow_env (p);
309         break;
310       case WCMD_SHIFT:
311         WCMD_shift ();
312         break;
313       case WCMD_TIME:
314         WCMD_setshow_time ();
315         break;
316       case WCMD_TITLE:
317         if (strlen(&whichcmd[count]) > 0)
318           WCMD_title(&whichcmd[count+1]);
319         break;
320       case WCMD_TYPE:
321         WCMD_type ();
322         break;
323       case WCMD_VER:
324         WCMD_version ();
325         break;
326       case WCMD_VERIFY:
327         WCMD_verify (p);
328         break;
329       case WCMD_VOL:
330         WCMD_volume (0, p);
331         break;
332       case WCMD_EXIT:
333         ExitProcess (0);
334       default:
335         WCMD_run_program (whichcmd);
336     };
337     if (old_stdin) {
338       CloseHandle (GetStdHandle (STD_INPUT_HANDLE));
339       SetStdHandle (STD_INPUT_HANDLE, old_stdin);
340     }
341     if (old_stdout) {
342       CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE));
343       SetStdHandle (STD_OUTPUT_HANDLE, old_stdout);
344     }
345   }
346
347 /******************************************************************************
348  * WCMD_run_program
349  *
350  *      Execute a command line as an external program. If no extension given then
351  *      precedence is given to .BAT files. Must allow recursion.
352  *
353  *      FIXME: Case sensitivity in suffixes!
354  */
355
356 void WCMD_run_program (char *command) {
357
358 STARTUPINFO st;
359 PROCESS_INFORMATION pe;
360 SHFILEINFO psfi;
361 DWORD console;
362 BOOL status;
363 HANDLE h;
364 HINSTANCE hinst;
365 char filetorun[MAX_PATH];
366
367   WCMD_parse (command, quals, param1, param2);  /* Quick way to get the filename */
368   if (!(*param1) && !(*param2))
369     return;
370   if (strpbrk (param1, "\\:") == NULL) {        /* No explicit path given */
371     if ((strchr (param1, '.') == NULL) || (strstr (param1, ".bat") != NULL)) {
372       if (SearchPath (NULL, param1, ".bat", sizeof(filetorun), filetorun, NULL)) {
373         WCMD_batch (filetorun, command, 0);
374         return;
375       }
376     }
377   }
378   else {                                        /* Explicit path given */
379     if (strstr (param1, ".bat") != NULL) {
380       WCMD_batch (param1, command, 0);
381       return;
382     }
383     if (strchr (param1, '.') == NULL) {
384       strcpy (filetorun, param1);
385       strcat (filetorun, ".bat");
386       h = CreateFile (filetorun, GENERIC_READ, 0, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
387       if (h != INVALID_HANDLE_VALUE) {
388         CloseHandle (h);
389         WCMD_batch (param1, command, 0);
390         return;
391       }
392     }
393   }
394
395         /* No batch file found, assume executable */
396
397   hinst = FindExecutable (param1, NULL, filetorun);
398   if ((int)hinst < 32) {
399     WCMD_print_error ();
400     return;
401   }
402   console = SHGetFileInfo (filetorun, 0, &psfi, sizeof(psfi), SHGFI_EXETYPE);
403   ZeroMemory (&st, sizeof(STARTUPINFO));
404   st.cb = sizeof(STARTUPINFO);
405   status = CreateProcess (NULL, command, NULL, NULL, FALSE,
406                  0, NULL, NULL, &st, &pe);
407   if (!status) {
408     WCMD_print_error ();
409     return;
410   }
411   if (!console) errorlevel = 0;
412   else
413   {
414       if (!HIWORD(console)) WaitForSingleObject (pe.hProcess, INFINITE);
415       GetExitCodeProcess (pe.hProcess, &errorlevel);
416       if (errorlevel == STILL_ACTIVE) errorlevel = 0;
417   }
418 }
419
420 /******************************************************************************
421  * WCMD_show_prompt
422  *
423  *      Display the prompt on STDout
424  *
425  */
426
427 void WCMD_show_prompt () {
428
429 int status;
430 char out_string[MAX_PATH], curdir[MAX_PATH], prompt_string[MAX_PATH];
431 char *p, *q;
432
433   status = GetEnvironmentVariable ("PROMPT", prompt_string, sizeof(prompt_string));
434   if ((status == 0) || (status > sizeof(prompt_string))) {
435     lstrcpy (prompt_string, "$N$G");
436   }
437   p = prompt_string;
438   q = out_string;
439   *q = '\0';
440   while (*p != '\0') {
441     if (*p != '$') {
442       *q++ = *p++;
443       *q = '\0';
444     }
445     else {
446       p++;
447       switch (toupper(*p)) {
448         case '$':
449           *q++ = '$';
450           break;
451         case 'B':
452           *q++ = '|';
453           break;
454         case 'D':
455           GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, q, MAX_PATH);
456           while (*q) q++;
457           break;
458         case 'E':
459           *q++ = '\E';
460           break;
461         case 'G':
462           *q++ = '>';
463           break;
464         case 'L':
465           *q++ = '<';
466           break;
467         case 'N':
468           status = GetCurrentDirectory (sizeof(curdir), curdir);
469           if (status) {
470             *q++ = curdir[0];
471           }
472           break;
473         case 'P':
474           status = GetCurrentDirectory (sizeof(curdir), curdir);
475           if (status) {
476             lstrcat (q, curdir);
477             while (*q) q++;
478           }
479           break;
480         case 'Q':
481           *q++ = '=';
482           break;
483         case 'T':
484           GetTimeFormat (LOCALE_USER_DEFAULT, 0, NULL, NULL, q, MAX_PATH);
485           while (*q) q++;
486           break;
487         case '_':
488           *q++ = '\n';
489           break;
490       }
491       p++;
492       *q = '\0';
493     }
494   }
495   WCMD_output (out_string);
496 }
497
498 /****************************************************************************
499  * WCMD_print_error
500  *
501  * Print the message for GetLastError
502  */
503
504 void WCMD_print_error () {
505 LPVOID lpMsgBuf;
506 DWORD error_code;
507 int status;
508
509   error_code = GetLastError ();
510   status = FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
511                         NULL, error_code, 0, (LPTSTR) &lpMsgBuf, 0, NULL);
512   if (!status) {
513     WCMD_output ("FIXME: Cannot display message for error %d, status %d\n",
514                         error_code, GetLastError());
515     return;
516   }
517   WCMD_output (lpMsgBuf);
518   LocalFree ((HLOCAL)lpMsgBuf);
519   WCMD_output (newline);
520   return;
521 }
522
523 /*******************************************************************
524  * WCMD_parse - parse a command into parameters and qualifiers.
525  *
526  *      On exit, all qualifiers are concatenated into q, the first string
527  *      not beginning with "/" is in p1 and the
528  *      second in p2. Any subsequent non-qualifier strings are lost.
529  *      Parameters in quotes are handled.
530  */
531
532 void WCMD_parse (char *s, char *q, char *p1, char *p2) {
533
534 int p = 0;
535
536   *q = *p1 = *p2 = '\0';
537   while (TRUE) {
538     switch (*s) {
539       case '/':
540         *q++ = *s++;
541         while ((*s != '\0') && (*s != ' ') && *s != '/') {
542           *q++ = toupper (*s++);
543         }
544         *q = '\0';
545         break;
546       case ' ':
547         s++;
548         break;
549       case '"':
550         s++;
551         while ((*s != '\0') && (*s != '"')) {
552           if (p == 0) *p1++ = *s++;
553           else if (p == 1) *p2++ = *s++;
554           else s++;
555         }
556         if (p == 0) *p1 = '\0';
557         if (p == 1) *p2 = '\0';
558         p++;
559         if (*s == '"') s++;
560         break;
561       case '\0':
562         return;
563       default:
564         while ((*s != '\0') && (*s != ' ')) {
565           if (p == 0) *p1++ = *s++;
566           else if (p == 1) *p2++ = *s++;
567           else s++;
568         }
569         if (p == 0) *p1 = '\0';
570         if (p == 1) *p2 = '\0';
571         p++;
572     }
573   }
574 }
575
576 /*******************************************************************
577  * WCMD_output - send output to current standard output device.
578  *
579  */
580
581 void WCMD_output (char *format, ...) {
582
583 va_list ap;
584 char string[1024];
585 DWORD count;
586
587   va_start(ap,format);
588   vsprintf (string, format, ap);
589   WriteFile (GetStdHandle(STD_OUTPUT_HANDLE), string, lstrlen(string), &count, NULL);
590   va_end(ap);
591 }
592
593 /*******************************************************************
594  * WCMD_output_asis - send output to current standard output device.
595  *        without formatting eg. when message contains '%'
596  */
597
598 void WCMD_output_asis (char *message) {
599   DWORD count;
600   WriteFile (GetStdHandle(STD_OUTPUT_HANDLE), message, lstrlen(message), &count, NULL);
601 }
602
603
604
605 /***************************************************************************
606  * WCMD_strtrim_leading_spaces
607  *
608  *      Remove leading spaces from a string. Return a pointer to the first
609  *      non-space character. Does not modify the input string
610  */
611
612 char *WCMD_strtrim_leading_spaces (char *string) {
613
614 char *ptr;
615
616   ptr = string;
617   while (*ptr == ' ') ptr++;
618   return ptr;
619 }
620
621 /*************************************************************************
622  * WCMD_strtrim_trailing_spaces
623  *
624  *      Remove trailing spaces from a string. This routine modifies the input
625  *      string by placing a null after the last non-space character
626  */
627
628 void WCMD_strtrim_trailing_spaces (char *string) {
629
630 char *ptr;
631
632   ptr = string + lstrlen (string) - 1;
633   while ((*ptr == ' ') && (ptr >= string)) {
634     *ptr = '\0';
635     ptr--;
636   }
637 }
638
639 /*************************************************************************
640  * WCMD_pipe
641  *
642  *      Handle pipes within a command - the DOS way using temporary files.
643  */
644
645 void WCMD_pipe (char *command) {
646
647 char *p;
648 char temp_path[MAX_PATH], temp_file[MAX_PATH], temp_file2[MAX_PATH], temp_cmd[1024];
649
650   GetTempPath (sizeof(temp_path), temp_path);
651   GetTempFileName (temp_path, "WCMD", 0, temp_file);
652   p = strchr(command, '|');
653   *p++ = '\0';
654   wsprintf (temp_cmd, "%s > %s", command, temp_file);
655   WCMD_process_command (temp_cmd);
656   command = p;
657   while ((p = strchr(command, '|'))) {
658     *p++ = '\0';
659     GetTempFileName (temp_path, "WCMD", 0, temp_file2);
660     wsprintf (temp_cmd, "%s < %s > %s", command, temp_file, temp_file2);
661     WCMD_process_command (temp_cmd);
662     DeleteFile (temp_file);
663     lstrcpy (temp_file, temp_file2);
664     command = p;
665   }
666   wsprintf (temp_cmd, "%s < %s", command, temp_file);
667   WCMD_process_command (temp_cmd);
668   DeleteFile (temp_file);
669 }