1/* getifaddrs -- get names and addresses of all network interfaces
2 Copyright (C) 2003-2018 Free Software Foundation, Inc.
3 This file is part of the GNU C Library.
4
5 The GNU C Library is free software; you can redistribute it and/or
6 modify it under the terms of the GNU Lesser General Public
7 License as published by the Free Software Foundation; either
8 version 2.1 of the License, or (at your option) any later version.
9
10 The GNU C Library is distributed in the hope that it will be useful,
11 but WITHOUT ANY WARRANTY; without even the implied warranty of
12 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
13 Lesser General Public License for more details.
14
15 You should have received a copy of the GNU Lesser General Public
16 License along with the GNU C Library; if not, see
17 <http://www.gnu.org/licenses/>. */
18
19#include <alloca.h>
20#include <assert.h>
21#include <errno.h>
22#include <ifaddrs.h>
23#include <net/if.h>
24#include <netinet/in.h>
25#include <netpacket/packet.h>
26#include <stdbool.h>
27#include <stdint.h>
28#include <stdlib.h>
29#include <string.h>
30#include <sys/ioctl.h>
31#include <sys/socket.h>
32#include <sysdep.h>
33#include <time.h>
34#include <unistd.h>
35
36#include "netlinkaccess.h"
37
38
39/* There is a problem with this type. The address length for
40 Infiniband sockets is much longer than the 8 bytes allocated in the
41 sockaddr_ll definition. Hence we use here a special
42 definition. */
43struct sockaddr_ll_max
44 {
45 unsigned short int sll_family;
46 unsigned short int sll_protocol;
47 int sll_ifindex;
48 unsigned short int sll_hatype;
49 unsigned char sll_pkttype;
50 unsigned char sll_halen;
51 unsigned char sll_addr[24];
52 };
53
54
55/* struct to hold the data for one ifaddrs entry, so we can allocate
56 everything at once. */
57struct ifaddrs_storage
58{
59 struct ifaddrs ifa;
60 union
61 {
62 /* Save space for the biggest of the four used sockaddr types and
63 avoid a lot of casts. */
64 struct sockaddr sa;
65 struct sockaddr_ll_max sl;
66 struct sockaddr_in s4;
67 struct sockaddr_in6 s6;
68 } addr, netmask, broadaddr;
69 char name[IF_NAMESIZE + 1];
70};
71
72
73void
74__netlink_free_handle (struct netlink_handle *h)
75{
76 struct netlink_res *ptr;
77 int saved_errno = errno;
78
79 ptr = h->nlm_list;
80 while (ptr != NULL)
81 {
82 struct netlink_res *tmpptr;
83
84 tmpptr = ptr->next;
85 free (ptr);
86 ptr = tmpptr;
87 }
88
89 __set_errno (saved_errno);
90}
91
92
93static int
94__netlink_sendreq (struct netlink_handle *h, int type)
95{
96 struct req
97 {
98 struct nlmsghdr nlh;
99 struct rtgenmsg g;
100 char pad[0];
101 } req;
102 struct sockaddr_nl nladdr;
103
104 if (h->seq == 0)
105 h->seq = time (NULL);
106
107 req.nlh.nlmsg_len = sizeof (req);
108 req.nlh.nlmsg_type = type;
109 req.nlh.nlmsg_flags = NLM_F_ROOT | NLM_F_MATCH | NLM_F_REQUEST;
110 req.nlh.nlmsg_pid = 0;
111 req.nlh.nlmsg_seq = h->seq;
112 req.g.rtgen_family = AF_UNSPEC;
113 if (sizeof (req) != offsetof (struct req, pad))
114 memset (req.pad, '\0', sizeof (req) - offsetof (struct req, pad));
115
116 memset (&nladdr, '\0', sizeof (nladdr));
117 nladdr.nl_family = AF_NETLINK;
118
119 return TEMP_FAILURE_RETRY (__sendto (h->fd, (void *) &req, sizeof (req), 0,
120 (struct sockaddr *) &nladdr,
121 sizeof (nladdr)));
122}
123
124
125int
126__netlink_request (struct netlink_handle *h, int type)
127{
128 struct netlink_res *nlm_next;
129 struct sockaddr_nl nladdr;
130 struct nlmsghdr *nlmh;
131 ssize_t read_len;
132 bool done = false;
133
134#ifdef PAGE_SIZE
135 /* Help the compiler optimize out the malloc call if PAGE_SIZE
136 is constant and smaller or equal to PTHREAD_STACK_MIN/4. */
137 const size_t buf_size = PAGE_SIZE;
138#else
139 const size_t buf_size = __getpagesize ();
140#endif
141 bool use_malloc = false;
142 char *buf;
143
144 if (__libc_use_alloca (buf_size))
145 buf = alloca (buf_size);
146 else
147 {
148 buf = malloc (buf_size);
149 if (buf != NULL)
150 use_malloc = true;
151 else
152 goto out_fail;
153 }
154
155 struct iovec iov = { buf, buf_size };
156
157 if (__netlink_sendreq (h, type) < 0)
158 goto out_fail;
159
160 while (! done)
161 {
162 struct msghdr msg =
163 {
164 .msg_name = (void *) &nladdr,
165 .msg_namelen = sizeof (nladdr),
166 .msg_iov = &iov,
167 .msg_iovlen = 1,
168 .msg_control = NULL,
169 .msg_controllen = 0,
170 .msg_flags = 0
171 };
172
173 read_len = TEMP_FAILURE_RETRY (__recvmsg (h->fd, &msg, 0));
174 __netlink_assert_response (h->fd, read_len);
175 if (read_len < 0)
176 goto out_fail;
177
178 if (nladdr.nl_pid != 0)
179 continue;
180
181 if (__glibc_unlikely (msg.msg_flags & MSG_TRUNC))
182 goto out_fail;
183
184 size_t count = 0;
185 size_t remaining_len = read_len;
186 for (nlmh = (struct nlmsghdr *) buf;
187 NLMSG_OK (nlmh, remaining_len);
188 nlmh = (struct nlmsghdr *) NLMSG_NEXT (nlmh, remaining_len))
189 {
190 if ((pid_t) nlmh->nlmsg_pid != h->pid
191 || nlmh->nlmsg_seq != h->seq)
192 continue;
193
194 ++count;
195 if (nlmh->nlmsg_type == NLMSG_DONE)
196 {
197 /* We found the end, leave the loop. */
198 done = true;
199 break;
200 }
201 if (nlmh->nlmsg_type == NLMSG_ERROR)
202 {
203 struct nlmsgerr *nlerr = (struct nlmsgerr *) NLMSG_DATA (nlmh);
204 if (nlmh->nlmsg_len < NLMSG_LENGTH (sizeof (struct nlmsgerr)))
205 errno = EIO;
206 else
207 errno = -nlerr->error;
208 goto out_fail;
209 }
210 }
211
212 /* If there was nothing with the expected nlmsg_pid and nlmsg_seq,
213 there is no point to record it. */
214 if (count == 0)
215 continue;
216
217 nlm_next = (struct netlink_res *) malloc (sizeof (struct netlink_res)
218 + read_len);
219 if (nlm_next == NULL)
220 goto out_fail;
221 nlm_next->next = NULL;
222 nlm_next->nlh = memcpy (nlm_next + 1, buf, read_len);
223 nlm_next->size = read_len;
224 nlm_next->seq = h->seq;
225 if (h->nlm_list == NULL)
226 h->nlm_list = nlm_next;
227 else
228 h->end_ptr->next = nlm_next;
229 h->end_ptr = nlm_next;
230 }
231
232 if (use_malloc)
233 free (buf);
234 return 0;
235
236out_fail:
237 if (use_malloc)
238 free (buf);
239 return -1;
240}
241
242
243void
244__netlink_close (struct netlink_handle *h)
245{
246 /* Don't modify errno. */
247 INTERNAL_SYSCALL_DECL (err);
248 (void) INTERNAL_SYSCALL (close, err, 1, h->fd);
249}
250
251
252/* Open a NETLINK socket. */
253int
254__netlink_open (struct netlink_handle *h)
255{
256 struct sockaddr_nl nladdr;
257
258 h->fd = __socket (PF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
259 if (h->fd < 0)
260 goto out;
261
262 memset (&nladdr, '\0', sizeof (nladdr));
263 nladdr.nl_family = AF_NETLINK;
264 if (__bind (h->fd, (struct sockaddr *) &nladdr, sizeof (nladdr)) < 0)
265 {
266 close_and_out:
267 __netlink_close (h);
268 out:
269 return -1;
270 }
271 /* Determine the ID the kernel assigned for this netlink connection.
272 It is not necessarily the PID if there is more than one socket
273 open. */
274 socklen_t addr_len = sizeof (nladdr);
275 if (__getsockname (h->fd, (struct sockaddr *) &nladdr, &addr_len) < 0)
276 goto close_and_out;
277 h->pid = nladdr.nl_pid;
278 return 0;
279}
280
281
282/* We know the number of RTM_NEWLINK entries, so we reserve the first
283 # of entries for this type. All RTM_NEWADDR entries have an index
284 pointer to the RTM_NEWLINK entry. To find the entry, create
285 a table to map kernel index entries to our index numbers.
286 Since we get at first all RTM_NEWLINK entries, it can never happen
287 that a RTM_NEWADDR index is not known to this map. */
288static int
289map_newlink (int index, struct ifaddrs_storage *ifas, int *map, int max)
290{
291 int i;
292
293 for (i = 0; i < max; i++)
294 {
295 if (map[i] == -1)
296 {
297 map[i] = index;
298 if (i > 0)
299 ifas[i - 1].ifa.ifa_next = &ifas[i].ifa;
300 return i;
301 }
302 else if (map[i] == index)
303 return i;
304 }
305
306 /* This means interfaces changed between the reading of the
307 RTM_GETLINK and RTM_GETADDR information. We have to repeat
308 everything. */
309 return -1;
310}
311
312
313/* Create a linked list of `struct ifaddrs' structures, one for each
314 network interface on the host machine. If successful, store the
315 list in *IFAP and return 0. On errors, return -1 and set `errno'. */
316static int
317getifaddrs_internal (struct ifaddrs **ifap)
318{
319 struct netlink_handle nh = { 0, 0, 0, NULL, NULL };
320 struct netlink_res *nlp;
321 struct ifaddrs_storage *ifas;
322 unsigned int i, newlink, newaddr, newaddr_idx;
323 int *map_newlink_data;
324 size_t ifa_data_size = 0; /* Size to allocate for all ifa_data. */
325 char *ifa_data_ptr; /* Pointer to the unused part of memory for
326 ifa_data. */
327 int result = 0;
328
329 *ifap = NULL;
330
331 if (__netlink_open (&nh) < 0)
332 return -1;
333
334 /* Tell the kernel that we wish to get a list of all
335 active interfaces, collect all data for every interface. */
336 if (__netlink_request (&nh, RTM_GETLINK) < 0)
337 {
338 result = -1;
339 goto exit_free;
340 }
341
342 /* Now ask the kernel for all addresses which are assigned
343 to an interface and collect all data for every interface.
344 Since we store the addresses after the interfaces in the
345 list, we will later always find the interface before the
346 corresponding addresses. */
347 ++nh.seq;
348 if (__netlink_request (&nh, RTM_GETADDR) < 0)
349 {
350 result = -1;
351 goto exit_free;
352 }
353
354 /* Count all RTM_NEWLINK and RTM_NEWADDR entries to allocate
355 enough memory. */
356 newlink = newaddr = 0;
357 for (nlp = nh.nlm_list; nlp; nlp = nlp->next)
358 {
359 struct nlmsghdr *nlh;
360 size_t size = nlp->size;
361
362 if (nlp->nlh == NULL)
363 continue;
364
365 /* Walk through all entries we got from the kernel and look, which
366 message type they contain. */
367 for (nlh = nlp->nlh; NLMSG_OK (nlh, size); nlh = NLMSG_NEXT (nlh, size))
368 {
369 /* Check if the message is what we want. */
370 if ((pid_t) nlh->nlmsg_pid != nh.pid || nlh->nlmsg_seq != nlp->seq)
371 continue;
372
373 /* If the dump got interrupted, we can't rely on the results
374 so try again. */
375 if (nlh->nlmsg_flags & NLM_F_DUMP_INTR)
376 {
377 result = -EAGAIN;
378 goto exit_free;
379 }
380
381 if (nlh->nlmsg_type == NLMSG_DONE)
382 break; /* ok */
383
384 if (nlh->nlmsg_type == RTM_NEWLINK)
385 {
386 /* A RTM_NEWLINK message can have IFLA_STATS data. We need to
387 know the size before creating the list to allocate enough
388 memory. */
389 struct ifinfomsg *ifim = (struct ifinfomsg *) NLMSG_DATA (nlh);
390 struct rtattr *rta = IFLA_RTA (ifim);
391 size_t rtasize = IFLA_PAYLOAD (nlh);
392
393 while (RTA_OK (rta, rtasize))
394 {
395 size_t rta_payload = RTA_PAYLOAD (rta);
396
397 if (rta->rta_type == IFLA_STATS)
398 {
399 ifa_data_size += rta_payload;
400 break;
401 }
402 else
403 rta = RTA_NEXT (rta, rtasize);
404 }
405 ++newlink;
406 }
407 else if (nlh->nlmsg_type == RTM_NEWADDR)
408 ++newaddr;
409 }
410 }
411
412 /* Return if no interface is up. */
413 if ((newlink + newaddr) == 0)
414 goto exit_free;
415
416 /* Allocate memory for all entries we have and initialize next
417 pointer. */
418 ifas = (struct ifaddrs_storage *) calloc (1,
419 (newlink + newaddr)
420 * sizeof (struct ifaddrs_storage)
421 + ifa_data_size);
422 if (ifas == NULL)
423 {
424 result = -1;
425 goto exit_free;
426 }
427
428 /* Table for mapping kernel index to entry in our list. */
429 map_newlink_data = alloca (newlink * sizeof (int));
430 memset (map_newlink_data, '\xff', newlink * sizeof (int));
431
432 ifa_data_ptr = (char *) &ifas[newlink + newaddr];
433 newaddr_idx = 0; /* Counter for newaddr index. */
434
435 /* Walk through the list of data we got from the kernel. */
436 for (nlp = nh.nlm_list; nlp; nlp = nlp->next)
437 {
438 struct nlmsghdr *nlh;
439 size_t size = nlp->size;
440
441 if (nlp->nlh == NULL)
442 continue;
443
444 /* Walk through one message and look at the type: If it is our
445 message, we need RTM_NEWLINK/RTM_NEWADDR and stop if we reach
446 the end or we find the end marker (in this case we ignore the
447 following data. */
448 for (nlh = nlp->nlh; NLMSG_OK (nlh, size); nlh = NLMSG_NEXT (nlh, size))
449 {
450 int ifa_index = 0;
451
452 /* Check if the message is the one we want */
453 if ((pid_t) nlh->nlmsg_pid != nh.pid || nlh->nlmsg_seq != nlp->seq)
454 continue;
455
456 if (nlh->nlmsg_type == NLMSG_DONE)
457 break; /* ok */
458
459 if (nlh->nlmsg_type == RTM_NEWLINK)
460 {
461 /* We found a new interface. Now extract everything from the
462 interface data we got and need. */
463 struct ifinfomsg *ifim = (struct ifinfomsg *) NLMSG_DATA (nlh);
464 struct rtattr *rta = IFLA_RTA (ifim);
465 size_t rtasize = IFLA_PAYLOAD (nlh);
466
467 /* Interfaces are stored in the first "newlink" entries
468 of our list, starting in the order as we got from the
469 kernel. */
470 ifa_index = map_newlink (ifim->ifi_index - 1, ifas,
471 map_newlink_data, newlink);
472 if (__glibc_unlikely (ifa_index == -1))
473 {
474 try_again:
475 result = -EAGAIN;
476 free (ifas);
477 goto exit_free;
478 }
479 ifas[ifa_index].ifa.ifa_flags = ifim->ifi_flags;
480
481 while (RTA_OK (rta, rtasize))
482 {
483 char *rta_data = RTA_DATA (rta);
484 size_t rta_payload = RTA_PAYLOAD (rta);
485
486 switch (rta->rta_type)
487 {
488 case IFLA_ADDRESS:
489 if (rta_payload <= sizeof (ifas[ifa_index].addr))
490 {
491 ifas[ifa_index].addr.sl.sll_family = AF_PACKET;
492 memcpy (ifas[ifa_index].addr.sl.sll_addr,
493 (char *) rta_data, rta_payload);
494 ifas[ifa_index].addr.sl.sll_halen = rta_payload;
495 ifas[ifa_index].addr.sl.sll_ifindex
496 = ifim->ifi_index;
497 ifas[ifa_index].addr.sl.sll_hatype = ifim->ifi_type;
498
499 ifas[ifa_index].ifa.ifa_addr
500 = &ifas[ifa_index].addr.sa;
501 }
502 break;
503
504 case IFLA_BROADCAST:
505 if (rta_payload <= sizeof (ifas[ifa_index].broadaddr))
506 {
507 ifas[ifa_index].broadaddr.sl.sll_family = AF_PACKET;
508 memcpy (ifas[ifa_index].broadaddr.sl.sll_addr,
509 (char *) rta_data, rta_payload);
510 ifas[ifa_index].broadaddr.sl.sll_halen = rta_payload;
511 ifas[ifa_index].broadaddr.sl.sll_ifindex
512 = ifim->ifi_index;
513 ifas[ifa_index].broadaddr.sl.sll_hatype
514 = ifim->ifi_type;
515
516 ifas[ifa_index].ifa.ifa_broadaddr
517 = &ifas[ifa_index].broadaddr.sa;
518 }
519 break;
520
521 case IFLA_IFNAME: /* Name of Interface */
522 if ((rta_payload + 1) <= sizeof (ifas[ifa_index].name))
523 {
524 ifas[ifa_index].ifa.ifa_name = ifas[ifa_index].name;
525 *(char *) __mempcpy (ifas[ifa_index].name, rta_data,
526 rta_payload) = '\0';
527 }
528 break;
529
530 case IFLA_STATS: /* Statistics of Interface */
531 ifas[ifa_index].ifa.ifa_data = ifa_data_ptr;
532 ifa_data_ptr += rta_payload;
533 memcpy (ifas[ifa_index].ifa.ifa_data, rta_data,
534 rta_payload);
535 break;
536
537 case IFLA_UNSPEC:
538 break;
539 case IFLA_MTU:
540 break;
541 case IFLA_LINK:
542 break;
543 case IFLA_QDISC:
544 break;
545 default:
546 break;
547 }
548
549 rta = RTA_NEXT (rta, rtasize);
550 }
551 }
552 else if (nlh->nlmsg_type == RTM_NEWADDR)
553 {
554 struct ifaddrmsg *ifam = (struct ifaddrmsg *) NLMSG_DATA (nlh);
555 struct rtattr *rta = IFA_RTA (ifam);
556 size_t rtasize = IFA_PAYLOAD (nlh);
557
558 /* New Addresses are stored in the order we got them from
559 the kernel after the interfaces. Theoretically it is possible
560 that we have holes in the interface part of the list,
561 but we always have already the interface for this address. */
562 ifa_index = newlink + newaddr_idx;
563 int idx = map_newlink (ifam->ifa_index - 1, ifas,
564 map_newlink_data, newlink);
565 if (__glibc_unlikely (idx == -1))
566 goto try_again;
567 ifas[ifa_index].ifa.ifa_flags = ifas[idx].ifa.ifa_flags;
568 if (ifa_index > 0)
569 ifas[ifa_index - 1].ifa.ifa_next = &ifas[ifa_index].ifa;
570 ++newaddr_idx;
571
572 while (RTA_OK (rta, rtasize))
573 {
574 char *rta_data = RTA_DATA (rta);
575 size_t rta_payload = RTA_PAYLOAD (rta);
576
577 switch (rta->rta_type)
578 {
579 case IFA_ADDRESS:
580 {
581 struct sockaddr *sa;
582
583 if (ifas[ifa_index].ifa.ifa_addr != NULL)
584 {
585 /* In a point-to-poing network IFA_ADDRESS
586 contains the destination address, local
587 address is supplied in IFA_LOCAL attribute.
588 destination address and broadcast address
589 are stored in an union, so it doesn't matter
590 which name we use. */
591 ifas[ifa_index].ifa.ifa_broadaddr
592 = &ifas[ifa_index].broadaddr.sa;
593 sa = &ifas[ifa_index].broadaddr.sa;
594 }
595 else
596 {
597 ifas[ifa_index].ifa.ifa_addr
598 = &ifas[ifa_index].addr.sa;
599 sa = &ifas[ifa_index].addr.sa;
600 }
601
602 sa->sa_family = ifam->ifa_family;
603
604 switch (ifam->ifa_family)
605 {
606 case AF_INET:
607 /* Size must match that of an address for IPv4. */
608 if (rta_payload == 4)
609 memcpy (&((struct sockaddr_in *) sa)->sin_addr,
610 rta_data, rta_payload);
611 break;
612
613 case AF_INET6:
614 /* Size must match that of an address for IPv6. */
615 if (rta_payload == 16)
616 {
617 memcpy (&((struct sockaddr_in6 *) sa)->sin6_addr,
618 rta_data, rta_payload);
619 if (IN6_IS_ADDR_LINKLOCAL (rta_data)
620 || IN6_IS_ADDR_MC_LINKLOCAL (rta_data))
621 ((struct sockaddr_in6 *) sa)->sin6_scope_id
622 = ifam->ifa_index;
623 }
624 break;
625
626 default:
627 if (rta_payload <= sizeof (ifas[ifa_index].addr))
628 memcpy (sa->sa_data, rta_data, rta_payload);
629 break;
630 }
631 }
632 break;
633
634 case IFA_LOCAL:
635 if (ifas[ifa_index].ifa.ifa_addr != NULL)
636 {
637 /* If ifa_addr is set and we get IFA_LOCAL,
638 assume we have a point-to-point network.
639 Move address to correct field. */
640 ifas[ifa_index].broadaddr = ifas[ifa_index].addr;
641 ifas[ifa_index].ifa.ifa_broadaddr
642 = &ifas[ifa_index].broadaddr.sa;
643 memset (&ifas[ifa_index].addr, '\0',
644 sizeof (ifas[ifa_index].addr));
645 }
646
647 ifas[ifa_index].ifa.ifa_addr = &ifas[ifa_index].addr.sa;
648 ifas[ifa_index].ifa.ifa_addr->sa_family
649 = ifam->ifa_family;
650
651 switch (ifam->ifa_family)
652 {
653 case AF_INET:
654 /* Size must match that of an address for IPv4. */
655 if (rta_payload == 4)
656 memcpy (&ifas[ifa_index].addr.s4.sin_addr,
657 rta_data, rta_payload);
658 break;
659
660 case AF_INET6:
661 /* Size must match that of an address for IPv6. */
662 if (rta_payload == 16)
663 {
664 memcpy (&ifas[ifa_index].addr.s6.sin6_addr,
665 rta_data, rta_payload);
666 if (IN6_IS_ADDR_LINKLOCAL (rta_data)
667 || IN6_IS_ADDR_MC_LINKLOCAL (rta_data))
668 ifas[ifa_index].addr.s6.sin6_scope_id =
669 ifam->ifa_index;
670 }
671 break;
672
673 default:
674 if (rta_payload <= sizeof (ifas[ifa_index].addr))
675 memcpy (ifas[ifa_index].addr.sa.sa_data,
676 rta_data, rta_payload);
677 break;
678 }
679 break;
680
681 case IFA_BROADCAST:
682 /* We get IFA_BROADCAST, so IFA_LOCAL was too much. */
683 if (ifas[ifa_index].ifa.ifa_broadaddr != NULL)
684 memset (&ifas[ifa_index].broadaddr, '\0',
685 sizeof (ifas[ifa_index].broadaddr));
686
687 ifas[ifa_index].ifa.ifa_broadaddr
688 = &ifas[ifa_index].broadaddr.sa;
689 ifas[ifa_index].ifa.ifa_broadaddr->sa_family
690 = ifam->ifa_family;
691
692 switch (ifam->ifa_family)
693 {
694 case AF_INET:
695 /* Size must match that of an address for IPv4. */
696 if (rta_payload == 4)
697 memcpy (&ifas[ifa_index].broadaddr.s4.sin_addr,
698 rta_data, rta_payload);
699 break;
700
701 case AF_INET6:
702 /* Size must match that of an address for IPv6. */
703 if (rta_payload == 16)
704 {
705 memcpy (&ifas[ifa_index].broadaddr.s6.sin6_addr,
706 rta_data, rta_payload);
707 if (IN6_IS_ADDR_LINKLOCAL (rta_data)
708 || IN6_IS_ADDR_MC_LINKLOCAL (rta_data))
709 ifas[ifa_index].broadaddr.s6.sin6_scope_id
710 = ifam->ifa_index;
711 }
712 break;
713
714 default:
715 if (rta_payload <= sizeof (ifas[ifa_index].addr))
716 memcpy (&ifas[ifa_index].broadaddr.sa.sa_data,
717 rta_data, rta_payload);
718 break;
719 }
720 break;
721
722 case IFA_LABEL:
723 if (rta_payload + 1 <= sizeof (ifas[ifa_index].name))
724 {
725 ifas[ifa_index].ifa.ifa_name = ifas[ifa_index].name;
726 *(char *) __mempcpy (ifas[ifa_index].name, rta_data,
727 rta_payload) = '\0';
728 }
729 else
730 abort ();
731 break;
732
733 case IFA_UNSPEC:
734 break;
735 case IFA_CACHEINFO:
736 break;
737 default:
738 break;
739 }
740
741 rta = RTA_NEXT (rta, rtasize);
742 }
743
744 /* If we didn't get the interface name with the
745 address, use the name from the interface entry. */
746 if (ifas[ifa_index].ifa.ifa_name == NULL)
747 {
748 int idx = map_newlink (ifam->ifa_index - 1, ifas,
749 map_newlink_data, newlink);
750 if (__glibc_unlikely (idx == -1))
751 goto try_again;
752 ifas[ifa_index].ifa.ifa_name = ifas[idx].ifa.ifa_name;
753 }
754
755 /* Calculate the netmask. */
756 if (ifas[ifa_index].ifa.ifa_addr
757 && ifas[ifa_index].ifa.ifa_addr->sa_family != AF_UNSPEC
758 && ifas[ifa_index].ifa.ifa_addr->sa_family != AF_PACKET)
759 {
760 uint32_t max_prefixlen = 0;
761 char *cp = NULL;
762
763 ifas[ifa_index].ifa.ifa_netmask
764 = &ifas[ifa_index].netmask.sa;
765
766 switch (ifas[ifa_index].ifa.ifa_addr->sa_family)
767 {
768 case AF_INET:
769 cp = (char *) &ifas[ifa_index].netmask.s4.sin_addr;
770 max_prefixlen = 32;
771 break;
772
773 case AF_INET6:
774 cp = (char *) &ifas[ifa_index].netmask.s6.sin6_addr;
775 max_prefixlen = 128;
776 break;
777 }
778
779 ifas[ifa_index].ifa.ifa_netmask->sa_family
780 = ifas[ifa_index].ifa.ifa_addr->sa_family;
781
782 if (cp != NULL)
783 {
784 unsigned int preflen;
785
786 if (ifam->ifa_prefixlen > max_prefixlen)
787 preflen = max_prefixlen;
788 else
789 preflen = ifam->ifa_prefixlen;
790
791 for (i = 0; i < preflen / 8; i++)
792 *cp++ = 0xff;
793 if (preflen % 8)
794 *cp = 0xff << (8 - preflen % 8);
795 }
796 }
797 }
798 }
799 }
800
801 assert (ifa_data_ptr <= (char *) &ifas[newlink + newaddr] + ifa_data_size);
802
803 if (newaddr_idx > 0)
804 {
805 for (i = 0; i < newlink; ++i)
806 if (map_newlink_data[i] == -1)
807 {
808 /* We have fewer links then we anticipated. Adjust the
809 forward pointer to the first address entry. */
810 ifas[i - 1].ifa.ifa_next = &ifas[newlink].ifa;
811 }
812
813 if (i == 0 && newlink > 0)
814 /* No valid link, but we allocated memory. We have to
815 populate the first entry. */
816 memmove (ifas, &ifas[newlink], sizeof (struct ifaddrs_storage));
817 }
818
819 *ifap = &ifas[0].ifa;
820
821 exit_free:
822 __netlink_free_handle (&nh);
823 __netlink_close (&nh);
824
825 return result;
826}
827
828
829/* Create a linked list of `struct ifaddrs' structures, one for each
830 network interface on the host machine. If successful, store the
831 list in *IFAP and return 0. On errors, return -1 and set `errno'. */
832int
833__getifaddrs (struct ifaddrs **ifap)
834{
835 int res;
836
837 do
838 res = getifaddrs_internal (ifap);
839 while (res == -EAGAIN);
840
841 return res;
842}
843weak_alias (__getifaddrs, getifaddrs)
844libc_hidden_def (__getifaddrs)
845libc_hidden_weak (getifaddrs)
846
847
848void
849__freeifaddrs (struct ifaddrs *ifa)
850{
851 free (ifa);
852}
853weak_alias (__freeifaddrs, freeifaddrs)
854libc_hidden_def (__freeifaddrs)
855libc_hidden_weak (freeifaddrs)
856