[bpt/emacs.git] / lib-src / emacsserver.c

/* Communication subprocess for GNU Emacs acting as server.
   Copyright (C) 1986, 1987, 1992, 1994, 1999 Free Software Foundation, Inc.

This file is part of GNU Emacs.

GNU Emacs is free software; you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation; either version 2, or (at your option)
any later version.

GNU Emacs is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with GNU Emacs; see the file COPYING.  If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.  */


/* The GNU Emacs edit server process is run as a subprocess of Emacs
   under control of the file lisp/server.el.
   This program accepts communication from client (program emacsclient.c)
   and passes their commands (consisting of keyboard characters)
   up to the Emacs which then executes them.  */

#define NO_SHORTNAMES
#include <../src/config.h>
#include <signal.h>
#undef signal

#if !defined (HAVE_SOCKETS) && !defined (HAVE_SYSVIPC)
#include <stdio.h>

int
main ()
{
  fprintf (stderr, "Sorry, the Emacs server is supported only on systems\n");
  fprintf (stderr, "with Berkeley sockets or System V IPC.\n");
  exit (1);
}

#else /* HAVE_SOCKETS or HAVE_SYSVIPC */

void perror_1 ();
void fatal_error ();

#if defined (HAVE_SOCKETS) && ! defined (NO_SOCKETS_IN_FILE_SYSTEM)
/* BSD code is very different from SYSV IPC code */

#include <sys/types.h>
#include <sys/file.h>
#include <sys/socket.h>
#include <sys/un.h>
#include <stdio.h>
#include <errno.h>
#include <sys/stat.h>

#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif

#ifndef errno
extern int errno;
#endif

/* Copied from src/process.c */
#ifdef FD_SET
/* We could get this from param.h, but better not to depend on finding that.
   And better not to risk that it might define other symbols used in this
   file.  */
#ifdef FD_SETSIZE
#define MAXDESC FD_SETSIZE
#else
#define MAXDESC 64
#endif
#define SELECT_TYPE fd_set
#else /* no FD_SET */
#define MAXDESC 32
#define SELECT_TYPE int

/* Define the macros to access a single-int bitmap of descriptors.  */
#define FD_SET(n, p) (*(p) |= (1 << (n)))
#define FD_CLR(n, p) (*(p) &= ~(1 << (n)))
#define FD_ISSET(n, p) (*(p) & (1 << (n)))
#define FD_ZERO(p) (*(p) = 0)
#endif /* no FD_SET */

/* This is the file name of the socket that we made.  */

char *socket_name;

/* Name of this program.  */

char *progname;
\f
/* Handle fatal signals.  */

/* This is the handler.  */

SIGTYPE
delete_socket (sig)
     int sig;
{
  signal (sig, SIG_DFL);
  unlink (socket_name);
  kill (getpid (), sig);
}

/* Set up to handle all the signals.  */

void
handle_signals ()
{
  signal (SIGHUP, delete_socket);
  signal (SIGINT, delete_socket);
  signal (SIGQUIT, delete_socket);
  signal (SIGILL, delete_socket);
  signal (SIGTRAP, delete_socket);
#ifdef SIGABRT
  signal (SIGABRT, delete_socket);
#endif
#ifdef SIGHWE
  signal (SIGHWE, delete_socket);
#endif
#ifdef SIGPRE
  signal (SIGPRE, delete_socket);
#endif
#ifdef SIGORE
  signal (SIGORE, delete_socket);
#endif
#ifdef SIGUME
  signal (SIGUME, delete_socket);
#endif
#ifdef SIGDLK
  signal (SIGDLK, delete_socket);
#endif
#ifdef SIGCPULIM
  signal (SIGCPULIM, delete_socket);
#endif
#ifdef SIGIOT
  /* This is missing on some systems - OS/2, for example.  */
  signal (SIGIOT, delete_socket);
#endif
#ifdef SIGEMT
  signal (SIGEMT, delete_socket);
#endif
  signal (SIGFPE, delete_socket);
#ifdef SIGBUS
  signal (SIGBUS, delete_socket);
#endif
  signal (SIGSEGV, delete_socket);
#ifdef SIGSYS
  signal (SIGSYS, delete_socket);
#endif
  signal (SIGTERM, delete_socket);
#ifdef SIGXCPU
  signal (SIGXCPU, delete_socket);
#endif
#ifdef SIGXFSZ
  signal (SIGXFSZ, delete_socket);
#endif /* SIGXFSZ */

#ifdef AIX
/* 20 is SIGCHLD, 21 is SIGTTIN, 22 is SIGTTOU.  */
  signal (SIGXCPU, delete_socket);
#ifndef _I386
  signal (SIGIOINT, delete_socket);
#endif
  signal (SIGGRANT, delete_socket);
  signal (SIGRETRACT, delete_socket);
  signal (SIGSOUND, delete_socket);
  signal (SIGMSG, delete_socket);
#endif /* AIX */
}
\f
/* Print error message.  `s1' is printf control string, `s2' is arg for it. */
void
error (s1, s2)
     char *s1, *s2;
{
  fprintf (stderr, "%s: ", progname);
  fprintf (stderr, s1, s2);
  fprintf (stderr, "\n");
}

