git.oblomov.eu Git - wine/blob - 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 i;
  54 DWORD count;
  55 HANDLE h;
  56
  57   args[0] = param[0] = '\0';
  58   if (argc > 1) {
  59     /* interpreter options must come before the command to execute.
  60      * Any options after the command are command options, not interpreter options.
  61      */
  62     for (i=1; i<argc && argv[i][0] == '/'; i++)
  63         strcat (args, argv[i]);
  64     for (; i<argc; i++) {
  65         strcat (param, argv[i]);
  66         strcat (param, " ");
  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   SetConsoleMode (GetStdHandle(STD_INPUT_HANDLE), ENABLE_LINE_INPUT | ENABLE_ECHO_INPUT |
  81         ENABLE_PROCESSED_INPUT);
  82   SetConsoleTitle("Wine Command Prompt");
  83
  84 /*
  85  *      Execute any command-line options.
  86  */
  87
  88   if (strstr(args, "/q") != NULL) {
  89     WCMD_echo ("OFF");
  90   }
  91
  92   if (strstr(args, "/k") != NULL) {
  93     WCMD_process_command (param);
  94   }
  95
  96 /*
  97  *      If there is an AUTOEXEC.BAT file, try to execute it.
  98  */
  99
 100   GetFullPathName ("\\autoexec.bat", sizeof(string), string, NULL);
 101   h = CreateFile (string, GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 102   if (h != INVALID_HANDLE_VALUE) {
 103     CloseHandle (h);
 104 #if 0
 105     WCMD_batch_command (string);
 106 #endif
 107   }
 108
 109 /*
 110  *      Loop forever getting commands and executing them.
 111  */
 112
 113   WCMD_version ();
 114   while (TRUE) {
 115     WCMD_show_prompt ();
 116     ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
 117     if (count > 1) {
 118       string[count-1] = '\0';           /* ReadFile output is not null-terminated! */
 119       if (string[count-2] == '\r') string[count-2] = '\0'; /* Under Windoze we get CRLF! */
 120       if (lstrlen (string) != 0) {
 121         if (strchr(string,'|') != NULL) {
 122           WCMD_pipe (string);
 123         }
 124         else {
 125           WCMD_process_command (string);
 126         }
 127       }
 128     }
 129   }
 130 }
 131
 132
 133 /*****************************************************************************
 134  * Process one command. If the command is EXIT this routine does not return.
 135  * We will recurse through here executing batch files.
 136  */
 137
 138
 139 void WCMD_process_command (char *command) {
 140
 141 char cmd[1024];
 142 char *p;
 143 int status, i;
 144 DWORD count;
 145 HANDLE old_stdin = 0, old_stdout = 0, h;
 146 char *whichcmd;
 147
 148
 149 /*
 150  *      Expand up environment variables.
 151  */
 152
 153     status = ExpandEnvironmentStrings (command, cmd, sizeof(cmd));
 154     if (!status) {
 155       WCMD_print_error ();
 156       return;
 157     }
 158
 159 /*
 160  *      Changing default drive has to be handled as a special case.
 161  */
 162
 163     if ((cmd[1] == ':') && IsCharAlpha (cmd[0]) && (strlen(cmd) == 2)) {
 164       status = SetCurrentDirectory (cmd);
 165       if (!status) WCMD_print_error ();
 166       return;
 167     }
 168
 169     /* Dont issue newline WCMD_output (newline);           @JED*/
 170
 171 /*
 172  *      Redirect stdin and/or stdout if required.
 173  */
 174
 175     if ((p = strchr(cmd,'<')) != NULL) {
 176       h = CreateFile (WCMD_parameter (++p, 0, NULL), GENERIC_READ, FILE_SHARE_READ, NULL, OPEN_EXISTING,
 177                 FILE_ATTRIBUTE_NORMAL, NULL);
 178       if (h == INVALID_HANDLE_VALUE) {
 179         WCMD_print_error ();
 180         return;
 181       }
 182       old_stdin = GetStdHandle (STD_INPUT_HANDLE);
 183       SetStdHandle (STD_INPUT_HANDLE, h);
 184     }
 185     if ((p = strchr(cmd,'>')) != NULL) {
 186       h = CreateFile (WCMD_parameter (++p, 0, NULL), GENERIC_WRITE, 0, NULL, CREATE_ALWAYS,
 187                 FILE_ATTRIBUTE_NORMAL, NULL);
 188       if (h == INVALID_HANDLE_VALUE) {
 189         WCMD_print_error ();
 190         return;
 191       }
 192       old_stdout = GetStdHandle (STD_OUTPUT_HANDLE);
 193       SetStdHandle (STD_OUTPUT_HANDLE, h);
 194       *--p = '\0';
 195     }
 196     if ((p = strchr(cmd,'<')) != NULL) *p = '\0';
 197
 198 /*
 199  * Strip leading whitespaces, and a '@' if supplied
 200  */
 201     whichcmd = WCMD_strtrim_leading_spaces(cmd);
 202     if (whichcmd[0] == '@') whichcmd++;
 203
 204 /*
 205  *      Check if the command entered is internal. If it is, pass the rest of the
 206  *      line down to the command. If not try to run a program.
 207  */
 208
 209     count = 0;
 210     while (IsCharAlphaNumeric(whichcmd[count])) {
 211       count++;
 212     }
 213     for (i=0; i<=WCMD_EXIT; i++) {
 214       if (CompareString (LOCALE_USER_DEFAULT, NORM_IGNORECASE | SORT_STRINGSORT,
 215           whichcmd, count, inbuilt[i], -1) == 2) break;
 216     }
 217     p = WCMD_strtrim_leading_spaces (&whichcmd[count]);
 218     WCMD_parse (p, quals, param1, param2);
 219     switch (i) {
 220
 221       case WCMD_ATTRIB:
 222         WCMD_setshow_attrib ();
 223         break;
 224       case WCMD_CALL:
 225         WCMD_batch (param1, p, 1);
 226         break;
 227       case WCMD_CD:
 228       case WCMD_CHDIR:
 229         WCMD_setshow_default ();
 230         break;
 231       case WCMD_CLS:
 232         WCMD_clear_screen ();
 233         break;
 234       case WCMD_COPY:
 235         WCMD_copy ();
 236         break;
 237       case WCMD_CTTY:
 238         WCMD_change_tty ();
 239         break;
 240       case WCMD_DATE:
 241         WCMD_setshow_date ();
 242         break;
 243       case WCMD_DEL:
 244       case WCMD_ERASE:
 245         WCMD_delete (0);
 246         break;
 247       case WCMD_DIR:
 248         WCMD_directory ();
 249         break;
 250       case WCMD_ECHO:
 251         /* Use the unstripped version of the following data - step over the space */
 252         /* but only if a parameter follows                                        */
 253         if (strlen(&whichcmd[count]) > 0)
 254           WCMD_echo(&whichcmd[count+1]);
 255         else
 256           WCMD_echo(&whichcmd[count]);
 257         break;
 258       case WCMD_FOR:
 259         WCMD_for (p);
 260         break;
 261       case WCMD_GOTO:
 262         WCMD_goto ();
 263         break;
 264       case WCMD_HELP:
 265         WCMD_give_help (p);
 266         break;
 267       case WCMD_IF:
 268         WCMD_if (p);
 269         break;
 270       case WCMD_LABEL:
 271         WCMD_volume (1, p);
 272         break;
 273       case WCMD_MD:
 274       case WCMD_MKDIR:
 275         WCMD_create_dir ();
 276         break;
 277       case WCMD_MOVE:
 278         WCMD_move ();
 279         break;
 280       case WCMD_PATH:
 281         WCMD_setshow_path (p);
 282         break;
 283       case WCMD_PAUSE:
 284         WCMD_pause ();
 285         break;
 286       case WCMD_PROMPT:
 287         WCMD_setshow_prompt ();
 288         break;
 289       case WCMD_REM:
 290         break;
 291       case WCMD_REN:
 292       case WCMD_RENAME:
 293         WCMD_rename ();
 294         break;
 295       case WCMD_RD:
 296       case WCMD_RMDIR:
 297         WCMD_remove_dir ();
 298         break;
 299       case WCMD_SET:
 300         WCMD_setshow_env (p);
 301         break;
 302       case WCMD_SHIFT:
 303         WCMD_shift ();
 304         break;
 305       case WCMD_TIME:
 306         WCMD_setshow_time ();
 307         break;
 308       case WCMD_TITLE:
 309         if (strlen(&whichcmd[count]) > 0)
 310           WCMD_title(&whichcmd[count+1]);
 311         break;
 312       case WCMD_TYPE:
 313         WCMD_type ();
 314         break;
 315       case WCMD_VER:
 316         WCMD_version ();
 317         break;
 318       case WCMD_VERIFY:
 319         WCMD_verify (p);
 320         break;
 321       case WCMD_VOL:
 322         WCMD_volume (0, p);
 323         break;
 324       case WCMD_EXIT:
 325         ExitProcess (0);
 326       default:
 327         WCMD_run_program (whichcmd);
 328     };
 329     if (old_stdin) {
 330       CloseHandle (GetStdHandle (STD_INPUT_HANDLE));
 331       SetStdHandle (STD_INPUT_HANDLE, old_stdin);
 332     }
 333     if (old_stdout) {
 334       CloseHandle (GetStdHandle (STD_OUTPUT_HANDLE));
 335       SetStdHandle (STD_OUTPUT_HANDLE, old_stdout);
 336     }
 337   }
 338
 339 /******************************************************************************
 340  * WCMD_run_program
 341  *
 342  *      Execute a command line as an external program. If no extension given then
 343  *      precedence is given to .BAT files. Must allow recursion.
 344  *
 345  *      FIXME: Case sensitivity in suffixes!
 346  */
 347
 348 void WCMD_run_program (char *command) {
 349
 350 STARTUPINFO st;
 351 PROCESS_INFORMATION pe;
 352 SHFILEINFO psfi;
 353 DWORD console;
 354 BOOL status;
 355 HANDLE h;
 356 HINSTANCE hinst;
 357 char filetorun[MAX_PATH];
 358
 359   WCMD_parse (command, quals, param1, param2);  /* Quick way to get the filename */
 360   if (!(*param1) && !(*param2))
 361     return;
 362   if (strpbrk (param1, "\\:") == NULL) {        /* No explicit path given */
 363     if ((strchr (param1, '.') == NULL) || (strstr (param1, ".bat") != NULL)) {
 364       if (SearchPath (NULL, param1, ".bat", sizeof(filetorun), filetorun, NULL)) {
 365         WCMD_batch (filetorun, command, 0);
 366         return;
 367       }
 368     }
 369   }
 370   else {                                        /* Explicit path given */
 371     if (strstr (param1, ".bat") != NULL) {
 372       WCMD_batch (param1, command, 0);
 373       return;
 374     }
 375     if (strchr (param1, '.') == NULL) {
 376       strcpy (filetorun, param1);
 377       strcat (filetorun, ".bat");
 378       h = CreateFile (filetorun, GENERIC_READ, FILE_SHARE_READ,
 379                       NULL, OPEN_EXISTING, FILE_ATTRIBUTE_NORMAL, NULL);
 380       if (h != INVALID_HANDLE_VALUE) {
 381         CloseHandle (h);
 382         WCMD_batch (param1, command, 0);
 383         return;
 384       }
 385     }
 386   }
 387
 388         /* No batch file found, assume executable */
 389
 390   hinst = FindExecutable (param1, NULL, filetorun);
 391   if ((int)hinst < 32) {
 392     WCMD_print_error ();
 393     return;
 394   }
 395   console = SHGetFileInfo (filetorun, 0, &psfi, sizeof(psfi), SHGFI_EXETYPE);
 396   ZeroMemory (&st, sizeof(STARTUPINFO));
 397   st.cb = sizeof(STARTUPINFO);
 398   status = CreateProcess (NULL, command, NULL, NULL, FALSE,
 399                  0, NULL, NULL, &st, &pe);
 400   if (!status) {
 401     WCMD_print_error ();
 402     return;
 403   }
 404   if (!console) errorlevel = 0;
 405   else
 406   {
 407       if (!HIWORD(console)) WaitForSingleObject (pe.hProcess, INFINITE);
 408       GetExitCodeProcess (pe.hProcess, &errorlevel);
 409       if (errorlevel == STILL_ACTIVE) errorlevel = 0;
 410   }
 411 }
 412
 413 /******************************************************************************
 414  * WCMD_show_prompt
 415  *
 416  *      Display the prompt on STDout
 417  *
 418  */
 419
 420 void WCMD_show_prompt (void) {
 421
 422 int status;
 423 char out_string[MAX_PATH], curdir[MAX_PATH], prompt_string[MAX_PATH];
 424 char *p, *q;
 425
 426   status = GetEnvironmentVariable ("PROMPT", prompt_string, sizeof(prompt_string));
 427   if ((status == 0) || (status > sizeof(prompt_string))) {
 428     lstrcpy (prompt_string, "$P$G");
 429   }
 430   p = prompt_string;
 431   q = out_string;
 432   *q = '\0';
 433   while (*p != '\0') {
 434     if (*p != '$') {
 435       *q++ = *p++;
 436       *q = '\0';
 437     }
 438     else {
 439       p++;
 440       switch (toupper(*p)) {
 441         case '$':
 442           *q++ = '$';
 443           break;
 444         case 'B':
 445           *q++ = '|';
 446           break;
 447         case 'D':
 448           GetDateFormat (LOCALE_USER_DEFAULT, DATE_SHORTDATE, NULL, NULL, q, MAX_PATH);
 449           while (*q) q++;
 450           break;
 451         case 'E':
 452           *q++ = '\E';
 453           break;
 454         case 'G':
 455           *q++ = '>';
 456           break;
 457         case 'L':
 458           *q++ = '<';
 459           break;
 460         case 'N':
 461           status = GetCurrentDirectory (sizeof(curdir), curdir);
 462           if (status) {
 463             *q++ = curdir[0];
 464           }
 465           break;
 466         case 'P':
 467           status = GetCurrentDirectory (sizeof(curdir), curdir);
 468           if (status) {
 469             lstrcat (q, curdir);
 470             while (*q) q++;
 471           }
 472           break;
 473         case 'Q':
 474           *q++ = '=';
 475           break;
 476         case 'T':
 477           GetTimeFormat (LOCALE_USER_DEFAULT, 0, NULL, NULL, q, MAX_PATH);
 478           while (*q) q++;
 479           break;
 480        case 'V':
 481            lstrcat (q, version_string);
 482            while (*q) q++;
 483          break;
 484         case '_':
 485           *q++ = '\n';
 486           break;
 487       }
 488       p++;
 489       *q = '\0';
 490     }
 491   }
 492   WCMD_output (out_string);
 493 }
 494
 495 /****************************************************************************
 496  * WCMD_print_error
 497  *
 498  * Print the message for GetLastError
 499  */
 500
 501 void WCMD_print_error (void) {
 502 LPVOID lpMsgBuf;
 503 DWORD error_code;
 504 int status;
 505
 506   error_code = GetLastError ();
 507   status = FormatMessage (FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
 508                         NULL, error_code, 0, (LPTSTR) &lpMsgBuf, 0, NULL);
 509   if (!status) {
 510     WCMD_output ("FIXME: Cannot display message for error %d, status %d\n",
 511                         error_code, GetLastError());
 512     return;
 513   }
 514   WCMD_output (lpMsgBuf);
 515   LocalFree ((HLOCAL)lpMsgBuf);
 516   WCMD_output (newline);
 517   return;
 518 }
 519
 520 /*******************************************************************
 521  * WCMD_parse - parse a command into parameters and qualifiers.
 522  *
 523  *      On exit, all qualifiers are concatenated into q, the first string
 524  *      not beginning with "/" is in p1 and the
 525  *      second in p2. Any subsequent non-qualifier strings are lost.
 526  *      Parameters in quotes are handled.
 527  */
 528
 529 void WCMD_parse (char *s, char *q, char *p1, char *p2) {
 530
 531 int p = 0;
 532
 533   *q = *p1 = *p2 = '\0';
 534   while (TRUE) {
 535     switch (*s) {
 536       case '/':
 537         *q++ = *s++;
 538         while ((*s != '\0') && (*s != ' ') && *s != '/') {
 539           *q++ = toupper (*s++);
 540         }
 541         *q = '\0';
 542         break;
 543       case ' ':
 544         s++;
 545         break;
 546       case '"':
 547         s++;
 548         while ((*s != '\0') && (*s != '"')) {
 549           if (p == 0) *p1++ = *s++;
 550           else if (p == 1) *p2++ = *s++;
 551           else s++;
 552         }
 553         if (p == 0) *p1 = '\0';
 554         if (p == 1) *p2 = '\0';
 555         p++;
 556         if (*s == '"') s++;
 557         break;
 558       case '\0':
 559         return;
 560       default:
 561         while ((*s != '\0') && (*s != ' ')) {
 562           if (p == 0) *p1++ = *s++;
 563           else if (p == 1) *p2++ = *s++;
 564           else s++;
 565         }
 566         if (p == 0) *p1 = '\0';
 567         if (p == 1) *p2 = '\0';
 568         p++;
 569     }
 570   }
 571 }
 572
 573 /*******************************************************************
 574  * WCMD_output - send output to current standard output device.
 575  *
 576  */
 577
 578 void WCMD_output (char *format, ...) {
 579
 580 va_list ap;
 581 char string[1024];
 582
 583   va_start(ap,format);
 584   vsprintf (string, format, ap);
 585   va_end(ap);
 586   WCMD_output_asis(string);
 587 }
 588
 589
 590 static int line_count;
 591 static int max_height;
 592 static BOOL paged_mode;
 593
 594 void WCMD_enter_paged_mode(void)
 595 {
 596 CONSOLE_SCREEN_BUFFER_INFO consoleInfo;
 597
 598   if (GetConsoleScreenBufferInfo(GetStdHandle(STD_OUTPUT_HANDLE), &consoleInfo))
 599     max_height = consoleInfo.dwSize.Y;
 600   else
 601     max_height = 25;
 602   paged_mode = TRUE;
 603   line_count = 5; /* keep 5 lines from previous output */
 604 }
 605
 606 void WCMD_leave_paged_mode(void)
 607 {
 608   paged_mode = FALSE;
 609 }
 610
 611 /*******************************************************************
 612  * WCMD_output_asis - send output to current standard output device.
 613  *        without formatting eg. when message contains '%'
 614  */
 615
 616 void WCMD_output_asis (char *message) {
 617   DWORD count;
 618   char* ptr;
 619   char string[1024];
 620
 621   if (paged_mode) {
 622     do {
 623       if ((ptr = strchr(message, '\n')) != NULL) ptr++;
 624       WriteFile (GetStdHandle(STD_OUTPUT_HANDLE), message,
 625                  (ptr) ? ptr - message : lstrlen(message), &count, NULL);
 626       if (ptr) {
 627         if (++line_count >= max_height - 1) {
 628           line_count = 0;
 629           WCMD_output_asis (anykey);
 630           ReadFile (GetStdHandle(STD_INPUT_HANDLE), string, sizeof(string), &count, NULL);
 631         }
 632       }
 633     } while ((message = ptr) != NULL);
 634   } else {
 635       WriteFile (GetStdHandle(STD_OUTPUT_HANDLE), message, lstrlen(message), &count, NULL);
 636   }
 637 }
 638
 639
 640 /***************************************************************************
 641  * WCMD_strtrim_leading_spaces
 642  *
 643  *      Remove leading spaces from a string. Return a pointer to the first
 644  *      non-space character. Does not modify the input string
 645  */
 646
 647 char *WCMD_strtrim_leading_spaces (char *string) {
 648
 649 char *ptr;
 650
 651   ptr = string;
 652   while (*ptr == ' ') ptr++;
 653   return ptr;
 654 }
 655
 656 /*************************************************************************
 657  * WCMD_strtrim_trailing_spaces
 658  *
 659  *      Remove trailing spaces from a string. This routine modifies the input
 660  *      string by placing a null after the last non-space character
 661  */
 662
 663 void WCMD_strtrim_trailing_spaces (char *string) {
 664
 665 char *ptr;
 666
 667   ptr = string + lstrlen (string) - 1;
 668   while ((*ptr == ' ') && (ptr >= string)) {
 669     *ptr = '\0';
 670     ptr--;
 671   }
 672 }
 673
 674 /*************************************************************************
 675  * WCMD_pipe
 676  *
 677  *      Handle pipes within a command - the DOS way using temporary files.
 678  */
 679
 680 void WCMD_pipe (char *command) {
 681
 682 char *p;
 683 char temp_path[MAX_PATH], temp_file[MAX_PATH], temp_file2[MAX_PATH], temp_cmd[1024];
 684
 685   GetTempPath (sizeof(temp_path), temp_path);
 686   GetTempFileName (temp_path, "WCMD", 0, temp_file);
 687   p = strchr(command, '|');
 688   *p++ = '\0';
 689   wsprintf (temp_cmd, "%s > %s", command, temp_file);
 690   WCMD_process_command (temp_cmd);
 691   command = p;
 692   while ((p = strchr(command, '|'))) {
 693     *p++ = '\0';
 694     GetTempFileName (temp_path, "WCMD", 0, temp_file2);
 695     wsprintf (temp_cmd, "%s < %s > %s", command, temp_file, temp_file2);
 696     WCMD_process_command (temp_cmd);
 697     DeleteFile (temp_file);
 698     lstrcpy (temp_file, temp_file2);
 699     command = p;
 700   }
 701   wsprintf (temp_cmd, "%s < %s", command, temp_file);
 702   WCMD_process_command (temp_cmd);
 703   DeleteFile (temp_file);
 704 }