src/inet.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  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
  48 #include "connman.h"
  49
  50 #define NLMSG_TAIL(nmsg)                                \
  51         ((struct rtattr *) (((uint8_t*) (nmsg)) +       \
  52         NLMSG_ALIGN((nmsg)->nlmsg_len)))
  53
  54 int __connman_inet_rtnl_addattr_l(struct nlmsghdr *n, size_t max_length,
  55                                 int type, const void *data, size_t data_length)
  56 {
  57         size_t length;
  58         struct rtattr *rta;
  59
  60         length = RTA_LENGTH(data_length);
  61
  62         if (NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(length) > max_length)
  63                 return -E2BIG;
  64
  65         rta = NLMSG_TAIL(n);
  66         rta->rta_type = type;
  67         rta->rta_len = length;
  68         memcpy(RTA_DATA(rta), data, data_length);
  69         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(length);
  70
  71         return 0;
  72 }
  73
  74 int __connman_inet_modify_address(int cmd, int flags,
  75                                 int index, int family,
  76                                 const char *address,
  77                                 const char *peer,
  78                                 unsigned char prefixlen,
  79                                 const char *broadcast)
  80 {
  81         uint8_t request[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
  82                         NLMSG_ALIGN(sizeof(struct ifaddrmsg)) +
  83                         RTA_LENGTH(sizeof(struct in6_addr)) +
  84                         RTA_LENGTH(sizeof(struct in6_addr))];
  85
  86         struct nlmsghdr *header;
  87         struct sockaddr_nl nl_addr;
  88         struct ifaddrmsg *ifaddrmsg;
  89         struct in6_addr ipv6_addr;
  90         struct in_addr ipv4_addr, ipv4_dest, ipv4_bcast;
  91         int sk, err;
  92
  93         DBG("cmd %#x flags %#x index %d family %d address %s peer %s "
  94                 "prefixlen %hhu broadcast %s", cmd, flags, index, family,
  95                 address, peer, prefixlen, broadcast);
  96
  97         if (address == NULL)
  98                 return -EINVAL;
  99
 100         if (family != AF_INET && family != AF_INET6)
 101                 return -EINVAL;
 102
 103         memset(&request, 0, sizeof(request));
 104
 105         header = (struct nlmsghdr *)request;
 106         header->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
 107         header->nlmsg_type = cmd;
 108         header->nlmsg_flags = NLM_F_REQUEST | flags;
 109         header->nlmsg_seq = 1;
 110
 111         ifaddrmsg = NLMSG_DATA(header);
 112         ifaddrmsg->ifa_family = family;
 113         ifaddrmsg->ifa_prefixlen = prefixlen;
 114         ifaddrmsg->ifa_flags = IFA_F_PERMANENT;
 115         ifaddrmsg->ifa_scope = RT_SCOPE_UNIVERSE;
 116         ifaddrmsg->ifa_index = index;
 117
 118         if (family == AF_INET) {
 119                 if (inet_pton(AF_INET, address, &ipv4_addr) < 1)
 120                         return -1;
 121
 122                 if (broadcast != NULL)
 123                         inet_pton(AF_INET, broadcast, &ipv4_bcast);
 124                 else
 125                         ipv4_bcast.s_addr = ipv4_addr.s_addr |
 126                                 htonl(0xfffffffflu >> prefixlen);
 127
 128                 if (peer != NULL) {
 129                         if (inet_pton(AF_INET, peer, &ipv4_dest) < 1)
 130                                 return -1;
 131
 132                         err = __connman_inet_rtnl_addattr_l(header,
 133                                                         sizeof(request),
 134                                                         IFA_ADDRESS,
 135                                                         &ipv4_dest,
 136                                                         sizeof(ipv4_dest));
 137                         if (err < 0)
 138                                 return err;
 139                 }
 140
 141                 err = __connman_inet_rtnl_addattr_l(header,
 142                                                 sizeof(request),
 143                                                 IFA_LOCAL,
 144                                                 &ipv4_addr,
 145                                                 sizeof(ipv4_addr));
 146                 if (err < 0)
 147                         return err;
 148
 149                 err = __connman_inet_rtnl_addattr_l(header,
 150                                                 sizeof(request),
 151                                                 IFA_BROADCAST,
 152                                                 &ipv4_bcast,
 153                                                 sizeof(ipv4_bcast));
 154                 if (err < 0)
 155                         return err;
 156
 157         } else if (family == AF_INET6) {
 158                 if (inet_pton(AF_INET6, address, &ipv6_addr) < 1)
 159                         return -1;
 160
 161                 err = __connman_inet_rtnl_addattr_l(header,
 162                                                 sizeof(request),
 163                                                 IFA_LOCAL,
 164                                                 &ipv6_addr,
 165                                                 sizeof(ipv6_addr));
 166                 if (err < 0)
 167                         return err;
 168         }
 169
 170         sk = socket(AF_NETLINK, SOCK_DGRAM | SOCK_CLOEXEC, NETLINK_ROUTE);
 171         if (sk < 0)
 172                 return -errno;
 173
 174         memset(&nl_addr, 0, sizeof(nl_addr));
 175         nl_addr.nl_family = AF_NETLINK;
 176
 177         if ((err = sendto(sk, request, header->nlmsg_len, 0,
 178                         (struct sockaddr *) &nl_addr, sizeof(nl_addr))) < 0)
 179                 goto done;
 180
 181         err = 0;
 182
 183 done:
 184         close(sk);
 185
 186         return err;
 187 }
 188
 189 int connman_inet_ifindex(const char *name)
 190 {
 191         struct ifreq ifr;
 192         int sk, err;
 193
 194         if (name == NULL)
 195                 return -1;
 196
 197         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 198         if (sk < 0)
 199                 return -1;
 200
 201         memset(&ifr, 0, sizeof(ifr));
 202         strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
 203
 204         err = ioctl(sk, SIOCGIFINDEX, &ifr);
 205
 206         close(sk);
 207
 208         if (err < 0)
 209                 return -1;
 210
 211         return ifr.ifr_ifindex;
 212 }
 213
 214 char *connman_inet_ifname(int index)
 215 {
 216         struct ifreq ifr;
 217         int sk, err;
 218
 219         if (index < 0)
 220                 return NULL;
 221
 222         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 223         if (sk < 0)
 224                 return NULL;
 225
 226         memset(&ifr, 0, sizeof(ifr));
 227         ifr.ifr_ifindex = index;
 228
 229         err = ioctl(sk, SIOCGIFNAME, &ifr);
 230
 231         close(sk);
 232
 233         if (err < 0)
 234                 return NULL;
 235
 236         return strdup(ifr.ifr_name);
 237 }
 238
 239 short int connman_inet_ifflags(int index)
 240 {
 241         struct ifreq ifr;
 242         int sk, err;
 243
 244         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 245         if (sk < 0)
 246                 return -errno;
 247
 248         memset(&ifr, 0, sizeof(ifr));
 249         ifr.ifr_ifindex = index;
 250
 251         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 252                 err = -errno;
 253                 goto done;
 254         }
 255
 256         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 257                 err = -errno;
 258                 goto done;
 259         }
 260
 261         err = ifr.ifr_flags;
 262
 263 done:
 264         close(sk);
 265
 266         return err;
 267 }
 268
 269 int connman_inet_ifup(int index)
 270 {
 271         struct ifreq ifr;
 272         int sk, err;
 273
 274         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 275         if (sk < 0)
 276                 return -errno;
 277
 278         memset(&ifr, 0, sizeof(ifr));
 279         ifr.ifr_ifindex = index;
 280
 281         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 282                 err = -errno;
 283                 goto done;
 284         }
 285
 286         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 287                 err = -errno;
 288                 goto done;
 289         }
 290
 291         if (ifr.ifr_flags & IFF_UP) {
 292                 err = -EALREADY;
 293                 goto done;
 294         }
 295
 296         ifr.ifr_flags |= IFF_UP;
 297
 298         if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0) {
 299                 err = -errno;
 300                 goto done;
 301         }
 302
 303         err = 0;
 304
 305 done:
 306         close(sk);
 307
 308         return err;
 309 }
 310
 311 int connman_inet_ifdown(int index)
 312 {
 313         struct ifreq ifr;
 314         int sk, err;
 315
 316         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 317         if (sk < 0)
 318                 return -errno;
 319
 320         memset(&ifr, 0, sizeof(ifr));
 321         ifr.ifr_ifindex = index;
 322
 323         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 324                 err = -errno;
 325                 goto done;
 326         }
 327
 328         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 329                 err = -errno;
 330                 goto done;
 331         }
 332
 333         if (!(ifr.ifr_flags & IFF_UP)) {
 334                 err = -EALREADY;
 335                 goto done;
 336         }
 337
 338         ifr.ifr_flags &= ~IFF_UP;
 339
 340         if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0)
 341                 err = -errno;
 342         else
 343                 err = 0;
 344
 345 done:
 346         close(sk);
 347
 348         return err;
 349 }
 350
 351 static char *index2addr(int index)
 352 {
 353         struct ifreq ifr;
 354         struct ether_addr eth;
 355         char *str;
 356         int sk, err;
 357
 358         if (index < 0)
 359                 return NULL;
 360
 361         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 362         if (sk < 0)
 363                 return NULL;
 364
 365         memset(&ifr, 0, sizeof(ifr));
 366         ifr.ifr_ifindex = index;
 367
 368         err = ioctl(sk, SIOCGIFNAME, &ifr);
 369
 370         if (err == 0)
 371                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
 372
 373         close(sk);
 374
 375         if (err < 0)
 376                 return NULL;
 377
 378         str = malloc(18);
 379         if (!str)
 380                 return NULL;
 381
 382         memcpy(&eth, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
 383         snprintf(str, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
 384                                                 eth.ether_addr_octet[0],
 385                                                 eth.ether_addr_octet[1],
 386                                                 eth.ether_addr_octet[2],
 387                                                 eth.ether_addr_octet[3],
 388                                                 eth.ether_addr_octet[4],
 389                                                 eth.ether_addr_octet[5]);
 390
 391         return str;
 392 }
 393
 394 static char *index2ident(int index, const char *prefix)
 395 {
 396         struct ifreq ifr;
 397         struct ether_addr eth;
 398         char *str;
 399         int sk, err, len;
 400
 401         if (index < 0)
 402                 return NULL;
 403
 404         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 405         if (sk < 0)
 406                 return NULL;
 407
 408         memset(&ifr, 0, sizeof(ifr));
 409         ifr.ifr_ifindex = index;
 410
 411         err = ioctl(sk, SIOCGIFNAME, &ifr);
 412
 413         if (err == 0)
 414                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
 415
 416         close(sk);
 417
 418         if (err < 0)
 419                 return NULL;
 420
 421         len = prefix ? strlen(prefix) + 18 : 18;
 422
 423         str = malloc(len);
 424         if (!str)
 425                 return NULL;
 426
 427         memcpy(&eth, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
 428         snprintf(str, len, "%s%02x%02x%02x%02x%02x%02x",
 429                                                 prefix ? prefix : "",
 430                                                 eth.ether_addr_octet[0],
 431                                                 eth.ether_addr_octet[1],
 432                                                 eth.ether_addr_octet[2],
 433                                                 eth.ether_addr_octet[3],
 434                                                 eth.ether_addr_octet[4],
 435                                                 eth.ether_addr_octet[5]);
 436
 437         return str;
 438 }
 439
 440 connman_bool_t connman_inet_is_cfg80211(int index)
 441 {
 442         connman_bool_t result = FALSE;
 443         char phy80211_path[PATH_MAX];
 444         struct stat st;
 445         struct ifreq ifr;
 446         int sk;
 447
 448         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 449         if (sk < 0)
 450                 return FALSE;
 451
 452         memset(&ifr, 0, sizeof(ifr));
 453         ifr.ifr_ifindex = index;
 454
 455         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0)
 456                 goto done;
 457
 458         snprintf(phy80211_path, PATH_MAX,
 459                                 "/sys/class/net/%s/phy80211", ifr.ifr_name);
 460
 461         if (stat(phy80211_path, &st) == 0 && (st.st_mode & S_IFDIR))
 462                 result = TRUE;
 463
 464 done:
 465         close(sk);
 466
 467         return result;
 468 }
 469
 470 struct connman_device *connman_inet_create_device(int index)
 471 {
 472         enum connman_device_type type;
 473         struct connman_device *device;
 474         char *devname, *ident = NULL;
 475         char *addr = NULL, *name = NULL;
 476
 477         if (index < 0)
 478                 return NULL;
 479
 480         devname = connman_inet_ifname(index);
 481         if (devname == NULL)
 482                 return NULL;
 483
 484         if (__connman_device_isfiltered(devname) == TRUE) {
 485                 connman_info("Ignoring interface %s (filtered)", devname);
 486                 free(devname);
 487                 return NULL;
 488         }
 489
 490         type = __connman_rtnl_get_device_type(index);
 491
 492         switch (type) {
 493         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 494                 connman_info("Ignoring interface %s (type unknown)", devname);
 495                 free(devname);
 496                 return NULL;
 497         case CONNMAN_DEVICE_TYPE_ETHERNET:
 498         case CONNMAN_DEVICE_TYPE_GADGET:
 499         case CONNMAN_DEVICE_TYPE_WIFI:
 500         case CONNMAN_DEVICE_TYPE_WIMAX:
 501                 name = index2ident(index, "");
 502                 addr = index2addr(index);
 503                 break;
 504         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 505         case CONNMAN_DEVICE_TYPE_CELLULAR:
 506         case CONNMAN_DEVICE_TYPE_GPS:
 507         case CONNMAN_DEVICE_TYPE_VENDOR:
 508                 name = strdup(devname);
 509                 break;
 510         }
 511
 512         device = connman_device_create(name, type);
 513         if (device == NULL)
 514                 goto done;
 515
 516         switch (type) {
 517         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 518         case CONNMAN_DEVICE_TYPE_VENDOR:
 519         case CONNMAN_DEVICE_TYPE_GPS:
 520                 break;
 521         case CONNMAN_DEVICE_TYPE_ETHERNET:
 522         case CONNMAN_DEVICE_TYPE_GADGET:
 523                 ident = index2ident(index, NULL);
 524                 break;
 525         case CONNMAN_DEVICE_TYPE_WIFI:
 526         case CONNMAN_DEVICE_TYPE_WIMAX:
 527                 ident = index2ident(index, NULL);
 528                 break;
 529         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 530                 break;
 531         case CONNMAN_DEVICE_TYPE_CELLULAR:
 532                 ident = index2ident(index, NULL);
 533                 break;
 534         }
 535
 536         connman_device_set_index(device, index);
 537         connman_device_set_interface(device, devname);
 538
 539         if (ident != NULL) {
 540                 connman_device_set_ident(device, ident);
 541                 free(ident);
 542         }
 543
 544         connman_device_set_string(device, "Address", addr);
 545
 546 done:
 547         free(devname);
 548         free(name);
 549         free(addr);
 550
 551         return device;
 552 }
 553
 554 struct in6_ifreq {
 555         struct in6_addr ifr6_addr;
 556         __u32 ifr6_prefixlen;
 557         unsigned int ifr6_ifindex;
 558 };
 559
 560 int connman_inet_set_ipv6_address(int index,
 561                 struct connman_ipaddress *ipaddress)
 562 {
 563         int err;
 564         unsigned char prefix_len;
 565         const char *address;
 566
 567         if (ipaddress->local == NULL)
 568                 return 0;
 569
 570         prefix_len = ipaddress->prefixlen;
 571         address = ipaddress->local;
 572
 573         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 574
 575         err = __connman_inet_modify_address(RTM_NEWADDR,
 576                                 NLM_F_REPLACE | NLM_F_ACK, index, AF_INET6,
 577                                 address, NULL, prefix_len, NULL);
 578         if (err < 0) {
 579                 connman_error("%s: %s", __func__, strerror(-err));
 580                 return err;
 581         }
 582
 583         return 0;
 584 }
 585
 586 int connman_inet_set_address(int index, struct connman_ipaddress *ipaddress)
 587 {
 588         int err;
 589         unsigned char prefix_len;
 590         const char *address, *broadcast, *peer;
 591
 592         if (ipaddress->local == NULL)
 593                 return -1;
 594
 595         prefix_len = ipaddress->prefixlen;
 596         address = ipaddress->local;
 597         broadcast = ipaddress->broadcast;
 598         peer = ipaddress->peer;
 599
 600         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 601
 602         err = __connman_inet_modify_address(RTM_NEWADDR,
 603                                 NLM_F_REPLACE | NLM_F_ACK, index, AF_INET,
 604                                 address, peer, prefix_len, broadcast);
 605         if (err < 0) {
 606                 connman_error("%s: %s", __func__, strerror(-err));
 607                 return err;
 608         }
 609
 610         return 0;
 611 }
 612
 613 int connman_inet_clear_ipv6_address(int index, const char *address,
 614                                                         int prefix_len)
 615 {
 616         int err;
 617
 618         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 619
 620         err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET6,
 621                                 address, NULL, prefix_len, NULL);
 622         if (err < 0) {
 623                 connman_error("%s: %s", __func__, strerror(-err));
 624                 return err;
 625         }
 626
 627         return 0;
 628 }
 629
 630 int connman_inet_clear_address(int index, struct connman_ipaddress *ipaddress)
 631 {
 632         int err;
 633         unsigned char prefix_len;
 634         const char *address, *broadcast, *peer;
 635
 636         prefix_len = ipaddress->prefixlen;
 637         address = ipaddress->local;
 638         broadcast = ipaddress->broadcast;
 639         peer = ipaddress->peer;
 640
 641         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 642
 643         err = __connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET,
 644                                 address, peer, prefix_len, broadcast);
 645         if (err < 0) {
 646                 connman_error("%s: %s", __func__, strerror(-err));
 647                 return err;
 648         }
 649
 650         return 0;
 651 }
 652
 653 int connman_inet_add_host_route(int index, const char *host,
 654                                 const char *gateway)
 655 {
 656         return connman_inet_add_network_route(index, host, gateway, NULL);
 657 }
 658
 659 int connman_inet_del_host_route(int index, const char *host)
 660 {
 661         return connman_inet_del_network_route(index, host);
 662 }
 663
 664 int connman_inet_add_network_route(int index, const char *host,
 665                                         const char *gateway,
 666                                         const char *netmask)
 667 {
 668         struct ifreq ifr;
 669         struct rtentry rt;
 670         struct sockaddr_in addr;
 671         int sk, err;
 672
 673         DBG("index %d host %s gateway %s netmask %s", index,
 674                 host, gateway, netmask);
 675
 676         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 677         if (sk < 0)
 678                 return -1;
 679
 680         memset(&ifr, 0, sizeof(ifr));
 681         ifr.ifr_ifindex = index;
 682
 683         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 684                 close(sk);
 685                 return -1;
 686         }
 687
 688         DBG("ifname %s", ifr.ifr_name);
 689
 690         memset(&rt, 0, sizeof(rt));
 691         rt.rt_flags = RTF_UP;
 692         if (gateway != NULL)
 693                 rt.rt_flags |= RTF_GATEWAY;
 694         if (netmask == NULL)
 695                 rt.rt_flags |= RTF_HOST;
 696
 697         memset(&addr, 0, sizeof(addr));
 698         addr.sin_family = AF_INET;
 699         addr.sin_addr.s_addr = inet_addr(host);
 700         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 701
 702         memset(&addr, 0, sizeof(addr));
 703         addr.sin_family = AF_INET;
 704         if (gateway != NULL)
 705                 addr.sin_addr.s_addr = inet_addr(gateway);
 706         else
 707                 addr.sin_addr.s_addr = INADDR_ANY;
 708         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 709
 710         memset(&addr, 0, sizeof(addr));
 711         addr.sin_family = AF_INET;
 712         addr.sin_addr.s_addr = INADDR_ANY;
 713         if (netmask != NULL)
 714                 addr.sin_addr.s_addr = inet_addr(netmask);
 715         else
 716                 addr.sin_addr.s_addr = INADDR_ANY;
 717         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 718
 719         rt.rt_dev = ifr.ifr_name;
 720
 721         err = ioctl(sk, SIOCADDRT, &rt);
 722         if (err < 0)
 723                 connman_error("Adding host route failed (%s)",
 724                                                         strerror(errno));
 725
 726         close(sk);
 727
 728         return err;
 729 }
 730
 731 int connman_inet_del_network_route(int index, const char *host)
 732 {
 733         struct ifreq ifr;
 734         struct rtentry rt;
 735         struct sockaddr_in addr;
 736         int sk, err;
 737
 738         DBG("index %d host %s", index, host);
 739
 740         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 741         if (sk < 0)
 742                 return -1;
 743
 744         memset(&ifr, 0, sizeof(ifr));
 745         ifr.ifr_ifindex = index;
 746
 747         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 748                 close(sk);
 749                 return -1;
 750         }
 751
 752         DBG("ifname %s", ifr.ifr_name);
 753
 754         memset(&rt, 0, sizeof(rt));
 755         rt.rt_flags = RTF_UP | RTF_HOST;
 756
 757         memset(&addr, 0, sizeof(addr));
 758         addr.sin_family = AF_INET;
 759         addr.sin_addr.s_addr = inet_addr(host);
 760         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 761
 762         rt.rt_dev = ifr.ifr_name;
 763
 764         err = ioctl(sk, SIOCDELRT, &rt);
 765         if (err < 0)
 766                 connman_error("Deleting host route failed (%s)",
 767                                                         strerror(errno));
 768
 769         close(sk);
 770
 771         return err;
 772 }
 773
 774 int connman_inet_del_ipv6_network_route(int index, const char *host,
 775                                                 unsigned char prefix_len)
 776 {
 777         struct in6_rtmsg rt;
 778         int sk, err;
 779
 780         DBG("index %d host %s", index, host);
 781
 782         if (host == NULL)
 783                 return -EINVAL;
 784
 785         memset(&rt, 0, sizeof(rt));
 786
 787         rt.rtmsg_dst_len = prefix_len;
 788
 789         err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
 790         if (err < 0)
 791                 goto out;
 792
 793         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 794
 795         rt.rtmsg_metric = 1;
 796         rt.rtmsg_ifindex = index;
 797
 798         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 799         if (sk < 0) {
 800                 err = -1;
 801                 goto out;
 802         }
 803
 804         err = ioctl(sk, SIOCDELRT, &rt);
 805         close(sk);
 806 out:
 807         if (err < 0)
 808                 connman_error("Del IPv6 host route error (%s)",
 809                                                 strerror(errno));
 810
 811         return err;
 812 }
 813
 814 int connman_inet_del_ipv6_host_route(int index, const char *host)
 815 {
 816         return connman_inet_del_ipv6_network_route(index, host, 128);
 817 }
 818
 819 int connman_inet_add_ipv6_network_route(int index, const char *host,
 820                                         const char *gateway,
 821                                         unsigned char prefix_len)
 822 {
 823         struct in6_rtmsg rt;
 824         int sk, err;
 825
 826         DBG("index %d host %s gateway %s", index, host, gateway);
 827
 828         if (host == NULL)
 829                 return -EINVAL;
 830
 831         memset(&rt, 0, sizeof(rt));
 832
 833         rt.rtmsg_dst_len = prefix_len;
 834
 835         err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
 836         if (err < 0)
 837                 goto out;
 838
 839         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 840
 841         if (gateway != NULL) {
 842                 rt.rtmsg_flags |= RTF_GATEWAY;
 843                 inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 844         }
 845
 846         rt.rtmsg_metric = 1;
 847         rt.rtmsg_ifindex = index;
 848
 849         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 850         if (sk < 0) {
 851                 err = -1;
 852                 goto out;
 853         }
 854
 855         err = ioctl(sk, SIOCADDRT, &rt);
 856         close(sk);
 857 out:
 858         if (err < 0)
 859                 connman_error("Set IPv6 host route error (%s)",
 860                                                 strerror(errno));
 861
 862         return err;
 863 }
 864
 865 int connman_inet_add_ipv6_host_route(int index, const char *host,
 866                                         const char *gateway)
 867 {
 868         return connman_inet_add_ipv6_network_route(index, host, gateway, 128);
 869 }
 870
 871 int connman_inet_set_ipv6_gateway_address(int index, const char *gateway)
 872 {
 873         struct in6_rtmsg rt;
 874         int sk, err;
 875
 876         DBG("index %d gateway %s", index, gateway);
 877
 878         if (gateway == NULL)
 879                 return -EINVAL;
 880
 881         memset(&rt, 0, sizeof(rt));
 882
 883         err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 884         if (err < 0)
 885                 goto out;
 886
 887         rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
 888         rt.rtmsg_metric = 1;
 889         rt.rtmsg_dst_len = 0;
 890         rt.rtmsg_ifindex = index;
 891
 892         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 893         if (sk < 0) {
 894                 err = -1;
 895                 goto out;
 896         }
 897
 898         err = ioctl(sk, SIOCADDRT, &rt);
 899         close(sk);
 900 out:
 901         if (err < 0)
 902                 connman_error("Set default IPv6 gateway error (%s)",
 903                                                 strerror(errno));
 904
 905         return err;
 906 }
 907
 908 int connman_inet_clear_ipv6_gateway_address(int index, const char *gateway)
 909 {
 910         struct in6_rtmsg rt;
 911         int sk, err;
 912
 913         DBG("index %d gateway %s", index, gateway);
 914
 915         if (gateway == NULL)
 916                 return -EINVAL;
 917
 918         memset(&rt, 0, sizeof(rt));
 919
 920         err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 921         if (err < 0)
 922                 goto out;
 923
 924         rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
 925         rt.rtmsg_metric = 1;
 926         rt.rtmsg_dst_len = 0;
 927         rt.rtmsg_ifindex = index;
 928
 929         sk = socket(AF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 930         if (sk < 0) {
 931                 err = -1;
 932                 goto out;
 933         }
 934
 935         err = ioctl(sk, SIOCDELRT, &rt);
 936         close(sk);
 937 out:
 938         if (err < 0)
 939                 connman_error("Clear default IPv6 gateway error (%s)",
 940                                                 strerror(errno));
 941
 942         return err;
 943 }
 944
 945 int connman_inet_set_gateway_address(int index, const char *gateway)
 946 {
 947         struct ifreq ifr;
 948         struct rtentry rt;
 949         struct sockaddr_in addr;
 950         int sk, err;
 951
 952         DBG("index %d gateway %s", index, gateway);
 953
 954         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
 955         if (sk < 0)
 956                 return -1;
 957
 958         memset(&ifr, 0, sizeof(ifr));
 959         ifr.ifr_ifindex = index;
 960
 961         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 962                 close(sk);
 963                 return -1;
 964         }
 965
 966         DBG("ifname %s", ifr.ifr_name);
 967
 968         memset(&rt, 0, sizeof(rt));
 969         rt.rt_flags = RTF_UP | RTF_GATEWAY;
 970
 971         memset(&addr, 0, sizeof(addr));
 972         addr.sin_family = AF_INET;
 973         addr.sin_addr.s_addr = INADDR_ANY;
 974         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 975
 976         memset(&addr, 0, sizeof(addr));
 977         addr.sin_family = AF_INET;
 978         addr.sin_addr.s_addr = inet_addr(gateway);
 979         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 980
 981         memset(&addr, 0, sizeof(addr));
 982         addr.sin_family = AF_INET;
 983         addr.sin_addr.s_addr = INADDR_ANY;
 984         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 985
 986         err = ioctl(sk, SIOCADDRT, &rt);
 987         if (err < 0)
 988                 connman_error("Setting default gateway route failed (%s)",
 989                                                         strerror(errno));
 990
 991         close(sk);
 992
 993         return err;
 994 }
 995
 996 int connman_inet_set_gateway_interface(int index)
 997 {
 998         struct ifreq ifr;
 999         struct rtentry rt;
1000         struct sockaddr_in addr;
1001         int sk, err;
1002
1003         DBG("index %d", index);
1004
1005         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1006         if (sk < 0)
1007                 return -1;
1008
1009         memset(&ifr, 0, sizeof(ifr));
1010         ifr.ifr_ifindex = index;
1011
1012         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1013                 close(sk);
1014                 return -1;
1015         }
1016
1017         DBG("ifname %s", ifr.ifr_name);
1018
1019         memset(&rt, 0, sizeof(rt));
1020         rt.rt_flags = RTF_UP;
1021
1022         memset(&addr, 0, sizeof(addr));
1023         addr.sin_family = AF_INET;
1024         addr.sin_addr.s_addr = INADDR_ANY;
1025
1026         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1027         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1028         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1029
1030         rt.rt_dev = ifr.ifr_name;
1031
1032         err = ioctl(sk, SIOCADDRT, &rt);
1033         if (err < 0)
1034                 connman_error("Setting default interface route failed (%s)",
1035                                                         strerror(errno));
1036         close(sk);
1037
1038         return err;
1039 }
1040
1041 int connman_inet_set_ipv6_gateway_interface(int index)
1042 {
1043         struct ifreq ifr;
1044         struct rtentry rt;
1045         struct sockaddr_in6 addr;
1046         const struct in6_addr any = IN6ADDR_ANY_INIT;
1047         int sk, err;
1048
1049         DBG("index %d", index);
1050
1051         sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1052         if (sk < 0)
1053                 return -1;
1054
1055         memset(&ifr, 0, sizeof(ifr));
1056         ifr.ifr_ifindex = index;
1057
1058         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1059                 close(sk);
1060                 return -1;
1061         }
1062
1063         DBG("ifname %s", ifr.ifr_name);
1064
1065         memset(&rt, 0, sizeof(rt));
1066         rt.rt_flags = RTF_UP;
1067
1068         memset(&addr, 0, sizeof(addr));
1069         addr.sin6_family = AF_INET6;
1070         addr.sin6_addr = any;
1071
1072         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1073         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1074         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1075
1076         rt.rt_dev = ifr.ifr_name;
1077
1078         err = ioctl(sk, SIOCADDRT, &rt);
1079         if (err < 0)
1080                 connman_error("Setting default interface route failed (%s)",
1081                                                         strerror(errno));
1082         close(sk);
1083
1084         return err;
1085 }
1086
1087 int connman_inet_clear_gateway_address(int index, const char *gateway)
1088 {
1089         struct ifreq ifr;
1090         struct rtentry rt;
1091         struct sockaddr_in addr;
1092         int sk, err;
1093
1094         DBG("index %d gateway %s", index, gateway);
1095
1096         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1097         if (sk < 0)
1098                 return -1;
1099
1100         memset(&ifr, 0, sizeof(ifr));
1101         ifr.ifr_ifindex = index;
1102
1103         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1104                 close(sk);
1105                 return -1;
1106         }
1107
1108         DBG("ifname %s", ifr.ifr_name);
1109
1110         memset(&rt, 0, sizeof(rt));
1111         rt.rt_flags = RTF_UP | RTF_GATEWAY;
1112
1113         memset(&addr, 0, sizeof(addr));
1114         addr.sin_family = AF_INET;
1115         addr.sin_addr.s_addr = INADDR_ANY;
1116         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1117
1118         memset(&addr, 0, sizeof(addr));
1119         addr.sin_family = AF_INET;
1120         addr.sin_addr.s_addr = inet_addr(gateway);
1121         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1122
1123         memset(&addr, 0, sizeof(addr));
1124         addr.sin_family = AF_INET;
1125         addr.sin_addr.s_addr = INADDR_ANY;
1126         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1127
1128         err = ioctl(sk, SIOCDELRT, &rt);
1129         if (err < 0)
1130                 connman_error("Removing default gateway route failed (%s)",
1131                                                         strerror(errno));
1132
1133         close(sk);
1134
1135         return err;
1136 }
1137
1138 int connman_inet_clear_gateway_interface(int index)
1139 {
1140         struct ifreq ifr;
1141         struct rtentry rt;
1142         struct sockaddr_in addr;
1143         int sk, err;
1144
1145         DBG("index %d", index);
1146
1147         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1148         if (sk < 0)
1149                 return -1;
1150
1151         memset(&ifr, 0, sizeof(ifr));
1152         ifr.ifr_ifindex = index;
1153
1154         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1155                 close(sk);
1156                 return -1;
1157         }
1158
1159         DBG("ifname %s", ifr.ifr_name);
1160
1161         memset(&rt, 0, sizeof(rt));
1162         rt.rt_flags = RTF_UP;
1163
1164         memset(&addr, 0, sizeof(addr));
1165         addr.sin_family = AF_INET;
1166         addr.sin_addr.s_addr = INADDR_ANY;
1167
1168         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1169         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1170         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1171
1172         rt.rt_dev = ifr.ifr_name;
1173
1174         err = ioctl(sk, SIOCDELRT, &rt);
1175         if (err < 0)
1176                 connman_error("Removing default interface route failed (%s)",
1177                                                         strerror(errno));
1178         close(sk);
1179
1180         return err;
1181 }
1182
1183 int connman_inet_clear_ipv6_gateway_interface(int index)
1184 {
1185         struct ifreq ifr;
1186         struct rtentry rt;
1187         struct sockaddr_in6 addr;
1188         const struct in6_addr any = IN6ADDR_ANY_INIT;
1189         int sk, err;
1190
1191         DBG("index %d", index);
1192
1193         sk = socket(PF_INET6, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1194         if (sk < 0)
1195                 return -1;
1196
1197         memset(&ifr, 0, sizeof(ifr));
1198         ifr.ifr_ifindex = index;
1199
1200         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1201                 close(sk);
1202                 return -1;
1203         }
1204
1205         DBG("ifname %s", ifr.ifr_name);
1206
1207         memset(&rt, 0, sizeof(rt));
1208         rt.rt_flags = RTF_UP;
1209
1210         memset(&addr, 0, sizeof(addr));
1211         addr.sin6_family = AF_INET6;
1212         addr.sin6_addr = any;
1213
1214         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1215         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1216         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1217
1218         rt.rt_dev = ifr.ifr_name;
1219
1220         err = ioctl(sk, SIOCDELRT, &rt);
1221         if (err < 0)
1222                 connman_error("Removing default interface route failed (%s)",
1223                                                         strerror(errno));
1224         close(sk);
1225
1226         return err;
1227 }
1228
1229 connman_bool_t connman_inet_compare_subnet(int index, const char *host)
1230 {
1231         struct ifreq ifr;
1232         struct in_addr _host_addr;
1233         in_addr_t host_addr, netmask_addr, if_addr;
1234         struct sockaddr_in *netmask, *addr;
1235         int sk;
1236
1237         DBG("host %s", host);
1238
1239         if (host == NULL)
1240                 return FALSE;
1241
1242         if (inet_aton(host, &_host_addr) == 0)
1243                 return -1;
1244         host_addr = _host_addr.s_addr;
1245
1246         sk = socket(PF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1247         if (sk < 0)
1248                 return FALSE;
1249
1250         memset(&ifr, 0, sizeof(ifr));
1251         ifr.ifr_ifindex = index;
1252
1253         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1254                 close(sk);
1255                 return FALSE;
1256         }
1257
1258         if (ioctl(sk, SIOCGIFNETMASK, &ifr) < 0) {
1259                 close(sk);
1260                 return FALSE;
1261         }
1262
1263         netmask = (struct sockaddr_in *)&ifr.ifr_netmask;
1264         netmask_addr = netmask->sin_addr.s_addr;
1265
1266         if (ioctl(sk, SIOCGIFADDR, &ifr) < 0) {
1267                 close(sk);
1268                 return FALSE;
1269         }
1270
1271         close(sk);
1272
1273         addr = (struct sockaddr_in *)&ifr.ifr_addr;
1274         if_addr = addr->sin_addr.s_addr;
1275
1276         return ((if_addr & netmask_addr) == (host_addr & netmask_addr));
1277 }
1278
1279 int connman_inet_remove_from_bridge(int index, const char *bridge)
1280 {
1281         struct ifreq ifr;
1282         int sk, err;
1283
1284         if (bridge == NULL)
1285                 return -EINVAL;
1286
1287         sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
1288         if (sk < 0)
1289                 return sk;
1290
1291         memset(&ifr, 0, sizeof(ifr));
1292         strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1293         ifr.ifr_ifindex = index;
1294
1295         err = ioctl(sk, SIOCBRDELIF, &ifr);
1296
1297         close(sk);
1298
1299         if (err < 0) {
1300                 connman_error("Remove interface from bridge error %s",
1301                                                         strerror(errno));
1302                 return err;
1303         }
1304
1305         return 0;
1306 }
1307
1308 int connman_inet_add_to_bridge(int index, const char *bridge)
1309 {
1310         struct ifreq ifr;
1311         int sk, err;
1312
1313         if (bridge == NULL)
1314                 return -EINVAL;
1315
1316         sk = socket(AF_INET, SOCK_STREAM | SOCK_CLOEXEC, 0);
1317         if (sk < 0)
1318                 return sk;
1319
1320         memset(&ifr, 0, sizeof(ifr));
1321         strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1322         ifr.ifr_ifindex = index;
1323
1324         err = ioctl(sk, SIOCBRADDIF, &ifr);
1325
1326         close(sk);
1327
1328         if (err < 0) {
1329                 connman_error("Add interface to bridge error %s",
1330                                                         strerror(errno));
1331                 return err;
1332         }
1333
1334         return 0;
1335 }
1336
1337 int connman_inet_set_mtu(int index, int mtu)
1338 {
1339         struct ifreq ifr;
1340         int sk, err;
1341
1342         sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1343         if (sk < 0)
1344                 return sk;
1345
1346         memset(&ifr, 0, sizeof(ifr));
1347         ifr.ifr_ifindex = index;
1348
1349         err = ioctl(sk, SIOCGIFNAME, &ifr);
1350         if (err == 0) {
1351                 ifr.ifr_mtu = mtu;
1352                 err = ioctl(sk, SIOCSIFMTU, &ifr);
1353         }
1354
1355         close(sk);
1356         return err;
1357 }
1358
1359 int connman_inet_setup_tunnel(char *tunnel, int mtu)
1360 {
1361         struct ifreq ifr;
1362         int sk, err, index;
1363         __u32 mask;
1364         __u32 flags;
1365
1366         if (tunnel == NULL)
1367                 return -EINVAL;
1368
1369         sk = socket(AF_INET, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1370         if (sk < 0)
1371                 return sk;
1372
1373         index = if_nametoindex(tunnel);
1374
1375         err = connman_inet_set_mtu(index, mtu);
1376         if (err < 0)
1377                 return err;
1378         else if (err)
1379                 goto done;
1380
1381         memset(&ifr, 0, sizeof(ifr));
1382         strncpy(ifr.ifr_name, tunnel, IFNAMSIZ);
1383         err = ioctl(sk, SIOCGIFFLAGS, &ifr);
1384         if (err)
1385                 goto done;
1386
1387         mask = IFF_UP;
1388         flags = IFF_UP;
1389
1390         if ((ifr.ifr_flags ^ flags) & mask) {
1391                 ifr.ifr_flags &= ~mask;
1392                 ifr.ifr_flags |= mask & flags;
1393                 err = ioctl(sk, SIOCSIFFLAGS, &ifr);
1394                 if (err)
1395                         connman_error("SIOCSIFFLAGS failed: %s",
1396                                                         strerror(errno));
1397         }
1398
1399 done:
1400         close(sk);
1401         return err;
1402 }
1403
1404 int connman_inet_create_tunnel(char **iface)
1405 {
1406         struct ifreq ifr;
1407         int i, fd;
1408
1409         fd = open("/dev/net/tun", O_RDWR | O_CLOEXEC);
1410         if (fd < 0) {
1411                 i = -errno;
1412                 connman_error("Failed to open /dev/net/tun: %s",
1413                                 strerror(errno));
1414                 return i;
1415         }
1416
1417         memset(&ifr, 0, sizeof(ifr));
1418         ifr.ifr_flags = IFF_TUN | IFF_NO_PI;
1419
1420         for (i = 0; i < 256; i++) {
1421                 sprintf(ifr.ifr_name, "tun%d", i);
1422
1423                 if (!ioctl(fd, TUNSETIFF, (void *)&ifr))
1424                         break;
1425         }
1426
1427         if (i == 256) {
1428                 connman_error("Failed to find available tun device");
1429                 close(fd);
1430                 return -ENODEV;
1431         }
1432
1433         *iface = g_strdup(ifr.ifr_name);
1434
1435         return fd;
1436 }
1437
1438 struct rs_cb_data {
1439         GIOChannel *channel;
1440         __connman_inet_rs_cb_t callback;
1441         struct sockaddr_in6 addr;
1442         guint rs_timeout;
1443         guint watch_id;
1444         void *user_data;
1445 };
1446
1447 #define CMSG_BUF_LEN 512
1448 #define IN6ADDR_ALL_NODES_MC_INIT \
1449         { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x1 } } } /* ff02::1 */
1450 #define IN6ADDR_ALL_ROUTERS_MC_INIT \
1451         { { { 0xff,0x02,0,0,0,0,0,0,0,0,0,0,0,0,0,0x2 } } } /* ff02::2 */
1452
1453 static const struct in6_addr in6addr_all_nodes_mc = IN6ADDR_ALL_NODES_MC_INIT;
1454 static const struct in6_addr in6addr_all_routers_mc =
1455                                                 IN6ADDR_ALL_ROUTERS_MC_INIT;
1456
1457 static void rs_cleanup(struct rs_cb_data *data)
1458 {
1459         if (data->channel != NULL) {
1460                 g_io_channel_shutdown(data->channel, TRUE, NULL);
1461                 g_io_channel_unref(data->channel);
1462                 data->channel = NULL;
1463         }
1464
1465         if (data->rs_timeout > 0)
1466                 g_source_remove(data->rs_timeout);
1467
1468         if (data->watch_id > 0)
1469                 g_source_remove(data->watch_id);
1470
1471         g_free(data);
1472 }
1473
1474 static gboolean rs_timeout_cb(gpointer user_data)
1475 {
1476         struct rs_cb_data *data = user_data;
1477
1478         DBG("user data %p", user_data);
1479
1480         if (data == NULL)
1481                 return FALSE;
1482
1483         if (data->callback != NULL)
1484                 data->callback(NULL, 0, data->user_data);
1485
1486         data->rs_timeout = 0;
1487         rs_cleanup(data);
1488         return FALSE;
1489 }
1490
1491 static int icmpv6_recv(int fd, gpointer user_data)
1492 {
1493         struct msghdr mhdr;
1494         struct iovec iov;
1495         unsigned char chdr[CMSG_BUF_LEN];
1496         unsigned char buf[1540];
1497         struct rs_cb_data *data = user_data;
1498         struct nd_router_advert *hdr;
1499         struct sockaddr_in6 saddr;
1500         ssize_t len;
1501
1502         DBG("");
1503
1504         iov.iov_len = sizeof(buf);
1505         iov.iov_base = buf;
1506
1507         mhdr.msg_name = (void *)&saddr;
1508         mhdr.msg_namelen = sizeof(struct sockaddr_in6);
1509         mhdr.msg_iov = &iov;
1510         mhdr.msg_iovlen = 1;
1511         mhdr.msg_control = (void *)chdr;
1512         mhdr.msg_controllen = CMSG_BUF_LEN;
1513
1514         len = recvmsg(fd, &mhdr, 0);
1515         if (len < 0) {
1516                 data->callback(NULL, 0, data->user_data);
1517                 rs_cleanup(data);
1518                 return -errno;
1519         }
1520
1521         hdr = (struct nd_router_advert *)buf;
1522         DBG("code %d len %zd hdr %zd", hdr->nd_ra_code, len,
1523                                 sizeof(struct nd_router_advert));
1524         if (hdr->nd_ra_code != 0)
1525                 return 0;
1526
1527         data->callback(hdr, len, data->user_data);
1528         rs_cleanup(data);
1529
1530         return len;
1531 }
1532
1533 static gboolean icmpv6_event(GIOChannel *chan, GIOCondition cond,
1534                                                                 gpointer data)
1535 {
1536         int fd, ret;
1537
1538         DBG("");
1539
1540         if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
1541                 return FALSE;
1542
1543         fd = g_io_channel_unix_get_fd(chan);
1544         ret = icmpv6_recv(fd, data);
1545         if (ret == 0)
1546                 return TRUE;
1547
1548         return FALSE;
1549 }
1550
1551 /* Adapted from RFC 1071 "C" Implementation Example */
1552 static uint16_t csum(const void *phdr, const void *data, socklen_t datalen)
1553 {
1554         register unsigned long sum = 0;
1555         socklen_t count;
1556         uint16_t *addr;
1557         int i;
1558
1559         /* caller must make sure datalen is even */
1560
1561         addr = (uint16_t *)phdr;
1562         for (i = 0; i < 20; i++)
1563                 sum += *addr++;
1564
1565         count = datalen;
1566         addr = (uint16_t *)data;
1567
1568         while (count > 1) {
1569                 sum += *(addr++);
1570                 count -= 2;
1571         }
1572
1573         while (sum >> 16)
1574                 sum = (sum & 0xffff) + (sum >> 16);
1575
1576         return (uint16_t)~sum;
1577 }
1578
1579 static int ndisc_send_unspec(int type, int oif, const struct in6_addr *dest)
1580 {
1581         struct _phdr {
1582                 struct in6_addr src;
1583                 struct in6_addr dst;
1584                 uint32_t plen;
1585                 uint8_t reserved[3];
1586                 uint8_t nxt;
1587         } phdr;
1588
1589         struct {
1590                 struct ip6_hdr ip;
1591                 union {
1592                         struct icmp6_hdr icmp;
1593                         struct nd_neighbor_solicit ns;
1594                         struct nd_router_solicit rs;
1595                 } i;
1596         } frame;
1597
1598         struct msghdr msgh;
1599         struct cmsghdr *cmsg;
1600         struct in6_pktinfo *pinfo;
1601         struct sockaddr_in6 dst;
1602         char cbuf[CMSG_SPACE(sizeof(*pinfo))];
1603         struct iovec iov;
1604         int fd, datalen, ret;
1605
1606         DBG("");
1607
1608         fd = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_RAW);
1609         if (fd < 0)
1610                 return -errno;
1611
1612         memset(&frame, 0, sizeof(frame));
1613         memset(&dst, 0, sizeof(dst));
1614
1615         datalen = sizeof(frame.i.rs); /* 8, csum() safe */
1616         dst.sin6_addr = *dest;
1617
1618         /* Fill in the IPv6 header */
1619         frame.ip.ip6_vfc = 0x60;
1620         frame.ip.ip6_plen = htons(datalen);
1621         frame.ip.ip6_nxt = IPPROTO_ICMPV6;
1622         frame.ip.ip6_hlim = 255;
1623         frame.ip.ip6_dst = dst.sin6_addr;
1624         /* all other fields are already set to zero */
1625
1626         /* Prepare pseudo header for csum */
1627         memset(&phdr, 0, sizeof(phdr));
1628         phdr.dst = dst.sin6_addr;
1629         phdr.plen = htonl(datalen);
1630         phdr.nxt = IPPROTO_ICMPV6;
1631
1632         /* Fill in remaining ICMP header fields */
1633         frame.i.icmp.icmp6_type = type;
1634         frame.i.icmp.icmp6_cksum = csum(&phdr, &frame.i, datalen);
1635
1636         iov.iov_base = &frame;
1637         iov.iov_len = sizeof(frame.ip) + datalen;
1638
1639         dst.sin6_family = AF_INET6;
1640         msgh.msg_name = &dst;
1641         msgh.msg_namelen = sizeof(dst);
1642         msgh.msg_iov = &iov;
1643         msgh.msg_iovlen = 1;
1644         msgh.msg_flags = 0;
1645
1646         memset(cbuf, 0, CMSG_SPACE(sizeof(*pinfo)));
1647         cmsg = (struct cmsghdr *)cbuf;
1648         pinfo = (struct in6_pktinfo *)CMSG_DATA(cmsg);
1649         pinfo->ipi6_ifindex = oif;
1650
1651         cmsg->cmsg_len = CMSG_LEN(sizeof(*pinfo));
1652         cmsg->cmsg_level = IPPROTO_IPV6;
1653         cmsg->cmsg_type = IPV6_PKTINFO;
1654         msgh.msg_control = cmsg;
1655         msgh.msg_controllen = cmsg->cmsg_len;
1656
1657         ret = sendmsg(fd, &msgh, 0);
1658
1659         close(fd);
1660         return ret;
1661 }
1662
1663 static inline void ipv6_addr_set(struct in6_addr *addr,
1664                                 uint32_t w1, uint32_t w2,
1665                                 uint32_t w3, uint32_t w4)
1666 {
1667         addr->s6_addr32[0] = w1;
1668         addr->s6_addr32[1] = w2;
1669         addr->s6_addr32[2] = w3;
1670         addr->s6_addr32[3] = w4;
1671 }
1672
1673 static inline void ipv6_addr_solict_mult(const struct in6_addr *addr,
1674                                         struct in6_addr *solicited)
1675 {
1676         ipv6_addr_set(solicited, htonl(0xFF020000), 0, htonl(0x1),
1677                         htonl(0xFF000000) | addr->s6_addr32[3]);
1678 }
1679
1680 static int if_mc_group(int sock, int ifindex, const struct in6_addr *mc_addr,
1681                                                                 int cmd)
1682 {
1683         unsigned int val = 0;
1684         struct ipv6_mreq mreq;
1685         int ret;
1686
1687         memset(&mreq, 0, sizeof(mreq));
1688         mreq.ipv6mr_interface = ifindex;
1689         mreq.ipv6mr_multiaddr = *mc_addr;
1690
1691         ret = setsockopt(sock, IPPROTO_IPV6, IPV6_MULTICAST_LOOP,
1692                         &val, sizeof(int));
1693
1694         if (ret < 0)
1695                 return ret;
1696
1697         return setsockopt(sock, IPPROTO_IPV6, cmd, &mreq, sizeof(mreq));
1698 }
1699
1700 int __connman_inet_ipv6_send_rs(int index, int timeout,
1701                         __connman_inet_rs_cb_t callback, void *user_data)
1702 {
1703         struct rs_cb_data *data;
1704         struct icmp6_filter filter;
1705         struct in6_addr solicit;
1706         struct in6_addr dst = in6addr_all_routers_mc;
1707         int sk;
1708
1709         DBG("");
1710
1711         if (timeout <= 0)
1712                 return -EINVAL;
1713
1714         data = g_try_malloc0(sizeof(struct rs_cb_data));
1715         if (data == NULL)
1716                 return -ENOMEM;
1717
1718         data->callback = callback;
1719         data->user_data = user_data;
1720         data->rs_timeout = g_timeout_add_seconds(timeout, rs_timeout_cb, data);
1721
1722         sk = socket(AF_INET6, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_ICMPV6);
1723         if (sk < 0)
1724                 return -errno;
1725
1726         ICMP6_FILTER_SETBLOCKALL(&filter);
1727         ICMP6_FILTER_SETPASS(ND_ROUTER_ADVERT, &filter);
1728
1729         setsockopt(sk, IPPROTO_ICMPV6, ICMP6_FILTER, &filter,
1730                                                 sizeof(struct icmp6_filter));
1731
1732         ipv6_addr_solict_mult(&dst, &solicit);
1733         if_mc_group(sk, index, &in6addr_all_nodes_mc, IPV6_JOIN_GROUP);
1734         if_mc_group(sk, index, &solicit, IPV6_JOIN_GROUP);
1735
1736         data->channel = g_io_channel_unix_new(sk);
1737         g_io_channel_set_close_on_unref(data->channel, TRUE);
1738
1739         g_io_channel_set_encoding(data->channel, NULL, NULL);
1740         g_io_channel_set_buffered(data->channel, FALSE);
1741
1742         data->watch_id = g_io_add_watch(data->channel,
1743                         G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
1744                         icmpv6_event, data);
1745
1746         ndisc_send_unspec(ND_ROUTER_SOLICIT, index, &dst);
1747
1748         return 0;
1749 }
1750
1751 GSList *__connman_inet_ipv6_get_prefixes(struct nd_router_advert *hdr,
1752                                         unsigned int length)
1753 {
1754         GSList *prefixes = NULL;
1755         uint8_t *pos;
1756         int len;
1757
1758         if (length <= sizeof(struct nd_router_advert))
1759                 return NULL;
1760
1761         len = length - sizeof(struct nd_router_advert);
1762         pos = (uint8_t *)hdr + sizeof(struct nd_router_advert);
1763
1764         while (len > 0) {
1765                 struct nd_opt_prefix_info *pinfo;
1766                 char prefix_str[INET6_ADDRSTRLEN+1], *str;
1767                 const char *prefix;
1768                 int optlen;
1769
1770                 if (len < 2)
1771                         break;
1772
1773                 optlen = pos[1] << 3;
1774                 if (optlen == 0 || optlen > len)
1775                         break;
1776
1777                 switch (pos[0]) {
1778                 case ND_OPT_PREFIX_INFORMATION:
1779                         pinfo = (struct nd_opt_prefix_info *)pos;
1780                         prefix = inet_ntop(AF_INET6, &pinfo->nd_opt_pi_prefix,
1781                                         prefix_str, INET6_ADDRSTRLEN);
1782                         if (prefix == NULL)
1783                                 break;
1784
1785                         str = g_strdup_printf("%s/%d", prefix,
1786                                                 pinfo->nd_opt_pi_prefix_len);
1787                         prefixes = g_slist_append(prefixes, str);
1788
1789                         DBG("prefix %s", str);
1790
1791                         break;
1792                 }
1793
1794                 len -= optlen;
1795                 pos += optlen;
1796         }
1797
1798         return prefixes;
1799 }
1800
1801 static int get_dest_addr(int family, int index, char *buf, int len)
1802 {
1803         struct ifreq ifr;
1804         void *addr;
1805         int sk;
1806
1807         sk = socket(family, SOCK_DGRAM | SOCK_CLOEXEC, 0);
1808         if (sk < 0)
1809                 return -errno;
1810
1811         memset(&ifr, 0, sizeof(ifr));
1812         ifr.ifr_ifindex = index;
1813
1814         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1815                 DBG("SIOCGIFNAME (%d/%s)", errno, strerror(errno));
1816                 close(sk);
1817                 return -errno;
1818         }
1819
1820         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
1821                 DBG("SIOCGIFFLAGS (%d/%s)", errno, strerror(errno));
1822                 close(sk);
1823                 return -errno;
1824         }
1825
1826         if ((ifr.ifr_flags & IFF_POINTOPOINT) == 0) {
1827                 close(sk);
1828                 errno = EINVAL;
1829                 return -errno;
1830         }
1831
1832         DBG("index %d %s", index, ifr.ifr_name);
1833
1834         if (ioctl(sk, SIOCGIFDSTADDR, &ifr) < 0) {
1835                 connman_error("Get destination address failed (%s)",
1836                                                         strerror(errno));
1837                 close(sk);
1838                 return -errno;
1839         }
1840
1841         close(sk);
1842
1843         switch (family) {
1844         case AF_INET:
1845                 addr = &((struct sockaddr_in *)&ifr.ifr_dstaddr)->sin_addr;
1846                 break;
1847         case AF_INET6:
1848                 addr = &((struct sockaddr_in6 *)&ifr.ifr_dstaddr)->sin6_addr;
1849                 break;
1850         default:
1851                 errno = EINVAL;
1852                 return -errno;
1853         }
1854
1855         if (inet_ntop(family, addr, buf, len) == NULL) {
1856                 DBG("error %d/%s", errno, strerror(errno));
1857                 return -errno;
1858         }
1859
1860         return 0;
1861 }
1862
1863 int connman_inet_get_dest_addr(int index, char **dest)
1864 {
1865         char addr[INET_ADDRSTRLEN];
1866         int ret;
1867
1868         ret = get_dest_addr(PF_INET, index, addr, INET_ADDRSTRLEN);
1869         if (ret < 0)
1870                 return ret;
1871
1872         *dest = g_strdup(addr);
1873
1874         DBG("destination %s", *dest);
1875
1876         return 0;
1877 }
1878
1879 int connman_inet_ipv6_get_dest_addr(int index, char **dest)
1880 {
1881         char addr[INET6_ADDRSTRLEN];
1882         int ret;
1883
1884         ret = get_dest_addr(PF_INET6, index, addr, INET6_ADDRSTRLEN);
1885         if (ret < 0)
1886                 return ret;
1887
1888         *dest = g_strdup(addr);
1889
1890         DBG("destination %s", *dest);
1891
1892         return 0;
1893 }
1894
1895 int __connman_inet_rtnl_open(struct __connman_inet_rtnl_handle *rth)
1896 {
1897         int sndbuf = 1024;
1898         int rcvbuf = 1024 * 4;
1899
1900         rth->fd = socket(AF_NETLINK, SOCK_RAW | SOCK_CLOEXEC, NETLINK_ROUTE);
1901         if (rth->fd < 0) {
1902                 connman_error("Can not open netlink socket: %s",
1903                                                 strerror(errno));
1904                 return -errno;
1905         }
1906
1907         if (setsockopt(rth->fd, SOL_SOCKET, SO_SNDBUF, &sndbuf,
1908                         sizeof(sndbuf)) < 0) {
1909                 connman_error("SO_SNDBUF: %s", strerror(errno));
1910                 return -errno;
1911         }
1912
1913         if (setsockopt(rth->fd, SOL_SOCKET, SO_RCVBUF, &rcvbuf,
1914                         sizeof(rcvbuf)) < 0) {
1915                 connman_error("SO_RCVBUF: %s", strerror(errno));
1916                 return -errno;
1917         }
1918
1919         memset(&rth->local, 0, sizeof(rth->local));
1920         rth->local.nl_family = AF_NETLINK;
1921         rth->local.nl_groups = 0;
1922
1923         if (bind(rth->fd, (struct sockaddr *)&rth->local,
1924                                                 sizeof(rth->local)) < 0) {
1925                 connman_error("Can not bind netlink socket: %s",
1926                                                         strerror(errno));
1927                 return -errno;
1928         }
1929
1930         rth->seq = time(NULL);
1931
1932         DBG("fd %d", rth->fd);
1933
1934         return 0;
1935 }
1936
1937 struct inet_rtnl_cb_data {
1938         GIOChannel *channel;
1939         __connman_inet_rtnl_cb_t callback;
1940         guint rtnl_timeout;
1941         guint watch_id;
1942         struct __connman_inet_rtnl_handle *rtnl;
1943         void *user_data;
1944 };
1945
1946 static void inet_rtnl_cleanup(struct inet_rtnl_cb_data *data)
1947 {
1948         struct __connman_inet_rtnl_handle *rth = data->rtnl;
1949
1950         if (data->channel != NULL) {
1951                 g_io_channel_shutdown(data->channel, TRUE, NULL);
1952                 g_io_channel_unref(data->channel);
1953                 data->channel = NULL;
1954         }
1955
1956         DBG("data %p", data);
1957
1958         if (data->rtnl_timeout > 0)
1959                 g_source_remove(data->rtnl_timeout);
1960
1961         if (data->watch_id > 0)
1962                 g_source_remove(data->watch_id);
1963
1964         if (rth != NULL) {
1965                 __connman_inet_rtnl_close(rth);
1966                 g_free(rth);
1967         }
1968
1969         g_free(data);
1970 }
1971
1972 static gboolean inet_rtnl_timeout_cb(gpointer user_data)
1973 {
1974         struct inet_rtnl_cb_data *data = user_data;
1975
1976         DBG("user data %p", user_data);
1977
1978         if (data == NULL)
1979                 return FALSE;
1980
1981         if (data->callback != NULL)
1982                 data->callback(NULL, data->user_data);
1983
1984         data->rtnl_timeout = 0;
1985         inet_rtnl_cleanup(data);
1986         return FALSE;
1987 }
1988
1989 static int inet_rtnl_recv(GIOChannel *chan, gpointer user_data)
1990 {
1991         struct inet_rtnl_cb_data *rtnl_data = user_data;
1992         struct __connman_inet_rtnl_handle *rth = rtnl_data->rtnl;
1993         struct nlmsghdr *h = NULL;
1994         unsigned char buf[4096];
1995         void *ptr = buf;
1996         gsize len;
1997         int status;
1998
1999         memset(buf, 0, sizeof(buf));
2000
2001         status = g_io_channel_read_chars(chan, (gchar *) buf,
2002                                                 sizeof(buf), &len, NULL);
2003
2004         DBG("status %d", status);
2005
2006         switch (status) {
2007         case G_IO_STATUS_NORMAL:
2008                 break;
2009         case G_IO_STATUS_AGAIN:
2010                 return 0;
2011         default:
2012                 return -1;
2013         }
2014
2015         while (len > 0) {
2016                 struct nlmsgerr *err;
2017
2018                 h = ptr;
2019
2020                 if (!NLMSG_OK(h, len)) {
2021                         return -1;
2022                         break;
2023                 }
2024
2025                 if (h->nlmsg_seq != rth->seq) {
2026                         /* Skip this msg */
2027                         DBG("skip %d/%d len %d", rth->seq,
2028                                 h->nlmsg_seq, h->nlmsg_len);
2029
2030                         len -= h->nlmsg_len;
2031                         ptr += h->nlmsg_len;
2032                         continue;
2033                 }
2034
2035                 switch (h->nlmsg_type) {
2036                 case NLMSG_NOOP:
2037                 case NLMSG_OVERRUN:
2038                         return -1;
2039
2040                 case NLMSG_ERROR:
2041                         err = (struct nlmsgerr *)NLMSG_DATA(h);
2042                         connman_error("RTNETLINK answers %s (%d)",
2043                                 strerror(-err->error), -err->error);
2044                         return err->error;
2045                 }
2046
2047                 break;
2048         }
2049
2050         if (h->nlmsg_seq == rth->seq) {
2051                 DBG("received %d seq %d", h->nlmsg_len, h->nlmsg_seq);
2052
2053                 rtnl_data->callback(h, rtnl_data->user_data);
2054
2055                 if (rtnl_data->rtnl_timeout > 0) {
2056                         g_source_remove(rtnl_data->rtnl_timeout);
2057                         rtnl_data->rtnl_timeout = 0;
2058                 }
2059
2060                 __connman_inet_rtnl_close(rth);
2061                 g_free(rth);
2062         }
2063
2064         return 0;
2065 }
2066
2067 static gboolean inet_rtnl_event(GIOChannel *chan, GIOCondition cond,
2068                                                         gpointer user_data)
2069 {
2070         int ret;
2071
2072         DBG("");
2073
2074         if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
2075                 return FALSE;
2076
2077         ret = inet_rtnl_recv(chan, user_data);
2078         if (ret != 0)
2079                 return TRUE;
2080
2081         return FALSE;
2082 }
2083
2084 int __connman_inet_rtnl_talk(struct __connman_inet_rtnl_handle *rtnl,
2085                         struct nlmsghdr *n, int timeout,
2086                         __connman_inet_rtnl_cb_t callback, void *user_data)
2087 {
2088         struct sockaddr_nl nladdr;
2089         struct inet_rtnl_cb_data *data;
2090         unsigned seq;
2091         int err;
2092
2093         memset(&nladdr, 0, sizeof(nladdr));
2094         nladdr.nl_family = AF_NETLINK;
2095
2096         n->nlmsg_seq = seq = ++rtnl->seq;
2097
2098         if (callback != NULL) {
2099                 data = g_try_malloc0(sizeof(struct inet_rtnl_cb_data));
2100                 if (data == NULL)
2101                         return -ENOMEM;
2102
2103                 data->callback = callback;
2104                 data->user_data = user_data;
2105                 data->rtnl = rtnl;
2106                 data->rtnl_timeout = g_timeout_add_seconds(timeout,
2107                                                 inet_rtnl_timeout_cb, data);
2108
2109                 data->channel = g_io_channel_unix_new(rtnl->fd);
2110                 g_io_channel_set_close_on_unref(data->channel, TRUE);
2111
2112                 g_io_channel_set_encoding(data->channel, NULL, NULL);
2113                 g_io_channel_set_buffered(data->channel, FALSE);
2114
2115                 data->watch_id = g_io_add_watch(data->channel,
2116                                 G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
2117                                                 inet_rtnl_event, data);
2118         } else
2119                 n->nlmsg_flags |= NLM_F_ACK;
2120
2121         err = sendto(rtnl->fd, &rtnl->req.n, rtnl->req.n.nlmsg_len, 0,
2122                 (struct sockaddr *) &nladdr, sizeof(nladdr));
2123         DBG("handle %p len %d err %d", rtnl, rtnl->req.n.nlmsg_len, err);
2124         if (err < 0) {
2125                 connman_error("Can not talk to rtnetlink");
2126                 return -errno;
2127         }
2128
2129         if ((unsigned int)err != rtnl->req.n.nlmsg_len) {
2130                 connman_error("Sent %d bytes, msg truncated", err);
2131                 return -EINVAL;
2132         }
2133
2134         return 0;
2135 }
2136
2137 void __connman_inet_rtnl_close(struct __connman_inet_rtnl_handle *rth)
2138 {
2139         DBG("handle %p", rth);
2140
2141         if (rth->fd >= 0) {
2142                 close(rth->fd);
2143                 rth->fd = -1;
2144         }
2145 }
2146
2147 int __connman_inet_rtnl_addattr32(struct nlmsghdr *n, size_t maxlen, int type,
2148                                 __u32 data)
2149 {
2150         int len = RTA_LENGTH(4);
2151         struct rtattr *rta;
2152
2153         if (NLMSG_ALIGN(n->nlmsg_len) + len > maxlen) {
2154                 DBG("Error! max allowed bound %d exceeded", maxlen);
2155                 return -1;
2156         }
2157         rta = NLMSG_TAIL(n);
2158         rta->rta_type = type;
2159         rta->rta_len = len;
2160         memcpy(RTA_DATA(rta), &data, 4);
2161         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + len;
2162
2163         return 0;
2164 }