*
* Connection Manager
*
- * Copyright (C) 2007-2012 Intel Corporation. All rights reserved.
+ * Copyright (C) 2007-2013 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
#include <errno.h>
#include <string.h>
+#if defined TIZEN_EXT
+#include <stdio.h>
+#include <stdlib.h>
+#endif
#include <gdbus.h>
static GSList *techless_device_list = NULL;
static GHashTable *rfkill_list;
-static connman_bool_t global_offlinemode;
+static bool global_offlinemode;
+
+#if defined TIZEN_EXT
+typedef enum {
+ CONNMAN_SCAN_TYPE_FULL_CHANNEL = 0x00,
+ CONNMAN_SCAN_TYPE_SPECIFIC_AP,
+ CONNMAN_SCAN_TYPE_MULTI_AP,
+} connman_scan_type_e;
+
+static connman_scan_type_e g_scan_type = -1;
+#endif
struct connman_rfkill {
unsigned int index;
enum connman_service_type type;
- connman_bool_t softblock;
- connman_bool_t hardblock;
+ bool softblock;
+ bool hardblock;
};
struct connman_technology {
enum connman_service_type type;
char *path;
GSList *device_list;
- int enabled;
+ bool enabled;
char *regdom;
- connman_bool_t connected;
+ bool connected;
- connman_bool_t tethering;
+ bool tethering;
+ bool tethering_persistent; /* Tells the save status, needed
+ * as offline mode might set
+ * tethering OFF.
+ */
char *tethering_ident;
char *tethering_passphrase;
+ bool tethering_hidden;
- connman_bool_t enable_persistent; /* Save the tech state */
+ bool enable_persistent; /* Save the tech state */
- struct connman_technology_driver *driver;
- void *driver_data;
+ GSList *driver_list;
DBusMessage *pending_reply;
guint pending_timeout;
GSList *scan_pending;
- connman_bool_t hardblocked;
- connman_bool_t dbus_registered;
+ bool rfkill_driven;
+ bool softblocked;
+ bool hardblocked;
+ bool dbus_registered;
+#if defined TIZEN_EXT_WIFI_MESH
+ DBusMessage *mesh_dbus_msg;
+#endif
};
static GSList *driver_list = NULL;
+static int technology_enabled(struct connman_technology *technology);
+static int technology_disabled(struct connman_technology *technology);
+
static gint compare_priority(gconstpointer a, gconstpointer b)
{
const struct connman_technology_driver *driver1 = a;
rfkill->softblock, rfkill->hardblock);
}
-/**
- * connman_technology_driver_register:
- * @driver: Technology driver definition
- *
- * Register a new technology driver
- *
- * Returns: %0 on success
- */
-int connman_technology_driver_register(struct connman_technology_driver *driver)
+bool
+connman_technology_is_tethering_allowed(enum connman_service_type type)
{
- GSList *list;
- struct connman_device *device;
- enum connman_service_type type;
+ static char *allowed_default[] = { "wifi", "bluetooth", "gadget",
+ NULL };
+ const char *type_str = __connman_service_type2string(type);
+ char **allowed;
+ int i;
+
+ if (!type_str)
+ return false;
+
+ allowed = connman_setting_get_string_list("TetheringTechnologies");
+ if (!allowed)
+ allowed = allowed_default;
+
+ for (i = 0; allowed[i]; i++) {
+ if (g_strcmp0(allowed[i], type_str) == 0)
+ return true;
+ }
- DBG("Registering %s driver", driver->name);
+ return false;
+}
- driver_list = g_slist_insert_sorted(driver_list, driver,
- compare_priority);
+static const char *get_name(enum connman_service_type type)
+{
+ switch (type) {
+ case CONNMAN_SERVICE_TYPE_UNKNOWN:
+ case CONNMAN_SERVICE_TYPE_SYSTEM:
+ case CONNMAN_SERVICE_TYPE_GPS:
+ case CONNMAN_SERVICE_TYPE_VPN:
+ break;
+ case CONNMAN_SERVICE_TYPE_GADGET:
+ return "Gadget";
+ case CONNMAN_SERVICE_TYPE_ETHERNET:
+ return "Wired";
+ case CONNMAN_SERVICE_TYPE_WIFI:
+ return "WiFi";
+ case CONNMAN_SERVICE_TYPE_BLUETOOTH:
+ return "Bluetooth";
+ case CONNMAN_SERVICE_TYPE_CELLULAR:
+ return "Cellular";
+ case CONNMAN_SERVICE_TYPE_P2P:
+ return "P2P";
+#if defined TIZEN_EXT_WIFI_MESH
+ case CONNMAN_SERVICE_TYPE_MESH:
+ return "Mesh";
+#endif
+ }
- if (techless_device_list == NULL)
- goto check_rfkill;
+ return NULL;
+}
- /*
- * Check for technology less devices if this driver
- * can service any of them.
- */
- for (list = techless_device_list; list; list = list->next) {
- device = list->data;
+static void technology_save(struct connman_technology *technology)
+{
+ GKeyFile *keyfile;
+ gchar *identifier;
+ const char *name = get_name(technology->type);
- type = __connman_device_get_service_type(device);
- if (type != driver->type)
- continue;
+ DBG("technology %p type %d name %s", technology, technology->type,
+ name);
+ if (!name)
+ return;
- techless_device_list = g_slist_remove(techless_device_list,
- device);
+ keyfile = __connman_storage_load_global();
+ if (!keyfile)
+ keyfile = g_key_file_new();
- __connman_technology_add_device(device);
- }
+ identifier = g_strdup_printf("%s", name);
+ if (!identifier)
+ goto done;
-check_rfkill:
- /* Check for orphaned rfkill switches. */
- g_hash_table_foreach(rfkill_list, rfkill_check,
- GINT_TO_POINTER(driver->type));
+ g_key_file_set_boolean(keyfile, identifier, "Enable",
+ technology->enable_persistent);
- return 0;
-}
+ g_key_file_set_boolean(keyfile, identifier, "Tethering",
+ technology->tethering_persistent);
-/**
- * connman_technology_driver_unregister:
- * @driver: Technology driver definition
- *
- * Remove a previously registered technology driver
- */
-void connman_technology_driver_unregister(struct connman_technology_driver *driver)
-{
- GSList *list;
- struct connman_technology *technology;
+ g_key_file_set_boolean(keyfile, identifier, "Hidden",
+ technology->tethering_hidden);
- DBG("Unregistering driver %p name %s", driver, driver->name);
+ if (technology->tethering_ident)
+ g_key_file_set_string(keyfile, identifier,
+ "Tethering.Identifier",
+ technology->tethering_ident);
- for (list = technology_list; list; list = list->next) {
- technology = list->data;
+ if (technology->tethering_passphrase)
+ g_key_file_set_string(keyfile, identifier,
+ "Tethering.Passphrase",
+ technology->tethering_passphrase);
- if (technology->driver == NULL)
- continue;
+done:
+ g_free(identifier);
- if (technology->type == driver->type) {
- technology->driver->remove(technology);
- technology->driver = NULL;
- }
- }
+ __connman_storage_save_global(keyfile);
- driver_list = g_slist_remove(driver_list, driver);
+ g_key_file_free(keyfile);
+
+ return;
}
static void tethering_changed(struct connman_technology *technology)
{
- connman_bool_t tethering = technology->tethering;
+ dbus_bool_t tethering = technology->tethering;
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE, "Tethering",
DBUS_TYPE_BOOLEAN, &tethering);
+
+ technology_save(technology);
}
-void connman_technology_tethering_notify(struct connman_technology *technology,
- connman_bool_t enabled)
+int connman_technology_tethering_notify(struct connman_technology *technology,
+ bool enabled)
{
- GSList *list;
+ int err;
DBG("technology %p enabled %u", technology, enabled);
if (technology->tethering == enabled)
- return;
+ return -EALREADY;
- technology->tethering = enabled;
+ if (enabled) {
+ err = __connman_tethering_set_enabled();
+ if (err < 0)
+ return err;
+ } else
+ __connman_tethering_set_disabled();
+ technology->tethering = enabled;
tethering_changed(technology);
- if (enabled == TRUE)
- __connman_tethering_set_enabled();
- else {
- for (list = technology_list; list; list = list->next) {
- struct connman_technology *other_tech = list->data;
- if (other_tech->tethering == TRUE)
- break;
- }
- if (list == NULL)
- __connman_tethering_set_disabled();
- }
+ return 0;
}
static int set_tethering(struct connman_technology *technology,
- connman_bool_t enabled)
+ bool enabled)
{
+ int result = -EOPNOTSUPP;
+ int err;
const char *ident, *passphrase, *bridge;
+ GSList *tech_drivers;
ident = technology->tethering_ident;
passphrase = technology->tethering_passphrase;
- if (technology->driver == NULL ||
- technology->driver->set_tethering == NULL)
- return -EOPNOTSUPP;
+ __sync_synchronize();
+ if (!technology->enabled)
+ return -EACCES;
bridge = __connman_tethering_get_bridge();
- if (bridge == NULL)
+ if (!bridge)
return -EOPNOTSUPP;
- if (technology->type == CONNMAN_SERVICE_TYPE_WIFI &&
- (ident == NULL || passphrase == NULL))
+ if (technology->type == CONNMAN_SERVICE_TYPE_WIFI && (!ident))
return -EINVAL;
- return technology->driver->set_tethering(technology, ident, passphrase,
- bridge, enabled);
+ for (tech_drivers = technology->driver_list; tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+ struct connman_technology_driver *driver = tech_drivers->data;
+
+ if (!driver || !driver->set_tethering)
+ continue;
+
+ err = driver->set_tethering(technology, ident, passphrase,
+ bridge, enabled);
+
+ if (result == -EINPROGRESS)
+ continue;
+
+ if (err == -EINPROGRESS || err == 0)
+ result = err;
+ }
+
+ return result;
}
void connman_technology_regdom_notify(struct connman_technology *technology,
{
DBG("");
- if (alpha2 == NULL)
+ if (!alpha2)
connman_error("Failed to set regulatory domain");
else
DBG("Regulatory domain set to %s", alpha2);
int connman_technology_set_regdom(const char *alpha2)
{
- GSList *list;
+ GSList *list, *tech_drivers;
for (list = technology_list; list; list = list->next) {
struct connman_technology *technology = list->data;
if (set_regdom_by_device(technology, alpha2) != 0) {
- if (technology->driver == NULL)
- continue;
- if (technology->driver->set_regdom != NULL)
- technology->driver->set_regdom(technology,
- alpha2);
+ for (tech_drivers = technology->driver_list;
+ tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+
+ struct connman_technology_driver *driver =
+ tech_drivers->data;
+
+ if (driver->set_regdom)
+ driver->set_regdom(technology, alpha2);
+ }
}
}
return 0;
}
-static void free_rfkill(gpointer data)
+static struct connman_technology *technology_find(enum connman_service_type type)
{
- struct connman_rfkill *rfkill = data;
+ GSList *list;
- g_free(rfkill);
-}
+ DBG("type %d", type);
-static const char *get_name(enum connman_service_type type)
-{
- switch (type) {
- case CONNMAN_SERVICE_TYPE_UNKNOWN:
- case CONNMAN_SERVICE_TYPE_SYSTEM:
- case CONNMAN_SERVICE_TYPE_GPS:
- case CONNMAN_SERVICE_TYPE_VPN:
- case CONNMAN_SERVICE_TYPE_GADGET:
- break;
- case CONNMAN_SERVICE_TYPE_ETHERNET:
- return "Wired";
- case CONNMAN_SERVICE_TYPE_WIFI:
- return "WiFi";
- case CONNMAN_SERVICE_TYPE_WIMAX:
- return "WiMAX";
- case CONNMAN_SERVICE_TYPE_BLUETOOTH:
- return "Bluetooth";
- case CONNMAN_SERVICE_TYPE_CELLULAR:
- return "Cellular";
+ for (list = technology_list; list; list = list->next) {
+ struct connman_technology *technology = list->data;
+
+ if (technology->type == type)
+ return technology;
}
return NULL;
}
-static void technology_save(struct connman_technology *technology)
+bool connman_technology_get_wifi_tethering(const char **ssid,
+ const char **psk)
{
- GKeyFile *keyfile;
- gchar *identifier;
-
- DBG("technology %p", technology);
-
- keyfile = __connman_storage_load_global();
- if (keyfile == NULL)
- keyfile = g_key_file_new();
+ struct connman_technology *technology;
- identifier = g_strdup_printf("%s", get_name(technology->type));
- if (identifier == NULL)
- goto done;
+ if (!ssid || !psk)
+ return false;
- g_key_file_set_boolean(keyfile, identifier, "Enable",
- technology->enable_persistent);
+ *ssid = *psk = NULL;
- if (technology->tethering_ident != NULL)
- g_key_file_set_string(keyfile, identifier,
- "Tethering.Identifier",
- technology->tethering_ident);
+ technology = technology_find(CONNMAN_SERVICE_TYPE_WIFI);
+ if (!technology)
+ return false;
- if (technology->tethering_passphrase != NULL)
- g_key_file_set_string(keyfile, identifier,
- "Tethering.Passphrase",
- technology->tethering_passphrase);
+ if (!technology->tethering)
+ return false;
-done:
- g_free(identifier);
+ *ssid = technology->tethering_ident;
+ *psk = technology->tethering_passphrase;
- __connman_storage_save_global(keyfile);
+ return true;
+}
- g_key_file_free(keyfile);
+static void free_rfkill(gpointer data)
+{
+ struct connman_rfkill *rfkill = data;
- return;
+ g_free(rfkill);
}
static void technology_load(struct connman_technology *technology)
GKeyFile *keyfile;
gchar *identifier;
GError *error = NULL;
- connman_bool_t enable;
+ bool enable, need_saving = false;
DBG("technology %p", technology);
keyfile = __connman_storage_load_global();
/* Fallback on disabling technology if file not found. */
- if (keyfile == NULL) {
+ if (!keyfile) {
if (technology->type == CONNMAN_SERVICE_TYPE_ETHERNET)
/* We enable ethernet by default */
- technology->enable_persistent = TRUE;
+ technology->enable_persistent = true;
else
- technology->enable_persistent = FALSE;
+ technology->enable_persistent = false;
return;
}
identifier = g_strdup_printf("%s", get_name(technology->type));
- if (identifier == NULL)
+ if (!identifier)
goto done;
enable = g_key_file_get_boolean(keyfile, identifier, "Enable", &error);
- if (error == NULL)
+ if (!error)
technology->enable_persistent = enable;
else {
if (technology->type == CONNMAN_SERVICE_TYPE_ETHERNET)
- technology->enable_persistent = TRUE;
+ technology->enable_persistent = true;
else
- technology->enable_persistent = FALSE;
+ technology->enable_persistent = false;
- technology_save(technology);
+ need_saving = true;
+ g_clear_error(&error);
+ }
+
+ enable = g_key_file_get_boolean(keyfile, identifier,
+ "Tethering", &error);
+ if (!error)
+ technology->tethering_persistent = enable;
+ else {
+ need_saving = true;
g_clear_error(&error);
}
+ if (need_saving)
+ technology_save(technology);
+
technology->tethering_ident = g_key_file_get_string(keyfile,
identifier, "Tethering.Identifier", NULL);
return;
}
-connman_bool_t __connman_technology_get_offlinemode(void)
+bool __connman_technology_get_offlinemode(void)
{
return global_offlinemode;
}
-static void connman_technology_save_offlinemode()
+static void connman_technology_save_offlinemode(void)
{
GKeyFile *keyfile;
+ GError *error = NULL;
+ bool offlinemode;
keyfile = __connman_storage_load_global();
- if (keyfile == NULL)
+
+ if (!keyfile) {
keyfile = g_key_file_new();
+ g_key_file_set_boolean(keyfile, "global",
+ "OfflineMode", global_offlinemode);
+
+ __connman_storage_save_global(keyfile);
+ }
+ else {
+ offlinemode = g_key_file_get_boolean(keyfile, "global",
+ "OfflineMode", &error);
- g_key_file_set_boolean(keyfile, "global",
+ if (error || offlinemode != global_offlinemode) {
+ g_key_file_set_boolean(keyfile, "global",
"OfflineMode", global_offlinemode);
+ if (error)
+ g_clear_error(&error);
- __connman_storage_save_global(keyfile);
+ __connman_storage_save_global(keyfile);
+ }
+ }
g_key_file_free(keyfile);
return;
}
-static connman_bool_t connman_technology_load_offlinemode()
+static bool connman_technology_load_offlinemode(void)
{
GKeyFile *keyfile;
GError *error = NULL;
- connman_bool_t offlinemode;
+ bool offlinemode;
/* If there is a error, we enable offlinemode */
keyfile = __connman_storage_load_global();
- if (keyfile == NULL)
- return FALSE;
+ if (!keyfile)
+ return false;
offlinemode = g_key_file_get_boolean(keyfile, "global",
"OfflineMode", &error);
- if (error != NULL) {
- offlinemode = FALSE;
+ if (error) {
+ offlinemode = false;
g_clear_error(&error);
}
struct connman_technology *technology)
{
DBusMessageIter dict;
+ dbus_bool_t val;
const char *str;
- connman_bool_t powered;
connman_dbus_dict_open(iter, &dict);
str = get_name(technology->type);
- if (str != NULL)
+ if (str)
connman_dbus_dict_append_basic(&dict, "Name",
DBUS_TYPE_STRING, &str);
str = __connman_service_type2string(technology->type);
- if (str != NULL)
+ if (str)
connman_dbus_dict_append_basic(&dict, "Type",
DBUS_TYPE_STRING, &str);
__sync_synchronize();
- if (technology->enabled > 0)
- powered = TRUE;
- else
- powered = FALSE;
+ val = technology->enabled;
connman_dbus_dict_append_basic(&dict, "Powered",
- DBUS_TYPE_BOOLEAN, &powered);
+ DBUS_TYPE_BOOLEAN,
+ &val);
+ val = technology->connected;
connman_dbus_dict_append_basic(&dict, "Connected",
DBUS_TYPE_BOOLEAN,
- &technology->connected);
+ &val);
+ val = technology->tethering;
connman_dbus_dict_append_basic(&dict, "Tethering",
DBUS_TYPE_BOOLEAN,
- &technology->tethering);
+ &val);
- if (technology->tethering_ident != NULL)
+ if (technology->tethering_ident)
connman_dbus_dict_append_basic(&dict, "TetheringIdentifier",
- DBUS_TYPE_STRING,
- &technology->tethering_ident);
+ DBUS_TYPE_STRING,
+ &technology->tethering_ident);
- if (technology->tethering_passphrase != NULL)
+ if (technology->tethering_passphrase)
connman_dbus_dict_append_basic(&dict, "TetheringPassphrase",
- DBUS_TYPE_STRING,
- &technology->tethering_passphrase);
+ DBUS_TYPE_STRING,
+ &technology->tethering_passphrase);
+
+ val = technology->tethering_hidden;
+ connman_dbus_dict_append_basic(&dict, "Hidden",
+ DBUS_TYPE_BOOLEAN,
+ &val);
connman_dbus_dict_close(iter, &dict);
}
signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
CONNMAN_MANAGER_INTERFACE, "TechnologyAdded");
- if (signal == NULL)
+ if (!signal)
return;
dbus_message_iter_init_append(signal, &iter);
DBusMessageIter iter;
reply = dbus_message_new_method_return(message);
- if (reply == NULL)
+ if (!reply)
return NULL;
dbus_message_iter_init_append(reply, &iter);
for (list = technology_list; list; list = list->next) {
struct connman_technology *technology = list->data;
- if (technology->path == NULL ||
- technology->hardblocked == TRUE)
+ if (!technology->path ||
+ (technology->rfkill_driven &&
+ technology->hardblocked))
continue;
dbus_message_iter_open_container(array, DBUS_TYPE_STRUCT,
DBusMessage *reply;
/* Power request timedout, send ETIMEDOUT. */
- if (technology->pending_reply != NULL) {
+ if (technology->pending_reply) {
reply = __connman_error_failed(technology->pending_reply, ETIMEDOUT);
- if (reply != NULL)
+ if (reply)
g_dbus_send_message(connection, reply);
dbus_message_unref(technology->pending_reply);
}
static int technology_affect_devices(struct connman_technology *technology,
- connman_bool_t enable_device)
+ bool enable_device)
{
+ int err = 0, err_dev;
GSList *list;
- int err = 0;
+
+ if (technology->type == CONNMAN_SERVICE_TYPE_P2P) {
+ if (enable_device)
+ __connman_technology_enabled(technology->type);
+ else
+ __connman_technology_disabled(technology->type);
+ return 0;
+ }
+
+#if defined TIZEN_EXT_WIFI_MESH
+ if (technology->type == CONNMAN_SERVICE_TYPE_MESH)
+ return 0;
+#endif
for (list = technology->device_list; list; list = list->next) {
struct connman_device *device = list->data;
- if (enable_device == TRUE)
- err = __connman_device_enable(device);
+ if (enable_device)
+ err_dev = __connman_device_enable(device);
else
- err = __connman_device_disable(device);
+ err_dev = __connman_device_disable(device);
+
+ if (err_dev < 0 && err_dev != -EALREADY)
+ err = err_dev;
}
return err;
}
-static int technology_enable(struct connman_technology *technology,
- connman_bool_t hardblock)
+static void powered_changed(struct connman_technology *technology)
{
- DBG("technology %p enable", technology);
-
- __sync_synchronize();
- if (technology->enabled > 0)
- return -EALREADY;
+ dbus_bool_t enabled;
- if (technology->pending_reply != NULL)
- return -EBUSY;
+ if (!technology->dbus_registered)
+ return;
- if (hardblock == TRUE && technology->enable_persistent == FALSE)
- return 0;
+ if (technology->pending_reply) {
+ g_dbus_send_reply(connection,
+ technology->pending_reply, DBUS_TYPE_INVALID);
+ dbus_message_unref(technology->pending_reply);
+ technology->pending_reply = NULL;
- __connman_rfkill_block(technology->type, FALSE);
+ g_source_remove(technology->pending_timeout);
+ technology->pending_timeout = 0;
+ }
- return technology_affect_devices(technology, TRUE);
+ __sync_synchronize();
+ enabled = technology->enabled;
+#if defined TIZEN_EXT
+ DBG("ConnMan, Powered : %s, %s",
+ enabled ? "TRUE" : "FALSE",technology->path);
+#endif
+ connman_dbus_property_changed_basic(technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE, "Powered",
+ DBUS_TYPE_BOOLEAN, &enabled);
}
-static int technology_disable(struct connman_technology *technology,
- connman_bool_t hardblock)
+static void enable_tethering(struct connman_technology *technology)
{
- DBG("technology %p disable", technology);
+ int ret;
+
+ if (!connman_setting_get_bool("PersistentTetheringMode"))
+ return;
+
+ ret = set_tethering(technology, true);
+ if (ret < 0 && ret != -EALREADY)
+ DBG("Cannot enable tethering yet for %s (%d/%s)",
+ get_name(technology->type),
+ -ret, strerror(-ret));
+}
+static int technology_enabled(struct connman_technology *technology)
+{
__sync_synchronize();
- if (technology->enabled == 0)
+ if (technology->enabled)
return -EALREADY;
- if (technology->pending_reply != NULL)
- return -EBUSY;
+ technology->enabled = true;
+
+ if (technology->type == CONNMAN_SERVICE_TYPE_WIFI) {
+ struct connman_technology *p2p;
- if (technology->tethering == TRUE)
- set_tethering(technology, FALSE);
+ p2p = technology_find(CONNMAN_SERVICE_TYPE_P2P);
+ if (p2p && !p2p->enabled && p2p->enable_persistent)
+ technology_enabled(p2p);
+ }
+
+ if (technology->tethering_persistent)
+ enable_tethering(technology);
- if (hardblock == FALSE)
- __connman_rfkill_block(technology->type, TRUE);
+ powered_changed(technology);
- return technology_affect_devices(technology, FALSE);
+ return 0;
}
-static DBusMessage *set_powered(struct connman_technology *technology,
- DBusMessage *msg, connman_bool_t powered)
+static int technology_enable(struct connman_technology *technology)
{
- DBusMessage *reply = NULL;
int err = 0;
+ int err_dev;
- if (technology->hardblocked == TRUE) {
- err = -EACCES;
- goto make_reply;
- }
+ DBG("technology %p enable", technology);
- if (powered == TRUE)
- err = technology_enable(technology, FALSE);
- else
- err = technology_disable(technology, FALSE);
+ __sync_synchronize();
- if (err != -EBUSY) {
- technology->enable_persistent = powered;
- technology_save(technology);
- }
+ if (technology->type == CONNMAN_SERVICE_TYPE_P2P) {
+ struct connman_technology *wifi;
+
+ wifi = technology_find(CONNMAN_SERVICE_TYPE_WIFI);
+ if (wifi && wifi->enabled)
+ return technology_enabled(technology);
+ return 0;
+ }
+
+ if (technology->enabled)
+ return -EALREADY;
+
+ if (technology->pending_reply)
+ return -EBUSY;
+
+ if (connman_setting_get_bool("PersistentTetheringMode") &&
+ technology->tethering)
+ set_tethering(technology, true);
+
+ if (technology->rfkill_driven)
+ err = __connman_rfkill_block(technology->type, false);
+
+ err_dev = technology_affect_devices(technology, true);
+
+ if (!technology->rfkill_driven)
+ err = err_dev;
+
+ return err;
+}
+
+static int technology_disabled(struct connman_technology *technology)
+{
+ __sync_synchronize();
+ if (!technology->enabled)
+ return -EALREADY;
+
+ technology->enabled = false;
+
+ powered_changed(technology);
+
+ return 0;
+}
+
+static int technology_disable(struct connman_technology *technology)
+{
+ int err;
+
+ DBG("technology %p disable", technology);
+
+ __sync_synchronize();
+
+ if (technology->type == CONNMAN_SERVICE_TYPE_P2P) {
+ technology->enable_persistent = false;
+ return technology_disabled(technology);
+ } else if (technology->type == CONNMAN_SERVICE_TYPE_WIFI) {
+ struct connman_technology *p2p;
+
+ p2p = technology_find(CONNMAN_SERVICE_TYPE_P2P);
+ if (p2p && p2p->enabled) {
+ p2p->enable_persistent = true;
+ technology_disabled(p2p);
+ }
+ }
+
+ if (!technology->enabled)
+ return -EALREADY;
+
+ if (technology->pending_reply)
+ return -EBUSY;
+
+ if (technology->tethering)
+ set_tethering(technology, false);
+
+ err = technology_affect_devices(technology, false);
+
+ if (technology->rfkill_driven)
+ err = __connman_rfkill_block(technology->type, true);
+
+ return err;
+}
+
+static DBusMessage *set_powered(struct connman_technology *technology,
+ DBusMessage *msg, bool powered)
+{
+ DBusMessage *reply = NULL;
+ int err = 0;
+
+ if (technology->rfkill_driven && technology->hardblocked) {
+ err = -EACCES;
+ goto make_reply;
+ }
+
+ if (powered)
+ err = technology_enable(technology);
+ else
+ err = technology_disable(technology);
+
+ if (err != -EBUSY) {
+ technology->enable_persistent = powered;
+ technology_save(technology);
+ }
make_reply:
if (err == -EINPROGRESS) {
technology->pending_timeout = g_timeout_add_seconds(10,
technology_pending_reply, technology);
} else if (err == -EALREADY) {
- if (powered == TRUE)
+ if (powered)
reply = __connman_error_already_enabled(msg);
else
reply = __connman_error_already_disabled(msg);
return reply;
}
+#if defined TIZEN_EXT
+int set_connman_bssid(enum bssid_type mode, char *bssid)
+{
+ static unsigned char bssid_for_connect[6];
+ static int bssid_len;
+
+ DBG("mode : %d", mode);
+
+ if (mode == CHECK_BSSID) {
+ return bssid_len;
+ }
+
+ if (mode == GET_BSSID && bssid) {
+ memcpy(bssid, bssid_for_connect, 6);
+ return bssid_len;
+ }
+
+ if (mode == RESET_BSSID) {
+ bssid_len = 0;
+ return bssid_len;
+ }
+
+ if (mode != SET_BSSID || !bssid) {
+ DBG("Invalid parameter");
+ return 0;
+ }
+
+ bssid_len = sscanf(bssid, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
+ &bssid_for_connect[0], &bssid_for_connect[1], &bssid_for_connect[2],
+ &bssid_for_connect[3], &bssid_for_connect[4], &bssid_for_connect[5]);
+ if (bssid_len != 6) {
+ DBG("Incorrect BSSID format. bssid_len = %d", bssid_len);
+ bssid_len = 0;
+ }
+
+ DBG("SET BSSID len : %d, BSSID : %02x:%02x:%02x:%02x:%02x:%02x", bssid_len,
+ bssid_for_connect[0], bssid_for_connect[1], bssid_for_connect[2],
+ bssid_for_connect[3], bssid_for_connect[4], bssid_for_connect[5]);
+
+ return bssid_len;
+}
+#endif
+
static DBusMessage *set_property(DBusConnection *conn,
DBusMessage *msg, void *data)
{
struct connman_technology *technology = data;
DBusMessageIter iter, value;
const char *name;
- int type;
+ int type, err;
DBG("conn %p", conn);
- if (dbus_message_iter_init(msg, &iter) == FALSE)
+ if (!dbus_message_iter_init(msg, &iter))
return __connman_error_invalid_arguments(msg);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
DBG("property %s", name);
- if (g_str_equal(name, "Tethering") == TRUE) {
+ if (technology->type == CONNMAN_SERVICE_TYPE_WIFI && technology->connected) {
+ uid_t uid;
+ if (connman_dbus_get_connection_unix_user_sync(conn,
+ dbus_message_get_sender(msg),
+ &uid) < 0) {
+ DBG("Can not get unix user id!");
+ return __connman_error_permission_denied(msg);
+ }
+
+ if (!__connman_service_is_user_allowed(CONNMAN_SERVICE_TYPE_WIFI, uid)) {
+ DBG("Not allow this user to operate wifi technology now!");
+ return __connman_error_permission_denied(msg);
+ }
+ }
+
+ if (g_str_equal(name, "Tethering")) {
+ dbus_bool_t tethering;
int err;
- connman_bool_t tethering;
if (type != DBUS_TYPE_BOOLEAN)
return __connman_error_invalid_arguments(msg);
+ if (!connman_technology_is_tethering_allowed(technology->type)) {
+ DBG("%s tethering not allowed by config file",
+ __connman_service_type2string(technology->type));
+ return __connman_error_not_supported(msg);
+ }
+
dbus_message_iter_get_basic(&value, &tethering);
if (technology->tethering == tethering) {
- if (tethering == FALSE)
+ if (!tethering)
return __connman_error_already_disabled(msg);
else
return __connman_error_already_enabled(msg);
if (err < 0)
return __connman_error_failed(msg, -err);
- } else if (g_str_equal(name, "TetheringIdentifier") == TRUE) {
+ technology->tethering_persistent = tethering;
+
+ technology_save(technology);
+
+ } else if (g_str_equal(name, "TetheringIdentifier")) {
const char *str;
dbus_message_iter_get_basic(&value, &str);
DBUS_TYPE_STRING,
&technology->tethering_ident);
}
- } else if (g_str_equal(name, "TetheringPassphrase") == TRUE) {
+ } else if (g_str_equal(name, "TetheringPassphrase")) {
const char *str;
dbus_message_iter_get_basic(&value, &str);
if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
return __connman_error_not_supported(msg);
- if (strlen(str) < 8 || strlen(str) > 63)
+ err = __connman_service_check_passphrase(CONNMAN_SERVICE_SECURITY_PSK,
+ str);
+ if (err < 0)
return __connman_error_passphrase_required(msg);
if (g_strcmp0(technology->tethering_passphrase, str) != 0) {
DBUS_TYPE_STRING,
&technology->tethering_passphrase);
}
- } else if (g_str_equal(name, "Powered") == TRUE) {
- connman_bool_t enable;
+ } else if (g_str_equal(name, "Hidden")) {
+ dbus_bool_t hidden;
if (type != DBUS_TYPE_BOOLEAN)
return __connman_error_invalid_arguments(msg);
- dbus_message_iter_get_basic(&value, &enable);
+ dbus_message_iter_get_basic(&value, &hidden);
- return set_powered(technology, msg, enable);
- } else
- return __connman_error_invalid_property(msg);
+ if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
+ return __connman_error_not_supported(msg);
- return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
-}
+ technology->tethering_hidden = hidden;
+ technology_save(technology);
-static struct connman_technology *technology_find(enum connman_service_type type)
-{
- GSList *list;
+ connman_dbus_property_changed_basic(technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE,
+ "Hidden",
+ DBUS_TYPE_BOOLEAN,
+ &hidden);
+ } else if (g_str_equal(name, "Powered")) {
+ dbus_bool_t enable;
- DBG("type %d", type);
+ if (type != DBUS_TYPE_BOOLEAN)
+ return __connman_error_invalid_arguments(msg);
- for (list = technology_list; list; list = list->next) {
- struct connman_technology *technology = list->data;
+ dbus_message_iter_get_basic(&value, &enable);
- if (technology->type == type)
- return technology;
- }
+ return set_powered(technology, msg, enable);
+#if defined TIZEN_EXT
+ } else if (g_str_equal(name, "SetBSSID")) {
+ char *key;
- return NULL;
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value, &key);
+ DBG("BSSID %s", key);
+ set_connman_bssid(SET_BSSID, key);
+#endif
+ } else
+ return __connman_error_invalid_property(msg);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
static void reply_scan_pending(struct connman_technology *technology, int err)
DBG("technology %p err %d", technology, err);
- while (technology->scan_pending != NULL) {
+ while (technology->scan_pending) {
DBusMessage *msg = technology->scan_pending->data;
DBG("reply to %s", dbus_message_get_sender(msg));
}
}
+#if defined TIZEN_EXT
+dbus_bool_t __connman_technology_notify_scan_changed(const char *key, void *val)
+{
+ DBG("key %s", key);
+ DBusMessage *signal;
+ DBusMessageIter iter;
+ dbus_bool_t result = FALSE;
+
+ signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE, "ScanChanged");
+ if (!signal)
+ return result;
+
+ dbus_message_iter_init_append(signal, &iter);
+ connman_dbus_property_append_basic(&iter, key, DBUS_TYPE_BOOLEAN, val);
+
+ result = dbus_connection_send(connection, signal, NULL);
+ dbus_message_unref(signal);
+
+ DBG("Successfuly sent signal");
+
+ return result;
+}
+#endif
+
void __connman_technology_scan_started(struct connman_device *device)
{
DBG("device %p", device);
+#if defined TIZEN_EXT
+ dbus_bool_t status = 1;
+ __connman_technology_notify_scan_changed("scan_started", &status);
+#endif
}
-void __connman_technology_scan_stopped(struct connman_device *device)
+void __connman_technology_scan_stopped(struct connman_device *device,
+ enum connman_service_type type)
{
int count = 0;
struct connman_technology *technology;
- enum connman_service_type type;
GSList *list;
- type = __connman_device_get_service_type(device);
technology = technology_find(type);
DBG("technology %p device %p", technology, device);
- if (technology == NULL)
+ if (!technology)
return;
- for (list = technology->device_list; list != NULL; list = list->next) {
+ for (list = technology->device_list; list; list = list->next) {
struct connman_device *other_device = list->data;
if (device == other_device)
if (__connman_device_get_service_type(other_device) != type)
continue;
- if (connman_device_get_scanning(other_device) == TRUE)
+ if (connman_device_get_scanning(other_device))
count += 1;
}
+#if defined TIZEN_EXT
+ if (count == 0) {
+ DBusMessage *signal;
+ DBusMessageIter iter;
+ dbus_bool_t status = 0;
+ __connman_technology_notify_scan_changed("scan_done", &status);
+
+ signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE, "ScanDone");
+ if (!signal)
+ return;
+
+ dbus_message_iter_init_append(signal, &iter);
+ connman_dbus_property_append_basic(&iter, "Scantype",
+ DBUS_TYPE_INT32, &g_scan_type);
+
+ dbus_connection_send(connection, signal, NULL);
+ dbus_message_unref(signal);
+ reply_scan_pending(technology, 0);
+
+ DBG("Successfuly sent ScanDone signal");
+ }
+#else
if (count == 0)
reply_scan_pending(technology, 0);
+#endif
}
void __connman_technology_notify_regdom_by_device(struct connman_device *device,
int result, const char *alpha2)
{
+ bool regdom_set = false;
struct connman_technology *technology;
enum connman_service_type type;
+ GSList *tech_drivers;
+
+ type = __connman_device_get_service_type(device);
+ technology = technology_find(type);
+
+ if (!technology)
+ return;
+
+ if (result < 0) {
+
+ for (tech_drivers = technology->driver_list;
+ tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+ struct connman_technology_driver *driver =
+ tech_drivers->data;
+
+ if (driver->set_regdom) {
+ driver->set_regdom(technology, alpha2);
+ regdom_set = true;
+ }
+
+ }
+
+ if (!regdom_set)
+ alpha2 = NULL;
+ }
+
+ connman_technology_regdom_notify(technology, alpha2);
+}
+
+static DBusMessage *scan(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+ struct connman_technology *technology = data;
+ int err;
+
+ DBG("technology %p request from %s", technology,
+ dbus_message_get_sender(msg));
+
+ if (technology->type == CONNMAN_SERVICE_TYPE_P2P &&
+ !technology->enabled)
+ return __connman_error_permission_denied(msg);
+
+ dbus_message_ref(msg);
+#if !defined TIZEN_EXT
+ technology->scan_pending =
+ g_slist_prepend(technology->scan_pending, msg);
+#endif
+
+ err = __connman_device_request_scan(technology->type);
+#if defined TIZEN_EXT
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+#else
+ if (err < 0)
+ reply_scan_pending(technology, err);
+#endif
+
+#if defined TIZEN_EXT
+ if (err == 0) {
+ g_scan_type = CONNMAN_SCAN_TYPE_FULL_CHANNEL;
+ DBG("g_scan_type %d", g_scan_type);
+ }
+ technology->scan_pending =
+ g_slist_prepend(technology->scan_pending, msg);
+#endif
+ return NULL;
+}
+
+#if defined TIZEN_EXT
+static DBusMessage *specific_scan(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+ struct connman_technology *technology = data;
+ GSList *specific_scan_list = NULL;
+ int scan_type = 0;
+ const char *name = NULL;
+ const char *freq = NULL;
+ DBusMessageIter iter, dict;
+ int err;
+
+ DBG("technology %p request from %s", technology,
+ dbus_message_get_sender(msg));
+
+ if (!dbus_message_iter_init(msg, &iter))
+ return __connman_error_invalid_arguments(msg);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&iter, &dict);
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value2;
+ const char *key;
+ int type;
+
+ dbus_message_iter_recurse(&dict, &entry);
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING) {
+ g_slist_free_full(specific_scan_list, g_free);
+ return __connman_error_invalid_arguments(msg);
+ }
+
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT) {
+ g_slist_free_full(specific_scan_list, g_free);
+ return __connman_error_invalid_arguments(msg);
+ }
+
+ dbus_message_iter_recurse(&entry, &value2);
+ type = dbus_message_iter_get_arg_type(&value2);
+ if (g_str_equal(key, "SSID")) {
+ if (type != DBUS_TYPE_STRING) {
+ g_slist_free_full(specific_scan_list, g_free);
+ return __connman_error_invalid_arguments(msg);
+ }
+
+ scan_type = CONNMAN_MULTI_SCAN_SSID; /* SSID based scan */
+ dbus_message_iter_get_basic(&value2, &name);
+ DBG("name %s", name);
+ specific_scan_list = g_slist_append(specific_scan_list, g_strdup(name));
+ } else if (g_str_equal(key, "Frequency")) {
+ if (type != DBUS_TYPE_STRING) {
+ g_slist_free_full(specific_scan_list, g_free);
+ return __connman_error_invalid_arguments(msg);
+ }
+
+ scan_type = CONNMAN_MULTI_SCAN_FREQ; /* Frequency based scan */
+ dbus_message_iter_get_basic(&value2, &freq);
+ DBG("freq %s", freq);
+ specific_scan_list = g_slist_append(specific_scan_list, GINT_TO_POINTER(atoi(freq)));
+ } else if (g_str_equal(key, "SSID_Mixed")) {
+ if (type != DBUS_TYPE_STRING) {
+ g_slist_free_full(specific_scan_list, g_free);
+ return __connman_error_invalid_arguments(msg);
+ }
+
+ scan_type = CONNMAN_MULTI_SCAN_SSID_FREQ; /* SSID & Frequency mixed scan */
+ dbus_message_iter_get_basic(&value2, &name);
+
+ connman_multi_scan_ap_s *ap = (connman_multi_scan_ap_s*)g_try_malloc0(sizeof(connman_multi_scan_ap_s));
+ if (ap) {
+ g_strlcpy(ap->str, name, strlen(name) + 1);
+ ap->flag = true;
+ specific_scan_list = g_slist_append(specific_scan_list, ap);
+ } else
+ DBG("Failed to allocate memory");
+
+ } else if (g_str_equal(key, "Frequency_Mixed")) {
+ if (type != DBUS_TYPE_STRING) {
+ g_slist_free_full(specific_scan_list, g_free);
+ return __connman_error_invalid_arguments(msg);
+ }
+
+ scan_type = CONNMAN_MULTI_SCAN_SSID_FREQ; /* SSID & Frequency mixed scan */
+ dbus_message_iter_get_basic(&value2, &freq);
+
+ connman_multi_scan_ap_s *ap = (connman_multi_scan_ap_s*)g_try_malloc0(sizeof(connman_multi_scan_ap_s));
+ if (ap) {
+ g_strlcpy(ap->str, freq, strlen(freq) + 1);
+ ap->flag = false;
+ specific_scan_list = g_slist_append(specific_scan_list, ap);
+ } else
+ DBG("Failed to allocate memory");
+ }
+ dbus_message_iter_next(&dict);
+ }
+
+ dbus_message_ref(msg);
+
+ err = __connman_device_request_specific_scan(technology->type, scan_type, specific_scan_list);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ if (err == 0) {
+ guint list_size = g_slist_length(specific_scan_list);
+ if (list_size == 1)
+ g_scan_type = CONNMAN_SCAN_TYPE_SPECIFIC_AP;
+ else
+ g_scan_type = CONNMAN_SCAN_TYPE_MULTI_AP;
+ DBG("list_size %u g_scan_type %d", list_size, g_scan_type);
+ }
+ technology->scan_pending =
+ g_slist_prepend(technology->scan_pending, msg);
+
+ if (scan_type == CONNMAN_MULTI_SCAN_SSID ||
+ scan_type == CONNMAN_MULTI_SCAN_SSID_FREQ) {
+ g_slist_free_full(specific_scan_list, g_free);
+ scan_type = 0;
+ }
+ return NULL;
+}
+
+static DBusMessage *get_scan_state(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+ DBusMessageIter iter, dict;
+ GSList *list;
+ struct connman_technology *technology = data;
+ dbus_bool_t scanning = false;
+
+ DBG("technology %p", technology);
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+ scanning = connman_device_get_scanning(device);
+ if(scanning)
+ break;
+ }
+
+ DBG("scanning : %d", scanning);
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+
+ connman_dbus_dict_open(&iter, &dict);
+ connman_dbus_dict_append_basic(&dict, "Scanstate",
+ DBUS_TYPE_BOOLEAN,
+ &scanning);
+
+ connman_dbus_dict_close(&iter, &dict);
+
+ return reply;
+}
+#endif
+
+#if defined TIZEN_EXT_WIFI_MESH
+bool __connman_technology_get_connected(enum connman_service_type type)
+{
+ struct connman_technology *technology;
+
+ technology = technology_find(type);
+
+ if (!technology)
+ return false;
+
+ return technology->connected;
+}
+
+void __connman_technology_mesh_interface_create_finished(
+ enum connman_service_type type, bool success,
+ const char *error)
+{
+ DBusMessage *reply;
+ struct connman_technology *technology;
+ DBusMessage *msg;
+ technology = technology_find(type);
+
+ DBG("technology %p success %d", technology, success);
+
+ if (!technology)
+ return;
+
+ msg = technology->mesh_dbus_msg;
+ if (!msg) {
+ DBG("No pending dbus message");
+ return;
+ }
+
+ if (success) {
+ reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+ __connman_device_request_scan(technology->type);
+ } else
+ reply = g_dbus_create_error(msg, CONNMAN_ERROR_INTERFACE
+ ".MeshInterfaceAddFailed", "%s", error);
+ g_dbus_send_message(connection, reply);
+ dbus_message_unref(msg);
+ technology->mesh_dbus_msg = NULL;
+}
+
+void __connman_technology_mesh_interface_remove_finished(
+ enum connman_service_type type, bool success)
+{
+ DBusMessage *reply;
+ struct connman_technology *technology;
+ DBusMessage *msg;
+ technology = technology_find(type);
+
+ DBG("technology %p success %d", technology, success);
+
+ if (!technology || !technology->mesh_dbus_msg)
+ return;
+
+ msg = technology->mesh_dbus_msg;
+ if (!msg) {
+ DBG("No pending dbus message");
+ return;
+ }
+
+ if (success)
+ reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+ else
+ reply = __connman_error_failed(msg, EINVAL);
+ g_dbus_send_message(connection, reply);
+ dbus_message_unref(msg);
+ technology->mesh_dbus_msg = NULL;
+}
+
+void __connman_technology_notify_abort_scan(enum connman_service_type type,
+ int result)
+{
+ DBusMessage *reply;
+ struct connman_technology *technology;
+ DBusMessage *msg;
+ technology = technology_find(type);
+
+ DBG("technology %p result %d", technology, result);
+
+ if (!technology || !technology->mesh_dbus_msg)
+ return;
+
+ msg = technology->mesh_dbus_msg;
+ if (!msg) {
+ DBG("No pending dbus message");
+ return;
+ }
+
+ if (result < 0)
+ reply = __connman_error_scan_abort_failed(msg);
+ else
+ reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ g_dbus_send_message(connection, reply);
+ dbus_message_unref(msg);
+ technology->mesh_dbus_msg = NULL;
+}
+
+static DBusMessage *mesh_commands(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct connman_technology *technology = data;
+ DBusMessageIter iter, value, dict;
+ const char *cmd = NULL, *ifname = NULL, *parent_ifname = NULL;
+ int err;
+
+ DBG("conn %p", conn);
+
+ if (technology->type != CONNMAN_SERVICE_TYPE_MESH)
+ return __connman_error_invalid_arguments(msg);
+
+ if (!dbus_message_iter_init(msg, &iter))
+ return __connman_error_invalid_arguments(msg);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&iter, &cmd);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&iter, &value);
+
+ if (dbus_message_iter_get_arg_type(&value) != DBUS_TYPE_ARRAY)
+ return __connman_error_invalid_arguments(msg);
+
+ DBG("Mesh Command %s", cmd);
+ if (g_str_equal(cmd, "MeshInterfaceAdd")) {
+ dbus_message_iter_recurse(&value, &dict);
+ const char *bridge_ifname = NULL;
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value2;
+ const char *key;
+ int type;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&entry, &value2);
+
+ type = dbus_message_iter_get_arg_type(&value2);
+
+ if (g_str_equal(key, "Ifname")) {
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value2, &ifname);
+ } else if (g_str_equal(key, "ParentIfname")) {
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value2, &parent_ifname);
+ } else if (g_str_equal(key, "BridgeIfname")) {
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value2, &bridge_ifname);
+ }
+ dbus_message_iter_next(&dict);
+ }
+ DBG("Mesh Ifname %s parent %s bridge %s", ifname, parent_ifname,
+ bridge_ifname ? bridge_ifname : "NULL");
+ err = __connman_mesh_add_virtual_interface(ifname, parent_ifname,
+ bridge_ifname);
+
+ if (err != 0) {
+ DBG("Failed to add virtual mesh interface");
+ return __connman_error_failed(msg, -err);
+ }
+
+ DBG("Successfully added virtual mesh interface");
+
+ dbus_message_ref(msg);
+ technology->mesh_dbus_msg = msg;
+
+ } else if (g_str_equal(cmd, "MeshInterfaceRemove")) {
+ dbus_message_iter_recurse(&value, &dict);
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value2;
+ const char *key;
+ int type;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&entry, &value2);
+
+ type = dbus_message_iter_get_arg_type(&value2);
+
+ if (g_str_equal(key, "Ifname")) {
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value2, &ifname);
+ }
+ dbus_message_iter_next(&dict);
+ }
+ DBG("Mesh Ifname %s", ifname);
+ err = __connman_mesh_remove_virtual_interface(ifname);
+
+ if (err != 0) {
+ DBG("Failed to remove virtual mesh interface");
+ return __connman_error_failed(msg, -err);
+ }
+
+ DBG("Successfully removed virtual mesh interface");
+
+ dbus_message_ref(msg);
+ technology->mesh_dbus_msg = msg;
+
+ } else if (g_str_equal(cmd, "MeshCreateNetwork")) {
+ struct connman_mesh *connman_mesh;
+ const char *name = NULL;
+ const char *sec_type = NULL;
+ const char *mesh_ifname = NULL;
+ char *identifier, *group, *address;
+ unsigned int freq = 0;
+ unsigned int ieee80211w = 0;
+ GString *str;
+ int i;
+ dbus_message_iter_recurse(&value, &dict);
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value2;
+ const char *key;
+ int type;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&entry, &value2);
+
+ type = dbus_message_iter_get_arg_type(&value2);
+
+ if (g_str_equal(key, "Name")) {
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value2, &name);
+ } else if (g_str_equal(key, "Frequency")) {
+ if (type != DBUS_TYPE_UINT16)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value2, &freq);
+ } else if (g_str_equal(key, "Security")) {
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value2, &sec_type);
+ } else if (g_str_equal(key, "Pmf")) {
+ if (type != DBUS_TYPE_UINT16)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value2, &ieee80211w);
+ }
+ dbus_message_iter_next(&dict);
+ }
+
+ if (name == NULL || sec_type == NULL || freq == 0)
+ return __connman_error_invalid_arguments(msg);
+
+ DBG("Name %s Frequency %d Security type %s Pmf %u",
+ name, freq, sec_type, ieee80211w);
+
+ if (g_strcmp0(sec_type, "none") != 0 &&
+ g_strcmp0(sec_type, "sae") != 0) {
+ DBG("Unsupported security");
+ return __connman_error_invalid_arguments(msg);
+ }
+
+ mesh_ifname = connman_mesh_get_interface_name();
+
+ if (!connman_mesh_is_interface_created()) {
+ DBG("Mesh interface doesn't exists");
+ return __connman_error_invalid_command(msg);
+ }
+
+ str = g_string_sized_new((strlen(name) * 2) + 24);
+
+ for (i = 0; name[i]; i++)
+ g_string_append_printf(str, "%02x", name[i]);
+
+ g_string_append_printf(str, "_mesh");
+
+ if (g_strcmp0(sec_type, "none") == 0)
+ g_string_append_printf(str, "_none");
+ else if (g_strcmp0(sec_type, "sae") == 0)
+ g_string_append_printf(str, "_sae");
+
+ group = g_string_free(str, FALSE);
+
+ identifier = connman_inet_ifaddr(mesh_ifname);
+ address = connman_inet_ifname2addr(mesh_ifname);
+
+ connman_mesh = connman_mesh_create(identifier, group);
+ connman_mesh_set_name(connman_mesh, name);
+ connman_mesh_set_address(connman_mesh, address);
+ connman_mesh_set_security(connman_mesh, sec_type);
+ connman_mesh_set_frequency(connman_mesh, freq);
+ connman_mesh_set_index(connman_mesh, connman_inet_ifindex(mesh_ifname));
+ connman_mesh_set_peer_type(connman_mesh,
+ CONNMAN_MESH_PEER_TYPE_CREATED);
+ connman_mesh_set_ieee80211w(connman_mesh, ieee80211w);
+
+ connman_mesh_register(connman_mesh);
+ g_free(group);
+ g_free(identifier);
+ g_free(address);
+ DBG("Successfully Created Mesh Network");
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ } else if (g_str_equal(cmd, "AbortScan")) {
+ DBG("Abort Scan method");
+ err = __connman_device_abort_scan(technology->type);
+ if (err != 0) {
+ DBG("Failed to abort scan");
+ return __connman_error_failed(msg, -err);
+ }
+
+ DBG("Successfully requested to abort scan");
+ dbus_message_ref(msg);
+ technology->mesh_dbus_msg = msg;
+
+ } else if (g_str_equal(cmd, "MeshSpecificScan")) {
+ const char *name = NULL;
+ unsigned int freq = 0;
+ dbus_message_iter_recurse(&value, &dict);
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value2;
+ const char *key;
+ int type;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_recurse(&entry, &value2);
+
+ type = dbus_message_iter_get_arg_type(&value2);
+
+ if (g_str_equal(key, "Name")) {
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value2, &name);
+ } else if (g_str_equal(key, "Frequency")) {
+ if (type != DBUS_TYPE_UINT16)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value2, &freq);
+ }
+ dbus_message_iter_next(&dict);
+ }
+
+ DBG("MeshID %s Frequency %d sender %s", name, freq,
+ dbus_message_get_sender(msg));
+
+ dbus_message_ref(msg);
+ technology->scan_pending =
+ g_slist_prepend(technology->scan_pending, msg);
+
+ err = __connman_device_request_mesh_specific_scan(technology->type,
+ name, freq);
+ if (err < 0)
+ reply_scan_pending(technology, err);
+ else
+ DBG("Successfully requested to scan specific Mesh Network");
+
+ } else if (g_str_equal(cmd, "SetMeshGate")) {
+ unsigned int hwmp_rootmode = 0;
+ bool gate_announce = false;
+ unsigned int stp = 0;
+ int err;
+ dbus_message_iter_recurse(&value, &dict);
+ while (dbus_message_iter_get_arg_type(&dict) == DBUS_TYPE_DICT_ENTRY) {
+ DBusMessageIter entry, value2;
+ const char *key;
+ int type;
+
+ dbus_message_iter_recurse(&dict, &entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
+
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
- type = __connman_device_get_service_type(device);
- technology = technology_find(type);
+ dbus_message_iter_recurse(&entry, &value2);
- if (technology == NULL)
- return;
+ type = dbus_message_iter_get_arg_type(&value2);
- if (result < 0) {
- if (technology->driver != NULL &&
- technology->driver->set_regdom != NULL) {
- technology->driver->set_regdom(technology, alpha2);
- return;
- }
+ if (g_str_equal(key, "GateAnnounce")) {
+ if (type != DBUS_TYPE_BOOLEAN)
+ return __connman_error_invalid_arguments(msg);
- alpha2 = NULL;
- }
+ dbus_message_iter_get_basic(&value2, &gate_announce);
+ } else if (g_str_equal(key, "HWMPRootMode")) {
+ if (type != DBUS_TYPE_UINT16)
+ return __connman_error_invalid_arguments(msg);
- connman_technology_regdom_notify(technology, alpha2);
-}
+ dbus_message_iter_get_basic(&value2, &hwmp_rootmode);
+ } else if (g_str_equal(key, "STP")) {
+ if (type != DBUS_TYPE_UINT16)
+ return __connman_error_invalid_arguments(msg);
-static DBusMessage *scan(DBusConnection *conn, DBusMessage *msg, void *data)
-{
- struct connman_technology *technology = data;
- int err;
+ dbus_message_iter_get_basic(&value2, &stp);
+ }
+ dbus_message_iter_next(&dict);
+ }
- DBG ("technology %p request from %s", technology,
- dbus_message_get_sender(msg));
+ DBG("GateAnnounce %d HWMPRootMode %d STP %d sender %s",
+ gate_announce, hwmp_rootmode, stp, dbus_message_get_sender(msg));
- dbus_message_ref(msg);
- technology->scan_pending =
- g_slist_prepend(technology->scan_pending, msg);
+ err = __connman_mesh_set_stp_gate_announce(gate_announce,
+ hwmp_rootmode,
+ stp);
- err = __connman_device_request_scan(technology->type);
- if (err < 0)
- reply_scan_pending(technology, err);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+ } else
+ return __connman_error_invalid_command(msg);
return NULL;
}
+#endif
static const GDBusMethodTable technology_methods[] = {
{ GDBUS_DEPRECATED_METHOD("GetProperties",
GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
NULL, set_property) },
{ GDBUS_ASYNC_METHOD("Scan", NULL, NULL, scan) },
+#if defined TIZEN_EXT
+ { GDBUS_ASYNC_METHOD("SpecificScan", GDBUS_ARGS({ "specificscan", "a{sv}" }),
+ NULL, specific_scan) },
+ { GDBUS_METHOD("GetScanState", NULL, GDBUS_ARGS({ "scan_state", "a{sv}" }),
+ get_scan_state) },
+#endif
+#if defined TIZEN_EXT_WIFI_MESH
+ { GDBUS_ASYNC_METHOD("MeshCommands",
+ GDBUS_ARGS({ "name", "s" }, { "value", "v" }),
+ NULL, mesh_commands) },
+#endif
{ },
};
static const GDBusSignalTable technology_signals[] = {
{ GDBUS_SIGNAL("PropertyChanged",
GDBUS_ARGS({ "name", "s" }, { "value", "v" })) },
+ { GDBUS_SIGNAL("DhcpConnected",
+ GDBUS_ARGS({ "aptype", "s" },
+ { "ipaddr", "s" },
+ { "macaddr", "s" },
+ { "hostname", "s" })) },
+ { GDBUS_SIGNAL("DhcpLeaseDeleted",
+ GDBUS_ARGS({ "aptype", "s" },
+ { "ipaddr", "s" },
+ { "macaddr", "s" },
+ { "hostname", "s" })) },
{ },
};
-static gboolean technology_dbus_register(struct connman_technology *technology)
+static bool technology_dbus_register(struct connman_technology *technology)
{
- if (technology->dbus_registered == TRUE ||
- technology->hardblocked == TRUE)
- return TRUE;
+ if (technology->dbus_registered ||
+ (technology->rfkill_driven &&
+ technology->hardblocked))
+ return true;
- if (g_dbus_register_interface(connection, technology->path,
- CONNMAN_TECHNOLOGY_INTERFACE,
- technology_methods, technology_signals,
- NULL, technology, NULL) == FALSE) {
+ if (!g_dbus_register_interface(connection, technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE,
+ technology_methods, technology_signals,
+ NULL, technology, NULL)) {
connman_error("Failed to register %s", technology->path);
- return FALSE;
+ return false;
}
technology_added_signal(technology);
- technology->dbus_registered = TRUE;
+ technology->dbus_registered = true;
+
+ return true;
+}
+
+static void technology_dbus_unregister(struct connman_technology *technology)
+{
+ if (!technology->dbus_registered)
+ return;
+
+ technology_removed_signal(technology);
+ g_dbus_unregister_interface(connection, technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE);
+
+ technology->dbus_registered = false;
+}
+
+static void technology_put(struct connman_technology *technology)
+{
+ DBG("technology %p", technology);
+
+ if (__sync_sub_and_fetch(&technology->refcount, 1) > 0)
+ return;
- return TRUE;
+ reply_scan_pending(technology, -EINTR);
+
+ while (technology->driver_list) {
+ struct connman_technology_driver *driver;
+
+ driver = technology->driver_list->data;
+
+ if (driver->remove)
+ driver->remove(technology);
+
+ technology->driver_list =
+ g_slist_delete_link(technology->driver_list,
+ technology->driver_list);
+ }
+
+ technology_list = g_slist_remove(technology_list, technology);
+
+ technology_dbus_unregister(technology);
+
+ g_slist_free(technology->device_list);
+
+ if (technology->pending_reply) {
+ dbus_message_unref(technology->pending_reply);
+ technology->pending_reply = NULL;
+ g_source_remove(technology->pending_timeout);
+ technology->pending_timeout = 0;
+ }
+
+ g_free(technology->path);
+ g_free(technology->regdom);
+ g_free(technology->tethering_ident);
+ g_free(technology->tethering_passphrase);
+ g_free(technology);
}
static struct connman_technology *technology_get(enum connman_service_type type)
{
+ GSList *tech_drivers = NULL;
+ struct connman_technology_driver *driver;
struct connman_technology *technology;
- struct connman_technology_driver *driver = NULL;
const char *str;
GSList *list;
- int err;
DBG("type %d", type);
str = __connman_service_type2string(type);
- if (str == NULL)
+ if (!str)
return NULL;
technology = technology_find(type);
- if (technology != NULL) {
- __sync_fetch_and_add(&technology->refcount, 1);
+ if (technology) {
+#if defined TIZEN_EXT_WIFI_MESH
+ if (type != CONNMAN_SERVICE_TYPE_P2P &&
+ type != CONNMAN_SERVICE_TYPE_MESH)
+#else
+ if (type != CONNMAN_SERVICE_TYPE_P2P)
+#endif
+ __sync_fetch_and_add(&technology->refcount, 1);
return technology;
}
for (list = driver_list; list; list = list->next) {
driver = list->data;
- if (driver->type == type)
- break;
- else
- driver = NULL;
+ if (driver->type == type) {
+ DBG("technology %p driver %p", technology, driver);
+ tech_drivers = g_slist_append(tech_drivers, driver);
+ }
}
- if (driver == NULL) {
- DBG("No matching driver found for %s.",
+ if (!tech_drivers) {
+ DBG("No matching drivers found for %s.",
__connman_service_type2string(type));
return NULL;
}
technology = g_try_new0(struct connman_technology, 1);
- if (technology == NULL)
+ if (!technology)
return NULL;
technology->refcount = 1;
-
- if (type == CONNMAN_SERVICE_TYPE_ETHERNET)
- technology->hardblocked = FALSE;
- else
- technology->hardblocked = TRUE;
-
technology->type = type;
+ technology->tethering_hidden = FALSE;
technology->path = g_strdup_printf("%s/technology/%s",
CONNMAN_PATH, str);
- technology->device_list = NULL;
+#if defined TIZEN_EXT_WIFI_MESH
+ if (type == CONNMAN_SERVICE_TYPE_MESH) {
+ struct connman_technology *wifi;
- technology->pending_reply = NULL;
+ wifi = technology_find(CONNMAN_SERVICE_TYPE_WIFI);
+ if (wifi)
+ technology->enabled = wifi->enabled;
+ }
+#endif
technology_load(technology);
+ technology_list = g_slist_prepend(technology_list, technology);
+ technology->driver_list = tech_drivers;
+
+ for (list = tech_drivers; list; list = list->next) {
+ driver = list->data;
+
+ if (driver->probe && driver->probe(technology) < 0)
+ DBG("Driver probe failed for technology %p",
+ technology);
+ }
- if (technology_dbus_register(technology) == FALSE) {
- g_free(technology);
+ if (!technology_dbus_register(technology)) {
+ technology_put(technology);
return NULL;
}
- technology_list = g_slist_prepend(technology_list, technology);
+ if (type == CONNMAN_SERVICE_TYPE_P2P) {
+ struct connman_technology *wifi;
+ bool enable;
- technology->driver = driver;
- err = driver->probe(technology);
- if (err != 0)
- DBG("Driver probe failed for technology %p", technology);
+ enable = technology->enable_persistent;
- DBG("technology %p", technology);
+ wifi = technology_find(CONNMAN_SERVICE_TYPE_WIFI);
+ if (enable && wifi)
+ enable = wifi->enabled;
+
+ technology_affect_devices(technology, enable);
+ }
+
+ DBG("technology %p %s", technology, get_name(technology->type));
return technology;
}
-static void technology_dbus_unregister(struct connman_technology *technology)
+int connman_technology_driver_register(struct connman_technology_driver *driver)
{
- if (technology->dbus_registered == FALSE)
- return;
+ GSList *list;
+ struct connman_device *device;
+ enum connman_service_type type;
- technology_removed_signal(technology);
- g_dbus_unregister_interface(connection, technology->path,
- CONNMAN_TECHNOLOGY_INTERFACE);
+ for (list = driver_list; list; list = list->next) {
+ if (list->data == driver)
+ goto exist;
+ }
+
+ DBG("Registering %s driver", driver->name);
+
+ driver_list = g_slist_insert_sorted(driver_list, driver,
+ compare_priority);
+
+ /*
+ * Check for technology less devices if this driver
+ * can service any of them.
+ */
+ for (list = techless_device_list; list; list = list->next) {
+ device = list->data;
+
+ type = __connman_device_get_service_type(device);
+ if (type != driver->type)
+ continue;
+
+ techless_device_list = g_slist_remove(techless_device_list,
+ device);
+
+ __connman_technology_add_device(device);
+ }
+
+ /* Check for orphaned rfkill switches. */
+ g_hash_table_foreach(rfkill_list, rfkill_check,
+ GINT_TO_POINTER(driver->type));
+
+exist:
+ if (driver->type == CONNMAN_SERVICE_TYPE_P2P) {
+ if (!technology_get(CONNMAN_SERVICE_TYPE_P2P))
+ return -ENOMEM;
+ }
+
+#if defined TIZEN_EXT_WIFI_MESH
+ if (driver->type == CONNMAN_SERVICE_TYPE_MESH) {
+ if (!technology_get(CONNMAN_SERVICE_TYPE_MESH))
+ return -ENOMEM;
+ }
+#endif
- technology->dbus_registered = FALSE;
+ return 0;
}
-static void technology_put(struct connman_technology *technology)
+void connman_technology_driver_unregister(struct connman_technology_driver *driver)
{
- DBG("technology %p", technology);
+ GSList *list, *tech_drivers;
+ struct connman_technology *technology;
+ struct connman_technology_driver *current;
- if (__sync_sub_and_fetch(&technology->refcount, 1) > 0)
- return;
+ DBG("Unregistering driver %p name %s", driver, driver->name);
- reply_scan_pending(technology, -EINTR);
+ for (list = technology_list; list; list = list->next) {
+ technology = list->data;
- if (technology->driver) {
- technology->driver->remove(technology);
- technology->driver = NULL;
- }
+ for (tech_drivers = technology->driver_list; tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+ current = tech_drivers->data;
+ if (driver != current)
+ continue;
- technology_list = g_slist_remove(technology_list, technology);
+ if (driver->remove)
+ driver->remove(technology);
- technology_dbus_unregister(technology);
+ technology->driver_list =
+ g_slist_remove(technology->driver_list,
+ driver);
+ break;
+ }
+ }
- g_slist_free(technology->device_list);
+ driver_list = g_slist_remove(driver_list, driver);
- g_free(technology->path);
- g_free(technology->regdom);
- g_free(technology->tethering_ident);
- g_free(technology->tethering_passphrase);
- g_free(technology);
+ if (driver->type == CONNMAN_SERVICE_TYPE_P2P) {
+ technology = technology_find(CONNMAN_SERVICE_TYPE_P2P);
+ if (technology)
+ technology_put(technology);
+ }
+#if defined TIZEN_EXT_WIFI_MESH
+ if (driver->type == CONNMAN_SERVICE_TYPE_MESH) {
+ technology = technology_find(CONNMAN_SERVICE_TYPE_MESH);
+ if (technology)
+ technology_put(technology);
+ }
+#endif
}
void __connman_technology_add_interface(enum connman_service_type type,
- int index, const char *name, const char *ident)
+ int index, const char *ident)
{
struct connman_technology *technology;
+ GSList *tech_drivers;
+ struct connman_technology_driver *driver;
+ char *name;
switch (type) {
case CONNMAN_SERVICE_TYPE_UNKNOWN:
return;
case CONNMAN_SERVICE_TYPE_ETHERNET:
case CONNMAN_SERVICE_TYPE_WIFI:
- case CONNMAN_SERVICE_TYPE_WIMAX:
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:
+ case CONNMAN_SERVICE_TYPE_P2P:
+#if defined TIZEN_EXT_WIFI_MESH
+ case CONNMAN_SERVICE_TYPE_MESH:
+#endif
break;
}
+ name = connman_inet_ifname(index);
connman_info("Adding interface %s [ %s ]", name,
__connman_service_type2string(type));
technology = technology_find(type);
- if (technology == NULL || technology->driver == NULL
- || technology->driver->add_interface == NULL)
- return;
+ if (!technology)
+ goto out;
+
+ for (tech_drivers = technology->driver_list; tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+ driver = tech_drivers->data;
+
+ if (driver->add_interface)
+ driver->add_interface(technology, index, name, ident);
+ }
- technology->driver->add_interface(technology,
- index, name, ident);
+ /*
+ * At this point we can try to enable tethering automatically as
+ * now the interfaces are set properly.
+ */
+ if (technology->tethering_persistent)
+ enable_tethering(technology);
+
+out:
+ g_free(name);
}
void __connman_technology_remove_interface(enum connman_service_type type,
- int index, const char *name, const char *ident)
+ int index, const char *ident)
{
struct connman_technology *technology;
+ GSList *tech_drivers;
+ struct connman_technology_driver *driver;
+ char *name;
switch (type) {
case CONNMAN_SERVICE_TYPE_UNKNOWN:
return;
case CONNMAN_SERVICE_TYPE_ETHERNET:
case CONNMAN_SERVICE_TYPE_WIFI:
- case CONNMAN_SERVICE_TYPE_WIMAX:
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:
+ case CONNMAN_SERVICE_TYPE_P2P:
+#if defined TIZEN_EXT_WIFI_MESH
+ case CONNMAN_SERVICE_TYPE_MESH:
+#endif
break;
}
+ name = connman_inet_ifname(index);
connman_info("Remove interface %s [ %s ]", name,
__connman_service_type2string(type));
+ g_free(name);
technology = technology_find(type);
- if (technology == NULL || technology->driver == NULL)
+ if (!technology)
return;
- if (technology->driver->remove_interface)
- technology->driver->remove_interface(technology, index);
+ for (tech_drivers = technology->driver_list; tech_drivers;
+ tech_drivers = g_slist_next(tech_drivers)) {
+ driver = tech_drivers->data;
+
+ if (driver->remove_interface)
+ driver->remove_interface(technology, index);
+ }
}
int __connman_technology_add_device(struct connman_device *device)
struct connman_technology *technology;
enum connman_service_type type;
- DBG("device %p", device);
-
type = __connman_device_get_service_type(device);
+ DBG("device %p type %s", device, get_name(type));
+
technology = technology_get(type);
- if (technology == NULL) {
+ if (!technology) {
/*
* Since no driver can be found for this device at the moment we
* add it to the techless device list.
return -ENXIO;
}
+ __sync_synchronize();
+ if (technology->rfkill_driven) {
+ if (technology->enabled)
+ __connman_device_enable(device);
+ else
+ __connman_device_disable(device);
+
+ goto done;
+ }
+
if (technology->enable_persistent &&
- global_offlinemode == FALSE &&
- technology->hardblocked == FALSE) {
+ !global_offlinemode) {
int err = __connman_device_enable(device);
/*
* connman_technology_add_device() calls __connman_device_enable()
if (err == -EALREADY)
__connman_technology_enabled(type);
}
- /* if technology persistent state is offline or hardblocked */
- if (technology->enable_persistent == FALSE ||
- technology->hardblocked == TRUE)
+ /* if technology persistent state is offline */
+ if (!technology->enable_persistent)
__connman_device_disable(device);
+done:
technology->device_list = g_slist_prepend(technology->device_list,
device);
type = __connman_device_get_service_type(device);
technology = technology_find(type);
- if (technology == NULL) {
+ if (!technology) {
techless_device_list = g_slist_remove(techless_device_list,
device);
return -ENXIO;
technology->device_list = g_slist_remove(technology->device_list,
device);
- technology_put(technology);
-
- return 0;
-}
-static void powered_changed(struct connman_technology *technology)
-{
- connman_bool_t powered;
+ if (technology->tethering)
+ set_tethering(technology, false);
- __sync_synchronize();
- if (technology->enabled >0)
- powered = TRUE;
- else
- powered = FALSE;
+ technology_put(technology);
- connman_dbus_property_changed_basic(technology->path,
- CONNMAN_TECHNOLOGY_INTERFACE, "Powered",
- DBUS_TYPE_BOOLEAN, &powered);
+ return 0;
}
int __connman_technology_enabled(enum connman_service_type type)
struct connman_technology *technology;
technology = technology_find(type);
- if (technology == NULL)
+ if (!technology)
return -ENXIO;
- if (__sync_fetch_and_add(&technology->enabled, 1) != 0)
- return -EALREADY;
-
- powered_changed(technology);
-
- if (technology->pending_reply != NULL) {
- g_dbus_send_reply(connection, technology->pending_reply, DBUS_TYPE_INVALID);
- dbus_message_unref(technology->pending_reply);
- g_source_remove(technology->pending_timeout);
- technology->pending_reply = NULL;
- technology->pending_timeout = 0;
+ DBG("technology %p type %s rfkill %d enabled %d", technology,
+ get_name(type), technology->rfkill_driven,
+ technology->enabled);
+#if !defined TIZEN_EXT
+ if (technology->rfkill_driven) {
+ if (technology->tethering_persistent)
+ enable_tethering(technology);
+ return 0;
}
+#endif
- return 0;
+ return technology_enabled(technology);
}
int __connman_technology_disabled(enum connman_service_type type)
{
struct connman_technology *technology;
+ GSList *list;
technology = technology_find(type);
- if (technology == NULL)
+ if (!technology)
return -ENXIO;
+#if !defined TIZEN_EXT
+ if (technology->rfkill_driven)
+ return 0;
+#endif
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
- if (__sync_fetch_and_sub(&technology->enabled, 1) != 1)
- return -EINPROGRESS;
-
- if (technology->pending_reply != NULL) {
- g_dbus_send_reply(connection, technology->pending_reply, DBUS_TYPE_INVALID);
- dbus_message_unref(technology->pending_reply);
- g_source_remove(technology->pending_timeout);
- technology->pending_reply = NULL;
- technology->pending_timeout = 0;
+ if (connman_device_get_powered(device))
+ return 0;
}
- powered_changed(technology);
-
- return 0;
+ return technology_disabled(technology);
}
-int __connman_technology_set_offlinemode(connman_bool_t offlinemode)
+int __connman_technology_set_offlinemode(bool offlinemode)
{
GSList *list;
- int err = -EINVAL;
+ int err = -EINVAL, enabled_tech_count = 0;
if (global_offlinemode == offlinemode)
return 0;
struct connman_technology *technology = list->data;
if (offlinemode)
- err = technology_disable(technology, FALSE);
+ err = technology_disable(technology);
+ else {
+ if (technology->hardblocked)
+ continue;
- if (!offlinemode && technology->enable_persistent)
- err = technology_enable(technology, FALSE);
+ if (technology->enable_persistent) {
+ err = technology_enable(technology);
+ enabled_tech_count++;
+ }
+ }
}
- if (err == 0 || err == -EINPROGRESS || err == -EALREADY) {
+ if (err == 0 || err == -EINPROGRESS || err == -EALREADY ||
+ (err == -EINVAL && enabled_tech_count == 0)) {
connman_technology_save_offlinemode();
__connman_notifier_offlinemode(offlinemode);
} else
return err;
}
+#if defined TIZEN_EXT_WIFI_MESH
+static gboolean __add_ethernet_to_bridge(gpointer data)
+{
+ DBG("");
+ __connman_mesh_add_ethernet_to_bridge();
+ return FALSE;
+}
+#endif
+
void __connman_technology_set_connected(enum connman_service_type type,
- connman_bool_t connected)
+ bool connected)
{
struct connman_technology *technology;
+ dbus_bool_t val;
technology = technology_find(type);
- if (technology == NULL)
+ if (!technology)
return;
DBG("technology %p connected %d", technology, connected);
technology->connected = connected;
+#if defined TIZEN_EXT_WIFI_MESH
+ if (technology->type == CONNMAN_SERVICE_TYPE_ETHERNET && connected)
+ g_idle_add(__add_ethernet_to_bridge, NULL);
+#endif
+
+ val = connected;
connman_dbus_property_changed_basic(technology->path,
CONNMAN_TECHNOLOGY_INTERFACE, "Connected",
- DBUS_TYPE_BOOLEAN, &connected);
+ DBUS_TYPE_BOOLEAN, &val);
}
-static void technology_apply_hardblock_change(struct connman_technology *technology,
- connman_bool_t hardblock)
+static bool technology_apply_rfkill_change(struct connman_technology *technology,
+ bool softblock,
+ bool hardblock,
+ bool new_rfkill)
{
- gboolean apply = TRUE;
+ bool hardblock_changed = false;
+ bool apply = true;
GList *start, *list;
+ DBG("technology %p --> %d/%d vs %d/%d",
+ technology, softblock, hardblock,
+ technology->softblocked, technology->hardblocked);
+
if (technology->hardblocked == hardblock)
- return;
+ goto softblock_change;
- start = g_hash_table_get_values(rfkill_list);
- for (list = start; list != NULL; list = list->next) {
- struct connman_rfkill *rfkill = list->data;
+ if (!(new_rfkill && !hardblock)) {
+ start = g_hash_table_get_values(rfkill_list);
- if (rfkill->type != technology->type)
- continue;
+ for (list = start; list; list = list->next) {
+ struct connman_rfkill *rfkill = list->data;
- if (rfkill->hardblock != hardblock)
- apply = FALSE;
- }
+ if (rfkill->type != technology->type)
+ continue;
- g_list_free(start);
+ if (rfkill->hardblock != hardblock)
+ apply = false;
+ }
- if (apply == FALSE)
- return;
+ g_list_free(start);
+ }
+
+ if (!apply)
+ goto softblock_change;
technology->hardblocked = hardblock;
+ hardblock_changed = true;
+
+softblock_change:
+ if (!apply && technology->softblocked != softblock)
+ apply = true;
+
+ if (!apply)
+ return technology->hardblocked;
+
+ technology->softblocked = softblock;
+
+ if (technology->hardblocked ||
+ technology->softblocked) {
+ if (technology_disabled(technology) != -EALREADY)
+ technology_affect_devices(technology, false);
+ } else if (!technology->hardblocked &&
+ !technology->softblocked) {
+ if (technology_enabled(technology) != -EALREADY)
+ technology_affect_devices(technology, true);
+ }
+
+ if (hardblock_changed) {
+ if (technology->hardblocked) {
+ DBG("%s is switched off.", get_name(technology->type));
+ technology_dbus_unregister(technology);
+ } else {
+ DBG("%s is switched on.", get_name(technology->type));
+ technology_dbus_register(technology);
- if (hardblock == TRUE) {
- DBG("%s is switched off.", get_name(technology->type));
- technology_disable(technology, TRUE);
- technology_dbus_unregister(technology);
- } else {
- technology_enable(technology, TRUE);
- technology_dbus_register(technology);
+ if (global_offlinemode)
+ __connman_rfkill_block(technology->type, true);
+ }
}
+
+ return technology->hardblocked;
}
int __connman_technology_add_rfkill(unsigned int index,
enum connman_service_type type,
- connman_bool_t softblock,
- connman_bool_t hardblock)
+ bool softblock,
+ bool hardblock)
{
struct connman_technology *technology;
struct connman_rfkill *rfkill;
softblock, hardblock);
rfkill = g_hash_table_lookup(rfkill_list, GINT_TO_POINTER(index));
- if (rfkill != NULL)
+ if (rfkill)
goto done;
rfkill = g_try_new0(struct connman_rfkill, 1);
- if (rfkill == NULL)
+ if (!rfkill)
return -ENOMEM;
rfkill->index = index;
g_hash_table_insert(rfkill_list, GINT_TO_POINTER(index), rfkill);
done:
+#if defined TIZEN_EXT
+ /* Fix Svace Issue [WGID: 1348]. */
+ g_free(rfkill);
+#endif
technology = technology_get(type);
/* If there is no driver for this type, ignore it. */
- if (technology == NULL)
+ if (!technology)
return -ENXIO;
- technology_apply_hardblock_change(technology, hardblock);
+ technology->rfkill_driven = true;
+
+#if !defined TIZEN_EXT
+ /* If hardblocked, there is no need to handle softblocked state */
+ if (technology_apply_rfkill_change(technology,
+ softblock, hardblock, true))
+ return 0;
+#endif
+ if (global_offlinemode)
+ return 0;
/*
- * If Offline mode is on, we softblock the device if it isnt already.
- * If Offline mode is off, we rely on the persistent state of tech.
+ * Depending on softblocked state we unblock/block according to
+ * offlinemode and persistente state.
*/
- if (global_offlinemode) {
- if (!softblock)
- return __connman_rfkill_block(type, TRUE);
- } else {
- if (technology->enable_persistent && softblock)
- return __connman_rfkill_block(type, FALSE);
- /* if technology persistent state is offline */
- if (!technology->enable_persistent && !softblock)
- return __connman_rfkill_block(type, TRUE);
- }
+ if (technology->softblocked &&
+ technology->enable_persistent)
+ return __connman_rfkill_block(type, false);
+ else if (!technology->softblocked &&
+ !technology->enable_persistent)
+ return __connman_rfkill_block(type, true);
return 0;
}
int __connman_technology_update_rfkill(unsigned int index,
enum connman_service_type type,
- connman_bool_t softblock,
- connman_bool_t hardblock)
+ bool softblock,
+ bool hardblock)
{
struct connman_technology *technology;
struct connman_rfkill *rfkill;
DBG("index %u soft %u hard %u", index, softblock, hardblock);
rfkill = g_hash_table_lookup(rfkill_list, GINT_TO_POINTER(index));
- if (rfkill == NULL)
+ if (!rfkill)
return -ENXIO;
if (rfkill->softblock == softblock &&
- rfkill->hardblock == hardblock)
+ rfkill->hardblock == hardblock)
return 0;
rfkill->softblock = softblock;
technology = technology_find(type);
/* If there is no driver for this type, ignore it. */
- if (technology == NULL)
+ if (!technology)
return -ENXIO;
- technology_apply_hardblock_change(technology, hardblock);
+ technology_apply_rfkill_change(technology, softblock, hardblock,
+ false);
- if (!global_offlinemode) {
- if (technology->enable_persistent && softblock)
- return __connman_rfkill_block(type, FALSE);
- if (!technology->enable_persistent && !softblock)
- return __connman_rfkill_block(type, TRUE);
- }
+ if (technology->hardblocked)
+ DBG("%s hardblocked", get_name(technology->type));
+ else
+ DBG("%s is%s softblocked", get_name(technology->type),
+ technology->softblocked ? "" : " not");
return 0;
}
DBG("index %u", index);
rfkill = g_hash_table_lookup(rfkill_list, GINT_TO_POINTER(index));
- if (rfkill == NULL)
+ if (!rfkill)
return -ENXIO;
g_hash_table_remove(rfkill_list, GINT_TO_POINTER(index));
technology = technology_find(type);
- if (technology == NULL)
+ if (!technology)
return -ENXIO;
+ technology_apply_rfkill_change(technology,
+ technology->softblocked, !technology->hardblocked, false);
+
technology_put(technology);
return 0;
{
DBG("");
+ while (technology_list) {
+ struct connman_technology *technology = technology_list->data;
+ technology_list = g_slist_remove(technology_list, technology);
+ technology_put(technology);
+ }
+
g_hash_table_destroy(rfkill_list);
dbus_connection_unref(connection);
projects / platform / upstream / connman.git / blobdiff