diff options
Diffstat (limited to 'src/technology.c')
| -rw-r--r-- | src/technology.c | 923 |
1 files changed, 923 insertions, 0 deletions
diff --git a/src/technology.c b/src/technology.c index 4e053fc9..782ce15c 100644 --- a/src/technology.c +++ b/src/technology.c @@ -25,6 +25,10 @@ #include <errno.h> #include <string.h> +#if defined TIZEN_EXT +#include <stdio.h> +#include <stdlib.h> +#endif #include <gdbus.h> @@ -43,6 +47,16 @@ static GHashTable *rfkill_list; 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; @@ -80,6 +94,13 @@ struct connman_technology { bool softblocked; bool hardblocked; bool dbus_registered; +#if defined TIZEN_EXT_WIFI_MESH + DBusMessage *mesh_dbus_msg; +#endif +#if defined TIZEN_EXT + bool is_5_0_ghz_supported; + int max_scan_ssids; +#endif }; static GSList *driver_list = NULL; @@ -150,6 +171,10 @@ static const char *get_name(enum connman_service_type type) 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; @@ -377,6 +402,16 @@ bool connman_technology_get_wifi_tethering(const char **ssid, return true; } +#if defined TIZEN_EXT +void connman_techonology_wifi_set_5ghz_supported(struct connman_technology *wifi_technology, + bool is_5_0_ghz_supported) +{ + DBG(""); + + wifi_technology->is_5_0_ghz_supported = is_5_0_ghz_supported; +} +#endif + static void free_rfkill(gpointer data) { struct connman_rfkill *rfkill = data; @@ -651,6 +686,11 @@ static int technology_affect_devices(struct connman_technology *technology, 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; @@ -685,6 +725,10 @@ static void powered_changed(struct connman_technology *technology) __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); @@ -859,6 +903,49 @@ make_reply: 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) { @@ -972,6 +1059,17 @@ static DBusMessage *set_property(DBusConnection *conn, 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); +#endif } else return __connman_error_invalid_property(msg); @@ -1002,9 +1100,38 @@ static void reply_scan_pending(struct connman_technology *technology, int err) } } +#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, @@ -1031,8 +1158,32 @@ void __connman_technology_scan_stopped(struct connman_device *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, @@ -1084,15 +1235,713 @@ static DBusMessage *scan(DBusConnection *conn, DBusMessage *msg, void *data) 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_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 + 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; +} + +#if defined TIZEN_EXT +static DBusMessage *get_5ghz_supported(DBusConnection *conn, DBusMessage *msg, void *data) +{ + DBusMessage *reply; + DBusMessageIter iter, dict; + struct connman_technology *technology = data; + dbus_bool_t supported = technology->is_5_0_ghz_supported; + + 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); + connman_dbus_dict_append_basic(&dict, "Is5GhzSupported", + DBUS_TYPE_BOOLEAN, + &supported); + + connman_dbus_dict_close(&iter, &dict); + + return reply; +} +#endif + +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, + connman_device_get_type(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; +} + +void connman_techonology_set_max_scan_ssids(struct connman_technology *technology, + int max_scan_ssids) +{ + DBG(""); + technology->max_scan_ssids = max_scan_ssids; +} + +static DBusMessage *get_max_scan_ssid(DBusConnection *conn, DBusMessage *msg, void *data) +{ + DBusMessage *reply; + DBusMessageIter iter, dict; + struct connman_technology *technology = data; + dbus_int32_t max_scan_ssids = technology->max_scan_ssids; + + 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); + connman_dbus_dict_append_basic(&dict, "MaxScanSSID", + DBUS_TYPE_INT32, + &max_scan_ssids); + + 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); + + dbus_message_iter_recurse(&entry, &value2); + + type = dbus_message_iter_get_arg_type(&value2); + + if (g_str_equal(key, "GateAnnounce")) { + if (type != DBUS_TYPE_BOOLEAN) + return __connman_error_invalid_arguments(msg); + + 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 static const GDBusMethodTable technology_methods[] = { { GDBUS_DEPRECATED_METHOD("GetProperties", @@ -1102,6 +1951,21 @@ static const GDBusMethodTable technology_methods[] = { 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) }, + { 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) }, +#endif +#if defined TIZEN_EXT_WIFI_MESH + { GDBUS_ASYNC_METHOD("MeshCommands", + GDBUS_ARGS({ "name", "s" }, { "value", "v" }), + NULL, mesh_commands) }, +#endif { }, }; @@ -1202,7 +2066,12 @@ static struct connman_technology *technology_get(enum connman_service_type type) 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; } @@ -1232,6 +2101,16 @@ static struct connman_technology *technology_get(enum connman_service_type type) 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; @@ -1310,6 +2189,13 @@ exist: 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; } @@ -1347,6 +2233,13 @@ void connman_technology_driver_unregister(struct connman_technology_driver *driv 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, @@ -1369,6 +2262,9 @@ 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; } @@ -1420,6 +2316,9 @@ void __connman_technology_remove_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; } @@ -1535,11 +2434,13 @@ int __connman_technology_enabled(enum connman_service_type type) 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 technology_enabled(technology); } @@ -1553,9 +2454,11 @@ int __connman_technology_disabled(enum connman_service_type 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; @@ -1614,6 +2517,15 @@ int __connman_technology_set_offlinemode(bool 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) { @@ -1628,6 +2540,11 @@ void __connman_technology_set_connected(enum connman_service_type type, 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", @@ -1734,6 +2651,10 @@ int __connman_technology_add_rfkill(unsigned int 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) @@ -1741,10 +2662,12 @@ done: 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; |