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 g_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 connman_bool_t connman_inet_is_cfg80211(int index)
 361 {
 362         connman_bool_t result = FALSE;
 363         char phy80211_path[PATH_MAX];
 364         struct stat st;
 365         struct ifreq ifr;
 366         int sk;
 367
 368         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 369         if (sk < 0)
 370                 return FALSE;
 371
 372         memset(&ifr, 0, sizeof(ifr));
 373         ifr.ifr_ifindex = index;
 374
 375         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0)
 376                 goto done;
 377
 378         snprintf(phy80211_path, PATH_MAX,
 379                                 "/sys/class/net/%s/phy80211", ifr.ifr_name);
 380
 381         if (stat(phy80211_path, &st) == 0 && (st.st_mode & S_IFDIR))
 382                 result = TRUE;
 383
 384 done:
 385         close(sk);
 386
 387         return result;
 388 }
 389
 390 struct in6_ifreq {
 391         struct in6_addr ifr6_addr;
 392         __u32 ifr6_prefixlen;
 393         unsigned int ifr6_ifindex;
 394 };
 395
 396 int connman_inet_set_ipv6_address(int index,
 397                 struct connman_ipaddress *ipaddress)
 398 {
 399         int err;
 400         unsigned char prefix_len;
 401         const char *address;
 402
 403         if (ipaddress->local == NULL)
 404                 return 0;
 405
 406         prefix_len = ipaddress->prefixlen;
 407         address = ipaddress->local;
 408
 409         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 410
 411         err = __connman_inet_modify_address(RTM_NEWADDR,
 412                                 NLM_F_REPLACE | NLM_F_ACK, index, AF_INET6,
 413                                 address, NULL, prefix_len, NULL);
 414         if (err < 0) {
 415                 connman_error("%s: %s", __func__, strerror(-err));
 416                 return err;
 417         }
 418
 419         return 0;
 420 }
 421
 422 int connman_inet_set_address(int index, struct connman_ipaddress *ipaddress)
 423 {
 424         int err;
 425         unsigned char prefix_len;
 426         const char *address, *broadcast, *peer;
 427
 428         if (ipaddress->local == NULL)
 429                 return -1;
 430
 431         prefix_len = ipaddress->prefixlen;
 432         address = ipaddress->local;
 433         broadcast = ipaddress->broadcast;
 434         peer = ipaddress->peer;
 435
 436         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 437
 438         err = __connman_inet_modify_address(RTM_NEWADDR,
 439                                 NLM_F_REPLACE | NLM_F_ACK, index, AF_INET,
 440                                 address, peer, prefix_len, broadcast);
 441         if (err < 0) {
 442                 connman_error("%s: %s", __func__, strerror(-err));
 443                 return err;
 444         }
 445
 446         return 0;
 447 }
 448
 449 int connman_inet_clear_ipv6_address(int index, const char *address,
 450                                                         int prefix_len)
 451 {
 452         int err;
 453
 454         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 455
 456         err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET6,
 457                                 address, NULL, prefix_len, NULL);
 458         if (err < 0) {
 459                 connman_error("%s: %s", __func__, strerror(-err));
 460                 return err;
 461         }
 462
 463         return 0;
 464 }
 465
 466 int connman_inet_clear_address(int index, struct connman_ipaddress *ipaddress)
 467 {
 468         int err;
 469         unsigned char prefix_len;
 470         const char *address, *broadcast, *peer;
 471
 472         prefix_len = ipaddress->prefixlen;
 473         address = ipaddress->local;
 474         broadcast = ipaddress->broadcast;
 475         peer = ipaddress->peer;
 476
 477         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 478
 479         err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET,
 480                                 address, peer, prefix_len, broadcast);
 481         if (err < 0) {
 482                 connman_error("%s: %s", __func__, strerror(-err));
 483                 return err;
 484         }
 485
 486         return 0;
 487 }
 488
 489 int connman_inet_add_host_route(int index, const char *host,
 490                                 const char *gateway)
 491 {
 492         return connman_inet_add_network_route(index, host, gateway, NULL);
 493 }
 494
 495 int connman_inet_del_host_route(int index, const char *host)
 496 {
 497         return connman_inet_del_network_route(index, host);
 498 }
 499
 500 int connman_inet_add_network_route(int index, const char *host,
 501                                         const char *gateway,
 502                                         const char *netmask)
 503 {
 504         struct ifreq ifr;
 505         struct rtentry rt;
 506         struct sockaddr_in addr;
 507         int sk, err = 0;
 508
 509         DBG("index %d host %s gateway %s netmask %s", index,
 510                 host, gateway, netmask);
 511
 512         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 513         if (sk < 0) {
 514                 err = -errno;
 515                 goto out;
 516         }
 517
 518         memset(&ifr, 0, sizeof(ifr));
 519         ifr.ifr_ifindex = index;
 520
 521         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 522                 err = -errno;
 523                 close(sk);
 524                 goto out;
 525         }
 526
 527         DBG("ifname %s", ifr.ifr_name);
 528
 529         memset(&rt, 0, sizeof(rt));
 530         rt.rt_flags = RTF_UP;
 531         if (gateway != NULL)
 532                 rt.rt_flags |= RTF_GATEWAY;
 533         if (netmask == NULL)
 534                 rt.rt_flags |= RTF_HOST;
 535
 536         memset(&addr, 0, sizeof(addr));
 537         addr.sin_family = AF_INET;
 538         addr.sin_addr.s_addr = inet_addr(host);
 539         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 540
 541         memset(&addr, 0, sizeof(addr));
 542         addr.sin_family = AF_INET;
 543         if (gateway != NULL)
 544                 addr.sin_addr.s_addr = inet_addr(gateway);
 545         else
 546                 addr.sin_addr.s_addr = INADDR_ANY;
 547         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 548
 549         memset(&addr, 0, sizeof(addr));
 550         addr.sin_family = AF_INET;
 551         addr.sin_addr.s_addr = INADDR_ANY;
 552         if (netmask != NULL)
 553                 addr.sin_addr.s_addr = inet_addr(netmask);
 554         else
 555                 addr.sin_addr.s_addr = INADDR_ANY;
 556         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 557
 558         rt.rt_dev = ifr.ifr_name;
 559
 560         if (ioctl(sk, SIOCADDRT, &rt) < 0 && errno != EEXIST)
 561                 err = -errno;
 562
 563         close(sk);
 564
 565 out:
 566         if (err < 0)
 567                 connman_error("Adding host route failed (%s)",
 568                                                         strerror(-err));
 569
 570         return err;
 571 }
 572
 573 int connman_inet_del_network_route(int index, const char *host)
 574 {
 575         struct ifreq ifr;
 576         struct rtentry rt;
 577         struct sockaddr_in addr;
 578         int sk, err = 0;
 579
 580         DBG("index %d host %s", index, host);
 581
 582         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 583         if (sk < 0) {
 584                 err = -errno;
 585                 goto out;
 586         }
 587
 588         memset(&ifr, 0, sizeof(ifr));
 589         ifr.ifr_ifindex = index;
 590
 591         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 592                 err = -errno;
 593                 close(sk);
 594                 goto out;
 595         }
 596
 597         DBG("ifname %s", ifr.ifr_name);
 598
 599         memset(&rt, 0, sizeof(rt));
 600         rt.rt_flags = RTF_UP | RTF_HOST;
 601
 602         memset(&addr, 0, sizeof(addr));
 603         addr.sin_family = AF_INET;
 604         addr.sin_addr.s_addr = inet_addr(host);
 605         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 606
 607         rt.rt_dev = ifr.ifr_name;
 608
 609         if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
 610                 err = -errno;
 611
 612         close(sk);
 613
 614 out:
 615         if (err < 0)
 616                 connman_error("Deleting host route failed (%s)",
 617                                                         strerror(-err));
 618
 619         return err;
 620 }
 621
 622 int connman_inet_del_ipv6_network_route(int index, const char *host,
 623                                                 unsigned char prefix_len)
 624 {
 625         struct in6_rtmsg rt;
 626         int sk, err = 0;
 627
 628         DBG("index %d host %s", index, host);
 629
 630         if (host == NULL)
 631                 return -EINVAL;
 632
 633         memset(&rt, 0, sizeof(rt));
 634
 635         rt.rtmsg_dst_len = prefix_len;
 636
 637         if (inet_pton(AF_INET6, host, &rt.rtmsg_dst) < 0) {
 638                 err = -errno;
 639                 goto out;
 640         }
 641
 642         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 643
 644         rt.rtmsg_metric = 1;
 645         rt.rtmsg_ifindex = index;
 646
 647         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 648         if (sk < 0) {
 649                 err = -errno;
 650                 goto out;
 651         }
 652
 653         if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
 654                 err = -errno;
 655
 656         close(sk);
 657
 658 out:
 659         if (err < 0)
 660                 connman_error("Del IPv6 host route error (%s)",
 661                                                 strerror(-err));
 662
 663         return err;
 664 }
 665
 666 int connman_inet_del_ipv6_host_route(int index, const char *host)
 667 {
 668         return connman_inet_del_ipv6_network_route(index, host, 128);
 669 }
 670
 671 int connman_inet_add_ipv6_network_route(int index, const char *host,
 672                                         const char *gateway,
 673                                         unsigned char prefix_len)
 674 {
 675         struct in6_rtmsg rt;
 676         int sk, err = 0;
 677
 678         DBG("index %d host %s gateway %s", index, host, gateway);
 679
 680         if (host == NULL)
 681                 return -EINVAL;
 682
 683         memset(&rt, 0, sizeof(rt));
 684
 685         rt.rtmsg_dst_len = prefix_len;
 686
 687         if (inet_pton(AF_INET6, host, &rt.rtmsg_dst) < 0) {
 688                 err = -errno;
 689                 goto out;
 690         }
 691
 692         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 693
 694         if (gateway != NULL) {
 695                 rt.rtmsg_flags |= RTF_GATEWAY;
 696                 inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 697         }
 698
 699         rt.rtmsg_metric = 1;
 700         rt.rtmsg_ifindex = index;
 701
 702         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 703         if (sk < 0) {
 704                 err = -errno;
 705                 goto out;
 706         }
 707
 708         if (ioctl(sk, SIOCADDRT, &rt) < 0 && errno != EEXIST)
 709                 err = -errno;
 710
 711         close(sk);
 712
 713 out:
 714         if (err < 0)
 715                 connman_error("Set IPv6 host route error (%s)",
 716                                                 strerror(-err));
 717
 718         return err;
 719 }
 720
 721 int connman_inet_add_ipv6_host_route(int index, const char *host,
 722                                         const char *gateway)
 723 {
 724         return connman_inet_add_ipv6_network_route(index, host, gateway, 128);
 725 }
 726
 727 int connman_inet_set_ipv6_gateway_address(int index, const char *gateway)
 728 {
 729         struct in6_rtmsg rt;
 730         int sk, err = 0;
 731
 732         DBG("index %d gateway %s", index, gateway);
 733
 734         if (gateway == NULL)
 735                 return -EINVAL;
 736
 737         memset(&rt, 0, sizeof(rt));
 738
 739         if (inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway) < 0) {
 740                 err = -errno;
 741                 goto out;
 742         }
 743
 744         rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
 745         rt.rtmsg_metric = 1;
 746         rt.rtmsg_dst_len = 0;
 747         rt.rtmsg_ifindex = index;
 748
 749         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 750         if (sk < 0) {
 751                 err = -errno;
 752                 goto out;
 753         }
 754
 755         if (ioctl(sk, SIOCADDRT, &rt) < 0 && errno != EEXIST)
 756                 err = -errno;
 757
 758         close(sk);
 759
 760 out:
 761         if (err < 0)
 762                 connman_error("Set default IPv6 gateway error (%s)",
 763                                                 strerror(-err));
 764
 765         return err;
 766 }
 767
 768 int connman_inet_clear_ipv6_gateway_address(int index, const char *gateway)
 769 {
 770         struct in6_rtmsg rt;
 771         int sk, err = 0;
 772
 773         DBG("index %d gateway %s", index, gateway);
 774
 775         if (gateway == NULL)
 776                 return -EINVAL;
 777
 778         memset(&rt, 0, sizeof(rt));
 779
 780         if (inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway) < 0) {
 781                 err = -errno;
 782                 goto out;
 783         }
 784
 785         rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
 786         rt.rtmsg_metric = 1;
 787         rt.rtmsg_dst_len = 0;
 788         rt.rtmsg_ifindex = index;
 789
 790         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 791         if (sk < 0) {
 792                 err = -errno;
 793                 goto out;
 794         }
 795
 796         if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
 797                 err = -errno;
 798
 799         close(sk);
 800
 801 out:
 802         if (err < 0)
 803                 connman_error("Clear default IPv6 gateway error (%s)",
 804                                                 strerror(-err));
 805
 806         return err;
 807 }
 808
 809 int connman_inet_set_gateway_address(int index, const char *gateway)
 810 {
 811         struct ifreq ifr;
 812         struct rtentry rt;
 813         struct sockaddr_in addr;
 814         int sk, err = 0;
 815
 816         DBG("index %d gateway %s", index, gateway);
 817
 818         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 819         if (sk < 0) {
 820                 err = -errno;
 821                 goto out;
 822         }
 823
 824         memset(&ifr, 0, sizeof(ifr));
 825         ifr.ifr_ifindex = index;
 826
 827         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 828                 err = -errno;
 829                 close(sk);
 830                 goto out;
 831         }
 832
 833         DBG("ifname %s", ifr.ifr_name);
 834
 835         memset(&rt, 0, sizeof(rt));
 836         rt.rt_flags = RTF_UP | RTF_GATEWAY;
 837
 838         memset(&addr, 0, sizeof(addr));
 839         addr.sin_family = AF_INET;
 840         addr.sin_addr.s_addr = INADDR_ANY;
 841         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 842
 843         memset(&addr, 0, sizeof(addr));
 844         addr.sin_family = AF_INET;
 845         addr.sin_addr.s_addr = inet_addr(gateway);
 846         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 847
 848         memset(&addr, 0, sizeof(addr));
 849         addr.sin_family = AF_INET;
 850         addr.sin_addr.s_addr = INADDR_ANY;
 851         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 852
 853         if (ioctl(sk, SIOCADDRT, &rt) < 0 && errno != EEXIST)
 854                 err = -errno;
 855
 856         close(sk);
 857
 858 out:
 859         if (err < 0)
 860                 connman_error("Setting default gateway route failed (%s)",
 861                                                         strerror(-err));
 862
 863         return err;
 864 }
 865
 866 int connman_inet_set_gateway_interface(int index)
 867 {
 868         struct ifreq ifr;
 869         struct rtentry rt;
 870         struct sockaddr_in addr;
 871         int sk, err = 0;
 872
 873         DBG("index %d", index);
 874
 875         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 876         if (sk < 0) {
 877                 err = -errno;
 878                 goto out;
 879         }
 880
 881         memset(&ifr, 0, sizeof(ifr));
 882         ifr.ifr_ifindex = index;
 883
 884         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 885                 err = -errno;
 886                 close(sk);
 887                 goto out;
 888         }
 889
 890         DBG("ifname %s", ifr.ifr_name);
 891
 892         memset(&rt, 0, sizeof(rt));
 893         rt.rt_flags = RTF_UP;
 894
 895         memset(&addr, 0, sizeof(addr));
 896         addr.sin_family = AF_INET;
 897         addr.sin_addr.s_addr = INADDR_ANY;
 898
 899         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 900         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 901         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 902
 903         rt.rt_dev = ifr.ifr_name;
 904
 905         if (ioctl(sk, SIOCADDRT, &rt) < 0 && errno != EEXIST)
 906                 err = -errno;
 907
 908         close(sk);
 909
 910 out:
 911         if (err < 0)
 912                 connman_error("Setting default interface route failed (%s)",
 913                                                         strerror(-err));
 914
 915         return err;
 916 }
 917
 918 int connman_inet_set_ipv6_gateway_interface(int index)
 919 {
 920         struct ifreq ifr;
 921         struct rtentry rt;
 922         struct sockaddr_in6 addr;
 923         const struct in6_addr any = IN6ADDR_ANY_INIT;
 924         int sk, err = 0;
 925
 926         DBG("index %d", index);
 927
 928         sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 929         if (sk < 0) {
 930                 err = -errno;
 931                 goto out;
 932         }
 933
 934         memset(&ifr, 0, sizeof(ifr));
 935         ifr.ifr_ifindex = index;
 936
 937         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 938                 err = -errno;
 939                 close(sk);
 940                 goto out;
 941         }
 942
 943         DBG("ifname %s", ifr.ifr_name);
 944
 945         memset(&rt, 0, sizeof(rt));
 946         rt.rt_flags = RTF_UP;
 947
 948         memset(&addr, 0, sizeof(addr));
 949         addr.sin6_family = AF_INET6;
 950         addr.sin6_addr = any;
 951
 952         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 953         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 954         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 955
 956         rt.rt_dev = ifr.ifr_name;
 957
 958         if (ioctl(sk, SIOCADDRT, &rt) < 0 && errno != EEXIST)
 959                 err = -errno;
 960
 961         close(sk);
 962
 963 out:
 964         if (err < 0)
 965                 connman_error("Setting default interface route failed (%s)",
 966                                                         strerror(-err));
 967
 968         return err;
 969 }
 970
 971 int connman_inet_clear_gateway_address(int index, const char *gateway)
 972 {
 973         struct ifreq ifr;
 974         struct rtentry rt;
 975         struct sockaddr_in addr;
 976         int sk, err = 0;
 977
 978         DBG("index %d gateway %s", index, gateway);
 979
 980         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 981         if (sk < 0) {
 982                 err = -errno;
 983                 goto out;
 984         }
 985
 986         memset(&ifr, 0, sizeof(ifr));
 987         ifr.ifr_ifindex = index;
 988
 989         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 990                 err = -errno;
 991                 close(sk);
 992                 goto out;
 993         }
 994
 995         DBG("ifname %s", ifr.ifr_name);
 996
 997         memset(&rt, 0, sizeof(rt));
 998         rt.rt_flags = RTF_UP | RTF_GATEWAY;
 999
