X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fdevice.c;h=75561c9f8046d92240d80429d9b5592413c7ce6f;hb=fe83d954f0a1a80e9e48008e0465edaaf0cd65ea;hp=21ba42751f38aea600489ca31d5cd65903a7c03d;hpb=3ff4b7697b40c744fd540350fc53a448eb813c27;p=framework%2Fconnectivity%2Fconnman.git diff --git a/src/device.c b/src/device.c index 21ba427..d06bffd 100644 --- a/src/device.c +++ b/src/device.c @@ -2,7 +2,7 @@ * * Connection Manager * - * Copyright (C) 2007-2009 Intel Corporation. All rights reserved. + * Copyright (C) 2007-2012 Intel Corporation. All rights reserved. * * This program is free software; you can redistribute it and/or modify * it under the terms of the GNU General Public License version 2 as @@ -26,95 +26,54 @@ #include #include -#include - #include "connman.h" -static DBusConnection *connection = NULL; +static GSList *device_list = NULL; +static gchar **device_filter = NULL; +static gchar **nodevice_filter = NULL; + +enum connman_pending_type { + PENDING_NONE = 0, + PENDING_ENABLE = 1, + PENDING_DISABLE = 2, +}; struct connman_device { - struct connman_element element; + int refcount; enum connman_device_type type; - enum connman_device_mode mode; - connman_bool_t secondary; - connman_bool_t offlinemode; - connman_bool_t blocked; + enum connman_pending_type powered_pending; /* Indicates a pending + enable/disable request */ connman_bool_t powered; - connman_bool_t powered_pending; - connman_bool_t powered_persistent; - connman_bool_t carrier; connman_bool_t scanning; connman_bool_t disconnected; connman_bool_t reconnect; - connman_uint16_t scan_interval; char *name; char *node; char *address; char *interface; - char *control; char *ident; + char *path; + char *devname; int phyindex; - unsigned int connections; - guint scan_timeout; - struct connman_ipconfig *ipconfig; + int index; + guint pending_timeout; struct connman_device_driver *driver; void *driver_data; - connman_bool_t registered; - char *last_network; struct connman_network *network; GHashTable *networks; - - DBusMessage *pending; - guint timeout; }; -static gboolean device_scan_trigger(gpointer user_data) -{ - struct connman_device *device = user_data; - - DBG("device %p", device); - - if (device->driver == NULL) { - device->scan_timeout = 0; - return FALSE; - } - - if (device->driver->scan) - device->driver->scan(device); - - return TRUE; -} - -static void clear_scan_trigger(struct connman_device *device) -{ - if (device->scan_timeout > 0) { - g_source_remove(device->scan_timeout); - device->scan_timeout = 0; - } -} - -static void reset_scan_trigger(struct connman_device *device) +static void clear_pending_trigger(struct connman_device *device) { - clear_scan_trigger(device); - - if (device->scan_interval > 0) { - guint interval = device->scan_interval; - device->scan_timeout = g_timeout_add_seconds(interval, - device_scan_trigger, device); + if (device->pending_timeout > 0) { + g_source_remove(device->pending_timeout); + device->pending_timeout = 0; } } -static void force_scan_trigger(struct connman_device *device) -{ - clear_scan_trigger(device); - - device->scan_timeout = g_timeout_add_seconds(5, - device_scan_trigger, device); -} - static const char *type2description(enum connman_device_type type) { switch (type) { @@ -131,12 +90,11 @@ static const char *type2description(enum connman_device_type type) return "Bluetooth"; case CONNMAN_DEVICE_TYPE_GPS: return "GPS"; - case CONNMAN_DEVICE_TYPE_MBM: - case CONNMAN_DEVICE_TYPE_HSO: - case CONNMAN_DEVICE_TYPE_NOZOMI: - case CONNMAN_DEVICE_TYPE_HUAWEI: - case CONNMAN_DEVICE_TYPE_NOVATEL: + case CONNMAN_DEVICE_TYPE_CELLULAR: return "Cellular"; + case CONNMAN_DEVICE_TYPE_GADGET: + return "Gadget"; + } return NULL; @@ -158,12 +116,11 @@ static const char *type2string(enum connman_device_type type) return "bluetooth"; case CONNMAN_DEVICE_TYPE_GPS: return "gps"; - case CONNMAN_DEVICE_TYPE_MBM: - case CONNMAN_DEVICE_TYPE_HSO: - case CONNMAN_DEVICE_TYPE_HUAWEI: - case CONNMAN_DEVICE_TYPE_NOZOMI: - case CONNMAN_DEVICE_TYPE_NOVATEL: + case CONNMAN_DEVICE_TYPE_CELLULAR: return "cellular"; + case CONNMAN_DEVICE_TYPE_GADGET: + return "gadget"; + } return NULL; @@ -177,9 +134,6 @@ enum connman_service_type __connman_device_get_service_type(struct connman_devic case CONNMAN_DEVICE_TYPE_UNKNOWN: case CONNMAN_DEVICE_TYPE_VENDOR: case CONNMAN_DEVICE_TYPE_GPS: - case CONNMAN_DEVICE_TYPE_NOZOMI: - case CONNMAN_DEVICE_TYPE_HUAWEI: - case CONNMAN_DEVICE_TYPE_NOVATEL: break; case CONNMAN_DEVICE_TYPE_ETHERNET: return CONNMAN_SERVICE_TYPE_ETHERNET; @@ -189,586 +143,153 @@ enum connman_service_type __connman_device_get_service_type(struct connman_devic return CONNMAN_SERVICE_TYPE_WIMAX; case CONNMAN_DEVICE_TYPE_BLUETOOTH: return CONNMAN_SERVICE_TYPE_BLUETOOTH; - case CONNMAN_DEVICE_TYPE_MBM: - case CONNMAN_DEVICE_TYPE_HSO: + case CONNMAN_DEVICE_TYPE_CELLULAR: return CONNMAN_SERVICE_TYPE_CELLULAR; - } - - return CONNMAN_SERVICE_TYPE_UNKNOWN; -} - -static int set_connected(struct connman_device *device, - connman_bool_t connected) -{ - if (connected == TRUE) { - enum connman_element_type type = CONNMAN_ELEMENT_TYPE_UNKNOWN; - struct connman_element *element; - - device->disconnected = TRUE; - - switch (device->element.ipv4.method) { - case CONNMAN_IPCONFIG_METHOD_UNKNOWN: - case CONNMAN_IPCONFIG_METHOD_IGNORE: - return 0; - case CONNMAN_IPCONFIG_METHOD_STATIC: - type = CONNMAN_ELEMENT_TYPE_IPV4; - break; - case CONNMAN_IPCONFIG_METHOD_DHCP: - type = CONNMAN_ELEMENT_TYPE_DHCP; - break; - } - - element = connman_element_create(NULL); - if (element != NULL) { - struct connman_service *service; - - element->type = type; - element->index = device->element.index; - - if (connman_element_register(element, - &device->element) < 0) - connman_element_unref(element); - - device->disconnected = FALSE; + case CONNMAN_DEVICE_TYPE_GADGET: + return CONNMAN_SERVICE_TYPE_GADGET; - service = __connman_service_lookup_from_device(device); - __connman_service_indicate_state(service, - CONNMAN_SERVICE_STATE_CONFIGURATION); - } - } else { - struct connman_service *service; - - connman_element_unregister_children(&device->element); - - device->disconnected = TRUE; - - service = __connman_service_lookup_from_device(device); - __connman_service_indicate_state(service, - CONNMAN_SERVICE_STATE_IDLE); - } - - if (connected == TRUE) { - enum connman_service_type type; - - type = __connman_device_get_service_type(device); - __connman_notifier_connect(type); - } else { - enum connman_service_type type; - - type = __connman_device_get_service_type(device); - __connman_notifier_disconnect(type); } - return 0; -} - -static int set_carrier(struct connman_device *device, connman_bool_t carrier) -{ - if (carrier == TRUE) - __connman_profile_add_device(device); - else - __connman_profile_remove_device(device); - - return set_connected(device, carrier); + return CONNMAN_SERVICE_TYPE_UNKNOWN; } -static int powered_changed(struct connman_device *device) +static gboolean device_pending_reset(gpointer user_data) { - DBusMessage *signal; - DBusMessageIter entry, value; - const char *key = "Powered"; - - signal = dbus_message_new_signal(device->element.path, - CONNMAN_DEVICE_INTERFACE, "PropertyChanged"); - if (signal == NULL) - return -ENOMEM; - - dbus_message_iter_init_append(signal, &entry); - - dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); + struct connman_device *device = user_data; - dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, - DBUS_TYPE_BOOLEAN_AS_STRING, &value); - dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, - &device->powered); - dbus_message_iter_close_container(&entry, &value); + DBG("device %p", device); - g_dbus_send_message(connection, signal); + /* Power request timedout, reset power pending state. */ + device->pending_timeout = 0; + device->powered_pending = PENDING_NONE; - return 0; + return FALSE; } -static int set_powered(struct connman_device *device, connman_bool_t powered) +int __connman_device_enable(struct connman_device *device) { - struct connman_device_driver *driver = device->driver; - enum connman_service_type type; int err; - DBG("device %p powered %d", device, powered); - - if (device->powered_pending == powered) - return -EALREADY; - - if (!driver) - return -EINVAL; - - type = __connman_device_get_service_type(device); - - if (powered == TRUE) { - if (driver->enable) { - device->powered_pending = powered; - - err = driver->enable(device); - if (err == 0) - __connman_notifier_enable(type); - } else - err = -EINVAL; - } else { - device->powered_pending = powered; + DBG("device %p", device); - device->reconnect = FALSE; + if (!device->driver || !device->driver->enable) + return -EOPNOTSUPP; - clear_scan_trigger(device); + /* There is an ongoing power disable request. */ + if (device->powered_pending == PENDING_DISABLE) + return -EBUSY; - g_hash_table_remove_all(device->networks); + if (device->powered_pending == PENDING_ENABLE) + return -EALREADY; - set_carrier(device, FALSE); + if (device->powered_pending == PENDING_NONE && device->powered == TRUE) + return -EALREADY; - if (driver->disable) { - err = driver->disable(device); - if (err == 0) - __connman_notifier_disable(type); - } else - err = -EINVAL; - } + device->powered_pending = PENDING_ENABLE; + err = device->driver->enable(device); + /* + * device gets enabled right away. + * Invoke the callback + */ if (err == 0) { - device->powered = powered; - - if (device->registered == TRUE) - powered_changed(device); + connman_device_set_powered(device, TRUE); + goto done; } - return err; -} - -static void append_path(gpointer key, gpointer value, gpointer user_data) -{ - struct connman_element *element = value; - DBusMessageIter *iter = user_data; - - dbus_message_iter_append_basic(iter, DBUS_TYPE_OBJECT_PATH, - &element->path); -} - -static void append_networks(struct connman_device *device, - DBusMessageIter *entry) -{ - DBusMessageIter value, iter; - const char *key = "Networks"; - - dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key); - - dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT, - DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING, - &value); - - dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY, - DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter); - g_hash_table_foreach(device->networks, append_path, &iter); - dbus_message_iter_close_container(&value, &iter); - - dbus_message_iter_close_container(entry, &value); -} - -static DBusMessage *get_properties(DBusConnection *conn, - DBusMessage *msg, void *data) -{ - struct connman_device *device = data; - DBusMessage *reply; - DBusMessageIter array, dict, entry; - const char *str; - - DBG("conn %p", conn); - - if (__connman_security_check_privilege(msg, - CONNMAN_SECURITY_PRIVILEGE_PUBLIC) < 0) - return __connman_error_permission_denied(msg); - - reply = dbus_message_new_method_return(msg); - if (reply == NULL) - return NULL; - - dbus_message_iter_init_append(reply, &array); - - dbus_message_iter_open_container(&array, DBUS_TYPE_ARRAY, - DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING - DBUS_TYPE_STRING_AS_STRING DBUS_TYPE_VARIANT_AS_STRING - DBUS_DICT_ENTRY_END_CHAR_AS_STRING, &dict); - - if (device->name != NULL) - connman_dbus_dict_append_variant(&dict, "Name", - DBUS_TYPE_STRING, &device->name); - - str = type2string(device->type); - if (str != NULL) - connman_dbus_dict_append_variant(&dict, "Type", - DBUS_TYPE_STRING, &str); - - if (device->address != NULL) - connman_dbus_dict_append_variant(&dict, "Address", - DBUS_TYPE_STRING, &device->address); - - if (device->interface != NULL) - connman_dbus_dict_append_variant(&dict, "Interface", - DBUS_TYPE_STRING, &device->interface); - - connman_dbus_dict_append_variant(&dict, "Powered", - DBUS_TYPE_BOOLEAN, &device->powered); - - if (device->driver && device->driver->scan) - connman_dbus_dict_append_variant(&dict, "Scanning", - DBUS_TYPE_BOOLEAN, &device->scanning); - - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - break; - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: - __connman_element_append_ipv4(&device->element, &dict); - break; - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - if (device->scan_interval > 0) - connman_dbus_dict_append_variant(&dict, "ScanInterval", - DBUS_TYPE_UINT16, &device->scan_interval); - - dbus_message_iter_open_container(&dict, DBUS_TYPE_DICT_ENTRY, - NULL, &entry); - append_networks(device, &entry); - dbus_message_iter_close_container(&dict, &entry); - break; + if (err == -EALREADY) { + /* If device is already powered, but connman is not updated */ + connman_device_set_powered(device, TRUE); + goto done; } - - dbus_message_iter_close_container(&array, &dict); - - return reply; + /* + * if err == -EINPROGRESS, then the DBus call to the respective daemon + * was successful. We set a 4 sec timeout so if the daemon never + * returns a reply, we would reset the pending request. + */ + if (err == -EINPROGRESS) + device->pending_timeout = g_timeout_add_seconds(4, + device_pending_reset, device); +done: + return err; } -static gboolean powered_timeout(gpointer user_data) +int __connman_device_disable(struct connman_device *device) { - struct connman_device *device = user_data; + int err; DBG("device %p", device); - device->timeout = 0; - - if (device->pending != NULL) { - DBusMessage *reply; - - reply = __connman_error_operation_timeout(device->pending); - if (reply != NULL) - g_dbus_send_message(connection, reply); - - dbus_message_unref(device->pending); - device->pending = NULL; - } - - return FALSE; -} - -static DBusMessage *set_property(DBusConnection *conn, - DBusMessage *msg, void *data) -{ - struct connman_device *device = data; - DBusMessageIter iter, value; - const char *name; - int type; - - DBG("conn %p", conn); - - if (dbus_message_iter_init(msg, &iter) == FALSE) - return __connman_error_invalid_arguments(msg); - - dbus_message_iter_get_basic(&iter, &name); - dbus_message_iter_next(&iter); - dbus_message_iter_recurse(&iter, &value); - - if (__connman_security_check_privilege(msg, - CONNMAN_SECURITY_PRIVILEGE_MODIFY) < 0) - return __connman_error_permission_denied(msg); - - type = dbus_message_iter_get_arg_type(&value); - - if (g_str_equal(name, "Powered") == TRUE) { - connman_bool_t powered; - int err; - - if (type != DBUS_TYPE_BOOLEAN) - return __connman_error_invalid_arguments(msg); - - dbus_message_iter_get_basic(&value, &powered); - - device->powered_persistent = powered; - - __connman_storage_save_device(device); - - if (device->powered == powered) - return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); - - if (device->pending != NULL) - return __connman_error_in_progress(msg); - - err = set_powered(device, powered); - if (err < 0) { - if (err != -EINPROGRESS) - return __connman_error_failed(msg, -err); - - device->pending = dbus_message_ref(msg); - - device->timeout = g_timeout_add_seconds(15, - powered_timeout, device); - - return NULL; - } - } else if (g_str_equal(name, "ScanInterval") == TRUE) { - connman_uint16_t interval; - - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: - return __connman_error_invalid_arguments(msg); - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - break; - } - - if (type != DBUS_TYPE_UINT16) - return __connman_error_invalid_arguments(msg); - - dbus_message_iter_get_basic(&value, &interval); - - if (device->scan_interval != interval) { - device->scan_interval = interval; - - __connman_storage_save_device(device); + if (!device->driver || !device->driver->disable) + return -EOPNOTSUPP; - reset_scan_trigger(device); - } - } else if (g_str_has_prefix(name, "IPv4.") == TRUE) { - int err; - - if (device->ipconfig == NULL) - return __connman_error_invalid_property(msg); - - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - return __connman_error_invalid_arguments(msg); - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: - break; - } + /* Ongoing power enable request */ + if (device->powered_pending == PENDING_ENABLE) + return -EBUSY; - err = __connman_ipconfig_set_ipv4(device->ipconfig, - name + 5, &value); - if (err < 0) - return __connman_error_failed(msg, -err); - } else - return __connman_error_invalid_property(msg); + if (device->powered_pending == PENDING_DISABLE) + return -EALREADY; - return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); -} + if (device->powered_pending == PENDING_NONE && device->powered == FALSE) + return -EALREADY; -static DBusMessage *propose_scan(DBusConnection *conn, - DBusMessage *msg, void *data) -{ - struct connman_device *device = data; - int err; + device->powered_pending = PENDING_DISABLE; + device->reconnect = FALSE; - DBG("conn %p", conn); + if (device->network) { + struct connman_service *service = + __connman_service_lookup_from_network(device->network); - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: - return __connman_error_not_supported(msg); - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - break; + if (service != NULL) + __connman_service_disconnect(service); + else + connman_network_set_connected(device->network, FALSE); } - err = __connman_device_scan(device); - if (err < 0) - return __connman_error_failed(msg, -err); - - return g_dbus_create_reply(msg, DBUS_TYPE_INVALID); -} - -static GDBusMethodTable device_methods[] = { - { "GetProperties", "", "a{sv}", get_properties }, - { "SetProperty", "sv", "", set_property, - G_DBUS_METHOD_FLAG_ASYNC }, - { "ProposeScan", "", "", propose_scan }, - { }, -}; - -static GDBusSignalTable device_signals[] = { - { "PropertyChanged", "sv" }, - { }, -}; - -static void append_devices(DBusMessageIter *entry) -{ - DBusMessageIter value, iter; - const char *key = "Devices"; - - dbus_message_iter_append_basic(entry, DBUS_TYPE_STRING, &key); - - dbus_message_iter_open_container(entry, DBUS_TYPE_VARIANT, - DBUS_TYPE_ARRAY_AS_STRING DBUS_TYPE_OBJECT_PATH_AS_STRING, - &value); - - dbus_message_iter_open_container(&value, DBUS_TYPE_ARRAY, - DBUS_TYPE_OBJECT_PATH_AS_STRING, &iter); - __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, &iter); - dbus_message_iter_close_container(&value, &iter); - - dbus_message_iter_close_container(entry, &value); -} - -static void emit_devices_signal(void) -{ - DBusMessage *signal; - DBusMessageIter entry; - - signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH, - CONNMAN_MANAGER_INTERFACE, "PropertyChanged"); - if (signal == NULL) - return; - - dbus_message_iter_init_append(signal, &entry); - - append_devices(&entry); - - g_dbus_send_message(connection, signal); -} - -static int register_interface(struct connman_element *element) -{ - struct connman_device *device = element->device; - - DBG("element %p name %s", element, element->name); - - if (g_dbus_register_interface(connection, element->path, - CONNMAN_DEVICE_INTERFACE, - device_methods, device_signals, - NULL, device, NULL) == FALSE) { - connman_error("Failed to register %s device", element->path); - return -EIO; + err = device->driver->disable(device); + if (err == 0 || err == -EALREADY) { + connman_device_set_powered(device, FALSE); + goto done; } - device->registered = TRUE; - - emit_devices_signal(); - - return 0; + if (err == -EINPROGRESS) + device->pending_timeout = g_timeout_add_seconds(4, + device_pending_reset, device); +done: + return err; } -static void unregister_interface(struct connman_element *element) +static void probe_driver(struct connman_device_driver *driver) { - struct connman_device *device = element->device; - - DBG("element %p name %s", element, element->name); - - device->registered = FALSE; + GSList *list; - emit_devices_signal(); + DBG("driver %p name %s", driver, driver->name); - g_dbus_unregister_interface(connection, element->path, - CONNMAN_DEVICE_INTERFACE); -} + for (list = device_list; list != NULL; list = list->next) { + struct connman_device *device = list->data; -static int setup_device(struct connman_device *device) -{ - enum connman_service_type type; - int err; + if (device->driver != NULL) + continue; - DBG("device %p", device); + if (driver->type != device->type) + continue; - err = register_interface(&device->element); - if (err < 0) { - if (device->driver->remove) - device->driver->remove(device); - device->driver = NULL; - return err; - } + if (driver->probe(device) < 0) + continue; - type = __connman_device_get_service_type(device); - __connman_notifier_register(type); + device->driver = driver; - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - break; - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: - if (device->carrier == TRUE && device->secondary == FALSE) - __connman_profile_add_device(device); - break; + __connman_technology_add_device(device); } - - if (device->offlinemode == FALSE && - device->powered_persistent == TRUE) - __connman_device_enable(device); - - return 0; -} - -static void probe_driver(struct connman_element *element, gpointer user_data) -{ - struct connman_device_driver *driver = user_data; - - DBG("element %p name %s", element, element->name); - - if (element->device == NULL) - return; - - if (element->device->driver != NULL) - return; - - if (driver->type != element->device->type) - return; - - if (driver->probe(element->device) < 0) - return; - - element->device->driver = driver; - - setup_device(element->device); } static void remove_device(struct connman_device *device) { - enum connman_service_type type; - DBG("device %p", device); __connman_device_disable(device); - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - break; - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: - if (device->secondary == FALSE) - __connman_profile_remove_device(device); - break; - } - - type = __connman_device_get_service_type(device); - __connman_notifier_unregister(type); - - unregister_interface(&device->element); + __connman_technology_remove_device(device); if (device->driver->remove) device->driver->remove(device); @@ -776,17 +297,18 @@ static void remove_device(struct connman_device *device) device->driver = NULL; } -static void remove_driver(struct connman_element *element, gpointer user_data) +static void remove_driver(struct connman_device_driver *driver) { - struct connman_device_driver *driver = user_data; + GSList *list; - DBG("element %p name %s", element, element->name); + DBG("driver %p name %s", driver, driver->name); - if (element->device == NULL) - return; + for (list = device_list; list != NULL; list = list->next) { + struct connman_device *device = list->data; - if (element->device->driver == driver) - remove_device(element->device); + if (device->driver == driver) + remove_device(device); + } } connman_bool_t __connman_device_has_driver(struct connman_device *device) @@ -794,7 +316,7 @@ connman_bool_t __connman_device_has_driver(struct connman_device *device) if (device == NULL || device->driver == NULL) return FALSE; - return device->registered; + return TRUE; } static GSList *driver_list = NULL; @@ -821,9 +343,7 @@ int connman_device_driver_register(struct connman_device_driver *driver) driver_list = g_slist_insert_sorted(driver_list, driver, compare_priority); - - __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, - probe_driver, driver); + probe_driver(driver); return 0; } @@ -840,53 +360,40 @@ void connman_device_driver_unregister(struct connman_device_driver *driver) driver_list = g_slist_remove(driver_list, driver); - __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, - remove_driver, driver); + remove_driver(driver); } -static void unregister_network(gpointer data) +static void free_network(gpointer data) { struct connman_network *network = data; DBG("network %p", network); - connman_element_unregister((struct connman_element *) network); + __connman_network_set_device(network, NULL); connman_network_unref(network); } -static void device_destruct(struct connman_element *element) +static void device_destruct(struct connman_device *device) { - struct connman_device *device = element->device; - - DBG("element %p name %s", element, element->name); + DBG("device %p name %s", device, device->name); - if (device->timeout > 0) { - g_source_remove(device->timeout); - device->timeout = 0; - } - - if (device->pending != NULL) { - dbus_message_unref(device->pending); - device->pending = NULL; - } + clear_pending_trigger(device); g_free(device->ident); g_free(device->node); g_free(device->name); g_free(device->address); - g_free(device->control); g_free(device->interface); - - if (device->ipconfig != NULL) { - connman_ipconfig_unref(device->ipconfig); - device->ipconfig = NULL; - } + g_free(device->path); + g_free(device->devname); g_free(device->last_network); g_hash_table_destroy(device->networks); device->networks = NULL; + + g_free(device); } /** @@ -902,7 +409,6 @@ struct connman_device *connman_device_create(const char *node, enum connman_device_type type) { struct connman_device *device; - const char *str; DBG("node %s type %d", node, type); @@ -912,59 +418,17 @@ struct connman_device *connman_device_create(const char *node, DBG("device %p", device); - __connman_element_initialize(&device->element); - - device->element.name = g_strdup(node); - device->element.type = CONNMAN_ELEMENT_TYPE_DEVICE; + device->refcount = 1; - device->element.device = device; - device->element.destruct = device_destruct; - - str = type2string(type); - if (str != NULL) - connman_element_set_string(&device->element, - CONNMAN_PROPERTY_ID_TYPE, str); - - device->element.ipv4.method = CONNMAN_IPCONFIG_METHOD_DHCP; - - device->type = type; - device->name = g_strdup(type2description(device->type)); - device->mode = CONNMAN_DEVICE_MODE_UNKNOWN; - device->secondary = FALSE; - - device->powered_persistent = TRUE; + device->type = type; + device->name = g_strdup(type2description(device->type)); device->phyindex = -1; - switch (type) { - case CONNMAN_DEVICE_TYPE_UNKNOWN: - case CONNMAN_DEVICE_TYPE_VENDOR: - device->scan_interval = 0; - break; - case CONNMAN_DEVICE_TYPE_ETHERNET: - case CONNMAN_DEVICE_TYPE_WIFI: - device->scan_interval = 300; - break; - case CONNMAN_DEVICE_TYPE_WIMAX: - device->scan_interval = 0; - break; - case CONNMAN_DEVICE_TYPE_BLUETOOTH: - device->scan_interval = 0; - break; - case CONNMAN_DEVICE_TYPE_GPS: - device->scan_interval = 0; - break; - case CONNMAN_DEVICE_TYPE_MBM: - case CONNMAN_DEVICE_TYPE_HSO: - case CONNMAN_DEVICE_TYPE_NOZOMI: - case CONNMAN_DEVICE_TYPE_HUAWEI: - case CONNMAN_DEVICE_TYPE_NOVATEL: - device->scan_interval = 0; - break; - } - device->networks = g_hash_table_new_full(g_str_hash, g_str_equal, - g_free, unregister_network); + g_free, free_network); + + device_list = g_slist_append(device_list, device); return device; } @@ -975,10 +439,13 @@ struct connman_device *connman_device_create(const char *node, * * Increase reference counter of device */ -struct connman_device *connman_device_ref(struct connman_device *device) +struct connman_device *connman_device_ref_debug(struct connman_device *device, + const char *file, int line, const char *caller) { - if (connman_element_ref(&device->element) == NULL) - return NULL; + DBG("%p ref %d by %s:%d:%s()", device, device->refcount + 1, + file, line, caller); + + __sync_fetch_and_add(&device->refcount, 1); return device; } @@ -989,9 +456,23 @@ struct connman_device *connman_device_ref(struct connman_device *device) * * Decrease reference counter of device */ -void connman_device_unref(struct connman_device *device) +void connman_device_unref_debug(struct connman_device *device, + const char *file, int line, const char *caller) { - connman_element_unref(&device->element); + DBG("%p ref %d by %s:%d:%s()", device, device->refcount - 1, + file, line, caller); + + if (__sync_fetch_and_sub(&device->refcount, 1) != 1) + return; + + if (device->driver) { + device->driver->remove(device); + device->driver = NULL; + } + + device_list = g_slist_remove(device_list, device); + + device_destruct(device); } const char *__connman_device_get_type(struct connman_device *device) @@ -1011,28 +492,6 @@ enum connman_device_type connman_device_get_type(struct connman_device *device) } /** - * connman_device_get_name: - * @device: device structure - * - * Get unique name of device - */ -const char *connman_device_get_name(struct connman_device *device) -{ - return device->element.name; -} - -/** - * connman_device_get_path: - * @device: device structure - * - * Get path name of device - */ -const char *connman_device_get_path(struct connman_device *device) -{ - return device->element.path; -} - -/** * connman_device_set_index: * @device: device structure * @index: index number @@ -1041,16 +500,7 @@ const char *connman_device_get_path(struct connman_device *device) */ void connman_device_set_index(struct connman_device *device, int index) { - device->element.index = index; - - if (device->ipconfig != NULL) { - if (index == connman_ipconfig_get_index(device->ipconfig)) - return; - - connman_ipconfig_unref(device->ipconfig); - } - - device->ipconfig = connman_ipconfig_create(index); + device->index = index; } /** @@ -1061,7 +511,7 @@ void connman_device_set_index(struct connman_device *device, int index) */ int connman_device_get_index(struct connman_device *device) { - return device->element.index; + return device->index; } int __connman_device_get_phyindex(struct connman_device *device) @@ -1079,22 +529,18 @@ void __connman_device_set_phyindex(struct connman_device *device, * connman_device_set_interface: * @device: device structure * @interface: interface name - * @control: control interface * * Set interface name of device */ void connman_device_set_interface(struct connman_device *device, - const char *interface, const char *control) + const char *interface) { - g_free(device->element.devname); - device->element.devname = g_strdup(interface); + g_free(device->devname); + device->devname = g_strdup(interface); g_free(device->interface); device->interface = g_strdup(interface); - g_free(device->control); - device->control = g_strdup(control); - if (device->name == NULL) { const char *str = type2description(device->type); if (str != NULL && device->interface != NULL) @@ -1103,11 +549,6 @@ void connman_device_set_interface(struct connman_device *device, } } -const char *connman_device_get_control(struct connman_device *device) -{ - return device->control; -} - /** * connman_device_set_ident: * @device: device structure @@ -1122,275 +563,63 @@ void connman_device_set_ident(struct connman_device *device, device->ident = g_strdup(ident); } -const char *__connman_device_get_ident(struct connman_device *device) +const char *connman_device_get_ident(struct connman_device *device) { return device->ident; } /** - * connman_device_set_mode: - * @device: device structure - * @mode: network mode - * - * Change network mode of device - */ -void connman_device_set_mode(struct connman_device *device, - enum connman_device_mode mode) -{ - device->mode = mode; -} - -/** - * connman_device_get_mode: - * @device: device structure - * - * Get network mode of device - */ -enum connman_device_mode connman_device_get_mode(struct connman_device *device) -{ - return device->mode; -} - -/** - * connman_device_set_secondary: - * @device: device structure - * @secondary: secondary value - * - * Change secondary value of device - */ -void connman_device_set_secondary(struct connman_device *device, - connman_bool_t secondary) -{ - device->secondary = secondary; -} - -/** - * connman_device_get_secondary: - * @device: device structure - * - * Get secondary value of device - */ -connman_bool_t connman_device_get_secondary(struct connman_device *device) -{ - return device->secondary; -} - -/** * connman_device_set_powered: * @device: device structure * @powered: powered state * * Change power state of device - */ -int connman_device_set_powered(struct connman_device *device, - connman_bool_t powered) -{ - enum connman_service_type type; - - DBG("driver %p powered %d", device, powered); - - if (device->timeout > 0) { - g_source_remove(device->timeout); - device->timeout = 0; - } - - if (device->pending != NULL) { - g_dbus_send_reply(connection, device->pending, - DBUS_TYPE_INVALID); - - dbus_message_unref(device->pending); - device->pending = NULL; - } - - if (device->powered == powered) - return -EALREADY; - - device->powered = powered; - device->powered_pending = powered; - - type = __connman_device_get_service_type(device); - - if (device->powered == TRUE) - __connman_notifier_enable(type); - else - __connman_notifier_disable(type); - - if (device->registered == FALSE) - return 0; - - powered_changed(device); - - if (powered == FALSE) - return 0; - - reset_scan_trigger(device); - - if (device->driver->scan) - device->driver->scan(device); - - return 0; -} - -int __connman_device_set_blocked(struct connman_device *device, - connman_bool_t blocked) -{ - connman_bool_t powered; - - DBG("device %p blocked %d", device, blocked); - - device->blocked = blocked; - - if (device->offlinemode == TRUE) - return 0; - - connman_info("%s {rfkill} blocked %d", device->interface, blocked); - - if (blocked == FALSE) - powered = device->powered_persistent; - else - powered = FALSE; - - return set_powered(device, powered); -} - -/** - * connman_device_set_carrier: - * @device: device structure - * @carrier: carrier state - * - * Change carrier state of device (only for device without scanning) - */ -int connman_device_set_carrier(struct connman_device *device, - connman_bool_t carrier) -{ - DBG("device %p carrier %d", device, carrier); - - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - return -EINVAL; - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: - break; - } - - if (device->carrier == carrier) - return -EALREADY; - - device->carrier = carrier; - - return set_carrier(device, device->carrier); -} - -int __connman_device_scan(struct connman_device *device) -{ - if (!device->driver || !device->driver->scan) - return -EOPNOTSUPP; - - if (device->powered == FALSE) - return -ENOLINK; - - reset_scan_trigger(device); - - return device->driver->scan(device); -} - -int __connman_device_enable(struct connman_device *device) -{ - enum connman_service_type type; - int err; - - DBG("device %p", device); - - if (!device->driver || !device->driver->enable) - return -EOPNOTSUPP; - - if (device->powered_pending == TRUE) - return -EALREADY; - - device->powered_pending = TRUE; - - err = device->driver->enable(device); - if (err < 0) - return err; - - device->powered = TRUE; - - type = __connman_device_get_service_type(device); - __connman_notifier_enable(type); - - return 0; -} - -int __connman_device_enable_persistent(struct connman_device *device) -{ - DBG("device %p", device); - - device->powered_persistent = TRUE; - - __connman_storage_save_device(device); - - return __connman_device_enable(device); -} - -int __connman_device_disable(struct connman_device *device) -{ - enum connman_service_type type; - int err; - - DBG("device %p", device); - - if (!device->driver || !device->driver->disable) - return -EOPNOTSUPP; + */ +int connman_device_set_powered(struct connman_device *device, + connman_bool_t powered) +{ + enum connman_service_type type; - if (device->powered == FALSE) - return -ENOLINK; + DBG("driver %p powered %d", device, powered); - if (device->powered_pending == FALSE) + if (device->powered == powered) return -EALREADY; - device->powered_pending = FALSE; - - device->reconnect = FALSE; - - clear_scan_trigger(device); + clear_pending_trigger(device); - g_hash_table_remove_all(device->networks); - - err = device->driver->disable(device); - if (err < 0) - return err; + device->powered_pending = PENDING_NONE; - device->powered = FALSE; + device->powered = powered; type = __connman_device_get_service_type(device); - __connman_notifier_disable(type); - return 0; -} + if (device->powered == FALSE) { + __connman_technology_disabled(type); + return 0; + } -int __connman_device_disable_persistent(struct connman_device *device) -{ - DBG("device %p", device); + __connman_technology_enabled(type); - device->powered_persistent = FALSE; + connman_device_set_disconnected(device, FALSE); + device->scanning = FALSE; - __connman_storage_save_device(device); + if (device->driver && device->driver->scan_fast) + device->driver->scan_fast(device); + else if (device->driver && device->driver->scan) + device->driver->scan(device); - return __connman_device_disable(device); + return 0; } -int __connman_device_connect(struct connman_device *device) +static int device_scan(struct connman_device *device) { - DBG("device %p", device); - - if (device->disconnected == FALSE) - return -EINVAL; + if (!device->driver || !device->driver->scan) + return -EOPNOTSUPP; - if (device->driver && device->driver->connect) - device->driver->connect(device); + if (device->powered == FALSE) + return -ENOLINK; - return 0; + return device->driver->scan(device); } int __connman_device_disconnect(struct connman_device *device) @@ -1407,15 +636,36 @@ int __connman_device_disconnect(struct connman_device *device) while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) { struct connman_network *network = value; + if (connman_network_get_connecting(network) == TRUE) { + /* + * Skip network in the process of connecting. + * This is a workaround for WiFi networks serviced + * by the supplicant plugin that hold a reference + * to the network. If we disconnect the network + * here then the referenced object will not be + * registered and usage (like launching DHCP client) + * will fail. There is nothing to be gained by + * removing the network here anyway. + */ + connman_warn("Skipping disconnect of %s, network is connecting.", + connman_network_get_identifier(network)); + continue; + } + __connman_network_disconnect(network); } - if (device->driver && device->driver->disconnect) - device->driver->disconnect(device); - return 0; } +static void mark_network_available(gpointer key, gpointer value, + gpointer user_data) +{ + struct connman_network *network = value; + + connman_network_set_available(network, TRUE); +} + static void mark_network_unavailable(gpointer key, gpointer value, gpointer user_data) { @@ -1447,44 +697,15 @@ void __connman_device_cleanup_networks(struct connman_device *device) remove_unavailable_network, NULL); } -static void scanning_changed(struct connman_device *device) -{ - DBusMessage *signal; - DBusMessageIter entry, value; - const char *key = "Scanning"; - - signal = dbus_message_new_signal(device->element.path, - CONNMAN_DEVICE_INTERFACE, "PropertyChanged"); - if (signal == NULL) - return; - - dbus_message_iter_init_append(signal, &entry); - - dbus_message_iter_append_basic(&entry, DBUS_TYPE_STRING, &key); - - dbus_message_iter_open_container(&entry, DBUS_TYPE_VARIANT, - DBUS_TYPE_BOOLEAN_AS_STRING, &value); - dbus_message_iter_append_basic(&value, DBUS_TYPE_BOOLEAN, - &device->scanning); - dbus_message_iter_close_container(&entry, &value); - - g_dbus_send_message(connection, signal); -} - -static void mark_network_available(gpointer key, gpointer value, - gpointer user_data) +connman_bool_t connman_device_get_scanning(struct connman_device *device) { - struct connman_network *network = value; - - connman_network_set_available(network, TRUE); + return device->scanning; } -void connman_device_cleanup_scanning(struct connman_device *device) +void connman_device_reset_scanning(struct connman_device *device) { device->scanning = FALSE; - scanning_changed(device); - g_hash_table_foreach(device->networks, mark_network_available, NULL); } @@ -1509,10 +730,8 @@ int connman_device_set_scanning(struct connman_device *device, device->scanning = scanning; - scanning_changed(device); - if (scanning == TRUE) { - reset_scan_trigger(device); + __connman_technology_scan_started(device); g_hash_table_foreach(device->networks, mark_network_unavailable, NULL); @@ -1522,11 +741,7 @@ int connman_device_set_scanning(struct connman_device *device, __connman_device_cleanup_networks(device); - if (device->connections > 0) - return 0; - - if (device->disconnected == TRUE) - return 0; + __connman_technology_scan_stopped(device); __connman_service_auto_connect(); @@ -1545,23 +760,11 @@ int connman_device_set_disconnected(struct connman_device *device, { DBG("device %p disconnected %d", device, disconnected); - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: - return -EINVAL; - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - break; - } - if (device->disconnected == disconnected) return -EALREADY; device->disconnected = disconnected; - if (disconnected == TRUE) - force_scan_trigger(device); - return 0; } @@ -1577,33 +780,6 @@ connman_bool_t connman_device_get_disconnected(struct connman_device *device) } /** - * connman_device_set_connected: - * @device: device structure - * @connected: connected state - * - * Change connected state of device (for Ethernet like devices) - */ -int connman_device_set_connected(struct connman_device *device, - connman_bool_t connected) -{ - DBG("device %p connected %d", device, connected); - - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - return -EINVAL; - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: - break; - } - - if (device->carrier == FALSE) - return -ENOTCONN; - - return set_connected(device, connected); -} - -/** * connman_device_set_string: * @device: device structure * @key: unique identifier @@ -1625,9 +801,14 @@ int connman_device_set_string(struct connman_device *device, } else if (g_str_equal(key, "Node") == TRUE) { g_free(device->node); device->node = g_strdup(value); + } else if (g_str_equal(key, "Path") == TRUE) { + g_free(device->path); + device->path = g_strdup(value); + } else { + return -EINVAL; } - return connman_element_set_string(&device->element, key, value); + return 0; } /** @@ -1648,54 +829,12 @@ const char *connman_device_get_string(struct connman_device *device, return device->name; else if (g_str_equal(key, "Node") == TRUE) return device->node; + else if (g_str_equal(key, "Interface") == TRUE) + return device->interface; + else if (g_str_equal(key, "Path") == TRUE) + return device->path; - return connman_element_get_string(&device->element, key); -} - -static void set_offlinemode(struct connman_element *element, gpointer user_data) -{ - struct connman_device *device = element->device; - connman_bool_t offlinemode = GPOINTER_TO_UINT(user_data); - connman_bool_t powered; - - DBG("element %p name %s", element, element->name); - - if (device == NULL) - return; - - device->offlinemode = offlinemode; - - powered = (offlinemode == TRUE) ? FALSE : TRUE; - - if (device->powered == powered) - return; - - if (device->powered_persistent == FALSE) - powered = FALSE; - - set_powered(device, powered); -} - -int __connman_device_set_offlinemode(connman_bool_t offlinemode) -{ - DBG("offlinmode %d", offlinemode); - - __connman_element_foreach(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, - set_offlinemode, GUINT_TO_POINTER(offlinemode)); - - __connman_notifier_offlinemode(offlinemode); - - return 0; -} - -void __connman_device_increase_connections(struct connman_device *device) -{ - device->connections++; -} - -void __connman_device_decrease_connections(struct connman_device *device) -{ - device->connections--; + return NULL; } /** @@ -1709,29 +848,17 @@ int connman_device_add_network(struct connman_device *device, struct connman_network *network) { const char *identifier = connman_network_get_identifier(network); - int err; DBG("device %p network %p", device, network); - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: + if (identifier == NULL) return -EINVAL; - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - break; - } - __connman_network_set_device(network, device); + connman_network_ref(network); - err = connman_element_register((struct connman_element *) network, - &device->element); - if (err < 0) { - __connman_network_set_device(network, NULL); - return err; - } + __connman_network_set_device(network, device); - g_hash_table_insert(device->networks, g_strdup(identifier), + g_hash_table_replace(device->networks, g_strdup(identifier), network); return 0; @@ -1760,33 +887,43 @@ struct connman_network *connman_device_get_network(struct connman_device *device * Remove network for given identifier */ int connman_device_remove_network(struct connman_device *device, - const char *identifier) + struct connman_network *network) { - DBG("device %p identifier %s", device, identifier); + const char *identifier; + + DBG("device %p network %p", device, network); + + if (network == NULL) + return 0; + identifier = connman_network_get_identifier(network); g_hash_table_remove(device->networks, identifier); return 0; } +void connman_device_remove_all_networks(struct connman_device *device) +{ + g_hash_table_remove_all(device->networks); +} + void __connman_device_set_network(struct connman_device *device, struct connman_network *network) { const char *name; - if (device->network == network) + if (device == NULL) return; - if (device->network != NULL) - connman_network_unref(device->network); + if (device->network == network) + return; if (network != NULL) { - name = connman_network_get_string(network, - CONNMAN_PROPERTY_ID_NAME); + name = connman_network_get_string(network, "Name"); g_free(device->last_network); device->last_network = g_strdup(name); - device->network = connman_network_ref(network); + device->network = network; } else { g_free(device->last_network); device->last_network = NULL; @@ -1807,6 +944,16 @@ connman_bool_t __connman_device_get_reconnect( return device->reconnect; } +static gboolean match_driver(struct connman_device *device, + struct connman_device_driver *driver) +{ + if (device->type == driver->type || + driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN) + return TRUE; + + return FALSE; +} + /** * connman_device_register: * @device: device structure @@ -1815,11 +962,31 @@ connman_bool_t __connman_device_get_reconnect( */ int connman_device_register(struct connman_device *device) { - __connman_storage_load_device(device); + GSList *list; + + DBG("device %p name %s", device, device->name); + + if (device->driver != NULL) + return -EALREADY; + + for (list = driver_list; list; list = list->next) { + struct connman_device_driver *driver = list->data; + + if (match_driver(device, driver) == FALSE) + continue; + + DBG("driver %p name %s", driver, driver->name); + + if (driver->probe(device) == 0) { + device->driver = driver; + break; + } + } - device->offlinemode = __connman_profile_get_offlinemode(); + if (device->driver == NULL) + return 0; - return connman_element_register(&device->element, NULL); + return __connman_technology_add_device(device); } /** @@ -1830,9 +997,12 @@ int connman_device_register(struct connman_device *device) */ void connman_device_unregister(struct connman_device *device) { - __connman_storage_save_device(device); + DBG("device %p name %s", device, device->name); + + if (device->driver == NULL) + return; - connman_element_unregister(&device->element); + remove_device(device); } /** @@ -1858,184 +1028,140 @@ void connman_device_set_data(struct connman_device *device, void *data) device->driver_data = data; } -static gboolean match_driver(struct connman_device *device, - struct connman_device_driver *driver) -{ - if (device->type == driver->type || - driver->type == CONNMAN_DEVICE_TYPE_UNKNOWN) - return TRUE; - - return FALSE; -} - -static int device_probe(struct connman_element *element) +struct connman_device *__connman_device_find_device( + enum connman_service_type type) { - struct connman_device *device = element->device; GSList *list; - DBG("element %p name %s", element, element->name); - - if (device == NULL) - return -ENODEV; - - if (device->driver != NULL) - return -EALREADY; - - for (list = driver_list; list; list = list->next) { - struct connman_device_driver *driver = list->data; + for (list = device_list; list != NULL; list = list->next) { + struct connman_device *device = list->data; + enum connman_service_type service_type = + __connman_device_get_service_type(device); - if (match_driver(device, driver) == FALSE) + if (service_type != type) continue; - DBG("driver %p name %s", driver, driver->name); - - if (driver->probe(device) == 0) { - device->driver = driver; - break; - } + return device; } - if (device->driver == NULL) - return -ENODEV; - - return setup_device(device); + return NULL; } -static void device_remove(struct connman_element *element) +int __connman_device_request_scan(enum connman_service_type type) { - struct connman_device *device = element->device; - - DBG("element %p name %s", element, element->name); - - if (device == NULL) - return; - - if (device->driver == NULL) - return; + connman_bool_t success = FALSE; + int last_err = -ENOSYS; + GSList *list; + int err; - remove_device(device); -} + switch (type) { + case CONNMAN_SERVICE_TYPE_UNKNOWN: + case CONNMAN_SERVICE_TYPE_SYSTEM: + case CONNMAN_SERVICE_TYPE_ETHERNET: + case CONNMAN_SERVICE_TYPE_BLUETOOTH: + case CONNMAN_SERVICE_TYPE_CELLULAR: + case CONNMAN_SERVICE_TYPE_GPS: + case CONNMAN_SERVICE_TYPE_VPN: + case CONNMAN_SERVICE_TYPE_GADGET: + return -EOPNOTSUPP; + case CONNMAN_SERVICE_TYPE_WIFI: + case CONNMAN_SERVICE_TYPE_WIMAX: + break; + } -static struct connman_driver device_driver = { - .name = "device", - .type = CONNMAN_ELEMENT_TYPE_DEVICE, - .priority = CONNMAN_DRIVER_PRIORITY_LOW, - .probe = device_probe, - .remove = device_remove, -}; + for (list = device_list; list != NULL; list = list->next) { + struct connman_device *device = list->data; + enum connman_service_type service_type = + __connman_device_get_service_type(device); -static int device_load(struct connman_device *device) -{ - const char *ident = __connman_profile_active_ident(); - GKeyFile *keyfile; - GError *error = NULL; - gchar *identifier; - connman_bool_t powered; - int val; + if (service_type != CONNMAN_SERVICE_TYPE_UNKNOWN && + service_type != type) { + continue; + } - DBG("device %p", device); + err = device_scan(device); + if (err == 0 || err == -EALREADY || err == -EINPROGRESS) { + success = TRUE; + } else { + last_err = err; + DBG("device %p err %d", device, err); + } + } - keyfile = __connman_storage_open(ident); - if (keyfile == NULL) + if (success == TRUE) return 0; - identifier = g_strdup_printf("device_%s", device->element.name); - if (identifier == NULL) - goto done; - - powered = g_key_file_get_boolean(keyfile, identifier, - "Powered", &error); - if (error == NULL) - device->powered_persistent = powered; - g_clear_error(&error); + return last_err; +} - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: - break; - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - val = g_key_file_get_integer(keyfile, identifier, - "ScanInterval", &error); - if (error == NULL && val > 0) - device->scan_interval = val; - g_clear_error(&error); - break; - } +int __connman_device_request_hidden_scan(struct connman_device *device, + const char *ssid, unsigned int ssid_len, + const char *identity, const char *passphrase, + void *user_data) +{ + DBG("device %p", device); -done: - g_free(identifier); + if (device == NULL || device->driver == NULL || + device->driver->scan_hidden == NULL) + return -EINVAL; - __connman_storage_close(ident, keyfile, FALSE); + if (device->scanning == TRUE) + return -EALREADY; - return 0; + return device->driver->scan_hidden(device, ssid, ssid_len, + identity, passphrase, user_data); } -static int device_save(struct connman_device *device) +connman_bool_t __connman_device_isfiltered(const char *devname) { - const char *ident = __connman_profile_active_ident(); - GKeyFile *keyfile; - gchar *identifier; - - DBG("device %p", device); + char **pattern; - keyfile = __connman_storage_open(ident); - if (keyfile == NULL) - return 0; - - identifier = g_strdup_printf("device_%s", device->element.name); - if (identifier == NULL) - goto done; + if (device_filter == NULL) + goto nodevice; - g_key_file_set_boolean(keyfile, identifier, - "Powered", device->powered_persistent); + for (pattern = device_filter; *pattern; pattern++) { + if (g_pattern_match_simple(*pattern, devname) == FALSE) { + DBG("ignoring device %s (match)", devname); + return TRUE; + } + } - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_TRANSPORT_IP: - break; - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - if (device->scan_interval > 0) - g_key_file_set_integer(keyfile, identifier, - "ScanInterval", device->scan_interval); - break; +nodevice: + if (g_pattern_match_simple("dummy*", devname) == TRUE) { + DBG("ignoring dummy networking devices"); + return TRUE; } -done: - g_free(identifier); + if (nodevice_filter == NULL) + return FALSE; - __connman_storage_close(ident, keyfile, TRUE); + for (pattern = nodevice_filter; *pattern; pattern++) { + if (g_pattern_match_simple(*pattern, devname) == TRUE) { + DBG("ignoring device %s (no match)", devname); + return TRUE; + } + } - return 0; + return FALSE; } -static struct connman_storage device_storage = { - .name = "device", - .priority = CONNMAN_STORAGE_PRIORITY_LOW, - .device_load = device_load, - .device_save = device_save, -}; - -int __connman_device_init(void) +int __connman_device_init(const char *device, const char *nodevice) { DBG(""); - connection = connman_dbus_get_connection(); + if (device != NULL) + device_filter = g_strsplit(device, ",", -1); - if (connman_storage_register(&device_storage) < 0) - connman_error("Failed to register device storage"); + if (nodevice != NULL) + nodevice_filter = g_strsplit(nodevice, ",", -1); - return connman_driver_register(&device_driver); + return 0; } void __connman_device_cleanup(void) { DBG(""); - connman_driver_unregister(&device_driver); - - connman_storage_unregister(&device_storage); - - dbus_connection_unref(connection); + g_strfreev(nodevice_filter); + g_strfreev(device_filter); }