Home | History | Annotate | Line # | Download | only in libwrap
rfc931.c revision 1.5 
      1 /*	$NetBSD: rfc931.c,v 1.5 1999/07/03 12:30:41 simonb Exp $	*/
      2 
      3  /*
      4   * rfc931() speaks a common subset of the RFC 931, AUTH, TAP, IDENT and RFC
      5   * 1413 protocols. It queries an RFC 931 etc. compatible daemon on a remote
      6   * host to look up the owner of a connection. The information should not be
      7   * used for authentication purposes. This routine intercepts alarm signals.
      8   *
      9   * Diagnostics are reported through syslog(3).
     10   *
     11   * Author: Wietse Venema, Eindhoven University of Technology, The Netherlands.
     12   */
     13 
     14 #include <sys/cdefs.h>
     15 #ifndef lint
     16 #if 0
     17 static char sccsid[] = "@(#) rfc931.c 1.10 95/01/02 16:11:34";
     18 #else
     19 __RCSID("$NetBSD: rfc931.c,v 1.5 1999/07/03 12:30:41 simonb Exp $");
     20 #endif
     21 #endif
     22 
     23 /* System libraries. */
     24 
     25 #include <stdio.h>
     26 #include <syslog.h>
     27 #include <sys/types.h>
     28 #include <sys/socket.h>
     29 #include <netinet/in.h>
     30 #include <stdlib.h>
     31 #include <unistd.h>
     32 #include <setjmp.h>
     33 #include <signal.h>
     34 #include <string.h>
     35 
     36 /* Local stuff. */
     37 
     38 #include "tcpd.h"
     39 
     40 #define	RFC931_PORT	113		/* Semi-well-known port */
     41 #define	ANY_PORT	0		/* Any old port will do */
     42 
     43 int     rfc931_timeout = RFC931_TIMEOUT;/* Global so it can be changed */
     44 
     45 static jmp_buf timebuf;
     46 
     47 static FILE *fsocket __P((int, int, int));
     48 static void timeout __P((int));
     49 
     50 /* fsocket - open stdio stream on top of socket */
     51 
     52 static FILE *fsocket(domain, type, protocol)
     53 int     domain;
     54 int     type;
     55 int     protocol;
     56 {
     57     int     s;
     58     FILE   *fp;
     59 
     60     if ((s = socket(domain, type, protocol)) < 0) {
     61 	tcpd_warn("socket: %m");
     62 	return (0);
     63     } else {
     64 	if ((fp = fdopen(s, "r+")) == 0) {
     65 	    tcpd_warn("fdopen: %m");
     66 	    close(s);
     67 	}
     68 	return (fp);
     69     }
     70 }
     71 
     72 /* timeout - handle timeouts */
     73 
     74 static void timeout(sig)
     75 int     sig;
     76 {
     77     longjmp(timebuf, sig);
     78 }
     79 
     80 /* rfc931 - return remote user name, given socket structures */
     81 
     82 void    rfc931(rmt_sin, our_sin, dest)
     83 struct sockaddr_in *rmt_sin;
     84 struct sockaddr_in *our_sin;
     85 char   *dest;
     86 {
     87     unsigned rmt_port;
     88     unsigned our_port;
     89     struct sockaddr_in rmt_query_sin;
     90     struct sockaddr_in our_query_sin;
     91     char    user[256];			/* XXX */
     92     char    buffer[512];		/* XXX */
     93     char   *cp;
     94     char   *result = unknown;
     95     FILE   *fp;
     96 
     97 #ifdef __GNUC__
     98     (void)&result; /* Avoid longjmp clobbering */
     99     (void)&fp;	/* XXX gcc */
    100 #endif
    101 
    102     /*
    103      * Use one unbuffered stdio stream for writing to and for reading from
    104      * the RFC931 etc. server. This is done because of a bug in the SunOS
    105      * 4.1.x stdio library. The bug may live in other stdio implementations,
    106      * too. When we use a single, buffered, bidirectional stdio stream ("r+"
    107      * or "w+" mode) we read our own output. Such behaviour would make sense
    108      * with resources that support random-access operations, but not with
    109      * sockets.
    110      */
    111 
    112     if ((fp = fsocket(AF_INET, SOCK_STREAM, 0)) != 0) {
    113 	setbuf(fp, (char *) 0);
    114 
    115 	/*
    116 	 * Set up a timer so we won't get stuck while waiting for the server.
    117 	 */
    118 
    119 	if (setjmp(timebuf) == 0) {
    120 	    signal(SIGALRM, timeout);
    121 	    alarm(rfc931_timeout);
    122 
    123 	    /*
    124 	     * Bind the local and remote ends of the query socket to the same
    125 	     * IP addresses as the connection under investigation. We go
    126 	     * through all this trouble because the local or remote system
    127 	     * might have more than one network address. The RFC931 etc.
    128 	     * client sends only port numbers; the server takes the IP
    129 	     * addresses from the query socket.
    130 	     */
    131 
    132 	    our_query_sin = *our_sin;
    133 	    our_query_sin.sin_port = htons(ANY_PORT);
    134 	    rmt_query_sin = *rmt_sin;
    135 	    rmt_query_sin.sin_port = htons(RFC931_PORT);
    136 
    137 	    if (bind(fileno(fp), (struct sockaddr *) & our_query_sin,
    138 		     sizeof(our_query_sin)) >= 0 &&
    139 		connect(fileno(fp), (struct sockaddr *) & rmt_query_sin,
    140 			sizeof(rmt_query_sin)) >= 0) {
    141 
    142 		/*
    143 		 * Send query to server. Neglect the risk that a 13-byte
    144 		 * write would have to be fragmented by the local system and
    145 		 * cause trouble with buggy System V stdio libraries.
    146 		 */
    147 
    148 		fprintf(fp, "%u,%u\r\n",
    149 			ntohs(rmt_sin->sin_port),
    150 			ntohs(our_sin->sin_port));
    151 		fflush(fp);
    152 
    153 		/*
    154 		 * Read response from server. Use fgets()/sscanf() so we can
    155 		 * work around System V stdio libraries that incorrectly
    156 		 * assume EOF when a read from a socket returns less than
    157 		 * requested.
    158 		 */
    159 
    160 		if (fgets(buffer, sizeof(buffer), fp) != 0
    161 		    && ferror(fp) == 0 && feof(fp) == 0
    162 		    && sscanf(buffer, "%u , %u : USERID :%*[^:]:%255s",
    163 			      &rmt_port, &our_port, user) == 3
    164 		    && ntohs(rmt_sin->sin_port) == rmt_port
    165 		    && ntohs(our_sin->sin_port) == our_port) {
    166 
    167 		    /*
    168 		     * Strip trailing carriage return. It is part of the
    169 		     * protocol, not part of the data.
    170 		     */
    171 
    172 		    if ((cp = strchr(user, '\r')) != NULL)
    173 			*cp = '\0';
    174 		    result = user;
    175 		}
    176 	    }
    177 	    alarm(0);
    178 	}
    179 	fclose(fp);
    180     }
    181     STRN_CPY(dest, result, STRING_LENGTH);
    182 }
    183