* textmodes/fill.el (fill-region): Don't fill past the end.
[emacs.git] / nt / cmdproxy.c
blobaae852bf4fa7b4af91751b68d83346687b81253f
1 /* Proxy shell designed for use with Emacs on Windows 95 and NT.
2 Copyright (C) 1997, 2001, 2002, 2003, 2004, 2005, 2006, 2007,
3 2008, 2009, 2010 Free Software Foundation, Inc.
5 Accepts subset of Unix sh(1) command-line options, for compatibility
6 with elisp code written for Unix. When possible, executes external
7 programs directly (a common use of /bin/sh by Emacs), otherwise
8 invokes the user-specified command processor to handle built-in shell
9 commands, batch files and interactive mode.
11 The main function is simply to process the "-c string" option in the
12 way /bin/sh does, since the standard Windows command shells use the
13 convention that everything after "/c" (the Windows equivalent of
14 "-c") is the input string.
16 This file is part of GNU Emacs.
18 GNU Emacs is free software: you can redistribute it and/or modify
19 it under the terms of the GNU General Public License as published by
20 the Free Software Foundation, either version 3 of the License, or
21 (at your option) any later version.
23 GNU Emacs is distributed in the hope that it will be useful,
24 but WITHOUT ANY WARRANTY; without even the implied warranty of
25 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
26 GNU General Public License for more details.
28 You should have received a copy of the GNU General Public License
29 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
31 #include <windows.h>
33 #include <stdarg.h> /* va_args */
34 #include <malloc.h> /* alloca */
35 #include <stdlib.h> /* getenv */
36 #include <string.h> /* strlen */
39 /******* Mock C library routines *********************************/
41 /* These routines are used primarily to minimize the executable size. */
43 #define stdin GetStdHandle (STD_INPUT_HANDLE)
44 #define stdout GetStdHandle (STD_OUTPUT_HANDLE)
45 #define stderr GetStdHandle (STD_ERROR_HANDLE)
47 int
48 vfprintf(HANDLE hnd, char * msg, va_list args)
50 DWORD bytes_written;
51 char buf[1024];
53 wvsprintf (buf, msg, args);
54 return WriteFile (hnd, buf, strlen (buf), &bytes_written, NULL);
57 int
58 fprintf(HANDLE hnd, char * msg, ...)
60 va_list args;
61 int rc;
63 va_start (args, msg);
64 rc = vfprintf (hnd, msg, args);
65 va_end (args);
67 return rc;
70 int
71 printf(char * msg, ...)
73 va_list args;
74 int rc;
76 va_start (args, msg);
77 rc = vfprintf (stdout, msg, args);
78 va_end (args);
80 return rc;
83 void
84 fail (char * msg, ...)
86 va_list args;
88 va_start (args, msg);
89 vfprintf (stderr, msg, args);
90 va_end (args);
92 exit (-1);
95 void
96 warn (char * msg, ...)
98 va_list args;
100 va_start (args, msg);
101 vfprintf (stderr, msg, args);
102 va_end (args);
105 /******************************************************************/
107 char *
108 canon_filename (char *fname)
110 char *p = fname;
112 while (*p)
114 if (*p == '/')
115 *p = '\\';
116 p++;
119 return fname;
122 char *
123 skip_space (char *str)
125 while (isspace (*str)) str++;
126 return str;
129 char *
130 skip_nonspace (char *str)
132 while (*str && !isspace (*str)) str++;
133 return str;
136 int escape_char = '\\';
138 /* Get next token from input, advancing pointer. */
140 get_next_token (char * buf, char ** pSrc)
142 char * p = *pSrc;
143 char * o = buf;
145 p = skip_space (p);
146 if (*p == '"')
148 int escape_char_run = 0;
150 /* Go through src until an ending quote is found, unescaping
151 quotes along the way. If the escape char is not quote, then do
152 special handling of multiple escape chars preceding a quote
153 char (ie. the reverse of what Emacs does to escape quotes). */
154 p++;
155 while (1)
157 if (p[0] == escape_char && escape_char != '"')
159 escape_char_run++;
160 p++;
161 continue;
163 else if (p[0] == '"')
165 while (escape_char_run > 1)
167 *o++ = escape_char;
168 escape_char_run -= 2;
171 if (escape_char_run > 0)
173 /* escaped quote */
174 *o++ = *p++;
175 escape_char_run = 0;
177 else if (p[1] == escape_char && escape_char == '"')
179 /* quote escaped by doubling */
180 *o++ = *p;
181 p += 2;
183 else
185 /* The ending quote. */
186 *o = '\0';
187 /* Leave input pointer after token. */
188 p++;
189 break;
192 else if (p[0] == '\0')
194 /* End of string, but no ending quote found. We might want to
195 flag this as an error, but for now will consider the end as
196 the end of the token. */
197 *o = '\0';
198 break;
200 else
202 *o++ = *p++;
206 else
208 /* Next token is delimited by whitespace. */
209 char * p1 = skip_nonspace (p);
210 memcpy (o, p, p1 - p);
211 o += (p1 - p);
212 *o = '\0';
213 p = p1;
216 *pSrc = p;
218 return o - buf;
221 /* Search for EXEC file in DIR. If EXEC does not have an extension,
222 DIR is searched for EXEC with the standard extensions appended. */
224 search_dir (char *dir, char *exec, int bufsize, char *buffer)
226 char *exts[] = {".bat", ".cmd", ".exe", ".com"};
227 int n_exts = sizeof (exts) / sizeof (char *);
228 char *dummy;
229 int i, rc;
231 /* Search the directory for the program. */
232 for (i = 0; i < n_exts; i++)
234 rc = SearchPath (dir, exec, exts[i], bufsize, buffer, &dummy);
235 if (rc > 0)
236 return rc;
239 return 0;
242 /* Return the absolute name of executable file PROG, including
243 any file extensions. If an absolute name for PROG cannot be found,
244 return NULL. */
245 char *
246 make_absolute (char *prog)
248 char absname[MAX_PATH];
249 char dir[MAX_PATH];
250 char curdir[MAX_PATH];
251 char *p, *fname;
252 char *path;
253 int i;
255 /* At least partial absolute path specified; search there. */
256 if ((isalpha (prog[0]) && prog[1] == ':') ||
257 (prog[0] == '\\'))
259 /* Split the directory from the filename. */
260 fname = strrchr (prog, '\\');
261 if (!fname)
262 /* Only a drive specifier is given. */
263 fname = prog + 2;
264 strncpy (dir, prog, fname - prog);
265 dir[fname - prog] = '\0';
267 /* Search the directory for the program. */
268 if (search_dir (dir, prog, MAX_PATH, absname) > 0)
269 return strdup (absname);
270 else
271 return NULL;
274 if (GetCurrentDirectory (MAX_PATH, curdir) <= 0)
275 return NULL;
277 /* Relative path; search in current dir. */
278 if (strpbrk (prog, "\\"))
280 if (search_dir (curdir, prog, MAX_PATH, absname) > 0)
281 return strdup (absname);
282 else
283 return NULL;
286 /* Just filename; search current directory then PATH. */
287 path = alloca (strlen (getenv ("PATH")) + strlen (curdir) + 2);
288 strcpy (path, curdir);
289 strcat (path, ";");
290 strcat (path, getenv ("PATH"));
292 while (*path)
294 /* Get next directory from path. */
295 p = path;
296 while (*p && *p != ';') p++;
297 strncpy (dir, path, p - path);
298 dir[p - path] = '\0';
300 /* Search the directory for the program. */
301 if (search_dir (dir, prog, MAX_PATH, absname) > 0)
302 return strdup (absname);
304 /* Move to the next directory. */
305 path = p + 1;
308 return NULL;
311 /*****************************************************************/
313 #if 0
314 char ** _argv;
315 int _argc;
317 /* Parse commandline into argv array, allowing proper quoting of args. */
318 void
319 setup_argv (void)
321 char * cmdline = GetCommandLine ();
322 int arg_bytes = 0;
326 #endif
328 /* Information about child proc is global, to allow for automatic
329 termination when interrupted. At the moment, only one child process
330 can be running at any one time. */
332 PROCESS_INFORMATION child;
333 int interactive = TRUE;
335 BOOL
336 console_event_handler (DWORD event)
338 switch (event)
340 case CTRL_C_EVENT:
341 case CTRL_BREAK_EVENT:
342 if (!interactive)
344 /* Both command.com and cmd.exe have the annoying behavior of
345 prompting "Terminate batch job (y/n)?" when interrupted
346 while running a batch file, even if running in
347 non-interactive (-c) mode. Try to make up for this
348 deficiency by forcibly terminating the subprocess if
349 running non-interactively. */
350 if (child.hProcess &&
351 WaitForSingleObject (child.hProcess, 500) != WAIT_OBJECT_0)
352 TerminateProcess (child.hProcess, 0);
353 exit (STATUS_CONTROL_C_EXIT);
355 break;
357 #if 0
358 default:
359 /* CLOSE, LOGOFF and SHUTDOWN events - actually we don't get these
360 under Windows 95. */
361 fail ("cmdproxy: received %d event\n", event);
362 if (child.hProcess)
363 TerminateProcess (child.hProcess, 0);
364 #endif
366 return TRUE;
369 /* Change from normal usage; return value indicates whether spawn
370 succeeded or failed - program return code is returned separately. */
372 spawn (char * progname, char * cmdline, char * dir, int * retcode)
374 BOOL success = FALSE;
375 SECURITY_ATTRIBUTES sec_attrs;
376 STARTUPINFO start;
377 /* In theory, passing NULL for the environment block to CreateProcess
378 is the same as passing the value of GetEnvironmentStrings, but
379 doing this explicitly seems to cure problems running DOS programs
380 in some cases. */
381 char * envblock = GetEnvironmentStrings ();
383 sec_attrs.nLength = sizeof (sec_attrs);
384 sec_attrs.lpSecurityDescriptor = NULL;
385 sec_attrs.bInheritHandle = FALSE;
387 memset (&start, 0, sizeof (start));
388 start.cb = sizeof (start);
390 if (CreateProcess (progname, cmdline, &sec_attrs, NULL, TRUE,
391 0, envblock, dir, &start, &child))
393 success = TRUE;
394 /* wait for completion and pass on return code */
395 WaitForSingleObject (child.hProcess, INFINITE);
396 if (retcode)
397 GetExitCodeProcess (child.hProcess, (DWORD *)retcode);
398 CloseHandle (child.hThread);
399 CloseHandle (child.hProcess);
400 child.hProcess = NULL;
403 FreeEnvironmentStrings (envblock);
405 return success;
408 /* Return size of current environment block. */
410 get_env_size ()
412 char * start = GetEnvironmentStrings ();
413 char * tmp = start;
415 while (tmp[0] || tmp[1])
416 ++tmp;
417 FreeEnvironmentStrings (start);
418 return tmp + 2 - start;
421 /******* Main program ********************************************/
424 main (int argc, char ** argv)
426 int rc;
427 int need_shell;
428 char * cmdline;
429 char * progname;
430 int envsize;
431 char **pass_through_args;
432 int num_pass_through_args;
433 char modname[MAX_PATH];
434 char path[MAX_PATH];
435 char dir[MAX_PATH];
438 interactive = TRUE;
440 SetConsoleCtrlHandler ((PHANDLER_ROUTINE) console_event_handler, TRUE);
442 if (!GetCurrentDirectory (sizeof (dir), dir))
443 fail ("error: GetCurrentDirectory failed\n");
445 /* We serve double duty: we can be called either as a proxy for the
446 real shell (that is, because we are defined to be the user shell),
447 or in our role as a helper application for running DOS programs.
448 In the former case, we interpret the command line options as if we
449 were a Unix shell, but in the latter case we simply pass our
450 command line to CreateProcess. We know which case we are dealing
451 with by whether argv[0] refers to ourself or to some other program.
452 (This relies on an arcane feature of CreateProcess, where we can
453 specify cmdproxy as the module to run, but specify a different
454 program in the command line - the MSVC startup code sets argv[0]
455 from the command line.) */
457 if (!GetModuleFileName (NULL, modname, sizeof (modname)))
458 fail ("error: GetModuleFileName failed\n");
460 /* Change directory to location of .exe so startup directory can be
461 deleted. */
462 progname = strrchr (modname, '\\');
463 *progname = '\0';
464 SetCurrentDirectory (modname);
465 *progname = '\\';
467 /* Due to problems with interaction between API functions that use "OEM"
468 codepage vs API functions that use the "ANSI" codepage, we need to
469 make things consistent by choosing one and sticking with it. */
470 SetConsoleCP (GetACP());
471 SetConsoleOutputCP (GetACP());
473 /* Although Emacs always sets argv[0] to an absolute pathname, we
474 might get run in other ways as well, so convert argv[0] to an
475 absolute name before comparing to the module name. Don't get
476 caught out by mixed short and long names. */
477 GetShortPathName (modname, modname, sizeof (modname));
478 path[0] = '\0';
479 if (!SearchPath (NULL, argv[0], ".exe", sizeof (path), path, &progname)
480 || !GetShortPathName (path, path, sizeof (path))
481 || stricmp (modname, path) != 0)
483 /* We are being used as a helper to run a DOS app; just pass
484 command line to DOS app without change. */
485 /* TODO: fill in progname. */
486 if (spawn (NULL, GetCommandLine (), dir, &rc))
487 return rc;
488 fail ("Could not run %s\n", GetCommandLine ());
491 /* Process command line. If running interactively (-c or /c not
492 specified) then spawn a real command shell, passing it the command
493 line arguments.
495 If not running interactively, then attempt to execute the specified
496 command directly. If necessary, spawn a real shell to execute the
497 command.
501 progname = NULL;
502 cmdline = NULL;
503 /* If no args, spawn real shell for interactive use. */
504 need_shell = TRUE;
505 interactive = TRUE;
506 /* Ask command.com to create an environment block with a reasonable
507 amount of free space. */
508 envsize = get_env_size () + 300;
509 pass_through_args = (char **) alloca (argc * sizeof(char *));
510 num_pass_through_args = 0;
512 while (--argc > 0)
514 ++argv;
515 /* Act on switches we recognize (mostly single letter switches,
516 except for -e); all unrecognized switches and extra args are
517 passed on to real shell if used (only really of benefit for
518 interactive use, but allow for batch use as well). Accept / as
519 switch char for compatibility with cmd.exe. */
520 if (((*argv)[0] == '-' || (*argv)[0] == '/') && (*argv)[1] != '\0')
522 if (((*argv)[1] == 'c' || (*argv)[1] == 'C') && ((*argv)[2] == '\0'))
524 if (--argc == 0)
525 fail ("error: expecting arg for %s\n", *argv);
526 cmdline = *(++argv);
527 interactive = FALSE;
529 else if (((*argv)[1] == 'i' || (*argv)[1] == 'I') && ((*argv)[2] == '\0'))
531 if (cmdline)
532 warn ("warning: %s ignored because of -c\n", *argv);
534 else if (((*argv)[1] == 'e' || (*argv)[1] == 'E') && ((*argv)[2] == ':'))
536 int requested_envsize = atoi (*argv + 3);
537 /* Enforce a reasonable minimum size, as above. */
538 if (requested_envsize > envsize)
539 envsize = requested_envsize;
540 /* For sanity, enforce a reasonable maximum. */
541 if (envsize > 32768)
542 envsize = 32768;
544 else
546 /* warn ("warning: unknown option %s ignored", *argv); */
547 pass_through_args[num_pass_through_args++] = *argv;
550 else
551 break;
554 #if 0
555 /* I think this is probably not useful - cmd.exe ignores extra
556 (non-switch) args in interactive mode, and they cannot be passed on
557 when -c was given. */
559 /* Collect any remaining args after (initial) switches. */
560 while (argc-- > 0)
562 pass_through_args[num_pass_through_args++] = *argv++;
564 #else
565 /* Probably a mistake for there to be extra args; not fatal. */
566 if (argc > 0)
567 warn ("warning: extra args ignored after '%s'\n", argv[-1]);
568 #endif
570 pass_through_args[num_pass_through_args] = NULL;
572 /* If -c option, determine if we must spawn a real shell, or if we can
573 execute the command directly ourself. */
574 if (cmdline)
576 /* If no redirection or piping, and if program can be found, then
577 run program directly. Otherwise invoke a real shell. */
579 static char copout_chars[] = "|<>&";
581 if (strpbrk (cmdline, copout_chars) == NULL)
583 char *args;
585 /* The program name is the first token of cmdline. Since
586 filenames cannot legally contain embedded quotes, the value
587 of escape_char doesn't matter. */
588 args = cmdline;
589 if (!get_next_token (path, &args))
590 fail ("error: no program name specified.\n");
592 canon_filename (path);
593 progname = make_absolute (path);
595 /* If we found the program, run it directly (if not found it
596 might be an internal shell command, so don't fail). */
597 if (progname != NULL)
598 need_shell = FALSE;
602 pass_to_shell:
603 if (need_shell)
605 char * p;
606 int extra_arg_space = 0;
607 int run_command_dot_com;
609 progname = getenv ("COMSPEC");
610 if (!progname)
611 fail ("error: COMSPEC is not set\n");
613 canon_filename (progname);
614 progname = make_absolute (progname);
616 if (progname == NULL || strchr (progname, '\\') == NULL)
617 fail ("error: the program %s could not be found.\n", getenv ("COMSPEC"));
619 /* Need to set environment size when running command.com. */
620 run_command_dot_com =
621 (stricmp (strrchr (progname, '\\'), "command.com") == 0);
623 /* Work out how much extra space is required for
624 pass_through_args. */
625 for (argv = pass_through_args; *argv != NULL; ++argv)
626 /* We don't expect to have to quote switches. */
627 extra_arg_space += strlen (*argv) + 2;
629 if (cmdline)
631 char * buf;
633 /* Convert to syntax expected by cmd.exe/command.com for
634 running non-interactively. Always quote program name in
635 case path contains spaces (fortunately it can't contain
636 quotes, since they are illegal in path names). */
638 buf = p = alloca (strlen (progname) + extra_arg_space +
639 strlen (cmdline) + 16);
641 /* Quote progname in case it contains spaces. */
642 p += wsprintf (p, "\"%s\"", progname);
644 /* Include pass_through_args verbatim; these are just switches
645 so should not need quoting. */
646 for (argv = pass_through_args; *argv != NULL; ++argv)
647 p += wsprintf (p, " %s", *argv);
649 if (run_command_dot_com)
650 wsprintf(p, " /e:%d /c %s", envsize, cmdline);
651 else
652 wsprintf(p, " /c %s", cmdline);
653 cmdline = buf;
655 else
657 if (run_command_dot_com)
659 /* Provide dir arg expected by command.com when first
660 started interactively (the "command search path"). To
661 avoid potential problems with spaces in command dir
662 (which cannot be quoted - command.com doesn't like it),
663 we always use the 8.3 form. */
664 GetShortPathName (progname, path, sizeof (path));
665 p = strrchr (path, '\\');
666 /* Trailing slash is acceptable, so always leave it. */
667 *(++p) = '\0';
669 else
670 path[0] = '\0';
672 cmdline = p = alloca (strlen (progname) + extra_arg_space +
673 strlen (path) + 13);
675 /* Quote progname in case it contains spaces. */
676 p += wsprintf (p, "\"%s\" %s", progname, path);
678 /* Include pass_through_args verbatim; these are just switches
679 so should not need quoting. */
680 for (argv = pass_through_args; *argv != NULL; ++argv)
681 p += wsprintf (p, " %s", *argv);
683 if (run_command_dot_com)
684 wsprintf (p, " /e:%d", envsize);
688 if (!progname)
689 fail ("Internal error: program name not defined\n");
691 if (!cmdline)
692 cmdline = progname;
694 if (spawn (progname, cmdline, dir, &rc))
695 return rc;
697 if (!need_shell)
699 need_shell = TRUE;
700 goto pass_to_shell;
703 fail ("Could not run %s\n", progname);
705 return 0;
708 /* arch-tag: 88678d93-07ac-4e2f-ad63-d4a740ca69ac
709 (do not change this comment) */