nsz Git - musl/blob - src/network/getifaddrs.c

   1 /* (C) 2013 John Spencer. released under musl's standard MIT license. */
   2 #undef _GNU_SOURCE
   3 #define _GNU_SOURCE
   4 #include <ifaddrs.h>
   5 #include <stdlib.h>
   6 #include <net/if.h> /* IFNAMSIZ, ifreq, ifconf */
   7 #include <stdio.h>
   8 #include <ctype.h>
   9 #include <string.h>
  10 #include <errno.h>
  11 #include <arpa/inet.h> /* inet_pton */
  12 #include <unistd.h>
  13 #include <sys/ioctl.h>
  14
  15 typedef union {
  16         struct sockaddr_in6 v6;
  17         struct sockaddr_in v4;
  18 } soa;
  19
  20 typedef struct ifaddrs_storage {
  21         struct ifaddrs ifa;
  22         soa addr;
  23         soa netmask;
  24         soa dst;
  25         char name[IFNAMSIZ+1];
  26 } stor;
  27 #define next ifa.ifa_next
  28
  29 static stor* list_add(stor** list, stor** head, char* ifname)
  30 {
  31         stor* curr = calloc(1, sizeof(stor));
  32         if(curr) {
  33                 strcpy(curr->name, ifname);
  34                 curr->ifa.ifa_name = curr->name;
  35                 if(*head) (*head)->next = (struct ifaddrs*) curr;
  36                 *head = curr;
  37                 if(!*list) *list = curr;
  38         }
  39         return curr;
  40 }
  41
  42 void freeifaddrs(struct ifaddrs *ifp)
  43 {
  44         stor *head = (stor *) ifp;
  45         while(head) {
  46                 void *p = head;
  47                 head = (stor *) head->next;
  48                 free(p);
  49         }
  50 }
  51
  52 static void ipv6netmask(unsigned prefix_length, struct sockaddr_in6 *sa)
  53 {
  54         // FIXME: left for bit-wizard rich
  55         memset(&sa->sin6_addr, -1, sizeof(sa->sin6_addr));
  56 }
  57
  58 static void dealwithipv6(stor **list, stor** head)
  59 {
  60         FILE* f = fopen("/proc/net/if_inet6", "r");
  61         /* 00000000000000000000000000000001 01 80 10 80 lo
  62            A                                B  C  D  E  F
  63            all numbers in hex
  64            A = addr B=netlink device#, C=prefix length,
  65            D = scope value (ipv6.h) E = interface flags (rnetlink.h, addrconf.c)
  66            F = if name */
  67         char v6conv[32 + 7 + 1], *v6;
  68         char *line, linebuf[512];
  69         if(!f) return;
  70         while((line = fgets(linebuf, sizeof linebuf, f))) {
  71                 v6 = v6conv;
  72                 size_t i = 0;
  73                 for(; i < 8; i++) {
  74                         memcpy(v6, line, 4);
  75                         v6+=4;
  76                         *v6++=':';
  77                         line+=4;
  78                 }
  79                 --v6; *v6 = 0;
  80                 line++;
  81                 unsigned b, c, d, e;
  82                 char name[IFNAMSIZ+1];
  83                 if(5 == sscanf(line, "%x %x %x %x %s", &b, &c, &d, &e, name)) {
  84                         struct sockaddr_in6 sa = {0};
  85                         if(1 == inet_pton(AF_INET6, v6conv, &sa.sin6_addr)) {
  86                                 sa.sin6_family = AF_INET6;
  87                                 stor* curr = list_add(list, head, name);
  88                                 if(!curr) goto out;
  89                                 curr->addr.v6 = sa;
  90                                 curr->ifa.ifa_addr = (struct sockaddr*) &curr->addr;
  91                                 ipv6netmask(c, &sa);
  92                                 curr->netmask.v6 = sa;
  93                                 curr->ifa.ifa_netmask = (struct sockaddr*) &curr->netmask;
  94                                 /* find ipv4 struct with the same interface name to copy flags */
  95                                 stor* scan = *list;
  96                                 for(;scan && strcmp(name, scan->name);scan=(stor*)scan->next);
  97                                 if(scan) curr->ifa.ifa_flags = scan->ifa.ifa_flags;
  98                                 else curr->ifa.ifa_flags = 0;
  99                         } else errno = 0;
 100                 }
 101         }
 102         out:
 103         fclose(f);
 104 }
 105
 106 int getifaddrs(struct ifaddrs **ifap)
 107 {
 108         stor *list = 0, *head = 0;
 109         struct if_nameindex* ii = if_nameindex();
 110         if(!ii) return -1;
 111         size_t i;
 112         for(i = 0; ii[i].if_index || ii[i].if_name; i++) {
 113                 stor* curr = list_add(&list, &head, ii[i].if_name);
 114                 if(!curr) {
 115                         if_freenameindex(ii);
 116                         goto err2;
 117                 }
 118         }
 119         if_freenameindex(ii);
 120
 121         int sock = socket(PF_INET, SOCK_DGRAM, IPPROTO_IP);
 122         if(sock == -1) goto err2;
 123         struct ifreq reqs[32]; /* arbitrary chosen boundary */
 124         struct ifconf conf = {.ifc_len = sizeof reqs, .ifc_req = reqs};
 125         if(-1 == ioctl(sock, SIOCGIFCONF, &conf)) goto err;
 126         size_t reqitems = conf.ifc_len / sizeof(struct ifreq);
 127         for(head = list; head; head = (stor*)head->next) {
 128                 for(i = 0; i < reqitems; i++) {
 129                         // get SIOCGIFADDR of active interfaces.
 130                         if(!strcmp(reqs[i].ifr_name, head->name)) {
 131                                 head->addr.v4 = *(struct sockaddr_in*)&reqs[i].ifr_addr;
 132                                 head->ifa.ifa_addr = (struct sockaddr*) &head->addr;
 133                                 break;
 134                         }
 135                 }
 136                 struct ifreq req;
 137                 snprintf(req.ifr_name, sizeof req.ifr_name, "%s", head->name);
 138                 if(-1 == ioctl(sock, SIOCGIFFLAGS, &req)) goto err;
 139
 140                 head->ifa.ifa_flags = req.ifr_flags;
 141                 if(head->ifa.ifa_addr) {
 142                         /* or'ing flags with IFF_LOWER_UP on active interfaces to mimic glibc */
 143                         head->ifa.ifa_flags |= IFF_LOWER_UP;
 144                         if(-1 == ioctl(sock, SIOCGIFNETMASK, &req)) goto err;
 145                         head->netmask.v4 = *(struct sockaddr_in*)&req.ifr_netmask;
 146                         head->ifa.ifa_netmask = (struct sockaddr*) &head->netmask;
 147
 148                         if(head->ifa.ifa_flags & IFF_POINTOPOINT) {
 149                                 if(-1 == ioctl(sock, SIOCGIFDSTADDR, &req)) goto err;
 150                                 head->dst.v4 = *(struct sockaddr_in*)&req.ifr_dstaddr;
 151                         } else {
 152                                 if(-1 == ioctl(sock, SIOCGIFBRDADDR, &req)) goto err;
 153                                 head->dst.v4 = *(struct sockaddr_in*)&req.ifr_broadaddr;
 154                         }
 155                         head->ifa.ifa_ifu.ifu_dstaddr = (struct sockaddr*) &head->dst;
 156                 }
 157         }
 158         close(sock);
 159         void* last = 0;
 160         for(head = list; head; head=(stor*)head->next) last=head;
 161         head = last;
 162         dealwithipv6(&list, &head);
 163         *ifap = (struct ifaddrs*) list;
 164         return 0;
 165         err:
 166         close(sock);
 167         err2:
 168         freeifaddrs((struct ifaddrs*) list);
 169         return -1;
 170 }
 171