nt/cmdproxy.c

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