Change mesh id setting logic
[platform/core/connectivity/wifi-mesh-manager.git] / src / mesh-service-interface.c
1 /*
2  * Network Configuration Module
3  *
4  * Copyright (c) 2017 Samsung Electronics Co., Ltd. All rights reserved.
5  *
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
9  *
10  * http://www.apache.org/licenses/LICENSE-2.0
11  *
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.
17  *
18  */
19 #include <stdlib.h>
20 #include <string.h>
21
22 #include <glib.h>
23 #include <gio/gio.h>
24
25 #include "mesh.h"
26 #include "mesh-log.h"
27 #include "mesh-util.h"
28 #include "mesh-service.h"
29 #include "mesh-service-interface.h"
30 #include "mesh-generated-code.h"
31
32 #include "mesh-request.h"
33 #include "mesh-interface.h"
34
35 static NetMesh *meshd_dbus_object;
36 static Manager *meshd_activator_dbus_object;
37
38 /* global list to care resource handle for each client */
39 static GList *meshd_dbus_client_list;
40 static GMutex meshd_dbus_client_list_mutex;
41
42 typedef struct _meshd_dbus_client_s {
43         gchar *bus_name;
44 } meshd_dbus_client_s;
45
46 NetMesh* meshd_dbus_get_object()
47 {
48         return meshd_dbus_object;
49 }
50
51 int64_t meshd_dbus_generate_signal_number()
52 {
53         static int64_t i = 0;
54
55         return i++;
56 }
57
58 static int _meshd_dbus_client_list_cleanup(GList *client_list)
59 {
60         meshd_dbus_client_s *client;
61
62         meshd_check_null_ret_error("client_list", client_list, FALSE);
63
64         client = client_list->data;
65
66         free(client->bus_name);
67         client->bus_name = NULL;
68         free(client);
69         g_list_free(client_list);
70
71         return MESHD_ERROR_NONE;
72 }
73
74 static int _meshd_dbus_client_list_compare_bus_name(const void *a, const void *b)
75 {
76         const meshd_dbus_client_s *client = a;
77
78         return g_strcmp0(client->bus_name, b);
79 }
80
81 static inline GList* _meshd_dbus_client_list_find_client(const gchar *owner)
82 {
83         return g_list_find_custom(meshd_dbus_client_list, owner,
84                         _meshd_dbus_client_list_compare_bus_name);
85 }
86
87 static void _meshd_dbus_name_owner_changed_cb(GDBusConnection *conn,
88                 const gchar *sender_name,
89                 const gchar *object_path,
90                 const gchar *interface_name,
91                 const gchar *signal_name,
92                 GVariant *parameters,
93                 gpointer user_data)
94 {
95         int ret;
96         GList *client = NULL;
97         gchar *name, *old_owner, *new_owner;
98
99         NOTUSED(conn);
100         NOTUSED(sender_name);
101         NOTUSED(object_path);
102         NOTUSED(interface_name);
103         NOTUSED(signal_name);
104         NOTUSED(user_data);
105
106         g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
107
108         if (0 == strlen(new_owner)) {
109                 g_mutex_lock(&meshd_dbus_client_list_mutex);
110                 client = _meshd_dbus_client_list_find_client(old_owner);
111                 if (client) { /* found bus name in our bus list */
112                         MESH_LOGD("bus(%s) stopped", old_owner);
113                         meshd_dbus_client_list = g_list_remove_link(meshd_dbus_client_list, client);
114                 }
115                 g_mutex_unlock(&meshd_dbus_client_list_mutex);
116
117                 if (client) {
118                         ret = _meshd_dbus_client_list_cleanup(client);
119                         if (MESHD_ERROR_NONE != ret)
120                                 MESH_LOGE("_meshd_dbus_client_list_cleanup() Fail(%d)", ret);
121                 }
122         }
123 }
124
125 static int _meshd_dbus_subscribe_name_owner_changed(GDBusConnection *conn)
126 {
127         unsigned int id;
128
129         id = g_dbus_connection_signal_subscribe(conn,
130                         "org.freedesktop.DBus", /* bus name */
131                         "org.freedesktop.DBus", /* interface */
132                         "NameOwnerChanged", /* member */
133                         "/org/freedesktop/DBus", /* path */
134                         NULL, /* arg0 */
135                         G_DBUS_SIGNAL_FLAGS_NONE,
136                         _meshd_dbus_name_owner_changed_cb,
137                         NULL,
138                         NULL);
139         if (0 == id) {
140                 MESH_LOGE("g_dbus_connection_signal_subscribe() Fail");
141                 return MESHD_ERROR_IO_ERROR;
142         }
143
144         return MESHD_ERROR_NONE;
145 }
146
147 static gboolean _meshd_dbus_handle_enable(Manager *object,
148                 GDBusMethodInvocation *invocation,
149                 gpointer user_data)
150 {
151         int ret = MESHD_ERROR_NONE;
152         mesh_service *service = (mesh_service *)user_data;
153         mesh_interface_s *info = service->interface_info;
154
155         if (service->mesh_activated) {
156                 /* Already activated */
157                 manager_complete_enable(object, invocation,
158                                 MESHD_ERROR_OPERATION_FAILED);
159         } else {
160                 /* Do API response first */
161                 manager_complete_enable(object, invocation, ret);
162                 service->mesh_activated = TRUE;
163         }
164
165         meshd_check_null_ret_error("info", info, FALSE);
166
167         /* Register event handler first */
168         ret = mesh_request_register_event_handler();
169         if (MESHD_ERROR_NONE != ret) {
170                 MESH_LOGE("Failed to register mesh event handler !! [%d]", ret);
171         }
172
173         ret = mesh_interface_initialize(service->interface_info);
174         if (MESHD_ERROR_NONE != ret) {
175                 MESH_LOGE("Failed to mesh_interface_initialize [%d]", ret);
176                 goto FINISH;
177         }
178
179 FINISH:
180         net_mesh_emit_mesh_enabled(meshd_dbus_get_object(), ret);
181
182         return TRUE;
183 }
184
185 static gboolean _meshd_dbus_handle_disable(Manager *object,
186                 GDBusMethodInvocation *invocation,
187                 gpointer user_data)
188 {
189         int ret = MESHD_ERROR_NONE;
190         mesh_service *service = (mesh_service *)user_data;
191         mesh_interface_s *info = service->interface_info;
192
193         meshd_check_null_ret_error("info", info, FALSE);
194
195         /* Make response first */
196         manager_complete_disable(object, invocation, ret);
197
198         ret = mesh_request_unregister_event_handler();
199         if (MESHD_ERROR_NONE != ret) {
200                 MESH_LOGE("Failed to unregister mesh event handler !! [%d]", ret);
201         }
202
203         /* Terminate daemon */
204         meshd_service_exit(service);
205
206         return TRUE;
207 }
208
209 static gboolean _meshd_dbus_handle_scan(NetMesh *object,
210                 GDBusMethodInvocation *invocation,
211                 gpointer user_data)
212 {
213         int ret = MESHD_ERROR_NONE;
214         mesh_service *service = (mesh_service *)user_data;
215         mesh_interface_s *info = service->interface_info;
216
217         meshd_check_null_ret_error("info", info, FALSE);
218
219         ret = mesh_request_scan(info->mesh_interface);
220         if (MESHD_ERROR_NONE != ret) {
221                 MESH_LOGE("Failed to mesh_request_scan on mesh interface[%s] !",
222                                 info->mesh_interface);
223         }
224
225         /* Fall-back */
226         if (MESHD_ERROR_IN_PROGRESS != ret) {
227                 ret = mesh_request_scan(info->base_interface);
228                 if (MESHD_ERROR_NONE != ret)
229                         MESH_LOGE("Failed to mesh_request_scan on base interface[%s] !",
230                                         info->base_interface);
231         }
232
233         net_mesh_complete_scan(object, invocation, ret);
234
235         return TRUE;
236 }
237
238 static gboolean _meshd_dbus_handle_specific_scan(NetMesh *object,
239                 GDBusMethodInvocation *invocation,
240                 gchar *mesh_id,
241                 gint channel,
242                 gpointer user_data)
243 {
244         int ret = MESHD_ERROR_NONE;
245         mesh_service *service = (mesh_service *)user_data;
246         mesh_interface_s *info = service->interface_info;
247
248         meshd_check_null_ret_error("info", info, FALSE);
249
250         ret = mesh_request_specific_scan(info->mesh_interface, mesh_id, channel);
251         if (MESHD_ERROR_NONE != ret) {
252                 MESH_LOGE("Failed to mesh_request_specific_scan on mesh interface[%s]",
253                                 info->mesh_interface);
254         }
255
256         /* Fall-back */
257         if (MESHD_ERROR_IN_PROGRESS != ret) {
258                 ret = mesh_request_specific_scan(info->base_interface, mesh_id, channel);
259                 if (MESHD_ERROR_NONE != ret)
260                         MESH_LOGE("Failed to mesh_request_specific_scan on base interface[%s]",
261                                         info->base_interface);
262         }
263
264         net_mesh_complete_specific_scan(object, invocation, ret);
265
266         return TRUE;
267 }
268
269 static gboolean _meshd_dbus_handle_cancel_scan(NetMesh *object,
270                 GDBusMethodInvocation *invocation,
271                 gpointer user_data)
272 {
273         int ret = MESHD_ERROR_NONE;
274         mesh_service *service = (mesh_service *)user_data;
275         mesh_interface_s *info = service->interface_info;
276
277         ret = mesh_request_cancel_scan(info->mesh_interface);
278         if (MESHD_ERROR_NONE != ret) {
279                 MESH_LOGE("Failed to mesh_request_cancel_scan");
280         }
281
282         net_mesh_complete_cancel_scan(object, invocation, ret);
283
284         return TRUE;
285 }
286
287 static void _on_scan_result_destroy(gpointer data)
288 {
289         mesh_scan_result_s *scan_item = (mesh_scan_result_s *)data;
290
291         if (scan_item) {
292                 g_free(scan_item->mesh_id);
293                 g_free(scan_item->bssid);
294         }
295 }
296
297 static void _on_station_list_destroy(gpointer data)
298 {
299         mesh_station_info_s *info = (mesh_station_info_s*)data;
300
301         if (info) {
302                 g_free(info->bssid);
303                 g_free(info);
304         }
305 }
306
307 static void _on_mpath_list_destroy(gpointer data)
308 {
309         mesh_mpath_info_s *info = (mesh_mpath_info_s*)data;
310
311         if (info) {
312                 g_free(info->dest_addr);
313                 g_free(info->next_hop);
314                 g_free(info->interface);
315                 g_free(info);
316         }
317 }
318
319 static gboolean _meshd_dbus_handle_get_found_mesh_networks(NetMesh *object,
320                 GDBusMethodInvocation *invocation,
321                 gpointer user_data)
322 {
323         int ret = MESHD_ERROR_NONE;
324         mesh_service *service = (mesh_service *)user_data;
325         mesh_interface_s *info = service->interface_info;
326
327         GVariantBuilder builder;
328         GVariant* networks;
329         GList *iter = NULL;
330         mesh_scan_result_s *scan_item = NULL;
331
332         MESH_LOGD("Request to get scanned mesh network list");
333
334         ret = mesh_request_get_scan_result(info->mesh_interface, &service->scanned_mesh_network);
335         if (MESHD_ERROR_NONE != ret) {
336                 MESH_LOGE("Failed to mesh_request_get_scan_result");
337
338                 /* Fall-back */
339                 ret = mesh_request_get_scan_result(info->base_interface,
340                                 &service->scanned_mesh_network);
341                 if (MESHD_ERROR_NONE != ret) {
342                         MESH_LOGE("Failed to mesh_request_get_scan_result on base interface[%s]",
343                                         info->base_interface);
344
345                         g_dbus_method_invocation_return_error(invocation,
346                                         G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
347                 }
348         }
349
350         g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
351
352         iter = service->scanned_mesh_network;
353         while (iter != NULL) {
354                 scan_item = (mesh_scan_result_s*)iter->data;
355
356                 g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
357                 g_variant_builder_add(&builder, "{sv}", "mesh_id",
358                                 g_variant_new_string(scan_item->mesh_id));
359                 g_variant_builder_add(&builder, "{sv}", "bssid",
360                                 g_variant_new_string(scan_item->bssid));
361                 g_variant_builder_add(&builder, "{sv}", "rssi",
362                                 g_variant_new_int32(scan_item->rssi));
363                 g_variant_builder_add(&builder, "{sv}", "channel",
364                                 g_variant_new_uint32(scan_item->channel));
365                 g_variant_builder_close(&builder);
366
367                 iter = g_list_next(iter);
368         }
369
370         /* Clear scan list */
371         g_list_free_full(service->scanned_mesh_network, _on_scan_result_destroy);
372         service->scanned_mesh_network = NULL;
373
374         networks = g_variant_builder_end(&builder);
375         net_mesh_complete_get_found_mesh_networks(object, invocation, networks, ret);
376
377         return TRUE;
378 }
379
380 static gboolean _meshd_dbus_handle_enable_mesh(NetMesh *object,
381                 GDBusMethodInvocation *invocation,
382                 gpointer user_data)
383 {
384         int ret = MESHD_ERROR_NONE;
385         mesh_service *service = (mesh_service *)user_data;
386         mesh_interface_s *info = service->interface_info;
387
388         /* Create or join mesh network and create bridge */
389         ret = mesh_request_enable_mesh(info->base_interface, info->mesh_interface,
390                                 service->saved_mesh_network, &service->joined_network);
391         if (MESHD_ERROR_NONE != ret) {
392                 MESH_LOGE("Failed to mesh_request_enable_mesh [%d]", ret);
393                 goto FINISH;
394         }
395
396         ret = mesh_request_create_bridge(info->bridge_interface, info->mesh_interface);
397         if (MESHD_ERROR_NONE != ret) {
398                 MESH_LOGE("Failed to mesh_request_create_bridge [%d]", ret);
399                 goto FINISH;
400         }
401
402         /* Detect external network state (i.e. Ethernet)
403                         and decide to make gate enabled */
404         ret = mesh_request_set_mesh_gate(info->bridge_interface,
405                         info->mesh_interface, info->external_interface);
406         if (MESHD_ERROR_NONE != ret) {
407                 MESH_LOGE("Failed to mesh_request_set_mesh_gate [%d]", ret);
408         }
409
410 #if 0
411         /* TODO: Check if specific scan is required */
412         ret = mesh_request_specific_scan(info->mesh_interface,
413                         info->mesh_id, info->mesh_channel);
414         if (MESHD_ERROR_NONE != ret) {
415                 MESH_LOGE("Failed to mesh_request_specific_scan [%d]", ret);
416         }
417         ret = mesh_request_get_scan_result(info->mesh_interface,
418                         &service->scanned_mesh_network);
419 #endif
420
421         /* Request DHCP on bridge interface */
422         ret = mesh_request_dhcp(info->bridge_interface);
423         if (MESHD_ERROR_NONE != ret) {
424                 MESH_LOGE("Failed to mesh_request_dhcp [%d]", ret);
425         }
426
427         /* TODO: Notify bridge status to Connman */
428
429 FINISH:
430         net_mesh_complete_enable_mesh(object, invocation, ret);
431
432         return TRUE;
433 }
434
435 static gboolean _meshd_dbus_handle_disable_mesh(NetMesh *object,
436                 GDBusMethodInvocation *invocation,
437                 gpointer user_data)
438 {
439         int ret = MESHD_ERROR_NONE;
440         mesh_service *service = (mesh_service *)user_data;
441         mesh_interface_s *info = service->interface_info;
442
443         meshd_check_null_ret_error("info", info, FALSE);
444
445         /* Destroy bridge and return from mesh to infra mode */
446         if (service->joined_network) {
447                 g_free(service->joined_network->mesh_id);
448                 g_free(service->joined_network);
449                 service->joined_network = NULL;
450         }
451
452         if (FALSE == service->mesh_activated) {
453                 MESH_LOGD("Mesh network is not activated yet");
454                 ret = MESHD_ERROR_OPERATION_FAILED;
455                 net_mesh_complete_disable_mesh(object, invocation, ret);
456                 return TRUE;
457         }
458
459         /* If DHCP is on progress, stop it */
460         ret = mesh_request_stop_dhcp();
461         if (MESHD_ERROR_NONE != ret) {
462                 MESH_LOGE("Failed to stop DHCP request !");
463         }
464
465         ret = mesh_request_disable_mesh(info->mesh_interface);
466         if (MESHD_ERROR_NONE != ret) {
467                 MESH_LOGE("Failed to mesh_request_disable_mesh_gate");
468         }
469
470         ret = mesh_request_remove_bridge(info->bridge_interface);
471         if (MESHD_ERROR_NONE != ret) {
472                 MESH_LOGE("Failed to mesh_request_remove_bridge");
473         }
474
475         /* Make response */
476         net_mesh_complete_disable_mesh(object, invocation, ret);
477
478         /* Make notification */
479         mesh_notify_left_network();
480
481         return TRUE;
482 }
483
484 static gboolean _meshd_dbus_handle_get_joined_mesh_network(NetMesh *object,
485                 GDBusMethodInvocation *invocation,
486                 gpointer user_data)
487 {
488         int ret = MESHD_ERROR_NONE;
489         mesh_service *service = (mesh_service *)user_data;
490         mesh_network_info_s *joined = service->joined_network;
491
492         //gchar *meshid = strdup("meshnet");
493         //gchar *bssid = strdup("7c:dd:90:d8:2a:64");
494         //gint channel = 161;
495         //gint max_speed = 866;
496
497         if (joined) {
498                 net_mesh_complete_get_joined_mesh_network(object, invocation,
499                         joined->mesh_id, joined->bssid, joined->channel, ret);
500         } else {
501                 net_mesh_complete_get_joined_mesh_network(object, invocation,
502                         "", "", 0, MESHD_ERROR_NO_DATA);
503         }
504
505         return TRUE;
506 }
507
508 static gboolean _meshd_dbus_handle_set_gate(NetMesh *object,
509                 GDBusMethodInvocation *invocation, gboolean stp, gboolean gate_announce,
510                 gpointer user_data)
511 {
512         int ret = MESHD_ERROR_NONE;
513         mesh_service *service = (mesh_service *)user_data;
514         mesh_interface_s *info = service->interface_info;
515
516         MESH_LOGD("STP = %d", stp);
517         MESH_LOGD("gate_announce = %d", gate_announce);
518
519         /* Set STP and gate_announce */
520         ret = mesh_request_set_mesh_gate(info->bridge_interface,
521                         info->mesh_interface, info->external_interface);
522         if (MESHD_ERROR_NONE != ret) {
523                 MESH_LOGE("Failed to mesh_request_set_mesh_gate [%d]", ret);
524         }
525
526         net_mesh_complete_set_gate(object, invocation, ret);
527
528         return TRUE;
529 }
530
531 static gboolean _meshd_dbus_handle_unset_gate(NetMesh *object,
532                 GDBusMethodInvocation *invocation,
533                 gpointer user_data)
534 {
535         int ret = MESHD_ERROR_NONE;
536         mesh_service *service = (mesh_service *)user_data;
537         mesh_interface_s *info = service->interface_info;
538
539         ret = mesh_request_unset_mesh_gate(info->bridge_interface,
540                         info->mesh_interface, info->external_interface);
541         if (MESHD_ERROR_NONE != ret) {
542                 MESH_LOGE("Failed to mesh_request_unset_mesh_gate [%d]", ret);
543         }
544         net_mesh_complete_unset_gate(object, invocation, ret);
545
546         return TRUE;
547 }
548
549 static gboolean _meshd_dbus_handle_set_softap(NetMesh *object,
550                 GDBusMethodInvocation *invocation,
551                 gchar *ssid, gchar *passphrase,
552                 gchar *mode, gint channel, gint visibility, gint max_sta,
553                 gint security, gpointer user_data)
554 {
555         int ret = MESHD_ERROR_NONE;
556         mesh_service *service = (mesh_service *)user_data;
557         mesh_interface_s *info = service->interface_info;
558
559         MESH_LOGD("SSID      : %s", ssid);
560         MESH_LOGD("mode      : %s", mode);
561         MESH_LOGD("channel   : %d", channel);
562         MESH_LOGD("visibility: %d", visibility);
563         MESH_LOGD("max_sta   : %d", max_sta);
564         MESH_LOGD("security  : %d", security);
565
566         /* Save softAP information */
567         ret = mesh_request_set_softap_config(info->softap_interface,
568                 ssid, mode, channel, visibility, max_sta,
569                 security, passphrase);
570         if (MESHD_ERROR_NONE != ret) {
571                 MESH_LOGE("Failed to mesh_request_set_softap_config [%d]", ret);
572         }
573
574         net_mesh_complete_set_softap(object, invocation, ret);
575
576         return TRUE;
577 }
578
579 static gboolean _meshd_dbus_handle_enable_softap(NetMesh *object,
580                 GDBusMethodInvocation *invocation, gpointer user_data)
581 {
582         int ret = MESHD_ERROR_NONE;
583         mesh_service *service = (mesh_service *)user_data;
584         mesh_interface_s *info = service->interface_info;
585
586         /* Check softAP interface and execute it */
587         ret = mesh_request_enable_softap(info->bridge_interface, info->softap_interface);
588         if (MESHD_ERROR_NONE != ret) {
589                 MESH_LOGE("Failed to mesh_request_enable_softap [%d]", ret);
590         }
591
592         net_mesh_complete_enable_softap(object, invocation, ret);
593
594         return TRUE;
595 }
596
597 static gboolean _meshd_dbus_handle_disable_softap(NetMesh *object,
598                 GDBusMethodInvocation *invocation, gpointer user_data)
599 {
600         int ret = MESHD_ERROR_NONE;
601         mesh_service *service = (mesh_service *)user_data;
602         mesh_interface_s *info = service->interface_info;
603
604         /* Destroy softAP */
605         ret = mesh_request_disable_softap(info->bridge_interface, info->softap_interface);
606         if (MESHD_ERROR_NONE != ret) {
607                 MESH_LOGE("Failed to mesh_request_disable_softap [%d]", ret);
608         }
609
610         net_mesh_complete_disable_softap(object, invocation, ret);
611
612         return TRUE;
613 }
614
615 static gboolean _meshd_dbus_handle_add_mesh_network(NetMesh *object,
616                 GDBusMethodInvocation *invocation,
617                 gchar *mesh_id, gint channel, gint security,
618                 gpointer user_data)
619 {
620         int ret = MESHD_ERROR_NONE;
621         mesh_service *service = (mesh_service *)user_data;
622
623         ret = mesh_request_add_mesh_network(&service->saved_mesh_network,
624                         mesh_id, channel, security);
625
626         net_mesh_complete_add_mesh_network(object, invocation, ret);
627
628         return TRUE;
629 }
630
631 static gboolean _meshd_dbus_handle_get_saved_mesh_network(NetMesh *object,
632                 GDBusMethodInvocation *invocation,
633                 gpointer user_data)
634 {
635         int ret = MESHD_ERROR_NONE;
636         mesh_service *service = (mesh_service *)user_data;
637
638         GVariantBuilder builder;
639         GVariant* networks;
640         GList *iter = NULL;
641
642         ret = mesh_request_get_saved_mesh_network(&service->saved_mesh_network);
643         if (MESHD_ERROR_NONE != ret) {
644                 MESH_LOGE("Failed to mesh_request_get_saved_mesh_network");
645
646                 g_dbus_method_invocation_return_error(invocation,
647                                 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
648         } else {
649                 /* TODO: Get station information and make variant data */
650                 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
651
652                 iter = service->saved_mesh_network;
653                 while (iter != NULL) {
654                         mesh_network_info_s *item = (mesh_network_info_s*)iter->data;
655
656                         g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
657                         g_variant_builder_add(&builder, "{sv}", "mesh_id",
658                                         g_variant_new_string(item->mesh_id));
659                         g_variant_builder_add(&builder, "{sv}", "channel",
660                                         g_variant_new_uint32(item->channel));
661                         g_variant_builder_add(&builder, "{sv}", "security",
662                                         g_variant_new_uint32(item->security));
663                         g_variant_builder_close(&builder);
664
665                         iter = g_list_next(iter);
666                 }
667
668                 networks = g_variant_builder_end(&builder);
669                 net_mesh_complete_get_saved_mesh_network(object, invocation, networks, ret);
670         }
671
672         return TRUE;
673 }
674
675 static gboolean _meshd_dbus_handle_select_saved_mesh_network(NetMesh *object,
676                 GDBusMethodInvocation *invocation,
677                 gchar *mesh_id, gint channel, gint security,
678                 gpointer user_data)
679 {
680         int ret = MESHD_ERROR_NONE;
681         mesh_service *service = (mesh_service *)user_data;
682
683         ret = mesh_request_select_saved_mesh_network(&service->saved_mesh_network,
684                         mesh_id, channel, security);
685
686         net_mesh_complete_select_saved_mesh_network(object, invocation, ret);
687
688         return TRUE;
689 }
690
691 static gboolean _meshd_dbus_handle_forget_saved_mesh_network(NetMesh *object,
692                 GDBusMethodInvocation *invocation,
693                 gchar *mesh_id, gint channel, gint security,
694                 gpointer user_data)
695 {
696         int ret = MESHD_ERROR_NONE;
697         mesh_service *service = (mesh_service *)user_data;
698
699         ret = mesh_request_forget_saved_mesh_network(&service->saved_mesh_network,
700                         mesh_id, channel, security);
701
702         net_mesh_complete_forget_saved_mesh_network(object, invocation, ret);
703
704         return TRUE;
705 }
706
707 static gboolean _meshd_dbus_handle_set_interfaces(NetMesh *object,
708                 GDBusMethodInvocation *invocation,
709                 gchar *mesh, gchar *gate, gchar *softap,
710                 gpointer user_data)
711 {
712         int ret = MESHD_ERROR_NONE;
713         mesh_service *service = (mesh_service *)user_data;
714         mesh_interface_s *info = service->interface_info;
715
716         g_free(info->mesh_interface);
717         info->mesh_interface = g_strdup(mesh);
718
719         g_free(info->external_interface);
720         info->external_interface = g_strdup(gate);
721
722         g_free(info->softap_interface);
723         info->softap_interface = g_strdup(softap);
724
725         net_mesh_complete_set_interfaces(object, invocation, ret);
726
727         return TRUE;
728 }
729
730 static gboolean _meshd_dbus_handle_get_station_info(NetMesh *object,
731                 GDBusMethodInvocation *invocation,
732                 gpointer user_data)
733 {
734         int ret = MESHD_ERROR_NONE;
735
736         GVariantBuilder builder;
737         GVariant* station;
738         GList *iter = NULL;
739
740         mesh_service *service = (mesh_service *)user_data;
741         mesh_interface_s *info = service->interface_info;
742
743         /* Clear mesh station list */
744         g_list_free_full(service->station_list, _on_station_list_destroy);
745         service->station_list = NULL;
746
747         ret = mesh_request_get_station_info(
748                                 info->mesh_interface, &service->station_list);
749         if (MESHD_ERROR_NONE != ret) {
750                 MESH_LOGE("Failed to mesh_request_get_station_info");
751
752                 g_dbus_method_invocation_return_error(invocation,
753                                 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
754         } else {
755         /*
756          * sh-3.2#  iw mesh0 station dump
757          * Station 7c:dd:90:62:37:cf (on mesh0)
758          * inactive time:       1685 ms
759          * rx bytes:    34174
760          * rx packets:  1181
761          * tx bytes:    6877
762          * tx packets:  76
763          * tx retries:  0
764          * tx failed:   0
765          * beacon loss: 0
766          * signal:      -64 dBm
767          * signal avg:  -63 dBm
768          * tx bitrate:  54.0 MBit/s
769          * rx bitrate:  5.5 MBit/s
770          * mesh llid:   51731
771          * mesh plid:   35432
772          * mesh plink:  ESTAB
773          * mesh local PS mode:  ACTIVE
774          * mesh peer PS mode:   ACTIVE
775          * mesh non-peer PS mode:       ACTIVE
776          * authorized:  yes
777          * authenticated:       yes
778          * associated:  yes
779          * preamble:    long
780          * WMM/WME:     yes
781          * MFP:         no
782          * TDLS peer:   no
783          * DTIM period: 0
784          * beacon interval:1000
785          * short slot time:yes
786          * connected time:      256 seconds
787          */
788                 /* Get station information and make variant data */
789                 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
790
791                 iter = service->station_list;
792                 while (iter != NULL) {
793                         mesh_station_info_s *item = (mesh_station_info_s*)iter->data;
794
795                         g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
796                         g_variant_builder_add(&builder, "{sv}", "bssid",
797                                                 g_variant_new_string(item->bssid));
798                         g_variant_builder_add(&builder, "{sv}", "inactive_time",
799                                                 g_variant_new_uint32(item->inactive_time));
800                         g_variant_builder_add(&builder, "{sv}", "rx_bytes",
801                                                 g_variant_new_uint64(item->rx_bytes));
802                         g_variant_builder_add(&builder, "{sv}", "rx_packets",
803                                                 g_variant_new_uint32(item->rx_packets));
804                         g_variant_builder_add(&builder, "{sv}", "tx_bytes",
805                                                 g_variant_new_uint64(item->tx_bytes));
806                         g_variant_builder_add(&builder, "{sv}", "tx_packets",
807                                                 g_variant_new_uint32(item->tx_packets));
808                         g_variant_builder_add(&builder, "{sv}", "tx_retries",
809                                                 g_variant_new_uint32(item->tx_retries));
810                         g_variant_builder_add(&builder, "{sv}", "tx_failed",
811                                                 g_variant_new_uint32(item->tx_failed));
812                         g_variant_builder_add(&builder, "{sv}", "beacon_loss",
813                                                 g_variant_new_uint32(item->beacon_loss));
814                         g_variant_builder_add(&builder, "{sv}", "beacon_rx",
815                                                 g_variant_new_uint64(item->beacon_rx));
816                         g_variant_builder_add(&builder, "{sv}", "rx_drop_misc",
817                                                 g_variant_new_uint64(item->rx_drop_misc));
818                         g_variant_builder_add(&builder, "{sv}", "signal",
819                                                 g_variant_new_int32(item->rssi));
820                         g_variant_builder_add(&builder, "{sv}", "signal_avg",
821                                                 g_variant_new_int32(item->rssi_avg));
822                         g_variant_builder_add(&builder, "{sv}", "tx_bitrate",
823                                                 g_variant_new_uint32(item->tx_bitrate)); /* 10 times */
824                         g_variant_builder_add(&builder, "{sv}", "rx_bitrate",
825                                                 g_variant_new_uint32(item->rx_bitrate)); /* 10 times */
826                         g_variant_builder_add(&builder, "{sv}", "mesh_llid",
827                                                 g_variant_new_uint16(item->llid));
828                         g_variant_builder_add(&builder, "{sv}", "mesh_plid",
829                                                 g_variant_new_uint16(item->plid));
830                         g_variant_builder_add(&builder, "{sv}", "mesh_plink",
831                                                 g_variant_new_byte(item->mesh_plink)); /* 0 : DISCON, 1 : ESTAB */
832                         g_variant_builder_add(&builder, "{sv}", "local_ps_mode",
833                                                 g_variant_new_uint32(item->local_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
834                         g_variant_builder_add(&builder, "{sv}", "peer_ps_mode",
835                                                 g_variant_new_uint32(item->peer_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
836                         g_variant_builder_add(&builder, "{sv}", "non_peer_ps_mode",
837                                                 g_variant_new_uint32(item->non_peer_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
838                         g_variant_builder_add(&builder, "{sv}", "authorized",
839                                                 g_variant_new_boolean(item->authorized));
840                         g_variant_builder_add(&builder, "{sv}", "associated",
841                                                 g_variant_new_boolean(item->associated));
842                         g_variant_builder_add(&builder, "{sv}", "preamble",
843                                                 g_variant_new_boolean(item->preamble));
844                         g_variant_builder_add(&builder, "{sv}", "WMM_WME",
845                                                 g_variant_new_boolean(item->wme));
846                         g_variant_builder_add(&builder, "{sv}", "MFP",
847                                                 g_variant_new_boolean(item->mfp));
848                         g_variant_builder_add(&builder, "{sv}", "TDLS_peer",
849                                                 g_variant_new_boolean(item->tdls_peer));
850                         g_variant_builder_add(&builder, "{sv}", "DTIM_period",
851                                                 g_variant_new_byte(item->dtim_period));
852                         g_variant_builder_add(&builder, "{sv}", "beacon_interval",
853                                                 g_variant_new_uint16(item->beacon_interval));
854                         g_variant_builder_add(&builder, "{sv}", "short_slot_time",
855                                                 g_variant_new_boolean(item->short_slot_time));
856                         g_variant_builder_add(&builder, "{sv}", "connected_time",
857                                                 g_variant_new_uint32(item->connected_time));
858                         g_variant_builder_close(&builder);
859
860                         iter = g_list_next(iter);
861                 }
862
863                 station = g_variant_builder_end(&builder);
864                 net_mesh_complete_get_station_info(object, invocation, station, ret);
865
866                 g_object_unref(station);
867         }
868
869 #if 0
870         g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
871         g_variant_builder_add(&builder, "{sv}", "station", g_variant_new_string("7c:dd:90:62:37:cf"));
872         g_variant_builder_add(&builder, "{sv}", "inactive_time", g_variant_new_uint32(1685));
873         g_variant_builder_add(&builder, "{sv}", "rx_bytes", g_variant_new_uint32(34174));
874         g_variant_builder_add(&builder, "{sv}", "rx_packets", g_variant_new_uint32(1181));
875         g_variant_builder_add(&builder, "{sv}", "tx_bytes", g_variant_new_uint32(6877));
876         g_variant_builder_add(&builder, "{sv}", "tx_packets", g_variant_new_uint32(76));
877         g_variant_builder_add(&builder, "{sv}", "tx_retries", g_variant_new_uint32(0));
878         g_variant_builder_add(&builder, "{sv}", "tx_failed", g_variant_new_uint32(0));
879         g_variant_builder_add(&builder, "{sv}", "beacon_loss", g_variant_new_uint32(0));
880         g_variant_builder_add(&builder, "{sv}", "signal", g_variant_new_int32(-64));
881         g_variant_builder_add(&builder, "{sv}", "signal_avg", g_variant_new_int32(-63));
882         g_variant_builder_add(&builder, "{sv}", "tx_bitrate", g_variant_new_uint32(540)); /* 10 times */
883         g_variant_builder_add(&builder, "{sv}", "rx_bitrate", g_variant_new_uint32(55)); /* 10 times */
884         g_variant_builder_add(&builder, "{sv}", "mesh_llid", g_variant_new_uint32(51731));
885         g_variant_builder_add(&builder, "{sv}", "mesh_plid", g_variant_new_uint32(35432));
886         g_variant_builder_add(&builder, "{sv}", "mesh_plink", g_variant_new_uint32(1)); /* 0 : DISCON, 1 : ESTAB */
887         g_variant_builder_add(&builder, "{sv}", "mesh_local_PS_mode", g_variant_new_uint32(1)); /* 0 : INACTIVE, 1 : ACTIVE */
888         g_variant_builder_add(&builder, "{sv}", "mesh_peer_PS_mode", g_variant_new_uint32(1)); /* 0 : INACTIVE, 1 : ACTIVE */
889         g_variant_builder_add(&builder, "{sv}", "mesh_none_peer_PS_mode", g_variant_new_uint32(1)); /* 0 : INACTIVE, 1 : ACTIVE */
890         g_variant_builder_add(&builder, "{sv}", "authorized", g_variant_new_boolean(TRUE));
891         g_variant_builder_add(&builder, "{sv}", "associated", g_variant_new_boolean(TRUE));
892         g_variant_builder_add(&builder, "{sv}", "preamble",g_variant_new_string("long"));
893         g_variant_builder_add(&builder, "{sv}", "WMM_WME", g_variant_new_boolean(TRUE));
894         g_variant_builder_add(&builder, "{sv}", "MFP", g_variant_new_boolean(FALSE));
895         g_variant_builder_add(&builder, "{sv}", "TDLS_peer", g_variant_new_boolean(FALSE));
896         g_variant_builder_add(&builder, "{sv}", "DTIM_period", g_variant_new_uint32(0));
897         g_variant_builder_add(&builder, "{sv}", "beacon_interval", g_variant_new_uint32(1000));
898         g_variant_builder_add(&builder, "{sv}", "short_slot_time", g_variant_new_boolean(TRUE));
899         g_variant_builder_add(&builder, "{sv}", "connected_time", g_variant_new_uint32(256));
900         station = g_variant_builder_end(&builder);
901
902         net_mesh_complete_get_station_info(object, invocation, station, ret);
903
904         g_object_unref(station);
905 #endif
906         return TRUE;
907 }
908
909 static gboolean _meshd_dbus_handle_get_mpath_info(NetMesh *object,
910                 GDBusMethodInvocation *invocation,
911                 gpointer user_data)
912 {
913         int ret = MESHD_ERROR_NONE;
914         GVariantBuilder builder;
915         GVariant* mpath_data;
916         GList *iter = NULL;
917
918         mesh_service *service = (mesh_service *)user_data;
919         mesh_interface_s *info = service->interface_info;
920
921         /* Clear mesh path list */
922         g_list_free_full(service->mpath_list, _on_mpath_list_destroy);
923         service->mpath_list = NULL;
924
925         ret = mesh_request_get_mpath_info(
926                                 info->mesh_interface, &service->mpath_list);
927         if (MESHD_ERROR_NONE != ret) {
928                 MESH_LOGE("Failed to mesh_request_get_mpath_info");
929
930                 g_dbus_method_invocation_return_error(invocation,
931                                 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
932         } else {
933         /*
934          * Example) sh-3.2# iw mesh0 mpath dump
935          * DEST ADDR         NEXT HOP          IFACE    SN      METRIC  QLEN    EXPTIME         DTIM    DRET    FLAGS
936          * 7c:dd:90:62:37:cf 7c:dd:90:62:37:cf mesh0    221     152             0               10                      100             0               0x5
937          */
938                 /* Get mesh path information and make variant data */
939                 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
940         
941                 iter = service->mpath_list;
942                 while (iter != NULL) {
943                         mesh_mpath_info_s *item = (mesh_mpath_info_s*)iter->data;
944
945                         g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
946                         g_variant_builder_add(&builder, "{sv}", "DEST_ADDR",
947                                                 g_variant_new_string(item->dest_addr));
948                         g_variant_builder_add(&builder, "{sv}", "NEXT_HOP",
949                                                 g_variant_new_string(item->next_hop));
950                         g_variant_builder_add(&builder, "{sv}", "IFACE",
951                                                 g_variant_new_string(item->interface));
952                         g_variant_builder_add(&builder, "{sv}", "SN",
953                                                 g_variant_new_uint32(item->sn));
954                         g_variant_builder_add(&builder, "{sv}", "METRIC",
955                                                 g_variant_new_uint32(item->metric));
956                         g_variant_builder_add(&builder, "{sv}", "QLEN",
957                                                 g_variant_new_uint32(item->qlen));
958                         g_variant_builder_add(&builder, "{sv}", "EXPTIME",
959                                                 g_variant_new_uint32(item->exptime));
960                         g_variant_builder_add(&builder, "{sv}", "DTIM",
961                                                 g_variant_new_uint32(item->discovery_timeout));
962                         g_variant_builder_add(&builder, "{sv}", "DRET",
963                                                 g_variant_new_byte(item->discovery_retries));
964                         g_variant_builder_add(&builder, "{sv}", "FLAGS",
965                                                 g_variant_new_byte(item->flags));
966                         g_variant_builder_close(&builder);
967
968                         iter = g_list_next(iter);
969                 }
970
971                 mpath_data = g_variant_builder_end(&builder);
972                 net_mesh_complete_get_mpath_info(object, invocation, mpath_data, ret);
973
974                 g_object_unref(mpath_data);
975         }
976
977         return TRUE;
978 }
979
980 static void _meshd_dbus_on_activator_bus_acquired(GDBusConnection *conn,
981                 const gchar *name, gpointer user_data)
982 {
983         gboolean ret;
984         GError *error = NULL;
985         mesh_service *service = (mesh_service *)user_data;
986
987         NOTUSED(name);
988
989         meshd_activator_dbus_object = manager_skeleton_new();
990         if (NULL == meshd_activator_dbus_object) {
991                 MESH_LOGE("manager_skeleton_new() Fail");
992                 return;
993         }
994
995         g_signal_connect(meshd_activator_dbus_object, "handle-enable",
996                         G_CALLBACK(_meshd_dbus_handle_enable), service);
997         g_signal_connect(meshd_activator_dbus_object, "handle-disable",
998                         G_CALLBACK(_meshd_dbus_handle_disable), service);
999
1000         ret = g_dbus_interface_skeleton_export(
1001                                 G_DBUS_INTERFACE_SKELETON(meshd_activator_dbus_object),
1002                                 conn, MESH_DBUS_MANAGER_OBJPATH, &error);
1003         if (FALSE == ret) {
1004                 MESH_LOGE("g_dbus_interface_skeleton_export() Fail(%s)", error->message);
1005                 g_error_free(error);
1006         }
1007 }
1008
1009 static void _meshd_dbus_on_bus_acquired(GDBusConnection *conn, const gchar *name,
1010                 gpointer user_data)
1011 {
1012         gboolean ret;
1013         GError *error = NULL;
1014         mesh_service *service = (mesh_service *)user_data;
1015
1016         NOTUSED(name);
1017
1018         meshd_dbus_object = net_mesh_skeleton_new();
1019         if (NULL == meshd_dbus_object) {
1020                 MESH_LOGE("net_mesh_skeleton_new() Fail");
1021                 return;
1022         }
1023
1024         g_signal_connect(meshd_dbus_object, "handle-scan",
1025                         G_CALLBACK(_meshd_dbus_handle_scan), service);
1026         g_signal_connect(meshd_dbus_object, "handle-specific-scan",
1027                         G_CALLBACK(_meshd_dbus_handle_specific_scan), service);
1028         g_signal_connect(meshd_dbus_object, "handle-cancel-scan",
1029                         G_CALLBACK(_meshd_dbus_handle_cancel_scan), service);
1030         g_signal_connect(meshd_dbus_object, "handle-get-found-mesh-networks",
1031                         G_CALLBACK(_meshd_dbus_handle_get_found_mesh_networks), service);
1032         g_signal_connect(meshd_dbus_object, "handle-enable-mesh",
1033                         G_CALLBACK(_meshd_dbus_handle_enable_mesh), service);
1034         g_signal_connect(meshd_dbus_object, "handle-disable-mesh",
1035                         G_CALLBACK(_meshd_dbus_handle_disable_mesh), service);
1036         g_signal_connect(meshd_dbus_object, "handle-get-joined-mesh-network",
1037                         G_CALLBACK(_meshd_dbus_handle_get_joined_mesh_network), service);
1038         g_signal_connect(meshd_dbus_object, "handle-set-gate",
1039                         G_CALLBACK(_meshd_dbus_handle_set_gate), service);
1040         g_signal_connect(meshd_dbus_object, "handle-unset-gate",
1041                         G_CALLBACK(_meshd_dbus_handle_unset_gate), service);
1042         g_signal_connect(meshd_dbus_object, "handle-set-softap",
1043                         G_CALLBACK(_meshd_dbus_handle_set_softap), service);
1044         g_signal_connect(meshd_dbus_object, "handle-enable-softap",
1045                         G_CALLBACK(_meshd_dbus_handle_enable_softap), service);
1046         g_signal_connect(meshd_dbus_object, "handle-disable-softap",
1047                         G_CALLBACK(_meshd_dbus_handle_disable_softap), service);
1048         g_signal_connect(meshd_dbus_object, "handle-add-mesh-network",
1049                         G_CALLBACK(_meshd_dbus_handle_add_mesh_network), service);
1050         g_signal_connect(meshd_dbus_object, "handle-get-saved-mesh-network",
1051                         G_CALLBACK(_meshd_dbus_handle_get_saved_mesh_network), service);
1052         g_signal_connect(meshd_dbus_object, "handle-select-saved-mesh-network",
1053                         G_CALLBACK(_meshd_dbus_handle_select_saved_mesh_network), service);
1054         g_signal_connect(meshd_dbus_object, "handle-forget-saved-mesh-network",
1055                         G_CALLBACK(_meshd_dbus_handle_forget_saved_mesh_network), service);
1056         g_signal_connect(meshd_dbus_object, "handle-set-interfaces",
1057                         G_CALLBACK(_meshd_dbus_handle_set_interfaces), service);
1058         g_signal_connect(meshd_dbus_object, "handle-get-station-info",
1059                         G_CALLBACK(_meshd_dbus_handle_get_station_info), service);
1060         g_signal_connect(meshd_dbus_object, "handle-get-mpath-info",
1061                         G_CALLBACK(_meshd_dbus_handle_get_mpath_info), service);
1062
1063         ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(meshd_dbus_object),
1064                         conn, MESH_DBUS_OBJPATH, &error);
1065         if (FALSE == ret) {
1066                 MESH_LOGE("g_dbus_interface_skeleton_export() Fail(%s)", error->message);
1067                 g_error_free(error);
1068         }
1069
1070         ret = _meshd_dbus_subscribe_name_owner_changed(conn);
1071         if (MESHD_ERROR_NONE != ret) {
1072                 MESH_LOGE("_meshd_dbus_subscribe_name_owner_changed() Fail(%d)", ret);
1073                 return;
1074         }
1075 }
1076
1077 static void _meshd_dbus_on_name_lost(GDBusConnection *conn, const gchar *name,
1078                 gpointer user_data)
1079 {
1080         NOTUSED(conn);
1081         NOTUSED(user_data);
1082
1083         MESH_LOGD("Lost the name %s", name);
1084 }
1085
1086 static void _meshd_dbus_on_name_acquired(GDBusConnection *conn, const gchar *name,
1087                 gpointer user_data)
1088 {
1089         NOTUSED(conn);
1090         NOTUSED(user_data);
1091
1092         MESH_LOGD("Acquired the name %s", name);
1093 }
1094
1095 static gboolean _meshd_dbus_interface_init(mesh_service *service)
1096 {
1097         guint id;
1098         guint activation_dbus_id;
1099         meshd_check_null_ret_error("service", service, FALSE);
1100
1101         id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
1102                         MESH_DBUS_INTERFACE,
1103                         G_BUS_NAME_OWNER_FLAGS_REPLACE,
1104                         _meshd_dbus_on_bus_acquired,
1105                         _meshd_dbus_on_name_acquired,
1106                         _meshd_dbus_on_name_lost,
1107                         service,
1108                         NULL);
1109         if (0 == id) {
1110                 MESH_LOGE("g_bus_own_name() Fail");
1111                 return FALSE;
1112         }
1113
1114         /* Get D-Bus owner to activate zigbee-daemon */
1115         activation_dbus_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
1116                         MESH_DBUS_INTERFACE".manager",
1117                         G_BUS_NAME_OWNER_FLAGS_REPLACE,
1118                         _meshd_dbus_on_activator_bus_acquired,
1119                         NULL,
1120                         NULL,
1121                         service,
1122                         NULL);
1123
1124         service->dbus_id = id;
1125         service->activation_dbus_id = activation_dbus_id;
1126         service->interface_info = g_new0(mesh_interface_s, 1);
1127         service->scanned_mesh_network = NULL;
1128
1129         return TRUE;
1130 }
1131
1132 static void _meshd_dbus_deinit(mesh_service *service)
1133 {
1134         mesh_interface_s *info = NULL;
1135         meshd_check_null_ret("service", service);
1136
1137         g_bus_unown_name(service->dbus_id);
1138
1139         g_bus_unown_name(service->activation_dbus_id);
1140
1141         info = service->interface_info;
1142         meshd_check_null_ret("info", info);
1143         if (info->bridge_interface)
1144                 g_free(info->bridge_interface);
1145         if (info->base_interface)
1146                 g_free(info->base_interface);
1147         if (info->mesh_interface)
1148                 g_free(info->mesh_interface);
1149         if (info->softap_interface)
1150                 g_free(info->softap_interface);
1151         if (info->external_interface)
1152                 g_free(info->external_interface);
1153
1154         if (service->joined_network) {
1155                 g_free(service->joined_network->mesh_id);
1156                 g_free(service->joined_network);
1157                 service->joined_network = NULL;
1158         }
1159         mesh_request_clear_saved_mesh_network(&service->saved_mesh_network);
1160
1161         /* Clear scan list */
1162         g_list_free_full(service->scanned_mesh_network, _on_scan_result_destroy);
1163         service->scanned_mesh_network = NULL;
1164
1165         g_free(service->interface_info);
1166         service->interface_info = NULL;
1167 }
1168
1169  /**< mesh service interface initialization */
1170 gboolean meshd_service_interface_init(mesh_service *service)
1171 {
1172         guint ret;
1173         meshd_check_null_ret_error("service", service, FALSE);
1174
1175         /* Initialize dbus interface */
1176         ret = _meshd_dbus_interface_init(service);
1177         if (FALSE == ret) {
1178                 MESH_LOGE("zigbee_service_dbus_interface_init failed!!!");
1179                 return FALSE;
1180         }
1181
1182         return TRUE;
1183 }
1184
1185 /**< Zigbee service interface de-initialization */
1186 void meshd_service_interface_deinit(mesh_service *service)
1187 {
1188         meshd_check_null_ret("service", service);
1189
1190         /* De-initialize dbus interface */
1191         _meshd_dbus_deinit(service);
1192 }