#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 <stdlib.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];
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)
#define GETHOSTBYNAME_BUFLEN 512
#endif
#ifdef _AIX
#define AIX_SERVNAME_HACK 1
#else
#define AIX_SERVNAME_HACK 0
#endif
#ifdef _WIN32_WCE
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;
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;
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:")) {
memmove(buf, buf + strlen("::ffff:"),
strlen(buf + strlen("::ffff:"))+1);
}
#endif
buf[buflen-1] = '\0';
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) {
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
}
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;
*scope_id = NULL;
*port = 0;
ch = lastchar = str + strlen(str) - 1;
while (ch >= str && apr_isdigit(*ch)) {
--ch;
}
if (ch < str) {
big_port = atoi(str);
if (big_port < 1 || big_port > 65535) {
return APR_EINVAL;
}
*port = big_port;
return APR_SUCCESS;
}
if (*ch == ':' && ch < lastchar) {
if (ch == str) {
return APR_EINVAL;
}
big_port = atoi(ch + 1);
if (big_port < 1 || big_port > 65535) {
return APR_EINVAL;
}
*port = big_port;
lastchar = ch - 1;
}
addrlen = lastchar - str + 1;
#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;
}
scope_delim = memchr(str, '%', addrlen);
if (scope_delim) {
if (scope_delim == end_bracket - 1) {
*port = 0;
return APR_EINVAL;
}
addrlen = scope_delim - str - 1;
*scope_id = apr_palloc(p, end_bracket - scope_delim);
memcpy(*scope_id, scope_delim + 1, end_bracket - scope_delim - 1);
(*scope_id)[end_bracket - scope_delim - 1] = '\0';
}
else {
addrlen = addrlen - 2;
}
*addr = apr_palloc(p, addrlen + 1);
memcpy(*addr,
str + 1,
addrlen);
(*addr)[addrlen] = '\0';
if (apr_inet_pton(AF_INET6, *addr, &ipaddr) != 1) {
*addr = NULL;
*scope_id = NULL;
*port = 0;
return APR_EINVAL;
}
}
else
#endif
{
*addr = apr_palloc(p, addrlen + 1);
memcpy(*addr, str, addrlen);
(*addr)[addrlen] = '\0';
}
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) {
hints.ai_flags = AI_ADDRCONFIG;
}
#endif
if(hostname == NULL) {
#ifdef AI_PASSIVE
hints.ai_flags |= AI_PASSIVE;
#endif
#ifdef OSF1
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
servname = apr_itoa(p, port);
#endif
}
error = getaddrinfo(hostname, servname, &hints, &ai_list);
#ifdef HAVE_GAI_ADDRCONFIG
if (error == EAI_BADFLAGS && family == APR_UNSPEC) {
hints.ai_flags = 0;
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;
}
else
{
#if defined(NEGATIVE_EAI)
error = -error;
#endif
return error + APR_OS_START_EAIERR;
}
#endif
}
prev_sa = NULL;
ai = ai_list;
while (ai) {
apr_sockaddr_t *new_sa;
#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) {
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);
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;
}
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;
}
else {
return APR_SUCCESS;
}
}
#endif
return call_resolver(sa, hostname, family, port, flags, p);
}
#else
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
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) {
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;
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)
gethostbyname_r(hostname, &hs, &hd);
hp = &hs;
#else
#if defined(GETHOSTBYNAME_R_GLIBC2)
gethostbyname_r(hostname, &hs, tmp, GETHOSTBYNAME_BUFLEN - 1,
&hp, &hosterror);
#else
hp = gethostbyname_r(hostname, &hs, tmp, GETHOSTBYNAME_BUFLEN - 1,
&hosterror);
#endif
if (!hp) {
return (hosterror + APR_OS_START_SYSERR);
}
#endif
#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) {
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;
}
return APR_SUCCESS;
}
#endif
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 !APR_HAVE_IPV6
if (family == APR_UNSPEC) {
family = APR_INET;
}
#endif
return find_addresses(sa, hostname, family, port, flags, p);
}
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
SET_H_ERRNO(0);
#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);
}
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
if (rc == EAI_SYSTEM) {
if (h_errno) {
return h_errno + APR_OS_START_SYSERR;
}
else {
return errno + APR_OS_START_SYSERR;
}
}
else
#endif
{
#if defined(NEGATIVE_EAI)
if (rc < 0) rc = -rc;
#endif
return rc + APR_OS_START_EAIERR;
}
}
*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)
gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr,
sizeof(struct in_addr), AF_INET, &hs, &hd);
hptr = &hs;
#else
#if defined(GETHOSTBYNAME_R_GLIBC2)
gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr,
sizeof(struct in_addr), AF_INET,
&hs, tmp, GETHOSTBYNAME_BUFLEN - 1, &hptr, &hosterror);
#else
hptr = gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr,
sizeof(struct in_addr), AF_INET,
&hs, tmp, GETHOSTBYNAME_BUFLEN, &hosterror);
#endif
if (!hptr) {
*hostname = NULL;
return hosterror + APR_OS_START_SYSERR;
}
#endif
#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));
#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))
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)) {
return 1;
}
#if APR_HAVE_IPV6
if (V4MAPPED_EQUAL(addr1, addr2)) {
return 1;
}
if (V4MAPPED_EQUAL(addr2, addr1)) {
return 1;
}
#endif
return 0;
}
static apr_status_t parse_network(apr_ipsubnet_t *ipsub, const char *network)
{
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;
}
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;
}
static apr_status_t parse_ip(apr_ipsubnet_t *ipsub, const char *ipstr, int network_allowed)
{
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)) {
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 (strchr(ipstr, ':')) {
return 1;
}
while ((*ipstr == '.') || apr_isdigit(*ipstr))
ipstr++;
return (*ipstr == '\0');
}
static void fix_subnet(apr_ipsubnet_t *ipsub)
{
int i;
for (i = 0; i < sizeof ipsub->mask / sizeof(apr_int32_t); i++) {
ipsub->sub[i] &= ipsub->mask[i];
}
}
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;
if (!looks_like_ip(ipstr)) {
return APR_EINVAL;
}
*ipsub = apr_pcalloc(p, sizeof(apr_ipsubnet_t));
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) {
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;
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) {
}
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
if (sa->sa.sin.sin_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 {
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
return 0;
}