src/inet.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   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
   8  *
   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.
  12  *
  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.
  17  *
  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
  21  *
  22  */
  23
  24 #ifdef HAVE_CONFIG_H
  25 #include <config.h>
  26 #endif
  27
  28 #define _GNU_SOURCE
  29 #include <stdio.h>
  30 #include <errno.h>
  31 #include <unistd.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <sys/stat.h>
  35 #include <sys/ioctl.h>
  36 #include <sys/socket.h>
  37 #include <linux/sockios.h>
  38 #include <netdb.h>
  39 #include <arpa/inet.h>
  40 #include <net/route.h>
  41 #include <net/ethernet.h>
  42 #include <net/if.h>
  43 #include <net/if_arp.h>
  44 #include <netinet/icmp6.h>
  45 #include <fcntl.h>
  46 #include <linux/if_tun.h>
  47 #include <ctype.h>
  48
  49 #include "connman.h"
  50
  51 #define NLMSG_TAIL(nmsg)                                \
  52         ((struct rtattr *) (((uint8_t*) (nmsg)) +       \
  53         NLMSG_ALIGN((nmsg)->nlmsg_len)))
  54
  55 int __connman_inet_rtnl_addattr_l(struct nlmsghdr *n, size_t max_length,
  56                                 int type, const void *data, size_t data_length)
  57 {
  58         size_t length;
  59         struct rtattr *rta;
  60
  61         length = RTA_LENGTH(data_length);
  62
  63         if (NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(length) > max_length)
  64                 return -E2BIG;
  65
  66         rta = NLMSG_TAIL(n);
  67         rta->rta_type = type;
  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);
  71
  72         return 0;
  73 }
  74
  75 int __connman_inet_modify_address(int cmd, int flags,
  76                                 int index, int family,
  77                                 const char *address,
  78                                 const char *peer,
  79                                 unsigned char prefixlen,
  80                                 const char *broadcast)
  81 {
  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))];
  86
  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;
  92         int sk, err;
  93
  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);
  97
  98         if (address == NULL)
  99                 return -EINVAL;
 100
 101         if (family != AF_INET && family != AF_INET6)
 102                 return -EINVAL;
 103
 104         memset(&request, 0, sizeof(request));
 105
 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;
 111
 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;
 118
 119         if (family == AF_INET) {
 120                 if (inet_pton(AF_INET, address, &ipv4_addr) < 1)
 121                         return -1;
 122
 123                 if (broadcast != NULL)
 124                         inet_pton(AF_INET, broadcast, &ipv4_bcast);
 125                 else
 126                         ipv4_bcast.s_addr = ipv4_addr.s_addr |
 127                                 htonl(0xfffffffflu >> prefixlen);
 128
 129                 if (peer != NULL) {
 130                         if (inet_pton(AF_INET, peer, &ipv4_dest) < 1)
 131                                 return -1;
 132
 133                         err = __connman_inet_rtnl_addattr_l(header,
 134                                                         sizeof(request),
 135                                                         IFA_ADDRESS,
 136                                                         &ipv4_dest,
 137                                                         sizeof(ipv4_dest));
 138                         if (err < 0)
 139                                 return err;
 140                 }
 141
 142                 err = __connman_inet_rtnl_addattr_l(header,
 143                                                 sizeof(request),
 144                                                 IFA_LOCAL,
 145                                                 &ipv4_addr,
 146                                                 sizeof(ipv4_addr));
 147                 if (err < 0)
 148                         return err;
 149
 150                 err = __connman_inet_rtnl_addattr_l(header,
 151                                                 sizeof(request),
 152                                                 IFA_BROADCAST,
 153                                                 &ipv4_bcast,
 154                                                 sizeof(ipv4_bcast));
 155                 if (err < 0)
 156                         return err;
 157
 158         } else if (family == AF_INET6) {
 159                 if (inet_pton(AF_INET6, address, &ipv6_addr) < 1)
 160                         return -1;
 161
 162                 err = __connman_inet_rtnl_addattr_l(header,
 163                                                 sizeof(request),
 164                                                 IFA_LOCAL,
 165                                                 &ipv6_addr,
 166                                                 sizeof(ipv6_addr));
 167                 if (err < 0)
 168                         return err;
 169         }
 170
 171         sk = socket(AF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_ROUTE);
 172         if (sk < 0)
 173                 return -errno;
 174
 175         memset(&nl_addr, 0, sizeof(nl_addr));
 176         nl_addr.nl_family = AF_NETLINK;
 177
 178         if ((err = sendto(sk, request, header->nlmsg_len, 0,
 179                         (struct sockaddr *) &nl_addr, sizeof(nl_addr))) < 0)
 180                 goto done;
 181
 182         err = 0;
 183
 184 done:
 185         close(sk);
 186
 187         return err;
 188 }
 189
 190 int connman_inet_ifindex(const char *name)
 191 {
 192         struct ifreq ifr;
 193         int sk, err;
 194
 195         if (name == NULL)
 196                 return -1;
 197
 198         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 199         if (sk < 0)
 200                 return -1;
 201
 202         memset(&ifr, 0, sizeof(ifr));
 203         strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
 204
 205         err = ioctl(sk, SIOCGIFINDEX, &ifr);
 206
 207         close(sk);
 208
 209         if (err < 0)
 210                 return -1;
 211
 212         return ifr.ifr_ifindex;
 213 }
 214
 215 char *connman_inet_ifname(int index)
 216 {
 217         struct ifreq ifr;
 218         int sk, err;
 219
 220         if (index < 0)
 221                 return NULL;
 222
 223         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 224         if (sk < 0)
 225                 return NULL;
 226
 227         memset(&ifr, 0, sizeof(ifr));
 228         ifr.ifr_ifindex = index;
 229
 230         err = ioctl(sk, SIOCGIFNAME, &ifr);
 231
 232         close(sk);
 233
 234         if (err < 0)
 235                 return NULL;
 236
 237         return strdup(ifr.ifr_name);
 238 }
 239
 240 short int connman_inet_ifflags(int index)
 241 {
 242         struct ifreq ifr;
 243         int sk, err;
 244
 245         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 246         if (sk < 0)
 247                 return -errno;
 248
 249         memset(&ifr, 0, sizeof(ifr));
 250         ifr.ifr_ifindex = index;
 251
 252         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 253                 err = -errno;
 254                 goto done;
 255         }
 256
 257         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 258                 err = -errno;
 259                 goto done;
 260         }
 261
 262         err = ifr.ifr_flags;
 263
 264 done:
 265         close(sk);
 266
 267         return err;
 268 }
 269
 270 int connman_inet_ifup(int index)
 271 {
 272         struct ifreq ifr;
 273         int sk, err;
 274
 275         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 276         if (sk < 0)
 277                 return -errno;
 278
 279         memset(&ifr, 0, sizeof(ifr));
 280         ifr.ifr_ifindex = index;
 281
 282         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 283                 err = -errno;
 284                 goto done;
 285         }
 286
 287         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 288                 err = -errno;
 289                 goto done;
 290         }
 291
 292         if (ifr.ifr_flags & IFF_UP) {
 293                 err = -EALREADY;
 294                 goto done;
 295         }
 296
 297         ifr.ifr_flags |= (IFF_UP|IFF_DYNAMIC);
 298
 299         if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0) {
 300                 err = -errno;
 301                 goto done;
 302         }
 303
 304         err = 0;
 305
 306 done:
 307         close(sk);
 308
 309         return err;
 310 }
 311
 312 int connman_inet_ifdown(int index)
 313 {
 314         struct ifreq ifr, addr_ifr;
 315         struct sockaddr_in *addr;
 316         int sk, err;
 317
 318         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 319         if (sk < 0)
 320                 return -errno;
 321
 322         memset(&ifr, 0, sizeof(ifr));
 323         ifr.ifr_ifindex = index;
 324
 325         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 326                 err = -errno;
 327                 goto done;
 328         }
 329
 330         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 331                 err = -errno;
 332                 goto done;
 333         }
 334
 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);
 341
 342         if (!(ifr.ifr_flags & IFF_UP)) {
 343                 err = -EALREADY;
 344                 goto done;
 345         }
 346
 347         ifr.ifr_flags = (ifr.ifr_flags & ~IFF_UP) | IFF_DYNAMIC;
 348
 349         if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0)
 350                 err = -errno;
 351         else
 352                 err = 0;
 353
 354 done:
 355         close(sk);
 356
 357         return err;
 358 }
 359
 360 static char *index2addr(int index)
 361 {
 362         struct ifreq ifr;
 363         struct ether_addr eth;
 364         char *str;
 365         int sk, err;
 366
 367         if (index < 0)
 368                 return NULL;
 369
 370         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 371         if (sk < 0)
 372                 return NULL;
 373
 374         memset(&ifr, 0, sizeof(ifr));
 375         ifr.ifr_ifindex = index;
 376
 377         err = ioctl(sk, SIOCGIFNAME, &ifr);
 378
 379         if (err == 0)
 380                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
 381
 382         close(sk);
 383
 384         if (err < 0)
 385                 return NULL;
 386
 387         str = malloc(18);
 388         if (!str)
 389                 return NULL;
 390
 391         memcpy(&eth, &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]);
 399
 400         return str;
 401 }
 402
 403 static char *index2ident(int index, const char *prefix)
 404 {
 405         struct ifreq ifr;
 406         struct ether_addr eth;
 407         char *str;
 408         int sk, err, len;
 409
 410         if (index < 0)
 411                 return NULL;
 412
 413         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 414         if (sk < 0)
 415                 return NULL;
 416
 417         memset(&ifr, 0, sizeof(ifr));
 418         ifr.ifr_ifindex = index;
 419
 420         err = ioctl(sk, SIOCGIFNAME, &ifr);
 421
 422         if (err == 0)
 423                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
 424
 425         close(sk);
 426
 427         if (err < 0)
 428                 return NULL;
 429
 430         len = prefix ? strlen(prefix) + 18 : 18;
 431
 432         str = malloc(len);
 433         if (!str)
 434                 return NULL;
 435
 436         memcpy(&eth, &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]);
 445
 446         return str;
 447 }
 448
 449 connman_bool_t connman_inet_is_cfg80211(int index)
 450 {
 451         connman_bool_t result = FALSE;
 452         char phy80211_path[PATH_MAX];
 453         struct stat st;
 454         struct ifreq ifr;
 455         int sk;
 456
 457         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 458         if (sk < 0)
 459                 return FALSE;
 460
 461         memset(&ifr, 0, sizeof(ifr));
 462         ifr.ifr_ifindex = index;
 463
 464         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0)
 465                 goto done;
 466
 467         snprintf(phy80211_path, PATH_MAX,
 468                                 "/sys/class/net/%s/phy80211", ifr.ifr_name);
 469
 470         if (stat(phy80211_path, &st) == 0 && (st.st_mode & S_IFDIR))
 471                 result = TRUE;
 472
 473 done:
 474         close(sk);
 475
 476         return result;
 477 }
 478
 479 struct connman_device *connman_inet_create_device(int index)
 480 {
 481         enum connman_device_type type;
 482         struct connman_device *device;
 483         char *devname, *ident = NULL;
 484         char *addr = NULL, *name = NULL;
 485
 486         if (index < 0)
 487                 return NULL;
 488
 489         devname = connman_inet_ifname(index);
 490         if (devname == NULL)
 491                 return NULL;
 492
 493         if (__connman_device_isfiltered(devname) == TRUE) {
 494                 connman_info("Ignoring interface %s (filtered)", devname);
 495                 free(devname);
 496                 return NULL;
 497         }
 498
 499         type = __connman_rtnl_get_device_type(index);
 500
 501         switch (type) {
 502         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 503                 connman_info("Ignoring interface %s (type unknown)", devname);
 504                 free(devname);
 505                 return NULL;
 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);
 512                 break;
 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);
 518                 break;
 519         }
 520
 521         device = connman_device_create(name, type);
 522         if (device == NULL)
 523                 goto done;
 524
 525         switch (type) {
 526         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 527         case CONNMAN_DEVICE_TYPE_VENDOR:
 528         case CONNMAN_DEVICE_TYPE_GPS:
 529                 break;
 530         case CONNMAN_DEVICE_TYPE_ETHERNET:
 531         case CONNMAN_DEVICE_TYPE_GADGET:
 532                 ident = index2ident(index, NULL);
 533                 break;
 534         case CONNMAN_DEVICE_TYPE_WIFI:
 535         case CONNMAN_DEVICE_TYPE_WIMAX:
 536                 ident = index2ident(index, NULL);
 537                 break;
 538         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 539                 break;
 540         case CONNMAN_DEVICE_TYPE_CELLULAR:
 541                 ident = index2ident(index, NULL);
 542                 break;
 543         }
 544
 545         connman_device_set_index(device, index);
 546         connman_device_set_interface(device, devname);
 547
 548         if (ident != NULL) {
 549                 connman_device_set_ident(device, ident);
 550                 free(ident);
 551         }
 552
 553         connman_device_set_string(device, "Address", addr);
 554
 555 done:
 556         free(devname);
 557         free(name);
 558         free(addr);
 559
 560         return device;
 561 }
 562
 563 struct in6_ifreq {
 564         struct in6_addr ifr6_addr;
 565         __u32 ifr6_prefixlen;
 566         unsigned int ifr6_ifindex;
 567 };
 568
 569 int connman_inet_set_ipv6_address(int index,
 570                 struct connman_ipaddress *ipaddress)
 571 {
 572         int err;
 573         unsigned char prefix_len;
 574         const char *address;
 575
 576         if (ipaddress->local == NULL)
 577                 return 0;
 578
 579         prefix_len = ipaddress->prefixlen;
 580         address = ipaddress->local;
 581
 582         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 583
 584         err = __connman_inet_modify_address(RTM_NEWADDR,
 585                                 NLM_F_REPLACE | NLM_F_ACK, index, AF_INET6,
 586                                 address, NULL, prefix_len, NULL);
 587         if (err < 0) {
 588                 connman_error("%s: %s", __func__, strerror(-err));
 589                 return err;
 590         }
 591
 592         return 0;
 593 }
 594
 595 int connman_inet_set_address(int index, struct connman_ipaddress *ipaddress)
 596 {
 597         int err;
 598         unsigned char prefix_len;
 599         const char *address, *broadcast, *peer;
 600
 601         if (ipaddress->local == NULL)
 602                 return -1;
 603
 604         prefix_len = ipaddress->prefixlen;
 605         address = ipaddress->local;
 606         broadcast = ipaddress->broadcast;
 607         peer = ipaddress->peer;
 608
 609         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 610
 611         err = __connman_inet_modify_address(RTM_NEWADDR,
 612                                 NLM_F_REPLACE | NLM_F_ACK, index, AF_INET,
 613                                 address, peer, prefix_len, broadcast);
 614         if (err < 0) {
 615                 connman_error("%s: %s", __func__, strerror(-err));
 616                 return err;
 617         }
 618
 619         return 0;
 620 }
 621
 622 int connman_inet_clear_ipv6_address(int index, const char *address,
 623                                                         int prefix_len)
 624 {
 625         int err;
 626
 627         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 628
 629         err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET6,
 630                                 address, NULL, prefix_len, NULL);
 631         if (err < 0) {
 632                 connman_error("%s: %s", __func__, strerror(-err));
 633                 return err;
 634         }
 635
 636         return 0;
 637 }
 638
 639 int connman_inet_clear_address(int index, struct connman_ipaddress *ipaddress)
 640 {
 641         int err;
 642         unsigned char prefix_len;
 643         const char *address, *broadcast, *peer;
 644
 645         prefix_len = ipaddress->prefixlen;
 646         address = ipaddress->local;
 647         broadcast = ipaddress->broadcast;
 648         peer = ipaddress->peer;
 649
 650         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 651
 652         err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET,
 653                                 address, peer, prefix_len, broadcast);
 654         if (err < 0) {
 655                 connman_error("%s: %s", __func__, strerror(-err));
 656                 return err;
 657         }
 658
 659         return 0;
 660 }
 661
 662 int connman_inet_add_host_route(int index, const char *host,
 663                                 const char *gateway)
 664 {
 665         return connman_inet_add_network_route(index, host, gateway, NULL);
 666 }
 667
 668 int connman_inet_del_host_route(int index, const char *host)
 669 {
 670         return connman_inet_del_network_route(index, host);
 671 }
 672
 673 int connman_inet_add_network_route(int index, const char *host,
 674                                         const char *gateway,
 675                                         const char *netmask)
 676 {
 677         struct ifreq ifr;
 678         struct rtentry rt;
 679         struct sockaddr_in addr;
 680         int sk, err;
 681
 682         DBG("index %d host %s gateway %s netmask %s", index,
 683                 host, gateway, netmask);
 684
 685         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 686         if (sk < 0)
 687                 return -1;
 688
 689         memset(&ifr, 0, sizeof(ifr));
 690         ifr.ifr_ifindex = index;
 691
 692         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 693                 close(sk);
 694                 return -1;
 695         }
 696
 697         DBG("ifname %s", ifr.ifr_name);
 698
 699         memset(&rt, 0, sizeof(rt));
 700         rt.rt_flags = RTF_UP;
 701         if (gateway != NULL)
 702                 rt.rt_flags |= RTF_GATEWAY;
 703         if (netmask == NULL)
 704                 rt.rt_flags |= RTF_HOST;
 705
 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));
 710
 711         memset(&addr, 0, sizeof(addr));
 712         addr.sin_family = AF_INET;
 713         if (gateway != NULL)
 714                 addr.sin_addr.s_addr = inet_addr(gateway);
 715         else
 716                 addr.sin_addr.s_addr = INADDR_ANY;
 717         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 718
 719         memset(&addr, 0, sizeof(addr));
 720         addr.sin_family = AF_INET;
 721         addr.sin_addr.s_addr = INADDR_ANY;
 722         if (netmask != NULL)
 723                 addr.sin_addr.s_addr = inet_addr(netmask);
 724         else
 725                 addr.sin_addr.s_addr = INADDR_ANY;
 726         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 727
 728         rt.rt_dev = ifr.ifr_name;
 729
 730         err = ioctl(sk, SIOCADDRT, &rt);
 731         if (err < 0)
 732                 connman_error("Adding host route failed (%s)",
 733                                                         strerror(errno));
 734
 735         close(sk);
 736
 737         return err;
 738 }
 739
 740 int connman_inet_del_network_route(int index, const char *host)
 741 {
 742         struct ifreq ifr;
 743         struct rtentry rt;
 744         struct sockaddr_in addr;
 745         int sk, err;
 746
 747         DBG("index %d host %s", index, host);
 748
 749         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 750         if (sk < 0)
 751                 return -1;
 752
 753         memset(&ifr, 0, sizeof(ifr));
 754         ifr.ifr_ifindex = index;
 755
 756         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 757                 close(sk);
 758                 return -1;
 759         }
 760
 761         DBG("ifname %s", ifr.ifr_name);
 762
 763         memset(&rt, 0, sizeof(rt));
 764         rt.rt_flags = RTF_UP | RTF_HOST;
 765
 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));
 770
 771         rt.rt_dev = ifr.ifr_name;
 772
 773         err = ioctl(sk, SIOCDELRT, &rt);
 774         if (err < 0)
 775                 connman_error("Deleting host route failed (%s)",
 776                                                         strerror(errno));
 777
 778         close(sk);
 779
 780         return err;
 781 }
 782
 783 int connman_inet_del_ipv6_network_route(int index, const char *host,
 784                                                 unsigned char prefix_len)
 785 {
 786         struct in6_rtmsg rt;
 787         int sk, err;
 788
 789         DBG("index %d host %s", index, host);
 790
 791         if (host == NULL)
 792                 return -EINVAL;
 793
 794         memset(&rt, 0, sizeof(rt));
 795
 796         rt.rtmsg_dst_len = prefix_len;
 797
 798         err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
 799         if (err < 0)
 800                 goto out;
 801
 802         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 803
 804         rt.rtmsg_metric = 1;
 805         rt.rtmsg_ifindex = index;
 806
 807         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 808         if (sk < 0) {
 809                 err = -1;
 810                 goto out;
 811         }
 812
 813         err = ioctl(sk, SIOCDELRT, &rt);
 814         close(sk);
 815 out:
 816         if (err < 0)
 817                 connman_error("Del IPv6 host route error (%s)",
 818                                                 strerror(errno));
 819
 820         return err;
 821 }
 822
 823 int connman_inet_del_ipv6_host_route(int index, const char *host)
 824 {
 825         return connman_inet_del_ipv6_network_route(index, host, 128);
 826 }
 827
 828 int connman_inet_add_ipv6_network_route(int index, const char *host,
 829                                         const char *gateway,
 830                                         unsigned char prefix_len)
 831 {
 832         struct in6_rtmsg rt;
 833         int sk, err;
 834
 835         DBG("index %d host %s gateway %s", index, host, gateway);
 836
 837         if (host == NULL)
 838                 return -EINVAL;
 839
 840         memset(&rt, 0, sizeof(rt));
 841
 842         rt.rtmsg_dst_len = prefix_len;
 843
 844         err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
 845         if (err < 0)
 846                 goto out;
 847
 848         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 849
 850         if (gateway != NULL) {
 851                 rt.rtmsg_flags |= RTF_GATEWAY;
 852                 inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 853         }
 854
 855         rt.rtmsg_metric = 1;
 856         rt.rtmsg_ifindex = index;
 857
 858         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 859         if (sk < 0) {
 860                 err = -1;
 861                 goto out;
 862         }
 863
 864         err = ioctl(sk, SIOCADDRT, &rt);
 865         close(sk);
 866 out:
 867         if (err < 0)
 868                 connman_error("Set IPv6 host route error (%s)",
 869                                                 strerror(errno));
 870
 871         return err;
 872 }
 873
 874 int connman_inet_add_ipv6_host_route(int index, const char *host,
 875                                         const char *gateway)
 876 {
 877         return connman_inet_add_ipv6_network_route(index, host, gateway, 128);
 878 }
 879
 880 int connman_inet_set_ipv6_gateway_address(int index, const char *gateway)
 881 {
 882         struct in6_rtmsg rt;
 883         int sk, err;
 884
 885         DBG("index %d gateway %s", index, gateway);
 886
 887         if (gateway == NULL)
 888                 return -EINVAL;
 889
 890         memset(&rt, 0, sizeof(rt));
 891
 892         err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 893         if (err < 0)
 894                 goto out;
 895
 896         rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
 897         rt.rtmsg_metric = 1;
 898         rt.rtmsg_dst_len = 0;
 899         rt.rtmsg_ifindex = index;
 900
 901         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 902         if (sk < 0) {
 903                 err = -1;
 904                 goto out;
 905         }
 906
 907         err = ioctl(sk, SIOCADDRT, &rt);
 908         close(sk);
 909 out:
 910         if (err < 0)
 911                 connman_error("Set default IPv6 gateway error (%s)",
 912                                                 strerror(errno));
 913
 914         return err;
 915 }
 916
 917 int connman_inet_clear_ipv6_gateway_address(int index, const char *gateway)
 918 {
 919         struct in6_rtmsg rt;
 920         int sk, err;
 921
 922         DBG("index %d gateway %s", index, gateway);
 923
 924         if (gateway == NULL)
 925                 return -EINVAL;
 926
 927         memset(&rt, 0, sizeof(rt));
 928
 929         err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 930         if (err < 0)
 931                 goto out;
 932
 933         rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
 934         rt.rtmsg_metric = 1;
 935         rt.rtmsg_dst_len = 0;
 936         rt.rtmsg_ifindex = index;
 937
 938         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 939         if (sk < 0) {
 940                 err = -1;
 941                 goto out;
 942         }
 943
 944         err = ioctl(sk, SIOCDELRT, &rt);
 945         close(sk);
 946 out:
 947         if (err < 0)
 948                 connman_error("Clear default IPv6 gateway error (%s)",
 949                                                 strerror(errno));
 950
 951         return err;
 952 }
 953
 954 int connman_inet_set_gateway_address(int index, const char *gateway)
 955 {
 956         struct ifreq ifr;
 957         struct rtentry rt;
 958         struct sockaddr_in addr;
 959         int sk, err;
 960
 961         DBG("index %d gateway %s", index, gateway);
 962
 963         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 964         if (sk < 0)
 965                 return -1;
 966
 967         memset(&ifr, 0, sizeof(ifr));
 968         ifr.ifr_ifindex = index;
 969
 970         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 971                 close(sk);
 972                 return -1;
 973         }
 974
 975         DBG("ifname %s", ifr.ifr_name);
 976
 977         memset(&rt, 0, sizeof(rt));
 978         rt.rt_flags = RTF_UP | RTF_GATEWAY;
 979
 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));
 984
 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));
 989
 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));
 994
 995         err = ioctl(sk, SIOCADDRT, &rt);
 996         if (err < 0)
 997                 connman_error("Setting default gateway route failed (%s)",
 998                                                         strerror(errno));
 999
