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