#include "gnuserv.h"
char gnuserv_version[] = "gnuserv version" GNUSERV_VERSION;
#ifdef USE_LITOUT
#ifdef linux
#include <bsd/sgtty.h>
#else
#include <sgtty.h>
#endif
#endif
#ifdef AIX
#include <sys/select.h>
#endif
#include <stdlib.h>
#include <stdio.h>
#include <sys/types.h>
#include <sys/stat.h>
#ifdef HAVE_UNISTD_H
#include <unistd.h>
#endif
#ifdef HAVE_STRING_H
#include <string.h>
#endif
#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);
}
#else
#ifdef SYSV_IPC
int ipc_qid = 0;
pid_t ipc_wpid = 0;
void
ipc_exit (int stat)
{
msgctl (ipc_qid,IPC_RMID,0);
if (ipc_wpid != 0)
kill (ipc_wpid, SIGKILL);
exit (stat);
}
void
ipc_handle_signal(int sig)
{
ipc_exit (0);
}
void
ipc_spawn_watchdog (void)
{
if ((ipc_wpid = fork ()) == 0)
{
pid_t ppid = getppid ();
setpgrp();
while (1)
{
if (kill (ppid, 0) < 0)
{
ipc_exit (0);
}
sleep(10);
}
}
}
void
ipc_init (struct msgbuf **msgpp)
{
key_t key;
char buf[GSERV_BUFSZ];
sprintf (buf,"%s/gsrv%d",tmpdir,(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);
}
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);
}
}
void
handle_ipc_request (struct msgbuf *msgp)
{
struct msqid_ds msg_st;
char buf[GSERV_BUFSZ];
int len;
int s, result_len;
int offset = 0;
int total = 1;
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);
}
msgctl (ipc_qid, IPC_STAT, &msg_st);
strncpy (buf, msgp->mtext, len);
buf[len] = '\0';
printf ("%d %s", ipc_qid, buf);
fflush (stdout);
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);
}
sscanf (buf, "%d:%[^\n]\n", &junk, msgp->mtext);
#else
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);
}
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);
}
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;
}
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
msgp->mtype = msg_st.msg_lspid;
if (msgsnd (ipc_qid,msgp,strlen(msgp->mtext)+1,0) < 0)
perror ("msgsend(gnuserv)");
}
#endif
#if defined(INTERNET_DOMAIN_SOCKETS) || defined(UNIX_DOMAIN_SOCKETS)
static void
echo_request (int s)
{
char buf[GSERV_BUFSZ];
int len;
printf("%d ",s);
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;
}
}
if (len < 0) {
perror(progname);
fprintf(stderr,"%s: unable to recv\n",progname);
exit(1);
}
}
static void
handle_response (void)
{
char buf[GSERV_BUFSZ+1];
int offset=0;
int s;
int len = 0;
int result_len;
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);
}
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;
}
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);
}
buf[1] = '\0';
send_string(s,buf);
close(s);
}
#endif
#ifdef INTERNET_DOMAIN_SOCKETS
struct entry {
u_long host_addr;
struct entry *next;
};
struct entry *permitted_hosts[TABLE_SIZE];
#ifdef AUTH_MAGIC_COOKIE
# include <X11/X.h>
# include <X11/Xauth.h>
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;
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;
}
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;
int auth_data_pos;
int auth_mismatches;
if (fd > 0)
{
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))
{
if (timed_read(fd, buf, 10, AUTH_TIMEOUT, 1) <= 0)
return FALSE;
auth_data_len = atoi(buf);
if (auth_data_len <= 0 || auth_data_len > sizeof(buf))
{
return FALSE;
}
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)
{
auth_mismatches =
( auth_data_len ^
server_xauth->data_length );
for(auth_data_pos=0; auth_data_pos < auth_data_len; ++auth_data_pos)
auth_mismatches |=
( buf[auth_data_pos] ^
server_xauth->data[auth_data_pos % server_xauth->data_length]);
if (auth_mismatches == 0)
return TRUE;
for(;rand() % 1000;);
}
#else
printf ("client tried Xauth, but server is not compiled with Xauth\n");
#endif
printf ("Xauth authentication failed, trying GNU_SECURE auth...\004\n");
}
}
key = HASH(host_addr) % TABLE_SIZE;
for(entry=permitted_hosts[key]; entry != NULL; entry=entry->next)
if (host_addr == entry->host_addr)
return(TRUE);
return(FALSE);
}
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);
}
new_entry->host_addr = host_addr;
key = HASH(host_addr) % TABLE_SIZE;
new_entry->next = permitted_hosts[key];
permitted_hosts[key] = new_entry;
}
}
static int
setup_table (void)
{
FILE *host_file;
char *file_name;
char hostname[HOSTNAMSZ];
u_int host_addr;
int i, hosts=0;
for (i=0; i<TABLE_SIZE; i++)
permitted_hosts[i] = NULL;
gethostname(hostname,HOSTNAMSZ);
if ((host_addr = internet_addr(hostname)) == -1)
{
fprintf(stderr,"%s: unable to find %s in /etc/hosts or from YP",
progname,hostname);
exit(1);
}
#ifdef AUTH_MAGIC_COOKIE
server_xauth = XauGetAuthByAddr (FamilyInternet,
sizeof(host_addr), (char *)&host_addr,
strlen(MCOOKIE_SCREEN), MCOOKIE_SCREEN,
strlen(MCOOKIE_X_NAME), MCOOKIE_X_NAME);
hosts++;
#endif
#if 0
add_host(host_addr);
#endif
if (((file_name = getenv("GNU_SECURE")) != NULL &&
(host_file = fopen(file_name,"r")) != NULL))
{
while ((fscanf(host_file,"%s",hostname) != EOF))
if ((host_addr = internet_addr(hostname)) != -1)
{
add_host(host_addr);
hosts++;
}
fclose(host_file);
}
return hosts;
}
static int
internet_init (void)
{
int ls;
struct servent *sp;
struct sockaddr_in server;
char *ptr;
if (setup_table() == 0)
return -1;
memset (&server, '\0', sizeof (server));
server.sin_family = AF_INET;
server.sin_addr.s_addr = INADDR_ANY;
if ((ptr=getenv("GNU_PORT")) != NULL)
server.sin_port = htons(atoi(ptr));
else if ((sp = getservbyname ("gnuserv", "tcp")) == NULL)
server.sin_port = htons(DEFAULT_PORT+getuid());
else
server.sin_port = sp->s_port;
if ((ls = socket (AF_INET,SOCK_STREAM, 0)) == -1)
{
perror(progname);
fprintf(stderr,"%s: unable to create socket\n",progname);
exit(1);
}
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 (listen(ls,20) == -1)
{
perror(progname);
fprintf(stderr,"%s: unable to listen\n",progname);
exit(1);
}
return(ls);
}
static void
handle_internet_request (int ls)
{
int s;
socklen_t addrlen = sizeof (struct sockaddr_in);
struct sockaddr_in peer;
memset (&peer, '\0', sizeof (peer));
if ((s = accept(ls,(struct sockaddr *)&peer, &addrlen)) == -1)
{
perror(progname);
fprintf(stderr,"%s: unable to accept\n",progname);
exit(1);
}
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;
}
echo_request(s);
}
#endif
#ifdef UNIX_DOMAIN_SOCKETS
static int
unix_init (void)
{
int ls;
struct sockaddr_un server;
socklen_t bindlen;
if ((ls = socket(AF_UNIX,SOCK_STREAM, 0)) < 0)
{
perror(progname);
fprintf(stderr,"%s: unable to create socket\n",progname);
exit(1);
}
#ifdef HIDE_UNIX_SOCKET
sprintf(server.sun_path,"%s/gsrvdir%d",tmpdir,(int)geteuid());
if (mkdir(server.sun_path, 0700) < 0)
{
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);
#else
sprintf(server.sun_path,"%s/gsrv%d",tmpdir,(int)geteuid());
unlink(server.sun_path);
#endif
server.sun_family = AF_UNIX;
#ifdef HAVE_SOCKADDR_SUN_LEN
bindlen = (sizeof (server.sun_len) + sizeof (server.sun_family)
+ strlen (server.sun_path) + 1);
server.sun_len = bindlen;
#else
bindlen = sizeof(server);
#endif
if (bind(ls,(struct sockaddr *)&server,bindlen) < 0)
{
perror(progname);
fprintf(stderr,"%s: unable to bind socket\n",progname);
exit(1);
}
chmod(server.sun_path,0700);
if (listen(ls,20) < 0) {
perror(progname);
fprintf(stderr,"%s: unable to listen\n",progname);
exit(1);
}
#if defined (HAVE_SIGPROCMASK)
{
sigset_t _mask;
sigemptyset (&_mask);
sigaddset (&_mask, SIGPIPE);
sigprocmask (SIG_BLOCK, &_mask, NULL);
}
#else
signal(SIGPIPE,SIG_IGN);
#endif
return(ls);
}
static void
handle_unix_request (int ls)
{
int s;
socklen_t len = sizeof (struct sockaddr_un);
struct sockaddr_un server;
server.sun_family = AF_UNIX;
if ((s = accept(ls,(struct sockaddr *)&server, &len)) < 0)
{
perror(progname);
fprintf(stderr,"%s: unable to accept\n",progname);
}
echo_request(s);
}
#endif
int
main (int argc, char *argv[])
{
int chan;
#ifdef SYSV_IPC
struct msgbuf *msgp;
#else
int ils = -1;
int uls = -1;
#endif
progname = argv[0];
for(chan=3; chan < _NFILE; close(chan++))
;
#ifdef USE_TMPDIR
tmpdir = getenv("TMPDIR");
#endif
if (!tmpdir)
tmpdir = "/tmp";
#ifdef USE_LITOUT
{
int d = LLITOUT;
(void) ioctl(fileno(stdout), TIOCLBIS, &d);
}
#endif
#ifdef SYSV_IPC
ipc_init(&msgp);
#endif
#ifdef INTERNET_DOMAIN_SOCKETS
ils = internet_init();
#endif
#ifdef UNIX_DOMAIN_SOCKETS
uls = unix_init();
#endif
while (1) {
#ifdef SYSV_IPC
handle_ipc_request(msgp);
#else
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);
return 1;
}
#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
if (FD_ISSET(fileno(stdin), &rmask))
handle_response();
#endif
}
}
#endif