/* Print error message and exit.  */
void
fatal (s1, s2)
     char *s1, *s2;
{
  error (s1, s2);
  exit (1);
}

/* Like malloc but get fatal error if memory is exhausted.  */

long *
xmalloc (size)
     unsigned int size;
{
  long *result = (long *) malloc (size);
  if (result == NULL)
    fatal ("virtual memory exhausted", 0);
  return result;
}
\f
int
main (argc, argv)
     int argc;
     char **argv;
{
  char *system_name;
  int system_name_length;
  int s, infd;
#ifdef SOCKLEN_TYPE
  SOCKLEN_TYPE fromlen;
#else
  size_t fromlen;
#endif
  struct sockaddr_un server, fromunix;
#ifdef SERVER_HOME_DIR
  char *homedir;
#endif
  char *str, string[BUFSIZ], code[BUFSIZ];
  FILE *infile;
  FILE **openfiles;
  int openfiles_size;
  struct stat statbuf;

#ifndef convex
  char *getenv ();
#endif

  progname = argv[0];

  openfiles_size = 20;
  openfiles = (FILE **) malloc (openfiles_size * sizeof (FILE *));
  if (openfiles == 0)
    abort ();

  /* 
   * Open up an AF_UNIX socket in this person's home directory
   */

  if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
    {
      perror_1 ("socket");
      exit (1);
    }
  server.sun_family = AF_UNIX;

  system_name_length = 32;
  while (1)
    {
      system_name = (char *) xmalloc (system_name_length + 1);

      /* system_name must be null-terminated string.  */
      system_name[system_name_length] = '\0';

      if (gethostname (system_name, system_name_length) == 0)
	break;

      free (system_name);
      system_name_length *= 2;
    }

#ifndef SERVER_HOME_DIR
  sprintf (server.sun_path, "/tmp/esrv%d-%s", (int) geteuid (), system_name);

  if (unlink (server.sun_path) == -1 && errno != ENOENT)
    {
      perror_1 ("unlink");
      exit (1);
    }
#else  
  if ((homedir = getenv ("HOME")) == NULL)
    fatal_error ("No home directory\n");

  strcpy (server.sun_path, homedir);
  strcat (server.sun_path, "/.emacs-server-");
  strcat (server.sun_path, system_name);
  /* Delete anyone else's old server.  */
  unlink (server.sun_path);
#endif

  /* Save the socket name so we can delete it.  */
  socket_name = (char *) xmalloc (strlen (server.sun_path) + 1);
  strcpy (socket_name, server.sun_path);

  handle_signals ();

  if (bind (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2) < 0)
    {
      perror_1 ("bind");
      exit (1);
    }
  /* Only this user can send commands to this Emacs.  */
  if (stat (server.sun_path, &statbuf) < 0)
    {
      perror_1 ("bind");
      exit (1);
    }

  chmod (server.sun_path, statbuf.st_mode & 0600);
  /*
   * Now, just wait for everything to come in..
   */
  if (listen (s, 5) < 0)
    {
      perror_1 ("listen");
      exit (1);
    }

  /* Disable sigpipes in case luser kills client... */
  signal (SIGPIPE, SIG_IGN);
  for (;;)
    {
      SELECT_TYPE rmask;
      FD_ZERO (&rmask);
      FD_SET (0, &rmask);
      FD_SET (s, &rmask);
      if (select (s + 1, &rmask, 0, 0, 0) < 0)
	perror_1 ("select");
      if (FD_ISSET (s, &rmask))	/* client sends list of filenames */
	{
	  fromlen = sizeof (fromunix);
	  fromunix.sun_family = AF_UNIX;
	  infd = accept (s, (struct sockaddr *) &fromunix, &fromlen);
	  if (infd < 0)
	    {
	      if (errno == EMFILE || errno == ENFILE)
		fprintf (stderr, "Error: too many clients.\n");
	      else
		perror_1 ("accept");
	      continue;
	    }

	  if (infd >= openfiles_size)
	    {
	      openfiles_size *= 2;
	      openfiles = (FILE **) realloc (openfiles,
					     openfiles_size * sizeof (FILE *));
	      if (openfiles == 0)
		abort ();
	    }

	  infile = fdopen (infd, "r+"); /* open stream */
	  if (infile == NULL)
	    {
	      fprintf (stderr, "Error: too many clients.\n");
	      write (infd, "Too many clients.\n", 18);
	      close (infd);		/* Prevent descriptor leak.. */
	      continue;
	    }
	  str = fgets (string, BUFSIZ, infile);
	  if (str == NULL)
	    {
	      perror_1 ("fgets");
	      close (infd);		/* Prevent descriptor leak.. */
	      continue;
	    }
	  openfiles[infd] = infile;
	  printf ("Client: %d %s", infd, string);
	  /* If what we read did not end in a newline,
	     it means there is more.  Keep reading from the socket
	     and outputting to Emacs, until we get the newline.  */
	  while (string[strlen (string) - 1] != '\n')
	    {
	      if (fgets (string, BUFSIZ, infile) == 0)
		break;
	      printf ("%s", string);
	    }
	  fflush (stdout);
	  fflush (infile);
	  continue;
	}
      else if (FD_ISSET (0, &rmask)) /* emacs sends codeword, fd, and string message */
	{
	  /* Read command codeword and fd */
	  clearerr (stdin);
	  scanf ("%s %d%*c", code, &infd);
	  if (ferror (stdin) || feof (stdin))
	    fatal_error ("server: error reading from standard input\n");

	  /* Transfer text from Emacs to the client, up to a newline.  */
	  infile = openfiles[infd];
	  rewind (infile);
	  while (1)
	    {
	      if (fgets (string, BUFSIZ, stdin) == 0)
		break;
	      fprintf (infile, "%s", string);
	      if (string[strlen (string) - 1] == '\n')
		break;
	    }
	  fflush (infile);

	  /* If command is close, close connection to client.  */
	  if (strncmp (code, "Close:", 6) == 0) 
	    if (infd > 2) 
	      {
		fclose (infile);
		close (infd);
	      }
	  continue;
	} 
    }
}

