X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=src%2Fdevice.c;h=377ef47ebaa34a7b7912630b0e1b3c8932f6896e;hb=e5cb500cd0a676f693b1503ac59eae08fe0c05c2;hp=5325ed52c0037b1d4afbea0272aa9d6b31f36024;hpb=8c12ec683a443b72c600751e3496a790bade6981;p=platform%2Fupstream%2Fconnman.git diff --git a/src/device.c b/src/device.c old mode 100644 new mode 100755 index 5325ed5..377ef47 --- a/src/device.c +++ b/src/device.c @@ -2,7 +2,7 @@ * * Connection Manager * - * Copyright (C) 2007-2012 Intel Corporation. All rights reserved. + * Copyright (C) 2007-2014 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 @@ -27,6 +27,7 @@ #include #include #include +#include #include #include #include @@ -37,6 +38,10 @@ static GSList *device_list = NULL; static gchar **device_filter = NULL; static gchar **nodevice_filter = NULL; +#if defined TIZEN_EXT +static DBusConnection *connection; +#endif + enum connman_pending_type { PENDING_NONE = 0, PENDING_ENABLE = 1, @@ -47,18 +52,17 @@ struct connman_device { int refcount; enum connman_device_type type; enum connman_pending_type powered_pending; /* Indicates a pending - enable/disable request */ - connman_bool_t powered; - connman_bool_t scanning; - connman_bool_t disconnected; - connman_bool_t reconnect; + * enable/disable + * request + */ + bool powered; + bool scanning[MAX_CONNMAN_SERVICE_TYPES]; char *name; char *node; char *address; char *interface; char *ident; char *path; - char *devname; int index; guint pending_timeout; @@ -68,10 +72,39 @@ struct connman_device { char *last_network; struct connman_network *network; GHashTable *networks; +#if defined TIZEN_EXT + time_t last_user_selection_time; + char *last_user_selection_ident; + char *last_connected_ident; + GList *pending_reply_list; /* List of DBusMessage* for async reply to multiple + * device power dbus calls, which are made before + * connman_device_set_powered(). + */ + int max_scan_ssids; + bool is_5_0_ghz_supported; + unsigned int mac_policy; + unsigned int preassoc_mac_policy; + unsigned int random_mac_lifetime; +#endif }; +#if defined TIZEN_EXT +static void __clear_pending_trigger(gpointer data, gpointer user_data) +{ + DBusMessage *msg = (DBusMessage *)data; + dbus_message_unref(msg); +} +#endif + static void clear_pending_trigger(struct connman_device *device) { +#if defined TIZEN_EXT + if (device->pending_reply_list) { + g_list_foreach(device->pending_reply_list, __clear_pending_trigger, NULL); + g_list_free(device->pending_reply_list); + device->pending_reply_list = NULL; + } +#endif if (device->pending_timeout > 0) { g_source_remove(device->pending_timeout); device->pending_timeout = 0; @@ -88,8 +121,6 @@ static const char *type2description(enum connman_device_type type) return "Ethernet"; case CONNMAN_DEVICE_TYPE_WIFI: return "Wireless"; - case CONNMAN_DEVICE_TYPE_WIMAX: - return "WiMAX"; case CONNMAN_DEVICE_TYPE_BLUETOOTH: return "Bluetooth"; case CONNMAN_DEVICE_TYPE_GPS: @@ -114,8 +145,6 @@ static const char *type2string(enum connman_device_type type) return "ethernet"; case CONNMAN_DEVICE_TYPE_WIFI: return "wifi"; - case CONNMAN_DEVICE_TYPE_WIMAX: - return "wimax"; case CONNMAN_DEVICE_TYPE_BLUETOOTH: return "bluetooth"; case CONNMAN_DEVICE_TYPE_GPS: @@ -130,7 +159,8 @@ static const char *type2string(enum connman_device_type type) return NULL; } -enum connman_service_type __connman_device_get_service_type(struct connman_device *device) +enum connman_service_type __connman_device_get_service_type( + struct connman_device *device) { enum connman_device_type type = connman_device_get_type(device); @@ -143,8 +173,6 @@ enum connman_service_type __connman_device_get_service_type(struct connman_devic return CONNMAN_SERVICE_TYPE_ETHERNET; case CONNMAN_DEVICE_TYPE_WIFI: return CONNMAN_SERVICE_TYPE_WIFI; - case CONNMAN_DEVICE_TYPE_WIMAX: - return CONNMAN_SERVICE_TYPE_WIMAX; case CONNMAN_DEVICE_TYPE_BLUETOOTH: return CONNMAN_SERVICE_TYPE_BLUETOOTH; case CONNMAN_DEVICE_TYPE_CELLULAR: @@ -157,12 +185,63 @@ enum connman_service_type __connman_device_get_service_type(struct connman_devic return CONNMAN_SERVICE_TYPE_UNKNOWN; } +static bool device_has_service_type(struct connman_device *device, + enum connman_service_type service_type) +{ + enum connman_service_type device_service_type = + __connman_device_get_service_type(device); + + /* + * For devices whose device_service_type is unknown we should + * allow to decide whether they support specific service_type + * by themself. + */ + if (device_service_type == CONNMAN_SERVICE_TYPE_UNKNOWN) + return true; + +#if defined TIZEN_EXT_WIFI_MESH + if (device_service_type == CONNMAN_SERVICE_TYPE_MESH) + return service_type != CONNMAN_SERVICE_TYPE_MESH; +#endif + + if (device_service_type == CONNMAN_SERVICE_TYPE_WIFI) { + return service_type == CONNMAN_SERVICE_TYPE_WIFI || + service_type == CONNMAN_SERVICE_TYPE_P2P; + } + + return service_type == device_service_type; +} + +#if defined TIZEN_EXT +static void __device_pending_reset(gpointer data, gpointer user_data) +{ + DBusMessage *msg = (DBusMessage *)data; + DBusMessage *reply; + + reply = __connman_error_failed(msg, ETIMEDOUT); + if (reply) + g_dbus_send_message(connection, reply); + + dbus_message_unref(msg); +} +#endif + static gboolean device_pending_reset(gpointer user_data) { struct connman_device *device = user_data; DBG("device %p", device); +#if defined TIZEN_EXT + DBusMessage *reply; + + /* Power request timed out, send ETIMEDOUT. */ + if (device->pending_reply_list) { + g_list_foreach(device->pending_reply_list, __device_pending_reset, NULL); + g_list_free(device->pending_reply_list); + device->pending_reply_list = NULL; + } +#endif /* Power request timedout, reset power pending state. */ device->pending_timeout = 0; device->powered_pending = PENDING_NONE; @@ -184,11 +263,17 @@ int __connman_device_enable(struct connman_device *device) return -EBUSY; if (device->powered_pending == PENDING_ENABLE) - return -EALREADY; + return -EINPROGRESS; - if (device->powered_pending == PENDING_NONE && device->powered == TRUE) + if (device->powered_pending == PENDING_NONE && device->powered) return -EALREADY; + if (device->index > 0) { + err = connman_inet_ifup(device->index); + if (err < 0 && err != -EALREADY) + return err; + } + device->powered_pending = PENDING_ENABLE; err = device->driver->enable(device); @@ -197,22 +282,29 @@ int __connman_device_enable(struct connman_device *device) * Invoke the callback */ if (err == 0) { - connman_device_set_powered(device, TRUE); + connman_device_set_powered(device, true); goto done; } if (err == -EALREADY) { /* If device is already powered, but connman is not updated */ - connman_device_set_powered(device, TRUE); + connman_device_set_powered(device, true); +#ifdef TIZEN_EXT + if (device->type == CONNMAN_DEVICE_TYPE_WIFI) { + device->driver->set_mac_policy(device, device->mac_policy); + device->driver->set_preassoc_mac_policy(device, device->preassoc_mac_policy); + device->driver->set_random_mac_lifetime(device, device->random_mac_lifetime); + } +#endif /* TIZEN_EXT */ 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 + * was successful. We set a 10 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_timeout = g_timeout_add_seconds(10, device_pending_reset, device); done: return err; @@ -224,35 +316,34 @@ int __connman_device_disable(struct connman_device *device) DBG("device %p", device); - if (!device->driver || !device->driver->disable) - return -EOPNOTSUPP; - /* Ongoing power enable request */ if (device->powered_pending == PENDING_ENABLE) return -EBUSY; if (device->powered_pending == PENDING_DISABLE) - return -EALREADY; + return -EINPROGRESS; - if (device->powered_pending == PENDING_NONE && device->powered == FALSE) + if (device->powered_pending == PENDING_NONE && !device->powered) return -EALREADY; device->powered_pending = PENDING_DISABLE; - device->reconnect = FALSE; if (device->network) { struct connman_service *service = connman_service_lookup_from_network(device->network); - if (service != NULL) + if (service) __connman_service_disconnect(service); else - connman_network_set_connected(device->network, FALSE); + connman_network_set_connected(device->network, false); } + if (!device->driver || !device->driver->disable) + return -EOPNOTSUPP; + err = device->driver->disable(device); if (err == 0 || err == -EALREADY) { - connman_device_set_powered(device, FALSE); + connman_device_set_powered(device, false); goto done; } @@ -269,10 +360,10 @@ static void probe_driver(struct connman_device_driver *driver) DBG("driver %p name %s", driver, driver->name); - for (list = device_list; list != NULL; list = list->next) { + for (list = device_list; list; list = list->next) { struct connman_device *device = list->data; - if (device->driver != NULL) + if (device->driver) continue; if (driver->type != device->type) @@ -307,7 +398,7 @@ static void remove_driver(struct connman_device_driver *driver) DBG("driver %p name %s", driver, driver->name); - for (list = device_list; list != NULL; list = list->next) { + for (list = device_list; list; list = list->next) { struct connman_device *device = list->data; if (device->driver == driver) @@ -315,12 +406,12 @@ static void remove_driver(struct connman_device_driver *driver) } } -connman_bool_t __connman_device_has_driver(struct connman_device *device) +bool __connman_device_has_driver(struct connman_device *device) { - if (device == NULL || device->driver == NULL) - return FALSE; + if (!device || !device->driver) + return false; - return TRUE; + return true; } static GSList *driver_list = NULL; @@ -384,22 +475,77 @@ static void device_destruct(struct connman_device *device) clear_pending_trigger(device); + g_hash_table_destroy(device->networks); + device->networks = NULL; + g_free(device->ident); g_free(device->node); g_free(device->name); g_free(device->address); 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; +#if defined TIZEN_EXT + g_free(device->last_user_selection_ident); + g_free(device->last_connected_ident); +#endif g_free(device); } +#if defined TIZEN_EXT +static void device_send_changed(const char *ifname, enum connman_service_type type, + const char *key, bool state) +{ + DBusMessage *signal; + DBusMessageIter iter, dict; + dbus_bool_t value = state; + const char *tech_path = connman_techonology_get_path(type); + + if (!tech_path || !ifname) + return; + + DBG("%s %s %s", ifname, key, state ? "TRUE" : "FALSE"); + + signal = dbus_message_new_signal(tech_path, + CONNMAN_TECHNOLOGY_INTERFACE, "DeviceChanged"); + if (!signal) + return; + + dbus_message_iter_init_append(signal, &iter); + + connman_dbus_dict_open(&iter, &dict); + connman_dbus_dict_append_basic(&dict, "Ifname", + DBUS_TYPE_STRING, + &ifname); + connman_dbus_dict_append_basic(&dict, key, + DBUS_TYPE_BOOLEAN, + &value); + connman_dbus_dict_close(&iter, &dict); + + dbus_connection_send(connection, signal, NULL); + dbus_message_unref(signal); +} + +static void __device_send_reply(gpointer data, gpointer user_data) +{ + DBusMessage *msg = (DBusMessage *)data; + g_dbus_send_reply(connection, msg, DBUS_TYPE_INVALID); + dbus_message_unref(msg); +} + +static void device_send_reply(struct connman_device *device) +{ + if (device->pending_reply_list) { + g_list_foreach(device->pending_reply_list, __device_send_reply, NULL); + g_list_free(device->pending_reply_list); + device->pending_reply_list = NULL; + } +} +#endif + /** * connman_device_create: * @node: device node name (for example an address) @@ -417,7 +563,7 @@ struct connman_device *connman_device_create(const char *node, DBG("node %s type %d", node, type); device = g_try_new0(struct connman_device, 1); - if (device == NULL) + if (!device) return NULL; DBG("device %p", device); @@ -526,15 +672,12 @@ int connman_device_get_index(struct connman_device *device) void connman_device_set_interface(struct connman_device *device, const char *interface) { - g_free(device->devname); - device->devname = g_strdup(interface); - g_free(device->interface); device->interface = g_strdup(interface); - if (device->name == NULL) { + if (!device->name) { const char *str = type2description(device->type); - if (str != NULL && device->interface != NULL) + if (str && device->interface) device->name = g_strdup_printf("%s (%s)", str, device->interface); } @@ -550,6 +693,11 @@ void connman_device_set_interface(struct connman_device *device, void connman_device_set_ident(struct connman_device *device, const char *ident) { +#ifdef TIZEN_EXT + if (device->ident && device->powered) + return; + else +#endif g_free(device->ident); device->ident = g_strdup(ident); } @@ -567,15 +715,21 @@ const char *connman_device_get_ident(struct connman_device *device) * Change power state of device */ int connman_device_set_powered(struct connman_device *device, - connman_bool_t powered) + bool powered) { + struct connman_device_scan_params params; enum connman_service_type type; + int i; - DBG("driver %p powered %d", device, powered); + DBG("device %p powered %d", device, powered); if (device->powered == powered) return -EALREADY; +#if defined TIZEN_EXT + device_send_reply(device); +#endif + clear_pending_trigger(device); device->powered_pending = PENDING_NONE; @@ -584,36 +738,53 @@ int connman_device_set_powered(struct connman_device *device, type = __connman_device_get_service_type(device); - if (device->powered == FALSE) { +#if defined TIZEN_EXT + device_send_changed(device->interface, type, "Powered", powered); + technology_save_device(device); +#endif + + if (!device->powered) { __connman_technology_disabled(type); return 0; } __connman_technology_enabled(type); - connman_device_set_disconnected(device, FALSE); - device->scanning = FALSE; + for (i = 0; i < MAX_CONNMAN_SERVICE_TYPES; i++) + device->scanning[i] = false; - if (device->driver && device->driver->scan) - device->driver->scan(device, NULL, 0, NULL, NULL, NULL); + if (device->driver && device->driver->scan) { + memset(¶ms, 0, sizeof(params)); + params.type = CONNMAN_SERVICE_TYPE_UNKNOWN; + + device->driver->scan(device, ¶ms); + } return 0; } -connman_bool_t connman_device_get_powered(struct connman_device *device) +bool connman_device_get_powered(struct connman_device *device) { return device->powered; } -static int device_scan(struct connman_device *device) +static int device_scan(enum connman_service_type type, + struct connman_device *device, + bool force_full_scan) { + struct connman_device_scan_params params; + if (!device->driver || !device->driver->scan) return -EOPNOTSUPP; - if (device->powered == FALSE) + if (!device->powered) return -ENOLINK; - return device->driver->scan(device, NULL, 0, NULL, NULL, NULL); + memset(¶ms, 0, sizeof(params)); + params.type = type; + params.force_full_scan = force_full_scan; + + return device->driver->scan(device, ¶ms); } int __connman_device_disconnect(struct connman_device *device) @@ -623,14 +794,12 @@ int __connman_device_disconnect(struct connman_device *device) DBG("device %p", device); - connman_device_set_disconnected(device, TRUE); - g_hash_table_iter_init(&iter, device->networks); - while (g_hash_table_iter_next(&iter, &key, &value) == TRUE) { + while (g_hash_table_iter_next(&iter, &key, &value)) { struct connman_network *network = value; - if (connman_network_get_connecting(network) == TRUE) { + if (connman_network_get_connecting(network)) { /* * Skip network in the process of connecting. * This is a workaround for WiFi networks serviced @@ -652,12 +821,209 @@ int __connman_device_disconnect(struct connman_device *device) return 0; } +int connman_device_reconnect_service(struct connman_device *device) +{ + DBG("device %p", device); + + __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO); + + return 0; +} + +#if defined TIZEN_EXT +bool connman_device_set_last_user_selection_time(struct connman_device *device, + time_t time) +{ + if (device->last_user_selection_time != time) { + device->last_user_selection_time = time; + return true; + } + + return false; +} + +time_t connman_device_get_last_user_selection_time(struct connman_device *device) +{ + return device->last_user_selection_time; +} + +bool connman_device_set_last_user_selection_ident(struct connman_device *device, + const char *ident) +{ + if (g_strcmp0(device->last_user_selection_ident, ident) != 0) { + g_free(device->last_user_selection_ident); + device->last_user_selection_ident = g_strdup(ident); + + return true; + } + + return false; +} + +const char *connman_device_get_last_user_selection_ident(struct connman_device *device) +{ + return device->last_user_selection_ident; +} + +bool connman_device_set_last_connected_ident(struct connman_device *device, + const char *ident) +{ + if (g_strcmp0(device->last_connected_ident, ident) != 0) { + g_free(device->last_connected_ident); + device->last_connected_ident = g_strdup(ident); + + return true; + } + + return false; +} + +const char *connman_device_get_last_connected_ident(struct connman_device *device) +{ + return device->last_connected_ident; +} + +void connman_device_save_last_user_selection(struct connman_device *device) +{ + GKeyFile *keyfile; + gchar *get_str; + gchar *selection_str; + + keyfile = __connman_storage_load_ins(); + + selection_str = g_strdup_printf("%s:%ld", + device->last_user_selection_ident, device->last_user_selection_time); + + if (!keyfile) { + keyfile = g_key_file_new(); + + g_key_file_set_string(keyfile, device->interface, "LastUserSelection", selection_str); + DBG("%s", selection_str); + __connman_storage_save_ins(keyfile); + + } else { + get_str = g_key_file_get_string(keyfile, device->interface, "LastUserSelection", NULL); + if (!get_str || g_strcmp0(get_str, selection_str) != 0) { + g_key_file_set_string(keyfile, device->interface, "LastUserSelection", selection_str); + DBG("%s -> %s", get_str, selection_str); + __connman_storage_save_ins(keyfile); + } + + g_free(get_str); + } + + g_free(selection_str); + g_key_file_free(keyfile); +} + +void connman_device_load_last_user_selection(struct connman_device *device) +{ + GKeyFile *keyfile; + gchar *get_str; + char **selection_str; + + keyfile = __connman_storage_load_ins(); + if (!keyfile) + return; + + get_str = g_key_file_get_string(keyfile, device->interface, "LastUserSelection", NULL); + if (get_str) { + selection_str = g_strsplit(get_str, ":", 0); + if (selection_str) { + time_t ref_time; + struct tm* timeinfo; + time_t last_user_selection_time; + + /* Only events that occur within 8 hours are counted. */ + ref_time = time(NULL); + timeinfo = localtime(&ref_time); + timeinfo->tm_hour -= 8; + ref_time = mktime(timeinfo); + + last_user_selection_time = strtol(selection_str[1], NULL, 10); + + if (last_user_selection_time > ref_time) { + if (g_strcmp0(selection_str[0], device->last_user_selection_ident) != 0) { + g_free(device->last_user_selection_ident); + device->last_user_selection_ident = g_strdup(selection_str[0]); + } + + device->last_user_selection_time = last_user_selection_time; + + DBG("%s %ld", device->last_user_selection_ident, device->last_user_selection_time); + } + + g_strfreev(selection_str); + } + + g_free(get_str); + } + + g_key_file_free(keyfile); +} + +void connman_device_save_last_connected(struct connman_device *device) +{ + GKeyFile *keyfile; + gchar *get_str; + + if (!device->last_connected_ident) + return; + + keyfile = __connman_storage_load_ins(); + + if (!keyfile) { + keyfile = g_key_file_new(); + + g_key_file_set_string(keyfile, device->interface, "LastConnected", device->last_connected_ident); + DBG("%s", device->last_connected_ident); + __connman_storage_save_ins(keyfile); + + } else { + get_str = g_key_file_get_string(keyfile, device->interface, "LastConnected", NULL); + if (!get_str || g_strcmp0(get_str, device->last_connected_ident) != 0) { + g_key_file_set_string(keyfile, device->interface, "LastConnected", device->last_connected_ident); + DBG("%s -> %s", get_str, device->last_connected_ident); + __connman_storage_save_ins(keyfile); + } + + g_free(get_str); + } + + g_key_file_free(keyfile); +} + +void connman_device_load_last_connected(struct connman_device *device) +{ + GKeyFile *keyfile; + gchar *get_str; + + keyfile = __connman_storage_load_ins(); + if (!keyfile) + return; + + get_str = g_key_file_get_string(keyfile, device->interface, "LastConnected", NULL); + if (get_str) { + if (g_strcmp0(get_str, device->last_connected_ident) != 0) { + g_free(device->last_connected_ident); + device->last_connected_ident = g_strdup(get_str); + } + + DBG("%s", device->last_connected_ident); + + g_free(get_str); + } + + g_key_file_free(keyfile); +} +#endif + static void mark_network_available(gpointer key, gpointer value, gpointer user_data) { struct connman_network *network = value; - connman_network_set_available(network, TRUE); + connman_network_set_available(network, true); } static void mark_network_unavailable(gpointer key, gpointer value, @@ -665,11 +1031,11 @@ static void mark_network_unavailable(gpointer key, gpointer value, { struct connman_network *network = value; - if (connman_network_get_connected(network) == TRUE || - connman_network_get_connecting(network) == TRUE) + if (connman_network_get_connected(network) || + connman_network_get_connecting(network)) return; - connman_network_set_available(network, FALSE); + connman_network_set_available(network, false); } static gboolean remove_unavailable_network(gpointer key, gpointer value, @@ -677,10 +1043,11 @@ static gboolean remove_unavailable_network(gpointer key, gpointer value, { struct connman_network *network = value; - if (connman_network_get_connected(network) == TRUE) + if (connman_network_get_connected(network) || + connman_network_get_connecting(network)) return FALSE; - if (connman_network_get_available(network) == TRUE) + if (connman_network_get_available(network)) return FALSE; return TRUE; @@ -692,9 +1059,19 @@ void __connman_device_cleanup_networks(struct connman_device *device) remove_unavailable_network, NULL); } -connman_bool_t connman_device_get_scanning(struct connman_device *device) +bool connman_device_get_scanning(struct connman_device *device, + enum connman_service_type type) { - return device->scanning; + int i; + + if (type != CONNMAN_SERVICE_TYPE_UNKNOWN) + return device->scanning[type]; + + for (i = 0; i < MAX_CONNMAN_SERVICE_TYPES; i++) + if (device->scanning[i]) + return true; + + return false; } void connman_device_reset_scanning(struct connman_device *device) @@ -711,19 +1088,22 @@ void connman_device_reset_scanning(struct connman_device *device) * Change scanning state of device */ int connman_device_set_scanning(struct connman_device *device, - connman_bool_t scanning) + enum connman_service_type type, bool scanning) { DBG("device %p scanning %d", device, scanning); if (!device->driver || !device->driver->scan) return -EINVAL; - if (device->scanning == scanning) + if (type == CONNMAN_SERVICE_TYPE_UNKNOWN) + return -EINVAL; + + if (device->scanning[type] == scanning) return -EALREADY; - device->scanning = scanning; + device->scanning[type] = scanning; - if (scanning == TRUE) { + if (scanning) { __connman_technology_scan_started(device); g_hash_table_foreach(device->networks, @@ -734,45 +1114,19 @@ int connman_device_set_scanning(struct connman_device *device, __connman_device_cleanup_networks(device); - __connman_technology_scan_stopped(device); - - __connman_service_auto_connect(); + __connman_technology_scan_stopped(device, type); - return 0; -} + __connman_service_auto_connect(CONNMAN_SERVICE_CONNECT_REASON_AUTO); -/** - * connman_device_set_disconnected: - * @device: device structure - * @disconnected: disconnected state - * - * Change disconnected state of device (only for device with networks) - */ -int connman_device_set_disconnected(struct connman_device *device, - connman_bool_t disconnected) -{ - DBG("device %p disconnected %d", device, disconnected); - - if (device->disconnected == disconnected) - return -EALREADY; - - device->disconnected = disconnected; +#if defined TIZEN_EXT_WIFI_MESH + if (type == CONNMAN_SERVICE_TYPE_MESH) + __connman_mesh_auto_connect(); +#endif return 0; } /** - * connman_device_get_disconnected: - * @device: device structure - * - * Get device disconnected state - */ -connman_bool_t connman_device_get_disconnected(struct connman_device *device) -{ - return device->disconnected; -} - -/** * connman_device_set_string: * @device: device structure * @key: unique identifier @@ -785,16 +1139,21 @@ int connman_device_set_string(struct connman_device *device, { DBG("device %p key %s value %s", device, key, value); - if (g_str_equal(key, "Address") == TRUE) { + if (g_str_equal(key, "Address")) { +#ifdef TIZEN_EXT + if (device->address && device->powered) + return 0; + else +#endif g_free(device->address); device->address = g_strdup(value); - } else if (g_str_equal(key, "Name") == TRUE) { + } else if (g_str_equal(key, "Name")) { g_free(device->name); device->name = g_strdup(value); - } else if (g_str_equal(key, "Node") == TRUE) { + } else if (g_str_equal(key, "Node")) { g_free(device->node); device->node = g_strdup(value); - } else if (g_str_equal(key, "Path") == TRUE) { + } else if (g_str_equal(key, "Path")) { g_free(device->path); device->path = g_strdup(value); } else { @@ -814,17 +1173,20 @@ int connman_device_set_string(struct connman_device *device, const char *connman_device_get_string(struct connman_device *device, const char *key) { +#if defined TIZEN_EXT + if (!simplified_log) +#endif DBG("device %p key %s", device, key); - if (g_str_equal(key, "Address") == TRUE) + if (g_str_equal(key, "Address")) return device->address; - else if (g_str_equal(key, "Name") == TRUE) + else if (g_str_equal(key, "Name")) return device->name; - else if (g_str_equal(key, "Node") == TRUE) + else if (g_str_equal(key, "Node")) return device->node; - else if (g_str_equal(key, "Interface") == TRUE) + else if (g_str_equal(key, "Interface")) return device->interface; - else if (g_str_equal(key, "Path") == TRUE) + else if (g_str_equal(key, "Path")) return device->path; return NULL; @@ -841,10 +1203,12 @@ int connman_device_add_network(struct connman_device *device, struct connman_network *network) { const char *identifier = connman_network_get_identifier(network); - +#if defined TIZEN_EXT + if (!simplified_log) +#endif DBG("device %p network %p", device, network); - if (identifier == NULL) + if (!identifier) return -EINVAL; connman_network_ref(network); @@ -867,11 +1231,62 @@ int connman_device_add_network(struct connman_device *device, struct connman_network *connman_device_get_network(struct connman_device *device, const char *identifier) { +#if defined TIZEN_EXT + if (!simplified_log) +#endif DBG("device %p identifier %s", device, identifier); return g_hash_table_lookup(device->networks, identifier); } +#if defined TIZEN_EXT +struct connman_network *connman_device_get_default_network( + struct connman_device *device) +{ + return device->network; +} + +void connman_device_set_pending_reply(struct connman_device *device, + DBusMessage *msg) +{ + device->pending_reply_list = g_list_prepend(device->pending_reply_list, dbus_message_ref(msg)); +} + +void connman_device_send_connected_signal(struct connman_device *device, + bool connected) +{ + enum connman_service_type type; + + if (!device) + return; + + type = __connman_device_get_service_type(device); + device_send_changed(device->interface, type, "Connected", connected); +} + +void connman_device_set_max_scan_ssids(struct connman_device *device, + int max_scan_ssids) +{ + device->max_scan_ssids = max_scan_ssids; +} + +int connman_device_get_max_scan_ssids(struct connman_device *device) +{ + return device->max_scan_ssids; +} + +void connman_device_set_wifi_5ghz_supported(struct connman_device *device, + bool is_5_0_ghz_supported) +{ + device->is_5_0_ghz_supported = is_5_0_ghz_supported; +} + +bool connman_device_get_wifi_5ghz_supported(struct connman_device *device) +{ + return device->is_5_0_ghz_supported; +} +#endif + /** * connman_device_remove_network: * @device: device structure @@ -886,7 +1301,7 @@ int connman_device_remove_network(struct connman_device *device, DBG("device %p network %p", device, network); - if (network == NULL) + if (!network) return 0; identifier = connman_network_get_identifier(network); @@ -895,23 +1310,18 @@ int connman_device_remove_network(struct connman_device *device, 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 == NULL) + if (!device) return; if (device->network == network) return; - if (network != NULL) { + if (network) { name = connman_network_get_string(network, "Name"); g_free(device->last_network); device->last_network = g_strdup(name); @@ -925,26 +1335,14 @@ void __connman_device_set_network(struct connman_device *device, } } -void __connman_device_set_reconnect(struct connman_device *device, - connman_bool_t reconnect) -{ - device->reconnect = reconnect; -} - -connman_bool_t __connman_device_get_reconnect( - struct connman_device *device) -{ - return device->reconnect; -} - -static gboolean match_driver(struct connman_device *device, +static bool 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 true; - return FALSE; + return false; } /** @@ -959,13 +1357,13 @@ int connman_device_register(struct connman_device *device) DBG("device %p name %s", device, device->name); - if (device->driver != NULL) + if (device->driver) return -EALREADY; for (list = driver_list; list; list = list->next) { struct connman_device_driver *driver = list->data; - if (match_driver(device, driver) == FALSE) + if (!match_driver(device, driver)) continue; DBG("driver %p name %s", driver, driver->name); @@ -976,7 +1374,7 @@ int connman_device_register(struct connman_device *device) } } - if (device->driver == NULL) + if (!device->driver) return 0; return __connman_technology_add_device(device); @@ -992,7 +1390,7 @@ void connman_device_unregister(struct connman_device *device) { DBG("device %p name %s", device, device->name); - if (device->driver == NULL) + if (!device->driver) return; remove_device(device); @@ -1026,7 +1424,7 @@ struct connman_device *__connman_device_find_device( { GSList *list; - for (list = device_list; list != NULL; list = list->next) { + for (list = device_list; list; list = list->next) { struct connman_device *device = list->data; enum connman_service_type service_type = __connman_device_get_service_type(device); @@ -1040,6 +1438,19 @@ struct connman_device *__connman_device_find_device( return NULL; } +struct connman_device *connman_device_find_by_index(int index) +{ + GSList *list; + + for (list = device_list; list; list = list->next) { + struct connman_device *device = list->data; + if (device->index == index) + return device; + } + + return NULL; +} + /** * connman_device_set_regdom * @device: device structure @@ -1050,10 +1461,10 @@ struct connman_device *__connman_device_find_device( int connman_device_set_regdom(struct connman_device *device, const char *alpha2) { - if (device->driver == NULL || device->driver->set_regdom == NULL) + if (!device->driver || !device->driver->set_regdom) return -ENOTSUP; - if (device->powered == FALSE) + if (!device->powered) return -EINVAL; return device->driver->set_regdom(device, alpha2); @@ -1072,9 +1483,25 @@ void connman_device_regdom_notify(struct connman_device *device, __connman_technology_notify_regdom_by_device(device, result, alpha2); } -int __connman_device_request_scan(enum connman_service_type type) +#if defined TIZEN_EXT +static int device_specific_scan(enum connman_service_type type, + struct connman_device *device, + int scan_type, GSList *specific_scan_list) { - connman_bool_t success = FALSE; + if (!device->driver || !device->driver->specific_scan) + return -EOPNOTSUPP; + + if (!device->powered) + return -ENOLINK; + + return device->driver->specific_scan(type, device, scan_type, + specific_scan_list, NULL); +} + +int __connman_device_request_specific_scan(enum connman_service_type type, + const char *ifname, int scan_type, GSList *specific_scan_list) +{ + bool success = false; int last_err = -ENOSYS; GSList *list; int err; @@ -1090,54 +1517,381 @@ int __connman_device_request_scan(enum connman_service_type type) case CONNMAN_SERVICE_TYPE_GADGET: return -EOPNOTSUPP; case CONNMAN_SERVICE_TYPE_WIFI: - case CONNMAN_SERVICE_TYPE_WIMAX: + case CONNMAN_SERVICE_TYPE_P2P: +#if defined TIZEN_EXT_WIFI_MESH + case CONNMAN_SERVICE_TYPE_MESH: +#endif break; } - for (list = device_list; list != NULL; list = list->next) { + for (list = device_list; list; list = list->next) { struct connman_device *device = list->data; enum connman_service_type service_type = __connman_device_get_service_type(device); - if (service_type != CONNMAN_SERVICE_TYPE_UNKNOWN && - service_type != type) { + if (service_type != CONNMAN_SERVICE_TYPE_UNKNOWN) { + if (type == CONNMAN_SERVICE_TYPE_P2P) { + if (service_type != CONNMAN_SERVICE_TYPE_WIFI) + continue; + } else if (service_type != type) + continue; + } + + if (ifname && g_strcmp0(device->interface, ifname) != 0) continue; + + err = device_specific_scan(type, device, scan_type, specific_scan_list); + if (err == 0 || err == -EINPROGRESS) { + success = true; + } else { + last_err = err; + DBG("device %p err %d", device, err); } + } + + if (success) + return 0; + + return last_err; +} + +int connman_device_request_device_scan(enum connman_service_type type, + const char * ifname, bool force_full_scan) +{ + bool success = false; + int last_err = -ENOSYS; + GSList *list; + int err; + + 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_P2P: +#if defined TIZEN_EXT_WIFI_MESH + case CONNMAN_SERVICE_TYPE_MESH: +#endif + break; + } + + for (list = device_list; list; list = list->next) { + struct connman_device *device = list->data; + + if (!device_has_service_type(device, type)) + continue; + + if (g_strcmp0(device->interface, ifname) != 0) + continue; + + err = device_scan(type, device, force_full_scan); + + if (err == 0 || err == -EINPROGRESS) { + success = true; + } else { + last_err = err; + DBG("device %p err %d", device, err); + } + break; + } + + if (success) + return 0; + + return last_err; +} + +#if defined TIZEN_EXT_WIFI_MESH +static int device_abort_scan(enum connman_service_type type, + struct connman_device *device) +{ + if (!device->driver || !device->driver->scan) + return -EOPNOTSUPP; + + if (!device->powered) + return -ENOLINK; + + return device->driver->abort_scan(type, device); +} + +int __connman_device_abort_scan(enum connman_service_type type) +{ + GSList *list; + int err = -EINVAL; + + if (type != CONNMAN_SERVICE_TYPE_MESH) + return -EINVAL; + + for (list = device_list; list; list = list->next) { + struct connman_device *device = list->data; + enum connman_service_type service_type = + __connman_device_get_service_type(device); + + if (service_type != CONNMAN_SERVICE_TYPE_UNKNOWN) { + if (type == CONNMAN_SERVICE_TYPE_MESH) + if (service_type != CONNMAN_SERVICE_TYPE_WIFI) + continue; + + if (!device->scanning) { + err = -EEXIST; + continue; + } + + err = device_abort_scan(type, device); + } + } + return err; +} + +static int device_mesh_specific_scan(enum connman_service_type type, + struct connman_device *device, const char *name, + unsigned int freq) +{ + if (!device->driver || !device->driver->mesh_specific_scan) + return -EOPNOTSUPP; + + if (!device->powered) + return -ENOLINK; + + return device->driver->mesh_specific_scan(type, device, name, freq, NULL); +} + +int __connman_device_request_mesh_specific_scan(enum connman_service_type type, + const char *name, + unsigned int freq) +{ + bool success = false; + int last_err = -ENOSYS; + GSList *list; + int err; + + if (type != CONNMAN_SERVICE_TYPE_MESH) + return -EINVAL; + + for (list = device_list; list; list = list->next) { + struct connman_device *device = list->data; + enum connman_service_type service_type = + __connman_device_get_service_type(device); + + if (service_type != CONNMAN_SERVICE_TYPE_UNKNOWN) { + if (type == CONNMAN_SERVICE_TYPE_MESH) + if (service_type != CONNMAN_SERVICE_TYPE_WIFI) + continue; + } + + err = device_mesh_specific_scan(type, device, name, freq); + if (err == 0 || err == -EALREADY || err == -EINPROGRESS) { + success = true; + } else { + last_err = err; + DBG("device %p err %d", device, err); + } + } + + if (success) + return 0; + + return last_err; +} +#endif /* TIZEN_EXT_WIFI_MESH */ +#endif + +static int connman_device_request_scan(enum connman_service_type type, + bool force_full_scan) +{ + bool success = false; + int last_err = -ENOSYS; + GSList *list; + int err; + + 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_P2P: +#if defined TIZEN_EXT_WIFI_MESH + case CONNMAN_SERVICE_TYPE_MESH: +#endif + break; + } + + for (list = device_list; list; list = list->next) { + struct connman_device *device = list->data; + + if (!device_has_service_type(device, type)) + continue; - err = device_scan(device); + err = device_scan(type, device, force_full_scan); +#if defined TIZEN_EXT + /* When Scan is already in progress then return Error so that + * wifi-manager can block the scan-done signal to be sent to + * application and start requested scan after scan already in progress + * is completed then notify to application about the scan event */ + if (err == 0 || err == -EINPROGRESS) { +#else if (err == 0 || err == -EALREADY || err == -EINPROGRESS) { - success = TRUE; +#endif + success = true; } else { last_err = err; DBG("device %p err %d", device, err); } } - if (success == TRUE) + if (success) return 0; return last_err; } +int __connman_device_request_scan(enum connman_service_type type) +{ + return connman_device_request_scan(type, false); +} + +int __connman_device_request_scan_full(enum connman_service_type type) +{ + return connman_device_request_scan(type, true); +} + 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) + const char *security, void *user_data) { + struct connman_device_scan_params params; + DBG("device %p", device); - if (device == NULL || device->driver == NULL || - device->driver->scan == NULL) + if (!device || !device->driver || + !device->driver->scan) return -EINVAL; - if (device->scanning == TRUE) - return -EALREADY; + params.type = CONNMAN_SERVICE_TYPE_UNKNOWN; + params.ssid = ssid; + params.ssid_len = ssid_len; + params.identity = identity; + params.passphrase = passphrase; + params.security = security; + params.user_data = user_data; - return device->driver->scan(device, ssid, ssid_len, - identity, passphrase, user_data); + return device->driver->scan(device, ¶ms); } +void __connman_device_stop_scan(enum connman_service_type type) +{ + GSList *list; + + for (list = device_list; list; list = list->next) { + struct connman_device *device = list->data; + + if (!device_has_service_type(device, type)) + continue; + + if (device->driver && device->driver->stop_scan) + device->driver->stop_scan(type, device); + } +} + +#if defined TIZEN_EXT +#define WIFI_MAC "/opt/etc/.mac.info" +#define MAC_ADDR_LEN 18 + +char *_get_wifi_addr(void) +{ + FILE *fp = NULL; + char* rv = 0; + char wifi_mac[MAC_ADDR_LEN + 1]; + char *str; + + fp = fopen(WIFI_MAC, "r"); + if (!fp){ + connman_error("[%s] not present", WIFI_MAC); + return NULL; + } + + rv = fgets(wifi_mac, MAC_ADDR_LEN, fp); + if (!rv) { + connman_error("Failed to get wifi mac address"); + fclose(fp); + return NULL; + } + + str = g_try_malloc0(MAC_ADDR_LEN); + if (!str) { + connman_error("memory allocation failed"); + fclose(fp); + return NULL; + } + + snprintf(str, MAC_ADDR_LEN, "%c%c:%c%c:%c%c:%c%c:%c%c:%c%c", + g_ascii_tolower(wifi_mac[0]), g_ascii_tolower(wifi_mac[1]), + g_ascii_tolower(wifi_mac[3]), g_ascii_tolower(wifi_mac[4]), + g_ascii_tolower(wifi_mac[6]), g_ascii_tolower(wifi_mac[7]), + g_ascii_tolower(wifi_mac[9]), g_ascii_tolower(wifi_mac[10]), + g_ascii_tolower(wifi_mac[12]), g_ascii_tolower(wifi_mac[13]), + g_ascii_tolower(wifi_mac[15]), g_ascii_tolower(wifi_mac[16])); + fclose(fp); + return str; +} + +char *_get_wifi_ident(void) +{ + FILE *fp = NULL; + char* rv = 0; + char wifi_mac[MAC_ADDR_LEN + 1]; + char *str; + + fp = fopen(WIFI_MAC, "r"); + if (!fp){ + connman_error("[%s] not present", WIFI_MAC); + return NULL; + } + + rv = fgets(wifi_mac, MAC_ADDR_LEN, fp); + if (!rv) { + connman_error("Failed to get wifi mac address"); + fclose(fp); + return NULL; + } + + str = g_try_malloc0(MAC_ADDR_LEN); + if (!str) { + connman_error("memory allocation failed"); + fclose(fp); + return NULL; + } + + snprintf(str, MAC_ADDR_LEN, "%c%c%c%c%c%c%c%c%c%c%c%c", + g_ascii_tolower(wifi_mac[0]), g_ascii_tolower(wifi_mac[1]), + g_ascii_tolower(wifi_mac[3]), g_ascii_tolower(wifi_mac[4]), + g_ascii_tolower(wifi_mac[6]), g_ascii_tolower(wifi_mac[7]), + g_ascii_tolower(wifi_mac[9]), g_ascii_tolower(wifi_mac[10]), + g_ascii_tolower(wifi_mac[12]), g_ascii_tolower(wifi_mac[13]), + g_ascii_tolower(wifi_mac[15]), g_ascii_tolower(wifi_mac[16])); + fclose(fp); + return str; +} +#endif + +#if defined TIZEN_EXT +char *index2ident(int index, const char *prefix) +#else static char *index2ident(int index, const char *prefix) +#endif { struct ifreq ifr; struct ether_addr eth; @@ -1166,7 +1920,7 @@ static char *index2ident(int index, const char *prefix) len = prefix ? strlen(prefix) + 18 : 18; - str = malloc(len); + str = g_malloc(len); if (!str) return NULL; @@ -1183,7 +1937,11 @@ static char *index2ident(int index, const char *prefix) return str; } +#if defined TIZEN_EXT +char *index2addr(int index) +#else static char *index2addr(int index) +#endif { struct ifreq ifr; struct ether_addr eth; @@ -1210,7 +1968,7 @@ static char *index2addr(int index) if (err < 0) return NULL; - str = malloc(18); + str = g_malloc(18); if (!str) return NULL; @@ -1237,10 +1995,10 @@ struct connman_device *connman_device_create_from_index(int index) return NULL; devname = connman_inet_ifname(index); - if (devname == NULL) + if (!devname) return NULL; - if (__connman_device_isfiltered(devname) == TRUE) { + if (__connman_device_isfiltered(devname)) { connman_info("Ignoring interface %s (filtered)", devname); g_free(devname); return NULL; @@ -1256,7 +2014,6 @@ struct connman_device *connman_device_create_from_index(int index) case CONNMAN_DEVICE_TYPE_ETHERNET: case CONNMAN_DEVICE_TYPE_GADGET: case CONNMAN_DEVICE_TYPE_WIFI: - case CONNMAN_DEVICE_TYPE_WIMAX: name = index2ident(index, ""); addr = index2addr(index); break; @@ -1264,12 +2021,12 @@ struct connman_device *connman_device_create_from_index(int index) case CONNMAN_DEVICE_TYPE_CELLULAR: case CONNMAN_DEVICE_TYPE_GPS: case CONNMAN_DEVICE_TYPE_VENDOR: - name = strdup(devname); + name = g_strdup(devname); break; } device = connman_device_create(name, type); - if (device == NULL) + if (!device) goto done; switch (type) { @@ -1282,7 +2039,6 @@ struct connman_device *connman_device_create_from_index(int index) ident = index2ident(index, NULL); break; case CONNMAN_DEVICE_TYPE_WIFI: - case CONNMAN_DEVICE_TYPE_WIMAX: ident = index2ident(index, NULL); break; case CONNMAN_DEVICE_TYPE_BLUETOOTH: @@ -1294,8 +2050,12 @@ struct connman_device *connman_device_create_from_index(int index) connman_device_set_index(device, index); connman_device_set_interface(device, devname); +#if defined TIZEN_EXT + connman_device_load_last_connected(device); + connman_device_load_last_user_selection(device); +#endif - if (ident != NULL) { + if (ident) { connman_device_set_ident(device, ident); g_free(ident); } @@ -1310,51 +2070,62 @@ done: return device; } -connman_bool_t __connman_device_isfiltered(const char *devname) +bool __connman_device_isfiltered(const char *devname) { char **pattern; char **blacklisted_interfaces; + bool match; - if (device_filter == NULL) + if (!device_filter) goto nodevice; - for (pattern = device_filter; *pattern; pattern++) { - if (g_pattern_match_simple(*pattern, devname) == FALSE) { - DBG("ignoring device %s (match)", devname); - return TRUE; + for (pattern = device_filter, match = false; *pattern; pattern++) { + if (g_pattern_match_simple(*pattern, devname)) { + match = true; + break; } } + if (!match) { + DBG("ignoring device %s (match)", devname); + return true; + } + nodevice: - if (g_pattern_match_simple("dummy*", devname) == TRUE) { + if (g_pattern_match_simple("dummy*", devname)) { DBG("ignoring dummy networking devices"); - return TRUE; + return true; } - if (nodevice_filter == NULL) + if (!nodevice_filter) goto list; for (pattern = nodevice_filter; *pattern; pattern++) { - if (g_pattern_match_simple(*pattern, devname) == TRUE) { + if (g_pattern_match_simple(*pattern, devname)) { DBG("ignoring device %s (no match)", devname); - return TRUE; + return true; } } list: + if (__connman_inet_isrootnfs_device(devname)) { + DBG("ignoring device %s (rootnfs)", devname); + return true; + } + blacklisted_interfaces = connman_setting_get_string_list("NetworkInterfaceBlacklist"); - if (blacklisted_interfaces == NULL) - return FALSE; + if (!blacklisted_interfaces) + return false; for (pattern = blacklisted_interfaces; *pattern; pattern++) { - if (g_str_has_prefix(devname, *pattern) == TRUE) { + if (g_str_has_prefix(devname, *pattern)) { DBG("ignoring device %s (blacklist)", devname); - return TRUE; + return true; } } - return FALSE; + return false; } static void cleanup_devices(void) @@ -1377,23 +2148,46 @@ static void cleanup_devices(void) interfaces = __connman_inet_get_running_interfaces(); - if (interfaces == NULL) + if (!interfaces) return; - for (i = 0; interfaces[i] != NULL; i++) { - connman_bool_t filtered; + for (i = 0; interfaces[i]; i++) { + bool filtered; int index; + struct sockaddr_in sin_addr, sin_mask; filtered = __connman_device_isfiltered(interfaces[i]); - if (filtered == TRUE) + if (filtered) continue; index = connman_inet_ifindex(interfaces[i]); if (index < 0) continue; + if (!__connman_inet_get_address_netmask(index, &sin_addr, + &sin_mask)) { + char *address = g_strdup(inet_ntoa(sin_addr.sin_addr)); + char *netmask = g_strdup(inet_ntoa(sin_mask.sin_addr)); + + if (__connman_config_address_provisioned(address, + netmask)) { + DBG("Skip %s which is already provisioned " + "with %s/%s", interfaces[i], address, + netmask); + g_free(address); + g_free(netmask); + continue; + } + + g_free(address); + g_free(netmask); + } + DBG("cleaning up %s index %d", interfaces[i], index); +#if defined TIZEN_EXT + if (strcmp(interfaces[i], "wlan0") != 0) +#endif connman_inet_ifdown(index); /* @@ -1409,10 +2203,14 @@ int __connman_device_init(const char *device, const char *nodevice) { DBG(""); - if (device != NULL) +#if defined TIZEN_EXT + connection = connman_dbus_get_connection(); +#endif + + if (device) device_filter = g_strsplit(device, ",", -1); - if (nodevice != NULL) + if (nodevice) nodevice_filter = g_strsplit(nodevice, ",", -1); cleanup_devices(); @@ -1426,4 +2224,86 @@ void __connman_device_cleanup(void) g_strfreev(nodevice_filter); g_strfreev(device_filter); + +#if defined TIZEN_EXT + dbus_connection_unref(connection); +#endif +} + +#ifdef TIZEN_EXT +void connman_device_mac_policy_notify(struct connman_device *device, + int result, unsigned int policy) +{ + device->mac_policy = policy; + __connman_technology_notify_mac_policy_by_device(device, result, policy); +} + +int connman_device_set_mac_policy(struct connman_device *device, + unsigned int policy) +{ + int err = 0; + + if (!device || !device->driver || !device->driver->set_mac_policy) + return -EOPNOTSUPP; + + device->mac_policy = policy; + err = device->driver->set_mac_policy(device, policy); + return err; } + +unsigned int connman_device_get_mac_policy(struct connman_device *device) +{ + return device->mac_policy; +} + +void connman_device_preassoc_mac_policy_notify(struct connman_device *device, + int result, unsigned int policy) +{ + device->preassoc_mac_policy = policy; + __connman_technology_notify_preassoc_mac_policy_by_device(device, result, policy); +} + +int connman_device_set_preassoc_mac_policy(struct connman_device *device, + unsigned int policy) +{ + int err = 0; + + if (!device || !device->driver || !device->driver->set_preassoc_mac_policy) + return -EOPNOTSUPP; + + device->preassoc_mac_policy = policy; + err = device->driver->set_preassoc_mac_policy(device, policy); + return err; +} + +unsigned int connman_device_get_preassoc_mac_policy(struct connman_device *device) +{ + return device->preassoc_mac_policy; +} + +void connman_device_random_mac_lifetime_notify(struct connman_device *device, + int result, unsigned int lifetime) +{ + device->random_mac_lifetime = lifetime; + __connman_technology_notify_random_mac_lifetime_by_device(device, result, lifetime); +} + +int connman_device_set_random_mac_lifetime(struct connman_device *device, + unsigned int lifetime) +{ + int err = 0; + + if (!device || !device->driver || !device->driver->set_random_mac_lifetime) + return -EOPNOTSUPP; + + device->random_mac_lifetime = lifetime; + err = device->driver->set_random_mac_lifetime(device, lifetime); + return err; +} + +unsigned int connman_device_get_random_mac_lifetime(struct connman_device *device) +{ + return device->random_mac_lifetime; +} + +#endif