* emacsclient.c (message): Mark it as a printf-like function.
[bpt/emacs.git] / lib-src / emacsclient.c
1 /* Client process that communicates with GNU Emacs acting as server.
2 Copyright (C) 1986-1987, 1994, 1999-2011 Free Software Foundation, Inc.
3
4 This file is part of GNU Emacs.
5
6 GNU Emacs is free software: you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation, either version 3 of the License, or
9 (at your option) any later version.
10
11 GNU Emacs is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs. If not, see <http://www.gnu.org/licenses/>. */
18
19
20 #include <config.h>
21
22 #ifdef WINDOWSNT
23
24 /* config.h defines these, which disables sockets altogether! */
25 # undef _WINSOCKAPI_
26 # undef _WINSOCK_H
27
28 # include <malloc.h>
29 # include <stdlib.h>
30 # include <windows.h>
31 # include <commctrl.h>
32 # include <io.h>
33 # include <winsock2.h>
34
35 # define NO_SOCKETS_IN_FILE_SYSTEM
36
37 # define HSOCKET SOCKET
38 # define CLOSE_SOCKET closesocket
39 # define INITIALIZE() (initialize_sockets ())
40
41 char *w32_getenv (char *);
42 #define egetenv(VAR) w32_getenv(VAR)
43
44 #else /* !WINDOWSNT */
45
46 # include "syswait.h"
47
48 # ifdef HAVE_INET_SOCKETS
49 # include <netinet/in.h>
50 # ifdef HAVE_SOCKETS
51 # include <sys/types.h>
52 # include <sys/socket.h>
53 # include <sys/un.h>
54 # endif /* HAVE_SOCKETS */
55 # endif
56 # include <arpa/inet.h>
57
58 # define INVALID_SOCKET -1
59 # define HSOCKET int
60 # define CLOSE_SOCKET close
61 # define INITIALIZE()
62
63 # ifndef WCONTINUED
64 # define WCONTINUED 8
65 # endif
66
67 #define egetenv(VAR) getenv(VAR)
68
69 #endif /* !WINDOWSNT */
70
71 #undef signal
72
73 #include <stdarg.h>
74 #include <ctype.h>
75 #include <stdio.h>
76 #include <getopt.h>
77 #include <unistd.h>
78
79 #include <pwd.h>
80 #include <sys/stat.h>
81 #include <signal.h>
82 #include <errno.h>
83
84
85 \f
86 char *getenv (const char *), *getwd (char *);
87 #ifdef HAVE_GETCWD
88 char *(getcwd) (char *, size_t);
89 #endif
90
91 #ifndef VERSION
92 #define VERSION "unspecified"
93 #endif
94 \f
95
96 #ifndef EXIT_SUCCESS
97 #define EXIT_SUCCESS 0
98 #endif
99
100 #ifndef EXIT_FAILURE
101 #define EXIT_FAILURE 1
102 #endif
103
104 #ifndef FALSE
105 #define FALSE 0
106 #endif
107
108 #ifndef TRUE
109 #define TRUE 1
110 #endif
111
112 /* Additional space when allocating buffers for filenames, etc. */
113 #define EXTRA_SPACE 100
114
115 /* Use this to suppress gcc's `...may be used before initialized' warnings. */
116 #ifdef lint
117 # define IF_LINT(Code) Code
118 #else
119 # define IF_LINT(Code) /* empty */
120 #endif
121
122 \f
123 /* Name used to invoke this program. */
124 const char *progname;
125
126 /* The second argument to main. */
127 char **main_argv;
128
129 /* Nonzero means don't wait for a response from Emacs. --no-wait. */
130 int nowait = 0;
131
132 /* Nonzero means don't print messages for successful operations. --quiet. */
133 int quiet = 0;
134
135 /* Nonzero means args are expressions to be evaluated. --eval. */
136 int eval = 0;
137
138 /* Nonzero means don't open a new frame. Inverse of --create-frame. */
139 int current_frame = 1;
140
141 /* The display on which Emacs should work. --display. */
142 const char *display = NULL;
143
144 /* The parent window ID, if we are opening a frame via XEmbed. */
145 char *parent_id = NULL;
146
147 /* Nonzero means open a new Emacs frame on the current terminal. */
148 int tty = 0;
149
150 /* If non-NULL, the name of an editor to fallback to if the server
151 is not running. --alternate-editor. */
152 const char *alternate_editor = NULL;
153
154 /* If non-NULL, the filename of the UNIX socket. */
155 char *socket_name = NULL;
156
157 /* If non-NULL, the filename of the authentication file. */
158 const char *server_file = NULL;
159
160 /* PID of the Emacs server process. */
161 int emacs_pid = 0;
162
163 static void print_help_and_exit (void) NO_RETURN;
164 static void fail (void) NO_RETURN;
165
166
167 struct option longopts[] =
168 {
169 { "no-wait", no_argument, NULL, 'n' },
170 { "quiet", no_argument, NULL, 'q' },
171 { "eval", no_argument, NULL, 'e' },
172 { "help", no_argument, NULL, 'H' },
173 { "version", no_argument, NULL, 'V' },
174 { "tty", no_argument, NULL, 't' },
175 { "nw", no_argument, NULL, 't' },
176 { "create-frame", no_argument, NULL, 'c' },
177 { "alternate-editor", required_argument, NULL, 'a' },
178 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
179 { "socket-name", required_argument, NULL, 's' },
180 #endif
181 { "server-file", required_argument, NULL, 'f' },
182 #ifndef WINDOWSNT
183 { "display", required_argument, NULL, 'd' },
184 #endif
185 { "parent-id", required_argument, NULL, 'p' },
186 { 0, 0, 0, 0 }
187 };
188
189 \f
190 /* Like malloc but get fatal error if memory is exhausted. */
191
192 static long *
193 xmalloc (unsigned int size)
194 {
195 long *result = (long *) malloc (size);
196 if (result == NULL)
197 {
198 perror ("malloc");
199 exit (EXIT_FAILURE);
200 }
201 return result;
202 }
203
204 /* From sysdep.c */
205 #if !defined (HAVE_GET_CURRENT_DIR_NAME) || defined (BROKEN_GET_CURRENT_DIR_NAME)
206
207 /* From lisp.h */
208 #ifndef DIRECTORY_SEP
209 #define DIRECTORY_SEP '/'
210 #endif
211 #ifndef IS_DIRECTORY_SEP
212 #define IS_DIRECTORY_SEP(_c_) ((_c_) == DIRECTORY_SEP)
213 #endif
214 #ifndef IS_DEVICE_SEP
215 #ifndef DEVICE_SEP
216 #define IS_DEVICE_SEP(_c_) 0
217 #else
218 #define IS_DEVICE_SEP(_c_) ((_c_) == DEVICE_SEP)
219 #endif
220 #endif
221 #ifndef IS_ANY_SEP
222 #define IS_ANY_SEP(_c_) (IS_DIRECTORY_SEP (_c_))
223 #endif
224
225
226 /* Return the current working directory. Returns NULL on errors.
227 Any other returned value must be freed with free. This is used
228 only when get_current_dir_name is not defined on the system. */
229 char*
230 get_current_dir_name (void)
231 {
232 char *buf;
233 const char *pwd;
234 struct stat dotstat, pwdstat;
235 /* If PWD is accurate, use it instead of calling getwd. PWD is
236 sometimes a nicer name, and using it may avoid a fatal error if a
237 parent directory is searchable but not readable. */
238 if ((pwd = egetenv ("PWD")) != 0
239 && (IS_DIRECTORY_SEP (*pwd) || (*pwd && IS_DEVICE_SEP (pwd[1])))
240 && stat (pwd, &pwdstat) == 0
241 && stat (".", &dotstat) == 0
242 && dotstat.st_ino == pwdstat.st_ino
243 && dotstat.st_dev == pwdstat.st_dev
244 #ifdef MAXPATHLEN
245 && strlen (pwd) < MAXPATHLEN
246 #endif
247 )
248 {
249 buf = (char *) xmalloc (strlen (pwd) + 1);
250 if (!buf)
251 return NULL;
252 strcpy (buf, pwd);
253 }
254 #ifdef HAVE_GETCWD
255 else
256 {
257 size_t buf_size = 1024;
258 buf = (char *) xmalloc (buf_size);
259 if (!buf)
260 return NULL;
261 for (;;)
262 {
263 if (getcwd (buf, buf_size) == buf)
264 break;
265 if (errno != ERANGE)
266 {
267 int tmp_errno = errno;
268 free (buf);
269 errno = tmp_errno;
270 return NULL;
271 }
272 buf_size *= 2;
273 buf = (char *) realloc (buf, buf_size);
274 if (!buf)
275 return NULL;
276 }
277 }
278 #else
279 else
280 {
281 /* We need MAXPATHLEN here. */
282 buf = (char *) xmalloc (MAXPATHLEN + 1);
283 if (!buf)
284 return NULL;
285 if (getwd (buf) == NULL)
286 {
287 int tmp_errno = errno;
288 free (buf);
289 errno = tmp_errno;
290 return NULL;
291 }
292 }
293 #endif
294 return buf;
295 }
296 #endif
297
298 #ifdef WINDOWSNT
299
300 /* Like strdup but get a fatal error if memory is exhausted. */
301
302 char *
303 xstrdup (const char *s)
304 {
305 char *result = strdup (s);
306 if (result == NULL)
307 {
308 perror ("strdup");
309 exit (EXIT_FAILURE);
310 }
311 return result;
312 }
313
314 #define REG_ROOT "SOFTWARE\\GNU\\Emacs"
315
316 /* Retrieve an environment variable from the Emacs subkeys of the registry.
317 Return NULL if the variable was not found, or it was empty.
318 This code is based on w32_get_resource (w32.c). */
319 char *
320 w32_get_resource (HKEY predefined, char *key, LPDWORD type)
321 {
322 HKEY hrootkey = NULL;
323 char *result = NULL;
324 DWORD cbData;
325
326 if (RegOpenKeyEx (predefined, REG_ROOT, 0, KEY_READ, &hrootkey) == ERROR_SUCCESS)
327 {
328 if (RegQueryValueEx (hrootkey, key, NULL, NULL, NULL, &cbData) == ERROR_SUCCESS)
329 {
330 result = (char *) xmalloc (cbData);
331
332 if ((RegQueryValueEx (hrootkey, key, NULL, type, result, &cbData) != ERROR_SUCCESS)
333 || (*result == 0))
334 {
335 free (result);
336 result = NULL;
337 }
338 }
339
340 RegCloseKey (hrootkey);
341 }
342
343 return result;
344 }
345
346 /*
347 getenv wrapper for Windows
348
349 Value is allocated on the heap, and can be free'd.
350
351 This is needed to duplicate Emacs's behavior, which is to look for
352 environment variables in the registry if they don't appear in the
353 environment. */
354 char *
355 w32_getenv (char *envvar)
356 {
357 char *value;
358 DWORD dwType;
359
360 if (value = getenv (envvar))
361 /* Found in the environment. strdup it, because values returned
362 by getenv cannot be free'd. */
363 return xstrdup (value);
364
365 if (! (value = w32_get_resource (HKEY_CURRENT_USER, envvar, &dwType)) &&
366 ! (value = w32_get_resource (HKEY_LOCAL_MACHINE, envvar, &dwType)))
367 {
368 /* "w32console" is what Emacs on Windows uses for tty-type under -nw. */
369 if (strcmp (envvar, "TERM") == 0)
370 return xstrdup ("w32console");
371 /* Found neither in the environment nor in the registry. */
372 return NULL;
373 }
374
375 if (dwType == REG_SZ)
376 /* Registry; no need to expand. */
377 return value;
378
379 if (dwType == REG_EXPAND_SZ)
380 {
381 DWORD size;
382
383 if (size = ExpandEnvironmentStrings (value, NULL, 0))
384 {
385 char *buffer = (char *) xmalloc (size);
386 if (ExpandEnvironmentStrings (value, buffer, size))
387 {
388 /* Found and expanded. */
389 free (value);
390 return buffer;
391 }
392
393 /* Error expanding. */
394 free (buffer);
395 }
396 }
397
398 /* Not the right type, or not correctly expanded. */
399 free (value);
400 return NULL;
401 }
402
403 void
404 w32_set_user_model_id (void)
405 {
406 HMODULE shell;
407 HRESULT (WINAPI * set_user_model) (wchar_t * id);
408
409 /* On Windows 7 and later, we need to set the user model ID
410 to associate emacsclient launched files with Emacs frames
411 in the UI. */
412 shell = LoadLibrary ("shell32.dll");
413 if (shell)
414 {
415 set_user_model
416 = (void *) GetProcAddress (shell,
417 "SetCurrentProcessExplicitAppUserModelID");
418 /* If the function is defined, then we are running on Windows 7
419 or newer, and the UI uses this to group related windows
420 together. Since emacs, runemacs, emacsclient are related, we
421 want them grouped even though the executables are different,
422 so we need to set a consistent ID between them. */
423 if (set_user_model)
424 set_user_model (L"GNU.Emacs");
425
426 FreeLibrary (shell);
427 }
428 }
429
430 int
431 w32_window_app (void)
432 {
433 static int window_app = -1;
434 char szTitle[MAX_PATH];
435
436 if (window_app < 0)
437 {
438 /* Checking for STDOUT does not work; it's a valid handle also in
439 nonconsole apps. Testing for the console title seems to work. */
440 window_app = (GetConsoleTitleA (szTitle, MAX_PATH) == 0);
441 if (window_app)
442 InitCommonControls ();
443 }
444
445 return window_app;
446 }
447
448 /*
449 execvp wrapper for Windows. Quotes arguments with embedded spaces.
450
451 This is necessary due to the broken implementation of exec* routines in
452 the Microsoft libraries: they concatenate the arguments together without
453 quoting special characters, and pass the result to CreateProcess, with
454 predictably bad results. By contrast, POSIX execvp passes the arguments
455 directly into the argv array of the child process.
456 */
457 int
458 w32_execvp (const char *path, char **argv)
459 {
460 int i;
461
462 /* Required to allow a .BAT script as alternate editor. */
463 argv[0] = (char *) alternate_editor;
464
465 for (i = 0; argv[i]; i++)
466 if (strchr (argv[i], ' '))
467 {
468 char *quoted = alloca (strlen (argv[i]) + 3);
469 sprintf (quoted, "\"%s\"", argv[i]);
470 argv[i] = quoted;
471 }
472
473 return execvp (path, argv);
474 }
475
476 #undef execvp
477 #define execvp w32_execvp
478
479 /* Emulation of ttyname for Windows. */
480 char *
481 ttyname (int fd)
482 {
483 return "CONOUT$";
484 }
485
486 #endif /* WINDOWSNT */
487
488 /* Display a normal or error message.
489 On Windows, use a message box if compiled as a Windows app. */
490 static void message (int, const char *, ...) ATTRIBUTE_FORMAT_PRINTF (2, 3);
491 static void
492 message (int is_error, const char *format, ...)
493 {
494 char msg[2048];
495 va_list args;
496
497 va_start (args, format);
498 vsprintf (msg, format, args);
499 va_end (args);
500
501 #ifdef WINDOWSNT
502 if (w32_window_app ())
503 {
504 if (is_error)
505 MessageBox (NULL, msg, "Emacsclient ERROR", MB_ICONERROR);
506 else
507 MessageBox (NULL, msg, "Emacsclient", MB_ICONINFORMATION);
508 }
509 else
510 #endif
511 {
512 FILE *f = is_error ? stderr : stdout;
513
514 fputs (msg, f);
515 fflush (f);
516 }
517 }
518
519 /* Decode the options from argv and argc.
520 The global variable `optind' will say how many arguments we used up. */
521
522 static void
523 decode_options (int argc, char **argv)
524 {
525 alternate_editor = egetenv ("ALTERNATE_EDITOR");
526
527 while (1)
528 {
529 int opt = getopt_long_only (argc, argv,
530 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
531 "VHneqa:s:f:d:tc",
532 #else
533 "VHneqa:f:d:tc",
534 #endif
535 longopts, 0);
536
537 if (opt == EOF)
538 break;
539
540 switch (opt)
541 {
542 case 0:
543 /* If getopt returns 0, then it has already processed a
544 long-named option. We should do nothing. */
545 break;
546
547 case 'a':
548 alternate_editor = optarg;
549 break;
550
551 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
552 case 's':
553 socket_name = optarg;
554 break;
555 #endif
556
557 case 'f':
558 server_file = optarg;
559 break;
560
561 /* We used to disallow this argument in w32, but it seems better
562 to allow it, for the occasional case where the user is
563 connecting with a w32 client to a server compiled with X11
564 support. */
565 case 'd':
566 display = optarg;
567 break;
568
569 case 'n':
570 nowait = 1;
571 break;
572
573 case 'e':
574 eval = 1;
575 break;
576
577 case 'q':
578 quiet = 1;
579 break;
580
581 case 'V':
582 message (FALSE, "emacsclient %s\n", VERSION);
583 exit (EXIT_SUCCESS);
584 break;
585
586 case 't':
587 tty = 1;
588 current_frame = 0;
589 break;
590
591 case 'c':
592 current_frame = 0;
593 break;
594
595 case 'p':
596 parent_id = optarg;
597 current_frame = 0;
598 break;
599
600 case 'H':
601 print_help_and_exit ();
602 break;
603
604 default:
605 message (TRUE, "Try `%s --help' for more information\n", progname);
606 exit (EXIT_FAILURE);
607 break;
608 }
609 }
610
611 /* If the -c option is used (without -t) and no --display argument
612 is provided, try $DISPLAY.
613 Without the -c option, we used to set `display' to $DISPLAY by
614 default, but this changed the default behavior and is sometimes
615 inconvenient. So we force users to use "--display $DISPLAY" if
616 they want Emacs to connect to their current display. */
617 if (!current_frame && !tty && !display)
618 {
619 display = egetenv ("DISPLAY");
620 #ifdef NS_IMPL_COCOA
621 /* Under Cocoa, we don't really use displays the same way as in X,
622 so provide a dummy. */
623 if (!display || strlen (display) == 0)
624 display = "ns";
625 #endif
626 }
627
628 /* A null-string display is invalid. */
629 if (display && strlen (display) == 0)
630 display = NULL;
631
632 /* If no display is available, new frames are tty frames. */
633 if (!current_frame && !display)
634 tty = 1;
635
636 /* --no-wait implies --current-frame on ttys when there are file
637 arguments or expressions given. */
638 if (nowait && tty && argc - optind > 0)
639 current_frame = 1;
640
641 #ifdef WINDOWSNT
642 if (alternate_editor && alternate_editor[0] == '\0')
643 {
644 message (TRUE, "--alternate-editor argument or ALTERNATE_EDITOR variable cannot be\n\
645 an empty string");
646 exit (EXIT_FAILURE);
647 }
648 #endif /* WINDOWSNT */
649 }
650
651 \f
652 static void
653 print_help_and_exit (void)
654 {
655 /* Spaces and tabs are significant in this message; they're chosen so the
656 message aligns properly both in a tty and in a Windows message box.
657 Please try to preserve them; otherwise the output is very hard to read
658 when using emacsclientw. */
659 message (FALSE,
660 "Usage: %s [OPTIONS] FILE...\n\
661 Tell the Emacs server to visit the specified files.\n\
662 Every FILE can be either just a FILENAME or [+LINE[:COLUMN]] FILENAME.\n\
663 \n\
664 The following OPTIONS are accepted:\n\
665 -V, --version Just print version info and return\n\
666 -H, --help Print this usage information message\n\
667 -nw, -t, --tty Open a new Emacs frame on the current terminal\n\
668 -c, --create-frame Create a new frame instead of trying to\n\
669 use the current Emacs frame\n\
670 -e, --eval Evaluate the FILE arguments as ELisp expressions\n\
671 -n, --no-wait Don't wait for the server to return\n\
672 -q, --quiet Don't display messages on success\n\
673 -d DISPLAY, --display=DISPLAY\n\
674 Visit the file in the given display\n\
675 --parent-id=ID Open in parent window ID, via XEmbed\n"
676 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
677 "-s SOCKET, --socket-name=SOCKET\n\
678 Set filename of the UNIX socket for communication\n"
679 #endif
680 "-f SERVER, --server-file=SERVER\n\
681 Set filename of the TCP authentication file\n\
682 -a EDITOR, --alternate-editor=EDITOR\n\
683 Editor to fallback to if the server is not running\n"
684 #ifndef WINDOWSNT
685 " If EDITOR is the empty string, start Emacs in daemon\n\
686 mode and try connecting again\n"
687 #endif /* not WINDOWSNT */
688 "\n\
689 Report bugs with M-x report-emacs-bug.\n", progname);
690 exit (EXIT_SUCCESS);
691 }
692
693 /*
694 Try to run a different command, or --if no alternate editor is
695 defined-- exit with an errorcode.
696 Uses argv, but gets it from the global variable main_argv.
697 */
698 static void
699 fail (void)
700 {
701 if (alternate_editor)
702 {
703 int i = optind - 1;
704
705 execvp (alternate_editor, main_argv + i);
706 message (TRUE, "%s: error executing alternate editor \"%s\"\n",
707 progname, alternate_editor);
708 }
709 exit (EXIT_FAILURE);
710 }
711
712 \f
713 #if !defined (HAVE_SOCKETS) || !defined (HAVE_INET_SOCKETS)
714
715 int
716 main (int argc, char **argv)
717 {
718 main_argv = argv;
719 progname = argv[0];
720 message (TRUE, "%s: Sorry, the Emacs server is supported only\n"
721 "on systems with Berkeley sockets.\n",
722 argv[0]);
723 fail ();
724 }
725
726 #else /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
727
728 #define AUTH_KEY_LENGTH 64
729 #define SEND_BUFFER_SIZE 4096
730
731 extern char *strerror (int);
732
733 /* Buffer to accumulate data to send in TCP connections. */
734 char send_buffer[SEND_BUFFER_SIZE + 1];
735 int sblen = 0; /* Fill pointer for the send buffer. */
736 /* Socket used to communicate with the Emacs server process. */
737 HSOCKET emacs_socket = 0;
738
739 /* On Windows, the socket library was historically separate from the standard
740 C library, so errors are handled differently. */
741 static void
742 sock_err_message (const char *function_name)
743 {
744 #ifdef WINDOWSNT
745 char* msg = NULL;
746
747 FormatMessage (FORMAT_MESSAGE_FROM_SYSTEM
748 | FORMAT_MESSAGE_ALLOCATE_BUFFER
749 | FORMAT_MESSAGE_ARGUMENT_ARRAY,
750 NULL, WSAGetLastError (), 0, (LPTSTR)&msg, 0, NULL);
751
752 message (TRUE, "%s: %s: %s\n", progname, function_name, msg);
753
754 LocalFree (msg);
755 #else
756 message (TRUE, "%s: %s: %s\n", progname, function_name, strerror (errno));
757 #endif
758 }
759
760
761 /* Let's send the data to Emacs when either
762 - the data ends in "\n", or
763 - the buffer is full (but this shouldn't happen)
764 Otherwise, we just accumulate it. */
765 static void
766 send_to_emacs (HSOCKET s, const char *data)
767 {
768 while (data)
769 {
770 size_t dlen = strlen (data);
771 if (dlen + sblen >= SEND_BUFFER_SIZE)
772 {
773 int part = SEND_BUFFER_SIZE - sblen;
774 strncpy (&send_buffer[sblen], data, part);
775 data += part;
776 sblen = SEND_BUFFER_SIZE;
777 }
778 else if (dlen)
779 {
780 strcpy (&send_buffer[sblen], data);
781 data = NULL;
782 sblen += dlen;
783 }
784 else
785 break;
786
787 if (sblen == SEND_BUFFER_SIZE
788 || (sblen > 0 && send_buffer[sblen-1] == '\n'))
789 {
790 int sent = send (s, send_buffer, sblen, 0);
791 if (sent != sblen)
792 strcpy (send_buffer, &send_buffer[sent]);
793 sblen -= sent;
794 }
795 }
796 }
797
798 \f
799 /* In STR, insert a & before each &, each space, each newline, and
800 any initial -. Change spaces to underscores, too, so that the
801 return value never contains a space.
802
803 Does not change the string. Outputs the result to S. */
804 static void
805 quote_argument (HSOCKET s, const char *str)
806 {
807 char *copy = (char *) xmalloc (strlen (str) * 2 + 1);
808 const char *p;
809 char *q;
810
811 p = str;
812 q = copy;
813 while (*p)
814 {
815 if (*p == ' ')
816 {
817 *q++ = '&';
818 *q++ = '_';
819 p++;
820 }
821 else if (*p == '\n')
822 {
823 *q++ = '&';
824 *q++ = 'n';
825 p++;
826 }
827 else
828 {
829 if (*p == '&' || (*p == '-' && p == str))
830 *q++ = '&';
831 *q++ = *p++;
832 }
833 }
834 *q++ = 0;
835
836 send_to_emacs (s, copy);
837
838 free (copy);
839 }
840
841
842 /* The inverse of quote_argument. Removes quoting in string STR by
843 modifying the string in place. Returns STR. */
844
845 static char *
846 unquote_argument (char *str)
847 {
848 char *p, *q;
849
850 if (! str)
851 return str;
852
853 p = str;
854 q = str;
855 while (*p)
856 {
857 if (*p == '&')
858 {
859 p++;
860 if (*p == '&')
861 *p = '&';
862 else if (*p == '_')
863 *p = ' ';
864 else if (*p == 'n')
865 *p = '\n';
866 else if (*p == '-')
867 *p = '-';
868 }
869 *q++ = *p++;
870 }
871 *q = 0;
872 return str;
873 }
874
875 \f
876 static int
877 file_name_absolute_p (const char *filename)
878 {
879 /* Sanity check, it shouldn't happen. */
880 if (! filename) return FALSE;
881
882 /* /xxx is always an absolute path. */
883 if (filename[0] == '/') return TRUE;
884
885 /* Empty filenames (which shouldn't happen) are relative. */
886 if (filename[0] == '\0') return FALSE;
887
888 #ifdef WINDOWSNT
889 /* X:\xxx is always absolute. */
890 if (isalpha ((unsigned char) filename[0])
891 && filename[1] == ':' && (filename[2] == '\\' || filename[2] == '/'))
892 return TRUE;
893
894 /* Both \xxx and \\xxx\yyy are absolute. */
895 if (filename[0] == '\\') return TRUE;
896 #endif
897
898 return FALSE;
899 }
900
901 #ifdef WINDOWSNT
902 /* Wrapper to make WSACleanup a cdecl, as required by atexit. */
903 void __cdecl
904 close_winsock (void)
905 {
906 WSACleanup ();
907 }
908
909 /* Initialize the WinSock2 library. */
910 void
911 initialize_sockets (void)
912 {
913 WSADATA wsaData;
914
915 if (WSAStartup (MAKEWORD (2, 0), &wsaData))
916 {
917 message (TRUE, "%s: error initializing WinSock2\n", progname);
918 exit (EXIT_FAILURE);
919 }
920
921 atexit (close_winsock);
922 }
923 #endif /* WINDOWSNT */
924
925 \f
926 /*
927 * Read the information needed to set up a TCP comm channel with
928 * the Emacs server: host, port, and authentication string.
929 */
930 static int
931 get_server_config (struct sockaddr_in *server, char *authentication)
932 {
933 char dotted[32];
934 char *port;
935 FILE *config = NULL;
936
937 if (file_name_absolute_p (server_file))
938 config = fopen (server_file, "rb");
939 else
940 {
941 const char *home = egetenv ("HOME");
942
943 if (home)
944 {
945 char *path = alloca (strlen (home) + strlen (server_file)
946 + EXTRA_SPACE);
947 sprintf (path, "%s/.emacs.d/server/%s", home, server_file);
948 config = fopen (path, "rb");
949 }
950 #ifdef WINDOWSNT
951 if (!config && (home = egetenv ("APPDATA")))
952 {
953 char *path = alloca (strlen (home) + strlen (server_file)
954 + EXTRA_SPACE);
955 sprintf (path, "%s/.emacs.d/server/%s", home, server_file);
956 config = fopen (path, "rb");
957 }
958 #endif
959 }
960
961 if (! config)
962 return FALSE;
963
964 if (fgets (dotted, sizeof dotted, config)
965 && (port = strchr (dotted, ':')))
966 *port++ = '\0';
967 else
968 {
969 message (TRUE, "%s: invalid configuration info\n", progname);
970 exit (EXIT_FAILURE);
971 }
972
973 server->sin_family = AF_INET;
974 server->sin_addr.s_addr = inet_addr (dotted);
975 server->sin_port = htons (atoi (port));
976
977 if (! fread (authentication, AUTH_KEY_LENGTH, 1, config))
978 {
979 message (TRUE, "%s: cannot read authentication info\n", progname);
980 exit (EXIT_FAILURE);
981 }
982
983 fclose (config);
984
985 return TRUE;
986 }
987
988 static HSOCKET
989 set_tcp_socket (void)
990 {
991 HSOCKET s;
992 struct sockaddr_in server;
993 struct linger l_arg = {1, 1};
994 char auth_string[AUTH_KEY_LENGTH + 1];
995
996 if (! get_server_config (&server, auth_string))
997 return INVALID_SOCKET;
998
999 if (server.sin_addr.s_addr != inet_addr ("127.0.0.1") && !quiet)
1000 message (FALSE, "%s: connected to remote socket at %s\n",
1001 progname, inet_ntoa (server.sin_addr));
1002
1003 /*
1004 * Open up an AF_INET socket
1005 */
1006 if ((s = socket (AF_INET, SOCK_STREAM, IPPROTO_TCP)) < 0)
1007 {
1008 sock_err_message ("socket");
1009 return INVALID_SOCKET;
1010 }
1011
1012 /*
1013 * Set up the socket
1014 */
1015 if (connect (s, (struct sockaddr *) &server, sizeof server) < 0)
1016 {
1017 sock_err_message ("connect");
1018 return INVALID_SOCKET;
1019 }
1020
1021 setsockopt (s, SOL_SOCKET, SO_LINGER, (char *) &l_arg, sizeof l_arg);
1022
1023 /*
1024 * Send the authentication
1025 */
1026 auth_string[AUTH_KEY_LENGTH] = '\0';
1027
1028 send_to_emacs (s, "-auth ");
1029 send_to_emacs (s, auth_string);
1030 send_to_emacs (s, " ");
1031
1032 return s;
1033 }
1034
1035
1036 /* Returns 1 if PREFIX is a prefix of STRING. */
1037 static int
1038 strprefix (const char *prefix, const char *string)
1039 {
1040 return !strncmp (prefix, string, strlen (prefix));
1041 }
1042
1043 /* Get tty name and type. If successful, return the type in TTY_TYPE
1044 and the name in TTY_NAME, and return 1. Otherwise, fail if NOABORT
1045 is zero, or return 0 if NOABORT is non-zero. */
1046
1047 static int
1048 find_tty (const char **tty_type, const char **tty_name, int noabort)
1049 {
1050 const char *type = egetenv ("TERM");
1051 const char *name = ttyname (fileno (stdout));
1052
1053 if (!name)
1054 {
1055 if (noabort)
1056 return 0;
1057 else
1058 {
1059 message (TRUE, "%s: could not get terminal name\n", progname);
1060 fail ();
1061 }
1062 }
1063
1064 if (!type)
1065 {
1066 if (noabort)
1067 return 0;
1068 else
1069 {
1070 message (TRUE, "%s: please set the TERM variable to your terminal type\n",
1071 progname);
1072 fail ();
1073 }
1074 }
1075
1076 if (strcmp (type, "eterm") == 0)
1077 {
1078 if (noabort)
1079 return 0;
1080 else
1081 {
1082 /* This causes nasty, MULTI_KBOARD-related input lockouts. */
1083 message (TRUE, "%s: opening a frame in an Emacs term buffer"
1084 " is not supported\n", progname);
1085 fail ();
1086 }
1087 }
1088
1089 *tty_name = name;
1090 *tty_type = type;
1091 return 1;
1092 }
1093
1094
1095 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1096
1097 /* Three possibilities:
1098 2 - can't be `stat'ed (sets errno)
1099 1 - isn't owned by us
1100 0 - success: none of the above */
1101
1102 static int
1103 socket_status (char *name)
1104 {
1105 struct stat statbfr;
1106
1107 if (stat (name, &statbfr) == -1)
1108 return 2;
1109
1110 if (statbfr.st_uid != geteuid ())
1111 return 1;
1112
1113 return 0;
1114 }
1115
1116 \f
1117 /* A signal handler that passes the signal to the Emacs process.
1118 Useful for SIGWINCH. */
1119
1120 static void
1121 pass_signal_to_emacs (int signalnum)
1122 {
1123 int old_errno = errno;
1124
1125 if (emacs_pid)
1126 kill (emacs_pid, signalnum);
1127
1128 signal (signalnum, pass_signal_to_emacs);
1129 errno = old_errno;
1130 }
1131
1132 /* Signal handler for SIGCONT; notify the Emacs process that it can
1133 now resume our tty frame. */
1134
1135 static void
1136 handle_sigcont (int signalnum)
1137 {
1138 int old_errno = errno;
1139
1140 if (tcgetpgrp (1) == getpgrp ())
1141 {
1142 /* We are in the foreground. */
1143 send_to_emacs (emacs_socket, "-resume \n");
1144 }
1145 else
1146 {
1147 /* We are in the background; cancel the continue. */
1148 kill (getpid (), SIGSTOP);
1149 }
1150
1151 signal (signalnum, handle_sigcont);
1152 errno = old_errno;
1153 }
1154
1155 /* Signal handler for SIGTSTP; notify the Emacs process that we are
1156 going to sleep. Normally the suspend is initiated by Emacs via
1157 server-handle-suspend-tty, but if the server gets out of sync with
1158 reality, we may get a SIGTSTP on C-z. Handling this signal and
1159 notifying Emacs about it should get things under control again. */
1160
1161 static void
1162 handle_sigtstp (int signalnum)
1163 {
1164 int old_errno = errno;
1165 sigset_t set;
1166
1167 if (emacs_socket)
1168 send_to_emacs (emacs_socket, "-suspend \n");
1169
1170 /* Unblock this signal and call the default handler by temporarily
1171 changing the handler and resignalling. */
1172 sigprocmask (SIG_BLOCK, NULL, &set);
1173 sigdelset (&set, signalnum);
1174 signal (signalnum, SIG_DFL);
1175 kill (getpid (), signalnum);
1176 sigprocmask (SIG_SETMASK, &set, NULL); /* Let's the above signal through. */
1177 signal (signalnum, handle_sigtstp);
1178
1179 errno = old_errno;
1180 }
1181
1182
1183 /* Set up signal handlers before opening a frame on the current tty. */
1184
1185 static void
1186 init_signals (void)
1187 {
1188 /* Set up signal handlers. */
1189 signal (SIGWINCH, pass_signal_to_emacs);
1190
1191 /* Don't pass SIGINT and SIGQUIT to Emacs, because it has no way of
1192 deciding which terminal the signal came from. C-g is now a
1193 normal input event on secondary terminals. */
1194 #if 0
1195 signal (SIGINT, pass_signal_to_emacs);
1196 signal (SIGQUIT, pass_signal_to_emacs);
1197 #endif
1198
1199 signal (SIGCONT, handle_sigcont);
1200 signal (SIGTSTP, handle_sigtstp);
1201 signal (SIGTTOU, handle_sigtstp);
1202 }
1203
1204
1205 static HSOCKET
1206 set_local_socket (void)
1207 {
1208 HSOCKET s;
1209 struct sockaddr_un server;
1210
1211 /*
1212 * Open up an AF_UNIX socket in this person's home directory
1213 */
1214
1215 if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
1216 {
1217 message (TRUE, "%s: socket: %s\n", progname, strerror (errno));
1218 return INVALID_SOCKET;
1219 }
1220
1221 server.sun_family = AF_UNIX;
1222
1223 {
1224 int sock_status = 0;
1225 int default_sock = !socket_name;
1226 int saved_errno = 0;
1227 const char *server_name = "server";
1228 const char *tmpdir IF_LINT ( = NULL);
1229
1230 if (socket_name && !strchr (socket_name, '/')
1231 && !strchr (socket_name, '\\'))
1232 {
1233 /* socket_name is a file name component. */
1234 server_name = socket_name;
1235 socket_name = NULL;
1236 default_sock = 1; /* Try both UIDs. */
1237 }
1238
1239 if (default_sock)
1240 {
1241 tmpdir = egetenv ("TMPDIR");
1242 if (!tmpdir)
1243 {
1244 #ifdef DARWIN_OS
1245 #ifndef _CS_DARWIN_USER_TEMP_DIR
1246 #define _CS_DARWIN_USER_TEMP_DIR 65537
1247 #endif
1248 size_t n = confstr (_CS_DARWIN_USER_TEMP_DIR, NULL, (size_t) 0);
1249 if (n > 0)
1250 {
1251 tmpdir = alloca (n);
1252 confstr (_CS_DARWIN_USER_TEMP_DIR, tmpdir, n);
1253 }
1254 else
1255 #endif
1256 tmpdir = "/tmp";
1257 }
1258 socket_name = alloca (strlen (tmpdir) + strlen (server_name)
1259 + EXTRA_SPACE);
1260 sprintf (socket_name, "%s/emacs%d/%s",
1261 tmpdir, (int) geteuid (), server_name);
1262 }
1263
1264 if (strlen (socket_name) < sizeof (server.sun_path))
1265 strcpy (server.sun_path, socket_name);
1266 else
1267 {
1268 message (TRUE, "%s: socket-name %s too long\n",
1269 progname, socket_name);
1270 fail ();
1271 }
1272
1273 /* See if the socket exists, and if it's owned by us. */
1274 sock_status = socket_status (server.sun_path);
1275 saved_errno = errno;
1276 if (sock_status && default_sock)
1277 {
1278 /* Failing that, see if LOGNAME or USER exist and differ from
1279 our euid. If so, look for a socket based on the UID
1280 associated with the name. This is reminiscent of the logic
1281 that init_editfns uses to set the global Vuser_full_name. */
1282
1283 const char *user_name = egetenv ("LOGNAME");
1284
1285 if (!user_name)
1286 user_name = egetenv ("USER");
1287
1288 if (user_name)
1289 {
1290 struct passwd *pw = getpwnam (user_name);
1291
1292 if (pw && (pw->pw_uid != geteuid ()))
1293 {
1294 /* We're running under su, apparently. */
1295 socket_name = alloca (strlen (tmpdir) + strlen (server_name)
1296 + EXTRA_SPACE);
1297 sprintf (socket_name, "%s/emacs%d/%s",
1298 tmpdir, (int) pw->pw_uid, server_name);
1299
1300 if (strlen (socket_name) < sizeof (server.sun_path))
1301 strcpy (server.sun_path, socket_name);
1302 else
1303 {
1304 message (TRUE, "%s: socket-name %s too long\n",
1305 progname, socket_name);
1306 exit (EXIT_FAILURE);
1307 }
1308
1309 sock_status = socket_status (server.sun_path);
1310 saved_errno = errno;
1311 }
1312 else
1313 errno = saved_errno;
1314 }
1315 }
1316
1317 switch (sock_status)
1318 {
1319 case 1:
1320 /* There's a socket, but it isn't owned by us. This is OK if
1321 we are root. */
1322 if (0 != geteuid ())
1323 {
1324 message (TRUE, "%s: Invalid socket owner\n", progname);
1325 return INVALID_SOCKET;
1326 }
1327 break;
1328
1329 case 2:
1330 /* `stat' failed */
1331 if (saved_errno == ENOENT)
1332 message (TRUE,
1333 "%s: can't find socket; have you started the server?\n\
1334 To start the server in Emacs, type \"M-x server-start\".\n",
1335 progname);
1336 else
1337 message (TRUE, "%s: can't stat %s: %s\n",
1338 progname, server.sun_path, strerror (saved_errno));
1339 return INVALID_SOCKET;
1340 }
1341 }
1342
1343 if (connect (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2)
1344 < 0)
1345 {
1346 message (TRUE, "%s: connect: %s\n", progname, strerror (errno));
1347 return INVALID_SOCKET;
1348 }
1349
1350 return s;
1351 }
1352 #endif /* ! NO_SOCKETS_IN_FILE_SYSTEM */
1353
1354 static HSOCKET
1355 set_socket (int no_exit_if_error)
1356 {
1357 HSOCKET s;
1358
1359 INITIALIZE ();
1360
1361 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1362 /* Explicit --socket-name argument. */
1363 if (socket_name)
1364 {
1365 s = set_local_socket ();
1366 if ((s != INVALID_SOCKET) || no_exit_if_error)
1367 return s;
1368 message (TRUE, "%s: error accessing socket \"%s\"\n",
1369 progname, socket_name);
1370 exit (EXIT_FAILURE);
1371 }
1372 #endif
1373
1374 /* Explicit --server-file arg or EMACS_SERVER_FILE variable. */
1375 if (!server_file)
1376 server_file = egetenv ("EMACS_SERVER_FILE");
1377
1378 if (server_file)
1379 {
1380 s = set_tcp_socket ();
1381 if ((s != INVALID_SOCKET) || no_exit_if_error)
1382 return s;
1383
1384 message (TRUE, "%s: error accessing server file \"%s\"\n",
1385 progname, server_file);
1386 exit (EXIT_FAILURE);
1387 }
1388
1389 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1390 /* Implicit local socket. */
1391 s = set_local_socket ();
1392 if (s != INVALID_SOCKET)
1393 return s;
1394 #endif
1395
1396 /* Implicit server file. */
1397 server_file = "server";
1398 s = set_tcp_socket ();
1399 if ((s != INVALID_SOCKET) || no_exit_if_error)
1400 return s;
1401
1402 /* No implicit or explicit socket, and no alternate editor. */
1403 message (TRUE, "%s: No socket or alternate editor. Please use:\n\n"
1404 #ifndef NO_SOCKETS_IN_FILE_SYSTEM
1405 "\t--socket-name\n"
1406 #endif
1407 "\t--server-file (or environment variable EMACS_SERVER_FILE)\n\
1408 \t--alternate-editor (or environment variable ALTERNATE_EDITOR)\n",
1409 progname);
1410 exit (EXIT_FAILURE);
1411 }
1412
1413 #ifdef WINDOWSNT
1414 FARPROC set_fg; /* Pointer to AllowSetForegroundWindow. */
1415 FARPROC get_wc; /* Pointer to RealGetWindowClassA. */
1416
1417 BOOL CALLBACK
1418 w32_find_emacs_process (HWND hWnd, LPARAM lParam)
1419 {
1420 DWORD pid;
1421 char class[6];
1422
1423 /* Reject any window not of class "Emacs". */
1424 if (! get_wc (hWnd, class, sizeof (class))
1425 || strcmp (class, "Emacs"))
1426 return TRUE;
1427
1428 /* We only need the process id, not the thread id. */
1429 (void) GetWindowThreadProcessId (hWnd, &pid);
1430
1431 /* Not the one we're looking for. */
1432 if (pid != (DWORD) emacs_pid) return TRUE;
1433
1434 /* OK, let's raise it. */
1435 set_fg (emacs_pid);
1436
1437 /* Stop enumeration. */
1438 return FALSE;
1439 }
1440
1441 /*
1442 * Search for a window of class "Emacs" and owned by a process with
1443 * process id = emacs_pid. If found, allow it to grab the focus.
1444 */
1445 void
1446 w32_give_focus (void)
1447 {
1448 HANDLE user32;
1449
1450 /* It shouldn't happen when dealing with TCP sockets. */
1451 if (!emacs_pid) return;
1452
1453 user32 = GetModuleHandle ("user32.dll");
1454
1455 if (!user32)
1456 return;
1457
1458 /* Modern Windows restrict which processes can set the foreground window.
1459 emacsclient can allow Emacs to grab the focus by calling the function
1460 AllowSetForegroundWindow. Unfortunately, older Windows (W95, W98 and
1461 NT) lack this function, so we have to check its availability. */
1462 if ((set_fg = GetProcAddress (user32, "AllowSetForegroundWindow"))
1463 && (get_wc = GetProcAddress (user32, "RealGetWindowClassA")))
1464 EnumWindows (w32_find_emacs_process, (LPARAM) 0);
1465 }
1466 #endif
1467
1468 /* Start the emacs daemon and try to connect to it. */
1469
1470 static void
1471 start_daemon_and_retry_set_socket (void)
1472 {
1473 #ifndef WINDOWSNT
1474 pid_t dpid;
1475 int status;
1476
1477 dpid = fork ();
1478
1479 if (dpid > 0)
1480 {
1481 pid_t w;
1482 w = waitpid (dpid, &status, WUNTRACED | WCONTINUED);
1483
1484 if ((w == -1) || !WIFEXITED (status) || WEXITSTATUS (status))
1485 {
1486 message (TRUE, "Error: Could not start the Emacs daemon\n");
1487 exit (EXIT_FAILURE);
1488 }
1489
1490 /* Try connecting, the daemon should have started by now. */
1491 message (TRUE, "Emacs daemon should have started, trying to connect again\n");
1492 if ((emacs_socket = set_socket (1)) == INVALID_SOCKET)
1493 {
1494 message (TRUE, "Error: Cannot connect even after starting the Emacs daemon\n");
1495 exit (EXIT_FAILURE);
1496 }
1497 }
1498 else if (dpid < 0)
1499 {
1500 fprintf (stderr, "Error: Cannot fork!\n");
1501 exit (EXIT_FAILURE);
1502 }
1503 else
1504 {
1505 char emacs[] = "emacs";
1506 char daemon_option[] = "--daemon";
1507 char *d_argv[] = {emacs, daemon_option, 0 };
1508 if (socket_name != NULL)
1509 {
1510 /* Pass --daemon=socket_name as argument. */
1511 const char *deq = "--daemon=";
1512 char *daemon_arg = alloca (strlen (deq)
1513 + strlen (socket_name) + 1);
1514 strcpy (daemon_arg, deq);
1515 strcat (daemon_arg, socket_name);
1516 d_argv[1] = daemon_arg;
1517 }
1518 execvp ("emacs", d_argv);
1519 message (TRUE, "%s: error starting emacs daemon\n", progname);
1520 }
1521 #endif /* WINDOWSNT */
1522 }
1523
1524 int
1525 main (int argc, char **argv)
1526 {
1527 int rl, needlf = 0;
1528 char *cwd, *str;
1529 char string[BUFSIZ+1];
1530 int null_socket_name IF_LINT ( = 0);
1531 int null_server_file IF_LINT ( = 0);
1532 int start_daemon_if_needed;
1533 int exit_status = EXIT_SUCCESS;
1534
1535 main_argv = argv;
1536 progname = argv[0];
1537
1538 #ifdef WINDOWSNT
1539 /* On Windows 7 and later, we need to explicitly associate emacsclient
1540 with emacs so the UI behaves sensibly. */
1541 w32_set_user_model_id ();
1542 #endif
1543
1544 /* Process options. */
1545 decode_options (argc, argv);
1546
1547 if ((argc - optind < 1) && !eval && current_frame)
1548 {
1549 message (TRUE, "%s: file name or argument required\n"
1550 "Try `%s --help' for more information\n",
1551 progname, progname);
1552 exit (EXIT_FAILURE);
1553 }
1554
1555 /* If alternate_editor is the empty string, start the emacs daemon
1556 in case of failure to connect. */
1557 start_daemon_if_needed = (alternate_editor
1558 && (alternate_editor[0] == '\0'));
1559 if (start_daemon_if_needed)
1560 {
1561 /* set_socket changes the values for socket_name and
1562 server_file, we need to reset them, if they were NULL before
1563 for the second call to set_socket. */
1564 null_socket_name = (socket_name == NULL);
1565 null_server_file = (server_file == NULL);
1566 }
1567
1568 emacs_socket = set_socket (alternate_editor || start_daemon_if_needed);
1569 if (emacs_socket == INVALID_SOCKET)
1570 {
1571 if (! start_daemon_if_needed)
1572 fail ();
1573
1574 /* Reset socket_name and server_file if they were NULL
1575 before the set_socket call. */
1576 if (null_socket_name)
1577 socket_name = NULL;
1578 if (null_server_file)
1579 server_file = NULL;
1580
1581 start_daemon_and_retry_set_socket ();
1582 }
1583
1584 cwd = get_current_dir_name ();
1585 if (cwd == 0)
1586 {
1587 /* getwd puts message in STRING if it fails. */
1588 message (TRUE, "%s: %s\n", progname,
1589 "Cannot get current working directory");
1590 fail ();
1591 }
1592
1593 #ifdef WINDOWSNT
1594 w32_give_focus ();
1595 #endif
1596
1597 /* Send over our environment and current directory. */
1598 if (!current_frame)
1599 {
1600 extern char **environ;
1601 int i;
1602 for (i = 0; environ[i]; i++)
1603 {
1604 send_to_emacs (emacs_socket, "-env ");
1605 quote_argument (emacs_socket, environ[i]);
1606 send_to_emacs (emacs_socket, " ");
1607 }
1608 }
1609 send_to_emacs (emacs_socket, "-dir ");
1610 quote_argument (emacs_socket, cwd);
1611 send_to_emacs (emacs_socket, "/");
1612 send_to_emacs (emacs_socket, " ");
1613
1614 retry:
1615 if (nowait)
1616 send_to_emacs (emacs_socket, "-nowait ");
1617
1618 if (current_frame)
1619 send_to_emacs (emacs_socket, "-current-frame ");
1620
1621 if (display)
1622 {
1623 send_to_emacs (emacs_socket, "-display ");
1624 quote_argument (emacs_socket, display);
1625 send_to_emacs (emacs_socket, " ");
1626 }
1627
1628 if (parent_id)
1629 {
1630 send_to_emacs (emacs_socket, "-parent-id ");
1631 quote_argument (emacs_socket, parent_id);
1632 send_to_emacs (emacs_socket, " ");
1633 }
1634
1635 /* If using the current frame, send tty information to Emacs anyway.
1636 In daemon mode, Emacs may need to occupy this tty if no other
1637 frame is available. */
1638 if (tty || (current_frame && !eval))
1639 {
1640 const char *tty_type, *tty_name;
1641
1642 if (find_tty (&tty_type, &tty_name, !tty))
1643 {
1644 #if !defined (NO_SOCKETS_IN_FILE_SYSTEM)
1645 init_signals ();
1646 #endif
1647 send_to_emacs (emacs_socket, "-tty ");
1648 quote_argument (emacs_socket, tty_name);
1649 send_to_emacs (emacs_socket, " ");
1650 quote_argument (emacs_socket, tty_type);
1651 send_to_emacs (emacs_socket, " ");
1652 }
1653 }
1654
1655 if (!current_frame && !tty)
1656 send_to_emacs (emacs_socket, "-window-system ");
1657
1658 if ((argc - optind > 0))
1659 {
1660 int i;
1661 for (i = optind; i < argc; i++)
1662 {
1663
1664 if (eval)
1665 {
1666 /* Don't prepend cwd or anything like that. */
1667 send_to_emacs (emacs_socket, "-eval ");
1668 quote_argument (emacs_socket, argv[i]);
1669 send_to_emacs (emacs_socket, " ");
1670 continue;
1671 }
1672
1673 if (*argv[i] == '+')
1674 {
1675 char *p = argv[i] + 1;
1676 while (isdigit ((unsigned char) *p) || *p == ':') p++;
1677 if (*p == 0)
1678 {
1679 send_to_emacs (emacs_socket, "-position ");
1680 quote_argument (emacs_socket, argv[i]);
1681 send_to_emacs (emacs_socket, " ");
1682 continue;
1683 }
1684 }
1685 #ifdef WINDOWSNT
1686 else if (! file_name_absolute_p (argv[i])
1687 && (isalpha (argv[i][0]) && argv[i][1] == ':'))
1688 /* Windows can have a different default directory for each
1689 drive, so the cwd passed via "-dir" is not sufficient
1690 to account for that.
1691 If the user uses <drive>:<relpath>, we hence need to be
1692 careful to expand <relpath> with the default directory
1693 corresponding to <drive>. */
1694 {
1695 char *filename = (char *) xmalloc (MAX_PATH);
1696 DWORD size;
1697
1698 size = GetFullPathName (argv[i], MAX_PATH, filename, NULL);
1699 if (size > 0 && size < MAX_PATH)
1700 argv[i] = filename;
1701 else
1702 free (filename);
1703 }
1704 #endif
1705
1706 send_to_emacs (emacs_socket, "-file ");
1707 quote_argument (emacs_socket, argv[i]);
1708 send_to_emacs (emacs_socket, " ");
1709 }
1710 }
1711 else if (eval)
1712 {
1713 /* Read expressions interactively. */
1714 while ((str = fgets (string, BUFSIZ, stdin)))
1715 {
1716 send_to_emacs (emacs_socket, "-eval ");
1717 quote_argument (emacs_socket, str);
1718 }
1719 send_to_emacs (emacs_socket, " ");
1720 }
1721
1722 send_to_emacs (emacs_socket, "\n");
1723
1724 /* Wait for an answer. */
1725 if (!eval && !tty && !nowait && !quiet)
1726 {
1727 printf ("Waiting for Emacs...");
1728 needlf = 2;
1729 }
1730 fflush (stdout);
1731 fsync (1);
1732
1733 /* Now, wait for an answer and print any messages. */
1734 while (exit_status == EXIT_SUCCESS)
1735 {
1736 char *p;
1737 do
1738 {
1739 errno = 0;
1740 rl = recv (emacs_socket, string, BUFSIZ, 0);
1741 }
1742 /* If we receive a signal (e.g. SIGWINCH, which we pass
1743 through to Emacs), on some OSes we get EINTR and must retry. */
1744 while (rl < 0 && errno == EINTR);
1745
1746 if (rl <= 0)
1747 break;
1748
1749 string[rl] = '\0';
1750
1751 p = string + strlen (string) - 1;
1752 while (p > string && *p == '\n')
1753 *p-- = 0;
1754
1755 if (strprefix ("-emacs-pid ", string))
1756 {
1757 /* -emacs-pid PID: The process id of the Emacs process. */
1758 emacs_pid = strtol (string + strlen ("-emacs-pid"), NULL, 10);
1759 }
1760 else if (strprefix ("-window-system-unsupported ", string))
1761 {
1762 /* -window-system-unsupported: Emacs was compiled without X
1763 support. Try again on the terminal. */
1764 nowait = 0;
1765 tty = 1;
1766 goto retry;
1767 }
1768 else if (strprefix ("-print ", string))
1769 {
1770 /* -print STRING: Print STRING on the terminal. */
1771 str = unquote_argument (string + strlen ("-print "));
1772 if (needlf)
1773 printf ("\n");
1774 printf ("%s", str);
1775 needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1776 }
1777 else if (strprefix ("-error ", string))
1778 {
1779 /* -error DESCRIPTION: Signal an error on the terminal. */
1780 str = unquote_argument (string + strlen ("-error "));
1781 if (needlf)
1782 printf ("\n");
1783 fprintf (stderr, "*ERROR*: %s", str);
1784 needlf = str[0] == '\0' ? needlf : str[strlen (str) - 1] != '\n';
1785 exit_status = EXIT_FAILURE;
1786 }
1787 #ifdef SIGSTOP
1788 else if (strprefix ("-suspend ", string))
1789 {
1790 /* -suspend: Suspend this terminal, i.e., stop the process. */
1791 if (needlf)
1792 printf ("\n");
1793 needlf = 0;
1794 kill (0, SIGSTOP);
1795 }
1796 #endif
1797 else
1798 {
1799 /* Unknown command. */
1800 if (needlf)
1801 printf ("\n");
1802 printf ("*ERROR*: Unknown message: %s", string);
1803 needlf = string[0]
1804 == '\0' ? needlf : string[strlen (string) - 1] != '\n';
1805 }
1806 }
1807
1808 if (needlf)
1809 printf ("\n");
1810 fflush (stdout);
1811 fsync (1);
1812
1813 if (rl < 0)
1814 exit_status = EXIT_FAILURE;
1815
1816 CLOSE_SOCKET (emacs_socket);
1817 return exit_status;
1818 }
1819
1820 #endif /* HAVE_SOCKETS && HAVE_INET_SOCKETS */
1821
1822 \f
1823 #ifndef HAVE_STRERROR
1824 char *
1825 strerror (errnum)
1826 int errnum;
1827 {
1828 extern char *sys_errlist[];
1829 extern int sys_nerr;
1830
1831 if (errnum >= 0 && errnum < sys_nerr)
1832 return sys_errlist[errnum];
1833 return (char *) "Unknown error";
1834 }
1835
1836 #endif /* ! HAVE_STRERROR */
1837
1838
1839 /* emacsclient.c ends here */