src/rtnl.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 <unistd.h>
  28 #include <string.h>
  29 #include <sys/socket.h>
  30 #include <sys/ioctl.h>
  31 #include <arpa/inet.h>
  32 #include <netinet/ether.h>
  33 #include <netinet/icmp6.h>
  34 #include <net/if_arp.h>
  35 #include <linux/if.h>
  36 #include <linux/netlink.h>
  37 #include <linux/rtnetlink.h>
  38 #include <linux/wireless.h>
  39
  40 #include <glib.h>
  41
  42 #include "connman.h"
  43
  44 #ifndef ARPHDR_PHONET_PIPE
  45 #define ARPHDR_PHONET_PIPE (821)
  46 #endif
  47
  48 #define print(arg...) do { } while (0)
  49 //#define print(arg...) connman_info(arg)
  50
  51 struct watch_data {
  52         unsigned int id;
  53         int index;
  54         connman_rtnl_link_cb_t newlink;
  55         void *user_data;
  56 };
  57
  58 static GSList *watch_list = NULL;
  59 static unsigned int watch_id = 0;
  60
  61 static GSList *update_list = NULL;
  62 static guint update_interval = G_MAXUINT;
  63 static guint update_timeout = 0;
  64
  65 struct interface_data {
  66         int index;
  67         char *name;
  68         char *ident;
  69         enum connman_service_type service_type;
  70         enum connman_device_type device_type;
  71 };
  72
  73 static GHashTable *interface_list = NULL;
  74
  75 static void free_interface(gpointer data)
  76 {
  77         struct interface_data *interface = data;
  78
  79         __connman_technology_remove_interface(interface->service_type,
  80                         interface->index, interface->name, interface->ident);
  81
  82         g_free(interface->ident);
  83         g_free(interface->name);
  84         g_free(interface);
  85 }
  86
  87 static connman_bool_t ether_blacklisted(const char *name)
  88 {
  89         if (name == NULL)
  90                 return TRUE;
  91
  92         /* virtual interface from VMware */
  93         if (g_str_has_prefix(name, "vmnet") == TRUE)
  94                 return TRUE;
  95
  96         /* virtual interface from VirtualBox */
  97         if (g_str_has_prefix(name, "vboxnet") == TRUE)
  98                 return TRUE;
  99
 100         /* virtual interface from Virtual Machine Manager */
 101         if (g_str_has_prefix(name, "virbr") == TRUE)
 102                 return TRUE;
 103
 104         return FALSE;
 105 }
 106
 107 static connman_bool_t wext_interface(char *ifname)
 108 {
 109         struct iwreq wrq;
 110         int fd, err;
 111
 112         fd = socket(PF_INET, SOCK_DGRAM, 0);
 113         if (fd < 0)
 114                 return FALSE;
 115
 116         memset(&wrq, 0, sizeof(wrq));
 117         strncpy(wrq.ifr_name, ifname, IFNAMSIZ);
 118
 119         err = ioctl(fd, SIOCGIWNAME, &wrq);
 120
 121         close(fd);
 122
 123         if (err < 0)
 124                 return FALSE;
 125
 126         return TRUE;
 127 }
 128
 129 static void read_uevent(struct interface_data *interface)
 130 {
 131         char *filename, line[128];
 132         connman_bool_t found_devtype;
 133         FILE *f;
 134
 135         if (ether_blacklisted(interface->name) == TRUE) {
 136                 interface->service_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
 137                 interface->device_type = CONNMAN_DEVICE_TYPE_UNKNOWN;
 138         } else {
 139                 interface->service_type = CONNMAN_SERVICE_TYPE_ETHERNET;
 140                 interface->device_type = CONNMAN_DEVICE_TYPE_ETHERNET;
 141         }
 142
 143         filename = g_strdup_printf("/sys/class/net/%s/uevent",
 144                                                 interface->name);
 145
 146         f = fopen(filename, "re");
 147
 148         g_free(filename);
 149
 150         if (f == NULL)
 151                 return;
 152
 153         found_devtype = FALSE;
 154         while (fgets(line, sizeof(line), f)) {
 155                 char *pos;
 156
 157                 pos = strchr(line, '\n');
 158                 if (pos == NULL)
 159                         continue;
 160                 pos[0] = '\0';
 161
 162                 if (strncmp(line, "DEVTYPE=", 8) != 0)
 163                         continue;
 164
 165                 found_devtype = TRUE;
 166
 167                 if (strcmp(line + 8, "wlan") == 0) {
 168                         interface->service_type = CONNMAN_SERVICE_TYPE_WIFI;
 169                         interface->device_type = CONNMAN_DEVICE_TYPE_WIFI;
 170                 } else if (strcmp(line + 8, "wwan") == 0) {
 171                         interface->service_type = CONNMAN_SERVICE_TYPE_CELLULAR;
 172                         interface->device_type = CONNMAN_DEVICE_TYPE_CELLULAR;
 173                 } else if (strcmp(line + 8, "bluetooth") == 0) {
 174                         interface->service_type = CONNMAN_SERVICE_TYPE_BLUETOOTH;
 175                         interface->device_type = CONNMAN_DEVICE_TYPE_BLUETOOTH;
 176                 } else if (strcmp(line + 8, "wimax") == 0) {
 177                         interface->service_type = CONNMAN_SERVICE_TYPE_WIMAX;
 178                         interface->device_type = CONNMAN_DEVICE_TYPE_WIMAX;
 179                 } else if (strcmp(line + 8, "gadget") == 0) {
 180                         interface->service_type = CONNMAN_SERVICE_TYPE_GADGET;
 181                         interface->device_type = CONNMAN_DEVICE_TYPE_GADGET;
 182
 183                 } else {
 184                         interface->service_type = CONNMAN_SERVICE_TYPE_UNKNOWN;
 185                         interface->device_type = CONNMAN_DEVICE_TYPE_UNKNOWN;
 186                 }
 187         }
 188
 189         fclose(f);
 190
 191         if (found_devtype)
 192                 return;
 193
 194         /* We haven't got a DEVTYPE, let's check if it's a wireless device */
 195         if (wext_interface(interface->name)) {
 196                 interface->service_type = CONNMAN_SERVICE_TYPE_WIFI;
 197                 interface->device_type = CONNMAN_DEVICE_TYPE_WIFI;
 198
 199                 connman_error("%s runs an unsupported 802.11 driver",
 200                                 interface->name);
 201         }
 202 }
 203
 204 enum connman_device_type __connman_rtnl_get_device_type(int index)
 205 {
 206         struct interface_data *interface;
 207
 208         interface = g_hash_table_lookup(interface_list,
 209                                         GINT_TO_POINTER(index));
 210         if (interface == NULL)
 211                 return CONNMAN_DEVICE_TYPE_UNKNOWN;
 212
 213         return interface->device_type;
 214 }
 215
 216 /**
 217  * connman_rtnl_add_newlink_watch:
 218  * @index: network device index
 219  * @callback: callback function
 220  * @user_data: callback data;
 221  *
 222  * Add a new RTNL watch for newlink events
 223  *
 224  * Returns: %0 on failure and a unique id on success
 225  */
 226 unsigned int connman_rtnl_add_newlink_watch(int index,
 227                         connman_rtnl_link_cb_t callback, void *user_data)
 228 {
 229         struct watch_data *watch;
 230
 231         watch = g_try_new0(struct watch_data, 1);
 232         if (watch == NULL)
 233                 return 0;
 234
 235         watch->id = ++watch_id;
 236         watch->index = index;
 237
 238         watch->newlink = callback;
 239         watch->user_data = user_data;
 240
 241         watch_list = g_slist_prepend(watch_list, watch);
 242
 243         DBG("id %d", watch->id);
 244
 245         if (callback) {
 246                 unsigned int flags = __connman_ipconfig_get_flags(index);
 247
 248                 if (flags > 0)
 249                         callback(flags, 0, user_data);
 250         }
 251
 252         return watch->id;
 253 }
 254
 255 /**
 256  * connman_rtnl_remove_watch:
 257  * @id: watch identifier
 258  *
 259  * Remove the RTNL watch for the identifier
 260  */
 261 void connman_rtnl_remove_watch(unsigned int id)
 262 {
 263         GSList *list;
 264
 265         DBG("id %d", id);
 266
 267         if (id == 0)
 268                 return;
 269
 270         for (list = watch_list; list; list = list->next) {
 271                 struct watch_data *watch = list->data;
 272
 273                 if (watch->id  == id) {
 274                         watch_list = g_slist_remove(watch_list, watch);
 275                         g_free(watch);
 276                         break;
 277                 }
 278         }
 279 }
 280
 281 static void trigger_rtnl(int index, void *user_data)
 282 {
 283         struct connman_rtnl *rtnl = user_data;
 284
 285         if (rtnl->newlink) {
 286                 unsigned short type = __connman_ipconfig_get_type(index);
 287                 unsigned int flags = __connman_ipconfig_get_flags(index);
 288
 289                 rtnl->newlink(type, index, flags, 0);
 290         }
 291
 292         if (rtnl->newgateway) {
 293                 const char *gateway = __connman_ipconfig_get_gateway(index);
 294
 295                 if (gateway != NULL)
 296                         rtnl->newgateway(index, gateway);
 297         }
 298 }
 299
 300 static GSList *rtnl_list = NULL;
 301
 302 static gint compare_priority(gconstpointer a, gconstpointer b)
 303 {
 304         const struct connman_rtnl *rtnl1 = a;
 305         const struct connman_rtnl *rtnl2 = b;
 306
 307         return rtnl2->priority - rtnl1->priority;
 308 }
 309
 310 /**
 311  * connman_rtnl_register:
 312  * @rtnl: RTNL module
 313  *
 314  * Register a new RTNL module
 315  *
 316  * Returns: %0 on success
 317  */
 318 int connman_rtnl_register(struct connman_rtnl *rtnl)
 319 {
 320         DBG("rtnl %p name %s", rtnl, rtnl->name);
 321
 322         rtnl_list = g_slist_insert_sorted(rtnl_list, rtnl,
 323                                                         compare_priority);
 324
 325         __connman_ipconfig_foreach(trigger_rtnl, rtnl);
 326
 327         return 0;
 328 }
 329
 330 /**
 331  * connman_rtnl_unregister:
 332  * @rtnl: RTNL module
 333  *
 334  * Remove a previously registered RTNL module
 335  */
 336 void connman_rtnl_unregister(struct connman_rtnl *rtnl)
 337 {
 338         DBG("rtnl %p name %s", rtnl, rtnl->name);
 339
 340         rtnl_list = g_slist_remove(rtnl_list, rtnl);
 341 }
 342
 343 static const char *operstate2str(unsigned char operstate)
 344 {
 345         switch (operstate) {
 346         case IF_OPER_UNKNOWN:
 347                 return "UNKNOWN";
 348         case IF_OPER_NOTPRESENT:
 349                 return "NOT-PRESENT";
 350         case IF_OPER_DOWN:
 351                 return "DOWN";
 352         case IF_OPER_LOWERLAYERDOWN:
 353                 return "LOWER-LAYER-DOWN";
 354         case IF_OPER_TESTING:
 355                 return "TESTING";
 356         case IF_OPER_DORMANT:
 357                 return "DORMANT";
 358         case IF_OPER_UP:
 359                 return "UP";
 360         }
 361
 362         return "";
 363 }
 364
 365 static void extract_link(struct ifinfomsg *msg, int bytes,
 366                                 struct ether_addr *address, const char **ifname,
 367                                 unsigned int *mtu, unsigned char *operstate,
 368                                                 struct rtnl_link_stats *stats)
 369 {
 370         struct rtattr *attr;
 371
 372         for (attr = IFLA_RTA(msg); RTA_OK(attr, bytes);
 373                                         attr = RTA_NEXT(attr, bytes)) {
 374                 switch (attr->rta_type) {
 375                 case IFLA_ADDRESS:
 376                         if (address != NULL)
 377                                 memcpy(address, RTA_DATA(attr), ETH_ALEN);
 378                         break;
 379                 case IFLA_IFNAME:
 380                         if (ifname != NULL)
 381                                 *ifname = RTA_DATA(attr);
 382                         break;
 383                 case IFLA_MTU:
 384                         if (mtu != NULL)
 385                                 *mtu = *((unsigned int *) RTA_DATA(attr));
 386                         break;
 387                 case IFLA_STATS:
 388                         if (stats != NULL)
 389                                 memcpy(stats, RTA_DATA(attr),
 390                                         sizeof(struct rtnl_link_stats));
 391                         break;
 392                 case IFLA_OPERSTATE:
 393                         if (operstate != NULL)
 394                                 *operstate = *((unsigned char *) RTA_DATA(attr));
 395                         break;
 396                 case IFLA_LINKMODE:
 397                         break;
 398                 }
 399         }
 400 }
 401
 402 static void process_newlink(unsigned short type, int index, unsigned flags,
 403                         unsigned change, struct ifinfomsg *msg, int bytes)
 404 {
 405         struct ether_addr address = {{ 0, 0, 0, 0, 0, 0 }};
 406         struct ether_addr compare = {{ 0, 0, 0, 0, 0, 0 }};
 407         struct rtnl_link_stats stats;
 408         unsigned char operstate = 0xff;
 409         const char *ifname = NULL;
 410         unsigned int mtu = 0;
 411         char ident[13], str[18];
 412         GSList *list;
 413
 414         memset(&stats, 0, sizeof(stats));
 415         extract_link(msg, bytes, &address, &ifname, &mtu, &operstate, &stats);
 416
 417         snprintf(ident, 13, "%02x%02x%02x%02x%02x%02x",
 418                                                 address.ether_addr_octet[0],
 419                                                 address.ether_addr_octet[1],
 420                                                 address.ether_addr_octet[2],
 421                                                 address.ether_addr_octet[3],
 422                                                 address.ether_addr_octet[4],
 423                                                 address.ether_addr_octet[5]);
 424
 425         snprintf(str, 18, "%02X:%02X:%02X:%02X:%02X:%02X",
 426                                                 address.ether_addr_octet[0],
 427                                                 address.ether_addr_octet[1],
 428                                                 address.ether_addr_octet[2],
 429                                                 address.ether_addr_octet[3],
 430                                                 address.ether_addr_octet[4],
 431                                                 address.ether_addr_octet[5]);
 432
 433         switch (type) {
 434         case ARPHRD_ETHER:
 435         case ARPHRD_LOOPBACK:
 436         case ARPHDR_PHONET_PIPE:
 437         case ARPHRD_NONE:
 438                 __connman_ipconfig_newlink(index, type, flags,
 439                                                         str, mtu, &stats);
 440                 break;
 441         }
 442
 443         if (memcmp(&address, &compare, ETH_ALEN) != 0)
 444                 connman_info("%s {newlink} index %d address %s mtu %u",
 445                                                 ifname, index, str, mtu);
 446
 447         if (operstate != 0xff)
 448                 connman_info("%s {newlink} index %d operstate %u <%s>",
 449                                                 ifname, index, operstate,
 450                                                 operstate2str(operstate));
 451
 452         if (g_hash_table_lookup(interface_list,
 453                                         GINT_TO_POINTER(index)) == NULL) {
 454                 struct interface_data *interface;
 455
 456                 interface = g_new0(struct interface_data, 1);
 457                 interface->index = index;
 458                 interface->name = g_strdup(ifname);
 459                 interface->ident = g_strdup(ident);
 460
 461                 g_hash_table_insert(interface_list,
 462                                         GINT_TO_POINTER(index), interface);
 463
 464                 if (type == ARPHRD_ETHER)
 465                         read_uevent(interface);
 466
 467                 __connman_technology_add_interface(interface->service_type,
 468                         interface->index, interface->name, interface->ident);
 469         }
 470
 471         for (list = rtnl_list; list; list = list->next) {
 472                 struct connman_rtnl *rtnl = list->data;
 473
 474                 if (rtnl->newlink)
 475                         rtnl->newlink(type, index, flags, change);
 476         }
 477
 478         for (list = watch_list; list; list = list->next) {
 479                 struct watch_data *watch = list->data;
 480
 481                 if (watch->index != index)
 482                         continue;
 483
 484                 if (watch->newlink)
 485                         watch->newlink(flags, change, watch->user_data);
 486         }
 487 }
 488
 489 static void process_dellink(unsigned short type, int index, unsigned flags,
 490                         unsigned change, struct ifinfomsg *msg, int bytes)
 491 {
 492         struct rtnl_link_stats stats;
 493         unsigned char operstate = 0xff;
 494         const char *ifname = NULL;
 495         GSList *list;
 496
 497         memset(&stats, 0, sizeof(stats));
 498         extract_link(msg, bytes, NULL, &ifname, NULL, &operstate, &stats);
 499
 500         if (operstate != 0xff)
 501                 connman_info("%s {dellink} index %d operstate %u <%s>",
 502                                                 ifname, index, operstate,
 503                                                 operstate2str(operstate));
 504
 505         for (list = rtnl_list; list; list = list->next) {
 506                 struct connman_rtnl *rtnl = list->data;
 507
 508                 if (rtnl->dellink)
 509                         rtnl->dellink(type, index, flags, change);
 510         }
 511
 512         switch (type) {
 513         case ARPHRD_ETHER:
 514         case ARPHRD_LOOPBACK:
 515         case ARPHRD_NONE:
 516                 __connman_ipconfig_dellink(index, &stats);
 517                 break;
 518         }
 519
 520         g_hash_table_remove(interface_list, GINT_TO_POINTER(index));
 521 }
 522
 523 static void extract_ipv4_addr(struct ifaddrmsg *msg, int bytes,
 524                                                 const char **label,
 525                                                 struct in_addr *local,
 526                                                 struct in_addr *address,
 527                                                 struct in_addr *broadcast)
 528 {
 529         struct rtattr *attr;
 530
 531         for (attr = IFA_RTA(msg); RTA_OK(attr, bytes);
 532                                         attr = RTA_NEXT(attr, bytes)) {
 533                 switch (attr->rta_type) {
 534                 case IFA_ADDRESS:
 535                         if (address != NULL)
 536                                 *address = *((struct in_addr *) RTA_DATA(attr));
 537                         break;
 538                 case IFA_LOCAL:
 539                         if (local != NULL)
 540                                 *local = *((struct in_addr *) RTA_DATA(attr));
 541                         break;
 542                 case IFA_BROADCAST:
 543                         if (broadcast != NULL)
 544                                 *broadcast = *((struct in_addr *) RTA_DATA(attr));
 545                         break;
 546                 case IFA_LABEL:
 547                         if (label != NULL)
 548                                 *label = RTA_DATA(attr);
 549                         break;
 550                 }
 551         }
 552 }
 553
 554 static void extract_ipv6_addr(struct ifaddrmsg *msg, int bytes,
 555                                                 struct in6_addr *addr,
 556                                                 struct in6_addr *local)
 557 {
 558         struct rtattr *attr;
 559
 560         for (attr = IFA_RTA(msg); RTA_OK(attr, bytes);
 561                                         attr = RTA_NEXT(attr, bytes)) {
 562                 switch (attr->rta_type) {
 563                 case IFA_ADDRESS:
 564                         if (addr != NULL)
 565                                 *addr = *((struct in6_addr *) RTA_DATA(attr));
 566                         break;
 567                 case IFA_LOCAL:
 568                         if (local != NULL)
 569                                 *local = *((struct in6_addr *) RTA_DATA(attr));
 570                         break;
 571                 }
 572         }
 573 }
 574
 575 static void process_newaddr(unsigned char family, unsigned char prefixlen,
 576                                 int index, struct ifaddrmsg *msg, int bytes)
 577 {
 578         const char *label = NULL;
 579         void *src;
 580         char ip_string[INET6_ADDRSTRLEN];
 581
 582         if (family != AF_INET && family != AF_INET6)
 583                 return;
 584
 585         if (family == AF_INET) {
 586                 struct in_addr ipv4_addr = { INADDR_ANY };
 587
 588                 extract_ipv4_addr(msg, bytes, &label, &ipv4_addr, NULL, NULL);
 589                 src = &ipv4_addr;
 590         } else if (family == AF_INET6) {
 591                 struct in6_addr ipv6_address, ipv6_local;
 592
 593                 extract_ipv6_addr(msg, bytes, &ipv6_address, &ipv6_local);
 594                 if (IN6_IS_ADDR_LINKLOCAL(&ipv6_address))
 595                         return;
 596
 597                 src = &ipv6_address;
 598         }
 599
 600         if (inet_ntop(family, src, ip_string, INET6_ADDRSTRLEN) == NULL)
 601                 return;
 602
 603         __connman_ipconfig_newaddr(index, family, label,
 604                                         prefixlen, ip_string);
 605 }
 606
 607 static void process_deladdr(unsigned char family, unsigned char prefixlen,
 608                                 int index, struct ifaddrmsg *msg, int bytes)
 609 {
 610         const char *label = NULL;
 611         void *src;
 612         char ip_string[INET6_ADDRSTRLEN];
 613
 614         if (family != AF_INET && family != AF_INET6)
 615                 return;
 616
 617         if (family == AF_INET) {
 618                 struct in_addr ipv4_addr = { INADDR_ANY };
 619
 620                 extract_ipv4_addr(msg, bytes, &label, &ipv4_addr, NULL, NULL);
 621                 src = &ipv4_addr;
 622         } else if (family == AF_INET6) {
 623                 struct in6_addr ipv6_address, ipv6_local;
 624
 625                 extract_ipv6_addr(msg, bytes, &ipv6_address, &ipv6_local);
 626                 if (IN6_IS_ADDR_LINKLOCAL(&ipv6_address))
 627                         return;
 628
 629                 src = &ipv6_address;
 630         }
 631
 632         if (inet_ntop(family, src, ip_string, INET6_ADDRSTRLEN) == NULL)
 633                 return;
 634
 635         __connman_ipconfig_deladdr(index, family, label,
 636                                         prefixlen, ip_string);
 637 }
 638
 639 static void extract_route(struct rtmsg *msg, int bytes, int *index,
 640                                                 struct in_addr *dst,
 641                                                 struct in_addr *gateway)
 642 {
 643         struct rtattr *attr;
 644
 645         for (attr = RTM_RTA(msg); RTA_OK(attr, bytes);
 646                                         attr = RTA_NEXT(attr, bytes)) {
 647                 switch (attr->rta_type) {
 648                 case RTA_DST:
 649                         if (dst != NULL)
 650                                 *dst = *((struct in_addr *) RTA_DATA(attr));
 651                         break;
 652                 case RTA_GATEWAY:
 653                         if (gateway != NULL)
 654                                 *gateway = *((struct in_addr *) RTA_DATA(attr));
 655                         break;
 656                 case RTA_OIF:
 657                         if (index != NULL)
 658                                 *index = *((int *) RTA_DATA(attr));
 659                         break;
 660                 }
 661         }
 662 }
 663
 664 static void process_newroute(unsigned char family, unsigned char scope,
 665                                                 struct rtmsg *msg, int bytes)
 666 {
 667         GSList *list;
 668         struct in_addr dst = { INADDR_ANY }, gateway = { INADDR_ANY };
 669         char dststr[16], gatewaystr[16];
 670         int index = -1;
 671
 672         if (family != AF_INET)
 673                 return;
 674
 675         extract_route(msg, bytes, &index, &dst, &gateway);
 676
 677         inet_ntop(family, &dst, dststr, sizeof(dststr));
 678         inet_ntop(family, &gateway, gatewaystr, sizeof(gatewaystr));
 679
 680         __connman_ipconfig_newroute(index, family, scope, dststr, gatewaystr);
 681
 682         /* skip host specific routes */
 683         if (scope != RT_SCOPE_UNIVERSE &&
 684                         !(scope == RT_SCOPE_LINK && dst.s_addr == INADDR_ANY))
 685                 return;
 686
 687         if (dst.s_addr != INADDR_ANY)
 688                 return;
 689
 690         for (list = rtnl_list; list; list = list->next) {
 691                 struct connman_rtnl *rtnl = list->data;
 692
 693                 if (rtnl->newgateway)
 694                         rtnl->newgateway(index, gatewaystr);
 695         }
 696 }
 697
 698 static void process_delroute(unsigned char family, unsigned char scope,
 699                                                 struct rtmsg *msg, int bytes)
 700 {
 701         GSList *list;
 702         struct in_addr dst = { INADDR_ANY }, gateway = { INADDR_ANY };
 703         char dststr[16], gatewaystr[16];
 704         int index = -1;
 705
 706         if (family != AF_INET)
 707                 return;
 708
 709         extract_route(msg, bytes, &index, &dst, &gateway);
 710
 711         inet_ntop(family, &dst, dststr, sizeof(dststr));
 712         inet_ntop(family, &gateway, gatewaystr, sizeof(gatewaystr));
 713
 714         __connman_ipconfig_delroute(index, family, scope, dststr, gatewaystr);
 715
 716         /* skip host specific routes */
 717         if (scope != RT_SCOPE_UNIVERSE &&
 718                         !(scope == RT_SCOPE_LINK && dst.s_addr == INADDR_ANY))
 719                 return;
 720
 721         if (dst.s_addr != INADDR_ANY)
 722                 return;
 723
 724         for (list = rtnl_list; list; list = list->next) {
 725                 struct connman_rtnl *rtnl = list->data;
 726
 727                 if (rtnl->delgateway)
 728                         rtnl->delgateway(index, gatewaystr);
 729         }
 730 }
 731
 732 static inline void print_ether(struct rtattr *attr, const char *name)
 733 {
 734         int len = (int) RTA_PAYLOAD(attr);
 735
 736         if (len == ETH_ALEN) {
 737                 struct ether_addr eth;
 738                 memcpy(&eth, RTA_DATA(attr), ETH_ALEN);
 739                 print("  attr %s (len %d) %s\n", name, len, ether_ntoa(&eth));
 740         } else
 741                 print("  attr %s (len %d)\n", name, len);
 742 }
 743
 744 static inline void print_inet(struct rtattr *attr, const char *name,
 745                                                         unsigned char family)
 746 {
 747         int len = (int) RTA_PAYLOAD(attr);
 748
 749         if (family == AF_INET && len == sizeof(struct in_addr)) {
 750                 struct in_addr addr;
 751                 addr = *((struct in_addr *) RTA_DATA(attr));
 752                 print("  attr %s (len %d) %s\n", name, len, inet_ntoa(addr));
 753         } else
 754                 print("  attr %s (len %d)\n", name, len);
 755 }
 756
 757 static inline void print_string(struct rtattr *attr, const char *name)
 758 {
 759         print("  attr %s (len %d) %s\n", name, (int) RTA_PAYLOAD(attr),
 760                                                 (char *) RTA_DATA(attr));
 761 }
 762
 763 static inline void print_byte(struct rtattr *attr, const char *name)
 764 {
 765         print("  attr %s (len %d) 0x%02x\n", name, (int) RTA_PAYLOAD(attr),
 766                                         *((unsigned char *) RTA_DATA(attr)));
 767 }
 768
 769 static inline void print_integer(struct rtattr *attr, const char *name)
 770 {
 771         print("  attr %s (len %d) %d\n", name, (int) RTA_PAYLOAD(attr),
 772                                                 *((int *) RTA_DATA(attr)));
 773 }
 774
 775 static inline void print_attr(struct rtattr *attr, const char *name)
 776 {
 777         int len = (int) RTA_PAYLOAD(attr);
 778
 779         if (name && len > 0)
 780                 print("  attr %s (len %d)\n", name, len);
 781         else
 782                 print("  attr %d (len %d)\n", attr->rta_type, len);
 783 }
 784
 785 static void rtnl_link(struct nlmsghdr *hdr)
 786 {
 787         struct ifinfomsg *msg;
 788         struct rtattr *attr;
 789         int bytes;
 790
 791         msg = (struct ifinfomsg *) NLMSG_DATA(hdr);
 792         bytes = IFLA_PAYLOAD(hdr);
 793
 794         print("ifi_index %d ifi_flags 0x%04x", msg->ifi_index, msg->ifi_flags);
 795
 796         for (attr = IFLA_RTA(msg); RTA_OK(attr, bytes);
 797                                         attr = RTA_NEXT(attr, bytes)) {
 798                 switch (attr->rta_type) {
 799                 case IFLA_ADDRESS:
 800                         print_ether(attr, "address");
 801                         break;
 802                 case IFLA_BROADCAST:
 803                         print_ether(attr, "broadcast");
 804                         break;
 805                 case IFLA_IFNAME:
 806                         print_string(attr, "ifname");
 807                         break;
 808                 case IFLA_MTU:
 809                         print_integer(attr, "mtu");
 810                         break;
 811                 case IFLA_LINK:
 812                         print_attr(attr, "link");
 813                         break;
 814                 case IFLA_QDISC:
 815                         print_attr(attr, "qdisc");
 816                         break;
 817                 case IFLA_STATS:
 818                         print_attr(attr, "stats");
 819                         break;
 820                 case IFLA_COST:
 821                         print_attr(attr, "cost");
 822                         break;
 823                 case IFLA_PRIORITY:
 824                         print_attr(attr, "priority");
 825                         break;
 826                 case IFLA_MASTER:
 827                         print_attr(attr, "master");
 828                         break;
 829                 case IFLA_WIRELESS:
 830                         print_attr(attr, "wireless");
 831                         break;
 832                 case IFLA_PROTINFO:
 833                         print_attr(attr, "protinfo");
 834                         break;
 835                 case IFLA_TXQLEN:
 836                         print_integer(attr, "txqlen");
 837                         break;
 838                 case IFLA_MAP:
 839                         print_attr(attr, "map");
 840                         break;
 841                 case IFLA_WEIGHT:
 842                         print_attr(attr, "weight");
 843                         break;
 844                 case IFLA_OPERSTATE:
 845                         print_byte(attr, "operstate");
 846                         break;
 847                 case IFLA_LINKMODE:
 848                         print_byte(attr, "linkmode");
 849                         break;
 850                 default:
 851                         print_attr(attr, NULL);
 852                         break;
 853                 }
 854         }
 855 }
 856
 857 static void rtnl_newlink(struct nlmsghdr *hdr)
 858 {
 859         struct ifinfomsg *msg = (struct ifinfomsg *) NLMSG_DATA(hdr);
 860
 861         rtnl_link(hdr);
 862
 863         process_newlink(msg->ifi_type, msg->ifi_index, msg->ifi_flags,
 864                                 msg->ifi_change, msg, IFA_PAYLOAD(hdr));
 865 }
 866
 867 static void rtnl_dellink(struct nlmsghdr *hdr)
 868 {
 869         struct ifinfomsg *msg = (struct ifinfomsg *) NLMSG_DATA(hdr);
 870
 871         rtnl_link(hdr);
 872
 873         process_dellink(msg->ifi_type, msg->ifi_index, msg->ifi_flags,
 874                                 msg->ifi_change, msg, IFA_PAYLOAD(hdr));
 875 }
 876
 877 static void rtnl_addr(struct nlmsghdr *hdr)
 878 {
 879         struct ifaddrmsg *msg;
 880         struct rtattr *attr;
 881         int bytes;
 882
 883         msg = (struct ifaddrmsg *) NLMSG_DATA(hdr);
 884         bytes = IFA_PAYLOAD(hdr);
 885
 886         print("ifa_family %d ifa_index %d", msg->ifa_family, msg->ifa_index);
 887
 888         for (attr = IFA_RTA(msg); RTA_OK(attr, bytes);
 889                                         attr = RTA_NEXT(attr, bytes)) {
 890                 switch (attr->rta_type) {
 891                 case IFA_ADDRESS:
 892                         print_inet(attr, "address", msg->ifa_family);
 893                         break;
 894                 case IFA_LOCAL:
 895                         print_inet(attr, "local", msg->ifa_family);
 896                         break;
 897                 case IFA_LABEL:
 898                         print_string(attr, "label");
 899                         break;
 900                 case IFA_BROADCAST:
 901                         print_inet(attr, "broadcast", msg->ifa_family);
 902                         break;
 903                 case IFA_ANYCAST:
 904                         print_attr(attr, "anycast");
 905                         break;
 906                 case IFA_CACHEINFO:
 907                         print_attr(attr, "cacheinfo");
 908                         break;
 909                 case IFA_MULTICAST:
 910                         print_attr(attr, "multicast");
 911                         break;
 912                 default:
 913                         print_attr(attr, NULL);
 914                         break;
 915                 }
 916         }
 917 }
 918
 919 static void rtnl_newaddr(struct nlmsghdr *hdr)
 920 {
 921         struct ifaddrmsg *msg = (struct ifaddrmsg *) NLMSG_DATA(hdr);
 922
 923         rtnl_addr(hdr);
 924
 925         process_newaddr(msg->ifa_family, msg->ifa_prefixlen, msg->ifa_index,
 926                                                 msg, IFA_PAYLOAD(hdr));
 927 }
 928
 929 static void rtnl_deladdr(struct nlmsghdr *hdr)
 930 {
 931         struct ifaddrmsg *msg = (struct ifaddrmsg *) NLMSG_DATA(hdr);
 932
 933         rtnl_addr(hdr);
 934
 935         process_deladdr(msg->ifa_family, msg->ifa_prefixlen, msg->ifa_index,
 936                                                 msg, IFA_PAYLOAD(hdr));
 937 }
 938
 939 static void rtnl_route(struct nlmsghdr *hdr)
 940 {
 941         struct rtmsg *msg;
 942         struct rtattr *attr;
 943         int bytes;
 944
 945         msg = (struct rtmsg *) NLMSG_DATA(hdr);
 946         bytes = RTM_PAYLOAD(hdr);
 947
 948         print("rtm_family %d rtm_table %d rtm_protocol %d",
 949                         msg->rtm_family, msg->rtm_table, msg->rtm_protocol);
 950         print("rtm_scope %d rtm_type %d rtm_flags 0x%04x",
 951                                 msg->rtm_scope, msg->rtm_type, msg->rtm_flags);
 952
 953         for (attr = RTM_RTA(msg); RTA_OK(attr, bytes);
 954                                         attr = RTA_NEXT(attr, bytes)) {
 955                 switch (attr->rta_type) {
 956                 case RTA_DST:
 957                         print_inet(attr, "dst", msg->rtm_family);
 958                         break;
 959                 case RTA_SRC:
 960                         print_inet(attr, "src", msg->rtm_family);
 961                         break;
 962                 case RTA_IIF:
 963                         print_string(attr, "iif");
 964                         break;
 965                 case RTA_OIF:
 966                         print_integer(attr, "oif");
 967                         break;
 968                 case RTA_GATEWAY:
 969                         print_inet(attr, "gateway", msg->rtm_family);
 970                         break;
 971                 case RTA_PRIORITY:
 972                         print_attr(attr, "priority");
 973                         break;
 974                 case RTA_PREFSRC:
 975                         print_inet(attr, "prefsrc", msg->rtm_family);
 976                         break;
 977                 case RTA_METRICS:
 978                         print_attr(attr, "metrics");
 979                         break;
 980                 case RTA_TABLE:
 981                         print_integer(attr, "table");
 982                         break;
 983                 default:
 984                         print_attr(attr, NULL);
 985                         break;
 986                 }
 987         }
 988 }
 989
 990 static connman_bool_t is_route_rtmsg(struct rtmsg *msg)
 991 {
 992
 993         if (msg->rtm_table != RT_TABLE_MAIN)
 994                 return FALSE;
 995
 996         if (msg->rtm_protocol != RTPROT_BOOT &&
 997                         msg->rtm_protocol != RTPROT_KERNEL)
 998                 return FALSE;
 999
1000         if (msg->rtm_type != RTN_UNICAST)
1001                 return FALSE;
1002
1003         return TRUE;
1004 }
1005
1006 static void rtnl_newroute(struct nlmsghdr *hdr)
1007 {
1008         struct rtmsg *msg = (struct rtmsg *) NLMSG_DATA(hdr);
1009
1010         rtnl_route(hdr);
1011
1012         if (is_route_rtmsg(msg))
1013                 process_newroute(msg->rtm_family, msg->rtm_scope,
1014                                                 msg, RTM_PAYLOAD(hdr));
1015 }
1016
1017 static void rtnl_delroute(struct nlmsghdr *hdr)
1018 {
1019         struct rtmsg *msg = (struct rtmsg *) NLMSG_DATA(hdr);
1020
1021         rtnl_route(hdr);
1022
1023         if (is_route_rtmsg(msg))
1024                 process_delroute(msg->rtm_family, msg->rtm_scope,
1025                                                 msg, RTM_PAYLOAD(hdr));
1026 }
1027
1028 static void rtnl_nd_opt_rdnss(char *interface, struct nd_opt_hdr *opt)
1029 {
1030         guint32 *optint = (void *)opt;
1031         guint32 lifetime;
1032         char buf[80];
1033         int i;
1034
1035         if (opt->nd_opt_len < 3)
1036                 return;
1037
1038         lifetime = ntohl(optint[1]);
1039         if (!lifetime)
1040                 return;
1041
1042         optint += 2;
1043         for (i = 0; i < opt->nd_opt_len / 2; i++, optint += 4) {
1044                 if (inet_ntop(AF_INET6, optint, buf, sizeof(buf)))
1045                         connman_resolver_append_lifetime(interface, NULL,
1046                                                          buf, lifetime);
1047         }
1048 }
1049
1050 static void rtnl_newnduseropt(struct nlmsghdr *hdr)
1051 {
1052         struct nduseroptmsg *msg = (struct nduseroptmsg *) NLMSG_DATA(hdr);
1053         struct nd_opt_hdr *opt = (void *)&msg[1];
1054         int msglen = msg->nduseropt_opts_len;
1055         char *interface;
1056
1057         DBG("family %02x index %x len %04x type %02x code %02x",
1058             msg->nduseropt_family, msg->nduseropt_ifindex,
1059             msg->nduseropt_opts_len, msg->nduseropt_icmp_type,
1060             msg->nduseropt_icmp_code);
1061
1062         if (msg->nduseropt_family != AF_INET6 ||
1063             msg->nduseropt_icmp_type != ND_ROUTER_ADVERT ||
1064             msg->nduseropt_icmp_code != 0)
1065                 return;
1066
1067         interface = connman_inet_ifname(msg->nduseropt_ifindex);
1068         if (!interface)
1069                 return;
1070
1071         for (opt = (void *)&msg[1];
1072              msglen >= 2 && msglen >= opt->nd_opt_len && opt->nd_opt_len;
1073              msglen -= opt->nd_opt_len,
1074                      opt = ((void *)opt) + opt->nd_opt_len*8) {
1075
1076                 DBG("nd opt type %d len %d\n",
1077                     opt->nd_opt_type, opt->nd_opt_len);
1078
1079                 if (opt->nd_opt_type == 25)
1080                         rtnl_nd_opt_rdnss(interface, opt);
1081         }
1082         g_free(interface);
1083 }
1084
1085 static const char *type2string(uint16_t type)
1086 {
1087         switch (type) {
1088         case NLMSG_NOOP:
1089                 return "NOOP";
1090         case NLMSG_ERROR:
1091                 return "ERROR";
1092         case NLMSG_DONE:
1093                 return "DONE";
1094         case NLMSG_OVERRUN:
1095                 return "OVERRUN";
1096         case RTM_GETLINK:
1097                 return "GETLINK";
1098         case RTM_NEWLINK:
1099                 return "NEWLINK";
1100         case RTM_DELLINK:
1101                 return "DELLINK";
1102         case RTM_NEWADDR:
1103                 return "NEWADDR";
1104         case RTM_DELADDR:
1105                 return "DELADDR";
1106         case RTM_GETROUTE:
1107                 return "GETROUTE";
1108         case RTM_NEWROUTE:
1109                 return "NEWROUTE";
1110         case RTM_DELROUTE:
1111                 return "DELROUTE";
1112         case RTM_NEWNDUSEROPT:
1113                 return "NEWNDUSEROPT";
1114         default:
1115                 return "UNKNOWN";
1116         }
1117 }
1118
1119 static GIOChannel *channel = NULL;
1120
1121 struct rtnl_request {
1122         struct nlmsghdr hdr;
1123         struct rtgenmsg msg;
1124 };
1125 #define RTNL_REQUEST_SIZE  (sizeof(struct nlmsghdr) + sizeof(struct rtgenmsg))
1126
1127 static GSList *request_list = NULL;
1128 static guint32 request_seq = 0;
1129
1130 static struct rtnl_request *find_request(guint32 seq)
1131 {
1132         GSList *list;
1133
1134         for (list = request_list; list; list = list->next) {
1135                 struct rtnl_request *req = list->data;
1136
1137                 if (req->hdr.nlmsg_seq == seq)
1138                         return req;
1139         }
1140
1141         return NULL;
1142 }
1143
1144 static int send_request(struct rtnl_request *req)
1145 {
1146         struct sockaddr_nl addr;
1147         int sk;
1148
1149         DBG("%s len %d type %d flags 0x%04x seq %d",
1150                                 type2string(req->hdr.nlmsg_type),
1151                                 req->hdr.nlmsg_len, req->hdr.nlmsg_type,
1152                                 req->hdr.nlmsg_flags, req->hdr.nlmsg_seq);
1153
1154         sk = g_io_channel_unix_get_fd(channel);
1155
1156         memset(&addr, 0, sizeof(addr));
1157         addr.nl_family = AF_NETLINK;
1158
1159         return sendto(sk, req, req->hdr.nlmsg_len, 0,
1160                                 (struct sockaddr *) &addr, sizeof(addr));
1161 }
1162
1163 static int queue_request(struct rtnl_request *req)
1164 {
1165         request_list = g_slist_append(request_list, req);
1166
1167         if (g_slist_length(request_list) > 1)
1168                 return 0;
1169
1170         return send_request(req);
1171 }
1172
1173 static int process_response(guint32 seq)
1174 {
1175         struct rtnl_request *req;
1176
1177         DBG("seq %d", seq);
1178
1179         req = find_request(seq);
1180         if (req != NULL) {
1181                 request_list = g_slist_remove(request_list, req);
1182                 g_free(req);
1183         }
1184
1185         req = g_slist_nth_data(request_list, 0);
1186         if (req == NULL)
1187                 return 0;
1188
1189         return send_request(req);
1190 }
1191
1192 static void rtnl_message(void *buf, size_t len)
1193 {
1194         DBG("buf %p len %zd", buf, len);
1195
1196         while (len > 0) {
1197                 struct nlmsghdr *hdr = buf;
1198                 struct nlmsgerr *err;
1199
1200                 if (!NLMSG_OK(hdr, len))
1201                         break;
1202
1203                 DBG("%s len %d type %d flags 0x%04x seq %d",
1204                                         type2string(hdr->nlmsg_type),
1205                                         hdr->nlmsg_len, hdr->nlmsg_type,
1206                                         hdr->nlmsg_flags, hdr->nlmsg_seq);
1207
1208                 switch (hdr->nlmsg_type) {
1209                 case NLMSG_NOOP:
1210                 case NLMSG_OVERRUN:
1211                         return;
1212                 case NLMSG_DONE:
1213                         process_response(hdr->nlmsg_seq);
1214                         return;
1215                 case NLMSG_ERROR:
1216                         err = NLMSG_DATA(hdr);
1217                         DBG("error %d (%s)", -err->error,
1218                                                 strerror(-err->error));
1219                         return;
1220                 case RTM_NEWLINK:
1221                         rtnl_newlink(hdr);
1222                         break;
1223                 case RTM_DELLINK:
1224                         rtnl_dellink(hdr);
1225                         break;
1226                 case RTM_NEWADDR:
1227                         rtnl_newaddr(hdr);
1228                         break;
1229                 case RTM_DELADDR:
1230                         rtnl_deladdr(hdr);
1231                         break;
1232                 case RTM_NEWROUTE:
1233                         rtnl_newroute(hdr);
1234                         break;
1235                 case RTM_DELROUTE:
1236                         rtnl_delroute(hdr);
1237                         break;
1238                 case RTM_NEWNDUSEROPT:
1239                         rtnl_newnduseropt(hdr);
1240                         break;
1241                 }
1242
1243                 len -= hdr->nlmsg_len;
1244                 buf += hdr->nlmsg_len;
1245         }
1246 }
1247
1248 static gboolean netlink_event(GIOChannel *chan,
1249                                 GIOCondition cond, gpointer data)
1250 {
1251         unsigned char buf[4096];
1252         gsize len;
1253         GIOError err;
1254
1255         if (cond & (G_IO_NVAL | G_IO_HUP | G_IO_ERR))
1256                 return FALSE;
1257
1258         memset(buf, 0, sizeof(buf));
1259
1260         err = g_io_channel_read(chan, (gchar *) buf, sizeof(buf), &len);
1261         if (err) {
1262                 if (err == G_IO_ERROR_AGAIN)
1263                         return TRUE;
1264                 return FALSE;
1265         }
1266
1267         rtnl_message(buf, len);
1268
1269         return TRUE;
1270 }
1271
1272 static int send_getlink(void)
1273 {
1274         struct rtnl_request *req;
1275
1276         DBG("");
1277
1278         req = g_try_malloc0(RTNL_REQUEST_SIZE);
1279         if (req == NULL)
1280                 return -ENOMEM;
1281
1282         req->hdr.nlmsg_len = RTNL_REQUEST_SIZE;
1283         req->hdr.nlmsg_type = RTM_GETLINK;
1284         req->hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
1285         req->hdr.nlmsg_pid = 0;
1286         req->hdr.nlmsg_seq = request_seq++;
1287         req->msg.rtgen_family = AF_INET;
1288
1289         return queue_request(req);
1290 }
1291
1292 static int send_getaddr(void)
1293 {
1294         struct rtnl_request *req;
1295
1296         DBG("");
1297
1298         req = g_try_malloc0(RTNL_REQUEST_SIZE);
1299         if (req == NULL)
1300                 return -ENOMEM;
1301
1302         req->hdr.nlmsg_len = RTNL_REQUEST_SIZE;
1303         req->hdr.nlmsg_type = RTM_GETADDR;
1304         req->hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
1305         req->hdr.nlmsg_pid = 0;
1306         req->hdr.nlmsg_seq = request_seq++;
1307         req->msg.rtgen_family = AF_INET;
1308
1309         return queue_request(req);
1310 }
1311
1312 static int send_getroute(void)
1313 {
1314         struct rtnl_request *req;
1315
1316         DBG("");
1317
1318         req = g_try_malloc0(RTNL_REQUEST_SIZE);
1319         if (req == NULL)
1320                 return -ENOMEM;
1321
1322         req->hdr.nlmsg_len = RTNL_REQUEST_SIZE;
1323         req->hdr.nlmsg_type = RTM_GETROUTE;
1324         req->hdr.nlmsg_flags = NLM_F_REQUEST | NLM_F_DUMP;
1325         req->hdr.nlmsg_pid = 0;
1326         req->hdr.nlmsg_seq = request_seq++;
1327         req->msg.rtgen_family = AF_INET;
1328
1329         return queue_request(req);
1330 }
1331
1332 static gboolean update_timeout_cb(gpointer user_data)
1333 {
1334         __connman_rtnl_request_update();
1335
1336         return TRUE;
1337 }
1338
1339 static void update_interval_callback(guint min)
1340 {
1341         if (update_timeout > 0)
1342                 g_source_remove(update_timeout);
1343
1344         if (min < G_MAXUINT) {
1345                 update_interval = min;
1346                 update_timeout = g_timeout_add_seconds(update_interval,
1347                                                 update_timeout_cb, NULL);
1348         } else {
1349                 update_timeout = 0;
1350                 update_interval = G_MAXUINT;
1351         }
1352 }
1353
1354 static gint compare_interval(gconstpointer a, gconstpointer b)
1355 {
1356         guint val_a = GPOINTER_TO_UINT(a);
1357         guint val_b = GPOINTER_TO_UINT(b);
1358
1359         return val_a - val_b;
1360 }
1361
1362 unsigned int __connman_rtnl_update_interval_add(unsigned int interval)
1363 {
1364         guint min;
1365
1366         if (interval == 0)
1367                 return 0;
1368
1369         update_list = g_slist_insert_sorted(update_list,
1370                         GUINT_TO_POINTER(interval), compare_interval);
1371
1372         min = GPOINTER_TO_UINT(g_slist_nth_data(update_list, 0));
1373         if (min < update_interval) {
1374                 update_interval_callback(min);
1375                 __connman_rtnl_request_update();
1376         }
1377
1378         return update_interval;
1379 }
1380
1381 unsigned int __connman_rtnl_update_interval_remove(unsigned int interval)
1382 {
1383         guint min = G_MAXUINT;
1384
1385         if (interval == 0)
1386                 return 0;
1387
1388         update_list = g_slist_remove(update_list, GINT_TO_POINTER(interval));
1389
1390         if (update_list != NULL)
1391                 min = GPOINTER_TO_UINT(g_slist_nth_data(update_list, 0));
1392
1393         if (min > update_interval)
1394                 update_interval_callback(min);
1395
1396         return min;
1397 }
1398
1399 int __connman_rtnl_request_update(void)
1400 {
1401         return send_getlink();
1402 }
1403
1404 int __connman_rtnl_init(void)
1405 {
1406         struct sockaddr_nl addr;
1407         int sk;
1408
1409         DBG("");
1410
1411         interface_list = g_hash_table_new_full(g_direct_hash, g_direct_equal,
1412                                                         NULL, free_interface);
1413
1414         sk = socket(PF_NETLINK, SOCK_DGRAM, NETLINK_ROUTE);
1415         if (sk < 0)
1416                 return -1;
1417
1418         memset(&addr, 0, sizeof(addr));
1419         addr.nl_family = AF_NETLINK;
1420         addr.nl_groups = RTMGRP_LINK | RTMGRP_IPV4_IFADDR | RTMGRP_IPV4_ROUTE |
1421                                 RTMGRP_IPV6_IFADDR | RTMGRP_IPV6_ROUTE |
1422                                 (1<<(RTNLGRP_ND_USEROPT-1));
1423
1424         if (bind(sk, (struct sockaddr *) &addr, sizeof(addr)) < 0) {
1425                 close(sk);
1426                 return -1;
1427         }
1428
1429         channel = g_io_channel_unix_new(sk);
1430         g_io_channel_set_close_on_unref(channel, TRUE);
1431
1432         g_io_add_watch(channel, G_IO_IN | G_IO_NVAL | G_IO_HUP | G_IO_ERR,
1433                                                         netlink_event, NULL);
1434
1435         return 0;
1436 }
1437
1438 void __connman_rtnl_start(void)
1439 {
1440         DBG("");
1441
1442         send_getlink();
1443         send_getaddr();
1444         send_getroute();
1445 }
1446
1447 void __connman_rtnl_cleanup(void)
1448 {
1449         GSList *list;
1450
1451         DBG("");
1452
1453         for (list = watch_list; list; list = list->next) {
1454                 struct watch_data *watch = list->data;
1455
1456                 DBG("removing watch %d", watch->id);
1457
1458                 g_free(watch);
1459                 list->data = NULL;
1460         }
1461
1462         g_slist_free(watch_list);
1463         watch_list = NULL;
1464
1465         g_slist_free(update_list);
1466         update_list = NULL;
1467
1468         for (list = request_list; list; list = list->next) {
1469                 struct rtnl_request *req = list->data;
1470
1471                 DBG("%s len %d type %d flags 0x%04x seq %d",
1472                                 type2string(req->hdr.nlmsg_type),
1473                                 req->hdr.nlmsg_len, req->hdr.nlmsg_type,
1474                                 req->hdr.nlmsg_flags, req->hdr.nlmsg_seq);
1475
1476                 g_free(req);
1477                 list->data = NULL;
1478         }
1479
1480         g_slist_free(request_list);
1481         request_list = NULL;
1482
1483         g_io_channel_shutdown(channel, TRUE, NULL);
1484         g_io_channel_unref(channel);
1485
1486         channel = NULL;
1487
1488         g_hash_table_destroy(interface_list);
1489 }