1 /*
2 * Copyright (C) 2004, 2007-2009 Internet Systems Consortium, Inc. ("ISC")
3 * Copyright (C) 1999-2001 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: interfaceiter.c,v 1.15 2009/01/18 23:48:14 tbox Exp $ */
19
20 #include <config.h>
21
22 #include <stdio.h>
23 #include <stdlib.h>
24 #include <errno.h>
25 #include <sys/types.h>
26 #include <winsock2.h>
27 #include <ws2tcpip.h>
28 #include <gaa_compat.h>
29
30 #include <isc/interfaceiter.h>
31 #include <isc/mem.h>
32 #include <isc/result.h>
33 #include <isc/string.h>
34 #include <isc/strerror.h>
35 #include <isc/types.h>
36 #include <isc/util.h>
37 #include <isc/win32os.h>
38
39 void InitSockets(void);
40
41
42 #define IFITER_MAGIC 0x49464954U /* IFIT. */
43 #define VALID_IFITER(t) ((t) != NULL && (t)->magic == IFITER_MAGIC)
44
45 struct isc_interfaceiter {
46 unsigned int magic; /* Magic number. */
47 /* common fields */
48 isc_mem_t *mctx;
49 isc_interface_t current; /* Current interface data. */
50 isc_result_t result; /* Last result code. */
51 /* fields used if GetAdaptersAddresses is available at runtime */
52 IP_ADAPTER_ADDRESSES * ipaa; /* GAA() result buffer */
53 ULONG ipaasize; /* Bytes allocated */
54 IP_ADAPTER_ADDRESSES * ipaaCur; /* enumeration position */
55 IP_ADAPTER_UNICAST_ADDRESS *ipuaCur; /* enumeration subposition */
56 /* fields used for the older address enumeration ioctls */
57 SOCKET socket;
58 INTERFACE_INFO IFData; /* Current Interface Info */
59 int numIF; /* Current Interface count */
60 int v4IF; /* Number of IPv4 Interfaces */
61 INTERFACE_INFO *buf4; /* Buffer for WSAIoctl data. */
62 unsigned int buf4size; /* Bytes allocated. */
63 INTERFACE_INFO *pos4; /* Current offset in IF List */
64 SOCKET_ADDRESS_LIST *buf6;
65 unsigned int buf6size; /* Bytes allocated. */
66 unsigned int pos6; /* buf6 index, counts down */
67 struct in6_addr loop__1; /* ::1 node-scope localhost */
68 struct in6_addr loopfe80__1; /* fe80::1 link-scope localhost */
69 };
70
71 typedef ULONG (WINAPI *PGETADAPTERSADDRESSES)(
72 ULONG Family,
73 ULONG Flags,
74 PVOID Reserved,
75 PIP_ADAPTER_ADDRESSES AdapterAddresses,
76 PULONG SizePointer
77 );
78
79 static isc_boolean_t use_GAA;
80 static isc_boolean_t use_GAA_determined;
81 static HMODULE hmod_iphlpapi;
82 static PGETADAPTERSADDRESSES pGAA;
83
84
85 /*
86 * Size of buffer for SIO_GET_INTERFACE_LIST, in number of interfaces.
87 * We assume no sane system will have more than than 1K of IP addresses on
88 * all of its adapters.
89 */
90 #define IFCONF_SIZE_INITIAL 16
91 #define IFCONF_SIZE_INCREMENT 64
92 #define IFCONF_SIZE_MAX 1040
93
94
95 /* Common utility functions */
96
97 /*
98 * Windows always provides 255.255.255.255 as the the broadcast
99 * address. ntpd needs to know the broadcast address which will target
100 * only that network interface, not all. Reconstruct it from the
101 * address and mask.
102 */
103 static void
get_broadcastaddr(isc_netaddr_t * bcastaddr,isc_netaddr_t * addr,isc_netaddr_t * netmask)104 get_broadcastaddr(isc_netaddr_t *bcastaddr, isc_netaddr_t *addr, isc_netaddr_t *netmask) {
105
106 isc_uint32_t * b;
107 isc_uint32_t a, n;
108
109 b = (isc_uint32_t *)&bcastaddr->type.in;
110 a = *(isc_uint32_t *)&addr->type.in;
111 n = *(isc_uint32_t *)&netmask->type.in;
112
113 *b = a | ~n;
114 }
115
116 isc_result_t
isc_interfaceiter_create(isc_mem_t * mctx,isc_interfaceiter_t ** iterp)117 isc_interfaceiter_create(isc_mem_t *mctx, isc_interfaceiter_t **iterp) {
118 char strbuf[ISC_STRERRORSIZE];
119 isc_interfaceiter_t *iter;
120 isc_result_t result;
121 unsigned int major;
122 unsigned int minor;
123 unsigned int spmajor;
124 ULONG err;
125 int tries;
126 int error;
127 unsigned long bytesReturned = 0;
128
129 REQUIRE(mctx != NULL);
130 REQUIRE(iterp != NULL);
131 REQUIRE(*iterp == NULL);
132
133 iter = isc_mem_get(mctx, sizeof(*iter));
134 if (iter == NULL)
135 return (ISC_R_NOMEMORY);
136
137 InitSockets();
138
139 iter->mctx = mctx;
140 iter->ipaa = NULL;
141 iter->buf4 = NULL;
142 iter->buf6 = NULL;
143 iter->pos4 = NULL;
144 iter->ipaaCur = NULL;
145 iter->ipuaCur = NULL;
146 iter->ipaasize = 0;
147 iter->pos6 = 0;
148 iter->buf6size = 0;
149 iter->buf4size = 0;
150 iter->result = ISC_R_FAILURE;
151 iter->numIF = 0;
152 iter->v4IF = 0;
153
154 /*
155 * Use GetAdaptersAddresses in preference to ioctls when running
156 * on Windows XP SP1 or later. Earlier GetAdaptersAddresses do
157 * not appear to provide enough information to associate unicast
158 * addresses with their prefixes.
159 */
160 if (!use_GAA_determined) {
161 major = isc_win32os_majorversion();
162 minor = isc_win32os_minorversion();
163 spmajor = isc_win32os_servicepackmajor();
164 if (major > 5 || (5 == major &&
165 (minor > 1 || (1 == minor && spmajor >= 1)))) {
166 if (NULL == hmod_iphlpapi)
167 hmod_iphlpapi = LoadLibrary("iphlpapi");
168 if (NULL != hmod_iphlpapi)
169 pGAA = (PGETADAPTERSADDRESSES)
170 GetProcAddress(
171 hmod_iphlpapi,
172 "GetAdaptersAddresses");
173 if (NULL != pGAA)
174 use_GAA = ISC_TRUE;
175 }
176 use_GAA_determined = ISC_TRUE;
177 }
178
179 if (!use_GAA)
180 goto use_ioctls;
181
182 iter->ipaasize = 16 * 1024;
183
184 for (tries = 0; tries < 5; tries++) {
185 iter->ipaa = isc_mem_reallocate(mctx, iter->ipaa,
186 iter->ipaasize);
187 if (NULL == iter->ipaa) {
188 result = ISC_R_NOMEMORY;
189 goto put_iter;
190 }
191 err = (*pGAA)(
192 AF_UNSPEC,
193 GAA_FLAG_INCLUDE_PREFIX | GAA_FLAG_SKIP_ANYCAST,
194 NULL,
195 iter->ipaa,
196 &iter->ipaasize);
197 if (NO_ERROR == err || ERROR_BUFFER_OVERFLOW != err)
198 break;
199 }
200
201 if (NO_ERROR != err) {
202 isc__strerror(err, strbuf, sizeof(strbuf));
203 UNEXPECTED_ERROR(__FILE__, __LINE__,
204 "GetAdaptersAddresses: %s",
205 strbuf);
206 result = ISC_R_UNEXPECTED;
207 goto gaa_failure;
208 }
209
210 iter->ipaaCur = iter->ipaa;
211 goto success;
212
213 use_ioctls:
214 /*
215 * Create an unbound datagram socket to do the
216 * SIO_GET_INTERFACE_LIST WSAIoctl on.
217 */
218 if ((iter->socket = socket(AF_INET, SOCK_DGRAM, 0)) < 0) {
219 error = WSAGetLastError();
220 if (error == WSAEAFNOSUPPORT)
221 goto inet6_only;
222 isc__strerror(error, strbuf, sizeof(strbuf));
223 UNEXPECTED_ERROR(__FILE__, __LINE__,
224 "making interface scan socket: %s",
225 strbuf);
226 result = ISC_R_UNEXPECTED;
227 goto put_iter;
228 }
229
230 /*
231 * Get the interface configuration, allocating more memory if
232 * necessary.
233 */
234 iter->buf4size = IFCONF_SIZE_INITIAL*sizeof(INTERFACE_INFO);
235
236 for (;;) {
237 iter->buf4 = isc_mem_get(mctx, iter->buf4size);
238 if (iter->buf4 == NULL) {
239 result = ISC_R_NOMEMORY;
240 goto alloc_failure;
241 }
242
243 if (WSAIoctl(iter->socket, SIO_GET_INTERFACE_LIST,
244 0, 0, iter->buf4, iter->buf4size,
245 &bytesReturned, 0, 0) == SOCKET_ERROR)
246 {
247 error = WSAGetLastError();
248 if (error != WSAEFAULT && error != WSAENOBUFS) {
249 errno = error;
250 isc__strerror(error, strbuf, sizeof(strbuf));
251 UNEXPECTED_ERROR(__FILE__, __LINE__,
252 "get interface configuration: %s",
253 strbuf);
254 result = ISC_R_UNEXPECTED;
255 goto ioctl_failure;
256 }
257 /*
258 * EINVAL. Retry with a bigger buffer.
259 */
260 } else {
261 /*
262 * The WSAIoctl succeeded.
263 * If the number of the returned bytes is the same
264 * as the buffer size, we will grow it just in
265 * case and retry.
266 */
267 if (bytesReturned > 0 &&
268 (bytesReturned < iter->buf4size))
269 break;
270 }
271 if (iter->buf4size >= IFCONF_SIZE_MAX*sizeof(INTERFACE_INFO)) {
272 UNEXPECTED_ERROR(__FILE__, __LINE__,
273 "get interface configuration: "
274 "maximum buffer size exceeded");
275 result = ISC_R_UNEXPECTED;
276 goto ioctl_failure;
277 }
278 isc_mem_put(mctx, iter->buf4, iter->buf4size);
279
280 iter->buf4size += IFCONF_SIZE_INCREMENT *
281 sizeof(INTERFACE_INFO);
282 }
283
284 /*
285 * A newly created iterator has an undefined position
286 * until isc_interfaceiter_first() is called.
287 */
288 iter->v4IF = bytesReturned/sizeof(INTERFACE_INFO);
289
290 /* We don't need the socket any more, so close it */
291 closesocket(iter->socket);
292
293 inet6_only:
294 /*
295 * Create an unbound datagram socket to do the
296 * SIO_ADDRESS_LIST_QUERY WSAIoctl on.
297 */
298 if ((iter->socket = socket(AF_INET6, SOCK_DGRAM, 0)) < 0) {
299 error = WSAGetLastError();
300 if (error == WSAEAFNOSUPPORT)
301 goto success;
302 isc__strerror(error, strbuf, sizeof(strbuf));
303 UNEXPECTED_ERROR(__FILE__, __LINE__,
304 "making interface scan socket: %s",
305 strbuf);
306 result = ISC_R_UNEXPECTED;
307 goto put_iter;
308 }
309
310 /*
311 * Get the interface configuration, allocating more memory if
312 * necessary.
313 */
314 iter->buf6size = sizeof(SOCKET_ADDRESS_LIST) +
315 IFCONF_SIZE_INITIAL*sizeof(SOCKET_ADDRESS);
316
317 for (;;) {
318 iter->buf6 = isc_mem_get(mctx, iter->buf6size);
319 if (iter->buf6 == NULL) {
320 result = ISC_R_NOMEMORY;
321 goto ioctl_failure;
322 }
323
324 if (WSAIoctl(iter->socket, SIO_ADDRESS_LIST_QUERY,
325 0, 0, iter->buf6, iter->buf6size,
326 &bytesReturned, 0, 0) == SOCKET_ERROR)
327 {
328 error = WSAGetLastError();
329 if (error != WSAEFAULT && error != WSAENOBUFS) {
330 errno = error;
331 isc__strerror(error, strbuf, sizeof(strbuf));
332 UNEXPECTED_ERROR(__FILE__, __LINE__,
333 "sio address list query: %s",
334 strbuf);
335 result = ISC_R_UNEXPECTED;
336 goto ioctl6_failure;
337 }
338 /*
339 * EINVAL. Retry with a bigger buffer.
340 */
341 } else
342 break;
343
344 if (iter->buf6size >= IFCONF_SIZE_MAX*sizeof(SOCKET_ADDRESS)) {
345 UNEXPECTED_ERROR(__FILE__, __LINE__,
346 "get interface configuration: "
347 "maximum buffer size exceeded");
348 result = ISC_R_UNEXPECTED;
349 goto ioctl6_failure;
350 }
351 isc_mem_put(mctx, iter->buf6, iter->buf6size);
352
353 iter->buf6size += IFCONF_SIZE_INCREMENT *
354 sizeof(SOCKET_ADDRESS);
355 }
356
357 /*
358 * initialize loop__1 to [::1] and loopfe80__1 to [fe80::1].
359 * used by internal_current6().
360 */
361 memset(&iter->loop__1, 0, sizeof(iter->loop__1));
362 memset(&iter->loopfe80__1, 0, sizeof(iter->loopfe80__1));
363 iter->loop__1.s6_addr[15] = 1;
364 iter->loopfe80__1.s6_addr[15] = 1;
365 iter->loopfe80__1.s6_addr[0] = 0xfe;
366 iter->loopfe80__1.s6_addr[1] = 0x80;
367
368 closesocket(iter->socket);
369
370 success:
371 iter->magic = IFITER_MAGIC;
372 *iterp = iter;
373 return (ISC_R_SUCCESS);
374
375 gaa_failure:
376 isc_mem_put(mctx, iter->ipaa, iter->ipaasize);
377 goto put_iter;
378
379 ioctl6_failure:
380 isc_mem_put(mctx, iter->buf6, iter->buf6size);
381
382 ioctl_failure:
383 if (iter->buf4 != NULL)
384 isc_mem_put(mctx, iter->buf4, iter->buf4size);
385
386 alloc_failure:
387 if (iter->socket >= 0)
388 (void) closesocket(iter->socket);
389
390 put_iter:
391 isc_mem_put(mctx, iter, sizeof(*iter));
392 return (result);
393 }
394
395 static unsigned char
GAA_find_prefix(isc_interfaceiter_t * iter)396 GAA_find_prefix(isc_interfaceiter_t *iter) {
397 IP_ADAPTER_PREFIX * ipap;
398 IP_ADAPTER_PREFIX * ipap_match;
399 int match_len;
400 int max_len;
401 isc_netaddr_t target;
402 u_short af;
403 isc_netaddr_t pfx;
404 int pfx_len;
405 size_t nbytes;
406 unsigned char nbits;
407 unsigned char * pbits;
408 unsigned int octets;
409
410 match_len = 0;
411 ipap_match = NULL;
412 isc_netaddr_fromsockaddr(&target,
413 (isc_sockaddr_t *)iter->ipuaCur->Address.lpSockaddr);
414 af = (u_short)target.family;
415 INSIST(AF_INET == af || AF_INET6 == af);
416 max_len = (AF_INET6 == af) ? 128 : 32;
417 iter->current.netmask.family = af;
418 for (ipap = iter->ipaaCur->FirstPrefix;
419 ipap != NULL;
420 ipap = ipap->Next) {
421 if (ipap->Address.lpSockaddr->sa_family != af)
422 continue;
423 isc_netaddr_fromsockaddr(&pfx,
424 (isc_sockaddr_t *)ipap->Address.lpSockaddr);
425 pfx_len = ipap->PrefixLength;
426 INSIST(0 <= pfx_len && pfx_len <= max_len);
427 if (pfx_len > match_len && pfx_len < max_len &&
428 isc_netaddr_eqprefix(&target, &pfx, pfx_len)) {
429 ipap_match = ipap;
430 match_len = pfx_len;
431 }
432 }
433 if (NULL == ipap_match) {
434 /* presume all-ones mask */
435 if (AF_INET6 == af)
436 octets = sizeof(iter->current.netmask.type.in6);
437 else
438 octets = sizeof(iter->current.netmask.type.in);
439 memset(&iter->current.netmask.type, 0xFF, octets);
440 return (8 * (unsigned char)octets);
441 }
442 nbytes = match_len / 8;
443 nbits = match_len % 8;
444 memset(&iter->current.netmask.type.in6, 0xFF, nbytes);
445 pbits = (void *)&iter->current.netmask.type.in6;
446 pbits += nbytes;
447 *pbits |= 0xFF << (8 - nbits);
448 return ((unsigned char)match_len);
449 }
450
451 static isc_result_t
internal_current_GAA(isc_interfaceiter_t * iter)452 internal_current_GAA(isc_interfaceiter_t *iter) {
453 IP_ADAPTER_ADDRESSES *adap;
454 IP_ADAPTER_UNICAST_ADDRESS *addr;
455 unsigned char prefix_len;
456
457 REQUIRE(iter->ipaaCur != NULL);
458 REQUIRE(iter->ipuaCur != NULL);
459 adap = iter->ipaaCur;
460 addr = iter->ipuaCur;
461 if (IpDadStatePreferred != addr->DadState)
462 return (ISC_R_IGNORE);
463 memset(&iter->current, 0, sizeof(iter->current));
464 iter->current.af = addr->Address.lpSockaddr->sa_family;
465 isc_netaddr_fromsockaddr(&iter->current.address,
466 (isc_sockaddr_t *)addr->Address.lpSockaddr);
467 if (AF_INET6 == iter->current.af)
468 iter->current.ifindex = adap->Ipv6IfIndex;
469 iter->current.name[0] = '\0';
470 WideCharToMultiByte(
471 CP_ACP,
472 0,
473 adap->FriendlyName,
474 -1,
475 iter->current.name,
476 sizeof(iter->current.name),
477 NULL,
478 NULL);
479 iter->current.name[sizeof(iter->current.name) - 1] = '\0';
480 if (IfOperStatusUp == adap->OperStatus)
481 iter->current.flags |= INTERFACE_F_UP;
482 if (IF_TYPE_PPP == adap->IfType)
483 iter->current.flags |= INTERFACE_F_POINTTOPOINT;
484 else if (IF_TYPE_SOFTWARE_LOOPBACK == adap->IfType)
485 iter->current.flags |= INTERFACE_F_LOOPBACK;
486 if ((IP_ADAPTER_NO_MULTICAST & adap->Flags) == 0)
487 iter->current.flags |= INTERFACE_F_MULTICAST;
488 if (IpSuffixOriginRandom == addr->SuffixOrigin)
489 iter->current.flags |= INTERFACE_F_PRIVACY;
490
491 prefix_len = GAA_find_prefix(iter);
492 /* I'm failing to see a broadcast flag via GAA */
493 if (AF_INET == iter->current.af && prefix_len < 32 &&
494 (INTERFACE_F_LOOPBACK & iter->current.flags) == 0) {
495 iter->current.flags |= INTERFACE_F_BROADCAST;
496 get_broadcastaddr(&iter->current.broadcast,
497 &iter->current.address,
498 &iter->current.netmask);
499 }
500 return (ISC_R_SUCCESS);
501 }
502
503 /*
504 * Get information about the current interface to iter->current.
505 * If successful, return ISC_R_SUCCESS.
506 * If the interface has an unsupported address family, or if
507 * some operation on it fails, return ISC_R_IGNORE to make
508 * the higher-level iterator code ignore it.
509 */
510
511 static isc_result_t
internal_current(isc_interfaceiter_t * iter)512 internal_current(isc_interfaceiter_t *iter) {
513 BOOL ifNamed = FALSE;
514 unsigned long flags;
515
516 REQUIRE(VALID_IFITER(iter));
517 REQUIRE(iter->numIF >= 0);
518
519 memset(&iter->current, 0, sizeof(iter->current));
520 iter->current.af = AF_INET;
521
522 isc_netaddr_fromsockaddr(&iter->current.address,
523 (isc_sockaddr_t *)&(iter->IFData.iiAddress));
524
525 /*
526 * Get interface flags.
527 */
528
529 iter->current.flags = 0;
530 flags = iter->IFData.iiFlags;
531
532 if ((flags & IFF_UP) != 0)
533 iter->current.flags |= INTERFACE_F_UP;
534
535 if ((flags & IFF_BROADCAST) != 0)
536 iter->current.flags |= INTERFACE_F_BROADCAST;
537
538 if ((flags & IFF_MULTICAST) != 0)
539 iter->current.flags |= INTERFACE_F_MULTICAST;
540
541 if ((flags & IFF_POINTTOPOINT) != 0) {
542 iter->current.flags |= INTERFACE_F_POINTTOPOINT;
543 snprintf(iter->current.name, sizeof(iter->current.name),
544 "PPP %d", iter->numIF);
545 ifNamed = TRUE;
546 }
547
548 if ((flags & IFF_LOOPBACK) != 0) {
549 iter->current.flags |= INTERFACE_F_LOOPBACK;
550 snprintf(iter->current.name, sizeof(iter->current.name),
551 "v4loop %d", iter->numIF);
552 ifNamed = TRUE;
553 }
554
555 /*
556 * If the interface is point-to-point, get the destination address.
557 */
558 if ((iter->current.flags & INTERFACE_F_POINTTOPOINT) != 0)
559 isc_netaddr_fromsockaddr(&iter->current.dstaddress,
560 (isc_sockaddr_t *)&(iter->IFData.iiBroadcastAddress));
561
562 /*
563 * Get the network mask.
564 */
565 isc_netaddr_fromsockaddr(&iter->current.netmask,
566 (isc_sockaddr_t *)&(iter->IFData.iiNetmask));
567
568 /*
569 * If the interface is broadcast, get the broadcast address,
570 * based on the unicast address and network mask.
571 */
572 if ((iter->current.flags & INTERFACE_F_BROADCAST) != 0)
573 get_broadcastaddr(&iter->current.broadcast,
574 &iter->current.address,
575 &iter->current.netmask);
576
577 if (ifNamed == FALSE)
578 snprintf(iter->current.name, sizeof(iter->current.name),
579 "IPv4 %d", iter->numIF);
580
581 return (ISC_R_SUCCESS);
582 }
583
584 static isc_result_t
internal_current6(isc_interfaceiter_t * iter)585 internal_current6(isc_interfaceiter_t *iter) {
586 BOOL ifNamed = FALSE;
587 struct sockaddr_in6 *psa6;
588 BOOL localhostSeen;
589 int i;
590
591 REQUIRE(VALID_IFITER(iter));
592 REQUIRE(iter->pos6 >= 0);
593 REQUIRE(iter->buf6 != 0);
594
595 memset(&iter->current, 0, sizeof(iter->current));
596 iter->current.af = AF_INET6;
597
598 /*
599 * synthesize localhost ::1 before returning the rest, if ::1
600 * is not on the list.
601 */
602 if (iter->pos6 >= (unsigned)iter->buf6->iAddressCount) {
603 localhostSeen = FALSE;
604 for (i = 0; i < iter->buf6->iAddressCount; i++) {
605 psa6 = (struct sockaddr_in6 *)
606 iter->buf6->Address[i].lpSockaddr;
607 if (!memcmp(&iter->loop__1, &psa6->sin6_addr,
608 sizeof(iter->loop__1))) {
609 localhostSeen = TRUE;
610 break;
611 }
612 }
613 if (localhostSeen)
614 iter->pos6 = iter->buf6->iAddressCount - 1;
615 }
616
617 if (iter->pos6 < (unsigned)iter->buf6->iAddressCount) {
618 isc_netaddr_fromsockaddr(&iter->current.address,
619 (isc_sockaddr_t *)iter->buf6->Address[iter->pos6].lpSockaddr);
620 } else {
621 iter->current.address.family = AF_INET6;
622 memcpy(&iter->current.address.type.in6, &iter->loop__1,
623 sizeof(iter->current.address.type.in6));
624 }
625
626 /*
627 * Get interface flags.
628 */
629
630 iter->current.flags = INTERFACE_F_UP | INTERFACE_F_MULTICAST;
631
632 if (!memcmp(&iter->current.address.type.in6, &iter->loop__1,
633 sizeof(iter->current.address.type.in6)) ||
634 !memcmp(&iter->current.address.type.in6, &iter->loopfe80__1,
635 sizeof(iter->current.address.type.in6))) {
636
637 iter->current.flags |= INTERFACE_F_LOOPBACK;
638 snprintf(iter->current.name, sizeof(iter->current.name),
639 "v6loop %d",
640 iter->buf6->iAddressCount - iter->pos6);
641 ifNamed = TRUE;
642 }
643
644 if (ifNamed == FALSE)
645 snprintf(iter->current.name, sizeof(iter->current.name),
646 "IPv6 %d",
647 iter->buf6->iAddressCount - iter->pos6);
648
649 memset(iter->current.netmask.type.in6.s6_addr, 0xff,
650 sizeof(iter->current.netmask.type.in6.s6_addr));
651 iter->current.netmask.family = AF_INET6;
652 return (ISC_R_SUCCESS);
653 }
654
655 static isc_result_t
internal_next_GAA(isc_interfaceiter_t * iter)656 internal_next_GAA(isc_interfaceiter_t *iter) {
657 REQUIRE(use_GAA);
658 if (NULL == iter->ipaaCur)
659 return (ISC_R_NOMORE);
660 if (NULL == iter->ipuaCur)
661 iter->ipuaCur = iter->ipaaCur->FirstUnicastAddress;
662 else
663 iter->ipuaCur = iter->ipuaCur->Next;
664 while (NULL == iter->ipuaCur) {
665 iter->ipaaCur = iter->ipaaCur->Next;
666 if (NULL == iter->ipaaCur)
667 return (ISC_R_NOMORE);
668 iter->ipuaCur = iter->ipaaCur->FirstUnicastAddress;
669 }
670 return (ISC_R_SUCCESS);
671 }
672
673 /*
674 * Step the iterator to the next interface. Unlike
675 * isc_interfaceiter_next(), this may leave the iterator
676 * positioned on an interface that will ultimately
677 * be ignored. Return ISC_R_NOMORE if there are no more
678 * interfaces, otherwise ISC_R_SUCCESS.
679 */
680 static isc_result_t
internal_next(isc_interfaceiter_t * iter)681 internal_next(isc_interfaceiter_t *iter) {
682 if (iter->numIF >= iter->v4IF)
683 return (ISC_R_NOMORE);
684
685 /*
686 * The first one needs to be set up to point to the last
687 * Element of the array. Go to the end and back up
688 * Microsoft's implementation is peculiar for returning
689 * the list in reverse order
690 */
691
692 if (iter->numIF == 0)
693 iter->pos4 = (INTERFACE_INFO *)(iter->buf4 + (iter->v4IF));
694
695 iter->pos4--;
696 if (&(iter->pos4) < &(iter->buf4))
697 return (ISC_R_NOMORE);
698
699 memset(&(iter->IFData), 0, sizeof(INTERFACE_INFO));
700 memcpy(&(iter->IFData), iter->pos4, sizeof(INTERFACE_INFO));
701 iter->numIF++;
702
703 return (ISC_R_SUCCESS);
704 }
705
706 static isc_result_t
internal_next6(isc_interfaceiter_t * iter)707 internal_next6(isc_interfaceiter_t *iter) {
708 if (iter->pos6 == 0)
709 return (ISC_R_NOMORE);
710 iter->pos6--;
711 return (ISC_R_SUCCESS);
712 }
713
714 isc_result_t
isc_interfaceiter_current(isc_interfaceiter_t * iter,isc_interface_t * ifdata)715 isc_interfaceiter_current(isc_interfaceiter_t *iter,
716 isc_interface_t *ifdata) {
717 REQUIRE(iter->result == ISC_R_SUCCESS);
718 memcpy(ifdata, &iter->current, sizeof(*ifdata));
719 return (ISC_R_SUCCESS);
720 }
721
722 isc_result_t
isc_interfaceiter_first(isc_interfaceiter_t * iter)723 isc_interfaceiter_first(isc_interfaceiter_t *iter) {
724 REQUIRE(VALID_IFITER(iter));
725 REQUIRE(use_GAA_determined);
726 /*
727 * SIO_ADDRESS_LIST_QUERY (used to query IPv6 addresses)
728 * intentionally omits localhost addresses [::1] and [::fe80] in
729 * some cases. ntpd depends on enumerating [::1] to listen on
730 * it, and ntpq and ntpdc default to "localhost" as the target,
731 * so they will attempt to talk to [::1]:123 and fail. This
732 * means we need to synthesize ::1, which we will do first,
733 * hence iAddressCount + 1. internal_next6() will decrement
734 * it before the first use as an index, and internal_current6()
735 * will treat pos6 == iAddressCount as a sign to synthesize
736 * [::1] if needed.
737 */
738 if (!use_GAA && iter->buf6 != NULL)
739 iter->pos6 = iter->buf6->iAddressCount + 1;
740 iter->result = ISC_R_SUCCESS;
741 return (isc_interfaceiter_next(iter));
742 }
743
744 isc_result_t
isc_interfaceiter_next(isc_interfaceiter_t * iter)745 isc_interfaceiter_next(isc_interfaceiter_t *iter) {
746 isc_result_t result;
747
748 REQUIRE(VALID_IFITER(iter));
749 REQUIRE(iter->result == ISC_R_SUCCESS);
750 REQUIRE(use_GAA_determined);
751
752 if (use_GAA) {
753 do {
754 result = internal_next_GAA(iter);
755 if (ISC_R_NOMORE == result)
756 goto set_result;
757 result = internal_current_GAA(iter);
758 } while (ISC_R_IGNORE == result);
759 goto set_result;
760 }
761
762 for (;;) {
763 result = internal_next(iter);
764 if (result == ISC_R_NOMORE) {
765 result = internal_next6(iter);
766 if (result != ISC_R_SUCCESS)
767 break;
768 result = internal_current6(iter);
769 if (result != ISC_R_IGNORE)
770 break;
771 } else if (result != ISC_R_SUCCESS)
772 break;
773 result = internal_current(iter);
774 if (result != ISC_R_IGNORE)
775 break;
776 }
777 set_result:
778 iter->result = result;
779 return (result);
780 }
781
782 void
isc_interfaceiter_destroy(isc_interfaceiter_t ** iterp)783 isc_interfaceiter_destroy(isc_interfaceiter_t **iterp) {
784 isc_interfaceiter_t *iter;
785
786 REQUIRE(iterp != NULL);
787 iter = *iterp;
788 REQUIRE(VALID_IFITER(iter));
789 REQUIRE(use_GAA_determined);
790
791 if (use_GAA) {
792 REQUIRE(NULL == iter->buf4);
793 REQUIRE(NULL == iter->buf4);
794 if (iter->ipaa != NULL)
795 isc_mem_put(iter->mctx, iter->ipaa, iter->ipaasize);
796 } else {
797 REQUIRE(NULL == iter->ipaa);
798 if (iter->buf4 != NULL)
799 isc_mem_put(iter->mctx, iter->buf4, iter->buf4size);
800 if (iter->buf6 != NULL)
801 isc_mem_put(iter->mctx, iter->buf6, iter->buf6size);
802 }
803
804 iter->magic = 0;
805 isc_mem_put(iter->mctx, iter, sizeof(*iter));
806 *iterp = NULL;
807 }
808