2 * Network Configuration Module
4 * Copyright (c) 2017 Samsung Electronics Co., Ltd. All rights reserved.
6 * Licensed under the Apache License, Version 2.0 (the "License");
7 * you may not use this file except in compliance with the License.
8 * You may obtain a copy of the License at
10 * http://www.apache.org/licenses/LICENSE-2.0
12 * Unless required by applicable law or agreed to in writing, software
13 * distributed under the License is distributed on an "AS IS" BASIS,
14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
15 * See the License for the specific language governing permissions and
16 * limitations under the License.
24 #include <wifi-manager.h>
27 #include "wmesh-log.h"
28 #include "wmesh-util.h"
29 #include "wmesh-gdbus.h"
30 #include "wmesh-service.h"
31 #include "wmesh-peer-monitor.h"
32 #include "wmesh-service-interface.h"
33 #include "wmesh-generated-code.h"
35 #include "wmesh-request.h"
36 #include "wmesh-interface.h"
38 static NetWmesh *meshd_dbus_object;
39 static Manager *meshd_activator_dbus_object;
41 /* global list to care resource handle for each client */
42 static GList *meshd_dbus_client_list;
43 static GMutex meshd_dbus_client_list_mutex;
45 typedef struct _meshd_dbus_client_s {
47 } meshd_dbus_client_s;
49 #define CASE_TO_STR(x) case x: return #x;
51 static const char* wifi_error_to_string(wifi_manager_error_e err)
54 /* CHECK: List all enum values here */
55 CASE_TO_STR(WIFI_MANAGER_ERROR_NONE)
56 CASE_TO_STR(WIFI_MANAGER_ERROR_INVALID_PARAMETER)
57 CASE_TO_STR(WIFI_MANAGER_ERROR_OUT_OF_MEMORY)
58 CASE_TO_STR(WIFI_MANAGER_ERROR_INVALID_OPERATION)
59 CASE_TO_STR(WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED)
60 CASE_TO_STR(WIFI_MANAGER_ERROR_OPERATION_FAILED)
61 CASE_TO_STR(WIFI_MANAGER_ERROR_NO_CONNECTION)
62 CASE_TO_STR(WIFI_MANAGER_ERROR_NOW_IN_PROGRESS)
63 CASE_TO_STR(WIFI_MANAGER_ERROR_ALREADY_EXISTS)
64 CASE_TO_STR(WIFI_MANAGER_ERROR_OPERATION_ABORTED)
65 CASE_TO_STR(WIFI_MANAGER_ERROR_DHCP_FAILED)
66 CASE_TO_STR(WIFI_MANAGER_ERROR_INVALID_KEY)
67 CASE_TO_STR(WIFI_MANAGER_ERROR_NO_REPLY)
68 CASE_TO_STR(WIFI_MANAGER_ERROR_SECURITY_RESTRICTED)
69 CASE_TO_STR(WIFI_MANAGER_ERROR_ALREADY_INITIALIZED)
70 CASE_TO_STR(WIFI_MANAGER_ERROR_PERMISSION_DENIED)
71 CASE_TO_STR(WIFI_MANAGER_ERROR_NOT_SUPPORTED)
73 return "WIFI_MANAGER_ERROR_UNKNOWN";
77 NetWmesh* wmeshd_dbus_get_object()
79 return meshd_dbus_object;
82 int64_t wmeshd_dbus_generate_signal_number()
89 static int _wmeshd_dbus_client_list_cleanup(GList *client_list)
91 meshd_dbus_client_s *client;
93 wmeshd_check_null_ret_error("client_list", client_list, FALSE);
95 client = client_list->data;
97 free(client->bus_name);
98 client->bus_name = NULL;
100 g_list_free(client_list);
102 return WMESHD_ERROR_NONE;
105 static int _wmeshd_dbus_client_list_compare_bus_name(const void *a, const void *b)
107 const meshd_dbus_client_s *client = a;
109 return g_strcmp0(client->bus_name, b);
112 static inline GList* _wmeshd_dbus_client_list_find_client(const gchar *owner)
114 return g_list_find_custom(meshd_dbus_client_list, owner,
115 _wmeshd_dbus_client_list_compare_bus_name);
118 static void _wmeshd_dbus_name_owner_changed_cb(GDBusConnection *conn,
119 const gchar *sender_name,
120 const gchar *object_path,
121 const gchar *interface_name,
122 const gchar *signal_name,
123 GVariant *parameters,
127 GList *client = NULL;
128 gchar *name, *old_owner, *new_owner;
131 NOTUSED(sender_name);
132 NOTUSED(object_path);
133 NOTUSED(interface_name);
134 NOTUSED(signal_name);
137 g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
139 if (0 == strlen(new_owner)) {
140 g_mutex_lock(&meshd_dbus_client_list_mutex);
141 client = _wmeshd_dbus_client_list_find_client(old_owner);
142 if (client) { /* found bus name in our bus list */
143 WMESH_LOGD("bus(%s) stopped", old_owner);
144 meshd_dbus_client_list = g_list_remove_link(meshd_dbus_client_list, client);
146 g_mutex_unlock(&meshd_dbus_client_list_mutex);
149 ret = _wmeshd_dbus_client_list_cleanup(client);
150 if (WMESHD_ERROR_NONE != ret)
151 WMESH_LOGE("_wmeshd_dbus_client_list_cleanup() Fail(%d)", ret);
156 static int _wmeshd_dbus_subscribe_name_owner_changed(GDBusConnection *conn)
160 id = g_dbus_connection_signal_subscribe(conn,
161 "org.freedesktop.DBus", /* bus name */
162 "org.freedesktop.DBus", /* interface */
163 "NameOwnerChanged", /* member */
164 "/org/freedesktop/DBus", /* path */
166 G_DBUS_SIGNAL_FLAGS_NONE,
167 _wmeshd_dbus_name_owner_changed_cb,
171 WMESH_LOGE("g_dbus_connection_signal_subscribe() Fail");
172 return WMESHD_ERROR_IO_ERROR;
175 return WMESHD_ERROR_NONE;
178 static gboolean _wmeshd_dbus_handle_enable(Manager *object,
179 GDBusMethodInvocation *invocation,
182 int ret = WMESHD_ERROR_NONE;
183 wmesh_service *service = (wmesh_service *)user_data;
184 wmesh_interface_s *info = service->interface_info;
186 wifi_manager_h wifi_handle = NULL;
187 bool wifi_activated = false;
189 /* Initialize Wi-Fi driver */
190 ret = wifi_manager_initialize(&wifi_handle);
191 if (WIFI_MANAGER_ERROR_NONE != ret)
192 WMESH_LOGE("Failed to get wifi manager handle ! [%s(%X)]",
193 wifi_error_to_string(ret), ret);
195 wifi_manager_is_activated(wifi_handle, &wifi_activated);
196 if (false == wifi_activated) {
197 ret = wifi_manager_activate(wifi_handle, NULL, NULL);
198 if (WIFI_MANAGER_ERROR_NONE != ret)
199 WMESH_LOGE("Failed to activate wifi ! [%s(%X)]",
200 wifi_error_to_string(ret), ret);
202 wifi_manager_deinitialize(wifi_handle);
204 if (service->mesh_activated) {
205 /* Already activated */
206 manager_complete_enable(object, invocation, WMESHD_ERROR_NONE);
210 /* Do API response first */
211 manager_complete_enable(object, invocation, ret);
212 service->mesh_activated = TRUE;
214 wmeshd_check_null_ret_error("info", info, FALSE);
216 /* Register event handler first */
217 ret = wmesh_request_register_event_handler(service);
218 if (WMESHD_ERROR_IN_PROGRESS == ret) {
219 WMESH_LOGE("Currently set netlink event handler !! [%d]", ret);
220 ret = WMESHD_ERROR_NONE;
221 } else if (WMESHD_ERROR_NONE != ret) {
222 WMESH_LOGE("Failed to register mesh event handler !! [%d]", ret);
225 ret = wmesh_interface_initialize(service->interface_info);
226 if (WMESHD_ERROR_NONE != ret) {
227 WMESH_LOGE("Failed to wmesh_interface_initialize [%d]", ret);
232 net_wmesh_emit_mesh_enabled(wmeshd_dbus_get_object(), ret);
237 static gboolean _wmeshd_dbus_handle_disable(Manager *object,
238 GDBusMethodInvocation *invocation,
241 int ret = WMESHD_ERROR_NONE;
242 wmesh_service *service = (wmesh_service *)user_data;
243 wmesh_interface_s *info = service->interface_info;
245 wmeshd_check_null_ret_error("info", info, FALSE);
247 /* Make response first */
248 manager_complete_disable(object, invocation, ret);
250 ret = wmesh_request_unregister_event_handler();
251 if (WMESHD_ERROR_NONE != ret)
252 WMESH_LOGE("Failed to unregister mesh event handler !! [%d]", ret);
254 /* Terminate daemon */
255 wmeshd_service_exit(service);
260 static gboolean _wmeshd_dbus_handle_scan(NetWmesh *object,
261 GDBusMethodInvocation *invocation,
264 int ret = WMESHD_ERROR_NONE;
265 wmesh_service *service = (wmesh_service *)user_data;
266 wmesh_interface_s *info = service->interface_info;
268 wmeshd_check_null_ret_error("info", info, FALSE);
270 ret = wmesh_request_scan(service);
271 if (WMESHD_ERROR_NONE != ret)
272 WMESH_LOGE("Failed to wmesh_request_scan !");
274 net_wmesh_complete_scan(object, invocation, ret);
279 static gboolean _wmeshd_dbus_handle_specific_scan(NetWmesh *object,
280 GDBusMethodInvocation *invocation,
285 int ret = WMESHD_ERROR_NONE;
286 wmesh_service *service = (wmesh_service *)user_data;
287 wmesh_interface_s *info = service->interface_info;
289 wmeshd_check_null_ret_error("info", info, FALSE);
291 ret = wmesh_request_specific_scan(service, mesh_id, channel);
292 if (WMESHD_ERROR_NONE != ret)
293 WMESH_LOGE("Failed to wmesh_request_specific_scan !");
295 net_wmesh_complete_specific_scan(object, invocation, ret);
300 static gboolean _wmeshd_dbus_handle_cancel_scan(NetWmesh *object,
301 GDBusMethodInvocation *invocation,
304 int ret = WMESHD_ERROR_NONE;
305 wmesh_service *service = (wmesh_service *)user_data;
307 ret = wmesh_request_cancel_scan(service);
308 if (WMESHD_ERROR_NONE != ret)
309 WMESH_LOGE("Failed to wmesh_request_cancel_scan");
311 net_wmesh_complete_cancel_scan(object, invocation, ret);
316 static void _on_scan_result_destroy(gpointer data)
318 wmesh_scan_result_s *scan_item = (wmesh_scan_result_s *)data;
321 g_free(scan_item->mesh_id);
322 g_free(scan_item->bssid);
323 g_free(scan_item->object_path);
328 static void _on_peer_info_destroy(gpointer data)
330 wmesh_peer_info_s *peer = (wmesh_peer_info_s *)data;
332 g_free(peer->address);
336 static void _on_station_list_destroy(gpointer data)
338 wmesh_station_info_s *info = (wmesh_station_info_s*)data;
346 static void _on_mpath_list_destroy(gpointer data)
348 wmesh_mpath_info_s *info = (wmesh_mpath_info_s*)data;
351 g_free(info->dest_addr);
352 g_free(info->next_hop);
353 g_free(info->interface);
358 static gboolean _wmeshd_dbus_handle_get_found_mesh_networks(NetWmesh *object,
359 GDBusMethodInvocation *invocation,
362 int ret = WMESHD_ERROR_NONE;
363 wmesh_service *service = (wmesh_service *)user_data;
365 GVariantBuilder builder;
368 wmesh_scan_result_s *scan_item = NULL;
370 WMESH_LOGD("Request to get scanned mesh network list");
372 ret = wmesh_request_get_networks(service);
373 if (WMESHD_ERROR_NONE != ret)
374 WMESH_LOGE("Failed to wmesh_request_get_networks");
376 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
378 /* scanned_mesh_network would be filled above request */
379 iter = service->scanned_mesh_network;
380 while (iter != NULL) {
381 scan_item = (wmesh_scan_result_s*)iter->data;
383 g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
384 g_variant_builder_add(&builder, "{sv}", "mesh_id",
385 g_variant_new_string(scan_item->mesh_id));
386 g_variant_builder_add(&builder, "{sv}", "bssid",
387 g_variant_new_string(scan_item->bssid));
388 g_variant_builder_add(&builder, "{sv}", "rssi",
389 g_variant_new_int32(scan_item->rssi));
390 g_variant_builder_add(&builder, "{sv}", "channel",
391 g_variant_new_uint32(scan_item->channel));
392 g_variant_builder_add(&builder, "{sv}", "data_rate",
393 g_variant_new_int32(scan_item->data_rate));
394 g_variant_builder_add(&builder, "{sv}", "security",
395 g_variant_new_uint32((int)scan_item->security));
396 g_variant_builder_add(&builder, "{sv}", "state",
397 g_variant_new_uint32(scan_item->state));
398 g_variant_builder_close(&builder);
400 iter = g_list_next(iter);
403 networks = g_variant_builder_end(&builder);
405 net_wmesh_complete_get_found_mesh_networks(object, invocation, networks, ret);
410 static gboolean _wmeshd_dbus_handle_enable_mesh(NetWmesh *object,
411 GDBusMethodInvocation *invocation,
414 int ret = WMESHD_ERROR_NONE;
415 wmesh_service *service = (wmesh_service *)user_data;
417 /* It handles creating virtual network and bridge */
418 ret = wmesh_request_enable_network(service);
419 if (WMESHD_ERROR_NONE != ret)
420 WMESH_LOGE("Failed to wmesh_request_enable_network [%d]", ret);
422 wmesh_start_monitor_service(service);
424 net_wmesh_complete_enable_mesh(object, invocation, ret);
429 static gboolean _wmeshd_dbus_handle_disable_mesh(NetWmesh *object,
430 GDBusMethodInvocation *invocation,
433 int ret = WMESHD_ERROR_NONE;
434 wmesh_service *service = (wmesh_service *)user_data;
435 wmesh_interface_s *info = service->interface_info;
437 wmeshd_check_null_ret_error("info", info, FALSE);
439 if (FALSE == service->mesh_activated) {
440 WMESH_LOGD("Mesh network is not activated yet");
441 ret = WMESHD_ERROR_OPERATION_FAILED;
442 net_wmesh_complete_disable_mesh(object, invocation, ret);
446 ret = wmesh_request_disable_network(service);
447 if (WMESHD_ERROR_NONE != ret)
448 WMESH_LOGE("Failed to disable mesh network !");
450 /* Stop Mesh Node Monitoring Service */
451 wmesh_stop_monitor_service(service);
453 net_wmesh_complete_disable_mesh(object, invocation, ret);
458 static gboolean _wmeshd_dbus_handle_is_mesh_enabled(NetWmesh *object,
459 GDBusMethodInvocation *invocation,
462 int ret = WMESHD_ERROR_NONE;
463 gboolean state = TRUE;
464 wmesh_service *service = (wmesh_service *)user_data;
466 /* It handles creating virtual network and bridge */
467 ret = wmesh_interface_check(service->interface_info->mesh_interface);
468 if (WMESHD_ERROR_NONE != ret) {
469 WMESH_LOGE("Mesh Interface doesn't exists");
473 net_wmesh_complete_is_mesh_enabled(object, invocation, state);
478 static gboolean _wmeshd_dbus_handle_is_joined(NetWmesh *object,
479 GDBusMethodInvocation *invocation,
482 int ret = WMESHD_ERROR_NONE;
483 gboolean state = FALSE;
484 wmesh_service *service = (wmesh_service *)user_data;
486 ret = wmesh_request_get_joined_network(service);
487 if (WMESHD_ERROR_NONE == ret) {
488 if (service->joined_network)
492 net_wmesh_complete_is_joined(object, invocation, state, ret);
497 static gboolean _wmeshd_dbus_handle_get_joined_mesh_network(NetWmesh *object,
498 GDBusMethodInvocation *invocation,
501 int ret = WMESHD_ERROR_NONE;
502 wmesh_service *service = (wmesh_service *)user_data;
503 wmesh_network_info_s *joined = NULL;
505 ret = wmesh_request_get_joined_network(service);
506 if (WMESHD_ERROR_NONE == ret) {
507 joined = service->joined_network;
509 net_wmesh_complete_get_joined_mesh_network(object, invocation,
510 joined->mesh_id, joined->bssid,
511 joined->channel, (int)joined->security,
512 joined->state, joined->ipv4_type, joined->ipv4_address,
513 joined->ipv4_netmask, ret);
515 net_wmesh_complete_get_joined_mesh_network(object, invocation,
516 "", "", 0, 0, 0, 0, "", "", WMESHD_ERROR_NO_DATA);
519 net_wmesh_complete_get_joined_mesh_network(object, invocation,
520 "", "", 0, 0, 0, 0, "", "", ret);
526 static gboolean _wmeshd_dbus_handle_get_connected_peers(NetWmesh *object,
527 GDBusMethodInvocation *invocation,
530 int ret = WMESHD_ERROR_NONE;
531 wmesh_service *service = (wmesh_service *)user_data;
533 GVariantBuilder builder;
536 wmesh_peer_info_s *peer = NULL;
538 WMESH_LOGD("Request to get connected peers");
540 ret = wmesh_request_get_connected_peers(service);
541 if (WMESHD_ERROR_NONE != ret)
542 WMESH_LOGE("Failed to wmesh_request_get_connected_peers");
543 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
545 iter = service->connected_mesh_peers;
546 while (iter != NULL) {
547 peer = (wmesh_peer_info_s*)iter->data;
549 g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
550 g_variant_builder_add(&builder, "{sv}", "Address",
551 g_variant_new_string(peer->address));
552 g_variant_builder_close(&builder);
554 iter = g_list_next(iter);
557 peer_list = g_variant_builder_end(&builder);
559 net_wmesh_complete_get_connected_peers(object, invocation, peer_list, ret);
564 static gboolean _wmeshd_dbus_handle_set_gate(NetWmesh *object,
565 GDBusMethodInvocation *invocation, gint16 gate_announce, guint hwmp_root_mode,
566 gboolean stp, gpointer user_data)
568 int ret = WMESHD_ERROR_NONE;
569 wmesh_service *service = (wmesh_service *)user_data;
570 wmesh_interface_s *info = service->interface_info;
572 WMESH_LOGD("gate_announce = %d", gate_announce);
573 WMESH_LOGD("HWMP_Root_Mode = %d", hwmp_root_mode);
574 WMESH_LOGD("STP = %d", stp);
576 info->gate_announce = gate_announce;
577 info->hwmp_root_mode = hwmp_root_mode;
580 /* Set STP and gate_announce for connmand */
581 ret = wmesh_gdbus_set_mesh_gate(service);
582 if (WMESHD_ERROR_NONE != ret)
583 WMESH_LOGE("Failed to wmesh_gdbus_set_mesh_gate [%d]", ret);
585 /* Set STP and gate_announce right now */
586 ret = wmesh_request_set_mesh_gate(info->bridge_interface,
587 info->mesh_interface, info->external_interface);
588 if (WMESHD_ERROR_NONE != ret)
589 WMESH_LOGE("Failed to wmesh_gdbus_set_mesh_gate [%d]", ret);
592 net_wmesh_complete_set_gate(object, invocation, ret);
597 static gboolean _wmeshd_dbus_handle_unset_gate(NetWmesh *object,
598 GDBusMethodInvocation *invocation,
601 int ret = WMESHD_ERROR_NONE;
602 wmesh_service *service = (wmesh_service *)user_data;
603 wmesh_interface_s *info = service->interface_info;
605 info->gate_announce = 0;
606 info->hwmp_root_mode = 0;
609 /* Set STP and gate_announce for connmand */
610 ret = wmesh_gdbus_set_mesh_gate(service);
611 if (WMESHD_ERROR_NONE != ret)
612 WMESH_LOGE("Failed to wmesh_gdbus_set_mesh_gate [%d]", ret);
614 /* Unset STP and Gate Annouce right now */
615 ret = wmesh_request_unset_mesh_gate(info->bridge_interface,
616 info->mesh_interface, info->external_interface);
617 if (WMESHD_ERROR_NONE != ret)
618 WMESH_LOGE("Failed to wmesh_request_unset_mesh_gate [%d]", ret);
620 net_wmesh_complete_unset_gate(object, invocation, ret);
625 static gboolean _wmeshd_dbus_handle_set_softap(NetWmesh *object,
626 GDBusMethodInvocation *invocation,
627 gchar *ssid, gchar *passphrase,
628 gchar *mode, gint channel, gint visibility, gint max_sta,
629 gint security, gpointer user_data)
631 int ret = WMESHD_ERROR_NONE;
632 wmesh_service *service = (wmesh_service *)user_data;
633 wmesh_interface_s *info = service->interface_info;
635 WMESH_LOGD("SSID : %s", ssid);
636 WMESH_LOGD("mode : %s", mode);
637 WMESH_LOGD("channel : %d", channel);
638 WMESH_LOGD("visibility: %d", visibility);
639 WMESH_LOGD("max_sta : %d", max_sta);
640 WMESH_LOGD("security : %d", security);
642 /* Save softAP information */
643 ret = wmesh_request_set_softap_config(info->softap_interface,
644 ssid, mode, channel, visibility, max_sta,
645 security, passphrase);
646 if (WMESHD_ERROR_NONE != ret)
647 WMESH_LOGE("Failed to wmesh_request_set_softap_config [%d]", ret);
649 net_wmesh_complete_set_softap(object, invocation, ret);
654 static gboolean _wmeshd_dbus_handle_get_softap(NetWmesh *object,
655 GDBusMethodInvocation *invocation, gpointer user_data)
657 int ret = WMESHD_ERROR_NONE;
658 wmesh_service *service = (wmesh_service *)user_data;
659 char *interface, *ssid, *mode, *passphrase;
660 int channel, visibility, max_sta, security;
661 (void) service; // unused
663 /* Get softAP information */
664 ret = wmesh_request_get_softap_config(&interface, &ssid, &mode, &channel,
665 &visibility, &max_sta, &security, &passphrase);
666 if (WMESHD_ERROR_NONE != ret) {
667 WMESH_LOGE("Failed to wmesh_request_get_softap_config [%d]", ret);
668 net_wmesh_complete_get_softap(object, invocation, "", "", 0, 0, 0, 0,
673 WMESH_LOGD("SSID : %s", ssid);
674 WMESH_LOGD("mode : %s", mode);
675 WMESH_LOGD("channel : %d", channel);
676 WMESH_LOGD("visibility: %d", visibility);
677 WMESH_LOGD("max_sta : %d", max_sta);
678 WMESH_LOGD("security : %d", security);
679 WMESH_LOGD("Passphrase : %s", passphrase ? passphrase : "NULL");
682 net_wmesh_complete_get_softap(object, invocation, ssid, mode, channel,
683 visibility, max_sta, security, passphrase, ret);
685 net_wmesh_complete_get_softap(object, invocation, ssid, mode, channel,
686 visibility, max_sta, security, "", ret);
691 static gboolean _wmeshd_dbus_handle_enable_softap(NetWmesh *object,
692 GDBusMethodInvocation *invocation, gpointer user_data)
694 int ret = WMESHD_ERROR_NONE;
695 wmesh_service *service = (wmesh_service *)user_data;
696 wmesh_interface_s *info = service->interface_info;
698 /* Check softAP interface and execute it */
699 ret = wmesh_request_enable_softap(info->bridge_interface, info->softap_interface);
700 if (WMESHD_ERROR_NONE != ret)
701 WMESH_LOGE("Failed to wmesh_request_enable_softap [%d]", ret);
703 net_wmesh_complete_enable_softap(object, invocation, ret);
708 static gboolean _wmeshd_dbus_handle_disable_softap(NetWmesh *object,
709 GDBusMethodInvocation *invocation, gpointer user_data)
711 int ret = WMESHD_ERROR_NONE;
712 wmesh_service *service = (wmesh_service *)user_data;
713 wmesh_interface_s *info = service->interface_info;
716 ret = wmesh_request_disable_softap(info->bridge_interface, info->softap_interface);
717 if (WMESHD_ERROR_NONE != ret)
718 WMESH_LOGE("Failed to wmesh_request_disable_softap [%d]", ret);
720 net_wmesh_complete_disable_softap(object, invocation, ret);
725 static gboolean _wmeshd_dbus_handle_is_softap_enabled(NetWmesh *object,
726 GDBusMethodInvocation *invocation, gpointer user_data)
731 /* Check SoftAP status */
732 status = wmesh_request_check_softap_status();
733 WMESH_LOGD("SoftAP is %s", status ? "enabled" : "disabled");
735 net_wmesh_complete_is_softap_enabled(object, invocation, status);
740 static gboolean _wmeshd_dbus_handle_create_mesh_network(NetWmesh *object,
741 GDBusMethodInvocation *invocation,
742 gchar *mesh_id, gint channel, gint security,
745 int ret = WMESHD_ERROR_NONE;
746 wmesh_service *service = (wmesh_service *)user_data;
747 wmeshd_security_type_e sec = (1 == security) ? WMESHD_SECURITY_SAE : WMESHD_SECURITY_NONE;
749 ret = wmesh_request_create_mesh_network(service, mesh_id, channel, sec);
751 net_wmesh_complete_create_mesh_network(object, invocation, ret);
756 static gboolean _wmeshd_dbus_handle_connect_mesh_network(NetWmesh *object,
757 GDBusMethodInvocation *invocation,
758 gchar *mesh_id, gint channel, gint security, gchar *passphrase,
761 int ret = WMESHD_ERROR_NONE;
762 wmesh_service *service = (wmesh_service *)user_data;
763 wmeshd_security_type_e sec = (1 == security) ? WMESHD_SECURITY_SAE : WMESHD_SECURITY_NONE;
765 ret = wmesh_request_connect_mesh_network(service, mesh_id, channel, sec, passphrase);
767 net_wmesh_complete_connect_mesh_network(object, invocation, ret);
771 static gboolean _wmeshd_dbus_handle_disconnect_mesh_network(NetWmesh *object,
772 GDBusMethodInvocation *invocation,
773 gchar *mesh_id, gint channel, gint security,
776 int ret = WMESHD_ERROR_NONE;
777 wmesh_service *service = (wmesh_service *)user_data;
778 wmeshd_security_type_e sec = (1 == security) ? WMESHD_SECURITY_SAE : WMESHD_SECURITY_NONE;
780 ret = wmesh_request_disconnect_mesh_network(service, mesh_id, channel, sec);
782 net_wmesh_complete_disconnect_mesh_network(object, invocation, ret);
787 static gboolean _wmeshd_dbus_handle_forget_mesh_network(NetWmesh *object,
788 GDBusMethodInvocation *invocation,
789 gchar *mesh_id, gint channel, gint security,
792 int ret = WMESHD_ERROR_NONE;
793 wmesh_service *service = (wmesh_service *)user_data;
794 wmeshd_security_type_e sec = (1 == security) ? WMESHD_SECURITY_SAE : WMESHD_SECURITY_NONE;
796 ret = wmesh_request_remove_mesh_network(service, mesh_id, channel, sec);
798 net_wmesh_complete_forget_mesh_network(object, invocation, ret);
803 static gboolean _wmeshd_dbus_handle_set_interfaces(NetWmesh *object,
804 GDBusMethodInvocation *invocation,
805 gchar *mesh, gchar *gate, gchar *softap,
808 int ret = WMESHD_ERROR_NONE;
809 wmesh_service *service = (wmesh_service *)user_data;
810 wmesh_interface_s *info = service->interface_info;
812 g_free(info->mesh_interface);
813 info->mesh_interface = g_strdup(mesh);
815 g_free(info->external_interface);
816 info->external_interface = g_strdup(gate);
818 g_free(info->softap_interface);
819 info->softap_interface = g_strdup(softap);
821 WMESH_LOGD("Interface configuration for mesh network :");
822 WMESH_LOGD(" Base : [%s]", info->base_interface);
823 WMESH_LOGD(" Mesh : [%s]", info->mesh_interface);
824 WMESH_LOGD(" Bridge : [%s]", info->bridge_interface);
825 WMESH_LOGD(" SoftAP : [%s]", info->softap_interface);
826 WMESH_LOGD(" External: [%s]", info->external_interface);
828 net_wmesh_complete_set_interfaces(object, invocation, ret);
833 static gboolean _wmeshd_dbus_handle_get_station_info(NetWmesh *object,
834 GDBusMethodInvocation *invocation, gint station_type,
837 int ret = WMESHD_ERROR_NONE;
839 GVariantBuilder builder;
843 wmesh_service *service = (wmesh_service *)user_data;
844 wmesh_interface_s *info = service->interface_info;
846 if (station_type == WMESHD_STATION_TYPE_MESH_POINT) {
847 /* Clear mesh station list */
848 g_list_free_full(service->station_list, _on_station_list_destroy);
849 service->station_list = NULL;
851 ret = wmesh_request_get_station_info(
852 info->mesh_interface, &service->station_list);
853 } else if (station_type == WMESHD_STATION_TYPE_SOFTAP) {
854 /* Clear softAP station list */
855 g_list_free_full(service->softap_station_list,
856 _on_station_list_destroy);
857 service->softap_station_list = NULL;
859 ret = wmesh_request_get_station_info(
860 info->softap_interface,
861 &service->softap_station_list);
863 WMESH_LOGE("Invalid station type");
865 g_dbus_method_invocation_return_error(invocation,
866 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid station type");
871 if (WMESHD_ERROR_NONE != ret) {
872 WMESH_LOGE("Failed to wmesh_request_get_station_info");
874 g_dbus_method_invocation_return_error(invocation,
875 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
878 * sh-3.2# iw mesh0 station dump
879 * Station 7c:dd:90:62:37:cf (on mesh0)
880 * inactive time: 1685 ms
889 * signal avg: -63 dBm
890 * tx bitrate: 54.0 MBit/s
891 * rx bitrate: 5.5 MBit/s
895 * mesh local PS mode: ACTIVE
896 * mesh peer PS mode: ACTIVE
897 * mesh non-peer PS mode: ACTIVE
906 * beacon interval:1000
907 * short slot time:yes
908 * connected time: 256 seconds
910 /* Get station information and make variant data */
911 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
913 if (station_type == WMESHD_STATION_TYPE_MESH_POINT)
914 iter = service->station_list;
916 iter = service->softap_station_list;
918 while (iter != NULL) {
919 wmesh_station_info_s *item = (wmesh_station_info_s*)iter->data;
921 g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
922 g_variant_builder_add(&builder, "{sv}", "bssid",
923 g_variant_new_string(item->bssid));
924 g_variant_builder_add(&builder, "{sv}", "inactive_time",
925 g_variant_new_uint32(item->inactive_time));
926 g_variant_builder_add(&builder, "{sv}", "rx_bytes",
927 g_variant_new_uint64(item->rx_bytes));
928 g_variant_builder_add(&builder, "{sv}", "rx_packets",
929 g_variant_new_uint32(item->rx_packets));
930 g_variant_builder_add(&builder, "{sv}", "tx_bytes",
931 g_variant_new_uint64(item->tx_bytes));
932 g_variant_builder_add(&builder, "{sv}", "tx_packets",
933 g_variant_new_uint32(item->tx_packets));
934 g_variant_builder_add(&builder, "{sv}", "tx_retries",
935 g_variant_new_uint32(item->tx_retries));
936 g_variant_builder_add(&builder, "{sv}", "tx_failed",
937 g_variant_new_uint32(item->tx_failed));
938 g_variant_builder_add(&builder, "{sv}", "beacon_loss",
939 g_variant_new_uint32(item->beacon_loss));
940 g_variant_builder_add(&builder, "{sv}", "beacon_rx",
941 g_variant_new_uint64(item->beacon_rx));
942 g_variant_builder_add(&builder, "{sv}", "rx_drop_misc",
943 g_variant_new_uint64(item->rx_drop_misc));
944 g_variant_builder_add(&builder, "{sv}", "signal",
945 g_variant_new_int32(item->rssi));
946 g_variant_builder_add(&builder, "{sv}", "signal_avg",
947 g_variant_new_int32(item->rssi_avg));
948 g_variant_builder_add(&builder, "{sv}", "tx_bitrate",
949 g_variant_new_uint32(item->tx_bitrate)); /* 10 times */
950 g_variant_builder_add(&builder, "{sv}", "rx_bitrate",
951 g_variant_new_uint32(item->rx_bitrate)); /* 10 times */
952 if (station_type == WMESHD_STATION_TYPE_MESH_POINT) {
953 g_variant_builder_add(&builder, "{sv}", "mesh_llid",
954 g_variant_new_uint16(item->llid));
955 g_variant_builder_add(&builder, "{sv}", "mesh_plid",
956 g_variant_new_uint16(item->plid));
957 g_variant_builder_add(&builder, "{sv}", "mesh_plink",
958 g_variant_new_byte(item->mesh_plink)); /* 0 : DISCON, 1 : ESTAB */
959 g_variant_builder_add(&builder, "{sv}", "local_ps_mode",
960 g_variant_new_uint32(item->local_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
961 g_variant_builder_add(&builder, "{sv}", "peer_ps_mode",
962 g_variant_new_uint32(item->peer_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
963 g_variant_builder_add(&builder, "{sv}", "non_peer_ps_mode",
964 g_variant_new_uint32(item->non_peer_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
966 g_variant_builder_add(&builder, "{sv}", "authorized",
967 g_variant_new_boolean(item->authorized));
968 g_variant_builder_add(&builder, "{sv}", "authenticated",
969 g_variant_new_boolean(item->authenticated));
970 g_variant_builder_add(&builder, "{sv}", "associated",
971 g_variant_new_boolean(item->associated));
972 g_variant_builder_add(&builder, "{sv}", "preamble",
973 g_variant_new_boolean(item->preamble));
974 g_variant_builder_add(&builder, "{sv}", "WMM_WME",
975 g_variant_new_boolean(item->wme));
976 g_variant_builder_add(&builder, "{sv}", "MFP",
977 g_variant_new_boolean(item->mfp));
978 g_variant_builder_add(&builder, "{sv}", "TDLS_peer",
979 g_variant_new_boolean(item->tdls_peer));
980 g_variant_builder_add(&builder, "{sv}", "DTIM_period",
981 g_variant_new_byte(item->dtim_period));
982 g_variant_builder_add(&builder, "{sv}", "beacon_interval",
983 g_variant_new_uint16(item->beacon_interval));
984 g_variant_builder_add(&builder, "{sv}", "short_slot_time",
985 g_variant_new_boolean(item->short_slot_time));
986 g_variant_builder_add(&builder, "{sv}", "connected_time",
987 g_variant_new_uint32(item->connected_time));
988 g_variant_builder_close(&builder);
990 iter = g_list_next(iter);
993 station = g_variant_builder_end(&builder);
994 net_wmesh_complete_get_station_info(object, invocation, station, ret);
996 g_object_unref(station);
1002 static gboolean _wmeshd_dbus_handle_get_mpath_info(NetWmesh *object,
1003 GDBusMethodInvocation *invocation,
1006 int ret = WMESHD_ERROR_NONE;
1007 GVariantBuilder builder;
1008 GVariant* mpath_data;
1011 wmesh_service *service = (wmesh_service *)user_data;
1012 wmesh_interface_s *info = service->interface_info;
1014 /* Clear mesh path list */
1015 g_list_free_full(service->mpath_list, _on_mpath_list_destroy);
1016 service->mpath_list = NULL;
1018 ret = wmesh_request_get_mpath_info(
1019 info->mesh_interface, &service->mpath_list);
1020 if (WMESHD_ERROR_NONE != ret) {
1021 WMESH_LOGE("Failed to wmesh_request_get_mpath_info");
1023 g_dbus_method_invocation_return_error(invocation,
1024 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
1027 * Example) sh-3.2# iw mesh0 mpath dump
1028 * DEST ADDR NEXT HOP IFACE SN METRIC QLEN EXPTIME DTIM DRET FLAGS
1029 * 7c:dd:90:62:37:cf 7c:dd:90:62:37:cf mesh0 221 152 0 10 100 0 0x5
1031 /* Get mesh path information and make variant data */
1032 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
1034 iter = service->mpath_list;
1035 while (iter != NULL) {
1036 wmesh_mpath_info_s *item = (wmesh_mpath_info_s*)iter->data;
1038 g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
1039 g_variant_builder_add(&builder, "{sv}", "DEST_ADDR",
1040 g_variant_new_string(item->dest_addr));
1041 g_variant_builder_add(&builder, "{sv}", "NEXT_HOP",
1042 g_variant_new_string(item->next_hop));
1043 g_variant_builder_add(&builder, "{sv}", "IFACE",
1044 g_variant_new_string(item->interface));
1045 g_variant_builder_add(&builder, "{sv}", "SN",
1046 g_variant_new_uint32(item->sn));
1047 g_variant_builder_add(&builder, "{sv}", "METRIC",
1048 g_variant_new_uint32(item->metric));
1049 g_variant_builder_add(&builder, "{sv}", "QLEN",
1050 g_variant_new_uint32(item->qlen));
1051 g_variant_builder_add(&builder, "{sv}", "EXPTIME",
1052 g_variant_new_uint32(item->exptime));
1053 g_variant_builder_add(&builder, "{sv}", "DTIM",
1054 g_variant_new_uint32(item->discovery_timeout));
1055 g_variant_builder_add(&builder, "{sv}", "DRET",
1056 g_variant_new_byte(item->discovery_retries));
1057 g_variant_builder_add(&builder, "{sv}", "FLAGS",
1058 g_variant_new_byte(item->flags));
1059 g_variant_builder_close(&builder);
1061 iter = g_list_next(iter);
1064 mpath_data = g_variant_builder_end(&builder);
1065 net_wmesh_complete_get_mpath_info(object, invocation, mpath_data, ret);
1067 g_object_unref(mpath_data);
1073 static gboolean _wmeshd_dbus_handle_get_meshconf_info(NetWmesh *object,
1074 GDBusMethodInvocation *invocation,
1077 int ret = WMESHD_ERROR_NONE;
1078 GVariantBuilder builder;
1079 GVariant* meshconf_data;
1080 wmesh_meshconf_info_s *item;
1082 wmesh_service *service = (wmesh_service *)user_data;
1084 ret = wmesh_request_get_meshconf_info(service);
1085 if (WMESHD_ERROR_NONE != ret) {
1086 WMESH_LOGE("Failed to wmesh_request_get_mpath_info");
1088 g_dbus_method_invocation_return_error(invocation,
1089 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
1091 /* Get mesh path information and make variant data */
1092 g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));
1094 item = service->meshconf;
1096 g_variant_builder_add(&builder, "{sv}", "RETRY_TIMEOUT",
1097 g_variant_new_uint16(item->retry_timeout));
1098 g_variant_builder_add(&builder, "{sv}", "HWMP_MAX_PREQ_RETRIES",
1099 g_variant_new_byte(item->hwmp_max_preq_retries));
1100 g_variant_builder_add(&builder, "{sv}", "CONFIRM_TIMEOUT",
1101 g_variant_new_uint16(item->confirm_timeout));
1102 g_variant_builder_add(&builder, "{sv}", "PATH_REFRESH_TIME",
1103 g_variant_new_uint32(item->path_refresh_time));
1104 g_variant_builder_add(&builder, "{sv}", "HOLDING_TIMEOUT",
1105 g_variant_new_uint16(item->holding_timeout));
1106 g_variant_builder_add(&builder, "{sv}", "MIN_DISC_TIMEOUT",
1107 g_variant_new_uint16(item->min_disc_timeout));
1108 g_variant_builder_add(&builder, "{sv}", "MAX_PEER_LINKS",
1109 g_variant_new_uint16(item->max_peer_links));
1110 g_variant_builder_add(&builder, "{sv}", "HWMP_PREQ_MIN_INTERVAL",
1111 g_variant_new_uint16(item->hwmp_preq_min_interval));
1112 g_variant_builder_add(&builder, "{sv}", "TTL",
1113 g_variant_new_byte(item->ttl));
1114 g_variant_builder_add(&builder, "{sv}", "HWMP_ACTIVE_PATH_TIMEOUT",
1115 g_variant_new_uint32(item->hwmp_active_path_timeout));
1116 g_variant_builder_add(&builder, "{sv}", "ELEMENT_TTL",
1117 g_variant_new_byte(item->element_ttl));
1118 g_variant_builder_add(&builder, "{sv}", "HWMP_RANN_INTERVAL",
1119 g_variant_new_uint16(item->hwmp_rann_interval));
1120 g_variant_builder_add(&builder, "{sv}", "GATE_ANNOUNCEMENTS",
1121 g_variant_new_byte(item->gate_announcements));
1124 meshconf_data = g_variant_builder_end(&builder);
1125 net_wmesh_complete_get_meshconf_info(object, invocation, meshconf_data,
1128 g_object_unref(meshconf_data);
1131 g_free(service->meshconf);
1136 static void _wmeshd_dbus_on_activator_bus_acquired(GDBusConnection *conn,
1137 const gchar *name, gpointer user_data)
1140 GError *error = NULL;
1141 wmesh_service *service = (wmesh_service *)user_data;
1145 meshd_activator_dbus_object = manager_skeleton_new();
1146 if (NULL == meshd_activator_dbus_object) {
1147 WMESH_LOGE("manager_skeleton_new() Fail");
1151 g_signal_connect(meshd_activator_dbus_object, "handle-enable",
1152 G_CALLBACK(_wmeshd_dbus_handle_enable), service);
1153 g_signal_connect(meshd_activator_dbus_object, "handle-disable",
1154 G_CALLBACK(_wmeshd_dbus_handle_disable), service);
1156 ret = g_dbus_interface_skeleton_export(
1157 G_DBUS_INTERFACE_SKELETON(meshd_activator_dbus_object),
1158 conn, WMESH_DBUS_MANAGER_OBJPATH, &error);
1160 WMESH_LOGE("g_dbus_interface_skeleton_export() Fail(%s)", error->message);
1161 g_error_free(error);
1165 static void _wmeshd_dbus_on_bus_acquired(GDBusConnection *conn, const gchar *name,
1169 GError *error = NULL;
1170 wmesh_service *service = (wmesh_service *)user_data;
1174 meshd_dbus_object = net_wmesh_skeleton_new();
1175 if (NULL == meshd_dbus_object) {
1176 WMESH_LOGE("net_wmesh_skeleton_new() Fail");
1180 g_signal_connect(meshd_dbus_object, "handle-scan",
1181 G_CALLBACK(_wmeshd_dbus_handle_scan), service);
1182 g_signal_connect(meshd_dbus_object, "handle-specific-scan",
1183 G_CALLBACK(_wmeshd_dbus_handle_specific_scan), service);
1184 g_signal_connect(meshd_dbus_object, "handle-cancel-scan",
1185 G_CALLBACK(_wmeshd_dbus_handle_cancel_scan), service);
1186 g_signal_connect(meshd_dbus_object, "handle-get-found-mesh-networks",
1187 G_CALLBACK(_wmeshd_dbus_handle_get_found_mesh_networks), service);
1188 g_signal_connect(meshd_dbus_object, "handle-enable-mesh",
1189 G_CALLBACK(_wmeshd_dbus_handle_enable_mesh), service);
1190 g_signal_connect(meshd_dbus_object, "handle-disable-mesh",
1191 G_CALLBACK(_wmeshd_dbus_handle_disable_mesh), service);
1192 g_signal_connect(meshd_dbus_object, "handle-is-mesh-enabled",
1193 G_CALLBACK(_wmeshd_dbus_handle_is_mesh_enabled), service);
1194 g_signal_connect(meshd_dbus_object, "handle-is-joined",
1195 G_CALLBACK(_wmeshd_dbus_handle_is_joined), service);
1196 g_signal_connect(meshd_dbus_object, "handle-get-joined-mesh-network",
1197 G_CALLBACK(_wmeshd_dbus_handle_get_joined_mesh_network), service);
1198 g_signal_connect(meshd_dbus_object, "handle-get-connected-peers",
1199 G_CALLBACK(_wmeshd_dbus_handle_get_connected_peers), service);
1200 g_signal_connect(meshd_dbus_object, "handle-set-gate",
1201 G_CALLBACK(_wmeshd_dbus_handle_set_gate), service);
1202 g_signal_connect(meshd_dbus_object, "handle-unset-gate",
1203 G_CALLBACK(_wmeshd_dbus_handle_unset_gate), service);
1204 g_signal_connect(meshd_dbus_object, "handle-set-softap",
1205 G_CALLBACK(_wmeshd_dbus_handle_set_softap), service);
1206 g_signal_connect(meshd_dbus_object, "handle-get-softap",
1207 G_CALLBACK(_wmeshd_dbus_handle_get_softap), service);
1208 g_signal_connect(meshd_dbus_object, "handle-enable-softap",
1209 G_CALLBACK(_wmeshd_dbus_handle_enable_softap), service);
1210 g_signal_connect(meshd_dbus_object, "handle-disable-softap",
1211 G_CALLBACK(_wmeshd_dbus_handle_disable_softap), service);
1212 g_signal_connect(meshd_dbus_object, "handle-is-softap-enabled",
1213 G_CALLBACK(_wmeshd_dbus_handle_is_softap_enabled), NULL);
1214 g_signal_connect(meshd_dbus_object, "handle-create-mesh-network",
1215 G_CALLBACK(_wmeshd_dbus_handle_create_mesh_network), service);
1216 g_signal_connect(meshd_dbus_object, "handle-connect-mesh-network",
1217 G_CALLBACK(_wmeshd_dbus_handle_connect_mesh_network), service);
1218 g_signal_connect(meshd_dbus_object, "handle-disconnect-mesh-network",
1219 G_CALLBACK(_wmeshd_dbus_handle_disconnect_mesh_network), service);
1220 g_signal_connect(meshd_dbus_object, "handle-forget-mesh-network",
1221 G_CALLBACK(_wmeshd_dbus_handle_forget_mesh_network), service);
1222 g_signal_connect(meshd_dbus_object, "handle-set-interfaces",
1223 G_CALLBACK(_wmeshd_dbus_handle_set_interfaces), service);
1224 g_signal_connect(meshd_dbus_object, "handle-get-station-info",
1225 G_CALLBACK(_wmeshd_dbus_handle_get_station_info), service);
1226 g_signal_connect(meshd_dbus_object, "handle-get-mpath-info",
1227 G_CALLBACK(_wmeshd_dbus_handle_get_mpath_info), service);
1228 g_signal_connect(meshd_dbus_object, "handle-get-meshconf-info",
1229 G_CALLBACK(_wmeshd_dbus_handle_get_meshconf_info), service);
1231 ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(meshd_dbus_object),
1232 conn, WMESH_DBUS_OBJPATH, &error);
1234 WMESH_LOGE("g_dbus_interface_skeleton_export() Fail(%s)", error->message);
1235 g_error_free(error);
1238 ret = _wmeshd_dbus_subscribe_name_owner_changed(conn);
1239 if (WMESHD_ERROR_NONE != ret) {
1240 WMESH_LOGE("_wmeshd_dbus_subscribe_name_owner_changed() Fail(%d)", ret);
1245 static void _wmeshd_dbus_on_name_lost(GDBusConnection *conn, const gchar *name,
1251 WMESH_LOGD("Lost the name %s", name);
1254 static void _wmeshd_dbus_on_name_acquired(GDBusConnection *conn, const gchar *name,
1260 WMESH_LOGD("Acquired the name %s", name);
1263 static gboolean _wmeshd_dbus_interface_init(wmesh_service *service)
1266 guint activation_dbus_id;
1267 wmeshd_check_null_ret_error("service", service, FALSE);
1269 id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
1270 WMESH_DBUS_INTERFACE,
1271 G_BUS_NAME_OWNER_FLAGS_REPLACE,
1272 _wmeshd_dbus_on_bus_acquired,
1273 _wmeshd_dbus_on_name_acquired,
1274 _wmeshd_dbus_on_name_lost,
1278 WMESH_LOGE("g_bus_own_name() Fail");
1282 /* Get D-Bus owner to activate mesh service daemon */
1283 activation_dbus_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
1284 WMESH_DBUS_INTERFACE".manager",
1285 G_BUS_NAME_OWNER_FLAGS_REPLACE,
1286 _wmeshd_dbus_on_activator_bus_acquired,
1292 service->dbus_id = id;
1293 service->activation_dbus_id = activation_dbus_id;
1294 service->interface_info = g_new0(wmesh_interface_s, 1);
1295 service->scanned_mesh_network = NULL;
1297 /* Initialize DBus sendor logic */
1298 wmeshd_dbus_start(service);
1303 static void _wmeshd_dbus_deinit(wmesh_service *service)
1305 wmesh_interface_s *info = NULL;
1306 wmeshd_check_null_ret("service", service);
1308 /* De-Initialize DBus sendor logic */
1309 wmeshd_dbus_stop(service);
1311 g_bus_unown_name(service->dbus_id);
1312 g_bus_unown_name(service->activation_dbus_id);
1314 info = service->interface_info;
1315 wmeshd_check_null_ret("info", info);
1316 if (info->bridge_interface)
1317 g_free(info->bridge_interface);
1318 if (info->base_interface)
1319 g_free(info->base_interface);
1320 if (info->mesh_interface)
1321 g_free(info->mesh_interface);
1322 if (info->softap_interface)
1323 g_free(info->softap_interface);
1324 if (info->external_interface)
1325 g_free(info->external_interface);
1327 if (service->joined_network) {
1328 g_free(service->joined_network->mesh_id);
1329 g_free(service->joined_network->bssid);
1330 g_free(service->joined_network);
1331 service->joined_network = NULL;
1334 /* Clear scan list */
1335 if (service->scanned_mesh_network)
1336 g_list_free_full(service->scanned_mesh_network, _on_scan_result_destroy);
1337 service->scanned_mesh_network = NULL;
1339 /* Clear connected peers list */
1340 if (service->connected_mesh_peers)
1341 g_list_free_full(service->connected_mesh_peers, _on_peer_info_destroy);
1342 service->connected_mesh_peers = NULL;
1344 /* Clear mesh path list */
1345 if (service->mpath_list)
1346 g_list_free_full(service->mpath_list, _on_mpath_list_destroy);
1347 service->mpath_list = NULL;
1349 /* Clear mesh station list */
1350 if (service->station_list)
1351 g_list_free_full(service->station_list, _on_station_list_destroy);
1352 service->station_list = NULL;
1354 /* Clear mesh station list */
1355 if (service->softap_station_list)
1356 g_list_free_full(service->softap_station_list,
1357 _on_station_list_destroy);
1358 service->softap_station_list = NULL;
1360 g_free(service->interface_info);
1361 service->interface_info = NULL;
1364 /**< Mesh service interface initialization */
1365 gboolean wmeshd_service_interface_init(wmesh_service *service)
1368 wmeshd_check_null_ret_error("service", service, FALSE);
1370 /* Initialize dbus interface */
1371 ret = _wmeshd_dbus_interface_init(service);
1373 WMESH_LOGE("_wmeshd_dbus_interface_init failed!!!");
1380 /**< Mesh service interface de-initialization */
1381 void wmeshd_service_interface_deinit(wmesh_service *service)
1383 wmeshd_check_null_ret("service", service);
1385 /* De-initialize dbus interface */
1386 _wmeshd_dbus_deinit(service);