?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Detect FPU by checking CPUID features.
[dragonfly.git] / contrib / bind-9.5.2 / lib / isc / unix / ifiter_ioctl.c
blob1096e3e82b52ae35569964099ade705026580881
1 /*
2 * Copyright (C) 2004-2007, 2009 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: ifiter_ioctl.c,v 1.58.90.3 2009/02/16 00:53:58 marka Exp $ */
19
20 /*! \file
21 * \brief
22 * Obtain the list of network interfaces using the SIOCGLIFCONF ioctl.
23 * See netintro(4).
24 */
25
26 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
27 #ifdef ISC_PLATFORM_HAVEIF_LADDRCONF
28 #define lifc_len iflc_len
29 #define lifc_buf iflc_buf
30 #define lifc_req iflc_req
31 #define LIFCONF if_laddrconf
32 #else
33 #define ISC_HAVE_LIFC_FAMILY 1
34 #define ISC_HAVE_LIFC_FLAGS 1
35 #define LIFCONF lifconf
36 #endif
37
38 #ifdef ISC_PLATFORM_HAVEIF_LADDRREQ
39 #define lifr_addr iflr_addr
40 #define lifr_name iflr_name
41 #define lifr_dstaddr iflr_dstaddr
42 #define lifr_flags iflr_flags
43 #define ss_family sa_family
44 #define LIFREQ if_laddrreq
45 #else
46 #define LIFREQ lifreq
47 #endif
48 #endif
49
50 #define IFITER_MAGIC ISC_MAGIC('I', 'F', 'I', 'T')
51 #define VALID_IFITER(t) ISC_MAGIC_VALID(t, IFITER_MAGIC)
52
53 #define ISC_IF_INET6_SZ \
54 sizeof("00000000000000000000000000000001 01 80 10 80 XXXXXXloXXXXXXXX\n")
55
56 struct isc_interfaceiter {
57 unsigned int magic; /* Magic number. */
58 isc_mem_t *mctx;
59 int mode;
60 int socket;
61 struct ifconf ifc;
62 void *buf; /* Buffer for sysctl data. */
63 unsigned int bufsize; /* Bytes allocated. */
64 unsigned int pos; /* Current offset in
65 SIOCGIFCONF data */
66 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
67 int socket6;
68 struct LIFCONF lifc;
69 void *buf6; /* Buffer for sysctl data. */
70 unsigned int bufsize6; /* Bytes allocated. */
71 unsigned int pos6; /* Current offset in
72 SIOCGLIFCONF data */
73 isc_result_t result6; /* Last result code. */
74 isc_boolean_t first6;
75 #endif
76 #ifdef HAVE_TRUCLUSTER
77 int clua_context; /* Cluster alias context */
78 isc_boolean_t clua_done;
79 struct sockaddr clua_sa;
80 #endif
81 #ifdef __linux
82 FILE * proc;
83 char entry[ISC_IF_INET6_SZ];
84 isc_result_t valid;
85 isc_boolean_t first;
86 #endif
87 isc_interface_t current; /* Current interface data. */
88 isc_result_t result; /* Last result code. */
89 };
90
91 #ifdef HAVE_TRUCLUSTER
92 #include <clua/clua.h>
93 #include <sys/socket.h>
94 #endif
95
96
97 /*%
98 * Size of buffer for SIOCGLIFCONF, in bytes. We assume no sane system
99 * will have more than a megabyte of interface configuration data.
100 */
101 #define IFCONF_BUFSIZE_INITIAL 4096
102 #define IFCONF_BUFSIZE_MAX 1048576
103
104 #ifdef __linux
105 #ifndef IF_NAMESIZE
106 # ifdef IFNAMSIZ
107 # define IF_NAMESIZE IFNAMSIZ
108 # else
109 # define IF_NAMESIZE 16
110 # endif
111 #endif
112 #endif
113
114 static isc_result_t
115 getbuf4(isc_interfaceiter_t *iter) {
116 char strbuf[ISC_STRERRORSIZE];
117
118 iter->bufsize = IFCONF_BUFSIZE_INITIAL;
119
120 for (;;) {
121 iter->buf = isc_mem_get(iter->mctx, iter->bufsize);
122 if (iter->buf == NULL)
123 return (ISC_R_NOMEMORY);
124
125 memset(&iter->ifc.ifc_len, 0, sizeof(iter->ifc.ifc_len));
126 iter->ifc.ifc_len = iter->bufsize;
127 iter->ifc.ifc_buf = iter->buf;
128 /*
129 * Ignore the HP/UX warning about "integer overflow during
130 * conversion". It comes from its own macro definition,
131 * and is really hard to shut up.
132 */
133 if (ioctl(iter->socket, SIOCGIFCONF, (char *)&iter->ifc)
134 == -1) {
135 if (errno != EINVAL) {
136 isc__strerror(errno, strbuf, sizeof(strbuf));
137 UNEXPECTED_ERROR(__FILE__, __LINE__,
138 isc_msgcat_get(isc_msgcat,
139 ISC_MSGSET_IFITERIOCTL,
140 ISC_MSG_GETIFCONFIG,
141 "get interface "
142 "configuration: %s"),
143 strbuf);
144 goto unexpected;
145 }
146 /*
147 * EINVAL. Retry with a bigger buffer.
148 */
149 } else {
150 /*
151 * The ioctl succeeded.
152 * Some OS's just return what will fit rather
153 * than set EINVAL if the buffer is too small
154 * to fit all the interfaces in. If
155 * ifc.lifc_len is too near to the end of the
156 * buffer we will grow it just in case and
157 * retry.
158 */
159 if (iter->ifc.ifc_len + 2 * sizeof(struct ifreq)
160 < iter->bufsize)
161 break;
162 }
163 if (iter->bufsize >= IFCONF_BUFSIZE_MAX) {
164 UNEXPECTED_ERROR(__FILE__, __LINE__,
165 isc_msgcat_get(isc_msgcat,
166 ISC_MSGSET_IFITERIOCTL,
167 ISC_MSG_BUFFERMAX,
168 "get interface "
169 "configuration: "
170 "maximum buffer "
171 "size exceeded"));
172 goto unexpected;
173 }
174 isc_mem_put(iter->mctx, iter->buf, iter->bufsize);
175
176 iter->bufsize *= 2;
177 }
178 return (ISC_R_SUCCESS);
179
180 unexpected:
181 isc_mem_put(iter->mctx, iter->buf, iter->bufsize);
182 iter->buf = NULL;
183 return (ISC_R_UNEXPECTED);
184 }
185
186 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
187 static isc_result_t
188 getbuf6(isc_interfaceiter_t *iter) {
189 char strbuf[ISC_STRERRORSIZE];
190 isc_result_t result;
191
192 iter->bufsize6 = IFCONF_BUFSIZE_INITIAL;
193
194 for (;;) {
195 iter->buf6 = isc_mem_get(iter->mctx, iter->bufsize6);
196 if (iter->buf6 == NULL)
197 return (ISC_R_NOMEMORY);
198
199 memset(&iter->lifc, 0, sizeof(iter->lifc));
200 #ifdef ISC_HAVE_LIFC_FAMILY
201 iter->lifc.lifc_family = AF_INET6;
202 #endif
203 #ifdef ISC_HAVE_LIFC_FLAGS
204 iter->lifc.lifc_flags = 0;
205 #endif
206 iter->lifc.lifc_len = iter->bufsize6;
207 iter->lifc.lifc_buf = iter->buf6;
208 /*
209 * Ignore the HP/UX warning about "integer overflow during
210 * conversion". It comes from its own macro definition,
211 * and is really hard to shut up.
212 */
213 if (ioctl(iter->socket6, SIOCGLIFCONF, (char *)&iter->lifc)
214 == -1) {
215 #ifdef __hpux
216 /*
217 * IPv6 interface scanning is not available on all
218 * kernels w/ IPv6 sockets.
219 */
220 if (errno == ENOENT) {
221 isc__strerror(errno, strbuf, sizeof(strbuf));
222 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
223 ISC_LOGMODULE_INTERFACE,
224 ISC_LOG_DEBUG(1),
225 isc_msgcat_get(isc_msgcat,
226 ISC_MSGSET_IFITERIOCTL,
227 ISC_MSG_GETIFCONFIG,
228 "get interface "
229 "configuration: %s"),
230 strbuf);
231 result = ISC_R_FAILURE;
232 goto cleanup;
233 }
234 #endif
235 if (errno != EINVAL) {
236 isc__strerror(errno, strbuf, sizeof(strbuf));
237 UNEXPECTED_ERROR(__FILE__, __LINE__,
238 isc_msgcat_get(isc_msgcat,
239 ISC_MSGSET_IFITERIOCTL,
240 ISC_MSG_GETIFCONFIG,
241 "get interface "
242 "configuration: %s"),
243 strbuf);
244 result = ISC_R_UNEXPECTED;
245 goto cleanup;
246 }
247 /*
248 * EINVAL. Retry with a bigger buffer.
249 */
250 } else {
251 /*
252 * The ioctl succeeded.
253 * Some OS's just return what will fit rather
254 * than set EINVAL if the buffer is too small
255 * to fit all the interfaces in. If
256 * ifc.ifc_len is too near to the end of the
257 * buffer we will grow it just in case and
258 * retry.
259 */
260 if (iter->lifc.lifc_len + 2 * sizeof(struct LIFREQ)
261 < iter->bufsize6)
262 break;
263 }
264 if (iter->bufsize6 >= IFCONF_BUFSIZE_MAX) {
265 UNEXPECTED_ERROR(__FILE__, __LINE__,
266 isc_msgcat_get(isc_msgcat,
267 ISC_MSGSET_IFITERIOCTL,
268 ISC_MSG_BUFFERMAX,
269 "get interface "
270 "configuration: "
271 "maximum buffer "
272 "size exceeded"));
273 result = ISC_R_UNEXPECTED;
274 goto cleanup;
275 }
276 isc_mem_put(iter->mctx, iter->buf6, iter->bufsize6);
277
278 iter->bufsize6 *= 2;
279 }
280
281 if (iter->lifc.lifc_len != 0)
282 iter->mode = 6;
283 return (ISC_R_SUCCESS);
284
285 cleanup:
286 isc_mem_put(iter->mctx, iter->buf6, iter->bufsize6);
287 iter->buf6 = NULL;
288 return (result);
289 }
290 #endif
291
292 isc_result_t
293 isc_interfaceiter_create(isc_mem_t *mctx, isc_interfaceiter_t **iterp) {
294 isc_interfaceiter_t *iter;
295 isc_result_t result;
296 char strbuf[ISC_STRERRORSIZE];
297
298 REQUIRE(mctx != NULL);
299 REQUIRE(iterp != NULL);
300 REQUIRE(*iterp == NULL);
301
302 iter = isc_mem_get(mctx, sizeof(*iter));
303 if (iter == NULL)
304 return (ISC_R_NOMEMORY);
305
306 iter->mctx = mctx;
307 iter->mode = 4;
308 iter->buf = NULL;
309 iter->pos = (unsigned int) -1;
310 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
311 iter->buf6 = NULL;
312 iter->pos6 = (unsigned int) -1;
313 iter->result6 = ISC_R_NOMORE;
314 iter->socket6 = -1;
315 iter->first6 = ISC_FALSE;
316 #endif
317
318 /*
319 * Get the interface configuration, allocating more memory if
320 * necessary.
321 */
322
323 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
324 result = isc_net_probeipv6();
325 if (result == ISC_R_SUCCESS) {
326 /*
327 * Create an unbound datagram socket to do the SIOCGLIFCONF
328 * ioctl on. HP/UX requires an AF_INET6 socket for
329 * SIOCGLIFCONF to get IPv6 addresses.
330 */
331 if ((iter->socket6 = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
332 isc__strerror(errno, strbuf, sizeof(strbuf));
333 UNEXPECTED_ERROR(__FILE__, __LINE__,
334 isc_msgcat_get(isc_msgcat,
335 ISC_MSGSET_IFITERIOCTL,
336 ISC_MSG_MAKESCANSOCKET,
337 "making interface "
338 "scan socket: %s"),
339 strbuf);
340 result = ISC_R_UNEXPECTED;
341 goto socket6_failure;
342 }
343 result = iter->result6 = getbuf6(iter);
344 if (result != ISC_R_NOTIMPLEMENTED && result != ISC_R_SUCCESS)
345 goto ioctl6_failure;
346 }
347 #endif
348 if ((iter->socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
349 isc__strerror(errno, strbuf, sizeof(strbuf));
350 UNEXPECTED_ERROR(__FILE__, __LINE__,
351 isc_msgcat_get(isc_msgcat,
352 ISC_MSGSET_IFITERIOCTL,
353 ISC_MSG_MAKESCANSOCKET,
354 "making interface "
355 "scan socket: %s"),
356 strbuf);
357 result = ISC_R_UNEXPECTED;
358 goto socket_failure;
359 }
360 result = getbuf4(iter);
361 if (result != ISC_R_SUCCESS)
362 goto ioctl_failure;
363
364 /*
365 * A newly created iterator has an undefined position
366 * until isc_interfaceiter_first() is called.
367 */
368 #ifdef HAVE_TRUCLUSTER
369 iter->clua_context = -1;
370 iter->clua_done = ISC_TRUE;
371 #endif
372 #ifdef __linux
373 iter->proc = fopen("/proc/net/if_inet6", "r");
374 iter->valid = ISC_R_FAILURE;
375 iter->first = ISC_FALSE;
376 #endif
377 iter->result = ISC_R_FAILURE;
378
379 iter->magic = IFITER_MAGIC;
380 *iterp = iter;
381 return (ISC_R_SUCCESS);
382
383 ioctl_failure:
384 if (iter->buf != NULL)
385 isc_mem_put(mctx, iter->buf, iter->bufsize);
386 (void) close(iter->socket);
387
388 socket_failure:
389 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
390 if (iter->buf6 != NULL)
391 isc_mem_put(mctx, iter->buf6, iter->bufsize6);
392 ioctl6_failure:
393 if (iter->socket6 != -1)
394 (void) close(iter->socket6);
395 socket6_failure:
396 #endif
397
398 isc_mem_put(mctx, iter, sizeof(*iter));
399 return (result);
400 }
401
402 #ifdef HAVE_TRUCLUSTER
403 static void
404 get_inaddr(isc_netaddr_t *dst, struct in_addr *src) {
405 dst->family = AF_INET;
406 memcpy(&dst->type.in, src, sizeof(struct in_addr));
407 }
408
409 static isc_result_t
410 internal_current_clusteralias(isc_interfaceiter_t *iter) {
411 struct clua_info ci;
412 if (clua_getaliasinfo(&iter->clua_sa, &ci) != CLUA_SUCCESS)
413 return (ISC_R_IGNORE);
414 memset(&iter->current, 0, sizeof(iter->current));
415 iter->current.af = iter->clua_sa.sa_family;
416 memset(iter->current.name, 0, sizeof(iter->current.name));
417 sprintf(iter->current.name, "clua%d", ci.aliasid);
418 iter->current.flags = INTERFACE_F_UP;
419 get_inaddr(&iter->current.address, &ci.addr);
420 get_inaddr(&iter->current.netmask, &ci.netmask);
421 return (ISC_R_SUCCESS);
422 }
423 #endif
424
425 #ifdef __linux
426 static isc_result_t
427 linux_if_inet6_next(isc_interfaceiter_t *iter) {
428 if (iter->proc != NULL &&
429 fgets(iter->entry, sizeof(iter->entry), iter->proc) != NULL)
430 iter->valid = ISC_R_SUCCESS;
431 else
432 iter->valid = ISC_R_NOMORE;
433 return (iter->valid);
434 }
435
436 static void
437 linux_if_inet6_first(isc_interfaceiter_t *iter) {
438 if (iter->proc != NULL) {
439 rewind(iter->proc);
440 (void)linux_if_inet6_next(iter);
441 } else
442 iter->valid = ISC_R_NOMORE;
443 iter->first = ISC_FALSE;
444 }
445
446 static isc_result_t
447 linux_if_inet6_current(isc_interfaceiter_t *iter) {
448 char address[33];
449 char name[IF_NAMESIZE+1];
450 struct in6_addr addr6;
451 int ifindex, prefix, flag3, flag4;
452 int res;
453 unsigned int i;
454
455 if (iter->valid != ISC_R_SUCCESS)
456 return (iter->valid);
457 if (iter->proc == NULL) {
458 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
459 ISC_LOGMODULE_INTERFACE, ISC_LOG_ERROR,
460 "/proc/net/if_inet6:iter->proc == NULL");
461 return (ISC_R_FAILURE);
462 }
463
464 res = sscanf(iter->entry, "%32[a-f0-9] %x %x %x %x %16s\n",
465 address, &ifindex, &prefix, &flag3, &flag4, name);
466 if (res != 6) {
467 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
468 ISC_LOGMODULE_INTERFACE, ISC_LOG_ERROR,
469 "/proc/net/if_inet6:sscanf() -> %d (expected 6)",
470 res);
471 return (ISC_R_FAILURE);
472 }
473 if (strlen(address) != 32) {
474 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
475 ISC_LOGMODULE_INTERFACE, ISC_LOG_ERROR,
476 "/proc/net/if_inet6:strlen(%s) != 32", address);
477 return (ISC_R_FAILURE);
478 }
479 for (i = 0; i < 16; i++) {
480 unsigned char byte;
481 static const char hex[] = "0123456789abcdef";
482 byte = ((strchr(hex, address[i * 2]) - hex) << 4) |
483 (strchr(hex, address[i * 2 + 1]) - hex);
484 addr6.s6_addr[i] = byte;
485 }
486 iter->current.af = AF_INET6;
487 iter->current.flags = INTERFACE_F_UP;
488 isc_netaddr_fromin6(&iter->current.address, &addr6);
489 if (isc_netaddr_islinklocal(&iter->current.address)) {
490 isc_netaddr_setzone(&iter->current.address,
491 (isc_uint32_t)ifindex);
492 }
493 for (i = 0; i < 16; i++) {
494 if (prefix > 8) {
495 addr6.s6_addr[i] = 0xff;
496 prefix -= 8;
497 } else {
498 addr6.s6_addr[i] = (0xff << (8 - prefix)) & 0xff;
499 prefix = 0;
500 }
501 }
502 isc_netaddr_fromin6(&iter->current.netmask, &addr6);
503 strncpy(iter->current.name, name, sizeof(iter->current.name));
504 return (ISC_R_SUCCESS);
505 }
506 #endif
507
508 /*
509 * Get information about the current interface to iter->current.
510 * If successful, return ISC_R_SUCCESS.
511 * If the interface has an unsupported address family, or if
512 * some operation on it fails, return ISC_R_IGNORE to make
513 * the higher-level iterator code ignore it.
514 */
515
516 static isc_result_t
517 internal_current4(isc_interfaceiter_t *iter) {
518 struct ifreq *ifrp;
519 struct ifreq ifreq;
520 int family;
521 char strbuf[ISC_STRERRORSIZE];
522 #if !defined(ISC_PLATFORM_HAVEIF_LADDRREQ) && defined(SIOCGLIFADDR)
523 struct lifreq lifreq;
524 #else
525 char sabuf[256];
526 #endif
527 int i, bits, prefixlen;
528 #ifdef __linux
529 isc_result_t result;
530 #endif
531
532 REQUIRE(VALID_IFITER(iter));
533 REQUIRE(iter->ifc.ifc_len == 0 ||
534 iter->pos < (unsigned int) iter->ifc.ifc_len);
535
536 #ifdef __linux
537 result = linux_if_inet6_current(iter);
538 if (result != ISC_R_NOMORE)
539 return (result);
540 iter->first = ISC_TRUE;
541 #endif
542
543 if (iter->ifc.ifc_len == 0)
544 return (ISC_R_NOMORE);
545
546 ifrp = (struct ifreq *)((char *) iter->ifc.ifc_req + iter->pos);
547
548 memset(&ifreq, 0, sizeof(ifreq));
549 memcpy(&ifreq, ifrp, sizeof(ifreq));
550
551 family = ifreq.ifr_addr.sa_family;
552 #if defined(ISC_PLATFORM_HAVEIPV6)
553 if (family != AF_INET && family != AF_INET6)
554 #else
555 if (family != AF_INET)
556 #endif
557 return (ISC_R_IGNORE);
558
559 memset(&iter->current, 0, sizeof(iter->current));
560 iter->current.af = family;
561
562 INSIST(sizeof(ifreq.ifr_name) <= sizeof(iter->current.name));
563 memset(iter->current.name, 0, sizeof(iter->current.name));
564 memcpy(iter->current.name, ifreq.ifr_name, sizeof(ifreq.ifr_name));
565
566 get_addr(family, &iter->current.address,
567 (struct sockaddr *)&ifrp->ifr_addr, ifreq.ifr_name);
568
569 /*
570 * If the interface does not have a address ignore it.
571 */
572 switch (family) {
573 case AF_INET:
574 if (iter->current.address.type.in.s_addr == htonl(INADDR_ANY))
575 return (ISC_R_IGNORE);
576 break;
577 case AF_INET6:
578 if (memcmp(&iter->current.address.type.in6, &in6addr_any,
579 sizeof(in6addr_any)) == 0)
580 return (ISC_R_IGNORE);
581 break;
582 }
583
584 /*
585 * Get interface flags.
586 */
587
588 iter->current.flags = 0;
589
590 /*
591 * Ignore the HP/UX warning about "integer overflow during
592 * conversion. It comes from its own macro definition,
593 * and is really hard to shut up.
594 */
595 if (ioctl(iter->socket, SIOCGIFFLAGS, (char *) &ifreq) < 0) {
596 isc__strerror(errno, strbuf, sizeof(strbuf));
597 UNEXPECTED_ERROR(__FILE__, __LINE__,
598 "%s: getting interface flags: %s",
599 ifreq.ifr_name, strbuf);
600 return (ISC_R_IGNORE);
601 }
602
603 if ((ifreq.ifr_flags & IFF_UP) != 0)
604 iter->current.flags |= INTERFACE_F_UP;
605
606 #ifdef IFF_POINTOPOINT
607 if ((ifreq.ifr_flags & IFF_POINTOPOINT) != 0)
608 iter->current.flags |= INTERFACE_F_POINTTOPOINT;
609 #endif
610
611 if ((ifreq.ifr_flags & IFF_LOOPBACK) != 0)
612 iter->current.flags |= INTERFACE_F_LOOPBACK;
613
614 if (family == AF_INET)
615 goto inet;
616
617 #if !defined(ISC_PLATFORM_HAVEIF_LADDRREQ) && defined(SIOCGLIFADDR)
618 memset(&lifreq, 0, sizeof(lifreq));
619 memcpy(lifreq.lifr_name, iter->current.name, sizeof(lifreq.lifr_name));
620 memcpy(&lifreq.lifr_addr, &iter->current.address.type.in6,
621 sizeof(iter->current.address.type.in6));
622
623 if (ioctl(iter->socket, SIOCGLIFADDR, &lifreq) < 0) {
624 isc__strerror(errno, strbuf, sizeof(strbuf));
625 UNEXPECTED_ERROR(__FILE__, __LINE__,
626 "%s: getting interface address: %s",
627 ifreq.ifr_name, strbuf);
628 return (ISC_R_IGNORE);
629 }
630 prefixlen = lifreq.lifr_addrlen;
631 #else
632 isc_netaddr_format(&iter->current.address, sabuf, sizeof(sabuf));
633 isc_log_write(isc_lctx, ISC_LOGCATEGORY_GENERAL,
634 ISC_LOGMODULE_INTERFACE,
635 ISC_LOG_INFO,
636 isc_msgcat_get(isc_msgcat,
637 ISC_MSGSET_IFITERIOCTL,
638 ISC_MSG_GETIFCONFIG,
639 "prefix length for %s is unknown "
640 "(assume 128)"), sabuf);
641 prefixlen = 128;
642 #endif
643
644 /*
645 * Netmask already zeroed.
646 */
647 iter->current.netmask.family = family;
648 for (i = 0; i < 16; i++) {
649 if (prefixlen > 8) {
650 bits = 0;
651 prefixlen -= 8;
652 } else {
653 bits = 8 - prefixlen;
654 prefixlen = 0;
655 }
656 iter->current.netmask.type.in6.s6_addr[i] = (~0 << bits) & 0xff;
657 }
658 return (ISC_R_SUCCESS);
659
660 inet:
661 if (family != AF_INET)
662 return (ISC_R_IGNORE);
663 #ifdef IFF_POINTOPOINT
664 /*
665 * If the interface is point-to-point, get the destination address.
666 */
667 if ((iter->current.flags & INTERFACE_F_POINTTOPOINT) != 0) {
668 /*
669 * Ignore the HP/UX warning about "integer overflow during
670 * conversion. It comes from its own macro definition,
671 * and is really hard to shut up.
672 */
673 if (ioctl(iter->socket, SIOCGIFDSTADDR, (char *)&ifreq)
674 < 0) {
675 isc__strerror(errno, strbuf, sizeof(strbuf));
676 UNEXPECTED_ERROR(__FILE__, __LINE__,
677 isc_msgcat_get(isc_msgcat,
678 ISC_MSGSET_IFITERIOCTL,
679 ISC_MSG_GETDESTADDR,
680 "%s: getting "
681 "destination address: %s"),
682 ifreq.ifr_name, strbuf);
683 return (ISC_R_IGNORE);
684 }
685 get_addr(family, &iter->current.dstaddress,
686 (struct sockaddr *)&ifreq.ifr_dstaddr, ifreq.ifr_name);
687 }
688 #endif
689
690 /*
691 * Get the network mask.
692 */
693 memset(&ifreq, 0, sizeof(ifreq));
694 memcpy(&ifreq, ifrp, sizeof(ifreq));
695 /*
696 * Ignore the HP/UX warning about "integer overflow during
697 * conversion. It comes from its own macro definition,
698 * and is really hard to shut up.
699 */
700 if (ioctl(iter->socket, SIOCGIFNETMASK, (char *)&ifreq) < 0) {
701 isc__strerror(errno, strbuf, sizeof(strbuf));
702 UNEXPECTED_ERROR(__FILE__, __LINE__,
703 isc_msgcat_get(isc_msgcat,
704 ISC_MSGSET_IFITERIOCTL,
705 ISC_MSG_GETNETMASK,
706 "%s: getting netmask: %s"),
707 ifreq.ifr_name, strbuf);
708 return (ISC_R_IGNORE);
709 }
710 get_addr(family, &iter->current.netmask,
711 (struct sockaddr *)&ifreq.ifr_addr, ifreq.ifr_name);
712 return (ISC_R_SUCCESS);
713 }
714
715 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
716 static isc_result_t
717 internal_current6(isc_interfaceiter_t *iter) {
718 struct LIFREQ *ifrp;
719 struct LIFREQ lifreq;
720 int family;
721 char strbuf[ISC_STRERRORSIZE];
722 int fd;
723
724 REQUIRE(VALID_IFITER(iter));
725 if (iter->result6 != ISC_R_SUCCESS)
726 return (iter->result6);
727 REQUIRE(iter->pos6 < (unsigned int) iter->lifc.lifc_len);
728
729 ifrp = (struct LIFREQ *)((char *) iter->lifc.lifc_req + iter->pos6);
730
731 memset(&lifreq, 0, sizeof(lifreq));
732 memcpy(&lifreq, ifrp, sizeof(lifreq));
733
734 family = lifreq.lifr_addr.ss_family;
735 #ifdef ISC_PLATFORM_HAVEIPV6
736 if (family != AF_INET && family != AF_INET6)
737 #else
738 if (family != AF_INET)
739 #endif
740 return (ISC_R_IGNORE);
741
742 memset(&iter->current, 0, sizeof(iter->current));
743 iter->current.af = family;
744
745 INSIST(sizeof(lifreq.lifr_name) <= sizeof(iter->current.name));
746 memset(iter->current.name, 0, sizeof(iter->current.name));
747 memcpy(iter->current.name, lifreq.lifr_name, sizeof(lifreq.lifr_name));
748
749 get_addr(family, &iter->current.address,
750 (struct sockaddr *)&lifreq.lifr_addr, lifreq.lifr_name);
751
752 /*
753 * If the interface does not have a address ignore it.
754 */
755 switch (family) {
756 case AF_INET:
757 if (iter->current.address.type.in.s_addr == htonl(INADDR_ANY))
758 return (ISC_R_IGNORE);
759 break;
760 case AF_INET6:
761 if (memcmp(&iter->current.address.type.in6, &in6addr_any,
762 sizeof(in6addr_any)) == 0)
763 return (ISC_R_IGNORE);
764 break;
765 }
766
767 /*
768 * Get interface flags.
769 */
770
771 iter->current.flags = 0;
772
773 if (family == AF_INET6)
774 fd = iter->socket6;
775 else
776 fd = iter->socket;
777
778 /*
779 * Ignore the HP/UX warning about "integer overflow during
780 * conversion. It comes from its own macro definition,
781 * and is really hard to shut up.
782 */
783 if (ioctl(fd, SIOCGLIFFLAGS, (char *) &lifreq) < 0) {
784 isc__strerror(errno, strbuf, sizeof(strbuf));
785 UNEXPECTED_ERROR(__FILE__, __LINE__,
786 "%s: getting interface flags: %s",
787 lifreq.lifr_name, strbuf);
788 return (ISC_R_IGNORE);
789 }
790
791 if ((lifreq.lifr_flags & IFF_UP) != 0)
792 iter->current.flags |= INTERFACE_F_UP;
793
794 #ifdef IFF_POINTOPOINT
795 if ((lifreq.lifr_flags & IFF_POINTOPOINT) != 0)
796 iter->current.flags |= INTERFACE_F_POINTTOPOINT;
797 #endif
798
799 if ((lifreq.lifr_flags & IFF_LOOPBACK) != 0)
800 iter->current.flags |= INTERFACE_F_LOOPBACK;
801
802 #ifdef IFF_POINTOPOINT
803 /*
804 * If the interface is point-to-point, get the destination address.
805 */
806 if ((iter->current.flags & INTERFACE_F_POINTTOPOINT) != 0) {
807 /*
808 * Ignore the HP/UX warning about "integer overflow during
809 * conversion. It comes from its own macro definition,
810 * and is really hard to shut up.
811 */
812 if (ioctl(fd, SIOCGLIFDSTADDR, (char *)&lifreq)
813 < 0) {
814 isc__strerror(errno, strbuf, sizeof(strbuf));
815 UNEXPECTED_ERROR(__FILE__, __LINE__,
816 isc_msgcat_get(isc_msgcat,
817 ISC_MSGSET_IFITERIOCTL,
818 ISC_MSG_GETDESTADDR,
819 "%s: getting "
820 "destination address: %s"),
821 lifreq.lifr_name, strbuf);
822 return (ISC_R_IGNORE);
823 }
824 get_addr(family, &iter->current.dstaddress,
825 (struct sockaddr *)&lifreq.lifr_dstaddr,
826 lifreq.lifr_name);
827 }
828 #endif
829
830 /*
831 * Get the network mask. Netmask already zeroed.
832 */
833 memset(&lifreq, 0, sizeof(lifreq));
834 memcpy(&lifreq, ifrp, sizeof(lifreq));
835
836 #ifdef lifr_addrlen
837 /*
838 * Special case: if the system provides lifr_addrlen member, the
839 * netmask of an IPv6 address can be derived from the length, since
840 * an IPv6 address always has a contiguous mask.
841 */
842 if (family == AF_INET6) {
843 int i, bits;
844
845 iter->current.netmask.family = family;
846 for (i = 0; i < lifreq.lifr_addrlen; i += 8) {
847 bits = lifreq.lifr_addrlen - i;
848 bits = (bits < 8) ? (8 - bits) : 0;
849 iter->current.netmask.type.in6.s6_addr[i / 8] =
850 (~0 << bits) & 0xff;
851 }
852
853 return (ISC_R_SUCCESS);
854 }
855 #endif
856
857 /*
858 * Ignore the HP/UX warning about "integer overflow during
859 * conversion. It comes from its own macro definition,
860 * and is really hard to shut up.
861 */
862 if (ioctl(fd, SIOCGLIFNETMASK, (char *)&lifreq) < 0) {
863 isc__strerror(errno, strbuf, sizeof(strbuf));
864 UNEXPECTED_ERROR(__FILE__, __LINE__,
865 isc_msgcat_get(isc_msgcat,
866 ISC_MSGSET_IFITERIOCTL,
867 ISC_MSG_GETNETMASK,
868 "%s: getting netmask: %s"),
869 lifreq.lifr_name, strbuf);
870 return (ISC_R_IGNORE);
871 }
872 get_addr(family, &iter->current.netmask,
873 (struct sockaddr *)&lifreq.lifr_addr, lifreq.lifr_name);
874
875 return (ISC_R_SUCCESS);
876 }
877 #endif
878
879 static isc_result_t
880 internal_current(isc_interfaceiter_t *iter) {
881 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
882 if (iter->mode == 6) {
883 iter->result6 = internal_current6(iter);
884 if (iter->result6 != ISC_R_NOMORE)
885 return (iter->result6);
886 }
887 #endif
888 #ifdef HAVE_TRUCLUSTER
889 if (!iter->clua_done)
890 return(internal_current_clusteralias(iter));
891 #endif
892 return (internal_current4(iter));
893 }
894
895 /*
896 * Step the iterator to the next interface. Unlike
897 * isc_interfaceiter_next(), this may leave the iterator
898 * positioned on an interface that will ultimately
899 * be ignored. Return ISC_R_NOMORE if there are no more
900 * interfaces, otherwise ISC_R_SUCCESS.
901 */
902 static isc_result_t
903 internal_next4(isc_interfaceiter_t *iter) {
904 #ifdef ISC_PLATFORM_HAVESALEN
905 struct ifreq *ifrp;
906 #endif
907
908 REQUIRE(iter->ifc.ifc_len == 0 ||
909 iter->pos < (unsigned int) iter->ifc.ifc_len);
910
911 #ifdef __linux
912 if (linux_if_inet6_next(iter) == ISC_R_SUCCESS)
913 return (ISC_R_SUCCESS);
914 if (!iter->first)
915 return (ISC_R_SUCCESS);
916 #endif
917
918 if (iter->ifc.ifc_len == 0)
919 return (ISC_R_NOMORE);
920
921 #ifdef ISC_PLATFORM_HAVESALEN
922 ifrp = (struct ifreq *)((char *) iter->ifc.ifc_req + iter->pos);
923
924 if (ifrp->ifr_addr.sa_len > sizeof(struct sockaddr))
925 iter->pos += sizeof(ifrp->ifr_name) + ifrp->ifr_addr.sa_len;
926 else
927 #endif
928 iter->pos += sizeof(struct ifreq);
929
930 if (iter->pos >= (unsigned int) iter->ifc.ifc_len)
931 return (ISC_R_NOMORE);
932
933 return (ISC_R_SUCCESS);
934 }
935
936 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
937 static isc_result_t
938 internal_next6(isc_interfaceiter_t *iter) {
939 #ifdef ISC_PLATFORM_HAVESALEN
940 struct LIFREQ *ifrp;
941 #endif
942
943 if (iter->result6 != ISC_R_SUCCESS && iter->result6 != ISC_R_IGNORE)
944 return (iter->result6);
945
946 REQUIRE(iter->pos6 < (unsigned int) iter->lifc.lifc_len);
947
948 #ifdef ISC_PLATFORM_HAVESALEN
949 ifrp = (struct LIFREQ *)((char *) iter->lifc.lifc_req + iter->pos6);
950
951 if (ifrp->lifr_addr.sa_len > sizeof(struct sockaddr))
952 iter->pos6 += sizeof(ifrp->lifr_name) + ifrp->lifr_addr.sa_len;
953 else
954 #endif
955 iter->pos6 += sizeof(struct LIFREQ);
956
957 if (iter->pos6 >= (unsigned int) iter->lifc.lifc_len)
958 return (ISC_R_NOMORE);
959
960 return (ISC_R_SUCCESS);
961 }
962 #endif
963
964 static isc_result_t
965 internal_next(isc_interfaceiter_t *iter) {
966 #ifdef HAVE_TRUCLUSTER
967 int clua_result;
968 #endif
969 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
970 if (iter->mode == 6) {
971 iter->result6 = internal_next6(iter);
972 if (iter->result6 != ISC_R_NOMORE)
973 return (iter->result6);
974 if (iter->first6) {
975 iter->first6 = ISC_FALSE;
976 return (ISC_R_SUCCESS);
977 }
978 }
979 #endif
980 #ifdef HAVE_TRUCLUSTER
981 if (!iter->clua_done) {
982 clua_result = clua_getaliasaddress(&iter->clua_sa,
983 &iter->clua_context);
984 if (clua_result != CLUA_SUCCESS)
985 iter->clua_done = ISC_TRUE;
986 return (ISC_R_SUCCESS);
987 }
988 #endif
989 return (internal_next4(iter));
990 }
991
992 static void
993 internal_destroy(isc_interfaceiter_t *iter) {
994 (void) close(iter->socket);
995 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
996 if (iter->socket6 != -1)
997 (void) close(iter->socket6);
998 if (iter->buf6 != NULL) {
999 isc_mem_put(iter->mctx, iter->buf6, iter->bufsize6);
1000 }
1001 #endif
1002 #ifdef __linux
1003 if (iter->proc != NULL)
1004 fclose(iter->proc);
1005 #endif
1006 }
1007
1008 static
1009 void internal_first(isc_interfaceiter_t *iter) {
1010 #ifdef HAVE_TRUCLUSTER
1011 int clua_result;
1012 #endif
1013 iter->pos = 0;
1014 #if defined(SIOCGLIFCONF) && defined(SIOCGLIFADDR)
1015 iter->pos6 = 0;
1016 if (iter->result6 == ISC_R_NOMORE)
1017 iter->result6 = ISC_R_SUCCESS;
1018 iter->first6 = ISC_TRUE;
1019 #endif
1020 #ifdef HAVE_TRUCLUSTER
1021 iter->clua_context = 0;
1022 clua_result = clua_getaliasaddress(&iter->clua_sa,
1023 &iter->clua_context);
1024 iter->clua_done = ISC_TF(clua_result != CLUA_SUCCESS);
1025 #endif
1026 #ifdef __linux
1027 linux_if_inet6_first(iter);
1028 #endif
1029 }
DragonFly BSD