Import bind 9.5.2 vendor sources.
[dragonfly.git] / contrib / bind-9.5.2 / lib / isc / unix / net.c
1 /*
2  * Copyright (C) 2004, 2005, 2007, 2008  Internet Systems Consortium, Inc. ("ISC")
3  * Copyright (C) 1999-2003  Internet Software Consortium.
4  *
5  * Permission to use, copy, modify, and/or distribute this software for any
6  * purpose with or without fee is hereby granted, provided that the above
7  * copyright notice and this permission notice appear in all copies.
8  *
9  * THE SOFTWARE IS PROVIDED "AS IS" AND ISC DISCLAIMS ALL WARRANTIES WITH
10  * REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
11  * AND FITNESS.  IN NO EVENT SHALL ISC BE LIABLE FOR ANY SPECIAL, DIRECT,
12  * INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
13  * LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE
14  * OR OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
15  * PERFORMANCE OF THIS SOFTWARE.
16  */
17
18 /* $Id: net.c,v 1.36.60.4 2008/07/04 05:52:16 each Exp $ */
19
20 #include <config.h>
21
22 #include <sys/types.h>
23
24 #if defined(HAVE_SYS_SYSCTL_H)
25 #if defined(HAVE_SYS_PARAM_H)
26 #include <sys/param.h>
27 #endif
28 #include <sys/sysctl.h>
29 #endif
30
31 #include <errno.h>
32 #include <unistd.h>
33
34 #include <isc/log.h>
35 #include <isc/msgs.h>
36 #include <isc/net.h>
37 #include <isc/once.h>
38 #include <isc/strerror.h>
39 #include <isc/string.h>
40 #include <isc/util.h>
41
42 /*%
43  * Definitions about UDP port range specification.  This is a total mess of
44  * portability variants: some use sysctl (but the sysctl names vary), some use
45  * system-specific interfaces, some have the same interface for IPv4 and IPv6,
46  * some separate them, etc...
47  */
48
49 /*%
50  * The last resort defaults: use all non well known port space
51  */
52 #ifndef ISC_NET_PORTRANGELOW
53 #define ISC_NET_PORTRANGELOW 1024
54 #endif  /* ISC_NET_PORTRANGELOW */
55 #ifndef ISC_NET_PORTRANGEHIGH
56 #define ISC_NET_PORTRANGEHIGH 65535
57 #endif  /* ISC_NET_PORTRANGEHIGH */
58
59 #ifdef HAVE_SYSCTLBYNAME
60
61 /*%
62  * sysctl variants
63  */
64 #if defined(__FreeBSD__) || defined(__APPLE__) || defined(__DragonFly__)
65 #define USE_SYSCTL_PORTRANGE
66 #define SYSCTL_V4PORTRANGE_LOW  "net.inet.ip.portrange.hifirst"
67 #define SYSCTL_V4PORTRANGE_HIGH "net.inet.ip.portrange.hilast"
68 #define SYSCTL_V6PORTRANGE_LOW  "net.inet.ip.portrange.hifirst"
69 #define SYSCTL_V6PORTRANGE_HIGH "net.inet.ip.portrange.hilast"
70 #endif
71
72 #ifdef __NetBSD__
73 #define USE_SYSCTL_PORTRANGE
74 #define SYSCTL_V4PORTRANGE_LOW  "net.inet.ip.anonportmin"
75 #define SYSCTL_V4PORTRANGE_HIGH "net.inet.ip.anonportmax"
76 #define SYSCTL_V6PORTRANGE_LOW  "net.inet6.ip6.anonportmin"
77 #define SYSCTL_V6PORTRANGE_HIGH "net.inet6.ip6.anonportmax"
78 #endif
79
80 #else /* !HAVE_SYSCTLBYNAME */
81
82 #ifdef __OpenBSD__
83 #define USE_SYSCTL_PORTRANGE
84 #define SYSCTL_V4PORTRANGE_LOW  { CTL_NET, PF_INET, IPPROTO_IP, \
85                                   IPCTL_IPPORT_HIFIRSTAUTO }
86 #define SYSCTL_V4PORTRANGE_HIGH { CTL_NET, PF_INET, IPPROTO_IP, \
87                                   IPCTL_IPPORT_HILASTAUTO }
88 /* Same for IPv6 */
89 #define SYSCTL_V6PORTRANGE_LOW  SYSCTL_V4PORTRANGE_LOW
90 #define SYSCTL_V6PORTRANGE_HIGH SYSCTL_V4PORTRANGE_HIGH
91 #endif
92
93 #endif /* HAVE_SYSCTLBYNAME */
94
95 #if defined(ISC_PLATFORM_HAVEIPV6)
96 # if defined(ISC_PLATFORM_NEEDIN6ADDRANY)
97 const struct in6_addr isc_net_in6addrany = IN6ADDR_ANY_INIT;
98 # endif
99
100 # if defined(ISC_PLATFORM_NEEDIN6ADDRLOOPBACK)
101 const struct in6_addr isc_net_in6addrloop = IN6ADDR_LOOPBACK_INIT;
102 # endif
103
104 # if defined(WANT_IPV6)
105 static isc_once_t       once_ipv6only = ISC_ONCE_INIT;
106 # endif
107
108 # if defined(ISC_PLATFORM_HAVEIN6PKTINFO)
109 static isc_once_t       once_ipv6pktinfo = ISC_ONCE_INIT;
110 # endif
111 #endif /* ISC_PLATFORM_HAVEIPV6 */
112
113 static isc_once_t       once = ISC_ONCE_INIT;
114
115 static isc_result_t     ipv4_result = ISC_R_NOTFOUND;
116 static isc_result_t     ipv6_result = ISC_R_NOTFOUND;
117 static isc_result_t     unix_result = ISC_R_NOTFOUND;
118 static isc_result_t     ipv6only_result = ISC_R_NOTFOUND;
119 static isc_result_t     ipv6pktinfo_result = ISC_R_NOTFOUND;
120
121 static isc_result_t
122 try_proto(int domain) {
123         int s;
124         isc_result_t result = ISC_R_SUCCESS;
125         char strbuf[ISC_STRERRORSIZE];
126
127         s = socket(domain, SOCK_STREAM, 0);
128         if (s == -1) {
129                 switch (errno) {
130 #ifdef EAFNOSUPPORT
131                 case EAFNOSUPPORT:
132 #endif
133 #ifdef EPROTONOSUPPORT
134                 case EPROTONOSUPPORT:
135 #endif
136 #ifdef EINVAL
137                 case EINVAL:
138 #endif
139                         return (ISC_R_NOTFOUND);
140                 default:
141                         isc__strerror(errno, strbuf, sizeof(strbuf));
142                         UNEXPECTED_ERROR(__FILE__, __LINE__,
143                                          "socket() %s: %s",
144                                          isc_msgcat_get(isc_msgcat,
145                                                         ISC_MSGSET_GENERAL,
146                                                         ISC_MSG_FAILED,
147                                                         "failed"),
148                                          strbuf);
149                         return (ISC_R_UNEXPECTED);
150                 }
151         }
152
153 #ifdef ISC_PLATFORM_HAVEIPV6
154 #ifdef WANT_IPV6
155 #ifdef ISC_PLATFORM_HAVEIN6PKTINFO
156         if (domain == PF_INET6) {
157                 struct sockaddr_in6 sin6;
158                 unsigned int len;
159
160                 /*
161                  * Check to see if IPv6 is broken, as is common on Linux.
162                  */
163                 len = sizeof(sin6);
164                 if (getsockname(s, (struct sockaddr *)&sin6, (void *)&len) < 0)
165                 {
166                         isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
167                                       ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
168                                       "retrieving the address of an IPv6 "
169                                       "socket from the kernel failed.");
170                         isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
171                                       ISC_LOGMODULE_SOCKET, ISC_LOG_ERROR,
172                                       "IPv6 is not supported.");
173                         result = ISC_R_NOTFOUND;
174                 } else {
175                         if (len == sizeof(struct sockaddr_in6))
176                                 result = ISC_R_SUCCESS;
177                         else {
178                                 isc_log_write(isc_lctx,
179                                               ISC_LOGCATEGORY_GENERAL,
180                                               ISC_LOGMODULE_SOCKET,
181                                               ISC_LOG_ERROR,
182                                               "IPv6 structures in kernel and "
183                                               "user space do not match.");
184                                 isc_log_write(isc_lctx,
185                                               ISC_LOGCATEGORY_GENERAL,
186                                               ISC_LOGMODULE_SOCKET,
187                                               ISC_LOG_ERROR,
188                                               "IPv6 is not supported.");
189                                 result = ISC_R_NOTFOUND;
190                         }
191                 }
192         }
193 #endif
194 #endif
195 #endif
196
197         (void)close(s);
198
199         return (result);
200 }
201
202 static void
203 initialize_action(void) {
204         ipv4_result = try_proto(PF_INET);
205 #ifdef ISC_PLATFORM_HAVEIPV6
206 #ifdef WANT_IPV6
207 #ifdef ISC_PLATFORM_HAVEIN6PKTINFO
208         ipv6_result = try_proto(PF_INET6);
209 #endif
210 #endif
211 #endif
212 #ifdef ISC_PLATFORM_HAVESYSUNH
213         unix_result = try_proto(PF_UNIX);
214 #endif
215 }
216
217 static void
218 initialize(void) {
219         RUNTIME_CHECK(isc_once_do(&once, initialize_action) == ISC_R_SUCCESS);
220 }
221
222 isc_result_t
223 isc_net_probeipv4(void) {
224         initialize();
225         return (ipv4_result);
226 }
227
228 isc_result_t
229 isc_net_probeipv6(void) {
230         initialize();
231         return (ipv6_result);
232 }
233
234 isc_result_t
235 isc_net_probeunix(void) {
236         initialize();
237         return (unix_result);
238 }
239
240 #ifdef ISC_PLATFORM_HAVEIPV6
241 #ifdef WANT_IPV6
242 static void
243 try_ipv6only(void) {
244 #ifdef IPV6_V6ONLY
245         int s, on;
246         char strbuf[ISC_STRERRORSIZE];
247 #endif
248         isc_result_t result;
249
250         result = isc_net_probeipv6();
251         if (result != ISC_R_SUCCESS) {
252                 ipv6only_result = result;
253                 return;
254         }
255
256 #ifndef IPV6_V6ONLY
257         ipv6only_result = ISC_R_NOTFOUND;
258         return;
259 #else
260         /* check for TCP sockets */
261         s = socket(PF_INET6, SOCK_STREAM, 0);
262         if (s == -1) {
263                 isc__strerror(errno, strbuf, sizeof(strbuf));
264                 UNEXPECTED_ERROR(__FILE__, __LINE__,
265                                  "socket() %s: %s",
266                                  isc_msgcat_get(isc_msgcat,
267                                                 ISC_MSGSET_GENERAL,
268                                                 ISC_MSG_FAILED,
269                                                 "failed"),
270                                  strbuf);
271                 ipv6only_result = ISC_R_UNEXPECTED;
272                 return;
273         }
274
275         on = 1;
276         if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) < 0) {
277                 ipv6only_result = ISC_R_NOTFOUND;
278                 goto close;
279         }
280
281         close(s);
282
283         /* check for UDP sockets */
284         s = socket(PF_INET6, SOCK_DGRAM, 0);
285         if (s == -1) {
286                 isc__strerror(errno, strbuf, sizeof(strbuf));
287                 UNEXPECTED_ERROR(__FILE__, __LINE__,
288                                  "socket() %s: %s",
289                                  isc_msgcat_get(isc_msgcat,
290                                                 ISC_MSGSET_GENERAL,
291                                                 ISC_MSG_FAILED,
292                                                 "failed"),
293                                  strbuf);
294                 ipv6only_result = ISC_R_UNEXPECTED;
295                 return;
296         }
297
298         on = 1;
299         if (setsockopt(s, IPPROTO_IPV6, IPV6_V6ONLY, &on, sizeof(on)) < 0) {
300                 ipv6only_result = ISC_R_NOTFOUND;
301                 goto close;
302         }
303
304         close(s);
305
306         ipv6only_result = ISC_R_SUCCESS;
307
308 close:
309         close(s);
310         return;
311 #endif /* IPV6_V6ONLY */
312 }
313
314 static void
315 initialize_ipv6only(void) {
316         RUNTIME_CHECK(isc_once_do(&once_ipv6only,
317                                   try_ipv6only) == ISC_R_SUCCESS);
318 }
319 #endif /* WANT_IPV6 */
320
321 #ifdef ISC_PLATFORM_HAVEIN6PKTINFO
322 static void
323 try_ipv6pktinfo(void) {
324         int s, on;
325         char strbuf[ISC_STRERRORSIZE];
326         isc_result_t result;
327         int optname;
328
329         result = isc_net_probeipv6();
330         if (result != ISC_R_SUCCESS) {
331                 ipv6pktinfo_result = result;
332                 return;
333         }
334
335         /* we only use this for UDP sockets */
336         s = socket(PF_INET6, SOCK_DGRAM, IPPROTO_UDP);
337         if (s == -1) {
338                 isc__strerror(errno, strbuf, sizeof(strbuf));
339                 UNEXPECTED_ERROR(__FILE__, __LINE__,
340                                  "socket() %s: %s",
341                                  isc_msgcat_get(isc_msgcat,
342                                                 ISC_MSGSET_GENERAL,
343                                                 ISC_MSG_FAILED,
344                                                 "failed"),
345                                  strbuf);
346                 ipv6pktinfo_result = ISC_R_UNEXPECTED;
347                 return;
348         }
349
350 #ifdef IPV6_RECVPKTINFO
351         optname = IPV6_RECVPKTINFO;
352 #else
353         optname = IPV6_PKTINFO;
354 #endif
355         on = 1;
356         if (setsockopt(s, IPPROTO_IPV6, optname, &on, sizeof(on)) < 0) {
357                 ipv6pktinfo_result = ISC_R_NOTFOUND;
358                 goto close;
359         }
360
361         close(s);
362         ipv6pktinfo_result = ISC_R_SUCCESS;
363
364 close:
365         close(s);
366         return;
367 }
368
369 static void
370 initialize_ipv6pktinfo(void) {
371         RUNTIME_CHECK(isc_once_do(&once_ipv6pktinfo,
372                                   try_ipv6pktinfo) == ISC_R_SUCCESS);
373 }
374 #endif /* ISC_PLATFORM_HAVEIN6PKTINFO */
375 #endif /* ISC_PLATFORM_HAVEIPV6 */
376
377 isc_result_t
378 isc_net_probe_ipv6only(void) {
379 #ifdef ISC_PLATFORM_HAVEIPV6
380 #ifdef WANT_IPV6
381         initialize_ipv6only();
382 #else
383         ipv6only_result = ISC_R_NOTFOUND;
384 #endif
385 #endif
386         return (ipv6only_result);
387 }
388
389 isc_result_t
390 isc_net_probe_ipv6pktinfo(void) {
391 #ifdef ISC_PLATFORM_HAVEIPV6
392 #ifdef ISC_PLATFORM_HAVEIN6PKTINFO
393 #ifdef WANT_IPV6
394         initialize_ipv6pktinfo();
395 #else
396         ipv6pktinfo_result = ISC_R_NOTFOUND;
397 #endif
398 #endif
399 #endif
400         return (ipv6pktinfo_result);
401 }
402
403 #if defined(USE_SYSCTL_PORTRANGE)
404 #if defined(HAVE_SYSCTLBYNAME)
405 static isc_result_t
406 getudpportrange_sysctl(int af, in_port_t *low, in_port_t *high) {
407         int port_low, port_high;
408         size_t portlen;
409         const char *sysctlname_lowport, *sysctlname_hiport;
410
411         if (af == AF_INET) {
412                 sysctlname_lowport = SYSCTL_V4PORTRANGE_LOW;
413                 sysctlname_hiport = SYSCTL_V4PORTRANGE_HIGH;
414         } else {
415                 sysctlname_lowport = SYSCTL_V6PORTRANGE_LOW;
416                 sysctlname_hiport = SYSCTL_V6PORTRANGE_HIGH;
417         }
418         portlen = sizeof(portlen);
419         if (sysctlbyname(sysctlname_lowport, &port_low, &portlen,
420                          NULL, 0) < 0) {
421                 return (ISC_R_FAILURE);
422         }
423         portlen = sizeof(portlen);
424         if (sysctlbyname(sysctlname_hiport, &port_high, &portlen,
425                          NULL, 0) < 0) {
426                 return (ISC_R_FAILURE);
427         }
428         if ((port_low & ~0xffff) != 0 || (port_high & ~0xffff) != 0)
429                 return (ISC_R_RANGE);
430
431         *low = (in_port_t)port_low;
432         *high = (in_port_t)port_high;
433
434         return (ISC_R_SUCCESS);
435 }
436 #else /* !HAVE_SYSCTLBYNAME */
437 static isc_result_t
438 getudpportrange_sysctl(int af, in_port_t *low, in_port_t *high) {
439         int mib_lo4[4] = SYSCTL_V4PORTRANGE_LOW;
440         int mib_hi4[4] = SYSCTL_V4PORTRANGE_HIGH;
441         int mib_lo6[4] = SYSCTL_V6PORTRANGE_LOW;
442         int mib_hi6[4] = SYSCTL_V6PORTRANGE_HIGH;
443         int *mib_lo, *mib_hi, miblen;
444         int port_low, port_high;
445         size_t portlen;
446
447         if (af == AF_INET) {
448                 mib_lo = mib_lo4;
449                 mib_hi = mib_hi4;
450                 miblen = sizeof(mib_lo4) / sizeof(mib_lo4[0]);
451         } else {
452                 mib_lo = mib_lo6;
453                 mib_hi = mib_hi6;
454                 miblen = sizeof(mib_lo6) / sizeof(mib_lo6[0]);
455         }
456
457         portlen = sizeof(portlen);
458         if (sysctl(mib_lo, miblen, &port_low, &portlen, NULL, 0) < 0) {
459                 return (ISC_R_FAILURE);
460         }
461
462         portlen = sizeof(portlen);
463         if (sysctl(mib_hi, miblen, &port_high, &portlen, NULL, 0) < 0) {
464                 return (ISC_R_FAILURE);
465         }
466
467         if ((port_low & ~0xffff) != 0 || (port_high & ~0xffff) != 0)
468                 return (ISC_R_RANGE);
469
470         *low = (in_port_t) port_low;
471         *high = (in_port_t) port_high;
472
473         return (ISC_R_SUCCESS);
474 }
475 #endif /* HAVE_SYSCTLBYNAME */
476 #endif /* USE_SYSCTL_PORTRANGE */
477
478 isc_result_t
479 isc_net_getudpportrange(int af, in_port_t *low, in_port_t *high) {
480         int result = ISC_R_FAILURE;
481
482         REQUIRE(low != NULL && high != NULL);
483
484 #if defined(USE_SYSCTL_PORTRANGE)
485         result = getudpportrange_sysctl(af, low, high);
486 #else
487         UNUSED(af);
488 #endif
489
490         if (result != ISC_R_SUCCESS) {
491                 *low = ISC_NET_PORTRANGELOW;
492                 *high = ISC_NET_PORTRANGEHIGH;
493         }
494
495         return (ISC_R_SUCCESS); /* we currently never fail in this function */
496 }
497
498 void
499 isc_net_disableipv4(void) {
500         initialize();
501         if (ipv4_result == ISC_R_SUCCESS)
502                 ipv4_result = ISC_R_DISABLED;
503 }
504
505 void
506 isc_net_disableipv6(void) {
507         initialize();
508         if (ipv6_result == ISC_R_SUCCESS)
509                 ipv6_result = ISC_R_DISABLED;
510 }
511
512 void
513 isc_net_enableipv4(void) {
514         initialize();
515         if (ipv4_result == ISC_R_DISABLED)
516                 ipv4_result = ISC_R_SUCCESS;
517 }
518
519 void
520 isc_net_enableipv6(void) {
521         initialize();
522         if (ipv6_result == ISC_R_DISABLED)
523                 ipv6_result = ISC_R_SUCCESS;
524 }