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 <linux/sockios.h>
  35 #include <arpa/inet.h>
  36 #include <net/route.h>
  37 #include <net/ethernet.h>
  38 #include <linux/if_arp.h>
  39 #include <linux/wireless.h>
  40
  41 #include "connman.h"
  42
  43 #define NLMSG_TAIL(nmsg)                                \
  44         ((struct rtattr *) (((uint8_t*) (nmsg)) +       \
  45         NLMSG_ALIGN((nmsg)->nlmsg_len)))
  46
  47 static int add_rtattr(struct nlmsghdr *n, size_t max_length, int type,
  48                                 const void *data, size_t data_length)
  49 {
  50         size_t length;
  51         struct rtattr *rta;
  52
  53         length = RTA_LENGTH(data_length);
  54
  55         if (NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(length) > max_length)
  56                 return -E2BIG;
  57
  58         rta = NLMSG_TAIL(n);
  59         rta->rta_type = type;
  60         rta->rta_len = length;
  61         memcpy(RTA_DATA(rta), data, data_length);
  62         n->nlmsg_len = NLMSG_ALIGN(n->nlmsg_len) + RTA_ALIGN(length);
  63
  64         return 0;
  65 }
  66
  67 int __connman_inet_modify_address(int cmd, int flags,
  68                                 int index, int family,
  69                                 const char *address,
  70                                 const char *peer,
  71                                 unsigned char prefixlen,
  72                                 const char *broadcast)
  73 {
  74         uint8_t request[NLMSG_ALIGN(sizeof(struct nlmsghdr)) +
  75                         NLMSG_ALIGN(sizeof(struct ifaddrmsg)) +
  76                         RTA_LENGTH(sizeof(struct in6_addr)) +
  77                         RTA_LENGTH(sizeof(struct in6_addr))];
  78
  79         struct nlmsghdr *header;
  80         struct sockaddr_nl nl_addr;
  81         struct ifaddrmsg *ifaddrmsg;
  82         struct in6_addr ipv6_addr;
  83         struct in_addr ipv4_addr, ipv4_dest, ipv4_bcast;
  84         int sk, err;
  85
  86         DBG("");
  87
  88         if (address == NULL)
  89                 return -1;
  90
  91         if (family != AF_INET && family != AF_INET6)
  92                 return -1;
  93
  94         memset(&request, 0, sizeof(request));
  95
  96         header = (struct nlmsghdr *)request;
  97         header->nlmsg_len = NLMSG_LENGTH(sizeof(struct ifaddrmsg));
  98         header->nlmsg_type = cmd;
  99         header->nlmsg_flags = NLM_F_REQUEST | flags;
 100         header->nlmsg_seq = 1;
 101
 102         ifaddrmsg = NLMSG_DATA(header);
 103         ifaddrmsg->ifa_family = family;
 104         ifaddrmsg->ifa_prefixlen = prefixlen;
 105         ifaddrmsg->ifa_flags = IFA_F_PERMANENT;
 106         ifaddrmsg->ifa_scope = RT_SCOPE_UNIVERSE;
 107         ifaddrmsg->ifa_index = index;
 108
 109         if (family == AF_INET) {
 110                 if (inet_pton(AF_INET, address, &ipv4_addr) < 1)
 111                         return -1;
 112
 113                 if (broadcast != NULL)
 114                         inet_pton(AF_INET, broadcast, &ipv4_bcast);
 115                 else
 116                         ipv4_bcast.s_addr = ipv4_addr.s_addr |
 117                                 htonl(0xfffffffflu >> prefixlen);
 118
 119                 if (peer != NULL) {
 120                         if (inet_pton(AF_INET, peer, &ipv4_dest) < 1)
 121                                 return -1;
 122
 123                         if ((err = add_rtattr(header, sizeof(request),
 124                                         IFA_ADDRESS,
 125                                         &ipv4_dest, sizeof(ipv4_dest))) < 0)
 126                         return err;
 127                 }
 128
 129                 if ((err = add_rtattr(header, sizeof(request), IFA_LOCAL,
 130                                 &ipv4_addr, sizeof(ipv4_addr))) < 0)
 131                         return err;
 132
 133                 if ((err = add_rtattr(header, sizeof(request), IFA_BROADCAST,
 134                                 &ipv4_bcast, sizeof(ipv4_bcast))) < 0)
 135                         return err;
 136
 137         } else if (family == AF_INET6) {
 138                 if (inet_pton(AF_INET6, address, &ipv6_addr) < 1)
 139                         return -1;
 140
 141                 if ((err = add_rtattr(header, sizeof(request), IFA_LOCAL,
 142                                 &ipv6_addr, sizeof(ipv6_addr))) < 0)
 143                         return err;
 144         }
 145
 146         sk = socket(AF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
 147         if (sk < 0)
 148                 return -1;
 149
 150         memset(&nl_addr, 0, sizeof(nl_addr));
 151         nl_addr.nl_family = AF_NETLINK;
 152
 153         if ((err = sendto(sk, request, header->nlmsg_len, 0,
 154                         (struct sockaddr *) &nl_addr, sizeof(nl_addr))) < 0)
 155                 goto done;
 156
 157         err = 0;
 158
 159 done:
 160         close(sk);
 161
 162         return err;
 163 }
 164
 165 int connman_inet_ifindex(const char *name)
 166 {
 167         struct ifreq ifr;
 168         int sk, err;
 169
 170         if (name == NULL)
 171                 return -1;
 172
 173         sk = socket(PF_INET, SOCK_DGRAM, 0);
 174         if (sk < 0)
 175                 return -1;
 176
 177         memset(&ifr, 0, sizeof(ifr));
 178         strncpy(ifr.ifr_name, name, sizeof(ifr.ifr_name));
 179
 180         err = ioctl(sk, SIOCGIFINDEX, &ifr);
 181
 182         close(sk);
 183
 184         if (err < 0)
 185                 return -1;
 186
 187         return ifr.ifr_ifindex;
 188 }
 189
 190 char *connman_inet_ifname(int index)
 191 {
 192         struct ifreq ifr;
 193         int sk, err;
 194
 195         if (index < 0)
 196                 return NULL;
 197
 198         sk = socket(PF_INET, SOCK_DGRAM, 0);
 199         if (sk < 0)
 200                 return NULL;
 201
 202         memset(&ifr, 0, sizeof(ifr));
 203         ifr.ifr_ifindex = index;
 204
 205         err = ioctl(sk, SIOCGIFNAME, &ifr);
 206
 207         close(sk);
 208
 209         if (err < 0)
 210                 return NULL;
 211
 212         return strdup(ifr.ifr_name);
 213 }
 214
 215 short int connman_inet_ifflags(int index)
 216 {
 217         struct ifreq ifr;
 218         int sk, err;
 219
 220         sk = socket(PF_INET, SOCK_DGRAM, 0);
 221         if (sk < 0)
 222                 return -errno;
 223
 224         memset(&ifr, 0, sizeof(ifr));
 225         ifr.ifr_ifindex = index;
 226
 227         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 228                 err = -errno;
 229                 goto done;
 230         }
 231
 232         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 233                 err = -errno;
 234                 goto done;
 235         }
 236
 237         err = ifr.ifr_flags;
 238
 239 done:
 240         close(sk);
 241
 242         return err;
 243 }
 244
 245 int connman_inet_ifup(int index)
 246 {
 247         struct ifreq ifr;
 248         int sk, err;
 249
 250         sk = socket(PF_INET, SOCK_DGRAM, 0);
 251         if (sk < 0)
 252                 return -errno;
 253
 254         memset(&ifr, 0, sizeof(ifr));
 255         ifr.ifr_ifindex = index;
 256
 257         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 258                 err = -errno;
 259                 goto done;
 260         }
 261
 262         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 263                 err = -errno;
 264                 goto done;
 265         }
 266
 267         if (ifr.ifr_flags & IFF_UP) {
 268                 err = -EALREADY;
 269                 goto done;
 270         }
 271
 272         ifr.ifr_flags |= IFF_UP;
 273
 274         if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0) {
 275                 err = -errno;
 276                 goto done;
 277         }
 278
 279         err = 0;
 280
 281 done:
 282         close(sk);
 283
 284         return err;
 285 }
 286
 287 int connman_inet_ifdown(int index)
 288 {
 289         struct ifreq ifr;
 290         int sk, err;
 291
 292         sk = socket(PF_INET, SOCK_DGRAM, 0);
 293         if (sk < 0)
 294                 return -errno;
 295
 296         memset(&ifr, 0, sizeof(ifr));
 297         ifr.ifr_ifindex = index;
 298
 299         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0) {
 300                 err = -errno;
 301                 goto done;
 302         }
 303
 304         if (ioctl(sk, SIOCGIFFLAGS, &ifr) < 0) {
 305                 err = -errno;
 306                 goto done;
 307         }
 308
 309         if (!(ifr.ifr_flags & IFF_UP)) {
 310                 err = -EALREADY;
 311                 goto done;
 312         }
 313
 314         ifr.ifr_flags &= ~IFF_UP;
 315
 316         if (ioctl(sk, SIOCSIFFLAGS, &ifr) < 0)
 317                 err = -errno;
 318         else
 319                 err = 0;
 320
 321 done:
 322         close(sk);
 323
 324         return err;
 325 }
 326
 327 static char *index2addr(int index)
 328 {
 329         struct ifreq ifr;
 330         struct ether_addr eth;
 331         char *str;
 332         int sk, err;
 333
 334         if (index < 0)
 335                 return NULL;
 336
 337         sk = socket(PF_INET, SOCK_DGRAM, 0);
 338         if (sk < 0)
 339                 return NULL;
 340
 341         memset(&ifr, 0, sizeof(ifr));
 342         ifr.ifr_ifindex = index;
 343
 344         err = ioctl(sk, SIOCGIFNAME, &ifr);
 345
 346         if (err == 0)
 347                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
 348
 349         close(sk);
 350
 351         if (err < 0)
 352                 return NULL;
 353
 354         str = malloc(18);
 355         if (!str)
 356                 return NULL;
 357
 358         memcpy(&eth, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
 359         snprintf(str, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
 360                                                 eth.ether_addr_octet[0],
 361                                                 eth.ether_addr_octet[1],
 362                                                 eth.ether_addr_octet[2],
 363                                                 eth.ether_addr_octet[3],
 364                                                 eth.ether_addr_octet[4],
 365                                                 eth.ether_addr_octet[5]);
 366
 367         return str;
 368 }
 369
 370 static char *index2ident(int index, const char *prefix)
 371 {
 372         struct ifreq ifr;
 373         struct ether_addr eth;
 374         char *str;
 375         int sk, err, len;
 376
 377         if (index < 0)
 378                 return NULL;
 379
 380         sk = socket(PF_INET, SOCK_DGRAM, 0);
 381         if (sk < 0)
 382                 return NULL;
 383
 384         memset(&ifr, 0, sizeof(ifr));
 385         ifr.ifr_ifindex = index;
 386
 387         err = ioctl(sk, SIOCGIFNAME, &ifr);
 388
 389         if (err == 0)
 390                 err = ioctl(sk, SIOCGIFHWADDR, &ifr);
 391
 392         close(sk);
 393
 394         if (err < 0)
 395                 return NULL;
 396
 397         len = prefix ? strlen(prefix) + 18 : 18;
 398
 399         str = malloc(len);
 400         if (!str)
 401                 return NULL;
 402
 403         memcpy(&eth, &ifr.ifr_hwaddr.sa_data, sizeof(eth));
 404         snprintf(str, len, "%s%02x%02x%02x%02x%02x%02x",
 405                                                 prefix ? prefix : "",
 406                                                 eth.ether_addr_octet[0],
 407                                                 eth.ether_addr_octet[1],
 408                                                 eth.ether_addr_octet[2],
 409                                                 eth.ether_addr_octet[3],
 410                                                 eth.ether_addr_octet[4],
 411                                                 eth.ether_addr_octet[5]);
 412
 413         return str;
 414 }
 415
 416 connman_bool_t connman_inet_is_cfg80211(int index)
 417 {
 418         connman_bool_t result = FALSE;
 419         char phy80211_path[PATH_MAX];
 420         struct stat st;
 421         struct ifreq ifr;
 422         int sk;
 423
 424         sk = socket(PF_INET, SOCK_DGRAM, 0);
 425         if (sk < 0)
 426                 return FALSE;
 427
 428         memset(&ifr, 0, sizeof(ifr));
 429         ifr.ifr_ifindex = index;
 430
 431         if (ioctl(sk, SIOCGIFNAME, &ifr) < 0)
 432                 goto done;
 433
 434         snprintf(phy80211_path, PATH_MAX,
 435                                 "/sys/class/net/%s/phy80211", ifr.ifr_name);
 436
 437         if (stat(phy80211_path, &st) == 0 && (st.st_mode & S_IFDIR))
 438                 result = TRUE;
 439
 440 done:
 441         close(sk);
 442
 443         return result;
 444 }
 445
 446 struct connman_device *connman_inet_create_device(int index)
 447 {
 448         enum connman_device_type type;
 449         struct connman_device *device;
 450         char *devname, *ident = NULL;
 451         char *addr = NULL, *name = NULL;
 452
 453         if (index < 0)
 454                 return NULL;
 455
 456         devname = connman_inet_ifname(index);
 457         if (devname == NULL)
 458                 return NULL;
 459
 460         if (__connman_element_device_isfiltered(devname) == TRUE) {
 461                 connman_info("Ignoring interface %s (filtered)", devname);
 462                 return NULL;
 463         }
 464
 465         type = __connman_rtnl_get_device_type(index);
 466
 467         switch (type) {
 468         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 469                 connman_info("Ignoring interface %s (type unknown)", devname);
 470                 g_free(devname);
 471                 return NULL;
 472         case CONNMAN_DEVICE_TYPE_ETHERNET:
 473         case CONNMAN_DEVICE_TYPE_WIFI:
 474         case CONNMAN_DEVICE_TYPE_WIMAX:
 475                 name = index2ident(index, "");
 476                 addr = index2addr(index);
 477                 break;
 478         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 479         case CONNMAN_DEVICE_TYPE_CELLULAR:
 480         case CONNMAN_DEVICE_TYPE_GPS:
 481         case CONNMAN_DEVICE_TYPE_VENDOR:
 482                 name = strdup(devname);
 483                 break;
 484         }
 485
 486         device = connman_device_create(name, type);
 487         if (device == NULL)
 488                 goto done;
 489
 490         switch (type) {
 491         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 492         case CONNMAN_DEVICE_TYPE_VENDOR:
 493         case CONNMAN_DEVICE_TYPE_GPS:
 494                 break;
 495         case CONNMAN_DEVICE_TYPE_ETHERNET:
 496                 ident = index2ident(index, NULL);
 497                 break;
 498         case CONNMAN_DEVICE_TYPE_WIFI:
 499         case CONNMAN_DEVICE_TYPE_WIMAX:
 500                 ident = index2ident(index, NULL);
 501                 break;
 502         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 503                 break;
 504         case CONNMAN_DEVICE_TYPE_CELLULAR:
 505                 ident = index2ident(index, NULL);
 506                 break;
 507         }
 508
 509         connman_device_set_index(device, index);
 510         connman_device_set_interface(device, devname);
 511
 512         if (ident != NULL) {
 513                 connman_device_set_ident(device, ident);
 514                 free(ident);
 515         }
 516
 517         connman_device_set_string(device, "Address", addr);
 518
 519 done:
 520         g_free(devname);
 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 }
1104
1105 int connman_inet_remove_from_bridge(int index, const char *bridge)
1106 {
1107         struct ifreq ifr;
1108         int sk, err;
1109
1110         if (bridge == NULL)
1111                 return -EINVAL;
1112
1113         sk = socket(AF_INET, SOCK_STREAM, 0);
1114         if (sk < 0)
1115                 return sk;
1116
1117         memset(&ifr, 0, sizeof(ifr));
1118         strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1119         ifr.ifr_ifindex = index;
1120
1121         err = ioctl(sk, SIOCBRDELIF, &ifr);
1122
1123         close(sk);
1124
1125         if (err < 0) {
1126                 connman_error("Remove interface from bridge error %s",
1127                                                         strerror(errno));
1128                 return err;
1129         }
1130
1131         return 0;
1132 }
1133
1134 int connman_inet_add_to_bridge(int index, const char *bridge)
1135 {
1136         struct ifreq ifr;
1137         int sk, err;
1138
1139         if (bridge == NULL)
1140                 return -EINVAL;
1141
1142         sk = socket(AF_INET, SOCK_STREAM, 0);
1143         if (sk < 0)
1144                 return sk;
1145
1146         memset(&ifr, 0, sizeof(ifr));
1147         strncpy(ifr.ifr_name, bridge, IFNAMSIZ - 1);
1148         ifr.ifr_ifindex = index;
1149
1150         err = ioctl(sk, SIOCBRADDIF, &ifr);
1151
1152         close(sk);
1153
1154         if (err < 0) {
1155                 connman_error("Add interface to bridge error %s",
1156                                                         strerror(errno));
1157                 return err;
1158         }
1159
1160         return 0;
1161 }