src/inet.c

   1 /*
   2  *
   3  *  Connection Manager
   4  *
   5  *  Copyright (C) 2007-2010  Intel Corporation. All rights reserved.
   6  *
   7  *  This program is free software; you can redistribute it and/or modify
   8  *  it under the terms of the GNU General Public License version 2 as
   9  *  published by the Free Software Foundation.
  10  *
  11  *  This program is distributed in the hope that it will be useful,
  12  *  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14  *  GNU General Public License for more details.
  15  *
  16  *  You should have received a copy of the GNU General Public License
  17  *  along with this program; if not, write to the Free Software
  18  *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  19  *
  20  */
  21
  22 #ifdef HAVE_CONFIG_H
  23 #include <config.h>
  24 #endif
  25
  26 #include <stdio.h>
  27 #include <errno.h>
  28 #include <unistd.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include <sys/stat.h>
  32 #include <sys/ioctl.h>
  33 #include <sys/socket.h>
  34 #include <arpa/inet.h>
  35 #include <net/route.h>
  36 #include <net/ethernet.h>
  37 #include <linux/if_arp.h>
  38 #include <linux/wireless.h>
  39
  40 #include "connman.h"
  41
  42 #define NLMSG_TAIL(nmsg)                                \
  43         ((struct rtattr *) (((uint8_t*) (nmsg)) +       \
  44         NLMSG_ALIGN((nmsg)->nlmsg_len)))
  45
  46 static int add_rtattr(struct nlmsghdr *n, size_t max_length, int type,
  47                                 const void *data, size_t data_length)
  48 {
  49         size_t length;
  50         struct rtattr *rta;
  51
  52         length = RTA_LENGTH(data_length);
  53
  54         if (NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(length) > max_length)
  55                 return -E2BIG;
  56
  57         rta = NLMSG_TAIL(n);
  58         rta->rta_type = type;
  59         rta->rta_len = length;
  60         memcpy(RTA_DATA(rta), data, data_length);
  61         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(length);
  62
  63         return 0;
  64 }
  65
  66 int __connman_inet_modify_address(int cmd, int flags,
  67                                 int index, int family,
  68                                 const char *address,
  69                                 const char *peer,
  70                                 unsigned char prefixlen,
  71                                 const char *broadcast)
  72 {
  73         uint8_t request[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
  74                         NLMSG_ALIGN(sizeof(struct ifaddrmsg)) +
  75                         RTA_LENGTH(sizeof(struct in6_addr)) +
  76                         RTA_LENGTH(sizeof(struct in6_addr))];
  77
  78         struct nlmsghdr *header;
  79         struct sockaddr_nl nl_addr;
  80         struct ifaddrmsg *ifaddrmsg;
  81         struct in6_addr ipv6_addr;
  82         struct in_addr ipv4_addr, ipv4_dest, ipv4_bcast;
  83         int sk, err;
  84
  85         DBG("");
  86
  87         if (address == NULL)
  88                 return -1;
  89
  90         if (family != AF_INET && family != AF_INET6)
  91                 return -1;
  92
  93         memset(&request, 0, sizeof(request));
  94
  95         header = (struct nlmsghdr *)request;
  96         header->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
  97         header->nlmsg_type = cmd;
  98         header->nlmsg_flags = NLM_F_REQUEST | flags;
  99         header->nlmsg_seq = 1;
 100
 101         ifaddrmsg = NLMSG_DATA(header);
 102         ifaddrmsg->ifa_family = family;
 103         ifaddrmsg->ifa_prefixlen = prefixlen;
 104         ifaddrmsg->ifa_flags = IFA_F_PERMANENT;
 105         ifaddrmsg->ifa_scope = RT_SCOPE_UNIVERSE;
 106         ifaddrmsg->ifa_index = index;
 107
 108         if (family == AF_INET) {
 109                 if (inet_pton(AF_INET, address, &ipv4_addr) < 1)
 110                         return -1;
 111
 112                 if (broadcast != NULL)
 113                         inet_pton(AF_INET, broadcast, &ipv4_bcast);
 114                 else
 115                         ipv4_bcast.s_addr = ipv4_addr.s_addr |
 116                                 htonl(0xfffffffflu >> prefixlen);
 117
 118                 if (peer != NULL) {
 119                         if (inet_pton(AF_INET, peer, &ipv4_dest) < 1)
 120                                 return -1;
 121
 122                         if ((err = add_rtattr(header, sizeof(request),
 123                                         IFA_ADDRESS,
 124                                         &ipv4_dest, sizeof(ipv4_dest))) < 0)
 125                         return err;
 126                 }
 127
 128                 if ((err = add_rtattr(header, sizeof(request), IFA_LOCAL,
 129                                 &ipv4_addr, sizeof(ipv4_addr))) < 0)
 130                         return err;
 131
 132                 if ((err = add_rtattr(header, sizeof(request), IFA_BROADCAST,
 133                                 &ipv4_bcast, sizeof(ipv4_bcast))) < 0)
 134                         return err;
 135
 136         } else if (family == AF_INET6) {
 137                 if (inet_pton(AF_INET6, address, &ipv6_addr) < 1)
 138                         return -1;
 139
 140                 if ((err = add_rtattr(header, sizeof(request), IFA_LOCAL,
 141                                 &ipv6_addr, sizeof(ipv6_addr))) < 0)
 142                         return err;
 143         }
 144
 145         sk = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
 146         if (sk < 0)
 147                 return -1;
 148
 149         memset(&nl_addr, 0, sizeof(nl_addr));
 150         nl_addr.nl_family = AF_NETLINK;
 151
 152         if ((err = sendto(sk, request, header->nlmsg_len, 0,
 153                         (struct sockaddr *) &nl_addr, sizeof(nl_addr))) < 0)
 154                 goto done;
 155
 156         err = 0;
 157
 158 done:
 159         close(sk);
 160
 161         return err;
 162 }
 163
 164 int connman_inet_ifindex(const char *name)
 165 {
 166         struct ifreq ifr;
 167         int sk, err;
 168
 169         if (name == NULL)
 170                 return -1;
 171
 172         sk = socket(PF_INET, SOCK_DGRAM, 0);
 173         if (sk < 0)
 174                 return -1;
 175
 176         memset(&ifr, 0, sizeof(ifr));
 177         strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
 178
 179         err = ioctl(sk, SIOCGIFINDEX, &ifr);
 180
 181         close(sk);
 182
 183         if (err < 0)
 184                 return -1;
 185
 186         return ifr.ifr_ifindex;
 187 }
 188
 189 char *connman_inet_ifname(int index)
 190 {
 191         struct ifreq ifr;
 192         int sk, err;
 193
 194         if (index < 0)
 195                 return NULL;
 196
 197         sk = socket(PF_INET, SOCK_DGRAM, 0);
 198         if (sk < 0)
 199                 return NULL;
 200
 201         memset(&ifr, 0, sizeof(ifr));
 202         ifr.ifr_ifindex = index;
 203
 204         err = ioctl(sk, SIOCGIFNAME, &ifr);
 205
 206         close(sk);
 207
 208         if (err < 0)
 209                 return NULL;
 210
 211         return strdup(ifr.ifr_name);
 212 }
 213
 214 short int connman_inet_ifflags(int index)
 215 {
 216         struct ifreq ifr;
 217         int sk, err;
 218
 219         sk = socket(PF_INET, SOCK_DGRAM, 0);
 220         if (sk < 0)
 221                 return -errno;
 222
 223         memset(&ifr, 0, sizeof(ifr));
 224         ifr.ifr_ifindex = index;
 225
 226         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 227                 err = -errno;
 228                 goto done;
 229         }
 230
 231         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 232                 err = -errno;
 233                 goto done;
 234         }
 235
 236         err = ifr.ifr_flags;
 237
 238 done:
 239         close(sk);
 240
 241         return err;
 242 }
 243
 244 int connman_inet_ifup(int index)
 245 {
 246         struct ifreq ifr;
 247         int sk, err;
 248
 249         sk = socket(PF_INET, SOCK_DGRAM, 0);
 250         if (sk < 0)
 251                 return -errno;
 252
 253         memset(&ifr, 0, sizeof(ifr));
 254         ifr.ifr_ifindex = index;
 255
 256         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 257                 err = -errno;
 258                 goto done;
 259         }
 260
 261         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 262                 err = -errno;
 263                 goto done;
 264         }
 265
 266         if (ifr.ifr_flags & IFF_UP) {
 267                 err = -EALREADY;
 268                 goto done;
 269         }
 270
 271         ifr.ifr_flags |= IFF_UP;
 272
 273         if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0) {
 274                 err = -errno;
 275                 goto done;
 276         }
 277
 278         err = 0;
 279
 280 done:
 281         close(sk);
 282
 283         return err;
 284 }
 285
 286 int connman_inet_ifdown(int index)
 287 {
 288         struct ifreq ifr;
 289         int sk, err;
 290
 291         sk = socket(PF_INET, SOCK_DGRAM, 0);
 292         if (sk < 0)
 293                 return -errno;
 294
 295         memset(&ifr, 0, sizeof(ifr));
 296         ifr.ifr_ifindex = index;
 297
 298         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 299                 err = -errno;
 300                 goto done;
 301         }
 302
 303         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 304                 err = -errno;
 305                 goto done;
 306         }
 307
 308         if (!(ifr.ifr_flags & IFF_UP)) {
 309                 err = -EALREADY;
 310                 goto done;
 311         }
 312
 313         ifr.ifr_flags &= ~IFF_UP;
 314
 315         if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0)
 316                 err = -errno;
 317         else
 318                 err = 0;
 319
 320 done:
 321         close(sk);
 322
 323         return err;
 324 }
 325
 326 static char *index2addr(int index)
 327 {
 328         struct ifreq ifr;
 329         struct ether_addr eth;
 330         char *str;
 331         int sk, err;
 332
 333         if (index < 0)
 334                 return NULL;
 335
 336         sk = socket(PF_INET, SOCK_DGRAM, 0);
 337         if (sk < 0)
 338                 return NULL;
 339
 340         memset(&ifr, 0, sizeof(ifr));
 341         ifr.ifr_ifindex = index;
 342
 343         err = ioctl(sk, SIOCGIFNAME, &ifr);
 344
 345         if (err == 0)
 346                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
 347
 348         close(sk);
 349
 350         if (err < 0)
 351                 return NULL;
 352
 353         str = malloc(18);
 354         if (!str)
 355                 return NULL;
 356
 357         memcpy(&eth, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
 358         snprintf(str, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
 359                                                 eth.ether_addr_octet[0],
 360                                                 eth.ether_addr_octet[1],
 361                                                 eth.ether_addr_octet[2],
 362                                                 eth.ether_addr_octet[3],
 363                                                 eth.ether_addr_octet[4],
 364                                                 eth.ether_addr_octet[5]);
 365
 366         return str;
 367 }
 368
 369 static char *index2ident(int index, const char *prefix)
 370 {
 371         struct ifreq ifr;
 372         struct ether_addr eth;
 373         char *str;
 374         int sk, err, len;
 375
 376         if (index < 0)
 377                 return NULL;
 378
 379         sk = socket(PF_INET, SOCK_DGRAM, 0);
 380         if (sk < 0)
 381                 return NULL;
 382
 383         memset(&ifr, 0, sizeof(ifr));
 384         ifr.ifr_ifindex = index;
 385
 386         err = ioctl(sk, SIOCGIFNAME, &ifr);
 387
 388         if (err == 0)
 389                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
 390
 391         close(sk);
 392
 393         if (err < 0)
 394                 return NULL;
 395
 396         len = prefix ? strlen(prefix) + 18 : 18;
 397
 398         str = malloc(len);
 399         if (!str)
 400                 return NULL;
 401
 402         memcpy(&eth, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
 403         snprintf(str, len, "%s%02x%02x%02x%02x%02x%02x",
 404                                                 prefix ? prefix : "",
 405                                                 eth.ether_addr_octet[0],
 406                                                 eth.ether_addr_octet[1],
 407                                                 eth.ether_addr_octet[2],
 408                                                 eth.ether_addr_octet[3],
 409                                                 eth.ether_addr_octet[4],
 410                                                 eth.ether_addr_octet[5]);
 411
 412         return str;
 413 }
 414
 415 connman_bool_t connman_inet_is_cfg80211(int index)
 416 {
 417         connman_bool_t result = FALSE;
 418         char phy80211_path[PATH_MAX];
 419         struct stat st;
 420         struct ifreq ifr;
 421         int sk;
 422
 423         sk = socket(PF_INET, SOCK_DGRAM, 0);
 424         if (sk < 0)
 425                 return FALSE;
 426
 427         memset(&ifr, 0, sizeof(ifr));
 428         ifr.ifr_ifindex = index;
 429
 430         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0)
 431                 goto done;
 432
 433         snprintf(phy80211_path, PATH_MAX,
 434                                 "/sys/class/net/%s/phy80211", ifr.ifr_name);
 435
 436         if (stat(phy80211_path, &st) == 0 && (st.st_mode & S_IFDIR))
 437                 result = TRUE;
 438
 439 done:
 440         close(sk);
 441
 442         return result;
 443 }
 444
 445 struct connman_device *connman_inet_create_device(int index)
 446 {
 447         enum connman_device_type type;
 448         struct connman_device *device;
 449         char *devname, *ident = NULL;
 450         char *addr = NULL, *name = NULL, *node = NULL;
 451
 452         if (index < 0)
 453                 return NULL;
 454
 455         devname = connman_inet_ifname(index);
 456         if (devname == NULL)
 457                 return NULL;
 458
 459         if (__connman_element_device_isfiltered(devname) == TRUE) {
 460                 connman_info("Ignoring interface %s (filtered)", devname);
 461                 return NULL;
 462         }
 463
 464         type = __connman_rtnl_get_device_type(index);
 465
 466         switch (type) {
 467         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 468                 connman_info("Ignoring interface %s (type unknown)", devname);
 469                 g_free(devname);
 470                 return NULL;
 471         case CONNMAN_DEVICE_TYPE_ETHERNET:
 472         case CONNMAN_DEVICE_TYPE_WIFI:
 473         case CONNMAN_DEVICE_TYPE_WIMAX:
 474                 name = index2ident(index, "");
 475                 addr = index2addr(index);
 476                 break;
 477         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 478         case CONNMAN_DEVICE_TYPE_CELLULAR:
 479         case CONNMAN_DEVICE_TYPE_GPS:
 480         case CONNMAN_DEVICE_TYPE_VENDOR:
 481                 name = strdup(devname);
 482                 break;
 483         }
 484
 485         device = connman_device_create(name, type);
 486         if (device == NULL)
 487                 goto done;
 488
 489         switch (type) {
 490         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 491         case CONNMAN_DEVICE_TYPE_VENDOR:
 492         case CONNMAN_DEVICE_TYPE_GPS:
 493                 break;
 494         case CONNMAN_DEVICE_TYPE_ETHERNET:
 495                 ident = index2ident(index, NULL);
 496                 break;
 497         case CONNMAN_DEVICE_TYPE_WIFI:
 498         case CONNMAN_DEVICE_TYPE_WIMAX:
 499                 ident = index2ident(index, NULL);
 500                 break;
 501         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 502                 break;
 503         case CONNMAN_DEVICE_TYPE_CELLULAR:
 504                 ident = index2ident(index, NULL);
 505                 break;
 506         }
 507
 508         connman_device_set_index(device, index);
 509         connman_device_set_interface(device, devname, node);
 510
 511         if (ident != NULL) {
 512                 connman_device_set_ident(device, ident);
 513                 free(ident);
 514         }
 515
 516         connman_device_set_string(device, "Address", addr);
 517
 518 done:
 519         g_free(devname);
 520         g_free(node);
 521         free(name);
 522         free(addr);
 523
 524         return device;
 525 }
 526
 527 struct in6_ifreq {
 528         struct in6_addr ifr6_addr;
 529         __u32 ifr6_prefixlen;
 530         unsigned int ifr6_ifindex;
 531 };
 532
 533 int connman_inet_set_ipv6_address(int index,
 534                 struct connman_ipaddress *ipaddress)
 535 {
 536         unsigned char prefix_len;
 537         const char *address;
 538
 539         if (ipaddress->local == NULL)
 540                 return 0;
 541
 542         prefix_len = ipaddress->prefixlen;
 543         address = ipaddress->local;
 544
 545         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 546
 547         if ((__connman_inet_modify_address(RTM_NEWADDR,
 548                         NLM_F_REPLACE | NLM_F_ACK, index, AF_INET6,
 549                                 address, NULL, prefix_len, NULL)) < 0) {
 550                 connman_error("Set IPv6 address error");
 551                 return -1;
 552         }
 553
 554         return 0;
 555 }
 556
 557 int connman_inet_set_address(int index, struct connman_ipaddress *ipaddress)
 558 {
 559         unsigned char prefix_len;
 560         const char *address, *broadcast, *peer;
 561
 562         if (ipaddress->local == NULL)
 563                 return -1;
 564
 565         prefix_len = ipaddress->prefixlen;
 566         address = ipaddress->local;
 567         broadcast = ipaddress->broadcast;
 568         peer = ipaddress->peer;
 569
 570         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 571
 572         if ((__connman_inet_modify_address(RTM_NEWADDR,
 573                         NLM_F_REPLACE | NLM_F_ACK, index, AF_INET,
 574                                 address, peer, prefix_len, broadcast)) < 0) {
 575                 DBG("address setting failed");
 576                 return -1;
 577         }
 578
 579         return 0;
 580 }
 581
 582 int connman_inet_clear_ipv6_address(int index, const char *address,
 583                                                         int prefix_len)
 584 {
 585         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 586
 587         if ((__connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET6,
 588                                         address, NULL, prefix_len, NULL)) < 0) {
 589                 connman_error("Clear IPv6 address error");
 590                 return -1;
 591         }
 592
 593         return 0;
 594 }
 595
 596 int connman_inet_clear_address(int index, struct connman_ipaddress *ipaddress)
 597 {
 598         unsigned char prefix_len;
 599         const char *address, *broadcast, *peer;
 600
 601         prefix_len = ipaddress->prefixlen;
 602         address = ipaddress->local;
 603         broadcast = ipaddress->broadcast;
 604         peer = ipaddress->peer;
 605
 606         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 607
 608         if ((__connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET,
 609                                 address, peer, prefix_len, broadcast)) < 0) {
 610                 DBG("address removal failed");
 611                 return -1;
 612         }
 613
 614         return 0;
 615 }
 616
 617 int connman_inet_add_host_route(int index, const char *host, const char *gateway)
 618 {
 619         struct ifreq ifr;
 620         struct rtentry rt;
 621         struct sockaddr_in addr;
 622         int sk, err;
 623
 624         sk = socket(PF_INET, SOCK_DGRAM, 0);
 625         if (sk < 0)
 626                 return -1;
 627
 628         memset(&ifr, 0, sizeof(ifr));
 629         ifr.ifr_ifindex = index;
 630
 631         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 632                 close(sk);
 633                 return -1;
 634         }
 635
 636         DBG("ifname %s", ifr.ifr_name);
 637
 638         memset(&rt, 0, sizeof(rt));
 639         rt.rt_flags = RTF_UP | RTF_HOST;
 640         if (gateway != NULL)
 641                 rt.rt_flags |= RTF_GATEWAY;
 642
 643         memset(&addr, 0, sizeof(addr));
 644         addr.sin_family = AF_INET;
 645         addr.sin_addr.s_addr = inet_addr(host);
 646         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 647
 648         memset(&addr, 0, sizeof(addr));
 649         addr.sin_family = AF_INET;
 650         if (gateway != NULL)
 651                 addr.sin_addr.s_addr = inet_addr(gateway);
 652         else
 653                 addr.sin_addr.s_addr = INADDR_ANY;
 654         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 655
 656         memset(&addr, 0, sizeof(addr));
 657         addr.sin_family = AF_INET;
 658         addr.sin_addr.s_addr = INADDR_ANY;
 659         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 660
 661         rt.rt_dev = ifr.ifr_name;
 662
 663         err = ioctl(sk, SIOCADDRT, &rt);
 664         if (err < 0)
 665                 connman_error("Adding host route failed (%s)",
 666                                                         strerror(errno));
 667
 668         close(sk);
 669
 670         return err;
 671 }
 672
 673 int connman_inet_del_host_route(int index, const char *host)
 674 {
 675         struct ifreq ifr;
 676         struct rtentry rt;
 677         struct sockaddr_in addr;
 678         int sk, err;
 679
 680         sk = socket(PF_INET, SOCK_DGRAM, 0);
 681         if (sk < 0)
 682                 return -1;
 683
 684         memset(&ifr, 0, sizeof(ifr));
 685         ifr.ifr_ifindex = index;
 686
 687         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 688                 close(sk);
 689                 return -1;
 690         }
 691
 692         DBG("ifname %s", ifr.ifr_name);
 693
 694         memset(&rt, 0, sizeof(rt));
 695         rt.rt_flags = RTF_UP | 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         rt.rt_dev = ifr.ifr_name;
 703
 704         err = ioctl(sk, SIOCDELRT, &rt);
 705         if (err < 0)
 706                 connman_error("Deleting host route failed (%s)",
 707                                                         strerror(errno));
 708
 709         close(sk);
 710
 711         return err;
 712 }
 713
 714 int connman_inet_del_ipv6_host_route(int index, const char *host)
 715 {
 716         struct in6_rtmsg rt;
 717         int sk, err;
 718
 719         DBG("index %d host %s", index, host);
 720
 721         if (host == NULL)
 722                 return -EINVAL;
 723
 724         memset(&rt, 0, sizeof(rt));
 725
 726         rt.rtmsg_dst_len = 128;
 727
 728         err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
 729         if (err < 0)
 730                 goto out;
 731
 732         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 733
 734         rt.rtmsg_metric = 1;
 735         rt.rtmsg_ifindex = index;
 736
 737         sk = socket(AF_INET6, SOCK_DGRAM, 0);
 738         if (sk < 0) {
 739                 err = -1;
 740                 goto out;
 741         }
 742
 743         err = ioctl(sk, SIOCDELRT, &rt);
 744         close(sk);
 745 out:
 746         if (err < 0)
 747                 connman_error("Del IPv6 host route error");
 748
 749         return err;
 750 }
 751
 752 int connman_inet_add_ipv6_host_route(int index, const char *host,
 753                                                 const char *gateway)
 754 {
 755         struct in6_rtmsg rt;
 756         int sk, err;
 757
 758         DBG("index %d host %s gateway %s", index, host, gateway);
 759
 760         if (host == NULL)
 761                 return -EINVAL;
 762
 763         memset(&rt, 0, sizeof(rt));
 764
 765         rt.rtmsg_dst_len = 128;
 766
 767         err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
 768         if (err < 0)
 769                 goto out;
 770
 771         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 772
 773         if (gateway != NULL) {
 774                 rt.rtmsg_flags |= RTF_GATEWAY;
 775                 inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 776         }
 777
 778         rt.rtmsg_metric = 1;
 779         rt.rtmsg_ifindex = index;
 780
 781         sk = socket(AF_INET6, SOCK_DGRAM, 0);
 782         if (sk < 0) {
 783                 err = -1;
 784                 goto out;
 785         }
 786
 787         err = ioctl(sk, SIOCADDRT, &rt);
 788         close(sk);
 789 out:
 790         if (err < 0)
 791                 connman_error("Set IPv6 host route error");
 792
 793         return err;
 794 }
 795
 796 int connman_inet_set_ipv6_gateway_address(int index, const char *gateway)
 797 {
 798         struct in6_rtmsg rt;
 799         int sk, err;
 800
 801         DBG("index %d, gateway %s", index, gateway);
 802
 803         if (gateway == NULL)
 804                 return -EINVAL;
 805
 806         memset(&rt, 0, sizeof(rt));
 807
 808         err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 809         if (err < 0)
 810                 goto out;
 811
 812         rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
 813         rt.rtmsg_metric = 1;
 814         rt.rtmsg_dst_len = 0;
 815         rt.rtmsg_ifindex = index;
 816
 817         sk = socket(AF_INET6, SOCK_DGRAM, 0);
 818         if (sk < 0) {
 819                 err = -1;
 820                 goto out;
 821         }
 822
 823         err = ioctl(sk, SIOCADDRT, &rt);
 824         close(sk);
 825 out:
 826         if (err < 0)
 827                 connman_error("Set default IPv6 gateway error");
 828
 829         return err;
 830 }
 831
 832 int connman_inet_clear_ipv6_gateway_address(int index, const char *gateway)
 833 {
 834         struct in6_rtmsg rt;
 835         int sk, err;
 836
 837         DBG("index %d, gateway %s", index, gateway);
 838
 839         if (gateway == NULL)
 840                 return -EINVAL;
 841
 842         memset(&rt, 0, sizeof(rt));
 843
 844         err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 845         if (err < 0)
 846                 goto out;
 847
 848         rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
 849         rt.rtmsg_metric = 1;
 850         rt.rtmsg_dst_len = 0;
 851         rt.rtmsg_ifindex = index;
 852
 853         sk = socket(AF_INET6, SOCK_DGRAM, 0);
 854         if (sk < 0) {
 855                 err = -1;
 856                 goto out;
 857         }
 858
 859         err = ioctl(sk, SIOCDELRT, &rt);
 860         close(sk);
 861 out:
 862         if (err < 0)
 863                 connman_error("Clear default IPv6 gateway error");
 864
 865         return err;
 866 }
 867
 868 int connman_inet_set_gateway_address(int index, const char *gateway)
 869 {
 870         struct ifreq ifr;
 871         struct rtentry rt;
 872         struct sockaddr_in addr;
 873         int sk, err;
 874
 875         sk = socket(PF_INET, SOCK_DGRAM, 0);
 876         if (sk < 0)
 877                 return -1;
 878
 879         memset(&ifr, 0, sizeof(ifr));
 880         ifr.ifr_ifindex = index;
 881
 882         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 883                 close(sk);
 884                 return -1;
 885         }
 886
 887         DBG("ifname %s", ifr.ifr_name);
 888
 889         memset(&rt, 0, sizeof(rt));
 890         rt.rt_flags = RTF_UP | RTF_GATEWAY;
 891
 892         memset(&addr, 0, sizeof(addr));
 893         addr.sin_family = AF_INET;
 894         addr.sin_addr.s_addr = INADDR_ANY;
 895         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 896
 897         memset(&addr, 0, sizeof(addr));
 898         addr.sin_family = AF_INET;
 899         addr.sin_addr.s_addr = inet_addr(gateway);
 900         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 901
 902         memset(&addr, 0, sizeof(addr));
 903         addr.sin_family = AF_INET;
 904         addr.sin_addr.s_addr = INADDR_ANY;
 905         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 906
 907         err = ioctl(sk, SIOCADDRT, &rt);
 908         if (err < 0)
 909                 connman_error("Setting default gateway route failed (%s)",
 910                                                         strerror(errno));
 911
 912         close(sk);
 913
 914         return err;
 915 }
 916
 917 int connman_inet_set_gateway_interface(int index)
 918 {
 919         struct ifreq ifr;
 920         struct rtentry rt;
 921         struct sockaddr_in addr;
 922         int sk, err;
 923
 924         DBG("");
 925
 926         sk = socket(PF_INET, SOCK_DGRAM, 0);
 927         if (sk < 0)
 928                 return -1;
 929
 930         memset(&ifr, 0, sizeof(ifr));
 931         ifr.ifr_ifindex = index;
 932
 933         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 934                 close(sk);
 935                 return -1;
 936         }
 937
 938         DBG("ifname %s", ifr.ifr_name);
 939
 940         memset(&rt, 0, sizeof(rt));
 941         rt.rt_flags = RTF_UP;
 942
 943         memset(&addr, 0, sizeof(addr));
 944         addr.sin_family = AF_INET;
 945         addr.sin_addr.s_addr = INADDR_ANY;
 946
 947         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 948         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 949         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 950
 951         rt.rt_dev = ifr.ifr_name;
 952
 953         err = ioctl(sk, SIOCADDRT, &rt);
 954         if (err < 0)
 955                 connman_error("Setting default interface route failed (%s)",
 956                                                         strerror(errno));
 957         close(sk);
 958
 959         return err;
 960 }
 961
 962 int connman_inet_clear_gateway_address(int index, const char *gateway)
 963 {
 964         struct ifreq ifr;
 965         struct rtentry rt;
 966         struct sockaddr_in addr;
 967         int sk, err;
 968
 969         DBG("");
 970
 971         sk = socket(PF_INET, SOCK_DGRAM, 0);
 972         if (sk < 0)
 973                 return -1;
 974
 975         memset(&ifr, 0, sizeof(ifr));
 976         ifr.ifr_ifindex = index;
 977
 978         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 979                 close(sk);
 980                 return -1;
 981         }
 982
 983         DBG("ifname %s", ifr.ifr_name);
 984
 985         memset(&rt, 0, sizeof(rt));
 986         rt.rt_flags = RTF_UP | RTF_GATEWAY;
 987
 988         memset(&addr, 0, sizeof(addr));
 989         addr.sin_family = AF_INET;
 990         addr.sin_addr.s_addr = INADDR_ANY;
 991         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 992
 993         memset(&addr, 0, sizeof(addr));
 994         addr.sin_family = AF_INET;
 995         addr.sin_addr.s_addr = inet_addr(gateway);
 996         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 997
 998         memset(&addr, 0, sizeof(addr));
 999         addr.sin_family = AF_INET;
