sockaddr.c revision 251886
1/* Licensed to the Apache Software Foundation (ASF) under one or more
2 * contributor license agreements.  See the NOTICE file distributed with
3 * this work for additional information regarding copyright ownership.
4 * The ASF licenses this file to You under the Apache License, Version 2.0
5 * (the "License"); you may not use this file except in compliance with
6 * the License.  You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include "apr_arch_networkio.h"
18#include "apr_strings.h"
19#include "apr.h"
20#include "apr_lib.h"
21#include "apr_strings.h"
22#include "apr_private.h"
23
24#if APR_HAVE_STDLIB_H
25#include <stdlib.h>
26#endif
27
28#define APR_WANT_STRFUNC
29#include "apr_want.h"
30
31struct apr_ipsubnet_t {
32    int family;
33#if APR_HAVE_IPV6
34    apr_uint32_t sub[4]; /* big enough for IPv4 and IPv6 addresses */
35    apr_uint32_t mask[4];
36#else
37    apr_uint32_t sub[1];
38    apr_uint32_t mask[1];
39#endif
40};
41
42#if !defined(NETWARE) && !defined(WIN32)
43#ifdef HAVE_SET_H_ERRNO
44#define SET_H_ERRNO(newval) set_h_errno(newval)
45#else
46#define SET_H_ERRNO(newval) h_errno = (newval)
47#endif
48#else
49#define SET_H_ERRNO(newval)
50#endif
51
52#if APR_HAS_THREADS && !defined(GETHOSTBYNAME_IS_THREAD_SAFE) && \
53    defined(HAVE_GETHOSTBYNAME_R)
54/* This is the maximum size that may be returned from the reentrant
55 * gethostbyname_r function.  If the system tries to use more, it
56 * should return ERANGE.
57 */
58#define GETHOSTBYNAME_BUFLEN 512
59#endif
60
61#ifdef _AIX
62/* Some levels of AIX getaddrinfo() don't like servname = "0", so
63 * set servname to "1" when port is 0 and fix it up later.
64 */
65#define AIX_SERVNAME_HACK 1
66#else
67#define AIX_SERVNAME_HACK 0
68#endif
69
70#ifdef _WIN32_WCE
71/* XXX: BS solution.  Need an HAVE_GETSERVBYNAME and actually
72 * do something here, to provide the obvious proto mappings.
73 */
74static void *getservbyname(const char *name, const char *proto)
75{
76    return NULL;
77}
78#endif
79
80static apr_status_t get_local_addr(apr_socket_t *sock)
81{
82    sock->local_addr->salen = sizeof(sock->local_addr->sa);
83    if (getsockname(sock->socketdes, (struct sockaddr *)&sock->local_addr->sa,
84                    &sock->local_addr->salen) < 0) {
85        return apr_get_netos_error();
86    }
87    else {
88        sock->local_port_unknown = sock->local_interface_unknown = 0;
89        /* XXX assumes sin_port and sin6_port at same offset */
90        sock->local_addr->port = ntohs(sock->local_addr->sa.sin.sin_port);
91        return APR_SUCCESS;
92    }
93}
94
95static apr_status_t get_remote_addr(apr_socket_t *sock)
96{
97    sock->remote_addr->salen = sizeof(sock->remote_addr->sa);
98    if (getpeername(sock->socketdes, (struct sockaddr *)&sock->remote_addr->sa,
99                    &sock->remote_addr->salen) < 0) {
100        return apr_get_netos_error();
101    }
102    else {
103        sock->remote_addr_unknown = 0;
104        /* XXX assumes sin_port and sin6_port at same offset */
105        sock->remote_addr->port = ntohs(sock->remote_addr->sa.sin.sin_port);
106        return APR_SUCCESS;
107    }
108}
109
110APR_DECLARE(apr_status_t) apr_sockaddr_ip_getbuf(char *buf, apr_size_t buflen,
111                                                 apr_sockaddr_t *sockaddr)
112{
113    if (!apr_inet_ntop(sockaddr->family, sockaddr->ipaddr_ptr, buf, buflen)) {
114        return APR_ENOSPC;
115    }
116
117#if APR_HAVE_IPV6
118    if (sockaddr->family == AF_INET6
119        && IN6_IS_ADDR_V4MAPPED((struct in6_addr *)sockaddr->ipaddr_ptr)
120        && buflen > strlen("::ffff:")) {
121        /* This is an IPv4-mapped IPv6 address; drop the leading
122         * part of the address string so we're left with the familiar
123         * IPv4 format.
124         */
125        memmove(buf, buf + strlen("::ffff:"),
126                strlen(buf + strlen("::ffff:"))+1);
127    }
128#endif
129    /* ensure NUL termination if the buffer is too short */
130    buf[buflen-1] = '\0';
131    return APR_SUCCESS;
132}
133
134APR_DECLARE(apr_status_t) apr_sockaddr_ip_get(char **addr,
135                                              apr_sockaddr_t *sockaddr)
136{
137    *addr = apr_palloc(sockaddr->pool, sockaddr->addr_str_len);
138    return apr_sockaddr_ip_getbuf(*addr, sockaddr->addr_str_len, sockaddr);
139}
140
141void apr_sockaddr_vars_set(apr_sockaddr_t *addr, int family, apr_port_t port)
142{
143    addr->family = family;
144    addr->sa.sin.sin_family = family;
145    if (port) {
146        /* XXX IPv6: assumes sin_port and sin6_port at same offset */
147        addr->sa.sin.sin_port = htons(port);
148        addr->port = port;
149    }
150#if AIX_SERVNAME_HACK
151    else {
152        addr->sa.sin.sin_port = htons(port);
153    }
154#endif
155
156    if (family == APR_INET) {
157        addr->salen = sizeof(struct sockaddr_in);
158        addr->addr_str_len = 16;
159        addr->ipaddr_ptr = &(addr->sa.sin.sin_addr);
160        addr->ipaddr_len = sizeof(struct in_addr);
161    }
162#if APR_HAVE_IPV6
163    else if (family == APR_INET6) {
164        addr->salen = sizeof(struct sockaddr_in6);
165        addr->addr_str_len = 46;
166        addr->ipaddr_ptr = &(addr->sa.sin6.sin6_addr);
167        addr->ipaddr_len = sizeof(struct in6_addr);
168    }
169#endif
170}
171
172APR_DECLARE(apr_status_t) apr_socket_addr_get(apr_sockaddr_t **sa,
173                                           apr_interface_e which,
174                                           apr_socket_t *sock)
175{
176    if (which == APR_LOCAL) {
177        if (sock->local_interface_unknown || sock->local_port_unknown) {
178            apr_status_t rv = get_local_addr(sock);
179
180            if (rv != APR_SUCCESS) {
181                return rv;
182            }
183        }
184        *sa = sock->local_addr;
185    }
186    else if (which == APR_REMOTE) {
187        if (sock->remote_addr_unknown) {
188            apr_status_t rv = get_remote_addr(sock);
189
190            if (rv != APR_SUCCESS) {
191                return rv;
192            }
193        }
194        *sa = sock->remote_addr;
195    }
196    else {
197        *sa = NULL;
198        return APR_EINVAL;
199    }
200    return APR_SUCCESS;
201}
202
203APR_DECLARE(apr_status_t) apr_parse_addr_port(char **addr,
204                                              char **scope_id,
205                                              apr_port_t *port,
206                                              const char *str,
207                                              apr_pool_t *p)
208{
209    const char *ch, *lastchar;
210    int big_port;
211    apr_size_t addrlen;
212
213    *addr = NULL;         /* assume not specified */
214    *scope_id = NULL;     /* assume not specified */
215    *port = 0;            /* assume not specified */
216
217    /* First handle the optional port number.  That may be all that
218     * is specified in the string.
219     */
220    ch = lastchar = str + strlen(str) - 1;
221    while (ch >= str && apr_isdigit(*ch)) {
222        --ch;
223    }
224
225    if (ch < str) {       /* Entire string is the port. */
226        big_port = atoi(str);
227        if (big_port < 1 || big_port > 65535) {
228            return APR_EINVAL;
229        }
230        *port = big_port;
231        return APR_SUCCESS;
232    }
233
234    if (*ch == ':' && ch < lastchar) { /* host and port number specified */
235        if (ch == str) {               /* string starts with ':' -- bad */
236            return APR_EINVAL;
237        }
238        big_port = atoi(ch + 1);
239        if (big_port < 1 || big_port > 65535) {
240            return APR_EINVAL;
241        }
242        *port = big_port;
243        lastchar = ch - 1;
244    }
245
246    /* now handle the hostname */
247    addrlen = lastchar - str + 1;
248
249/* XXX we don't really have to require APR_HAVE_IPV6 for this;
250 * just pass char[] for ipaddr (so we don't depend on struct in6_addr)
251 * and always define APR_INET6
252 */
253#if APR_HAVE_IPV6
254    if (*str == '[') {
255        const char *end_bracket = memchr(str, ']', addrlen);
256        struct in6_addr ipaddr;
257        const char *scope_delim;
258
259        if (!end_bracket || end_bracket != lastchar) {
260            *port = 0;
261            return APR_EINVAL;
262        }
263
264        /* handle scope id; this is the only context where it is allowed */
265        scope_delim = memchr(str, '%', addrlen);
266        if (scope_delim) {
267            if (scope_delim == end_bracket - 1) { /* '%' without scope id */
268                *port = 0;
269                return APR_EINVAL;
270            }
271            addrlen = scope_delim - str - 1;
272            *scope_id = apr_palloc(p, end_bracket - scope_delim);
273            memcpy(*scope_id, scope_delim + 1, end_bracket - scope_delim - 1);
274            (*scope_id)[end_bracket - scope_delim - 1] = '\0';
275        }
276        else {
277            addrlen = addrlen - 2; /* minus 2 for '[' and ']' */
278        }
279
280        *addr = apr_palloc(p, addrlen + 1);
281        memcpy(*addr,
282               str + 1,
283               addrlen);
284        (*addr)[addrlen] = '\0';
285        if (apr_inet_pton(AF_INET6, *addr, &ipaddr) != 1) {
286            *addr = NULL;
287            *scope_id = NULL;
288            *port = 0;
289            return APR_EINVAL;
290        }
291    }
292    else
293#endif
294    {
295        /* XXX If '%' is not a valid char in a DNS name, we *could* check
296         *     for bogus scope ids first.
297         */
298        *addr = apr_palloc(p, addrlen + 1);
299        memcpy(*addr, str, addrlen);
300        (*addr)[addrlen] = '\0';
301    }
302    return APR_SUCCESS;
303}
304
305#if defined(HAVE_GETADDRINFO)
306
307static apr_status_t call_resolver(apr_sockaddr_t **sa,
308                                  const char *hostname, apr_int32_t family,
309                                  apr_port_t port, apr_int32_t flags,
310                                  apr_pool_t *p)
311{
312    struct addrinfo hints, *ai, *ai_list;
313    apr_sockaddr_t *prev_sa;
314    int error;
315    char *servname = NULL;
316
317    memset(&hints, 0, sizeof(hints));
318    hints.ai_family = family;
319    hints.ai_socktype = SOCK_STREAM;
320#ifdef HAVE_GAI_ADDRCONFIG
321    if (family == APR_UNSPEC) {
322        /* By default, only look up addresses using address types for
323         * which a local interface is configured, i.e. no IPv6 if no
324         * IPv6 interfaces configured. */
325        hints.ai_flags = AI_ADDRCONFIG;
326    }
327#endif
328    if(hostname == NULL) {
329#ifdef AI_PASSIVE
330        /* If hostname is NULL, assume we are trying to bind to all
331         * interfaces. */
332        hints.ai_flags |= AI_PASSIVE;
333#endif
334        /* getaddrinfo according to RFC 2553 must have either hostname
335         * or servname non-NULL.
336         */
337#ifdef OSF1
338        /* The Tru64 5.0 getaddrinfo() can only resolve services given
339         * by the name listed in /etc/services; a numeric or unknown
340         * servname gets an EAI_SERVICE error.  So just resolve the
341         * appropriate anyaddr and fill in the port later. */
342        hostname = family == AF_INET6 ? "::" : "0.0.0.0";
343        servname = NULL;
344#ifdef AI_NUMERICHOST
345        hints.ai_flags |= AI_NUMERICHOST;
346#endif
347#else
348#if AIX_SERVNAME_HACK
349        if (!port) {
350            servname = "1";
351        }
352        else
353#endif /* AIX_SERVNAME_HACK */
354        servname = apr_itoa(p, port);
355#endif /* OSF1 */
356    }
357    error = getaddrinfo(hostname, servname, &hints, &ai_list);
358#ifdef HAVE_GAI_ADDRCONFIG
359    if (error == EAI_BADFLAGS && family == APR_UNSPEC) {
360        /* Retry with no flags if AI_ADDRCONFIG was rejected. */
361        hints.ai_flags = 0;
362        error = getaddrinfo(hostname, servname, &hints, &ai_list);
363    }
364#endif
365    if (error) {
366#if defined(WIN32)
367        return apr_get_netos_error();
368#else
369        if (error == EAI_SYSTEM) {
370            return errno;
371        }
372        else
373        {
374            /* issues with representing this with APR's error scheme:
375             * glibc uses negative values for these numbers, perhaps so
376             * they don't conflict with h_errno values...  Tru64 uses
377             * positive values which conflict with h_errno values
378             */
379#if defined(NEGATIVE_EAI)
380            error = -error;
381#endif
382            return error + APR_OS_START_EAIERR;
383        }
384#endif /* WIN32 */
385    }
386
387    prev_sa = NULL;
388    ai = ai_list;
389    while (ai) { /* while more addresses to report */
390        apr_sockaddr_t *new_sa;
391
392        /* Ignore anything bogus: getaddrinfo in some old versions of
393         * glibc will return AF_UNIX entries for APR_UNSPEC+AI_PASSIVE
394         * lookups. */
395#if APR_HAVE_IPV6
396        if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6) {
397#else
398        if (ai->ai_family != AF_INET) {
399#endif
400            ai = ai->ai_next;
401            continue;
402        }
403
404        new_sa = apr_pcalloc(p, sizeof(apr_sockaddr_t));
405
406        new_sa->pool = p;
407        memcpy(&new_sa->sa, ai->ai_addr, ai->ai_addrlen);
408        apr_sockaddr_vars_set(new_sa, ai->ai_family, port);
409
410        if (!prev_sa) { /* first element in new list */
411            if (hostname) {
412                new_sa->hostname = apr_pstrdup(p, hostname);
413            }
414            *sa = new_sa;
415        }
416        else {
417            new_sa->hostname = prev_sa->hostname;
418            prev_sa->next = new_sa;
419        }
420
421        prev_sa = new_sa;
422        ai = ai->ai_next;
423    }
424    freeaddrinfo(ai_list);
425    return APR_SUCCESS;
426}
427
428static apr_status_t find_addresses(apr_sockaddr_t **sa,
429                                   const char *hostname, apr_int32_t family,
430                                   apr_port_t port, apr_int32_t flags,
431                                   apr_pool_t *p)
432{
433    if (flags & APR_IPV4_ADDR_OK) {
434        apr_status_t error = call_resolver(sa, hostname, AF_INET, port, flags, p);
435
436#if APR_HAVE_IPV6
437        if (error) {
438            family = AF_INET6; /* try again */
439        }
440        else
441#endif
442        return error;
443    }
444#if APR_HAVE_IPV6
445    else if (flags & APR_IPV6_ADDR_OK) {
446        apr_status_t error = call_resolver(sa, hostname, AF_INET6, port, flags, p);
447
448        if (error) {
449            family = AF_INET; /* try again */
450        }
451        else {
452            return APR_SUCCESS;
453        }
454    }
455#endif
456
457    return call_resolver(sa, hostname, family, port, flags, p);
458}
459
460#else /* end of HAVE_GETADDRINFO code */
461
462static apr_status_t find_addresses(apr_sockaddr_t **sa,
463                                   const char *hostname, apr_int32_t family,
464                                   apr_port_t port, apr_int32_t flags,
465                                   apr_pool_t *p)
466{
467    struct hostent *hp;
468    apr_sockaddr_t *prev_sa;
469    int curaddr;
470#if APR_HAS_THREADS && !defined(GETHOSTBYNAME_IS_THREAD_SAFE) && \
471    defined(HAVE_GETHOSTBYNAME_R) && !defined(BEOS)
472#ifdef GETHOSTBYNAME_R_HOSTENT_DATA
473    struct hostent_data hd;
474#else
475    /* If you see ERANGE, that means GETHOSBYNAME_BUFLEN needs to be
476     * bumped. */
477    char tmp[GETHOSTBYNAME_BUFLEN];
478#endif
479    int hosterror;
480#endif
481    struct hostent hs;
482    struct in_addr ipaddr;
483    char *addr_list[2];
484    const char *orig_hostname = hostname;
485
486    if (hostname == NULL) {
487        /* if we are given a NULL hostname, assume '0.0.0.0' */
488        hostname = "0.0.0.0";
489    }
490
491    if (*hostname >= '0' && *hostname <= '9' &&
492        strspn(hostname, "0123456789.") == strlen(hostname)) {
493
494        ipaddr.s_addr = inet_addr(hostname);
495        addr_list[0] = (char *)&ipaddr;
496        addr_list[1] = NULL; /* just one IP in list */
497        hs.h_addr_list = (char **)addr_list;
498        hp = &hs;
499    }
500    else {
501#if APR_HAS_THREADS && !defined(GETHOSTBYNAME_IS_THREAD_SAFE) && \
502    defined(HAVE_GETHOSTBYNAME_R) && !defined(BEOS)
503#if defined(GETHOSTBYNAME_R_HOSTENT_DATA)
504        /* AIX, HP/UX, D/UX et alia */
505        gethostbyname_r(hostname, &hs, &hd);
506        hp = &hs;
507#else
508#if defined(GETHOSTBYNAME_R_GLIBC2)
509        /* Linux glibc2+ */
510        gethostbyname_r(hostname, &hs, tmp, GETHOSTBYNAME_BUFLEN - 1,
511                        &hp, &hosterror);
512#else
513        /* Solaris, Irix et alia */
514        hp = gethostbyname_r(hostname, &hs, tmp, GETHOSTBYNAME_BUFLEN - 1,
515                             &hosterror);
516#endif /* !defined(GETHOSTBYNAME_R_GLIBC2) */
517        if (!hp) {
518            return (hosterror + APR_OS_START_SYSERR);
519        }
520#endif /* !defined(GETHOSTBYNAME_R_HOSTENT_DATA) */
521#else
522        hp = gethostbyname(hostname);
523#endif
524
525        if (!hp) {
526#ifdef WIN32
527            return apr_get_netos_error();
528#else
529            return (h_errno + APR_OS_START_SYSERR);
530#endif
531        }
532    }
533
534    prev_sa = NULL;
535    curaddr = 0;
536    while (hp->h_addr_list[curaddr]) {
537        apr_sockaddr_t *new_sa = apr_pcalloc(p, sizeof(apr_sockaddr_t));
538
539        new_sa->pool = p;
540        new_sa->sa.sin.sin_addr = *(struct in_addr *)hp->h_addr_list[curaddr];
541        apr_sockaddr_vars_set(new_sa, AF_INET, port);
542
543        if (!prev_sa) { /* first element in new list */
544            if (orig_hostname) {
545                new_sa->hostname = apr_pstrdup(p, orig_hostname);
546            }
547            *sa = new_sa;
548        }
549        else {
550            new_sa->hostname = prev_sa->hostname;
551            prev_sa->next = new_sa;
552        }
553
554        prev_sa = new_sa;
555        ++curaddr;
556    }
557
558    return APR_SUCCESS;
559}
560
561#endif /* end of !HAVE_GETADDRINFO code */
562
563APR_DECLARE(apr_status_t) apr_sockaddr_info_get(apr_sockaddr_t **sa,
564                                                const char *hostname,
565                                                apr_int32_t family, apr_port_t port,
566                                                apr_int32_t flags, apr_pool_t *p)
567{
568    apr_int32_t masked;
569    *sa = NULL;
570
571    if ((masked = flags & (APR_IPV4_ADDR_OK | APR_IPV6_ADDR_OK))) {
572        if (!hostname ||
573            family != APR_UNSPEC ||
574            masked == (APR_IPV4_ADDR_OK | APR_IPV6_ADDR_OK)) {
575            return APR_EINVAL;
576        }
577#if !APR_HAVE_IPV6
578        if (flags & APR_IPV6_ADDR_OK) {
579            return APR_ENOTIMPL;
580        }
581#endif
582    }
583#if !APR_HAVE_IPV6
584    /* What may happen is that APR is not IPv6-enabled, but we're still
585     * going to call getaddrinfo(), so we have to tell the OS we only
586     * want IPv4 addresses back since we won't know what to do with
587     * IPv6 addresses.
588     */
589    if (family == APR_UNSPEC) {
590        family = APR_INET;
591    }
592#endif
593
594    return find_addresses(sa, hostname, family, port, flags, p);
595}
596
597APR_DECLARE(apr_status_t) apr_getnameinfo(char **hostname,
598                                          apr_sockaddr_t *sockaddr,
599                                          apr_int32_t flags)
600{
601#if defined(HAVE_GETNAMEINFO)
602    int rc;
603#if defined(NI_MAXHOST)
604    char tmphostname[NI_MAXHOST];
605#else
606    char tmphostname[256];
607#endif
608
609    /* don't know if it is portable for getnameinfo() to set h_errno;
610     * clear it then see if it was set */
611    SET_H_ERRNO(0);
612
613    /* default flags are NI_NAMREQD; otherwise, getnameinfo() will return
614     * a numeric address string if it fails to resolve the host name;
615     * that is *not* what we want here
616     *
617     * For IPv4-mapped IPv6 addresses, drop down to IPv4 before calling
618     * getnameinfo() to avoid getnameinfo bugs (MacOS X, glibc).
619     */
620#if APR_HAVE_IPV6
621    if (sockaddr->family == AF_INET6 &&
622        IN6_IS_ADDR_V4MAPPED(&sockaddr->sa.sin6.sin6_addr)) {
623        struct sockaddr_in tmpsa;
624        tmpsa.sin_family = AF_INET;
625        tmpsa.sin_port = 0;
626        tmpsa.sin_addr.s_addr = ((apr_uint32_t *)sockaddr->ipaddr_ptr)[3];
627#ifdef SIN6_LEN
628        tmpsa.sin_len = sizeof(tmpsa);
629#endif
630
631        rc = getnameinfo((const struct sockaddr *)&tmpsa, sizeof(tmpsa),
632                         tmphostname, sizeof(tmphostname), NULL, 0,
633                         flags != 0 ? flags : NI_NAMEREQD);
634    }
635    else
636#endif
637    rc = getnameinfo((const struct sockaddr *)&sockaddr->sa, sockaddr->salen,
638                     tmphostname, sizeof(tmphostname), NULL, 0,
639                     flags != 0 ? flags : NI_NAMEREQD);
640    if (rc != 0) {
641        *hostname = NULL;
642
643#ifndef WIN32
644        /* something went wrong. Look at the EAI_ error code */
645        if (rc == EAI_SYSTEM) {
646            /* EAI_SYSTEM      System error returned in errno. */
647            /* IMHO, Implementations that set h_errno a simply broken. */
648            if (h_errno) { /* for broken implementations which set h_errno */
649                return h_errno + APR_OS_START_SYSERR;
650            }
651            else { /* "normal" case */
652                return errno + APR_OS_START_SYSERR;
653            }
654        }
655        else
656#endif
657        {
658#if defined(NEGATIVE_EAI)
659            if (rc < 0) rc = -rc;
660#endif
661            return rc + APR_OS_START_EAIERR; /* return the EAI_ error */
662        }
663    }
664    *hostname = sockaddr->hostname = apr_pstrdup(sockaddr->pool,
665                                                 tmphostname);
666    return APR_SUCCESS;
667#else
668#if APR_HAS_THREADS && !defined(GETHOSTBYADDR_IS_THREAD_SAFE) && \
669    defined(HAVE_GETHOSTBYADDR_R) && !defined(BEOS)
670#ifdef GETHOSTBYNAME_R_HOSTENT_DATA
671    struct hostent_data hd;
672#else
673    char tmp[GETHOSTBYNAME_BUFLEN];
674#endif
675    int hosterror;
676    struct hostent hs, *hptr;
677
678#if defined(GETHOSTBYNAME_R_HOSTENT_DATA)
679    /* AIX, HP/UX, D/UX et alia */
680    gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr,
681                  sizeof(struct in_addr), AF_INET, &hs, &hd);
682    hptr = &hs;
683#else
684#if defined(GETHOSTBYNAME_R_GLIBC2)
685    /* Linux glibc2+ */
686    gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr,
687                    sizeof(struct in_addr), AF_INET,
688                    &hs, tmp, GETHOSTBYNAME_BUFLEN - 1, &hptr, &hosterror);
689#else
690    /* Solaris, Irix et alia */
691    hptr = gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr,
692                           sizeof(struct in_addr), AF_INET,
693                           &hs, tmp, GETHOSTBYNAME_BUFLEN, &hosterror);
694#endif /* !defined(GETHOSTBYNAME_R_GLIBC2) */
695    if (!hptr) {
696        *hostname = NULL;
697        return hosterror + APR_OS_START_SYSERR;
698    }
699#endif /* !defined(GETHOSTBYNAME_R_HOSTENT_DATA) */
700#else
701    struct hostent *hptr;
702    hptr = gethostbyaddr((char *)&sockaddr->sa.sin.sin_addr,
703                         sizeof(struct in_addr), AF_INET);
704#endif
705
706    if (hptr) {
707        *hostname = sockaddr->hostname = apr_pstrdup(sockaddr->pool, hptr->h_name);
708        return APR_SUCCESS;
709    }
710    *hostname = NULL;
711#if defined(WIN32)
712    return apr_get_netos_error();
713#elif defined(OS2)
714    return h_errno;
715#else
716    return h_errno + APR_OS_START_SYSERR;
717#endif
718#endif
719}
720
721APR_DECLARE(apr_status_t) apr_getservbyname(apr_sockaddr_t *sockaddr,
722                                            const char *servname)
723{
724#if APR_HAS_THREADS && !defined(GETSERVBYNAME_IS_THREAD_SAFE) && \
725    defined(HAVE_GETSERVBYNAME_R) && \
726    (defined(GETSERVBYNAME_R_GLIBC2) || defined(GETSERVBYNAME_R_SOLARIS) || \
727     defined(GETSERVBYNAME_R_OSF1))
728    struct servent se;
729#if defined(GETSERVBYNAME_R_OSF1)
730    struct servent_data sed;
731
732    memset(&sed, 0, sizeof(sed)); /* must zero fill before use */
733#else
734#if defined(GETSERVBYNAME_R_GLIBC2)
735    struct servent *res;
736#endif
737    char buf[1024];
738#endif
739#else
740    struct servent *se;
741#endif
742
743    if (servname == NULL)
744        return APR_EINVAL;
745
746#if APR_HAS_THREADS && !defined(GETSERVBYNAME_IS_THREAD_SAFE) && \
747    defined(HAVE_GETSERVBYNAME_R) && \
748    (defined(GETSERVBYNAME_R_GLIBC2) || defined(GETSERVBYNAME_R_SOLARIS) || \
749     defined(GETSERVBYNAME_R_OSF1))
750#if defined(GETSERVBYNAME_R_GLIBC2)
751    if (getservbyname_r(servname, NULL,
752                        &se, buf, sizeof(buf), &res) == 0 && res != NULL) {
753        sockaddr->port = ntohs(res->s_port);
754        sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
755        sockaddr->sa.sin.sin_port = res->s_port;
756        return APR_SUCCESS;
757    }
758#elif defined(GETSERVBYNAME_R_SOLARIS)
759    if (getservbyname_r(servname, NULL, &se, buf, sizeof(buf)) != NULL) {
760        sockaddr->port = ntohs(se.s_port);
761        sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
762        sockaddr->sa.sin.sin_port = se.s_port;
763        return APR_SUCCESS;
764    }
765#elif defined(GETSERVBYNAME_R_OSF1)
766    if (getservbyname_r(servname, NULL, &se, &sed) == 0) {
767        sockaddr->port = ntohs(se.s_port);
768        sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
769        sockaddr->sa.sin.sin_port = se.s_port;
770        return APR_SUCCESS;
771    }
772#endif
773#else
774    if ((se = getservbyname(servname, NULL)) != NULL){
775        sockaddr->port = ntohs(se->s_port);
776        sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
777        sockaddr->sa.sin.sin_port = se->s_port;
778        return APR_SUCCESS;
779    }
780#endif
781    return APR_ENOENT;
782}
783
784#define V4MAPPED_EQUAL(a,b)                                   \
785((a)->sa.sin.sin_family == AF_INET &&                         \
786 (b)->sa.sin.sin_family == AF_INET6 &&                        \
787 IN6_IS_ADDR_V4MAPPED((struct in6_addr *)(b)->ipaddr_ptr) &&  \
788 !memcmp((a)->ipaddr_ptr,                                     \
789         &((struct in6_addr *)(b)->ipaddr_ptr)->s6_addr[12],  \
790         (a)->ipaddr_len))
791
792APR_DECLARE(int) apr_sockaddr_equal(const apr_sockaddr_t *addr1,
793                                    const apr_sockaddr_t *addr2)
794{
795    if (addr1->ipaddr_len == addr2->ipaddr_len &&
796        !memcmp(addr1->ipaddr_ptr, addr2->ipaddr_ptr, addr1->ipaddr_len)) {
797        return 1;
798    }
799#if APR_HAVE_IPV6
800    if (V4MAPPED_EQUAL(addr1, addr2)) {
801        return 1;
802    }
803    if (V4MAPPED_EQUAL(addr2, addr1)) {
804        return 1;
805    }
806#endif
807    return 0; /* not equal */
808}
809
810static apr_status_t parse_network(apr_ipsubnet_t *ipsub, const char *network)
811{
812    /* legacy syntax for ip addrs: a.b.c. ==> a.b.c.0/24 for example */
813    int shift;
814    char *s, *t;
815    int octet;
816    char buf[sizeof "255.255.255.255"];
817
818    if (strlen(network) < sizeof buf) {
819        strcpy(buf, network);
820    }
821    else {
822        return APR_EBADIP;
823    }
824
825    /* parse components */
826    s = buf;
827    ipsub->sub[0] = 0;
828    ipsub->mask[0] = 0;
829    shift = 24;
830    while (*s) {
831        t = s;
832        if (!apr_isdigit(*t)) {
833            return APR_EBADIP;
834        }
835        while (apr_isdigit(*t)) {
836            ++t;
837        }
838        if (*t == '.') {
839            *t++ = 0;
840        }
841        else if (*t) {
842            return APR_EBADIP;
843        }
844        if (shift < 0) {
845            return APR_EBADIP;
846        }
847        octet = atoi(s);
848        if (octet < 0 || octet > 255) {
849            return APR_EBADIP;
850        }
851        ipsub->sub[0] |= octet << shift;
852        ipsub->mask[0] |= 0xFFUL << shift;
853        s = t;
854        shift -= 8;
855    }
856    ipsub->sub[0] = ntohl(ipsub->sub[0]);
857    ipsub->mask[0] = ntohl(ipsub->mask[0]);
858    ipsub->family = AF_INET;
859    return APR_SUCCESS;
860}
861
862/* return values:
863 * APR_EINVAL     not an IP address; caller should see if it is something else
864 * APR_BADIP      IP address portion is is not valid
865 * APR_BADMASK    mask portion is not valid
866 */
867
868static apr_status_t parse_ip(apr_ipsubnet_t *ipsub, const char *ipstr, int network_allowed)
869{
870    /* supported flavors of IP:
871     *
872     * . IPv6 numeric address string (e.g., "fe80::1")
873     *
874     *   IMPORTANT: Don't store IPv4-mapped IPv6 address as an IPv6 address.
875     *
876     * . IPv4 numeric address string (e.g., "127.0.0.1")
877     *
878     * . IPv4 network string (e.g., "9.67")
879     *
880     *   IMPORTANT: This network form is only allowed if network_allowed is on.
881     */
882    int rc;
883
884#if APR_HAVE_IPV6
885    rc = apr_inet_pton(AF_INET6, ipstr, ipsub->sub);
886    if (rc == 1) {
887        if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ipsub->sub)) {
888            /* apr_ipsubnet_test() assumes that we don't create IPv4-mapped IPv6
889             * addresses; this of course forces the user to specify IPv4 addresses
890             * in a.b.c.d style instead of ::ffff:a.b.c.d style.
891             */
892            return APR_EBADIP;
893        }
894        ipsub->family = AF_INET6;
895    }
896    else
897#endif
898    {
899        rc = apr_inet_pton(AF_INET, ipstr, ipsub->sub);
900        if (rc == 1) {
901            ipsub->family = AF_INET;
902        }
903    }
904    if (rc != 1) {
905        if (network_allowed) {
906            return parse_network(ipsub, ipstr);
907        }
908        else {
909            return APR_EBADIP;
910        }
911    }
912    return APR_SUCCESS;
913}
914
915static int looks_like_ip(const char *ipstr)
916{
917    if (strchr(ipstr, ':')) {
918        /* definitely not a hostname; assume it is intended to be an IPv6 address */
919        return 1;
920    }
921
922    /* simple IPv4 address string check */
923    while ((*ipstr == '.') || apr_isdigit(*ipstr))
924        ipstr++;
925    return (*ipstr == '\0');
926}
927
928static void fix_subnet(apr_ipsubnet_t *ipsub)
929{
930    /* in case caller specified more bits in network address than are
931     * valid according to the mask, turn off the extra bits
932     */
933    int i;
934
935    for (i = 0; i < sizeof ipsub->mask / sizeof(apr_int32_t); i++) {
936        ipsub->sub[i] &= ipsub->mask[i];
937    }
938}
939
940/* be sure not to store any IPv4 address as a v4-mapped IPv6 address */
941APR_DECLARE(apr_status_t) apr_ipsubnet_create(apr_ipsubnet_t **ipsub, const char *ipstr,
942                                              const char *mask_or_numbits, apr_pool_t *p)
943{
944    apr_status_t rv;
945    char *endptr;
946    long bits, maxbits = 32;
947
948    /* filter out stuff which doesn't look remotely like an IP address; this helps
949     * callers like mod_access which have a syntax allowing hostname or IP address;
950     * APR_EINVAL tells the caller that it was probably not intended to be an IP
951     * address
952     */
953    if (!looks_like_ip(ipstr)) {
954        return APR_EINVAL;
955    }
956
957    *ipsub = apr_pcalloc(p, sizeof(apr_ipsubnet_t));
958
959    /* assume ipstr is an individual IP address, not a subnet */
960    memset((*ipsub)->mask, 0xFF, sizeof (*ipsub)->mask);
961
962    rv = parse_ip(*ipsub, ipstr, mask_or_numbits == NULL);
963    if (rv != APR_SUCCESS) {
964        return rv;
965    }
966
967    if (mask_or_numbits) {
968#if APR_HAVE_IPV6
969        if ((*ipsub)->family == AF_INET6) {
970            maxbits = 128;
971        }
972#endif
973        bits = strtol(mask_or_numbits, &endptr, 10);
974        if (*endptr == '\0' && bits > 0 && bits <= maxbits) {
975            /* valid num-bits string; fill in mask appropriately */
976            int cur_entry = 0;
977            apr_int32_t cur_bit_value;
978
979            memset((*ipsub)->mask, 0, sizeof (*ipsub)->mask);
980            while (bits > 32) {
981                (*ipsub)->mask[cur_entry] = 0xFFFFFFFF; /* all 32 bits */
982                bits -= 32;
983                ++cur_entry;
984            }
985            cur_bit_value = 0x80000000;
986            while (bits) {
987                (*ipsub)->mask[cur_entry] |= cur_bit_value;
988                --bits;
989                cur_bit_value /= 2;
990            }
991            (*ipsub)->mask[cur_entry] = htonl((*ipsub)->mask[cur_entry]);
992        }
993        else if (apr_inet_pton(AF_INET, mask_or_numbits, (*ipsub)->mask) == 1 &&
994            (*ipsub)->family == AF_INET) {
995            /* valid IPv4 netmask */
996        }
997        else {
998            return APR_EBADMASK;
999        }
1000    }
1001
1002    fix_subnet(*ipsub);
1003
1004    return APR_SUCCESS;
1005}
1006
1007APR_DECLARE(int) apr_ipsubnet_test(apr_ipsubnet_t *ipsub, apr_sockaddr_t *sa)
1008{
1009#if APR_HAVE_IPV6
1010    /* XXX This line will segv on Win32 build with APR_HAVE_IPV6,
1011     * but without the IPV6 drivers installed.
1012     */
1013    if (sa->sa.sin.sin_family == AF_INET) {
1014        if (ipsub->family == AF_INET &&
1015            ((sa->sa.sin.sin_addr.s_addr & ipsub->mask[0]) == ipsub->sub[0])) {
1016            return 1;
1017        }
1018    }
1019    else if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)sa->ipaddr_ptr)) {
1020        if (ipsub->family == AF_INET &&
1021            (((apr_uint32_t *)sa->ipaddr_ptr)[3] & ipsub->mask[0]) == ipsub->sub[0]) {
1022            return 1;
1023        }
1024    }
1025    else {
1026        apr_uint32_t *addr = (apr_uint32_t *)sa->ipaddr_ptr;
1027
1028        if ((addr[0] & ipsub->mask[0]) == ipsub->sub[0] &&
1029            (addr[1] & ipsub->mask[1]) == ipsub->sub[1] &&
1030            (addr[2] & ipsub->mask[2]) == ipsub->sub[2] &&
1031            (addr[3] & ipsub->mask[3]) == ipsub->sub[3]) {
1032            return 1;
1033        }
1034    }
1035#else
1036    if ((sa->sa.sin.sin_addr.s_addr & ipsub->mask[0]) == ipsub->sub[0]) {
1037        return 1;
1038    }
1039#endif /* APR_HAVE_IPV6 */
1040    return 0; /* no match */
1041}
1042