5 * Copyright (C) 2007-2010 Intel Corporation. All rights reserved.
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.
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.
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
35 static DBusConnection *connection;
37 static GNode *element_root = NULL;
38 static GSList *driver_list = NULL;
39 static gchar **device_filter = NULL;
40 static gchar **nodevice_filter = NULL;
42 static gboolean started = FALSE;
44 static const char *type2string(enum connman_element_type type)
47 case CONNMAN_ELEMENT_TYPE_UNKNOWN:
49 case CONNMAN_ELEMENT_TYPE_ROOT:
51 case CONNMAN_ELEMENT_TYPE_PROFILE:
53 case CONNMAN_ELEMENT_TYPE_DEVICE:
55 case CONNMAN_ELEMENT_TYPE_NETWORK:
57 case CONNMAN_ELEMENT_TYPE_SERVICE:
59 case CONNMAN_ELEMENT_TYPE_IPV4:
61 case CONNMAN_ELEMENT_TYPE_IPV6:
63 case CONNMAN_ELEMENT_TYPE_DHCP:
65 case CONNMAN_ELEMENT_TYPE_BOOTP:
67 case CONNMAN_ELEMENT_TYPE_ZEROCONF:
69 case CONNMAN_ELEMENT_TYPE_CONNECTION:
71 case CONNMAN_ELEMENT_TYPE_VENDOR:
79 enum connman_element_type type;
80 element_cb_t callback;
84 static gboolean foreach_callback(GNode *node, gpointer user_data)
86 struct connman_element *element = node->data;
87 struct foreach_data *data = user_data;
89 DBG("element %p name %s", element, element->name);
91 if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
94 if (data->type != CONNMAN_ELEMENT_TYPE_UNKNOWN &&
95 data->type != element->type)
99 data->callback(element, data->user_data);
104 void __connman_element_foreach(struct connman_element *element,
105 enum connman_element_type type,
106 element_cb_t callback, gpointer user_data)
108 struct foreach_data data = { type, callback, user_data };
113 if (element != NULL) {
114 node = g_node_find(element_root, G_PRE_ORDER,
115 G_TRAVERSE_ALL, element);
121 g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
122 foreach_callback, &data);
125 struct append_filter {
126 enum connman_element_type type;
127 DBusMessageIter *iter;
130 static gboolean append_path(GNode *node, gpointer user_data)
132 struct connman_element *element = node->data;
133 struct append_filter *filter = user_data;
135 DBG("element %p name %s", element, element->name);
137 if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
140 if (filter->type != CONNMAN_ELEMENT_TYPE_UNKNOWN &&
141 filter->type != element->type)
144 if (filter->type == CONNMAN_ELEMENT_TYPE_DEVICE &&
145 __connman_device_has_driver(element->device) == FALSE)
148 if (filter->type == CONNMAN_ELEMENT_TYPE_NETWORK &&
149 __connman_network_has_driver(element->network) == FALSE)
152 dbus_message_iter_append_basic(filter->iter,
153 DBUS_TYPE_OBJECT_PATH, &element->path);
158 void __connman_element_list(struct connman_element *element,
159 enum connman_element_type type,
160 DBusMessageIter *iter)
162 struct append_filter filter = { type, iter };
167 if (element != NULL) {
168 node = g_node_find(element_root, G_PRE_ORDER,
169 G_TRAVERSE_ALL, element);
175 g_node_traverse(node, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
176 append_path, &filter);
179 static struct connman_network *get_network(struct connman_element *element)
181 if (element->type == CONNMAN_ELEMENT_TYPE_NETWORK &&
182 element->network != NULL)
183 return element->network;
185 if (element->parent == NULL)
188 return get_network(element->parent);
191 struct connman_service *__connman_element_get_service(struct connman_element *element)
193 struct connman_service *service = NULL;
194 struct connman_network *network;
195 struct connman_device *device;
196 enum connman_device_type type;
198 device = __connman_element_get_device(element);
202 type = connman_device_get_type(device);
205 case CONNMAN_DEVICE_TYPE_UNKNOWN:
206 case CONNMAN_DEVICE_TYPE_VENDOR:
207 case CONNMAN_DEVICE_TYPE_GPS:
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 = get_network(element);
217 service = __connman_service_lookup_from_network(network);
224 struct connman_device *__connman_element_get_device(struct connman_element *element)
226 if (element->type == CONNMAN_ELEMENT_TYPE_DEVICE &&
227 element->device != NULL)
228 return element->device;
230 if (element->parent == NULL)
233 return __connman_element_get_device(element->parent);
237 enum connman_service_type type;
238 struct connman_device *device;
239 connman_bool_t error;
242 static gboolean find_device(GNode *node, gpointer user_data)
244 struct connman_element *element = node->data;
245 struct find_data *data = user_data;
247 if (element->type != CONNMAN_ELEMENT_TYPE_DEVICE)
250 if (element->device == NULL)
253 if (data->type != __connman_device_get_service_type(element->device))
256 data->device = element->device;
261 struct connman_device *__connman_element_find_device(enum connman_service_type type)
263 struct find_data data = { .type = type, .device = NULL };
265 g_node_traverse(element_root, G_PRE_ORDER,
266 G_TRAVERSE_ALL, -1, find_device, &data);
271 static gboolean request_scan(GNode *node, gpointer user_data)
273 struct connman_element *element = node->data;
274 struct find_data *data = user_data;
275 enum connman_service_type type;
277 if (element->type != CONNMAN_ELEMENT_TYPE_DEVICE)
280 if (element->device == NULL)
283 type = __connman_device_get_service_type(element->device);
286 case CONNMAN_SERVICE_TYPE_UNKNOWN:
287 case CONNMAN_SERVICE_TYPE_SYSTEM:
288 case CONNMAN_SERVICE_TYPE_ETHERNET:
289 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
290 case CONNMAN_SERVICE_TYPE_CELLULAR:
291 case CONNMAN_SERVICE_TYPE_GPS:
292 case CONNMAN_SERVICE_TYPE_VPN:
294 case CONNMAN_SERVICE_TYPE_WIFI:
295 case CONNMAN_SERVICE_TYPE_WIMAX:
296 if (data->type != CONNMAN_SERVICE_TYPE_UNKNOWN &&
302 __connman_device_scan(element->device);
307 int __connman_element_request_scan(enum connman_service_type type)
309 struct find_data data = { .type = type, .device = NULL };
311 g_node_traverse(element_root, G_PRE_ORDER,
312 G_TRAVERSE_ALL, -1, request_scan, &data);
317 static gboolean enable_technology(GNode *node, gpointer user_data)
319 struct connman_element *element = node->data;
320 struct find_data *data = user_data;
321 enum connman_service_type type;
324 if (element->type != CONNMAN_ELEMENT_TYPE_DEVICE)
327 if (element->device == NULL)
330 type = __connman_device_get_service_type(element->device);
333 case CONNMAN_SERVICE_TYPE_UNKNOWN:
334 case CONNMAN_SERVICE_TYPE_SYSTEM:
335 case CONNMAN_SERVICE_TYPE_GPS:
336 case CONNMAN_SERVICE_TYPE_VPN:
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 &&
349 err = __connman_device_enable_persistent(element->device);
350 if (err == 0 || (err < 0 && err == -EINPROGRESS))
356 int __connman_element_enable_technology(enum connman_service_type type)
358 struct find_data data = { .type = type, .device = NULL, .error = TRUE };
360 g_node_traverse(element_root, G_PRE_ORDER,
361 G_TRAVERSE_ALL, -1, enable_technology, &data);
363 if (data.error == TRUE)
369 static gboolean disable_technology(GNode *node, gpointer user_data)
371 struct connman_element *element = node->data;
372 struct find_data *data = user_data;
373 enum connman_service_type type;
376 if (element->type != CONNMAN_ELEMENT_TYPE_DEVICE)
379 if (element->device == NULL)
382 type = __connman_device_get_service_type(element->device);
385 case CONNMAN_SERVICE_TYPE_UNKNOWN:
386 case CONNMAN_SERVICE_TYPE_SYSTEM:
387 case CONNMAN_SERVICE_TYPE_GPS:
388 case CONNMAN_SERVICE_TYPE_VPN:
390 case CONNMAN_SERVICE_TYPE_ETHERNET:
391 case CONNMAN_SERVICE_TYPE_WIFI:
392 case CONNMAN_SERVICE_TYPE_WIMAX:
393 case CONNMAN_SERVICE_TYPE_BLUETOOTH:
394 case CONNMAN_SERVICE_TYPE_CELLULAR:
395 if (data->type != CONNMAN_SERVICE_TYPE_UNKNOWN &&
401 err = __connman_device_disable_persistent(element->device);
402 if (err == 0 || (err < 0 && err == -EINPROGRESS))
408 int __connman_element_disable_technology(enum connman_service_type type)
410 struct find_data data = { .type = type, .device = NULL, .error = TRUE };
412 g_node_traverse(element_root, G_PRE_ORDER,
413 G_TRAVERSE_ALL, -1, disable_technology, &data);
415 if (data.error == TRUE)
421 static gint compare_priority(gconstpointer a, gconstpointer b)
423 const struct connman_driver *driver1 = a;
424 const struct connman_driver *driver2 = b;
426 return driver2->priority - driver1->priority;
429 static gboolean match_driver(struct connman_element *element,
430 struct connman_driver *driver)
432 if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
435 if (element->type == driver->type ||
436 driver->type == CONNMAN_ELEMENT_TYPE_UNKNOWN)
442 static gboolean probe_driver(GNode *node, gpointer data)
444 struct connman_element *element = node->data;
445 struct connman_driver *driver = data;
447 DBG("element %p name %s", element, element->name);
449 if (!element->driver && match_driver(element, driver) == TRUE) {
450 if (driver->probe(element) < 0)
453 element->driver = driver;
459 void __connman_driver_rescan(struct connman_driver *driver)
461 DBG("driver %p name %s", driver, driver->name);
466 if (element_root != NULL)
467 g_node_traverse(element_root, G_PRE_ORDER,
468 G_TRAVERSE_ALL, -1, probe_driver, driver);
472 * connman_driver_register:
473 * @driver: driver definition
475 * Register a new driver
477 * Returns: %0 on success
479 int connman_driver_register(struct connman_driver *driver)
481 DBG("driver %p name %s", driver, driver->name);
483 if (driver->type == CONNMAN_ELEMENT_TYPE_ROOT)
489 driver_list = g_slist_insert_sorted(driver_list, driver,
492 if (started == FALSE)
495 if (element_root != NULL)
496 g_node_traverse(element_root, G_PRE_ORDER,
497 G_TRAVERSE_ALL, -1, probe_driver, driver);
502 static gboolean remove_driver(GNode *node, gpointer data)
504 struct connman_element *element = node->data;
505 struct connman_driver *driver = data;
507 DBG("element %p name %s", element, element->name);
509 if (element->driver == driver) {
511 driver->remove(element);
513 element->driver = NULL;
520 * connman_driver_unregister:
521 * @driver: driver definition
523 * Remove a previously registered driver
525 void connman_driver_unregister(struct connman_driver *driver)
527 DBG("driver %p name %s", driver, driver->name);
529 driver_list = g_slist_remove(driver_list, driver);
531 if (element_root != NULL)
532 g_node_traverse(element_root, G_POST_ORDER,
533 G_TRAVERSE_ALL, -1, remove_driver, driver);
536 static void unregister_property(gpointer data)
538 struct connman_property *property = data;
540 DBG("property %p", property);
542 g_free(property->value);
546 static void unregister_child(gpointer data)
548 struct connman_element *element = data;
550 DBG("element %p", element);
552 connman_element_unref(element);
555 void __connman_element_initialize(struct connman_element *element)
557 DBG("element %p", element);
559 element->refcount = 1;
561 element->name = NULL;
562 element->type = CONNMAN_ELEMENT_TYPE_UNKNOWN;
563 element->state = CONNMAN_ELEMENT_STATE_UNKNOWN;
564 element->error = CONNMAN_ELEMENT_ERROR_UNKNOWN;
566 element->enabled = FALSE;
568 element->children = g_hash_table_new_full(g_str_hash, g_str_equal,
569 NULL, unregister_child);
571 element->properties = g_hash_table_new_full(g_str_hash, g_str_equal,
572 g_free, unregister_property);
576 * connman_element_create:
577 * @name: element name
579 * Allocate a new element and assign the given #name to it. If the name
580 * is #NULL, it will be later on created based on the element type.
582 * Returns: a newly-allocated #connman_element structure
584 struct connman_element *connman_element_create(const char *name)
586 struct connman_element *element;
588 element = g_try_new0(struct connman_element, 1);
592 DBG("element %p", element);
594 __connman_element_initialize(element);
599 struct connman_element *connman_element_ref(struct connman_element *element)
601 DBG("element %p name %s refcount %d", element, element->name,
602 g_atomic_int_get(&element->refcount) + 1);
604 g_atomic_int_inc(&element->refcount);
609 static void free_properties(struct connman_element *element)
611 DBG("element %p name %s", element, element->name);
613 g_hash_table_destroy(element->properties);
614 element->properties = NULL;
617 static void free_children(struct connman_element *element)
619 DBG("element %p name %s", element, element->name);
621 g_hash_table_destroy(element->children);
622 element->children = NULL;
625 void connman_element_unref(struct connman_element *element)
627 DBG("element %p name %s refcount %d", element, element->name,
628 g_atomic_int_get(&element->refcount) - 1);
630 if (g_atomic_int_dec_and_test(&element->refcount) == TRUE) {
631 if (element->destruct)
632 element->destruct(element);
633 free_children(element);
634 free_properties(element);
635 g_free(element->hostname);
636 g_free(element->domainname);
637 g_free(element->ipv4.address);
638 g_free(element->ipv4.netmask);
639 g_free(element->ipv4.gateway);
640 g_free(element->ipv4.network);
641 g_free(element->ipv4.broadcast);
642 g_free(element->ipv4.nameserver);
643 g_free(element->ipv4.timeserver);
644 g_free(element->ipv4.pac);
645 g_free(element->ipv6.address);
646 g_free(element->ipv6.network);
647 g_free(element->devname);
648 g_free(element->path);
649 g_free(element->name);
654 static int set_static_property(struct connman_element *element,
655 const char *name, int type, const void *value)
657 struct connman_property *property;
659 DBG("element %p name %s", element, element->name);
661 if (type != DBUS_TYPE_STRING && type != DBUS_TYPE_BYTE)
664 property = g_try_new0(struct connman_property, 1);
665 if (property == NULL)
668 property->id = CONNMAN_PROPERTY_ID_INVALID;
669 property->type = type;
671 DBG("name %s type %d value %p", name, type, value);
674 case DBUS_TYPE_STRING:
675 property->value = g_strdup(*((const char **) value));
677 case DBUS_TYPE_BOOLEAN:
679 property->value = g_try_malloc(1);
680 if (property->value != NULL)
681 memcpy(property->value, value, 1);
685 g_hash_table_replace(element->properties, g_strdup(name), property);
690 static int set_static_array_property(struct connman_element *element,
691 const char *name, int type, const void *value, int len)
693 struct connman_property *property;
695 DBG("element %p name %s", element, element->name);
697 if (type != DBUS_TYPE_BYTE)
700 property = g_try_new0(struct connman_property, 1);
701 if (property == NULL)
704 property->id = CONNMAN_PROPERTY_ID_INVALID;
705 property->type = DBUS_TYPE_ARRAY;
706 property->subtype = type;
708 DBG("name %s type %d value %p", name, type, value);
712 property->value = g_try_malloc(len);
713 if (property->value != NULL) {
714 memcpy(property->value,
715 *((const unsigned char **) value), len);
716 property->size = len;
721 g_hash_table_replace(element->properties, g_strdup(name), property);
726 int connman_element_get_value(struct connman_element *element,
727 enum connman_property_id id, void *value)
729 if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
733 case CONNMAN_PROPERTY_ID_HOSTNAME:
734 if (element->hostname == NULL)
735 return connman_element_get_value(element->parent,
737 *((char **) value) = element->hostname;
739 case CONNMAN_PROPERTY_ID_DOMAINNAME:
740 if (element->domainname == NULL)
741 return connman_element_get_value(element->parent,
743 *((char **) value) = element->domainname;
745 case CONNMAN_PROPERTY_ID_IPV4_METHOD:
746 if (element->ipv4.method == CONNMAN_IPCONFIG_METHOD_UNKNOWN)
747 return connman_element_get_value(element->parent,
749 *((const char **) value) = __connman_ipconfig_method2string(element->ipv4.method);
751 case CONNMAN_PROPERTY_ID_IPV4_ADDRESS:
752 if (element->ipv4.address == NULL)
753 return connman_element_get_value(element->parent,
755 *((char **) value) = element->ipv4.address;
757 case CONNMAN_PROPERTY_ID_IPV4_PEER:
758 if (element->ipv4.peer == NULL)
759 return connman_element_get_value(element->parent,
761 *((char **) value) = element->ipv4.peer;
763 case CONNMAN_PROPERTY_ID_IPV4_NETMASK:
764 if (element->ipv4.netmask == NULL)
765 return connman_element_get_value(element->parent,
767 *((char **) value) = element->ipv4.netmask;
769 case CONNMAN_PROPERTY_ID_IPV4_GATEWAY:
770 if (element->ipv4.gateway == NULL)
771 return connman_element_get_value(element->parent,
773 *((char **) value) = element->ipv4.gateway;
775 case CONNMAN_PROPERTY_ID_IPV4_BROADCAST:
776 if (element->ipv4.broadcast == NULL)
777 return connman_element_get_value(element->parent,
779 *((char **) value) = element->ipv4.broadcast;
781 case CONNMAN_PROPERTY_ID_IPV4_NAMESERVER:
782 if (element->ipv4.nameserver == NULL)
783 return connman_element_get_value(element->parent,
785 *((char **) value) = element->ipv4.nameserver;
787 case CONNMAN_PROPERTY_ID_IPV4_TIMESERVER:
788 if (element->ipv4.timeserver == NULL)
789 return connman_element_get_value(element->parent,
791 *((char **) value) = element->ipv4.timeserver;
793 case CONNMAN_PROPERTY_ID_IPV4_PAC:
794 if (element->ipv4.pac == NULL)
795 return connman_element_get_value(element->parent,
797 *((char **) value) = element->ipv4.pac;
799 case CONNMAN_PROPERTY_ID_IPV6_GATEWAY:
800 if (element->ipv6.gateway == NULL)
801 return connman_element_get_value(element->parent,
803 *((char **) value) = element->ipv6.gateway;
813 static gboolean get_static_property(struct connman_element *element,
814 const char *name, void *value)
816 struct connman_property *property;
817 gboolean found = FALSE;
819 DBG("element %p name %s", element, element->name);
821 property = g_hash_table_lookup(element->properties, name);
822 if (property != NULL) {
823 switch (property->type) {
824 case DBUS_TYPE_STRING:
825 *((char **) value) = property->value;
828 case DBUS_TYPE_BOOLEAN:
830 memcpy(value, property->value, 1);
836 if (found == FALSE && element->parent != NULL)
837 return get_static_property(element->parent, name, value);
842 static gboolean get_static_array_property(struct connman_element *element,
843 const char *name, void *value, unsigned int *len)
845 struct connman_property *property;
846 gboolean found = FALSE;
848 DBG("element %p name %s", element, element->name);
850 property = g_hash_table_lookup(element->properties, name);
851 if (property != NULL) {
852 *((void **) value) = property->value;
853 *len = property->size;
861 * connman_element_set_string:
862 * @element: element structure
863 * @key: unique identifier
864 * @value: string value
866 * Set string value for specific key
868 int connman_element_set_string(struct connman_element *element,
869 const char *key, const char *value)
871 return set_static_property(element, key, DBUS_TYPE_STRING, &value);
875 * connman_element_get_string:
876 * @element: element structure
877 * @key: unique identifier
879 * Get string value for specific key
881 const char *connman_element_get_string(struct connman_element *element,
886 if (get_static_property(element, key, &value) == FALSE)
893 * connman_element_set_bool:
894 * @element: element structure
895 * @key: unique identifier
896 * @value: boolean value
898 * Set boolean value for specific key
900 int connman_element_set_bool(struct connman_element *element,
901 const char *key, connman_bool_t value)
903 return set_static_property(element, key, DBUS_TYPE_BOOLEAN, &value);
907 * connman_element_get_bool:
908 * @element: element structure
909 * @key: unique identifier
911 * Get boolean value for specific key
913 connman_bool_t connman_element_get_bool(struct connman_element *element,
916 connman_bool_t value;
918 if (get_static_property(element, key, &value) == FALSE)
925 * connman_element_set_uint8:
926 * @element: element structure
927 * @key: unique identifier
928 * @value: integer value
930 * Set integer value for specific key
932 int connman_element_set_uint8(struct connman_element *element,
933 const char *key, connman_uint8_t value)
935 return set_static_property(element, key, DBUS_TYPE_BYTE, &value);
939 * connman_element_get_uint8:
940 * @element: element structure
941 * @key: unique identifier
943 * Get integer value for specific key
945 connman_uint8_t connman_element_get_uint8(struct connman_element *element,
948 connman_uint8_t value;
950 if (get_static_property(element, key, &value) == FALSE)
957 * connman_element_set_blob:
958 * @element: element structure
959 * @key: unique identifier
963 * Set binary blob value for specific key
965 int connman_element_set_blob(struct connman_element *element,
966 const char *key, const void *data, unsigned int size)
968 return set_static_array_property(element, key,
969 DBUS_TYPE_BYTE, &data, size);
973 * connman_element_get_blob:
974 * @element: element structure
975 * @key: unique identifier
976 * @size: pointer to blob size
978 * Get binary blob value for specific key
980 const void *connman_element_get_blob(struct connman_element *element,
981 const char *key, unsigned int *size)
985 if (get_static_array_property(element, key, &value, size) == FALSE)
991 static void probe_element(struct connman_element *element)
995 DBG("element %p name %s", element, element->name);
997 for (list = driver_list; list; list = list->next) {
998 struct connman_driver *driver = list->data;
1000 if (match_driver(element, driver) == FALSE)
1003 DBG("driver %p name %s", driver, driver->name);
1005 if (driver->probe(element) == 0) {
1006 element->driver = driver;
1012 static void register_element(gpointer data, gpointer user_data)
1014 struct connman_element *element = data;
1015 const gchar *basepath;
1018 if (element->parent) {
1019 node = g_node_find(element_root, G_PRE_ORDER,
1020 G_TRAVERSE_ALL, element->parent);
1021 basepath = element->parent->path;
1023 element->parent = element_root->data;
1025 node = element_root;
1026 basepath = CONNMAN_PATH "/device";
1029 element->path = g_strdup_printf("%s/%s", basepath, element->name);
1032 connman_error("Element registration for %s failed",
1037 DBG("element %p path %s", element, element->path);
1039 g_node_append_data(node, element);
1041 if (started == FALSE)
1044 probe_element(element);
1047 gboolean __connman_element_device_isfiltered(const char *devname)
1051 if (device_filter == NULL)
1054 for (pattern = device_filter; *pattern; pattern++) {
1055 if (g_pattern_match_simple(*pattern, devname) == FALSE) {
1056 DBG("ignoring device %s (match)", devname);
1062 if (nodevice_filter == NULL)
1065 for (pattern = nodevice_filter; *pattern; pattern++) {
1066 if (g_pattern_match_simple(*pattern, devname) == TRUE) {
1067 DBG("ignoring device %s (no match)", devname);
1076 * connman_element_register:
1077 * @element: the element to register
1078 * @parent: the parent to register the element with
1080 * Register an element with the core. It will be register under the given
1081 * parent of if %NULL is provided under the root element.
1083 * Returns: %0 on success
1085 int connman_element_register(struct connman_element *element,
1086 struct connman_element *parent)
1088 DBG("element %p name %s parent %p", element, element->name, parent);
1090 if (element->devname == NULL)
1091 element->devname = g_strdup(element->name);
1093 if (element->type != CONNMAN_ELEMENT_TYPE_DEVICE)
1096 if (__connman_element_device_isfiltered(element->devname) == TRUE)
1100 if (connman_element_ref(element) == NULL)
1103 if (element->name == NULL) {
1104 element->name = g_strdup(type2string(element->type));
1105 if (element->name == NULL) {
1110 if (element->type == CONNMAN_ELEMENT_TYPE_DHCP)
1111 element->ipv4.method = CONNMAN_IPCONFIG_METHOD_DHCP;
1113 element->parent = parent;
1115 register_element(element, NULL);
1120 static gboolean remove_element(GNode *node, gpointer user_data)
1122 struct connman_element *element = node->data;
1123 struct connman_element *root = user_data;
1125 DBG("element %p name %s", element, element->name);
1127 if (element == root)
1130 g_node_unlink(node);
1132 if (element->driver) {
1133 if (element->driver->remove)
1134 element->driver->remove(element);
1136 element->driver = NULL;
1139 g_node_destroy(node);
1141 connman_element_unref(element);
1146 struct unregister_type {
1147 struct connman_element *root;
1148 enum connman_element_type type;
1151 static gboolean remove_element_type(GNode *node, gpointer user_data)
1153 struct unregister_type *children_type = user_data;
1154 struct connman_element *root = children_type->root;
1155 struct connman_element *element = node->data;
1156 enum connman_element_type type = children_type->type;
1158 DBG("element %p name %s", element, element->name);
1160 if (element == root)
1163 if(element->type != type)
1166 g_node_unlink(node);
1168 if (element->driver) {
1169 if (element->driver->remove)
1170 element->driver->remove(element);
1172 element->driver = NULL;
1175 g_node_destroy(node);
1177 connman_element_unref(element);
1183 void connman_element_unregister(struct connman_element *element)
1187 DBG("element %p name %s", element, element->name);
1189 node = g_node_find(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, element);
1192 g_node_traverse(node, G_POST_ORDER,
1193 G_TRAVERSE_ALL, -1, remove_element, NULL);
1196 void connman_element_unregister_children(struct connman_element *element)
1200 DBG("element %p name %s", element, element->name);
1202 node = g_node_find(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, element);
1205 g_node_traverse(node, G_POST_ORDER,
1206 G_TRAVERSE_ALL, -1, remove_element, element);
1209 void connman_element_unregister_children_type(struct connman_element *element, enum connman_element_type type)
1213 DBG("element %p name %s", element, element->name);
1215 node = g_node_find(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, element);
1218 struct unregister_type children_type;
1220 children_type.root = element;
1221 children_type.type = type;
1222 g_node_traverse(node, G_POST_ORDER,
1223 G_TRAVERSE_ALL, -1, remove_element_type, &children_type);
1228 static gboolean update_element(GNode *node, gpointer user_data)
1230 struct connman_element *element = node->data;
1232 DBG("element %p name %s", element, element->name);
1234 if (element->driver && element->driver->update)
1235 element->driver->update(element);
1240 void connman_element_update(struct connman_element *element)
1244 DBG("element %p name %s", element, element->name);
1246 node = g_node_find(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, element);
1249 g_node_traverse(node, G_PRE_ORDER,
1250 G_TRAVERSE_ALL, -1, update_element, element);
1253 int connman_element_set_enabled(struct connman_element *element,
1256 if (element->enabled == enabled)
1259 element->enabled = enabled;
1261 connman_element_update(element);
1266 static enum connman_service_error convert_error(enum connman_element_error error)
1269 case CONNMAN_ELEMENT_ERROR_UNKNOWN:
1270 case CONNMAN_ELEMENT_ERROR_FAILED:
1272 case CONNMAN_ELEMENT_ERROR_DHCP_FAILED:
1273 return CONNMAN_SERVICE_ERROR_DHCP_FAILED;
1274 case CONNMAN_ELEMENT_ERROR_CONNECT_FAILED:
1275 return CONNMAN_SERVICE_ERROR_CONNECT_FAILED;
1278 return CONNMAN_SERVICE_ERROR_UNKNOWN;
1282 * connman_element_set_error:
1283 * @element: element structure
1284 * @error: error identifier
1286 * Set error state and specific error identifier
1288 void connman_element_set_error(struct connman_element *element,
1289 enum connman_element_error error)
1291 struct connman_service *service;
1293 DBG("element %p error %d", element, error);
1295 if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
1298 element->state = CONNMAN_ELEMENT_STATE_ERROR;
1299 element->error = error;
1301 if (element->driver && element->driver->change)
1302 element->driver->change(element);
1304 service = __connman_element_get_service(element);
1305 __connman_service_indicate_error(service, convert_error(error));
1308 void __connman_element_set_driver(struct connman_element *element)
1312 DBG("element %p name %s driver %p", element, element->name,
1315 if (element->driver)
1318 for (list = driver_list; list; list = list->next) {
1319 struct connman_driver *driver = list->data;
1321 if (match_driver(element, driver) == FALSE)
1324 element->driver = driver;
1330 int __connman_element_init(const char *device, const char *nodevice)
1332 struct connman_element *element;
1336 connection = connman_dbus_get_connection();
1337 if (connection == NULL)
1341 device_filter = g_strsplit(device, ",", -1);
1344 nodevice_filter = g_strsplit(nodevice, ",", -1);
1346 element = connman_element_create("root");
1348 element->path = g_strdup("/");
1349 element->type = CONNMAN_ELEMENT_TYPE_ROOT;
1351 element_root = g_node_new(element);
1353 __connman_technology_init();
1354 __connman_notifier_init();
1355 __connman_location_init();
1356 __connman_service_init();
1357 __connman_provider_init();
1358 __connman_network_init();
1359 __connman_device_init();
1364 static gboolean probe_node(GNode *node, gpointer data)
1366 struct connman_element *element = node->data;
1368 DBG("element %p name %s", element, element->name);
1370 if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
1373 if (element->driver)
1376 probe_element(element);
1381 void __connman_element_start(void)
1385 __connman_storage_init_profile();
1387 g_node_traverse(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
1392 __connman_rtnl_start();
1394 __connman_connection_init();
1395 __connman_ipv4_init();
1396 __connman_dhcp_init();
1397 __connman_wpad_init();
1399 __connman_rfkill_init();
1402 void __connman_element_stop(void)
1406 __connman_rfkill_cleanup();
1408 __connman_wpad_cleanup();
1409 __connman_dhcp_cleanup();
1410 __connman_ipv4_cleanup();
1411 __connman_provider_cleanup();
1412 __connman_connection_cleanup();
1415 static gboolean free_driver(GNode *node, gpointer data)
1417 struct connman_element *element = node->data;
1419 DBG("element %p name %s", element, element->name);
1421 if (element->driver) {
1422 if (element->driver->remove)
1423 element->driver->remove(element);
1425 element->driver = NULL;
1431 static gboolean free_node(GNode *node, gpointer data)
1433 struct connman_element *element = node->data;
1435 DBG("element %p name %s", element, element->name);
1437 if (g_node_depth(node) > 1)
1438 connman_element_unregister(element);
1443 void __connman_element_cleanup(void)
1447 __connman_device_cleanup();
1448 __connman_network_cleanup();
1449 __connman_service_cleanup();
1450 __connman_location_cleanup();
1451 __connman_notifier_cleanup();
1452 __connman_technology_cleanup();
1454 g_node_traverse(element_root, G_POST_ORDER, G_TRAVERSE_ALL, -1,
1457 g_node_traverse(element_root, G_POST_ORDER, G_TRAVERSE_ALL, -1,
1460 g_node_destroy(element_root);
1461 element_root = NULL;
1463 g_strfreev(nodevice_filter);
1464 g_strfreev(device_filter);
1466 if (connection == NULL)
1469 dbus_connection_unref(connection);