X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fdevice.c;h=d06bffdaa78275e20500b9692593d64e22488c6e;hb=fe83d954f0a1a80e9e48008e0465edaaf0cd65ea;hp=813e3bcd6883c900036d22cc9ef57a8881934b08;hpb=ae3b3b3ea9df42424964cb18df943747367271eb;p=framework%2Fconnectivity%2Fconnman.git diff --git a/src/device.c b/src/device.c index 813e3bc..d06bffd 100644 --- a/src/device.c +++ b/src/device.c @@ -2,7 +2,7 @@ * * Connection Manager * - * Copyright (C) 2007-2010 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,97 +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 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 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; + 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) +static void clear_pending_trigger(struct connman_device *device) { - if (device->scan_timeout > 0) { - g_source_remove(device->scan_timeout); - device->scan_timeout = 0; + if (device->pending_timeout > 0) { + g_source_remove(device->pending_timeout); + device->pending_timeout = 0; } } -static void reset_scan_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); - } -} - -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); -} - -void connman_device_schedule_scan(struct connman_device *device) -{ - reset_scan_trigger(device); -} - static const char *type2description(enum connman_device_type type) { switch (type) { @@ -135,6 +92,9 @@ static const char *type2description(enum connman_device_type type) return "GPS"; case CONNMAN_DEVICE_TYPE_CELLULAR: return "Cellular"; + case CONNMAN_DEVICE_TYPE_GADGET: + return "Gadget"; + } return NULL; @@ -158,6 +118,9 @@ static const char *type2string(enum connman_device_type type) return "gps"; case CONNMAN_DEVICE_TYPE_CELLULAR: return "cellular"; + case CONNMAN_DEVICE_TYPE_GADGET: + return "gadget"; + } return NULL; @@ -182,23 +145,25 @@ enum connman_service_type __connman_device_get_service_type(struct connman_devic return CONNMAN_SERVICE_TYPE_BLUETOOTH; case CONNMAN_DEVICE_TYPE_CELLULAR: return CONNMAN_SERVICE_TYPE_CELLULAR; + case CONNMAN_DEVICE_TYPE_GADGET: + return CONNMAN_SERVICE_TYPE_GADGET; + } return CONNMAN_SERVICE_TYPE_UNKNOWN; } -static void powered_changed(struct connman_device *device) +static gboolean device_pending_reset(gpointer user_data) { - connman_dbus_property_changed_basic(device->element.path, - CONNMAN_DEVICE_INTERFACE, "Powered", - DBUS_TYPE_BOOLEAN, &device->powered); -} + struct connman_device *device = user_data; -static void blocked_changed(struct connman_device *device) -{ - connman_dbus_property_changed_basic(device->element.path, - CONNMAN_DEVICE_INTERFACE, "Blocked", - DBUS_TYPE_BOOLEAN, &device->blocked); + DBG("device %p", device); + + /* Power request timedout, reset power pending state. */ + device->pending_timeout = 0; + device->powered_pending = PENDING_NONE; + + return FALSE; } int __connman_device_enable(struct connman_device *device) @@ -210,25 +175,43 @@ int __connman_device_enable(struct connman_device *device) if (!device->driver || !device->driver->enable) return -EOPNOTSUPP; - if (device->powered_pending == TRUE) + /* There is an ongoing power disable request. */ + if (device->powered_pending == PENDING_DISABLE) + return -EBUSY; + + if (device->powered_pending == PENDING_ENABLE) return -EALREADY; - if (device->blocked == TRUE) - return -ENOLINK; + if (device->powered_pending == PENDING_NONE && device->powered == TRUE) + return -EALREADY; + + device->powered_pending = PENDING_ENABLE; err = device->driver->enable(device); - if (err < 0) { - if (err == -EINPROGRESS) - device->powered_pending = TRUE; - return err; + /* + * device gets enabled right away. + * Invoke the callback + */ + if (err == 0) { + connman_device_set_powered(device, TRUE); + goto done; } - device->powered_pending = TRUE; - device->powered = TRUE; - - __connman_technology_enable_device(device); - - return 0; + if (err == -EALREADY) { + /* If device is already powered, but connman is not updated */ + connman_device_set_powered(device, TRUE); + goto done; + } + /* + * 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; } int __connman_device_disable(struct connman_device *device) @@ -240,357 +223,64 @@ int __connman_device_disable(struct connman_device *device) if (!device->driver || !device->driver->disable) return -EOPNOTSUPP; - if (device->powered == FALSE) - return -ENOLINK; + /* Ongoing power enable request */ + if (device->powered_pending == PENDING_ENABLE) + return -EBUSY; - if (device->powered_pending == FALSE) + if (device->powered_pending == PENDING_DISABLE) return -EALREADY; - device->reconnect = FALSE; - - clear_scan_trigger(device); - - g_hash_table_remove_all(device->networks); - - err = device->driver->disable(device); - if (err < 0) { - if (err == -EINPROGRESS) - device->powered_pending = FALSE; - return err; - } - - device->powered_pending = FALSE; - device->powered = FALSE; - - __connman_technology_disable_device(device); - - return 0; -} - -static int set_powered(struct connman_device *device, connman_bool_t powered) -{ - DBG("device %p powered %d", device, powered); - - if (powered == TRUE) - return __connman_device_enable(device); - else - return __connman_device_disable(device); -} - -void __connman_device_list(DBusMessageIter *iter, void *user_data) -{ - __connman_element_list(NULL, CONNMAN_ELEMENT_TYPE_DEVICE, iter); -} - -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(DBusMessageIter *iter, void *user_data) -{ - struct connman_device *device = user_data; - - g_hash_table_foreach(device->networks, append_path, iter); -} - -static DBusMessage *get_properties(DBusConnection *conn, - DBusMessage *msg, void *data) -{ - struct connman_device *device = data; - DBusMessage *reply; - DBusMessageIter array, dict; - 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); - - connman_dbus_dict_open(&array, &dict); - - if (device->name != NULL) - connman_dbus_dict_append_basic(&dict, "Name", - DBUS_TYPE_STRING, &device->name); - - str = type2string(device->type); - if (str != NULL) - connman_dbus_dict_append_basic(&dict, "Type", - DBUS_TYPE_STRING, &str); - - if (device->address != NULL) - connman_dbus_dict_append_basic(&dict, "Address", - DBUS_TYPE_STRING, &device->address); - - if (device->interface != NULL) - connman_dbus_dict_append_basic(&dict, "Interface", - DBUS_TYPE_STRING, &device->interface); - - connman_dbus_dict_append_basic(&dict, "Powered", - DBUS_TYPE_BOOLEAN, &device->powered); - - connman_dbus_dict_append_basic(&dict, "Blocked", - DBUS_TYPE_BOOLEAN, &device->blocked); - - if (device->driver && device->driver->scan) - connman_dbus_dict_append_basic(&dict, "Scanning", - DBUS_TYPE_BOOLEAN, &device->scanning); - - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - break; - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - if (device->scan_interval > 0) - connman_dbus_dict_append_basic(&dict, "ScanInterval", - DBUS_TYPE_UINT16, &device->scan_interval); - - connman_dbus_dict_append_array(&dict, "Networks", - DBUS_TYPE_OBJECT_PATH, append_networks, device); - break; - } - - connman_dbus_dict_close(&array, &dict); - - return reply; -} - -static gboolean powered_timeout(gpointer user_data) -{ - struct connman_device *device = user_data; - - 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_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); - - reset_scan_trigger(device); - } - } else - return __connman_error_invalid_property(msg); - - 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: - 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 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; - - 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); + GSList *list; - device->registered = FALSE; + 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) -{ - 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; - __connman_technology_add_device(device); + device->driver = driver; - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - break; + __connman_technology_add_device(device); } - - if (__connman_udev_get_blocked(device->phyindex) == TRUE) - return 0; - - 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) @@ -599,34 +289,26 @@ static void remove_device(struct connman_device *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; - } - __connman_technology_remove_device(device); - unregister_interface(&device->element); - if (device->driver->remove) device->driver->remove(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) @@ -634,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; @@ -661,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; } @@ -680,50 +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); - - if (device->timeout > 0) { - g_source_remove(device->timeout); - device->timeout = 0; - } + DBG("device %p name %s", device, device->name); - clear_scan_trigger(device); - - 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); + 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); } /** @@ -739,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); @@ -749,54 +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->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->refcount = 1; device->type = type; device->name = g_strdup(type2description(device->type)); - device->mode = CONNMAN_DEVICE_MODE_UNKNOWN; - - device->powered_persistent = TRUE; 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_CELLULAR: - 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; } @@ -807,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; } @@ -821,47 +456,39 @@ 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); -const char *__connman_device_get_type(struct connman_device *device) -{ - return type2string(device->type); -} + if (__sync_fetch_and_sub(&device->refcount, 1) != 1) + return; -/** - * connman_device_get_type: - * @device: device structure - * - * Get type of device - */ -enum connman_device_type connman_device_get_type(struct connman_device *device) -{ - return device->type; + if (device->driver) { + device->driver->remove(device); + device->driver = NULL; + } + + device_list = g_slist_remove(device_list, device); + + device_destruct(device); } -/** - * connman_device_get_name: - * @device: device structure - * - * Get unique name of device - */ -const char *connman_device_get_name(struct connman_device *device) +const char *__connman_device_get_type(struct connman_device *device) { - return device->element.name; + return type2string(device->type); } /** - * connman_device_get_path: + * connman_device_get_type: * @device: device structure * - * Get path name of device + * Get type of device */ -const char *connman_device_get_path(struct connman_device *device) +enum connman_device_type connman_device_get_type(struct connman_device *device) { - return device->element.path; + return device->type; } /** @@ -873,7 +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; + device->index = index; } /** @@ -884,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) @@ -902,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) @@ -926,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 @@ -945,36 +563,12 @@ 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_powered: * @device: device structure * @powered: powered state @@ -984,85 +578,40 @@ enum connman_device_mode connman_device_get_mode(struct connman_device *device) int connman_device_set_powered(struct connman_device *device, connman_bool_t powered) { - DBG("driver %p powered %d", device, powered); + enum connman_service_type type; - 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; - } + DBG("driver %p powered %d", device, powered); - if (device->powered == powered) { - device->powered_pending = powered; + if (device->powered == powered) return -EALREADY; - } - if (powered == TRUE) - __connman_device_enable(device); - else - __connman_device_disable(device); + clear_pending_trigger(device); - device->powered = powered; - device->powered_pending = powered; + device->powered_pending = PENDING_NONE; - if (device->powered == TRUE) - __connman_technology_enable_device(device); - else - __connman_technology_disable_device(device); + device->powered = powered; - if (device->offlinemode == TRUE && powered == TRUE) { - powered_changed(device); - return connman_device_set_powered(device, FALSE); - } + type = __connman_device_get_service_type(device); - if (device->registered == FALSE) + if (device->powered == FALSE) { + __connman_technology_disabled(type); return 0; + } - powered_changed(device); - - if (powered == FALSE) - return 0; + __connman_technology_enabled(type); - reset_scan_trigger(device); + connman_device_set_disconnected(device, FALSE); + device->scanning = FALSE; - if (device->driver->scan) + if (device->driver && device->driver->scan_fast) + device->driver->scan_fast(device); + else if (device->driver && 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; - - blocked_changed(device); - - 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); -} - -int __connman_device_scan(struct connman_device *device) +static int device_scan(struct connman_device *device) { if (!device->driver || !device->driver->scan) return -EOPNOTSUPP; @@ -1070,44 +619,9 @@ int __connman_device_scan(struct connman_device *device) if (device->powered == FALSE) return -ENOLINK; - reset_scan_trigger(device); - return device->driver->scan(device); } -int __connman_device_enable_persistent(struct connman_device *device) -{ - int err; - - DBG("device %p", device); - - device->powered_persistent = TRUE; - - __connman_storage_save_device(device); - - err = __connman_device_enable(device); - if (err == 0 || err == -EINPROGRESS) { - if (__connman_profile_get_offlinemode() == TRUE) { - device->offlinemode = FALSE; - __connman_profile_set_offlinemode(FALSE, FALSE); - } - - } - - return err; -} - -int __connman_device_disable_persistent(struct connman_device *device) -{ - DBG("device %p", device); - - device->powered_persistent = FALSE; - - __connman_storage_save_device(device); - - return __connman_device_disable(device); -} - int __connman_device_disconnect(struct connman_device *device) { GHashTableIter iter; @@ -1122,7 +636,7 @@ 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) { + if (connman_network_get_connecting(network) == TRUE) { /* * Skip network in the process of connecting. * This is a workaround for WiFi networks serviced @@ -1133,7 +647,7 @@ int __connman_device_disconnect(struct connman_device *device) * will fail. There is nothing to be gained by * removing the network here anyway. */ - connman_warn("Skipping disconnect of %s", + connman_warn("Skipping disconnect of %s, network is connecting.", connman_network_get_identifier(network)); continue; } @@ -1144,6 +658,14 @@ int __connman_device_disconnect(struct connman_device *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) { @@ -1175,11 +697,17 @@ void __connman_device_cleanup_networks(struct connman_device *device) remove_unavailable_network, NULL); } -static void scanning_changed(struct connman_device *device) +connman_bool_t connman_device_get_scanning(struct connman_device *device) +{ + return device->scanning; +} + +void connman_device_reset_scanning(struct connman_device *device) { - connman_dbus_property_changed_basic(device->element.path, - CONNMAN_DEVICE_INTERFACE, "Scanning", - DBUS_TYPE_BOOLEAN, &device->scanning); + device->scanning = FALSE; + + g_hash_table_foreach(device->networks, + mark_network_available, NULL); } /** @@ -1202,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); @@ -1215,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(); @@ -1238,22 +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: - 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; } @@ -1290,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; } /** @@ -1313,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; } /** @@ -1374,31 +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); if (identifier == NULL) return -EINVAL; - switch (device->mode) { - case CONNMAN_DEVICE_MODE_UNKNOWN: - return -EINVAL; - case CONNMAN_DEVICE_MODE_NETWORK_SINGLE: - case CONNMAN_DEVICE_MODE_NETWORK_MULTIPLE: - break; - } + connman_network_ref(network); __connman_network_set_device(network, device); - err = connman_element_register((struct connman_element *) network, - &device->element); - if (err < 0) { - __connman_network_set_device(network, NULL); - return err; - } - - g_hash_table_insert(device->networks, g_strdup(identifier), + g_hash_table_replace(device->networks, g_strdup(identifier), network); return 0; @@ -1427,10 +887,16 @@ 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; @@ -1452,16 +918,12 @@ void __connman_device_set_network(struct connman_device *device, if (device->network == network) return; - if (device->network != NULL) - connman_network_unref(device->network); - 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; @@ -1482,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 @@ -1490,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); } /** @@ -1505,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); } /** @@ -1533,182 +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_profile(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: - 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_profile(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_profile(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: - 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_profile(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); }