ifc_utils.c revision eec232603d314e486888e5a0d2dd8d507c266be7 
1/*
2 * Copyright 2008, The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *     http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17#include <stdio.h>
18#include <stdlib.h>
19#include <unistd.h>
20#include <string.h>
21#include <errno.h>
22
23#include <sys/socket.h>
24#include <sys/select.h>
25#include <sys/types.h>
26#include <netinet/in.h>
27#include <arpa/inet.h>
28#include <net/if.h>
29#include <netdb.h>
30
31#include <linux/if.h>
32#include <linux/if_ether.h>
33#include <linux/if_arp.h>
34#include <linux/netlink.h>
35#include <linux/route.h>
36#include <linux/ipv6_route.h>
37#include <linux/rtnetlink.h>
38#include <linux/sockios.h>
39
40#include "netutils/ifc.h"
41
42#ifdef ANDROID
43#define LOG_TAG "NetUtils"
44#include <cutils/log.h>
45#include <cutils/properties.h>
46#else
47#include <stdio.h>
48#include <string.h>
49#define ALOGD printf
50#define ALOGW printf
51#endif
52
53#ifdef HAVE_ANDROID_OS
54/* SIOCKILLADDR is an Android extension. */
55#define SIOCKILLADDR 0x8939
56#endif
57
58static int ifc_ctl_sock = -1;
59static int ifc_ctl_sock6 = -1;
60void printerr(char *fmt, ...);
61
62#define DBG 0
63#define INET_ADDRLEN 4
64#define INET6_ADDRLEN 16
65
66in_addr_t prefixLengthToIpv4Netmask(int prefix_length)
67{
68    in_addr_t mask = 0;
69
70    // C99 (6.5.7): shifts of 32 bits have undefined results
71    if (prefix_length <= 0 || prefix_length > 32) {
72        return 0;
73    }
74
75    mask = ~mask << (32 - prefix_length);
76    mask = htonl(mask);
77
78    return mask;
79}
80
81int ipv4NetmaskToPrefixLength(in_addr_t mask)
82{
83    int prefixLength = 0;
84    uint32_t m = (uint32_t)ntohl(mask);
85    while (m & 0x80000000) {
86        prefixLength++;
87        m = m << 1;
88    }
89    return prefixLength;
90}
91
92static const char *ipaddr_to_string(in_addr_t addr)
93{
94    struct in_addr in_addr;
95
96    in_addr.s_addr = addr;
97    return inet_ntoa(in_addr);
98}
99
100int string_to_ip(const char *string, struct sockaddr_storage *ss) {
101    struct addrinfo hints, *ai;
102    int ret;
103
104    if (ss == NULL) {
105        return -EFAULT;
106    }
107
108    memset(&hints, 0, sizeof(hints));
109    hints.ai_family = AF_UNSPEC;
110    hints.ai_flags = AI_NUMERICHOST;
111    hints.ai_socktype = SOCK_DGRAM;
112
113    ret = getaddrinfo(string, NULL, &hints, &ai);
114    if (ret == 0) {
115        memcpy(ss, ai->ai_addr, ai->ai_addrlen);
116        freeaddrinfo(ai);
117    }
118
119    return ret;
120}
121
122int ifc_init(void)
123{
124    int ret;
125    if (ifc_ctl_sock == -1) {
126        ifc_ctl_sock = socket(AF_INET, SOCK_DGRAM, 0);
127        if (ifc_ctl_sock < 0) {
128            printerr("socket() failed: %s\n", strerror(errno));
129        }
130    }
131
132    ret = ifc_ctl_sock < 0 ? -1 : 0;
133    if (DBG) printerr("ifc_init_returning %d", ret);
134    return ret;
135}
136
137int ifc_init6(void)
138{
139    if (ifc_ctl_sock6 == -1) {
140        ifc_ctl_sock6 = socket(AF_INET6, SOCK_DGRAM, 0);
141        if (ifc_ctl_sock6 < 0) {
142            printerr("socket() failed: %s\n", strerror(errno));
143        }
144    }
145    return ifc_ctl_sock6 < 0 ? -1 : 0;
146}
147
148void ifc_close(void)
149{
150    if (DBG) printerr("ifc_close");
151    if (ifc_ctl_sock != -1) {
152        (void)close(ifc_ctl_sock);
153        ifc_ctl_sock = -1;
154    }
155}
156
157void ifc_close6(void)
158{
159    if (ifc_ctl_sock6 != -1) {
160        (void)close(ifc_ctl_sock6);
161        ifc_ctl_sock6 = -1;
162    }
163}
164
165static void ifc_init_ifr(const char *name, struct ifreq *ifr)
166{
167    memset(ifr, 0, sizeof(struct ifreq));
168    strncpy(ifr->ifr_name, name, IFNAMSIZ);
169    ifr->ifr_name[IFNAMSIZ - 1] = 0;
170}
171
172int ifc_get_hwaddr(const char *name, void *ptr)
173{
174    int r;
175    struct ifreq ifr;
176    ifc_init_ifr(name, &ifr);
177
178    r = ioctl(ifc_ctl_sock, SIOCGIFHWADDR, &ifr);
179    if(r < 0) return -1;
180
181    memcpy(ptr, &ifr.ifr_hwaddr.sa_data, ETH_ALEN);
182    return 0;
183}
184
185int ifc_get_ifindex(const char *name, int *if_indexp)
186{
187    int r;
188    struct ifreq ifr;
189    ifc_init_ifr(name, &ifr);
190
191    r = ioctl(ifc_ctl_sock, SIOCGIFINDEX, &ifr);
192    if(r < 0) return -1;
193
194    *if_indexp = ifr.ifr_ifindex;
195    return 0;
196}
197
198static int ifc_set_flags(const char *name, unsigned set, unsigned clr)
199{
200    struct ifreq ifr;
201    ifc_init_ifr(name, &ifr);
202
203    if(ioctl(ifc_ctl_sock, SIOCGIFFLAGS, &ifr) < 0) return -1;
204    ifr.ifr_flags = (ifr.ifr_flags & (~clr)) | set;
205    return ioctl(ifc_ctl_sock, SIOCSIFFLAGS, &ifr);
206}
207
208int ifc_up(const char *name)
209{
210    int ret = ifc_set_flags(name, IFF_UP, 0);
211    if (DBG) printerr("ifc_up(%s) = %d", name, ret);
212    return ret;
213}
214
215int ifc_down(const char *name)
216{
217    int ret = ifc_set_flags(name, 0, IFF_UP);
218    if (DBG) printerr("ifc_down(%s) = %d", name, ret);
219    return ret;
220}
221
222static void init_sockaddr_in(struct sockaddr *sa, in_addr_t addr)
223{
224    struct sockaddr_in *sin = (struct sockaddr_in *) sa;
225    sin->sin_family = AF_INET;
226    sin->sin_port = 0;
227    sin->sin_addr.s_addr = addr;
228}
229
230int ifc_set_addr(const char *name, in_addr_t addr)
231{
232    struct ifreq ifr;
233    int ret;
234
235    ifc_init_ifr(name, &ifr);
236    init_sockaddr_in(&ifr.ifr_addr, addr);
237
238    ret = ioctl(ifc_ctl_sock, SIOCSIFADDR, &ifr);
239    if (DBG) printerr("ifc_set_addr(%s, xx) = %d", name, ret);
240    return ret;
241}
242
243/*
244 * Adds or deletes an IP address on an interface.
245 *
246 * Action is one of:
247 * - RTM_NEWADDR (to add a new address)
248 * - RTM_DELADDR (to delete an existing address)
249 *
250 * Returns zero on success and negative errno on failure.
251 */
252int ifc_act_on_address(int action, const char *name, const char *address,
253                       int prefixlen) {
254    int ifindex, s, len, ret;
255    struct sockaddr_storage ss;
256    void *addr;
257    size_t addrlen;
258    struct {
259        struct nlmsghdr n;
260        struct ifaddrmsg r;
261        // Allow for IPv6 address, headers, and padding.
262        char attrbuf[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
263                     NLMSG_ALIGN(sizeof(struct rtattr)) +
264                     NLMSG_ALIGN(INET6_ADDRLEN)];
265    } req;
266    struct rtattr *rta;
267    struct nlmsghdr *nh;
268    struct nlmsgerr *err;
269    char buf[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
270             NLMSG_ALIGN(sizeof(struct nlmsgerr)) +
271             NLMSG_ALIGN(sizeof(struct nlmsghdr))];
272
273    // Get interface ID.
274    ifindex = if_nametoindex(name);
275    if (ifindex == 0) {
276        return -errno;
277    }
278
279    // Convert string representation to sockaddr_storage.
280    ret = string_to_ip(address, &ss);
281    if (ret) {
282        return ret;
283    }
284
285    // Determine address type and length.
286    if (ss.ss_family == AF_INET) {
287        struct sockaddr_in *sin = (struct sockaddr_in *) &ss;
288        addr = &sin->sin_addr;
289        addrlen = INET_ADDRLEN;
290    } else if (ss.ss_family == AF_INET6) {
291        struct sockaddr_in6 *sin6 = (struct sockaddr_in6 *) &ss;
292        addr = &sin6->sin6_addr;
293        addrlen = INET6_ADDRLEN;
294    } else {
295        return -EAFNOSUPPORT;
296    }
297
298    // Fill in netlink structures.
299    memset(&req, 0, sizeof(req));
300
301    // Netlink message header.
302    req.n.nlmsg_len = NLMSG_LENGTH(sizeof(req.r));
303    req.n.nlmsg_type = action;
304    req.n.nlmsg_flags = NLM_F_REQUEST | NLM_F_ACK;
305    req.n.nlmsg_pid = getpid();
306
307    // Interface address message header.
308    req.r.ifa_family = ss.ss_family;
309    req.r.ifa_prefixlen = prefixlen;
310    req.r.ifa_index = ifindex;
311
312    // Routing attribute. Contains the actual IP address.
313    rta = (struct rtattr *) (((char *) &req) + NLMSG_ALIGN(req.n.nlmsg_len));
314    rta->rta_type = IFA_LOCAL;
315    rta->rta_len = RTA_LENGTH(addrlen);
316    req.n.nlmsg_len = NLMSG_ALIGN(req.n.nlmsg_len) + RTA_LENGTH(addrlen);
317    memcpy(RTA_DATA(rta), addr, addrlen);
318
319    s = socket(PF_NETLINK, SOCK_RAW, NETLINK_ROUTE);
320    if (send(s, &req, req.n.nlmsg_len, 0) < 0) {
321        close(s);
322        return -errno;
323    }
324
325    len = recv(s, buf, sizeof(buf), 0);
326    close(s);
327    if (len < 0) {
328        return -errno;
329    }
330
331    // Parse the acknowledgement to find the return code.
332    nh = (struct nlmsghdr *) buf;
333    if (!NLMSG_OK(nh, (unsigned) len) || nh->nlmsg_type != NLMSG_ERROR) {
334        return -EINVAL;
335    }
336    err = NLMSG_DATA(nh);
337
338    // Return code is negative errno.
339    return err->error;
340}
341
342int ifc_add_address(const char *name, const char *address, int prefixlen) {
343    return ifc_act_on_address(RTM_NEWADDR, name, address, prefixlen);
344}
345
346int ifc_del_address(const char *name, const char * address, int prefixlen) {
347    return ifc_act_on_address(RTM_DELADDR, name, address, prefixlen);
348}
349
350/*
351 * Clears IPv6 addresses on the specified interface.
352 */
353int ifc_clear_ipv6_addresses(const char *name) {
354    char rawaddrstr[INET6_ADDRSTRLEN], addrstr[INET6_ADDRSTRLEN];
355    unsigned int prefixlen;
356    int lasterror = 0, i, j, ret;
357    char ifname[64];  // Currently, IFNAMSIZ = 16.
358    FILE *f = fopen("/proc/net/if_inet6", "r");
359    if (!f) {
360        return -errno;
361    }
362
363    // Format:
364    // 20010db8000a0001fc446aa4b5b347ed 03 40 00 01    wlan0
365    while (fscanf(f, "%32s %*02x %02x %*02x %*02x %63s\n",
366                  rawaddrstr, &prefixlen, ifname) == 3) {
367        // Is this the interface we're looking for?
368        if (strcmp(name, ifname)) {
369            continue;
370        }
371
372        // Put the colons back into the address.
373        for (i = 0, j = 0; i < 32; i++, j++) {
374            addrstr[j] = rawaddrstr[i];
375            if (i % 4 == 3) {
376                addrstr[++j] = ':';
377            }
378        }
379        addrstr[j - 1] = '\0';
380
381        // Don't delete the link-local address as well, or it will disable IPv6
382        // on the interface.
383        if (strncmp(addrstr, "fe80:", 5) == 0) {
384            continue;
385        }
386
387        ret = ifc_del_address(ifname, addrstr, prefixlen);
388        if (ret) {
389            ALOGE("Deleting address %s/%d on %s: %s", addrstr, prefixlen, ifname,
390                 strerror(-ret));
391            lasterror = ret;
392        }
393    }
394
395    fclose(f);
396    return lasterror;
397}
398
399/*
400 * Clears IPv4 addresses on the specified interface.
401 */
402void ifc_clear_ipv4_addresses(const char *name) {
403    unsigned count, addr;
404    ifc_init();
405    for (count=0, addr=1;((addr != 0) && (count < 255)); count++) {
406        if (ifc_get_addr(name, &addr) < 0)
407            break;
408        if (addr)
409            ifc_set_addr(name, 0);
410    }
411    ifc_close();
412}
413
414/*
415 * Clears all IP addresses on the specified interface.
416 */
417int ifc_clear_addresses(const char *name) {
418    ifc_clear_ipv4_addresses(name);
419    return ifc_clear_ipv6_addresses(name);
420}
421
422int ifc_set_hwaddr(const char *name, const void *ptr)
423{
424    int r;
425    struct ifreq ifr;
426    ifc_init_ifr(name, &ifr);
427
428    ifr.ifr_hwaddr.sa_family = ARPHRD_ETHER;
429    memcpy(&ifr.ifr_hwaddr.sa_data, ptr, ETH_ALEN);
430    return ioctl(ifc_ctl_sock, SIOCSIFHWADDR, &ifr);
431}
432
433int ifc_set_mask(const char *name, in_addr_t mask)
434{
435    struct ifreq ifr;
436    int ret;
437
438    ifc_init_ifr(name, &ifr);
439    init_sockaddr_in(&ifr.ifr_addr, mask);
440
441    ret = ioctl(ifc_ctl_sock, SIOCSIFNETMASK, &ifr);
442    if (DBG) printerr("ifc_set_mask(%s, xx) = %d", name, ret);
443    return ret;
444}
445
446int ifc_set_prefixLength(const char *name, int prefixLength)
447{
448    struct ifreq ifr;
449    // TODO - support ipv6
450    if (prefixLength > 32 || prefixLength < 0) return -1;
451
452    in_addr_t mask = prefixLengthToIpv4Netmask(prefixLength);
453    ifc_init_ifr(name, &ifr);
454    init_sockaddr_in(&ifr.ifr_addr, mask);
455
456    return ioctl(ifc_ctl_sock, SIOCSIFNETMASK, &ifr);
457}
458
459int ifc_get_addr(const char *name, in_addr_t *addr)
460{
461    struct ifreq ifr;
462    int ret = 0;
463
464    ifc_init_ifr(name, &ifr);
465    if (addr != NULL) {
466        ret = ioctl(ifc_ctl_sock, SIOCGIFADDR, &ifr);
467        if (ret < 0) {
468            *addr = 0;
469        } else {
470            *addr = ((struct sockaddr_in*) &ifr.ifr_addr)->sin_addr.s_addr;
471        }
472    }
473    return ret;
474}
475
476int ifc_get_info(const char *name, in_addr_t *addr, int *prefixLength, unsigned *flags)
477{
478    struct ifreq ifr;
479    ifc_init_ifr(name, &ifr);
480
481    if (addr != NULL) {
482        if(ioctl(ifc_ctl_sock, SIOCGIFADDR, &ifr) < 0) {
483            *addr = 0;
484        } else {
485            *addr = ((struct sockaddr_in*) &ifr.ifr_addr)->sin_addr.s_addr;
486        }
487    }
488
489    if (prefixLength != NULL) {
490        if(ioctl(ifc_ctl_sock, SIOCGIFNETMASK, &ifr) < 0) {
491            *prefixLength = 0;
492        } else {
493            *prefixLength = ipv4NetmaskToPrefixLength(
494                    ((struct sockaddr_in*) &ifr.ifr_addr)->sin_addr.s_addr);
495        }
496    }
497
498    if (flags != NULL) {
499        if(ioctl(ifc_ctl_sock, SIOCGIFFLAGS, &ifr) < 0) {
500            *flags = 0;
501        } else {
502            *flags = ifr.ifr_flags;
503        }
504    }
505
506    return 0;
507}
508
509int ifc_act_on_ipv4_route(int action, const char *ifname, struct in_addr dst, int prefix_length,
510      struct in_addr gw)
511{
512    struct rtentry rt;
513    int result;
514    in_addr_t netmask;
515
516    memset(&rt, 0, sizeof(rt));
517
518    rt.rt_dst.sa_family = AF_INET;
519    rt.rt_dev = (void*) ifname;
520
521    netmask = prefixLengthToIpv4Netmask(prefix_length);
522    init_sockaddr_in(&rt.rt_genmask, netmask);
523    init_sockaddr_in(&rt.rt_dst, dst.s_addr);
524    rt.rt_flags = RTF_UP;
525
526    if (prefix_length == 32) {
527        rt.rt_flags |= RTF_HOST;
528    }
529
530    if (gw.s_addr != 0) {
531        rt.rt_flags |= RTF_GATEWAY;
532        init_sockaddr_in(&rt.rt_gateway, gw.s_addr);
533    }
534
535    ifc_init();
536
537    if (ifc_ctl_sock < 0) {
538        return -errno;
539    }
540
541    result = ioctl(ifc_ctl_sock, action, &rt);
542    if (result < 0) {
543        if (errno == EEXIST) {
544            result = 0;
545        } else {
546            result = -errno;
547        }
548    }
549    ifc_close();
550    return result;
551}
552
553/* deprecated - v4 only */
554int ifc_create_default_route(const char *name, in_addr_t gw)
555{
556    struct in_addr in_dst, in_gw;
557
558    in_dst.s_addr = 0;
559    in_gw.s_addr = gw;
560
561    int ret = ifc_act_on_ipv4_route(SIOCADDRT, name, in_dst, 0, in_gw);
562    if (DBG) printerr("ifc_create_default_route(%s, %d) = %d", name, gw, ret);
563    return ret;
564}
565
566// Needed by code in hidden partner repositories / branches, so don't delete.
567int ifc_enable(const char *ifname)
568{
569    int result;
570
571    ifc_init();
572    result = ifc_up(ifname);
573    ifc_close();
574    return result;
575}
576
577int ifc_disable(const char *ifname)
578{
579    unsigned addr, count;
580    int result;
581
582    ifc_init();
583    result = ifc_down(ifname);
584
585    ifc_set_addr(ifname, 0);
586    for (count=0, addr=1;((addr != 0) && (count < 255)); count++) {
587       if (ifc_get_addr(ifname, &addr) < 0)
588            break;
589       if (addr)
590          ifc_set_addr(ifname, 0);
591    }
592
593    ifc_close();
594    return result;
595}
596
597int ifc_reset_connections(const char *ifname, const int reset_mask)
598{
599#ifdef HAVE_ANDROID_OS
600    int result, success;
601    in_addr_t myaddr;
602    struct ifreq ifr;
603    struct in6_ifreq ifr6;
604
605    if (reset_mask & RESET_IPV4_ADDRESSES) {
606        /* IPv4. Clear connections on the IP address. */
607        ifc_init();
608        ifc_get_info(ifname, &myaddr, NULL, NULL);
609        ifc_init_ifr(ifname, &ifr);
610        init_sockaddr_in(&ifr.ifr_addr, myaddr);
611        result = ioctl(ifc_ctl_sock, SIOCKILLADDR,  &ifr);
612        ifc_close();
613    } else {
614        result = 0;
615    }
616
617    if (reset_mask & RESET_IPV6_ADDRESSES) {
618        /*
619         * IPv6. On Linux, when an interface goes down it loses all its IPv6
620         * addresses, so we don't know which connections belonged to that interface
621         * So we clear all unused IPv6 connections on the device by specifying an
622         * empty IPv6 address.
623         */
624        ifc_init6();
625        // This implicitly specifies an address of ::, i.e., kill all IPv6 sockets.
626        memset(&ifr6, 0, sizeof(ifr6));
627        success = ioctl(ifc_ctl_sock6, SIOCKILLADDR,  &ifr6);
628        if (result == 0) {
629            result = success;
630        }
631        ifc_close6();
632    }
633
634    return result;
635#else
636    return 0;
637#endif
638}
639
640/*
641 * Removes the default route for the named interface.
642 */
643int ifc_remove_default_route(const char *ifname)
644{
645    struct rtentry rt;
646    int result;
647
648    ifc_init();
649    memset(&rt, 0, sizeof(rt));
650    rt.rt_dev = (void *)ifname;
651    rt.rt_flags = RTF_UP|RTF_GATEWAY;
652    init_sockaddr_in(&rt.rt_dst, 0);
653    if ((result = ioctl(ifc_ctl_sock, SIOCDELRT, &rt)) < 0) {
654        ALOGD("failed to remove default route for %s: %s", ifname, strerror(errno));
655    }
656    ifc_close();
657    return result;
658}
659
660int
661ifc_configure(const char *ifname,
662        in_addr_t address,
663        uint32_t prefixLength,
664        in_addr_t gateway,
665        in_addr_t dns1,
666        in_addr_t dns2) {
667
668    char dns_prop_name[PROPERTY_KEY_MAX];
669
670    ifc_init();
671
672    if (ifc_up(ifname)) {
673        printerr("failed to turn on interface %s: %s\n", ifname, strerror(errno));
674        ifc_close();
675        return -1;
676    }
677    if (ifc_set_addr(ifname, address)) {
678        printerr("failed to set ipaddr %s: %s\n", ipaddr_to_string(address), strerror(errno));
679        ifc_close();
680        return -1;
681    }
682    if (ifc_set_prefixLength(ifname, prefixLength)) {
683        printerr("failed to set prefixLength %d: %s\n", prefixLength, strerror(errno));
684        ifc_close();
685        return -1;
686    }
687    if (ifc_create_default_route(ifname, gateway)) {
688        printerr("failed to set default route %s: %s\n", ipaddr_to_string(gateway), strerror(errno));
689        ifc_close();
690        return -1;
691    }
692
693    ifc_close();
694
695    snprintf(dns_prop_name, sizeof(dns_prop_name), "net.%s.dns1", ifname);
696    property_set(dns_prop_name, dns1 ? ipaddr_to_string(dns1) : "");
697    snprintf(dns_prop_name, sizeof(dns_prop_name), "net.%s.dns2", ifname);
698    property_set(dns_prop_name, dns2 ? ipaddr_to_string(dns2) : "");
699
700    return 0;
701}
702