5 * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
6 * Copyright (C) 2003-2005 Go-Core Project
7 * Copyright (C) 2003-2006 Helsinki University of Technology
9 * This program is free software; you can redistribute it and/or modify
10 * it under the terms of the GNU General Public License version 2 as
11 * published by the Free Software Foundation.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
35 #include <sys/ioctl.h>
36 #include <sys/socket.h>
37 #include <linux/sockios.h>
39 #include <arpa/inet.h>
40 #include <net/route.h>
41 #include <net/ethernet.h>
43 #include <net/if_arp.h>
44 #include <netinet/icmp6.h>
46 #include <linux/if_tun.h>
51 #define NLMSG_TAIL(nmsg) \
52 ((struct rtattr *) (((uint8_t*) (nmsg)) + \
53 NLMSG_ALIGN((nmsg)->nlmsg_len)))
55 int __connman_inet_rtnl_addattr_l(struct nlmsghdr *n, size_t max_length,
56 int type, const void *data, size_t data_length)
61 length = RTA_LENGTH(data_length);
63 if (NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(length) > max_length)
68 rta->rta_len = length;
69 memcpy(RTA_DATA(rta), data, data_length);
70 n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(length);
75 int __connman_inet_modify_address(int cmd, int flags,
76 int index, int family,
79 unsigned char prefixlen,
80 const char *broadcast)
82 uint8_t request[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
83 NLMSG_ALIGN(sizeof(struct ifaddrmsg)) +
84 RTA_LENGTH(sizeof(struct in6_addr)) +
85 RTA_LENGTH(sizeof(struct in6_addr))];
87 struct nlmsghdr *header;
88 struct sockaddr_nl nl_addr;
89 struct ifaddrmsg *ifaddrmsg;
90 struct in6_addr ipv6_addr;
91 struct in_addr ipv4_addr, ipv4_dest, ipv4_bcast;
94 DBG("cmd %#x flags %#x index %d family %d address %s peer %s "
95 "prefixlen %hhu broadcast %s", cmd, flags, index, family,
96 address, peer, prefixlen, broadcast);
101 if (family != AF_INET && family != AF_INET6)
104 memset(&request, 0, sizeof(request));
106 header = (struct nlmsghdr *)request;
107 header->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
108 header->nlmsg_type = cmd;
109 header->nlmsg_flags = NLM_F_REQUEST | flags;
110 header->nlmsg_seq = 1;
112 ifaddrmsg = NLMSG_DATA(header);
113 ifaddrmsg->ifa_family = family;
114 ifaddrmsg->ifa_prefixlen = prefixlen;
115 ifaddrmsg->ifa_flags = IFA_F_PERMANENT;
116 ifaddrmsg->ifa_scope = RT_SCOPE_UNIVERSE;
117 ifaddrmsg->ifa_index = index;
119 if (family == AF_INET) {
120 if (inet_pton(AF_INET, address, &ipv4_addr) < 1)
123 if (broadcast != NULL)
124 inet_pton(AF_INET, broadcast, &ipv4_bcast);
126 ipv4_bcast.s_addr = ipv4_addr.s_addr |
127 htonl(0xfffffffflu >> prefixlen);
130 if (inet_pton(AF_INET, peer, &ipv4_dest) < 1)
133 err = __connman_inet_rtnl_addattr_l(header,
142 err = __connman_inet_rtnl_addattr_l(header,
150 err = __connman_inet_rtnl_addattr_l(header,
158 } else if (family == AF_INET6) {
159 if (inet_pton(AF_INET6, address, &ipv6_addr) < 1)
162 err = __connman_inet_rtnl_addattr_l(header,
171 sk = socket(AF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_ROUTE);
175 memset(&nl_addr, 0, sizeof(nl_addr));
176 nl_addr.nl_family = AF_NETLINK;
178 if ((err = sendto(sk, request, header->nlmsg_len, 0,
179 (struct sockaddr *) &nl_addr, sizeof(nl_addr))) < 0)
190 int connman_inet_ifindex(const char *name)
198 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
202 memset(&ifr, 0, sizeof(ifr));
203 strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
205 err = ioctl(sk, SIOCGIFINDEX, &ifr);
212 return ifr.ifr_ifindex;
215 char *connman_inet_ifname(int index)
223 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
227 memset(&ifr, 0, sizeof(ifr));
228 ifr.ifr_ifindex = index;
230 err = ioctl(sk, SIOCGIFNAME, &ifr);
237 return strdup(ifr.ifr_name);
240 short int connman_inet_ifflags(int index)
245 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
249 memset(&ifr, 0, sizeof(ifr));
250 ifr.ifr_ifindex = index;
252 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
257 if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
270 int connman_inet_ifup(int index)
275 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
279 memset(&ifr, 0, sizeof(ifr));
280 ifr.ifr_ifindex = index;
282 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
287 if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
292 if (ifr.ifr_flags & IFF_UP) {
297 ifr.ifr_flags |= (IFF_UP|IFF_DYNAMIC);
299 if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0) {
312 int connman_inet_ifdown(int index)
314 struct ifreq ifr, addr_ifr;
315 struct sockaddr_in *addr;
318 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
322 memset(&ifr, 0, sizeof(ifr));
323 ifr.ifr_ifindex = index;
325 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
330 if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
335 memset(&addr_ifr, 0, sizeof(addr_ifr));
336 memcpy(&addr_ifr.ifr_name, &ifr.ifr_name, sizeof(ifr.ifr_name));
337 addr = (struct sockaddr_in *)&addr_ifr.ifr_addr;
338 addr->sin_family = AF_INET;
339 if (ioctl(sk, SIOCSIFADDR, &addr_ifr) < 0)
340 connman_warn("Could not clear IPv4 address index %d", index);
342 if (!(ifr.ifr_flags & IFF_UP)) {
347 ifr.ifr_flags = (ifr.ifr_flags & ~IFF_UP) | IFF_DYNAMIC;
349 if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0)
360 static char *index2addr(int index)
363 struct ether_addr eth;
370 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
374 memset(&ifr, 0, sizeof(ifr));
375 ifr.ifr_ifindex = index;
377 err = ioctl(sk, SIOCGIFNAME, &ifr);
380 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
391 memcpy(ð, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
392 snprintf(str, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
393 eth.ether_addr_octet[0],
394 eth.ether_addr_octet[1],
395 eth.ether_addr_octet[2],
396 eth.ether_addr_octet[3],
397 eth.ether_addr_octet[4],
398 eth.ether_addr_octet[5]);
403 static char *index2ident(int index, const char *prefix)
406 struct ether_addr eth;
413 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
417 memset(&ifr, 0, sizeof(ifr));
418 ifr.ifr_ifindex = index;
420 err = ioctl(sk, SIOCGIFNAME, &ifr);
423 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
430 len = prefix ? strlen(prefix) + 18 : 18;
436 memcpy(ð, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
437 snprintf(str, len, "%s%02x%02x%02x%02x%02x%02x",
438 prefix ? prefix : "",
439 eth.ether_addr_octet[0],
440 eth.ether_addr_octet[1],
441 eth.ether_addr_octet[2],
442 eth.ether_addr_octet[3],
443 eth.ether_addr_octet[4],
444 eth.ether_addr_octet[5]);
449 connman_bool_t connman_inet_is_cfg80211(int index)
451 connman_bool_t result = FALSE;
452 char phy80211_path[PATH_MAX];
457 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
461 memset(&ifr, 0, sizeof(ifr));
462 ifr.ifr_ifindex = index;
464 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0)
467 snprintf(phy80211_path, PATH_MAX,
468 "/sys/class/net/%s/phy80211", ifr.ifr_name);
470 if (stat(phy80211_path, &st) == 0 && (st.st_mode & S_IFDIR))
479 struct connman_device *connman_inet_create_device(int index)
481 enum connman_device_type type;
482 struct connman_device *device;
483 char *devname, *ident = NULL;
484 char *addr = NULL, *name = NULL;
489 devname = connman_inet_ifname(index);
493 if (__connman_device_isfiltered(devname) == TRUE) {
494 connman_info("Ignoring interface %s (filtered)", devname);
499 type = __connman_rtnl_get_device_type(index);
502 case CONNMAN_DEVICE_TYPE_UNKNOWN:
503 connman_info("Ignoring interface %s (type unknown)", devname);
506 case CONNMAN_DEVICE_TYPE_ETHERNET:
507 case CONNMAN_DEVICE_TYPE_GADGET:
508 case CONNMAN_DEVICE_TYPE_WIFI:
509 case CONNMAN_DEVICE_TYPE_WIMAX:
510 name = index2ident(index, "");
511 addr = index2addr(index);
513 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
514 case CONNMAN_DEVICE_TYPE_CELLULAR:
515 case CONNMAN_DEVICE_TYPE_GPS:
516 case CONNMAN_DEVICE_TYPE_VENDOR:
517 name = strdup(devname);
521 device = connman_device_create(name, type);
526 case CONNMAN_DEVICE_TYPE_UNKNOWN:
527 case CONNMAN_DEVICE_TYPE_VENDOR:
528 case CONNMAN_DEVICE_TYPE_GPS:
530 case CONNMAN_DEVICE_TYPE_ETHERNET:
531 case CONNMAN_DEVICE_TYPE_GADGET:
532 ident = index2ident(index, NULL);
534 case CONNMAN_DEVICE_TYPE_WIFI:
535 case CONNMAN_DEVICE_TYPE_WIMAX:
536 ident = index2ident(index, NULL);
538 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
540 case CONNMAN_DEVICE_TYPE_CELLULAR:
541 ident = index2ident(index, NULL);
545 connman_device_set_index(device, index);
546 connman_device_set_interface(device, devname);
549 connman_device_set_ident(device, ident);
553 connman_device_set_string(device, "Address", addr);
564 struct in6_addr ifr6_addr;
565 __u32 ifr6_prefixlen;
566 unsigned int ifr6_ifindex;
569 int connman_inet_set_ipv6_address(int index,
570 struct connman_ipaddress *ipaddress)
573 unsigned char prefix_len;
576 if (ipaddress->local == NULL)
579 prefix_len = ipaddress->prefixlen;
580 address = ipaddress->local;
582 DBG("index %d address %s prefix_len %d", index, address, prefix_len);
584 err = __connman_inet_modify_address(RTM_NEWADDR,
585 NLM_F_REPLACE | NLM_F_ACK, index, AF_INET6,
586 address, NULL, prefix_len, NULL);
588 connman_error("%s: %s", __func__, strerror(-err));
595 int connman_inet_set_address(int index, struct connman_ipaddress *ipaddress)
598 unsigned char prefix_len;
599 const char *address, *broadcast, *peer;
601 if (ipaddress->local == NULL)
604 prefix_len = ipaddress->prefixlen;
605 address = ipaddress->local;
606 broadcast = ipaddress->broadcast;
607 peer = ipaddress->peer;
609 DBG("index %d address %s prefix_len %d", index, address, prefix_len);
611 err = __connman_inet_modify_address(RTM_NEWADDR,
612 NLM_F_REPLACE | NLM_F_ACK, index, AF_INET,
613 address, peer, prefix_len, broadcast);
615 connman_error("%s: %s", __func__, strerror(-err));
622 int connman_inet_clear_ipv6_address(int index, const char *address,
627 DBG("index %d address %s prefix_len %d", index, address, prefix_len);
629 err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET6,
630 address, NULL, prefix_len, NULL);
632 connman_error("%s: %s", __func__, strerror(-err));
639 int connman_inet_clear_address(int index, struct connman_ipaddress *ipaddress)
642 unsigned char prefix_len;
643 const char *address, *broadcast, *peer;
645 prefix_len = ipaddress->prefixlen;
646 address = ipaddress->local;
647 broadcast = ipaddress->broadcast;
648 peer = ipaddress->peer;
650 DBG("index %d address %s prefix_len %d", index, address, prefix_len);
652 err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET,
653 address, peer, prefix_len, broadcast);
655 connman_error("%s: %s", __func__, strerror(-err));
662 int connman_inet_add_host_route(int index, const char *host,
665 return connman_inet_add_network_route(index, host, gateway, NULL);
668 int connman_inet_del_host_route(int index, const char *host)
670 return connman_inet_del_network_route(index, host);
673 int connman_inet_add_network_route(int index, const char *host,
679 struct sockaddr_in addr;
682 DBG("index %d host %s gateway %s netmask %s", index,
683 host, gateway, netmask);
685 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
689 memset(&ifr, 0, sizeof(ifr));
690 ifr.ifr_ifindex = index;
692 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
697 DBG("ifname %s", ifr.ifr_name);
699 memset(&rt, 0, sizeof(rt));
700 rt.rt_flags = RTF_UP;
702 rt.rt_flags |= RTF_GATEWAY;
704 rt.rt_flags |= RTF_HOST;
706 memset(&addr, 0, sizeof(addr));
707 addr.sin_family = AF_INET;
708 addr.sin_addr.s_addr = inet_addr(host);
709 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
711 memset(&addr, 0, sizeof(addr));
712 addr.sin_family = AF_INET;
714 addr.sin_addr.s_addr = inet_addr(gateway);
716 addr.sin_addr.s_addr = INADDR_ANY;
717 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
719 memset(&addr, 0, sizeof(addr));
720 addr.sin_family = AF_INET;
721 addr.sin_addr.s_addr = INADDR_ANY;
723 addr.sin_addr.s_addr = inet_addr(netmask);
725 addr.sin_addr.s_addr = INADDR_ANY;
726 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
728 rt.rt_dev = ifr.ifr_name;
730 err = ioctl(sk, SIOCADDRT, &rt);
732 connman_error("Adding host route failed (%s)",
740 int connman_inet_del_network_route(int index, const char *host)
744 struct sockaddr_in addr;
747 DBG("index %d host %s", index, host);
749 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
753 memset(&ifr, 0, sizeof(ifr));
754 ifr.ifr_ifindex = index;
756 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
761 DBG("ifname %s", ifr.ifr_name);
763 memset(&rt, 0, sizeof(rt));
764 rt.rt_flags = RTF_UP | RTF_HOST;
766 memset(&addr, 0, sizeof(addr));
767 addr.sin_family = AF_INET;
768 addr.sin_addr.s_addr = inet_addr(host);
769 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
771 rt.rt_dev = ifr.ifr_name;
773 err = ioctl(sk, SIOCDELRT, &rt);
775 connman_error("Deleting host route failed (%s)",
783 int connman_inet_del_ipv6_network_route(int index, const char *host,
784 unsigned char prefix_len)
789 DBG("index %d host %s", index, host);
794 memset(&rt, 0, sizeof(rt));
796 rt.rtmsg_dst_len = prefix_len;
798 err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
802 rt.rtmsg_flags = RTF_UP | RTF_HOST;
805 rt.rtmsg_ifindex = index;
807 sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
813 err = ioctl(sk, SIOCDELRT, &rt);
817 connman_error("Del IPv6 host route error (%s)",
823 int connman_inet_del_ipv6_host_route(int index, const char *host)
825 return connman_inet_del_ipv6_network_route(index, host, 128);
828 int connman_inet_add_ipv6_network_route(int index, const char *host,
830 unsigned char prefix_len)
835 DBG("index %d host %s gateway %s", index, host, gateway);
840 memset(&rt, 0, sizeof(rt));
842 rt.rtmsg_dst_len = prefix_len;
844 err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
848 rt.rtmsg_flags = RTF_UP | RTF_HOST;
850 if (gateway != NULL) {
851 rt.rtmsg_flags |= RTF_GATEWAY;
852 inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
856 rt.rtmsg_ifindex = index;
858 sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
864 err = ioctl(sk, SIOCADDRT, &rt);
868 connman_error("Set IPv6 host route error (%s)",
874 int connman_inet_add_ipv6_host_route(int index, const char *host,
877 return connman_inet_add_ipv6_network_route(index, host, gateway, 128);
880 int connman_inet_set_ipv6_gateway_address(int index, const char *gateway)
885 DBG("index %d gateway %s", index, gateway);
890 memset(&rt, 0, sizeof(rt));
892 err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
896 rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
898 rt.rtmsg_dst_len = 0;
899 rt.rtmsg_ifindex = index;
901 sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
907 err = ioctl(sk, SIOCADDRT, &rt);
911 connman_error("Set default IPv6 gateway error (%s)",
917 int connman_inet_clear_ipv6_gateway_address(int index, const char *gateway)
922 DBG("index %d gateway %s", index, gateway);
927 memset(&rt, 0, sizeof(rt));
929 err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
933 rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
935 rt.rtmsg_dst_len = 0;
936 rt.rtmsg_ifindex = index;
938 sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
944 err = ioctl(sk, SIOCDELRT, &rt);
948 connman_error("Clear default IPv6 gateway error (%s)",
954 int connman_inet_set_gateway_address(int index, const char *gateway)
958 struct sockaddr_in addr;
961 DBG("index %d gateway %s", index, gateway);
963 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
967 memset(&ifr, 0, sizeof(ifr));
968 ifr.ifr_ifindex = index;
970 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
975 DBG("ifname %s", ifr.ifr_name);
977 memset(&rt, 0, sizeof(rt));
978 rt.rt_flags = RTF_UP | RTF_GATEWAY;
980 memset(&addr, 0, sizeof(addr));
981 addr.sin_family = AF_INET;
982 addr.sin_addr.s_addr = INADDR_ANY;
983 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
985 memset(&addr, 0, sizeof(addr));
986 addr.sin_family = AF_INET;
987 addr.sin_addr.s_addr = inet_addr(gateway);
988 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
990 memset(&addr, 0, sizeof(addr));
991 addr.sin_family = AF_INET;
992 addr.sin_addr.s_addr = INADDR_ANY;
993 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
995 err = ioctl(sk, SIOCADDRT, &rt);
997 connman_error("Setting default gateway route failed (%s)",
1005 int connman_inet_set_gateway_interface(int index)
1009 struct sockaddr_in addr;
1012 DBG("index %d", index);
1014 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1018 memset(&ifr, 0, sizeof(ifr));
1019 ifr.ifr_ifindex = index;
1021 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1026 DBG("ifname %s", ifr.ifr_name);
1028 memset(&rt, 0, sizeof(rt));
1029 rt.rt_flags = RTF_UP;
1031 memset(&addr, 0, sizeof(addr));
1032 addr.sin_family = AF_INET;
1033 addr.sin_addr.s_addr = INADDR_ANY;
1035 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1036 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1037 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1039 rt.rt_dev = ifr.ifr_name;
1041 err = ioctl(sk, SIOCADDRT, &rt);
1043 connman_error("Setting default interface route failed (%s)",
1050 int connman_inet_set_ipv6_gateway_interface(int index)
1054 struct sockaddr_in6 addr;
1055 const struct in6_addr any = IN6ADDR_ANY_INIT;
1058 DBG("index %d", index);
1060 sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1064 memset(&ifr, 0, sizeof(ifr));
1065 ifr.ifr_ifindex = index;
1067 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1072 DBG("ifname %s", ifr.ifr_name);
1074 memset(&rt, 0, sizeof(rt));
1075 rt.rt_flags = RTF_UP;
1077 memset(&addr, 0, sizeof(addr));
1078 addr.sin6_family = AF_INET6;
1079 addr.sin6_addr = any;
1081 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1082 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1083 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1085 rt.rt_dev = ifr.ifr_name;
1087 err = ioctl(sk, SIOCADDRT, &rt);
1089 connman_error("Setting default interface route failed (%s)",
1096 int connman_inet_clear_gateway_address(int index, const char *gateway)
1100 struct sockaddr_in addr;
1103 DBG("index %d gateway %s", index, gateway);
1105 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1109 memset(&ifr, 0, sizeof(ifr));
1110 ifr.ifr_ifindex = index;
1112 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1117 DBG("ifname %s", ifr.ifr_name);
1119 memset(&rt, 0, sizeof(rt));
1120 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1122 memset(&addr, 0, sizeof(addr));
1123 addr.sin_family = AF_INET;
1124 addr.sin_addr.s_addr = INADDR_ANY;
1125 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1127 memset(&addr, 0, sizeof(addr));
1128 addr.sin_family = AF_INET;
1129 addr.sin_addr.s_addr = inet_addr(gateway);
1130 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1132 memset(&addr, 0, sizeof(addr));
1133 addr.sin_family = AF_INET;
1134 addr.sin_addr.s_addr = INADDR_ANY;
1135 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1137 err = ioctl(sk, SIOCDELRT, &rt);
1139 connman_error("Removing default gateway route failed (%s)",
1147 int connman_inet_clear_gateway_interface(int index)
1151 struct sockaddr_in addr;
1154 DBG("index %d", index);
1156 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1160 memset(&ifr, 0, sizeof(ifr));
1161 ifr.ifr_ifindex = index;
1163 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1168 DBG("ifname %s", ifr.ifr_name);
1170 memset(&rt, 0, sizeof(rt));
1171 rt.rt_flags = RTF_UP;
1173 memset(&addr, 0, sizeof(addr));
1174 addr.sin_family = AF_INET;
1175 addr.sin_addr.s_addr = INADDR_ANY;
1177 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1178 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1179 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1181 rt.rt_dev = ifr.ifr_name;
1183 err = ioctl(sk, SIOCDELRT, &rt);
1185 connman_error("Removing default interface route failed (%s)",
1192 int connman_inet_clear_ipv6_gateway_interface(int index)
1196 struct sockaddr_in6 addr;
1197 const struct in6_addr any = IN6ADDR_ANY_INIT;
1200 DBG("index %d", index);
1202 sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1206 memset(&ifr, 0, sizeof(ifr));
1207 ifr.ifr_ifindex = index;
1209 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1214 DBG("ifname %s", ifr.ifr_name);
1216 memset(&rt, 0, sizeof(rt));
1217 rt.rt_flags = RTF_UP;
1219 memset(&addr, 0, sizeof(addr));
1220 addr.sin6_family = AF_INET6;
1221 addr.sin6_addr = any;
1223 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1224 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1225 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1227 rt.rt_dev = ifr.ifr_name;
1229 err = ioctl(sk, SIOCDELRT, &rt);
1231 connman_error("Removing default interface route failed (%s)",
1238 connman_bool_t connman_inet_compare_subnet(int index, const char *host)
1241 struct in_addr _host_addr;
1242 in_addr_t host_addr, netmask_addr, if_addr;
1243 struct sockaddr_in *netmask, *addr;
1246 DBG("host %s", host);
1251 if (inet_aton(host, &_host_addr) == 0)
1253 host_addr = _host_addr.s_addr;
1255 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1259 memset(&ifr, 0, sizeof(ifr));
1260 ifr.ifr_ifindex = index;
1262 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1267 if (ioctl(sk, SIOCGIFNETMASK, &ifr) < 0) {
1272 netmask = (struct sockaddr_in *)&ifr.ifr_netmask;
1273 netmask_addr = netmask->sin_addr.s_addr;
1275 if (ioctl(sk, SIOCGIFADDR, &ifr) < 0) {
1282 addr = (struct sockaddr_in *)&ifr.ifr_addr;
1283 if_addr = addr->sin_addr.s_addr;
1285 return ((if_addr & netmask_addr) == (host_addr & netmask_addr));
1288 int connman_inet_remove_from_bridge(int index, const char *bridge)
1296 sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
1300 memset(&ifr, 0, sizeof(ifr));
1301 strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1302 ifr.ifr_ifindex = index;
1304 err = ioctl(sk, SIOCBRDELIF, &ifr);
1309 connman_error("Remove interface from bridge error %s",
1317 int connman_inet_add_to_bridge(int index, const char *bridge)
1325 sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
1329 memset(&ifr, 0, sizeof(ifr));
1330 strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1331 ifr.ifr_ifindex = index;
1333 err = ioctl(sk, SIOCBRADDIF, &ifr);
1338 connman_error("Add interface to bridge error %s",
1346 int connman_inet_set_mtu(int index, int mtu)
1351 sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1355 memset(&ifr, 0, sizeof(ifr));
1356 ifr.ifr_ifindex = index;
1358 err = ioctl(sk, SIOCGIFNAME, &ifr);
1361 err = ioctl(sk, SIOCSIFMTU, &ifr);
1368 int connman_inet_setup_tunnel(char *tunnel, int mtu)
1378 sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1382 index = if_nametoindex(tunnel);
1384 err = connman_inet_set_mtu(index, mtu);
1390 memset(&ifr, 0, sizeof(ifr));
1391 strncpy(ifr.ifr_name, tunnel, IFNAMSIZ);
1392 err = ioctl(sk, SIOCGIFFLAGS, &ifr);
1399 if ((ifr.ifr_flags ^ flags) & mask) {
1400 ifr.ifr_flags &= ~mask;
1401 ifr.ifr_flags |= mask & flags;
1402 err = ioctl(sk, SIOCSIFFLAGS, &ifr);
1404 connman_error("SIOCSIFFLAGS failed: %s",
1413 int connman_inet_create_tunnel(char **iface)
1418 fd = open("/dev/net/tun", O_RDWR | O_CLOEXEC);
1421 connman_error("Failed to open /dev/net/tun: %s",
1426 memset(&ifr, 0, sizeof(ifr));
1427 ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
1429 for (i = 0; i < 256; i++) {
1430 sprintf(ifr.ifr_name, "tun%d", i);
1432 if (!ioctl(fd, TUNSETIFF, (void *)&ifr))
1437 connman_error("Failed to find available tun device");
1442 *iface = g_strdup(ifr.ifr_name);
1448 GIOChannel *channel;
1449 __connman_inet_rs_cb_t callback;
1450 struct sockaddr_in6 addr;
1456 #define CMSG_BUF_LEN 512
1457 #define IN6ADDR_ALL_NODES_MC_INIT \
1458 { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x1 } } } /* ff02::1 */
1459 #define IN6ADDR_ALL_ROUTERS_MC_INIT \
1460 { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x2 } } } /* ff02::2 */
1462 static const struct in6_addr in6addr_all_nodes_mc = IN6ADDR_ALL_NODES_MC_INIT;
1463 static const struct in6_addr in6addr_all_routers_mc =
1464 IN6ADDR_ALL_ROUTERS_MC_INIT;
1466 static void rs_cleanup(struct rs_cb_data *data)
1468 if (data->channel != NULL) {
1469 g_io_channel_shutdown(data->channel, TRUE, NULL);
1470 g_io_channel_unref(data->channel);
1471 data->channel = NULL;
1474 if (data->rs_timeout > 0)
1475 g_source_remove(data->rs_timeout);
1477 if (data->watch_id > 0)
1478 g_source_remove(data->watch_id);
1483 static gboolean rs_timeout_cb(gpointer user_data)
1485 struct rs_cb_data *data = user_data;
1487 DBG("user data %p", user_data);
1492 if (data->callback != NULL)
1493 data->callback(NULL, 0, data->user_data);
1495 data->rs_timeout = 0;
1500 static int icmpv6_recv(int fd, gpointer user_data)
1504 unsigned char chdr[CMSG_BUF_LEN];
1505 unsigned char buf[1540];
1506 struct rs_cb_data *data = user_data;
1507 struct nd_router_advert *hdr;
1508 struct sockaddr_in6 saddr;
1513 iov.iov_len = sizeof(buf);
1516 mhdr.msg_name = (void *)&saddr;
1517 mhdr.msg_namelen = sizeof(struct sockaddr_in6);
1518 mhdr.msg_iov = &iov;
1519 mhdr.msg_iovlen = 1;
1520 mhdr.msg_control = (void *)chdr;
1521 mhdr.msg_controllen = CMSG_BUF_LEN;
1523 len = recvmsg(fd, &mhdr, 0);
1525 data->callback(NULL, 0, data->user_data);
1530 hdr = (struct nd_router_advert *)buf;
1531 DBG("code %d len %zd hdr %zd", hdr->nd_ra_code, len,
1532 sizeof(struct nd_router_advert));
1533 if (hdr->nd_ra_code != 0)
1536 data->callback(hdr, len, data->user_data);
1542 static gboolean icmpv6_event(GIOChannel *chan, GIOCondition cond,
1549 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
1552 fd = g_io_channel_unix_get_fd(chan);
1553 ret = icmpv6_recv(fd, data);
1560 /* Adapted from RFC 1071 "C" Implementation Example */
1561 static uint16_t csum(const void *phdr, const void *data, socklen_t datalen)
1563 register unsigned long sum = 0;
1568 /* caller must make sure datalen is even */
1570 addr = (uint16_t *)phdr;
1571 for (i = 0; i < 20; i++)
1575 addr = (uint16_t *)data;
1583 sum = (sum & 0xffff) + (sum >> 16);
1585 return (uint16_t)~sum;
1588 static int ndisc_send_unspec(int type, int oif, const struct in6_addr *dest)
1591 struct in6_addr src;
1592 struct in6_addr dst;
1594 uint8_t reserved[3];
1601 struct icmp6_hdr icmp;
1602 struct nd_neighbor_solicit ns;
1603 struct nd_router_solicit rs;
1608 struct cmsghdr *cmsg;
1609 struct in6_pktinfo *pinfo;
1610 struct sockaddr_in6 dst;
1611 char cbuf[CMSG_SPACE(sizeof(*pinfo))];
1613 int fd, datalen, ret;
1617 fd = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_RAW);
1621 memset(&frame, 0, sizeof(frame));
1622 memset(&dst, 0, sizeof(dst));
1624 datalen = sizeof(frame.i.rs); /* 8, csum() safe */
1625 dst.sin6_addr = *dest;
1627 /* Fill in the IPv6 header */
1628 frame.ip.ip6_vfc = 0x60;
1629 frame.ip.ip6_plen = htons(datalen);
1630 frame.ip.ip6_nxt = IPPROTO_ICMPV6;
1631 frame.ip.ip6_hlim = 255;
1632 frame.ip.ip6_dst = dst.sin6_addr;
1633 /* all other fields are already set to zero */
1635 /* Prepare pseudo header for csum */
1636 memset(&phdr, 0, sizeof(phdr));
1637 phdr.dst = dst.sin6_addr;
1638 phdr.plen = htonl(datalen);
1639 phdr.nxt = IPPROTO_ICMPV6;
1641 /* Fill in remaining ICMP header fields */
1642 frame.i.icmp.icmp6_type = type;
1643 frame.i.icmp.icmp6_cksum = csum(&phdr, &frame.i, datalen);
1645 iov.iov_base = &frame;
1646 iov.iov_len = sizeof(frame.ip) + datalen;
1648 dst.sin6_family = AF_INET6;
1649 msgh.msg_name = &dst;
1650 msgh.msg_namelen = sizeof(dst);
1651 msgh.msg_iov = &iov;
1652 msgh.msg_iovlen = 1;
1655 memset(cbuf, 0, CMSG_SPACE(sizeof(*pinfo)));
1656 cmsg = (struct cmsghdr *)cbuf;
1657 pinfo = (struct in6_pktinfo *)CMSG_DATA(cmsg);
1658 pinfo->ipi6_ifindex = oif;
1660 cmsg->cmsg_len = CMSG_LEN(sizeof(*pinfo));
1661 cmsg->cmsg_level = IPPROTO_IPV6;
1662 cmsg->cmsg_type = IPV6_PKTINFO;
1663 msgh.msg_control = cmsg;
1664 msgh.msg_controllen = cmsg->cmsg_len;
1666 ret = sendmsg(fd, &msgh, 0);
1672 static inline void ipv6_addr_set(struct in6_addr *addr,
1673 uint32_t w1, uint32_t w2,
1674 uint32_t w3, uint32_t w4)
1676 addr->s6_addr32[0] = w1;
1677 addr->s6_addr32[1] = w2;
1678 addr->s6_addr32[2] = w3;
1679 addr->s6_addr32[3] = w4;
1682 static inline void ipv6_addr_solict_mult(const struct in6_addr *addr,
1683 struct in6_addr *solicited)
1685 ipv6_addr_set(solicited, htonl(0xFF020000), 0, htonl(0x1),
1686 htonl(0xFF000000) | addr->s6_addr32[3]);
1689 static int if_mc_group(int sock, int ifindex, const struct in6_addr *mc_addr,
1692 unsigned int val = 0;
1693 struct ipv6_mreq mreq;
1696 memset(&mreq, 0, sizeof(mreq));
1697 mreq.ipv6mr_interface = ifindex;
1698 mreq.ipv6mr_multiaddr = *mc_addr;
1700 ret = setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
1706 return setsockopt(sock, IPPROTO_IPV6, cmd, &mreq, sizeof(mreq));
1709 int __connman_inet_ipv6_send_rs(int index, int timeout,
1710 __connman_inet_rs_cb_t callback, void *user_data)
1712 struct rs_cb_data *data;
1713 struct icmp6_filter filter;
1714 struct in6_addr solicit;
1715 struct in6_addr dst = in6addr_all_routers_mc;
1723 data = g_try_malloc0(sizeof(struct rs_cb_data));
1727 data->callback = callback;
1728 data->user_data = user_data;
1729 data->rs_timeout = g_timeout_add_seconds(timeout, rs_timeout_cb, data);
1731 sk = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
1735 ICMP6_FILTER_SETBLOCKALL(&filter);
1736 ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filter);
1738 setsockopt(sk, IPPROTO_ICMPV6, ICMP6_FILTER, &filter,
1739 sizeof(struct icmp6_filter));
1741 ipv6_addr_solict_mult(&dst, &solicit);
1742 if_mc_group(sk, index, &in6addr_all_nodes_mc, IPV6_JOIN_GROUP);
1743 if_mc_group(sk, index, &solicit, IPV6_JOIN_GROUP);
1745 data->channel = g_io_channel_unix_new(sk);
1746 g_io_channel_set_close_on_unref(data->channel, TRUE);
1748 g_io_channel_set_encoding(data->channel, NULL, NULL);
1749 g_io_channel_set_buffered(data->channel, FALSE);
1751 data->watch_id = g_io_add_watch(data->channel,
1752 G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
1753 icmpv6_event, data);
1755 ndisc_send_unspec(ND_ROUTER_SOLICIT, index, &dst);
1760 GSList *__connman_inet_ipv6_get_prefixes(struct nd_router_advert *hdr,
1761 unsigned int length)
1763 GSList *prefixes = NULL;
1767 if (length <= sizeof(struct nd_router_advert))
1770 len = length - sizeof(struct nd_router_advert);
1771 pos = (uint8_t *)hdr + sizeof(struct nd_router_advert);
1774 struct nd_opt_prefix_info *pinfo;
1775 char prefix_str[INET6_ADDRSTRLEN+1], *str;
1782 optlen = pos[1] << 3;
1783 if (optlen == 0 || optlen > len)
1787 case ND_OPT_PREFIX_INFORMATION:
1788 pinfo = (struct nd_opt_prefix_info *)pos;
1789 prefix = inet_ntop(AF_INET6, &pinfo->nd_opt_pi_prefix,
1790 prefix_str, INET6_ADDRSTRLEN);
1794 str = g_strdup_printf("%s/%d", prefix,
1795 pinfo->nd_opt_pi_prefix_len);
1796 prefixes = g_slist_prepend(prefixes, str);
1798 DBG("prefix %s", str);
1810 static int get_dest_addr(int family, int index, char *buf, int len)
1816 sk = socket(family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1820 memset(&ifr, 0, sizeof(ifr));
1821 ifr.ifr_ifindex = index;
1823 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1824 DBG("SIOCGIFNAME (%d/%s)", errno, strerror(errno));
1829 if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
1830 DBG("SIOCGIFFLAGS (%d/%s)", errno, strerror(errno));
1835 if ((ifr.ifr_flags & IFF_POINTOPOINT) == 0) {
1841 DBG("index %d %s", index, ifr.ifr_name);
1843 if (ioctl(sk, SIOCGIFDSTADDR, &ifr) < 0) {
1844 connman_error("Get destination address failed (%s)",
1854 addr = &((struct sockaddr_in *)&ifr.ifr_dstaddr)->sin_addr;
1857 addr = &((struct sockaddr_in6 *)&ifr.ifr_dstaddr)->sin6_addr;
1864 if (inet_ntop(family, addr, buf, len) == NULL) {
1865 DBG("error %d/%s", errno, strerror(errno));
1872 int connman_inet_get_dest_addr(int index, char **dest)
1874 char addr[INET_ADDRSTRLEN];
1877 ret = get_dest_addr(PF_INET, index, addr, INET_ADDRSTRLEN);
1881 *dest = g_strdup(addr);
1883 DBG("destination %s", *dest);
1888 int connman_inet_ipv6_get_dest_addr(int index, char **dest)
1890 char addr[INET6_ADDRSTRLEN];
1893 ret = get_dest_addr(PF_INET6, index, addr, INET6_ADDRSTRLEN);
1897 *dest = g_strdup(addr);
1899 DBG("destination %s", *dest);
1904 int __connman_inet_rtnl_open(struct __connman_inet_rtnl_handle *rth)
1907 int rcvbuf = 1024 * 4;
1909 rth->fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
1911 connman_error("Can not open netlink socket: %s",
1916 if (setsockopt(rth->fd, SOL_SOCKET, SO_SNDBUF, &sndbuf,
1917 sizeof(sndbuf)) < 0) {
1918 connman_error("SO_SNDBUF: %s", strerror(errno));
1922 if (setsockopt(rth->fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf,
1923 sizeof(rcvbuf)) < 0) {
1924 connman_error("SO_RCVBUF: %s", strerror(errno));
1928 memset(&rth->local, 0, sizeof(rth->local));
1929 rth->local.nl_family = AF_NETLINK;
1930 rth->local.nl_groups = 0;
1932 if (bind(rth->fd, (struct sockaddr *)&rth->local,
1933 sizeof(rth->local)) < 0) {
1934 connman_error("Can not bind netlink socket: %s",
1939 rth->seq = time(NULL);
1941 DBG("fd %d", rth->fd);
1946 struct inet_rtnl_cb_data {
1947 GIOChannel *channel;
1948 __connman_inet_rtnl_cb_t callback;
1951 struct __connman_inet_rtnl_handle *rtnl;
1955 static void inet_rtnl_cleanup(struct inet_rtnl_cb_data *data)
1957 struct __connman_inet_rtnl_handle *rth = data->rtnl;
1959 if (data->channel != NULL) {
1960 g_io_channel_shutdown(data->channel, TRUE, NULL);
1961 g_io_channel_unref(data->channel);
1962 data->channel = NULL;
1965 DBG("data %p", data);
1967 if (data->rtnl_timeout > 0)
1968 g_source_remove(data->rtnl_timeout);
1970 if (data->watch_id > 0)
1971 g_source_remove(data->watch_id);
1974 __connman_inet_rtnl_close(rth);
1981 static gboolean inet_rtnl_timeout_cb(gpointer user_data)
1983 struct inet_rtnl_cb_data *data = user_data;
1985 DBG("user data %p", user_data);
1990 if (data->callback != NULL)
1991 data->callback(NULL, data->user_data);
1993 data->rtnl_timeout = 0;
1994 inet_rtnl_cleanup(data);
1998 static int inet_rtnl_recv(GIOChannel *chan, gpointer user_data)
2000 struct inet_rtnl_cb_data *rtnl_data = user_data;
2001 struct __connman_inet_rtnl_handle *rth = rtnl_data->rtnl;
2002 struct nlmsghdr *h = NULL;
2003 struct sockaddr_nl nladdr;
2004 socklen_t addr_len = sizeof(nladdr);
2005 unsigned char buf[4096];
2010 memset(buf, 0, sizeof(buf));
2011 memset(&nladdr, 0, sizeof(nladdr));
2013 fd = g_io_channel_unix_get_fd(chan);
2015 status = recvfrom(fd, buf, sizeof(buf), 0,
2016 (struct sockaddr *) &nladdr, &addr_len);
2018 if (errno == EINTR || errno == EAGAIN)
2027 if (nladdr.nl_pid != 0) { /* not sent by kernel, ignore */
2028 DBG("Received msg from %u, ignoring it", nladdr.nl_pid);
2035 struct nlmsgerr *err;
2039 if (!NLMSG_OK(h, len)) {
2044 if (h->nlmsg_seq != rth->seq) {
2046 DBG("skip %d/%d len %d", rth->seq,
2047 h->nlmsg_seq, h->nlmsg_len);
2049 len -= h->nlmsg_len;
2050 ptr += h->nlmsg_len;
2054 switch (h->nlmsg_type) {
2060 err = (struct nlmsgerr *)NLMSG_DATA(h);
2061 connman_error("RTNETLINK answers %s (%d)",
2062 strerror(-err->error), -err->error);
2069 if (h->nlmsg_seq == rth->seq) {
2070 DBG("received %d seq %d", h->nlmsg_len, h->nlmsg_seq);
2072 rtnl_data->callback(h, rtnl_data->user_data);
2074 if (rtnl_data->rtnl_timeout > 0) {
2075 g_source_remove(rtnl_data->rtnl_timeout);
2076 rtnl_data->rtnl_timeout = 0;
2079 __connman_inet_rtnl_close(rth);
2086 static gboolean inet_rtnl_event(GIOChannel *chan, GIOCondition cond,
2093 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
2096 ret = inet_rtnl_recv(chan, user_data);
2103 int __connman_inet_rtnl_talk(struct __connman_inet_rtnl_handle *rtnl,
2104 struct nlmsghdr *n, int timeout,
2105 __connman_inet_rtnl_cb_t callback, void *user_data)
2107 struct sockaddr_nl nladdr;
2108 struct inet_rtnl_cb_data *data;
2112 memset(&nladdr, 0, sizeof(nladdr));
2113 nladdr.nl_family = AF_NETLINK;
2115 n->nlmsg_seq = seq = ++rtnl->seq;
2117 if (callback != NULL) {
2118 data = g_try_malloc0(sizeof(struct inet_rtnl_cb_data));
2122 data->callback = callback;
2123 data->user_data = user_data;
2125 data->rtnl_timeout = g_timeout_add_seconds(timeout,
2126 inet_rtnl_timeout_cb, data);
2128 data->channel = g_io_channel_unix_new(rtnl->fd);
2129 g_io_channel_set_close_on_unref(data->channel, TRUE);
2131 g_io_channel_set_encoding(data->channel, NULL, NULL);
2132 g_io_channel_set_buffered(data->channel, FALSE);
2134 data->watch_id = g_io_add_watch(data->channel,
2135 G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
2136 inet_rtnl_event, data);
2138 n->nlmsg_flags |= NLM_F_ACK;
2140 err = sendto(rtnl->fd, &rtnl->req.n, rtnl->req.n.nlmsg_len, 0,
2141 (struct sockaddr *) &nladdr, sizeof(nladdr));
2142 DBG("handle %p len %d err %d", rtnl, rtnl->req.n.nlmsg_len, err);
2144 connman_error("Can not talk to rtnetlink");
2148 if ((unsigned int)err != rtnl->req.n.nlmsg_len) {
2149 connman_error("Sent %d bytes, msg truncated", err);
2156 void __connman_inet_rtnl_close(struct __connman_inet_rtnl_handle *rth)
2158 DBG("handle %p", rth);
2166 int __connman_inet_rtnl_addattr32(struct nlmsghdr *n, size_t maxlen, int type,
2169 int len = RTA_LENGTH(4);
2172 if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen) {
2173 DBG("Error! max allowed bound %zd exceeded", maxlen);
2176 rta = NLMSG_TAIL(n);
2177 rta->rta_type = type;
2179 memcpy(RTA_DATA(rta), &data, 4);
2180 n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
2185 static int parse_rtattr(struct rtattr *tb[], int max,
2186 struct rtattr *rta, int len)
2188 memset(tb, 0, sizeof(struct rtattr *) * (max + 1));
2189 while (RTA_OK(rta, len)) {
2190 if ((rta->rta_type <= max) && (!tb[rta->rta_type]))
2191 tb[rta->rta_type] = rta;
2192 rta = RTA_NEXT(rta, len);
2195 connman_error("Deficit %d, rta_len=%d", len, rta->rta_len);
2200 struct get_route_cb_data {
2201 connman_inet_addr_cb_t callback;
2205 static void get_route_cb(struct nlmsghdr *answer, void *user_data)
2207 struct get_route_cb_data *data = user_data;
2208 struct rtattr *tb[RTA_MAX+1];
2209 struct rtmsg *r = NLMSG_DATA(answer);
2210 int len, index = -1;
2212 const char *addr = NULL;
2214 DBG("answer %p data %p", answer, user_data);
2219 len = answer->nlmsg_len;
2221 if (answer->nlmsg_type != RTM_NEWROUTE &&
2222 answer->nlmsg_type != RTM_DELROUTE) {
2223 connman_error("Not a route: %08x %08x %08x",
2224 answer->nlmsg_len, answer->nlmsg_type,
2225 answer->nlmsg_flags);
2229 len -= NLMSG_LENGTH(sizeof(*r));
2231 connman_error("BUG: wrong nlmsg len %d", len);
2235 parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
2237 if (tb[RTA_OIF] != NULL)
2238 index = *(int *)RTA_DATA(tb[RTA_OIF]);
2240 if (tb[RTA_GATEWAY] != NULL)
2241 addr = inet_ntop(r->rtm_family,
2242 RTA_DATA(tb[RTA_GATEWAY]),
2243 abuf, sizeof(abuf));
2245 DBG("addr %s index %d user %p", addr, index, data->user_data);
2248 if (data != NULL && data->callback != NULL)
2249 data->callback(addr, index, data->user_data);
2257 * Return the interface index that contains route to host.
2259 int __connman_inet_get_route(const char *dest_address,
2260 connman_inet_addr_cb_t callback, void *user_data)
2262 struct get_route_cb_data *data;
2263 struct addrinfo hints, *rp;
2264 struct __connman_inet_rtnl_handle *rth;
2267 DBG("dest %s", dest_address);
2269 if (dest_address == NULL)
2272 memset(&hints, 0, sizeof(hints));
2273 hints.ai_family = AF_UNSPEC;
2274 hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV | AI_NUMERICHOST;
2276 err = getaddrinfo(dest_address, NULL, &hints, &rp);
2280 rth = g_try_malloc0(sizeof(struct __connman_inet_rtnl_handle));
2286 rth->req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
2287 rth->req.n.nlmsg_flags = NLM_F_REQUEST;
2288 rth->req.n.nlmsg_type = RTM_GETROUTE;
2289 rth->req.u.r.rt.rtm_family = rp->ai_family;
2290 rth->req.u.r.rt.rtm_table = 0;
2291 rth->req.u.r.rt.rtm_protocol = 0;
2292 rth->req.u.r.rt.rtm_scope = 0;
2293 rth->req.u.r.rt.rtm_type = 0;
2294 rth->req.u.r.rt.rtm_src_len = 0;
2295 rth->req.u.r.rt.rtm_dst_len = rp->ai_addrlen << 3;
2296 rth->req.u.r.rt.rtm_tos = 0;
2298 __connman_inet_rtnl_addattr_l(&rth->req.n, sizeof(rth->req), RTA_DST,
2299 &rp->ai_addr, rp->ai_addrlen);
2303 err = __connman_inet_rtnl_open(rth);
2307 data = g_try_malloc(sizeof(struct get_route_cb_data));
2313 data->callback = callback;
2314 data->user_data = user_data;
2316 #define GET_ROUTE_TIMEOUT 2
2317 err = __connman_inet_rtnl_talk(rth, &rth->req.n, GET_ROUTE_TIMEOUT,
2318 get_route_cb, data);
2327 __connman_inet_rtnl_close(rth);
2334 int connman_inet_check_ipaddress(const char *host)
2336 struct addrinfo hints;
2337 struct addrinfo *addr;
2340 memset(&hints, 0, sizeof(struct addrinfo));
2341 hints.ai_flags = AI_NUMERICHOST;
2344 result = getaddrinfo(host, NULL, &hints, &addr);
2346 result = addr->ai_family;
2352 /* Check routine modified from ics-dhcp 4.2.3-P2 */
2353 connman_bool_t connman_inet_check_hostname(const char *ptr, size_t len)
2358 * Not empty or complete length not over 255 characters.
2360 if ((len == 0) || (len > 256))
2364 * Consists of [[:alnum:]-]+ labels separated by [.]
2365 * a [_] is against RFC but seems to be "widely used"
2367 for (p = ptr; (*p != 0) && (len-- > 0); p++) {
2369 if ((*p == '-') || (*p == '_')) {
2371 * Not allowed at begin or end of a label.
2373 if (((p - ptr) == 0) || (len == 0) || (p[1] == '.'))
2376 } else if (*p == '.') {
2378 * Each label has to be 1-63 characters;
2379 * we allow [.] at the end ('foo.bar.')
2383 if ((d <= 0) || (d >= 64))
2386 ptr = p + 1; /* Jump to the next label */
2388 } else if (isalnum((unsigned char)*p) == 0) {
2390 * Also numbers at the begin are fine
2399 char **__connman_inet_get_running_interfaces(void)
2403 struct ifreq *ifr = NULL;
2404 int sk, i, numif, count = 0;
2406 memset(&ifc, 0, sizeof(ifc));
2408 sk = socket(AF_INET, SOCK_DGRAM, 0);
2412 if (ioctl(sk, SIOCGIFCONF, &ifc) < 0)
2416 * Allocate some extra bytes just in case there will
2417 * be new interfaces added between two SIOCGIFCONF
2420 ifr = g_try_malloc0(ifc.ifc_len * 2);
2426 if (ioctl(sk, SIOCGIFCONF, &ifc) < 0)
2429 numif = ifc.ifc_len / sizeof(struct ifreq);
2431 result = g_try_malloc0((numif + 1) * sizeof(char *));
2437 for (i = 0; i < numif; i++) {
2438 struct ifreq *r = &ifr[i];
2439 struct in6_addr *addr6;
2443 * Note that we do not return loopback interfaces here as they
2444 * are not needed for our purposes.
2446 switch (r->ifr_addr.sa_family) {
2448 addr4 = ntohl(((struct sockaddr_in *)
2449 &r->ifr_addr)->sin_addr.s_addr);
2450 if (((addr4 & 0xff000000) >> 24) == 127)
2454 addr6 = &((struct sockaddr_in6 *)
2455 &r->ifr_addr)->sin6_addr;
2456 if (IN6_IS_ADDR_LINKLOCAL(addr6))
2461 result[count++] = g_strdup(r->ifr_name);
2467 result = g_try_realloc(result, (count + 1) * sizeof(char *));
2477 connman_bool_t connman_inet_is_ipv6_supported()
2481 sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);