diff options
Diffstat (limited to 'plugins')
-rw-r--r--[-rwxr-xr-x] | plugins/ethernet.c | 65 | ||||
-rw-r--r--[-rwxr-xr-x] | plugins/wifi.c | 805 |
2 files changed, 868 insertions, 2 deletions
diff --git a/plugins/ethernet.c b/plugins/ethernet.c index 9a4d7413..aadfe897 100755..100644 --- a/plugins/ethernet.c +++ b/plugins/ethernet.c @@ -48,6 +48,9 @@ #include <connman/rtnl.h> #include <connman/log.h> #include <connman/setting.h> +#if defined TIZEN_EXT_WIFI_MESH +#include <connman/mesh.h> +#endif static bool eth_tethering = false; @@ -252,6 +255,10 @@ static void ethernet_newlink(unsigned flags, unsigned change, void *user_data) } else { DBG("carrier off"); remove_network(device, ethernet); +#if defined TIZEN_EXT_WIFI_MESH + /* Remove ethernet from mesh bridge */ + __connman_mesh_remove_ethernet_from_bridge(); +#endif } } @@ -430,6 +437,54 @@ static struct connman_technology_driver eth_tech_driver = { .set_tethering = eth_tech_set_tethering, }; +#if defined TIZEN_EXT_WIFI_MESH +static int eth_mesh_add_to_bridge(const char *bridge) +{ + GList *list; + struct ethernet_data *ethernet; + + DBG("Add ethernet to bridge %s", bridge); + + for (list = eth_interface_list; list; list = list->next) { + int index = GPOINTER_TO_INT(list->data); + struct connman_device *device = + connman_device_find_by_index(index); + + if (device) { + ethernet = connman_device_get_data(device); + if (ethernet) + remove_network(device, ethernet); + } + + connman_inet_ifup(index); + + connman_inet_add_to_bridge(index, bridge); + } + + return 0; +} + +static int eth_mesh_remove_from_bridge(const char *bridge) +{ + GList *list; + + DBG("Remove ethernet from bridge %s", bridge); + + for (list = eth_interface_list; list; list = list->next) { + int index = GPOINTER_TO_INT(list->data); + + connman_inet_remove_from_bridge(index, bridge); + } + + return 0; +} + +static struct connman_mesh_eth_driver eth_mesh_driver = { + .add_to_bridge = eth_mesh_add_to_bridge, + .remove_from_bridge = eth_mesh_remove_from_bridge, +}; +#endif + static int ethernet_init(void) { int err; @@ -438,6 +493,12 @@ static int ethernet_init(void) if (err < 0) return err; +#if defined TIZEN_EXT_WIFI_MESH + err = connman_mesh_eth_driver_register(ð_mesh_driver); + if (err < 0) + return err; +#endif + err = connman_network_driver_register(ð_network_driver); if (err < 0) return err; @@ -455,6 +516,10 @@ static void ethernet_exit(void) { connman_technology_driver_unregister(ð_tech_driver); +#if defined TIZEN_EXT_WIFI_MESH + connman_mesh_eth_driver_unregister(ð_mesh_driver); +#endif + connman_network_driver_unregister(ð_network_driver); connman_device_driver_unregister(ð_dev_driver); diff --git a/plugins/wifi.c b/plugins/wifi.c index 6103dc8c..8e8017d0 100755..100644 --- a/plugins/wifi.c +++ b/plugins/wifi.c @@ -163,6 +163,10 @@ struct wifi_data { #endif int disconnect_code; int assoc_code; +#if defined TIZEN_EXT_WIFI_MESH + bool mesh_interface; + struct wifi_mesh_info *mesh_info; +#endif }; #if defined TIZEN_EXT @@ -347,6 +351,506 @@ static void add_pending_wifi_device(struct wifi_data *wifi) pending_wifi_device = g_list_append(pending_wifi_device, wifi); } +#if defined TIZEN_EXT_WIFI_MESH +struct wifi_mesh_info { + struct wifi_data *wifi; + GSupplicantInterface *interface; + struct connman_mesh *mesh; + char *parent_ifname; + char *ifname; + char *identifier; + int index; +}; + +struct mesh_change_peer_status_info { + char *peer_address; + enum connman_mesh_peer_status peer_status; + mesh_change_peer_status_cb_t callback; + void *user_data; +}; + +static struct connman_technology_driver mesh_tech_driver = { + .name = "mesh", + .type = CONNMAN_SERVICE_TYPE_MESH, +}; + +static void mesh_interface_create_callback(int result, + GSupplicantInterface *interface, + void *user_data) +{ + struct wifi_mesh_info *mesh_info = user_data; + struct wifi_data *wifi; + bool success = false; + + DBG("result %d ifname %s, mesh_info %p", result, + g_supplicant_interface_get_ifname(interface), + mesh_info); + + if (result < 0 || !mesh_info) + goto done; + + wifi = mesh_info->wifi; + + mesh_info->interface = interface; + mesh_info->identifier = connman_inet_ifaddr(mesh_info->ifname); + mesh_info->index = connman_inet_ifindex(mesh_info->ifname); + DBG("Mesh Interface identifier %s", mesh_info->identifier); + wifi->mesh_interface = true; + wifi->mesh_info = mesh_info; + g_supplicant_interface_set_data(interface, wifi); + success = true; + +done: + connman_mesh_notify_interface_create(success); +} + +static int add_mesh_interface(const char *ifname, const char *parent_ifname) +{ + GList *list; + struct wifi_data *wifi; + struct wifi_mesh_info *mesh_info; + const char *wifi_ifname; + bool parent_found = false; + const char *driver = "nl80211"; + + for (list = iface_list; list; list = list->next) { + wifi = list->data; + + if (!g_supplicant_interface_has_mesh(wifi->interface)) + continue; + + wifi_ifname = g_supplicant_interface_get_ifname(wifi->interface); + if (!wifi_ifname) + continue; + + if (!g_strcmp0(wifi_ifname, parent_ifname)) { + parent_found = true; + break; + } + } + + if (!parent_found) { + DBG("Parent interface %s doesn't exist", parent_ifname); + return -ENODEV; + } + + mesh_info = g_try_malloc0(sizeof(struct wifi_mesh_info)); + if (!mesh_info) + return -ENOMEM; + + mesh_info->wifi = wifi; + mesh_info->ifname = g_strdup(ifname); + mesh_info->parent_ifname = g_strdup(parent_ifname); + + g_supplicant_mesh_interface_create(ifname, driver, NULL, parent_ifname, + mesh_interface_create_callback, mesh_info); + return -EINPROGRESS; +} + +static void mesh_interface_remove_callback(int result, + GSupplicantInterface *interface, + void *user_data) +{ + struct wifi_data *wifi = user_data; + struct wifi_mesh_info *mesh_info = wifi->mesh_info; + bool success = false; + + DBG("result %d mesh_info %p", result, mesh_info); + + if (result < 0 || !mesh_info) + goto done; + + mesh_info->interface = NULL; + g_free(mesh_info->parent_ifname); + g_free(mesh_info->ifname); + g_free(mesh_info->identifier); + g_free(mesh_info); + wifi->mesh_interface = false; + wifi->mesh_info = NULL; + success = true; + +done: + connman_mesh_notify_interface_remove(success); +} + +static int remove_mesh_interface(const char *ifname) +{ + GList *list; + struct wifi_data *wifi; + struct wifi_mesh_info *mesh_info; + bool mesh_if_found = false; + int ret; + + for (list = iface_list; list; list = list->next) { + wifi = list->data; + + if (wifi->mesh_interface) { + mesh_if_found = true; + break; + } + } + + if (!mesh_if_found) { + DBG("Mesh interface %s doesn't exist", ifname); + return -ENODEV; + } + + mesh_info = wifi->mesh_info; + ret = g_supplicant_interface_remove(mesh_info->interface, + mesh_interface_remove_callback, wifi); + if (ret < 0) + return ret; + + return -EINPROGRESS; +} + +static void mesh_disconnect_callback(int result, + GSupplicantInterface *interface, void *user_data) +{ + struct connman_mesh *mesh = user_data; + + DBG("result %d interface %p mesh %p", result, interface, mesh); +} + +static int mesh_peer_disconnect(struct connman_mesh *mesh) +{ + GList *list; + struct wifi_data *wifi; + struct wifi_mesh_info *mesh_info; + bool mesh_if_found = false; + GSupplicantInterface *interface; + + for (list = iface_list; list; list = list->next) { + wifi = list->data; + + if (wifi->mesh_interface) { + mesh_if_found = true; + break; + } + } + + if (!mesh_if_found) { + DBG("Mesh interface is not created"); + return -ENODEV; + } + + mesh_info = wifi->mesh_info; + + interface = mesh_info->interface; + return g_supplicant_interface_disconnect(interface, + mesh_disconnect_callback, mesh); +} + +static void mesh_connect_callback(int result, GSupplicantInterface *interface, + void *user_data) +{ + struct connman_mesh *mesh = user_data; + DBG("mesh %p result %d", mesh, result); + + if (result < 0) + connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_FAILURE); + else + connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_ASSOCIATION); +} + +static GSupplicantSecurity mesh_network_security(const char *security) +{ + if (g_str_equal(security, "none")) + return G_SUPPLICANT_SECURITY_NONE; + else if (g_str_equal(security, "sae")) + return G_SUPPLICANT_SECURITY_SAE; + + return G_SUPPLICANT_SECURITY_UNKNOWN; +} + +static void mesh_ssid_init(GSupplicantSSID *ssid, struct connman_mesh *mesh) +{ + const char *name; + const char *security; + + if (ssid->ssid) + g_free(ssid->ssid); + + memset(ssid, 0, sizeof(*ssid)); + ssid->mode = G_SUPPLICANT_MODE_MESH; + + security = connman_mesh_get_security(mesh); + ssid->security = mesh_network_security(security); + + if (ssid->security == G_SUPPLICANT_SECURITY_SAE) + ssid->passphrase = connman_mesh_get_passphrase(mesh); + + ssid->freq = connman_mesh_get_frequency(mesh); + name = connman_mesh_get_name(mesh); + if (name) { + ssid->ssid_len = strlen(name); + ssid->ssid = g_malloc0(ssid->ssid_len + 1); + memcpy(ssid->ssid, name, ssid->ssid_len); + ssid->scan_ssid = 1; + } +} + +static int mesh_peer_connect(struct connman_mesh *mesh) +{ + GList *list; + struct wifi_data *wifi; + struct wifi_mesh_info *mesh_info; + bool mesh_if_found = false; + GSupplicantInterface *interface; + GSupplicantSSID *ssid; + + for (list = iface_list; list; list = list->next) { + wifi = list->data; + + if (wifi->mesh_interface) { + mesh_if_found = true; + break; + } + } + + if (!mesh_if_found) { + DBG("Mesh interface is not created"); + return -ENODEV; + } + + mesh_info = wifi->mesh_info; + + interface = mesh_info->interface; + + ssid = g_try_malloc0(sizeof(GSupplicantSSID)); + if (!ssid) + return -ENOMEM; + + mesh_info->mesh = mesh; + + mesh_ssid_init(ssid, mesh); + return g_supplicant_interface_connect(interface, ssid, + mesh_connect_callback, mesh); +} + +static void mesh_peer_change_status_callback(int result, + GSupplicantInterface *interface, + void *user_data) +{ + struct mesh_change_peer_status_info *data = user_data; + + DBG("result %d Peer Status %d", result, data->peer_status); + + if (result == 0 && data->peer_status == CONNMAN_MESH_PEER_REMOVE) { + /* WLAN_REASON_MESH_PEERING_CANCELLED = 52 */ + connman_mesh_remove_connected_peer(data->peer_address, 52); + } + + if (data->callback) + data->callback(result, data->user_data); + + g_free(data->peer_address); + g_free(data); + return; +} + +static int mesh_change_peer_status(const char *peer_address, + enum connman_mesh_peer_status status, + mesh_change_peer_status_cb_t callback, void *user_data) +{ + GList *list; + struct wifi_data *wifi; + struct wifi_mesh_info *mesh_info; + bool mesh_if_found = false; + GSupplicantInterface *interface; + struct mesh_change_peer_status_info *data; + const char *method; + + for (list = iface_list; list; list = list->next) { + wifi = list->data; + + if (wifi->mesh_interface) { + mesh_if_found = true; + break; + } + } + + if (!mesh_if_found) { + DBG("Mesh interface is not created"); + return -ENODEV; + } + + mesh_info = wifi->mesh_info; + + interface = mesh_info->interface; + + switch (status) { + case CONNMAN_MESH_PEER_ADD: + method = "MeshPeerAdd"; + break; + case CONNMAN_MESH_PEER_REMOVE: + method = "MeshPeerRemove"; + break; + default: + DBG("Invalid method"); + return -EINVAL; + } + + data = g_try_malloc0(sizeof(struct mesh_change_peer_status_info)); + if (data == NULL) { + DBG("Memory allocation failed"); + return -ENOMEM; + } + + data->peer_address = g_strdup(peer_address); + data->peer_status = status; + data->callback = callback; + data->user_data = user_data; + + return g_supplicant_interface_mesh_peer_change_status(interface, + mesh_peer_change_status_callback, peer_address, method, + data); +} + +static struct connman_mesh_driver mesh_driver = { + .add_interface = add_mesh_interface, + .remove_interface = remove_mesh_interface, + .connect = mesh_peer_connect, + .disconnect = mesh_peer_disconnect, + .change_peer_status = mesh_change_peer_status, +}; + +static void mesh_support(GSupplicantInterface *interface) +{ + DBG(""); + + if (!g_supplicant_interface_has_mesh(interface)) + return; + + if (connman_technology_driver_register(&mesh_tech_driver) < 0) { + DBG("Could not register Mesh technology driver"); + return; + } + + connman_mesh_driver_register(&mesh_driver); +} + +static void check_mesh_technology(void) +{ + bool mesh_exists = false; + GList *list; + + for (list = iface_list; list; list = list->next) { + struct wifi_data *w = list->data; + + if (w->interface && + g_supplicant_interface_has_mesh(w->interface)) + mesh_exists = true; + } + + if (!mesh_exists) { + connman_technology_driver_unregister(&mesh_tech_driver); + connman_mesh_driver_unregister(&mesh_driver); + } +} + +static void mesh_group_started(GSupplicantInterface *interface) +{ + struct wifi_data *wifi; + struct wifi_mesh_info *mesh_info; + struct connman_mesh *mesh; + const unsigned char *ssid; + unsigned int ssid_len; + char name[33]; + + ssid = g_supplicant_interface_get_mesh_group_ssid(interface, &ssid_len); + memcpy(name, ssid, ssid_len); + name[ssid_len] = '\0'; + DBG("name %s", name); + wifi = g_supplicant_interface_get_data(interface); + DBG("wifi %p", wifi); + + if (!wifi) + return; + + mesh_info = wifi->mesh_info; + if (!mesh_info) + return; + + mesh = mesh_info->mesh; + if (!mesh) + return; + + connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_CONFIGURATION); +} + +static void mesh_group_removed(GSupplicantInterface *interface) +{ + struct wifi_data *wifi; + struct wifi_mesh_info *mesh_info; + struct connman_mesh *mesh; + const unsigned char *ssid; + unsigned int ssid_len; + int disconnect_reason; + char name[33]; + + ssid = g_supplicant_interface_get_mesh_group_ssid(interface, &ssid_len); + memcpy(name, ssid, ssid_len); + name[ssid_len] = '\0'; + DBG("name %s", name); + + disconnect_reason = g_supplicant_mesh_get_disconnect_reason(interface); + DBG("Disconnect Reason %d", disconnect_reason); + + wifi = g_supplicant_interface_get_data(interface); + DBG("wifi %p", wifi); + + if (!wifi) + return; + + mesh_info = wifi->mesh_info; + if (!mesh_info) + return; + + mesh = connman_get_connected_mesh_from_name(name); + if (!mesh) { + DBG("%s is not connected", name); + mesh = connman_get_connecting_mesh_from_name(name); + if (!mesh) { + DBG("%s is not connecting", name); + return; + } + } + + connman_mesh_peer_set_disconnect_reason(mesh, disconnect_reason); + connman_mesh_peer_set_state(mesh, CONNMAN_MESH_STATE_DISCONNECT); +} + +static void mesh_peer_connected(GSupplicantMeshPeer *mesh_peer) +{ + const char *peer_address; + + peer_address = g_supplicant_mesh_peer_get_address(mesh_peer); + + if (!peer_address) + return; + + DBG("Peer %s connected", peer_address); + connman_mesh_add_connected_peer(peer_address); +} + +static void mesh_peer_disconnected(GSupplicantMeshPeer *mesh_peer) +{ + const char *peer_address; + int reason; + + peer_address = g_supplicant_mesh_peer_get_address(mesh_peer); + + if (!peer_address) + return; + + reason = g_supplicant_mesh_peer_get_disconnect_reason(mesh_peer); + + DBG("Peer %s disconnected with reason %d", peer_address, reason); + connman_mesh_remove_connected_peer(peer_address, reason); +} +#endif + static struct wifi_data *get_pending_wifi_data(const char *ifname) { GList *list; @@ -1034,6 +1538,9 @@ static void wifi_remove(struct connman_device *device) iface_list = g_list_remove(iface_list, wifi); check_p2p_technology(); +#if defined TIZEN_EXT_WIFI_MESH + check_mesh_technology(); +#endif remove_pending_wifi_device(wifi); @@ -2094,7 +2601,7 @@ static int wifi_specific_scan(enum connman_service_type type, } memcpy(scan_ssid->ssid, ssid, (ssid_len + 1)); - DBG("scan ssid %s len: %d", scan_ssid->ssid, ssid_len); + /* DBG("scan ssid %s len: %d", scan_ssid->ssid, ssid_len); */ scan_ssid->ssid_len = ssid_len; scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid); count++; @@ -2160,7 +2667,7 @@ static int wifi_specific_scan(enum connman_service_type type, } memcpy(scan_ssid->ssid, ssid, (ssid_len + 1)); - DBG("scan ssid %s len: %d", scan_ssid->ssid, ssid_len); + /* DBG("scan ssid %s len: %d", scan_ssid->ssid, ssid_len); */ scan_ssid->ssid_len = ssid_len; scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid); ap_count++; @@ -2197,6 +2704,159 @@ static int wifi_specific_scan(enum connman_service_type type, } #endif +#if defined TIZEN_EXT_WIFI_MESH +static void mesh_scan_callback(int result, GSupplicantInterface *interface, + void *user_data) +{ + struct connman_device *device = user_data; + struct wifi_data *wifi = connman_device_get_data(device); + bool scanning; + + DBG("result %d wifi %p", result, wifi); + + scanning = connman_device_get_scanning(device); + if (scanning) + connman_device_set_scanning(device, + CONNMAN_SERVICE_TYPE_MESH, false); + + if (scanning) + connman_device_unref(device); +} + +static int mesh_scan(struct connman_device *device) +{ + struct wifi_data *wifi; + struct wifi_mesh_info *mesh_info; + int ret; + + DBG(""); + + wifi = connman_device_get_data(device); + + if (!wifi->mesh_interface) + return -ENOTSUP; + + mesh_info = wifi->mesh_info; + reset_autoscan(device); + connman_device_ref(device); + + ret = g_supplicant_interface_scan(mesh_info->interface, NULL, + mesh_scan_callback, device); + if (ret) + connman_device_unref(device); + else + connman_device_set_scanning(device, + CONNMAN_SERVICE_TYPE_MESH, true); + + return ret; +} + +static void abort_scan_callback(int result, GSupplicantInterface *interface, + void *user_data) +{ + struct connman_device *device = user_data; + struct wifi_data *wifi = connman_device_get_data(device); + + DBG("result %d wifi %p", result, wifi); + + __connman_technology_notify_abort_scan(CONNMAN_SERVICE_TYPE_MESH, result); +} + +static int mesh_abort_scan(enum connman_service_type type, + struct connman_device *device) +{ + struct wifi_data *wifi = connman_device_get_data(device); + struct wifi_mesh_info *mesh_info; + bool scanning; + int ret; + + if (!wifi || !wifi->mesh_interface) + return -ENODEV; + + if (type != CONNMAN_SERVICE_TYPE_MESH) + return -EINVAL; + + mesh_info = wifi->mesh_info; + + scanning = connman_device_get_scanning(device); + if (!scanning) + return -EEXIST; + + ret = g_supplicant_interface_abort_scan(mesh_info->interface, + abort_scan_callback, device); + + return ret; +} + +static int mesh_specific_scan(enum connman_service_type type, + struct connman_device *device, const char *ssid, + unsigned int freq, void *user_data) +{ + struct wifi_data *wifi = connman_device_get_data(device); + GSupplicantScanParams *scan_params = NULL; + struct wifi_mesh_info *mesh_info; + struct scan_ssid *scan_ssid; + bool scanning; + int ret; + + if (!wifi || !wifi->mesh_interface) + return -ENODEV; + + if (type != CONNMAN_SERVICE_TYPE_MESH) + return -EINVAL; + + if (wifi->p2p_device) + return 0; + + mesh_info = wifi->mesh_info; + + scanning = connman_device_get_scanning(device); + if (scanning) + return -EALREADY; + + scan_params = g_try_malloc0(sizeof(GSupplicantScanParams)); + if (!scan_params) + return -ENOMEM; + + scan_ssid = g_try_new(struct scan_ssid, 1); + if (!scan_ssid) { + g_free(scan_params); + return -ENOMEM; + } + + scan_ssid->ssid_len = strlen(ssid); + memcpy(scan_ssid->ssid, ssid, scan_ssid->ssid_len); + scan_params->ssids = g_slist_prepend(scan_params->ssids, scan_ssid); + scan_params->num_ssids = 1; + + scan_params->freqs = g_try_new(uint16_t, 1); + if (!scan_params->freqs) { + g_slist_free_full(scan_params->ssids, g_free); + g_free(scan_params); + return -ENOMEM; + } + + scan_params->freqs[0] = freq; + scan_params->num_freqs = 1; + + reset_autoscan(device); + connman_device_ref(device); + + ret = g_supplicant_interface_scan(mesh_info->interface, scan_params, + mesh_scan_callback, device); + + if (ret == 0) { + connman_device_set_scanning(device, + CONNMAN_SERVICE_TYPE_MESH, true); + } else { + g_supplicant_free_scan_params(scan_params); + connman_device_unref(device); + } + + return ret; +} +#endif + /* * Note that the hidden scan is only used when connecting to this specific * hidden AP first time. It is not used when system autoconnects to hidden AP. @@ -2228,6 +2888,11 @@ static int wifi_scan(enum connman_service_type type, if (type == CONNMAN_SERVICE_TYPE_P2P) return p2p_find(device); +#if defined TIZEN_EXT_WIFI_MESH + if (type == CONNMAN_SERVICE_TYPE_MESH) + return mesh_scan(device); +#endif + DBG("device %p wifi %p hidden ssid %s", device, wifi->interface, ssid); scanning = connman_device_get_scanning(device); @@ -2379,6 +3044,10 @@ static struct connman_device_driver wifi_ng_driver = { #if defined TIZEN_EXT .specific_scan = wifi_specific_scan, #endif +#if defined TIZEN_EXT_WIFI_MESH + .abort_scan = mesh_abort_scan, + .mesh_specific_scan = mesh_specific_scan, +#endif }; static void system_ready(void) @@ -3238,6 +3907,21 @@ static void interface_removed(GSupplicantInterface *interface) wifi = g_supplicant_interface_get_data(interface); +#if defined TIZEN_EXT_WIFI_MESH + if (wifi && wifi->mesh_interface) { + DBG("Notify mesh interface remove"); + connman_mesh_notify_interface_remove(true); + struct wifi_mesh_info *mesh_info = wifi->mesh_info; + g_free(mesh_info->parent_ifname); + g_free(mesh_info->ifname); + g_free(mesh_info->identifier); + g_free(mesh_info); + wifi->mesh_interface = false; + wifi->mesh_info = NULL; + return; + } +#endif + if (wifi) wifi->interface = NULL; @@ -3252,6 +3936,9 @@ static void interface_removed(GSupplicantInterface *interface) connman_device_set_powered(wifi->device, false); check_p2p_technology(); +#if defined TIZEN_EXT_WIFI_MESH + check_mesh_technology(); +#endif } static void set_device_type(const char *type, char dev_type[17]) @@ -3391,6 +4078,97 @@ static unsigned char calculate_strength(GSupplicantNetwork *supplicant_network) return strength; } +#if defined TIZEN_EXT_WIFI_MESH +static void mesh_peer_added(GSupplicantNetwork *supplicant_network) +{ + GSupplicantInterface *interface; + struct wifi_data *wifi; + const char *name, *security; + struct connman_mesh *connman_mesh; + struct wifi_mesh_info *mesh_info; + const unsigned char *bssid; + const char *identifier; + char *address; + uint16_t frequency; + int ret; + + interface = g_supplicant_network_get_interface(supplicant_network); + wifi = g_supplicant_interface_get_data(interface); + if (!wifi || !wifi->mesh_interface) { + DBG("Virtual Mesh interface not created"); + return; + } + + bssid = g_supplicant_network_get_bssid(supplicant_network); + address = g_malloc0(19); + snprintf(address, 19, "%02x:%02x:%02x:%02x:%02x:%02x", bssid[0], bssid[1], + bssid[2], bssid[3], bssid[4], bssid[5]); + + identifier = g_supplicant_network_get_identifier(supplicant_network); + name = g_supplicant_network_get_name(supplicant_network); + security = g_supplicant_network_get_security(supplicant_network); + frequency = g_supplicant_network_get_frequency(supplicant_network); + + mesh_info = wifi->mesh_info; + connman_mesh = connman_mesh_get(mesh_info->identifier, identifier); + if (connman_mesh) + goto done; + + DBG("Mesh Peer name %s identifier %s security %s added", name, identifier, + security); + connman_mesh = connman_mesh_create(mesh_info->identifier, identifier); + connman_mesh_set_name(connman_mesh, name); + connman_mesh_set_security(connman_mesh, security); + connman_mesh_set_frequency(connman_mesh, frequency); + connman_mesh_set_address(connman_mesh, address); + connman_mesh_set_index(connman_mesh, mesh_info->index); + connman_mesh_set_strength(connman_mesh, + calculate_strength(supplicant_network)); + connman_mesh_set_peer_type(connman_mesh, CONNMAN_MESH_PEER_TYPE_DISCOVERED); + + ret = connman_mesh_register(connman_mesh); + if (ret == -EALREADY) + DBG("Mesh Peer is already registered"); + +done: + g_free(address); +} + +static void mesh_peer_removed(GSupplicantNetwork *supplicant_network) +{ + GSupplicantInterface *interface; + struct wifi_data *wifi; + struct connman_mesh *connman_mesh; + struct wifi_mesh_info *mesh_info; + const char *identifier; + + interface = g_supplicant_network_get_interface(supplicant_network); + wifi = g_supplicant_interface_get_data(interface); + if (!wifi || !wifi->mesh_interface) { + DBG("Virtual Mesh interface not created"); + return; + } + + identifier = g_supplicant_network_get_identifier(supplicant_network); + if (!identifier) { + DBG("Failed to get Mesh Peer identifier"); + return; + } + + mesh_info = wifi->mesh_info; + connman_mesh = connman_mesh_get(mesh_info->identifier, identifier); + if (connman_mesh) { + /* Do not unregister connected mesh peer */ + if (connman_mesh_peer_is_connected_state(connman_mesh)) { + DBG("Mesh Peer %s is connected", identifier); + return; + } + DBG("Mesh Peer identifier %s removed", identifier); + connman_mesh_unregister(connman_mesh); + } +} +#endif + static void network_added(GSupplicantNetwork *supplicant_network) { struct connman_network *network; @@ -3417,6 +4195,13 @@ static void network_added(GSupplicantNetwork *supplicant_network) if (!g_strcmp0(mode, "adhoc")) return; +#if defined TIZEN_EXT_WIFI_MESH + if (!g_strcmp0(mode, "mesh")) { + mesh_peer_added(supplicant_network); + return; + } +#endif + interface = g_supplicant_network_get_interface(supplicant_network); wifi = g_supplicant_interface_get_data(interface); name = g_supplicant_network_get_name(supplicant_network); @@ -3543,6 +4328,15 @@ static void network_removed(GSupplicantNetwork *network) const char *name, *identifier; struct connman_network *connman_network; +#if defined TIZEN_EXT_WIFI_MESH + const char *mode; + mode = g_supplicant_network_get_mode(network); + if (!g_strcmp0(mode, "mesh")) { + mesh_peer_removed(network); + return; + } +#endif + interface = g_supplicant_network_get_interface(network); wifi = g_supplicant_interface_get_data(interface); identifier = g_supplicant_network_get_identifier(network); @@ -4026,6 +4820,13 @@ static const GSupplicantCallbacks callbacks = { .debug = debug, .disconnect_reasoncode = disconnect_reasoncode, .assoc_status_code = assoc_status_code, +#if defined TIZEN_EXT_WIFI_MESH + .mesh_support = mesh_support, + .mesh_group_started = mesh_group_started, + .mesh_group_removed = mesh_group_removed, + .mesh_peer_connected = mesh_peer_connected, + .mesh_peer_disconnected = mesh_peer_disconnected, +#endif }; |