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