getifaddrs.c raw
1 #define _GNU_SOURCE
2 #include <errno.h>
3 #include <string.h>
4 #include <stdlib.h>
5 #include <unistd.h>
6 #include <ifaddrs.h>
7 #include <syscall.h>
8 #include <net/if.h>
9 #include <netinet/in.h>
10 #include "netlink.h"
11
12 #define IFADDRS_HASH_SIZE 64
13
14 /* getifaddrs() reports hardware addresses with PF_PACKET that implies
15 * struct sockaddr_ll. But e.g. Infiniband socket address length is
16 * longer than sockaddr_ll.ssl_addr[8] can hold. Use this hack struct
17 * to extend ssl_addr - callers should be able to still use it. */
18 struct sockaddr_ll_hack {
19 unsigned short sll_family, sll_protocol;
20 int sll_ifindex;
21 unsigned short sll_hatype;
22 unsigned char sll_pkttype, sll_halen;
23 unsigned char sll_addr[24];
24 };
25
26 union sockany {
27 struct sockaddr sa;
28 struct sockaddr_ll_hack ll;
29 struct sockaddr_in v4;
30 struct sockaddr_in6 v6;
31 };
32
33 struct ifaddrs_storage {
34 struct ifaddrs ifa;
35 struct ifaddrs_storage *hash_next;
36 union sockany addr, netmask, ifu;
37 unsigned int index;
38 char name[IFNAMSIZ+1];
39 };
40
41 struct ifaddrs_ctx {
42 struct ifaddrs_storage *first;
43 struct ifaddrs_storage *last;
44 struct ifaddrs_storage *hash[IFADDRS_HASH_SIZE];
45 };
46
47 void freeifaddrs(struct ifaddrs *ifp)
48 {
49 struct ifaddrs *n;
50 while (ifp) {
51 n = ifp->ifa_next;
52 free(ifp);
53 ifp = n;
54 }
55 }
56
57 static void copy_addr(struct sockaddr **r, int af, union sockany *sa, void *addr, size_t addrlen, int ifindex)
58 {
59 uint8_t *dst;
60 int len;
61
62 switch (af) {
63 case AF_INET:
64 dst = (uint8_t*) &sa->v4.sin_addr;
65 len = 4;
66 break;
67 case AF_INET6:
68 dst = (uint8_t*) &sa->v6.sin6_addr;
69 len = 16;
70 if (IN6_IS_ADDR_LINKLOCAL(addr) || IN6_IS_ADDR_MC_LINKLOCAL(addr))
71 sa->v6.sin6_scope_id = ifindex;
72 break;
73 default:
74 return;
75 }
76 if (addrlen < len) return;
77 sa->sa.sa_family = af;
78 memcpy(dst, addr, len);
79 *r = &sa->sa;
80 }
81
82 static void gen_netmask(struct sockaddr **r, int af, union sockany *sa, int prefixlen)
83 {
84 uint8_t addr[16] = {0};
85 int i;
86
87 if (prefixlen > 8*sizeof(addr)) prefixlen = 8*sizeof(addr);
88 i = prefixlen / 8;
89 memset(addr, 0xff, i);
90 if (i < sizeof(addr)) addr[i++] = 0xff << (8 - (prefixlen % 8));
91 copy_addr(r, af, sa, addr, sizeof(addr), 0);
92 }
93
94 static void copy_lladdr(struct sockaddr **r, union sockany *sa, void *addr, size_t addrlen, int ifindex, unsigned short hatype)
95 {
96 if (addrlen > sizeof(sa->ll.sll_addr)) return;
97 sa->ll.sll_family = AF_PACKET;
98 sa->ll.sll_ifindex = ifindex;
99 sa->ll.sll_hatype = hatype;
100 sa->ll.sll_halen = addrlen;
101 memcpy(sa->ll.sll_addr, addr, addrlen);
102 *r = &sa->sa;
103 }
104
105 static int netlink_msg_to_ifaddr(void *pctx, struct nlmsghdr *h)
106 {
107 struct ifaddrs_ctx *ctx = pctx;
108 struct ifaddrs_storage *ifs, *ifs0;
109 struct ifinfomsg *ifi = NLMSG_DATA(h);
110 struct ifaddrmsg *ifa = NLMSG_DATA(h);
111 struct rtattr *rta;
112 int stats_len = 0;
113
114 if (h->nlmsg_type == RTM_NEWLINK) {
115 for (rta = NLMSG_RTA(h, sizeof(*ifi)); NLMSG_RTAOK(rta, h); rta = RTA_NEXT(rta)) {
116 if (rta->rta_type != IFLA_STATS) continue;
117 stats_len = RTA_DATALEN(rta);
118 break;
119 }
120 } else {
121 for (ifs0 = ctx->hash[ifa->ifa_index % IFADDRS_HASH_SIZE]; ifs0; ifs0 = ifs0->hash_next)
122 if (ifs0->index == ifa->ifa_index)
123 break;
124 if (!ifs0) return 0;
125 }
126
127 ifs = calloc(1, sizeof(struct ifaddrs_storage) + stats_len);
128 if (ifs == 0) return -1;
129
130 if (h->nlmsg_type == RTM_NEWLINK) {
131 ifs->index = ifi->ifi_index;
132 ifs->ifa.ifa_flags = ifi->ifi_flags;
133
134 for (rta = NLMSG_RTA(h, sizeof(*ifi)); NLMSG_RTAOK(rta, h); rta = RTA_NEXT(rta)) {
135 switch (rta->rta_type) {
136 case IFLA_IFNAME:
137 if (RTA_DATALEN(rta) < sizeof(ifs->name)) {
138 memcpy(ifs->name, RTA_DATA(rta), RTA_DATALEN(rta));
139 ifs->ifa.ifa_name = ifs->name;
140 }
141 break;
142 case IFLA_ADDRESS:
143 copy_lladdr(&ifs->ifa.ifa_addr, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifi->ifi_index, ifi->ifi_type);
144 break;
145 case IFLA_BROADCAST:
146 copy_lladdr(&ifs->ifa.ifa_broadaddr, &ifs->ifu, RTA_DATA(rta), RTA_DATALEN(rta), ifi->ifi_index, ifi->ifi_type);
147 break;
148 case IFLA_STATS:
149 ifs->ifa.ifa_data = (void*)(ifs+1);
150 memcpy(ifs->ifa.ifa_data, RTA_DATA(rta), RTA_DATALEN(rta));
151 break;
152 }
153 }
154 if (ifs->ifa.ifa_name) {
155 unsigned int bucket = ifs->index % IFADDRS_HASH_SIZE;
156 ifs->hash_next = ctx->hash[bucket];
157 ctx->hash[bucket] = ifs;
158 }
159 } else {
160 ifs->ifa.ifa_name = ifs0->ifa.ifa_name;
161 ifs->ifa.ifa_flags = ifs0->ifa.ifa_flags;
162 for (rta = NLMSG_RTA(h, sizeof(*ifa)); NLMSG_RTAOK(rta, h); rta = RTA_NEXT(rta)) {
163 switch (rta->rta_type) {
164 case IFA_ADDRESS:
165 /* If ifa_addr is already set we, received an IFA_LOCAL before
166 * so treat this as destination address */
167 if (ifs->ifa.ifa_addr)
168 copy_addr(&ifs->ifa.ifa_dstaddr, ifa->ifa_family, &ifs->ifu, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
169 else
170 copy_addr(&ifs->ifa.ifa_addr, ifa->ifa_family, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
171 break;
172 case IFA_BROADCAST:
173 copy_addr(&ifs->ifa.ifa_broadaddr, ifa->ifa_family, &ifs->ifu, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
174 break;
175 case IFA_LOCAL:
176 /* If ifa_addr is set and we get IFA_LOCAL, assume we have
177 * a point-to-point network. Move address to correct field. */
178 if (ifs->ifa.ifa_addr) {
179 ifs->ifu = ifs->addr;
180 ifs->ifa.ifa_dstaddr = &ifs->ifu.sa;
181 memset(&ifs->addr, 0, sizeof(ifs->addr));
182 }
183 copy_addr(&ifs->ifa.ifa_addr, ifa->ifa_family, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
184 break;
185 case IFA_LABEL:
186 if (RTA_DATALEN(rta) < sizeof(ifs->name)) {
187 memcpy(ifs->name, RTA_DATA(rta), RTA_DATALEN(rta));
188 ifs->ifa.ifa_name = ifs->name;
189 }
190 break;
191 }
192 }
193 if (ifs->ifa.ifa_addr)
194 gen_netmask(&ifs->ifa.ifa_netmask, ifa->ifa_family, &ifs->netmask, ifa->ifa_prefixlen);
195 }
196
197 if (ifs->ifa.ifa_name) {
198 if (!ctx->first) ctx->first = ifs;
199 if (ctx->last) ctx->last->ifa.ifa_next = &ifs->ifa;
200 ctx->last = ifs;
201 } else {
202 free(ifs);
203 }
204 return 0;
205 }
206
207 int getifaddrs(struct ifaddrs **ifap)
208 {
209 struct ifaddrs_ctx _ctx, *ctx = &_ctx;
210 int r;
211 memset(ctx, 0, sizeof *ctx);
212 r = __rtnetlink_enumerate(AF_UNSPEC, AF_UNSPEC, netlink_msg_to_ifaddr, ctx);
213 if (r == 0) *ifap = &ctx->first->ifa;
214 else freeifaddrs(&ctx->first->ifa);
215 return r;
216 }
217