*
*/
#include <stdlib.h>
+#include <string.h>
#include <glib.h>
#include <gio/gio.h>
#include "mesh.h"
#include "mesh-log.h"
#include "mesh-util.h"
+#include "mesh-gdbus.h"
+#include "mesh-service.h"
#include "mesh-service-interface.h"
#include "mesh-generated-code.h"
#include "mesh-interface.h"
static NetMesh *meshd_dbus_object;
+static Manager *meshd_activator_dbus_object;
/* global list to care resource handle for each client */
static GList *meshd_dbus_client_list;
return MESHD_ERROR_NONE;
}
-static gboolean _meshd_dbus_handle_enable(NetMesh *object,
+static gboolean _meshd_dbus_handle_enable(Manager *object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
if (service->mesh_activated) {
/* Already activated */
- net_mesh_complete_enable(object, invocation,
- MESHD_ERROR_OPERATION_FAILED);
- } else {
- /* Do API response first */
- net_mesh_complete_enable(object, invocation, ret);
- service->mesh_activated = TRUE;
+ manager_complete_enable(object, invocation, MESHD_ERROR_NONE);
+ goto FINISH;
}
+ /* Do API response first */
+ manager_complete_enable(object, invocation, ret);
+ service->mesh_activated = TRUE;
+
meshd_check_null_ret_error("info", info, FALSE);
+ /* Register event handler first */
+ ret = mesh_request_register_event_handler();
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to register mesh event handler !! [%d]", ret);
+
ret = mesh_interface_initialize(service->interface_info);
if (MESHD_ERROR_NONE != ret) {
MESH_LOGE("Failed to mesh_interface_initialize [%d]", ret);
goto FINISH;
}
- ret = mesh_request_enable_mesh_gate(info->base_interface,
- info->mesh_interface, info->mesh_id, info->mesh_channel);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_enable_mesh_gate [%d]", ret);
- goto FINISH;
- }
+FINISH:
+ net_mesh_emit_mesh_enabled(meshd_dbus_get_object(), ret);
- ret = mesh_request_create_bridge(info->bridge_interface,
- info->mesh_interface, info->external_interface);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_create_bridge [%d]", ret);
- goto FINISH;
- }
+ return TRUE;
+}
- ret = mesh_request_specific_scan(info->mesh_interface,
- info->mesh_id, info->mesh_channel);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_specific_scan [%d]", ret);
- }
+static gboolean _meshd_dbus_handle_disable(Manager *object,
+ GDBusMethodInvocation *invocation,
+ gpointer user_data)
+{
+ int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+ mesh_interface_s *info = service->interface_info;
- ret = mesh_request_dhcp(info->bridge_interface);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_dhcp [%d]", ret);
- }
+ meshd_check_null_ret_error("info", info, FALSE);
-FINISH:
- net_mesh_emit_mesh_enabled(object, ret);
+ /* Make response first */
+ manager_complete_disable(object, invocation, ret);
+
+ ret = mesh_request_unregister_event_handler();
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to unregister mesh event handler !! [%d]", ret);
+
+ /* Terminate daemon */
+ meshd_service_exit(service);
return TRUE;
}
-static gboolean _meshd_dbus_handle_disable(NetMesh *object,
+static gboolean _meshd_dbus_handle_scan(NetMesh *object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
meshd_check_null_ret_error("info", info, FALSE);
- if (FALSE == service->mesh_activated) {
- MESH_LOGD("Mesh network is not activated yet");
- ret = MESHD_ERROR_OPERATION_FAILED;
- goto FINISH;
- }
+ ret = mesh_request_scan(service);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_scan !");
- ret = mesh_request_disable_mesh_gate(info->mesh_interface);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_disable_mesh_gate");
- goto FINISH;
+ net_mesh_complete_scan(object, invocation, ret);
+
+ return TRUE;
+}
+
+static gboolean _meshd_dbus_handle_specific_scan(NetMesh *object,
+ GDBusMethodInvocation *invocation,
+ gchar *mesh_id,
+ gint channel,
+ gpointer user_data)
+{
+ int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+ mesh_interface_s *info = service->interface_info;
+
+ meshd_check_null_ret_error("info", info, FALSE);
+
+ ret = mesh_request_specific_scan(service, mesh_id, channel);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_specific_scan !");
+
+ net_mesh_complete_specific_scan(object, invocation, ret);
+
+ return TRUE;
+}
+
+static gboolean _meshd_dbus_handle_cancel_scan(NetMesh *object,
+ GDBusMethodInvocation *invocation,
+ gpointer user_data)
+{
+ int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+
+ ret = mesh_request_cancel_scan(service);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_cancel_scan");
+
+ net_mesh_complete_cancel_scan(object, invocation, ret);
+
+ return TRUE;
+}
+
+static void _on_scan_result_destroy(gpointer data)
+{
+ mesh_scan_result_s *scan_item = (mesh_scan_result_s *)data;
+
+ if (scan_item) {
+ g_free(scan_item->mesh_id);
+ g_free(scan_item->bssid);
+ g_free(scan_item->object_path);
}
+ g_free(scan_item);
+}
- ret = mesh_request_remove_bridge(info->bridge_interface);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_remove_bridge");
+static void _on_peer_info_destroy(gpointer data)
+{
+ mesh_peer_info_s *peer = (mesh_peer_info_s *)data;
+ if (peer)
+ g_free(peer->address);
+ g_free(peer);
+}
+
+static void _on_station_list_destroy(gpointer data)
+{
+ mesh_station_info_s *info = (mesh_station_info_s*)data;
+
+ if (info) {
+ g_free(info->bssid);
+ g_free(info);
}
+}
-FINISH:
- net_mesh_complete_disable(object, invocation, ret);
+static void _on_mpath_list_destroy(gpointer data)
+{
+ mesh_mpath_info_s *info = (mesh_mpath_info_s*)data;
- return TRUE;
+ if (info) {
+ g_free(info->dest_addr);
+ g_free(info->next_hop);
+ g_free(info->interface);
+ g_free(info);
+ }
}
-static gboolean _meshd_dbus_handle_set_mesh_gate(NetMesh *object,
+static gboolean _meshd_dbus_handle_get_found_mesh_networks(NetMesh *object,
GDBusMethodInvocation *invocation,
- gboolean state,
gpointer user_data)
{
int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
- MESH_LOGD("Not implemented yet !");
- NOTUSED(state);
- NOTUSED(user_data);
+ GVariantBuilder builder;
+ GVariant* networks;
+ GList *iter = NULL;
+ mesh_scan_result_s *scan_item = NULL;
+
+ MESH_LOGD("Request to get scanned mesh network list");
+
+ ret = mesh_request_get_networks(service);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_get_networks");
+
+ g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
+
+ /* scanned_mesh_network would be filled above request */
+ iter = service->scanned_mesh_network;
+ while (iter != NULL) {
+ scan_item = (mesh_scan_result_s*)iter->data;
+
+ g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
+ g_variant_builder_add(&builder, "{sv}", "mesh_id",
+ g_variant_new_string(scan_item->mesh_id));
+ g_variant_builder_add(&builder, "{sv}", "bssid",
+ g_variant_new_string(scan_item->bssid));
+ g_variant_builder_add(&builder, "{sv}", "rssi",
+ g_variant_new_int32(scan_item->rssi));
+ g_variant_builder_add(&builder, "{sv}", "channel",
+ g_variant_new_uint32(scan_item->channel));
+ g_variant_builder_add(&builder, "{sv}", "security",
+ g_variant_new_uint32((int)scan_item->security));
+ g_variant_builder_add(&builder, "{sv}", "state",
+ g_variant_new_uint32(scan_item->state));
+ g_variant_builder_close(&builder);
+
+ iter = g_list_next(iter);
+ }
- /* TODO: Check external interface and set it into bridge */
+ networks = g_variant_builder_end(&builder);
- net_mesh_complete_set_mesh_gate(object, invocation, ret);
+ net_mesh_complete_get_found_mesh_networks(object, invocation, networks, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_set_mesh_softap(NetMesh *object,
+static gboolean _meshd_dbus_handle_enable_mesh(NetMesh *object,
GDBusMethodInvocation *invocation,
- gboolean state,
gpointer user_data)
{
int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
- MESH_LOGD("Not implemented yet !");
- NOTUSED(state);
- NOTUSED(user_data);
+ /* It handles creating virtual network and bridge */
+ ret = mesh_request_enable_network(service);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_enable_network [%d]", ret);
- /* TODO: Check softAP interface and execute it */
+#if 0
+ /* Detect external network state (i.e. Ethernet)
+ and decide to make gate enabled */
+ ret = mesh_request_set_mesh_gate(info->bridge_interface,
+ info->mesh_interface, info->external_interface);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_set_mesh_gate [%d]", ret);
+#endif
- net_mesh_complete_set_mesh_softap(object, invocation, ret);
+ net_mesh_complete_enable_mesh(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_scan(NetMesh *object,
+static gboolean _meshd_dbus_handle_disable_mesh(NetMesh *object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
meshd_check_null_ret_error("info", info, FALSE);
- ret = mesh_request_scan(info->mesh_interface);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_scan");
+ if (FALSE == service->mesh_activated) {
+ MESH_LOGD("Mesh network is not activated yet");
+ ret = MESHD_ERROR_OPERATION_FAILED;
+ net_mesh_complete_disable_mesh(object, invocation, ret);
+ return TRUE;
}
- net_mesh_complete_scan(object, invocation, ret);
+ ret = mesh_request_disable_network(service);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to disable mesh network !");
+
+ /* Make response */
+ net_mesh_complete_disable_mesh(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_specific_scan(NetMesh *object,
+static gboolean _meshd_dbus_handle_get_joined_mesh_network(NetMesh *object,
GDBusMethodInvocation *invocation,
- gchar *mesh_id,
- gint channel,
gpointer user_data)
{
int ret = MESHD_ERROR_NONE;
mesh_service *service = (mesh_service *)user_data;
- mesh_interface_s *info = service->interface_info;
+ mesh_network_info_s *joined = NULL;
+
+ ret = mesh_request_get_joined_network(service);
+ if (MESHD_ERROR_NONE == ret) {
+ joined = service->joined_network;
+ if (joined) {
+ net_mesh_complete_get_joined_mesh_network(object, invocation,
+ joined->mesh_id, joined->bssid,
+ joined->channel, (int)joined->security,
+ joined->state, ret);
+ } else {
+ net_mesh_complete_get_joined_mesh_network(object, invocation,
+ "", "", 0, 0, 0, MESHD_ERROR_NO_DATA);
+ }
+ } else {
+ net_mesh_complete_get_joined_mesh_network(object, invocation,
+ "", "", 0, 0, 0, ret);
+ }
- meshd_check_null_ret_error("info", info, FALSE);
+ return TRUE;
+}
- ret = mesh_request_specific_scan(info->mesh_interface, mesh_id, channel);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_specific_scan");
+static gboolean _meshd_dbus_handle_get_connected_peers(NetMesh *object,
+ GDBusMethodInvocation *invocation,
+ gpointer user_data)
+{
+ int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+
+ GVariantBuilder builder;
+ GVariant* peer_list;
+ GList *iter = NULL;
+ mesh_peer_info_s *peer = NULL;
+
+ MESH_LOGD("Request to get connected peers");
+
+ ret = mesh_request_get_connected_peers(service);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_get_connected_peers");
+ g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
+
+ iter = service->connected_mesh_peers;
+ while (iter != NULL) {
+ peer = (mesh_peer_info_s*)iter->data;
+
+ g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
+ g_variant_builder_add(&builder, "{sv}", "Address",
+ g_variant_new_string(peer->address));
+ g_variant_builder_close(&builder);
+
+ iter = g_list_next(iter);
}
- net_mesh_complete_specific_scan(object, invocation, ret);
+ peer_list = g_variant_builder_end(&builder);
+
+ net_mesh_complete_get_connected_peers(object, invocation, peer_list, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_cancel_scan(NetMesh *object,
+static gboolean _meshd_dbus_handle_set_gate(NetMesh *object,
+ GDBusMethodInvocation *invocation, gboolean stp, gboolean gate_announce,
+ gpointer user_data)
+{
+ int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+ mesh_interface_s *info = service->interface_info;
+
+ MESH_LOGD("STP = %d", stp);
+ MESH_LOGD("gate_announce = %d", gate_announce);
+
+ /* Set STP and gate_announce */
+ ret = mesh_request_set_mesh_gate(info->bridge_interface,
+ info->mesh_interface, info->external_interface);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_set_mesh_gate [%d]", ret);
+
+ net_mesh_complete_set_gate(object, invocation, ret);
+
+ return TRUE;
+}
+
+static gboolean _meshd_dbus_handle_unset_gate(NetMesh *object,
GDBusMethodInvocation *invocation,
gpointer user_data)
{
mesh_service *service = (mesh_service *)user_data;
mesh_interface_s *info = service->interface_info;
- ret = mesh_request_cancel_scan(info->mesh_interface);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_cancel_scan");
- }
+ ret = mesh_request_unset_mesh_gate(info->bridge_interface,
+ info->mesh_interface, info->external_interface);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_unset_mesh_gate [%d]", ret);
- net_mesh_complete_cancel_scan(object, invocation, ret);
+ net_mesh_complete_unset_gate(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_get_station_info(NetMesh *object,
- GDBusMethodInvocation *invocation)
+static gboolean _meshd_dbus_handle_set_softap(NetMesh *object,
+ GDBusMethodInvocation *invocation,
+ gchar *ssid, gchar *passphrase,
+ gchar *mode, gint channel, gint visibility, gint max_sta,
+ gint security, gpointer user_data)
{
int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+ mesh_interface_s *info = service->interface_info;
- NOTUSED(ret);
- NOTUSED(object);
- NOTUSED(invocation);
+ MESH_LOGD("SSID : %s", ssid);
+ MESH_LOGD("mode : %s", mode);
+ MESH_LOGD("channel : %d", channel);
+ MESH_LOGD("visibility: %d", visibility);
+ MESH_LOGD("max_sta : %d", max_sta);
+ MESH_LOGD("security : %d", security);
- MESH_LOGD("Not implemented yet !");
- //net_mesh_complete_get_station_info(object, invocation, ret);
+ /* Save softAP information */
+ ret = mesh_request_set_softap_config(info->softap_interface,
+ ssid, mode, channel, visibility, max_sta,
+ security, passphrase);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_set_softap_config [%d]", ret);
+
+ net_mesh_complete_set_softap(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_get_mpath_info(NetMesh *object,
- GDBusMethodInvocation *invocation)
+static gboolean _meshd_dbus_handle_enable_softap(NetMesh *object,
+ GDBusMethodInvocation *invocation, gpointer user_data)
{
int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+ mesh_interface_s *info = service->interface_info;
- NOTUSED(ret);
- NOTUSED(object);
- NOTUSED(invocation);
+ /* Check softAP interface and execute it */
+ ret = mesh_request_enable_softap(info->bridge_interface, info->softap_interface);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_enable_softap [%d]", ret);
- MESH_LOGD("Not implemented yet !");
- //net_mesh_complete_get_mpath_info(object, invocation, ret);
+ net_mesh_complete_enable_softap(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_join(NetMesh *object,
- GDBusMethodInvocation *invocation)
+static gboolean _meshd_dbus_handle_disable_softap(NetMesh *object,
+ GDBusMethodInvocation *invocation, gpointer user_data)
{
int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+ mesh_interface_s *info = service->interface_info;
+
+ /* Destroy softAP */
+ ret = mesh_request_disable_softap(info->bridge_interface, info->softap_interface);
+ if (MESHD_ERROR_NONE != ret)
+ MESH_LOGE("Failed to mesh_request_disable_softap [%d]", ret);
- MESH_LOGD("Not implemented yet !");
- net_mesh_complete_join(object, invocation, ret);
+ net_mesh_complete_disable_softap(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_is_joined(NetMesh *object,
- GDBusMethodInvocation *invocation)
+static gboolean _meshd_dbus_handle_create_mesh_network(NetMesh *object,
+ GDBusMethodInvocation *invocation,
+ gchar *mesh_id, gint channel, gint security,
+ gpointer user_data)
{
int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+ meshd_security_type_e sec = (1 == security) ? MESHD_SECURITY_SAE : MESHD_SECURITY_NONE;
+
+ ret = mesh_request_create_mesh_network(service, mesh_id, channel, sec);
- MESH_LOGD("Not implemented yet !");
- net_mesh_complete_is_joined(object, invocation, ret);
+ net_mesh_complete_create_mesh_network(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_disjoin(NetMesh *object,
- GDBusMethodInvocation *invocation)
+static gboolean _meshd_dbus_handle_connect_mesh_network(NetMesh *object,
+ GDBusMethodInvocation *invocation,
+ gchar *mesh_id, gint channel, gint security, gchar *passphrase,
+ gpointer user_data)
{
int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+ meshd_security_type_e sec = (1 == security) ? MESHD_SECURITY_SAE : MESHD_SECURITY_NONE;
+
+ ret = mesh_request_connect_mesh_network(service, mesh_id, channel, sec, passphrase);
- MESH_LOGD("Not implemented yet !");
- net_mesh_complete_disjoin(object, invocation, ret);
+ net_mesh_complete_connect_mesh_network(object, invocation, ret);
return TRUE;
}
+static gboolean _meshd_dbus_handle_disconnect_mesh_network(NetMesh *object,
+ GDBusMethodInvocation *invocation,
+ gchar *mesh_id, gint channel, gint security,
+ gpointer user_data)
+{
+ int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+ meshd_security_type_e sec = (1 == security) ? MESHD_SECURITY_SAE : MESHD_SECURITY_NONE;
+
+ ret = mesh_request_disconnect_mesh_network(service, mesh_id, channel, sec);
-static gboolean _meshd_dbus_handle_load_softap_settings(NetMesh *object,
- GDBusMethodInvocation *invocation)
+ net_mesh_complete_disconnect_mesh_network(object, invocation, ret);
+
+ return TRUE;
+}
+
+static gboolean _meshd_dbus_handle_forget_mesh_network(NetMesh *object,
+ GDBusMethodInvocation *invocation,
+ gchar *mesh_id, gint channel, gint security,
+ gpointer user_data)
{
int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+ meshd_security_type_e sec = (1 == security) ? MESHD_SECURITY_SAE : MESHD_SECURITY_NONE;
+
+ ret = mesh_request_remove_mesh_network(service, mesh_id, channel, sec);
- MESH_LOGD("Not implemented yet !");
- net_mesh_complete_load_softap_settings(object, invocation, ret);
+ net_mesh_complete_forget_mesh_network(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_start_bridge(NetMesh *object,
+static gboolean _meshd_dbus_handle_set_interfaces(NetMesh *object,
GDBusMethodInvocation *invocation,
- gint mode,
- gchar *bridge_interface,
+ gchar *mesh, gchar *gate, gchar *softap,
gpointer user_data)
{
int ret = MESHD_ERROR_NONE;
+ mesh_service *service = (mesh_service *)user_data;
+ mesh_interface_s *info = service->interface_info;
- NOTUSED(user_data);
+ g_free(info->mesh_interface);
+ info->mesh_interface = g_strdup(mesh);
+
+ g_free(info->external_interface);
+ info->external_interface = g_strdup(gate);
- MESH_LOGD("Mode : %d", mode);
- MESH_LOGD("Interface : %s", bridge_interface);
- ret = mesh_request_create_bridge(bridge_interface, NULL, NULL);
+ g_free(info->softap_interface);
+ info->softap_interface = g_strdup(softap);
- net_mesh_complete_start_bridge(object, invocation, ret);
+ MESH_LOGD("Interface configuration for mesh network :");
+ MESH_LOGD(" Base : [%s]", info->base_interface);
+ MESH_LOGD(" Mesh : [%s]", info->mesh_interface);
+ MESH_LOGD(" Bridge : [%s]", info->bridge_interface);
+ MESH_LOGD(" SoftAP : [%s]", info->softap_interface);
+ MESH_LOGD(" External: [%s]", info->external_interface);
+
+ net_mesh_complete_set_interfaces(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_stop_bridge(NetMesh *object,
+static gboolean _meshd_dbus_handle_get_station_info(NetMesh *object,
GDBusMethodInvocation *invocation,
- gchar *bridge_interface,
gpointer user_data)
{
int ret = MESHD_ERROR_NONE;
- NOTUSED(user_data);
+ GVariantBuilder builder;
+ GVariant* station;
+ GList *iter = NULL;
- MESH_LOGD("Interface : %s", bridge_interface);
- ret = mesh_request_remove_bridge(bridge_interface);
+ mesh_service *service = (mesh_service *)user_data;
+ mesh_interface_s *info = service->interface_info;
- net_mesh_complete_stop_bridge(object, invocation, ret);
+ /* Clear mesh station list */
+ g_list_free_full(service->station_list, _on_station_list_destroy);
+ service->station_list = NULL;
+
+ ret = mesh_request_get_station_info(
+ info->mesh_interface, &service->station_list);
+ if (MESHD_ERROR_NONE != ret) {
+ MESH_LOGE("Failed to mesh_request_get_station_info");
+
+ g_dbus_method_invocation_return_error(invocation,
+ G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
+ } else {
+ /*
+ * sh-3.2# iw mesh0 station dump
+ * Station 7c:dd:90:62:37:cf (on mesh0)
+ * inactive time: 1685 ms
+ * rx bytes: 34174
+ * rx packets: 1181
+ * tx bytes: 6877
+ * tx packets: 76
+ * tx retries: 0
+ * tx failed: 0
+ * beacon loss: 0
+ * signal: -64 dBm
+ * signal avg: -63 dBm
+ * tx bitrate: 54.0 MBit/s
+ * rx bitrate: 5.5 MBit/s
+ * mesh llid: 51731
+ * mesh plid: 35432
+ * mesh plink: ESTAB
+ * mesh local PS mode: ACTIVE
+ * mesh peer PS mode: ACTIVE
+ * mesh non-peer PS mode: ACTIVE
+ * authorized: yes
+ * authenticated: yes
+ * associated: yes
+ * preamble: long
+ * WMM/WME: yes
+ * MFP: no
+ * TDLS peer: no
+ * DTIM period: 0
+ * beacon interval:1000
+ * short slot time:yes
+ * connected time: 256 seconds
+ */
+ /* Get station information and make variant data */
+ g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
+
+ iter = service->station_list;
+ while (iter != NULL) {
+ mesh_station_info_s *item = (mesh_station_info_s*)iter->data;
+
+ g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
+ g_variant_builder_add(&builder, "{sv}", "bssid",
+ g_variant_new_string(item->bssid));
+ g_variant_builder_add(&builder, "{sv}", "inactive_time",
+ g_variant_new_uint32(item->inactive_time));
+ g_variant_builder_add(&builder, "{sv}", "rx_bytes",
+ g_variant_new_uint64(item->rx_bytes));
+ g_variant_builder_add(&builder, "{sv}", "rx_packets",
+ g_variant_new_uint32(item->rx_packets));
+ g_variant_builder_add(&builder, "{sv}", "tx_bytes",
+ g_variant_new_uint64(item->tx_bytes));
+ g_variant_builder_add(&builder, "{sv}", "tx_packets",
+ g_variant_new_uint32(item->tx_packets));
+ g_variant_builder_add(&builder, "{sv}", "tx_retries",
+ g_variant_new_uint32(item->tx_retries));
+ g_variant_builder_add(&builder, "{sv}", "tx_failed",
+ g_variant_new_uint32(item->tx_failed));
+ g_variant_builder_add(&builder, "{sv}", "beacon_loss",
+ g_variant_new_uint32(item->beacon_loss));
+ g_variant_builder_add(&builder, "{sv}", "beacon_rx",
+ g_variant_new_uint64(item->beacon_rx));
+ g_variant_builder_add(&builder, "{sv}", "rx_drop_misc",
+ g_variant_new_uint64(item->rx_drop_misc));
+ g_variant_builder_add(&builder, "{sv}", "signal",
+ g_variant_new_int32(item->rssi));
+ g_variant_builder_add(&builder, "{sv}", "signal_avg",
+ g_variant_new_int32(item->rssi_avg));
+ g_variant_builder_add(&builder, "{sv}", "tx_bitrate",
+ g_variant_new_uint32(item->tx_bitrate)); /* 10 times */
+ g_variant_builder_add(&builder, "{sv}", "rx_bitrate",
+ g_variant_new_uint32(item->rx_bitrate)); /* 10 times */
+ g_variant_builder_add(&builder, "{sv}", "mesh_llid",
+ g_variant_new_uint16(item->llid));
+ g_variant_builder_add(&builder, "{sv}", "mesh_plid",
+ g_variant_new_uint16(item->plid));
+ g_variant_builder_add(&builder, "{sv}", "mesh_plink",
+ g_variant_new_byte(item->mesh_plink)); /* 0 : DISCON, 1 : ESTAB */
+ g_variant_builder_add(&builder, "{sv}", "local_ps_mode",
+ g_variant_new_uint32(item->local_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
+ g_variant_builder_add(&builder, "{sv}", "peer_ps_mode",
+ g_variant_new_uint32(item->peer_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
+ g_variant_builder_add(&builder, "{sv}", "non_peer_ps_mode",
+ g_variant_new_uint32(item->non_peer_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
+ g_variant_builder_add(&builder, "{sv}", "authorized",
+ g_variant_new_boolean(item->authorized));
+ g_variant_builder_add(&builder, "{sv}", "associated",
+ g_variant_new_boolean(item->associated));
+ g_variant_builder_add(&builder, "{sv}", "preamble",
+ g_variant_new_boolean(item->preamble));
+ g_variant_builder_add(&builder, "{sv}", "WMM_WME",
+ g_variant_new_boolean(item->wme));
+ g_variant_builder_add(&builder, "{sv}", "MFP",
+ g_variant_new_boolean(item->mfp));
+ g_variant_builder_add(&builder, "{sv}", "TDLS_peer",
+ g_variant_new_boolean(item->tdls_peer));
+ g_variant_builder_add(&builder, "{sv}", "DTIM_period",
+ g_variant_new_byte(item->dtim_period));
+ g_variant_builder_add(&builder, "{sv}", "beacon_interval",
+ g_variant_new_uint16(item->beacon_interval));
+ g_variant_builder_add(&builder, "{sv}", "short_slot_time",
+ g_variant_new_boolean(item->short_slot_time));
+ g_variant_builder_add(&builder, "{sv}", "connected_time",
+ g_variant_new_uint32(item->connected_time));
+ g_variant_builder_close(&builder);
+
+ iter = g_list_next(iter);
+ }
+
+ station = g_variant_builder_end(&builder);
+ net_mesh_complete_get_station_info(object, invocation, station, ret);
+
+ g_object_unref(station);
+ }
return TRUE;
}
+static gboolean _meshd_dbus_handle_get_mpath_info(NetMesh *object,
+ GDBusMethodInvocation *invocation,
+ gpointer user_data)
+{
+ int ret = MESHD_ERROR_NONE;
+ GVariantBuilder builder;
+ GVariant* mpath_data;
+ GList *iter = NULL;
+
+ mesh_service *service = (mesh_service *)user_data;
+ mesh_interface_s *info = service->interface_info;
+
+ /* Clear mesh path list */
+ g_list_free_full(service->mpath_list, _on_mpath_list_destroy);
+ service->mpath_list = NULL;
+
+ ret = mesh_request_get_mpath_info(
+ info->mesh_interface, &service->mpath_list);
+ if (MESHD_ERROR_NONE != ret) {
+ MESH_LOGE("Failed to mesh_request_get_mpath_info");
+
+ g_dbus_method_invocation_return_error(invocation,
+ G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
+ } else {
+ /*
+ * Example) sh-3.2# iw mesh0 mpath dump
+ * DEST ADDR NEXT HOP IFACE SN METRIC QLEN EXPTIME DTIM DRET FLAGS
+ * 7c:dd:90:62:37:cf 7c:dd:90:62:37:cf mesh0 221 152 0 10 100 0 0x5
+ */
+ /* Get mesh path information and make variant data */
+ g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
+
+ iter = service->mpath_list;
+ while (iter != NULL) {
+ mesh_mpath_info_s *item = (mesh_mpath_info_s*)iter->data;
+
+ g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
+ g_variant_builder_add(&builder, "{sv}", "DEST_ADDR",
+ g_variant_new_string(item->dest_addr));
+ g_variant_builder_add(&builder, "{sv}", "NEXT_HOP",
+ g_variant_new_string(item->next_hop));
+ g_variant_builder_add(&builder, "{sv}", "IFACE",
+ g_variant_new_string(item->interface));
+ g_variant_builder_add(&builder, "{sv}", "SN",
+ g_variant_new_uint32(item->sn));
+ g_variant_builder_add(&builder, "{sv}", "METRIC",
+ g_variant_new_uint32(item->metric));
+ g_variant_builder_add(&builder, "{sv}", "QLEN",
+ g_variant_new_uint32(item->qlen));
+ g_variant_builder_add(&builder, "{sv}", "EXPTIME",
+ g_variant_new_uint32(item->exptime));
+ g_variant_builder_add(&builder, "{sv}", "DTIM",
+ g_variant_new_uint32(item->discovery_timeout));
+ g_variant_builder_add(&builder, "{sv}", "DRET",
+ g_variant_new_byte(item->discovery_retries));
+ g_variant_builder_add(&builder, "{sv}", "FLAGS",
+ g_variant_new_byte(item->flags));
+ g_variant_builder_close(&builder);
+
+ iter = g_list_next(iter);
+ }
+
+ mpath_data = g_variant_builder_end(&builder);
+ net_mesh_complete_get_mpath_info(object, invocation, mpath_data, ret);
+
+ g_object_unref(mpath_data);
+ }
+
+ return TRUE;
+}
+
+static void _meshd_dbus_on_activator_bus_acquired(GDBusConnection *conn,
+ const gchar *name, gpointer user_data)
+{
+ gboolean ret;
+ GError *error = NULL;
+ mesh_service *service = (mesh_service *)user_data;
+
+ NOTUSED(name);
+
+ meshd_activator_dbus_object = manager_skeleton_new();
+ if (NULL == meshd_activator_dbus_object) {
+ MESH_LOGE("manager_skeleton_new() Fail");
+ return;
+ }
+
+ g_signal_connect(meshd_activator_dbus_object, "handle-enable",
+ G_CALLBACK(_meshd_dbus_handle_enable), service);
+ g_signal_connect(meshd_activator_dbus_object, "handle-disable",
+ G_CALLBACK(_meshd_dbus_handle_disable), service);
+
+ ret = g_dbus_interface_skeleton_export(
+ G_DBUS_INTERFACE_SKELETON(meshd_activator_dbus_object),
+ conn, MESH_DBUS_MANAGER_OBJPATH, &error);
+ if (FALSE == ret) {
+ MESH_LOGE("g_dbus_interface_skeleton_export() Fail(%s)", error->message);
+ g_error_free(error);
+ }
+}
static void _meshd_dbus_on_bus_acquired(GDBusConnection *conn, const gchar *name,
gpointer user_data)
return;
}
- g_signal_connect(meshd_dbus_object, "handle-enable",
- G_CALLBACK(_meshd_dbus_handle_enable), service);
- g_signal_connect(meshd_dbus_object, "handle-disable",
- G_CALLBACK(_meshd_dbus_handle_disable), service);
- g_signal_connect(meshd_dbus_object, "handle-set-mesh-gate",
- G_CALLBACK(_meshd_dbus_handle_set_mesh_gate), service);
- g_signal_connect(meshd_dbus_object, "handle-set-mesh-softap",
- G_CALLBACK(_meshd_dbus_handle_set_mesh_softap), service);
g_signal_connect(meshd_dbus_object, "handle-scan",
G_CALLBACK(_meshd_dbus_handle_scan), service);
g_signal_connect(meshd_dbus_object, "handle-specific-scan",
G_CALLBACK(_meshd_dbus_handle_specific_scan), service);
g_signal_connect(meshd_dbus_object, "handle-cancel-scan",
G_CALLBACK(_meshd_dbus_handle_cancel_scan), service);
+ g_signal_connect(meshd_dbus_object, "handle-get-found-mesh-networks",
+ G_CALLBACK(_meshd_dbus_handle_get_found_mesh_networks), service);
+ g_signal_connect(meshd_dbus_object, "handle-enable-mesh",
+ G_CALLBACK(_meshd_dbus_handle_enable_mesh), service);
+ g_signal_connect(meshd_dbus_object, "handle-disable-mesh",
+ G_CALLBACK(_meshd_dbus_handle_disable_mesh), service);
+ g_signal_connect(meshd_dbus_object, "handle-get-joined-mesh-network",
+ G_CALLBACK(_meshd_dbus_handle_get_joined_mesh_network), service);
+ g_signal_connect(meshd_dbus_object, "handle-get-connected-peers",
+ G_CALLBACK(_meshd_dbus_handle_get_connected_peers), service);
+ g_signal_connect(meshd_dbus_object, "handle-set-gate",
+ G_CALLBACK(_meshd_dbus_handle_set_gate), service);
+ g_signal_connect(meshd_dbus_object, "handle-unset-gate",
+ G_CALLBACK(_meshd_dbus_handle_unset_gate), service);
+ g_signal_connect(meshd_dbus_object, "handle-set-softap",
+ G_CALLBACK(_meshd_dbus_handle_set_softap), service);
+ g_signal_connect(meshd_dbus_object, "handle-enable-softap",
+ G_CALLBACK(_meshd_dbus_handle_enable_softap), service);
+ g_signal_connect(meshd_dbus_object, "handle-disable-softap",
+ G_CALLBACK(_meshd_dbus_handle_disable_softap), service);
+ g_signal_connect(meshd_dbus_object, "handle-create-mesh-network",
+ G_CALLBACK(_meshd_dbus_handle_create_mesh_network), service);
+ g_signal_connect(meshd_dbus_object, "handle-connect-mesh-network",
+ G_CALLBACK(_meshd_dbus_handle_connect_mesh_network), service);
+ g_signal_connect(meshd_dbus_object, "handle-disconnect-mesh-network",
+ G_CALLBACK(_meshd_dbus_handle_disconnect_mesh_network), service);
+ g_signal_connect(meshd_dbus_object, "handle-forget-mesh-network",
+ G_CALLBACK(_meshd_dbus_handle_forget_mesh_network), service);
+ g_signal_connect(meshd_dbus_object, "handle-set-interfaces",
+ G_CALLBACK(_meshd_dbus_handle_set_interfaces), service);
g_signal_connect(meshd_dbus_object, "handle-get-station-info",
G_CALLBACK(_meshd_dbus_handle_get_station_info), service);
g_signal_connect(meshd_dbus_object, "handle-get-mpath-info",
G_CALLBACK(_meshd_dbus_handle_get_mpath_info), service);
- g_signal_connect(meshd_dbus_object, "handle-join",
- G_CALLBACK(_meshd_dbus_handle_join), service);
- g_signal_connect(meshd_dbus_object, "handle-is-joined",
- G_CALLBACK(_meshd_dbus_handle_is_joined), service);
- g_signal_connect(meshd_dbus_object, "handle-disjoin",
- G_CALLBACK(_meshd_dbus_handle_disjoin), service);
- g_signal_connect(meshd_dbus_object, "handle-load-softap-settings",
- G_CALLBACK(_meshd_dbus_handle_load_softap_settings), service);
- g_signal_connect(meshd_dbus_object, "handle-start-bridge",
- G_CALLBACK(_meshd_dbus_handle_start_bridge), service);
- g_signal_connect(meshd_dbus_object, "handle-stop-bridge",
- G_CALLBACK(_meshd_dbus_handle_stop_bridge), service);
ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(meshd_dbus_object),
conn, MESH_DBUS_OBJPATH, &error);
static gboolean _meshd_dbus_interface_init(mesh_service *service)
{
guint id;
+ guint activation_dbus_id;
meshd_check_null_ret_error("service", service, FALSE);
id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
return FALSE;
}
+ /* Get D-Bus owner to activate mesh service daemon */
+ activation_dbus_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
+ MESH_DBUS_INTERFACE".manager",
+ G_BUS_NAME_OWNER_FLAGS_REPLACE,
+ _meshd_dbus_on_activator_bus_acquired,
+ NULL,
+ NULL,
+ service,
+ NULL);
+
service->dbus_id = id;
+ service->activation_dbus_id = activation_dbus_id;
service->interface_info = g_new0(mesh_interface_s, 1);
+ service->scanned_mesh_network = NULL;
+
+ /* Initialize DBus sendor logic */
+ meshd_dbus_start(service);
return TRUE;
}
mesh_interface_s *info = NULL;
meshd_check_null_ret("service", service);
+ /* De-Initialize DBus sendor logic */
+ meshd_dbus_stop(service);
+
g_bus_unown_name(service->dbus_id);
+ g_bus_unown_name(service->activation_dbus_id);
info = service->interface_info;
meshd_check_null_ret("info", info);
if (info->external_interface)
g_free(info->external_interface);
+ if (service->joined_network) {
+ g_free(service->joined_network->mesh_id);
+ g_free(service->joined_network->bssid);
+ g_free(service->joined_network);
+ service->joined_network = NULL;
+ }
+
+ /* Clear scan list */
+ g_list_free_full(service->scanned_mesh_network, _on_scan_result_destroy);
+ service->scanned_mesh_network = NULL;
+
+ /* Clear connected peers list */
+ g_list_free_full(service->connected_mesh_peers, _on_peer_info_destroy);
+ service->connected_mesh_peers = NULL;
+
g_free(service->interface_info);
service->interface_info = NULL;
}
- /**< mesh service interface initialization */
+/**< Mesh service interface initialization */
gboolean meshd_service_interface_init(mesh_service *service)
{
guint ret;
/* Initialize dbus interface */
ret = _meshd_dbus_interface_init(service);
if (FALSE == ret) {
- MESH_LOGE("zigbee_service_dbus_interface_init failed!!!");
+ MESH_LOGE("_meshd_dbus_interface_init failed!!!");
return FALSE;
}
return TRUE;
}
-/**< Zigbee service interface de-initialization */
+/**< Mesh service interface de-initialization */
void meshd_service_interface_deinit(mesh_service *service)
{
meshd_check_null_ret("service", service);
projects / platform / core / connectivity / wifi-mesh-manager.git / blobdiff