src/element.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 <errno.h>
  27 #include <stdarg.h>
  28 #include <string.h>
  29
  30 #include <glib.h>
  31 #include <gdbus.h>
  32
  33 #include "connman.h"
  34
  35 static DBusConnection *connection;
  36
  37 static GNode *element_root = NULL;
  38 static GSList *driver_list = NULL;
  39 static gchar **device_filter = NULL;
  40 static gchar **nodevice_filter = NULL;
  41
  42 static gboolean started = FALSE;
  43
  44 static const char *type2string(enum connman_element_type type)
  45 {
  46         switch (type) {
  47         case CONNMAN_ELEMENT_TYPE_UNKNOWN:
  48                 return "unknown";
  49         case CONNMAN_ELEMENT_TYPE_ROOT:
  50                 return "root";
  51         case CONNMAN_ELEMENT_TYPE_DEVICE:
  52                 return "device";
  53         case CONNMAN_ELEMENT_TYPE_NETWORK:
  54                 return "network";
  55         case CONNMAN_ELEMENT_TYPE_SERVICE:
  56                 return "service";
  57         case CONNMAN_ELEMENT_TYPE_BOOTP:
  58                 return "bootp";
  59         case CONNMAN_ELEMENT_TYPE_ZEROCONF:
  60                 return "zeroconf";
  61         case CONNMAN_ELEMENT_TYPE_VENDOR:
  62                 return "vendor";
  63         }
  64
  65         return NULL;
  66 }
  67
  68 struct foreach_data {
  69         enum connman_element_type type;
  70         element_cb_t callback;
  71         gpointer user_data;
  72 };
  73
  74 static gboolean foreach_callback(GNode *node, gpointer user_data)
  75 {
  76         struct connman_element *element = node->data;
  77         struct foreach_data *data = user_data;
  78
  79         DBG("element %p name %s", element, element->name);
  80
  81         if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
  82                 return FALSE;
  83
  84         if (data->type != CONNMAN_ELEMENT_TYPE_UNKNOWN &&
  85                                         data->type != element->type)
  86                 return FALSE;
  87
  88         if (data->callback)
  89                 data->callback(element, data->user_data);
  90
  91         return FALSE;
  92 }
  93
  94 void __connman_element_foreach(struct connman_element *element,
  95                                 enum connman_element_type type,
  96                                 element_cb_t callback, gpointer user_data)
  97 {
  98         struct foreach_data data = { type, callback, user_data };
  99         GNode *node;
 100
 101         DBG("");
 102
 103         if (element != NULL) {
 104                 node = g_node_find(element_root, G_PRE_ORDER,
 105                                                 G_TRAVERSE_ALL, element);
 106                 if (node == NULL)
 107                         return;
 108         } else
 109                 node = element_root;
 110
 111         g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
 112                                                 foreach_callback, &data);
 113 }
 114
 115 struct append_filter {
 116         enum connman_element_type type;
 117         DBusMessageIter *iter;
 118 };
 119
 120 static gboolean append_path(GNode *node, gpointer user_data)
 121 {
 122         struct connman_element *element = node->data;
 123         struct append_filter *filter = user_data;
 124
 125         DBG("element %p name %s", element, element->name);
 126
 127         if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
 128                 return FALSE;
 129
 130         if (filter->type != CONNMAN_ELEMENT_TYPE_UNKNOWN &&
 131                                         filter->type != element->type)
 132                 return FALSE;
 133
 134         if (filter->type == CONNMAN_ELEMENT_TYPE_DEVICE &&
 135                         __connman_device_has_driver(element->device) == FALSE)
 136                 return FALSE;
 137
 138         if (filter->type == CONNMAN_ELEMENT_TYPE_NETWORK &&
 139                         __connman_network_has_driver(element->network) == FALSE)
 140                 return FALSE;
 141
 142         dbus_message_iter_append_basic(filter->iter,
 143                                 DBUS_TYPE_OBJECT_PATH, &element->path);
 144
 145         return FALSE;
 146 }
 147
 148 void __connman_element_list(struct connman_element *element,
 149                                         enum connman_element_type type,
 150                                                         DBusMessageIter *iter)
 151 {
 152         struct append_filter filter = { type, iter };
 153         GNode *node;
 154
 155         DBG("");
 156
 157         if (element != NULL) {
 158                 node = g_node_find(element_root, G_PRE_ORDER,
 159                                                 G_TRAVERSE_ALL, element);
 160                 if (node == NULL)
 161                         return;
 162         } else
 163                 node = element_root;
 164
 165         g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
 166                                                 append_path, &filter);
 167 }
 168
 169 static struct connman_network *get_network(struct connman_element *element)
 170 {
 171         if (element->type == CONNMAN_ELEMENT_TYPE_NETWORK &&
 172                                                 element->network != NULL)
 173                 return element->network;
 174
 175         if (element->parent == NULL)
 176                 return NULL;
 177
 178         return get_network(element->parent);
 179 }
 180
 181 struct connman_service *__connman_element_get_service(struct connman_element *element)
 182 {
 183         struct connman_service *service = NULL;
 184         struct connman_network *network;
 185         struct connman_device *device;
 186         enum connman_device_type type;
 187
 188         device = __connman_element_get_device(element);
 189         if (device == NULL) {
 190                 /* Workaround for the connection removal. */
 191                 service = __connman_service_lookup_from_index(element->index);
 192                 return service;
 193         }
 194
 195         type = connman_device_get_type(device);
 196
 197         switch (type) {
 198         case CONNMAN_DEVICE_TYPE_UNKNOWN:
 199         case CONNMAN_DEVICE_TYPE_VENDOR:
 200         case CONNMAN_DEVICE_TYPE_GPS:
 201         case CONNMAN_DEVICE_TYPE_GADGET:
 202                 break;
 203         case CONNMAN_DEVICE_TYPE_ETHERNET:
 204         case CONNMAN_DEVICE_TYPE_WIFI:
 205         case CONNMAN_DEVICE_TYPE_WIMAX:
 206         case CONNMAN_DEVICE_TYPE_BLUETOOTH:
 207         case CONNMAN_DEVICE_TYPE_CELLULAR:
 208                 network = get_network(element);
 209                 if (network == NULL)
 210                         return NULL;
 211                 service = __connman_service_lookup_from_network(network);
 212                 break;
 213         }
 214
 215         return service;
 216 }
 217
 218 struct connman_device *__connman_element_get_device(struct connman_element *element)
 219 {
 220         if (element->type == CONNMAN_ELEMENT_TYPE_DEVICE &&
 221                                                 element->device != NULL)
 222                 return element->device;
 223
 224         if (element->parent == NULL)
 225                 return NULL;
 226
 227         return __connman_element_get_device(element->parent);
 228 }
 229
 230 struct find_data {
 231         enum connman_service_type type;
 232         struct connman_device *device;
 233         connman_bool_t error;
 234 };
 235
 236 static gboolean find_device(GNode *node, gpointer user_data)
 237 {
 238         struct connman_element *element = node->data;
 239         struct find_data *data = user_data;
 240
 241         if (element->type != CONNMAN_ELEMENT_TYPE_DEVICE)
 242                 return FALSE;
 243
 244         if (element->device == NULL)
 245                 return FALSE;
 246
 247         if (data->type != __connman_device_get_service_type(element->device))
 248                 return FALSE;
 249
 250         data->device = element->device;
 251
 252         return TRUE;
 253 }
 254
 255 struct connman_device *__connman_element_find_device(enum connman_service_type type)
 256 {
 257         struct find_data data = { .type = type, .device = NULL };
 258
 259         g_node_traverse(element_root, G_PRE_ORDER,
 260                                 G_TRAVERSE_ALL, -1, find_device, &data);
 261
 262         return data.device;
 263 }
 264
 265 static gboolean request_scan(GNode *node, gpointer user_data)
 266 {
 267         struct connman_element *element = node->data;
 268         struct find_data *data = user_data;
 269         enum connman_service_type type;
 270
 271         if (element->type != CONNMAN_ELEMENT_TYPE_DEVICE)
 272                 return FALSE;
 273
 274         if (element->device == NULL)
 275                 return FALSE;
 276
 277         type = __connman_device_get_service_type(element->device);
 278
 279         switch (type) {
 280         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 281         case CONNMAN_SERVICE_TYPE_SYSTEM:
 282         case CONNMAN_SERVICE_TYPE_ETHERNET:
 283         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 284         case CONNMAN_SERVICE_TYPE_CELLULAR:
 285         case CONNMAN_SERVICE_TYPE_GPS:
 286         case CONNMAN_SERVICE_TYPE_VPN:
 287         case CONNMAN_SERVICE_TYPE_GADGET:
 288                 return FALSE;
 289         case CONNMAN_SERVICE_TYPE_WIFI:
 290         case CONNMAN_SERVICE_TYPE_WIMAX:
 291                 if (data->type != CONNMAN_SERVICE_TYPE_UNKNOWN &&
 292                                                         data->type != type)
 293                         return FALSE;
 294                 break;
 295         }
 296
 297         __connman_device_scan(element->device);
 298
 299         return FALSE;
 300 }
 301
 302 int __connman_element_request_scan(enum connman_service_type type)
 303 {
 304         struct find_data data = { .type = type, .device = NULL };
 305
 306         g_node_traverse(element_root, G_PRE_ORDER,
 307                                 G_TRAVERSE_ALL, -1, request_scan, &data);
 308
 309         return 0;
 310 }
 311
 312 static gboolean enable_technology(GNode *node, gpointer user_data)
 313 {
 314         struct connman_element *element = node->data;
 315         struct find_data *data = user_data;
 316         enum connman_service_type type;
 317         int err;
 318
 319         if (element->type != CONNMAN_ELEMENT_TYPE_DEVICE)
 320                 return FALSE;
 321
 322         if (element->device == NULL)
 323                 return FALSE;
 324
 325         type = __connman_device_get_service_type(element->device);
 326
 327         switch (type) {
 328         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 329         case CONNMAN_SERVICE_TYPE_SYSTEM:
 330         case CONNMAN_SERVICE_TYPE_GPS:
 331         case CONNMAN_SERVICE_TYPE_VPN:
 332         case CONNMAN_SERVICE_TYPE_GADGET:
 333                 return FALSE;
 334         case CONNMAN_SERVICE_TYPE_ETHERNET:
 335         case CONNMAN_SERVICE_TYPE_WIFI:
 336         case CONNMAN_SERVICE_TYPE_WIMAX:
 337         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 338         case CONNMAN_SERVICE_TYPE_CELLULAR:
 339                 if (data->type != CONNMAN_SERVICE_TYPE_UNKNOWN &&
 340                                                         data->type != type)
 341                         return FALSE;
 342                 break;
 343         }
 344
 345         err = __connman_device_enable_persistent(element->device);
 346         if (err == 0 || (err < 0 && err == -EINPROGRESS))
 347                 data->error = FALSE;
 348
 349         return FALSE;
 350 }
 351
 352 int __connman_element_enable_technology(enum connman_service_type type)
 353 {
 354         struct find_data data = { .type = type, .device = NULL, .error = TRUE };
 355
 356         g_node_traverse(element_root, G_PRE_ORDER,
 357                                 G_TRAVERSE_ALL, -1, enable_technology, &data);
 358
 359         if (data.error == TRUE)
 360                 return -ENODEV;
 361
 362         return 0;
 363 }
 364
 365 static gboolean disable_technology(GNode *node, gpointer user_data)
 366 {
 367         struct connman_element *element = node->data;
 368         struct find_data *data = user_data;
 369         enum connman_service_type type;
 370         int err;
 371
 372         if (element->type != CONNMAN_ELEMENT_TYPE_DEVICE)
 373                 return FALSE;
 374
 375         if (element->device == NULL)
 376                 return FALSE;
 377
 378         type = __connman_device_get_service_type(element->device);
 379
 380         switch (type) {
 381         case CONNMAN_SERVICE_TYPE_UNKNOWN:
 382         case CONNMAN_SERVICE_TYPE_SYSTEM:
 383         case CONNMAN_SERVICE_TYPE_GPS:
 384         case CONNMAN_SERVICE_TYPE_VPN:
 385         case CONNMAN_SERVICE_TYPE_GADGET:
 386                 return FALSE;
 387         case CONNMAN_SERVICE_TYPE_ETHERNET:
 388         case CONNMAN_SERVICE_TYPE_WIFI:
 389         case CONNMAN_SERVICE_TYPE_WIMAX:
 390         case CONNMAN_SERVICE_TYPE_BLUETOOTH:
 391         case CONNMAN_SERVICE_TYPE_CELLULAR:
 392                 if (data->type != CONNMAN_SERVICE_TYPE_UNKNOWN &&
 393                                                         data->type != type)
 394                         return FALSE;
 395                 break;
 396         }
 397
 398         err = __connman_device_disable_persistent(element->device);
 399         if (err == 0 || (err < 0 && err == -EINPROGRESS))
 400                 data->error = FALSE;
 401
 402         return FALSE;
 403 }
 404
 405 int __connman_element_disable_technology(enum connman_service_type type)
 406 {
 407         struct find_data data = { .type = type, .device = NULL, .error = TRUE };
 408
 409         g_node_traverse(element_root, G_PRE_ORDER,
 410                                 G_TRAVERSE_ALL, -1, disable_technology, &data);
 411
 412         if (data.error == TRUE)
 413                 return -ENODEV;
 414
 415         return 0;
 416 }
 417
 418 static gint compare_priority(gconstpointer a, gconstpointer b)
 419 {
 420         const struct connman_driver *driver1 = a;
 421         const struct connman_driver *driver2 = b;
 422
 423         return driver2->priority - driver1->priority;
 424 }
 425
 426 static gboolean match_driver(struct connman_element *element,
 427                                         struct connman_driver *driver)
 428 {
 429         if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
 430                 return FALSE;
 431
 432         if (element->type == driver->type ||
 433                         driver->type == CONNMAN_ELEMENT_TYPE_UNKNOWN)
 434                 return TRUE;
 435
 436         return FALSE;
 437 }
 438
 439 static gboolean probe_driver(GNode *node, gpointer data)
 440 {
 441         struct connman_element *element = node->data;
 442         struct connman_driver *driver = data;
 443
 444         DBG("element %p name %s", element, element->name);
 445
 446         if (!element->driver && match_driver(element, driver) == TRUE) {
 447                 if (driver->probe(element) < 0)
 448                         return FALSE;
 449
 450                 element->driver = driver;
 451         }
 452
 453         return FALSE;
 454 }
 455
 456 void __connman_driver_rescan(struct connman_driver *driver)
 457 {
 458         DBG("driver %p name %s", driver, driver->name);
 459
 460         if (!driver->probe)
 461                 return;
 462
 463         if (element_root != NULL)
 464                 g_node_traverse(element_root, G_PRE_ORDER,
 465                                 G_TRAVERSE_ALL, -1, probe_driver, driver);
 466 }
 467
 468 /**
 469  * connman_driver_register:
 470  * @driver: driver definition
 471  *
 472  * Register a new driver
 473  *
 474  * Returns: %0 on success
 475  */
 476 int connman_driver_register(struct connman_driver *driver)
 477 {
 478         DBG("driver %p name %s", driver, driver->name);
 479
 480         if (driver->type == CONNMAN_ELEMENT_TYPE_ROOT)
 481                 return -EINVAL;
 482
 483         if (!driver->probe)
 484                 return -EINVAL;
 485
 486         driver_list = g_slist_insert_sorted(driver_list, driver,
 487                                                         compare_priority);
 488
 489         if (started == FALSE)
 490                 return 0;
 491
 492         if (element_root != NULL)
 493                 g_node_traverse(element_root, G_PRE_ORDER,
 494                                 G_TRAVERSE_ALL, -1, probe_driver, driver);
 495
 496         return 0;
 497 }
 498
 499 static gboolean remove_driver(GNode *node, gpointer data)
 500 {
 501         struct connman_element *element = node->data;
 502         struct connman_driver *driver = data;
 503
 504         DBG("element %p name %s", element, element->name);
 505
 506         if (element->driver == driver) {
 507                 if (driver->remove)
 508                         driver->remove(element);
 509
 510                 element->driver = NULL;
 511         }
 512
 513         return FALSE;
 514 }
 515
 516 /**
 517  * connman_driver_unregister:
 518  * @driver: driver definition
 519  *
 520  * Remove a previously registered driver
 521  */
 522 void connman_driver_unregister(struct connman_driver *driver)
 523 {
 524         DBG("driver %p name %s", driver, driver->name);
 525
 526         driver_list = g_slist_remove(driver_list, driver);
 527
 528         if (element_root != NULL)
 529                 g_node_traverse(element_root, G_POST_ORDER,
 530                                 G_TRAVERSE_ALL, -1, remove_driver, driver);
 531 }
 532
 533 static void unregister_property(gpointer data)
 534 {
 535         struct connman_property *property = data;
 536
 537         DBG("property %p", property);
 538
 539         g_free(property->value);
 540         g_free(property);
 541 }
 542
 543 static void unregister_child(gpointer data)
 544 {
 545         struct connman_element *element = data;
 546
 547         DBG("element %p", element);
 548
 549         connman_element_unref(element);
 550 }
 551
 552 void __connman_element_initialize(struct connman_element *element)
 553 {
 554         DBG("element %p", element);
 555
 556         element->refcount = 1;
 557
 558         element->name    = NULL;
 559         element->type    = CONNMAN_ELEMENT_TYPE_UNKNOWN;
 560         element->state   = CONNMAN_ELEMENT_STATE_UNKNOWN;
 561         element->error   = CONNMAN_ELEMENT_ERROR_UNKNOWN;
 562         element->index   = -1;
 563         element->enabled = FALSE;
 564
 565         element->children = g_hash_table_new_full(g_str_hash, g_str_equal,
 566                                                 NULL, unregister_child);
 567
 568         element->properties = g_hash_table_new_full(g_str_hash, g_str_equal,
 569                                                 g_free, unregister_property);
 570 }
 571
 572 /**
 573  * connman_element_create:
 574  * @name: element name
 575  *
 576  * Allocate a new element and assign the given #name to it. If the name
 577  * is #NULL, it will be later on created based on the element type.
 578  *
 579  * Returns: a newly-allocated #connman_element structure
 580  */
 581 struct connman_element *connman_element_create(const char *name)
 582 {
 583         struct connman_element *element;
 584
 585         element = g_try_new0(struct connman_element, 1);
 586         if (element == NULL)
 587                 return NULL;
 588
 589         DBG("element %p", element);
 590
 591         __connman_element_initialize(element);
 592
 593         element->name = g_strdup(name);
 594
 595         return element;
 596 }
 597
 598 struct connman_element *connman_element_ref(struct connman_element *element)
 599 {
 600         DBG("element %p name %s refcount %d", element, element->name,
 601                                 g_atomic_int_get(&element->refcount) + 1);
 602
 603         g_atomic_int_inc(&element->refcount);
 604
 605         return element;
 606 }
 607
 608 static void free_properties(struct connman_element *element)
 609 {
 610         DBG("element %p name %s", element, element->name);
 611
 612         g_hash_table_destroy(element->properties);
 613         element->properties = NULL;
 614 }
 615
 616 static void free_children(struct connman_element *element)
 617 {
 618         DBG("element %p name %s", element, element->name);
 619
 620         g_hash_table_destroy(element->children);
 621         element->children = NULL;
 622 }
 623
 624 void connman_element_unref(struct connman_element *element)
 625 {
 626         DBG("element %p name %s refcount %d", element, element->name,
 627                                 g_atomic_int_get(&element->refcount) - 1);
 628
 629         if (g_atomic_int_dec_and_test(&element->refcount) == TRUE) {
 630                 if (element->destruct)
 631                         element->destruct(element);
 632                 free_children(element);
 633                 free_properties(element);
 634                 g_free(element->hostname);
 635                 g_free(element->domainname);
 636                 g_free(element->ipv6.address);
 637                 g_free(element->ipv6.network);
 638                 g_free(element->devname);
 639                 g_free(element->path);
 640                 g_free(element->name);
 641                 g_free(element);
 642         }
 643 }
 644
 645 static int set_static_property(struct connman_element *element,
 646                                 const char *name, int type, const void *value)
 647 {
 648         struct connman_property *property;
 649
 650         DBG("element %p name %s", element, element->name);
 651
 652         if (type != DBUS_TYPE_STRING && type != DBUS_TYPE_BYTE)
 653                 return -EINVAL;
 654
 655         property = g_try_new0(struct connman_property, 1);
 656         if (property == NULL)
 657                 return -ENOMEM;
 658
 659         property->id   = CONNMAN_PROPERTY_ID_INVALID;
 660         property->type = type;
 661
 662         DBG("name %s type %d value %p", name, type, value);
 663
 664         switch (type) {
 665         case DBUS_TYPE_STRING:
 666                 property->value = g_strdup(*((const char **) value));
 667                 break;
 668         case DBUS_TYPE_BOOLEAN:
 669         case DBUS_TYPE_BYTE:
 670                 property->value = g_try_malloc(1);
 671                 if (property->value != NULL)
 672                         memcpy(property->value, value, 1);
 673                 break;
 674         }
 675
 676         g_hash_table_replace(element->properties, g_strdup(name), property);
 677
 678         return 0;
 679 }
 680
 681 static int set_static_array_property(struct connman_element *element,
 682                         const char *name, int type, const void *value, int len)
 683 {
 684         struct connman_property *property;
 685
 686         DBG("element %p name %s", element, element->name);
 687
 688         if (type != DBUS_TYPE_BYTE)
 689                 return -EINVAL;
 690
 691         property = g_try_new0(struct connman_property, 1);
 692         if (property == NULL)
 693                 return -ENOMEM;
 694
 695         property->id      = CONNMAN_PROPERTY_ID_INVALID;
 696         property->type    = DBUS_TYPE_ARRAY;
 697         property->subtype = type;
 698
 699         DBG("name %s type %d value %p", name, type, value);
 700
 701         switch (type) {
 702         case DBUS_TYPE_BYTE:
 703                 property->value = g_try_malloc(len);
 704                 if (property->value != NULL) {
 705                         memcpy(property->value,
 706                                 *((const unsigned char **) value), len);
 707                         property->size = len;
 708                 }
 709                 break;
 710         }
 711
 712         g_hash_table_replace(element->properties, g_strdup(name), property);
 713
 714         return 0;
 715 }
 716
 717 int connman_element_get_value(struct connman_element *element,
 718                                 enum connman_property_id id, void *value)
 719 {
 720         if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
 721                 return -EINVAL;
 722
 723         switch (id) {
 724         case CONNMAN_PROPERTY_ID_HOSTNAME:
 725                 if (element->hostname == NULL)
 726                         return connman_element_get_value(element->parent,
 727                                                                 id, value);
 728                 *((char **) value) = element->hostname;
 729                 break;
 730         case CONNMAN_PROPERTY_ID_DOMAINNAME:
 731                 if (element->domainname == NULL)
 732                         return connman_element_get_value(element->parent,
 733                                                                 id, value);
 734                 *((char **) value) = element->domainname;
 735                 break;
 736         case CONNMAN_PROPERTY_ID_IPV6_GATEWAY:
 737                 if (element->ipv6.gateway == NULL)
 738                         return connman_element_get_value(element->parent,
 739                                                                 id, value);
 740                 *((char **) value) = element->ipv6.gateway;
 741                 break;
 742
 743         default:
 744                 return -EINVAL;
 745         }
 746
 747         return 0;
 748 }
 749
 750 static gboolean get_static_property(struct connman_element *element,
 751                                                 const char *name, void *value)
 752 {
 753         struct connman_property *property;
 754         gboolean found = FALSE;
 755
 756         DBG("element %p name %s", element, element->name);
 757
 758         property = g_hash_table_lookup(element->properties, name);
 759         if (property != NULL) {
 760                 switch (property->type) {
 761                 case DBUS_TYPE_STRING:
 762                         *((char **) value) = property->value;
 763                         found = TRUE;
 764                         break;
 765                 case DBUS_TYPE_BOOLEAN:
 766                 case DBUS_TYPE_BYTE:
 767                         memcpy(value, property->value, 1);
 768                         found = TRUE;
 769                         break;
 770                 }
 771         }
 772
 773         if (found == FALSE && element->parent != NULL)
 774                 return get_static_property(element->parent, name, value);
 775
 776         return found;
 777 }
 778
 779 static gboolean get_static_array_property(struct connman_element *element,
 780                         const char *name, void *value, unsigned int *len)
 781 {
 782         struct connman_property *property;
 783         gboolean found = FALSE;
 784
 785         DBG("element %p name %s", element, element->name);
 786
 787         property = g_hash_table_lookup(element->properties, name);
 788         if (property != NULL) {
 789                 *((void **) value) = property->value;
 790                 *len = property->size;
 791                 found = TRUE;
 792         }
 793
 794         return found;
 795 }
 796
 797 /**
 798  * connman_element_set_string:
 799  * @element: element structure
 800  * @key: unique identifier
 801  * @value: string value
 802  *
 803  * Set string value for specific key
 804  */
 805 int connman_element_set_string(struct connman_element *element,
 806                                         const char *key, const char *value)
 807 {
 808         return set_static_property(element, key, DBUS_TYPE_STRING, &value);
 809 }
 810
 811 /**
 812  * connman_element_get_string:
 813  * @element: element structure
 814  * @key: unique identifier
 815  *
 816  * Get string value for specific key
 817  */
 818 const char *connman_element_get_string(struct connman_element *element,
 819                                                         const char *key)
 820 {
 821         const char *value;
 822
 823         if (get_static_property(element, key, &value) == FALSE)
 824                 return NULL;
 825
 826         return value;
 827 }
 828
 829 /**
 830  * connman_element_set_bool:
 831  * @element: element structure
 832  * @key: unique identifier
 833  * @value: boolean value
 834  *
 835  * Set boolean value for specific key
 836  */
 837 int connman_element_set_bool(struct connman_element *element,
 838                                         const char *key, connman_bool_t value)
 839 {
 840         return set_static_property(element, key, DBUS_TYPE_BOOLEAN, &value);
 841 }
 842
 843 /**
 844  * connman_element_get_bool:
 845  * @element: element structure
 846  * @key: unique identifier
 847  *
 848  * Get boolean value for specific key
 849  */
 850 connman_bool_t connman_element_get_bool(struct connman_element *element,
 851                                                         const char *key)
 852 {
 853         connman_bool_t value;
 854
 855         if (get_static_property(element, key, &value) == FALSE)
 856                 return FALSE;
 857
 858         return value;
 859 }
 860
 861 /**
 862  * connman_element_set_uint8:
 863  * @element: element structure
 864  * @key: unique identifier
 865  * @value: integer value
 866  *
 867  * Set integer value for specific key
 868  */
 869 int connman_element_set_uint8(struct connman_element *element,
 870                                         const char *key, connman_uint8_t value)
 871 {
 872         return set_static_property(element, key, DBUS_TYPE_BYTE, &value);
 873 }
 874
 875 /**
 876  * connman_element_get_uint8:
 877  * @element: element structure
 878  * @key: unique identifier
 879  *
 880  * Get integer value for specific key
 881  */
 882 connman_uint8_t connman_element_get_uint8(struct connman_element *element,
 883                                                         const char *key)
 884 {
 885         connman_uint8_t value;
 886
 887         if (get_static_property(element, key, &value) == FALSE)
 888                 return 0;
 889
 890         return value;
 891 }
 892
 893 /**
 894  * connman_element_set_blob:
 895  * @element: element structure
 896  * @key: unique identifier
 897  * @data: blob data
 898  * @size: blob size
 899  *
 900  * Set binary blob value for specific key
 901  */
 902 int connman_element_set_blob(struct connman_element *element,
 903                         const char *key, const void *data, unsigned int size)
 904 {
 905         return set_static_array_property(element, key,
 906                                                 DBUS_TYPE_BYTE, &data, size);
 907 }
 908
 909 /**
 910  * connman_element_get_blob:
 911  * @element: element structure
 912  * @key: unique identifier
 913  * @size: pointer to blob size
 914  *
 915  * Get binary blob value for specific key
 916  */
 917 const void *connman_element_get_blob(struct connman_element *element,
 918                                         const char *key, unsigned int *size)
 919 {
 920         void *value;
 921
 922         if (get_static_array_property(element, key, &value, size) == FALSE)
 923                 return NULL;
 924
 925         return value;
 926 }
 927
 928 static void probe_element(struct connman_element *element)
 929 {
 930         GSList *list;
 931
 932         DBG("element %p name %s", element, element->name);
 933
 934         for (list = driver_list; list; list = list->next) {
 935                 struct connman_driver *driver = list->data;
 936
 937                 if (match_driver(element, driver) == FALSE)
 938                         continue;
 939
 940                 DBG("driver %p name %s", driver, driver->name);
 941
 942                 if (driver->probe(element) == 0) {
 943                         element->driver = driver;
 944                         break;
 945                 }
 946         }
 947 }
 948
 949 static void register_element(gpointer data, gpointer user_data)
 950 {
 951         struct connman_element *element = data;
 952         const gchar *basepath;
 953         GNode *node;
 954
 955         if (element->parent) {
 956                 node = g_node_find(element_root, G_PRE_ORDER,
 957                                         G_TRAVERSE_ALL, element->parent);
 958                 basepath = element->parent->path;
 959         } else {
 960                 element->parent = element_root->data;
 961
 962                 node = element_root;
 963                 basepath = CONNMAN_PATH "/device";
 964         }
 965
 966         element->path = g_strdup_printf("%s/%s", basepath, element->name);
 967
 968         if (node == NULL) {
 969                 connman_error("Element registration for %s failed",
 970                                                         element->path);
 971                 return;
 972         }
 973
 974         DBG("element %p path %s", element, element->path);
 975
 976         g_node_append_data(node, element);
 977
 978         if (started == FALSE)
 979                 return;
 980
 981         probe_element(element);
 982 }
 983
 984 gboolean __connman_element_device_isfiltered(const char *devname)
 985 {
 986         char **pattern;
 987
 988         if (device_filter == NULL)
 989                 goto nodevice;
 990
 991         for (pattern = device_filter; *pattern; pattern++) {
 992                 if (g_pattern_match_simple(*pattern, devname) == FALSE) {
 993                         DBG("ignoring device %s (match)", devname);
 994                         return TRUE;
 995                 }
 996         }
 997
 998 nodevice:
 999         if (nodevice_filter == NULL)
1000                 return FALSE;
1001
1002         for (pattern = nodevice_filter; *pattern; pattern++) {
1003                 if (g_pattern_match_simple(*pattern, devname) == TRUE) {
1004                         DBG("ignoring device %s (no match)", devname);
1005                         return TRUE;
1006                 }
1007         }
1008
1009         return FALSE;
1010 }
1011
1012 /**
1013  * connman_element_register:
1014  * @element: the element to register
1015  * @parent: the parent to register the element with
1016  *
1017  * Register an element with the core. It will be register under the given
1018  * parent of if %NULL is provided under the root element.
1019  *
1020  * Returns: %0 on success
1021  */
1022 int connman_element_register(struct connman_element *element,
1023                                         struct connman_element *parent)
1024 {
1025         DBG("element %p name %s parent %p", element, element->name, parent);
1026
1027         if (element->devname == NULL)
1028                 element->devname = g_strdup(element->name);
1029
1030         if (element->type != CONNMAN_ELEMENT_TYPE_DEVICE)
1031                 goto setup;
1032
1033         if (__connman_element_device_isfiltered(element->devname) == TRUE)
1034                 return -EPERM;
1035
1036 setup:
1037         if (connman_element_ref(element) == NULL)
1038                 return -EINVAL;
1039
1040         if (element->name == NULL) {
1041                 element->name = g_strdup(type2string(element->type));
1042                 if (element->name == NULL) {
1043                         return -EINVAL;
1044                 }
1045         }
1046
1047         element->parent = parent;
1048
1049         register_element(element, NULL);
1050
1051         return 0;
1052 }
1053
1054 static gboolean remove_element(GNode *node, gpointer user_data)
1055 {
1056         struct connman_element *element = node->data;
1057         struct connman_element *root = user_data;
1058
1059         DBG("element %p name %s", element, element->name);
1060
1061         if (element == root)
1062                 return FALSE;
1063
1064         g_node_unlink(node);
1065
1066         if (element->driver) {
1067                 if (element->driver->remove)
1068                         element->driver->remove(element);
1069
1070                 element->driver = NULL;
1071         }
1072
1073         g_node_destroy(node);
1074
1075         connman_element_unref(element);
1076
1077         return FALSE;
1078 }
1079
1080 struct unregister_type {
1081         struct connman_element *root;
1082         enum connman_element_type type;
1083 };
1084
1085 static gboolean remove_element_type(GNode *node, gpointer user_data)
1086 {
1087         struct unregister_type *children_type = user_data;
1088         struct connman_element *root = children_type->root;
1089         struct connman_element *element = node->data;
1090         enum connman_element_type type = children_type->type;
1091
1092         DBG("element %p name %s", element, element->name);
1093
1094         if (element == root)
1095                 return FALSE;
1096
1097         if(element->type != type)
1098                 return FALSE;
1099
1100         g_node_unlink(node);
1101
1102         if (element->driver) {
1103                 if (element->driver->remove)
1104                         element->driver->remove(element);
1105
1106                 element->driver = NULL;
1107         }
1108
1109         g_node_destroy(node);
1110
1111         connman_element_unref(element);
1112
1113         return FALSE;
1114 }
1115
1116
1117 void connman_element_unregister(struct connman_element *element)
1118 {
1119         GNode *node;
1120
1121         DBG("element %p name %s", element, element->name);
1122
1123         node = g_node_find(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, element);
1124
1125         if (node != NULL)
1126                 g_node_traverse(node, G_POST_ORDER,
1127                                 G_TRAVERSE_ALL, -1, remove_element, NULL);
1128 }
1129
1130 void connman_element_unregister_children(struct connman_element *element)
1131 {
1132         GNode *node;
1133
1134         DBG("element %p name %s", element, element->name);
1135
1136         node = g_node_find(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, element);
1137
1138         if (node != NULL)
1139                 g_node_traverse(node, G_POST_ORDER,
1140                                 G_TRAVERSE_ALL, -1, remove_element, element);
1141 }
1142
1143 void connman_element_unregister_children_type(struct connman_element *element, enum connman_element_type type)
1144 {
1145         GNode *node;
1146
1147         DBG("element %p name %s", element, element->name);
1148
1149         node = g_node_find(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, element);
1150
1151         if (node != NULL) {
1152                 struct unregister_type children_type;
1153
1154                 children_type.root = element;
1155                 children_type.type = type;
1156                 g_node_traverse(node, G_POST_ORDER,
1157                                 G_TRAVERSE_ALL, -1, remove_element_type, &children_type);
1158         }
1159 }
1160
1161
1162 static gboolean update_element(GNode *node, gpointer user_data)
1163 {
1164         struct connman_element *element = node->data;
1165
1166         DBG("element %p name %s", element, element->name);
1167
1168         if (element->driver && element->driver->update)
1169                 element->driver->update(element);
1170
1171         return FALSE;
1172 }
1173
1174 void connman_element_update(struct connman_element *element)
1175 {
1176         GNode *node;
1177
1178         DBG("element %p name %s", element, element->name);
1179
1180         node = g_node_find(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, element);
1181
1182         if (node != NULL)
1183                 g_node_traverse(node, G_PRE_ORDER,
1184                                 G_TRAVERSE_ALL, -1, update_element, element);
1185 }
1186
1187 int connman_element_set_enabled(struct connman_element *element,
1188                                                         gboolean enabled)
1189 {
1190         if (element->enabled == enabled)
1191                 return 0;
1192
1193         element->enabled = enabled;
1194
1195         connman_element_update(element);
1196
1197         return 0;
1198 }
1199
1200 static enum connman_service_error convert_error(enum connman_element_error error)
1201 {
1202         switch (error) {
1203         case CONNMAN_ELEMENT_ERROR_UNKNOWN:
1204         case CONNMAN_ELEMENT_ERROR_FAILED:
1205                 break;
1206         case CONNMAN_ELEMENT_ERROR_DHCP_FAILED:
1207                 return CONNMAN_SERVICE_ERROR_DHCP_FAILED;
1208         case CONNMAN_ELEMENT_ERROR_CONNECT_FAILED:
1209                 return CONNMAN_SERVICE_ERROR_CONNECT_FAILED;
1210         }
1211
1212         return CONNMAN_SERVICE_ERROR_UNKNOWN;
1213 }
1214
1215 /**
1216  * connman_element_set_error:
1217  * @element: element structure
1218  * @error: error identifier
1219  *
1220  * Set error state and specific error identifier
1221  */
1222 void connman_element_set_error(struct connman_element *element,
1223                                         enum connman_element_error error)
1224 {
1225         struct connman_service *service;
1226
1227         DBG("element %p error %d", element, error);
1228
1229         if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
1230                 return;
1231
1232         element->state = CONNMAN_ELEMENT_STATE_ERROR;
1233         element->error = error;
1234
1235         if (element->driver && element->driver->change)
1236                 element->driver->change(element);
1237
1238         service = __connman_element_get_service(element);
1239         __connman_service_indicate_error(service, convert_error(error));
1240 }
1241
1242 void __connman_element_set_driver(struct connman_element *element)
1243 {
1244         GSList *list;
1245
1246         DBG("element %p name %s driver %p", element, element->name,
1247                                                 element->driver);
1248
1249         if (element->driver)
1250                 return;
1251
1252         for (list = driver_list; list; list = list->next) {
1253                 struct connman_driver *driver = list->data;
1254
1255                 if (match_driver(element, driver) == FALSE)
1256                         continue;
1257
1258                 element->driver = driver;
1259
1260                 break;
1261         }
1262 }
1263
1264 int __connman_element_init(const char *device, const char *nodevice)
1265 {
1266         struct connman_element *element;
1267
1268         DBG("");
1269
1270         connection = connman_dbus_get_connection();
1271         if (connection == NULL)
1272                 return -EIO;
1273
1274         if (device)
1275                 device_filter = g_strsplit(device, ",", -1);
1276
1277         if (nodevice)
1278                 nodevice_filter = g_strsplit(nodevice, ",", -1);
1279
1280         element = connman_element_create("root");
1281
1282         element->path = g_strdup("/");
1283         element->type = CONNMAN_ELEMENT_TYPE_ROOT;
1284
1285         element_root = g_node_new(element);
1286
1287         __connman_technology_init();
1288         __connman_notifier_init();
1289         __connman_location_init();
1290         __connman_service_init();
1291         __connman_provider_init();
1292         __connman_network_init();
1293         __connman_device_init();
1294
1295         return 0;
1296 }
1297
1298 static gboolean probe_node(GNode *node, gpointer data)
1299 {
1300         struct connman_element *element = node->data;
1301
1302         DBG("element %p name %s", element, element->name);
1303
1304         if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
1305                 return FALSE;
1306
1307         if (element->driver)
1308                 return FALSE;
1309
1310         probe_element(element);
1311
1312         return FALSE;
1313 }
1314
1315 void __connman_element_start(void)
1316 {
1317         DBG("");
1318
1319         __connman_storage_init_profile();
1320
1321         g_node_traverse(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1322                                                         probe_node, NULL);
1323
1324         started = TRUE;
1325
1326         __connman_rtnl_start();
1327
1328         __connman_dhcp_init();
1329         __connman_wpad_init();
1330         __connman_wispr_init();
1331
1332         __connman_rfkill_init();
1333 }
1334
1335 void __connman_element_stop(void)
1336 {
1337         DBG("");
1338
1339         __connman_rfkill_cleanup();
1340
1341         __connman_wispr_cleanup();
1342         __connman_wpad_cleanup();
1343         __connman_dhcp_cleanup();
1344         __connman_provider_cleanup();
1345 }
1346
1347 static gboolean free_driver(GNode *node, gpointer data)
1348 {
1349         struct connman_element *element = node->data;
1350
1351         DBG("element %p name %s", element, element->name);
1352
1353         if (element->driver) {
1354                 if (element->driver->remove)
1355                         element->driver->remove(element);
1356
1357                 element->driver = NULL;
1358         }
1359
1360         return FALSE;
1361 }
1362
1363 static gboolean free_node(GNode *node, gpointer data)
1364 {
1365         struct connman_element *element = node->data;
1366
1367         DBG("element %p name %s", element, element->name);
1368
1369         if (g_node_depth(node) > 1)
1370                 connman_element_unregister(element);
1371
1372         return FALSE;
1373 }
1374
1375 void __connman_element_cleanup(void)
1376 {
1377         DBG("");
1378
1379         __connman_device_cleanup();
1380         __connman_network_cleanup();
1381         __connman_service_cleanup();
1382         __connman_location_cleanup();
1383         __connman_notifier_cleanup();
1384         __connman_technology_cleanup();
1385
1386         g_node_traverse(element_root, G_POST_ORDER, G_TRAVERSE_ALL, -1,
1387                                                         free_driver, NULL);
1388
1389         g_node_traverse(element_root, G_POST_ORDER, G_TRAVERSE_ALL, -1,
1390                                                         free_node, NULL);
1391
1392         connman_element_unref(element_root->data);
1393
1394         g_node_destroy(element_root);
1395         element_root = NULL;
1396
1397         g_strfreev(nodevice_filter);
1398         g_strfreev(device_filter);
1399
1400         if (connection == NULL)
1401                 return;
1402
1403         dbus_connection_unref(connection);
1404 }