/* Licensed to the Apache Software Foundation (ASF) under one or more * contributor license agreements. See the NOTICE file distributed with * this work for additional information regarding copyright ownership. * The ASF licenses this file to You under the Apache License, Version 2.0 * (the "License"); you may not use this file except in compliance with * the License. You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ #include "apr_arch_networkio.h" #include "apr_strings.h" #include "apr.h" #include "apr_lib.h" #include "apr_strings.h" #include "apr_private.h" #if APR_HAVE_STDLIB_H #include #endif #ifdef HAVE_NET_IF_H #include #endif #if defined(HAVE_IF_INDEXTONAME) && defined(_MSC_VER) #include "arch/win32/apr_arch_misc.h" #endif #define APR_WANT_STRFUNC #include "apr_want.h" struct apr_ipsubnet_t { int family; #if APR_HAVE_IPV6 apr_uint32_t sub[4]; /* big enough for IPv4 and IPv6 addresses */ apr_uint32_t mask[4]; #else apr_uint32_t sub[1]; apr_uint32_t mask[1]; #endif }; #if !defined(NETWARE) && !defined(WIN32) #ifdef HAVE_SET_H_ERRNO #define SET_H_ERRNO(newval) set_h_errno(newval) #else #define SET_H_ERRNO(newval) h_errno = (newval) #endif #else #define SET_H_ERRNO(newval) #endif #if APR_HAS_THREADS && !defined(GETHOSTBYNAME_IS_THREAD_SAFE) && \ defined(HAVE_GETHOSTBYNAME_R) /* This is the maximum size that may be returned from the reentrant * gethostbyname_r function. If the system tries to use more, it * should return ERANGE. */ #define GETHOSTBYNAME_BUFLEN 512 #endif #ifdef _AIX /* Some levels of AIX getaddrinfo() don't like servname = "0", so * set servname to "1" when port is 0 and fix it up later. */ #define AIX_SERVNAME_HACK 1 #else #define AIX_SERVNAME_HACK 0 #endif #ifdef _WIN32_WCE /* XXX: BS solution. Need an HAVE_GETSERVBYNAME and actually * do something here, to provide the obvious proto mappings. */ static void *getservbyname(const char *name, const char *proto) { return NULL; } #endif static apr_status_t get_local_addr(apr_socket_t *sock) { sock->local_addr->salen = sizeof(sock->local_addr->sa); if (getsockname(sock->socketdes, (struct sockaddr *)&sock->local_addr->sa, &sock->local_addr->salen) < 0) { return apr_get_netos_error(); } else { sock->local_port_unknown = sock->local_interface_unknown = 0; /* XXX assumes sin_port and sin6_port at same offset */ sock->local_addr->port = ntohs(sock->local_addr->sa.sin.sin_port); return APR_SUCCESS; } } static apr_status_t get_remote_addr(apr_socket_t *sock) { sock->remote_addr->salen = sizeof(sock->remote_addr->sa); if (getpeername(sock->socketdes, (struct sockaddr *)&sock->remote_addr->sa, &sock->remote_addr->salen) < 0) { return apr_get_netos_error(); } else { sock->remote_addr_unknown = 0; /* XXX assumes sin_port and sin6_port at same offset */ sock->remote_addr->port = ntohs(sock->remote_addr->sa.sin.sin_port); return APR_SUCCESS; } } APR_DECLARE(apr_status_t) apr_sockaddr_ip_getbuf(char *buf, apr_size_t buflen, apr_sockaddr_t *sockaddr) { if (!apr_inet_ntop(sockaddr->family, sockaddr->ipaddr_ptr, buf, buflen)) { return APR_ENOSPC; } #if APR_HAVE_IPV6 if (sockaddr->family == AF_INET6 && IN6_IS_ADDR_V4MAPPED((struct in6_addr *)sockaddr->ipaddr_ptr) && buflen > strlen("::ffff:")) { /* This is an IPv4-mapped IPv6 address; drop the leading * part of the address string so we're left with the familiar * IPv4 format. */ memmove(buf, buf + strlen("::ffff:"), strlen(buf + strlen("::ffff:"))+1); } /* ensure NUL termination if the buffer is too short */ buf[buflen-1] = '\0'; #ifdef HAVE_IF_INDEXTONAME /* Append scope name for link-local addresses. */ if (sockaddr->family == AF_INET6 && IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)sockaddr->ipaddr_ptr)) { char scbuf[IF_NAMESIZE], *p = buf + strlen(buf); if (if_indextoname(sockaddr->sa.sin6.sin6_scope_id, scbuf) == scbuf) { /* Space check, need room for buf + '%' + scope + '\0'. * Assert: buflen >= strlen(buf) + strlen(scbuf) + 2 * Equiv: buflen >= (p-buf) + strlen(buf) + 2 * Thus, fail in inverse condition: */ if (buflen < strlen(scbuf) + (p - buf) + 2) { return APR_ENOSPC; } *p++ = '%'; memcpy(p, scbuf, strlen(scbuf) + 1); } } #endif /* HAVE_IF_INDEXTONAME */ #endif /* APR_HAVE_IPV6 */ return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_sockaddr_ip_get(char **addr, apr_sockaddr_t *sockaddr) { *addr = apr_palloc(sockaddr->pool, sockaddr->addr_str_len); return apr_sockaddr_ip_getbuf(*addr, sockaddr->addr_str_len, sockaddr); } void apr_sockaddr_vars_set(apr_sockaddr_t *addr, int family, apr_port_t port) { addr->family = family; addr->sa.sin.sin_family = family; if (port) { /* XXX IPv6: assumes sin_port and sin6_port at same offset */ addr->sa.sin.sin_port = htons(port); addr->port = port; } #if AIX_SERVNAME_HACK else { addr->sa.sin.sin_port = htons(port); } #endif if (family == APR_INET) { addr->salen = sizeof(struct sockaddr_in); addr->addr_str_len = 16; addr->ipaddr_ptr = &(addr->sa.sin.sin_addr); addr->ipaddr_len = sizeof(struct in_addr); } #if APR_HAVE_IPV6 else if (family == APR_INET6) { addr->salen = sizeof(struct sockaddr_in6); addr->addr_str_len = 46; addr->ipaddr_ptr = &(addr->sa.sin6.sin6_addr); addr->ipaddr_len = sizeof(struct in6_addr); } #endif #if APR_HAVE_SOCKADDR_UN else if (family == APR_UNIX) { addr->salen = sizeof(struct sockaddr_un); addr->addr_str_len = sizeof(addr->sa.unx.sun_path);; addr->ipaddr_ptr = &(addr->sa.unx.sun_path); addr->ipaddr_len = addr->addr_str_len; } #endif } APR_DECLARE(apr_status_t) apr_socket_addr_get(apr_sockaddr_t **sa, apr_interface_e which, apr_socket_t *sock) { if (which == APR_LOCAL) { if (sock->local_interface_unknown || sock->local_port_unknown) { apr_status_t rv = get_local_addr(sock); if (rv != APR_SUCCESS) { return rv; } } *sa = sock->local_addr; } else if (which == APR_REMOTE) { if (sock->remote_addr_unknown) { apr_status_t rv = get_remote_addr(sock); if (rv != APR_SUCCESS) { return rv; } } *sa = sock->remote_addr; } else { *sa = NULL; return APR_EINVAL; } return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_parse_addr_port(char **addr, char **scope_id, apr_port_t *port, const char *str, apr_pool_t *p) { const char *ch, *lastchar; int big_port; apr_size_t addrlen; *addr = NULL; /* assume not specified */ *scope_id = NULL; /* assume not specified */ *port = 0; /* assume not specified */ /* First handle the optional port number. That may be all that * is specified in the string. */ ch = lastchar = str + strlen(str) - 1; while (ch >= str && apr_isdigit(*ch)) { --ch; } if (ch < str) { /* Entire string is the port. */ big_port = atoi(str); if (big_port < 1 || big_port > 65535) { return APR_EINVAL; } *port = big_port; return APR_SUCCESS; } if (*ch == ':' && ch < lastchar) { /* host and port number specified */ if (ch == str) { /* string starts with ':' -- bad */ return APR_EINVAL; } big_port = atoi(ch + 1); if (big_port < 1 || big_port > 65535) { return APR_EINVAL; } *port = big_port; lastchar = ch - 1; } /* now handle the hostname */ addrlen = lastchar - str + 1; /* XXX we don't really have to require APR_HAVE_IPV6 for this; * just pass char[] for ipaddr (so we don't depend on struct in6_addr) * and always define APR_INET6 */ #if APR_HAVE_IPV6 if (*str == '[') { const char *end_bracket = memchr(str, ']', addrlen); struct in6_addr ipaddr; const char *scope_delim; if (!end_bracket || end_bracket != lastchar) { *port = 0; return APR_EINVAL; } /* handle scope id; this is the only context where it is allowed */ scope_delim = memchr(str, '%', addrlen); if (scope_delim) { if (scope_delim == end_bracket - 1) { /* '%' without scope id */ *port = 0; return APR_EINVAL; } addrlen = scope_delim - str - 1; *scope_id = apr_pstrmemdup(p, scope_delim + 1, end_bracket - scope_delim - 1); } else { addrlen = addrlen - 2; /* minus 2 for '[' and ']' */ } *addr = apr_pstrmemdup(p, str + 1, addrlen); if (apr_inet_pton(AF_INET6, *addr, &ipaddr) != 1) { *addr = NULL; *scope_id = NULL; *port = 0; return APR_EINVAL; } } else #endif { /* XXX If '%' is not a valid char in a DNS name, we *could* check * for bogus scope ids first. */ *addr = apr_pstrmemdup(p, str, addrlen); } return APR_SUCCESS; } #if defined(HAVE_GETADDRINFO) static apr_status_t call_resolver(apr_sockaddr_t **sa, const char *hostname, apr_int32_t family, apr_port_t port, apr_int32_t flags, apr_pool_t *p) { struct addrinfo hints, *ai, *ai_list; apr_sockaddr_t *prev_sa; int error; char *servname = NULL; memset(&hints, 0, sizeof(hints)); hints.ai_family = family; hints.ai_socktype = SOCK_STREAM; #ifdef HAVE_GAI_ADDRCONFIG if (family == APR_UNSPEC) { /* By default, only look up addresses using address types for * which a local interface is configured, i.e. no IPv6 if no * IPv6 interfaces configured. */ hints.ai_flags = AI_ADDRCONFIG; } #endif #ifdef __MVS__ /* z/OS will not return IPv4 address under AF_UNSPEC if any IPv6 results * are returned, w/o AI_ALL. */ if (family == APR_UNSPEC) { hints.ai_flags |= AI_ALL; } #endif if(hostname == NULL) { #ifdef AI_PASSIVE /* If hostname is NULL, assume we are trying to bind to all * interfaces. */ hints.ai_flags |= AI_PASSIVE; #endif /* getaddrinfo according to RFC 2553 must have either hostname * or servname non-NULL. */ #ifdef OSF1 /* The Tru64 5.0 getaddrinfo() can only resolve services given * by the name listed in /etc/services; a numeric or unknown * servname gets an EAI_SERVICE error. So just resolve the * appropriate anyaddr and fill in the port later. */ hostname = family == AF_INET6 ? "::" : "0.0.0.0"; servname = NULL; #ifdef AI_NUMERICHOST hints.ai_flags |= AI_NUMERICHOST; #endif #else #if AIX_SERVNAME_HACK if (!port) { servname = "1"; } else #endif /* AIX_SERVNAME_HACK */ servname = apr_itoa(p, port); #endif /* OSF1 */ } error = getaddrinfo(hostname, servname, &hints, &ai_list); #ifdef HAVE_GAI_ADDRCONFIG /* * Using AI_ADDRCONFIG involves some unfortunate guesswork because it * does not consider loopback addresses when trying to determine if * IPv4 or IPv6 is configured on a system (see RFC 3493). * This is a problem if one actually wants to listen on or connect to * the loopback address of a protocol family that is not otherwise * configured on the system. See PR 52709. * To work around some of the problems, retry without AI_ADDRCONFIG * in case of EAI_ADDRFAMILY. * XXX: apr_sockaddr_info_get() should really accept a flag to determine * XXX: if AI_ADDRCONFIG's guesswork is wanted and if the address is * XXX: to be used for listen() or connect(). * * In case of EAI_BADFLAGS, AI_ADDRCONFIG is not supported. */ if ((family == APR_UNSPEC) && (error == EAI_BADFLAGS #ifdef EAI_ADDRFAMILY || error == EAI_ADDRFAMILY #endif )) { hints.ai_flags &= ~AI_ADDRCONFIG; error = getaddrinfo(hostname, servname, &hints, &ai_list); } #endif if (error) { #if defined(WIN32) return apr_get_netos_error(); #else if (error == EAI_SYSTEM) { return errno ? errno : APR_EGENERAL; } else { /* issues with representing this with APR's error scheme: * glibc uses negative values for these numbers, perhaps so * they don't conflict with h_errno values... Tru64 uses * positive values which conflict with h_errno values */ #if defined(NEGATIVE_EAI) error = -error; #endif return error + APR_OS_START_EAIERR; } #endif /* WIN32 */ } prev_sa = NULL; ai = ai_list; while (ai) { /* while more addresses to report */ apr_sockaddr_t *new_sa; /* Ignore anything bogus: getaddrinfo in some old versions of * glibc will return AF_UNIX entries for APR_UNSPEC+AI_PASSIVE * lookups. */ #if APR_HAVE_IPV6 if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6) { #else if (ai->ai_family != AF_INET) { #endif ai = ai->ai_next; continue; } new_sa = apr_pcalloc(p, sizeof(apr_sockaddr_t)); new_sa->pool = p; memcpy(&new_sa->sa, ai->ai_addr, ai->ai_addrlen); apr_sockaddr_vars_set(new_sa, ai->ai_family, port); if (!prev_sa) { /* first element in new list */ if (hostname) { new_sa->hostname = apr_pstrdup(p, hostname); } *sa = new_sa; } else { new_sa->hostname = prev_sa->hostname; prev_sa->next = new_sa; } prev_sa = new_sa; ai = ai->ai_next; } freeaddrinfo(ai_list); if (prev_sa == NULL) { /* * getaddrinfo returned only useless entries and *sa is still empty. * This should be treated as an error. */ return APR_EGENERAL; } return APR_SUCCESS; } static apr_status_t find_addresses(apr_sockaddr_t **sa, const char *hostname, apr_int32_t family, apr_port_t port, apr_int32_t flags, apr_pool_t *p) { if (flags & APR_IPV4_ADDR_OK) { apr_status_t error = call_resolver(sa, hostname, AF_INET, port, flags, p); #if APR_HAVE_IPV6 if (error) { family = AF_INET6; /* try again */ } else #endif return error; } #if APR_HAVE_IPV6 else if (flags & APR_IPV6_ADDR_OK) { apr_status_t error = call_resolver(sa, hostname, AF_INET6, port, flags, p); if (error) { family = AF_INET; /* try again */ } else { return APR_SUCCESS; } } #endif return call_resolver(sa, hostname, family, port, flags, p); } #else /* end of HAVE_GETADDRINFO code */ static apr_status_t find_addresses(apr_sockaddr_t **sa, const char *hostname, apr_int32_t family, apr_port_t port, apr_int32_t flags, apr_pool_t *p) { struct hostent *hp; apr_sockaddr_t *prev_sa; int curaddr; #if APR_HAS_THREADS && !defined(GETHOSTBYNAME_IS_THREAD_SAFE) && \ defined(HAVE_GETHOSTBYNAME_R) && !defined(BEOS) #ifdef GETHOSTBYNAME_R_HOSTENT_DATA struct hostent_data hd; #else /* If you see ERANGE, that means GETHOSBYNAME_BUFLEN needs to be * bumped. */ char tmp[GETHOSTBYNAME_BUFLEN]; #endif int hosterror; #endif struct hostent hs; struct in_addr ipaddr; char *addr_list[2]; const char *orig_hostname = hostname; if (hostname == NULL) { /* if we are given a NULL hostname, assume '0.0.0.0' */ hostname = "0.0.0.0"; } if (*hostname >= '0' && *hostname <= '9' && strspn(hostname, "0123456789.") == strlen(hostname)) { ipaddr.s_addr = inet_addr(hostname); addr_list[0] = (char *)&ipaddr; addr_list[1] = NULL; /* just one IP in list */ hs.h_addr_list = (char **)addr_list; hp = &hs; } else { #if APR_HAS_THREADS && !defined(GETHOSTBYNAME_IS_THREAD_SAFE) && \ defined(HAVE_GETHOSTBYNAME_R) && !defined(BEOS) #if defined(GETHOSTBYNAME_R_HOSTENT_DATA) /* AIX, HP/UX, D/UX et alia */ gethostbyname_r(hostname, &hs, &hd); hp = &hs; #else #if defined(GETHOSTBYNAME_R_GLIBC2) /* Linux glibc2+ */ gethostbyname_r(hostname, &hs, tmp, GETHOSTBYNAME_BUFLEN - 1, &hp, &hosterror); #else /* Solaris, Irix et alia */ hp = gethostbyname_r(hostname, &hs, tmp, GETHOSTBYNAME_BUFLEN - 1, &hosterror); #endif /* !defined(GETHOSTBYNAME_R_GLIBC2) */ if (!hp) { return (hosterror + APR_OS_START_SYSERR); } #endif /* !defined(GETHOSTBYNAME_R_HOSTENT_DATA) */ #else hp = gethostbyname(hostname); #endif if (!hp) { #ifdef WIN32 return apr_get_netos_error(); #else return (h_errno + APR_OS_START_SYSERR); #endif } } prev_sa = NULL; curaddr = 0; while (hp->h_addr_list[curaddr]) { apr_sockaddr_t *new_sa = apr_pcalloc(p, sizeof(apr_sockaddr_t)); new_sa->pool = p; new_sa->sa.sin.sin_addr = *(struct in_addr *)hp->h_addr_list[curaddr]; apr_sockaddr_vars_set(new_sa, AF_INET, port); if (!prev_sa) { /* first element in new list */ if (orig_hostname) { new_sa->hostname = apr_pstrdup(p, orig_hostname); } *sa = new_sa; } else { new_sa->hostname = prev_sa->hostname; prev_sa->next = new_sa; } prev_sa = new_sa; ++curaddr; } if (prev_sa == NULL) { /* this should not happen but no result should be treated as error */ return APR_EGENERAL; } return APR_SUCCESS; } #endif /* end of !HAVE_GETADDRINFO code */ APR_DECLARE(apr_status_t) apr_sockaddr_info_get(apr_sockaddr_t **sa, const char *hostname, apr_int32_t family, apr_port_t port, apr_int32_t flags, apr_pool_t *p) { apr_int32_t masked; *sa = NULL; if ((masked = flags & (APR_IPV4_ADDR_OK | APR_IPV6_ADDR_OK))) { if (!hostname || family != APR_UNSPEC || masked == (APR_IPV4_ADDR_OK | APR_IPV6_ADDR_OK)) { return APR_EINVAL; } #if !APR_HAVE_IPV6 if (flags & APR_IPV6_ADDR_OK) { return APR_ENOTIMPL; } #endif } if (family == APR_UNSPEC && hostname && *hostname == '/') { family = APR_UNIX; } if (family == APR_UNIX) { #if APR_HAVE_SOCKADDR_UN if (hostname && *hostname == '/') { *sa = apr_pcalloc(p, sizeof(apr_sockaddr_t)); (*sa)->pool = p; apr_cpystrn((*sa)->sa.unx.sun_path, hostname, sizeof((*sa)->sa.unx.sun_path)); (*sa)->hostname = apr_pstrdup(p, hostname); (*sa)->family = APR_UNIX; (*sa)->sa.unx.sun_family = APR_UNIX; (*sa)->salen = sizeof(struct sockaddr_un); (*sa)->addr_str_len = sizeof((*sa)->sa.unx.sun_path); (*sa)->ipaddr_ptr = &((*sa)->sa.unx.sun_path); (*sa)->ipaddr_len = (*sa)->addr_str_len; return APR_SUCCESS; } else #endif { *sa = NULL; return APR_ENOTIMPL; } } #if !APR_HAVE_IPV6 /* What may happen is that APR is not IPv6-enabled, but we're still * going to call getaddrinfo(), so we have to tell the OS we only * want IPv4 addresses back since we won't know what to do with * IPv6 addresses. */ if (family == APR_UNSPEC) { family = APR_INET; } #endif return find_addresses(sa, hostname, family, port, flags, p); } APR_DECLARE(apr_status_t) apr_sockaddr_info_copy(apr_sockaddr_t **dst, const apr_sockaddr_t *src, apr_pool_t *p) { apr_sockaddr_t *d; const apr_sockaddr_t *s; for (*dst = d = NULL, s = src; s; s = s->next) { if (!d) { *dst = d = apr_pmemdup(p, s, sizeof *s); } else { d = d->next = apr_pmemdup(p, s, sizeof *s); } if (s->hostname) { if (s == src || s->hostname != src->hostname) { d->hostname = apr_pstrdup(p, s->hostname); } else { d->hostname = (*dst)->hostname; } } if (s->servname) { if (s == src || s->servname != src->servname) { d->servname = apr_pstrdup(p, s->servname); } else { d->servname = (*dst)->servname; } } d->pool = p; apr_sockaddr_vars_set(d, s->family, s->port); } return APR_SUCCESS; } APR_DECLARE(apr_status_t) apr_getnameinfo(char **hostname, apr_sockaddr_t *sockaddr, apr_int32_t flags) { #if defined(HAVE_GETNAMEINFO) int rc; #if defined(NI_MAXHOST) char tmphostname[NI_MAXHOST]; #else char tmphostname[256]; #endif /* don't know if it is portable for getnameinfo() to set h_errno; * clear it then see if it was set */ SET_H_ERRNO(0); /* default flags are NI_NAMREQD; otherwise, getnameinfo() will return * a numeric address string if it fails to resolve the host name; * that is *not* what we want here * * For IPv4-mapped IPv6 addresses, drop down to IPv4 before calling * getnameinfo() to avoid getnameinfo bugs (MacOS X, glibc). */ #if APR_HAVE_IPV6 if (sockaddr->family == AF_INET6 && IN6_IS_ADDR_V4MAPPED(&sockaddr->sa.sin6.sin6_addr)) { struct sockaddr_in tmpsa; tmpsa.sin_family = AF_INET; tmpsa.sin_port = 0; tmpsa.sin_addr.s_addr = ((apr_uint32_t *)sockaddr->ipaddr_ptr)[3]; #ifdef SIN6_LEN tmpsa.sin_len = sizeof(tmpsa); #endif rc = getnameinfo((const struct sockaddr *)&tmpsa, sizeof(tmpsa), tmphostname, sizeof(tmphostname), NULL, 0, flags != 0 ? flags : NI_NAMEREQD); } #if APR_HAVE_SOCKADDR_UN else if (sockaddr->family == APR_UNIX) { *hostname = sockaddr->hostname; return APR_SUCCESS; } #endif else #endif rc = getnameinfo((const struct sockaddr *)&sockaddr->sa, sockaddr->salen, tmphostname, sizeof(tmphostname), NULL, 0, flags != 0 ? flags : NI_NAMEREQD); if (rc != 0) { *hostname = NULL; #ifndef WIN32 /* something went wrong. Look at the EAI_ error code */ if (rc == EAI_SYSTEM) { /* EAI_SYSTEM System error returned in errno. */ /* IMHO, Implementations that set h_errno a simply broken. */ if (h_errno) { /* for broken implementations which set h_errno */ return h_errno + APR_OS_START_SYSERR; } else { /* "normal" case */ return errno + APR_OS_START_SYSERR; } } else #endif { #if defined(NEGATIVE_EAI) if (rc < 0) rc = -rc; #endif return rc + APR_OS_START_EAIERR; /* return the EAI_ error */ } } *hostname = sockaddr->hostname = apr_pstrdup(sockaddr->pool, tmphostname); return APR_SUCCESS; #else #if APR_HAS_THREADS && !defined(GETHOSTBYADDR_IS_THREAD_SAFE) && \ defined(HAVE_GETHOSTBYADDR_R) && !defined(BEOS) #ifdef GETHOSTBYNAME_R_HOSTENT_DATA struct hostent_data hd; #else char tmp[GETHOSTBYNAME_BUFLEN]; #endif int hosterror; struct hostent hs, *hptr; #if defined(GETHOSTBYNAME_R_HOSTENT_DATA) /* AIX, HP/UX, D/UX et alia */ gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr, sizeof(struct in_addr), AF_INET, &hs, &hd); hptr = &hs; #else #if defined(GETHOSTBYNAME_R_GLIBC2) /* Linux glibc2+ */ gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr, sizeof(struct in_addr), AF_INET, &hs, tmp, GETHOSTBYNAME_BUFLEN - 1, &hptr, &hosterror); #else /* Solaris, Irix et alia */ hptr = gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr, sizeof(struct in_addr), AF_INET, &hs, tmp, GETHOSTBYNAME_BUFLEN, &hosterror); #endif /* !defined(GETHOSTBYNAME_R_GLIBC2) */ if (!hptr) { *hostname = NULL; return hosterror + APR_OS_START_SYSERR; } #endif /* !defined(GETHOSTBYNAME_R_HOSTENT_DATA) */ #else struct hostent *hptr; hptr = gethostbyaddr((char *)&sockaddr->sa.sin.sin_addr, sizeof(struct in_addr), AF_INET); #endif if (hptr) { *hostname = sockaddr->hostname = apr_pstrdup(sockaddr->pool, hptr->h_name); return APR_SUCCESS; } *hostname = NULL; #if defined(WIN32) return apr_get_netos_error(); #elif defined(OS2) return h_errno; #else return h_errno + APR_OS_START_SYSERR; #endif #endif } APR_DECLARE(apr_status_t) apr_getservbyname(apr_sockaddr_t *sockaddr, const char *servname) { #if APR_HAS_THREADS && !defined(GETSERVBYNAME_IS_THREAD_SAFE) && \ defined(HAVE_GETSERVBYNAME_R) && \ (defined(GETSERVBYNAME_R_GLIBC2) || defined(GETSERVBYNAME_R_SOLARIS) || \ defined(GETSERVBYNAME_R_OSF1)) struct servent se; #if defined(GETSERVBYNAME_R_OSF1) struct servent_data sed; memset(&sed, 0, sizeof(sed)); /* must zero fill before use */ #else #if defined(GETSERVBYNAME_R_GLIBC2) struct servent *res; #endif char buf[1024]; #endif #else struct servent *se; #endif if (servname == NULL) return APR_EINVAL; #if APR_HAS_THREADS && !defined(GETSERVBYNAME_IS_THREAD_SAFE) && \ defined(HAVE_GETSERVBYNAME_R) && \ (defined(GETSERVBYNAME_R_GLIBC2) || defined(GETSERVBYNAME_R_SOLARIS) || \ defined(GETSERVBYNAME_R_OSF1)) #if defined(GETSERVBYNAME_R_GLIBC2) if (getservbyname_r(servname, NULL, &se, buf, sizeof(buf), &res) == 0 && res != NULL) { sockaddr->port = ntohs(res->s_port); sockaddr->servname = apr_pstrdup(sockaddr->pool, servname); sockaddr->sa.sin.sin_port = res->s_port; return APR_SUCCESS; } #elif defined(GETSERVBYNAME_R_SOLARIS) if (getservbyname_r(servname, NULL, &se, buf, sizeof(buf)) != NULL) { sockaddr->port = ntohs(se.s_port); sockaddr->servname = apr_pstrdup(sockaddr->pool, servname); sockaddr->sa.sin.sin_port = se.s_port; return APR_SUCCESS; } #elif defined(GETSERVBYNAME_R_OSF1) if (getservbyname_r(servname, NULL, &se, &sed) == 0) { sockaddr->port = ntohs(se.s_port); sockaddr->servname = apr_pstrdup(sockaddr->pool, servname); sockaddr->sa.sin.sin_port = se.s_port; return APR_SUCCESS; } #endif #else if ((se = getservbyname(servname, NULL)) != NULL){ sockaddr->port = ntohs(se->s_port); sockaddr->servname = apr_pstrdup(sockaddr->pool, servname); sockaddr->sa.sin.sin_port = se->s_port; return APR_SUCCESS; } #endif return APR_ENOENT; } #define V4MAPPED_EQUAL(a,b) \ ((a)->sa.sin.sin_family == AF_INET && \ (b)->sa.sin.sin_family == AF_INET6 && \ IN6_IS_ADDR_V4MAPPED((struct in6_addr *)(b)->ipaddr_ptr) && \ !memcmp((a)->ipaddr_ptr, \ &((struct in6_addr *)(b)->ipaddr_ptr)->s6_addr[12], \ (a)->ipaddr_len)) #if APR_HAVE_IPV6 #define SCOPE_OR_ZERO(sa_) ((sa_)->family != AF_INET6 ? 0 : \ ((sa_)->sa.sin6.sin6_scope_id)) #else #define SCOPE_OR_ZERO(sa_) (0) #endif APR_DECLARE(int) apr_sockaddr_equal(const apr_sockaddr_t *addr1, const apr_sockaddr_t *addr2) { if (addr1->ipaddr_len == addr2->ipaddr_len && !memcmp(addr1->ipaddr_ptr, addr2->ipaddr_ptr, addr1->ipaddr_len) && SCOPE_OR_ZERO(addr1) == SCOPE_OR_ZERO(addr2)) { return 1; } #if APR_HAVE_IPV6 if (V4MAPPED_EQUAL(addr1, addr2)) { return 1; } if (V4MAPPED_EQUAL(addr2, addr1)) { return 1; } #endif return 0; /* not equal */ } APR_DECLARE(int) apr_sockaddr_is_wildcard(const apr_sockaddr_t *addr) { static const char inaddr_any[ #if APR_HAVE_IPV6 sizeof(struct in6_addr) #else sizeof(struct in_addr) #endif ] = {0}; if (addr->ipaddr_ptr /* IP address initialized */ && addr->ipaddr_len <= sizeof inaddr_any) { /* else bug elsewhere? */ if (!memcmp(inaddr_any, addr->ipaddr_ptr, addr->ipaddr_len)) { return 1; } #if APR_HAVE_IPV6 if (addr->family == AF_INET6 && IN6_IS_ADDR_V4MAPPED((struct in6_addr *)addr->ipaddr_ptr)) { struct in_addr *v4 = (struct in_addr *)&((apr_uint32_t *)addr->ipaddr_ptr)[3]; if (!memcmp(inaddr_any, v4, sizeof *v4)) { return 1; } } #endif } return 0; } static apr_status_t parse_network(apr_ipsubnet_t *ipsub, const char *network) { /* legacy syntax for ip addrs: a.b.c. ==> a.b.c.0/24 for example */ int shift; char *s, *t; int octet; char buf[sizeof "255.255.255.255"]; if (strlen(network) < sizeof buf) { strcpy(buf, network); } else { return APR_EBADIP; } /* parse components */ s = buf; ipsub->sub[0] = 0; ipsub->mask[0] = 0; shift = 24; while (*s) { t = s; if (!apr_isdigit(*t)) { return APR_EBADIP; } while (apr_isdigit(*t)) { ++t; } if (*t == '.') { *t++ = 0; } else if (*t) { return APR_EBADIP; } if (shift < 0) { return APR_EBADIP; } octet = atoi(s); if (octet < 0 || octet > 255) { return APR_EBADIP; } ipsub->sub[0] |= octet << shift; ipsub->mask[0] |= 0xFFUL << shift; s = t; shift -= 8; } ipsub->sub[0] = ntohl(ipsub->sub[0]); ipsub->mask[0] = ntohl(ipsub->mask[0]); ipsub->family = AF_INET; return APR_SUCCESS; } /* return values: * APR_EINVAL not an IP address; caller should see if it is something else * APR_BADIP IP address portion is is not valid * APR_BADMASK mask portion is not valid */ static apr_status_t parse_ip(apr_ipsubnet_t *ipsub, const char *ipstr, int network_allowed) { /* supported flavors of IP: * * . IPv6 numeric address string (e.g., "fe80::1") * * IMPORTANT: Don't store IPv4-mapped IPv6 address as an IPv6 address. * * . IPv4 numeric address string (e.g., "127.0.0.1") * * . IPv4 network string (e.g., "9.67") * * IMPORTANT: This network form is only allowed if network_allowed is on. */ int rc; #if APR_HAVE_IPV6 rc = apr_inet_pton(AF_INET6, ipstr, ipsub->sub); if (rc == 1) { if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ipsub->sub)) { /* apr_ipsubnet_test() assumes that we don't create IPv4-mapped IPv6 * addresses; this of course forces the user to specify IPv4 addresses * in a.b.c.d style instead of ::ffff:a.b.c.d style. */ return APR_EBADIP; } ipsub->family = AF_INET6; } else #endif { rc = apr_inet_pton(AF_INET, ipstr, ipsub->sub); if (rc == 1) { ipsub->family = AF_INET; } } if (rc != 1) { if (network_allowed) { return parse_network(ipsub, ipstr); } else { return APR_EBADIP; } } return APR_SUCCESS; } static int looks_like_ip(const char *ipstr) { if (strlen(ipstr) == 0) { return 0; } if (strchr(ipstr, ':')) { /* definitely not a hostname; assume it is intended to be an IPv6 address */ return 1; } /* simple IPv4 address string check */ while ((*ipstr == '.') || apr_isdigit(*ipstr)) ipstr++; return (*ipstr == '\0'); } static void fix_subnet(apr_ipsubnet_t *ipsub) { /* in case caller specified more bits in network address than are * valid according to the mask, turn off the extra bits */ int i; for (i = 0; i < sizeof ipsub->mask / sizeof(apr_int32_t); i++) { ipsub->sub[i] &= ipsub->mask[i]; } } /* be sure not to store any IPv4 address as a v4-mapped IPv6 address */ APR_DECLARE(apr_status_t) apr_ipsubnet_create(apr_ipsubnet_t **ipsub, const char *ipstr, const char *mask_or_numbits, apr_pool_t *p) { apr_status_t rv; char *endptr; long bits, maxbits = 32; /* filter out stuff which doesn't look remotely like an IP address; this helps * callers like mod_access which have a syntax allowing hostname or IP address; * APR_EINVAL tells the caller that it was probably not intended to be an IP * address */ if (!looks_like_ip(ipstr)) { return APR_EINVAL; } *ipsub = apr_pcalloc(p, sizeof(apr_ipsubnet_t)); /* assume ipstr is an individual IP address, not a subnet */ memset((*ipsub)->mask, 0xFF, sizeof (*ipsub)->mask); rv = parse_ip(*ipsub, ipstr, mask_or_numbits == NULL); if (rv != APR_SUCCESS) { return rv; } if (mask_or_numbits) { #if APR_HAVE_IPV6 if ((*ipsub)->family == AF_INET6) { maxbits = 128; } #endif bits = strtol(mask_or_numbits, &endptr, 10); if (*endptr == '\0' && bits > 0 && bits <= maxbits) { /* valid num-bits string; fill in mask appropriately */ int cur_entry = 0; apr_int32_t cur_bit_value; memset((*ipsub)->mask, 0, sizeof (*ipsub)->mask); while (bits > 32) { (*ipsub)->mask[cur_entry] = 0xFFFFFFFF; /* all 32 bits */ bits -= 32; ++cur_entry; } cur_bit_value = 0x80000000; while (bits) { (*ipsub)->mask[cur_entry] |= cur_bit_value; --bits; cur_bit_value /= 2; } (*ipsub)->mask[cur_entry] = htonl((*ipsub)->mask[cur_entry]); } else if (apr_inet_pton(AF_INET, mask_or_numbits, (*ipsub)->mask) == 1 && (*ipsub)->family == AF_INET) { /* valid IPv4 netmask */ } else { return APR_EBADMASK; } } fix_subnet(*ipsub); return APR_SUCCESS; } APR_DECLARE(int) apr_ipsubnet_test(apr_ipsubnet_t *ipsub, apr_sockaddr_t *sa) { #if APR_HAVE_IPV6 /* XXX This line will segv on Win32 build with APR_HAVE_IPV6, * but without the IPV6 drivers installed. */ if (sa->family == AF_INET) { if (ipsub->family == AF_INET && ((sa->sa.sin.sin_addr.s_addr & ipsub->mask[0]) == ipsub->sub[0])) { return 1; } } else if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)sa->ipaddr_ptr)) { if (ipsub->family == AF_INET && (((apr_uint32_t *)sa->ipaddr_ptr)[3] & ipsub->mask[0]) == ipsub->sub[0]) { return 1; } } else if (sa->family == AF_INET6 && ipsub->family == AF_INET6) { apr_uint32_t *addr = (apr_uint32_t *)sa->ipaddr_ptr; if ((addr[0] & ipsub->mask[0]) == ipsub->sub[0] && (addr[1] & ipsub->mask[1]) == ipsub->sub[1] && (addr[2] & ipsub->mask[2]) == ipsub->sub[2] && (addr[3] & ipsub->mask[3]) == ipsub->sub[3]) { return 1; } } #else if ((sa->sa.sin.sin_addr.s_addr & ipsub->mask[0]) == ipsub->sub[0]) { return 1; } #endif /* APR_HAVE_IPV6 */ return 0; /* no match */ } APR_DECLARE(apr_status_t) apr_sockaddr_zone_set(apr_sockaddr_t *sa, const char *zone_id) { #if !APR_HAVE_IPV6 || !defined(HAVE_IF_NAMETOINDEX) return APR_ENOTIMPL; #else unsigned int idx; if (sa->family != APR_INET6 || !IN6_IS_ADDR_LINKLOCAL((struct in6_addr *)sa->ipaddr_ptr)) { return APR_EBADIP; } idx = if_nametoindex(zone_id); if (idx) { sa->sa.sin6.sin6_scope_id = idx; return APR_SUCCESS; } if (errno != ENODEV) { return errno; } else { char *endptr; apr_int64_t i = apr_strtoi64(zone_id, &endptr, 10); if (*endptr != '\0' || errno || i < 1 || i > APR_INT16_MAX) { return APR_EGENERAL; } sa->sa.sin6.sin6_scope_id = (unsigned int) i; return APR_SUCCESS; } #endif } APR_DECLARE(apr_status_t) apr_sockaddr_zone_get(const apr_sockaddr_t *sa, const char **name, apr_uint32_t *id, apr_pool_t *p) { #if !APR_HAVE_IPV6 || !defined(HAVE_IF_INDEXTONAME) return APR_ENOTIMPL; #else if (sa->family != APR_INET6 || !sa->sa.sin6.sin6_scope_id) { return APR_EBADIP; } if (name) { char *buf = apr_palloc(p, IF_NAMESIZE); if (if_indextoname(sa->sa.sin6.sin6_scope_id, buf) == NULL) return errno; *name = buf; } if (id) *id = sa->sa.sin6.sin6_scope_id; return APR_SUCCESS; #endif }