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;
 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);
 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         free(name);
 521         free(addr);
 522
 523         return device;
 524 }
 525
 526 struct in6_ifreq {
 527         struct in6_addr ifr6_addr;
 528         __u32 ifr6_prefixlen;
 529         unsigned int ifr6_ifindex;
 530 };
 531
 532 int connman_inet_set_ipv6_address(int index,
 533                 struct connman_ipaddress *ipaddress)
 534 {
 535         unsigned char prefix_len;
 536         const char *address;
 537
 538         if (ipaddress->local == NULL)
 539                 return 0;
 540
 541         prefix_len = ipaddress->prefixlen;
 542         address = ipaddress->local;
 543
 544         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 545
 546         if ((__connman_inet_modify_address(RTM_NEWADDR,
 547                         NLM_F_REPLACE | NLM_F_ACK, index, AF_INET6,
 548                                 address, NULL, prefix_len, NULL)) < 0) {
 549                 connman_error("Set IPv6 address error");
 550                 return -1;
 551         }
 552
 553         return 0;
 554 }
 555
 556 int connman_inet_set_address(int index, struct connman_ipaddress *ipaddress)
 557 {
 558         unsigned char prefix_len;
 559         const char *address, *broadcast, *peer;
 560
 561         if (ipaddress->local == NULL)
 562                 return -1;
 563
 564         prefix_len = ipaddress->prefixlen;
 565         address = ipaddress->local;
 566         broadcast = ipaddress->broadcast;
 567         peer = ipaddress->peer;
 568
 569         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 570
 571         if ((__connman_inet_modify_address(RTM_NEWADDR,
 572                         NLM_F_REPLACE | NLM_F_ACK, index, AF_INET,
 573                                 address, peer, prefix_len, broadcast)) < 0) {
 574                 DBG("address setting failed");
 575                 return -1;
 576         }
 577
 578         return 0;
 579 }
 580
 581 int connman_inet_clear_ipv6_address(int index, const char *address,
 582                                                         int prefix_len)
 583 {
 584         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 585
 586         if ((__connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET6,
 587                                         address, NULL, prefix_len, NULL)) < 0) {
 588                 connman_error("Clear IPv6 address error");
 589                 return -1;
 590         }
 591
 592         return 0;
 593 }
 594
 595 int connman_inet_clear_address(int index, struct connman_ipaddress *ipaddress)
 596 {
 597         unsigned char prefix_len;
 598         const char *address, *broadcast, *peer;
 599
 600         prefix_len = ipaddress->prefixlen;
 601         address = ipaddress->local;
 602         broadcast = ipaddress->broadcast;
 603         peer = ipaddress->peer;
 604
 605         DBG("index %d address %s prefix_len %d", index, address, prefix_len);
 606
 607         if ((__connman_inet_modify_address(RTM_DELADDR, 0, index, AF_INET,
 608                                 address, peer, prefix_len, broadcast)) < 0) {
 609                 DBG("address removal failed");
 610                 return -1;
 611         }
 612
 613         return 0;
 614 }
 615
 616 int connman_inet_add_host_route(int index, const char *host, const char *gateway)
 617 {
 618         struct ifreq ifr;
 619         struct rtentry rt;
 620         struct sockaddr_in addr;
 621         int sk, err;
 622
 623         sk = socket(PF_INET, SOCK_DGRAM, 0);
 624         if (sk < 0)
 625                 return -1;
 626
 627         memset(&ifr, 0, sizeof(ifr));
 628         ifr.ifr_ifindex = index;
 629
 630         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 631                 close(sk);
 632                 return -1;
 633         }
 634
 635         DBG("ifname %s", ifr.ifr_name);
 636
 637         memset(&rt, 0, sizeof(rt));
 638         rt.rt_flags = RTF_UP | RTF_HOST;
 639         if (gateway != NULL)
 640                 rt.rt_flags |= RTF_GATEWAY;
 641
 642         memset(&addr, 0, sizeof(addr));
 643         addr.sin_family = AF_INET;
 644         addr.sin_addr.s_addr = inet_addr(host);
 645         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 646
 647         memset(&addr, 0, sizeof(addr));
 648         addr.sin_family = AF_INET;
 649         if (gateway != NULL)
 650                 addr.sin_addr.s_addr = inet_addr(gateway);
 651         else
 652                 addr.sin_addr.s_addr = INADDR_ANY;
 653         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 654
 655         memset(&addr, 0, sizeof(addr));
 656         addr.sin_family = AF_INET;
 657         addr.sin_addr.s_addr = INADDR_ANY;
 658         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 659
 660         rt.rt_dev = ifr.ifr_name;
 661
 662         err = ioctl(sk, SIOCADDRT, &rt);
 663         if (err < 0)
 664                 connman_error("Adding host route failed (%s)",
 665                                                         strerror(errno));
 666
 667         close(sk);
 668
 669         return err;
 670 }
 671
 672 int connman_inet_del_host_route(int index, const char *host)
 673 {
 674         struct ifreq ifr;
 675         struct rtentry rt;
 676         struct sockaddr_in addr;
 677         int sk, err;
 678
 679         sk = socket(PF_INET, SOCK_DGRAM, 0);
 680         if (sk < 0)
 681                 return -1;
 682
 683         memset(&ifr, 0, sizeof(ifr));
 684         ifr.ifr_ifindex = index;
 685
 686         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 687                 close(sk);
 688                 return -1;
 689         }
 690
 691         DBG("ifname %s", ifr.ifr_name);
 692
 693         memset(&rt, 0, sizeof(rt));
 694         rt.rt_flags = RTF_UP | RTF_HOST;
 695
 696         memset(&addr, 0, sizeof(addr));
 697         addr.sin_family = AF_INET;
 698         addr.sin_addr.s_addr = inet_addr(host);
 699         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 700
 701         rt.rt_dev = ifr.ifr_name;
 702
 703         err = ioctl(sk, SIOCDELRT, &rt);
 704         if (err < 0)
 705                 connman_error("Deleting host route failed (%s)",
 706                                                         strerror(errno));
 707
 708         close(sk);
 709
 710         return err;
 711 }
 712
 713 int connman_inet_del_ipv6_host_route(int index, const char *host)
 714 {
 715         struct in6_rtmsg rt;
 716         int sk, err;
 717
 718         DBG("index %d host %s", index, host);
 719
 720         if (host == NULL)
 721                 return -EINVAL;
 722
 723         memset(&rt, 0, sizeof(rt));
 724
 725         rt.rtmsg_dst_len = 128;
 726
 727         err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
 728         if (err < 0)
 729                 goto out;
 730
 731         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 732
 733         rt.rtmsg_metric = 1;
 734         rt.rtmsg_ifindex = index;
 735
 736         sk = socket(AF_INET6, SOCK_DGRAM, 0);
 737         if (sk < 0) {
 738                 err = -1;
 739                 goto out;
 740         }
 741
 742         err = ioctl(sk, SIOCDELRT, &rt);
 743         close(sk);
 744 out:
 745         if (err < 0)
 746                 connman_error("Del IPv6 host route error");
 747
 748         return err;
 749 }
 750
 751 int connman_inet_add_ipv6_host_route(int index, const char *host,
 752                                                 const char *gateway)
 753 {
 754         struct in6_rtmsg rt;
 755         int sk, err;
 756
 757         DBG("index %d host %s gateway %s", index, host, gateway);
 758
 759         if (host == NULL)
 760                 return -EINVAL;
 761
 762         memset(&rt, 0, sizeof(rt));
 763
 764         rt.rtmsg_dst_len = 128;
 765
 766         err = inet_pton(AF_INET6, host, &rt.rtmsg_dst);
 767         if (err < 0)
 768                 goto out;
 769
 770         rt.rtmsg_flags = RTF_UP | RTF_HOST;
 771
 772         if (gateway != NULL) {
 773                 rt.rtmsg_flags |= RTF_GATEWAY;
 774                 inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 775         }
 776
 777         rt.rtmsg_metric = 1;
 778         rt.rtmsg_ifindex = index;
 779
 780         sk = socket(AF_INET6, SOCK_DGRAM, 0);
 781         if (sk < 0) {
 782                 err = -1;
 783                 goto out;
 784         }
 785
 786         err = ioctl(sk, SIOCADDRT, &rt);
 787         close(sk);
 788 out:
 789         if (err < 0)
 790                 connman_error("Set IPv6 host route error");
 791
 792         return err;
 793 }
 794
 795 int connman_inet_set_ipv6_gateway_address(int index, const char *gateway)
 796 {
 797         struct in6_rtmsg rt;
 798         int sk, err;
 799
 800         DBG("index %d, gateway %s", index, gateway);
 801
 802         if (gateway == NULL)
 803                 return -EINVAL;
 804
 805         memset(&rt, 0, sizeof(rt));
 806
 807         err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 808         if (err < 0)
 809                 goto out;
 810
 811         rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
 812         rt.rtmsg_metric = 1;
 813         rt.rtmsg_dst_len = 0;
 814         rt.rtmsg_ifindex = index;
 815
 816         sk = socket(AF_INET6, SOCK_DGRAM, 0);
 817         if (sk < 0) {
 818                 err = -1;
 819                 goto out;
 820         }
 821
 822         err = ioctl(sk, SIOCADDRT, &rt);
 823         close(sk);
 824 out:
 825         if (err < 0)
 826                 connman_error("Set default IPv6 gateway error");
 827
 828         return err;
 829 }
 830
 831 int connman_inet_clear_ipv6_gateway_address(int index, const char *gateway)
 832 {
 833         struct in6_rtmsg rt;
 834         int sk, err;
 835
 836         DBG("index %d, gateway %s", index, gateway);
 837
 838         if (gateway == NULL)
 839                 return -EINVAL;
 840
 841         memset(&rt, 0, sizeof(rt));
 842
 843         err = inet_pton(AF_INET6, gateway, &rt.rtmsg_gateway);
 844         if (err < 0)
 845                 goto out;
 846
 847         rt.rtmsg_flags = RTF_UP | RTF_GATEWAY;
 848         rt.rtmsg_metric = 1;
 849         rt.rtmsg_dst_len = 0;
 850         rt.rtmsg_ifindex = index;
 851
 852         sk = socket(AF_INET6, SOCK_DGRAM, 0);
 853         if (sk < 0) {
 854                 err = -1;
 855                 goto out;
 856         }
 857
 858         err = ioctl(sk, SIOCDELRT, &rt);
 859         close(sk);
 860 out:
 861         if (err < 0)
 862                 connman_error("Clear default IPv6 gateway error");
 863
 864         return err;
 865 }
 866
 867 int connman_inet_set_gateway_address(int index, const char *gateway)
 868 {
 869         struct ifreq ifr;
 870         struct rtentry rt;
 871         struct sockaddr_in addr;
 872         int sk, err;
 873
 874         sk = socket(PF_INET, SOCK_DGRAM, 0);
 875         if (sk < 0)
 876                 return -1;
 877
 878         memset(&ifr, 0, sizeof(ifr));
 879         ifr.ifr_ifindex = index;
 880
 881         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 882                 close(sk);
 883                 return -1;
 884         }
 885
 886         DBG("ifname %s", ifr.ifr_name);
 887
 888         memset(&rt, 0, sizeof(rt));
 889         rt.rt_flags = RTF_UP | RTF_GATEWAY;
 890
 891         memset(&addr, 0, sizeof(addr));
 892         addr.sin_family = AF_INET;
 893         addr.sin_addr.s_addr = INADDR_ANY;
 894         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 895
 896         memset(&addr, 0, sizeof(addr));
 897         addr.sin_family = AF_INET;
 898         addr.sin_addr.s_addr = inet_addr(gateway);
 899         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 900
 901         memset(&addr, 0, sizeof(addr));
 902         addr.sin_family = AF_INET;
 903         addr.sin_addr.s_addr = INADDR_ANY;
 904         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 905
 906         err = ioctl(sk, SIOCADDRT, &rt);
 907         if (err < 0)
 908                 connman_error("Setting default gateway route failed (%s)",
 909                                                         strerror(errno));
 910
 911         close(sk);
 912
 913         return err;
 914 }
 915
 916 int connman_inet_set_gateway_interface(int index)
 917 {
 918         struct ifreq ifr;
 919         struct rtentry rt;
 920         struct sockaddr_in addr;
 921         int sk, err;
 922
 923         DBG("");
 924
 925         sk = socket(PF_INET, SOCK_DGRAM, 0);
 926         if (sk < 0)
 927                 return -1;
 928
 929         memset(&ifr, 0, sizeof(ifr));
 930         ifr.ifr_ifindex = index;
 931
 932         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 933                 close(sk);
 934                 return -1;
 935         }
 936
 937         DBG("ifname %s", ifr.ifr_name);
 938
 939         memset(&rt, 0, sizeof(rt));
 940         rt.rt_flags = RTF_UP;
 941
 942         memset(&addr, 0, sizeof(addr));
 943         addr.sin_family = AF_INET;
 944         addr.sin_addr.s_addr = INADDR_ANY;
 945
 946         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
 947         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 948         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 949
 950         rt.rt_dev = ifr.ifr_name;
 951
 952         err = ioctl(sk, SIOCADDRT, &rt);
 953         if (err < 0)
 954                 connman_error("Setting default interface route failed (%s)",
 955                                                         strerror(errno));
 956         close(sk);
 957
 958         return err;
 959 }
 960
 961 int connman_inet_clear_gateway_address(int index, const char *gateway)
 962 {
 963         struct ifreq ifr;
 964         struct rtentry rt;
 965         struct sockaddr_in addr;
 966         int sk, err;
 967
 968         DBG("");
 969
 970         sk = socket(PF_INET, SOCK_DGRAM, 0);
 971         if (sk < 0)
 972                 return -1;
 973
 974         memset(&ifr, 0, sizeof(ifr));
 975         ifr.ifr_ifindex = index;
 976
 977         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 978                 close(sk);
 979                 return -1;
 980         }
 981
 982         DBG("ifname %s", ifr.ifr_name);
 983
 984         memset(&rt, 0, sizeof(rt));
 985         rt.rt_flags = RTF_UP | RTF_GATEWAY;
 986
 987         memset(&addr, 0, sizeof(addr));
 988         addr.sin_family = AF_INET;
 989         addr.sin_addr.s_addr = INADDR_ANY;
 990         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
 991
 992         memset(&addr, 0, sizeof(addr));
 993         addr.sin_family = AF_INET;
 994         addr.sin_addr.s_addr = inet_addr(gateway);
 995         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
 996
 997         memset(&addr, 0, sizeof(addr));
 998         addr.sin_family = AF_INET;
 999         addr.sin_addr.s_addr = INADDR_ANY;