1000         addr.sin_addr.s_addr = INADDR_ANY;
1001         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1002
1003         err = ioctl(sk, SIOCDELRT, &rt);
1004         if (err < 0)
1005                 connman_error("Removing default gateway route failed (%s)",
1006                                                         strerror(errno));
1007
1008         close(sk);
1009
1010         return err;
1011 }
1012
1013 int connman_inet_clear_gateway_interface(int index)
1014 {
1015         struct ifreq ifr;
1016         struct rtentry rt;
1017         struct sockaddr_in addr;
1018         int sk, err;
1019
1020         DBG("");
1021
1022         sk = socket(PF_INET, SOCK_DGRAM, 0);
1023         if (sk < 0)
1024                 return -1;
1025
1026         memset(&ifr, 0, sizeof(ifr));
1027         ifr.ifr_ifindex = index;
1028
1029         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1030                 close(sk);
1031                 return -1;
1032         }
1033
1034         DBG("ifname %s", ifr.ifr_name);
1035
1036         memset(&rt, 0, sizeof(rt));
1037         rt.rt_flags = RTF_UP;
1038
1039         memset(&addr, 0, sizeof(addr));
1040         addr.sin_family = AF_INET;
1041         addr.sin_addr.s_addr = INADDR_ANY;
1042
1043         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1044         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1045         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1046
1047         rt.rt_dev = ifr.ifr_name;
1048
1049         err = ioctl(sk, SIOCDELRT, &rt);
1050         if (err < 0)
1051                 connman_error("Removing default interface route failed (%s)",
1052                                                         strerror(errno));
1053         close(sk);
1054
1055         return err;
1056 }
1057
1058 connman_bool_t connman_inet_compare_subnet(int index, const char *host)
1059 {
1060         struct ifreq ifr;
1061         struct in_addr _host_addr;
1062         in_addr_t host_addr, netmask_addr, if_addr;
1063         struct sockaddr_in *netmask, *addr;
1064         int sk;
1065
1066         DBG("host %s", host);
1067
1068         if (host == NULL)
1069                 return FALSE;
1070
1071         if (inet_aton(host, &_host_addr) == 0)
1072                 return -1;
1073         host_addr = _host_addr.s_addr;
1074
1075         sk = socket(PF_INET, SOCK_DGRAM, 0);
1076         if (sk < 0)
1077                 return FALSE;
1078
1079         memset(&ifr, 0, sizeof(ifr));
1080         ifr.ifr_ifindex = index;
1081
1082         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1083                 close(sk);
1084                 return FALSE;
1085         }
1086
1087         if (ioctl(sk, SIOCGIFNETMASK, &ifr) < 0) {
1088                 close(sk);
1089                 return FALSE;
1090         }
1091
1092         netmask = (struct sockaddr_in *)&ifr.ifr_netmask;
1093         netmask_addr = netmask->sin_addr.s_addr;
1094
1095         if (ioctl(sk, SIOCGIFADDR, &ifr) < 0) {
1096                 close(sk);
1097                 return FALSE;
1098         }
1099         addr = (struct sockaddr_in *)&ifr.ifr_addr;
1100         if_addr = addr->sin_addr.s_addr;
1101
1102         return ((if_addr & netmask_addr) == (host_addr & netmask_addr));
1103 }