*** empty log message ***
[emacs.git] / nt / cmdproxy.c
blob52760402f1b6ae19fbdb468b4bcf320f7489626f
1 /* Proxy shell designed for use with Emacs on Windows 95 and NT.
2 Copyright (C) 1997 Free Software Foundation, Inc.
4 Accepts subset of Unix sh(1) command-line options, for compatability
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.
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.
15 This file is part of GNU Emacs.
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 2, or (at your option)
20 any later version.
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.
27 You should have received a copy of the GNU General Public License
28 along with GNU Emacs; see the file COPYING. If not, write to
29 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
30 Boston, MA 02111-1307, USA. */
32 #include <windows.h>
34 #include <stdarg.h> /* va_args */
35 #include <malloc.h> /* alloca */
36 #include <stdlib.h> /* getenv */
37 #include <string.h> /* strlen */
40 /******* Mock C library routines *********************************/
42 /* These routines are used primarily to minimize the executable size. */
44 #define stdin GetStdHandle (STD_INPUT_HANDLE)
45 #define stdout GetStdHandle (STD_OUTPUT_HANDLE)
46 #define stderr GetStdHandle (STD_ERROR_HANDLE)
48 int
49 vfprintf(HANDLE hnd, char * msg, va_list args)
51 DWORD bytes_written;
52 char buf[1024];
54 wvsprintf (buf, msg, args);
55 return WriteFile (hnd, buf, strlen (buf), &bytes_written, NULL);
58 int
59 fprintf(HANDLE hnd, char * msg, ...)
61 va_list args;
62 int rc;
64 va_start (args, msg);
65 rc = vfprintf (hnd, msg, args);
66 va_end (args);
68 return rc;
71 int
72 printf(char * msg, ...)
74 va_list args;
75 int rc;
77 va_start (args, msg);
78 rc = vfprintf (stdout, msg, args);
79 va_end (args);
81 return rc;
84 void
85 fail (char * msg, ...)
87 va_list args;
89 va_start (args, msg);
90 vfprintf (stderr, msg, args);
91 va_end (args);
93 exit (-1);
96 void
97 warn (char * msg, ...)
99 va_list args;
101 va_start (args, msg);
102 vfprintf (stderr, msg, args);
103 va_end (args);
106 /******************************************************************/
108 char *
109 canon_filename (char *fname)
111 char *p = fname;
113 while (*p)
115 if (*p == '/')
116 *p = '\\';
117 p++;
120 return fname;
123 char *
124 skip_space (char *str)
126 while (isspace (*str)) str++;
127 return str;
130 char *
131 skip_nonspace (char *str)
133 while (*str && !isspace (*str)) str++;
134 return str;
137 int escape_char = '\\';
139 /* Get next token from input, advancing pointer. */
141 get_next_token (char * buf, char ** pSrc)
143 char * p = *pSrc;
144 char * o = buf;
146 p = skip_space (p);
147 if (*p == '"')
149 int escape_char_run = 0;
151 /* Go through src until an ending quote is found, unescaping
152 quotes along the way. If the escape char is not quote, then do
153 special handling of multiple escape chars preceding a quote
154 char (ie. the reverse of what Emacs does to escape quotes). */
155 p++;
156 while (1)
158 if (p[0] == escape_char && escape_char != '"')
160 escape_char_run++;
161 p++;
162 continue;
164 else if (p[0] == '"')
166 while (escape_char_run > 1)
168 *o++ = escape_char;
169 escape_char_run -= 2;
172 if (escape_char_run > 0)
174 /* escaped quote */
175 *o++ = *p++;
176 escape_char_run = 0;
178 else if (p[1] == escape_char && escape_char == '"')
180 /* quote escaped by doubling */
181 *o++ = *p;
182 p += 2;
184 else
186 /* The ending quote. */
187 *o = '\0';
188 /* Leave input pointer after token. */
189 p++;
190 break;
193 else if (p[0] == '\0')
195 /* End of string, but no ending quote found. We might want to
196 flag this as an error, but for now will consider the end as
197 the end of the token. */
198 *o = '\0';
199 break;
201 else
203 *o++ = *p++;
207 else
209 /* Next token is delimited by whitespace. */
210 char * p1 = skip_nonspace (p);
211 memcpy (o, p, p1 - p);
212 o += (p1 - p);
213 *o = '\0';
214 p = p1;
217 *pSrc = p;
219 return o - buf;
222 /* Search for EXEC file in DIR. If EXEC does not have an extension,
223 DIR is searched for EXEC with the standard extensions appended. */
225 search_dir (char *dir, char *exec, int bufsize, char *buffer)
227 char *exts[] = {".bat", ".cmd", ".exe", ".com"};
228 int n_exts = sizeof (exts) / sizeof (char *);
229 char *dummy;
230 int i, rc;
232 /* Search the directory for the program. */
233 for (i = 0; i < n_exts; i++)
235 rc = SearchPath (dir, exec, exts[i], bufsize, buffer, &dummy);
236 if (rc > 0)
237 return rc;
240 return 0;
243 /* Return the absolute name of executable file PROG, including
244 any file extensions. If an absolute name for PROG cannot be found,
245 return NULL. */
246 char *
247 make_absolute (char *prog)
249 char absname[MAX_PATH];
250 char dir[MAX_PATH];
251 char curdir[MAX_PATH];
252 char *p, *fname;
253 char *path;
254 int i;
256 /* At least partial absolute path specified; search there. */
257 if ((isalpha (prog[0]) && prog[1] == ':') ||
258 (prog[0] == '\\'))
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';
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;
275 if (GetCurrentDirectory (MAX_PATH, curdir) <= 0)
276 return NULL;
278 /* Relative path; search in current dir. */
279 if (strpbrk (prog, "\\"))
281 if (search_dir (curdir, prog, MAX_PATH, absname) > 0)
282 return strdup (absname);
283 else
284 return NULL;
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"));
293 while (*path)
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';
301 /* Search the directory for the program. */
302 if (search_dir (dir, prog, MAX_PATH, absname) > 0)
303 return strdup (absname);
305 /* Move to the next directory. */
306 path = p + 1;
309 return NULL;
312 /*****************************************************************/
314 #if 0
315 char ** _argv;
316 int _argc;
318 /* Parse commandline into argv array, allowing proper quoting of args. */
319 void
320 setup_argv (void)
322 char * cmdline = GetCommandLine ();
323 int arg_bytes = 0;
327 #endif
329 /* Information about child proc is global, to allow for automatic
330 termination when interrupted. At the moment, only one child process
331 can be running at any one time. */
333 PROCESS_INFORMATION child;
334 int interactive = TRUE;
336 BOOL
337 console_event_handler (DWORD event)
339 switch (event)
341 case CTRL_C_EVENT:
342 case CTRL_BREAK_EVENT:
343 if (!interactive)
345 /* Both command.com and cmd.exe have the annoying behaviour of
346 prompting "Terminate batch job (y/n)?" when interrupted
347 while running a batch file, even if running in
348 non-interactive (-c) mode. Try to make up for this
349 deficiency by forcibly terminating the subprocess if
350 running non-interactively. */
351 if (child.hProcess &&
352 WaitForSingleObject (child.hProcess, 500) != WAIT_OBJECT_0)
353 TerminateProcess (child.hProcess, 0);
354 exit (STATUS_CONTROL_C_EXIT);
356 break;
358 #if 0
359 default:
360 /* CLOSE, LOGOFF and SHUTDOWN events - actually we don't get these
361 under Windows 95. */
362 fail ("cmdproxy: received %d event\n", event);
363 if (child.hProcess)
364 TerminateProcess (child.hProcess, 0);
365 #endif
367 return TRUE;
370 /* Change from normal usage; return value indicates whether spawn
371 succeeded or failed - program return code is returned separately. */
373 spawn (char * progname, char * cmdline, char * dir, int * retcode)
375 BOOL success = FALSE;
376 SECURITY_ATTRIBUTES sec_attrs;
377 STARTUPINFO start;
378 /* In theory, passing NULL for the environment block to CreateProcess
379 is the same as passing the value of GetEnvironmentStrings, but
380 doing this explicitly seems to cure problems running DOS programs
381 in some cases. */
382 char * envblock = GetEnvironmentStrings ();
384 sec_attrs.nLength = sizeof (sec_attrs);
385 sec_attrs.lpSecurityDescriptor = NULL;
386 sec_attrs.bInheritHandle = FALSE;
388 memset (&start, 0, sizeof (start));
389 start.cb = sizeof (start);
391 if (CreateProcess (progname, cmdline, &sec_attrs, NULL, TRUE,
392 0, envblock, dir, &start, &child))
394 success = TRUE;
395 /* wait for completion and pass on return code */
396 WaitForSingleObject (child.hProcess, INFINITE);
397 if (retcode)
398 GetExitCodeProcess (child.hProcess, (DWORD *)retcode);
399 CloseHandle (child.hThread);
400 CloseHandle (child.hProcess);
401 child.hProcess = NULL;
404 FreeEnvironmentStrings (envblock);
406 return success;
409 /* Return size of current environment block. */
411 get_env_size ()
413 char * start = GetEnvironmentStrings ();
414 char * tmp = start;
416 while (tmp[0] || tmp[1])
417 ++tmp;
418 FreeEnvironmentStrings (start);
419 return tmp + 2 - start;
422 /******* Main program ********************************************/
425 main (int argc, char ** argv)
427 int rc;
428 int need_shell;
429 char * cmdline;
430 char * progname;
431 int envsize;
432 char **pass_through_args;
433 int num_pass_through_args;
434 char modname[MAX_PATH];
435 char path[MAX_PATH];
436 char dir[MAX_PATH];
439 interactive = TRUE;
441 SetConsoleCtrlHandler ((PHANDLER_ROUTINE) console_event_handler, TRUE);
443 if (!GetCurrentDirectory (sizeof (dir), dir))
444 fail ("error: GetCurrentDirectory failed\n");
446 /* We serve double duty: we can be called either as a proxy for the
447 real shell (that is, because we are defined to be the user shell),
448 or in our role as a helper application for running DOS programs.
449 In the former case, we interpret the command line options as if we
450 were a Unix shell, but in the latter case we simply pass our
451 command line to CreateProcess. We know which case we are dealing
452 with by whether argv[0] refers to ourself or to some other program.
453 (This relies on an arcane feature of CreateProcess, where we can
454 specify cmdproxy as the module to run, but specify a different
455 program in the command line - the MSVC startup code sets argv[0]
456 from the command line.) */
458 if (!GetModuleFileName (NULL, modname, sizeof (modname)))
459 fail ("error: GetModuleFileName failed\n");
461 /* Change directory to location of .exe so startup directory can be
462 deleted. */
463 progname = strrchr (modname, '\\');
464 *progname = '\0';
465 SetCurrentDirectory (modname);
466 *progname = '\\';
468 /* Although Emacs always sets argv[0] to an absolute pathname, we
469 might get run in other ways as well, so convert argv[0] to an
470 absolute name before comparing to the module name. Don't get
471 caught out by mixed short and long names. */
472 GetShortPathName (modname, modname, sizeof (modname));
473 path[0] = '\0';
474 if (!SearchPath (NULL, argv[0], ".exe", sizeof (path), path, &progname)
475 || !GetShortPathName (path, path, sizeof (path))
476 || stricmp (modname, path) != 0)
478 /* We are being used as a helper to run a DOS app; just pass
479 command line to DOS app without change. */
480 /* TODO: fill in progname. */
481 if (spawn (NULL, GetCommandLine (), dir, &rc))
482 return rc;
483 fail ("Could not run %s\n", GetCommandLine ());
486 /* Process command line. If running interactively (-c or /c not
487 specified) then spawn a real command shell, passing it the command
488 line arguments.
490 If not running interactively, then attempt to execute the specified
491 command directly. If necessary, spawn a real shell to execute the
492 command.
496 progname = NULL;
497 cmdline = NULL;
498 /* If no args, spawn real shell for interactive use. */
499 need_shell = TRUE;
500 interactive = TRUE;
501 /* Ask command.com to create an environment block with a reasonable
502 amount of free space. */
503 envsize = get_env_size () + 300;
504 pass_through_args = (char **) alloca (argc * sizeof(char *));
505 num_pass_through_args = 0;
507 while (--argc > 0)
509 ++argv;
510 /* Act on switches we recognize (mostly single letter switches,
511 except for -e); all unrecognised switches and extra args are
512 passed on to real shell if used (only really of benefit for
513 interactive use, but allow for batch use as well). Accept / as
514 switch char for compatability with cmd.exe. */
515 if (((*argv)[0] == '-' || (*argv)[0] == '/') && (*argv)[1] != '\0')
517 if (((*argv)[1] == 'c' || (*argv)[1] == 'C') && ((*argv)[2] == '\0'))
519 if (--argc == 0)
520 fail ("error: expecting arg for %s\n", *argv);
521 cmdline = *(++argv);
522 interactive = FALSE;
524 else if (((*argv)[1] == 'i' || (*argv)[1] == 'I') && ((*argv)[2] == '\0'))
526 if (cmdline)
527 warn ("warning: %s ignored because of -c\n", *argv);
529 else if (((*argv)[1] == 'e' || (*argv)[1] == 'E') && ((*argv)[2] == ':'))
531 int requested_envsize = atoi (*argv + 3);
532 /* Enforce a reasonable minimum size, as above. */
533 if (requested_envsize > envsize)
534 envsize = requested_envsize;
535 /* For sanity, enforce a reasonable maximum. */
536 if (envsize > 32768)
537 envsize = 32768;
539 else
541 /* warn ("warning: unknown option %s ignored", *argv); */
542 pass_through_args[num_pass_through_args++] = *argv;
545 else
546 break;
549 #if 0
550 /* I think this is probably not useful - cmd.exe ignores extra
551 (non-switch) args in interactive mode, and they cannot be passed on
552 when -c was given. */
554 /* Collect any remaining args after (initial) switches. */
555 while (argc-- > 0)
557 pass_through_args[num_pass_through_args++] = *argv++;
559 #else
560 /* Probably a mistake for there to be extra args; not fatal. */
561 if (argc > 0)
562 warn ("warning: extra args ignored after '%s'\n", argv[-1]);
563 #endif
565 pass_through_args[num_pass_through_args] = NULL;
567 /* If -c option, determine if we must spawn a real shell, or if we can
568 execute the command directly ourself. */
569 if (cmdline)
571 /* If no redirection or piping, and if program can be found, then
572 run program directly. Otherwise invoke a real shell. */
574 static char copout_chars[] = "|<>&";
576 if (strpbrk (cmdline, copout_chars) == NULL)
578 char *args;
580 /* The program name is the first token of cmdline. Since
581 filenames cannot legally contain embedded quotes, the value
582 of escape_char doesn't matter. */
583 args = cmdline;
584 if (!get_next_token (path, &args))
585 fail ("error: no program name specified.\n");
587 canon_filename (path);
588 progname = make_absolute (path);
590 /* If we found the program, run it directly (if not found it
591 might be an internal shell command, so don't fail). */
592 if (progname != NULL)
593 need_shell = FALSE;
597 pass_to_shell:
598 if (need_shell)
600 char * p;
601 int extra_arg_space = 0;
602 int run_command_dot_com;
604 progname = getenv ("COMSPEC");
605 if (!progname)
606 fail ("error: COMSPEC is not set\n");
608 canon_filename (progname);
609 progname = make_absolute (progname);
611 if (progname == NULL || strchr (progname, '\\') == NULL)
612 fail ("error: the program %s could not be found.\n", getenv ("COMSPEC"));
614 /* Need to set environment size when running command.com. */
615 run_command_dot_com =
616 (stricmp (strrchr (progname, '\\'), "command.com") == 0);
618 /* Work out how much extra space is required for
619 pass_through_args. */
620 for (argv = pass_through_args; *argv != NULL; ++argv)
621 /* We don't expect to have to quote switches. */
622 extra_arg_space += strlen (*argv) + 2;
624 if (cmdline)
626 char * buf;
628 /* Convert to syntax expected by cmd.exe/command.com for
629 running non-interactively. Always quote program name in
630 case path contains spaces (fortunately it can't contain
631 quotes, since they are illegal in path names). */
633 buf = p = alloca (strlen (progname) + extra_arg_space +
634 strlen (cmdline) + 16);
636 /* Quote progname in case it contains spaces. */
637 p += wsprintf (p, "\"%s\"", progname);
639 /* Include pass_through_args verbatim; these are just switches
640 so should not need quoting. */
641 for (argv = pass_through_args; *argv != NULL; ++argv)
642 p += wsprintf (p, " %s", *argv);
644 if (run_command_dot_com)
645 wsprintf(p, " /e:%d /c %s", envsize, cmdline);
646 else
647 wsprintf(p, " /c %s", cmdline);
648 cmdline = buf;
650 else
652 if (run_command_dot_com)
654 /* Provide dir arg expected by command.com when first
655 started interactively (the "command search path"). To
656 avoid potential problems with spaces in command dir
657 (which cannot be quoted - command.com doesn't like it),
658 we always use the 8.3 form. */
659 GetShortPathName (progname, path, sizeof (path));
660 p = strrchr (path, '\\');
661 /* Trailing slash is acceptable, so always leave it. */
662 *(++p) = '\0';
664 else
665 path[0] = '\0';
667 cmdline = p = alloca (strlen (progname) + extra_arg_space +
668 strlen (path) + 13);
670 /* Quote progname in case it contains spaces. */
671 p += wsprintf (p, "\"%s\" %s", progname, path);
673 /* Include pass_through_args verbatim; these are just switches
674 so should not need quoting. */
675 for (argv = pass_through_args; *argv != NULL; ++argv)
676 p += wsprintf (p, " %s", *argv);
678 if (run_command_dot_com)
679 wsprintf (p, " /e:%d", envsize);
683 if (!progname)
684 fail ("Internal error: program name not defined\n");
686 if (!cmdline)
687 cmdline = progname;
689 if (spawn (progname, cmdline, dir, &rc))
690 return rc;
692 if (!need_shell)
694 need_shell = TRUE;
695 goto pass_to_shell;
698 fail ("Could not run %s\n", progname);
700 return 0;
703 /* arch-tag: 88678d93-07ac-4e2f-ad63-d4a740ca69ac
704 (do not change this comment) */