#else  /* This is the SYSV IPC section */

#include <sys/types.h>
#include <sys/ipc.h>
#include <sys/msg.h>
#include <setjmp.h>
#include <errno.h>
#include <sys/utsname.h>

struct utsname system_name;

#ifndef errno
extern int errno;
#endif

jmp_buf msgenv;

SIGTYPE
msgcatch ()
{
  longjmp (msgenv, 1);
}


/* "THIS has to be fixed.  Remember, stderr may not exist...-rlk."
   Incorrect.  This program runs as an inferior of Emacs.
   Its stderr always exists--rms.  */
#include <stdio.h>

int
main ()
{
  int s, infd, fromlen, ioproc;
  key_t key;
  struct msgbuf * msgp =
    (struct msgbuf *) malloc (sizeof *msgp + BUFSIZ);
  struct msqid_ds msg_st;
  int p;
  char *homedir, *getenv ();
  char string[BUFSIZ];
  FILE *infile;

  /*
   * Create a message queue using ~/.emacs-server as the path for ftok
   */
  if ((homedir = getenv ("HOME")) == NULL)
    fatal_error ("No home directory\n");

  strcpy (string, homedir);
#ifndef HAVE_LONG_FILE_NAMES
  /* If file names are short, we can't fit the host name.  */
  strcat (string, "/.emacs-server");
#else
  strcat (string, "/.emacs-server-");
  uname (&system_name);
  strcat (string, system_name.nodename);
#endif
  creat (string, 0600);
  key = ftok (string, 1);	/* unlikely to be anyone else using it */
  s = msgget (key, 0600 | IPC_CREAT);
  if (s == -1)
    {
      perror_1 ("msgget");
      exit (1);
    }

  /* Fork so we can close connection even if parent dies */
  p = fork ();
  if (setjmp (msgenv))
    {
      msgctl (s, IPC_RMID, 0);
      if (p > 0)
	kill (p, SIGKILL);
      exit (0);
    }
  signal (SIGTERM, msgcatch);
  signal (SIGINT, msgcatch);
  signal (SIGHUP, msgcatch);
  if (p > 0)
    {
      /* This is executed in the original process that did the fork above.  */
      /* Get pid of Emacs itself.  */
      p = getppid ();
      setpgrp ();		/* Gnu kills process group on exit */
      while (1)
	{
	  /* Is Emacs still alive?  */
	  if (kill (p, 0) < 0)
	    {
	      msgctl (s, IPC_RMID, 0);
	      exit (0);
	    }
	  sleep (10);
	}
    }

  /* This is executed in the child made by forking above.
     Call it c1.  Make another process, ioproc.  */

  ioproc = fork ();
  if (ioproc == 0)
    {
      /* In process ioproc, wait for text from Emacs,
	 and send it to the process c1.
	 This way, c1 only has to wait for one source of input.  */
      while (fgets (msgp->mtext, BUFSIZ, stdin))
	{
	  msgp->mtype = 1;
	  msgsnd (s, msgp, strlen (msgp->mtext) + 1, 0);
	}
      exit (1);
    }

  /* In the process c1,
     listen for messages from clients and pass them to Emacs.  */
  while (1)
    {
      if ((fromlen = msgrcv (s, msgp, BUFSIZ - 1, 1, 0)) < 0)
        {
#ifdef EINTR
	  if (errno == EINTR)
	    continue;
#endif
	  perror_1 ("msgrcv");
	  exit (1);
        }
      else
        {
	  msgctl (s, IPC_STAT, &msg_st);

	  /* Distinguish whether the message came from a client, or from
	     ioproc.  */
	  if (msg_st.msg_lspid == ioproc)
	    {
	      char code[BUFSIZ];
	      int inproc;

	      /* Message from ioproc: tell a client we are done.  */
	      msgp->mtext[strlen (msgp->mtext)-1] = 0;
	      sscanf (msgp->mtext, "%s %d", code, &inproc);
	      msgp->mtype = inproc;
	      msgsnd (s, msgp, strlen (msgp->mtext) + 1, 0);
	      continue;
	    }

	  /* This is a request from a client: copy to stdout
	     so that Emacs will get it.  Include msg_lspid
	     so server.el can tell us where to send the reply.  */
	  strncpy (string, msgp->mtext, fromlen);
	  string[fromlen] = 0;	/* make sure */
	  /* Newline is part of string.. */
	  printf ("Client: %d %s", msg_st.msg_lspid, string);
	  fflush (stdout);
	}
    }
}

