nt/cmdproxy.c

   1 /* Proxy shell designed for use with Emacs on Windows 95 and NT.
   2    Copyright (C) 1997 Free Software Foundation, Inc.
   3
   4    Accepts subset of Unix sh(1) command-line options, for compatability
   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 2, or (at your option)
  20 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; see the file COPYING.  If not, write to
  29 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  30 Boston, MA 02111-1307, USA.  */
  31
  32 #include <windows.h>
  33
  34 #include <stdarg.h>  /* va_args */
  35 #include <malloc.h>  /* alloca */
  36 #include <stdlib.h>  /* getenv */
  37 #include <string.h>  /* strlen */
  38
  39
  40 /*******  Mock C library routines  *********************************/
  41
  42 /* These routines are used primarily to minimize the executable size.  */
  43
  44 #define stdin  GetStdHandle (STD_INPUT_HANDLE)
  45 #define stdout GetStdHandle (STD_OUTPUT_HANDLE)
  46 #define stderr GetStdHandle (STD_ERROR_HANDLE)
  47
  48 int
  49 vfprintf(HANDLE hnd, 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, 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(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 (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 (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 char *
 124 skip_space (char *str)
 125 {
 126   while (isspace (*str)) str++;
 127   return str;
 128 }
 129
 130 char *
 131 skip_nonspace (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, char ** pSrc)
 142 {
 143   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               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 behaviour 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 int
 370 spawn (char * progname, char * cmdline)
 371 {
 372   DWORD rc = 0xff;
 373   SECURITY_ATTRIBUTES sec_attrs;
 374   STARTUPINFO start;
 375   char * envblock = GetEnvironmentStrings ();
 376
 377   sec_attrs.nLength = sizeof (sec_attrs);
 378   sec_attrs.lpSecurityDescriptor = NULL;
 379   sec_attrs.bInheritHandle = FALSE;
 380
 381   memset (&start, 0, sizeof (start));
 382   start.cb = sizeof (start);
 383
 384   if (CreateProcess (progname, cmdline, &sec_attrs, NULL, TRUE,
 385                      0, envblock, NULL, &start, &child))
 386   {
 387     /* wait for completion and pass on return code */
 388     WaitForSingleObject (child.hProcess, INFINITE);
 389     GetExitCodeProcess (child.hProcess, &rc);
 390     CloseHandle (child.hThread);
 391     CloseHandle (child.hProcess);
 392     child.hProcess = NULL;
 393   }
 394
 395   FreeEnvironmentStrings (envblock);
 396
 397   return (int) rc;
 398 }
 399
 400 /* Return size of current environment block.  */
 401 int
 402 get_env_size ()
 403 {
 404   char * start = GetEnvironmentStrings ();
 405   char * tmp = start;
 406
 407   while (tmp[0] || tmp[1])
 408     ++tmp;
 409   FreeEnvironmentStrings (start);
 410   return  tmp + 2 - start;
 411 }
 412
 413 /*******  Main program  ********************************************/
 414
 415 int
 416 main (int argc, char ** argv)
 417 {
 418   int rc;
 419   int need_shell;
 420   char * cmdline;
 421   char * progname;
 422   int envsize;
 423   char **pass_through_args;
 424   int num_pass_through_args;
 425   char modname[MAX_PATH];
 426   char path[MAX_PATH];
 427
 428
 429   interactive = TRUE;
 430
 431   SetConsoleCtrlHandler ((PHANDLER_ROUTINE) console_event_handler, TRUE);
 432
 433   /* We serve double duty: we can be called either as a proxy for the
 434      real shell (that is, because we are defined to be the user shell),
 435      or in our role as a helper application for running DOS programs.
 436      In the former case, we interpret the command line options as if we
 437      were a Unix shell, but in the latter case we simply pass our
 438      command line to CreateProcess.  We know which case we are dealing
 439      with by whether argv[0] refers to ourself or to some other program.
 440      (This relies on an arcane feature of CreateProcess, where we can
 441      specify cmdproxy as the module to run, but specify a different
 442      program in the command line - the MSVC startup code sets argv[0]
 443      from the command line.)  */
 444
 445   if (!GetModuleFileName (NULL, modname, sizeof (modname)))
 446     fail ("error: GetModuleFileName failed\n");
 447
 448   /* Although Emacs always sets argv[0] to an absolute pathname, we
 449      might get run in other ways as well, so convert argv[0] to an
 450      absolute name before comparing to the module name.  */
 451   if (!SearchPath (NULL, argv[0], ".exe", sizeof (path), path, &progname)
 452       || stricmp (modname, path) != 0)
 453     {
 454       /* We are being used as a helper to run a DOS app; just pass
 455          command line to DOS app without change.  */
 456       /* TODO: fill in progname.  */
 457       return spawn (NULL, GetCommandLine ());
 458     }
 459
 460   /* Process command line.  If running interactively (-c or /c not
 461      specified) then spawn a real command shell, passing it the command
 462      line arguments.
 463
 464      If not running interactively, then attempt to execute the specified
 465      command directly.  If necessary, spawn a real shell to execute the
 466      command.
 467
 468   */
 469
 470   progname = NULL;
 471   cmdline = NULL;
 472   /* If no args, spawn real shell for interactive use.  */
 473   need_shell = TRUE;
 474   interactive = TRUE;
 475   /* Ask command.com to create an environment block with a reasonable
 476      amount of free space.  */
 477   envsize = get_env_size () + 300;
 478   pass_through_args = (char **) alloca (argc * sizeof(char *));
 479   num_pass_through_args = 0;
 480
 481   while (--argc > 0)
 482     {
 483       ++argv;
 484       /* Act on switches we recognize (mostly single letter switches,
 485          except for -e); all unrecognised switches and extra args are
 486          passed on to real shell if used (only really of benefit for
 487          interactive use, but allow for batch use as well).  Accept / as
 488          switch char for compatability with cmd.exe.  */
 489       if ( ((*argv)[0] == '-' || (*argv)[0] == '/') && (*argv)[1] != '\0' )
 490         {
 491           if ( ((*argv)[1] == 'c') && ((*argv)[2] == '\0')  )
 492             {
 493               if (--argc == 0)
 494                 fail ("error: expecting arg for %s\n", *argv);
 495               cmdline = *(++argv);
 496               interactive = FALSE;
 497             }
 498           else if ( ((*argv)[1] == 'i') && ((*argv)[2] == '\0')  )
 499             {
 500               if (cmdline)
 501                 warn ("warning: %s ignored because of -c\n", *argv);
 502             }
 503           else if ( ((*argv)[1] == 'e') && ((*argv)[2] == ':')  )
 504             {
 505               int requested_envsize = atoi (*argv + 3);
 506               /* Enforce a reasonable minimum size, as above.  */
 507               if (requested_envsize > envsize)
 508                 envsize = requested_envsize;
 509               /* For sanity, enforce a reasonable maximum.  */
 510               if (envsize > 32768)
 511                 envsize = 32768;
 512             }
 513           else
 514             {
 515               /* warn ("warning: unknown option %s ignored", *argv); */
 516               pass_through_args[num_pass_through_args++] = *argv;
 517             }
 518         }
 519       else
 520         break;
 521     }
 522
 523 #if 0
 524   /* I think this is probably not useful - cmd.exe ignores extra
 525      (non-switch) args in interactive mode, and they cannot be passed on
 526      when -c was given.  */
 527
 528   /* Collect any remaining args after (initial) switches.  */
 529   while (argc-- > 0)
 530     {
 531       pass_through_args[num_pass_through_args++] = *argv++;
 532     }
 533 #else
 534   /* Probably a mistake for there to be extra args; not fatal.  */
 535   if (argc > 0)
 536     warn ("warning: extra args ignored after %s\n", argv[-1]);
 537 #endif
 538
 539   pass_through_args[num_pass_through_args] = NULL;
 540
 541   /* If -c option, determine if we must spawn a real shell, or if we can
 542      execute the command directly ourself.  */
 543   if (cmdline)
 544     {
 545       /* If no redirection or piping, and if program can be found, then
 546          run program directly.  Otherwise invoke a real shell. */
 547
 548       static char copout_chars[] = "|<>&";
 549
 550       if (strpbrk (cmdline, copout_chars) == NULL)
 551         {
 552           char *args;
 553
 554           /* The program name is the first token of cmdline.  Since
 555              filenames cannot legally contain embedded quotes, the value
 556              of escape_char doesn't matter.  */
 557           args = cmdline;
 558           if (!get_next_token (path, &args))
 559             fail ("error: no program name specified.\n");
 560
 561           canon_filename (path);
 562           progname = make_absolute (path);
 563
 564           /* If we found the program, run it directly (if not found it
 565              might be an internal shell command, so don't fail).  */
 566           if (progname != NULL)
 567             need_shell = FALSE;
 568         }
 569     }
 570
 571   if (need_shell)
 572     {
 573       char * p;
 574       int    extra_arg_space = 0;
 575
 576       progname = getenv ("COMSPEC");
 577       if (!progname)
 578         fail ("error: COMSPEC is not set\n");
 579
 580       canon_filename (progname);
 581       progname = make_absolute (progname);
 582
 583       if (progname == NULL || strchr (progname, '\\') == NULL)
 584         fail ("error: the program %s could not be found.\n", getenv ("COMSPEC"));
 585
 586       /* Work out how much extra space is required for
 587          pass_through_args.  */
 588       for (argv = pass_through_args; *argv != NULL; ++argv)
 589         /* We don't expect to have to quote switches.  */
 590         extra_arg_space += strlen (*argv) + 2;
 591
 592       if (cmdline)
 593         {
 594           char * buf;
 595
 596           /* Convert to syntax expected by cmd.exe/command.com for
 597              running non-interactively.  Always quote program name in
 598              case path contains spaces (fortunately it can't contain
 599              quotes, since they are illegal in path names).  */
 600
 601           buf = p = alloca (strlen (progname) + extra_arg_space +
 602                             strlen (cmdline) + 16);
 603
 604           /* Quote progname in case it contains spaces.  */
 605           p += wsprintf (p, "\"%s\"", progname);
 606
 607           /* Include pass_through_args verbatim; these are just switches
 608              so should not need quoting.  */
 609           for (argv = pass_through_args; *argv != NULL; ++argv)
 610             p += wsprintf (p, " %s", *argv);
 611
 612           /* Always set environment size to something reasonable.  */
 613           wsprintf(p, " /e:%d /c %s", envsize, cmdline);
 614           cmdline = buf;
 615         }
 616       else
 617         {
 618           /* Provide dir arg expected by command.com when first started
 619              interactively (the "command search path").  cmd.exe does
 620              not require it, but accepts it silently - presumably other
 621              DOS compatible shells do the same.  To avoid potential
 622              problems with spaces in command dir (which cannot be quoted
 623              - command.com doesn't like it), we always use the 8.3 form.  */
 624           GetShortPathName (progname, path, sizeof (path));
 625           p = strrchr (path, '\\');
 626           /* Trailing slash is acceptable, so always leave it.  */
 627           *(++p) = '\0';
 628
 629           cmdline = p = alloca (strlen (progname) + extra_arg_space +
 630                                 strlen (path) + 13);
 631
 632           /* Quote progname in case it contains spaces.  */
 633           p += wsprintf (p, "\"%s\" %s", progname, path);
 634
 635           /* Include pass_through_args verbatim; these are just switches
 636              so should not need quoting.  */
 637           for (argv = pass_through_args; *argv != NULL; ++argv)
 638             p += wsprintf (p, " %s", *argv);
 639
 640           /* Always set environment size to something reasonable - again
 641              cmd.exe ignores this silently.  */
 642           wsprintf (p, " /e:%d", envsize);
 643         }
 644     }
 645
 646   if (!progname)
 647     fail ("Internal error: program name not defined\n");
 648
 649   if (!cmdline)
 650     cmdline = progname;
 651
 652   rc = spawn (progname, cmdline);
 653
 654   return rc;
 655 }