#include <errno.h>
#include <string.h>
+#if defined TIZEN_EXT
+#include <stdio.h>
+#include <stdlib.h>
+#include <net/if.h>
+#endif
#include <gdbus.h>
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;
+struct connman_scan_pending {
+ char *ifname;
+ connman_scan_type_e scan_type;
+ DBusMessage *msg;
+};
-static connman_scan_type_e g_scan_type = -1;
+struct connman_bssid_pending {
+ char *ifname;
+ unsigned char bssid[6];
+};
#endif
struct connman_rfkill {
*/
char *tethering_ident;
char *tethering_passphrase;
- bool tethering_hidden;
bool enable_persistent; /* Save the tech state */
bool softblocked;
bool hardblocked;
bool dbus_registered;
+#if defined TIZEN_EXT
+ char **enabled_devices;
+ unsigned int mac_policy;
+ unsigned int preassoc_mac_policy;
+ unsigned int random_mac_lifetime;
+#endif
+#if defined TIZEN_EXT_WIFI_MESH
+ DBusMessage *mesh_dbus_msg;
+#endif
};
static GSList *driver_list = NULL;
struct connman_rfkill *rfkill = value;
enum connman_service_type type = GPOINTER_TO_INT(user_data);
- /* Calling _technology_rfkill_add will update the tech. */
+ /* Calling _technology_add_rfkill will update the tech. */
if (rfkill->type == type)
__connman_technology_add_rfkill(rfkill->index, type,
rfkill->softblock, rfkill->hardblock);
return "Cellular";
case CONNMAN_SERVICE_TYPE_P2P:
return "P2P";
+#if defined TIZEN_EXT_WIFI_MESH
+ case CONNMAN_SERVICE_TYPE_MESH:
+ return "Mesh";
+#endif
}
return NULL;
g_key_file_set_boolean(keyfile, identifier, "Tethering",
technology->tethering_persistent);
- g_key_file_set_boolean(keyfile, identifier, "Hidden",
- technology->tethering_hidden);
-
if (technology->tethering_ident)
g_key_file_set_string(keyfile, identifier,
"Tethering.Identifier",
"Tethering.Passphrase",
technology->tethering_passphrase);
+#ifdef TIZEN_EXT
+ if (technology->type == CONNMAN_SERVICE_TYPE_WIFI) {
+ g_key_file_set_uint64(keyfile, identifier, "MacPolicy",
+ technology->mac_policy);
+
+ g_key_file_set_uint64(keyfile, identifier, "PreassocMacPolicy",
+ technology->preassoc_mac_policy);
+
+ g_key_file_set_uint64(keyfile, identifier, "RandomMacLifetime",
+ technology->random_mac_lifetime);
+ }
+#endif /* TIZEN_EXT */
+
done:
g_free(identifier);
__connman_storage_save_global(keyfile);
g_key_file_free(keyfile);
-
- return;
}
static void tethering_changed(struct connman_technology *technology)
technology_save(technology);
}
-void connman_technology_tethering_notify(struct connman_technology *technology,
+int connman_technology_tethering_notify(struct connman_technology *technology,
bool enabled)
{
+ 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)
- __connman_tethering_set_enabled();
- else
- __connman_tethering_set_disabled();
+ return 0;
}
static int set_tethering(struct connman_technology *technology,
int err;
const char *ident, *passphrase, *bridge;
GSList *tech_drivers;
- bool hidden;
ident = technology->tethering_ident;
passphrase = technology->tethering_passphrase;
- hidden = technology->tethering_hidden;
__sync_synchronize();
if (!technology->enabled)
if (!bridge)
return -EOPNOTSUPP;
- if (technology->type == CONNMAN_SERVICE_TYPE_WIFI && (!ident))
+ if (technology->type == CONNMAN_SERVICE_TYPE_WIFI &&
+ (!ident || !passphrase))
return -EINVAL;
for (tech_drivers = technology->driver_list; tech_drivers;
continue;
err = driver->set_tethering(technology, ident, passphrase,
- bridge, enabled, hidden);
+ bridge, enabled);
if (result == -EINPROGRESS)
continue;
- if (err == -EINPROGRESS || err == 0) {
+ if (err == -EINPROGRESS || err == 0)
result = err;
- continue;
- }
}
return result;
return NULL;
}
+enum connman_service_type connman_technology_get_type
+ (struct connman_technology *technology)
+{
+ if (!technology)
+ return CONNMAN_SERVICE_TYPE_UNKNOWN;
+
+ return technology->type;
+}
+
bool connman_technology_get_wifi_tethering(const char **ssid,
const char **psk)
{
return true;
}
+#if defined TIZEN_EXT
+const char *connman_techonology_get_path(enum connman_service_type type)
+{
+ struct connman_technology *technology = technology_find(type);
+
+ if (!technology)
+ return NULL;
+
+ return technology->path;
+}
+#endif
+
static void free_rfkill(gpointer data)
{
struct connman_rfkill *rfkill = data;
if (!identifier)
goto done;
+#ifdef TIZEN_EXT
+ gsize length;
+ technology->enabled_devices = g_key_file_get_string_list(keyfile,
+ identifier, "Enable.Devices", &length, NULL);
+ if (technology->enabled_devices && length == 0) {
+ g_strfreev(technology->enabled_devices);
+ technology->enabled_devices = NULL;
+ }
+#endif
+
enable = g_key_file_get_boolean(keyfile, identifier, "Enable", &error);
if (!error)
technology->enable_persistent = enable;
technology->tethering_passphrase = g_key_file_get_string(keyfile,
identifier, "Tethering.Passphrase", NULL);
+
+#ifdef TIZEN_EXT
+ if (technology->type == CONNMAN_SERVICE_TYPE_WIFI) {
+ unsigned int val = 0;
+
+ val = g_key_file_get_uint64(keyfile,
+ identifier, "MacPolicy", NULL);
+ if (val <= 2)
+ technology->mac_policy = val;
+ else
+ technology->mac_policy = 0;
+
+ val = g_key_file_get_uint64(keyfile,
+ identifier, "PreassocMacPolicy", NULL);
+ if (val <= 2)
+ technology->preassoc_mac_policy = val;
+ else
+ technology->preassoc_mac_policy = 0;
+
+ val = g_key_file_get_uint64(keyfile,
+ identifier, "RandomMacLifetime", NULL);
+ if (val > 0)
+ technology->random_mac_lifetime = val;
+ else
+ technology->random_mac_lifetime = 60;
+ }
+#endif /* TIZEN_EXT */
+
done:
g_free(identifier);
g_key_file_free(keyfile);
-
- return;
}
bool __connman_technology_get_offlinemode(void)
static void connman_technology_save_offlinemode(void)
{
GKeyFile *keyfile;
+ GError *error = NULL;
+ bool offlinemode;
keyfile = __connman_storage_load_global();
- if (!keyfile)
+
+ 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 bool connman_technology_load_offlinemode(void)
return offlinemode;
}
+#if defined TIZEN_EXT
+static void append_devices(DBusMessageIter *iter, void *user_data)
+{
+ GSList *list;
+ dbus_bool_t val;
+ struct connman_technology *technology = user_data;
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ const char *str = connman_device_get_string(device, "Interface");
+ struct connman_network *network = connman_device_get_default_network(device);
+ struct connman_service *service = connman_service_lookup_from_network(network);
+
+ connman_dbus_dict_append_basic(iter, "Ifname",
+ DBUS_TYPE_STRING, &str);
+
+ val = connman_device_get_powered(device);
+ connman_dbus_dict_append_basic(iter, "Powered",
+ DBUS_TYPE_BOOLEAN, &val);
+
+ if (__connman_service_is_connected_state(service, CONNMAN_IPCONFIG_TYPE_IPV4) ||
+ __connman_service_is_connected_state(service, CONNMAN_IPCONFIG_TYPE_IPV6))
+ val = TRUE;
+ else
+ val = FALSE;
+
+ connman_dbus_dict_append_basic(iter, "Connected",
+ DBUS_TYPE_BOOLEAN, &val);
+
+ str = connman_device_get_string(device, "Address");
+ connman_dbus_dict_append_basic(iter, "MAC.Address",
+ DBUS_TYPE_STRING, &str);
+ }
+}
+
+void __connman_technology_append_interfaces(DBusMessageIter *array,
+ enum connman_service_type type, const char *ifname)
+{
+ GSList *list;
+ struct connman_technology *technology = NULL;
+
+ for (list = technology_list; list; list = list->next) {
+ struct connman_technology *local_tech = list->data;
+
+ if (local_tech->type != type)
+ continue;
+
+ technology = local_tech;
+ break;
+ }
+
+ if (!technology)
+ return;
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+ const char *str = connman_device_get_string(device, "Interface");
+
+ if (g_strcmp0(ifname, str) == 0)
+ continue;
+
+ dbus_message_iter_append_basic(array,
+ DBUS_TYPE_STRING, &str);
+ }
+}
+#endif
+
static void append_properties(DBusMessageIter *iter,
struct connman_technology *technology)
{
DBUS_TYPE_STRING,
&technology->tethering_passphrase);
- val = technology->tethering_hidden;
- connman_dbus_dict_append_basic(&dict, "Hidden",
- DBUS_TYPE_BOOLEAN,
- &val);
+ connman_dbus_dict_append_basic(&dict, "MacPolicy",
+ DBUS_TYPE_UINT32,
+ &(technology->mac_policy));
+ connman_dbus_dict_append_basic(&dict, "PreassocMacPolicy",
+ DBUS_TYPE_UINT32,
+ &(technology->preassoc_mac_policy));
+
+ connman_dbus_dict_append_basic(&dict, "RandomMacLifetime",
+ DBUS_TYPE_UINT32,
+ &(technology->random_mac_lifetime));
+#if defined TIZEN_EXT
+ if (technology->type == CONNMAN_SERVICE_TYPE_WIFI)
+ connman_dbus_dict_append_dict(&dict, "Device.List",
+ append_devices, technology);
+#endif
connman_dbus_dict_close(iter, &dict);
}
struct connman_technology *technology = user_data;
DBusMessage *reply;
- /* Power request timedout, send ETIMEDOUT. */
+ /* Power request timed out, send ETIMEDOUT. */
if (technology->pending_reply) {
reply = __connman_error_failed(technology->pending_reply, ETIMEDOUT);
if (reply)
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 (technology->type == CONNMAN_SERVICE_TYPE_P2P) {
technology->enable_persistent = false;
+ __connman_device_stop_scan(CONNMAN_SERVICE_TYPE_P2P);
+ __connman_peer_disconnect_all();
return technology_disabled(technology);
} else if (technology->type == CONNMAN_SERVICE_TYPE_WIFI) {
struct connman_technology *p2p;
return reply;
}
-static DBusMessage *set_property(DBusConnection *conn,
- DBusMessage *msg, void *data)
+#if defined TIZEN_EXT
+int set_connman_bssid(enum bssid_type mode, char *bssid, const char *ifname)
{
- struct connman_technology *technology = data;
- DBusMessageIter iter, value;
- const char *name;
- int type;
-
- DBG("conn %p", conn);
-
- if (!dbus_message_iter_init(msg, &iter))
- return __connman_error_invalid_arguments(msg);
+ static int bssid_len;
+ static const char *def_ifname = "default";
+ static GSList *bssid_list = NULL;
+ GSList *list;
+ const char *local_ifname = ifname;
+ bool found = false;
+ struct connman_bssid_pending *bssid_info;
- if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
- return __connman_error_invalid_arguments(msg);
+ DBG("mode: %d, ifname: %s", mode, ifname);
- dbus_message_iter_get_basic(&iter, &name);
- dbus_message_iter_next(&iter);
+ if (!ifname)
+ local_ifname = def_ifname;
- if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_VARIANT)
- return __connman_error_invalid_arguments(msg);
+ for (list = bssid_list; list; list = list->next) {
+ bssid_info = list->data;
- dbus_message_iter_recurse(&iter, &value);
+ if (g_strcmp0(bssid_info->ifname, local_ifname) == 0) {
+ found = true;
+ break;
+ }
+ }
- type = dbus_message_iter_get_arg_type(&value);
+ if (mode == CHECK_BSSID) {
+ if (found)
+ return 6;
- DBG("property %s", name);
+ return 0;
+ }
- 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 (mode == GET_BSSID && bssid) {
+ if (found) {
+ memcpy(bssid, bssid_info->bssid, 6);
+ return 6;
}
+ return 0;
+ }
- 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 (mode == RESET_BSSID) {
+ if (found) {
+ bssid_list = g_slist_remove(bssid_list, bssid_info);
+ g_free(bssid_info->ifname);
+ g_free(bssid_info);
}
+ return 0;
}
- if (g_str_equal(name, "Tethering")) {
- dbus_bool_t tethering;
- int err;
+ if (mode != SET_BSSID || !bssid) {
+ DBG("Invalid parameter");
+ return 0;
+ }
- if (type != DBUS_TYPE_BOOLEAN)
- return __connman_error_invalid_arguments(msg);
+ if (found) {
+ bssid_list = g_slist_remove(bssid_list, bssid_info);
+ g_free(bssid_info->ifname);
+ g_free(bssid_info);
+ }
- 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);
- }
+ bssid_info = g_try_malloc0(sizeof(struct connman_bssid_pending));
+ if (!bssid_info) {
+ DBG("Failed to allocate memory");
+ return 0;
+ }
- dbus_message_iter_get_basic(&value, &tethering);
+ unsigned char *bssid_data = bssid_info->bssid;
- if (technology->tethering == tethering) {
- if (!tethering)
- return __connman_error_already_disabled(msg);
- else
- return __connman_error_already_enabled(msg);
- }
+ bssid_len = sscanf(bssid, "%02hhx:%02hhx:%02hhx:%02hhx:%02hhx:%02hhx",
+ &bssid_data[0], &bssid_data[1], &bssid_data[2],
+ &bssid_data[3], &bssid_data[4], &bssid_data[5]);
+ if (bssid_len != 6) {
+ DBG("Incorrect BSSID format. bssid_len = %d", bssid_len);
+ g_free(bssid_info);
+ return 0;
+ }
- err = set_tethering(technology, tethering);
- if (err < 0)
- return __connman_error_failed(msg, -err);
+ DBG("SET BSSID len: %d, BSSID: %02x:%02x:%02x:%02x:%02x:%02x ifname: %s",
+ bssid_len,
+ bssid_data[0], bssid_data[1], bssid_data[2],
+ bssid_data[3], bssid_data[4], bssid_data[5],
+ ifname);
- technology->tethering_persistent = tethering;
+ bssid_info->ifname = g_strdup(ifname);
+ bssid_list = g_slist_prepend(bssid_list, bssid_info);
- technology_save(technology);
+ return bssid_len;
+}
- } else if (g_str_equal(name, "TetheringIdentifier")) {
- const char *str;
+void connman_technology_mac_policy_notify(struct connman_technology *technology,
+ unsigned int policy)
+{
+ DBG("Mac polict set to %u", policy);
- dbus_message_iter_get_basic(&value, &str);
+ technology->mac_policy = policy;
+ technology_save(technology);
+}
- if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
- return __connman_error_not_supported(msg);
+void __connman_technology_notify_mac_policy_by_device(struct connman_device *device,
+ int result, unsigned int policy)
+{
+ struct connman_technology *technology;
+ enum connman_service_type type;
- if (strlen(str) < 1 || strlen(str) > 32)
- return __connman_error_invalid_arguments(msg);
+ type = __connman_device_get_service_type(device);
+ technology = technology_find(type);
- if (g_strcmp0(technology->tethering_ident, str) != 0) {
- g_free(technology->tethering_ident);
- technology->tethering_ident = g_strdup(str);
- technology_save(technology);
+ if (!technology)
+ return;
- connman_dbus_property_changed_basic(technology->path,
- CONNMAN_TECHNOLOGY_INTERFACE,
- "TetheringIdentifier",
- DBUS_TYPE_STRING,
- &technology->tethering_ident);
- }
- } else if (g_str_equal(name, "TetheringPassphrase")) {
- const char *str;
+ connman_technology_mac_policy_notify(technology, policy);
+}
- dbus_message_iter_get_basic(&value, &str);
+static DBusMessage *set_mac_policy(struct connman_technology *technology,
+ DBusMessage *msg, unsigned int policy)
+{
+ DBusMessage *reply = NULL;
+ int err = 0;
+ unsigned int last_policy = technology->mac_policy;
- if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
- return __connman_error_not_supported(msg);
+ if (technology->rfkill_driven && technology->hardblocked) {
+ err = -EACCES;
+ goto make_reply;
+ }
- if (strlen(str) < 8 || strlen(str) > 63) {
- if (g_str_equal(str, "")) {
- technology->tethering_passphrase = NULL;
+ for (GSList *list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
- connman_dbus_property_changed_basic(technology->path,
- CONNMAN_TECHNOLOGY_INTERFACE,
- "TetheringPassphrase",
- DBUS_TYPE_STRING,
- &str);
- }
- else
- return __connman_error_passphrase_required(msg);
- } else {
- if (g_strcmp0(technology->tethering_passphrase, str) != 0) {
- g_free(technology->tethering_passphrase);
- technology->tethering_passphrase = g_strdup(str);
- technology_save(technology);
+ err = connman_device_set_mac_policy(device, policy);
+ if (err < 0)
+ break;
+ }
- connman_dbus_property_changed_basic(technology->path,
- CONNMAN_TECHNOLOGY_INTERFACE,
- "TetheringPassphrase",
- DBUS_TYPE_STRING,
- &technology->tethering_passphrase);
+make_reply:
+ if (err < 0) {
+ if (err != -EACCES && err != -EOPNOTSUPP) {
+ for (GSList *list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ connman_device_set_mac_policy(device, last_policy);
}
}
- } else if (g_str_equal(name, "Hidden")) {
- dbus_bool_t hidden;
- if (type != DBUS_TYPE_BOOLEAN)
- return __connman_error_invalid_arguments(msg);
+ reply = __connman_error_failed(msg, -err);
+ } else {
+ reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+ }
- dbus_message_iter_get_basic(&value, &hidden);
+ return reply;
+}
- if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
- return __connman_error_not_supported(msg);
+void connman_technology_preassoc_mac_policy_notify(struct connman_technology *technology,
+ unsigned int policy)
+{
+ DBG("Preassoc mac polict set to %u", policy);
- technology->tethering_hidden = hidden;
- technology_save(technology);
+ technology->preassoc_mac_policy = policy;
+ technology_save(technology);
+}
- 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;
+void __connman_technology_notify_preassoc_mac_policy_by_device(struct connman_device *device,
+ int result, unsigned int policy)
+{
+ struct connman_technology *technology;
+ enum connman_service_type type;
- if (type != DBUS_TYPE_BOOLEAN)
- return __connman_error_invalid_arguments(msg);
+ type = __connman_device_get_service_type(device);
+ technology = technology_find(type);
+
+ if (!technology)
+ return;
+
+ connman_technology_preassoc_mac_policy_notify(technology, policy);
+}
+
+static DBusMessage *set_preassoc_mac_policy(struct connman_technology *technology,
+ DBusMessage *msg, unsigned int policy)
+{
+ DBusMessage *reply = NULL;
+ int err = 0;
+ unsigned int last_policy = technology->preassoc_mac_policy;
+
+ if (technology->rfkill_driven && technology->hardblocked) {
+ err = -EACCES;
+ goto make_reply;
+ }
+
+ for (GSList *list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ err = connman_device_set_preassoc_mac_policy(device, policy);
+ if (err < 0)
+ break;
+ }
+
+make_reply:
+ if (err < 0) {
+ if (err != -EACCES && err != -EOPNOTSUPP) {
+ for (GSList *list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ connman_device_set_preassoc_mac_policy(device, last_policy);
+ }
+ }
+
+ reply = __connman_error_failed(msg, -err);
+ } else {
+ reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+ }
+
+ return reply;
+}
+
+void connman_technology_random_mac_lifetime_notify(struct connman_technology *technology,
+ unsigned int lifetime)
+{
+ DBG("Random mac lifetime set to %u", lifetime);
+
+ technology->random_mac_lifetime = lifetime;
+ technology_save(technology);
+}
+
+void __connman_technology_notify_random_mac_lifetime_by_device(struct connman_device *device,
+ int result, unsigned int lifetime)
+{
+ struct connman_technology *technology;
+ enum connman_service_type type;
+
+ type = __connman_device_get_service_type(device);
+ technology = technology_find(type);
+
+ if (!technology)
+ return;
+
+ connman_technology_random_mac_lifetime_notify(technology, lifetime);
+}
+
+static DBusMessage *set_random_mac_lifetime(struct connman_technology *technology,
+ DBusMessage *msg, unsigned int lifetime)
+{
+ DBusMessage *reply = NULL;
+ int err = 0;
+ unsigned int last_lifetime = technology->random_mac_lifetime;
+
+ if (technology->rfkill_driven && technology->hardblocked) {
+ err = -EACCES;
+ goto make_reply;
+ }
+
+ for (GSList *list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ err = connman_device_set_random_mac_lifetime(device, lifetime);
+ }
+
+make_reply:
+ if (err < 0) {
+ if (err != -EACCES && err != -EOPNOTSUPP) {
+ for (GSList *list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ connman_device_set_random_mac_lifetime(device, last_lifetime);
+ }
+ }
+
+ reply = __connman_error_failed(msg, -err);
+ } else {
+ reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+ }
+
+ return reply;
+}
+#endif
+
+static DBusMessage *set_property(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct connman_technology *technology = data;
+ DBusMessageIter iter, value;
+ const char *name;
+ int type, err;
+
+ DBG("conn %p", conn);
+
+ 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, &name);
+ 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);
+
+ type = dbus_message_iter_get_arg_type(&value);
+
+ DBG("property %s", name);
+
+ if (g_str_equal(name, "Tethering")) {
+ dbus_bool_t tethering;
+ int err;
+
+ 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)
+ return __connman_error_already_disabled(msg);
+ else
+ return __connman_error_already_enabled(msg);
+ }
+
+ err = set_tethering(technology, tethering);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ technology->tethering_persistent = tethering;
+
+ technology_save(technology);
+
+ } else if (g_str_equal(name, "TetheringIdentifier")) {
+ 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) < 1 || strlen(str) > 32)
+ return __connman_error_invalid_arguments(msg);
+
+ if (g_strcmp0(technology->tethering_ident, str) != 0) {
+ g_free(technology->tethering_ident);
+ technology->tethering_ident = g_strdup(str);
+ technology_save(technology);
+
+ connman_dbus_property_changed_basic(technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE,
+ "TetheringIdentifier",
+ DBUS_TYPE_STRING,
+ &technology->tethering_ident);
+ }
+ } 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);
+
+ 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) {
+ g_free(technology->tethering_passphrase);
+ technology->tethering_passphrase = g_strdup(str);
+ technology_save(technology);
+
+ connman_dbus_property_changed_basic(technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE,
+ "TetheringPassphrase",
+ DBUS_TYPE_STRING,
+ &technology->tethering_passphrase);
+ }
+ } else if (g_str_equal(name, "Powered")) {
+ dbus_bool_t enable;
+
+ if (type != DBUS_TYPE_BOOLEAN)
+ return __connman_error_invalid_arguments(msg);
dbus_message_iter_get_basic(&value, &enable);
return set_powered(technology, msg, enable);
+#if defined TIZEN_EXT
+ } else if (g_str_equal(name, "SetBSSID")) {
+ char *key;
+
+ 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, NULL);
+ } else if (g_str_equal(name, "MacPolicy")) {
+ dbus_uint32_t mac_policy;
+
+ if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
+ return __connman_error_not_supported(msg);
+
+ if (type != DBUS_TYPE_UINT32)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value, &mac_policy);
+
+ if (mac_policy <= 2)
+ return set_mac_policy(technology, msg, mac_policy);
+ else
+ return __connman_error_invalid_arguments(msg);
+
+ } else if (g_str_equal(name, "PreassocMacPolicy")) {
+ dbus_uint32_t preassoc_mac_policy;
+
+ if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
+ return __connman_error_not_supported(msg);
+
+ if (type != DBUS_TYPE_UINT32)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value, &preassoc_mac_policy);
+
+ if (preassoc_mac_policy <= 2)
+ return set_preassoc_mac_policy(technology, msg, preassoc_mac_policy);
+ else
+ return __connman_error_invalid_arguments(msg);
+
+ } else if (g_str_equal(name, "RandomMacLifetime")) {
+ dbus_uint32_t random_mac_lifetime;
+
+ if (technology->type != CONNMAN_SERVICE_TYPE_WIFI)
+ return __connman_error_not_supported(msg);
+
+ if (type != DBUS_TYPE_UINT32)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&value, &random_mac_lifetime);
+
+ if (random_mac_lifetime > 0)
+ return set_random_mac_lifetime(technology, msg, random_mac_lifetime);
+ else
+ return __connman_error_invalid_arguments(msg);
+#endif
} else
return __connman_error_invalid_property(msg);
DBG("technology %p err %d", technology, err);
while (technology->scan_pending) {
+#if defined TIZEN_EXT
+ struct connman_scan_pending *pending_data = technology->scan_pending->data;
+ DBusMessage *msg = pending_data->msg;
+#else
DBusMessage *msg = technology->scan_pending->data;
-
+#endif
DBG("reply to %s", dbus_message_get_sender(msg));
if (err == 0)
technology->scan_pending =
g_slist_delete_link(technology->scan_pending,
technology->scan_pending);
+#if defined TIZEN_EXT
+ g_free(pending_data->ifname);
+ g_free(pending_data);
+#endif
}
}
if (!signal)
return result;
- dbus_message_iter_init_append(signal, &iter);
- connman_dbus_property_append_basic(&iter, key, DBUS_TYPE_BOOLEAN, val);
+ dbus_message_iter_init_append(signal, &iter);
+ if (key)
+ connman_dbus_property_append_basic(&iter, key, DBUS_TYPE_BOOLEAN, val);
+ else
+ connman_dbus_property_append_basic(&iter, "", DBUS_TYPE_BOOLEAN, val);
+
+ result = dbus_connection_send(connection, signal, NULL);
+ dbus_message_unref(signal);
+
+ DBG("Successfuly sent signal");
+
+ return result;
+}
+
+void __connman_technology_notify_scan_done(const char *ifname, int val)
+{
+ DBG("");
+ DBusMessage *signal;
+ DBusMessageIter iter;
+
+ signal = dbus_message_new_signal(CONNMAN_MANAGER_PATH,
+ CONNMAN_MANAGER_INTERFACE, "ScanDone");
+ if (!signal)
+ return;
+
+ dbus_message_iter_init_append(signal, &iter);
+ if (ifname)
+ connman_dbus_property_append_basic(&iter, ifname,
+ DBUS_TYPE_INT32, &val);
+ else
+ connman_dbus_property_append_basic(&iter, "",
+ DBUS_TYPE_INT32, &val);
+
+ dbus_connection_send(connection, signal, NULL);
+ dbus_message_unref(signal);
+
+ DBG("Successfuly sent ScanDone signal");
+}
+
+static void reply_scan_pending_device(
+ struct connman_technology *technology, const char *ifname, int count)
+{
+ DBusMessage *reply;
+ GSList *list;
+ dbus_bool_t status = 0;
+ connman_scan_type_e scan_type = CONNMAN_SCAN_TYPE_UNKNOWN;
+
+ DBG("technology %p ifname %s count %d", technology, ifname, count);
+
+ list = technology->scan_pending;
+
+ while (list) {
+ struct connman_scan_pending *pending_data = list->data;
+ DBusMessage *msg = pending_data->msg;
+ list = list->next;
+
+ if (scan_type == CONNMAN_SCAN_TYPE_UNKNOWN)
+ scan_type = pending_data->scan_type;
+
+ if (count != 0 && g_strcmp0(pending_data->ifname, ifname) != 0)
+ continue;
+
+ scan_type = pending_data->scan_type;
+
+ DBG("reply to %s", dbus_message_get_sender(msg));
+ reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ g_dbus_send_message(connection, reply);
+ dbus_message_unref(msg);
+
+ technology->scan_pending =
+ g_slist_remove(technology->scan_pending, pending_data);
+
+ g_free(pending_data->ifname);
+ g_free(pending_data);
+ }
+
+ if (scan_type == CONNMAN_SCAN_TYPE_UNKNOWN)
+ scan_type = CONNMAN_SCAN_TYPE_FULL_CHANNEL;
+
+ __connman_technology_notify_scan_changed(ifname, &status);
+ __connman_technology_notify_scan_done(ifname, scan_type);
+}
+
+static void __connman_technology_notify_device_detected(
+ struct connman_technology *technology, const char *ifname, bool val)
+{
+ DBG("");
+ DBusMessage *signal;
+ DBusMessageIter iter;
+ dbus_bool_t detected = val;
+
+ if (!ifname)
+ return;
+
+ signal = dbus_message_new_signal(technology->path,
+ CONNMAN_TECHNOLOGY_INTERFACE, "DeviceDetected");
+ if (!signal)
+ return;
+
+ dbus_message_iter_init_append(signal, &iter);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_STRING, &ifname);
+ dbus_message_iter_append_basic(&iter, DBUS_TYPE_BOOLEAN, &detected);
+
+ dbus_connection_send(connection, signal, NULL);
+ dbus_message_unref(signal);
+
+ DBG("Successfuly sent DeviceDetected signal");
+}
+#endif
+
+void __connman_technology_scan_started(struct connman_device *device)
+{
+ DBG("device %p", device);
+#if defined TIZEN_EXT
+ dbus_bool_t status = 1;
+ const char *ifname = connman_device_get_string(device, "Interface");
+
+ __connman_technology_notify_scan_changed(ifname, &status);
+#endif
+}
+
+void __connman_technology_scan_stopped(struct connman_device *device,
+ enum connman_service_type type)
+{
+ int count = 0;
+ struct connman_technology *technology;
+ GSList *list;
+
+ technology = technology_find(type);
+
+ DBG("technology %p device %p", technology, device);
+
+ if (!technology)
+ return;
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *other_device = list->data;
+
+ if (device == other_device)
+ continue;
+
+ if (connman_device_get_scanning(other_device, type))
+ count += 1;
+ }
+
+#if defined TIZEN_EXT
+ const char *ifname = connman_device_get_string(device, "Interface");
+ reply_scan_pending_device(technology, ifname, count);
+
+ return;
+#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);
+
+#if !defined TIZEN_EXT
+ dbus_message_ref(msg);
+ technology->scan_pending =
+ g_slist_prepend(technology->scan_pending, msg);
+#endif
+
+ err = __connman_device_request_scan_full(technology->type);
+ if (err < 0)
+#if defined TIZEN_EXT
+ return __connman_error_failed(msg, -err);
+#else
+ reply_scan_pending(technology, err);
+#endif
+
+#if defined TIZEN_EXT
+ struct connman_scan_pending *pending_data =
+ g_try_malloc0(sizeof(struct connman_scan_pending));
+ if (!pending_data)
+ return __connman_error_failed(msg, ENOMEM);
+
+ pending_data->scan_type = CONNMAN_SCAN_TYPE_FULL_CHANNEL;
+ DBG("scan_type %d", pending_data->scan_type);
+
+ pending_data->msg = dbus_message_ref(msg);
+
+ technology->scan_pending =
+ g_slist_prepend(technology->scan_pending, pending_data);
+#endif
+ return NULL;
+}
+
+#if defined TIZEN_EXT
+static DBusMessage *scan_device(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+ struct connman_technology *technology = data;
+ DBusMessageIter iter;
+ const char *ifname;
+ 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_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&iter, &ifname);
+ DBG("Interface name %s", ifname);
+
+ if (!ifname || strlen(ifname) == 0)
+ return __connman_error_invalid_arguments(msg);
+
+ err = connman_device_request_device_scan(technology->type, ifname, true);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ struct connman_scan_pending *pending_data =
+ g_try_malloc0(sizeof(struct connman_scan_pending));
+ if (!pending_data)
+ return __connman_error_failed(msg, ENOMEM);
+
+ pending_data->ifname = g_strdup(ifname);
+ if (pending_data->ifname == NULL) {
+ g_free(pending_data);
+ return __connman_error_failed(msg, ENOMEM);
+ }
+
+ pending_data->scan_type = CONNMAN_SCAN_TYPE_FULL_CHANNEL;
+ DBG("scan_type %d", pending_data->scan_type);
+
+ pending_data->msg = dbus_message_ref(msg);
+
+ technology->scan_pending =
+ g_slist_prepend(technology->scan_pending, pending_data);
+
+ return NULL;
+}
+
+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;
+ const char *ifname = 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, "Ifname") && type == DBUS_TYPE_STRING) {
+
+ dbus_message_iter_get_basic(&value2, &ifname);
+ DBG("ifname %s", ifname);
+ } else 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);
+ }
+
+ err = __connman_device_request_specific_scan(technology->type, ifname, scan_type, specific_scan_list);
+ if (err < 0)
+ return __connman_error_failed(msg, -err);
+
+ guint list_size = g_slist_length(specific_scan_list);
+
+ if (scan_type == CONNMAN_MULTI_SCAN_SSID ||
+ scan_type == CONNMAN_MULTI_SCAN_SSID_FREQ)
+ g_slist_free_full(specific_scan_list, g_free);
+
+ struct connman_scan_pending *pending_data =
+ g_try_malloc0(sizeof(struct connman_scan_pending));
+ if (!pending_data)
+ return __connman_error_failed(msg, ENOMEM);
+
+ if (ifname) {
+ pending_data->ifname = g_strdup(ifname);
+ if (pending_data->ifname == NULL) {
+ g_free(pending_data);
+ return __connman_error_failed(msg, ENOMEM);
+ }
+ }
+
+ if (list_size == 1)
+ pending_data->scan_type = CONNMAN_SCAN_TYPE_SPECIFIC_AP;
+ else
+ pending_data->scan_type = CONNMAN_SCAN_TYPE_MULTI_AP;
+ DBG("list_size %u scan_type %d", list_size, pending_data->scan_type);
+
+ pending_data->msg = dbus_message_ref(msg);
+
+ technology->scan_pending =
+ g_slist_prepend(technology->scan_pending, pending_data);
+
+ return NULL;
+}
+
+static DBusMessage *get_5ghz_supported(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+ DBusMessageIter iter, dict;
+ GSList *list;
+ struct connman_technology *technology = data;
+ dbus_bool_t supported = false;
+ const char *ifname = NULL;
+
+ DBG("technology %p", technology);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+ connman_dbus_dict_open(&iter, &dict);
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ supported = connman_device_get_wifi_5ghz_supported(device);
+ ifname = connman_device_get_string(device, "Interface");
+
+ DBG("ifname %s supported : %d", ifname, supported);
+ connman_dbus_dict_append_basic(&dict, ifname,
+ DBUS_TYPE_BOOLEAN,
+ &supported);
+ }
+
+ connman_dbus_dict_close(&iter, &dict);
+
+ return reply;
+}
+
+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;
+ const char *ifname = NULL;
+
+ DBG("technology %p", technology);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+ connman_dbus_dict_open(&iter, &dict);
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ scanning = connman_device_get_scanning(device, technology->type);
+ ifname = connman_device_get_string(device, "Interface");
+
+ DBG("ifname %s scanning : %d", ifname, scanning);
+ connman_dbus_dict_append_basic(&dict, ifname,
+ DBUS_TYPE_BOOLEAN,
+ &scanning);
+ }
+
+ connman_dbus_dict_close(&iter, &dict);
+
+ return reply;
+}
+
+static DBusMessage *get_max_scan_ssid(DBusConnection *conn, DBusMessage *msg, void *data)
+{
+ DBusMessage *reply;
+ DBusMessageIter iter, dict;
+ GSList *list;
+ struct connman_technology *technology = data;
+ dbus_int32_t max_scan_ssids = 0;
+ const char *ifname = NULL;
+
+ DBG("technology %p", technology);
+
+ reply = dbus_message_new_method_return(msg);
+ if (!reply)
+ return NULL;
+
+ dbus_message_iter_init_append(reply, &iter);
+ connman_dbus_dict_open(&iter, &dict);
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ max_scan_ssids = connman_device_get_max_scan_ssids(device);
+ ifname = connman_device_get_string(device, "Interface");
+
+ DBG("ifname %s max_scan_ssids : %d", ifname, max_scan_ssids);
+ connman_dbus_dict_append_basic(&dict, ifname,
+ DBUS_TYPE_INT32,
+ &max_scan_ssids);
+ }
+
+ connman_dbus_dict_close(&iter, &dict);
+
+ return reply;
+}
+
+static int technology_enable_device(struct connman_technology *technology,
+ bool enable_device, const char *ifname, struct connman_device **device_out)
+{
+ int err = 0;
+ GSList *list;
+
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+ const char *str = connman_device_get_string(device, "Interface");
+
+ if (g_strcmp0(str, ifname) != 0)
+ continue;
+
+ if (enable_device)
+ err = __connman_device_enable(device);
+ else
+ err = __connman_device_disable(device);
+
+ *device_out = device;
+ return err;
+ }
+
+ return -ENXIO;
+}
+
+static DBusMessage *technology_set_device_powered(struct connman_technology *technology,
+ DBusMessage *msg, bool powered, const char *ifname)
+{
+ DBusMessage *reply = NULL;
+ struct connman_device *device = NULL;
+ int err = 0;
+
+ err = technology_enable_device(technology, powered, ifname, &device);
+
+ if (err == -EINPROGRESS) {
+ if (device)
+ connman_device_set_pending_reply(device, msg);
+ return reply;
+ } else if (err == -EALREADY) {
+ if (powered)
+ reply = __connman_error_already_enabled(msg);
+ else
+ reply = __connman_error_already_disabled(msg);
+ } else if (err < 0)
+ reply = __connman_error_failed(msg, -err);
+ else
+ reply = g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+
+ return reply;
+}
+
+static DBusMessage *set_device_power(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ struct connman_technology *technology = data;
+ DBusMessageIter iter;
+ const char *name;
+ int len;
+ dbus_bool_t enable;
+
+ DBG("conn %p", conn);
+
+ 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, &name);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_BOOLEAN)
+ return __connman_error_invalid_arguments(msg);
+
+ DBG("interface name %s", name);
+
+ len = strlen(name);
+
+ if (len + 1 > IFNAMSIZ)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&iter, &enable);
+ DBG("powered %s", enable ? "TRUE" : "FALSE");
+
+ return technology_set_device_powered(technology, msg, enable, name);
+}
+
+static DBusMessage *set_bssid(DBusConnection *conn,
+ DBusMessage *msg, void *data)
+{
+ DBusMessageIter iter;
+ char *name, *bssid;
+ int len;
+
+ DBG("conn %p", conn);
+
+ 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, &name);
+ dbus_message_iter_next(&iter);
+
+ if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
+
+ dbus_message_iter_get_basic(&iter, &bssid);
+
+ DBG("interface name %s bssid %s", name, bssid);
+
+ len = strlen(name);
+
+ if (len + 1 > IFNAMSIZ)
+ return __connman_error_invalid_arguments(msg);
+
+ set_connman_bssid(SET_BSSID, bssid, name);
+
+ return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
+}
+static struct connman_technology *technology_get(enum connman_service_type type);
+
+void technology_save_device(struct connman_device *device)
+{
+ struct connman_technology *technology;
+ enum connman_service_type type;
+
+ type = __connman_device_get_service_type(device);
+ technology = technology_get(type);
+ if (!technology)
+ return;
+
+ GKeyFile *keyfile;
+ gchar *identifier;
+ const char *name = get_name(technology->type);
+
+ DBG("technology %p type %d name %s", technology, technology->type,
+ name);
+ if (!name)
+ return;
+
+ keyfile = __connman_storage_load_global();
+ if (!keyfile)
+ keyfile = g_key_file_new();
+
+ identifier = g_strdup_printf("%s", name);
+ if (!identifier)
+ goto done;
+
+ GSList *list = NULL;
+ gchar **ifname_list = NULL;
+ guint dev_count = g_slist_length(technology->device_list);
+
+ if (dev_count > 1) {
+ GString *ifname_str = g_string_new(NULL);
+
+ if (ifname_str) {
+ for (list = technology->device_list; list; list = list->next) {
+ struct connman_device *device = list->data;
+
+ if (connman_device_get_powered(device)) {
+ const char *ifname = connman_device_get_string(device, "Interface");
+
+ if (ifname_str->len > 0)
+ g_string_append_printf(ifname_str, " %s", ifname);
+ else
+ g_string_append(ifname_str, ifname);
+ }
+ }
+
+ if (ifname_str->len > 0) {
+ ifname_list = g_strsplit_set(ifname_str->str, " ", 0);
+ dev_count = g_strv_length(ifname_list);
+ g_key_file_set_string_list(keyfile, identifier, "Enable.Devices",
+ (const gchar **) ifname_list, dev_count);
+
+ technology->enable_persistent = true;
+ } else {
+ g_key_file_remove_key(keyfile, identifier, "Enable.Devices", NULL);
+ technology->enable_persistent = false;
+ }
+
+ g_strfreev(ifname_list);
+ g_string_free(ifname_str, TRUE);
+ }
+ }
+
+ g_key_file_set_boolean(keyfile, identifier, "Enable",
+ technology->enable_persistent);
+
+ g_key_file_set_boolean(keyfile, identifier, "Tethering",
+ technology->tethering_persistent);
+
+ if (technology->tethering_ident)
+ g_key_file_set_string(keyfile, identifier,
+ "Tethering.Identifier",
+ technology->tethering_ident);
+
+ if (technology->tethering_passphrase)
+ g_key_file_set_string(keyfile, identifier,
+ "Tethering.Passphrase",
+ technology->tethering_passphrase);
+
+done:
+ g_free(identifier);
+
+ __connman_storage_save_global(keyfile);
+
+ g_key_file_free(keyfile);
+}
+#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;
- result = dbus_connection_send(connection, signal, NULL);
- dbus_message_unref(signal);
+ dbus_message_iter_recurse(&dict, &entry);
- DBG("Successfuly sent signal");
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
- return result;
-}
-#endif
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
-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
-}
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
-void __connman_technology_scan_stopped(struct connman_device *device,
- enum connman_service_type type)
-{
- int count = 0;
- struct connman_technology *technology;
- GSList *list;
+ dbus_message_iter_recurse(&entry, &value2);
- technology = technology_find(type);
+ type = dbus_message_iter_get_arg_type(&value2);
- DBG("technology %p device %p", technology, device);
+ if (g_str_equal(key, "Ifname")) {
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
- if (!technology)
- return;
+ 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);
- for (list = technology->device_list; list; list = list->next) {
- struct connman_device *other_device = list->data;
+ 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);
- if (device == other_device)
- continue;
+ 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 (__connman_device_get_service_type(other_device) != type)
- continue;
+ if (err != 0) {
+ DBG("Failed to add virtual mesh interface");
+ return __connman_error_failed(msg, -err);
+ }
- if (connman_device_get_scanning(other_device))
- count += 1;
- }
+ DBG("Successfully added virtual mesh interface");
-#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);
+ dbus_message_ref(msg);
+ technology->mesh_dbus_msg = msg;
- DBG("Successfuly sent ScanDone signal");
- }
-#else
- if (count == 0)
- reply_scan_pending(technology, 0);
-#endif
-}
+ } 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;
-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;
+ dbus_message_iter_recurse(&dict, &entry);
- type = __connman_device_get_service_type(device);
- technology = technology_find(type);
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
- if (!technology)
- return;
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
- if (result < 0) {
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
- for (tech_drivers = technology->driver_list;
- tech_drivers;
- tech_drivers = g_slist_next(tech_drivers)) {
- struct connman_technology_driver *driver =
- tech_drivers->data;
+ dbus_message_iter_recurse(&entry, &value2);
- if (driver->set_regdom) {
- driver->set_regdom(technology, alpha2);
- regdom_set = true;
+ 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);
}
- if (!regdom_set)
- alpha2 = NULL;
- }
+ 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);
- connman_technology_regdom_notify(technology, alpha2);
-}
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
-static DBusMessage *scan(DBusConnection *conn, DBusMessage *msg, void *data)
-{
- struct connman_technology *technology = data;
- int err;
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
- DBG("technology %p request from %s", technology,
- dbus_message_get_sender(msg));
+ dbus_message_iter_recurse(&entry, &value2);
- dbus_message_ref(msg);
-#if !defined TIZEN_EXT
- technology->scan_pending =
- g_slist_prepend(technology->scan_pending, msg);
-#endif
+ type = dbus_message_iter_get_arg_type(&value2);
- 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 (g_str_equal(key, "Name")) {
+ if (type != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
-#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;
-}
+ 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);
-#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;
- unsigned int freq = 0;
- DBusMessageIter iter, dict;
- int err;
+ 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);
- DBG("technology %p request from %s", technology,
- dbus_message_get_sender(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);
- if (!dbus_message_iter_init(msg, &iter))
- return __connman_error_invalid_arguments(msg);
+ dbus_message_iter_get_basic(&value2, &ieee80211w);
+ }
+ dbus_message_iter_next(&dict);
+ }
- if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY)
- return __connman_error_invalid_arguments(msg);
+ if (name == NULL || sec_type == NULL || freq == 0)
+ 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;
+ DBG("Name %s Frequency %d Security type %s Pmf %u",
+ name, freq, sec_type, ieee80211w);
- 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);
+ if (g_strcmp0(sec_type, "none") != 0 &&
+ g_strcmp0(sec_type, "sae") != 0) {
+ DBG("Unsupported security");
return __connman_error_invalid_arguments(msg);
}
- dbus_message_iter_get_basic(&entry, &key);
- dbus_message_iter_next(&entry);
+ mesh_ifname = connman_mesh_get_interface_name();
- 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);
+ if (!connman_mesh_is_interface_created()) {
+ DBG("Mesh interface doesn't exists");
+ return __connman_error_invalid_command(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);
+ 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);
- }
- scan_type = 1; /* 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_UINT16) {
- g_slist_free_full(specific_scan_list, g_free);
+ 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);
- }
- scan_type = 2; /* Frequency based scan */
- dbus_message_iter_get_basic(&value2, &freq);
- DBG("freq %d", freq);
- specific_scan_list = g_slist_append(specific_scan_list, GINT_TO_POINTER(freq));
+ 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);
}
- dbus_message_iter_next(&dict);
- }
- dbus_message_ref(msg);
+ DBG("MeshID %s Frequency %d sender %s", name, freq,
+ dbus_message_get_sender(msg));
- err = __connman_device_request_specific_scan(technology->type, scan_type, specific_scan_list);
- if (err < 0)
- return __connman_error_failed(msg, -err);
+ struct connman_scan_pending *pending_data =
+ g_try_malloc0(sizeof(struct connman_scan_pending));
+ if (!pending_data)
+ return __connman_error_failed(msg, ENOMEM);
+
+ pending_data->msg = dbus_message_ref(msg);
- if (err == 0) {
- guint list_size = g_slist_length(specific_scan_list);
- if (list_size == 1)
- g_scan_type = CONNMAN_SCAN_TYPE_SPECIFIC_AP;
+ technology->scan_pending =
+ g_slist_prepend(technology->scan_pending, pending_data);
+
+ err = __connman_device_request_mesh_specific_scan(technology->type,
+ name, freq);
+ if (err < 0)
+ reply_scan_pending(technology, err);
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);
+ DBG("Successfully requested to scan specific Mesh Network");
- if (scan_type == 1) {
- g_slist_free_full(specific_scan_list, g_free);
- scan_type = 0;
- }
- return NULL;
-}
+ } 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;
-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;
+ dbus_message_iter_recurse(&dict, &entry);
- DBG("technology %p", technology);
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_STRING)
+ return __connman_error_invalid_arguments(msg);
- for (list = technology->device_list; list; list = list->next) {
- struct connman_device *device = list->data;
- scanning = connman_device_get_scanning(device);
- if(scanning)
- break;
- }
+ dbus_message_iter_get_basic(&entry, &key);
+ dbus_message_iter_next(&entry);
- DBG("scanning : %d", scanning);
- reply = dbus_message_new_method_return(msg);
- if (!reply)
- return NULL;
+ if (dbus_message_iter_get_arg_type(&entry) != DBUS_TYPE_VARIANT)
+ return __connman_error_invalid_arguments(msg);
- dbus_message_iter_init_append(reply, &iter);
+ dbus_message_iter_recurse(&entry, &value2);
- connman_dbus_dict_open(&iter, &dict);
- connman_dbus_dict_append_basic(&dict, "Scanstate",
- DBUS_TYPE_BOOLEAN,
- &scanning);
+ type = dbus_message_iter_get_arg_type(&value2);
- connman_dbus_dict_close(&iter, &dict);
+ if (g_str_equal(key, "GateAnnounce")) {
+ if (type != DBUS_TYPE_BOOLEAN)
+ return __connman_error_invalid_arguments(msg);
- return reply;
+ 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);
+
+ 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);
+
+ dbus_message_iter_get_basic(&value2, &stp);
+ }
+ dbus_message_iter_next(&dict);
+ }
+
+ DBG("GateAnnounce %d HWMPRootMode %d STP %d sender %s",
+ gate_announce, hwmp_rootmode, stp, dbus_message_get_sender(msg));
+
+ err = __connman_mesh_set_stp_gate_announce(gate_announce,
+ hwmp_rootmode,
+ stp);
+
+ 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
NULL, set_property) },
{ GDBUS_ASYNC_METHOD("Scan", NULL, NULL, scan) },
#if defined TIZEN_EXT
+ { GDBUS_ASYNC_METHOD("ScanDevice", GDBUS_ARGS({ "interface_name", "s" }),
+ NULL, scan_device) },
{ 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) },
+ { GDBUS_METHOD("Get5GhzSupported", NULL, GDBUS_ARGS({ "supported", "a{sv}" }),
+ get_5ghz_supported) },
+ { GDBUS_METHOD("GetMaxScanSsid", NULL, GDBUS_ARGS({ "maxscanssid", "a{sv}" }),
+ get_max_scan_ssid) },
+ { GDBUS_ASYNC_METHOD("SetDevicePower",
+ GDBUS_ARGS({ "ifname", "s" }, { "value", "b" }),
+ NULL, set_device_power) },
+ { GDBUS_ASYNC_METHOD("SetBSSID",
+ GDBUS_ARGS({ "ifname", "s" }, { "bssid", "s" }),
+ NULL, set_bssid) },
+#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" })) },
+#if defined TIZEN_EXT
+ { GDBUS_SIGNAL("DeviceChanged",
+ GDBUS_ARGS({ "device_property", "a{sv}" })) },
+ { GDBUS_SIGNAL("DeviceDetected",
+ GDBUS_ARGS({ "ifname", "s" }, { "detected", "b" })) },
+#endif
{ },
};
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;
+ }
+#ifdef TIZEN_EXT
+ g_strfreev(technology->enabled_devices);
+#endif
g_free(technology->path);
g_free(technology->regdom);
g_free(technology->tethering_ident);
technology = technology_find(type);
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;
}
technology->refcount = 1;
technology->type = type;
- technology->tethering_hidden = FALSE;
technology->path = g_strdup_printf("%s/technology/%s",
CONNMAN_PATH, str);
+#if defined TIZEN_EXT_WIFI_MESH
+ if (type == CONNMAN_SERVICE_TYPE_MESH) {
+ struct connman_technology *wifi;
+
+ 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;
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
+
return 0;
}
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,
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;
}
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;
}
if (technology->enable_persistent &&
!global_offlinemode) {
+#if defined TIZEN_EXT
+ bool found = true;
+ int err = 0;
+ if (technology->enabled_devices) {
+ int i = 0;
+ found = false;
+ const char *ifname = connman_device_get_string(device, "Interface");
+
+ while (technology->enabled_devices[i]) {
+ if (g_strcmp0(technology->enabled_devices[i], ifname) == 0) {
+ found = true;
+ break;
+ }
+ i++;
+ }
+ }
+
+ if (found)
+ err = __connman_device_enable(device);
+#else
int err = __connman_device_enable(device);
+#endif
/*
* connman_technology_add_device() calls __connman_device_enable()
- * but since the device is already enabled, the calls does not
+ * but since the device is already enabled, the call does not
* propagate through to connman_technology_enabled via
* connman_device_set_powered.
*/
technology->device_list = g_slist_prepend(technology->device_list,
device);
+#if defined TIZEN_EXT
+ const char *ifname = connman_device_get_string(device, "Interface");
+ __connman_technology_notify_device_detected(technology, ifname, true);
+
+ connman_device_set_mac_policy(device, technology->mac_policy);
+ connman_device_set_preassoc_mac_policy(device, technology->preassoc_mac_policy);
+ connman_device_set_random_mac_lifetime(device, technology->random_mac_lifetime);
+#endif
return 0;
}
technology->device_list = g_slist_remove(technology->device_list,
device);
+#if defined TIZEN_EXT
+ const char *ifname = connman_device_get_string(device, "Interface");
+ __connman_technology_notify_device_detected(technology, ifname, false);
+#endif
+
if (technology->tethering)
set_tethering(technology, false);
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)
technology = technology_find(type);
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;
* resuming offlinemode from last saved profile. We need that
* information in rfkill_update, otherwise it falls back on the
* technology's persistent state. Hence we set the offline mode here
- * but save it & call the notifier only if its successful.
+ * but save it & call the notifier only if it is successful.
*/
global_offlinemode = offlinemode;
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,
bool 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",
softblock, hardblock, true))
return 0;
#endif
+
if (global_offlinemode)
return 0;
projects / platform / upstream / connman.git / blobdiff