nt/cmdproxy.c

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