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