static DBusConnection *connection;
-static GStaticRWLock driver_lock = G_STATIC_RW_LOCK_INIT;
-static GSList *driver_list = NULL;
-static GThreadPool *driver_thread;
-
static GStaticRWLock element_lock = G_STATIC_RW_LOCK_INIT;
static GNode *element_root = NULL;
-static GThreadPool *element_thread;
+
+static GSList *driver_list = NULL;
+
+static GThreadPool *thread_register = NULL;
+static GThreadPool *thread_unregister = NULL;
+static GThreadPool *thread_unregister_children = NULL;
+
+static gchar *device_filter = NULL;
static const char *type2string(enum connman_element_type type)
{
return "bootp";
case CONNMAN_ELEMENT_TYPE_ZEROCONF:
return "zeroconf";
- case CONNMAN_ELEMENT_TYPE_CONNECTION:
- return "42";
+ case CONNMAN_ELEMENT_TYPE_RESOLVER:
+ return "resolver";
+ case CONNMAN_ELEMENT_TYPE_INTERNET:
+ return "internet";
}
return NULL;
dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key);
switch (type) {
+ case DBUS_TYPE_BOOLEAN:
+ signature = DBUS_TYPE_BOOLEAN_AS_STRING;
+ break;
case DBUS_TYPE_STRING:
signature = DBUS_TYPE_STRING_AS_STRING;
break;
if (str != NULL)
append_entry(&dict, "Subtype", DBUS_TYPE_STRING, &str);
+ append_entry(&dict, "Enabled", DBUS_TYPE_BOOLEAN, &element->enabled);
+
if (element->priority > 0)
append_entry(&dict, "Priority",
DBUS_TYPE_UINT16, &element->priority);
+ if (element->network.identifier != NULL)
+ append_entry(&dict, "Identifier",
+ DBUS_TYPE_STRING, &element->network.identifier);
+
if (element->ipv4.address != NULL)
append_entry(&dict, "IPv4.Address",
DBUS_TYPE_STRING, &element->ipv4.address);
return reply;
}
+static DBusMessage *set_property(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *do_update(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct connman_element *element = data;
+
+ DBG("conn %p", conn);
+
+ if (element->driver == NULL)
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ if (element->driver->update) {
+ DBG("Calling update callback");
+ element->driver->update(element);
+ }
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *do_enable(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct connman_element *element = data;
+
+ DBG("conn %p", conn);
+
+ if (element->driver == NULL)
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ if (element->driver->enable) {
+ DBG("Calling enable callback");
+ element->driver->enable(element);
+ }
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
+static DBusMessage *do_disable(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct connman_element *element = data;
+
+ DBG("conn %p", conn);
+
+ if (element->driver == NULL)
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ if (element->driver->disable) {
+ DBG("Calling disable callback");
+ element->driver->disable(element);
+ }
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+
static GDBusMethodTable element_methods[] = {
- { "GetProperties", "", "a{sv}", get_properties },
+ { "GetProperties", "", "a{sv}", get_properties },
+ { "SetProperty", "sv", "", set_property },
+ { "Update", "", "", do_update },
+ { "Enable", "", "", do_enable },
+ { "Disable", "", "", do_disable },
+ { },
+};
+
+static GDBusSignalTable element_signals[] = {
+ { "PropertyChanged", "sv" },
{ },
};
return driver2->priority - driver1->priority;
}
+static gboolean match_driver(struct connman_element *element,
+ struct connman_driver *driver)
+{
+ if (element->type == CONNMAN_ELEMENT_TYPE_ROOT)
+ return FALSE;
+
+ if (element->type != driver->type &&
+ driver->type != CONNMAN_ELEMENT_TYPE_UNKNOWN)
+ return FALSE;
+
+ if (element->subtype == driver->subtype ||
+ driver->subtype == CONNMAN_ELEMENT_SUBTYPE_UNKNOWN)
+ return TRUE;
+
+ return FALSE;
+}
+
+static gboolean probe_driver(GNode *node, gpointer data)
+{
+ struct connman_element *element = node->data;
+ struct connman_driver *driver = data;
+
+ DBG("element %p name %s", element, element->name);
+
+ if (!element->driver && match_driver(element, driver) == TRUE) {
+ if (driver->probe(element) < 0)
+ return FALSE;
+
+ connman_element_lock(element);
+ element->driver = driver;
+ connman_element_unlock(element);
+ }
+
+ return FALSE;
+}
+
+/**
+ * connman_driver_register:
+ * @driver: driver definition
+ *
+ * Register a new driver
+ *
+ * Returns: %0 on success
+ */
int connman_driver_register(struct connman_driver *driver)
{
DBG("driver %p name %s", driver, driver->name);
if (driver->type == CONNMAN_ELEMENT_TYPE_ROOT)
- return -1;
+ return -EINVAL;
if (!driver->probe)
return -EINVAL;
- g_static_rw_lock_writer_lock(&driver_lock);
+ g_static_rw_lock_writer_lock(&element_lock);
+
driver_list = g_slist_insert_sorted(driver_list, driver,
compare_priority);
- g_static_rw_lock_writer_unlock(&driver_lock);
- g_thread_pool_push(driver_thread, driver, NULL);
+ if (element_root != NULL)
+ g_node_traverse(element_root, G_PRE_ORDER,
+ G_TRAVERSE_ALL, -1, probe_driver, driver);
+
+ g_static_rw_lock_writer_unlock(&element_lock);
return 0;
}
if (element->driver == driver) {
if (driver->remove)
driver->remove(element);
+
+ connman_element_lock(element);
element->driver = NULL;
+ connman_element_unlock(element);
}
return FALSE;
}
+/**
+ * connman_driver_unregister:
+ * @driver: driver definition
+ *
+ * Remove a previously registered driver
+ */
void connman_driver_unregister(struct connman_driver *driver)
{
DBG("driver %p name %s", driver, driver->name);
- g_static_rw_lock_reader_lock(&element_lock);
- g_node_traverse(element_root, G_POST_ORDER, G_TRAVERSE_ALL, -1,
- remove_driver, driver);
- g_static_rw_lock_reader_unlock(&element_lock);
+ g_static_rw_lock_writer_lock(&element_lock);
- g_static_rw_lock_writer_lock(&driver_lock);
driver_list = g_slist_remove(driver_list, driver);
- g_static_rw_lock_writer_unlock(&driver_lock);
+
+ if (element_root != NULL)
+ g_node_traverse(element_root, G_POST_ORDER,
+ G_TRAVERSE_ALL, -1, remove_driver, driver);
+
+ g_static_rw_lock_writer_unlock(&element_lock);
}
struct connman_element *connman_element_create(void)
element->refcount = 1;
+ g_static_mutex_init(&element->mutex);
+
element->type = CONNMAN_ELEMENT_TYPE_UNKNOWN;
element->subtype = CONNMAN_ELEMENT_SUBTYPE_UNKNOWN;
element->state = CONNMAN_ELEMENT_STATE_CLOSED;
+ element->enabled = FALSE;
+
element->netdev.index = -1;
return element;
g_free(element->ipv4.network);
g_free(element->ipv4.broadcast);
g_free(element->ipv4.nameserver);
+ g_free(element->network.identifier);
g_free(element->netdev.name);
g_free(element->path);
g_free(element->name);
break;
}
+ connman_element_lock(element);
element->properties = g_slist_append(element->properties, property);
+ connman_element_unlock(element);
return 0;
}
case CONNMAN_PROPERTY_TYPE_INVALID:
return -EINVAL;
case CONNMAN_PROPERTY_TYPE_IPV4_ADDRESS:
+ connman_element_lock(element);
g_free(element->ipv4.address);
element->ipv4.address = g_strdup(*((const char **) value));
+ connman_element_unlock(element);
break;
case CONNMAN_PROPERTY_TYPE_IPV4_NETMASK:
+ connman_element_lock(element);
g_free(element->ipv4.netmask);
element->ipv4.netmask = g_strdup(*((const char **) value));
+ connman_element_unlock(element);
break;
case CONNMAN_PROPERTY_TYPE_IPV4_GATEWAY:
+ connman_element_lock(element);
g_free(element->ipv4.gateway);
element->ipv4.gateway = g_strdup(*((const char **) value));
+ connman_element_unlock(element);
+ break;
+ case CONNMAN_PROPERTY_TYPE_IPV4_NAMESERVER:
+ connman_element_lock(element);
+ g_free(element->ipv4.nameserver);
+ element->ipv4.nameserver = g_strdup(*((const char **) value));
+ connman_element_unlock(element);
break;
}
if (element->ipv4.address == NULL)
return connman_element_get_value(element->parent,
type, value);
+ connman_element_lock(element);
*((char **) value) = element->ipv4.address;
+ connman_element_unlock(element);
break;
case CONNMAN_PROPERTY_TYPE_IPV4_NETMASK:
if (element->ipv4.netmask == NULL)
return connman_element_get_value(element->parent,
type, value);
+ connman_element_lock(element);
*((char **) value) = element->ipv4.netmask;
+ connman_element_unlock(element);
break;
case CONNMAN_PROPERTY_TYPE_IPV4_GATEWAY:
if (element->ipv4.gateway == NULL)
return connman_element_get_value(element->parent,
type, value);
+ connman_element_lock(element);
*((char **) value) = element->ipv4.gateway;
+ connman_element_unlock(element);
+ break;
+ case CONNMAN_PROPERTY_TYPE_IPV4_NAMESERVER:
+ if (element->ipv4.nameserver == NULL)
+ return connman_element_get_value(element->parent,
+ type, value);
+ connman_element_lock(element);
+ *((char **) value) = element->ipv4.nameserver;
+ connman_element_unlock(element);
break;
}
int connman_element_register(struct connman_element *element,
struct connman_element *parent)
{
- GNode *node;
- const gchar *basepath;
-
DBG("element %p name %s parent %p", element, element->name, parent);
- if (connman_element_ref(element) == NULL)
- return -1;
-
- __connman_element_load(element);
+ if (device_filter && element->type == CONNMAN_ELEMENT_TYPE_DEVICE) {
+ if (g_str_equal(device_filter, element->netdev.name) == FALSE)
+ return -EINVAL;
+ }
- g_static_rw_lock_writer_lock(&element_lock);
+ if (connman_element_ref(element) == NULL)
+ return -EINVAL;
- if (parent) {
- node = g_node_find(element_root, G_PRE_ORDER,
- G_TRAVERSE_ALL, parent);
- basepath = parent->path;
+ connman_element_lock(element);
- if (element->subtype == CONNMAN_ELEMENT_SUBTYPE_UNKNOWN)
- element->subtype = parent->subtype;
- } else {
- node = element_root;
- basepath = "";
- }
+ __connman_element_load(element);
if (element->name == NULL) {
- switch (element->type) {
- case CONNMAN_ELEMENT_TYPE_IPV4:
- element->name = g_strdup("ipv4");
- break;
- case CONNMAN_ELEMENT_TYPE_IPV6:
- element->name = g_strdup("ipv6");
- break;
- case CONNMAN_ELEMENT_TYPE_DHCP:
- element->name = g_strdup("dhcp");
- break;
- case CONNMAN_ELEMENT_TYPE_BOOTP:
- element->name = g_strdup("bootp");
- break;
- case CONNMAN_ELEMENT_TYPE_ZEROCONF:
- element->name = g_strdup("zeroconf");
- break;
- default:
- break;
- }
+ element->name = g_strdup(type2string(element->type));
+ if (element->name == NULL)
+ return -EINVAL;
}
- element->path = g_strdup_printf("%s/%s", basepath, element->name);
element->parent = parent;
- DBG("element %p path %s", element, element->path);
-
- g_node_append_data(node, element);
-
- g_static_rw_lock_writer_unlock(&element_lock);
+ connman_element_unlock(element);
- __connman_element_store(element);
+ if (thread_register != NULL)
+ g_thread_pool_push(thread_register, element, NULL);
- g_dbus_register_interface(connection, element->path,
- CONNMAN_ELEMENT_INTERFACE,
- element_methods, NULL, NULL,
- element, NULL);
+ return 0;
+}
- g_dbus_emit_signal(connection, CONNMAN_MANAGER_PATH,
- CONNMAN_MANAGER_INTERFACE, "ElementAdded",
- DBUS_TYPE_OBJECT_PATH, &element->path,
- DBUS_TYPE_INVALID);
+void connman_element_unregister(struct connman_element *element)
+{
+ DBG("element %p name %s", element, element->name);
- if (element->type == CONNMAN_ELEMENT_TYPE_DEVICE)
- g_dbus_emit_signal(connection, CONNMAN_MANAGER_PATH,
- CONNMAN_MANAGER_INTERFACE, "DeviceAdded",
- DBUS_TYPE_OBJECT_PATH, &element->path,
- DBUS_TYPE_INVALID);
+ if (thread_unregister != NULL)
+ g_thread_pool_push(thread_unregister, element, NULL);
+}
- g_thread_pool_push(element_thread, element, NULL);
+void connman_element_unregister_children(struct connman_element *element)
+{
+ DBG("element %p name %s", element, element->name);
- return 0;
+ if (thread_unregister_children != NULL)
+ g_thread_pool_push(thread_unregister_children, element, NULL);
}
-void connman_element_unregister(struct connman_element *element)
+static gboolean update_element(GNode *node, gpointer user_data)
{
- GNode *node;
+ struct connman_element *element = node->data;
DBG("element %p name %s", element, element->name);
- if (element->type == CONNMAN_ELEMENT_TYPE_DEVICE)
- g_dbus_emit_signal(connection, CONNMAN_MANAGER_PATH,
- CONNMAN_MANAGER_INTERFACE, "DeviceRemoved",
- DBUS_TYPE_OBJECT_PATH, &element->path,
- DBUS_TYPE_INVALID);
+ if (element->driver && element->driver->update)
+ element->driver->update(element);
g_dbus_emit_signal(connection, CONNMAN_MANAGER_PATH,
- CONNMAN_MANAGER_INTERFACE, "ElementRemoved",
+ CONNMAN_MANAGER_INTERFACE, "ElementUpdated",
DBUS_TYPE_OBJECT_PATH, &element->path,
DBUS_TYPE_INVALID);
- g_dbus_unregister_interface(connection, element->path,
- CONNMAN_ELEMENT_INTERFACE);
+ return FALSE;
+}
- g_static_rw_lock_writer_lock(&element_lock);
+void connman_element_update(struct connman_element *element)
+{
+ GNode *node;
- if (element->driver) {
- if (element->driver->remove)
- element->driver->remove(element);
- element->driver = NULL;
- }
+ DBG("element %p name %s", element, element->name);
+
+ g_static_rw_lock_reader_lock(&element_lock);
node = g_node_find(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, element);
- if (node != NULL) {
- g_node_unlink(node);
- g_node_destroy(node);
- }
- g_static_rw_lock_writer_unlock(&element_lock);
+ if (node != NULL)
+ g_node_traverse(node, G_PRE_ORDER,
+ G_TRAVERSE_ALL, -1, update_element, NULL);
- connman_element_unref(element);
+ g_static_rw_lock_reader_unlock(&element_lock);
}
-void connman_element_update(struct connman_element *element)
+static void register_element(gpointer data, gpointer user_data)
{
- DBG("element %p name %s", element, element->name);
+ struct connman_element *element = data;
+ const gchar *basepath;
+ GSList *list;
+ GNode *node;
- g_static_rw_lock_reader_lock(&element_lock);
+ g_static_rw_lock_writer_lock(&element_lock);
- if (element->driver && element->driver->update)
- element->driver->update(element);
+ connman_element_lock(element);
- g_static_rw_lock_reader_unlock(&element_lock);
+ if (element->parent) {
+ node = g_node_find(element_root, G_PRE_ORDER,
+ G_TRAVERSE_ALL, element->parent);
+ basepath = element->parent->path;
+
+ if (element->subtype == CONNMAN_ELEMENT_SUBTYPE_UNKNOWN)
+ element->subtype = element->parent->subtype;
+ } else {
+ node = element_root;
+ basepath = "";
+ }
+
+ element->path = g_strdup_printf("%s/%s", basepath, element->name);
+
+ connman_element_unlock(element);
+
+ DBG("element %p path %s", element, element->path);
+
+ g_node_append_data(node, element);
+
+ if (g_dbus_register_interface(connection, element->path,
+ CONNMAN_ELEMENT_INTERFACE,
+ element_methods, element_signals,
+ NULL, element, NULL) == FALSE)
+ connman_error("Failed to register %s", element->path);
g_dbus_emit_signal(connection, CONNMAN_MANAGER_PATH,
- CONNMAN_MANAGER_INTERFACE, "ElementUpdated",
+ CONNMAN_MANAGER_INTERFACE, "ElementAdded",
DBUS_TYPE_OBJECT_PATH, &element->path,
DBUS_TYPE_INVALID);
-}
-static inline void set_driver(struct connman_element *element,
- struct connman_driver *driver)
-{
- g_static_rw_lock_reader_lock(&element_lock);
- element->driver = driver;
- g_static_rw_lock_reader_unlock(&element_lock);
-}
+ g_static_rw_lock_writer_unlock(&element_lock);
-static gboolean match_driver(struct connman_element *element,
- struct connman_driver *driver)
-{
- if (element->type != driver->type &&
- driver->type != CONNMAN_ELEMENT_TYPE_UNKNOWN)
- return FALSE;
+ __connman_element_store(element);
- if (element->subtype == driver->subtype ||
- driver->subtype == CONNMAN_ELEMENT_SUBTYPE_UNKNOWN)
- return TRUE;
+ g_static_rw_lock_writer_lock(&element_lock);
- return FALSE;
+ for (list = driver_list; list; list = list->next) {
+ struct connman_driver *driver = list->data;
+
+ if (match_driver(element, driver) == FALSE)
+ continue;
+
+ DBG("driver %p name %s", driver, driver->name);
+
+ if (driver->probe(element) == 0) {
+ connman_element_lock(element);
+ element->driver = driver;
+ connman_element_unlock(element);
+ break;
+ }
+ }
+
+ g_static_rw_lock_writer_unlock(&element_lock);
}
-static gboolean probe_driver(GNode *node, gpointer data)
+static gboolean remove_element(GNode *node, gpointer user_data)
{
struct connman_element *element = node->data;
- struct connman_driver *driver = data;
+ struct connman_element *root = user_data;
DBG("element %p name %s", element, element->name);
- if (!element->driver && match_driver(element, driver) == TRUE) {
- element->driver = driver;
+ if (element == root)
+ return FALSE;
- if (driver->probe(element) < 0)
- element->driver = NULL;
+ if (element->driver) {
+ if (element->driver->remove)
+ element->driver->remove(element);
+
+ connman_element_lock(element);
+ element->driver = NULL;
+ connman_element_unlock(element);
}
- return FALSE;
-}
+ if (node != NULL) {
+ g_node_unlink(node);
+ g_node_destroy(node);
+ }
-static void driver_probe(gpointer data, gpointer user_data)
-{
- struct connman_driver *driver = data;
+ g_dbus_emit_signal(connection, CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE, "ElementRemoved",
+ DBUS_TYPE_OBJECT_PATH, &element->path,
+ DBUS_TYPE_INVALID);
- DBG("driver %p name %s", driver, driver->name);
+ g_dbus_unregister_interface(connection, element->path,
+ CONNMAN_ELEMENT_INTERFACE);
- g_static_rw_lock_reader_lock(&element_lock);
- g_node_traverse(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, -1,
- probe_driver, driver);
- g_static_rw_lock_reader_unlock(&element_lock);
+ connman_element_unref(element);
+
+ return FALSE;
}
-static void element_probe(gpointer data, gpointer user_data)
+static void unregister_element(gpointer data, gpointer user_data)
{
struct connman_element *element = data;
- GSList *list;
+ GNode *node;
DBG("element %p name %s", element, element->name);
- if (connman_element_ref(element) == NULL)
- return;
+ g_static_rw_lock_writer_lock(&element_lock);
- g_static_rw_lock_reader_lock(&driver_lock);
+ node = g_node_find(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, element);
- for (list = driver_list; list; list = list->next) {
- struct connman_driver *driver = list->data;
+ if (node != NULL)
+ g_node_traverse(node, G_POST_ORDER,
+ G_TRAVERSE_ALL, -1, remove_element, NULL);
- DBG("driver %p name %s", driver, driver->name);
+ g_static_rw_lock_writer_unlock(&element_lock);
+}
- set_driver(element, driver);
+static void unregister_children(gpointer data, gpointer user_data)
+{
+ struct connman_element *element = data;
+ GNode *node;
- if (match_driver(element, driver) == TRUE &&
- driver->probe(element) == 0)
- break;
+ DBG("element %p name %s", element, element->name);
- set_driver(element, NULL);
- }
+ g_static_rw_lock_writer_lock(&element_lock);
- g_static_rw_lock_reader_unlock(&driver_lock);
+ node = g_node_find(element_root, G_PRE_ORDER, G_TRAVERSE_ALL, element);
- connman_element_unref(element);
+ if (node != NULL)
+ g_node_traverse(node, G_POST_ORDER,
+ G_TRAVERSE_ALL, -1, remove_element, element);
+
+ g_static_rw_lock_writer_unlock(&element_lock);
}
-int __connman_element_init(DBusConnection *conn)
+int __connman_element_init(DBusConnection *conn, const char *device)
{
struct connman_element *element;
if (connection == NULL)
return -EIO;
+ device_filter = g_strdup(device);
+
g_static_rw_lock_writer_lock(&element_lock);
element = connman_element_create();
g_static_rw_lock_writer_unlock(&element_lock);
- element_thread = g_thread_pool_new(element_probe, NULL, 1, FALSE, NULL);
-
- driver_thread = g_thread_pool_new(driver_probe, NULL, 1, FALSE, NULL);
+ thread_register = g_thread_pool_new(register_element,
+ NULL, 1, FALSE, NULL);
+ thread_unregister = g_thread_pool_new(unregister_element,
+ NULL, 1, FALSE, NULL);
+ thread_unregister_children = g_thread_pool_new(unregister_children,
+ NULL, 1, FALSE, NULL);
return 0;
}
-static gboolean free_node(GNode *node, gpointer data)
+static gboolean free_driver(GNode *node, gpointer data)
{
struct connman_element *element = node->data;
DBG("element %p name %s", element, element->name);
- g_dbus_unregister_interface(connection, element->path,
- CONNMAN_ELEMENT_INTERFACE);
-
if (element->driver) {
if (element->driver->remove)
element->driver->remove(element);
+
+ connman_element_lock(element);
element->driver = NULL;
+ connman_element_unlock(element);
}
- connman_element_unref(element);
+ return FALSE;
+}
+
+static gboolean free_node(GNode *node, gpointer data)
+{
+ struct connman_element *element = node->data;
+
+ DBG("element %p name %s", element, element->name);
- node->data = NULL;
+ if (g_node_depth(node) > 1)
+ g_thread_pool_push(thread_unregister, element, NULL);
return FALSE;
}
{
DBG("");
- g_thread_pool_free(driver_thread, TRUE, TRUE);
-
- g_thread_pool_free(element_thread, TRUE, TRUE);
+ g_thread_pool_free(thread_register, TRUE, TRUE);
+ thread_register = NULL;
g_static_rw_lock_writer_lock(&element_lock);
+ g_node_traverse(element_root, G_POST_ORDER, G_TRAVERSE_ALL, -1,
+ free_driver, NULL);
+ g_static_rw_lock_writer_unlock(&element_lock);
+ g_static_rw_lock_writer_lock(&element_lock);
g_node_traverse(element_root, G_POST_ORDER, G_TRAVERSE_ALL, -1,
free_node, NULL);
+ g_static_rw_lock_writer_unlock(&element_lock);
+ g_thread_pool_free(thread_unregister, FALSE, TRUE);
+ thread_unregister = NULL;
+
+ g_thread_pool_free(thread_unregister_children, FALSE, TRUE);
+ thread_unregister_children = NULL;
+
+ g_static_rw_lock_writer_lock(&element_lock);
g_node_destroy(element_root);
element_root = NULL;
-
g_static_rw_lock_writer_unlock(&element_lock);
+ g_free(device_filter);
+
dbus_connection_unref(connection);
}
projects / connman / blobdiff