nt/cmdproxy.c

   1 /* Proxy shell designed for use with Emacs on Windows 95 and NT.
   2    Copyright (C) 1997, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
   3      2008  Free Software Foundation, Inc.
   4
   5    Accepts subset of Unix sh(1) command-line options, for compatability
   6    with elisp code written for Unix.  When possible, executes external
   7    programs directly (a common use of /bin/sh by Emacs), otherwise
   8    invokes the user-specified command processor to handle built-in shell
   9    commands, batch files and interactive mode.
  10
  11    The main function is simply to process the "-c string" option in the
  12    way /bin/sh does, since the standard Windows command shells use the
  13    convention that everything after "/c" (the Windows equivalent of
  14    "-c") is the input string.
  15
  16 This file is part of GNU Emacs.
  17
  18 GNU Emacs is free software: you can redistribute it and/or modify
  19 it under the terms of the GNU General Public License as published by
  20 the Free Software Foundation, either version 3 of the License, or
  21 (at your option) any later version.
  22
  23 GNU Emacs is distributed in the hope that it will be useful,
  24 but WITHOUT ANY WARRANTY; without even the implied warranty of
  25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  26 GNU General Public License for more details.
  27
  28 You should have received a copy of the GNU General Public License
  29 along with GNU Emacs.  If not, see <http://www.gnu.org/licenses/>.  */
  30
  31 #include <windows.h>
  32
  33 #include <stdarg.h>  /* va_args */
  34 #include <malloc.h>  /* alloca */
  35 #include <stdlib.h>  /* getenv */
  36 #include <string.h>  /* strlen */
  37
  38
  39 /*******  Mock C library routines  *********************************/
  40
  41 /* These routines are used primarily to minimize the executable size.  */
  42
  43 #define stdin  GetStdHandle (STD_INPUT_HANDLE)
  44 #define stdout GetStdHandle (STD_OUTPUT_HANDLE)
  45 #define stderr GetStdHandle (STD_ERROR_HANDLE)
  46
  47 int
  48 vfprintf(HANDLE hnd, char * msg, va_list args)
  49 {
  50   DWORD bytes_written;
  51   char buf[1024];
  52
  53   wvsprintf (buf, msg, args);
  54   return WriteFile (hnd, buf, strlen (buf), &bytes_written, NULL);
  55 }
  56
  57 int
  58 fprintf(HANDLE hnd, char * msg, ...)
  59 {
  60   va_list args;
  61   int rc;
  62
  63   va_start (args, msg);
  64   rc = vfprintf (hnd, msg, args);
  65   va_end (args);
  66
  67   return rc;
  68 }
  69
  70 int
  71 printf(char * msg, ...)
  72 {
  73   va_list args;
  74   int rc;
  75
  76   va_start (args, msg);
  77   rc = vfprintf (stdout, msg, args);
  78   va_end (args);
  79
  80   return rc;
  81 }
  82
  83 void
  84 fail (char * msg, ...)
  85 {
  86   va_list args;
  87
  88   va_start (args, msg);
  89   vfprintf (stderr, msg, args);
  90   va_end (args);
  91
  92   exit (-1);
  93 }
  94
  95 void
  96 warn (char * msg, ...)
  97 {
  98   va_list args;
  99
 100   va_start (args, msg);
 101   vfprintf (stderr, msg, args);
 102   va_end (args);
 103 }
 104
 105 /******************************************************************/
 106
 107 char *
 108 canon_filename (char *fname)
 109 {
 110   char *p = fname;
 111
 112   while (*p)
 113     {
 114       if (*p == '/')
 115         *p = '\\';
 116       p++;
 117     }
 118
 119   return fname;
 120 }
 121
 122 char *
 123 skip_space (char *str)
 124 {
 125   while (isspace (*str)) str++;
 126   return str;
 127 }
 128
 129 char *
 130 skip_nonspace (char *str)
 131 {
 132   while (*str && !isspace (*str)) str++;
 133   return str;
 134 }
 135
 136 int escape_char = '\\';
 137
 138 /* Get next token from input, advancing pointer.  */
 139 int
 140 get_next_token (char * buf, char ** pSrc)
 141 {
 142   char * p = *pSrc;
 143   char * o = buf;
 144
 145   p = skip_space (p);
 146   if (*p == '"')
 147     {
 148       int escape_char_run = 0;
 149
 150       /* Go through src until an ending quote is found, unescaping
 151          quotes along the way.  If the escape char is not quote, then do
 152          special handling of multiple escape chars preceding a quote
 153          char (ie. the reverse of what Emacs does to escape quotes).  */
 154       p++;
 155       while (1)
 156         {
 157           if (p[0] == escape_char && escape_char != '"')
 158             {
 159               escape_char_run++;
 160               p++;
 161               continue;
 162             }
 163           else if (p[0] == '"')
 164             {
 165               while (escape_char_run > 1)
 166                 {
 167                   *o++ = escape_char;
 168                   escape_char_run -= 2;
 169                 }
 170
 171               if (escape_char_run > 0)
 172                 {
 173                   /* escaped quote */
 174                   *o++ = *p++;
 175                   escape_char_run = 0;
 176                 }
 177               else if (p[1] == escape_char && escape_char == '"')
 178                 {
 179                   /* quote escaped by doubling */
 180                   *o++ = *p;
 181                   p += 2;
 182                 }
 183               else
 184                 {
 185                   /* The ending quote.  */
 186                   *o = '\0';
 187                   /* Leave input pointer after token.  */
 188                   p++;
 189                   break;
 190                 }
 191             }
 192           else if (p[0] == '\0')
 193             {
 194               /* End of string, but no ending quote found.  We might want to
 195                  flag this as an error, but for now will consider the end as
 196                  the end of the token.  */
 197               *o = '\0';
 198               break;
 199             }
 200           else
 201             {
 202               *o++ = *p++;
 203             }
 204         }
 205     }
 206   else
 207     {
 208       /* Next token is delimited by whitespace.  */
 209       char * p1 = skip_nonspace (p);
 210       memcpy (o, p, p1 - p);
 211       o += (p1 - p);
 212       *o = '\0';
 213       p = p1;
 214     }
 215
 216   *pSrc = p;
 217
 218   return o - buf;
 219 }
 220
 221 /* Search for EXEC file in DIR.  If EXEC does not have an extension,
 222    DIR is searched for EXEC with the standard extensions appended.  */
 223 int
 224 search_dir (char *dir, char *exec, int bufsize, char *buffer)
 225 {
 226   char *exts[] = {".bat", ".cmd", ".exe", ".com"};
 227   int n_exts = sizeof (exts) / sizeof (char *);
 228   char *dummy;
 229   int i, rc;
 230
 231   /* Search the directory for the program.  */
 232   for (i = 0; i < n_exts; i++)
 233     {
 234       rc = SearchPath (dir, exec, exts[i], bufsize, buffer, &dummy);
 235       if (rc > 0)
 236         return rc;
 237     }
 238
 239   return 0;
 240 }
 241
 242 /* Return the absolute name of executable file PROG, including
 243    any file extensions.  If an absolute name for PROG cannot be found,
 244    return NULL.  */
 245 char *
 246 make_absolute (char *prog)
 247 {
 248   char absname[MAX_PATH];
 249   char dir[MAX_PATH];
 250   char curdir[MAX_PATH];
 251   char *p, *fname;
 252   char *path;
 253   int i;
 254
 255   /* At least partial absolute path specified; search there.  */
 256   if ((isalpha (prog[0]) && prog[1] == ':') ||
 257       (prog[0] == '\\'))
 258     {
 259       /* Split the directory from the filename.  */
 260       fname = strrchr (prog, '\\');
 261       if (!fname)
 262         /* Only a drive specifier is given.  */
 263         fname = prog + 2;
 264       strncpy (dir, prog, fname - prog);
 265       dir[fname - prog] = '\0';
 266
 267       /* Search the directory for the program.  */
 268       if (search_dir (dir, prog, MAX_PATH, absname) > 0)
 269         return strdup (absname);
 270       else
 271         return NULL;
 272     }
 273
 274   if (GetCurrentDirectory (MAX_PATH, curdir) <= 0)
 275     return NULL;
 276
 277   /* Relative path; search in current dir. */
 278   if (strpbrk (prog, "\\"))
 279     {
 280       if (search_dir (curdir, prog, MAX_PATH, absname) > 0)
 281         return strdup (absname);
 282       else
 283         return NULL;
 284     }
 285
 286   /* Just filename; search current directory then PATH.  */
 287   path = alloca (strlen (getenv ("PATH")) + strlen (curdir) + 2);
 288   strcpy (path, curdir);
 289   strcat (path, ";");
 290   strcat (path, getenv ("PATH"));
 291
 292   while (*path)
 293     {
 294       /* Get next directory from path.  */
 295       p = path;
 296       while (*p && *p != ';') p++;
 297       strncpy (dir, path, p - path);
 298       dir[p - path] = '\0';
 299
 300       /* Search the directory for the program.  */
 301       if (search_dir (dir, prog, MAX_PATH, absname) > 0)
 302         return strdup (absname);
 303
 304       /* Move to the next directory.  */
 305       path = p + 1;
 306     }
 307
 308   return NULL;
 309 }
 310
 311 /*****************************************************************/
 312
 313 #if 0
 314 char ** _argv;
 315 int     _argc;
 316
 317 /* Parse commandline into argv array, allowing proper quoting of args.  */
 318 void
 319 setup_argv (void)
 320 {
 321   char * cmdline = GetCommandLine ();
 322   int arg_bytes = 0;
 323
 324
 325 }
 326 #endif
 327
 328 /* Information about child proc is global, to allow for automatic
 329    termination when interrupted.  At the moment, only one child process
 330    can be running at any one time.  */
 331
 332 PROCESS_INFORMATION child;
 333 int interactive = TRUE;
 334
 335 BOOL
 336 console_event_handler (DWORD event)
 337 {
 338   switch (event)
 339     {
 340     case CTRL_C_EVENT:
 341     case CTRL_BREAK_EVENT:
 342       if (!interactive)
 343         {
 344           /* Both command.com and cmd.exe have the annoying behavior of
 345              prompting "Terminate batch job (y/n)?" when interrupted
 346              while running a batch file, even if running in
 347              non-interactive (-c) mode.  Try to make up for this
 348              deficiency by forcibly terminating the subprocess if
 349              running non-interactively.  */
 350           if (child.hProcess &&
 351               WaitForSingleObject (child.hProcess, 500) != WAIT_OBJECT_0)
 352             TerminateProcess (child.hProcess, 0);
 353           exit (STATUS_CONTROL_C_EXIT);
 354         }
 355       break;
 356
 357 #if 0
 358     default:
 359       /* CLOSE, LOGOFF and SHUTDOWN events - actually we don't get these
 360          under Windows 95.  */
 361       fail ("cmdproxy: received %d event\n", event);
 362       if (child.hProcess)
 363         TerminateProcess (child.hProcess, 0);
 364 #endif
 365     }
 366   return TRUE;
 367 }
 368
 369 /* Change from normal usage; return value indicates whether spawn
 370    succeeded or failed - program return code is returned separately.  */
 371 int
 372 spawn (char * progname, char * cmdline, char * dir, int * retcode)
 373 {
 374   BOOL success = FALSE;
 375   SECURITY_ATTRIBUTES sec_attrs;
 376   STARTUPINFO start;
 377   /* In theory, passing NULL for the environment block to CreateProcess
 378      is the same as passing the value of GetEnvironmentStrings, but
 379      doing this explicitly seems to cure problems running DOS programs
 380      in some cases.  */
 381   char * envblock = GetEnvironmentStrings ();
 382
 383   sec_attrs.nLength = sizeof (sec_attrs);
 384   sec_attrs.lpSecurityDescriptor = NULL;
 385   sec_attrs.bInheritHandle = FALSE;
 386
 387   memset (&start, 0, sizeof (start));
 388   start.cb = sizeof (start);
 389
 390   if (CreateProcess (progname, cmdline, &sec_attrs, NULL, TRUE,
 391                      0, envblock, dir, &start, &child))
 392   {
 393     success = TRUE;
 394     /* wait for completion and pass on return code */
 395     WaitForSingleObject (child.hProcess, INFINITE);
 396     if (retcode)
 397       GetExitCodeProcess (child.hProcess, (DWORD *)retcode);
 398     CloseHandle (child.hThread);
 399     CloseHandle (child.hProcess);
 400     child.hProcess = NULL;
 401   }
 402
 403   FreeEnvironmentStrings (envblock);
 404
 405   return success;
 406 }
 407
 408 /* Return size of current environment block.  */
 409 int
 410 get_env_size ()
 411 {
 412   char * start = GetEnvironmentStrings ();
 413   char * tmp = start;
 414
 415   while (tmp[0] || tmp[1])
 416     ++tmp;
 417   FreeEnvironmentStrings (start);
 418   return  tmp + 2 - start;
 419 }
 420
 421 /*******  Main program  ********************************************/
 422
 423 int
 424 main (int argc, char ** argv)
 425 {
 426   int rc;
 427   int need_shell;
 428   char * cmdline;
 429   char * progname;
 430   int envsize;
 431   char **pass_through_args;
 432   int num_pass_through_args;
 433   char modname[MAX_PATH];
 434   char path[MAX_PATH];
 435   char dir[MAX_PATH];
 436
 437
 438   interactive = TRUE;
 439
 440   SetConsoleCtrlHandler ((PHANDLER_ROUTINE) console_event_handler, TRUE);
 441
 442   if (!GetCurrentDirectory (sizeof (dir), dir))
 443     fail ("error: GetCurrentDirectory failed\n");
 444
 445   /* We serve double duty: we can be called either as a proxy for the
 446      real shell (that is, because we are defined to be the user shell),
 447      or in our role as a helper application for running DOS programs.
 448      In the former case, we interpret the command line options as if we
 449      were a Unix shell, but in the latter case we simply pass our
 450      command line to CreateProcess.  We know which case we are dealing
 451      with by whether argv[0] refers to ourself or to some other program.
 452      (This relies on an arcane feature of CreateProcess, where we can
 453      specify cmdproxy as the module to run, but specify a different
 454      program in the command line - the MSVC startup code sets argv[0]
 455      from the command line.)  */
 456
 457   if (!GetModuleFileName (NULL, modname, sizeof (modname)))
 458     fail ("error: GetModuleFileName failed\n");
 459
 460   /* Change directory to location of .exe so startup directory can be
 461      deleted.  */
 462   progname = strrchr (modname, '\\');
 463   *progname = '\0';
 464   SetCurrentDirectory (modname);
 465   *progname = '\\';
 466
 467   /* Due to problems with interaction between API functions that use "OEM"
 468      codepage vs API functions that use the "ANSI" codepage, we need to
 469      make things consistent by choosing one and sticking with it.  */
 470   SetConsoleCP (GetACP());
 471   SetConsoleOutputCP (GetACP());
 472
 473   /* Although Emacs always sets argv[0] to an absolute pathname, we
 474      might get run in other ways as well, so convert argv[0] to an
 475      absolute name before comparing to the module name.  Don't get
 476      caught out by mixed short and long names.  */
 477   GetShortPathName (modname, modname, sizeof (modname));
 478   path[0] = '\0';
 479   if (!SearchPath (NULL, argv[0], ".exe", sizeof (path), path, &progname)
 480       || !GetShortPathName (path, path, sizeof (path))
 481       || stricmp (modname, path) != 0)
 482     {
 483       /* We are being used as a helper to run a DOS app; just pass
 484          command line to DOS app without change.  */
 485       /* TODO: fill in progname.  */
 486       if (spawn (NULL, GetCommandLine (), dir, &rc))
 487         return rc;
 488       fail ("Could not run %s\n", GetCommandLine ());
 489     }
 490
 491   /* Process command line.  If running interactively (-c or /c not
 492      specified) then spawn a real command shell, passing it the command
 493      line arguments.
 494
 495      If not running interactively, then attempt to execute the specified
 496      command directly.  If necessary, spawn a real shell to execute the
 497      command.
 498
 499   */
 500
 501   progname = NULL;
 502   cmdline = NULL;
 503   /* If no args, spawn real shell for interactive use.  */
 504   need_shell = TRUE;
 505   interactive = TRUE;
 506   /* Ask command.com to create an environment block with a reasonable
 507      amount of free space.  */
 508   envsize = get_env_size () + 300;
 509   pass_through_args = (char **) alloca (argc * sizeof(char *));
 510   num_pass_through_args = 0;
 511
 512   while (--argc > 0)
 513     {
 514       ++argv;
 515       /* Act on switches we recognize (mostly single letter switches,
 516          except for -e); all unrecognised switches and extra args are
 517          passed on to real shell if used (only really of benefit for
 518          interactive use, but allow for batch use as well).  Accept / as
 519          switch char for compatability with cmd.exe.  */
 520       if (((*argv)[0] == '-' || (*argv)[0] == '/') && (*argv)[1] != '\0')
 521         {
 522           if (((*argv)[1] == 'c' || (*argv)[1] == 'C') && ((*argv)[2] == '\0'))
 523             {
 524               if (--argc == 0)
 525                 fail ("error: expecting arg for %s\n", *argv);
 526               cmdline = *(++argv);
 527               interactive = FALSE;
 528             }
 529           else if (((*argv)[1] == 'i' || (*argv)[1] == 'I') && ((*argv)[2] == '\0'))
 530             {
 531               if (cmdline)
 532                 warn ("warning: %s ignored because of -c\n", *argv);
 533             }
 534           else if (((*argv)[1] == 'e' || (*argv)[1] == 'E') && ((*argv)[2] == ':'))
 535             {
 536               int requested_envsize = atoi (*argv + 3);
 537               /* Enforce a reasonable minimum size, as above.  */
 538               if (requested_envsize > envsize)
 539                 envsize = requested_envsize;
 540               /* For sanity, enforce a reasonable maximum.  */
 541               if (envsize > 32768)
 542                 envsize = 32768;
 543             }
 544           else
 545             {
 546               /* warn ("warning: unknown option %s ignored", *argv); */
 547               pass_through_args[num_pass_through_args++] = *argv;
 548             }
 549         }
 550       else
 551         break;
 552     }
 553
 554 #if 0
 555   /* I think this is probably not useful - cmd.exe ignores extra
 556      (non-switch) args in interactive mode, and they cannot be passed on
 557      when -c was given.  */
 558
 559   /* Collect any remaining args after (initial) switches.  */
 560   while (argc-- > 0)
 561     {
 562       pass_through_args[num_pass_through_args++] = *argv++;
 563     }
 564 #else
 565   /* Probably a mistake for there to be extra args; not fatal.  */
 566   if (argc > 0)
 567     warn ("warning: extra args ignored after '%s'\n", argv[-1]);
 568 #endif
 569
 570   pass_through_args[num_pass_through_args] = NULL;
 571
 572   /* If -c option, determine if we must spawn a real shell, or if we can
 573      execute the command directly ourself.  */
 574   if (cmdline)
 575     {
 576       /* If no redirection or piping, and if program can be found, then
 577          run program directly.  Otherwise invoke a real shell. */
 578
 579       static char copout_chars[] = "|<>&";
 580
 581       if (strpbrk (cmdline, copout_chars) == NULL)
 582         {
 583           char *args;
 584
 585           /* The program name is the first token of cmdline.  Since
 586              filenames cannot legally contain embedded quotes, the value
 587              of escape_char doesn't matter.  */
 588           args = cmdline;
 589           if (!get_next_token (path, &args))
 590             fail ("error: no program name specified.\n");
 591
 592           canon_filename (path);
 593           progname = make_absolute (path);
 594
 595           /* If we found the program, run it directly (if not found it
 596              might be an internal shell command, so don't fail).  */
 597           if (progname != NULL)
 598             need_shell = FALSE;
 599         }
 600     }
 601
 602  pass_to_shell:
 603   if (need_shell)
 604     {
 605       char * p;
 606       int    extra_arg_space = 0;
 607       int    run_command_dot_com;
 608
 609       progname = getenv ("COMSPEC");
 610       if (!progname)
 611         fail ("error: COMSPEC is not set\n");
 612
 613       canon_filename (progname);
 614       progname = make_absolute (progname);
 615
 616       if (progname == NULL || strchr (progname, '\\') == NULL)
 617         fail ("error: the program %s could not be found.\n", getenv ("COMSPEC"));
 618
 619       /* Need to set environment size when running command.com.  */
 620       run_command_dot_com =
 621         (stricmp (strrchr (progname, '\\'), "command.com") == 0);
 622
 623       /* Work out how much extra space is required for
 624          pass_through_args.  */
 625       for (argv = pass_through_args; *argv != NULL; ++argv)
 626         /* We don't expect to have to quote switches.  */
 627         extra_arg_space += strlen (*argv) + 2;
 628
 629       if (cmdline)
 630         {
 631           char * buf;
 632
 633           /* Convert to syntax expected by cmd.exe/command.com for
 634              running non-interactively.  Always quote program name in
 635              case path contains spaces (fortunately it can't contain
 636              quotes, since they are illegal in path names).  */
 637
 638           buf = p = alloca (strlen (progname) + extra_arg_space +
 639                             strlen (cmdline) + 16);
 640
 641           /* Quote progname in case it contains spaces.  */
 642           p += wsprintf (p, "\"%s\"", progname);
 643
 644           /* Include pass_through_args verbatim; these are just switches
 645              so should not need quoting.  */
 646           for (argv = pass_through_args; *argv != NULL; ++argv)
 647             p += wsprintf (p, " %s", *argv);
 648
 649           if (run_command_dot_com)
 650             wsprintf(p, " /e:%d /c %s", envsize, cmdline);
 651           else
 652             wsprintf(p, " /c %s", cmdline);
 653           cmdline = buf;
 654         }
 655       else
 656         {
 657           if (run_command_dot_com)
 658             {
 659               /* Provide dir arg expected by command.com when first
 660                  started interactively (the "command search path").  To
 661                  avoid potential problems with spaces in command dir
 662                  (which cannot be quoted - command.com doesn't like it),
 663                  we always use the 8.3 form.  */
 664               GetShortPathName (progname, path, sizeof (path));
 665               p = strrchr (path, '\\');
 666               /* Trailing slash is acceptable, so always leave it.  */
 667               *(++p) = '\0';
 668             }
 669           else
 670             path[0] = '\0';
 671
 672           cmdline = p = alloca (strlen (progname) + extra_arg_space +
 673                                 strlen (path) + 13);
 674
 675           /* Quote progname in case it contains spaces.  */
 676           p += wsprintf (p, "\"%s\" %s", progname, path);
 677
 678           /* Include pass_through_args verbatim; these are just switches
 679              so should not need quoting.  */
 680           for (argv = pass_through_args; *argv != NULL; ++argv)
 681             p += wsprintf (p, " %s", *argv);
 682
 683           if (run_command_dot_com)
 684             wsprintf (p, " /e:%d", envsize);
 685         }
 686     }
 687
 688   if (!progname)
 689     fail ("Internal error: program name not defined\n");
 690
 691   if (!cmdline)
 692     cmdline = progname;
 693
 694   if (spawn (progname, cmdline, dir, &rc))
 695     return rc;
 696
 697   if (!need_shell)
 698     {
 699       need_shell = TRUE;
 700       goto pass_to_shell;
 701     }
 702
 703   fail ("Could not run %s\n", progname);
 704
 705   return 0;
 706 }
 707
 708 /* arch-tag: 88678d93-07ac-4e2f-ad63-d4a740ca69ac
 709    (do not change this comment) */