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;
299 if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0) {
312 int connman_inet_ifdown(int index)
317 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
321 memset(&ifr, 0, sizeof(ifr));
322 ifr.ifr_ifindex = index;
324 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
329 if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
334 if (!(ifr.ifr_flags & IFF_UP)) {
339 ifr.ifr_flags &= ~IFF_UP;
341 if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0)
352 static char *index2addr(int index)
355 struct ether_addr eth;
362 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
366 memset(&ifr, 0, sizeof(ifr));
367 ifr.ifr_ifindex = index;
369 err = ioctl(sk, SIOCGIFNAME, &ifr);
372 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
383 memcpy(ð, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
384 snprintf(str, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
385 eth.ether_addr_octet[0],
386 eth.ether_addr_octet[1],
387 eth.ether_addr_octet[2],
388 eth.ether_addr_octet[3],
389 eth.ether_addr_octet[4],
390 eth.ether_addr_octet[5]);
395 static char *index2ident(int index, const char *prefix)
398 struct ether_addr eth;
405 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
409 memset(&ifr, 0, sizeof(ifr));
410 ifr.ifr_ifindex = index;
412 err = ioctl(sk, SIOCGIFNAME, &ifr);
415 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
422 len = prefix ? strlen(prefix) + 18 : 18;
428 memcpy(ð, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
429 snprintf(str, len, "%s%02x%02x%02x%02x%02x%02x",
430 prefix ? prefix : "",
431 eth.ether_addr_octet[0],
432 eth.ether_addr_octet[1],
433 eth.ether_addr_octet[2],
434 eth.ether_addr_octet[3],
435 eth.ether_addr_octet[4],
436 eth.ether_addr_octet[5]);
441 connman_bool_t connman_inet_is_cfg80211(int index)
443 connman_bool_t result = FALSE;
444 char phy80211_path[PATH_MAX];
449 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
453 memset(&ifr, 0, sizeof(ifr));
454 ifr.ifr_ifindex = index;
456 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0)
459 snprintf(phy80211_path, PATH_MAX,
460 "/sys/class/net/%s/phy80211", ifr.ifr_name);
462 if (stat(phy80211_path, &st) == 0 && (st.st_mode & S_IFDIR))
471 struct connman_device *connman_inet_create_device(int index)
473 enum connman_device_type type;
474 struct connman_device *device;
475 char *devname, *ident = NULL;
476 char *addr = NULL, *name = NULL;
481 devname = connman_inet_ifname(index);
485 if (__connman_device_isfiltered(devname) == TRUE) {
486 connman_info("Ignoring interface %s (filtered)", devname);
491 type = __connman_rtnl_get_device_type(index);
494 case CONNMAN_DEVICE_TYPE_UNKNOWN:
495 connman_info("Ignoring interface %s (type unknown)", devname);
498 case CONNMAN_DEVICE_TYPE_ETHERNET:
499 case CONNMAN_DEVICE_TYPE_GADGET:
500 case CONNMAN_DEVICE_TYPE_WIFI:
501 case CONNMAN_DEVICE_TYPE_WIMAX:
502 name = index2ident(index, "");
503 addr = index2addr(index);
505 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
506 case CONNMAN_DEVICE_TYPE_CELLULAR:
507 case CONNMAN_DEVICE_TYPE_GPS:
508 case CONNMAN_DEVICE_TYPE_VENDOR:
509 name = strdup(devname);
513 device = connman_device_create(name, type);
518 case CONNMAN_DEVICE_TYPE_UNKNOWN:
519 case CONNMAN_DEVICE_TYPE_VENDOR:
520 case CONNMAN_DEVICE_TYPE_GPS:
522 case CONNMAN_DEVICE_TYPE_ETHERNET:
523 case CONNMAN_DEVICE_TYPE_GADGET:
524 ident = index2ident(index, NULL);
526 case CONNMAN_DEVICE_TYPE_WIFI:
527 case CONNMAN_DEVICE_TYPE_WIMAX:
528 ident = index2ident(index, NULL);
530 case CONNMAN_DEVICE_TYPE_BLUETOOTH:
532 case CONNMAN_DEVICE_TYPE_CELLULAR:
533 ident = index2ident(index, NULL);
537 connman_device_set_index(device, index);
538 connman_device_set_interface(device, devname);
541 connman_device_set_ident(device, ident);
545 connman_device_set_string(device, "Address", addr);
556 struct in6_addr ifr6_addr;
557 __u32 ifr6_prefixlen;
558 unsigned int ifr6_ifindex;
561 int connman_inet_set_ipv6_address(int index,
562 struct connman_ipaddress *ipaddress)
565 unsigned char prefix_len;
568 if (ipaddress->local == NULL)
571 prefix_len = ipaddress->prefixlen;
572 address = ipaddress->local;
574 DBG("index %d address %s prefix_len %d", index, address, prefix_len);
576 err = __connman_inet_modify_address(RTM_NEWADDR,
577 NLM_F_REPLACE | NLM_F_ACK, index, AF_INET6,
578 address, NULL, prefix_len, NULL);
580 connman_error("%s: %s", __func__, strerror(-err));
587 int connman_inet_set_address(int index, struct connman_ipaddress *ipaddress)
590 unsigned char prefix_len;
591 const char *address, *broadcast, *peer;
593 if (ipaddress->local == NULL)
596 prefix_len = ipaddress->prefixlen;
597 address = ipaddress->local;
598 broadcast = ipaddress->broadcast;
599 peer = ipaddress->peer;
601 DBG("index %d address %s prefix_len %d", index, address, prefix_len);
603 err = __connman_inet_modify_address(RTM_NEWADDR,
604 NLM_F_REPLACE | NLM_F_ACK, index, AF_INET,
605 address, peer, prefix_len, broadcast);
607 connman_error("%s: %s", __func__, strerror(-err));
614 int connman_inet_clear_ipv6_address(int index, const char *address,
619 DBG("index %d address %s prefix_len %d", index, address, prefix_len);
621 err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET6,
622 address, NULL, prefix_len, NULL);
624 connman_error("%s: %s", __func__, strerror(-err));
631 int connman_inet_clear_address(int index, struct connman_ipaddress *ipaddress)
634 unsigned char prefix_len;
635 const char *address, *broadcast, *peer;
637 prefix_len = ipaddress->prefixlen;
638 address = ipaddress->local;
639 broadcast = ipaddress->broadcast;
640 peer = ipaddress->peer;
642 DBG("index %d address %s prefix_len %d", index, address, prefix_len);
644 err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET,
645 address, peer, prefix_len, broadcast);
647 connman_error("%s: %s", __func__, strerror(-err));
654 int connman_inet_add_host_route(int index, const char *host,
657 return connman_inet_add_network_route(index, host, gateway, NULL);
660 int connman_inet_del_host_route(int index, const char *host)
662 return connman_inet_del_network_route(index, host);
665 int connman_inet_add_network_route(int index, const char *host,
671 struct sockaddr_in addr;
674 DBG("index %d host %s gateway %s netmask %s", index,
675 host, gateway, netmask);
677 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
681 memset(&ifr, 0, sizeof(ifr));
682 ifr.ifr_ifindex = index;
684 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
689 DBG("ifname %s", ifr.ifr_name);
691 memset(&rt, 0, sizeof(rt));
692 rt.rt_flags = RTF_UP;
694 rt.rt_flags |= RTF_GATEWAY;
696 rt.rt_flags |= RTF_HOST;
698 memset(&addr, 0, sizeof(addr));
699 addr.sin_family = AF_INET;
700 addr.sin_addr.s_addr = inet_addr(host);
701 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
703 memset(&addr, 0, sizeof(addr));
704 addr.sin_family = AF_INET;
706 addr.sin_addr.s_addr = inet_addr(gateway);
708 addr.sin_addr.s_addr = INADDR_ANY;
709 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
711 memset(&addr, 0, sizeof(addr));
712 addr.sin_family = AF_INET;
713 addr.sin_addr.s_addr = INADDR_ANY;
715 addr.sin_addr.s_addr = inet_addr(netmask);
717 addr.sin_addr.s_addr = INADDR_ANY;
718 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
720 rt.rt_dev = ifr.ifr_name;
722 err = ioctl(sk, SIOCADDRT, &rt);
724 connman_error("Adding host route failed (%s)",
732 int connman_inet_del_network_route(int index, const char *host)
736 struct sockaddr_in addr;
739 DBG("index %d host %s", index, host);
741 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
745 memset(&ifr, 0, sizeof(ifr));
746 ifr.ifr_ifindex = index;
748 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
753 DBG("ifname %s", ifr.ifr_name);
755 memset(&rt, 0, sizeof(rt));
756 rt.rt_flags = RTF_UP | RTF_HOST;
758 memset(&addr, 0, sizeof(addr));
759 addr.sin_family = AF_INET;
760 addr.sin_addr.s_addr = inet_addr(host);
761 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
763 rt.rt_dev = ifr.ifr_name;
765 err = ioctl(sk, SIOCDELRT, &rt);
767 connman_error("Deleting host route failed (%s)",
775 int connman_inet_del_ipv6_network_route(int index, const char *host,
776 unsigned char prefix_len)
781 DBG("index %d host %s", index, host);
786 memset(&rt, 0, sizeof(rt));
788 rt.rtmsg_dst_len = prefix_len;
790 err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
794 rt.rtmsg_flags = RTF_UP | RTF_HOST;
797 rt.rtmsg_ifindex = index;
799 sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
805 err = ioctl(sk, SIOCDELRT, &rt);
809 connman_error("Del IPv6 host route error (%s)",
815 int connman_inet_del_ipv6_host_route(int index, const char *host)
817 return connman_inet_del_ipv6_network_route(index, host, 128);
820 int connman_inet_add_ipv6_network_route(int index, const char *host,
822 unsigned char prefix_len)
827 DBG("index %d host %s gateway %s", index, host, gateway);
832 memset(&rt, 0, sizeof(rt));
834 rt.rtmsg_dst_len = prefix_len;
836 err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
840 rt.rtmsg_flags = RTF_UP | RTF_HOST;
842 if (gateway != NULL) {
843 rt.rtmsg_flags |= RTF_GATEWAY;
844 inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
848 rt.rtmsg_ifindex = index;
850 sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
856 err = ioctl(sk, SIOCADDRT, &rt);
860 connman_error("Set IPv6 host route error (%s)",
866 int connman_inet_add_ipv6_host_route(int index, const char *host,
869 return connman_inet_add_ipv6_network_route(index, host, gateway, 128);
872 int connman_inet_set_ipv6_gateway_address(int index, const char *gateway)
877 DBG("index %d gateway %s", index, gateway);
882 memset(&rt, 0, sizeof(rt));
884 err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
888 rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
890 rt.rtmsg_dst_len = 0;
891 rt.rtmsg_ifindex = index;
893 sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
899 err = ioctl(sk, SIOCADDRT, &rt);
903 connman_error("Set default IPv6 gateway error (%s)",
909 int connman_inet_clear_ipv6_gateway_address(int index, const char *gateway)
914 DBG("index %d gateway %s", index, gateway);
919 memset(&rt, 0, sizeof(rt));
921 err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
925 rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
927 rt.rtmsg_dst_len = 0;
928 rt.rtmsg_ifindex = index;
930 sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
936 err = ioctl(sk, SIOCDELRT, &rt);
940 connman_error("Clear default IPv6 gateway error (%s)",
946 int connman_inet_set_gateway_address(int index, const char *gateway)
950 struct sockaddr_in addr;
953 DBG("index %d gateway %s", index, gateway);
955 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
959 memset(&ifr, 0, sizeof(ifr));
960 ifr.ifr_ifindex = index;
962 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
967 DBG("ifname %s", ifr.ifr_name);
969 memset(&rt, 0, sizeof(rt));
970 rt.rt_flags = RTF_UP | RTF_GATEWAY;
972 memset(&addr, 0, sizeof(addr));
973 addr.sin_family = AF_INET;
974 addr.sin_addr.s_addr = INADDR_ANY;
975 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
977 memset(&addr, 0, sizeof(addr));
978 addr.sin_family = AF_INET;
979 addr.sin_addr.s_addr = inet_addr(gateway);
980 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
982 memset(&addr, 0, sizeof(addr));
983 addr.sin_family = AF_INET;
984 addr.sin_addr.s_addr = INADDR_ANY;
985 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
987 err = ioctl(sk, SIOCADDRT, &rt);
989 connman_error("Setting default gateway route failed (%s)",
997 int connman_inet_set_gateway_interface(int index)
1001 struct sockaddr_in addr;
1004 DBG("index %d", index);
1006 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1010 memset(&ifr, 0, sizeof(ifr));
1011 ifr.ifr_ifindex = index;
1013 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1018 DBG("ifname %s", ifr.ifr_name);
1020 memset(&rt, 0, sizeof(rt));
1021 rt.rt_flags = RTF_UP;
1023 memset(&addr, 0, sizeof(addr));
1024 addr.sin_family = AF_INET;
1025 addr.sin_addr.s_addr = INADDR_ANY;
1027 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1028 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1029 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1031 rt.rt_dev = ifr.ifr_name;
1033 err = ioctl(sk, SIOCADDRT, &rt);
1035 connman_error("Setting default interface route failed (%s)",
1042 int connman_inet_set_ipv6_gateway_interface(int index)
1046 struct sockaddr_in6 addr;
1047 const struct in6_addr any = IN6ADDR_ANY_INIT;
1050 DBG("index %d", index);
1052 sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1056 memset(&ifr, 0, sizeof(ifr));
1057 ifr.ifr_ifindex = index;
1059 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1064 DBG("ifname %s", ifr.ifr_name);
1066 memset(&rt, 0, sizeof(rt));
1067 rt.rt_flags = RTF_UP;
1069 memset(&addr, 0, sizeof(addr));
1070 addr.sin6_family = AF_INET6;
1071 addr.sin6_addr = any;
1073 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1074 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1075 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1077 rt.rt_dev = ifr.ifr_name;
1079 err = ioctl(sk, SIOCADDRT, &rt);
1081 connman_error("Setting default interface route failed (%s)",
1088 int connman_inet_clear_gateway_address(int index, const char *gateway)
1092 struct sockaddr_in addr;
1095 DBG("index %d gateway %s", index, gateway);
1097 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1101 memset(&ifr, 0, sizeof(ifr));
1102 ifr.ifr_ifindex = index;
1104 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1109 DBG("ifname %s", ifr.ifr_name);
1111 memset(&rt, 0, sizeof(rt));
1112 rt.rt_flags = RTF_UP | RTF_GATEWAY;
1114 memset(&addr, 0, sizeof(addr));
1115 addr.sin_family = AF_INET;
1116 addr.sin_addr.s_addr = INADDR_ANY;
1117 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1119 memset(&addr, 0, sizeof(addr));
1120 addr.sin_family = AF_INET;
1121 addr.sin_addr.s_addr = inet_addr(gateway);
1122 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1124 memset(&addr, 0, sizeof(addr));
1125 addr.sin_family = AF_INET;
1126 addr.sin_addr.s_addr = INADDR_ANY;
1127 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1129 err = ioctl(sk, SIOCDELRT, &rt);
1131 connman_error("Removing default gateway route failed (%s)",
1139 int connman_inet_clear_gateway_interface(int index)
1143 struct sockaddr_in addr;
1146 DBG("index %d", index);
1148 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1152 memset(&ifr, 0, sizeof(ifr));
1153 ifr.ifr_ifindex = index;
1155 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1160 DBG("ifname %s", ifr.ifr_name);
1162 memset(&rt, 0, sizeof(rt));
1163 rt.rt_flags = RTF_UP;
1165 memset(&addr, 0, sizeof(addr));
1166 addr.sin_family = AF_INET;
1167 addr.sin_addr.s_addr = INADDR_ANY;
1169 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1170 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1171 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1173 rt.rt_dev = ifr.ifr_name;
1175 err = ioctl(sk, SIOCDELRT, &rt);
1177 connman_error("Removing default interface route failed (%s)",
1184 int connman_inet_clear_ipv6_gateway_interface(int index)
1188 struct sockaddr_in6 addr;
1189 const struct in6_addr any = IN6ADDR_ANY_INIT;
1192 DBG("index %d", index);
1194 sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1198 memset(&ifr, 0, sizeof(ifr));
1199 ifr.ifr_ifindex = index;
1201 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1206 DBG("ifname %s", ifr.ifr_name);
1208 memset(&rt, 0, sizeof(rt));
1209 rt.rt_flags = RTF_UP;
1211 memset(&addr, 0, sizeof(addr));
1212 addr.sin6_family = AF_INET6;
1213 addr.sin6_addr = any;
1215 memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1216 memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1217 memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1219 rt.rt_dev = ifr.ifr_name;
1221 err = ioctl(sk, SIOCDELRT, &rt);
1223 connman_error("Removing default interface route failed (%s)",
1230 connman_bool_t connman_inet_compare_subnet(int index, const char *host)
1233 struct in_addr _host_addr;
1234 in_addr_t host_addr, netmask_addr, if_addr;
1235 struct sockaddr_in *netmask, *addr;
1238 DBG("host %s", host);
1243 if (inet_aton(host, &_host_addr) == 0)
1245 host_addr = _host_addr.s_addr;
1247 sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1251 memset(&ifr, 0, sizeof(ifr));
1252 ifr.ifr_ifindex = index;
1254 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1259 if (ioctl(sk, SIOCGIFNETMASK, &ifr) < 0) {
1264 netmask = (struct sockaddr_in *)&ifr.ifr_netmask;
1265 netmask_addr = netmask->sin_addr.s_addr;
1267 if (ioctl(sk, SIOCGIFADDR, &ifr) < 0) {
1274 addr = (struct sockaddr_in *)&ifr.ifr_addr;
1275 if_addr = addr->sin_addr.s_addr;
1277 return ((if_addr & netmask_addr) == (host_addr & netmask_addr));
1280 int connman_inet_remove_from_bridge(int index, const char *bridge)
1288 sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
1292 memset(&ifr, 0, sizeof(ifr));
1293 strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1294 ifr.ifr_ifindex = index;
1296 err = ioctl(sk, SIOCBRDELIF, &ifr);
1301 connman_error("Remove interface from bridge error %s",
1309 int connman_inet_add_to_bridge(int index, const char *bridge)
1317 sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
1321 memset(&ifr, 0, sizeof(ifr));
1322 strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1323 ifr.ifr_ifindex = index;
1325 err = ioctl(sk, SIOCBRADDIF, &ifr);
1330 connman_error("Add interface to bridge error %s",
1338 int connman_inet_set_mtu(int index, int mtu)
1343 sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1347 memset(&ifr, 0, sizeof(ifr));
1348 ifr.ifr_ifindex = index;
1350 err = ioctl(sk, SIOCGIFNAME, &ifr);
1353 err = ioctl(sk, SIOCSIFMTU, &ifr);
1360 int connman_inet_setup_tunnel(char *tunnel, int mtu)
1370 sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1374 index = if_nametoindex(tunnel);
1376 err = connman_inet_set_mtu(index, mtu);
1382 memset(&ifr, 0, sizeof(ifr));
1383 strncpy(ifr.ifr_name, tunnel, IFNAMSIZ);
1384 err = ioctl(sk, SIOCGIFFLAGS, &ifr);
1391 if ((ifr.ifr_flags ^ flags) & mask) {
1392 ifr.ifr_flags &= ~mask;
1393 ifr.ifr_flags |= mask & flags;
1394 err = ioctl(sk, SIOCSIFFLAGS, &ifr);
1396 connman_error("SIOCSIFFLAGS failed: %s",
1405 int connman_inet_create_tunnel(char **iface)
1410 fd = open("/dev/net/tun", O_RDWR | O_CLOEXEC);
1413 connman_error("Failed to open /dev/net/tun: %s",
1418 memset(&ifr, 0, sizeof(ifr));
1419 ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
1421 for (i = 0; i < 256; i++) {
1422 sprintf(ifr.ifr_name, "tun%d", i);
1424 if (!ioctl(fd, TUNSETIFF, (void *)&ifr))
1429 connman_error("Failed to find available tun device");
1434 *iface = g_strdup(ifr.ifr_name);
1440 GIOChannel *channel;
1441 __connman_inet_rs_cb_t callback;
1442 struct sockaddr_in6 addr;
1448 #define CMSG_BUF_LEN 512
1449 #define IN6ADDR_ALL_NODES_MC_INIT \
1450 { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x1 } } } /* ff02::1 */
1451 #define IN6ADDR_ALL_ROUTERS_MC_INIT \
1452 { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x2 } } } /* ff02::2 */
1454 static const struct in6_addr in6addr_all_nodes_mc = IN6ADDR_ALL_NODES_MC_INIT;
1455 static const struct in6_addr in6addr_all_routers_mc =
1456 IN6ADDR_ALL_ROUTERS_MC_INIT;
1458 static void rs_cleanup(struct rs_cb_data *data)
1460 if (data->channel != NULL) {
1461 g_io_channel_shutdown(data->channel, TRUE, NULL);
1462 g_io_channel_unref(data->channel);
1463 data->channel = NULL;
1466 if (data->rs_timeout > 0)
1467 g_source_remove(data->rs_timeout);
1469 if (data->watch_id > 0)
1470 g_source_remove(data->watch_id);
1475 static gboolean rs_timeout_cb(gpointer user_data)
1477 struct rs_cb_data *data = user_data;
1479 DBG("user data %p", user_data);
1484 if (data->callback != NULL)
1485 data->callback(NULL, 0, data->user_data);
1487 data->rs_timeout = 0;
1492 static int icmpv6_recv(int fd, gpointer user_data)
1496 unsigned char chdr[CMSG_BUF_LEN];
1497 unsigned char buf[1540];
1498 struct rs_cb_data *data = user_data;
1499 struct nd_router_advert *hdr;
1500 struct sockaddr_in6 saddr;
1505 iov.iov_len = sizeof(buf);
1508 mhdr.msg_name = (void *)&saddr;
1509 mhdr.msg_namelen = sizeof(struct sockaddr_in6);
1510 mhdr.msg_iov = &iov;
1511 mhdr.msg_iovlen = 1;
1512 mhdr.msg_control = (void *)chdr;
1513 mhdr.msg_controllen = CMSG_BUF_LEN;
1515 len = recvmsg(fd, &mhdr, 0);
1517 data->callback(NULL, 0, data->user_data);
1522 hdr = (struct nd_router_advert *)buf;
1523 DBG("code %d len %zd hdr %zd", hdr->nd_ra_code, len,
1524 sizeof(struct nd_router_advert));
1525 if (hdr->nd_ra_code != 0)
1528 data->callback(hdr, len, data->user_data);
1534 static gboolean icmpv6_event(GIOChannel *chan, GIOCondition cond,
1541 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
1544 fd = g_io_channel_unix_get_fd(chan);
1545 ret = icmpv6_recv(fd, data);
1552 /* Adapted from RFC 1071 "C" Implementation Example */
1553 static uint16_t csum(const void *phdr, const void *data, socklen_t datalen)
1555 register unsigned long sum = 0;
1560 /* caller must make sure datalen is even */
1562 addr = (uint16_t *)phdr;
1563 for (i = 0; i < 20; i++)
1567 addr = (uint16_t *)data;
1575 sum = (sum & 0xffff) + (sum >> 16);
1577 return (uint16_t)~sum;
1580 static int ndisc_send_unspec(int type, int oif, const struct in6_addr *dest)
1583 struct in6_addr src;
1584 struct in6_addr dst;
1586 uint8_t reserved[3];
1593 struct icmp6_hdr icmp;
1594 struct nd_neighbor_solicit ns;
1595 struct nd_router_solicit rs;
1600 struct cmsghdr *cmsg;
1601 struct in6_pktinfo *pinfo;
1602 struct sockaddr_in6 dst;
1603 char cbuf[CMSG_SPACE(sizeof(*pinfo))];
1605 int fd, datalen, ret;
1609 fd = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_RAW);
1613 memset(&frame, 0, sizeof(frame));
1614 memset(&dst, 0, sizeof(dst));
1616 datalen = sizeof(frame.i.rs); /* 8, csum() safe */
1617 dst.sin6_addr = *dest;
1619 /* Fill in the IPv6 header */
1620 frame.ip.ip6_vfc = 0x60;
1621 frame.ip.ip6_plen = htons(datalen);
1622 frame.ip.ip6_nxt = IPPROTO_ICMPV6;
1623 frame.ip.ip6_hlim = 255;
1624 frame.ip.ip6_dst = dst.sin6_addr;
1625 /* all other fields are already set to zero */
1627 /* Prepare pseudo header for csum */
1628 memset(&phdr, 0, sizeof(phdr));
1629 phdr.dst = dst.sin6_addr;
1630 phdr.plen = htonl(datalen);
1631 phdr.nxt = IPPROTO_ICMPV6;
1633 /* Fill in remaining ICMP header fields */
1634 frame.i.icmp.icmp6_type = type;
1635 frame.i.icmp.icmp6_cksum = csum(&phdr, &frame.i, datalen);
1637 iov.iov_base = &frame;
1638 iov.iov_len = sizeof(frame.ip) + datalen;
1640 dst.sin6_family = AF_INET6;
1641 msgh.msg_name = &dst;
1642 msgh.msg_namelen = sizeof(dst);
1643 msgh.msg_iov = &iov;
1644 msgh.msg_iovlen = 1;
1647 memset(cbuf, 0, CMSG_SPACE(sizeof(*pinfo)));
1648 cmsg = (struct cmsghdr *)cbuf;
1649 pinfo = (struct in6_pktinfo *)CMSG_DATA(cmsg);
1650 pinfo->ipi6_ifindex = oif;
1652 cmsg->cmsg_len = CMSG_LEN(sizeof(*pinfo));
1653 cmsg->cmsg_level = IPPROTO_IPV6;
1654 cmsg->cmsg_type = IPV6_PKTINFO;
1655 msgh.msg_control = cmsg;
1656 msgh.msg_controllen = cmsg->cmsg_len;
1658 ret = sendmsg(fd, &msgh, 0);
1664 static inline void ipv6_addr_set(struct in6_addr *addr,
1665 uint32_t w1, uint32_t w2,
1666 uint32_t w3, uint32_t w4)
1668 addr->s6_addr32[0] = w1;
1669 addr->s6_addr32[1] = w2;
1670 addr->s6_addr32[2] = w3;
1671 addr->s6_addr32[3] = w4;
1674 static inline void ipv6_addr_solict_mult(const struct in6_addr *addr,
1675 struct in6_addr *solicited)
1677 ipv6_addr_set(solicited, htonl(0xFF020000), 0, htonl(0x1),
1678 htonl(0xFF000000) | addr->s6_addr32[3]);
1681 static int if_mc_group(int sock, int ifindex, const struct in6_addr *mc_addr,
1684 unsigned int val = 0;
1685 struct ipv6_mreq mreq;
1688 memset(&mreq, 0, sizeof(mreq));
1689 mreq.ipv6mr_interface = ifindex;
1690 mreq.ipv6mr_multiaddr = *mc_addr;
1692 ret = setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
1698 return setsockopt(sock, IPPROTO_IPV6, cmd, &mreq, sizeof(mreq));
1701 int __connman_inet_ipv6_send_rs(int index, int timeout,
1702 __connman_inet_rs_cb_t callback, void *user_data)
1704 struct rs_cb_data *data;
1705 struct icmp6_filter filter;
1706 struct in6_addr solicit;
1707 struct in6_addr dst = in6addr_all_routers_mc;
1715 data = g_try_malloc0(sizeof(struct rs_cb_data));
1719 data->callback = callback;
1720 data->user_data = user_data;
1721 data->rs_timeout = g_timeout_add_seconds(timeout, rs_timeout_cb, data);
1723 sk = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
1727 ICMP6_FILTER_SETBLOCKALL(&filter);
1728 ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filter);
1730 setsockopt(sk, IPPROTO_ICMPV6, ICMP6_FILTER, &filter,
1731 sizeof(struct icmp6_filter));
1733 ipv6_addr_solict_mult(&dst, &solicit);
1734 if_mc_group(sk, index, &in6addr_all_nodes_mc, IPV6_JOIN_GROUP);
1735 if_mc_group(sk, index, &solicit, IPV6_JOIN_GROUP);
1737 data->channel = g_io_channel_unix_new(sk);
1738 g_io_channel_set_close_on_unref(data->channel, TRUE);
1740 g_io_channel_set_encoding(data->channel, NULL, NULL);
1741 g_io_channel_set_buffered(data->channel, FALSE);
1743 data->watch_id = g_io_add_watch(data->channel,
1744 G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
1745 icmpv6_event, data);
1747 ndisc_send_unspec(ND_ROUTER_SOLICIT, index, &dst);
1752 GSList *__connman_inet_ipv6_get_prefixes(struct nd_router_advert *hdr,
1753 unsigned int length)
1755 GSList *prefixes = NULL;
1759 if (length <= sizeof(struct nd_router_advert))
1762 len = length - sizeof(struct nd_router_advert);
1763 pos = (uint8_t *)hdr + sizeof(struct nd_router_advert);
1766 struct nd_opt_prefix_info *pinfo;
1767 char prefix_str[INET6_ADDRSTRLEN+1], *str;
1774 optlen = pos[1] << 3;
1775 if (optlen == 0 || optlen > len)
1779 case ND_OPT_PREFIX_INFORMATION:
1780 pinfo = (struct nd_opt_prefix_info *)pos;
1781 prefix = inet_ntop(AF_INET6, &pinfo->nd_opt_pi_prefix,
1782 prefix_str, INET6_ADDRSTRLEN);
1786 str = g_strdup_printf("%s/%d", prefix,
1787 pinfo->nd_opt_pi_prefix_len);
1788 prefixes = g_slist_append(prefixes, str);
1790 DBG("prefix %s", str);
1802 static int get_dest_addr(int family, int index, char *buf, int len)
1808 sk = socket(family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1812 memset(&ifr, 0, sizeof(ifr));
1813 ifr.ifr_ifindex = index;
1815 if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1816 DBG("SIOCGIFNAME (%d/%s)", errno, strerror(errno));
1821 if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
1822 DBG("SIOCGIFFLAGS (%d/%s)", errno, strerror(errno));
1827 if ((ifr.ifr_flags & IFF_POINTOPOINT) == 0) {
1833 DBG("index %d %s", index, ifr.ifr_name);
1835 if (ioctl(sk, SIOCGIFDSTADDR, &ifr) < 0) {
1836 connman_error("Get destination address failed (%s)",
1846 addr = &((struct sockaddr_in *)&ifr.ifr_dstaddr)->sin_addr;
1849 addr = &((struct sockaddr_in6 *)&ifr.ifr_dstaddr)->sin6_addr;
1856 if (inet_ntop(family, addr, buf, len) == NULL) {
1857 DBG("error %d/%s", errno, strerror(errno));
1864 int connman_inet_get_dest_addr(int index, char **dest)
1866 char addr[INET_ADDRSTRLEN];
1869 ret = get_dest_addr(PF_INET, index, addr, INET_ADDRSTRLEN);
1873 *dest = g_strdup(addr);
1875 DBG("destination %s", *dest);
1880 int connman_inet_ipv6_get_dest_addr(int index, char **dest)
1882 char addr[INET6_ADDRSTRLEN];
1885 ret = get_dest_addr(PF_INET6, index, addr, INET6_ADDRSTRLEN);
1889 *dest = g_strdup(addr);
1891 DBG("destination %s", *dest);
1896 int __connman_inet_rtnl_open(struct __connman_inet_rtnl_handle *rth)
1899 int rcvbuf = 1024 * 4;
1901 rth->fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
1903 connman_error("Can not open netlink socket: %s",
1908 if (setsockopt(rth->fd, SOL_SOCKET, SO_SNDBUF, &sndbuf,
1909 sizeof(sndbuf)) < 0) {
1910 connman_error("SO_SNDBUF: %s", strerror(errno));
1914 if (setsockopt(rth->fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf,
1915 sizeof(rcvbuf)) < 0) {
1916 connman_error("SO_RCVBUF: %s", strerror(errno));
1920 memset(&rth->local, 0, sizeof(rth->local));
1921 rth->local.nl_family = AF_NETLINK;
1922 rth->local.nl_groups = 0;
1924 if (bind(rth->fd, (struct sockaddr *)&rth->local,
1925 sizeof(rth->local)) < 0) {
1926 connman_error("Can not bind netlink socket: %s",
1931 rth->seq = time(NULL);
1933 DBG("fd %d", rth->fd);
1938 struct inet_rtnl_cb_data {
1939 GIOChannel *channel;
1940 __connman_inet_rtnl_cb_t callback;
1943 struct __connman_inet_rtnl_handle *rtnl;
1947 static void inet_rtnl_cleanup(struct inet_rtnl_cb_data *data)
1949 struct __connman_inet_rtnl_handle *rth = data->rtnl;
1951 if (data->channel != NULL) {
1952 g_io_channel_shutdown(data->channel, TRUE, NULL);
1953 g_io_channel_unref(data->channel);
1954 data->channel = NULL;
1957 DBG("data %p", data);
1959 if (data->rtnl_timeout > 0)
1960 g_source_remove(data->rtnl_timeout);
1962 if (data->watch_id > 0)
1963 g_source_remove(data->watch_id);
1966 __connman_inet_rtnl_close(rth);
1973 static gboolean inet_rtnl_timeout_cb(gpointer user_data)
1975 struct inet_rtnl_cb_data *data = user_data;
1977 DBG("user data %p", user_data);
1982 if (data->callback != NULL)
1983 data->callback(NULL, data->user_data);
1985 data->rtnl_timeout = 0;
1986 inet_rtnl_cleanup(data);
1990 static int inet_rtnl_recv(GIOChannel *chan, gpointer user_data)
1992 struct inet_rtnl_cb_data *rtnl_data = user_data;
1993 struct __connman_inet_rtnl_handle *rth = rtnl_data->rtnl;
1994 struct nlmsghdr *h = NULL;
1995 struct sockaddr_nl nladdr;
1996 socklen_t addr_len = sizeof(nladdr);
1997 unsigned char buf[4096];
2002 memset(buf, 0, sizeof(buf));
2003 memset(&nladdr, 0, sizeof(nladdr));
2005 fd = g_io_channel_unix_get_fd(chan);
2007 status = recvfrom(fd, buf, sizeof(buf), 0,
2008 (struct sockaddr *) &nladdr, &addr_len);
2010 if (errno == EINTR || errno == EAGAIN)
2019 if (nladdr.nl_pid != 0) { /* not sent by kernel, ignore */
2020 DBG("Received msg from %u, ignoring it", nladdr.nl_pid);
2027 struct nlmsgerr *err;
2031 if (!NLMSG_OK(h, len)) {
2036 if (h->nlmsg_seq != rth->seq) {
2038 DBG("skip %d/%d len %d", rth->seq,
2039 h->nlmsg_seq, h->nlmsg_len);
2041 len -= h->nlmsg_len;
2042 ptr += h->nlmsg_len;
2046 switch (h->nlmsg_type) {
2052 err = (struct nlmsgerr *)NLMSG_DATA(h);
2053 connman_error("RTNETLINK answers %s (%d)",
2054 strerror(-err->error), -err->error);
2061 if (h->nlmsg_seq == rth->seq) {
2062 DBG("received %d seq %d", h->nlmsg_len, h->nlmsg_seq);
2064 rtnl_data->callback(h, rtnl_data->user_data);
2066 if (rtnl_data->rtnl_timeout > 0) {
2067 g_source_remove(rtnl_data->rtnl_timeout);
2068 rtnl_data->rtnl_timeout = 0;
2071 __connman_inet_rtnl_close(rth);
2078 static gboolean inet_rtnl_event(GIOChannel *chan, GIOCondition cond,
2085 if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
2088 ret = inet_rtnl_recv(chan, user_data);
2095 int __connman_inet_rtnl_talk(struct __connman_inet_rtnl_handle *rtnl,
2096 struct nlmsghdr *n, int timeout,
2097 __connman_inet_rtnl_cb_t callback, void *user_data)
2099 struct sockaddr_nl nladdr;
2100 struct inet_rtnl_cb_data *data;
2104 memset(&nladdr, 0, sizeof(nladdr));
2105 nladdr.nl_family = AF_NETLINK;
2107 n->nlmsg_seq = seq = ++rtnl->seq;
2109 if (callback != NULL) {
2110 data = g_try_malloc0(sizeof(struct inet_rtnl_cb_data));
2114 data->callback = callback;
2115 data->user_data = user_data;
2117 data->rtnl_timeout = g_timeout_add_seconds(timeout,
2118 inet_rtnl_timeout_cb, data);
2120 data->channel = g_io_channel_unix_new(rtnl->fd);
2121 g_io_channel_set_close_on_unref(data->channel, TRUE);
2123 g_io_channel_set_encoding(data->channel, NULL, NULL);
2124 g_io_channel_set_buffered(data->channel, FALSE);
2126 data->watch_id = g_io_add_watch(data->channel,
2127 G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
2128 inet_rtnl_event, data);
2130 n->nlmsg_flags |= NLM_F_ACK;
2132 err = sendto(rtnl->fd, &rtnl->req.n, rtnl->req.n.nlmsg_len, 0,
2133 (struct sockaddr *) &nladdr, sizeof(nladdr));
2134 DBG("handle %p len %d err %d", rtnl, rtnl->req.n.nlmsg_len, err);
2136 connman_error("Can not talk to rtnetlink");
2140 if ((unsigned int)err != rtnl->req.n.nlmsg_len) {
2141 connman_error("Sent %d bytes, msg truncated", err);
2148 void __connman_inet_rtnl_close(struct __connman_inet_rtnl_handle *rth)
2150 DBG("handle %p", rth);
2158 int __connman_inet_rtnl_addattr32(struct nlmsghdr *n, size_t maxlen, int type,
2161 int len = RTA_LENGTH(4);
2164 if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen) {
2165 DBG("Error! max allowed bound %zd exceeded", maxlen);
2168 rta = NLMSG_TAIL(n);
2169 rta->rta_type = type;
2171 memcpy(RTA_DATA(rta), &data, 4);
2172 n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
2177 int connman_inet_check_ipaddress(const char *host)
2179 struct addrinfo hints;
2180 struct addrinfo *addr;
2183 memset(&hints, 0, sizeof(struct addrinfo));
2184 hints.ai_flags = AI_NUMERICHOST;
2187 result = getaddrinfo(host, NULL, &hints, &addr);
2189 result = addr->ai_family;
2197 /* Check routine modified from ics-dhcp 4.2.3-P2 */
2198 connman_bool_t connman_inet_check_hostname(const char *ptr, size_t len)
2203 * Not empty or complete length not over 255 characters.
2205 if ((len == 0) || (len > 256))
2209 * Consists of [[:alnum:]-]+ labels separated by [.]
2210 * a [_] is against RFC but seems to be "widely used"
2212 for (p = ptr; (*p != 0) && (len-- > 0); p++) {
2214 if ((*p == '-') || (*p == '_')) {
2216 * Not allowed at begin or end of a label.
2218 if (((p - ptr) == 0) || (len == 0) || (p[1] == '.'))
2221 } else if (*p == '.') {
2223 * Each label has to be 1-63 characters;
2224 * we allow [.] at the end ('foo.bar.')
2228 if ((d <= 0) || (d >= 64))
2231 ptr = p + 1; /* Jump to the next label */
2233 } else if (isalnum((unsigned char)*p) == 0) {
2235 * Also numbers at the begin are fine