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 /* Search for EXEC file in DIR.  If EXEC does not have an extension,
 224    DIR is searched for EXEC with the standard extensions appended.  */
 225 int
 226 search_dir (const char *dir, const char *exec, int bufsize, char *buffer)
 227 {
 228   const char *exts[] = {".bat", ".cmd", ".exe", ".com"};
 229   int n_exts = sizeof (exts) / sizeof (char *);
 230   char *dummy;
 231   int i, rc;
 232
 233   /* Search the directory for the program.  */
 234   for (i = 0; i < n_exts; i++)
 235     {
 236       rc = SearchPath (dir, exec, exts[i], bufsize, buffer, &dummy);
 237       if (rc > 0)
 238         return rc;
 239     }
 240
 241   return 0;
 242 }
 243
 244 /* Return the absolute name of executable file PROG, including
 245    any file extensions.  If an absolute name for PROG cannot be found,
 246    return NULL.  */
 247 char *
 248 make_absolute (const char *prog)
 249 {
 250   char absname[MAX_PATH];
 251   char dir[MAX_PATH];
 252   char curdir[MAX_PATH];
 253   char *p, *path;
 254   const char *fname;
 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 /* Try to decode the given command line the way cmd would do it.  On
 313    success, return 1 with cmdline dequoted.  Otherwise, when we've
 314    found constructs only cmd can properly interpret, return 0 and
 315    leave cmdline unchanged.  */
 316 int
 317 try_dequote_cmdline (char* cmdline)
 318 {
 319   /* Dequoting can only subtract characters, so the length of the
 320      original command line is a bound on the amount of scratch space
 321      we need.  This length, in turn, is bounded by the 32k
 322      CreateProcess limit.  */
 323   char * old_pos = cmdline;
 324   char * new_cmdline = alloca (strlen(cmdline));
 325   char * new_pos = new_cmdline;
 326   char c;
 327
 328   enum {
 329     NORMAL,
 330     AFTER_CARET,
 331     INSIDE_QUOTE
 332   } state = NORMAL;
 333
 334   while ((c = *old_pos++))
 335     {
 336       switch (state)
 337         {
 338         case NORMAL:
 339           switch(c)
 340             {
 341             case '"':
 342               *new_pos++ = c;
 343               state = INSIDE_QUOTE;
 344               break;
 345             case '^':
 346               state = AFTER_CARET;
 347               break;
 348             case '<': case '>':
 349             case '&': case '|':
 350             case '(': case ')':
 351             case '%': case '!':
 352               /* We saw an unquoted shell metacharacter and we don't
 353                  understand it. Bail out.  */
 354               return 0;
 355             default:
 356               *new_pos++ = c;
 357               break;
 358             }
 359           break;
 360         case AFTER_CARET:
 361           *new_pos++ = c;
 362           state = NORMAL;
 363           break;
 364         case INSIDE_QUOTE:
 365           switch (c)
 366             {
 367             case '"':
 368               *new_pos++ = c;
 369               state = NORMAL;
 370               break;
 371             case '%':
 372             case '!':
 373               /* Variable substitution inside quote.  Bail out.  */
 374               return 0;
 375             default:
 376               *new_pos++ = c;
 377               break;
 378             }
 379           break;
 380         }
 381     }
 382
 383   /* We were able to dequote the entire string.  Copy our scratch
 384      buffer on top of the original buffer and return success.  */
 385   memcpy (cmdline, new_cmdline, new_pos - new_cmdline);
 386   cmdline[new_pos - new_cmdline] = '\0';
 387   return 1;
 388 }
 389
 390 /*****************************************************************/
 391
 392 #if 0
 393 char ** _argv;
 394 int     _argc;
 395
 396 /* Parse commandline into argv array, allowing proper quoting of args.  */
 397 void
 398 setup_argv (void)
 399 {
 400   char * cmdline = GetCommandLine ();
 401   int arg_bytes = 0;
 402
 403
 404 }
 405 #endif
 406
 407 /* Information about child proc is global, to allow for automatic
 408    termination when interrupted.  At the moment, only one child process
 409    can be running at any one time.  */
 410
 411 PROCESS_INFORMATION child;
 412 int interactive = TRUE;
 413
 414 BOOL
 415 console_event_handler (DWORD event)
 416 {
 417   switch (event)
 418     {
 419     case CTRL_C_EVENT:
 420     case CTRL_BREAK_EVENT:
 421       if (!interactive)
 422         {
 423           /* Both command.com and cmd.exe have the annoying behavior of
 424              prompting "Terminate batch job (y/n)?" when interrupted
 425              while running a batch file, even if running in
 426              non-interactive (-c) mode.  Try to make up for this
 427              deficiency by forcibly terminating the subprocess if
 428              running non-interactively.  */
 429           if (child.hProcess &&
 430               WaitForSingleObject (child.hProcess, 500) != WAIT_OBJECT_0)
 431             TerminateProcess (child.hProcess, 0);
 432           exit (STATUS_CONTROL_C_EXIT);
 433         }
 434       break;
 435
 436 #if 0
 437     default:
 438       /* CLOSE, LOGOFF and SHUTDOWN events - actually we don't get these
 439          under Windows 95.  */
 440       fail ("cmdproxy: received %d event\n", event);
 441       if (child.hProcess)
 442         TerminateProcess (child.hProcess, 0);
 443 #endif
 444     }
 445   return TRUE;
 446 }
 447
 448 /* Change from normal usage; return value indicates whether spawn
 449    succeeded or failed - program return code is returned separately.  */
 450 int
 451 spawn (const char *progname, char *cmdline, const char *dir, int *retcode)
 452 {
 453   BOOL success = FALSE;
 454   SECURITY_ATTRIBUTES sec_attrs;
 455   STARTUPINFO start;
 456   /* In theory, passing NULL for the environment block to CreateProcess
 457      is the same as passing the value of GetEnvironmentStrings, but
 458      doing this explicitly seems to cure problems running DOS programs
 459      in some cases.  */
 460   char * envblock = GetEnvironmentStrings ();
 461
 462   sec_attrs.nLength = sizeof (sec_attrs);
 463   sec_attrs.lpSecurityDescriptor = NULL;
 464   sec_attrs.bInheritHandle = FALSE;
 465
 466   memset (&start, 0, sizeof (start));
 467   start.cb = sizeof (start);
 468
 469   if (CreateProcess (progname, cmdline, &sec_attrs, NULL, TRUE,
 470                      0, envblock, dir, &start, &child))
 471   {
 472     success = TRUE;
 473     /* wait for completion and pass on return code */
 474     WaitForSingleObject (child.hProcess, INFINITE);
 475     if (retcode)
 476       GetExitCodeProcess (child.hProcess, (DWORD *)retcode);
 477     CloseHandle (child.hThread);
 478     CloseHandle (child.hProcess);
 479     child.hProcess = NULL;
 480   }
 481
 482   FreeEnvironmentStrings (envblock);
 483
 484   return success;
 485 }
 486
 487 /* Return size of current environment block.  */
 488 int
 489 get_env_size (void)
 490 {
 491   char * start = GetEnvironmentStrings ();
 492   char * tmp = start;
 493
 494   while (tmp[0] || tmp[1])
 495     ++tmp;
 496   FreeEnvironmentStrings (start);
 497   return  tmp + 2 - start;
 498 }
 499
 500 /*******  Main program  ********************************************/
 501
 502 int
 503 main (int argc, char ** argv)
 504 {
 505   int rc;
 506   int need_shell;
 507   char * cmdline;
 508   char * progname;
 509   int envsize;
 510   char **pass_through_args;
 511   int num_pass_through_args;
 512   char modname[MAX_PATH];
 513   char path[MAX_PATH];
 514   char dir[MAX_PATH];
 515   int status;
 516
 517   interactive = TRUE;
 518
 519   SetConsoleCtrlHandler ((PHANDLER_ROUTINE) console_event_handler, TRUE);
 520
 521   if (!GetCurrentDirectory (sizeof (dir), dir))
 522     fail ("error: GetCurrentDirectory failed\n");
 523
 524   /* We serve double duty: we can be called either as a proxy for the
 525      real shell (that is, because we are defined to be the user shell),
 526      or in our role as a helper application for running DOS programs.
 527      In the former case, we interpret the command line options as if we
 528      were a Unix shell, but in the latter case we simply pass our
 529      command line to CreateProcess.  We know which case we are dealing
 530      with by whether argv[0] refers to ourself or to some other program.
 531      (This relies on an arcane feature of CreateProcess, where we can
 532      specify cmdproxy as the module to run, but specify a different
 533      program in the command line - the MSVC startup code sets argv[0]
 534      from the command line.)  */
 535
 536   if (!GetModuleFileName (NULL, modname, sizeof (modname)))
 537     fail ("error: GetModuleFileName failed\n");
 538
 539   /* Change directory to location of .exe so startup directory can be
 540      deleted.  */
 541   progname = strrchr (modname, '\\');
 542   *progname = '\0';
 543   SetCurrentDirectory (modname);
 544   *progname = '\\';
 545
 546   /* Due to problems with interaction between API functions that use "OEM"
 547      codepage vs API functions that use the "ANSI" codepage, we need to
 548      make things consistent by choosing one and sticking with it.  */
 549   SetConsoleCP (GetACP ());
 550   SetConsoleOutputCP (GetACP ());
 551
 552   /* Although Emacs always sets argv[0] to an absolute pathname, we
 553      might get run in other ways as well, so convert argv[0] to an
 554      absolute name before comparing to the module name.  */
 555   path[0] = '\0';
 556   /* The call to SearchPath will find argv[0] in the current
 557      directory, append ".exe" to it if needed, and also canonicalize
 558      it, to resolve references to ".", "..", etc.  */
 559   status = SearchPath (NULL, argv[0], ".exe", sizeof (path), path,
 560                                   &progname);
 561   if (!(status > 0 && stricmp (modname, path) == 0))
 562     {
 563       if (status <= 0)
 564         {
 565           char *s;
 566
 567           /* Make sure we have argv[0] in path[], as the failed
 568              SearchPath might not have copied it there.  */
 569           strcpy (path, argv[0]);
 570           /* argv[0] could include forward slashes; convert them all
 571              to backslashes, for strrchr calls below to DTRT.  */
 572           for (s = path; *s; s++)
 573             if (*s == '/')
 574               *s = '\\';
 575         }
 576       /* Perhaps MODNAME and PATH use mixed short and long file names.  */
 577       if (!(GetShortPathName (modname, modname, sizeof (modname))
 578             && GetShortPathName (path, path, sizeof (path))
 579             && stricmp (modname, path) == 0))
 580         {
 581           /* Sometimes GetShortPathName fails because one or more
 582              directories leading to argv[0] have issues with access
 583              rights.  In that case, at least we can compare the
 584              basenames.  Note: this disregards the improbable case of
 585              invoking a program of the same name from another
 586              directory, since the chances of that other executable to
 587              be both our namesake and a 16-bit DOS application are nil.  */
 588           char *p = strrchr (path, '\\');
 589           char *q = strrchr (modname, '\\');
 590           char *pdot, *qdot;
 591
 592           if (!p)
 593             p = strchr (path, ':');
 594           if (!p)
 595             p = path;
 596           else
 597             p++;
 598           if (!q)
 599             q = strchr (modname, ':');
 600           if (!q)
 601             q = modname;
 602           else
 603             q++;
 604
 605           pdot = strrchr (p, '.');
 606           if (!pdot || stricmp (pdot, ".exe") != 0)
 607             pdot = p + strlen (p);
 608           qdot = strrchr (q, '.');
 609           if (!qdot || stricmp (qdot, ".exe") != 0)
 610             qdot = q + strlen (q);
 611           if (pdot - p != qdot - q || strnicmp (p, q, pdot - p) != 0)
 612             {
 613               /* We are being used as a helper to run a DOS app; just
 614                  pass command line to DOS app without change.  */
 615               /* TODO: fill in progname.  */
 616               if (spawn (NULL, GetCommandLine (), dir, &rc))
 617                 return rc;
 618               fail ("Could not run %s\n", GetCommandLine ());
 619             }
 620         }
 621     }
 622
 623   /* Process command line.  If running interactively (-c or /c not
 624      specified) then spawn a real command shell, passing it the command
 625      line arguments.
 626
 627      If not running interactively, then attempt to execute the specified
 628      command directly.  If necessary, spawn a real shell to execute the
 629      command.
 630
 631   */
 632
 633   progname = NULL;
 634   cmdline = NULL;
 635   /* If no args, spawn real shell for interactive use.  */
 636   need_shell = TRUE;
 637   interactive = TRUE;
 638   /* Ask command.com to create an environment block with a reasonable
 639      amount of free space.  */
 640   envsize = get_env_size () + 300;
 641   pass_through_args = (char **) alloca (argc * sizeof (char *));
 642   num_pass_through_args = 0;
 643
 644   while (--argc > 0)
 645     {
 646       ++argv;
 647       /* Act on switches we recognize (mostly single letter switches,
 648          except for -e); all unrecognized switches and extra args are
 649          passed on to real shell if used (only really of benefit for
 650          interactive use, but allow for batch use as well).  Accept / as
 651          switch char for compatibility with cmd.exe.  */
 652       if (((*argv)[0] == '-' || (*argv)[0] == '/') && (*argv)[1] != '\0')
 653         {
 654           if (((*argv)[1] == 'c' || (*argv)[1] == 'C') && ((*argv)[2] == '\0'))
 655             {
 656               if (--argc == 0)
 657                 fail ("error: expecting arg for %s\n", *argv);
 658               cmdline = *(++argv);
 659               interactive = FALSE;
 660             }
 661           else if (((*argv)[1] == 'i' || (*argv)[1] == 'I') && ((*argv)[2] == '\0'))
 662             {
 663               if (cmdline)
 664                 warn ("warning: %s ignored because of -c\n", *argv);
 665             }
 666           else if (((*argv)[1] == 'e' || (*argv)[1] == 'E') && ((*argv)[2] == ':'))
 667             {
 668               int requested_envsize = atoi (*argv + 3);
 669               /* Enforce a reasonable minimum size, as above.  */
 670               if (requested_envsize > envsize)
 671                 envsize = requested_envsize;
 672               /* For sanity, enforce a reasonable maximum.  */
 673               if (envsize > 32768)
 674                 envsize = 32768;
 675             }
 676           else
 677             {
 678               /* warn ("warning: unknown option %s ignored", *argv); */
 679               pass_through_args[num_pass_through_args++] = *argv;
 680             }
 681         }
 682       else
 683         break;
 684     }
 685
 686 #if 0
 687   /* I think this is probably not useful - cmd.exe ignores extra
 688      (non-switch) args in interactive mode, and they cannot be passed on
 689      when -c was given.  */
 690
 691   /* Collect any remaining args after (initial) switches.  */
 692   while (argc-- > 0)
 693     {
 694       pass_through_args[num_pass_through_args++] = *argv++;
 695     }
 696 #else
 697   /* Probably a mistake for there to be extra args; not fatal.  */
 698   if (argc > 0)
 699     warn ("warning: extra args ignored after '%s'\n", argv[-1]);
 700 #endif
 701
 702   pass_through_args[num_pass_through_args] = NULL;
 703
 704   /* If -c option, determine if we must spawn a real shell, or if we can
 705      execute the command directly ourself.  */
 706   if (cmdline)
 707     {
 708       const char *args;
 709
 710       /* The program name is the first token of cmdline.  Since
 711          filenames cannot legally contain embedded quotes, the value
 712          of escape_char doesn't matter.  */
 713       args = cmdline;
 714       if (!get_next_token (path, &args))
 715         fail ("error: no program name specified.\n");
 716
 717       canon_filename (path);
 718       progname = make_absolute (path);
 719
 720       /* If we found the program and the rest of the command line does
 721          not contain unquoted shell metacharacters, run the program
 722          directly (if not found it might be an internal shell command,
 723          so don't fail).  */
 724       if (progname != NULL && try_dequote_cmdline (cmdline))
 725         need_shell = FALSE;
 726       else
 727         progname = NULL;
 728     }
 729
 730  pass_to_shell:
 731   if (need_shell)
 732     {
 733       char * p;
 734       int    extra_arg_space = 0;
 735       int    maxlen, remlen;
 736       int    run_command_dot_com;
 737
 738       progname = getenv ("COMSPEC");
 739       if (!progname)
 740         fail ("error: COMSPEC is not set\n");
 741
 742       canon_filename (progname);
 743       progname = make_absolute (progname);
 744
 745       if (progname == NULL || strchr (progname, '\\') == NULL)
 746         fail ("error: the program %s could not be found.\n", getenv ("COMSPEC"));
 747
 748       /* Need to set environment size when running command.com.  */
 749       run_command_dot_com =
 750         (stricmp (strrchr (progname, '\\'), "command.com") == 0);
 751
 752       /* Work out how much extra space is required for
 753          pass_through_args.  */
 754       for (argv = pass_through_args; *argv != NULL; ++argv)
 755         /* We don't expect to have to quote switches.  */
 756         extra_arg_space += strlen (*argv) + 2;
 757
 758       if (cmdline)
 759         {
 760           char * buf;
 761
 762           /* Convert to syntax expected by cmd.exe/command.com for
 763              running non-interactively.  Always quote program name in
 764              case path contains spaces (fortunately it can't contain
 765              quotes, since they are illegal in path names).  */
 766
 767           remlen = maxlen =
 768             strlen (progname) + extra_arg_space + strlen (cmdline) + 16;
 769           buf = p = alloca (maxlen + 1);
 770
 771           /* Quote progname in case it contains spaces.  */
 772           p += _snprintf (p, remlen, "\"%s\"", progname);
 773           remlen = maxlen - (p - buf);
 774
 775           /* Include pass_through_args verbatim; these are just switches
 776              so should not need quoting.  */
 777           for (argv = pass_through_args; *argv != NULL; ++argv)
 778             {
 779               p += _snprintf (p, remlen, " %s", *argv);
 780               remlen = maxlen - (p - buf);
 781             }
 782
 783           if (run_command_dot_com)
 784             _snprintf (p, remlen, " /e:%d /c %s", envsize, cmdline);
 785           else
 786             _snprintf (p, remlen, " /c %s", cmdline);
 787           cmdline = buf;
 788         }
 789       else
 790         {
 791           if (run_command_dot_com)
 792             {
 793               /* Provide dir arg expected by command.com when first
 794                  started interactively (the "command search path").  To
 795                  avoid potential problems with spaces in command dir
 796                  (which cannot be quoted - command.com doesn't like it),
 797                  we always use the 8.3 form.  */
 798               GetShortPathName (progname, path, sizeof (path));
 799               p = strrchr (path, '\\');
 800               /* Trailing slash is acceptable, so always leave it.  */
 801               *(++p) = '\0';
 802             }
 803           else
 804             path[0] = '\0';
 805
 806           remlen = maxlen =
 807             strlen (progname) + extra_arg_space + strlen (path) + 13;
 808           cmdline = p = alloca (maxlen + 1);
 809
 810           /* Quote progname in case it contains spaces.  */
 811           p += _snprintf (p, remlen, "\"%s\" %s", progname, path);
 812           remlen = maxlen - (p - cmdline);
 813
 814           /* Include pass_through_args verbatim; these are just switches
 815              so should not need quoting.  */
 816           for (argv = pass_through_args; *argv != NULL; ++argv)
 817             {
 818               p += _snprintf (p, remlen, " %s", *argv);
 819               remlen = maxlen - (p - cmdline);
 820             }
 821
 822           if (run_command_dot_com)
 823             _snprintf (p, remlen, " /e:%d", envsize);
 824         }
 825     }
 826
 827   if (!progname)
 828     fail ("Internal error: program name not defined\n");
 829
 830   if (!cmdline)
 831     cmdline = progname;
 832
 833   if (spawn (progname, cmdline, dir, &rc))
 834     return rc;
 835
 836   if (!need_shell)
 837     {
 838       need_shell = TRUE;
 839       goto pass_to_shell;
 840     }
 841
 842   fail ("Could not run %s\n", progname);
 843
 844   return 0;
 845 }