From 215ab9f17b90cf96654e82fc8340911a43180c9c Mon Sep 17 00:00:00 2001 From: Martin Baulig Date: Sun, 14 Jun 1998 14:09:34 +0000 Subject: [PATCH] Initial revision --- src/daemon/gnuclient.c | 620 ++++++++++++++++++++++++++++ src/daemon/gnuserv.c | 913 +++++++++++++++++++++++++++++++++++++++++ src/daemon/gnuserv.h | 220 ++++++++++ 3 files changed, 1753 insertions(+) create mode 100644 src/daemon/gnuclient.c create mode 100644 src/daemon/gnuserv.c create mode 100644 src/daemon/gnuserv.h diff --git a/src/daemon/gnuclient.c b/src/daemon/gnuclient.c new file mode 100644 index 00000000..41137abd --- /dev/null +++ b/src/daemon/gnuclient.c @@ -0,0 +1,620 @@ +/* -*-C-*- + Client code to allow local and remote editing of files by XEmacs. + Copyright (C) 1989 Free Software Foundation, Inc. + Copyright (C) 1995 Sun Microsystems, Inc. + Copyright (C) 1997 Free Software Foundation, Inc. + +This file is part of XEmacs. + +XEmacs 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. + +XEmacs 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 XEmacs; see the file COPYING. If not, write to +the Free Software Foundation, Inc., 59 Temple Place - Suite 330, +Boston, MA 02111-1307, USA. + + Author: Andy Norman (ange@hplb.hpl.hp.com), based on + 'etc/emacsclient.c' from the GNU Emacs 18.52 distribution. + + Please mail bugs and suggestions to the author at the above address. +*/ + +/* + * This file incorporates new features added by Bob Weiner , + * Darrell Kindred and Arup Mukherjee . + * GNUATTACH support added by Ben Wing . + * Please see the note at the end of the README file for details. + * + * (If gnuserv came bundled with your emacs, the README file is probably + * ../etc/gnuserv.README relative to the directory containing this file) + */ + +#if 0 +/* Hand-munged RCS header */ +static char rcsid [] = "!Header: gnuclient.c,v 2.2 95/12/12 01:39:21 wing nene !"; +#endif + +#include "gnuserv.h" +#include "getopt.h" + +#include +#include +#include + +#ifdef HAVE_STRING_H +#include +#endif /* HAVE_STRING_H */ + +#ifdef HAVE_UNISTD_H +#include +#endif /* HAVE_UNISTD_H */ + +#include + +#if !defined(SYSV_IPC) && !defined(UNIX_DOMAIN_SOCKETS) && \ + !defined(INTERNET_DOMAIN_SOCKETS) +int +main (int argc, char *argv[]) +{ + fprintf (stderr, "Sorry, the Emacs server is only " + "supported on systems that have\n"); + fprintf (stderr, "Unix Domain sockets, Internet Domain " + "sockets or System V IPC.\n"); + exit (1); +} /* main */ +#else /* SYSV_IPC || UNIX_DOMAIN_SOCKETS || INTERNET_DOMAIN_SOCKETS */ + +static char cwd[MAXPATHLEN+2]; /* current working directory when calculated */ +static char *cp = NULL; /* ptr into valid bit of cwd above */ + +static pid_t emacs_pid; /* Process id for emacs process */ + +void initialize_signals (void); + +static void +tell_emacs_to_resume (int sig) +{ + char buffer[GSERV_BUFSZ+1]; + int s; /* socket / msqid to server */ + int connect_type; /* CONN_UNIX, CONN_INTERNET, or + ONN_IPC */ + + /* Why is SYSV so retarded? */ + /* We want emacs to realize that we are resuming */ + signal(SIGCONT, tell_emacs_to_resume); + + connect_type = make_connection (NULL, (u_short) 0, &s); + + sprintf(buffer,"(gnuserv-eval '(resume-pid-console %d))", (int)getpid()); + send_string(s, buffer); + +#ifdef SYSV_IPC + if (connect_type == (int) CONN_IPC) + disconnect_from_ipc_server (s, msgp, FALSE); +#else /* !SYSV_IPC */ + if (connect_type != (int) CONN_IPC) + disconnect_from_server (s, FALSE); +#endif /* !SYSV_IPC */ +} + +static void +pass_signal_to_emacs (int sig) +{ + if (kill (emacs_pid, sig) == -1) + { + fprintf (stderr, "gnuattach: Could not pass signal to emacs process\n"); + exit (1); + } + initialize_signals (); +} + +void +initialize_signals () +{ + /* Set up signal handler to pass relevant signals to emacs process. + We used to send SIGSEGV, SIGBUS, SIGPIPE, SIGILL and others to + Emacs, but I think it's better not to. I can see no reason why + Emacs should SIGSEGV whenever gnuclient SIGSEGV-s, etc. */ + signal (SIGHUP, pass_signal_to_emacs); + signal (SIGQUIT, pass_signal_to_emacs); + signal (SIGINT, pass_signal_to_emacs); +#ifdef SIGWINCH + signal (SIGWINCH, pass_signal_to_emacs); +#endif + + /* We want emacs to realize that we are resuming */ + signal (SIGCONT, tell_emacs_to_resume); +} + + +/* + get_current_working_directory -- return the cwd. +*/ +static char * +get_current_working_directory (void) +{ + if (cp == NULL) + { /* haven't calculated it yet */ +#ifdef BSD + if (getwd (cwd) == 0) +#else /* !BSD */ + if (getcwd (cwd,MAXPATHLEN) == NULL) +#endif /* !BSD */ + { + perror (progname); + fprintf (stderr, "%s: unable to get current working directory\n", + progname); + exit (1); + } /* if */ + + /* on some systems, cwd can look like '@machine/' ... */ + /* ignore everything before the first '/' */ + for (cp = cwd; *cp && *cp != '/'; ++cp) + ; + + } /* if */ + + return cp; + +} /* get_current_working_directory */ + + +/* + filename_expand -- try to convert the given filename into a fully-qualified + pathname. +*/ +static void +filename_expand (char *fullpath, char *filename) + /* fullpath - returned full pathname */ + /* filename - filename to expand */ +{ + int len; + + fullpath[0] = '\0'; + + if (filename[0] && filename[0] != '/') + { /* relative filename */ + strcat (fullpath, get_current_working_directory ()); + len = strlen (fullpath); + + if (len > 0 && fullpath[len-1] == '/') /* trailing slash already? */ + ; /* yep */ + else + strcat (fullpath, "/"); /* nope, append trailing slash */ + } /* if */ + + strcat (fullpath,filename); + +} /* filename_expand */ + +/* Encase the string in quotes, escape all the backslashes and quotes + in string. */ +static char * +clean_string (CONST char *s) +{ + int i = 0; + char *p, *res; + + for (p = s; *p; p++, i++) + { + if (*p == '\\' || *p == '\"') + ++i; + else if (*p == '\004') + i += 3; + } + p = res = (char *)malloc (i + 2 + 1); + *p++ = '\"'; + for (; *s; p++, s++) + { + switch (*s) + { + case '\\': + *p++ = '\\'; + *p = '\\'; + break; + case '\"': + *p++ = '\\'; + *p = '\"'; + break; + case '\004': + *p++ = '\\'; + *p++ = 'C'; + *p++ = '-'; + *p = 'd'; + break; + default: + *p = *s; + } + } + *p++ = '\"'; + *p = '\0'; + return res; +} + +#define GET_ARGUMENT(var, desc) do { \ + if (*(p + 1)) (var) = p + 1; \ + else \ + { \ + if (!argv[++i]) \ + { \ + fprintf (stderr, "%s: `%s' must be followed by an argument\n", \ + progname, desc); \ + exit (1); \ + } \ + (var) = argv[i]; \ + } \ + over = 1; \ +} while (0) + +/* A strdup immitation. */ +static char * +my_strdup (CONST char *s) +{ + char *new = malloc (strlen (s) + 1); + if (new) + strcpy (new, s); + return new; +} + +int +main (int argc, char *argv[]) +{ + int starting_line = 1; /* line to start editing at */ + char command[MAXPATHLEN+50]; /* emacs command buffer */ + char fullpath[MAXPATHLEN+1]; /* full pathname to file */ + char *eval_form = NULL; /* form to evaluate with `-eval' */ + char *eval_function = NULL; /* function to evaluate with `-f' */ + char *load_library = NULL; /* library to load */ + int quick = 0; /* quick edit, don't wait for user to + finish */ + int batch = 0; /* batch mode */ + int view = 0; /* view only. */ + int nofiles = 0; + int errflg = 0; /* option error */ + int s; /* socket / msqid to server */ + int connect_type; /* CONN_UNIX, CONN_INTERNET, or + * CONN_IPC */ + int suppress_windows_system = 0; + char *display = NULL; +#ifdef INTERNET_DOMAIN_SOCKETS + char *hostarg = NULL; /* remote hostname */ + char *remotearg; + char thishost[HOSTNAMSZ]; /* this hostname */ + char remotepath[MAXPATHLEN+1]; /* remote pathname */ + char *path; + int rflg = 0; /* pathname given on cmdline */ + char *portarg; + u_short port = 0; /* port to server */ +#endif /* INTERNET_DOMAIN_SOCKETS */ +#ifdef SYSV_IPC + struct msgbuf *msgp; /* message */ +#endif /* SYSV_IPC */ + char *tty = NULL; + char buffer[GSERV_BUFSZ + 1]; /* buffer to read pid */ + char result[GSERV_BUFSZ + 1]; + int i; + +#ifdef INTERNET_DOMAIN_SOCKETS + memset (remotepath, 0, sizeof (remotepath)); +#endif /* INTERNET_DOMAIN_SOCKETS */ + + progname = strrchr (argv[0], '/'); + if (progname) + ++progname; + else + progname = argv[0]; + + display = getenv ("DISPLAY"); + if (!display) + suppress_windows_system = 1; + else + display = my_strdup (display); + + for (i = 1; argv[i] && !errflg; i++) + { + if (*argv[i] != '-') + break; + else if (*argv[i] == '-' + && (*(argv[i] + 1) == '\0' + || (*(argv[i] + 1) == '-' && *(argv[i] + 2) == '\0'))) + { + /* `-' or `--' */ + ++i; + break; + } + + if (!strcmp (argv[i], "-batch") || !strcmp (argv[i], "--batch")) + batch = 1; + else if (!strcmp (argv[i], "-eval") || !strcmp (argv[i], "--eval")) + { + if (!argv[++i]) + { + fprintf (stderr, "%s: `-eval' must be followed by an argument\n", + progname); + exit (1); + } + eval_form = argv[i]; + } + else if (!strcmp (argv[i], "-display") || !strcmp (argv[i], "--display")) + { + suppress_windows_system = 0; + if (!argv[++i]) + { + fprintf (stderr, + "%s: `-display' must be followed by an argument\n", + progname); + exit (1); + } + if (display) + free (display); + /* no need to strdup. */ + display = argv[i]; + } + else if (!strcmp (argv[i], "-nw")) + suppress_windows_system = 1; + else + { + /* Iterate over one-letter options. */ + char *p; + int over = 0; + for (p = argv[i] + 1; *p && !over; p++) + { + switch (*p) + { + case 'q': + quick = 1; + break; + case 'v': + view = 1; + break; + case 'f': + GET_ARGUMENT (eval_function, "-f"); + break; + case 'l': + GET_ARGUMENT (load_library, "-l"); + break; +#ifdef INTERNET_DOMAIN_SOCKETS + case 'h': + GET_ARGUMENT (hostarg, "-h"); + break; + case 'p': + GET_ARGUMENT (portarg, "-p"); + port = atoi (portarg); + break; + case 'r': + GET_ARGUMENT (remotearg, "-r"); + strcpy (remotepath, remotearg); + rflg = 1; + break; +#endif /* INTERNET_DOMAIN_SOCKETS */ + default: + errflg = 1; + } + } /* for */ + } /* else */ + } /* for */ + + if (errflg) + { + fprintf (stderr, +#ifdef INTERNET_DOMAIN_SOCKETS + "usage: %s [-nw] [-display display] [-q] [-v] [-l library]\n" + " [-batch] [-f function] [-eval form]\n" + " [-h host] [-p port] [-r remote-path] [[+line] file] ...\n", +#else /* !INTERNET_DOMAIN_SOCKETS */ + "usage: %s [-nw] [-q] [-v] [-l library] [-f function] [-eval form] " + "[[+line] path] ...\n", +#endif /* !INTERNET_DOMAIN_SOCKETS */ + progname); + exit (1); + } + if (batch && argv[i]) + { + fprintf (stderr, "%s: Cannot specify `-batch' with file names\n", + progname); + exit (1); + } + if (suppress_windows_system && hostarg) + { + fprintf (stderr, "%s: Remote editing is available only on X\n", + progname); + exit (1); + } + + *result = '\0'; + if (eval_function || eval_form || load_library) + { +#if defined(INTERNET_DOMAIN_SOCKETS) + connect_type = make_connection (hostarg, port, &s); +#else + connect_type = make_connection (NULL, (u_short) 0, &s); +#endif + sprintf (command, "(gnuserv-eval%s '(progn ", quick ? "-quickly" : ""); + send_string (s, command); + if (load_library) + { + sprintf (command, " (load-library %s)", clean_string (load_library)); + send_string (s, command); + } + if (eval_form) + { + sprintf (command, " %s", eval_form); + send_string (s, command); + } + if (eval_function) + { + sprintf (command, " (%s)", eval_function); + send_string (s, command); + } + send_string (s, "))"); + send_string (s, EOT_STR); + if (read_line (s, result) == 0) + { + fprintf (stderr, "%s: Could not read\n", progname); + exit (1); + } + } /* eval_function || eval_form || load_library */ + else if (batch) + { + fprintf (stderr, "%s: `-batch' requires an evaluation\n", + progname); + exit (1); + } + + if (!batch) + { + if (suppress_windows_system) + { + tty = ttyname (0); + if (!tty) + { + fprintf (stderr, "%s: Not connected to a tty", progname); + exit (1); + } +#if defined(INTERNET_DOMAIN_SOCKETS) + connect_type = make_connection (hostarg, port, &s); +#else + connect_type = make_connection (NULL, (u_short) 0, &s); +#endif + send_string (s, "(gnuserv-eval '(emacs-pid))"); + send_string (s, EOT_STR); + + if (read_line (s, buffer) == 0) + { + fprintf (stderr, "%s: Could not establish Emacs procces id\n", + progname); + exit (1); + } + /* Don't do disconnect_from_server becasue we have already read + data, and disconnect doesn't do anything else. */ +#ifndef INTERNET_DOMAIN_SOCKETS + if (connect_type == (int) CONN_IPC) + disconnect_from_ipc_server (s, msgp, FALSE); +#endif /* !SYSV_IPC */ + + emacs_pid = (pid_t)atol(buffer); + initialize_signals(); + } /* suppress_windows_system */ + +#if defined(INTERNET_DOMAIN_SOCKETS) + connect_type = make_connection (hostarg, port, &s); +#else + connect_type = make_connection (NULL, (u_short) 0, &s); +#endif + +#ifdef INTERNET_DOMAIN_SOCKETS + if (connect_type == (int) CONN_INTERNET) + { + char *ptr; + gethostname (thishost, HOSTNAMSZ); + if (!rflg) + { /* attempt to generate a path + * to this machine */ + if ((ptr = getenv ("GNU_NODE")) != NULL) + /* user specified a path */ + strcpy (remotepath, ptr); + } +#if 0 /* This is really bogus... re-enable it if you must have it! */ +#if defined (hp9000s300) || defined (hp9000s800) + else if (strcmp (thishost,hostarg)) + { /* try /net/thishost */ + strcpy (remotepath, "/net/"); /* (this fails using internet + addresses) */ + strcat (remotepath, thishost); + } +#endif +#endif + } + else + { /* same machines, no need for path */ + remotepath[0] = '\0'; /* default is the empty path */ + } +#endif /* INTERNET_DOMAIN_SOCKETS */ + +#ifdef SYSV_IPC + if ((msgp = (struct msgbuf *) + malloc (sizeof *msgp + GSERV_BUFSZ)) == NULL) + { + fprintf (stderr, "%s: not enough memory for message buffer\n", progname); + exit (1); + } /* if */ + + msgp->mtext[0] = '\0'; /* ready for later strcats */ +#endif /* SYSV_IPC */ + + if (suppress_windows_system) + { + char *term = getenv ("TERM"); + if (!term) + { + fprintf (stderr, "%s: unknown terminal type\n", progname); + exit (1); + } + sprintf (command, "(gnuserv-edit-files '(tty %s %s %d) '(", + clean_string (tty), clean_string (term), (int)getpid ()); + } + else /* !suppress_windows_system */ + { + sprintf (command, "(gnuserv-edit-files '(x %s) '(", + clean_string (display)); + } /* !suppress_windows_system */ + send_string (s, command); + + if (!argv[i]) + nofiles = 1; + + for (; argv[i]; i++) + { + if (i < argc - 1 && *argv[i] == '+') + starting_line = atoi (argv[i++]); + else + starting_line = 1; + /* If the last argument is +something, treat it as a file. */ + if (i == argc) + { + starting_line = 1; + --i; + } + filename_expand (fullpath, argv[i]); +#ifdef INTERNET_DOMAIN_SOCKETS + path = malloc (strlen (remotepath) + strlen (fullpath) + 1); + sprintf (path, "%s%s", remotepath, fullpath); +#else + path = my_strdup (fullpath); +#endif + sprintf (command, "(%d . %s)", starting_line, clean_string (path)); + send_string (s, command); + free (path); + } /* for */ + + sprintf (command, ")%s%s", + (quick || (nofiles && !suppress_windows_system)) ? " 'quick" : "", + view ? " 'view" : ""); + send_string (s, command); + send_string (s, ")"); + +#ifdef SYSV_IPC + if (connect_type == (int) CONN_IPC) + disconnect_from_ipc_server (s, msgp, FALSE); +#else /* !SYSV_IPC */ + if (connect_type != (int) CONN_IPC) + disconnect_from_server (s, FALSE); +#endif /* !SYSV_IPC */ + } /* not batch */ + + if (batch && !quick) + printf ("%s\n", result); + + return 0; + +} /* main */ + +#endif /* SYSV_IPC || UNIX_DOMAIN_SOCKETS || INTERNET_DOMAIN_SOCKETS */ diff --git a/src/daemon/gnuserv.c b/src/daemon/gnuserv.c new file mode 100644 index 00000000..8665ce40 --- /dev/null +++ b/src/daemon/gnuserv.c @@ -0,0 +1,913 @@ +/* -*-C-*- + Server code for handling requests from clients and forwarding them + on to the GNU Emacs process. + + This file is part of GNU Emacs. + + Copying is permitted under those conditions described by the GNU + General Public License. + + Copyright (C) 1989 Free Software Foundation, Inc. + + Author: Andy Norman (ange@hplb.hpl.hp.com), based on 'etc/server.c' + from the 18.52 GNU Emacs distribution. + + Please mail bugs and suggestions to the author at the above address. +*/ + +/* HISTORY + * 11-Nov-1990 bristor@simba + * Added EOT stuff. + */ + +/* + * This file incorporates new features added by Bob Weiner , + * Darrell Kindred and Arup Mukherjee . + * Please see the note at the end of the README file for details. + * + * (If gnuserv came bundled with your emacs, the README file is probably + * ../etc/gnuserv.README relative to the directory containing this file) + */ + +#if 0 +static char rcsid [] = "!Header: gnuserv.c,v 2.1 95/02/16 11:58:27 arup alpha !"; +#endif + +#include "gnuserv.h" + +#ifdef USE_LITOUT +#ifdef linux +#include +#else +#include +#endif +#endif + +#ifdef AIX +#include +#endif + +#include +#include +#include +#include + +#ifdef HAVE_UNISTD_H +#include +#endif /* HAVE_UNISTD_H */ + +#ifdef HAVE_STRING_H +#include +#endif /* HAVE_STRING_H */ + +#if !defined(SYSV_IPC) && !defined(UNIX_DOMAIN_SOCKETS) && \ + !defined(INTERNET_DOMAIN_SOCKETS) +main () +{ + fprintf (stderr,"Sorry, the Emacs server is only supported on systems that have\n"); + fprintf (stderr,"Unix Domain sockets, Internet Domain sockets or System V IPC\n"); + exit (1); +} /* main */ +#else /* SYSV_IPC || UNIX_DOMAIN_SOCKETS || INTERNET_DOMAIN_SOCKETS */ + +#ifdef SYSV_IPC + +int ipc_qid = 0; /* ipc message queue id */ +int ipc_wpid = 0; /* watchdog task pid */ + + +/* + ipc_exit -- clean up the queue id and queue, then kill the watchdog task + if it exists. exit with the given status. +*/ +void +ipc_exit (int stat) +{ + msgctl (ipc_qid,IPC_RMID,0); + + if (ipc_wpid != 0) + kill (ipc_wpid, SIGKILL); + + exit (stat); +} /* ipc_exit */ + + +/* + ipc_handle_signal -- catch the signal given and clean up. +*/ +void +ipc_handle_signal(int sig) +{ + ipc_exit (0); +} /* ipc_handle_signal */ + + +/* + ipc_spawn_watchdog -- spawn a watchdog task to clean up the message queue should the + server process die. +*/ +void +ipc_spawn_watchdog (void) +{ + if ((ipc_wpid = fork ()) == 0) + { /* child process */ + int ppid = getppid (); /* parent's process id */ + + setpgrp(); /* gnu kills process group on exit */ + + while (1) + { + if (kill (ppid, 0) < 0) /* ppid is no longer valid, parent + may have died */ + { + ipc_exit (0); + } /* if */ + + sleep(10); /* have another go later */ + } /* while */ + } /* if */ + +} /* ipc_spawn_watchdog */ + + +/* + ipc_init -- initialize server, setting the global msqid that can be listened on. +*/ +void +ipc_init (struct msgbuf **msgpp) +{ + key_t key; /* messge key */ + char buf[GSERV_BUFSZ]; /* pathname for key */ + + sprintf (buf,"/tmp/gsrv%d",(int)geteuid ()); + creat (buf,0600); + key = ftok (buf,1); + + if ((ipc_qid = msgget (key,0600|IPC_CREAT)) == -1) + { + perror (progname); + fprintf (stderr, "%s: unable to create msg queue\n", progname); + ipc_exit (1); + } /* if */ + + ipc_spawn_watchdog (); + + signal (SIGTERM,ipc_handle_signal); + signal (SIGINT,ipc_handle_signal); + + if ((*msgpp = (struct msgbuf *) + malloc (sizeof **msgpp + GSERV_BUFSZ)) == NULL) + { + fprintf (stderr, + "%s: unable to allocate space for message buffer\n", progname); + ipc_exit(1); + } /* if */ +} /* ipc_init */ + + +/* + handle_ipc_request -- accept a request from a client, pass the request on + to the GNU Emacs process, then wait for its reply and + pass that on to the client. +*/ +void +handle_ipc_request (struct msgbuf *msgp) +{ + struct msqid_ds msg_st; /* message status */ + char buf[GSERV_BUFSZ]; + int len; /* length of message / read */ + int s, result_len; /* tag fields on the response from emacs */ + int offset = 0; + int total = 1; /* # bytes that will actually be sent off */ + + if ((len = msgrcv (ipc_qid, msgp, GSERV_BUFSZ - 1, 1, 0)) < 0) + { + perror (progname); + fprintf (stderr, "%s: unable to receive\n", progname); + ipc_exit (1); + } /* if */ + + msgctl (ipc_qid, IPC_STAT, &msg_st); + strncpy (buf, msgp->mtext, len); + buf[len] = '\0'; /* terminate */ + + printf ("%d %s", ipc_qid, buf); + fflush (stdout); + + /* now for the response from gnu */ + msgp->mtext[0] = '\0'; + +#if 0 + if ((len = read(0,buf,GSERV_BUFSZ-1)) < 0) + { + perror (progname); + fprintf (stderr, "%s: unable to read\n", progname); + ipc_exit (1); + } /* if */ + + sscanf (buf, "%d:%[^\n]\n", &junk, msgp->mtext); +#else + + /* read in "n/m:" (n=client fd, m=message length) */ + + while (offset < (GSERV_BUFSZ-1) && + ((len = read (0, buf + offset, 1)) > 0) && + buf[offset] != ':') + { + offset += len; + } + + if (len < 0) + { + perror (progname); + fprintf (stderr, "%s: unable to read\n", progname); + exit(1); + } + + /* parse the response from emacs, getting client fd & result length */ + buf[offset] = '\0'; + sscanf (buf, "%d/%d", &s, &result_len); + + while (result_len > 0) + { + if ((len = read(0, buf, min2 (result_len, GSERV_BUFSZ - 1))) < 0) + { + perror (progname); + fprintf (stderr, "%s: unable to read\n", progname); + exit (1); + } + + /* Send this string off, but only if we have enough space */ + + if (GSERV_BUFSZ > total) + { + if (total + len <= GSERV_BUFSZ) + buf[len] = 0; + else + buf[GSERV_BUFSZ - total] = 0; + + send_string(s,buf); + total += strlen(buf); + } + + result_len -= len; + } + + /* eat the newline */ + while ((len = read (0,buf,1)) == 0) + ; + if (len < 0) + { + perror(progname); + fprintf (stderr,"%s: unable to read\n", progname); + exit (1); + } + if (buf[0] != '\n') + { + fprintf (stderr,"%s: garbage after result [%c]\n", progname, buf[0]); + exit (1); + } +#endif + + /* Send a response back to the client. */ + + msgp->mtype = msg_st.msg_lspid; + if (msgsnd (ipc_qid,msgp,strlen(msgp->mtext)+1,0) < 0) + perror ("msgsend(gnuserv)"); + +} /* handle_ipc_request */ +#endif /* SYSV_IPC */ + + +#if defined(INTERNET_DOMAIN_SOCKETS) || defined(UNIX_DOMAIN_SOCKETS) +/* + echo_request -- read request from a given socket descriptor, and send the information + to stdout (the gnu process). +*/ +static void +echo_request (int s) +{ + char buf[GSERV_BUFSZ]; + int len; + + printf("%d ",s); + + /* read until we get a newline or no characters */ + while ((len = recv(s,buf,GSERV_BUFSZ-1,0)) > 0) { + buf[len] = '\0'; + printf("%s",buf); + + if (buf[len-1] == EOT_CHR) { + fflush(stdout); + break; /* end of message */ + } + + } /* while */ + + if (len < 0) { + perror(progname); + fprintf(stderr,"%s: unable to recv\n",progname); + exit(1); + } /* if */ + +} /* echo_request */ + + +/* + handle_response -- accept a response from stdin (the gnu process) and pass the + information on to the relevant client. +*/ +static void +handle_response (void) +{ + char buf[GSERV_BUFSZ+1]; + int offset=0; + int s; + int len; + int result_len; + + /* read in "n/m:" (n=client fd, m=message length) */ + while (offset < GSERV_BUFSZ && + ((len = read(0,buf+offset,1)) > 0) && + buf[offset] != ':') { + offset += len; + } + + if (len < 0) { + perror(progname); + fprintf(stderr,"%s: unable to read\n",progname); + exit(1); + } + + /* parse the response from emacs, getting client fd & result length */ + buf[offset] = '\0'; + sscanf(buf,"%d/%d", &s, &result_len); + + while (result_len > 0) { + if ((len = read(0,buf,min2(result_len,GSERV_BUFSZ))) < 0) { + perror(progname); + fprintf(stderr,"%s: unable to read\n",progname); + exit(1); + } + buf[len] = '\0'; + send_string(s,buf); + result_len -= len; + } + + /* eat the newline */ + while ((len = read(0,buf,1)) == 0) + ; + if (len < 0) + { + perror(progname); + fprintf(stderr,"%s: unable to read\n",progname); + exit(1); + } + if (buf[0] != '\n') + { + fprintf(stderr,"%s: garbage after result\n",progname); + exit(1); + } + /* send the newline */ + buf[1] = '\0'; + send_string(s,buf); + close(s); + +} /* handle_response */ +#endif /* INTERNET_DOMAIN_SOCKETS || UNIX_DOMAIN_SOCKETS */ + + +#ifdef INTERNET_DOMAIN_SOCKETS +struct entry { + u_long host_addr; + struct entry *next; +}; + +struct entry *permitted_hosts[TABLE_SIZE]; + +#ifdef AUTH_MAGIC_COOKIE +# include +# include + +static Xauth *server_xauth = NULL; +#endif + +static int +timed_read (int fd, char *buf, int max, int timeout, int one_line) +{ + fd_set rmask; + struct timeval tv; /* = {timeout, 0}; */ + char c = 0; + int nbytes = 0; + int r; + + tv.tv_sec = timeout; + tv.tv_usec = 0; + + FD_ZERO(&rmask); + FD_SET(fd, &rmask); + + do + { + r = select(fd + 1, &rmask, NULL, NULL, &tv); + + if (r > 0) + { + if (read (fd, &c, 1) == 1 ) + { + *buf++ = c; + ++nbytes; + } + else + { + printf ("read error on socket\004\n"); + return -1; + } + } + else if (r == 0) + { + printf ("read timed out\004\n"); + return -1; + } + else + { + printf ("error in select\004\n"); + return -1; + } + } while ((nbytes < max) && !(one_line && (c == '\n'))); + + --buf; + if (one_line && *buf == '\n') + { + *buf = 0; + } + + return nbytes; +} + + + +/* + permitted -- return whether a given host is allowed to connect to the server. +*/ +static int +permitted (u_long host_addr, int fd) +{ + int key; + struct entry *entry; + + char auth_protocol[128]; + char buf[1024]; + int auth_data_len; + + if (fd > 0) + { + /* we are checking permission on a real connection */ + + /* Read auth protocol name */ + + if (timed_read(fd, auth_protocol, AUTH_NAMESZ, AUTH_TIMEOUT, 1) <= 0) + return FALSE; + + if (strcmp (auth_protocol, DEFAUTH_NAME) && + strcmp (auth_protocol, MCOOKIE_NAME)) + { + printf ("authentication protocol (%s) from client is invalid...\n", + auth_protocol); + printf ("... Was the client an old version of gnuclient/gnudoit?\004\n"); + + return FALSE; + } + + if (!strcmp(auth_protocol, MCOOKIE_NAME)) + { + + /* + * doing magic cookie auth + */ + + if (timed_read(fd, buf, 10, AUTH_TIMEOUT, 1) <= 0) + return FALSE; + + auth_data_len = atoi(buf); + + if (timed_read(fd, buf, auth_data_len, AUTH_TIMEOUT, 0) != auth_data_len) + return FALSE; + +#ifdef AUTH_MAGIC_COOKIE + if (server_xauth && server_xauth->data && + !memcmp(buf, server_xauth->data, auth_data_len)) + { + return TRUE; + } +#else + printf ("client tried Xauth, but server is not compiled with Xauth\n"); +#endif + + /* + * auth failed, but allow this to fall through to the GNU_SECURE + * protocol.... + */ + + printf ("Xauth authentication failed, trying GNU_SECURE auth...\004\n"); + + } + + /* Other auth protocols go here, and should execute only if the + * auth_protocol name matches. + */ + + } + + + /* Now, try the old GNU_SECURE stuff... */ + + /* First find the hash key */ + key = HASH(host_addr) % TABLE_SIZE; + + /* Now check the chain for that hash key */ + for(entry=permitted_hosts[key]; entry != NULL; entry=entry->next) + if (host_addr == entry->host_addr) + return(TRUE); + + return(FALSE); + +} /* permitted */ + + +/* + add_host -- add the given host to the list of permitted hosts, provided it isn't + already there. +*/ +static void +add_host (u_long host_addr) +{ + int key; + struct entry *new_entry; + + if (!permitted(host_addr, -1)) + { + if ((new_entry = (struct entry *) malloc(sizeof(struct entry))) == NULL) { + fprintf(stderr,"%s: unable to malloc space for permitted host entry\n", + progname); + exit(1); + } /* if */ + + new_entry->host_addr = host_addr; + key = HASH(host_addr) % TABLE_SIZE; + new_entry->next = permitted_hosts[key]; + permitted_hosts[key] = new_entry; + } /* if */ + +} /* add_host */ + + +/* + setup_table -- initialise the table of hosts allowed to contact the server, + by reading from the file specified by the GNU_SECURE + environment variable + Put in the local machine, and, if a security file is specifed, + add each host that is named in the file. + Return the number of hosts added. +*/ +static int +setup_table (void) +{ + FILE *host_file; + char *file_name; + char hostname[HOSTNAMSZ]; + u_int host_addr; + int i, hosts=0; + + /* Make sure every entry is null */ + for (i=0; is_port; + + /* Create the listen socket. */ + if ((ls = socket (AF_INET,SOCK_STREAM, 0)) == -1) + { + perror(progname); + fprintf(stderr,"%s: unable to create socket\n",progname); + exit(1); + } /* if */ + + /* Bind the listen address to the socket. */ + if (bind(ls,(struct sockaddr *) &server,sizeof(struct sockaddr_in)) == -1) + { + perror(progname); + fprintf(stderr,"%s: unable to bind socket\n",progname); + exit(1); + } /* if */ + + /* Initiate the listen on the socket so remote users + * can connect. + */ + if (listen(ls,20) == -1) + { + perror(progname); + fprintf(stderr,"%s: unable to listen\n",progname); + exit(1); + } /* if */ + + return(ls); + +} /* internet_init */ + + +/* + handle_internet_request -- accept a request from a client and send the information + to stdout (the gnu process). +*/ +static void +handle_internet_request (int ls) +{ + int s; + size_t addrlen = sizeof(struct sockaddr_in); + struct sockaddr_in peer; /* for peer socket address */ + + memset((char *)&peer,0,sizeof(struct sockaddr_in)); + + if ((s = accept(ls,(struct sockaddr *)&peer, (void *) &addrlen)) == -1) + { + perror(progname); + fprintf(stderr,"%s: unable to accept\n",progname); + exit(1); + } /* if */ + + /* Check that access is allowed - if not return crud to the client */ + if (!permitted(peer.sin_addr.s_addr, s)) + { + send_string(s,"gnudoit: Connection refused\ngnudoit: unable to connect to remote"); + close(s); + + printf("Refused connection from %s\004\n", inet_ntoa(peer.sin_addr)); + return; + } /* if */ + + echo_request(s); + +} /* handle_internet_request */ +#endif /* INTERNET_DOMAIN_SOCKETS */ + + +#ifdef UNIX_DOMAIN_SOCKETS +/* + unix_init -- initialize server, returning an unix-domain socket that can + be listened on. +*/ +static int +unix_init (void) +{ + int ls; /* socket descriptor */ + struct sockaddr_un server; /* unix socket address */ + int bindlen; + + if ((ls = socket(AF_UNIX,SOCK_STREAM, 0)) < 0) + { + perror(progname); + fprintf(stderr,"%s: unable to create socket\n",progname); + exit(1); + } /* if */ + + /* Set up address structure for the listen socket. */ +#ifdef HIDE_UNIX_SOCKET + sprintf(server.sun_path,"/tmp/gsrvdir%d",(int)geteuid()); + if (mkdir(server.sun_path, 0700) < 0) + { + /* assume it already exists, and try to set perms */ + if (chmod(server.sun_path, 0700) < 0) + { + perror(progname); + fprintf(stderr,"%s: can't set permissions on %s\n", + progname, server.sun_path); + exit(1); + } + } + strcat(server.sun_path,"/gsrv"); + unlink(server.sun_path); /* remove old file if it exists */ +#else /* HIDE_UNIX_SOCKET */ + sprintf(server.sun_path,"/tmp/gsrv%d",(int)geteuid()); + unlink(server.sun_path); /* remove old file if it exists */ +#endif /* HIDE_UNIX_SOCKET */ + + server.sun_family = AF_UNIX; +#ifdef HAVE_SOCKADDR_SUN_LEN + /* See W. R. Stevens "Advanced Programming in the Unix Environment" + p. 502 */ + bindlen = (sizeof (server.sun_len) + sizeof (server.sun_family) + + strlen (server.sun_path) + 1); + server.sun_len = bindlen; +#else + bindlen = strlen (server.sun_path) + sizeof (server.sun_family); +#endif + + if (bind(ls,(struct sockaddr *)&server,bindlen) < 0) + { + perror(progname); + fprintf(stderr,"%s: unable to bind socket\n",progname); + exit(1); + } /* if */ + + chmod(server.sun_path,0700); /* only this user can send commands */ + + if (listen(ls,20) < 0) { + perror(progname); + fprintf(stderr,"%s: unable to listen\n",progname); + exit(1); + } /* if */ + + /* #### there are also better ways of dealing with this when + sigvec() is present. */ +#if defined (HAVE_SIGPROCMASK) + { + sigset_t _mask; + sigemptyset (&_mask); + sigaddset (&_mask, SIGPIPE); + sigprocmask (SIG_BLOCK, &_mask, NULL); + } +#else + signal(SIGPIPE,SIG_IGN); /* in case user kills client */ +#endif + + return(ls); + +} /* unix_init */ + + +/* + handle_unix_request -- accept a request from a client and send the information + to stdout (the gnu process). +*/ +static void +handle_unix_request (int ls) +{ + int s; + size_t len = sizeof(struct sockaddr_un); + struct sockaddr_un server; /* for unix socket address */ + + server.sun_family = AF_UNIX; + + if ((s = accept(ls,(struct sockaddr *)&server, (void *)&len)) < 0) + { + perror(progname); + fprintf(stderr,"%s: unable to accept\n",progname); + } /* if */ + + echo_request(s); + +} /* handle_unix_request */ +#endif /* UNIX_DOMAIN_SOCKETS */ + + +int +main(argc,argv) + int argc; + char *argv[]; +{ + int chan; /* temporary channel number */ +#ifdef INTERNET_DOMAIN_SOCKETS + int ils = -1; /* internet domain listen socket */ +#endif +#ifdef UNIX_DOMAIN_SOCKETS + int uls = -1; /* unix domain listen socket */ +#endif +#ifdef SYSV_IPC + struct msgbuf *msgp; /* message buffer */ +#endif /* SYSV_IPC */ + + progname = argv[0]; + + for(chan=3; chan < _NFILE; close(chan++)) /* close unwanted channels */ + ; + +#ifdef USE_LITOUT + { + /* this is to allow ^D to pass to emacs */ + int d = LLITOUT; + (void) ioctl(fileno(stdout), TIOCLBIS, &d); + } +#endif + +#ifdef SYSV_IPC + ipc_init(&msgp); /* get a msqid to listen on, and a message buffer */ +#endif /* SYSV_IPC */ + +#ifdef INTERNET_DOMAIN_SOCKETS + ils = internet_init(); /* get a internet domain socket to listen on */ +#endif /* INTERNET_DOMAIN_SOCKETS */ + +#ifdef UNIX_DOMAIN_SOCKETS + uls = unix_init(); /* get a unix domain socket to listen on */ +#endif /* UNIX_DOMAIN_SOCKETS */ + + while (1) { +#ifdef SYSV_IPC + handle_ipc_request(msgp); +#else /* NOT SYSV_IPC */ + fd_set rmask; + FD_ZERO(&rmask); + FD_SET(fileno(stdin), &rmask); + if (uls >= 0) + FD_SET(uls, &rmask); + if (ils >= 0) + FD_SET(ils, &rmask); + + if (select(max2(fileno(stdin),max2(uls,ils)) + 1, &rmask, + (fd_set *)NULL, (fd_set *)NULL, (struct timeval *)NULL) < 0) + { + perror(progname); + fprintf(stderr,"%s: unable to select\n",progname); + exit(1); + } /* if */ + +#ifdef UNIX_DOMAIN_SOCKETS + if (uls > 0 && FD_ISSET(uls, &rmask)) + handle_unix_request(uls); +#endif + +#ifdef INTERNET_DOMAIN_SOCKETS + if (ils > 0 && FD_ISSET(ils, &rmask)) + handle_internet_request(ils); +#endif /* INTERNET_DOMAIN_SOCKETS */ + + if (FD_ISSET(fileno(stdin), &rmask)) /* from stdin (gnu process) */ + handle_response(); +#endif /* NOT SYSV_IPC */ + } /* while */ + + return 0; +} /* main */ + +#endif /* SYSV_IPC || UNIX_DOMAIN_SOCKETS || INTERNET_DOMAIN_SOCKETS */ diff --git a/src/daemon/gnuserv.h b/src/daemon/gnuserv.h new file mode 100644 index 00000000..31fab4d0 --- /dev/null +++ b/src/daemon/gnuserv.h @@ -0,0 +1,220 @@ +/* -*-C-*- + + Header file for the GNU Emacs server and client C code. + + This file is part of GNU Emacs. + + Copying is permitted under those conditions described by the GNU + General Public License. + + Copyright (C) 1989 Free Software Foundation, Inc. + + Author: Andy Norman (ange@hplb.hpl.hp.com), based on + 'etc/server.c' and 'etc/emacsclient.c' from the 18.52 GNU + Emacs distribution. + + Please mail bugs and suggestions to the author at the above address. +*/ + +/* HISTORY + * 11-Nov-1990 bristor@simba + * Added EOT stuff. + */ + +/* + * This file incorporates new features added by Bob Weiner , + * Darrell Kindred and Arup Mukherjee . + * Please see the note at the end of the README file for details. + * + * (If gnuserv came bundled with your emacs, the README file is probably + * ../etc/gnuserv.README relative to the directory containing this file) + */ + +#if 0 +static char header_rcsid [] = "!Header: gnuserv.h,v 2.4 95/02/16 11:58:11 arup alpha !"; +#endif + +#define NO_SHORTNAMES + +#define PATCHLEVEL 2 + +#define NO_SHORTNAMES +/* gnuserv should not be compiled using SOCKS */ +#define DO_NOT_SOCKSIFY +#include <../src/config.h> +#undef read +#undef write +#undef open +#undef close +#undef signal + +/* Define the communication method between server and clients: + * You can have either or both kinds of sockets, but you can't mix + * sockets with sysv ipc + */ + + +#define INTERNET_DOMAIN_SOCKETS +#define UNIX_DOMAIN_SOCKETS +/* #define SYSV_IPC */ + +/* + * Define additional authentication protocols to be used. These methods will + * be tried before falling back to the default gnuserv protocol (based on + * the GNU_SECURE environment variable). Currently, only MIT-MAGIC-COOKIE-1 + * is also supported. + * + * Comment out the next line(s) if you don't want to enable the + * appropriate authentication protocol. + */ + +#if defined (HAVE_XAUTH) +#define AUTH_MAGIC_COOKIE +#endif /* HAVE_XAUTH */ + +/* + * stuff related to supporting MIT-MAGIC-COOKIE-1 + */ + +#define MCOOKIE_SCREEN "999" /* screen # to use as the gnuserv cookie */ +#define MCOOKIE_NAME "MAGIC-1" /* authentication protocol name */ +#define MCOOKIE_X_NAME "MIT-MAGIC-COOKIE-1" /* as needed by X */ + + +#define DEFAUTH_NAME "GNU-SECURE" /* name of default auth protocol */ +#define AUTH_TIMEOUT 15 /* # seconds to wait for auth data */ +#define AUTH_NAMESZ 15 /* max allows auth protocol name size */ + + +/* + * Pick a default communication scheme, if none was specified. + */ + +#if !defined(SYSV_IPC) && !defined(UNIX_DOMAIN_SOCKETS) && !defined(INTERNET_DOMAIN_SOCKETS) + +#ifdef HAVE_SYSVIPC +#define SYSV_IPC /* SYSV systems use SYSV IPC by default */ +#endif /* HAVE_SYSVIPC */ + +#ifdef BSD +#define UNIX_DOMAIN_SOCKETS /* BSD systems use Unix Domain sockets by default */ +#endif /* BSD */ + +#endif /* No communication method pre-defined */ + +#include +#include +#include +#include +#include +#include +#include +#include + +#ifdef HAVE_UNISTD_H +#include +#endif + +#ifdef HAVE_SYS_TIME_H +#include +#endif + +/* + * If you are using SYSV_IPC, you might want to make the buffer size bigger + * since it limits the size of requests and responses. Don't make it bigger + * than your system's max message size though (usually a couple of k) or else + * msgsend will start failing. For sockets, using the system BUFSIZ is usually + * what you want. + */ + +# define GSERV_BUFSZ BUFSIZ + + +#ifdef SYSV_IPC +#include +#include + +#define send_string(s,str) \ + if (strlen(msgp->mtext) + strlen(str) < GSERV_BUFSZ) \ + strcat(msgp->mtext,str); \ + else \ + { \ + fprintf(stderr,"%s: not enough message buffer space\n",progname); \ + exit(1); \ + } \ + +#endif /* SYSV_IPC */ + +#if defined(INTERNET_DOMAIN_SOCKETS) || defined(UNIX_DOMAIN_SOCKETS) +#include +#endif /* INTERNET_DOMAIN_SOCKETS || UNIX_DOMAIN_SOCKETS */ + +#ifdef INTERNET_DOMAIN_SOCKETS +#include +#include +#include +#define TABLE_SIZE 101 /* The number of entries in the hash table */ +#define HASH(host) host /* Rather simplistic hash function */ +#define DEFAULT_PORT 21490 /* default port number to use is + * DEFAULT_PORT + uid */ +#endif /* INTERNET_DOMAIN_SOCKETS */ + +#ifdef UNIX_DOMAIN_SOCKETS +#include +#define HIDE_UNIX_SOCKET /* put the unix socket in a protected dir */ +#endif /* UNIX_DOMAIN_SOCKETS */ + +/* On some platforms, we need to do the equivalent of "stty litout" to get + * characters like ^D to pass through to emacs. This problem has only + * been observed under emacs18; fsf19 and lemacs are probably okay without it. + */ +#ifndef DONT_USE_LITOUT +#if !defined(HAVE_TERMIO) && !defined(HAVE_TERMIOS) && !defined(VMS) +#if !defined(MSDOS) && !defined(BSD4_1) +#define USE_LITOUT +#endif +#endif +#endif + + +#define HOSTNAMSZ 255 /* max size of a hostname */ +#define REPLYSIZ 300 /* max size of reply from server to client */ +#undef FALSE +#define FALSE 0 +#undef TRUE +#define TRUE 1 + +extern char *optarg; +extern int optind; +extern char *progname; + +/* The casts shut Sun's compiler up and are safe in the context these + are actually used. */ +#define max2(x,y) (((int) (x) > (int) (y)) ? (x) : (y)) +#define min2(x,y) (((int) (x) < (int) (y)) ? (x) : (y)) + +#ifndef _NFILE /* rough guess at maximum number of open files */ +#define _NFILE 20 +#endif + +#define EOT_STR "\004" +#define EOT_CHR '\004' + +/* connection types */ +#define CONN_UNIX 0 +#define CONN_INTERNET 1 +#define CONN_IPC 2 + +/* function declarations */ +int make_connection (char *hostarg, int portarg, int *s); +#ifdef SYSV_IPC +void disconnect_from_ipc_server(); +#endif +#if defined(INTERNET_DOMAIN_SOCKETS) || defined(UNIX_DOMAIN_SOCKETS) +void send_string (int s, CONST char *msg); +void disconnect_from_server (int s, int echo); +int read_line (int s, char *dest); +#endif +#ifdef INTERNET_DOMAIN_SOCKETS +int internet_addr (char *host); +#endif