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
31 struct 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 */
getservbyname(const char * name,const char * proto)74 static void *getservbyname(const char *name, const char *proto)
75 {
76 return NULL;
77 }
78 #endif
79
get_local_addr(apr_socket_t * sock)80 static 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
get_remote_addr(apr_socket_t * sock)95 static 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
apr_sockaddr_ip_getbuf(char * buf,apr_size_t buflen,apr_sockaddr_t * sockaddr)110 APR_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
apr_sockaddr_ip_get(char ** addr,apr_sockaddr_t * sockaddr)134 APR_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
apr_sockaddr_vars_set(apr_sockaddr_t * addr,int family,apr_port_t port)141 void 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
apr_socket_addr_get(apr_sockaddr_t ** sa,apr_interface_e which,apr_socket_t * sock)172 APR_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
apr_parse_addr_port(char ** addr,char ** scope_id,apr_port_t * port,const char * str,apr_pool_t * p)203 APR_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
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)307 static 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 /*
360 * Using AI_ADDRCONFIG involves some unfortunate guesswork because it
361 * does not consider loopback addresses when trying to determine if
362 * IPv4 or IPv6 is configured on a system (see RFC 3493).
363 * This is a problem if one actually wants to listen on or connect to
364 * the loopback address of a protocol family that is not otherwise
365 * configured on the system. See PR 52709.
366 * To work around some of the problems, retry without AI_ADDRCONFIG
367 * in case of EAI_ADDRFAMILY.
368 * XXX: apr_sockaddr_info_get() should really accept a flag to determine
369 * XXX: if AI_ADDRCONFIG's guesswork is wanted and if the address is
370 * XXX: to be used for listen() or connect().
371 *
372 * In case of EAI_BADFLAGS, AI_ADDRCONFIG is not supported.
373 */
374 if ((family == APR_UNSPEC) && (error == EAI_BADFLAGS
375 #ifdef EAI_ADDRFAMILY
376 || error == EAI_ADDRFAMILY
377 #endif
378 )) {
379 hints.ai_flags &= ~AI_ADDRCONFIG;
380 error = getaddrinfo(hostname, servname, &hints, &ai_list);
381 }
382 #endif
383 if (error) {
384 #if defined(WIN32)
385 return apr_get_netos_error();
386 #else
387 if (error == EAI_SYSTEM) {
388 return errno ? errno : APR_EGENERAL;
389 }
390 else
391 {
392 /* issues with representing this with APR's error scheme:
393 * glibc uses negative values for these numbers, perhaps so
394 * they don't conflict with h_errno values... Tru64 uses
395 * positive values which conflict with h_errno values
396 */
397 #if defined(NEGATIVE_EAI)
398 error = -error;
399 #endif
400 return error + APR_OS_START_EAIERR;
401 }
402 #endif /* WIN32 */
403 }
404
405 prev_sa = NULL;
406 ai = ai_list;
407 while (ai) { /* while more addresses to report */
408 apr_sockaddr_t *new_sa;
409
410 /* Ignore anything bogus: getaddrinfo in some old versions of
411 * glibc will return AF_UNIX entries for APR_UNSPEC+AI_PASSIVE
412 * lookups. */
413 #if APR_HAVE_IPV6
414 if (ai->ai_family != AF_INET && ai->ai_family != AF_INET6) {
415 #else
416 if (ai->ai_family != AF_INET) {
417 #endif
418 ai = ai->ai_next;
419 continue;
420 }
421
422 new_sa = apr_pcalloc(p, sizeof(apr_sockaddr_t));
423
424 new_sa->pool = p;
425 memcpy(&new_sa->sa, ai->ai_addr, ai->ai_addrlen);
426 apr_sockaddr_vars_set(new_sa, ai->ai_family, port);
427
428 if (!prev_sa) { /* first element in new list */
429 if (hostname) {
430 new_sa->hostname = apr_pstrdup(p, hostname);
431 }
432 *sa = new_sa;
433 }
434 else {
435 new_sa->hostname = prev_sa->hostname;
436 prev_sa->next = new_sa;
437 }
438
439 prev_sa = new_sa;
440 ai = ai->ai_next;
441 }
442 freeaddrinfo(ai_list);
443
444 if (prev_sa == NULL) {
445 /*
446 * getaddrinfo returned only useless entries and *sa is still empty.
447 * This should be treated as an error.
448 */
449 return APR_EGENERAL;
450 }
451
452 return APR_SUCCESS;
453 }
454
455 static apr_status_t find_addresses(apr_sockaddr_t **sa,
456 const char *hostname, apr_int32_t family,
457 apr_port_t port, apr_int32_t flags,
458 apr_pool_t *p)
459 {
460 if (flags & APR_IPV4_ADDR_OK) {
461 apr_status_t error = call_resolver(sa, hostname, AF_INET, port, flags, p);
462
463 #if APR_HAVE_IPV6
464 if (error) {
465 family = AF_INET6; /* try again */
466 }
467 else
468 #endif
469 return error;
470 }
471 #if APR_HAVE_IPV6
472 else if (flags & APR_IPV6_ADDR_OK) {
473 apr_status_t error = call_resolver(sa, hostname, AF_INET6, port, flags, p);
474
475 if (error) {
476 family = AF_INET; /* try again */
477 }
478 else {
479 return APR_SUCCESS;
480 }
481 }
482 #endif
483
484 return call_resolver(sa, hostname, family, port, flags, p);
485 }
486
487 #else /* end of HAVE_GETADDRINFO code */
488
489 static apr_status_t find_addresses(apr_sockaddr_t **sa,
490 const char *hostname, apr_int32_t family,
491 apr_port_t port, apr_int32_t flags,
492 apr_pool_t *p)
493 {
494 struct hostent *hp;
495 apr_sockaddr_t *prev_sa;
496 int curaddr;
497 #if APR_HAS_THREADS && !defined(GETHOSTBYNAME_IS_THREAD_SAFE) && \
498 defined(HAVE_GETHOSTBYNAME_R) && !defined(BEOS)
499 #ifdef GETHOSTBYNAME_R_HOSTENT_DATA
500 struct hostent_data hd;
501 #else
502 /* If you see ERANGE, that means GETHOSBYNAME_BUFLEN needs to be
503 * bumped. */
504 char tmp[GETHOSTBYNAME_BUFLEN];
505 #endif
506 int hosterror;
507 #endif
508 struct hostent hs;
509 struct in_addr ipaddr;
510 char *addr_list[2];
511 const char *orig_hostname = hostname;
512
513 if (hostname == NULL) {
514 /* if we are given a NULL hostname, assume '0.0.0.0' */
515 hostname = "0.0.0.0";
516 }
517
518 if (*hostname >= '0' && *hostname <= '9' &&
519 strspn(hostname, "0123456789.") == strlen(hostname)) {
520
521 ipaddr.s_addr = inet_addr(hostname);
522 addr_list[0] = (char *)&ipaddr;
523 addr_list[1] = NULL; /* just one IP in list */
524 hs.h_addr_list = (char **)addr_list;
525 hp = &hs;
526 }
527 else {
528 #if APR_HAS_THREADS && !defined(GETHOSTBYNAME_IS_THREAD_SAFE) && \
529 defined(HAVE_GETHOSTBYNAME_R) && !defined(BEOS)
530 #if defined(GETHOSTBYNAME_R_HOSTENT_DATA)
531 /* AIX, HP/UX, D/UX et alia */
532 gethostbyname_r(hostname, &hs, &hd);
533 hp = &hs;
534 #else
535 #if defined(GETHOSTBYNAME_R_GLIBC2)
536 /* Linux glibc2+ */
537 gethostbyname_r(hostname, &hs, tmp, GETHOSTBYNAME_BUFLEN - 1,
538 &hp, &hosterror);
539 #else
540 /* Solaris, Irix et alia */
541 hp = gethostbyname_r(hostname, &hs, tmp, GETHOSTBYNAME_BUFLEN - 1,
542 &hosterror);
543 #endif /* !defined(GETHOSTBYNAME_R_GLIBC2) */
544 if (!hp) {
545 return (hosterror + APR_OS_START_SYSERR);
546 }
547 #endif /* !defined(GETHOSTBYNAME_R_HOSTENT_DATA) */
548 #else
549 hp = gethostbyname(hostname);
550 #endif
551
552 if (!hp) {
553 #ifdef WIN32
554 return apr_get_netos_error();
555 #else
556 return (h_errno + APR_OS_START_SYSERR);
557 #endif
558 }
559 }
560
561 prev_sa = NULL;
562 curaddr = 0;
563 while (hp->h_addr_list[curaddr]) {
564 apr_sockaddr_t *new_sa = apr_pcalloc(p, sizeof(apr_sockaddr_t));
565
566 new_sa->pool = p;
567 new_sa->sa.sin.sin_addr = *(struct in_addr *)hp->h_addr_list[curaddr];
568 apr_sockaddr_vars_set(new_sa, AF_INET, port);
569
570 if (!prev_sa) { /* first element in new list */
571 if (orig_hostname) {
572 new_sa->hostname = apr_pstrdup(p, orig_hostname);
573 }
574 *sa = new_sa;
575 }
576 else {
577 new_sa->hostname = prev_sa->hostname;
578 prev_sa->next = new_sa;
579 }
580
581 prev_sa = new_sa;
582 ++curaddr;
583 }
584
585 if (prev_sa == NULL) {
586 /* this should not happen but no result should be treated as error */
587 return APR_EGENERAL;
588 }
589
590 return APR_SUCCESS;
591 }
592
593 #endif /* end of !HAVE_GETADDRINFO code */
594
595 APR_DECLARE(apr_status_t) apr_sockaddr_info_get(apr_sockaddr_t **sa,
596 const char *hostname,
597 apr_int32_t family, apr_port_t port,
598 apr_int32_t flags, apr_pool_t *p)
599 {
600 apr_int32_t masked;
601 *sa = NULL;
602
603 if ((masked = flags & (APR_IPV4_ADDR_OK | APR_IPV6_ADDR_OK))) {
604 if (!hostname ||
605 family != APR_UNSPEC ||
606 masked == (APR_IPV4_ADDR_OK | APR_IPV6_ADDR_OK)) {
607 return APR_EINVAL;
608 }
609 #if !APR_HAVE_IPV6
610 if (flags & APR_IPV6_ADDR_OK) {
611 return APR_ENOTIMPL;
612 }
613 #endif
614 }
615 #if !APR_HAVE_IPV6
616 /* What may happen is that APR is not IPv6-enabled, but we're still
617 * going to call getaddrinfo(), so we have to tell the OS we only
618 * want IPv4 addresses back since we won't know what to do with
619 * IPv6 addresses.
620 */
621 if (family == APR_UNSPEC) {
622 family = APR_INET;
623 }
624 #endif
625
626 return find_addresses(sa, hostname, family, port, flags, p);
627 }
628
629 APR_DECLARE(apr_status_t) apr_getnameinfo(char **hostname,
630 apr_sockaddr_t *sockaddr,
631 apr_int32_t flags)
632 {
633 #if defined(HAVE_GETNAMEINFO)
634 int rc;
635 #if defined(NI_MAXHOST)
636 char tmphostname[NI_MAXHOST];
637 #else
638 char tmphostname[256];
639 #endif
640
641 /* don't know if it is portable for getnameinfo() to set h_errno;
642 * clear it then see if it was set */
643 SET_H_ERRNO(0);
644
645 /* default flags are NI_NAMREQD; otherwise, getnameinfo() will return
646 * a numeric address string if it fails to resolve the host name;
647 * that is *not* what we want here
648 *
649 * For IPv4-mapped IPv6 addresses, drop down to IPv4 before calling
650 * getnameinfo() to avoid getnameinfo bugs (MacOS X, glibc).
651 */
652 #if APR_HAVE_IPV6
653 if (sockaddr->family == AF_INET6 &&
654 IN6_IS_ADDR_V4MAPPED(&sockaddr->sa.sin6.sin6_addr)) {
655 struct sockaddr_in tmpsa;
656 tmpsa.sin_family = AF_INET;
657 tmpsa.sin_port = 0;
658 tmpsa.sin_addr.s_addr = ((apr_uint32_t *)sockaddr->ipaddr_ptr)[3];
659 #ifdef SIN6_LEN
660 tmpsa.sin_len = sizeof(tmpsa);
661 #endif
662
663 rc = getnameinfo((const struct sockaddr *)&tmpsa, sizeof(tmpsa),
664 tmphostname, sizeof(tmphostname), NULL, 0,
665 flags != 0 ? flags : NI_NAMEREQD);
666 }
667 else
668 #endif
669 rc = getnameinfo((const struct sockaddr *)&sockaddr->sa, sockaddr->salen,
670 tmphostname, sizeof(tmphostname), NULL, 0,
671 flags != 0 ? flags : NI_NAMEREQD);
672 if (rc != 0) {
673 *hostname = NULL;
674
675 #ifndef WIN32
676 /* something went wrong. Look at the EAI_ error code */
677 if (rc == EAI_SYSTEM) {
678 /* EAI_SYSTEM System error returned in errno. */
679 /* IMHO, Implementations that set h_errno a simply broken. */
680 if (h_errno) { /* for broken implementations which set h_errno */
681 return h_errno + APR_OS_START_SYSERR;
682 }
683 else { /* "normal" case */
684 return errno + APR_OS_START_SYSERR;
685 }
686 }
687 else
688 #endif
689 {
690 #if defined(NEGATIVE_EAI)
691 if (rc < 0) rc = -rc;
692 #endif
693 return rc + APR_OS_START_EAIERR; /* return the EAI_ error */
694 }
695 }
696 *hostname = sockaddr->hostname = apr_pstrdup(sockaddr->pool,
697 tmphostname);
698 return APR_SUCCESS;
699 #else
700 #if APR_HAS_THREADS && !defined(GETHOSTBYADDR_IS_THREAD_SAFE) && \
701 defined(HAVE_GETHOSTBYADDR_R) && !defined(BEOS)
702 #ifdef GETHOSTBYNAME_R_HOSTENT_DATA
703 struct hostent_data hd;
704 #else
705 char tmp[GETHOSTBYNAME_BUFLEN];
706 #endif
707 int hosterror;
708 struct hostent hs, *hptr;
709
710 #if defined(GETHOSTBYNAME_R_HOSTENT_DATA)
711 /* AIX, HP/UX, D/UX et alia */
712 gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr,
713 sizeof(struct in_addr), AF_INET, &hs, &hd);
714 hptr = &hs;
715 #else
716 #if defined(GETHOSTBYNAME_R_GLIBC2)
717 /* Linux glibc2+ */
718 gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr,
719 sizeof(struct in_addr), AF_INET,
720 &hs, tmp, GETHOSTBYNAME_BUFLEN - 1, &hptr, &hosterror);
721 #else
722 /* Solaris, Irix et alia */
723 hptr = gethostbyaddr_r((char *)&sockaddr->sa.sin.sin_addr,
724 sizeof(struct in_addr), AF_INET,
725 &hs, tmp, GETHOSTBYNAME_BUFLEN, &hosterror);
726 #endif /* !defined(GETHOSTBYNAME_R_GLIBC2) */
727 if (!hptr) {
728 *hostname = NULL;
729 return hosterror + APR_OS_START_SYSERR;
730 }
731 #endif /* !defined(GETHOSTBYNAME_R_HOSTENT_DATA) */
732 #else
733 struct hostent *hptr;
734 hptr = gethostbyaddr((char *)&sockaddr->sa.sin.sin_addr,
735 sizeof(struct in_addr), AF_INET);
736 #endif
737
738 if (hptr) {
739 *hostname = sockaddr->hostname = apr_pstrdup(sockaddr->pool, hptr->h_name);
740 return APR_SUCCESS;
741 }
742 *hostname = NULL;
743 #if defined(WIN32)
744 return apr_get_netos_error();
745 #elif defined(OS2)
746 return h_errno;
747 #else
748 return h_errno + APR_OS_START_SYSERR;
749 #endif
750 #endif
751 }
752
753 APR_DECLARE(apr_status_t) apr_getservbyname(apr_sockaddr_t *sockaddr,
754 const char *servname)
755 {
756 #if APR_HAS_THREADS && !defined(GETSERVBYNAME_IS_THREAD_SAFE) && \
757 defined(HAVE_GETSERVBYNAME_R) && \
758 (defined(GETSERVBYNAME_R_GLIBC2) || defined(GETSERVBYNAME_R_SOLARIS) || \
759 defined(GETSERVBYNAME_R_OSF1))
760 struct servent se;
761 #if defined(GETSERVBYNAME_R_OSF1)
762 struct servent_data sed;
763
764 memset(&sed, 0, sizeof(sed)); /* must zero fill before use */
765 #else
766 #if defined(GETSERVBYNAME_R_GLIBC2)
767 struct servent *res;
768 #endif
769 char buf[1024];
770 #endif
771 #else
772 struct servent *se;
773 #endif
774
775 if (servname == NULL)
776 return APR_EINVAL;
777
778 #if APR_HAS_THREADS && !defined(GETSERVBYNAME_IS_THREAD_SAFE) && \
779 defined(HAVE_GETSERVBYNAME_R) && \
780 (defined(GETSERVBYNAME_R_GLIBC2) || defined(GETSERVBYNAME_R_SOLARIS) || \
781 defined(GETSERVBYNAME_R_OSF1))
782 #if defined(GETSERVBYNAME_R_GLIBC2)
783 if (getservbyname_r(servname, NULL,
784 &se, buf, sizeof(buf), &res) == 0 && res != NULL) {
785 sockaddr->port = ntohs(res->s_port);
786 sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
787 sockaddr->sa.sin.sin_port = res->s_port;
788 return APR_SUCCESS;
789 }
790 #elif defined(GETSERVBYNAME_R_SOLARIS)
791 if (getservbyname_r(servname, NULL, &se, buf, sizeof(buf)) != NULL) {
792 sockaddr->port = ntohs(se.s_port);
793 sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
794 sockaddr->sa.sin.sin_port = se.s_port;
795 return APR_SUCCESS;
796 }
797 #elif defined(GETSERVBYNAME_R_OSF1)
798 if (getservbyname_r(servname, NULL, &se, &sed) == 0) {
799 sockaddr->port = ntohs(se.s_port);
800 sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
801 sockaddr->sa.sin.sin_port = se.s_port;
802 return APR_SUCCESS;
803 }
804 #endif
805 #else
806 if ((se = getservbyname(servname, NULL)) != NULL){
807 sockaddr->port = ntohs(se->s_port);
808 sockaddr->servname = apr_pstrdup(sockaddr->pool, servname);
809 sockaddr->sa.sin.sin_port = se->s_port;
810 return APR_SUCCESS;
811 }
812 #endif
813 return APR_ENOENT;
814 }
815
816 #define V4MAPPED_EQUAL(a,b) \
817 ((a)->sa.sin.sin_family == AF_INET && \
818 (b)->sa.sin.sin_family == AF_INET6 && \
819 IN6_IS_ADDR_V4MAPPED((struct in6_addr *)(b)->ipaddr_ptr) && \
820 !memcmp((a)->ipaddr_ptr, \
821 &((struct in6_addr *)(b)->ipaddr_ptr)->s6_addr[12], \
822 (a)->ipaddr_len))
823
824 APR_DECLARE(int) apr_sockaddr_equal(const apr_sockaddr_t *addr1,
825 const apr_sockaddr_t *addr2)
826 {
827 if (addr1->ipaddr_len == addr2->ipaddr_len &&
828 !memcmp(addr1->ipaddr_ptr, addr2->ipaddr_ptr, addr1->ipaddr_len)) {
829 return 1;
830 }
831 #if APR_HAVE_IPV6
832 if (V4MAPPED_EQUAL(addr1, addr2)) {
833 return 1;
834 }
835 if (V4MAPPED_EQUAL(addr2, addr1)) {
836 return 1;
837 }
838 #endif
839 return 0; /* not equal */
840 }
841
842 APR_DECLARE(int) apr_sockaddr_is_wildcard(const apr_sockaddr_t *addr)
843 {
844 static const char inaddr_any[
845 #if APR_HAVE_IPV6
846 sizeof(struct in6_addr)
847 #else
848 sizeof(struct in_addr)
849 #endif
850 ] = {0};
851
852 if (addr->ipaddr_ptr /* IP address initialized */
853 && addr->ipaddr_len <= sizeof inaddr_any) { /* else bug elsewhere? */
854 if (!memcmp(inaddr_any, addr->ipaddr_ptr, addr->ipaddr_len)) {
855 return 1;
856 }
857 #if APR_HAVE_IPV6
858 if (addr->family == AF_INET6
859 && IN6_IS_ADDR_V4MAPPED((struct in6_addr *)addr->ipaddr_ptr)) {
860 struct in_addr *v4 = (struct in_addr *)&((apr_uint32_t *)addr->ipaddr_ptr)[3];
861
862 if (!memcmp(inaddr_any, v4, sizeof *v4)) {
863 return 1;
864 }
865 }
866 #endif
867 }
868 return 0;
869 }
870
871 static apr_status_t parse_network(apr_ipsubnet_t *ipsub, const char *network)
872 {
873 /* legacy syntax for ip addrs: a.b.c. ==> a.b.c.0/24 for example */
874 int shift;
875 char *s, *t;
876 int octet;
877 char buf[sizeof "255.255.255.255"];
878
879 if (strlen(network) < sizeof buf) {
880 strcpy(buf, network);
881 }
882 else {
883 return APR_EBADIP;
884 }
885
886 /* parse components */
887 s = buf;
888 ipsub->sub[0] = 0;
889 ipsub->mask[0] = 0;
890 shift = 24;
891 while (*s) {
892 t = s;
893 if (!apr_isdigit(*t)) {
894 return APR_EBADIP;
895 }
896 while (apr_isdigit(*t)) {
897 ++t;
898 }
899 if (*t == '.') {
900 *t++ = 0;
901 }
902 else if (*t) {
903 return APR_EBADIP;
904 }
905 if (shift < 0) {
906 return APR_EBADIP;
907 }
908 octet = atoi(s);
909 if (octet < 0 || octet > 255) {
910 return APR_EBADIP;
911 }
912 ipsub->sub[0] |= octet << shift;
913 ipsub->mask[0] |= 0xFFUL << shift;
914 s = t;
915 shift -= 8;
916 }
917 ipsub->sub[0] = ntohl(ipsub->sub[0]);
918 ipsub->mask[0] = ntohl(ipsub->mask[0]);
919 ipsub->family = AF_INET;
920 return APR_SUCCESS;
921 }
922
923 /* return values:
924 * APR_EINVAL not an IP address; caller should see if it is something else
925 * APR_BADIP IP address portion is is not valid
926 * APR_BADMASK mask portion is not valid
927 */
928
929 static apr_status_t parse_ip(apr_ipsubnet_t *ipsub, const char *ipstr, int network_allowed)
930 {
931 /* supported flavors of IP:
932 *
933 * . IPv6 numeric address string (e.g., "fe80::1")
934 *
935 * IMPORTANT: Don't store IPv4-mapped IPv6 address as an IPv6 address.
936 *
937 * . IPv4 numeric address string (e.g., "127.0.0.1")
938 *
939 * . IPv4 network string (e.g., "9.67")
940 *
941 * IMPORTANT: This network form is only allowed if network_allowed is on.
942 */
943 int rc;
944
945 #if APR_HAVE_IPV6
946 rc = apr_inet_pton(AF_INET6, ipstr, ipsub->sub);
947 if (rc == 1) {
948 if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)ipsub->sub)) {
949 /* apr_ipsubnet_test() assumes that we don't create IPv4-mapped IPv6
950 * addresses; this of course forces the user to specify IPv4 addresses
951 * in a.b.c.d style instead of ::ffff:a.b.c.d style.
952 */
953 return APR_EBADIP;
954 }
955 ipsub->family = AF_INET6;
956 }
957 else
958 #endif
959 {
960 rc = apr_inet_pton(AF_INET, ipstr, ipsub->sub);
961 if (rc == 1) {
962 ipsub->family = AF_INET;
963 }
964 }
965 if (rc != 1) {
966 if (network_allowed) {
967 return parse_network(ipsub, ipstr);
968 }
969 else {
970 return APR_EBADIP;
971 }
972 }
973 return APR_SUCCESS;
974 }
975
976 static int looks_like_ip(const char *ipstr)
977 {
978 if (strchr(ipstr, ':')) {
979 /* definitely not a hostname; assume it is intended to be an IPv6 address */
980 return 1;
981 }
982
983 /* simple IPv4 address string check */
984 while ((*ipstr == '.') || apr_isdigit(*ipstr))
985 ipstr++;
986 return (*ipstr == '\0');
987 }
988
989 static void fix_subnet(apr_ipsubnet_t *ipsub)
990 {
991 /* in case caller specified more bits in network address than are
992 * valid according to the mask, turn off the extra bits
993 */
994 int i;
995
996 for (i = 0; i < sizeof ipsub->mask / sizeof(apr_int32_t); i++) {
997 ipsub->sub[i] &= ipsub->mask[i];
998 }
999 }
1000
1001 /* be sure not to store any IPv4 address as a v4-mapped IPv6 address */
1002 APR_DECLARE(apr_status_t) apr_ipsubnet_create(apr_ipsubnet_t **ipsub, const char *ipstr,
1003 const char *mask_or_numbits, apr_pool_t *p)
1004 {
1005 apr_status_t rv;
1006 char *endptr;
1007 long bits, maxbits = 32;
1008
1009 /* filter out stuff which doesn't look remotely like an IP address; this helps
1010 * callers like mod_access which have a syntax allowing hostname or IP address;
1011 * APR_EINVAL tells the caller that it was probably not intended to be an IP
1012 * address
1013 */
1014 if (!looks_like_ip(ipstr)) {
1015 return APR_EINVAL;
1016 }
1017
1018 *ipsub = apr_pcalloc(p, sizeof(apr_ipsubnet_t));
1019
1020 /* assume ipstr is an individual IP address, not a subnet */
1021 memset((*ipsub)->mask, 0xFF, sizeof (*ipsub)->mask);
1022
1023 rv = parse_ip(*ipsub, ipstr, mask_or_numbits == NULL);
1024 if (rv != APR_SUCCESS) {
1025 return rv;
1026 }
1027
1028 if (mask_or_numbits) {
1029 #if APR_HAVE_IPV6
1030 if ((*ipsub)->family == AF_INET6) {
1031 maxbits = 128;
1032 }
1033 #endif
1034 bits = strtol(mask_or_numbits, &endptr, 10);
1035 if (*endptr == '\0' && bits > 0 && bits <= maxbits) {
1036 /* valid num-bits string; fill in mask appropriately */
1037 int cur_entry = 0;
1038 apr_int32_t cur_bit_value;
1039
1040 memset((*ipsub)->mask, 0, sizeof (*ipsub)->mask);
1041 while (bits > 32) {
1042 (*ipsub)->mask[cur_entry] = 0xFFFFFFFF; /* all 32 bits */
1043 bits -= 32;
1044 ++cur_entry;
1045 }
1046 cur_bit_value = 0x80000000;
1047 while (bits) {
1048 (*ipsub)->mask[cur_entry] |= cur_bit_value;
1049 --bits;
1050 cur_bit_value /= 2;
1051 }
1052 (*ipsub)->mask[cur_entry] = htonl((*ipsub)->mask[cur_entry]);
1053 }
1054 else if (apr_inet_pton(AF_INET, mask_or_numbits, (*ipsub)->mask) == 1 &&
1055 (*ipsub)->family == AF_INET) {
1056 /* valid IPv4 netmask */
1057 }
1058 else {
1059 return APR_EBADMASK;
1060 }
1061 }
1062
1063 fix_subnet(*ipsub);
1064
1065 return APR_SUCCESS;
1066 }
1067
1068 APR_DECLARE(int) apr_ipsubnet_test(apr_ipsubnet_t *ipsub, apr_sockaddr_t *sa)
1069 {
1070 #if APR_HAVE_IPV6
1071 /* XXX This line will segv on Win32 build with APR_HAVE_IPV6,
1072 * but without the IPV6 drivers installed.
1073 */
1074 if (sa->family == AF_INET) {
1075 if (ipsub->family == AF_INET &&
1076 ((sa->sa.sin.sin_addr.s_addr & ipsub->mask[0]) == ipsub->sub[0])) {
1077 return 1;
1078 }
1079 }
1080 else if (IN6_IS_ADDR_V4MAPPED((struct in6_addr *)sa->ipaddr_ptr)) {
1081 if (ipsub->family == AF_INET &&
1082 (((apr_uint32_t *)sa->ipaddr_ptr)[3] & ipsub->mask[0]) == ipsub->sub[0]) {
1083 return 1;
1084 }
1085 }
1086 else if (sa->family == AF_INET6 && ipsub->family == AF_INET6) {
1087 apr_uint32_t *addr = (apr_uint32_t *)sa->ipaddr_ptr;
1088
1089 if ((addr[0] & ipsub->mask[0]) == ipsub->sub[0] &&
1090 (addr[1] & ipsub->mask[1]) == ipsub->sub[1] &&
1091 (addr[2] & ipsub->mask[2]) == ipsub->sub[2] &&
1092 (addr[3] & ipsub->mask[3]) == ipsub->sub[3]) {
1093 return 1;
1094 }
1095 }
1096 #else
1097 if ((sa->sa.sin.sin_addr.s_addr & ipsub->mask[0]) == ipsub->sub[0]) {
1098 return 1;
1099 }
1100 #endif /* APR_HAVE_IPV6 */
1101 return 0; /* no match */
1102 }
1103