#endif /* HAVE_SYSVIPC */

\f
/* This is like perror but puts `Error: ' at the beginning.  */

void
perror_1 (string)
     char *string;
{
  char *copy = (char *) malloc (strlen (string) + 8);
  if (copy == 0)
    fatal_error ("Virtual memory exhausted");

  strcpy (copy, "Error: ");
  strcat (copy, string);
  perror (copy);
}

void
fatal_error (string)
     char *string;
{
  fprintf (stderr, "%s", "Error: ");
  fprintf (stderr, string);
  exit (1);
}
#endif /* HAVE_SOCKETS or HAVE_SYSVIPC */
Commit	Line	Data
d953f306	1	/* Communication subprocess for GNU Emacs acting as server.
4ee9629e	2	Copyright (C) 1986, 1987, 1992, 1994, 1999 Free Software Foundation, Inc.
d953f306 RS	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
d4327fec	8	the Free Software Foundation; either version 2, or (at your option)
d953f306 RS	9	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; see the file COPYING. If not, write to
3b7ad313 EN	18	the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
3b7ad313 EN	19	Boston, MA 02111-1307, USA. */
d953f306 RS	20
	21
	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. */
	27
	28	#define NO_SHORTNAMES
18160b98	29	#include <../src/config.h>
4ee9629e	30	#include <signal.h>
5ed8e09c	31	#undef signal
d953f306	32
021eac48	33	#if !defined (HAVE_SOCKETS) && !defined (HAVE_SYSVIPC)
d953f306 RS	34	#include <stdio.h>
d953f306 RS	35
4e7ef1d6	36	int
d953f306 RS	37	main ()
	38	{
	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);
	42	}
	43
	44	#else /* HAVE_SOCKETS or HAVE_SYSVIPC */
	45
4e7ef1d6 AS	46	void perror_1 ();
	47	void fatal_error ();
	48
1e523e3d	49	#if defined (HAVE_SOCKETS) && ! defined (NO_SOCKETS_IN_FILE_SYSTEM)
d953f306 RS	50	/* BSD code is very different from SYSV IPC code */
d953f306 RS	51
d953f306	52	#include <sys/types.h>
908d6b87	53	#include <sys/file.h>
d953f306	54	#include <sys/socket.h>
d953f306 RS	55	#include <sys/un.h>
	56	#include <stdio.h>
	57	#include <errno.h>
cbf5f47c	58	#include <sys/stat.h>
d953f306	59
4e7ef1d6 AS	60	#ifdef HAVE_UNISTD_H
	61	#include <unistd.h>
	62	#endif
	63
1ee65e5c	64	#ifndef errno
d953f306	65	extern int errno;
1ee65e5c	66	#endif
d953f306	67
b38bab94 KH	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
	82
	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 */
	89
d8888efa RS	90	/* This is the file name of the socket that we made. */
	91
	92	char *socket_name;
	93
	94	/* Name of this program. */
	95
	96	char *progname;
	97	\f
	98	/* Handle fatal signals. */
	99
	100	/* This is the handler. */
	101
	102	SIGTYPE
	103	delete_socket (sig)
	104	int sig;
	105	{
	106	signal (sig, SIG_DFL);
	107	unlink (socket_name);
	108	kill (getpid (), sig);
	109	}
	110
	111	/* Set up to handle all the signals. */
	112
4e7ef1d6	113	void
d8888efa RS	114	handle_signals ()
	115	{
	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 */
	164
	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 */
	176	}
	177	\f
178	/* Print error message. `s1' is printf control string, `s2' is arg for it. */
179	void
180	error (s1, s2)
181	char s1, s2;
182	{
183	fprintf (stderr, "%s: ", progname);
184	fprintf (stderr, s1, s2);
185	fprintf (stderr, "\n");
186	}
187
188	/* Print error message and exit. */
189	void
190	fatal (s1, s2)
191	char s1, s2;
192	{
193	error (s1, s2);
194	exit (1);
195	}
196
197	/* Like malloc but get fatal error if memory is exhausted. */
198
199	long *
200	xmalloc (size)
201	unsigned int size;
202	{
203	long result = (long ) malloc (size);
204	if (result == NULL)
205	fatal ("virtual memory exhausted", 0);
206	return result;
207	}
208	\f
c275f129	209	int
d8888efa RS	210	main (argc, argv)
	211	int argc;
	212	char **argv;
d953f306	213	{
40beb971 RS	214	char *system_name;
40beb971 RS	215	int system_name_length;
4893a437	216	int s, infd;
57b1f720 RS	217	#ifdef SOCKLEN_TYPE
	218	SOCKLEN_TYPE fromlen;
	219	#else
4893a437	220	size_t fromlen;
57b1f720	221	#endif
4893a437	222	struct sockaddr_un server, fromunix;
317ad01e	223	#ifdef SERVER_HOME_DIR
d953f306	224	char *homedir;
317ad01e	225	#endif
d953f306 RS	226	char *str, string[BUFSIZ], code[BUFSIZ];
	227	FILE *infile;
	228	FILE **openfiles;
	229	int openfiles_size;
cbf5f47c	230	struct stat statbuf;
d953f306	231
f662f9b0	232	#ifndef convex
d953f306	233	char *getenv ();
f662f9b0	234	#endif
d953f306	235
d8888efa RS	236	progname = argv[0];
d8888efa RS	237
d953f306 RS	238	openfiles_size = 20;
	239	openfiles = (FILE *) malloc (openfiles_size sizeof (FILE *));
	240	if (openfiles == 0)
	241	abort ();
	242
	243	/*
	244	* Open up an AF_UNIX socket in this person's home directory
	245	*/
	246
	247	if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
	248	{
ccd318fb	249	perror_1 ("socket");
d953f306 RS	250	exit (1);
	251	}
	252	server.sun_family = AF_UNIX;
40beb971	253
c5fee545	254	system_name_length = 32;
40beb971 RS	255	while (1)
	256	{
	257	system_name = (char *) xmalloc (system_name_length + 1);
	258
	259	/* system_name must be null-terminated string. */
	260	system_name[system_name_length] = '\0';
	261
	262	if (gethostname (system_name, system_name_length) == 0)
	263	break;
	264
	265	free (system_name);
	266	system_name_length *= 2;
	267	}
	268
c5fee545	269	#ifndef SERVER_HOME_DIR
c3d7eab2	270	sprintf (server.sun_path, "/tmp/esrv%d-%s", (int) geteuid (), system_name);
1464f5d5 JB	271
	272	if (unlink (server.sun_path) == -1 && errno != ENOENT)
	273	{
ccd318fb	274	perror_1 ("unlink");
1464f5d5 JB	275	exit (1);
	276	}
	277	#else
	278	if ((homedir = getenv ("HOME")) == NULL)
ccd318fb RS	279	fatal_error ("No home directory\n");
ccd318fb RS	280
d953f306	281	strcpy (server.sun_path, homedir);
021eac48	282	strcat (server.sun_path, "/.emacs-server-");
021eac48	283	strcat (server.sun_path, system_name);
d953f306 RS	284	/* Delete anyone else's old server. */
d953f306 RS	285	unlink (server.sun_path);
1464f5d5 JB	286	#endif
1464f5d5 JB	287
d8888efa RS	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);
	291
	292	handle_signals ();
	293
2fdfe079	294	if (bind (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2) < 0)
d953f306	295	{
ccd318fb	296	perror_1 ("bind");
d953f306 RS	297	exit (1);
	298	}
	299	/* Only this user can send commands to this Emacs. */
cbf5f47c KH	300	if (stat (server.sun_path, &statbuf) < 0)
	301	{
	302	perror_1 ("bind");
	303	exit (1);
	304	}
	305
	306	chmod (server.sun_path, statbuf.st_mode & 0600);
