nt/cmdproxy.c

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