*** empty log message ***
[emacs.git] / lib-src / emacsserver.c
blob7394a9a10b9fbe6705f58b7e205f28b56a0bf31f
1 /* Communication subprocess for GNU Emacs acting as server.
2 Copyright (C) 1986, 1987, 1992, 1994, 1999 Free Software Foundation, Inc.
4 This file is part of GNU Emacs.
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 2, or (at your option)
9 any later version.
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.
16 You should have received a copy of the GNU General Public License
17 along with GNU Emacs; see the file COPYING. If not, write to
18 the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19 Boston, MA 02111-1307, USA. */
22 /* The GNU Emacs edit server process is run as a subprocess of Emacs
23 under control of the file lisp/server.el.
24 This program accepts communication from client (program emacsclient.c)
25 and passes their commands (consisting of keyboard characters)
26 up to the Emacs which then executes them. */
28 #define NO_SHORTNAMES
29 #include <../src/config.h>
30 #include <signal.h>
31 #undef signal
33 #if !defined (HAVE_SOCKETS) && !defined (HAVE_SYSVIPC)
34 #include <stdio.h>
36 int
37 main ()
39 fprintf (stderr, "Sorry, the Emacs server is supported only on systems\n");
40 fprintf (stderr, "with Berkeley sockets or System V IPC.\n");
41 exit (1);
44 #else /* HAVE_SOCKETS or HAVE_SYSVIPC */
46 void perror_1 ();
47 void fatal_error ();
49 #if defined (HAVE_SOCKETS) && ! defined (NO_SOCKETS_IN_FILE_SYSTEM)
50 /* BSD code is very different from SYSV IPC code */
52 #include <sys/types.h>
53 #include <sys/file.h>
54 #include <sys/socket.h>
55 #include <sys/un.h>
56 #include <stdio.h>
57 #include <errno.h>
58 #include <sys/stat.h>
60 #ifdef HAVE_UNISTD_H
61 #include <unistd.h>
62 #endif
64 #ifndef errno
65 extern int errno;
66 #endif
68 /* Copied from src/process.c */
69 #ifdef FD_SET
70 /* We could get this from param.h, but better not to depend on finding that.
71 And better not to risk that it might define other symbols used in this
72 file. */
73 #ifdef FD_SETSIZE
74 #define MAXDESC FD_SETSIZE
75 #else
76 #define MAXDESC 64
77 #endif
78 #define SELECT_TYPE fd_set
79 #else /* no FD_SET */
80 #define MAXDESC 32
81 #define SELECT_TYPE int
83 /* Define the macros to access a single-int bitmap of descriptors. */
84 #define FD_SET(n, p) (*(p) |= (1 << (n)))
85 #define FD_CLR(n, p) (*(p) &= ~(1 << (n)))
86 #define FD_ISSET(n, p) (*(p) & (1 << (n)))
87 #define FD_ZERO(p) (*(p) = 0)
88 #endif /* no FD_SET */
90 /* This is the file name of the socket that we made. */
92 char *socket_name;
94 /* Name of this program. */
96 char *progname;
98 /* Handle fatal signals. */
100 /* This is the handler. */
102 SIGTYPE
103 delete_socket (sig)
104 int sig;
106 signal (sig, SIG_DFL);
107 unlink (socket_name);
108 kill (getpid (), sig);
111 /* Set up to handle all the signals. */
113 void
114 handle_signals ()
116 signal (SIGHUP, delete_socket);
117 signal (SIGINT, delete_socket);
118 signal (SIGQUIT, delete_socket);
119 signal (SIGILL, delete_socket);
120 signal (SIGTRAP, delete_socket);
121 #ifdef SIGABRT
122 signal (SIGABRT, delete_socket);
123 #endif
124 #ifdef SIGHWE
125 signal (SIGHWE, delete_socket);
126 #endif
127 #ifdef SIGPRE
128 signal (SIGPRE, delete_socket);
129 #endif
130 #ifdef SIGORE
131 signal (SIGORE, delete_socket);
132 #endif
133 #ifdef SIGUME
134 signal (SIGUME, delete_socket);
135 #endif
136 #ifdef SIGDLK
137 signal (SIGDLK, delete_socket);
138 #endif
139 #ifdef SIGCPULIM
140 signal (SIGCPULIM, delete_socket);
141 #endif
142 #ifdef SIGIOT
143 /* This is missing on some systems - OS/2, for example. */
144 signal (SIGIOT, delete_socket);
145 #endif
146 #ifdef SIGEMT
147 signal (SIGEMT, delete_socket);
148 #endif
149 signal (SIGFPE, delete_socket);
150 #ifdef SIGBUS
151 signal (SIGBUS, delete_socket);
152 #endif
153 signal (SIGSEGV, delete_socket);
154 #ifdef SIGSYS
155 signal (SIGSYS, delete_socket);
156 #endif
157 signal (SIGTERM, delete_socket);
158 #ifdef SIGXCPU
159 signal (SIGXCPU, delete_socket);
160 #endif
161 #ifdef SIGXFSZ
162 signal (SIGXFSZ, delete_socket);
163 #endif /* SIGXFSZ */
165 #ifdef AIX
166 /* 20 is SIGCHLD, 21 is SIGTTIN, 22 is SIGTTOU. */
167 signal (SIGXCPU, delete_socket);
168 #ifndef _I386
169 signal (SIGIOINT, delete_socket);
170 #endif
171 signal (SIGGRANT, delete_socket);
172 signal (SIGRETRACT, delete_socket);
173 signal (SIGSOUND, delete_socket);
174 signal (SIGMSG, delete_socket);
175 #endif /* AIX */
178 /* Print error message. `s1' is printf control string, `s2' is arg for it. */
179 void
180 error (s1, s2)
181 char *s1, *s2;
183 fprintf (stderr, "%s: ", progname);
184 fprintf (stderr, s1, s2);
185 fprintf (stderr, "\n");
188 /* Print error message and exit. */
189 void
190 fatal (s1, s2)
191 char *s1, *s2;
193 error (s1, s2);
194 exit (1);
197 /* Like malloc but get fatal error if memory is exhausted. */
199 long *
200 xmalloc (size)
201 unsigned int size;
203 long *result = (long *) malloc (size);
204 if (result == NULL)
205 fatal ("virtual memory exhausted", 0);
206 return result;
210 main (argc, argv)
211 int argc;
212 char **argv;
214 char *system_name;
215 int system_name_length;
216 int s, infd;
217 #ifdef SOCKLEN_TYPE
218 SOCKLEN_TYPE fromlen;
219 #else
220 size_t fromlen;
221 #endif
222 struct sockaddr_un server, fromunix;
223 #ifdef SERVER_HOME_DIR
224 char *homedir;
225 #endif
226 char *str, string[BUFSIZ], code[BUFSIZ];
227 FILE *infile;
228 FILE **openfiles;
229 int openfiles_size;
230 struct stat statbuf;
232 #ifndef convex
233 char *getenv ();
234 #endif
236 progname = argv[0];
238 openfiles_size = 20;
239 openfiles = (FILE **) malloc (openfiles_size * sizeof (FILE *));
240 if (openfiles == 0)
241 abort ();
244 * Open up an AF_UNIX socket in this person's home directory
247 if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
249 perror_1 ("socket");
250 exit (1);
252 server.sun_family = AF_UNIX;
254 system_name_length = 32;
255 while (1)
257 system_name = (char *) xmalloc (system_name_length + 1);
259 /* system_name must be null-terminated string. */
260 system_name[system_name_length] = '\0';
262 if (gethostname (system_name, system_name_length) == 0)
263 break;
265 free (system_name);
266 system_name_length *= 2;
269 #ifndef SERVER_HOME_DIR
270 sprintf (server.sun_path, "/tmp/esrv%d-%s", geteuid (), system_name);
272 if (unlink (server.sun_path) == -1 && errno != ENOENT)
274 perror_1 ("unlink");
275 exit (1);
277 #else
278 if ((homedir = getenv ("HOME")) == NULL)
279 fatal_error ("No home directory\n");
281 strcpy (server.sun_path, homedir);
282 strcat (server.sun_path, "/.emacs-server-");
283 strcat (server.sun_path, system_name);
284 /* Delete anyone else's old server. */
285 unlink (server.sun_path);
286 #endif
288 /* Save the socket name so we can delete it. */
289 socket_name = (char *) xmalloc (strlen (server.sun_path) + 1);
290 strcpy (socket_name, server.sun_path);
292 handle_signals ();
294 if (bind (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2) < 0)
296 perror_1 ("bind");
297 exit (1);
299 /* Only this user can send commands to this Emacs. */
300 if (stat (server.sun_path, &statbuf) < 0)
302 perror_1 ("bind");
303 exit (1);
306 chmod (server.sun_path, statbuf.st_mode & 0600);
308 * Now, just wait for everything to come in..
310 if (listen (s, 5) < 0)
312 perror_1 ("listen");
313 exit (1);
316 /* Disable sigpipes in case luser kills client... */
317 signal (SIGPIPE, SIG_IGN);
318 for (;;)
320 SELECT_TYPE rmask;
321 FD_ZERO (&rmask);
322 FD_SET (0, &rmask);
323 FD_SET (s, &rmask);
324 if (select (s + 1, &rmask, 0, 0, 0) < 0)
325 perror_1 ("select");
326 if (FD_ISSET (s, &rmask)) /* client sends list of filenames */
328 fromlen = sizeof (fromunix);
329 fromunix.sun_family = AF_UNIX;
330 infd = accept (s, (struct sockaddr *) &fromunix, &fromlen);
331 if (infd < 0)
333 if (errno == EMFILE || errno == ENFILE)
334 fprintf (stderr, "Error: too many clients.\n");
335 else
336 perror_1 ("accept");
337 continue;
340 if (infd >= openfiles_size)
342 openfiles_size *= 2;
343 openfiles = (FILE **) realloc (openfiles,
344 openfiles_size * sizeof (FILE *));
345 if (openfiles == 0)
346 abort ();
349 infile = fdopen (infd, "r+"); /* open stream */
350 if (infile == NULL)
352 fprintf (stderr, "Error: too many clients.\n");
353 write (infd, "Too many clients.\n", 18);
354 close (infd); /* Prevent descriptor leak.. */
355 continue;
357 str = fgets (string, BUFSIZ, infile);
358 if (str == NULL)
360 perror_1 ("fgets");
361 close (infd); /* Prevent descriptor leak.. */
362 continue;
364 openfiles[infd] = infile;
365 printf ("Client: %d %s", infd, string);
366 /* If what we read did not end in a newline,
367 it means there is more. Keep reading from the socket
368 and outputting to Emacs, until we get the newline. */
369 while (string[strlen (string) - 1] != '\n')
371 if (fgets (string, BUFSIZ, infile) == 0)
372 break;
373 printf ("%s", string);
375 fflush (stdout);
376 fflush (infile);
377 continue;
379 else if (FD_ISSET (0, &rmask)) /* emacs sends codeword, fd, and string message */
381 /* Read command codeword and fd */
382 clearerr (stdin);
383 scanf ("%s %d%*c", code, &infd);
384 if (ferror (stdin) || feof (stdin))
385 fatal_error ("server: error reading from standard input\n");
387 /* Transfer text from Emacs to the client, up to a newline. */
388 infile = openfiles[infd];
389 rewind (infile);
390 while (1)
392 if (fgets (string, BUFSIZ, stdin) == 0)
393 break;
394 fprintf (infile, "%s", string);
395 if (string[strlen (string) - 1] == '\n')
396 break;
398 fflush (infile);
400 /* If command is close, close connection to client. */
401 if (strncmp (code, "Close:", 6) == 0)
402 if (infd > 2)
404 fclose (infile);
405 close (infd);
407 continue;
412 #else /* This is the SYSV IPC section */
414 #include <sys/types.h>
415 #include <sys/ipc.h>
416 #include <sys/msg.h>
417 #include <setjmp.h>
418 #include <errno.h>
419 #include <sys/utsname.h>
421 struct utsname system_name;
423 #ifndef errno
424 extern int errno;
425 #endif
427 jmp_buf msgenv;
429 SIGTYPE
430 msgcatch ()
432 longjmp (msgenv, 1);
436 /* "THIS has to be fixed. Remember, stderr may not exist...-rlk."
437 Incorrect. This program runs as an inferior of Emacs.
438 Its stderr always exists--rms. */
439 #include <stdio.h>
442 main ()
444 int s, infd, fromlen, ioproc;
445 key_t key;
446 struct msgbuf * msgp =
447 (struct msgbuf *) malloc (sizeof *msgp + BUFSIZ);
448 struct msqid_ds msg_st;
449 int p;
450 char *homedir, *getenv ();
451 char string[BUFSIZ];
452 FILE *infile;
455 * Create a message queue using ~/.emacs-server as the path for ftok
457 if ((homedir = getenv ("HOME")) == NULL)
458 fatal_error ("No home directory\n");
460 strcpy (string, homedir);
461 #ifndef HAVE_LONG_FILE_NAMES
462 /* If file names are short, we can't fit the host name. */
463 strcat (string, "/.emacs-server");
464 #else
465 strcat (string, "/.emacs-server-");
466 uname (&system_name);
467 strcat (string, system_name.nodename);
468 #endif
469 creat (string, 0600);
470 key = ftok (string, 1); /* unlikely to be anyone else using it */
471 s = msgget (key, 0600 | IPC_CREAT);
472 if (s == -1)
474 perror_1 ("msgget");
475 exit (1);
478 /* Fork so we can close connection even if parent dies */
479 p = fork ();
480 if (setjmp (msgenv))
482 msgctl (s, IPC_RMID, 0);
483 if (p > 0)
484 kill (p, SIGKILL);
485 exit (0);
487 signal (SIGTERM, msgcatch);
488 signal (SIGINT, msgcatch);
489 signal (SIGHUP, msgcatch);
490 if (p > 0)
492 /* This is executed in the original process that did the fork above. */
493 /* Get pid of Emacs itself. */
494 p = getppid ();
495 setpgrp (); /* Gnu kills process group on exit */
496 while (1)
498 /* Is Emacs still alive? */
499 if (kill (p, 0) < 0)
501 msgctl (s, IPC_RMID, 0);
502 exit (0);
504 sleep (10);
508 /* This is executed in the child made by forking above.
509 Call it c1. Make another process, ioproc. */
511 ioproc = fork ();
512 if (ioproc == 0)
514 /* In process ioproc, wait for text from Emacs,
515 and send it to the process c1.
516 This way, c1 only has to wait for one source of input. */
517 while (fgets (msgp->mtext, BUFSIZ, stdin))
519 msgp->mtype = 1;
520 msgsnd (s, msgp, strlen (msgp->mtext) + 1, 0);
522 exit (1);
525 /* In the process c1,
526 listen for messages from clients and pass them to Emacs. */
527 while (1)
529 if ((fromlen = msgrcv (s, msgp, BUFSIZ - 1, 1, 0)) < 0)
531 #ifdef EINTR
532 if (errno == EINTR)
533 continue;
534 #endif
535 perror_1 ("msgrcv");
536 exit (1);
538 else
540 msgctl (s, IPC_STAT, &msg_st);
542 /* Distinguish whether the message came from a client, or from
543 ioproc. */
544 if (msg_st.msg_lspid == ioproc)
546 char code[BUFSIZ];
547 int inproc;
549 /* Message from ioproc: tell a client we are done. */
550 msgp->mtext[strlen (msgp->mtext)-1] = 0;
551 sscanf (msgp->mtext, "%s %d", code, &inproc);
552 msgp->mtype = inproc;
553 msgsnd (s, msgp, strlen (msgp->mtext) + 1, 0);
554 continue;
557 /* This is a request from a client: copy to stdout
558 so that Emacs will get it. Include msg_lspid
559 so server.el can tell us where to send the reply. */
560 strncpy (string, msgp->mtext, fromlen);
561 string[fromlen] = 0; /* make sure */
562 /* Newline is part of string.. */
563 printf ("Client: %d %s", msg_st.msg_lspid, string);
564 fflush (stdout);
569 #endif /* HAVE_SYSVIPC */
572 /* This is like perror but puts `Error: ' at the beginning. */
574 void
575 perror_1 (string)
576 char *string;
578 char *copy = (char *) malloc (strlen (string) + 8);
579 if (copy == 0)
580 fatal_error ("Virtual memory exhausted");
582 strcpy (copy, "Error: ");
583 strcat (copy, string);
584 perror (copy);
587 void
588 fatal_error (string)
589 char *string;
591 fprintf (stderr, "%s", "Error: ");
592 fprintf (stderr, string);
593 exit (1);
595 #endif /* HAVE_SOCKETS or HAVE_SYSVIPC */