1000         close(sk);
1001
1002         return err;
1003 }
1004
1005 int connman_inet_set_gateway_interface(int index)
1006 {
1007         struct ifreq ifr;
1008         struct rtentry rt;
1009         struct sockaddr_in addr;
1010         int sk, err;
1011
1012         DBG("index %d", index);
1013
1014         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1015         if (sk < 0)
1016                 return -1;
1017
1018         memset(&ifr, 0, sizeof(ifr));
1019         ifr.ifr_ifindex = index;
1020
1021         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1022                 close(sk);
1023                 return -1;
1024         }
1025
1026         DBG("ifname %s", ifr.ifr_name);
1027
1028         memset(&rt, 0, sizeof(rt));
1029         rt.rt_flags = RTF_UP;
1030
1031         memset(&addr, 0, sizeof(addr));
1032         addr.sin_family = AF_INET;
1033         addr.sin_addr.s_addr = INADDR_ANY;
1034
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));
1038
1039         rt.rt_dev = ifr.ifr_name;
1040
1041         err = ioctl(sk, SIOCADDRT, &rt);
1042         if (err < 0)
1043                 connman_error("Setting default interface route failed (%s)",
1044                                                         strerror(errno));
1045         close(sk);
1046
1047         return err;
1048 }
1049
1050 int connman_inet_set_ipv6_gateway_interface(int index)
1051 {
1052         struct ifreq ifr;
1053         struct rtentry rt;
1054         struct sockaddr_in6 addr;
1055         const struct in6_addr any = IN6ADDR_ANY_INIT;
1056         int sk, err;
1057
1058         DBG("index %d", index);
1059
1060         sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1061         if (sk < 0)
1062                 return -1;
1063
1064         memset(&ifr, 0, sizeof(ifr));
1065         ifr.ifr_ifindex = index;
1066
1067         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1068                 close(sk);
1069                 return -1;
1070         }
1071
1072         DBG("ifname %s", ifr.ifr_name);
1073
1074         memset(&rt, 0, sizeof(rt));
1075         rt.rt_flags = RTF_UP;
1076
1077         memset(&addr, 0, sizeof(addr));
1078         addr.sin6_family = AF_INET6;
1079         addr.sin6_addr = any;
1080
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));
1084
1085         rt.rt_dev = ifr.ifr_name;
1086
1087         err = ioctl(sk, SIOCADDRT, &rt);
1088         if (err < 0)
1089                 connman_error("Setting default interface route failed (%s)",
1090                                                         strerror(errno));
1091         close(sk);
1092
1093         return err;
1094 }
1095
1096 int connman_inet_clear_gateway_address(int index, const char *gateway)
1097 {
1098         struct ifreq ifr;
1099         struct rtentry rt;
1100         struct sockaddr_in addr;
1101         int sk, err;
1102
1103         DBG("index %d gateway %s", index, gateway);
1104
1105         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1106         if (sk < 0)
1107                 return -1;
1108
1109         memset(&ifr, 0, sizeof(ifr));
1110         ifr.ifr_ifindex = index;
1111
1112         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1113                 close(sk);
1114                 return -1;
1115         }
1116
1117         DBG("ifname %s", ifr.ifr_name);
1118
1119         memset(&rt, 0, sizeof(rt));
1120         rt.rt_flags = RTF_UP | RTF_GATEWAY;
1121
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));
1126
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));
1131
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));
1136
1137         err = ioctl(sk, SIOCDELRT, &rt);
1138         if (err < 0)
1139                 connman_error("Removing default gateway route failed (%s)",
1140                                                         strerror(errno));
1141
1142         close(sk);
1143
1144         return err;
1145 }
1146
1147 int connman_inet_clear_gateway_interface(int index)
1148 {
1149         struct ifreq ifr;
1150         struct rtentry rt;
1151         struct sockaddr_in addr;
1152         int sk, err;
1153
1154         DBG("index %d", index);
1155
1156         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1157         if (sk < 0)
1158                 return -1;
1159
1160         memset(&ifr, 0, sizeof(ifr));
1161         ifr.ifr_ifindex = index;
1162
1163         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1164                 close(sk);
1165                 return -1;
1166         }
1167
1168         DBG("ifname %s", ifr.ifr_name);
1169
1170         memset(&rt, 0, sizeof(rt));
1171         rt.rt_flags = RTF_UP;
1172
1173         memset(&addr, 0, sizeof(addr));
1174         addr.sin_family = AF_INET;
1175         addr.sin_addr.s_addr = INADDR_ANY;
1176
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));
1180
1181         rt.rt_dev = ifr.ifr_name;
1182
1183         err = ioctl(sk, SIOCDELRT, &rt);
1184         if (err < 0)
1185                 connman_error("Removing default interface route failed (%s)",
1186                                                         strerror(errno));
1187         close(sk);
1188
1189         return err;
1190 }
1191
1192 int connman_inet_clear_ipv6_gateway_interface(int index)
1193 {
1194         struct ifreq ifr;
1195         struct rtentry rt;
1196         struct sockaddr_in6 addr;
1197         const struct in6_addr any = IN6ADDR_ANY_INIT;
1198         int sk, err;
1199
1200         DBG("index %d", index);
1201
1202         sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1203         if (sk < 0)
1204                 return -1;
1205
1206         memset(&ifr, 0, sizeof(ifr));
1207         ifr.ifr_ifindex = index;
1208
1209         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1210                 close(sk);
1211                 return -1;
1212         }
1213
1214         DBG("ifname %s", ifr.ifr_name);
1215
1216         memset(&rt, 0, sizeof(rt));
1217         rt.rt_flags = RTF_UP;
1218
1219         memset(&addr, 0, sizeof(addr));
1220         addr.sin6_family = AF_INET6;
1221         addr.sin6_addr = any;
1222
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));
1226
1227         rt.rt_dev = ifr.ifr_name;
1228
1229         err = ioctl(sk, SIOCDELRT, &rt);
1230         if (err < 0)
1231                 connman_error("Removing default interface route failed (%s)",
1232                                                         strerror(errno));
1233         close(sk);
1234
1235         return err;
1236 }
1237
1238 connman_bool_t connman_inet_compare_subnet(int index, const char *host)
1239 {
1240         struct ifreq ifr;
1241         struct in_addr _host_addr;
1242         in_addr_t host_addr, netmask_addr, if_addr;
1243         struct sockaddr_in *netmask, *addr;
1244         int sk;
1245
1246         DBG("host %s", host);
1247
1248         if (host == NULL)
1249                 return FALSE;
1250
1251         if (inet_aton(host, &_host_addr) == 0)
1252                 return -1;
1253         host_addr = _host_addr.s_addr;
1254
1255         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1256         if (sk < 0)
1257                 return FALSE;
1258
1259         memset(&ifr, 0, sizeof(ifr));
1260         ifr.ifr_ifindex = index;
1261
1262         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1263                 close(sk);
1264                 return FALSE;
1265         }
1266
1267         if (ioctl(sk, SIOCGIFNETMASK, &ifr) < 0) {
1268                 close(sk);
1269                 return FALSE;
1270         }
1271
1272         netmask = (struct sockaddr_in *)&ifr.ifr_netmask;
1273         netmask_addr = netmask->sin_addr.s_addr;
1274
1275         if (ioctl(sk, SIOCGIFADDR, &ifr) < 0) {
1276                 close(sk);
1277                 return FALSE;
1278         }
1279
1280         close(sk);
1281
1282         addr = (struct sockaddr_in *)&ifr.ifr_addr;
1283         if_addr = addr->sin_addr.s_addr;
1284
1285         return ((if_addr & netmask_addr) == (host_addr & netmask_addr));
1286 }
1287
1288 int connman_inet_remove_from_bridge(int index, const char *bridge)
1289 {
1290         struct ifreq ifr;
1291         int sk, err;
1292
1293         if (bridge == NULL)
1294                 return -EINVAL;
1295
1296         sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
1297         if (sk < 0)
1298                 return sk;
1299
1300         memset(&ifr, 0, sizeof(ifr));
1301         strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1302         ifr.ifr_ifindex = index;
1303
1304         err = ioctl(sk, SIOCBRDELIF, &ifr);
1305
1306         close(sk);
1307
1308         if (err < 0) {
1309                 connman_error("Remove interface from bridge error %s",
1310                                                         strerror(errno));
1311                 return err;
1312         }
1313
1314         return 0;
1315 }
1316
1317 int connman_inet_add_to_bridge(int index, const char *bridge)
1318 {
1319         struct ifreq ifr;
1320         int sk, err;
1321
1322         if (bridge == NULL)
1323                 return -EINVAL;
1324
1325         sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
1326         if (sk < 0)
1327                 return sk;
1328
1329         memset(&ifr, 0, sizeof(ifr));
1330         strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1331         ifr.ifr_ifindex = index;
1332
1333         err = ioctl(sk, SIOCBRADDIF, &ifr);
1334
1335         close(sk);
1336
1337         if (err < 0) {
1338                 connman_error("Add interface to bridge error %s",
1339                                                         strerror(errno));
1340                 return err;
1341         }
1342
1343         return 0;
1344 }
1345
1346 int connman_inet_set_mtu(int index, int mtu)
1347 {
1348         struct ifreq ifr;
1349         int sk, err;
1350
1351         sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1352         if (sk < 0)
1353                 return sk;
1354
1355         memset(&ifr, 0, sizeof(ifr));
1356         ifr.ifr_ifindex = index;
1357
1358         err = ioctl(sk, SIOCGIFNAME, &ifr);
1359         if (err == 0) {
1360                 ifr.ifr_mtu = mtu;
1361                 err = ioctl(sk, SIOCSIFMTU, &ifr);
1362         }
1363
1364         close(sk);
1365         return err;
1366 }
1367
1368 int connman_inet_setup_tunnel(char *tunnel, int mtu)
1369 {
1370         struct ifreq ifr;
1371         int sk, err, index;
1372         __u32 mask;
1373         __u32 flags;
1374
1375         if (tunnel == NULL)
1376                 return -EINVAL;
1377
1378         sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1379         if (sk < 0)
1380                 return sk;
1381
1382         index = if_nametoindex(tunnel);
1383
1384         err = connman_inet_set_mtu(index, mtu);
1385         if (err < 0)
1386                 return err;
1387         else if (err)
1388                 goto done;
1389
1390         memset(&ifr, 0, sizeof(ifr));
1391         strncpy(ifr.ifr_name, tunnel, IFNAMSIZ);
1392         err = ioctl(sk, SIOCGIFFLAGS, &ifr);
1393         if (err)
1394                 goto done;
1395
1396         mask = IFF_UP;
1397         flags = IFF_UP;
1398
1399         if ((ifr.ifr_flags ^ flags) & mask) {
1400                 ifr.ifr_flags &= ~mask;
1401                 ifr.ifr_flags |= mask & flags;
1402                 err = ioctl(sk, SIOCSIFFLAGS, &ifr);
1403                 if (err)
1404                         connman_error("SIOCSIFFLAGS failed: %s",
1405                                                         strerror(errno));
1406         }
1407
1408 done:
1409         close(sk);
1410         return err;
1411 }
1412
1413 int connman_inet_create_tunnel(char **iface)
1414 {
1415         struct ifreq ifr;
1416         int i, fd;
1417
1418         fd = open("/dev/net/tun", O_RDWR | O_CLOEXEC);
1419         if (fd < 0) {
1420                 i = -errno;
1421                 connman_error("Failed to open /dev/net/tun: %s",
1422                                 strerror(errno));
1423                 return i;
1424         }
1425
1426         memset(&ifr, 0, sizeof(ifr));
1427         ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
1428
1429         for (i = 0; i < 256; i++) {
1430                 sprintf(ifr.ifr_name, "tun%d", i);
1431
1432                 if (!ioctl(fd, TUNSETIFF, (void *)&ifr))
1433                         break;
1434         }
1435
1436         if (i == 256) {
1437                 connman_error("Failed to find available tun device");
1438                 close(fd);
1439                 return -ENODEV;
1440         }
1441
1442         *iface = g_strdup(ifr.ifr_name);
1443
1444         return fd;
1445 }
1446
1447 struct rs_cb_data {
1448         GIOChannel *channel;
1449         __connman_inet_rs_cb_t callback;
1450         struct sockaddr_in6 addr;
1451         guint rs_timeout;
1452         guint watch_id;
1453         void *user_data;
1454 };
1455
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 */
1461
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;
1465
1466 static void rs_cleanup(struct rs_cb_data *data)
1467 {
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;
1472         }
1473
1474         if (data->rs_timeout > 0)
1475                 g_source_remove(data->rs_timeout);
1476
1477         if (data->watch_id > 0)
1478                 g_source_remove(data->watch_id);
1479
1480         g_free(data);
1481 }
1482
1483 static gboolean rs_timeout_cb(gpointer user_data)
1484 {
1485         struct rs_cb_data *data = user_data;
1486
1487         DBG("user data %p", user_data);
1488
1489         if (data == NULL)
1490                 return FALSE;
1491
1492         if (data->callback != NULL)
1493                 data->callback(NULL, 0, data->user_data);
1494
1495         data->rs_timeout = 0;
1496         rs_cleanup(data);
1497         return FALSE;
1498 }
1499
1500 static int icmpv6_recv(int fd, gpointer user_data)
1501 {
1502         struct msghdr mhdr;
1503         struct iovec iov;
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;
1509         ssize_t len;
1510
1511         DBG("");
1512
1513         iov.iov_len = sizeof(buf);
1514         iov.iov_base = buf;
1515
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;
1522
1523         len = recvmsg(fd, &mhdr, 0);
1524         if (len < 0) {
1525                 data->callback(NULL, 0, data->user_data);
1526                 rs_cleanup(data);
1527                 return -errno;
1528         }
1529
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)
1534                 return 0;
1535
1536         data->callback(hdr, len, data->user_data);
1537         rs_cleanup(data);
1538
1539         return len;
1540 }
1541
1542 static gboolean icmpv6_event(GIOChannel *chan, GIOCondition cond,
1543                                                                 gpointer data)
1544 {
1545         int fd, ret;
1546
1547         DBG("");
1548
1549         if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
1550                 return FALSE;
1551
1552         fd = g_io_channel_unix_get_fd(chan);
1553         ret = icmpv6_recv(fd, data);
1554         if (ret == 0)
1555                 return TRUE;
1556
1557         return FALSE;
1558 }
1559
1560 /* Adapted from RFC 1071 "C" Implementation Example */
1561 static uint16_t csum(const void *phdr, const void *data, socklen_t datalen)
1562 {
1563         register unsigned long sum = 0;
1564         socklen_t count;
1565         uint16_t *addr;
1566         int i;
1567
1568         /* caller must make sure datalen is even */
1569
1570         addr = (uint16_t *)phdr;
1571         for (i = 0; i < 20; i++)
1572                 sum += *addr++;
1573
1574         count = datalen;
1575         addr = (uint16_t *)data;
1576
1577         while (count > 1) {
1578                 sum += *(addr++);
1579                 count -= 2;
1580         }
1581
1582         while (sum >> 16)
1583                 sum = (sum & 0xffff) + (sum >> 16);
1584
1585         return (uint16_t)~sum;
1586 }
1587
1588 static int ndisc_send_unspec(int type, int oif, const struct in6_addr *dest)
1589 {
1590         struct _phdr {
1591                 struct in6_addr src;
1592                 struct in6_addr dst;
1593                 uint32_t plen;
1594                 uint8_t reserved[3];
1595                 uint8_t nxt;
1596         } phdr;
1597
1598         struct {
1599                 struct ip6_hdr ip;
1600                 union {
1601                         struct icmp6_hdr icmp;
1602                         struct nd_neighbor_solicit ns;
1603                         struct nd_router_solicit rs;
1604                 } i;
1605         } frame;
1606
1607         struct msghdr msgh;
1608         struct cmsghdr *cmsg;
1609         struct in6_pktinfo *pinfo;
1610         struct sockaddr_in6 dst;
1611         char cbuf[CMSG_SPACE(sizeof(*pinfo))];
1612         struct iovec iov;
1613         int fd, datalen, ret;
1614
1615         DBG("");
1616
1617         fd = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_RAW);
1618         if (fd < 0)
1619                 return -errno;
1620
1621         memset(&frame, 0, sizeof(frame));
1622         memset(&dst, 0, sizeof(dst));
1623
1624         datalen = sizeof(frame.i.rs); /* 8, csum() safe */
1625         dst.sin6_addr = *dest;
1626
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 */
1634
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;
1640
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);
1644
1645         iov.iov_base = &frame;
1646         iov.iov_len = sizeof(frame.ip) + datalen;
1647
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;
1653         msgh.msg_flags = 0;
1654
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;
1659
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;
1665
1666         ret = sendmsg(fd, &msgh, 0);
1667
1668         close(fd);
1669         return ret;
1670 }
1671
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)
1675 {
1676         addr->s6_addr32[0] = w1;
1677         addr->s6_addr32[1] = w2;
1678         addr->s6_addr32[2] = w3;
1679         addr->s6_addr32[3] = w4;
1680 }
1681
1682 static inline void ipv6_addr_solict_mult(const struct in6_addr *addr,
1683                                         struct in6_addr *solicited)
1684 {
1685         ipv6_addr_set(solicited, htonl(0xFF020000), 0, htonl(0x1),
1686                         htonl(0xFF000000) | addr->s6_addr32[3]);
1687 }
1688
1689 static int if_mc_group(int sock, int ifindex, const struct in6_addr *mc_addr,
1690                                                                 int cmd)
1691 {
1692         unsigned int val = 0;
1693         struct ipv6_mreq mreq;
1694         int ret;
1695
1696         memset(&mreq, 0, sizeof(mreq));
1697         mreq.ipv6mr_interface = ifindex;
1698         mreq.ipv6mr_multiaddr = *mc_addr;
1699
1700         ret = setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
1701                         &val, sizeof(int));
1702
1703         if (ret < 0)
1704                 return ret;
1705
1706         return setsockopt(sock, IPPROTO_IPV6, cmd, &mreq, sizeof(mreq));
1707 }
1708
1709 int __connman_inet_ipv6_send_rs(int index, int timeout,
1710                         __connman_inet_rs_cb_t callback, void *user_data)
1711 {
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;
1716         int sk;
1717
1718         DBG("");
1719
1720         if (timeout <= 0)
1721                 return -EINVAL;
1722
1723         data = g_try_malloc0(sizeof(struct rs_cb_data));
1724         if (data == NULL)
1725                 return -ENOMEM;
1726
1727         data->callback = callback;
1728         data->user_data = user_data;
1729         data->rs_timeout = g_timeout_add_seconds(timeout, rs_timeout_cb, data);
1730
1731         sk = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
1732         if (sk < 0)
1733                 return -errno;
1734
1735         ICMP6_FILTER_SETBLOCKALL(&filter);
1736         ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filter);
1737
1738         setsockopt(sk, IPPROTO_ICMPV6, ICMP6_FILTER, &filter,
1739                                                 sizeof(struct icmp6_filter));
1740
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);
1744
1745         data->channel = g_io_channel_unix_new(sk);
1746         g_io_channel_set_close_on_unref(data->channel, TRUE);
1747
1748         g_io_channel_set_encoding(data->channel, NULL, NULL);
1749         g_io_channel_set_buffered(data->channel, FALSE);
1750
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);
1754
1755         ndisc_send_unspec(ND_ROUTER_SOLICIT, index, &dst);
1756
1757         return 0;
1758 }
1759
1760 GSList *__connman_inet_ipv6_get_prefixes(struct nd_router_advert *hdr,
1761                                         unsigned int length)
1762 {
1763         GSList *prefixes = NULL;
1764         uint8_t *pos;
1765         int len;
1766
1767         if (length <= sizeof(struct nd_router_advert))
1768                 return NULL;
1769
1770         len = length - sizeof(struct nd_router_advert);
1771         pos = (uint8_t *)hdr + sizeof(struct nd_router_advert);
1772
1773         while (len > 0) {
1774                 struct nd_opt_prefix_info *pinfo;
1775                 char prefix_str[INET6_ADDRSTRLEN+1], *str;
1776                 const char *prefix;
1777                 int optlen;
1778
1779                 if (len < 2)
1780                         break;
1781
1782                 optlen = pos[1] << 3;
1783                 if (optlen == 0 || optlen > len)
1784                         break;
1785
1786                 switch (pos[0]) {
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);
1791                         if (prefix == NULL)
1792                                 break;
1793
1794                         str = g_strdup_printf("%s/%d", prefix,
1795                                                 pinfo->nd_opt_pi_prefix_len);
1796                         prefixes = g_slist_prepend(prefixes, str);
1797
1798                         DBG("prefix %s", str);
1799
1800                         break;
1801                 }
1802
1803                 len -= optlen;
1804                 pos += optlen;
1805         }
1806
1807         return prefixes;
1808 }
1809
1810 static int get_dest_addr(int family, int index, char *buf, int len)
1811 {
1812         struct ifreq ifr;
1813         void *addr;
1814         int sk;
1815
1816         sk = socket(family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1817         if (sk < 0)
1818                 return -errno;
1819
1820         memset(&ifr, 0, sizeof(ifr));
1821         ifr.ifr_ifindex = index;
1822
1823         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1824                 DBG("SIOCGIFNAME (%d/%s)", errno, strerror(errno));
1825                 close(sk);
1826                 return -errno;
1827         }
1828
1829         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
1830                 DBG("SIOCGIFFLAGS (%d/%s)", errno, strerror(errno));
1831                 close(sk);
1832                 return -errno;
1833         }
1834
1835         if ((ifr.ifr_flags & IFF_POINTOPOINT) == 0) {
1836                 close(sk);
1837                 errno = EINVAL;
1838                 return -errno;
1839         }
1840
1841         DBG("index %d %s", index, ifr.ifr_name);
1842
1843         if (ioctl(sk, SIOCGIFDSTADDR, &ifr) < 0) {
1844                 connman_error("Get destination address failed (%s)",
1845                                                         strerror(errno));
1846                 close(sk);
1847                 return -errno;
1848         }
1849
1850         close(sk);
1851
1852         switch (family) {
1853         case AF_INET:
1854                 addr = &((struct sockaddr_in *)&ifr.ifr_dstaddr)->sin_addr;
1855                 break;
1856         case AF_INET6:
1857                 addr = &((struct sockaddr_in6 *)&ifr.ifr_dstaddr)->sin6_addr;
1858                 break;
1859         default:
1860                 errno = EINVAL;
1861                 return -errno;
1862         }
1863
1864         if (inet_ntop(family, addr, buf, len) == NULL) {
1865                 DBG("error %d/%s", errno, strerror(errno));
1866                 return -errno;
1867         }
1868
1869         return 0;
1870 }
1871
1872 int connman_inet_get_dest_addr(int index, char **dest)
1873 {
1874         char addr[INET_ADDRSTRLEN];
1875         int ret;
1876
1877         ret = get_dest_addr(PF_INET, index, addr, INET_ADDRSTRLEN);
1878         if (ret < 0)
1879                 return ret;
1880
1881         *dest = g_strdup(addr);
1882
1883         DBG("destination %s", *dest);
1884
1885         return 0;
1886 }
1887
1888 int connman_inet_ipv6_get_dest_addr(int index, char **dest)
1889 {
1890         char addr[INET6_ADDRSTRLEN];
1891         int ret;
1892
1893         ret = get_dest_addr(PF_INET6, index, addr, INET6_ADDRSTRLEN);
1894         if (ret < 0)
1895                 return ret;
1896
1897         *dest = g_strdup(addr);
1898
1899         DBG("destination %s", *dest);
1900
1901         return 0;
1902 }
1903
1904 int __connman_inet_rtnl_open(struct __connman_inet_rtnl_handle *rth)
1905 {
1906         int sndbuf = 1024;
1907         int rcvbuf = 1024 * 4;
1908
1909         rth->fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
1910         if (rth->fd < 0) {
1911                 connman_error("Can not open netlink socket: %s",
1912                                                 strerror(errno));
1913                 return -errno;
1914         }
1915
1916         if (setsockopt(rth->fd, SOL_SOCKET, SO_SNDBUF, &sndbuf,
1917                         sizeof(sndbuf)) < 0) {
1918                 connman_error("SO_SNDBUF: %s", strerror(errno));
1919                 return -errno;
1920         }
1921
1922         if (setsockopt(rth->fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf,
1923                         sizeof(rcvbuf)) < 0) {
1924                 connman_error("SO_RCVBUF: %s", strerror(errno));
1925                 return -errno;
1926         }
1927
1928         memset(&rth->local, 0, sizeof(rth->local));
1929         rth->local.nl_family = AF_NETLINK;
1930         rth->local.nl_groups = 0;
1931
1932         if (bind(rth->fd, (struct sockaddr *)&rth->local,
1933                                                 sizeof(rth->local)) < 0) {
1934                 connman_error("Can not bind netlink socket: %s",
1935                                                         strerror(errno));
1936                 return -errno;
1937         }
1938
1939         rth->seq = time(NULL);
1940
1941         DBG("fd %d", rth->fd);
1942
1943         return 0;
1944 }
1945
1946 struct inet_rtnl_cb_data {
1947         GIOChannel *channel;
1948         __connman_inet_rtnl_cb_t callback;
1949         guint rtnl_timeout;
1950         guint watch_id;
1951         struct __connman_inet_rtnl_handle *rtnl;
1952         void *user_data;
1953 };
1954
1955 static void inet_rtnl_cleanup(struct inet_rtnl_cb_data *data)
1956 {
1957         struct __connman_inet_rtnl_handle *rth = data->rtnl;
1958
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;
1963         }
1964
1965         DBG("data %p", data);
1966
1967         if (data->rtnl_timeout > 0)
1968                 g_source_remove(data->rtnl_timeout);
1969
1970         if (data->watch_id > 0)
1971                 g_source_remove(data->watch_id);
1972
1973         if (rth != NULL) {
1974                 __connman_inet_rtnl_close(rth);
1975                 g_free(rth);
1976         }
1977
1978         g_free(data);
1979 }
1980
1981 static gboolean inet_rtnl_timeout_cb(gpointer user_data)
1982 {
1983         struct inet_rtnl_cb_data *data = user_data;
1984
1985         DBG("user data %p", user_data);
1986
1987         if (data == NULL)
1988                 return FALSE;
1989
1990         if (data->callback != NULL)
1991                 data->callback(NULL, data->user_data);
1992
1993         data->rtnl_timeout = 0;
1994         inet_rtnl_cleanup(data);
1995         return FALSE;
1996 }
1997
1998 static int inet_rtnl_recv(GIOChannel *chan, gpointer user_data)
1999 {
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];
2006         void *ptr = buf;
2007         gsize len;
2008         int status, fd;
2009
2010         memset(buf, 0, sizeof(buf));
2011         memset(&nladdr, 0, sizeof(nladdr));
2012
2013         fd = g_io_channel_unix_get_fd(chan);
2014
2015         status = recvfrom(fd, buf, sizeof(buf), 0,
2016                        (struct sockaddr *) &nladdr, &addr_len);
2017         if (status < 0) {
2018                 if (errno == EINTR || errno == EAGAIN)
2019                         return 0;
2020
2021                 return -1;
2022         }
2023
2024         if (status == 0)
2025                 return -1;
2026
2027         if (nladdr.nl_pid != 0) { /* not sent by kernel, ignore */
2028                 DBG("Received msg from %u, ignoring it", nladdr.nl_pid);
2029                 return 0;
2030         }
2031
2032         len = status;
2033
2034         while (len > 0) {
2035                 struct nlmsgerr *err;
2036
2037                 h = ptr;
2038
2039                 if (!NLMSG_OK(h, len)) {
2040                         return -1;
2041                         break;
2042                 }
2043
2044                 if (h->nlmsg_seq != rth->seq) {
2045                         /* Skip this msg */
2046                         DBG("skip %d/%d len %d", rth->seq,
2047                                 h->nlmsg_seq, h->nlmsg_len);
2048
2049                         len -= h->nlmsg_len;
2050                         ptr += h->nlmsg_len;
2051                         continue;
2052                 }
2053
2054                 switch (h->nlmsg_type) {
2055                 case NLMSG_NOOP:
2056                 case NLMSG_OVERRUN:
2057                         return -1;
2058
2059                 case NLMSG_ERROR:
2060                         err = (struct nlmsgerr *)NLMSG_DATA(h);
2061                         connman_error("RTNETLINK answers %s (%d)",
2062                                 strerror(-err->error), -err->error);
2063                         return err->error;
2064                 }
2065
2066                 break;
2067         }
2068
2069         if (h->nlmsg_seq == rth->seq) {
2070                 DBG("received %d seq %d", h->nlmsg_len, h->nlmsg_seq);
2071
2072                 rtnl_data->callback(h, rtnl_data->user_data);
2073
2074                 if (rtnl_data->rtnl_timeout > 0) {
2075                         g_source_remove(rtnl_data->rtnl_timeout);
2076                         rtnl_data->rtnl_timeout = 0;
2077                 }
2078
2079                 __connman_inet_rtnl_close(rth);
2080                 g_free(rth);
2081         }
2082
2083         return 0;
2084 }
2085
2086 static gboolean inet_rtnl_event(GIOChannel *chan, GIOCondition cond,
2087                                                         gpointer user_data)
2088 {
2089         int ret;
2090
2091         DBG("");
2092
2093         if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
2094                 return FALSE;
2095
2096         ret = inet_rtnl_recv(chan, user_data);
2097         if (ret != 0)
2098                 return TRUE;
2099
2100         return FALSE;
2101 }
2102
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)
2106 {
2107         struct sockaddr_nl nladdr;
2108         struct inet_rtnl_cb_data *data;
2109         unsigned seq;
2110         int err;
2111
2112         memset(&nladdr, 0, sizeof(nladdr));
2113         nladdr.nl_family = AF_NETLINK;
2114
2115         n->nlmsg_seq = seq = ++rtnl->seq;
2116
2117         if (callback != NULL) {
2118                 data = g_try_malloc0(sizeof(struct inet_rtnl_cb_data));
2119                 if (data == NULL)
2120                         return -ENOMEM;
2121
2122                 data->callback = callback;
2123                 data->user_data = user_data;
2124                 data->rtnl = rtnl;
2125                 data->rtnl_timeout = g_timeout_add_seconds(timeout,
2126                                                 inet_rtnl_timeout_cb, data);
2127
2128                 data->channel = g_io_channel_unix_new(rtnl->fd);
2129                 g_io_channel_set_close_on_unref(data->channel, TRUE);
2130
2131                 g_io_channel_set_encoding(data->channel, NULL, NULL);
2132                 g_io_channel_set_buffered(data->channel, FALSE);
2133
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);
2137         } else
2138                 n->nlmsg_flags |= NLM_F_ACK;
2139
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);
2143         if (err < 0) {
2144                 connman_error("Can not talk to rtnetlink");
2145                 return -errno;
2146         }
2147
2148         if ((unsigned int)err != rtnl->req.n.nlmsg_len) {
2149                 connman_error("Sent %d bytes, msg truncated", err);
2150                 return -EINVAL;
2151         }
2152
2153         return 0;
2154 }
2155
2156 void __connman_inet_rtnl_close(struct __connman_inet_rtnl_handle *rth)
2157 {
2158         DBG("handle %p", rth);
2159
2160         if (rth->fd >= 0) {
2161                 close(rth->fd);
2162                 rth->fd = -1;
2163         }
2164 }
2165
2166 int __connman_inet_rtnl_addattr32(struct nlmsghdr *n, size_t maxlen, int type,
2167                                 __u32 data)
2168 {
2169         int len = RTA_LENGTH(4);
2170         struct rtattr *rta;
2171
2172         if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen) {
2173                 DBG("Error! max allowed bound %zd exceeded", maxlen);
2174                 return -1;
2175         }
2176         rta = NLMSG_TAIL(n);
2177         rta->rta_type = type;
2178         rta->rta_len = len;
2179         memcpy(RTA_DATA(rta), &data, 4);
2180         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
2181
2182         return 0;
2183 }
2184
2185 static int parse_rtattr(struct rtattr *tb[], int max,
2186                         struct rtattr *rta, int len)
2187 {
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);
2193         }
2194         if (len)
2195                 connman_error("Deficit %d, rta_len=%d", len, rta->rta_len);
2196
2197         return 0;
2198 }
2199
2200 struct get_route_cb_data {
2201         connman_inet_addr_cb_t callback;
2202         void *user_data;
2203 };
2204
2205 static void get_route_cb(struct nlmsghdr *answer, void *user_data)
2206 {
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;
2211         char abuf[256];
2212         const char *addr = NULL;
2213
2214         DBG("answer %p data %p", answer, user_data);
2215
2216         if (answer == NULL)
2217                 goto out;
2218
2219         len = answer->nlmsg_len;
2220
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);
2226                 goto out;
2227         }
2228
2229         len -= NLMSG_LENGTH(sizeof(*r));
2230         if (len < 0) {
2231                 connman_error("BUG: wrong nlmsg len %d", len);
2232                 goto out;
2233         }
2234
2235         parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
2236
2237         if (tb[RTA_OIF] != NULL)
2238                 index = *(int *)RTA_DATA(tb[RTA_OIF]);
2239
2240         if (tb[RTA_GATEWAY] != NULL)
2241                 addr = inet_ntop(r->rtm_family,
2242                                 RTA_DATA(tb[RTA_GATEWAY]),
2243                                 abuf, sizeof(abuf));
2244
2245         DBG("addr %s index %d user %p", addr, index, data->user_data);
2246
2247 out:
2248         if (data != NULL && data->callback != NULL)
2249                 data->callback(addr, index, data->user_data);
2250
2251         g_free(data);
2252
2253         return;
2254 }
2255
2256 /*
2257  * Return the interface index that contains route to host.
2258  */
2259 int __connman_inet_get_route(const char *dest_address,
2260                         connman_inet_addr_cb_t callback, void *user_data)
2261 {
2262         struct get_route_cb_data *data;
2263         struct addrinfo hints, *rp;
2264         struct __connman_inet_rtnl_handle *rth;
2265         int err;
2266
2267         DBG("dest %s", dest_address);
2268
2269         if (dest_address == NULL)
2270                 return -EINVAL;
2271
2272         memset(&hints, 0, sizeof(hints));
2273         hints.ai_family = AF_UNSPEC;
2274         hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV | AI_NUMERICHOST;
2275
2276         err = getaddrinfo(dest_address, NULL, &hints, &rp);
2277         if (err)
2278                 return -EINVAL;
2279
2280         rth = g_try_malloc0(sizeof(struct __connman_inet_rtnl_handle));
2281         if (rth == NULL) {
2282                 freeaddrinfo(rp);
2283                 return -ENOMEM;
2284         }
2285
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;
2297
2298         __connman_inet_rtnl_addattr_l(&rth->req.n, sizeof(rth->req), RTA_DST,
2299                                 &rp->ai_addr, rp->ai_addrlen);
2300
2301         freeaddrinfo(rp);
2302
2303         err = __connman_inet_rtnl_open(rth);
2304         if (err < 0)
2305                 goto fail;
2306
2307         data = g_try_malloc(sizeof(struct get_route_cb_data));
2308         if (data == NULL) {
2309                 err = -ENOMEM;
2310                 goto done;
2311         }
2312
2313         data->callback = callback;
2314         data->user_data = user_data;
2315
2316 #define GET_ROUTE_TIMEOUT 2
2317         err = __connman_inet_rtnl_talk(rth, &rth->req.n, GET_ROUTE_TIMEOUT,
2318                                 get_route_cb, data);
2319         if (err < 0) {
2320                 g_free(data);
2321                 goto done;
2322         }
2323
2324         return 0;
2325
2326 done:
2327         __connman_inet_rtnl_close(rth);
2328
2329 fail:
2330         g_free(rth);
2331         return err;
2332 }
2333
2334 int connman_inet_check_ipaddress(const char *host)
2335 {
2336         struct addrinfo hints;
2337         struct addrinfo *addr;
2338         int result;
2339
2340         memset(&hints, 0, sizeof(struct addrinfo));
2341         hints.ai_flags = AI_NUMERICHOST;
2342         addr = NULL;
2343
2344         result = getaddrinfo(host, NULL, &hints, &addr);
2345         if (result == 0)
2346                 result = addr->ai_family;
2347         freeaddrinfo(addr);
2348
2349         return result;
2350 }
2351
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)
2354 {
2355         const char *p;
2356
2357         /*
2358          * Not empty or complete length not over 255 characters.
2359          */
2360         if ((len == 0) || (len > 256))
2361                 return FALSE;
2362
2363         /*
2364          * Consists of [[:alnum:]-]+ labels separated by [.]
2365          * a [_] is against RFC but seems to be "widely used"
2366          */
2367         for (p = ptr; (*p != 0) && (len-- > 0); p++) {
2368
2369                 if ((*p == '-') || (*p == '_')) {
2370                         /*
2371                          * Not allowed at begin or end of a label.
2372                          */
2373                         if (((p - ptr) == 0) || (len == 0) || (p[1] == '.'))
2374                                 return FALSE;
2375
2376                 } else if (*p == '.') {
2377                         /*
2378                          * Each label has to be 1-63 characters;
2379                          * we allow [.] at the end ('foo.bar.')
2380                          */
2381                         size_t d = p - ptr;
2382
2383                         if ((d <= 0) || (d >= 64))
2384                                 return FALSE;
2385
2386                         ptr = p + 1; /* Jump to the next label */
2387
2388                 } else if (isalnum((unsigned char)*p) == 0) {
2389                         /*
2390                          * Also numbers at the begin are fine
2391                          */
2392                         return FALSE;
2393                 }
2394         }
2395
2396         return TRUE;
2397 }
2398
2399 char **__connman_inet_get_running_interfaces(void)
2400 {
2401         char **result;
2402         struct ifconf ifc;
2403         struct ifreq *ifr = NULL;
2404         int sk, i, numif, count = 0;
2405
2406         memset(&ifc, 0, sizeof(ifc));
2407
2408         sk = socket(AF_INET, SOCK_DGRAM, 0);
2409         if (sk < 0)
2410                 return NULL;
2411
2412         if (ioctl(sk, SIOCGIFCONF, &ifc) < 0)
2413                 goto error;
2414
2415         /*
2416          * Allocate some extra bytes just in case there will
2417          * be new interfaces added between two SIOCGIFCONF
2418          * calls.
2419          */
2420         ifr = g_try_malloc0(ifc.ifc_len * 2);
2421         if (ifr == NULL)
2422                 goto error;
2423
2424         ifc.ifc_req = ifr;
2425
2426         if (ioctl(sk, SIOCGIFCONF, &ifc) < 0)
2427                 goto error;
2428
2429         numif = ifc.ifc_len / sizeof(struct ifreq);
2430
2431         result = g_try_malloc0((numif + 1) * sizeof(char *));
2432         if (result == NULL)
2433                 goto error;
2434
2435         close(sk);
2436
2437         for (i = 0; i < numif; i++) {
2438                 struct ifreq *r = &ifr[i];
2439                 struct in6_addr *addr6;
2440                 in_addr_t addr4;
2441
2442                 /*
2443                  * Note that we do not return loopback interfaces here as they
2444                  * are not needed for our purposes.
2445                  */
2446                 switch (r->ifr_addr.sa_family) {
2447                 case AF_INET:
2448                         addr4 = ntohl(((struct sockaddr_in *)
2449                                                 &r->ifr_addr)->sin_addr.s_addr);
2450                         if (((addr4 & 0xff000000) >> 24) == 127)
2451                                 continue;
2452                         break;
2453                 case AF_INET6:
2454                         addr6 = &((struct sockaddr_in6 *)
2455                                                 &r->ifr_addr)->sin6_addr;
2456                         if (IN6_IS_ADDR_LINKLOCAL(addr6))
2457                                 continue;
2458                         break;
2459                 }
2460
2461                 result[count++] = g_strdup(r->ifr_name);
2462         }
2463
2464         free(ifr);
2465
2466         if (count < numif)
2467                 result = g_try_realloc(result, (count + 1) * sizeof(char *));
2468
2469         return result;
2470
2471 error:
2472         close(sk);
2473         free(ifr);
2474         return NULL;
2475 }
2476
2477 connman_bool_t connman_inet_is_ipv6_supported()
2478 {
2479         int sk;
2480
2481         sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
2482         if (sk < 0)
2483                 return FALSE;
2484
2485         close(sk);
2486         return TRUE;
2487 }