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