if (service->mesh_activated) {
/* Already activated */
- manager_complete_enable(object, invocation,
- MESHD_ERROR_OPERATION_FAILED);
- } else {
- /* Do API response first */
- manager_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) {
+ 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) {
goto FINISH;
}
- ret = mesh_request_load_saved_mesh_network(&service->saved_mesh_network);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_load_saved_mesh_network [%d]", ret);
- goto FINISH;
- }
-
FINISH:
net_mesh_emit_mesh_enabled(meshd_dbus_get_object(), ret);
manager_complete_disable(object, invocation, ret);
ret = mesh_request_unregister_event_handler();
- if (MESHD_ERROR_NONE != ret) {
+ if (MESHD_ERROR_NONE != ret)
MESH_LOGE("Failed to unregister mesh event handler !! [%d]", ret);
- }
/* Terminate daemon */
meshd_service_exit(service);
meshd_check_null_ret_error("info", info, FALSE);
- ret = mesh_request_ipc_mesh_scan(service);
+ ret = mesh_request_scan(service);
if (MESHD_ERROR_NONE != ret)
- MESH_LOGE("Failed to mesh_request_ipc_mesh_scan !");
-
-#if 0
- ret = mesh_request_scan(info->mesh_interface);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_scan on mesh interface[%s] !",
- info->mesh_interface);
- }
+ MESH_LOGE("Failed to mesh_request_scan !");
- /* Fall-back */
- if (MESHD_ERROR_IN_PROGRESS != ret) {
- ret = mesh_request_scan(info->base_interface);
- if (MESHD_ERROR_NONE != ret)
- MESH_LOGE("Failed to mesh_request_scan on base interface[%s] !",
- info->base_interface);
- }
-#endif
net_mesh_complete_scan(object, invocation, ret);
return TRUE;
meshd_check_null_ret_error("info", info, FALSE);
- ret = mesh_ipc_mesh_specific_scan(service, mesh_id, channel);
+ ret = mesh_request_specific_scan(service, mesh_id, channel);
if (MESHD_ERROR_NONE != ret)
MESH_LOGE("Failed to mesh_request_specific_scan !");
-#if 0
- ret = mesh_request_specific_scan(info->mesh_interface, mesh_id, channel);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_specific_scan on mesh interface[%s]",
- info->mesh_interface);
- }
-
- /* Fall-back */
- if (MESHD_ERROR_IN_PROGRESS != ret) {
- ret = mesh_request_specific_scan(info->base_interface, mesh_id, channel);
- if (MESHD_ERROR_NONE != ret)
- MESH_LOGE("Failed to mesh_request_specific_scan on base interface[%s]",
- info->base_interface);
- }
-#endif
net_mesh_complete_specific_scan(object, invocation, ret);
return TRUE;
{
int ret = MESHD_ERROR_NONE;
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) {
+ 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);
g_free(scan_item->bssid);
g_free(scan_item->object_path);
}
+ g_free(scan_item);
+}
+
+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)
{
int ret = MESHD_ERROR_NONE;
mesh_service *service = (mesh_service *)user_data;
- //mesh_interface_s *info = service->interface_info;
GVariantBuilder builder;
GVariant* networks;
MESH_LOGD("Request to get scanned mesh network list");
- ret = mesh_request_ipc_mesh_get_peers(service);
+ ret = mesh_request_get_networks(service);
if (MESHD_ERROR_NONE != ret)
- MESH_LOGE("Failed to mesh_request_ipc_mesh_get_peers");
-
-#if 0
- ret = mesh_request_get_scan_result(info->mesh_interface, &service->scanned_mesh_network);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_get_scan_result");
+ MESH_LOGE("Failed to mesh_request_get_networks");
- /* Fall-back */
- ret = mesh_request_get_scan_result(info->base_interface,
- &service->scanned_mesh_network);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_get_scan_result on base interface[%s]",
- info->base_interface);
-
- g_dbus_method_invocation_return_error(invocation,
- G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
- }
- }
-#endif
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_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);
}
- /* Clear scan list */
- //g_list_free_full(service->scanned_mesh_network, _on_scan_result_destroy);
- //service->scanned_mesh_network = NULL;
-
networks = g_variant_builder_end(&builder);
net_mesh_complete_get_found_mesh_networks(object, invocation, networks, ret);
{
int ret = MESHD_ERROR_NONE;
mesh_service *service = (mesh_service *)user_data;
- //mesh_interface_s *info = service->interface_info;
-
-#if 0 ///////////////////
- /* Create or join mesh network and create bridge */
- ret = mesh_request_enable_mesh(info->base_interface, info->mesh_interface,
- service->saved_mesh_network, &service->joined_network);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_enable_mesh [%d]", ret);
- goto FINISH;
- }
- ret = mesh_request_create_bridge(info->bridge_interface, info->mesh_interface);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_create_bridge [%d]", ret);
- goto FINISH;
- }
-#endif
- ret = mesh_request_ipc_enable_network(service);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_ipc_enable_network [%d]", ret);
- goto FINISH;
- }
+ /* 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);
#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) {
+ if (MESHD_ERROR_NONE != ret)
MESH_LOGE("Failed to mesh_request_set_mesh_gate [%d]", ret);
- }
-
-
- /* TODO: Check if specific scan is required */
- 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);
- }
- ret = mesh_request_get_scan_result(info->mesh_interface,
- &service->scanned_mesh_network);
-
- /* Request DHCP on bridge interface */
- ret = mesh_request_dhcp(info->bridge_interface);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_dhcp [%d]", ret);
- }
-
- /* TODO: Notify bridge status to Connman */
#endif
-FINISH:
net_mesh_complete_enable_mesh(object, invocation, ret);
return TRUE;
mesh_interface_s *info = service->interface_info;
meshd_check_null_ret_error("info", info, FALSE);
-#if 0
- /* Destroy bridge and return from mesh to infra mode */
- if (service->joined_network) {
- g_free(service->joined_network->mesh_id);
- g_free(service->joined_network);
- service->joined_network = NULL;
- }
-#endif
+
if (FALSE == service->mesh_activated) {
MESH_LOGD("Mesh network is not activated yet");
ret = MESHD_ERROR_OPERATION_FAILED;
return TRUE;
}
- ret = mesh_request_ipc_disable_network(service);
- if (MESHD_ERROR_NONE != ret) {
+ ret = mesh_request_disable_network(service);
+ if (MESHD_ERROR_NONE != ret)
MESH_LOGE("Failed to disable mesh network !");
- }
-#if 0
- /* If DHCP is on progress, stop it */
- ret = mesh_request_stop_dhcp();
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to stop DHCP request !");
- }
- ret = mesh_request_disable_mesh(info->mesh_interface);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_disable_mesh_gate");
- }
-
- ret = mesh_request_remove_bridge(info->bridge_interface);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_remove_bridge");
- }
-#endif
/* Make response */
net_mesh_complete_disable_mesh(object, invocation, ret);
- /* Make notification */
- mesh_notify_left_network();
-
return TRUE;
}
{
int ret = MESHD_ERROR_NONE;
mesh_service *service = (mesh_service *)user_data;
- mesh_network_info_s *joined = service->joined_network;
-
- //gchar *meshid = strdup("meshnet");
- //gchar *bssid = strdup("7c:dd:90:d8:2a:64");
- //gint channel = 161;
- //gint max_speed = 866;
-
- if (joined) {
- net_mesh_complete_get_joined_mesh_network(object, invocation,
- joined->mesh_id, joined->bssid, joined->channel, ret);
+ 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, MESHD_ERROR_NO_DATA);
+ "", "", 0, 0, 0, ret);
}
return TRUE;
}
+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);
+ }
+
+ 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_set_gate(NetMesh *object,
GDBusMethodInvocation *invocation, gboolean stp, gboolean gate_announce,
gpointer user_data)
/* 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) {
+ if (MESHD_ERROR_NONE != ret)
MESH_LOGE("Failed to mesh_request_set_mesh_gate [%d]", ret);
- }
net_mesh_complete_set_gate(object, invocation, ret);
ret = mesh_request_unset_mesh_gate(info->bridge_interface,
info->mesh_interface, info->external_interface);
- if (MESHD_ERROR_NONE != ret) {
+ if (MESHD_ERROR_NONE != ret)
MESH_LOGE("Failed to mesh_request_unset_mesh_gate [%d]", ret);
- }
+
net_mesh_complete_unset_gate(object, invocation, ret);
return TRUE;
ret = mesh_request_set_softap_config(info->softap_interface,
ssid, mode, channel, visibility, max_sta,
security, passphrase);
- if (MESHD_ERROR_NONE != ret) {
+ if (MESHD_ERROR_NONE != ret)
MESH_LOGE("Failed to mesh_request_set_softap_config [%d]", ret);
- }
net_mesh_complete_set_softap(object, invocation, ret);
/* Check softAP interface and execute it */
ret = mesh_request_enable_softap(info->bridge_interface, info->softap_interface);
- if (MESHD_ERROR_NONE != ret) {
+ if (MESHD_ERROR_NONE != ret)
MESH_LOGE("Failed to mesh_request_enable_softap [%d]", ret);
- }
net_mesh_complete_enable_softap(object, invocation, ret);
/* Destroy softAP */
ret = mesh_request_disable_softap(info->bridge_interface, info->softap_interface);
- if (MESHD_ERROR_NONE != ret) {
+ if (MESHD_ERROR_NONE != ret)
MESH_LOGE("Failed to mesh_request_disable_softap [%d]", ret);
- }
net_mesh_complete_disable_softap(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_add_mesh_network(NetMesh *object,
+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_add_mesh_network(&service->saved_mesh_network,
- mesh_id, channel, security);
+ ret = mesh_request_create_mesh_network(service, mesh_id, channel, sec);
- net_mesh_complete_add_mesh_network(object, invocation, ret);
+ net_mesh_complete_create_mesh_network(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_get_saved_mesh_network(NetMesh *object,
+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;
- GVariantBuilder builder;
- GVariant* networks;
- GList *iter = NULL;
+ ret = mesh_request_connect_mesh_network(service, mesh_id, channel, sec, passphrase);
- ret = mesh_request_get_saved_mesh_network(&service->saved_mesh_network);
- if (MESHD_ERROR_NONE != ret) {
- MESH_LOGE("Failed to mesh_request_get_saved_mesh_network");
-
- g_dbus_method_invocation_return_error(invocation,
- G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
- } else {
- /* TODO: Get station information and make variant data */
- g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
-
- iter = service->saved_mesh_network;
- while (iter != NULL) {
- mesh_network_info_s *item = (mesh_network_info_s*)iter->data;
-
- g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
- g_variant_builder_add(&builder, "{sv}", "mesh_id",
- g_variant_new_string(item->mesh_id));
- g_variant_builder_add(&builder, "{sv}", "channel",
- g_variant_new_uint32(item->channel));
- g_variant_builder_add(&builder, "{sv}", "security",
- g_variant_new_uint32(item->security));
- g_variant_builder_close(&builder);
-
- iter = g_list_next(iter);
- }
-
- networks = g_variant_builder_end(&builder);
- net_mesh_complete_get_saved_mesh_network(object, invocation, networks, ret);
- }
+ net_mesh_complete_connect_mesh_network(object, invocation, ret);
return TRUE;
}
-
-static gboolean _meshd_dbus_handle_select_saved_mesh_network(NetMesh *object,
+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_select_saved_mesh_network(&service->saved_mesh_network,
- // mesh_id, channel, security);
-
-/* ADDED */
- ret = mesh_request_ipc_connect_mesh_network(service, mesh_id, channel, security);
-/* ADDED */
+ ret = mesh_request_disconnect_mesh_network(service, mesh_id, channel, sec);
- net_mesh_complete_select_saved_mesh_network(object, invocation, ret);
+ net_mesh_complete_disconnect_mesh_network(object, invocation, ret);
return TRUE;
}
-static gboolean _meshd_dbus_handle_forget_saved_mesh_network(NetMesh *object,
+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_forget_saved_mesh_network(&service->saved_mesh_network,
- // mesh_id, channel, security);
- ret = mesh_request_ipc_disconnect_mesh_network(service,
- mesh_id, channel, security);
+ ret = mesh_request_remove_mesh_network(service, mesh_id, channel, sec);
- net_mesh_complete_forget_saved_mesh_network(object, invocation, ret);
+ net_mesh_complete_forget_mesh_network(object, invocation, ret);
return TRUE;
}
* tx retries: 0
* tx failed: 0
* beacon loss: 0
- * signal: -64 dBm
+ * signal: -64 dBm
* signal avg: -63 dBm
* tx bitrate: 54.0 MBit/s
* rx bitrate: 5.5 MBit/s
g_object_unref(station);
}
-#if 0
- g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
- g_variant_builder_add(&builder, "{sv}", "station", g_variant_new_string("7c:dd:90:62:37:cf"));
- g_variant_builder_add(&builder, "{sv}", "inactive_time", g_variant_new_uint32(1685));
- g_variant_builder_add(&builder, "{sv}", "rx_bytes", g_variant_new_uint32(34174));
- g_variant_builder_add(&builder, "{sv}", "rx_packets", g_variant_new_uint32(1181));
- g_variant_builder_add(&builder, "{sv}", "tx_bytes", g_variant_new_uint32(6877));
- g_variant_builder_add(&builder, "{sv}", "tx_packets", g_variant_new_uint32(76));
- g_variant_builder_add(&builder, "{sv}", "tx_retries", g_variant_new_uint32(0));
- g_variant_builder_add(&builder, "{sv}", "tx_failed", g_variant_new_uint32(0));
- g_variant_builder_add(&builder, "{sv}", "beacon_loss", g_variant_new_uint32(0));
- g_variant_builder_add(&builder, "{sv}", "signal", g_variant_new_int32(-64));
- g_variant_builder_add(&builder, "{sv}", "signal_avg", g_variant_new_int32(-63));
- g_variant_builder_add(&builder, "{sv}", "tx_bitrate", g_variant_new_uint32(540)); /* 10 times */
- g_variant_builder_add(&builder, "{sv}", "rx_bitrate", g_variant_new_uint32(55)); /* 10 times */
- g_variant_builder_add(&builder, "{sv}", "mesh_llid", g_variant_new_uint32(51731));
- g_variant_builder_add(&builder, "{sv}", "mesh_plid", g_variant_new_uint32(35432));
- g_variant_builder_add(&builder, "{sv}", "mesh_plink", g_variant_new_uint32(1)); /* 0 : DISCON, 1 : ESTAB */
- g_variant_builder_add(&builder, "{sv}", "mesh_local_PS_mode", g_variant_new_uint32(1)); /* 0 : INACTIVE, 1 : ACTIVE */
- g_variant_builder_add(&builder, "{sv}", "mesh_peer_PS_mode", g_variant_new_uint32(1)); /* 0 : INACTIVE, 1 : ACTIVE */
- g_variant_builder_add(&builder, "{sv}", "mesh_none_peer_PS_mode", g_variant_new_uint32(1)); /* 0 : INACTIVE, 1 : ACTIVE */
- g_variant_builder_add(&builder, "{sv}", "authorized", g_variant_new_boolean(TRUE));
- g_variant_builder_add(&builder, "{sv}", "associated", g_variant_new_boolean(TRUE));
- g_variant_builder_add(&builder, "{sv}", "preamble",g_variant_new_string("long"));
- g_variant_builder_add(&builder, "{sv}", "WMM_WME", g_variant_new_boolean(TRUE));
- g_variant_builder_add(&builder, "{sv}", "MFP", g_variant_new_boolean(FALSE));
- g_variant_builder_add(&builder, "{sv}", "TDLS_peer", g_variant_new_boolean(FALSE));
- g_variant_builder_add(&builder, "{sv}", "DTIM_period", g_variant_new_uint32(0));
- g_variant_builder_add(&builder, "{sv}", "beacon_interval", g_variant_new_uint32(1000));
- g_variant_builder_add(&builder, "{sv}", "short_slot_time", g_variant_new_boolean(TRUE));
- g_variant_builder_add(&builder, "{sv}", "connected_time", g_variant_new_uint32(256));
- station = g_variant_builder_end(&builder);
-
- net_mesh_complete_get_station_info(object, invocation, station, ret);
-
- g_object_unref(station);
-#endif
return TRUE;
}
*/
/* 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_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_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-add-mesh-network",
- G_CALLBACK(_meshd_dbus_handle_add_mesh_network), service);
- g_signal_connect(meshd_dbus_object, "handle-get-saved-mesh-network",
- G_CALLBACK(_meshd_dbus_handle_get_saved_mesh_network), service);
- g_signal_connect(meshd_dbus_object, "handle-select-saved-mesh-network",
- G_CALLBACK(_meshd_dbus_handle_select_saved_mesh_network), service);
- g_signal_connect(meshd_dbus_object, "handle-forget-saved-mesh-network",
- G_CALLBACK(_meshd_dbus_handle_forget_saved_mesh_network), 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",
return FALSE;
}
- /* Get D-Bus owner to activate zigbee-daemon */
+ /* 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,
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;
}
- mesh_request_clear_saved_mesh_network(&service->saved_mesh_network);
/* 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