; Remove instrumentation of tramp-tests.el
[emacs.git] / lib-src / emacsclient.c
blobdd66d34da70fb98ce5a44807665b925f9f933c64
1 /* Client process that communicates with GNU Emacs acting as server.
3 Copyright (C) 1986-1987, 1994, 1999-2016 Free Software Foundation, Inc.
5 This file is part of GNU Emacs.
7 GNU Emacs is free software: you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation, either version 3 of the License, or (at
10 your option) any later version.
12 GNU Emacs is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
21 #include <config.h>
23 #ifdef WINDOWSNT
25 /* ms-w32.h defines these, which disables sockets altogether! */
26 # undef _WINSOCKAPI_
27 # undef _WINSOCK_H
29 # include <malloc.h>
30 # include <stdlib.h>
31 # include <windows.h>
32 # include <commctrl.h>
33 # include <io.h>
34 # include <winsock2.h>
36 # define NO_SOCKETS_IN_FILE_SYSTEM
38 # define HSOCKET SOCKET
39 # define CLOSE_SOCKET closesocket
40 # define INITIALIZE() (initialize_sockets ())
42 char *w32_getenv (char *);
43 #define egetenv(VAR) w32_getenv(VAR)
45 #else /* !WINDOWSNT */
47 # ifdef HAVE_NTGUI
48 # include <windows.h>
49 # endif /* HAVE_NTGUI */
51 # include "syswait.h"
53 # ifdef HAVE_INET_SOCKETS
54 # include <netinet/in.h>
55 # ifdef HAVE_SOCKETS
56 # include <sys/types.h>
57 # include <sys/socket.h>
58 # include <sys/un.h>
59 # endif /* HAVE_SOCKETS */
60 # endif
61 # include <arpa/inet.h>
63 # define INVALID_SOCKET -1
64 # define HSOCKET int
65 # define CLOSE_SOCKET close
66 # define INITIALIZE()
68 #define egetenv(VAR) getenv(VAR)
70 #endif /* !WINDOWSNT */
72 #undef signal
74 #include <stdarg.h>
75 #include <ctype.h>
76 #include <stdio.h>
77 #include <getopt.h>
78 #include <unistd.h>
80 #include <pwd.h>
81 #include <sys/stat.h>
82 #include <signal.h>
83 #include <errno.h>
85 #ifndef VERSION
86 #define VERSION "unspecified"
87 #endif
90 #ifndef EXIT_SUCCESS
91 #define EXIT_SUCCESS 0
92 #endif
94 #ifndef EXIT_FAILURE
95 #define EXIT_FAILURE 1
96 #endif
98 /* Additional space when allocating buffers for filenames, etc. */
99 #define EXTRA_SPACE 100
101 #ifdef min
102 #undef min
103 #endif
104 #define min(x, y) (((x) < (y)) ? (x) : (y))
107 /* Name used to invoke this program. */
108 const char *progname;
110 /* The second argument to main. */
111 char **main_argv;
113 /* Nonzero means don't wait for a response from Emacs. --no-wait. */
114 int nowait = 0;
116 /* Nonzero means don't print messages for successful operations. --quiet. */
117 int quiet = 0;
119 /* Nonzero means args are expressions to be evaluated. --eval. */
120 int eval = 0;
122 /* Nonzero means don't open a new frame. Inverse of --create-frame. */
123 int current_frame = 1;
125 /* The display on which Emacs should work. --display. */
126 const char *display = NULL;
128 /* The alternate display we should try if Emacs does not support display. */
129 const char *alt_display = NULL;
131 /* The parent window ID, if we are opening a frame via XEmbed. */
132 char *parent_id = NULL;
134 /* Nonzero means open a new Emacs frame on the current terminal. */
135 int tty = 0;
137 /* If non-NULL, the name of an editor to fallback to if the server
138 is not running. --alternate-editor. */
139 const char *alternate_editor = NULL;
141 /* If non-NULL, the filename of the UNIX socket. */
142 const char *socket_name = NULL;
144 /* If non-NULL, the filename of the authentication file. */
145 const char *server_file = NULL;
147 /* PID of the Emacs server process. */
148 int emacs_pid = 0;
150 /* If non-NULL, a string that should form a frame parameter alist to
151 be used for the new frame. */
152 const char *frame_parameters = NULL;
154 static _Noreturn void print_help_and_exit (void);
157 struct option longopts[] =
159 { "no-wait", no_argument, NULL, 'n' },
160 { "quiet", no_argument, NULL, 'q' },
161 { "eval", no_argument, NULL, 'e' },
162 { "help", no_argument, NULL, 'H' },
163 { "version", no_argument, NULL, 'V' },
164 { "tty", no_argument, NULL, 't' },
165 { "nw", no_argument, NULL, 't' },
166 { "create-frame", no_argument, NULL, 'c' },
167 { "alternate-editor", required_argument, NULL, 'a' },
168 { "frame-parameters", required_argument, NULL, 'F' },
169 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
170 { "socket-name", required_argument, NULL, 's' },
171 #endif
172 { "server-file", required_argument, NULL, 'f' },
173 { "display", required_argument, NULL, 'd' },
174 { "parent-id", required_argument, NULL, 'p' },
175 { 0, 0, 0, 0 }
179 /* Like malloc but get fatal error if memory is exhausted. */
181 static void *
182 xmalloc (size_t size)
184 void *result = malloc (size);
185 if (result == NULL)
187 perror ("malloc");
188 exit (EXIT_FAILURE);
190 return result;
193 /* From sysdep.c */
194 #if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
196 char *get_current_dir_name (void);
198 /* Return the current working directory. Returns NULL on errors.
199 Any other returned value must be freed with free. This is used
200 only when get_current_dir_name is not defined on the system. */
201 char*
202 get_current_dir_name (void)
204 char *buf;
205 const char *pwd;
206 struct stat dotstat, pwdstat;
207 /* If PWD is accurate, use it instead of calling getcwd. PWD is
208 sometimes a nicer name, and using it may avoid a fatal error if a
209 parent directory is searchable but not readable. */
210 if ((pwd = egetenv ("PWD")) != 0
211 && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
212 && stat (pwd, &pwdstat) == 0
213 && stat (".", &dotstat) == 0
214 && dotstat.st_ino == pwdstat.st_ino
215 && dotstat.st_dev == pwdstat.st_dev
216 #ifdef MAXPATHLEN
217 && strlen (pwd) < MAXPATHLEN
218 #endif
221 buf = (char *) xmalloc (strlen (pwd) + 1);
222 strcpy (buf, pwd);
224 else
226 size_t buf_size = 1024;
227 for (;;)
229 int tmp_errno;
230 buf = malloc (buf_size);
231 if (! buf)
232 break;
233 if (getcwd (buf, buf_size) == buf)
234 break;
235 tmp_errno = errno;
236 free (buf);
237 if (tmp_errno != ERANGE)
239 errno = tmp_errno;
240 return NULL;
242 buf_size *= 2;
243 if (! buf_size)
245 errno = ENOMEM;
246 return NULL;
250 return buf;
252 #endif
254 #ifdef WINDOWSNT
256 /* Like strdup but get a fatal error if memory is exhausted. */
258 char *
259 xstrdup (const char *s)
261 char *result = strdup (s);
262 if (result == NULL)
264 perror ("strdup");
265 exit (EXIT_FAILURE);
267 return result;
270 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
272 /* Retrieve an environment variable from the Emacs subkeys of the registry.
273 Return NULL if the variable was not found, or it was empty.
274 This code is based on w32_get_resource (w32.c). */
275 char *
276 w32_get_resource (HKEY predefined, char *key, LPDWORD type)
278 HKEY hrootkey = NULL;
279 char *result = NULL;
280 DWORD cbData;
282 if (RegOpenKeyEx (predefined, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
284 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS)
286 result = (char *) xmalloc (cbData);
288 if ((RegQueryValueEx (hrootkey, key, NULL, type, result, &cbData) != ERROR_SUCCESS)
289 || (*result == 0))
291 free (result);
292 result = NULL;
296 RegCloseKey (hrootkey);
299 return result;
303 getenv wrapper for Windows
305 Value is allocated on the heap, and can be free'd.
307 This is needed to duplicate Emacs's behavior, which is to look for
308 environment variables in the registry if they don't appear in the
309 environment. */
310 char *
311 w32_getenv (char *envvar)
313 char *value;
314 DWORD dwType;
316 if ((value = getenv (envvar)))
317 /* Found in the environment. strdup it, because values returned
318 by getenv cannot be free'd. */
319 return xstrdup (value);
321 if (! (value = w32_get_resource (HKEY_CURRENT_USER, envvar, &dwType)) &&
322 ! (value = w32_get_resource (HKEY_LOCAL_MACHINE, envvar, &dwType)))
324 /* "w32console" is what Emacs on Windows uses for tty-type under -nw. */
325 if (strcmp (envvar, "TERM") == 0)
326 return xstrdup ("w32console");
327 /* Found neither in the environment nor in the registry. */
328 return NULL;
331 if (dwType == REG_SZ)
332 /* Registry; no need to expand. */
333 return value;
335 if (dwType == REG_EXPAND_SZ)
337 DWORD size;
339 if ((size = ExpandEnvironmentStrings (value, NULL, 0)))
341 char *buffer = (char *) xmalloc (size);
342 if (ExpandEnvironmentStrings (value, buffer, size))
344 /* Found and expanded. */
345 free (value);
346 return buffer;
349 /* Error expanding. */
350 free (buffer);
354 /* Not the right type, or not correctly expanded. */
355 free (value);
356 return NULL;
361 w32_window_app (void)
363 static int window_app = -1;
364 char szTitle[MAX_PATH];
366 if (window_app < 0)
368 /* Checking for STDOUT does not work; it's a valid handle also in
369 nonconsole apps. Testing for the console title seems to work. */
370 window_app = (GetConsoleTitleA (szTitle, MAX_PATH) == 0);
371 if (window_app)
372 InitCommonControls ();
375 return window_app;
378 /* execvp wrapper for Windows. Quotes arguments with embedded spaces.
380 This is necessary due to the broken implementation of exec* routines in
381 the Microsoft libraries: they concatenate the arguments together without
382 quoting special characters, and pass the result to CreateProcess, with
383 predictably bad results. By contrast, POSIX execvp passes the arguments
384 directly into the argv array of the child process. */
387 w32_execvp (const char *path, char **argv)
389 int i;
390 extern int execvp (const char*, char **);
392 /* Required to allow a .BAT script as alternate editor. */
393 argv[0] = (char *) alternate_editor;
395 for (i = 0; argv[i]; i++)
396 if (strchr (argv[i], ' '))
398 char *quoted = alloca (strlen (argv[i]) + 3);
399 sprintf (quoted, "\"%s\"", argv[i]);
400 argv[i] = quoted;
403 return execvp (path, argv);
406 #undef execvp
407 #define execvp w32_execvp
409 /* Emulation of ttyname for Windows. */
410 char *
411 ttyname (int fd)
413 return "CONOUT$";
416 #endif /* WINDOWSNT */
418 /* Display a normal or error message.
419 On Windows, use a message box if compiled as a Windows app. */
420 static void message (bool, const char *, ...) ATTRIBUTE_FORMAT_PRINTF (2, 3);
421 static void
422 message (bool is_error, const char *format, ...)
424 va_list args;
426 va_start (args, format);
428 #ifdef WINDOWSNT
429 if (w32_window_app ())
431 char msg[2048];
432 vsnprintf (msg, sizeof msg, format, args);
433 msg[sizeof msg - 1] = '\0';
435 if (is_error)
436 MessageBox (NULL, msg, "Emacsclient ERROR", MB_ICONERROR);
437 else
438 MessageBox (NULL, msg, "Emacsclient", MB_ICONINFORMATION);
440 else
441 #endif
443 FILE *f = is_error ? stderr : stdout;
445 vfprintf (f, format, args);
446 fflush (f);
449 va_end (args);
452 /* Decode the options from argv and argc.
453 The global variable `optind' will say how many arguments we used up. */
455 static void
456 decode_options (int argc, char **argv)
458 alternate_editor = egetenv ("ALTERNATE_EDITOR");
460 while (1)
462 int opt = getopt_long_only (argc, argv,
463 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
464 "VHneqa:s:f:d:F:tc",
465 #else
466 "VHneqa:f:d:F:tc",
467 #endif
468 longopts, 0);
470 if (opt == EOF)
471 break;
473 switch (opt)
475 case 0:
476 /* If getopt returns 0, then it has already processed a
477 long-named option. We should do nothing. */
478 break;
480 case 'a':
481 alternate_editor = optarg;
482 break;
484 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
485 case 's':
486 socket_name = optarg;
487 break;
488 #endif
490 case 'f':
491 server_file = optarg;
492 break;
494 /* We used to disallow this argument in w32, but it seems better
495 to allow it, for the occasional case where the user is
496 connecting with a w32 client to a server compiled with X11
497 support. */
498 case 'd':
499 display = optarg;
500 break;
502 case 'n':
503 nowait = 1;
504 break;
506 case 'e':
507 eval = 1;
508 break;
510 case 'q':
511 quiet = 1;
512 break;
514 case 'V':
515 message (false, "emacsclient %s\n", VERSION);
516 exit (EXIT_SUCCESS);
517 break;
519 case 't':
520 tty = 1;
521 current_frame = 0;
522 break;
524 case 'c':
525 current_frame = 0;
526 break;
528 case 'p':
529 parent_id = optarg;
530 current_frame = 0;
531 break;
533 case 'H':
534 print_help_and_exit ();
535 break;
537 case 'F':
538 frame_parameters = optarg;
539 break;
541 default:
542 message (true, "Try '%s --help' for more information\n", progname);
543 exit (EXIT_FAILURE);
544 break;
548 /* If the -c option is used (without -t) and no --display argument
549 is provided, try $DISPLAY.
550 Without the -c option, we used to set `display' to $DISPLAY by
551 default, but this changed the default behavior and is sometimes
552 inconvenient. So we force users to use "--display $DISPLAY" if
553 they want Emacs to connect to their current display.
555 Some window systems have a notion of default display not
556 reflected in the DISPLAY variable. If the user didn't give us an
557 explicit display, try this platform-specific after trying the
558 display in DISPLAY (if any). */
559 if (!current_frame && !tty && !display)
561 /* Set these here so we use a default_display only when the user
562 didn't give us an explicit display. */
563 #if defined (NS_IMPL_COCOA)
564 alt_display = "ns";
565 #elif defined (HAVE_NTGUI)
566 alt_display = "w32";
567 #endif
569 display = egetenv ("DISPLAY");
572 if (!display)
574 display = alt_display;
575 alt_display = NULL;
578 /* A null-string display is invalid. */
579 if (display && strlen (display) == 0)
580 display = NULL;
582 /* If no display is available, new frames are tty frames. */
583 if (!current_frame && !display)
584 tty = 1;
586 #ifdef WINDOWSNT
587 /* Emacs on Windows does not support graphical and text terminal
588 frames in the same instance. So, treat the -t and -c options as
589 equivalent, and open a new frame on the server's terminal.
590 Ideally, we would only set tty = 1 when the serve is running in a
591 console, but alas we don't know that. As a workaround, always
592 ask for a tty frame, and let server.el figure it out. */
593 if (!current_frame)
595 display = NULL;
596 tty = 1;
598 #endif /* WINDOWSNT */
602 static _Noreturn void
603 print_help_and_exit (void)
605 /* Spaces and tabs are significant in this message; they're chosen so the
606 message aligns properly both in a tty and in a Windows message box.
607 Please try to preserve them; otherwise the output is very hard to read
608 when using emacsclientw. */
609 message (false,
610 "Usage: %s [OPTIONS] FILE...\n%s%s%s", progname, "\
611 Tell the Emacs server to visit the specified files.\n\
612 Every FILE can be either just a FILENAME or [+LINE[:COLUMN]] FILENAME.\n\
614 The following OPTIONS are accepted:\n\
615 -V, --version Just print version info and return\n\
616 -H, --help Print this usage information message\n\
617 -nw, -t, --tty Open a new Emacs frame on the current terminal\n\
618 -c, --create-frame Create a new frame instead of trying to\n\
619 use the current Emacs frame\n\
620 ", "\
621 -F ALIST, --frame-parameters=ALIST\n\
622 Set the parameters of a new frame\n\
623 -e, --eval Evaluate the FILE arguments as ELisp expressions\n\
624 -n, --no-wait Don't wait for the server to return\n\
625 -q, --quiet Don't display messages on success\n\
626 -d DISPLAY, --display=DISPLAY\n\
627 Visit the file in the given display\n\
628 ", "\
629 --parent-id=ID Open in parent window ID, via XEmbed\n"
630 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
631 "-s SOCKET, --socket-name=SOCKET\n\
632 Set filename of the UNIX socket for communication\n"
633 #endif
634 "-f SERVER, --server-file=SERVER\n\
635 Set filename of the TCP authentication file\n\
636 -a EDITOR, --alternate-editor=EDITOR\n\
637 Editor to fallback to if the server is not running\n"
638 " If EDITOR is the empty string, start Emacs in daemon\n\
639 mode and try connecting again\n"
640 "\n\
641 Report bugs with M-x report-emacs-bug.\n");
642 exit (EXIT_SUCCESS);
645 /* Try to run a different command, or --if no alternate editor is
646 defined-- exit with an errorcode.
647 Uses argv, but gets it from the global variable main_argv. */
649 static _Noreturn void
650 fail (void)
652 if (alternate_editor)
654 int i = optind - 1;
656 execvp (alternate_editor, main_argv + i);
657 message (true, "%s: error executing alternate editor \"%s\"\n",
658 progname, alternate_editor);
660 exit (EXIT_FAILURE);
664 #if !defined (HAVE_SOCKETS) || !defined (HAVE_INET_SOCKETS)
667 main (int argc, char **argv)
669 main_argv = argv;
670 progname = argv[0];
671 message (true, "%s: Sorry, the Emacs server is supported only\n"
672 "on systems with Berkeley sockets.\n",
673 argv[0]);
674 fail ();
677 #else /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
679 #define AUTH_KEY_LENGTH 64
680 #define SEND_BUFFER_SIZE 4096
682 /* Buffer to accumulate data to send in TCP connections. */
683 char send_buffer[SEND_BUFFER_SIZE + 1];
684 int sblen = 0; /* Fill pointer for the send buffer. */
685 /* Socket used to communicate with the Emacs server process. */
686 HSOCKET emacs_socket = 0;
688 /* On Windows, the socket library was historically separate from the
689 standard C library, so errors are handled differently. */
691 static void
692 sock_err_message (const char *function_name)
694 #ifdef WINDOWSNT
695 char* msg = NULL;
697 FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
698 | FORMAT_MESSAGE_ALLOCATE_BUFFER
699 | FORMAT_MESSAGE_ARGUMENT_ARRAY,
700 NULL, WSAGetLastError (), 0, (LPTSTR)&msg, 0, NULL);
702 message (true, "%s: %s: %s\n", progname, function_name, msg);
704 LocalFree (msg);
705 #else
706 message (true, "%s: %s: %s\n", progname, function_name, strerror (errno));
707 #endif
711 /* Let's send the data to Emacs when either
712 - the data ends in "\n", or
713 - the buffer is full (but this shouldn't happen)
714 Otherwise, we just accumulate it. */
715 static void
716 send_to_emacs (HSOCKET s, const char *data)
718 size_t dlen;
720 if (!data)
721 return;
723 dlen = strlen (data);
724 while (*data)
726 size_t part = min (dlen, SEND_BUFFER_SIZE - sblen);
727 memcpy (&send_buffer[sblen], data, part);
728 data += part;
729 sblen += part;
731 if (sblen == SEND_BUFFER_SIZE
732 || (sblen > 0 && send_buffer[sblen-1] == '\n'))
734 int sent = send (s, send_buffer, sblen, 0);
735 if (sent < 0)
737 message (true, "%s: failed to send %d bytes to socket: %s\n",
738 progname, sblen, strerror (errno));
739 fail ();
741 if (sent != sblen)
742 memmove (send_buffer, &send_buffer[sent], sblen - sent);
743 sblen -= sent;
746 dlen -= part;
751 /* In STR, insert a & before each &, each space, each newline, and
752 any initial -. Change spaces to underscores, too, so that the
753 return value never contains a space.
755 Does not change the string. Outputs the result to S. */
756 static void
757 quote_argument (HSOCKET s, const char *str)
759 char *copy = (char *) xmalloc (strlen (str) * 2 + 1);
760 const char *p;
761 char *q;
763 p = str;
764 q = copy;
765 while (*p)
767 if (*p == ' ')
769 *q++ = '&';
770 *q++ = '_';
771 p++;
773 else if (*p == '\n')
775 *q++ = '&';
776 *q++ = 'n';
777 p++;
779 else
781 if (*p == '&' || (*p == '-' && p == str))
782 *q++ = '&';
783 *q++ = *p++;
786 *q++ = 0;
788 send_to_emacs (s, copy);
790 free (copy);
794 /* The inverse of quote_argument. Removes quoting in string STR by
795 modifying the string in place. Returns STR. */
797 static char *
798 unquote_argument (char *str)
800 char *p, *q;
802 if (! str)
803 return str;
805 p = str;
806 q = str;
807 while (*p)
809 if (*p == '&')
811 p++;
812 if (*p == '&')
813 *p = '&';
814 else if (*p == '_')
815 *p = ' ';
816 else if (*p == 'n')
817 *p = '\n';
818 else if (*p == '-')
819 *p = '-';
821 *q++ = *p++;
823 *q = 0;
824 return str;
828 static int
829 file_name_absolute_p (const char *filename)
831 /* Sanity check, it shouldn't happen. */
832 if (! filename) return false;
834 /* /xxx is always an absolute path. */
835 if (filename[0] == '/') return true;
837 /* Empty filenames (which shouldn't happen) are relative. */
838 if (filename[0] == '\0') return false;
840 #ifdef WINDOWSNT
841 /* X:\xxx is always absolute. */
842 if (isalpha ((unsigned char) filename[0])
843 && filename[1] == ':' && (filename[2] == '\\' || filename[2] == '/'))
844 return true;
846 /* Both \xxx and \\xxx\yyy are absolute. */
847 if (filename[0] == '\\') return true;
848 #endif
850 return false;
853 #ifdef WINDOWSNT
854 /* Wrapper to make WSACleanup a cdecl, as required by atexit. */
855 void __cdecl
856 close_winsock (void)
858 WSACleanup ();
861 /* Initialize the WinSock2 library. */
862 void
863 initialize_sockets (void)
865 WSADATA wsaData;
867 if (WSAStartup (MAKEWORD (2, 0), &wsaData))
869 message (true, "%s: error initializing WinSock2\n", progname);
870 exit (EXIT_FAILURE);
873 atexit (close_winsock);
875 #endif /* WINDOWSNT */
878 /* Read the information needed to set up a TCP comm channel with
879 the Emacs server: host, port, and authentication string. */
881 static int
882 get_server_config (const char *config_file, struct sockaddr_in *server,
883 char *authentication)
885 char dotted[32];
886 char *port;
887 FILE *config = NULL;
889 if (file_name_absolute_p (config_file))
890 config = fopen (config_file, "rb");
891 else
893 const char *home = egetenv ("HOME");
895 if (home)
897 char *path = xmalloc (strlen (home) + strlen (config_file)
898 + EXTRA_SPACE);
899 char *z = stpcpy (path, home);
900 z = stpcpy (z, "/.emacs.d/server/");
901 strcpy (z, config_file);
902 config = fopen (path, "rb");
903 free (path);
905 #ifdef WINDOWSNT
906 if (!config && (home = egetenv ("APPDATA")))
908 char *path = xmalloc (strlen (home) + strlen (config_file)
909 + EXTRA_SPACE);
910 char *z = stpcpy (path, home);
911 z = stpcpy (z, "/.emacs.d/server/");
912 strcpy (z, config_file);
913 config = fopen (path, "rb");
914 free (path);
916 #endif
919 if (! config)
920 return false;
922 if (fgets (dotted, sizeof dotted, config)
923 && (port = strchr (dotted, ':')))
924 *port++ = '\0';
925 else
927 message (true, "%s: invalid configuration info\n", progname);
928 exit (EXIT_FAILURE);
931 server->sin_family = AF_INET;
932 server->sin_addr.s_addr = inet_addr (dotted);
933 server->sin_port = htons (atoi (port));
935 if (! fread (authentication, AUTH_KEY_LENGTH, 1, config))
937 message (true, "%s: cannot read authentication info\n", progname);
938 exit (EXIT_FAILURE);
941 fclose (config);
943 return true;
946 static HSOCKET
947 set_tcp_socket (const char *local_server_file)
949 HSOCKET s;
950 struct sockaddr_in server;
951 struct linger l_arg = {1, 1};
952 char auth_string[AUTH_KEY_LENGTH + 1];
954 if (! get_server_config (local_server_file, &server, auth_string))
955 return INVALID_SOCKET;
957 if (server.sin_addr.s_addr != inet_addr ("127.0.0.1") && !quiet)
958 message (false, "%s: connected to remote socket at %s\n",
959 progname, inet_ntoa (server.sin_addr));
961 /* Open up an AF_INET socket. */
962 if ((s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
964 /* Since we have an alternate to try out, this is not an error
965 yet; popping out a modal dialog at this stage would make -a
966 option totally useless for emacsclientw -- the user will
967 still get an error message if the alternate editor fails. */
968 #ifdef WINDOWSNT
969 if(!(w32_window_app () && alternate_editor))
970 #endif
971 sock_err_message ("socket");
972 return INVALID_SOCKET;
975 /* Set up the socket. */
976 if (connect (s, (struct sockaddr *) &server, sizeof server) < 0)
978 #ifdef WINDOWSNT
979 if(!(w32_window_app () && alternate_editor))
980 #endif
981 sock_err_message ("connect");
982 return INVALID_SOCKET;
985 setsockopt (s, SOL_SOCKET, SO_LINGER, (char *) &l_arg, sizeof l_arg);
987 /* Send the authentication. */
988 auth_string[AUTH_KEY_LENGTH] = '\0';
990 send_to_emacs (s, "-auth ");
991 send_to_emacs (s, auth_string);
992 send_to_emacs (s, " ");
994 return s;
998 /* Returns 1 if PREFIX is a prefix of STRING. */
999 static int
1000 strprefix (const char *prefix, const char *string)
1002 return !strncmp (prefix, string, strlen (prefix));
1005 /* Get tty name and type. If successful, return the type in TTY_TYPE
1006 and the name in TTY_NAME, and return 1. Otherwise, fail if NOABORT
1007 is zero, or return 0 if NOABORT is non-zero. */
1009 static int
1010 find_tty (const char **tty_type, const char **tty_name, int noabort)
1012 const char *type = egetenv ("TERM");
1013 const char *name = ttyname (fileno (stdout));
1015 if (!name)
1017 if (noabort)
1018 return 0;
1019 else
1021 message (true, "%s: could not get terminal name\n", progname);
1022 fail ();
1026 if (!type)
1028 if (noabort)
1029 return 0;
1030 else
1032 message (true, "%s: please set the TERM variable to your terminal type\n",
1033 progname);
1034 fail ();
1038 if (strcmp (type, "eterm") == 0)
1040 if (noabort)
1041 return 0;
1042 else
1044 /* This causes nasty, MULTI_KBOARD-related input lockouts. */
1045 message (true, "%s: opening a frame in an Emacs term buffer"
1046 " is not supported\n", progname);
1047 fail ();
1051 *tty_name = name;
1052 *tty_type = type;
1053 return 1;
1057 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1059 /* Three possibilities:
1060 2 - can't be `stat'ed (sets errno)
1061 1 - isn't owned by us
1062 0 - success: none of the above */
1064 static int
1065 socket_status (const char *name)
1067 struct stat statbfr;
1069 if (stat (name, &statbfr) == -1)
1070 return 2;
1072 if (statbfr.st_uid != geteuid ())
1073 return 1;
1075 return 0;
1079 /* A signal handler that passes the signal to the Emacs process.
1080 Useful for SIGWINCH. */
1082 static void
1083 pass_signal_to_emacs (int signalnum)
1085 int old_errno = errno;
1087 if (emacs_pid)
1088 kill (emacs_pid, signalnum);
1090 signal (signalnum, pass_signal_to_emacs);
1091 errno = old_errno;
1094 /* Signal handler for SIGCONT; notify the Emacs process that it can
1095 now resume our tty frame. */
1097 static void
1098 handle_sigcont (int signalnum)
1100 int old_errno = errno;
1101 pid_t pgrp = getpgrp ();
1102 pid_t tcpgrp = tcgetpgrp (1);
1104 if (tcpgrp == pgrp)
1106 /* We are in the foreground. */
1107 send_to_emacs (emacs_socket, "-resume \n");
1109 else if (0 <= tcpgrp && tty)
1111 /* We are in the background; cancel the continue. */
1112 kill (-pgrp, SIGTTIN);
1115 signal (signalnum, handle_sigcont);
1116 errno = old_errno;
1119 /* Signal handler for SIGTSTP; notify the Emacs process that we are
1120 going to sleep. Normally the suspend is initiated by Emacs via
1121 server-handle-suspend-tty, but if the server gets out of sync with
1122 reality, we may get a SIGTSTP on C-z. Handling this signal and
1123 notifying Emacs about it should get things under control again. */
1125 static void
1126 handle_sigtstp (int signalnum)
1128 int old_errno = errno;
1129 sigset_t set;
1131 if (emacs_socket)
1132 send_to_emacs (emacs_socket, "-suspend \n");
1134 /* Unblock this signal and call the default handler by temporarily
1135 changing the handler and resignaling. */
1136 sigprocmask (SIG_BLOCK, NULL, &set);
1137 sigdelset (&set, signalnum);
1138 signal (signalnum, SIG_DFL);
1139 raise (signalnum);
1140 sigprocmask (SIG_SETMASK, &set, NULL); /* Let's the above signal through. */
1141 signal (signalnum, handle_sigtstp);
1143 errno = old_errno;
1147 /* Set up signal handlers before opening a frame on the current tty. */
1149 static void
1150 init_signals (void)
1152 /* Set up signal handlers. */
1153 signal (SIGWINCH, pass_signal_to_emacs);
1155 /* Don't pass SIGINT and SIGQUIT to Emacs, because it has no way of
1156 deciding which terminal the signal came from. C-g is now a
1157 normal input event on secondary terminals. */
1158 #if 0
1159 signal (SIGINT, pass_signal_to_emacs);
1160 signal (SIGQUIT, pass_signal_to_emacs);
1161 #endif
1163 signal (SIGCONT, handle_sigcont);
1164 signal (SIGTSTP, handle_sigtstp);
1165 signal (SIGTTOU, handle_sigtstp);
1169 static HSOCKET
1170 set_local_socket (const char *local_socket_name)
1172 HSOCKET s;
1173 struct sockaddr_un server;
1175 /* Open up an AF_UNIX socket in this person's home directory. */
1176 if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
1178 message (true, "%s: socket: %s\n", progname, strerror (errno));
1179 return INVALID_SOCKET;
1182 server.sun_family = AF_UNIX;
1185 int sock_status;
1186 int use_tmpdir = 0;
1187 int saved_errno;
1188 const char *server_name = local_socket_name;
1189 const char *tmpdir IF_LINT ( = NULL);
1190 char *tmpdir_storage = NULL;
1191 char *socket_name_storage = NULL;
1193 if (!strchr (local_socket_name, '/') && !strchr (local_socket_name, '\\'))
1195 /* socket_name is a file name component. */
1196 long uid = geteuid ();
1197 use_tmpdir = 1;
1198 tmpdir = egetenv ("TMPDIR");
1199 if (!tmpdir)
1201 #ifdef DARWIN_OS
1202 #ifndef _CS_DARWIN_USER_TEMP_DIR
1203 #define _CS_DARWIN_USER_TEMP_DIR 65537
1204 #endif
1205 size_t n = confstr (_CS_DARWIN_USER_TEMP_DIR, NULL, (size_t) 0);
1206 if (n > 0)
1208 tmpdir = tmpdir_storage = xmalloc (n);
1209 confstr (_CS_DARWIN_USER_TEMP_DIR, tmpdir_storage, n);
1211 else
1212 #endif
1213 tmpdir = "/tmp";
1215 socket_name_storage =
1216 xmalloc (strlen (tmpdir) + strlen (server_name) + EXTRA_SPACE);
1217 char *z = stpcpy (socket_name_storage, tmpdir);
1218 z += sprintf (z, "/emacs%ld/", uid);
1219 strcpy (z, server_name);
1220 local_socket_name = socket_name_storage;
1223 if (strlen (local_socket_name) < sizeof (server.sun_path))
1224 strcpy (server.sun_path, local_socket_name);
1225 else
1227 message (true, "%s: socket-name %s too long\n",
1228 progname, local_socket_name);
1229 fail ();
1232 /* See if the socket exists, and if it's owned by us. */
1233 sock_status = socket_status (server.sun_path);
1234 saved_errno = errno;
1235 if (sock_status && use_tmpdir)
1237 /* Failing that, see if LOGNAME or USER exist and differ from
1238 our euid. If so, look for a socket based on the UID
1239 associated with the name. This is reminiscent of the logic
1240 that init_editfns uses to set the global Vuser_full_name. */
1242 const char *user_name = egetenv ("LOGNAME");
1244 if (!user_name)
1245 user_name = egetenv ("USER");
1247 if (user_name)
1249 struct passwd *pw = getpwnam (user_name);
1251 if (pw && (pw->pw_uid != geteuid ()))
1253 /* We're running under su, apparently. */
1254 long uid = pw->pw_uid;
1255 char *user_socket_name
1256 = xmalloc (strlen (tmpdir) + strlen (server_name)
1257 + EXTRA_SPACE);
1258 char *z = stpcpy (user_socket_name, tmpdir);
1259 z += sprintf (z, "/emacs%ld/", uid);
1260 strcpy (z, server_name);
1262 if (strlen (user_socket_name) < sizeof (server.sun_path))
1263 strcpy (server.sun_path, user_socket_name);
1264 else
1266 message (true, "%s: socket-name %s too long\n",
1267 progname, user_socket_name);
1268 exit (EXIT_FAILURE);
1270 free (user_socket_name);
1272 sock_status = socket_status (server.sun_path);
1273 saved_errno = errno;
1275 else
1276 errno = saved_errno;
1280 free (socket_name_storage);
1281 free (tmpdir_storage);
1283 switch (sock_status)
1285 case 1:
1286 /* There's a socket, but it isn't owned by us. This is OK if
1287 we are root. */
1288 if (0 != geteuid ())
1290 message (true, "%s: Invalid socket owner\n", progname);
1291 return INVALID_SOCKET;
1293 break;
1295 case 2:
1296 /* `stat' failed */
1297 if (saved_errno == ENOENT)
1298 message (true,
1299 "%s: can't find socket; have you started the server?\n\
1300 To start the server in Emacs, type \"M-x server-start\".\n",
1301 progname);
1302 else
1303 message (true, "%s: can't stat %s: %s\n",
1304 progname, server.sun_path, strerror (saved_errno));
1305 return INVALID_SOCKET;
1309 if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1310 < 0)
1312 message (true, "%s: connect: %s\n", progname, strerror (errno));
1313 return INVALID_SOCKET;
1316 return s;
1318 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1320 static HSOCKET
1321 set_socket (int no_exit_if_error)
1323 HSOCKET s;
1324 const char *local_server_file = server_file;
1326 INITIALIZE ();
1328 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1329 /* Explicit --socket-name argument. */
1330 if (socket_name)
1332 s = set_local_socket (socket_name);
1333 if ((s != INVALID_SOCKET) || no_exit_if_error)
1334 return s;
1335 message (true, "%s: error accessing socket \"%s\"\n",
1336 progname, socket_name);
1337 exit (EXIT_FAILURE);
1339 #endif
1341 /* Explicit --server-file arg or EMACS_SERVER_FILE variable. */
1342 if (!local_server_file)
1343 local_server_file = egetenv ("EMACS_SERVER_FILE");
1345 if (local_server_file)
1347 s = set_tcp_socket (local_server_file);
1348 if ((s != INVALID_SOCKET) || no_exit_if_error)
1349 return s;
1351 message (true, "%s: error accessing server file \"%s\"\n",
1352 progname, local_server_file);
1353 exit (EXIT_FAILURE);
1356 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1357 /* Implicit local socket. */
1358 s = set_local_socket ("server");
1359 if (s != INVALID_SOCKET)
1360 return s;
1361 #endif
1363 /* Implicit server file. */
1364 s = set_tcp_socket ("server");
1365 if ((s != INVALID_SOCKET) || no_exit_if_error)
1366 return s;
1368 /* No implicit or explicit socket, and no alternate editor. */
1369 message (true, "%s: No socket or alternate editor. Please use:\n\n"
1370 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1371 "\t--socket-name\n"
1372 #endif
1373 "\t--server-file (or environment variable EMACS_SERVER_FILE)\n\
1374 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1375 progname);
1376 exit (EXIT_FAILURE);
1379 #ifdef HAVE_NTGUI
1380 FARPROC set_fg; /* Pointer to AllowSetForegroundWindow. */
1381 FARPROC get_wc; /* Pointer to RealGetWindowClassA. */
1383 void
1384 w32_set_user_model_id (void)
1386 HMODULE shell;
1387 HRESULT (WINAPI * set_user_model) (wchar_t * id);
1389 /* On Windows 7 and later, we need to set the user model ID
1390 to associate emacsclient launched files with Emacs frames
1391 in the UI. */
1392 shell = LoadLibrary ("shell32.dll");
1393 if (shell)
1395 set_user_model
1396 = (void *) GetProcAddress (shell,
1397 "SetCurrentProcessExplicitAppUserModelID");
1398 /* If the function is defined, then we are running on Windows 7
1399 or newer, and the UI uses this to group related windows
1400 together. Since emacs, runemacs, emacsclient are related, we
1401 want them grouped even though the executables are different,
1402 so we need to set a consistent ID between them. */
1403 if (set_user_model)
1404 set_user_model (L"GNU.Emacs");
1406 FreeLibrary (shell);
1410 BOOL CALLBACK
1411 w32_find_emacs_process (HWND hWnd, LPARAM lParam)
1413 DWORD pid;
1414 char class[6];
1416 /* Reject any window not of class "Emacs". */
1417 if (! get_wc (hWnd, class, sizeof (class))
1418 || strcmp (class, "Emacs"))
1419 return TRUE;
1421 /* We only need the process id, not the thread id. */
1422 (void) GetWindowThreadProcessId (hWnd, &pid);
1424 /* Not the one we're looking for. */
1425 if (pid != (DWORD) emacs_pid) return TRUE;
1427 /* OK, let's raise it. */
1428 set_fg (emacs_pid);
1430 /* Stop enumeration. */
1431 return FALSE;
1434 /* Search for a window of class "Emacs" and owned by a process with
1435 process id = emacs_pid. If found, allow it to grab the focus. */
1437 void
1438 w32_give_focus (void)
1440 HANDLE user32;
1442 /* It shouldn't happen when dealing with TCP sockets. */
1443 if (!emacs_pid) return;
1445 user32 = GetModuleHandle ("user32.dll");
1447 if (!user32)
1448 return;
1450 /* Modern Windows restrict which processes can set the foreground window.
1451 emacsclient can allow Emacs to grab the focus by calling the function
1452 AllowSetForegroundWindow. Unfortunately, older Windows (W95, W98 and
1453 NT) lack this function, so we have to check its availability. */
1454 if ((set_fg = GetProcAddress (user32, "AllowSetForegroundWindow"))
1455 && (get_wc = GetProcAddress (user32, "RealGetWindowClassA")))
1456 EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1458 #endif /* HAVE_NTGUI */
1460 /* Start the emacs daemon and try to connect to it. */
1462 static void
1463 start_daemon_and_retry_set_socket (void)
1465 #ifndef WINDOWSNT
1466 pid_t dpid;
1467 int status;
1469 dpid = fork ();
1471 if (dpid > 0)
1473 pid_t w;
1474 w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);
1476 if ((w == -1) || !WIFEXITED (status) || WEXITSTATUS (status))
1478 message (true, "Error: Could not start the Emacs daemon\n");
1479 exit (EXIT_FAILURE);
1482 /* Try connecting, the daemon should have started by now. */
1483 message (true, "Emacs daemon should have started, trying to connect again\n");
1484 if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1486 message (true, "Error: Cannot connect even after starting the Emacs daemon\n");
1487 exit (EXIT_FAILURE);
1490 else if (dpid < 0)
1492 fprintf (stderr, "Error: Cannot fork!\n");
1493 exit (EXIT_FAILURE);
1495 else
1497 char emacs[] = "emacs";
1498 char daemon_option[] = "--daemon";
1499 char *d_argv[3];
1500 d_argv[0] = emacs;
1501 d_argv[1] = daemon_option;
1502 d_argv[2] = 0;
1503 if (socket_name != NULL)
1505 /* Pass --daemon=socket_name as argument. */
1506 const char *deq = "--daemon=";
1507 char *daemon_arg = xmalloc (strlen (deq)
1508 + strlen (socket_name) + 1);
1509 strcpy (stpcpy (daemon_arg, deq), socket_name);
1510 d_argv[1] = daemon_arg;
1512 execvp ("emacs", d_argv);
1513 message (true, "%s: error starting emacs daemon\n", progname);
1515 #else /* WINDOWSNT */
1516 DWORD wait_result;
1517 HANDLE w32_daemon_event;
1518 STARTUPINFO si;
1519 PROCESS_INFORMATION pi;
1521 ZeroMemory (&si, sizeof si);
1522 si.cb = sizeof si;
1523 ZeroMemory (&pi, sizeof pi);
1525 /* We start Emacs in daemon mode, and then wait for it to signal us
1526 it is ready to accept client connections, by asserting an event
1527 whose name is known to the daemon (defined by nt/inc/ms-w32.h). */
1529 if (!CreateProcess (NULL, "emacs --daemon", NULL, NULL, FALSE,
1530 CREATE_NO_WINDOW, NULL, NULL, &si, &pi))
1532 char* msg = NULL;
1534 FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
1535 | FORMAT_MESSAGE_ALLOCATE_BUFFER
1536 | FORMAT_MESSAGE_ARGUMENT_ARRAY,
1537 NULL, GetLastError (), 0, (LPTSTR)&msg, 0, NULL);
1538 message (true, "%s: error starting emacs daemon (%s)\n", progname, msg);
1539 exit (EXIT_FAILURE);
1542 w32_daemon_event = CreateEvent (NULL, TRUE, FALSE, W32_DAEMON_EVENT);
1543 if (w32_daemon_event == NULL)
1545 message (true, "Couldn't create Windows daemon event");
1546 exit (EXIT_FAILURE);
1548 if ((wait_result = WaitForSingleObject (w32_daemon_event, INFINITE))
1549 != WAIT_OBJECT_0)
1551 char *msg = NULL;
1553 switch (wait_result)
1555 case WAIT_ABANDONED:
1556 msg = "The daemon exited unexpectedly";
1557 break;
1558 case WAIT_TIMEOUT:
1559 /* Can't happen due to INFINITE. */
1560 default:
1561 case WAIT_FAILED:
1562 FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
1563 | FORMAT_MESSAGE_ALLOCATE_BUFFER
1564 | FORMAT_MESSAGE_ARGUMENT_ARRAY,
1565 NULL, GetLastError (), 0, (LPTSTR)&msg, 0, NULL);
1566 break;
1568 message (true, "Error: Could not start the Emacs daemon: %s\n", msg);
1569 exit (EXIT_FAILURE);
1571 CloseHandle (w32_daemon_event);
1573 /* Try connecting, the daemon should have started by now. */
1574 /* It's just a progress message, so don't pop a dialog if this is
1575 emacsclientw. */
1576 if (!w32_window_app ())
1577 message (true,
1578 "Emacs daemon should have started, trying to connect again\n");
1579 if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1581 message (true,
1582 "Error: Cannot connect even after starting the Emacs daemon\n");
1583 exit (EXIT_FAILURE);
1585 #endif /* WINDOWSNT */
1589 main (int argc, char **argv)
1591 int rl = 0, needlf = 0;
1592 char *cwd, *str;
1593 char string[BUFSIZ+1];
1594 int start_daemon_if_needed;
1595 int exit_status = EXIT_SUCCESS;
1597 main_argv = argv;
1598 progname = argv[0];
1600 #ifdef HAVE_NTGUI
1601 /* On Windows 7 and later, we need to explicitly associate
1602 emacsclient with emacs so the UI behaves sensibly. This
1603 association does no harm if we're not actually connecting to an
1604 Emacs using a window display. */
1605 w32_set_user_model_id ();
1606 #endif /* HAVE_NTGUI */
1608 /* Process options. */
1609 decode_options (argc, argv);
1611 if ((argc - optind < 1) && !eval && current_frame)
1613 message (true, "%s: file name or argument required\n"
1614 "Try '%s --help' for more information\n",
1615 progname, progname);
1616 exit (EXIT_FAILURE);
1619 #ifndef WINDOWSNT
1620 if (tty)
1622 pid_t pgrp = getpgrp ();
1623 pid_t tcpgrp = tcgetpgrp (1);
1624 if (0 <= tcpgrp && tcpgrp != pgrp)
1625 kill (-pgrp, SIGTTIN);
1627 #endif /* !WINDOWSNT */
1629 /* If alternate_editor is the empty string, start the emacs daemon
1630 in case of failure to connect. */
1631 start_daemon_if_needed = (alternate_editor
1632 && (alternate_editor[0] == '\0'));
1634 emacs_socket = set_socket (alternate_editor || start_daemon_if_needed);
1635 if (emacs_socket == INVALID_SOCKET)
1637 if (! start_daemon_if_needed)
1638 fail ();
1640 start_daemon_and_retry_set_socket ();
1643 cwd = get_current_dir_name ();
1644 if (cwd == 0)
1646 message (true, "%s: %s\n", progname,
1647 "Cannot get current working directory");
1648 fail ();
1651 #ifdef HAVE_NTGUI
1652 if (display && !strcmp (display, "w32"))
1653 w32_give_focus ();
1654 #endif /* HAVE_NTGUI */
1656 /* Send over our environment and current directory. */
1657 if (!current_frame)
1659 int i;
1660 for (i = 0; environ[i]; i++)
1662 send_to_emacs (emacs_socket, "-env ");
1663 quote_argument (emacs_socket, environ[i]);
1664 send_to_emacs (emacs_socket, " ");
1667 send_to_emacs (emacs_socket, "-dir ");
1668 quote_argument (emacs_socket, cwd);
1669 send_to_emacs (emacs_socket, "/");
1670 send_to_emacs (emacs_socket, " ");
1672 retry:
1673 if (nowait)
1674 send_to_emacs (emacs_socket, "-nowait ");
1676 if (current_frame)
1677 send_to_emacs (emacs_socket, "-current-frame ");
1679 if (display)
1681 send_to_emacs (emacs_socket, "-display ");
1682 quote_argument (emacs_socket, display);
1683 send_to_emacs (emacs_socket, " ");
1686 if (parent_id)
1688 send_to_emacs (emacs_socket, "-parent-id ");
1689 quote_argument (emacs_socket, parent_id);
1690 send_to_emacs (emacs_socket, " ");
1693 if (frame_parameters && !current_frame)
1695 send_to_emacs (emacs_socket, "-frame-parameters ");
1696 quote_argument (emacs_socket, frame_parameters);
1697 send_to_emacs (emacs_socket, " ");
1700 /* Unless we are certain we don't want to occupy the tty, send our
1701 tty information to Emacs. For example, in daemon mode Emacs may
1702 need to occupy this tty if no other frame is available. */
1703 if (!current_frame || !eval)
1705 const char *tty_type, *tty_name;
1707 if (find_tty (&tty_type, &tty_name, !tty))
1709 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1710 init_signals ();
1711 #endif
1712 send_to_emacs (emacs_socket, "-tty ");
1713 quote_argument (emacs_socket, tty_name);
1714 send_to_emacs (emacs_socket, " ");
1715 quote_argument (emacs_socket, tty_type);
1716 send_to_emacs (emacs_socket, " ");
1720 if (!current_frame && !tty)
1721 send_to_emacs (emacs_socket, "-window-system ");
1723 if ((argc - optind > 0))
1725 int i;
1726 for (i = optind; i < argc; i++)
1729 if (eval)
1731 /* Don't prepend cwd or anything like that. */
1732 send_to_emacs (emacs_socket, "-eval ");
1733 quote_argument (emacs_socket, argv[i]);
1734 send_to_emacs (emacs_socket, " ");
1735 continue;
1738 if (*argv[i] == '+')
1740 char *p = argv[i] + 1;
1741 while (isdigit ((unsigned char) *p) || *p == ':') p++;
1742 if (*p == 0)
1744 send_to_emacs (emacs_socket, "-position ");
1745 quote_argument (emacs_socket, argv[i]);
1746 send_to_emacs (emacs_socket, " ");
1747 continue;
1750 #ifdef WINDOWSNT
1751 else if (! file_name_absolute_p (argv[i])
1752 && (isalpha (argv[i][0]) && argv[i][1] == ':'))
1753 /* Windows can have a different default directory for each
1754 drive, so the cwd passed via "-dir" is not sufficient
1755 to account for that.
1756 If the user uses <drive>:<relpath>, we hence need to be
1757 careful to expand <relpath> with the default directory
1758 corresponding to <drive>. */
1760 char *filename = (char *) xmalloc (MAX_PATH);
1761 DWORD size;
1763 size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1764 if (size > 0 && size < MAX_PATH)
1765 argv[i] = filename;
1766 else
1767 free (filename);
1769 #endif
1771 send_to_emacs (emacs_socket, "-file ");
1772 quote_argument (emacs_socket, argv[i]);
1773 send_to_emacs (emacs_socket, " ");
1776 else if (eval)
1778 /* Read expressions interactively. */
1779 while ((str = fgets (string, BUFSIZ, stdin)))
1781 send_to_emacs (emacs_socket, "-eval ");
1782 quote_argument (emacs_socket, str);
1784 send_to_emacs (emacs_socket, " ");
1787 send_to_emacs (emacs_socket, "\n");
1789 /* Wait for an answer. */
1790 if (!eval && !tty && !nowait && !quiet)
1792 printf ("Waiting for Emacs...");
1793 needlf = 2;
1795 fflush (stdout);
1796 while (fdatasync (1) != 0 && errno == EINTR)
1797 continue;
1799 /* Now, wait for an answer and print any messages. */
1800 while (exit_status == EXIT_SUCCESS)
1802 char *p, *end_p;
1805 errno = 0;
1806 rl = recv (emacs_socket, string, BUFSIZ, 0);
1808 /* If we receive a signal (e.g. SIGWINCH, which we pass
1809 through to Emacs), on some OSes we get EINTR and must retry. */
1810 while (rl < 0 && errno == EINTR);
1812 if (rl <= 0)
1813 break;
1815 string[rl] = '\0';
1817 /* Loop over all NL-terminated messages. */
1818 for (end_p = p = string; end_p != NULL && *end_p != '\0'; p = end_p)
1820 end_p = strchr (p, '\n');
1821 if (end_p != NULL)
1822 *end_p++ = '\0';
1824 if (strprefix ("-emacs-pid ", p))
1826 /* -emacs-pid PID: The process id of the Emacs process. */
1827 emacs_pid = strtol (p + strlen ("-emacs-pid"), NULL, 10);
1829 else if (strprefix ("-window-system-unsupported ", p))
1831 /* -window-system-unsupported: Emacs was compiled without support
1832 for whatever window system we tried. Try the alternate
1833 display, or, failing that, try the terminal. */
1834 if (alt_display)
1836 display = alt_display;
1837 alt_display = NULL;
1839 else
1841 nowait = 0;
1842 tty = 1;
1845 goto retry;
1847 else if (strprefix ("-print ", p))
1849 /* -print STRING: Print STRING on the terminal. */
1850 str = unquote_argument (p + strlen ("-print "));
1851 if (needlf)
1852 printf ("\n");
1853 printf ("%s", str);
1854 needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1856 else if (strprefix ("-print-nonl ", p))
1858 /* -print-nonl STRING: Print STRING on the terminal.
1859 Used to continue a preceding -print command. */
1860 str = unquote_argument (p + strlen ("-print-nonl "));
1861 printf ("%s", str);
1862 needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1864 else if (strprefix ("-error ", p))
1866 /* -error DESCRIPTION: Signal an error on the terminal. */
1867 str = unquote_argument (p + strlen ("-error "));
1868 if (needlf)
1869 printf ("\n");
1870 fprintf (stderr, "*ERROR*: %s", str);
1871 needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1872 exit_status = EXIT_FAILURE;
1874 #ifdef SIGSTOP
1875 else if (strprefix ("-suspend ", p))
1877 /* -suspend: Suspend this terminal, i.e., stop the process. */
1878 if (needlf)
1879 printf ("\n");
1880 needlf = 0;
1881 kill (0, SIGSTOP);
1883 #endif
1884 else
1886 /* Unknown command. */
1887 if (needlf)
1888 printf ("\n");
1889 needlf = 0;
1890 printf ("*ERROR*: Unknown message: %s\n", p);
1895 if (needlf)
1896 printf ("\n");
1897 fflush (stdout);
1898 while (fdatasync (1) != 0 && errno == EINTR)
1899 continue;
1901 if (rl < 0)
1902 exit_status = EXIT_FAILURE;
1904 CLOSE_SOCKET (emacs_socket);
1905 return exit_status;
1908 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */