blob: 8270500d39e55c2b38ebeaf80459ee1141b06247 [file] [log] [blame]
Darren Tucker4abde772007-12-29 02:43:51 +11001/* $OpenBSD: canohost.c,v 1.62 2007/12/27 14:22:08 dtucker Exp $ */
Damien Millerd4a8b7e1999-10-27 13:42:43 +10002/*
Damien Miller95def091999-11-25 00:26:21 +11003 * Author: Tatu Ylonen <ylo@cs.hut.fi>
Damien Miller95def091999-11-25 00:26:21 +11004 * Copyright (c) 1995 Tatu Ylonen <ylo@cs.hut.fi>, Espoo, Finland
5 * All rights reserved
Damien Miller95def091999-11-25 00:26:21 +11006 * Functions for returning the canonical host name of the remote site.
Damien Miller4af51302000-04-16 11:18:38 +10007 *
Damien Millere4340be2000-09-16 13:29:08 +11008 * As far as I am concerned, the code I have written for this software
9 * can be used freely for any purpose. Any derived versions of this
10 * software must be clearly marked as such, and if the derived work is
11 * incompatible with the protocol description in the RFC file, it must be
12 * called by a name other than "ssh" or "Secure Shell".
Damien Miller95def091999-11-25 00:26:21 +110013 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100014
15#include "includes.h"
Damien Millerc7b06362006-03-15 11:53:45 +110016
Damien Millere3b60b52006-07-10 21:08:03 +100017#include <sys/types.h>
Damien Miller8ec8c3e2006-07-10 20:35:38 +100018#include <sys/socket.h>
19
20#include <netinet/in.h>
Darren Tuckerdace2332006-09-22 19:22:17 +100021#include <arpa/inet.h>
Damien Miller8ec8c3e2006-07-10 20:35:38 +100022
Damien Millerc7b06362006-03-15 11:53:45 +110023#include <ctype.h>
Darren Tucker39972492006-07-12 22:22:46 +100024#include <errno.h>
Damien Millerb8fe89c2006-07-24 14:51:00 +100025#include <netdb.h>
Damien Millera7a73ee2006-08-05 11:37:59 +100026#include <stdio.h>
Damien Millere7a1e5c2006-08-05 11:34:19 +100027#include <stdlib.h>
Damien Millere3476ed2006-07-24 14:13:33 +100028#include <string.h>
Damien Millerd7834352006-08-05 12:39:39 +100029#include <stdarg.h>
Damien Millerd4a8b7e1999-10-27 13:42:43 +100030
Damien Millerd4a8b7e1999-10-27 13:42:43 +100031#include "xmalloc.h"
Damien Millerd7834352006-08-05 12:39:39 +100032#include "packet.h"
Ben Lindstrom226cfa02001-01-22 05:34:40 +000033#include "log.h"
Ben Lindstrom31ca54a2001-02-09 02:11:24 +000034#include "canohost.h"
Darren Tucker4abde772007-12-29 02:43:51 +110035#include "misc.h"
Damien Millerd4a8b7e1999-10-27 13:42:43 +100036
Ben Lindstrombba81212001-06-25 05:01:22 +000037static void check_ip_options(int, char *);
Damien Miller33804262001-02-04 23:20:18 +110038
Damien Miller5428f641999-11-25 11:54:57 +110039/*
40 * Return the canonical name of the host at the other end of the socket. The
41 * caller should free the returned string with xfree.
42 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +100043
Ben Lindstrombba81212001-06-25 05:01:22 +000044static char *
Darren Tucker3f9fdc72004-06-22 12:56:01 +100045get_remote_hostname(int sock, int use_dns)
Damien Millerd4a8b7e1999-10-27 13:42:43 +100046{
Damien Miller34132e52000-01-14 15:45:46 +110047 struct sockaddr_storage from;
48 int i;
49 socklen_t fromlen;
50 struct addrinfo hints, *ai, *aitop;
Damien Miller33804262001-02-04 23:20:18 +110051 char name[NI_MAXHOST], ntop[NI_MAXHOST], ntop2[NI_MAXHOST];
Damien Millerd4a8b7e1999-10-27 13:42:43 +100052
Damien Miller95def091999-11-25 00:26:21 +110053 /* Get IP address of client. */
54 fromlen = sizeof(from);
55 memset(&from, 0, sizeof(from));
Darren Tucker3f9fdc72004-06-22 12:56:01 +100056 if (getpeername(sock, (struct sockaddr *)&from, &fromlen) < 0) {
Damien Miller95def091999-11-25 00:26:21 +110057 debug("getpeername failed: %.100s", strerror(errno));
Darren Tucker3e33cec2003-10-02 16:12:36 +100058 cleanup_exit(255);
Damien Millerd4a8b7e1999-10-27 13:42:43 +100059 }
Damien Miller7bcb0892000-03-11 20:45:40 +110060
Damien Miller2eaf37d2006-04-18 15:13:16 +100061 if (from.ss_family == AF_INET)
62 check_ip_options(sock, ntop);
63
Damien Miller927f5272003-11-24 12:57:25 +110064 ipv64_normalise_mapped(&from, &fromlen);
Damien Miller7bcb0892000-03-11 20:45:40 +110065
Damien Miller5e4471e2003-01-07 10:51:23 +110066 if (from.ss_family == AF_INET6)
67 fromlen = sizeof(struct sockaddr_in6);
Damien Miller7bcb0892000-03-11 20:45:40 +110068
Damien Miller34132e52000-01-14 15:45:46 +110069 if (getnameinfo((struct sockaddr *)&from, fromlen, ntop, sizeof(ntop),
Damien Miller9f0f5c62001-12-21 14:45:46 +110070 NULL, 0, NI_NUMERICHOST) != 0)
Damien Miller34132e52000-01-14 15:45:46 +110071 fatal("get_remote_hostname: getnameinfo NI_NUMERICHOST failed");
Damien Miller95def091999-11-25 00:26:21 +110072
Damien Miller3a961dc2003-06-03 10:25:48 +100073 if (!use_dns)
74 return xstrdup(ntop);
75
Ben Lindstrom121c7852001-04-18 15:32:44 +000076 debug3("Trying to reverse map address %.100s.", ntop);
Damien Miller34132e52000-01-14 15:45:46 +110077 /* Map the IP address to a host name. */
78 if (getnameinfo((struct sockaddr *)&from, fromlen, name, sizeof(name),
Damien Miller9f0f5c62001-12-21 14:45:46 +110079 NULL, 0, NI_NAMEREQD) != 0) {
Damien Miller33804262001-02-04 23:20:18 +110080 /* Host name not found. Use ip address. */
Damien Miller33804262001-02-04 23:20:18 +110081 return xstrdup(ntop);
Damien Millerd4a8b7e1999-10-27 13:42:43 +100082 }
Damien Millerd4a8b7e1999-10-27 13:42:43 +100083
Damien Miller3a961dc2003-06-03 10:25:48 +100084 /*
85 * if reverse lookup result looks like a numeric hostname,
86 * someone is trying to trick us by PTR record like following:
87 * 1.1.1.10.in-addr.arpa. IN PTR 2.3.4.5
88 */
89 memset(&hints, 0, sizeof(hints));
90 hints.ai_socktype = SOCK_DGRAM; /*dummy*/
Darren Tucker0f684862003-06-05 09:52:42 +100091 hints.ai_flags = AI_NUMERICHOST;
Damien Miller3a961dc2003-06-03 10:25:48 +100092 if (getaddrinfo(name, "0", &hints, &ai) == 0) {
93 logit("Nasty PTR record \"%s\" is set up for %s, ignoring",
94 name, ntop);
95 freeaddrinfo(ai);
96 return xstrdup(ntop);
97 }
98
Damien Miller5428f641999-11-25 11:54:57 +110099 /*
Damien Miller33804262001-02-04 23:20:18 +1100100 * Convert it to all lowercase (which is expected by the rest
101 * of this software).
Damien Miller5428f641999-11-25 11:54:57 +1100102 */
Damien Miller33804262001-02-04 23:20:18 +1100103 for (i = 0; name[i]; i++)
104 if (isupper(name[i]))
Damien Miller1d2b6702006-03-26 14:09:54 +1100105 name[i] = (char)tolower(name[i]);
Damien Miller33804262001-02-04 23:20:18 +1100106 /*
107 * Map it back to an IP address and check that the given
108 * address actually is an address of this host. This is
109 * necessary because anyone with access to a name server can
110 * define arbitrary names for an IP address. Mapping from
111 * name to IP address can be trusted better (but can still be
112 * fooled if the intruder has access to the name server of
113 * the domain).
114 */
115 memset(&hints, 0, sizeof(hints));
116 hints.ai_family = from.ss_family;
117 hints.ai_socktype = SOCK_STREAM;
118 if (getaddrinfo(name, NULL, &hints, &aitop) != 0) {
Damien Miller996acd22003-04-09 20:59:48 +1000119 logit("reverse mapping checking getaddrinfo for %.700s "
Damien Millerde85a282006-03-15 12:06:41 +1100120 "[%s] failed - POSSIBLE BREAK-IN ATTEMPT!", name, ntop);
Damien Miller33804262001-02-04 23:20:18 +1100121 return xstrdup(ntop);
Damien Miller95def091999-11-25 00:26:21 +1100122 }
Damien Miller33804262001-02-04 23:20:18 +1100123 /* Look for the address from the list of addresses. */
124 for (ai = aitop; ai; ai = ai->ai_next) {
125 if (getnameinfo(ai->ai_addr, ai->ai_addrlen, ntop2,
126 sizeof(ntop2), NULL, 0, NI_NUMERICHOST) == 0 &&
127 (strcmp(ntop, ntop2) == 0))
128 break;
129 }
130 freeaddrinfo(aitop);
131 /* If we reached the end of the list, the address was not there. */
132 if (!ai) {
133 /* Address not found for the host name. */
Damien Miller996acd22003-04-09 20:59:48 +1000134 logit("Address %.100s maps to %.600s, but this does not "
Damien Miller5eb137c2005-12-31 16:19:53 +1100135 "map back to the address - POSSIBLE BREAK-IN ATTEMPT!",
Damien Miller33804262001-02-04 23:20:18 +1100136 ntop, name);
137 return xstrdup(ntop);
138 }
Damien Miller95def091999-11-25 00:26:21 +1100139 return xstrdup(name);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000140}
141
Damien Miller5428f641999-11-25 11:54:57 +1100142/*
Damien Miller33804262001-02-04 23:20:18 +1100143 * If IP options are supported, make sure there are none (log and
144 * disconnect them if any are found). Basically we are worried about
145 * source routing; it can be used to pretend you are somebody
146 * (ip-address) you are not. That itself may be "almost acceptable"
147 * under certain circumstances, but rhosts autentication is useless
148 * if source routing is accepted. Notice also that if we just dropped
149 * source routing here, the other side could use IP spoofing to do
150 * rest of the interaction and could still bypass security. So we
151 * exit here if we detect any IP options.
152 */
153/* IPv4 only */
Ben Lindstrombba81212001-06-25 05:01:22 +0000154static void
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000155check_ip_options(int sock, char *ipaddr)
Damien Miller33804262001-02-04 23:20:18 +1100156{
Darren Tucker89f4cf02003-08-07 13:29:04 +1000157#ifdef IP_OPTIONS
Ben Lindstrom075390a2001-02-10 21:34:46 +0000158 u_char options[200];
159 char text[sizeof(options) * 3 + 1];
Damien Miller33804262001-02-04 23:20:18 +1100160 socklen_t option_size;
Damien Millereccb9de2005-06-17 12:59:34 +1000161 u_int i;
162 int ipproto;
Damien Miller33804262001-02-04 23:20:18 +1100163 struct protoent *ip;
164
165 if ((ip = getprotobyname("ip")) != NULL)
166 ipproto = ip->p_proto;
167 else
168 ipproto = IPPROTO_IP;
169 option_size = sizeof(options);
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000170 if (getsockopt(sock, ipproto, IP_OPTIONS, options,
Damien Miller33804262001-02-04 23:20:18 +1100171 &option_size) >= 0 && option_size != 0) {
Ben Lindstrom075390a2001-02-10 21:34:46 +0000172 text[0] = '\0';
173 for (i = 0; i < option_size; i++)
174 snprintf(text + i*3, sizeof(text) - i*3,
175 " %2.2x", options[i]);
Damien Miller4d3fd542005-11-05 15:13:24 +1100176 fatal("Connection from %.100s with IP options:%.800s",
Damien Miller33804262001-02-04 23:20:18 +1100177 ipaddr, text);
178 }
Darren Tucker89f4cf02003-08-07 13:29:04 +1000179#endif /* IP_OPTIONS */
Damien Miller33804262001-02-04 23:20:18 +1100180}
181
Darren Tucker2fba9932005-02-02 23:30:24 +1100182void
Damien Miller927f5272003-11-24 12:57:25 +1100183ipv64_normalise_mapped(struct sockaddr_storage *addr, socklen_t *len)
184{
185 struct sockaddr_in6 *a6 = (struct sockaddr_in6 *)addr;
186 struct sockaddr_in *a4 = (struct sockaddr_in *)addr;
187 struct in_addr inaddr;
188 u_int16_t port;
189
Damien Miller94cf4c82005-07-17 17:04:47 +1000190 if (addr->ss_family != AF_INET6 ||
Damien Miller927f5272003-11-24 12:57:25 +1100191 !IN6_IS_ADDR_V4MAPPED(&a6->sin6_addr))
192 return;
193
194 debug3("Normalising mapped IPv4 in IPv6 address");
195
196 memcpy(&inaddr, ((char *)&a6->sin6_addr) + 12, sizeof(inaddr));
197 port = a6->sin6_port;
198
199 memset(addr, 0, sizeof(*a4));
200
201 a4->sin_family = AF_INET;
202 *len = sizeof(*a4);
203 memcpy(&a4->sin_addr, &inaddr, sizeof(inaddr));
204 a4->sin_port = port;
205}
206
Damien Miller33804262001-02-04 23:20:18 +1100207/*
Damien Miller5428f641999-11-25 11:54:57 +1100208 * Return the canonical name of the host in the other side of the current
209 * connection. The host name is cached, so it is efficient to call this
210 * several times.
211 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000212
Damien Miller95def091999-11-25 00:26:21 +1100213const char *
Damien Miller3a961dc2003-06-03 10:25:48 +1000214get_canonical_hostname(int use_dns)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000215{
Damien Miller24ecf612005-11-05 15:16:52 +1100216 char *host;
Damien Miller34132e52000-01-14 15:45:46 +1100217 static char *canonical_host_name = NULL;
Damien Miller24ecf612005-11-05 15:16:52 +1100218 static char *remote_ip = NULL;
Damien Miller34132e52000-01-14 15:45:46 +1100219
Damien Miller33804262001-02-04 23:20:18 +1100220 /* Check if we have previously retrieved name with same option. */
Damien Miller24ecf612005-11-05 15:16:52 +1100221 if (use_dns && canonical_host_name != NULL)
222 return canonical_host_name;
223 if (!use_dns && remote_ip != NULL)
224 return remote_ip;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000225
Damien Miller95def091999-11-25 00:26:21 +1100226 /* Get the real hostname if socket; otherwise return UNKNOWN. */
Damien Miller34132e52000-01-14 15:45:46 +1100227 if (packet_connection_is_on_socket())
Damien Miller24ecf612005-11-05 15:16:52 +1100228 host = get_remote_hostname(packet_get_connection_in(), use_dns);
Damien Miller95def091999-11-25 00:26:21 +1100229 else
Damien Miller24ecf612005-11-05 15:16:52 +1100230 host = "UNKNOWN";
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000231
Damien Miller24ecf612005-11-05 15:16:52 +1100232 if (use_dns)
233 canonical_host_name = host;
234 else
235 remote_ip = host;
236 return host;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000237}
238
Damien Miller5428f641999-11-25 11:54:57 +1100239/*
Ben Lindstromacaac972002-12-23 02:13:37 +0000240 * Returns the local/remote IP-address/hostname of socket as a string.
241 * The returned string must be freed.
Damien Millerd83ff352001-01-30 09:19:34 +1100242 */
Ben Lindstrombba81212001-06-25 05:01:22 +0000243static char *
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000244get_socket_address(int sock, int remote, int flags)
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000245{
246 struct sockaddr_storage addr;
247 socklen_t addrlen;
248 char ntop[NI_MAXHOST];
Damien Miller9b8073e2005-03-01 21:16:18 +1100249 int r;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000250
251 /* Get IP address of client. */
252 addrlen = sizeof(addr);
253 memset(&addr, 0, sizeof(addr));
254
255 if (remote) {
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000256 if (getpeername(sock, (struct sockaddr *)&addr, &addrlen)
Damien Millerb2f844d2002-09-25 12:19:08 +1000257 < 0)
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000258 return NULL;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000259 } else {
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000260 if (getsockname(sock, (struct sockaddr *)&addr, &addrlen)
Damien Millerb2f844d2002-09-25 12:19:08 +1000261 < 0)
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000262 return NULL;
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000263 }
Damien Miller5e4471e2003-01-07 10:51:23 +1100264
265 /* Work around Linux IPv6 weirdness */
266 if (addr.ss_family == AF_INET6)
267 addrlen = sizeof(struct sockaddr_in6);
268
Darren Tucker5b115d42005-05-03 19:05:32 +1000269 ipv64_normalise_mapped(&addr, &addrlen);
270
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000271 /* Get the address in ascii. */
Damien Miller9b8073e2005-03-01 21:16:18 +1100272 if ((r = getnameinfo((struct sockaddr *)&addr, addrlen, ntop,
273 sizeof(ntop), NULL, 0, flags)) != 0) {
274 error("get_socket_address: getnameinfo %d failed: %s", flags,
Darren Tucker4abde772007-12-29 02:43:51 +1100275 ssh_gai_strerror(r));
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000276 return NULL;
277 }
278 return xstrdup(ntop);
279}
Damien Millerd83ff352001-01-30 09:19:34 +1100280
281char *
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000282get_peer_ipaddr(int sock)
Damien Millerd83ff352001-01-30 09:19:34 +1100283{
Damien Millerb2f844d2002-09-25 12:19:08 +1000284 char *p;
285
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000286 if ((p = get_socket_address(sock, 1, NI_NUMERICHOST)) != NULL)
Damien Millerb2f844d2002-09-25 12:19:08 +1000287 return p;
288 return xstrdup("UNKNOWN");
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000289}
Damien Millerd83ff352001-01-30 09:19:34 +1100290
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000291char *
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000292get_local_ipaddr(int sock)
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000293{
Damien Millerb2f844d2002-09-25 12:19:08 +1000294 char *p;
295
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000296 if ((p = get_socket_address(sock, 0, NI_NUMERICHOST)) != NULL)
Damien Millerb2f844d2002-09-25 12:19:08 +1000297 return p;
298 return xstrdup("UNKNOWN");
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000299}
300
301char *
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000302get_local_name(int sock)
Ben Lindstrom5eabda32001-04-12 23:34:34 +0000303{
Darren Tucker3f9fdc72004-06-22 12:56:01 +1000304 return get_socket_address(sock, 0, NI_NAMEREQD);
Damien Millerd83ff352001-01-30 09:19:34 +1100305}
306
307/*
Damien Miller5428f641999-11-25 11:54:57 +1100308 * Returns the IP-address of the remote host as a string. The returned
Damien Miller34132e52000-01-14 15:45:46 +1100309 * string must not be freed.
Damien Miller5428f641999-11-25 11:54:57 +1100310 */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000311
Damien Miller95def091999-11-25 00:26:21 +1100312const char *
Ben Lindstrom3c36bb22001-12-06 17:55:26 +0000313get_remote_ipaddr(void)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000314{
Damien Miller34132e52000-01-14 15:45:46 +1100315 static char *canonical_host_ip = NULL;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000316
Damien Millerd83ff352001-01-30 09:19:34 +1100317 /* Check whether we have cached the ipaddr. */
318 if (canonical_host_ip == NULL) {
319 if (packet_connection_is_on_socket()) {
320 canonical_host_ip =
321 get_peer_ipaddr(packet_get_connection_in());
322 if (canonical_host_ip == NULL)
Darren Tucker3e33cec2003-10-02 16:12:36 +1000323 cleanup_exit(255);
Damien Millerd83ff352001-01-30 09:19:34 +1100324 } else {
325 /* If not on socket, return UNKNOWN. */
326 canonical_host_ip = xstrdup("UNKNOWN");
327 }
Damien Miller95def091999-11-25 00:26:21 +1100328 }
Damien Miller95def091999-11-25 00:26:21 +1100329 return canonical_host_ip;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000330}
331
Ben Lindstromf15a3862001-04-05 23:32:17 +0000332const char *
Damien Miller3a961dc2003-06-03 10:25:48 +1000333get_remote_name_or_ip(u_int utmp_len, int use_dns)
Ben Lindstromf15a3862001-04-05 23:32:17 +0000334{
335 static const char *remote = "";
336 if (utmp_len > 0)
Damien Miller3a961dc2003-06-03 10:25:48 +1000337 remote = get_canonical_hostname(use_dns);
Ben Lindstromf15a3862001-04-05 23:32:17 +0000338 if (utmp_len == 0 || strlen(remote) > utmp_len)
339 remote = get_remote_ipaddr();
340 return remote;
341}
342
Damien Miller34132e52000-01-14 15:45:46 +1100343/* Returns the local/remote port for the socket. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000344
Ben Lindstrombba81212001-06-25 05:01:22 +0000345static int
Damien Miller34132e52000-01-14 15:45:46 +1100346get_sock_port(int sock, int local)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000347{
Damien Miller34132e52000-01-14 15:45:46 +1100348 struct sockaddr_storage from;
349 socklen_t fromlen;
350 char strport[NI_MAXSERV];
Damien Miller9b8073e2005-03-01 21:16:18 +1100351 int r;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000352
Damien Miller95def091999-11-25 00:26:21 +1100353 /* Get IP address of client. */
354 fromlen = sizeof(from);
355 memset(&from, 0, sizeof(from));
Damien Miller34132e52000-01-14 15:45:46 +1100356 if (local) {
357 if (getsockname(sock, (struct sockaddr *)&from, &fromlen) < 0) {
358 error("getsockname failed: %.100s", strerror(errno));
359 return 0;
360 }
361 } else {
Ben Lindstromacaac972002-12-23 02:13:37 +0000362 if (getpeername(sock, (struct sockaddr *)&from, &fromlen) < 0) {
Damien Miller34132e52000-01-14 15:45:46 +1100363 debug("getpeername failed: %.100s", strerror(errno));
Damien Miller677257f2005-06-17 12:55:03 +1000364 return -1;
Damien Miller34132e52000-01-14 15:45:46 +1100365 }
Damien Miller95def091999-11-25 00:26:21 +1100366 }
Damien Miller5e4471e2003-01-07 10:51:23 +1100367
368 /* Work around Linux IPv6 weirdness */
369 if (from.ss_family == AF_INET6)
370 fromlen = sizeof(struct sockaddr_in6);
371
Damien Miller95def091999-11-25 00:26:21 +1100372 /* Return port number. */
Damien Miller9b8073e2005-03-01 21:16:18 +1100373 if ((r = getnameinfo((struct sockaddr *)&from, fromlen, NULL, 0,
374 strport, sizeof(strport), NI_NUMERICSERV)) != 0)
375 fatal("get_sock_port: getnameinfo NI_NUMERICSERV failed: %s",
Darren Tucker4abde772007-12-29 02:43:51 +1100376 ssh_gai_strerror(r));
Damien Miller34132e52000-01-14 15:45:46 +1100377 return atoi(strport);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000378}
379
Damien Miller34132e52000-01-14 15:45:46 +1100380/* Returns remote/local port number for the current connection. */
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000381
Ben Lindstrombba81212001-06-25 05:01:22 +0000382static int
Damien Miller34132e52000-01-14 15:45:46 +1100383get_port(int local)
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000384{
Damien Miller5428f641999-11-25 11:54:57 +1100385 /*
386 * If the connection is not a socket, return 65535. This is
387 * intentionally chosen to be an unprivileged port number.
388 */
Damien Miller34132e52000-01-14 15:45:46 +1100389 if (!packet_connection_is_on_socket())
Damien Miller95def091999-11-25 00:26:21 +1100390 return 65535;
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000391
Damien Miller34132e52000-01-14 15:45:46 +1100392 /* Get socket and return the port number. */
393 return get_sock_port(packet_get_connection_in(), local);
394}
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000395
Damien Miller4af51302000-04-16 11:18:38 +1000396int
Damien Miller34132e52000-01-14 15:45:46 +1100397get_peer_port(int sock)
398{
399 return get_sock_port(sock, 0);
400}
401
Damien Miller4af51302000-04-16 11:18:38 +1000402int
Ben Lindstrom3c36bb22001-12-06 17:55:26 +0000403get_remote_port(void)
Damien Miller34132e52000-01-14 15:45:46 +1100404{
Damien Miller0670c732004-07-21 21:53:34 +1000405 static int port = -1;
406
407 /* Cache to avoid getpeername() on a dead connection */
408 if (port == -1)
409 port = get_port(0);
410
411 return port;
Damien Miller34132e52000-01-14 15:45:46 +1100412}
413
414int
Ben Lindstrom3c36bb22001-12-06 17:55:26 +0000415get_local_port(void)
Damien Miller34132e52000-01-14 15:45:46 +1100416{
417 return get_port(1);
Damien Millerd4a8b7e1999-10-27 13:42:43 +1000418}