1000         memset(&addr, 0, sizeof(addr));
1001         addr.sin_family = AF_INET;
1002         addr.sin_addr.s_addr = INADDR_ANY;
1003         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1004
1005         memset(&addr, 0, sizeof(addr));
1006         addr.sin_family = AF_INET;
1007         addr.sin_addr.s_addr = inet_addr(gateway);
1008         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1009
1010         memset(&addr, 0, sizeof(addr));
1011         addr.sin_family = AF_INET;
1012         addr.sin_addr.s_addr = INADDR_ANY;
1013         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1014
1015         if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
1016                 err = -errno;
1017
1018         close(sk);
1019
1020 out:
1021         if (err < 0)
1022                 connman_error("Removing default gateway route failed (%s)",
1023                                                         strerror(-err));
1024
1025         return err;
1026 }
1027
1028 int connman_inet_clear_gateway_interface(int index)
1029 {
1030         struct ifreq ifr;
1031         struct rtentry rt;
1032         struct sockaddr_in addr;
1033         int sk, err = 0;
1034
1035         DBG("index %d", index);
1036
1037         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1038         if (sk < 0) {
1039                 err = -errno;
1040                 goto out;
1041         }
1042
1043         memset(&ifr, 0, sizeof(ifr));
1044         ifr.ifr_ifindex = index;
1045
1046         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1047                 err = -errno;
1048                 close(sk);
1049                 goto out;
1050         }
1051
1052         DBG("ifname %s", ifr.ifr_name);
1053
1054         memset(&rt, 0, sizeof(rt));
1055         rt.rt_flags = RTF_UP;
1056
1057         memset(&addr, 0, sizeof(addr));
1058         addr.sin_family = AF_INET;
1059         addr.sin_addr.s_addr = INADDR_ANY;
1060
1061         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1062         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1063         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1064
1065         rt.rt_dev = ifr.ifr_name;
1066
1067         if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
1068                 err = -errno;
1069
1070         close(sk);
1071
1072 out:
1073         if (err < 0)
1074                 connman_error("Removing default interface route failed (%s)",
1075                                                         strerror(-err));
1076
1077         return err;
1078 }
1079
1080 int connman_inet_clear_ipv6_gateway_interface(int index)
1081 {
1082         struct ifreq ifr;
1083         struct rtentry rt;
1084         struct sockaddr_in6 addr;
1085         const struct in6_addr any = IN6ADDR_ANY_INIT;
1086         int sk, err = 0;
1087
1088         DBG("index %d", index);
1089
1090         sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1091         if (sk < 0) {
1092                 err = -errno;
1093                 goto out;
1094         }
1095
1096         memset(&ifr, 0, sizeof(ifr));
1097         ifr.ifr_ifindex = index;
1098
1099         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1100                 err = -errno;
1101                 close(sk);
1102                 goto out;
1103         }
1104
1105         DBG("ifname %s", ifr.ifr_name);
1106
1107         memset(&rt, 0, sizeof(rt));
1108         rt.rt_flags = RTF_UP;
1109
1110         memset(&addr, 0, sizeof(addr));
1111         addr.sin6_family = AF_INET6;
1112         addr.sin6_addr = any;
1113
1114         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1115         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1116         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1117
1118         rt.rt_dev = ifr.ifr_name;
1119
1120         if (ioctl(sk, SIOCDELRT, &rt) < 0 && errno != ESRCH)
1121                 err = -errno;
1122
1123         close(sk);
1124
1125 out:
1126         if (err < 0)
1127                 connman_error("Removing default interface route failed (%s)",
1128                                                         strerror(-err));
1129
1130         return err;
1131 }
1132
1133 connman_bool_t connman_inet_compare_subnet(int index, const char *host)
1134 {
1135         struct ifreq ifr;
1136         struct in_addr _host_addr;
1137         in_addr_t host_addr, netmask_addr, if_addr;
1138         struct sockaddr_in *netmask, *addr;
1139         int sk;
1140
1141         DBG("host %s", host);
1142
1143         if (host == NULL)
1144                 return FALSE;
1145
1146         if (inet_aton(host, &_host_addr) == 0)
1147                 return -1;
1148         host_addr = _host_addr.s_addr;
1149
1150         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1151         if (sk < 0)
1152                 return FALSE;
1153
1154         memset(&ifr, 0, sizeof(ifr));
1155         ifr.ifr_ifindex = index;
1156
1157         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1158                 close(sk);
1159                 return FALSE;
1160         }
1161
1162         if (ioctl(sk, SIOCGIFNETMASK, &ifr) < 0) {
1163                 close(sk);
1164                 return FALSE;
1165         }
1166
1167         netmask = (struct sockaddr_in *)&ifr.ifr_netmask;
1168         netmask_addr = netmask->sin_addr.s_addr;
1169
1170         if (ioctl(sk, SIOCGIFADDR, &ifr) < 0) {
1171                 close(sk);
1172                 return FALSE;
1173         }
1174
1175         close(sk);
1176
1177         addr = (struct sockaddr_in *)&ifr.ifr_addr;
1178         if_addr = addr->sin_addr.s_addr;
1179
1180         return ((if_addr & netmask_addr) == (host_addr & netmask_addr));
1181 }
1182
1183 int connman_inet_remove_from_bridge(int index, const char *bridge)
1184 {
1185         struct ifreq ifr;
1186         int sk, err = 0;
1187
1188         if (bridge == NULL)
1189                 return -EINVAL;
1190
1191         sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
1192         if (sk < 0) {
1193                 err = -errno;
1194                 goto out;
1195         }
1196
1197         memset(&ifr, 0, sizeof(ifr));
1198         strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1199         ifr.ifr_ifindex = index;
1200
1201         if (ioctl(sk, SIOCBRDELIF, &ifr) < 0)
1202                 err = -errno;
1203
1204         close(sk);
1205
1206 out:
1207         if (err < 0)
1208                 connman_error("Remove interface from bridge error %s",
1209                                                         strerror(-err));
1210
1211         return err;
1212 }
1213
1214 int connman_inet_add_to_bridge(int index, const char *bridge)
1215 {
1216         struct ifreq ifr;
1217         int sk, err = 0;
1218
1219         if (bridge == NULL)
1220                 return -EINVAL;
1221
1222         sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
1223         if (sk < 0) {
1224                 err = -errno;
1225                 goto out;
1226         }
1227
1228         memset(&ifr, 0, sizeof(ifr));
1229         strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1230         ifr.ifr_ifindex = index;
1231
1232         if (ioctl(sk, SIOCBRADDIF, &ifr) < 0)
1233                 err = -errno;
1234
1235         close(sk);
1236
1237 out:
1238         if (err < 0)
1239                 connman_error("Add interface to bridge error %s",
1240                                                         strerror(-err));
1241
1242         return err;
1243 }
1244
1245 int connman_inet_set_mtu(int index, int mtu)
1246 {
1247         struct ifreq ifr;
1248         int sk, err;
1249
1250         sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1251         if (sk < 0)
1252                 return sk;
1253
1254         memset(&ifr, 0, sizeof(ifr));
1255         ifr.ifr_ifindex = index;
1256
1257         err = ioctl(sk, SIOCGIFNAME, &ifr);
1258         if (err == 0) {
1259                 ifr.ifr_mtu = mtu;
1260                 err = ioctl(sk, SIOCSIFMTU, &ifr);
1261         }
1262
1263         close(sk);
1264         return err;
1265 }
1266
1267 int connman_inet_setup_tunnel(char *tunnel, int mtu)
1268 {
1269         struct ifreq ifr;
1270         int sk, err, index;
1271         __u32 mask;
1272         __u32 flags;
1273
1274         if (tunnel == NULL)
1275                 return -EINVAL;
1276
1277         sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1278         if (sk < 0)
1279                 return sk;
1280
1281         index = if_nametoindex(tunnel);
1282
1283         err = connman_inet_set_mtu(index, mtu);
1284         if (err != 0)
1285                 goto done;
1286
1287         memset(&ifr, 0, sizeof(ifr));
1288         strncpy(ifr.ifr_name, tunnel, IFNAMSIZ);
1289         err = ioctl(sk, SIOCGIFFLAGS, &ifr);
1290         if (err)
1291                 goto done;
1292
1293         mask = IFF_UP;
1294         flags = IFF_UP;
1295
1296         if ((ifr.ifr_flags ^ flags) & mask) {
1297                 ifr.ifr_flags &= ~mask;
1298                 ifr.ifr_flags |= mask & flags;
1299                 err = ioctl(sk, SIOCSIFFLAGS, &ifr);
1300                 if (err)
1301                         connman_error("SIOCSIFFLAGS failed: %s",
1302                                                         strerror(errno));
1303         }
1304
1305 done:
1306         close(sk);
1307         return err;
1308 }
1309
1310 int connman_inet_create_tunnel(char **iface)
1311 {
1312         struct ifreq ifr;
1313         int i, fd;
1314
1315         fd = open("/dev/net/tun", O_RDWR | O_CLOEXEC);
1316         if (fd < 0) {
1317                 i = -errno;
1318                 connman_error("Failed to open /dev/net/tun: %s",
1319                                 strerror(errno));
1320                 return i;
1321         }
1322
1323         memset(&ifr, 0, sizeof(ifr));
1324         ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
1325
1326         for (i = 0; i < 256; i++) {
1327                 sprintf(ifr.ifr_name, "tun%d", i);
1328
1329                 if (!ioctl(fd, TUNSETIFF, (void *)&ifr))
1330                         break;
1331         }
1332
1333         if (i == 256) {
1334                 connman_error("Failed to find available tun device");
1335                 close(fd);
1336                 return -ENODEV;
1337         }
1338
1339         *iface = g_strdup(ifr.ifr_name);
1340
1341         return fd;
1342 }
1343
1344 struct rs_cb_data {
1345         GIOChannel *channel;
1346         __connman_inet_rs_cb_t callback;
1347         struct sockaddr_in6 addr;
1348         guint rs_timeout;
1349         guint watch_id;
1350         void *user_data;
1351 };
1352
1353 #define CMSG_BUF_LEN 512
1354 #define IN6ADDR_ALL_NODES_MC_INIT \
1355         { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x1 } } } /* ff02::1 */
1356 #define IN6ADDR_ALL_ROUTERS_MC_INIT \
1357         { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x2 } } } /* ff02::2 */
1358
1359 static const struct in6_addr in6addr_all_nodes_mc = IN6ADDR_ALL_NODES_MC_INIT;
1360 static const struct in6_addr in6addr_all_routers_mc =
1361                                                 IN6ADDR_ALL_ROUTERS_MC_INIT;
1362
1363 static void rs_cleanup(struct rs_cb_data *data)
1364 {
1365         if (data->channel != NULL) {
1366                 g_io_channel_shutdown(data->channel, TRUE, NULL);
1367                 g_io_channel_unref(data->channel);
1368                 data->channel = NULL;
1369         }
1370
1371         if (data->rs_timeout > 0)
1372                 g_source_remove(data->rs_timeout);
1373
1374         if (data->watch_id > 0)
1375                 g_source_remove(data->watch_id);
1376
1377         g_free(data);
1378 }
1379
1380 static gboolean rs_timeout_cb(gpointer user_data)
1381 {
1382         struct rs_cb_data *data = user_data;
1383
1384         DBG("user data %p", user_data);
1385
1386         if (data == NULL)
1387                 return FALSE;
1388
1389         if (data->callback != NULL)
1390                 data->callback(NULL, 0, data->user_data);
1391
1392         data->rs_timeout = 0;
1393         rs_cleanup(data);
1394         return FALSE;
1395 }
1396
1397 static int icmpv6_recv(int fd, gpointer user_data)
1398 {
1399         struct msghdr mhdr;
1400         struct iovec iov;
1401         unsigned char chdr[CMSG_BUF_LEN];
1402         unsigned char buf[1540];
1403         struct rs_cb_data *data = user_data;
1404         struct nd_router_advert *hdr;
1405         struct sockaddr_in6 saddr;
1406         ssize_t len;
1407
1408         DBG("");
1409
1410         iov.iov_len = sizeof(buf);
1411         iov.iov_base = buf;
1412
1413         mhdr.msg_name = (void *)&saddr;
1414         mhdr.msg_namelen = sizeof(struct sockaddr_in6);
1415         mhdr.msg_iov = &iov;
1416         mhdr.msg_iovlen = 1;
1417         mhdr.msg_control = (void *)chdr;
1418         mhdr.msg_controllen = CMSG_BUF_LEN;
1419
1420         len = recvmsg(fd, &mhdr, 0);
1421         if (len < 0) {
1422                 data->callback(NULL, 0, data->user_data);
1423                 rs_cleanup(data);
1424                 return -errno;
1425         }
1426
1427         hdr = (struct nd_router_advert *)buf;
1428         DBG("code %d len %zd hdr %zd", hdr->nd_ra_code, len,
1429                                 sizeof(struct nd_router_advert));
1430         if (hdr->nd_ra_code != 0)
1431                 return 0;
1432
1433         data->callback(hdr, len, data->user_data);
1434         rs_cleanup(data);
1435
1436         return len;
1437 }
1438
1439 static gboolean icmpv6_event(GIOChannel *chan, GIOCondition cond,
1440                                                                 gpointer data)
1441 {
1442         int fd, ret;
1443
1444         DBG("");
1445
1446         if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
1447                 return FALSE;
1448
1449         fd = g_io_channel_unix_get_fd(chan);
1450         ret = icmpv6_recv(fd, data);
1451         if (ret == 0)
1452                 return TRUE;
1453
1454         return FALSE;
1455 }
1456
1457 /* Adapted from RFC 1071 "C" Implementation Example */
1458 static uint16_t csum(const void *phdr, const void *data, socklen_t datalen)
1459 {
1460         register unsigned long sum = 0;
1461         socklen_t count;
1462         uint16_t *addr;
1463         int i;
1464
1465         /* caller must make sure datalen is even */
1466
1467         addr = (uint16_t *)phdr;
1468         for (i = 0; i < 20; i++)
1469                 sum += *addr++;
1470
1471         count = datalen;
1472         addr = (uint16_t *)data;
1473
1474         while (count > 1) {
1475                 sum += *(addr++);
1476                 count -= 2;
1477         }
1478
1479         while (sum >> 16)
1480                 sum = (sum & 0xffff) + (sum >> 16);
1481
1482         return (uint16_t)~sum;
1483 }
1484
1485 static int ndisc_send_unspec(int type, int oif, const struct in6_addr *dest)
1486 {
1487         struct _phdr {
1488                 struct in6_addr src;
1489                 struct in6_addr dst;
1490                 uint32_t plen;
1491                 uint8_t reserved[3];
1492                 uint8_t nxt;
1493         } phdr;
1494
1495         struct {
1496                 struct ip6_hdr ip;
1497                 union {
1498                         struct icmp6_hdr icmp;
1499                         struct nd_neighbor_solicit ns;
1500                         struct nd_router_solicit rs;
1501                 } i;
1502         } frame;
1503
1504         struct msghdr msgh;
1505         struct cmsghdr *cmsg;
1506         struct in6_pktinfo *pinfo;
1507         struct sockaddr_in6 dst;
1508         char cbuf[CMSG_SPACE(sizeof(*pinfo))];
1509         struct iovec iov;
1510         int fd, datalen, ret;
1511
1512         DBG("");
1513
1514         fd = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_RAW);
1515         if (fd < 0)
1516                 return -errno;
1517
1518         memset(&frame, 0, sizeof(frame));
1519         memset(&dst, 0, sizeof(dst));
1520
1521         datalen = sizeof(frame.i.rs); /* 8, csum() safe */
1522         dst.sin6_addr = *dest;
1523
1524         /* Fill in the IPv6 header */
1525         frame.ip.ip6_vfc = 0x60;
1526         frame.ip.ip6_plen = htons(datalen);
1527         frame.ip.ip6_nxt = IPPROTO_ICMPV6;
1528         frame.ip.ip6_hlim = 255;
1529         frame.ip.ip6_dst = dst.sin6_addr;
1530         /* all other fields are already set to zero */
1531
1532         /* Prepare pseudo header for csum */
1533         memset(&phdr, 0, sizeof(phdr));
1534         phdr.dst = dst.sin6_addr;
1535         phdr.plen = htonl(datalen);
1536         phdr.nxt = IPPROTO_ICMPV6;
1537
1538         /* Fill in remaining ICMP header fields */
1539         frame.i.icmp.icmp6_type = type;
1540         frame.i.icmp.icmp6_cksum = csum(&phdr, &frame.i, datalen);
1541
1542         iov.iov_base = &frame;
1543         iov.iov_len = sizeof(frame.ip) + datalen;
1544
1545         dst.sin6_family = AF_INET6;
1546         msgh.msg_name = &dst;
1547         msgh.msg_namelen = sizeof(dst);
1548         msgh.msg_iov = &iov;
1549         msgh.msg_iovlen = 1;
1550         msgh.msg_flags = 0;
1551
1552         memset(cbuf, 0, CMSG_SPACE(sizeof(*pinfo)));
1553         cmsg = (struct cmsghdr *)cbuf;
1554         pinfo = (struct in6_pktinfo *)CMSG_DATA(cmsg);
1555         pinfo->ipi6_ifindex = oif;
1556
1557         cmsg->cmsg_len = CMSG_LEN(sizeof(*pinfo));
1558         cmsg->cmsg_level = IPPROTO_IPV6;
1559         cmsg->cmsg_type = IPV6_PKTINFO;
1560         msgh.msg_control = cmsg;
1561         msgh.msg_controllen = cmsg->cmsg_len;
1562
1563         ret = sendmsg(fd, &msgh, 0);
1564
1565         close(fd);
1566         return ret;
1567 }
1568
1569 static inline void ipv6_addr_set(struct in6_addr *addr,
1570                                 uint32_t w1, uint32_t w2,
1571                                 uint32_t w3, uint32_t w4)
1572 {
1573         addr->s6_addr32[0] = w1;
1574         addr->s6_addr32[1] = w2;
1575         addr->s6_addr32[2] = w3;
1576         addr->s6_addr32[3] = w4;
1577 }
1578
1579 static inline void ipv6_addr_solict_mult(const struct in6_addr *addr,
1580                                         struct in6_addr *solicited)
1581 {
1582         ipv6_addr_set(solicited, htonl(0xFF020000), 0, htonl(0x1),
1583                         htonl(0xFF000000) | addr->s6_addr32[3]);
1584 }
1585
1586 static int if_mc_group(int sock, int ifindex, const struct in6_addr *mc_addr,
1587                                                                 int cmd)
1588 {
1589         unsigned int val = 0;
1590         struct ipv6_mreq mreq;
1591         int ret;
1592
1593         memset(&mreq, 0, sizeof(mreq));
1594         mreq.ipv6mr_interface = ifindex;
1595         mreq.ipv6mr_multiaddr = *mc_addr;
1596
1597         ret = setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
1598                         &val, sizeof(int));
1599
1600         if (ret < 0)
1601                 return ret;
1602
1603         return setsockopt(sock, IPPROTO_IPV6, cmd, &mreq, sizeof(mreq));
1604 }
1605
1606 int __connman_inet_ipv6_send_rs(int index, int timeout,
1607                         __connman_inet_rs_cb_t callback, void *user_data)
1608 {
1609         struct rs_cb_data *data;
1610         struct icmp6_filter filter;
1611         struct in6_addr solicit;
1612         struct in6_addr dst = in6addr_all_routers_mc;
1613         int sk;
1614
1615         DBG("");
1616
1617         if (timeout <= 0)
1618                 return -EINVAL;
1619
1620         data = g_try_malloc0(sizeof(struct rs_cb_data));
1621         if (data == NULL)
1622                 return -ENOMEM;
1623
1624         data->callback = callback;
1625         data->user_data = user_data;
1626         data->rs_timeout = g_timeout_add_seconds(timeout, rs_timeout_cb, data);
1627
1628         sk = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
1629         if (sk < 0)
1630                 return -errno;
1631
1632         ICMP6_FILTER_SETBLOCKALL(&filter);
1633         ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filter);
1634
1635         setsockopt(sk, IPPROTO_ICMPV6, ICMP6_FILTER, &filter,
1636                                                 sizeof(struct icmp6_filter));
1637
1638         ipv6_addr_solict_mult(&dst, &solicit);
1639         if_mc_group(sk, index, &in6addr_all_nodes_mc, IPV6_JOIN_GROUP);
1640         if_mc_group(sk, index, &solicit, IPV6_JOIN_GROUP);
1641
1642         data->channel = g_io_channel_unix_new(sk);
1643         g_io_channel_set_close_on_unref(data->channel, TRUE);
1644
1645         g_io_channel_set_encoding(data->channel, NULL, NULL);
1646         g_io_channel_set_buffered(data->channel, FALSE);
1647
1648         data->watch_id = g_io_add_watch(data->channel,
1649                         G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
1650                         icmpv6_event, data);
1651
1652         ndisc_send_unspec(ND_ROUTER_SOLICIT, index, &dst);
1653
1654         return 0;
1655 }
1656
1657 GSList *__connman_inet_ipv6_get_prefixes(struct nd_router_advert *hdr,
1658                                         unsigned int length)
1659 {
1660         GSList *prefixes = NULL;
1661         uint8_t *pos;
1662         int len;
1663
1664         if (length <= sizeof(struct nd_router_advert))
1665                 return NULL;
1666
1667         len = length - sizeof(struct nd_router_advert);
1668         pos = (uint8_t *)hdr + sizeof(struct nd_router_advert);
1669
1670         while (len > 0) {
1671                 struct nd_opt_prefix_info *pinfo;
1672                 char prefix_str[INET6_ADDRSTRLEN+1], *str;
1673                 const char *prefix;
1674                 int optlen;
1675
1676                 if (len < 2)
1677                         break;
1678
1679                 optlen = pos[1] << 3;
1680                 if (optlen == 0 || optlen > len)
1681                         break;
1682
1683                 switch (pos[0]) {
1684                 case ND_OPT_PREFIX_INFORMATION:
1685                         pinfo = (struct nd_opt_prefix_info *)pos;
1686                         prefix = inet_ntop(AF_INET6, &pinfo->nd_opt_pi_prefix,
1687                                         prefix_str, INET6_ADDRSTRLEN);
1688                         if (prefix == NULL)
1689                                 break;
1690
1691                         str = g_strdup_printf("%s/%d", prefix,
1692                                                 pinfo->nd_opt_pi_prefix_len);
1693                         prefixes = g_slist_prepend(prefixes, str);
1694
1695                         DBG("prefix %s", str);
1696
1697                         break;
1698                 }
1699
1700                 len -= optlen;
1701                 pos += optlen;
1702         }
1703
1704         return prefixes;
1705 }
1706
1707 static int get_dest_addr(int family, int index, char *buf, int len)
1708 {
1709         struct ifreq ifr;
1710         void *addr;
1711         int sk;
1712
1713         sk = socket(family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1714         if (sk < 0)
1715                 return -errno;
1716
1717         memset(&ifr, 0, sizeof(ifr));
1718         ifr.ifr_ifindex = index;
1719
1720         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1721                 DBG("SIOCGIFNAME (%d/%s)", errno, strerror(errno));
1722                 close(sk);
1723                 return -errno;
1724         }
1725
1726         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
1727                 DBG("SIOCGIFFLAGS (%d/%s)", errno, strerror(errno));
1728                 close(sk);
1729                 return -errno;
1730         }
1731
1732         if ((ifr.ifr_flags & IFF_POINTOPOINT) == 0) {
1733                 close(sk);
1734                 errno = EINVAL;
1735                 return -errno;
1736         }
1737
1738         DBG("index %d %s", index, ifr.ifr_name);
1739
1740         if (ioctl(sk, SIOCGIFDSTADDR, &ifr) < 0) {
1741                 connman_error("Get destination address failed (%s)",
1742                                                         strerror(errno));
1743                 close(sk);
1744                 return -errno;
1745         }
1746
1747         close(sk);
1748
1749         switch (family) {
1750         case AF_INET:
1751                 addr = &((struct sockaddr_in *)&ifr.ifr_dstaddr)->sin_addr;
1752                 break;
1753         case AF_INET6:
1754                 addr = &((struct sockaddr_in6 *)&ifr.ifr_dstaddr)->sin6_addr;
1755                 break;
1756         default:
1757                 errno = EINVAL;
1758                 return -errno;
1759         }
1760
1761         if (inet_ntop(family, addr, buf, len) == NULL) {
1762                 DBG("error %d/%s", errno, strerror(errno));
1763                 return -errno;
1764         }
1765
1766         return 0;
1767 }
1768
1769 int connman_inet_get_dest_addr(int index, char **dest)
1770 {
1771         char addr[INET_ADDRSTRLEN];
1772         int ret;
1773
1774         ret = get_dest_addr(PF_INET, index, addr, INET_ADDRSTRLEN);
1775         if (ret < 0)
1776                 return ret;
1777
1778         *dest = g_strdup(addr);
1779
1780         DBG("destination %s", *dest);
1781
1782         return 0;
1783 }
1784
1785 int connman_inet_ipv6_get_dest_addr(int index, char **dest)
1786 {
1787         char addr[INET6_ADDRSTRLEN];
1788         int ret;
1789
1790         ret = get_dest_addr(PF_INET6, index, addr, INET6_ADDRSTRLEN);
1791         if (ret < 0)
1792                 return ret;
1793
1794         *dest = g_strdup(addr);
1795
1796         DBG("destination %s", *dest);
1797
1798         return 0;
1799 }
1800
1801 int __connman_inet_rtnl_open(struct __connman_inet_rtnl_handle *rth)
1802 {
1803         int sndbuf = 1024;
1804         int rcvbuf = 1024 * 4;
1805
1806         rth->fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
1807         if (rth->fd < 0) {
1808                 connman_error("Can not open netlink socket: %s",
1809                                                 strerror(errno));
1810                 return -errno;
1811         }
1812
1813         if (setsockopt(rth->fd, SOL_SOCKET, SO_SNDBUF, &sndbuf,
1814                         sizeof(sndbuf)) < 0) {
1815                 connman_error("SO_SNDBUF: %s", strerror(errno));
1816                 return -errno;
1817         }
1818
1819         if (setsockopt(rth->fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf,
1820                         sizeof(rcvbuf)) < 0) {
1821                 connman_error("SO_RCVBUF: %s", strerror(errno));
1822                 return -errno;
1823         }
1824
1825         memset(&rth->local, 0, sizeof(rth->local));
1826         rth->local.nl_family = AF_NETLINK;
1827         rth->local.nl_groups = 0;
1828
1829         if (bind(rth->fd, (struct sockaddr *)&rth->local,
1830                                                 sizeof(rth->local)) < 0) {
1831                 connman_error("Can not bind netlink socket: %s",
1832                                                         strerror(errno));
1833                 return -errno;
1834         }
1835
1836         rth->seq = time(NULL);
1837
1838         DBG("fd %d", rth->fd);
1839
1840         return 0;
1841 }
1842
1843 struct inet_rtnl_cb_data {
1844         GIOChannel *channel;
1845         __connman_inet_rtnl_cb_t callback;
1846         guint rtnl_timeout;
1847         guint watch_id;
1848         struct __connman_inet_rtnl_handle *rtnl;
1849         void *user_data;
1850 };
1851
1852 static void inet_rtnl_cleanup(struct inet_rtnl_cb_data *data)
1853 {
1854         struct __connman_inet_rtnl_handle *rth = data->rtnl;
1855
1856         if (data->channel != NULL) {
1857                 g_io_channel_shutdown(data->channel, TRUE, NULL);
1858                 g_io_channel_unref(data->channel);
1859                 data->channel = NULL;
1860         }
1861
1862         DBG("data %p", data);
1863
1864         if (data->rtnl_timeout > 0)
1865                 g_source_remove(data->rtnl_timeout);
1866
1867         if (data->watch_id > 0)
1868                 g_source_remove(data->watch_id);
1869
1870         if (rth != NULL) {
1871                 __connman_inet_rtnl_close(rth);
1872                 g_free(rth);
1873         }
1874
1875         g_free(data);
1876 }
1877
1878 static gboolean inet_rtnl_timeout_cb(gpointer user_data)
1879 {
1880         struct inet_rtnl_cb_data *data = user_data;
1881
1882         DBG("user data %p", user_data);
1883
1884         if (data == NULL)
1885                 return FALSE;
1886
1887         if (data->callback != NULL)
1888                 data->callback(NULL, data->user_data);
1889
1890         data->rtnl_timeout = 0;
1891         inet_rtnl_cleanup(data);
1892         return FALSE;
1893 }
1894
1895 static int inet_rtnl_recv(GIOChannel *chan, gpointer user_data)
1896 {
1897         struct inet_rtnl_cb_data *rtnl_data = user_data;
1898         struct __connman_inet_rtnl_handle *rth = rtnl_data->rtnl;
1899         struct nlmsghdr *h = NULL;
1900         struct sockaddr_nl nladdr;
1901         socklen_t addr_len = sizeof(nladdr);
1902         unsigned char buf[4096];
1903         void *ptr = buf;
1904         gsize len;
1905         int status, fd;
1906
1907         memset(buf, 0, sizeof(buf));
1908         memset(&nladdr, 0, sizeof(nladdr));
1909
1910         fd = g_io_channel_unix_get_fd(chan);
1911
1912         status = recvfrom(fd, buf, sizeof(buf), 0,
1913                        (struct sockaddr *) &nladdr, &addr_len);
1914         if (status < 0) {
1915                 if (errno == EINTR || errno == EAGAIN)
1916                         return 0;
1917
1918                 return -1;
1919         }
1920
1921         if (status == 0)
1922                 return -1;
1923
1924         if (nladdr.nl_pid != 0) { /* not sent by kernel, ignore */
1925                 DBG("Received msg from %u, ignoring it", nladdr.nl_pid);
1926                 return 0;
1927         }
1928
1929         len = status;
1930
1931         while (len > 0) {
1932                 struct nlmsgerr *err;
1933
1934                 h = ptr;
1935
1936                 if (!NLMSG_OK(h, len)) {
1937                         return -1;
1938                         break;
1939                 }
1940
1941                 if (h->nlmsg_seq != rth->seq) {
1942                         /* Skip this msg */
1943                         DBG("skip %d/%d len %d", rth->seq,
1944                                 h->nlmsg_seq, h->nlmsg_len);
1945
1946                         len -= h->nlmsg_len;
1947                         ptr += h->nlmsg_len;
1948                         continue;
1949                 }
1950
1951                 switch (h->nlmsg_type) {
1952                 case NLMSG_NOOP:
1953                 case NLMSG_OVERRUN:
1954                         return -1;
1955
1956                 case NLMSG_ERROR:
1957                         err = (struct nlmsgerr *)NLMSG_DATA(h);
1958                         connman_error("RTNETLINK answers %s (%d)",
1959                                 strerror(-err->error), -err->error);
1960                         return err->error;
1961                 }
1962
1963                 break;
1964         }
1965
1966         if (h->nlmsg_seq == rth->seq) {
1967                 DBG("received %d seq %d", h->nlmsg_len, h->nlmsg_seq);
1968
1969                 rtnl_data->callback(h, rtnl_data->user_data);
1970
1971                 inet_rtnl_cleanup(rtnl_data);
1972         }
1973
1974         return 0;
1975 }
1976
1977 static gboolean inet_rtnl_event(GIOChannel *chan, GIOCondition cond,
1978                                                         gpointer user_data)
1979 {
1980         int ret;
1981
1982         DBG("");
1983
1984         if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
1985                 return FALSE;
1986
1987         ret = inet_rtnl_recv(chan, user_data);
1988         if (ret != 0)
1989                 return TRUE;
1990
1991         return FALSE;
1992 }
1993
1994 int __connman_inet_rtnl_talk(struct __connman_inet_rtnl_handle *rtnl,
1995                         struct nlmsghdr *n, int timeout,
1996                         __connman_inet_rtnl_cb_t callback, void *user_data)
1997 {
1998         struct sockaddr_nl nladdr;
1999         struct inet_rtnl_cb_data *data;
2000         unsigned seq;
2001         int err;
2002
2003         memset(&nladdr, 0, sizeof(nladdr));
2004         nladdr.nl_family = AF_NETLINK;
2005
2006         n->nlmsg_seq = seq = ++rtnl->seq;
2007
2008         if (callback != NULL) {
2009                 data = g_try_malloc0(sizeof(struct inet_rtnl_cb_data));
2010                 if (data == NULL)
2011                         return -ENOMEM;
2012
2013                 data->callback = callback;
2014                 data->user_data = user_data;
2015                 data->rtnl = rtnl;
2016                 data->rtnl_timeout = g_timeout_add_seconds(timeout,
2017                                                 inet_rtnl_timeout_cb, data);
2018
2019                 data->channel = g_io_channel_unix_new(rtnl->fd);
2020                 g_io_channel_set_close_on_unref(data->channel, TRUE);
2021
2022                 g_io_channel_set_encoding(data->channel, NULL, NULL);
2023                 g_io_channel_set_buffered(data->channel, FALSE);
2024
2025                 data->watch_id = g_io_add_watch(data->channel,
2026                                 G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
2027                                                 inet_rtnl_event, data);
2028         } else
2029                 n->nlmsg_flags |= NLM_F_ACK;
2030
2031         err = sendto(rtnl->fd, &rtnl->req.n, rtnl->req.n.nlmsg_len, 0,
2032                 (struct sockaddr *) &nladdr, sizeof(nladdr));
2033         DBG("handle %p len %d err %d", rtnl, rtnl->req.n.nlmsg_len, err);
2034         if (err < 0) {
2035                 connman_error("Can not talk to rtnetlink");
2036                 return -errno;
2037         }
2038
2039         if ((unsigned int)err != rtnl->req.n.nlmsg_len) {
2040                 connman_error("Sent %d bytes, msg truncated", err);
2041                 return -EINVAL;
2042         }
2043
2044         return 0;
2045 }
2046
2047 void __connman_inet_rtnl_close(struct __connman_inet_rtnl_handle *rth)
2048 {
2049         DBG("handle %p", rth);
2050
2051         if (rth->fd >= 0) {
2052                 close(rth->fd);
2053                 rth->fd = -1;
2054         }
2055 }
2056
2057 int __connman_inet_rtnl_addattr32(struct nlmsghdr *n, size_t maxlen, int type,
2058                                 __u32 data)
2059 {
2060         int len = RTA_LENGTH(4);
2061         struct rtattr *rta;
2062
2063         if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen) {
2064                 DBG("Error! max allowed bound %zd exceeded", maxlen);
2065                 return -1;
2066         }
2067         rta = NLMSG_TAIL(n);
2068         rta->rta_type = type;
2069         rta->rta_len = len;
2070         memcpy(RTA_DATA(rta), &data, 4);
2071         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
2072
2073         return 0;
2074 }
2075
2076 static int parse_rtattr(struct rtattr *tb[], int max,
2077                         struct rtattr *rta, int len)
2078 {
2079         memset(tb, 0, sizeof(struct rtattr *) * (max + 1));
2080         while (RTA_OK(rta, len)) {
2081                 if ((rta->rta_type <= max) && (!tb[rta->rta_type]))
2082                         tb[rta->rta_type] = rta;
2083                 rta = RTA_NEXT(rta, len);
2084         }
2085         if (len)
2086                 connman_error("Deficit %d, rta_len=%d", len, rta->rta_len);
2087
2088         return 0;
2089 }
2090
2091 struct get_route_cb_data {
2092         connman_inet_addr_cb_t callback;
2093         void *user_data;
2094 };
2095
2096 static void get_route_cb(struct nlmsghdr *answer, void *user_data)
2097 {
2098         struct get_route_cb_data *data = user_data;
2099         struct rtattr *tb[RTA_MAX+1];
2100         struct rtmsg *r = NLMSG_DATA(answer);
2101         int len, index = -1;
2102         char abuf[256];
2103         const char *addr = NULL;
2104
2105         DBG("answer %p data %p", answer, user_data);
2106
2107         if (answer == NULL)
2108                 goto out;
2109
2110         len = answer->nlmsg_len;
2111
2112         if (answer->nlmsg_type != RTM_NEWROUTE &&
2113                                 answer->nlmsg_type != RTM_DELROUTE) {
2114                 connman_error("Not a route: %08x %08x %08x",
2115                         answer->nlmsg_len, answer->nlmsg_type,
2116                         answer->nlmsg_flags);
2117                 goto out;
2118         }
2119
2120         len -= NLMSG_LENGTH(sizeof(*r));
2121         if (len < 0) {
2122                 connman_error("BUG: wrong nlmsg len %d", len);
2123                 goto out;
2124         }
2125
2126         parse_rtattr(tb, RTA_MAX, RTM_RTA(r), len);
2127
2128         if (tb[RTA_OIF] != NULL)
2129                 index = *(int *)RTA_DATA(tb[RTA_OIF]);
2130
2131         if (tb[RTA_GATEWAY] != NULL)
2132                 addr = inet_ntop(r->rtm_family,
2133                                 RTA_DATA(tb[RTA_GATEWAY]),
2134                                 abuf, sizeof(abuf));
2135
2136         DBG("addr %s index %d user %p", addr, index, data->user_data);
2137
2138 out:
2139         if (data != NULL && data->callback != NULL)
2140                 data->callback(addr, index, data->user_data);
2141
2142         g_free(data);
2143
2144         return;
2145 }
2146
2147 /*
2148  * Return the interface index that contains route to host.
2149  */
2150 int __connman_inet_get_route(const char *dest_address,
2151                         connman_inet_addr_cb_t callback, void *user_data)
2152 {
2153         struct get_route_cb_data *data;
2154         struct addrinfo hints, *rp;
2155         struct __connman_inet_rtnl_handle *rth;
2156         int err;
2157
2158         DBG("dest %s", dest_address);
2159
2160         if (dest_address == NULL)
2161                 return -EINVAL;
2162
2163         memset(&hints, 0, sizeof(hints));
2164         hints.ai_family = AF_UNSPEC;
2165         hints.ai_flags = AI_PASSIVE | AI_NUMERICSERV | AI_NUMERICHOST;
2166
2167         err = getaddrinfo(dest_address, NULL, &hints, &rp);
2168         if (err)
2169                 return -EINVAL;
2170
2171         rth = g_try_malloc0(sizeof(struct __connman_inet_rtnl_handle));
2172         if (rth == NULL) {
2173                 freeaddrinfo(rp);
2174                 return -ENOMEM;
2175         }
2176
2177         rth->req.n.nlmsg_len = NLMSG_LENGTH(sizeof(struct rtmsg));
2178         rth->req.n.nlmsg_flags = NLM_F_REQUEST;
2179         rth->req.n.nlmsg_type = RTM_GETROUTE;
2180         rth->req.u.r.rt.rtm_family = rp->ai_family;
2181         rth->req.u.r.rt.rtm_table = 0;
2182         rth->req.u.r.rt.rtm_protocol = 0;
2183         rth->req.u.r.rt.rtm_scope = 0;
2184         rth->req.u.r.rt.rtm_type = 0;
2185         rth->req.u.r.rt.rtm_src_len = 0;
2186         rth->req.u.r.rt.rtm_dst_len = rp->ai_addrlen << 3;
2187         rth->req.u.r.rt.rtm_tos = 0;
2188
2189         __connman_inet_rtnl_addattr_l(&rth->req.n, sizeof(rth->req), RTA_DST,
2190                                 &rp->ai_addr, rp->ai_addrlen);
2191
2192         freeaddrinfo(rp);
2193
2194         err = __connman_inet_rtnl_open(rth);
2195         if (err < 0)
2196                 goto fail;
2197
2198         data = g_try_malloc(sizeof(struct get_route_cb_data));
2199         if (data == NULL) {
2200                 err = -ENOMEM;
2201                 goto done;
2202         }
2203
2204         data->callback = callback;
2205         data->user_data = user_data;
2206
2207 #define GET_ROUTE_TIMEOUT 2
2208         err = __connman_inet_rtnl_talk(rth, &rth->req.n, GET_ROUTE_TIMEOUT,
2209                                 get_route_cb, data);
2210         if (err < 0) {
2211                 g_free(data);
2212                 goto done;
2213         }
2214
2215         return 0;
2216
2217 done:
2218         __connman_inet_rtnl_close(rth);
2219
2220 fail:
2221         g_free(rth);
2222         return err;
2223 }
2224
2225 int connman_inet_check_ipaddress(const char *host)
2226 {
2227         struct addrinfo hints;
2228         struct addrinfo *addr;
2229         int result;
2230
2231         memset(&hints, 0, sizeof(struct addrinfo));
2232         hints.ai_flags = AI_NUMERICHOST;
2233         addr = NULL;
2234
2235         result = getaddrinfo(host, NULL, &hints, &addr);
2236         if (result == 0)
2237                 result = addr->ai_family;
2238         freeaddrinfo(addr);
2239
2240         return result;
2241 }
2242
2243 /* Check routine modified from ics-dhcp 4.2.3-P2 */
2244 connman_bool_t connman_inet_check_hostname(const char *ptr, size_t len)
2245 {
2246         const char *p;
2247
2248         /*
2249          * Not empty or complete length not over 255 characters.
2250          */
2251         if ((len == 0) || (len > 256))
2252                 return FALSE;
2253
2254         /*
2255          * Consists of [[:alnum:]-]+ labels separated by [.]
2256          * a [_] is against RFC but seems to be "widely used"
2257          */
2258         for (p = ptr; (*p != 0) && (len-- > 0); p++) {
2259
2260                 if ((*p == '-') || (*p == '_')) {
2261                         /*
2262                          * Not allowed at begin or end of a label.
2263                          */
2264                         if (((p - ptr) == 0) || (len == 0) || (p[1] == '.'))
2265                                 return FALSE;
2266
2267                 } else if (*p == '.') {
2268                         /*
2269                          * Each label has to be 1-63 characters;
2270                          * we allow [.] at the end ('foo.bar.')
2271                          */
2272                         size_t d = p - ptr;
2273
2274                         if ((d <= 0) || (d >= 64))
2275                                 return FALSE;
2276
2277                         ptr = p + 1; /* Jump to the next label */
2278
2279                 } else if (isalnum((unsigned char)*p) == 0) {
2280                         /*
2281                          * Also numbers at the begin are fine
2282                          */
2283                         return FALSE;
2284                 }
2285         }
2286
2287         return TRUE;
2288 }
2289
2290 char **__connman_inet_get_running_interfaces(void)
2291 {
2292         char **result;
2293         struct ifconf ifc;
2294         struct ifreq *ifr = NULL;
2295         int sk, i, numif, count = 0;
2296
2297         memset(&ifc, 0, sizeof(ifc));
2298
2299         sk = socket(AF_INET, SOCK_DGRAM, 0);
2300         if (sk < 0)
2301                 return NULL;
2302
2303         if (ioctl(sk, SIOCGIFCONF, &ifc) < 0)
2304                 goto error;
2305
2306         /*
2307          * Allocate some extra bytes just in case there will
2308          * be new interfaces added between two SIOCGIFCONF
2309          * calls.
2310          */
2311         ifr = g_try_malloc0(ifc.ifc_len * 2);
2312         if (ifr == NULL)
2313                 goto error;
2314
2315         ifc.ifc_req = ifr;
2316
2317         if (ioctl(sk, SIOCGIFCONF, &ifc) < 0)
2318                 goto error;
2319
2320         numif = ifc.ifc_len / sizeof(struct ifreq);
2321
2322         result = g_try_malloc0((numif + 1) * sizeof(char *));
2323         if (result == NULL)
2324                 goto error;
2325
2326         close(sk);
2327
2328         for (i = 0; i < numif; i++) {
2329                 struct ifreq *r = &ifr[i];
2330                 struct in6_addr *addr6;
2331                 in_addr_t addr4;
2332
2333                 /*
2334                  * Note that we do not return loopback interfaces here as they
2335                  * are not needed for our purposes.
2336                  */
2337                 switch (r->ifr_addr.sa_family) {
2338                 case AF_INET:
2339                         addr4 = ntohl(((struct sockaddr_in *)
2340                                                 &r->ifr_addr)->sin_addr.s_addr);
2341                         if (((addr4 & 0xff000000) >> 24) == 127)
2342                                 continue;
2343                         break;
2344                 case AF_INET6:
2345                         addr6 = &((struct sockaddr_in6 *)
2346                                                 &r->ifr_addr)->sin6_addr;
2347                         if (IN6_IS_ADDR_LINKLOCAL(addr6))
2348                                 continue;
2349                         break;
2350                 }
2351
2352                 result[count++] = g_strdup(r->ifr_name);
2353         }
2354
2355         g_free(ifr);
2356
2357         if (count < numif)
2358                 result = g_try_realloc(result, (count + 1) * sizeof(char *));
2359
2360         return result;
2361
2362 error:
2363         close(sk);
2364         g_free(ifr);
2365         return NULL;
2366 }
2367
2368 connman_bool_t connman_inet_is_ipv6_supported()
2369 {
2370         int sk;
2371
2372         sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
2373         if (sk < 0)
2374                 return FALSE;
2375
2376         close(sk);
2377         return TRUE;
2378 }