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 <sys/ioctl.h>
9 #include <net/if.h>
10 #include <netinet/in.h>
11 #include "netlink.h"
12 #ifndef __LITEOS__
13 #include <musl_log.h>
14 #endif
15
16 #define IFADDRS_HASH_SIZE 64
17
18 /* getifaddrs() reports hardware addresses with PF_PACKET that implies
19 * struct sockaddr_ll. But e.g. Infiniband socket address length is
20 * longer than sockaddr_ll.ssl_addr[8] can hold. Use this hack struct
21 * to extend ssl_addr - callers should be able to still use it. */
22 struct sockaddr_ll_hack {
23 unsigned short sll_family, sll_protocol;
24 int sll_ifindex;
25 unsigned short sll_hatype;
26 unsigned char sll_pkttype, sll_halen;
27 unsigned char sll_addr[24];
28 };
29
30 union sockany {
31 struct sockaddr sa;
32 struct sockaddr_ll_hack ll;
33 struct sockaddr_in v4;
34 struct sockaddr_in6 v6;
35 };
36
37 struct ifaddrs_storage {
38 struct ifaddrs ifa;
39 struct ifaddrs_storage *hash_next;
40 union sockany addr, netmask, ifu;
41 unsigned int index;
42 char name[IFNAMSIZ+1];
43 };
44
45 struct ifaddrs_ctx {
46 struct ifaddrs *first;
47 struct ifaddrs *last;
48 struct ifaddrs_storage *hash[IFADDRS_HASH_SIZE];
49 };
50
freeifaddrs(struct ifaddrs * ifp)51 void freeifaddrs(struct ifaddrs *ifp)
52 {
53 struct ifaddrs *n;
54 while (ifp) {
55 n = ifp->ifa_next;
56 free(ifp);
57 ifp = n;
58 }
59 }
60
copy_addr(struct sockaddr ** r,int af,union sockany * sa,void * addr,size_t addrlen,int ifindex)61 static void copy_addr(struct sockaddr **r, int af, union sockany *sa, void *addr, size_t addrlen, int ifindex)
62 {
63 uint8_t *dst;
64 int len;
65
66 switch (af) {
67 case AF_INET:
68 dst = (uint8_t*) &sa->v4.sin_addr;
69 len = 4;
70 break;
71 case AF_INET6:
72 dst = (uint8_t*) &sa->v6.sin6_addr;
73 len = 16;
74 if (IN6_IS_ADDR_LINKLOCAL(addr) || IN6_IS_ADDR_MC_LINKLOCAL(addr))
75 sa->v6.sin6_scope_id = ifindex;
76 break;
77 default:
78 return;
79 }
80 if (addrlen < len) return;
81 sa->sa.sa_family = af;
82 memcpy(dst, addr, len);
83 *r = &sa->sa;
84 }
85
gen_netmask(struct sockaddr ** r,int af,union sockany * sa,int prefixlen)86 static void gen_netmask(struct sockaddr **r, int af, union sockany *sa, int prefixlen)
87 {
88 uint8_t addr[16] = {0};
89 int i;
90
91 if (prefixlen > 8*sizeof(addr)) prefixlen = 8*sizeof(addr);
92 i = prefixlen / 8;
93 memset(addr, 0xff, i);
94 if (i < sizeof(addr)) addr[i++] = 0xff << (8 - (prefixlen % 8));
95 copy_addr(r, af, sa, addr, sizeof(addr), 0);
96 }
97
copy_lladdr(struct sockaddr ** r,union sockany * sa,void * addr,size_t addrlen,int ifindex,unsigned short hatype)98 static void copy_lladdr(struct sockaddr **r, union sockany *sa, void *addr, size_t addrlen, int ifindex, unsigned short hatype)
99 {
100 if (addrlen > sizeof(sa->ll.sll_addr)) return;
101 sa->ll.sll_family = AF_PACKET;
102 sa->ll.sll_ifindex = ifindex;
103 sa->ll.sll_hatype = hatype;
104 sa->ll.sll_halen = addrlen;
105 memcpy(sa->ll.sll_addr, addr, addrlen);
106 *r = &sa->sa;
107 }
108
netlink_msg_to_ifaddr(void * pctx,struct nlmsghdr * h)109 static int netlink_msg_to_ifaddr(void *pctx, struct nlmsghdr *h)
110 {
111 struct ifaddrs_ctx *ctx = pctx;
112 struct ifaddrs_storage *ifs, *ifs0;
113 struct ifinfomsg *ifi = NLMSG_DATA(h);
114 struct ifaddrmsg *ifa = NLMSG_DATA(h);
115 struct rtattr *rta;
116 int stats_len = 0;
117 int get_link_fail = 0;
118
119 if (h->nlmsg_type == RTM_NEWLINK) {
120 for (rta = NLMSG_RTA(h, sizeof(*ifi)); NLMSG_RTAOK(rta, h); rta = RTA_NEXT(rta)) {
121 if (rta->rta_type != IFLA_STATS) continue;
122 stats_len = RTA_DATALEN(rta);
123 break;
124 }
125 } else {
126 for (ifs0 = ctx->hash[ifa->ifa_index % IFADDRS_HASH_SIZE]; ifs0; ifs0 = ifs0->hash_next)
127 if (ifs0->index == ifa->ifa_index)
128 break;
129 if (!ifs0) {
130 get_link_fail = 1;
131 }
132 }
133
134 ifs = calloc(1, sizeof(struct ifaddrs_storage) + stats_len);
135 if (ifs == 0) return -1;
136
137 if (h->nlmsg_type == RTM_NEWLINK) {
138 ifs->index = ifi->ifi_index;
139 ifs->ifa.ifa_flags = ifi->ifi_flags;
140
141 for (rta = NLMSG_RTA(h, sizeof(*ifi)); NLMSG_RTAOK(rta, h); rta = RTA_NEXT(rta)) {
142 switch (rta->rta_type) {
143 case IFLA_IFNAME:
144 if (RTA_DATALEN(rta) < sizeof(ifs->name)) {
145 memcpy(ifs->name, RTA_DATA(rta), RTA_DATALEN(rta));
146 ifs->ifa.ifa_name = ifs->name;
147 }
148 break;
149 case IFLA_ADDRESS:
150 copy_lladdr(&ifs->ifa.ifa_addr, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifi->ifi_index, ifi->ifi_type);
151 break;
152 case IFLA_BROADCAST:
153 copy_lladdr(&ifs->ifa.ifa_broadaddr, &ifs->ifu, RTA_DATA(rta), RTA_DATALEN(rta), ifi->ifi_index, ifi->ifi_type);
154 break;
155 case IFLA_STATS:
156 ifs->ifa.ifa_data = (void*)(ifs+1);
157 memcpy(ifs->ifa.ifa_data, RTA_DATA(rta), RTA_DATALEN(rta));
158 break;
159 }
160 }
161 if (ifs->ifa.ifa_name) {
162 unsigned int bucket = ifs->index % IFADDRS_HASH_SIZE;
163 ifs->hash_next = ctx->hash[bucket];
164 ctx->hash[bucket] = ifs;
165 }
166 } else {
167 if (ifs0) {
168 ifs->ifa.ifa_name = ifs0->ifa.ifa_name;
169 ifs->ifa.ifa_flags = ifs0->ifa.ifa_flags;
170 }
171 ifs->index = ifa->ifa_index;
172 for (rta = NLMSG_RTA(h, sizeof(*ifa)); NLMSG_RTAOK(rta, h); rta = RTA_NEXT(rta)) {
173 switch (rta->rta_type) {
174 case IFA_ADDRESS:
175 /* If ifa_addr is already set we, received an IFA_LOCAL before
176 * so treat this as destination address */
177 if (ifs->ifa.ifa_addr)
178 copy_addr(&ifs->ifa.ifa_dstaddr, ifa->ifa_family, &ifs->ifu, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
179 else
180 copy_addr(&ifs->ifa.ifa_addr, ifa->ifa_family, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
181 break;
182 case IFA_BROADCAST:
183 copy_addr(&ifs->ifa.ifa_broadaddr, ifa->ifa_family, &ifs->ifu, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
184 break;
185 case IFA_LOCAL:
186 /* If ifa_addr is set and we get IFA_LOCAL, assume we have
187 * a point-to-point network. Move address to correct field. */
188 if (ifs->ifa.ifa_addr) {
189 ifs->ifu = ifs->addr;
190 ifs->ifa.ifa_dstaddr = &ifs->ifu.sa;
191 memset(&ifs->addr, 0, sizeof(ifs->addr));
192 }
193 copy_addr(&ifs->ifa.ifa_addr, ifa->ifa_family, &ifs->addr, RTA_DATA(rta), RTA_DATALEN(rta), ifa->ifa_index);
194 break;
195 case IFA_LABEL:
196 if (RTA_DATALEN(rta) < sizeof(ifs->name)) {
197 memcpy(ifs->name, RTA_DATA(rta), RTA_DATALEN(rta));
198 ifs->ifa.ifa_name = ifs->name;
199 }
200 break;
201 }
202 }
203 if (ifs->ifa.ifa_addr)
204 gen_netmask(&ifs->ifa.ifa_netmask, ifa->ifa_family, &ifs->netmask, ifa->ifa_prefixlen);
205 }
206
207 if (ifs->ifa.ifa_name || get_link_fail) {
208 if (!ctx->first) ctx->first = &ifs->ifa;
209 if (ctx->last) ctx->last->ifa_next = &ifs->ifa;
210 ctx->last = &ifs->ifa;
211 } else {
212 free(ifs);
213 }
214 return 0;
215 }
216
get_ifName_via_ioctl(struct ifaddrs_ctx * pctx)217 static void get_ifName_via_ioctl(struct ifaddrs_ctx *pctx)
218 {
219 struct ifaddrs_storage* addr = (struct ifaddrs_storage*)(pctx->first);
220 struct ifaddrs_storage* prev_addr = NULL;
221 while (addr != NULL) {
222 struct ifaddrs* next_addr = addr->ifa.ifa_next;
223
224 if (strlen(addr->name) == 0) {
225 if (if_indextoname(addr->index, addr->name) != NULL) {
226 addr->ifa.ifa_name = addr->name;
227 }
228 }
229
230 if (strlen(addr->name) == 0) {
231 if (prev_addr == NULL) {
232 pctx->first = next_addr;
233 } else {
234 prev_addr->ifa.ifa_next = next_addr;
235 }
236 free(addr);
237 } else {
238 prev_addr = addr;
239 }
240 addr = (struct ifaddrs_storage*)(next_addr);
241 }
242 }
243
get_ifFlag_via_ioctl(struct ifaddrs_ctx * pctx)244 static void get_ifFlag_via_ioctl(struct ifaddrs_ctx *pctx)
245 {
246 int fd;
247 if ((fd = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0)) < 0) {
248 #ifndef __LITEOS__
249 MUSL_LOGE("%{public}s: %{public}d: create Udp socket failed, errno: %{public}d",
250 __func__, __LINE__, errno);
251 #endif
252 return;
253 }
254 for (struct ifaddrs* addr = pctx->first; addr != NULL; addr = addr->ifa_next) {
255 struct ifreq ifr;
256 strlcpy(ifr.ifr_name, addr->ifa_name, sizeof(ifr.ifr_name));
257 if (ioctl(fd, SIOCGIFFLAGS, &ifr) != -1) {
258 addr->ifa_flags = ifr.ifr_flags;
259 } else {
260 #ifndef __LITEOS__
261 MUSL_LOGE("%{public}s: %{public}d: ioctl(SIOCGIFFLAGS) failed for %{public}s, errno: %{public}d",
262 __func__, __LINE__, addr->ifa_name, errno);
263 #endif
264 }
265 }
266 __syscall(SYS_close, fd);
267 }
268
getifaddrs(struct ifaddrs ** ifap)269 int getifaddrs(struct ifaddrs **ifap)
270 {
271 struct ifaddrs_ctx _ctx, *ctx = &_ctx;
272 int r, getlink;
273 memset(ctx, 0, sizeof *ctx);
274 r = __rtnetlink_enumerate_new(AF_UNSPEC, AF_UNSPEC, netlink_msg_to_ifaddr, ctx, &getlink);
275 if (r < 0) {
276 freeifaddrs(ctx->first);
277 return -1;
278 }
279 if (getlink < 0) {
280 get_ifName_via_ioctl(ctx);
281 get_ifFlag_via_ioctl(ctx);
282 }
283
284 *ifap = ctx->first;
285 return 0;
286 }
287