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               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       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 (char *dir, char *exec, int bufsize, char *buffer)
 226 {
 227   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 (char *prog)
 248 {
 249   char absname[MAX_PATH];
 250   char dir[MAX_PATH];
 251   char curdir[MAX_PATH];
 252   char *p, *fname;
 253   char *path;
 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 behaviour 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 (char * progname, char * cmdline, 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 ()
 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   /* Although Emacs always sets argv[0] to an absolute pathname, we
 469      might get run in other ways as well, so convert argv[0] to an
 470      absolute name before comparing to the module name.  Don't get
 471      caught out by mixed short and long names.  */
 472   GetShortPathName (modname, modname, sizeof (modname));
 473   path[0] = '\0';
 474   if (!SearchPath (NULL, argv[0], ".exe", sizeof (path), path, &progname)
 475       || !GetShortPathName (path, path, sizeof (path))
 476       || stricmp (modname, path) != 0)
 477     {
 478       /* We are being used as a helper to run a DOS app; just pass
 479          command line to DOS app without change.  */
 480       /* TODO: fill in progname.  */
 481       if (spawn (NULL, GetCommandLine (), dir, &rc))
 482         return rc;
 483       fail ("Could not run %s\n", GetCommandLine ());
 484     }
 485
 486   /* Process command line.  If running interactively (-c or /c not
 487      specified) then spawn a real command shell, passing it the command
 488      line arguments.
 489
 490      If not running interactively, then attempt to execute the specified
 491      command directly.  If necessary, spawn a real shell to execute the
 492      command.
 493
 494   */
 495
 496   progname = NULL;
 497   cmdline = NULL;
 498   /* If no args, spawn real shell for interactive use.  */
 499   need_shell = TRUE;
 500   interactive = TRUE;
 501   /* Ask command.com to create an environment block with a reasonable
 502      amount of free space.  */
 503   envsize = get_env_size () + 300;
 504   pass_through_args = (char **) alloca (argc * sizeof(char *));
 505   num_pass_through_args = 0;
 506
 507   while (--argc > 0)
 508     {
 509       ++argv;
 510       /* Act on switches we recognize (mostly single letter switches,
 511          except for -e); all unrecognised switches and extra args are
 512          passed on to real shell if used (only really of benefit for
 513          interactive use, but allow for batch use as well).  Accept / as
 514          switch char for compatability with cmd.exe.  */
 515       if (((*argv)[0] == '-' || (*argv)[0] == '/') && (*argv)[1] != '\0')
 516         {
 517           if (((*argv)[1] == 'c' || (*argv)[1] == 'C') && ((*argv)[2] == '\0'))
 518             {
 519               if (--argc == 0)
 520                 fail ("error: expecting arg for %s\n", *argv);
 521               cmdline = *(++argv);
 522               interactive = FALSE;
 523             }
 524           else if (((*argv)[1] == 'i' || (*argv)[1] == 'I') && ((*argv)[2] == '\0'))
 525             {
 526               if (cmdline)
 527                 warn ("warning: %s ignored because of -c\n", *argv);
 528             }
 529           else if (((*argv)[1] == 'e' || (*argv)[1] == 'E') && ((*argv)[2] == ':'))
 530             {
 531               int requested_envsize = atoi (*argv + 3);
 532               /* Enforce a reasonable minimum size, as above.  */
 533               if (requested_envsize > envsize)
 534                 envsize = requested_envsize;
 535               /* For sanity, enforce a reasonable maximum.  */
 536               if (envsize > 32768)
 537                 envsize = 32768;
 538             }
 539           else
 540             {
 541               /* warn ("warning: unknown option %s ignored", *argv); */
 542               pass_through_args[num_pass_through_args++] = *argv;
 543             }
 544         }
 545       else
 546         break;
 547     }
 548
 549 #if 0
 550   /* I think this is probably not useful - cmd.exe ignores extra
 551      (non-switch) args in interactive mode, and they cannot be passed on
 552      when -c was given.  */
 553
 554   /* Collect any remaining args after (initial) switches.  */
 555   while (argc-- > 0)
 556     {
 557       pass_through_args[num_pass_through_args++] = *argv++;
 558     }
 559 #else
 560   /* Probably a mistake for there to be extra args; not fatal.  */
 561   if (argc > 0)
 562     warn ("warning: extra args ignored after '%s'\n", argv[-1]);
 563 #endif
 564
 565   pass_through_args[num_pass_through_args] = NULL;
 566
 567   /* If -c option, determine if we must spawn a real shell, or if we can
 568      execute the command directly ourself.  */
 569   if (cmdline)
 570     {
 571       /* If no redirection or piping, and if program can be found, then
 572          run program directly.  Otherwise invoke a real shell. */
 573
 574       static char copout_chars[] = "|<>&";
 575
 576       if (strpbrk (cmdline, copout_chars) == NULL)
 577         {
 578           char *args;
 579
 580           /* The program name is the first token of cmdline.  Since
 581              filenames cannot legally contain embedded quotes, the value
 582              of escape_char doesn't matter.  */
 583           args = cmdline;
 584           if (!get_next_token (path, &args))
 585             fail ("error: no program name specified.\n");
 586
 587           canon_filename (path);
 588           progname = make_absolute (path);
 589
 590           /* If we found the program, run it directly (if not found it
 591              might be an internal shell command, so don't fail).  */
 592           if (progname != NULL)
 593             need_shell = FALSE;
 594         }
 595     }
 596
 597  pass_to_shell:
 598   if (need_shell)
 599     {
 600       char * p;
 601       int    extra_arg_space = 0;
 602       int    run_command_dot_com;
 603
 604       progname = getenv ("COMSPEC");
 605       if (!progname)
 606         fail ("error: COMSPEC is not set\n");
 607
 608       canon_filename (progname);
 609       progname = make_absolute (progname);
 610
 611       if (progname == NULL || strchr (progname, '\\') == NULL)
 612         fail ("error: the program %s could not be found.\n", getenv ("COMSPEC"));
 613
 614       /* Need to set environment size when running command.com.  */
 615       run_command_dot_com =
 616         (stricmp (strrchr (progname, '\\'), "command.com") == 0);
 617
 618       /* Work out how much extra space is required for
 619          pass_through_args.  */
 620       for (argv = pass_through_args; *argv != NULL; ++argv)
 621         /* We don't expect to have to quote switches.  */
 622         extra_arg_space += strlen (*argv) + 2;
 623
 624       if (cmdline)
 625         {
 626           char * buf;
 627
 628           /* Convert to syntax expected by cmd.exe/command.com for
 629              running non-interactively.  Always quote program name in
 630              case path contains spaces (fortunately it can't contain
 631              quotes, since they are illegal in path names).  */
 632
 633           buf = p = alloca (strlen (progname) + extra_arg_space +
 634                             strlen (cmdline) + 16);
 635
 636           /* Quote progname in case it contains spaces.  */
 637           p += wsprintf (p, "\"%s\"", progname);
 638
 639           /* Include pass_through_args verbatim; these are just switches
 640              so should not need quoting.  */
 641           for (argv = pass_through_args; *argv != NULL; ++argv)
 642             p += wsprintf (p, " %s", *argv);
 643
 644           if (run_command_dot_com)
 645             wsprintf(p, " /e:%d /c %s", envsize, cmdline);
 646           else
 647             wsprintf(p, " /c %s", cmdline);
 648           cmdline = buf;
 649         }
 650       else
 651         {
 652           if (run_command_dot_com)
 653             {
 654               /* Provide dir arg expected by command.com when first
 655                  started interactively (the "command search path").  To
 656                  avoid potential problems with spaces in command dir
 657                  (which cannot be quoted - command.com doesn't like it),
 658                  we always use the 8.3 form.  */
 659               GetShortPathName (progname, path, sizeof (path));
 660               p = strrchr (path, '\\');
 661               /* Trailing slash is acceptable, so always leave it.  */
 662               *(++p) = '\0';
 663             }
 664           else
 665             path[0] = '\0';
 666
 667           cmdline = p = alloca (strlen (progname) + extra_arg_space +
 668                                 strlen (path) + 13);
 669
 670           /* Quote progname in case it contains spaces.  */
 671           p += wsprintf (p, "\"%s\" %s", progname, path);
 672
 673           /* Include pass_through_args verbatim; these are just switches
 674              so should not need quoting.  */
 675           for (argv = pass_through_args; *argv != NULL; ++argv)
 676             p += wsprintf (p, " %s", *argv);
 677
 678           if (run_command_dot_com)
 679             wsprintf (p, " /e:%d", envsize);
 680         }
 681     }
 682
 683   if (!progname)
 684     fail ("Internal error: program name not defined\n");
 685
 686   if (!cmdline)
 687     cmdline = progname;
 688
 689   if (spawn (progname, cmdline, dir, &rc))
 690     return rc;
 691
 692   if (!need_shell)
 693     {
 694       need_shell = TRUE;
 695       goto pass_to_shell;
 696     }
 697
 698   fail ("Could not run %s\n", progname);
 699
 700   return 0;
 701 }
 702
 703 /* arch-tag: 88678d93-07ac-4e2f-ad63-d4a740ca69ac
 704    (do not change this comment) */