home *** CD-ROM | disk | FTP | other *** search
/ Geek Gadgets 1 / ADE-1.bin / ade-dist / emacs-19.28-src.tgz / tar.out / fsf / emacs / lib-src / emacsserver.c < prev    next >
C/C++ Source or Header  |  1996-09-28  |  9KB  |  365 lines
  1. /* Communication subprocess for GNU Emacs acting as server.
  2.    Copyright (C) 1986, 1987, 1992 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 2, or (at your option)
  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
  18. the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA.  */
  19.  
  20.  
  21. /* The GNU Emacs edit server process is run as a subprocess of Emacs
  22.    under control of the file lisp/server.el.
  23.    This program accepts communication from client (program emacsclient.c)
  24.    and passes their commands (consisting of keyboard characters)
  25.    up to the Emacs which then executes them.  */
  26.  
  27. #define NO_SHORTNAMES
  28. #include <../src/config.h>
  29. #undef read
  30. #undef write
  31. #undef open
  32. #undef close
  33. #undef signal
  34.  
  35.  
  36. #if !defined(HAVE_SOCKETS) && !defined(HAVE_SYSVIPC)
  37. #include <stdio.h>
  38.  
  39. main ()
  40. {
  41.   fprintf (stderr, "Sorry, the Emacs server is supported only on systems\n");
  42.   fprintf (stderr, "with Berkeley sockets or System V IPC.\n");
  43.   exit (1);
  44. }
  45.  
  46. #else /* HAVE_SOCKETS or HAVE_SYSVIPC */
  47.  
  48. #if ! defined (HAVE_SYSVIPC)
  49. /* BSD code is very different from SYSV IPC code */
  50.  
  51. #include <sys/types.h>
  52. #include <sys/file.h>
  53. #include <sys/socket.h>
  54. #include <sys/signal.h>
  55. #include <sys/un.h>
  56. #include <stdio.h>
  57. #include <errno.h>
  58.  
  59. extern int errno;
  60.  
  61. main ()
  62. {
  63.   char system_name[32];
  64.   int s, infd, fromlen;
  65.   struct sockaddr_un server, fromunix;
  66.   char *homedir;
  67.   char *str, string[BUFSIZ], code[BUFSIZ];
  68.   FILE *infile;
  69.   FILE **openfiles;
  70.   int openfiles_size;
  71.  
  72. #ifndef convex
  73.   char *getenv ();
  74. #endif
  75.  
  76.   openfiles_size = 20;
  77.   openfiles = (FILE **) malloc (openfiles_size * sizeof (FILE *));
  78.   if (openfiles == 0)
  79.     abort ();
  80.  
  81.   /* 
  82.    * Open up an AF_UNIX socket in this person's home directory
  83.    */
  84.  
  85.   if ((s = socket (AF_UNIX, SOCK_STREAM, 0)) < 0)
  86.     {
  87.       perror ("socket");
  88.       exit (1);
  89.     }
  90.   server.sun_family = AF_UNIX;
  91. #ifndef SERVER_HOME_DIR
  92.   gethostname (system_name, sizeof (system_name));
  93.   sprintf (server.sun_path, "/tmp/esrv%d-%s", geteuid (), system_name);
  94.  
  95.   if (unlink (server.sun_path) == -1 && errno != ENOENT)
  96.     {
  97.       perror ("unlink");
  98.       exit (1);
  99.     }
  100. #else  
  101.   if ((homedir = getenv ("HOME")) == NULL)
  102.     {
  103.       fprintf (stderr,"No home directory\n");
  104.       exit (1);
  105.     }
  106.   strcpy (server.sun_path, homedir);
  107.   strcat (server.sun_path, "/.emacs_server");
  108.   /* Delete anyone else's old server.  */
  109.   unlink (server.sun_path);
  110. #endif
  111.  
  112.   if (bind (s, (struct sockaddr *) &server, strlen (server.sun_path) + 2) < 0)
  113.     {
  114.       perror ("bind");
  115.       exit (1);
  116.     }
  117.   /* Only this user can send commands to this Emacs.  */
  118.   chmod (server.sun_path, 0600);
  119.   /*
  120.    * Now, just wait for everything to come in..
  121.    */
  122.   if (listen (s, 5) < 0)
  123.     {
  124.       perror ("listen");
  125.       exit (1);
  126.     }
  127.  
  128.   /* Disable sigpipes in case luser kills client... */
  129.   signal (SIGPIPE, SIG_IGN);
  130.   for (;;)
  131.     {
  132.       int rmask = (1 << s) + 1;
  133.       if (select (s + 1, (fd_set *)&rmask, 0, 0, 0) < 0)
  134.     perror ("select");
  135.       if (rmask & (1 << s))    /* client sends list of filenames */
  136.     {
  137.       fromlen = sizeof (fromunix);
  138.       fromunix.sun_family = AF_UNIX;
  139.       infd = accept (s, (struct sockaddr *) &fromunix,
  140.              (size_t *) &fromlen);
  141.       if (infd < 0)
  142.         {
  143.           if (errno == EMFILE || errno == ENFILE)
  144.         printf ("Too many clients.\n");
  145.           else
  146.         perror ("accept");
  147.           continue;
  148.         }
  149.  
  150.       if (infd >= openfiles_size)
  151.         {
  152.           openfiles_size *= 2;
  153.           openfiles = (FILE **) realloc (openfiles,
  154.                          openfiles_size * sizeof (FILE *));
  155.           if (openfiles == 0)
  156.         abort ();
  157.         }
  158.  
  159.       infile = fdopen (infd, "r+"); /* open stream */
  160.       if (infile == NULL)
  161.         {
  162.           printf ("Too many clients.\n");
  163.           write (infd, "Too many clients.\n", 18);
  164.           close (infd);        /* Prevent descriptor leak.. */
  165.           continue;
  166.         }
  167.       str = fgets (string, BUFSIZ, infile);
  168.       if (str == NULL)
  169.         {
  170.           perror ("fgets");
  171.           close (infd);        /* Prevent descriptor leak.. */
  172.           continue;
  173.         }
  174.       openfiles[infd] = infile;
  175.       printf ("Client: %d %s", infd, string);
  176.       /* If what we read did not end in a newline,
  177.          it means there is more.  Keep reading from the socket
  178.          and outputting to Emacs, until we get the newline.  */
  179.       while (string[strlen (string) - 1] != '\n')
  180.         {
  181.           if (fgets (string, BUFSIZ, infile) == 0)
  182.         break;
  183.           printf ("%s", string);
  184.         }
  185.       fflush (stdout);
  186.       fflush (infile);
  187.       continue;
  188.     }
  189.       else if (rmask & 1) /* emacs sends codeword, fd, and string message */
  190.     {
  191.       /* Read command codeword and fd */
  192.       clearerr (stdin);
  193.       scanf ("%s %d%*c", code, &infd);
  194.       if (ferror (stdin) || feof (stdin))
  195.         {
  196.           fprintf (stderr, "server: error reading from standard input\n");
  197.           exit (1);
  198.         }
  199.  
  200.       /* Transfer text from Emacs to the client, up to a newline.  */
  201.       infile = openfiles[infd];
  202.       while (1)
  203.         {
  204.           if (fgets (string, BUFSIZ, stdin) == 0)
  205.         break;
  206.           fprintf (infile, "%s", string);
  207.           if (string[strlen (string) - 1] == '\n')
  208.         break;
  209.         }
  210.       fflush (infile);
  211.  
  212.       /* If command is close, close connection to client.  */
  213.       if (strncmp (code, "Close:", 6) == 0) 
  214.         if (infd > 2) 
  215.           {
  216.         fclose (infile);
  217.         close (infd);
  218.           }
  219.       continue;
  220.     } 
  221.     }
  222. }
  223.  
  224. #else  /* This is the SYSV IPC section */
  225.  
  226. #include <sys/types.h>
  227. #include <sys/signal.h>
  228. #include <sys/ipc.h>
  229. #include <sys/msg.h>
  230. #include <setjmp.h>
  231.  
  232. jmp_buf msgenv;
  233.  
  234. SIGTYPE
  235. msgcatch ()
  236. {
  237.   longjmp (msgenv, 1);
  238. }
  239.  
  240.  
  241. /* "THIS has to be fixed.  Remember, stderr may not exist...-rlk."
  242.    Incorrect.  This program runs as an inferior of Emacs.
  243.    Its stderr always exists--rms.  */
  244. #include <stdio.h>
  245.  
  246. main ()
  247. {
  248.   int s, infd, fromlen, ioproc;
  249.   key_t key;
  250.   struct msgbuf * msgp =
  251.     (struct msgbuf *) malloc (sizeof *msgp + BUFSIZ);
  252.   struct msqid_ds msg_st;
  253.   int p;
  254.   char *homedir, *getenv ();
  255.   char string[BUFSIZ];
  256.   FILE *infile;
  257.  
  258.   /*
  259.    * Create a message queue using ~/.emacs_server as the path for ftok
  260.    */
  261.   if ((homedir = getenv ("HOME")) == NULL)
  262.     {
  263.       fprintf (stderr,"No home directory\n");
  264.       exit (1);
  265.     }
  266.   strcpy (string, homedir);
  267.   strcat (string, "/.emacs_server");
  268.   creat (string, 0600);
  269.   key = ftok (string, 1);    /* unlikely to be anyone else using it */
  270.   s = msgget (key, 0600 | IPC_CREAT);
  271.   if (s == -1)
  272.     {
  273.       perror ("msgget");
  274.       exit (1);
  275.     }
  276.  
  277.   /* Fork so we can close connection even if parent dies */
  278.   p = fork ();
  279.   if (setjmp (msgenv))
  280.     {
  281.       msgctl (s, IPC_RMID, 0);
  282.       kill (p, SIGKILL);
  283.       exit (0);
  284.     }
  285.   signal (SIGTERM, msgcatch);
  286.   signal (SIGINT, msgcatch);
  287.   if (p > 0)
  288.     {
  289.       /* This is executed in the original process that did the fork above.  */
  290.       /* Get pid of Emacs itself.  */
  291.       p = getppid ();
  292.       setpgrp ();        /* Gnu kills process group on exit */
  293.       while (1)
  294.     {
  295.       /* Is Emacs still alive?  */
  296.       if (kill (p, 0) < 0)
  297.         {
  298.           msgctl (s, IPC_RMID, 0);
  299.           exit (0);
  300.         }
  301.       sleep (10);
  302.     }
  303.     }
  304.  
  305.   /* This is executed in the child made by forking above.
  306.      Call it c1.  Make another process, ioproc.  */
  307.  
  308.   ioproc = fork ();
  309.   if (ioproc == 0)
  310.     {
  311.       /* In process ioproc, wait for text from Emacs,
  312.      and send it to the process c1.
  313.      This way, c1 only has to wait for one source of input.  */
  314.       while (fgets (msgp->mtext, BUFSIZ, stdin))
  315.     {
  316.       msgp->mtype = 1;
  317.       msgsnd (s, msgp, strlen (msgp->mtext) + 1, 0);
  318.     }
  319.       exit (1);
  320.     }
  321.  
  322.   /* In the process c1,
  323.      listen for messages from clients and pass them to Emacs.  */
  324.   while (1)
  325.     {
  326.       if ((fromlen = msgrcv (s, msgp, BUFSIZ - 1, 1, 0)) < 0)
  327.         {
  328.       perror ("msgrcv");
  329.       exit (1);
  330.         }
  331.       else
  332.         {
  333.       msgctl (s, IPC_STAT, &msg_st);
  334.  
  335.       /* Distinguish whether the message came from a client, or from
  336.          ioproc.  */
  337.       if (msg_st.msg_lspid == ioproc)
  338.         {
  339.           char code[BUFSIZ];
  340.           int inproc;
  341.  
  342.           /* Message from ioproc: tell a client we are done.  */
  343.           msgp->mtext[strlen (msgp->mtext)-1] = 0;
  344.           sscanf (msgp->mtext, "%s %d", code, &inproc);
  345.           msgp->mtype = inproc;
  346.           msgsnd (s, msgp, strlen (msgp->mtext) + 1, 0);
  347.           continue;
  348.         }
  349.  
  350.       /* This is a request from a client: copy to stdout
  351.          so that Emacs will get it.  Include msg_lspid
  352.          so server.el can tell us where to send the reply.  */
  353.       strncpy (string, msgp->mtext, fromlen);
  354.       string[fromlen] = 0;    /* make sure */
  355.       /* Newline is part of string.. */
  356.       printf ("Client: %d %s", msg_st.msg_lspid, string);
  357.       fflush (stdout);
  358.     }
  359.     }
  360. }
  361.  
  362. #endif /* HAVE_SYSVIPC */
  363.  
  364. #endif /* HAVE_SOCKETS or HAVE_SYSVIPC */
  365.