1 /* $NetBSD: rfc931.c,v 1.10 2012/03/22 22:59:43 joerg 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.10 2012/03/22 22:59:43 joerg 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(int, int, int); 48 static void timeout(int) __dead; 49 50 /* fsocket - open stdio stream on top of socket */ 51 52 static FILE * 53 fsocket(int domain, int type, int protocol) 54 { 55 int s; 56 FILE *fp; 57 58 if ((s = socket(domain, type, protocol)) < 0) { 59 tcpd_warn("socket: %m"); 60 return (0); 61 } else { 62 if ((fp = fdopen(s, "r+")) == 0) { 63 tcpd_warn("fdopen: %m"); 64 close(s); 65 } 66 return (fp); 67 } 68 } 69 70 /* timeout - handle timeouts */ 71 72 static void 73 timeout(int sig) 74 { 75 longjmp(timebuf, sig); 76 } 77 78 /* rfc931 - return remote user name, given socket structures */ 79 80 void 81 rfc931(struct sockaddr *rmt_sin, struct sockaddr *our_sin, char *dest) 82 { 83 unsigned rmt_port; 84 unsigned our_port; 85 struct sockaddr_storage rmt_query_sin; 86 struct sockaddr_storage our_query_sin; 87 char user[256]; /* XXX */ 88 char buffer[512]; /* XXX */ 89 char *cp; 90 char *result = unknown; 91 FILE *fp; 92 volatile int salen; 93 u_short * volatile rmt_portp; 94 u_short * volatile our_portp; 95 96 /* address family must be the same */ 97 if (rmt_sin->sa_family != our_sin->sa_family) { 98 strlcpy(dest, result, STRING_LENGTH); 99 return; 100 } 101 switch (rmt_sin->sa_family) { 102 case AF_INET: 103 salen = sizeof(struct sockaddr_in); 104 rmt_portp = &(((struct sockaddr_in *)rmt_sin)->sin_port); 105 break; 106 #ifdef INET6 107 case AF_INET6: 108 salen = sizeof(struct sockaddr_in6); 109 rmt_portp = &(((struct sockaddr_in6 *)rmt_sin)->sin6_port); 110 break; 111 #endif 112 default: 113 strlcpy(dest, result, STRING_LENGTH); 114 return; 115 } 116 switch (our_sin->sa_family) { 117 case AF_INET: 118 our_portp = &(((struct sockaddr_in *)our_sin)->sin_port); 119 break; 120 #ifdef INET6 121 case AF_INET6: 122 our_portp = &(((struct sockaddr_in6 *)our_sin)->sin6_port); 123 break; 124 #endif 125 default: 126 strlcpy(dest, result, STRING_LENGTH); 127 return; 128 } 129 130 #ifdef __GNUC__ 131 (void)&result; /* Avoid longjmp clobbering */ 132 (void)&fp; /* XXX gcc */ 133 #endif 134 135 /* 136 * Use one unbuffered stdio stream for writing to and for reading from 137 * the RFC931 etc. server. This is done because of a bug in the SunOS 138 * 4.1.x stdio library. The bug may live in other stdio implementations, 139 * too. When we use a single, buffered, bidirectional stdio stream ("r+" 140 * or "w+" mode) we read our own output. Such behaviour would make sense 141 * with resources that support random-access operations, but not with 142 * sockets. 143 */ 144 145 if ((fp = fsocket(rmt_sin->sa_family, SOCK_STREAM, 0)) != 0) { 146 setbuf(fp, (char *) 0); 147 148 /* 149 * Set up a timer so we won't get stuck while waiting for the server. 150 */ 151 152 if (setjmp(timebuf) == 0) { 153 signal(SIGALRM, timeout); 154 alarm(rfc931_timeout); 155 156 /* 157 * Bind the local and remote ends of the query socket to the same 158 * IP addresses as the connection under investigation. We go 159 * through all this trouble because the local or remote system 160 * might have more than one network address. The RFC931 etc. 161 * client sends only port numbers; the server takes the IP 162 * addresses from the query socket. 163 */ 164 165 memcpy(&our_query_sin, our_sin, salen); 166 switch (our_query_sin.ss_family) { 167 case AF_INET: 168 ((struct sockaddr_in *)&our_query_sin)->sin_port = 169 htons(ANY_PORT); 170 break; 171 #ifdef INET6 172 case AF_INET6: 173 ((struct sockaddr_in6 *)&our_query_sin)->sin6_port = 174 htons(ANY_PORT); 175 break; 176 #endif 177 } 178 memcpy(&rmt_query_sin, rmt_sin, salen); 179 switch (rmt_query_sin.ss_family) { 180 case AF_INET: 181 ((struct sockaddr_in *)&rmt_query_sin)->sin_port = 182 htons(RFC931_PORT); 183 break; 184 #ifdef INET6 185 case AF_INET6: 186 ((struct sockaddr_in6 *)&rmt_query_sin)->sin6_port = 187 htons(RFC931_PORT); 188 break; 189 #endif 190 } 191 192 if (bind(fileno(fp), (struct sockaddr *) & our_query_sin, 193 salen) >= 0 && 194 connect(fileno(fp), (struct sockaddr *) & rmt_query_sin, 195 salen) >= 0) { 196 197 /* 198 * Send query to server. Neglect the risk that a 13-byte 199 * write would have to be fragmented by the local system and 200 * cause trouble with buggy System V stdio libraries. 201 */ 202 203 fprintf(fp, "%u,%u\r\n", 204 ntohs(*rmt_portp), 205 ntohs(*our_portp)); 206 fflush(fp); 207 208 /* 209 * Read response from server. Use fgets()/sscanf() so we can 210 * work around System V stdio libraries that incorrectly 211 * assume EOF when a read from a socket returns less than 212 * requested. 213 */ 214 215 if (fgets(buffer, sizeof(buffer), fp) != 0 216 && ferror(fp) == 0 && feof(fp) == 0 217 && sscanf(buffer, "%u , %u : USERID :%*[^:]:%255s", 218 &rmt_port, &our_port, user) == 3 219 && ntohs(*rmt_portp) == rmt_port 220 && ntohs(*our_portp) == our_port) { 221 222 /* 223 * Strip trailing carriage return. It is part of the 224 * protocol, not part of the data. 225 */ 226 227 if ((cp = strchr(user, '\r')) != NULL) 228 *cp = '\0'; 229 result = user; 230 } 231 } 232 alarm(0); 233 } 234 fclose(fp); 235 } 236 strlcpy(dest, result, STRING_LENGTH); 237 } 238