292 lines
8.2 KiB
C
292 lines
8.2 KiB
C
/* $NetBSD: socket.c,v 1.19 2012/03/21 10:10:37 matt Exp $ */
|
|
|
|
/*
|
|
* This module determines the type of socket (datagram, stream), the client
|
|
* socket address and port, the server socket address and port. In addition,
|
|
* it provides methods to map a transport address to a printable host name
|
|
* or address. Socket address information results are in static memory.
|
|
*
|
|
* The result from the hostname lookup method is STRING_PARANOID when a host
|
|
* pretends to have someone elses name, or when a host name is available but
|
|
* could not be verified.
|
|
*
|
|
* When lookup or conversion fails the result is set to STRING_UNKNOWN.
|
|
*
|
|
* Diagnostics are reported through syslog(3).
|
|
*
|
|
* Author: Wietse Venema, Eindhoven University of Technology, The Netherlands.
|
|
*/
|
|
|
|
#include <sys/cdefs.h>
|
|
#ifndef lint
|
|
#if 0
|
|
static char sccsid[] = "@(#) socket.c 1.15 97/03/21 19:27:24";
|
|
#else
|
|
__RCSID("$NetBSD: socket.c,v 1.19 2012/03/21 10:10:37 matt Exp $");
|
|
#endif
|
|
#endif
|
|
|
|
/* System libraries. */
|
|
|
|
#include <sys/types.h>
|
|
#include <sys/param.h>
|
|
#include <sys/socket.h>
|
|
#include <netinet/in.h>
|
|
#include <netdb.h>
|
|
#include <stdio.h>
|
|
#include <syslog.h>
|
|
#include <string.h>
|
|
#include <arpa/inet.h>
|
|
|
|
/* Local stuff. */
|
|
|
|
#include "tcpd.h"
|
|
|
|
/* Forward declarations. */
|
|
|
|
#ifdef APPEND_DOT
|
|
static const char *append_dot __P((const char *));
|
|
#endif
|
|
static void sock_sink __P((int));
|
|
|
|
#ifdef APPEND_DOT
|
|
/*
|
|
* Speed up DNS lookups by terminating the host name with a dot. Should be
|
|
* done with care. The speedup can give problems with lookups from sources
|
|
* that lack DNS-style trailing dot magic, such as local files or NIS maps.
|
|
*/
|
|
|
|
static const char *
|
|
append_dot(name)
|
|
const char *name;
|
|
{
|
|
static char hbuf[MAXHOSTNAMELEN + 1];
|
|
|
|
/*
|
|
* Don't append dots to unqualified names. Such names are likely to come
|
|
* from local hosts files or from NIS.
|
|
*/
|
|
|
|
if (strchr(name, '.') == 0 || strlen(name) + 2 > sizeof(hbuf))
|
|
strlcpy(hbuf, name, sizeof(hbuf));
|
|
else
|
|
(void)snprintf(hbuf, sizeof(hbuf), "%s.", name);
|
|
return hbuf;
|
|
}
|
|
#endif
|
|
|
|
/* sock_host - look up endpoint addresses and install conversion methods */
|
|
|
|
void
|
|
sock_host(struct request_info *request)
|
|
{
|
|
static struct sockaddr_storage client;
|
|
static struct sockaddr_storage server;
|
|
socklen_t len;
|
|
char buf[BUFSIZ];
|
|
int fd = request->fd;
|
|
|
|
sock_methods(request);
|
|
|
|
/*
|
|
* Look up the client host address. Hal R. Brand <BRAND@addvax.llnl.gov>
|
|
* suggested how to get the client host info in case of UDP connections:
|
|
* peek at the first message without actually looking at its contents. We
|
|
* really should verify that client.sin_family gets the value AF_INET,
|
|
* but this program has already caused too much grief on systems with
|
|
* broken library code.
|
|
*
|
|
* XXX the last sentence is untrue as we support AF_INET6 as well :-)
|
|
*/
|
|
|
|
if (request->client->sin == NULL) {
|
|
len = sizeof(client);
|
|
if (getpeername(fd, (struct sockaddr *)(void *)& client, &len) < 0) {
|
|
request->sink = sock_sink;
|
|
len = sizeof(client);
|
|
if (recvfrom(fd, buf, sizeof(buf), MSG_PEEK,
|
|
(struct sockaddr *) & client, &len) < 0) {
|
|
tcpd_warn("can't get client address: %m");
|
|
return; /* give up */
|
|
}
|
|
#ifdef really_paranoid
|
|
memset(buf, 0, sizeof(buf));
|
|
#endif
|
|
}
|
|
request->client->sin = (struct sockaddr *)&client;
|
|
}
|
|
|
|
/*
|
|
* Determine the server binding. This is used for client username
|
|
* lookups, and for access control rules that trigger on the server
|
|
* address or name.
|
|
*/
|
|
|
|
if (request->server->sin == NULL) {
|
|
len = sizeof(server);
|
|
if (getsockname(fd, (struct sockaddr *) & server, &len) < 0) {
|
|
tcpd_warn("getsockname: %m");
|
|
return;
|
|
}
|
|
request->server->sin = (struct sockaddr *)&server;
|
|
}
|
|
}
|
|
|
|
/* sock_hostaddr - map endpoint address to printable form */
|
|
|
|
void
|
|
sock_hostaddr(struct host_info *host)
|
|
{
|
|
struct sockaddr *sa = host->sin;
|
|
|
|
if (!sa)
|
|
return;
|
|
host->addr[0] = '\0';
|
|
getnameinfo(sa, sa->sa_len, host->addr, sizeof(host->addr),
|
|
NULL, 0, NI_NUMERICHOST);
|
|
}
|
|
|
|
/* sock_hostname - map endpoint address to host name */
|
|
|
|
void
|
|
sock_hostname(struct host_info *host)
|
|
{
|
|
struct sockaddr *sa = host->sin;
|
|
char h1[NI_MAXHOST], h2[NI_MAXHOST];
|
|
struct addrinfo hints, *res, *res0;
|
|
#ifdef INET6
|
|
struct sockaddr_in tmp;
|
|
#endif
|
|
|
|
if (!sa)
|
|
return;
|
|
#ifdef INET6
|
|
/* special case on reverse lookup: mapped addr. I hate it */
|
|
if (sa->sa_family == AF_INET6 &&
|
|
IN6_IS_ADDR_V4MAPPED(&((struct sockaddr_in6 *)sa)->sin6_addr)) {
|
|
memset(&tmp, 0, sizeof(tmp));
|
|
tmp.sin_family = AF_INET;
|
|
tmp.sin_len = sizeof(struct sockaddr_in);
|
|
memcpy(&tmp.sin_addr,
|
|
&((struct sockaddr_in6 *)sa)->sin6_addr.s6_addr[12], 4);
|
|
sa = (struct sockaddr *)&tmp;
|
|
}
|
|
#endif
|
|
if (getnameinfo(sa, sa->sa_len, h1, sizeof(h1), NULL, 0,
|
|
NI_NUMERICHOST) != 0) {
|
|
return;
|
|
}
|
|
if (getnameinfo(sa, sa->sa_len, host->name, sizeof(host->name), NULL, 0,
|
|
NI_NAMEREQD) == 0) {
|
|
/*
|
|
* if reverse lookup result looks like a numeric hostname,
|
|
* someone is trying to trick us by PTR record like following:
|
|
* 1.1.1.10.in-addr.arpa. IN PTR 2.3.4.5
|
|
*/
|
|
memset(&hints, 0, sizeof(hints));
|
|
hints.ai_socktype = SOCK_DGRAM; /*dummy*/
|
|
hints.ai_flags = AI_NUMERICHOST;
|
|
#ifdef APPEND_DOT
|
|
if (getaddrinfo(append_dot(host->name), "0", &hints, &res0) == 0)
|
|
#else
|
|
if (getaddrinfo(host->name, "0", &hints, &res0) == 0)
|
|
#endif
|
|
{
|
|
tcpd_warn("Nasty PTR record is configured");
|
|
freeaddrinfo(res0);
|
|
/* name is bad, clobber it */
|
|
(void)strlcpy(host->name, paranoid, sizeof(host->name));
|
|
return;
|
|
}
|
|
|
|
/*
|
|
* Verify that the address is a member of the address list returned
|
|
* by getaddrinfo(hostname).
|
|
*
|
|
* Verify also that getnameinfo() and getaddrinfo() return the same
|
|
* hostname, or rshd and rlogind may still end up being spoofed.
|
|
*
|
|
* On some sites, getaddrinfo("localhost") returns "localhost.domain".
|
|
* This is a DNS artefact. We treat it as a special case. When we
|
|
* can't believe the address list from getaddrinfo("localhost")
|
|
* we're in big trouble anyway.
|
|
*/
|
|
memset(&hints, 0, sizeof(hints));
|
|
hints.ai_family = sa->sa_family;
|
|
hints.ai_socktype = SOCK_DGRAM; /*dummy*/
|
|
hints.ai_flags = AI_CANONNAME;
|
|
#ifdef APPEND_DOT
|
|
if (getaddrinfo(append_dot(host->name), "0", &hints, &res0) != 0)
|
|
#else
|
|
if (getaddrinfo(host->name, "0", &hints, &res0) != 0)
|
|
#endif
|
|
{
|
|
/*
|
|
* Unable to verify that the host name matches the address. This
|
|
* may be a transient problem or a botched name server setup.
|
|
*/
|
|
|
|
tcpd_warn("can't verify hostname: getaddrinfo(%s, %d) failed",
|
|
host->name, hints.ai_family);
|
|
} else if (res0->ai_canonname &&
|
|
STR_NE(host->name, res0->ai_canonname) &&
|
|
STR_NE(host->name, "localhost")) {
|
|
/*
|
|
* The getnameinfo() and getaddrinfo() calls did not return
|
|
* the same hostname. This could be a nameserver configuration
|
|
* problem. It could also be that someone is trying to spoof us.
|
|
*/
|
|
|
|
tcpd_warn("host name/name mismatch: %s != %s",
|
|
host->name, res0->ai_canonname);
|
|
freeaddrinfo(res0);
|
|
} else {
|
|
/*
|
|
* The address should be a member of the address list returned by
|
|
* getaddrinfo().
|
|
*/
|
|
|
|
for (res = res0; res; res = res->ai_next) {
|
|
if (getnameinfo(res->ai_addr, res->ai_addrlen, h2, sizeof(h2),
|
|
NULL, 0, NI_NUMERICHOST) != 0) {
|
|
continue;
|
|
}
|
|
if (STR_EQ(h1, h2)) {
|
|
freeaddrinfo(res0);
|
|
return;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* The host name does not map to the initial address. Perhaps
|
|
* someone has messed up. Perhaps someone compromised a name
|
|
* server.
|
|
*/
|
|
|
|
tcpd_warn("host name/address mismatch: %s != %s", h1,
|
|
res0->ai_canonname ? res0->ai_canonname : "?");
|
|
|
|
freeaddrinfo(res0);
|
|
}
|
|
/* name is bad, clobber it */
|
|
(void)strlcpy(host->name, paranoid, sizeof(host->name));
|
|
}
|
|
}
|
|
|
|
/* sock_sink - absorb unreceived IP datagram */
|
|
|
|
static void
|
|
sock_sink(int fd)
|
|
{
|
|
char buf[BUFSIZ];
|
|
struct sockaddr_storage ss;
|
|
socklen_t size = sizeof(ss);
|
|
|
|
/*
|
|
* Eat up the not-yet received datagram. Some systems insist on a
|
|
* non-zero source address argument in the recvfrom() call below.
|
|
*/
|
|
|
|
(void) recvfrom(fd, buf, sizeof(buf), 0, (struct sockaddr *) & ss, &size);
|
|
}
|