nt/cmdproxy.c

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