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