1000         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1001
1002         err = ioctl(sk, SIOCDELRT, &rt);
1003         if (err < 0)
1004                 connman_error("Removing default gateway route failed (%s)",
1005                                                         strerror(errno));
1006
1007         close(sk);
1008
1009         return err;
1010 }
1011
1012 int connman_inet_clear_gateway_interface(int index)
1013 {
1014         struct ifreq ifr;
1015         struct rtentry rt;
1016         struct sockaddr_in addr;
1017         int sk, err;
1018
1019         DBG("");
1020
1021         sk = socket(PF_INET, SOCK_DGRAM, 0);
1022         if (sk < 0)
1023                 return -1;
1024
1025         memset(&ifr, 0, sizeof(ifr));
1026         ifr.ifr_ifindex = index;
1027
1028         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1029                 close(sk);
1030                 return -1;
1031         }
1032
1033         DBG("ifname %s", ifr.ifr_name);
1034
1035         memset(&rt, 0, sizeof(rt));
1036         rt.rt_flags = RTF_UP;
1037
1038         memset(&addr, 0, sizeof(addr));
1039         addr.sin_family = AF_INET;
1040         addr.sin_addr.s_addr = INADDR_ANY;
1041
1042         memcpy(&rt.rt_genmask, &addr, sizeof(rt.rt_genmask));
1043         memcpy(&rt.rt_dst, &addr, sizeof(rt.rt_dst));
1044         memcpy(&rt.rt_gateway, &addr, sizeof(rt.rt_gateway));
1045
1046         rt.rt_dev = ifr.ifr_name;
1047
1048         err = ioctl(sk, SIOCDELRT, &rt);
1049         if (err < 0)
1050                 connman_error("Removing default interface route failed (%s)",
1051                                                         strerror(errno));
1052         close(sk);
1053
1054         return err;
1055 }
1056
1057 connman_bool_t connman_inet_compare_subnet(int index, const char *host)
1058 {
1059         struct ifreq ifr;
1060         struct in_addr _host_addr;
1061         in_addr_t host_addr, netmask_addr, if_addr;
1062         struct sockaddr_in *netmask, *addr;
1063         int sk;
1064
1065         DBG("host %s", host);
1066
1067         if (host == NULL)
1068                 return FALSE;
1069
1070         if (inet_aton(host, &_host_addr) == 0)
1071                 return -1;
1072         host_addr = _host_addr.s_addr;
1073
1074         sk = socket(PF_INET, SOCK_DGRAM, 0);
1075         if (sk < 0)
1076                 return FALSE;
1077
1078         memset(&ifr, 0, sizeof(ifr));
1079         ifr.ifr_ifindex = index;
1080
1081         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
1082                 close(sk);
1083                 return FALSE;
1084         }
1085
1086         if (ioctl(sk, SIOCGIFNETMASK, &ifr) < 0) {
1087                 close(sk);
1088                 return FALSE;
1089         }
1090
1091         netmask = (struct sockaddr_in *)&ifr.ifr_netmask;
1092         netmask_addr = netmask->sin_addr.s_addr;
1093
1094         if (ioctl(sk, SIOCGIFADDR, &ifr) < 0) {
1095                 close(sk);
1096                 return FALSE;
1097         }
1098         addr = (struct sockaddr_in *)&ifr.ifr_addr;
1099         if_addr = addr->sin_addr.s_addr;
1100
1101         return ((if_addr & netmask_addr) == (host_addr & netmask_addr));
1102 }