d953f306 RS	307	/*
	308	* Now, just wait for everything to come in..
	309	*/
	310	if (listen (s, 5) < 0)
	311	{
ccd318fb	312	perror_1 ("listen");
d953f306 RS	313	exit (1);
	314	}
	315
	316	/* Disable sigpipes in case luser kills client... */
	317	signal (SIGPIPE, SIG_IGN);
	318	for (;;)
	319	{
b38bab94	320	SELECT_TYPE rmask;
86af296b RM	321	FD_ZERO (&rmask);
	322	FD_SET (0, &rmask);
	323	FD_SET (s, &rmask);
b38bab94	324	if (select (s + 1, &rmask, 0, 0, 0) < 0)
ccd318fb	325	perror_1 ("select");
86af296b	326	if (FD_ISSET (s, &rmask)) /* client sends list of filenames */
d953f306 RS	327	{
	328	fromlen = sizeof (fromunix);
	329	fromunix.sun_family = AF_UNIX;
b38bab94	330	infd = accept (s, (struct sockaddr *) &fromunix, &fromlen);
d953f306 RS	331	if (infd < 0)
	332	{
	333	if (errno == EMFILE \|\| errno == ENFILE)
ccd318fb	334	fprintf (stderr, "Error: too many clients.\n");
d953f306	335	else
ccd318fb	336	perror_1 ("accept");
d953f306 RS	337	continue;
	338	}
	339
	340	if (infd >= openfiles_size)
	341	{
	342	openfiles_size *= 2;
	343	openfiles = (FILE **) realloc (openfiles,
	344	openfiles_size * sizeof (FILE *));
	345	if (openfiles == 0)
	346	abort ();
	347	}
	348
	349	infile = fdopen (infd, "r+"); /* open stream */
	350	if (infile == NULL)
	351	{
ccd318fb	352	fprintf (stderr, "Error: too many clients.\n");
d953f306 RS	353	write (infd, "Too many clients.\n", 18);
	354	close (infd); /* Prevent descriptor leak.. */
	355	continue;
	356	}
	357	str = fgets (string, BUFSIZ, infile);
	358	if (str == NULL)
	359	{
ccd318fb	360	perror_1 ("fgets");
d953f306 RS	361	close (infd); /* Prevent descriptor leak.. */
	362	continue;
	363	}
	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')
	370	{
	371	if (fgets (string, BUFSIZ, infile) == 0)
	372	break;
	373	printf ("%s", string);
	374	}
	375	fflush (stdout);
	376	fflush (infile);
	377	continue;
	378	}
86af296b	379	else if (FD_ISSET (0, &rmask)) /* emacs sends codeword, fd, and string message */
d953f306 RS	380	{
	381	/* Read command codeword and fd */
	382	clearerr (stdin);
	383	scanf ("%s %d%*c", code, &infd);
	384	if (ferror (stdin) \|\| feof (stdin))
ccd318fb	385	fatal_error ("server: error reading from standard input\n");
d953f306 RS	386
	387	/* Transfer text from Emacs to the client, up to a newline. */
	388	infile = openfiles[infd];
cbd1aee2	389	rewind (infile);
d953f306 RS	390	while (1)
	391	{
	392	if (fgets (string, BUFSIZ, stdin) == 0)
	393	break;
	394	fprintf (infile, "%s", string);
	395	if (string[strlen (string) - 1] == '\n')
	396	break;
	397	}
	398	fflush (infile);
	399
	400	/* If command is close, close connection to client. */
	401	if (strncmp (code, "Close:", 6) == 0)
	402	if (infd > 2)
	403	{
	404	fclose (infile);
	405	close (infd);
	406	}
	407	continue;
	408	}
	409	}
	410	}
	411
	412	#else /* This is the SYSV IPC section */
	413
	414	#include <sys/types.h>
d953f306 RS	415	#include <sys/ipc.h>
	416	#include <sys/msg.h>
	417	#include <setjmp.h>
b8a0f2d8	418	#include <errno.h>
021eac48 RS	419	#include <sys/utsname.h>
	420
	421	struct utsname system_name;
b8a0f2d8 RS	422
	423	#ifndef errno
	424	extern int errno;
	425	#endif
d953f306 RS	426
	427	jmp_buf msgenv;
	428
d4327fec	429	SIGTYPE
d953f306 RS	430	msgcatch ()
	431	{
	432	longjmp (msgenv, 1);
	433	}
	434
	435
	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>
	440
4e7ef1d6	441	int
d953f306 RS	442	main ()
d953f306 RS	443	{
2f317998	444	int s, infd, fromlen, ioproc;
d953f306 RS	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;
	453
	454	/*
021eac48	455	* Create a message queue using ~/.emacs-server as the path for ftok
d953f306 RS	456	*/
d953f306 RS	457	if ((homedir = getenv ("HOME")) == NULL)
ccd318fb RS	458	fatal_error ("No home directory\n");
ccd318fb RS	459
d953f306	460	strcpy (string, homedir);
021eac48 RS	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
d953f306 RS	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)
	473	{
ccd318fb	474	perror_1 ("msgget");
d953f306 RS	475	exit (1);
	476	}
	477
	478	/* Fork so we can close connection even if parent dies */
	479	p = fork ();
	480	if (setjmp (msgenv))
	481	{
	482	msgctl (s, IPC_RMID, 0);
b8a0f2d8 RS	483	if (p > 0)
b8a0f2d8 RS	484	kill (p, SIGKILL);
d953f306 RS	485	exit (0);
	486	}
	487	signal (SIGTERM, msgcatch);
	488	signal (SIGINT, msgcatch);
b8a0f2d8	489	signal (SIGHUP, msgcatch);
9e3891de	490	if (p > 0)
d953f306	491	{
9e3891de RS	492	/* This is executed in the original process that did the fork above. */
9e3891de RS	493	/* Get pid of Emacs itself. */
d953f306 RS	494	p = getppid ();
	495	setpgrp (); /* Gnu kills process group on exit */
	496	while (1)
	497	{
9e3891de	498	/* Is Emacs still alive? */
d953f306 RS	499	if (kill (p, 0) < 0)
	500	{
	501	msgctl (s, IPC_RMID, 0);
	502	exit (0);
	503	}
	504	sleep (10);
	505	}
	506	}
	507
2f317998 RS	508	/* This is executed in the child made by forking above.
	509	Call it c1. Make another process, ioproc. */
	510
	511	ioproc = fork ();
	512	if (ioproc == 0)
	513	{
	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))
	518	{
	519	msgp->mtype = 1;
	520	msgsnd (s, msgp, strlen (msgp->mtext) + 1, 0);
	521	}
	522	exit (1);
	523	}
	524
	525	/* In the process c1,
	526	listen for messages from clients and pass them to Emacs. */
d953f306 RS	527	while (1)
	528	{
	529	if ((fromlen = msgrcv (s, msgp, BUFSIZ - 1, 1, 0)) < 0)
	530	{
b8a0f2d8 RS	531	#ifdef EINTR
	532	if (errno == EINTR)
	533	continue;
	534	#endif
ccd318fb	535	perror_1 ("msgrcv");
1464f5d5	536	exit (1);
d953f306 RS	537	}
	538	else
	539	{
	540	msgctl (s, IPC_STAT, &msg_st);
2f317998 RS	541
	542	/* Distinguish whether the message came from a client, or from
	543	ioproc. */
	544	if (msg_st.msg_lspid == ioproc)
	545	{
	546	char code[BUFSIZ];
	547	int inproc;
	548
	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;
	555	}
	556
	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. */
d953f306 RS	560	strncpy (string, msgp->mtext, fromlen);
	561	string[fromlen] = 0; /* make sure */
	562	/* Newline is part of string.. */
2f317998	563	printf ("Client: %d %s", msg_st.msg_lspid, string);
d953f306	564	fflush (stdout);
d953f306 RS	565	}
	566	}
	567	}
	568
	569	#endif /* HAVE_SYSVIPC */
	570
ccd318fb RS	571	\f
	572	/* This is like perror but puts `Error: ' at the beginning. */
	573
4e7ef1d6	574	void
ccd318fb RS	575	perror_1 (string)
	576	char *string;
	577	{
	578	char copy = (char ) malloc (strlen (string) + 8);
	579	if (copy == 0)
	580	fatal_error ("Virtual memory exhausted");
	581
	582	strcpy (copy, "Error: ");
	583	strcat (copy, string);
	584	perror (copy);
	585	}
	586
4e7ef1d6	587	void
ccd318fb RS	588	fatal_error (string)
	589	char *string;
	590	{
	591	fprintf (stderr, "%s", "Error: ");
	592	fprintf (stderr, string);
	593	exit (1);
	594	}
bbe73f05	595	#endif /* HAVE_SOCKETS or HAVE_SYSVIPC */