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         if (MESHD_ERROR_NONE != ret) {
 391                 MESH_LOGE("Failed to mesh_request_enable_mesh [%d]", ret);
 392                 goto FINISH;
 393         }
 394
 395         ret = mesh_request_create_bridge(info->bridge_interface, info->mesh_interface);
 396         if (MESHD_ERROR_NONE != ret) {
 397                 MESH_LOGE("Failed to mesh_request_create_bridge [%d]", ret);
 398                 goto FINISH;
 399         }
 400
 401
 402         ret = mesh_request_join_mesh(info->mesh_interface,
 403                         service->saved_mesh_network, &service->joined_network);
 404         if (MESHD_ERROR_NONE != ret) {
 405                 MESH_LOGE("Failed to mesh_request_join_mesh [%d]", ret);
 406                 goto FINISH;
 407         }
 408
 409         /* Detect external network state (i.e. Ethernet)
 410                         and decide to make gate enabled */
 411         ret = mesh_request_set_mesh_gate(info->bridge_interface,
 412                         info->mesh_interface, info->external_interface);
 413         if (MESHD_ERROR_NONE != ret) {
 414                 MESH_LOGE("Failed to mesh_request_set_mesh_gate [%d]", ret);
 415         }
 416
 417 #if 0
 418         /* TODO: Check if specific scan is required */
 419         ret = mesh_request_specific_scan(info->mesh_interface,
 420                         info->mesh_id, info->mesh_channel);
 421         if (MESHD_ERROR_NONE != ret) {
 422                 MESH_LOGE("Failed to mesh_request_specific_scan [%d]", ret);
 423         }
 424         ret = mesh_request_get_scan_result(info->mesh_interface,
 425                         &service->scanned_mesh_network);
 426 #endif
 427
 428         /* Request DHCP on bridge interface */
 429         ret = mesh_request_dhcp(info->bridge_interface);
 430         if (MESHD_ERROR_NONE != ret) {
 431                 MESH_LOGE("Failed to mesh_request_dhcp [%d]", ret);
 432         }
 433
 434         /* TODO: Notify bridge status to Connman */
 435
 436 FINISH:
 437         net_mesh_complete_enable_mesh(object, invocation, ret);
 438
 439         return TRUE;
 440 }
 441
 442 static gboolean _meshd_dbus_handle_disable_mesh(NetMesh *object,
 443                 GDBusMethodInvocation *invocation,
 444                 gpointer user_data)
 445 {
 446         int ret = MESHD_ERROR_NONE;
 447         mesh_service *service = (mesh_service *)user_data;
 448         mesh_interface_s *info = service->interface_info;
 449
 450         meshd_check_null_ret_error("info", info, FALSE);
 451
 452         /* Destroy bridge and return from mesh to infra mode */
 453         if (service->joined_network) {
 454                 g_free(service->joined_network->mesh_id);
 455                 g_free(service->joined_network);
 456                 service->joined_network = NULL;
 457         }
 458
 459         if (FALSE == service->mesh_activated) {
 460                 MESH_LOGD("Mesh network is not activated yet");
 461                 ret = MESHD_ERROR_OPERATION_FAILED;
 462                 net_mesh_complete_disable_mesh(object, invocation, ret);
 463                 return TRUE;
 464         }
 465
 466         ret = mesh_request_disable_mesh(info->mesh_interface);
 467         if (MESHD_ERROR_NONE != ret) {
 468                 MESH_LOGE("Failed to mesh_request_disable_mesh_gate");
 469         }
 470
 471         ret = mesh_request_remove_bridge(info->bridge_interface);
 472         if (MESHD_ERROR_NONE != ret) {
 473                 MESH_LOGE("Failed to mesh_request_remove_bridge");
 474         }
 475
 476         /* Make response */
 477         net_mesh_complete_disable_mesh(object, invocation, ret);
 478
 479         /* Make notification */
 480         mesh_notify_left_network();
 481
 482         return TRUE;
 483 }
 484
 485 static gboolean _meshd_dbus_handle_get_joined_mesh_network(NetMesh *object,
 486                 GDBusMethodInvocation *invocation,
 487                 gpointer user_data)
 488 {
 489         int ret = MESHD_ERROR_NONE;
 490         mesh_service *service = (mesh_service *)user_data;
 491         mesh_network_info_s *joined = service->joined_network;
 492
 493         //gchar *meshid = strdup("meshnet");
 494         //gchar *bssid = strdup("7c:dd:90:d8:2a:64");
 495         //gint channel = 161;
 496         //gint max_speed = 866;
 497
 498         if (joined) {
 499                 net_mesh_complete_get_joined_mesh_network(object, invocation,
 500                         joined->mesh_id, joined->bssid, joined->channel, ret);
 501         } else {
 502                 net_mesh_complete_get_joined_mesh_network(object, invocation,
 503                         "", "", 0, MESHD_ERROR_NO_DATA);
 504         }
 505
 506         return TRUE;
 507 }
 508
 509 static gboolean _meshd_dbus_handle_set_gate(NetMesh *object,
 510                 GDBusMethodInvocation *invocation, gboolean stp, gboolean gate_announce,
 511                 gpointer user_data)
 512 {
 513         int ret = MESHD_ERROR_NONE;
 514         mesh_service *service = (mesh_service *)user_data;
 515         mesh_interface_s *info = service->interface_info;
 516
 517         MESH_LOGD("STP = %d", stp);
 518         MESH_LOGD("gate_announce = %d", gate_announce);
 519
 520         /* Set STP and gate_announce */
 521         ret = mesh_request_set_mesh_gate(info->bridge_interface,
 522                         info->mesh_interface, info->external_interface);
 523         if (MESHD_ERROR_NONE != ret) {
 524                 MESH_LOGE("Failed to mesh_request_set_mesh_gate [%d]", ret);
 525         }
 526
 527         net_mesh_complete_set_gate(object, invocation, ret);
 528
 529         return TRUE;
 530 }
 531
 532 static gboolean _meshd_dbus_handle_unset_gate(NetMesh *object,
 533                 GDBusMethodInvocation *invocation,
 534                 gpointer user_data)
 535 {
 536         int ret = MESHD_ERROR_NONE;
 537         mesh_service *service = (mesh_service *)user_data;
 538         mesh_interface_s *info = service->interface_info;
 539
 540         ret = mesh_request_unset_mesh_gate(info->bridge_interface,
 541                         info->mesh_interface, info->external_interface);
 542         if (MESHD_ERROR_NONE != ret) {
 543                 MESH_LOGE("Failed to mesh_request_unset_mesh_gate [%d]", ret);
 544         }
 545         net_mesh_complete_unset_gate(object, invocation, ret);
 546
 547         return TRUE;
 548 }
 549
 550 static gboolean _meshd_dbus_handle_set_softap(NetMesh *object,
 551                 GDBusMethodInvocation *invocation,
 552                 gchar *ssid, gchar *passphrase,
 553                 gchar *mode, gint channel, gint visibility, gint max_sta,
 554                 gint security, gpointer user_data)
 555 {
 556         int ret = MESHD_ERROR_NONE;
 557         mesh_service *service = (mesh_service *)user_data;
 558         mesh_interface_s *info = service->interface_info;
 559
 560         MESH_LOGD("SSID      : %s", ssid);
 561         MESH_LOGD("mode      : %s", mode);
 562         MESH_LOGD("channel   : %d", channel);
 563         MESH_LOGD("visibility: %d", visibility);
 564         MESH_LOGD("max_sta   : %d", max_sta);
 565         MESH_LOGD("security  : %d", security);
 566
 567         /* Save softAP information */
 568         ret = mesh_request_set_softap_config(info->softap_interface,
 569                 ssid, mode, channel, visibility, max_sta,
 570                 security, passphrase);
 571         if (MESHD_ERROR_NONE != ret) {
 572                 MESH_LOGE("Failed to mesh_request_set_softap_config [%d]", ret);
 573         }
 574
 575         net_mesh_complete_set_softap(object, invocation, ret);
 576
 577         return TRUE;
 578 }
 579
 580 static gboolean _meshd_dbus_handle_enable_softap(NetMesh *object,
 581                 GDBusMethodInvocation *invocation, gpointer user_data)
 582 {
 583         int ret = MESHD_ERROR_NONE;
 584         mesh_service *service = (mesh_service *)user_data;
 585         mesh_interface_s *info = service->interface_info;
 586
 587         /* Check softAP interface and execute it */
 588         ret = mesh_request_enable_softap(info->bridge_interface, info->softap_interface);
 589         if (MESHD_ERROR_NONE != ret) {
 590                 MESH_LOGE("Failed to mesh_request_enable_softap [%d]", ret);
 591         }
 592
 593         net_mesh_complete_enable_softap(object, invocation, ret);
 594
 595         return TRUE;
 596 }
 597
 598 static gboolean _meshd_dbus_handle_disable_softap(NetMesh *object,
 599                 GDBusMethodInvocation *invocation, gpointer user_data)
 600 {
 601         int ret = MESHD_ERROR_NONE;
 602         mesh_service *service = (mesh_service *)user_data;
 603         mesh_interface_s *info = service->interface_info;
 604
 605         /* Destroy softAP */
 606         ret = mesh_request_disable_softap(info->bridge_interface, info->softap_interface);
 607         if (MESHD_ERROR_NONE != ret) {
 608                 MESH_LOGE("Failed to mesh_request_disable_softap [%d]", ret);
 609         }
 610
 611         net_mesh_complete_disable_softap(object, invocation, ret);
 612
 613         return TRUE;
 614 }
 615
 616 static gboolean _meshd_dbus_handle_add_mesh_network(NetMesh *object,
 617                 GDBusMethodInvocation *invocation,
 618                 gchar *mesh_id, gint channel, gint security,
 619                 gpointer user_data)
 620 {
 621         int ret = MESHD_ERROR_NONE;
 622         mesh_service *service = (mesh_service *)user_data;
 623
 624         ret = mesh_request_add_mesh_network(&service->saved_mesh_network,
 625                         mesh_id, channel, security);
 626
 627         net_mesh_complete_add_mesh_network(object, invocation, ret);
 628
 629         return TRUE;
 630 }
 631
 632 static gboolean _meshd_dbus_handle_get_saved_mesh_network(NetMesh *object,
 633                 GDBusMethodInvocation *invocation,
 634                 gpointer user_data)
 635 {
 636         int ret = MESHD_ERROR_NONE;
 637         mesh_service *service = (mesh_service *)user_data;
 638
 639         GVariantBuilder builder;
 640         GVariant* networks;
 641         GList *iter = NULL;
 642
 643         ret = mesh_request_get_saved_mesh_network(&service->saved_mesh_network);
 644         if (MESHD_ERROR_NONE != ret) {
 645                 MESH_LOGE("Failed to mesh_request_get_saved_mesh_network");
 646
 647                 g_dbus_method_invocation_return_error(invocation,
 648                                 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
 649         } else {
 650                 /* TODO: Get station information and make variant data */
 651                 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
 652
 653                 iter = service->saved_mesh_network;
 654                 while (iter != NULL) {
 655                         mesh_network_info_s *item = (mesh_network_info_s*)iter->data;
 656
 657                         g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
 658                         g_variant_builder_add(&builder, "{sv}", "mesh_id",
 659                                         g_variant_new_string(item->mesh_id));
 660                         g_variant_builder_add(&builder, "{sv}", "channel",
 661                                         g_variant_new_uint32(item->channel));
 662                         g_variant_builder_add(&builder, "{sv}", "security",
 663                                         g_variant_new_uint32(item->security));
 664                         g_variant_builder_close(&builder);
 665
 666                         iter = g_list_next(iter);
 667                 }
 668
 669                 networks = g_variant_builder_end(&builder);
 670                 net_mesh_complete_get_saved_mesh_network(object, invocation, networks, ret);
 671         }
 672
 673         return TRUE;
 674 }
 675
 676 static gboolean _meshd_dbus_handle_select_saved_mesh_network(NetMesh *object,
 677                 GDBusMethodInvocation *invocation,
 678                 gchar *mesh_id, gint channel, gint security,
 679                 gpointer user_data)
 680 {
 681         int ret = MESHD_ERROR_NONE;
 682         mesh_service *service = (mesh_service *)user_data;
 683
 684         ret = mesh_request_select_saved_mesh_network(&service->saved_mesh_network,
 685                         mesh_id, channel, security);
 686
 687         net_mesh_complete_select_saved_mesh_network(object, invocation, ret);
 688
 689         return TRUE;
 690 }
 691
 692 static gboolean _meshd_dbus_handle_forget_saved_mesh_network(NetMesh *object,
 693                 GDBusMethodInvocation *invocation,
 694                 gchar *mesh_id, gint channel, gint security,
 695                 gpointer user_data)
 696 {
 697         int ret = MESHD_ERROR_NONE;
 698         mesh_service *service = (mesh_service *)user_data;
 699
 700         ret = mesh_request_forget_saved_mesh_network(&service->saved_mesh_network,
 701                         mesh_id, channel, security);
 702
 703         net_mesh_complete_forget_saved_mesh_network(object, invocation, ret);
 704
 705         return TRUE;
 706 }
 707
 708 static gboolean _meshd_dbus_handle_set_interfaces(NetMesh *object,
 709                 GDBusMethodInvocation *invocation,
 710                 gchar *mesh, gchar *gate, gchar *softap,
 711                 gpointer user_data)
 712 {
 713         int ret = MESHD_ERROR_NONE;
 714         mesh_service *service = (mesh_service *)user_data;
 715         mesh_interface_s *info = service->interface_info;
 716
 717         g_free(info->mesh_interface);
 718         info->mesh_interface = g_strdup(mesh);
 719
 720         g_free(info->external_interface);
 721         info->external_interface = g_strdup(gate);
 722
 723         g_free(info->softap_interface);
 724         info->softap_interface = g_strdup(softap);
 725
 726         net_mesh_complete_set_interfaces(object, invocation, ret);
 727
 728         return TRUE;
 729 }
 730
 731 static gboolean _meshd_dbus_handle_get_station_info(NetMesh *object,
 732                 GDBusMethodInvocation *invocation,
 733                 gpointer user_data)
 734 {
 735         int ret = MESHD_ERROR_NONE;
 736
 737         GVariantBuilder builder;
 738         GVariant* station;
 739         GList *iter = NULL;
 740
 741         mesh_service *service = (mesh_service *)user_data;
 742         mesh_interface_s *info = service->interface_info;
 743
 744         /* Clear mesh station list */
 745         g_list_free_full(service->station_list, _on_station_list_destroy);
 746         service->station_list = NULL;
 747
 748         ret = mesh_request_get_station_info(
 749                                 info->mesh_interface, &service->station_list);
 750         if (MESHD_ERROR_NONE != ret) {
 751                 MESH_LOGE("Failed to mesh_request_get_station_info");
 752
 753                 g_dbus_method_invocation_return_error(invocation,
 754                                 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
 755         } else {
 756         /*
 757          * sh-3.2#  iw mesh0 station dump
 758          * Station 7c:dd:90:62:37:cf (on mesh0)
 759          * inactive time:       1685 ms
 760          * rx bytes:    34174
 761          * rx packets:  1181
 762          * tx bytes:    6877
 763          * tx packets:  76
 764          * tx retries:  0
 765          * tx failed:   0
 766          * beacon loss: 0
 767          * signal:      -64 dBm
 768          * signal avg:  -63 dBm
 769          * tx bitrate:  54.0 MBit/s
 770          * rx bitrate:  5.5 MBit/s
 771          * mesh llid:   51731
 772          * mesh plid:   35432
 773          * mesh plink:  ESTAB
 774          * mesh local PS mode:  ACTIVE
 775          * mesh peer PS mode:   ACTIVE
 776          * mesh non-peer PS mode:       ACTIVE
 777          * authorized:  yes
 778          * authenticated:       yes
 779          * associated:  yes
 780          * preamble:    long
 781          * WMM/WME:     yes
 782          * MFP:         no
 783          * TDLS peer:   no
 784          * DTIM period: 0
 785          * beacon interval:1000
 786          * short slot time:yes
 787          * connected time:      256 seconds
 788          */
 789                 /* Get station information and make variant data */
 790                 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
 791
 792                 iter = service->station_list;
 793                 while (iter != NULL) {
 794                         mesh_station_info_s *item = (mesh_station_info_s*)iter->data;
 795
 796                         g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
 797                         g_variant_builder_add(&builder, "{sv}", "bssid",
 798                                                 g_variant_new_string(item->bssid));
 799                         g_variant_builder_add(&builder, "{sv}", "inactive_time",
 800                                                 g_variant_new_uint32(item->inactive_time));
 801                         g_variant_builder_add(&builder, "{sv}", "rx_bytes",
 802                                                 g_variant_new_uint64(item->rx_bytes));
 803                         g_variant_builder_add(&builder, "{sv}", "rx_packets",
 804                                                 g_variant_new_uint32(item->rx_packets));
 805                         g_variant_builder_add(&builder, "{sv}", "tx_bytes",
 806                                                 g_variant_new_uint64(item->tx_bytes));
 807                         g_variant_builder_add(&builder, "{sv}", "tx_packets",
 808                                                 g_variant_new_uint32(item->tx_packets));
 809                         g_variant_builder_add(&builder, "{sv}", "tx_retries",
 810                                                 g_variant_new_uint32(item->tx_retries));
 811                         g_variant_builder_add(&builder, "{sv}", "tx_failed",
 812                                                 g_variant_new_uint32(item->tx_failed));
 813                         g_variant_builder_add(&builder, "{sv}", "beacon_loss",
 814                                                 g_variant_new_uint32(item->beacon_loss));
 815                         g_variant_builder_add(&builder, "{sv}", "signal",
 816                                                 g_variant_new_int32(item->rssi));
 817                         g_variant_builder_add(&builder, "{sv}", "signal_avg",
 818                                                 g_variant_new_int32(item->rssi_avg));
 819                         g_variant_builder_add(&builder, "{sv}", "tx_bitrate",
 820                                                 g_variant_new_uint32(item->tx_bitrate)); /* 10 times */
 821                         g_variant_builder_add(&builder, "{sv}", "rx_bitrate",
 822                                                 g_variant_new_uint32(item->rx_bitrate)); /* 10 times */
 823                         g_variant_builder_add(&builder, "{sv}", "mesh_llid",
 824                                                 g_variant_new_uint16(item->llid));
 825                         g_variant_builder_add(&builder, "{sv}", "mesh_plid",
 826                                                 g_variant_new_uint16(item->plid));
 827                         g_variant_builder_add(&builder, "{sv}", "mesh_plink",
 828                                                 g_variant_new_byte(item->mesh_plink)); /* 0 : DISCON, 1 : ESTAB */
 829                         g_variant_builder_add(&builder, "{sv}", "local_ps_mode",
 830                                                 g_variant_new_uint32(item->local_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
 831                         g_variant_builder_add(&builder, "{sv}", "peer_ps_mode",
 832                                                 g_variant_new_uint32(item->peer_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
 833                         g_variant_builder_add(&builder, "{sv}", "non_peer_ps_mode",
 834                                                 g_variant_new_uint32(item->non_peer_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
 835                         g_variant_builder_add(&builder, "{sv}", "authorized",
 836                                                 g_variant_new_boolean(item->authorized));
 837                         g_variant_builder_add(&builder, "{sv}", "associated",
 838                                                 g_variant_new_boolean(item->associated));
 839                         g_variant_builder_add(&builder, "{sv}", "preamble",
 840                                                 g_variant_new_boolean(item->preamble));
 841                         g_variant_builder_add(&builder, "{sv}", "WMM_WME",
 842                                                 g_variant_new_boolean(item->wme));
 843                         g_variant_builder_add(&builder, "{sv}", "MFP",
 844                                                 g_variant_new_boolean(item->mfp));
 845                         g_variant_builder_add(&builder, "{sv}", "TDLS_peer",
 846                                                 g_variant_new_boolean(item->tdls_peer));
 847                         g_variant_builder_add(&builder, "{sv}", "DTIM_period",
 848                                                 g_variant_new_byte(item->dtim_period));
 849                         g_variant_builder_add(&builder, "{sv}", "beacon_interval",
 850                                                 g_variant_new_uint16(item->beacon_interval));
 851                         g_variant_builder_add(&builder, "{sv}", "short_slot_time",
 852                                                 g_variant_new_boolean(item->short_slot_time));
 853                         g_variant_builder_add(&builder, "{sv}", "connected_time",
 854                                                 g_variant_new_uint32(item->connected_time));
 855                         g_variant_builder_close(&builder);
 856
 857                         iter = g_list_next(iter);
 858                 }
 859
 860                 station = g_variant_builder_end(&builder);
 861                 net_mesh_complete_get_station_info(object, invocation, station, ret);
 862
 863                 g_object_unref(station);
 864         }
 865
 866 #if 0
 867         g_variant_builder_init(&builder, G_VARIANT_TYPE_VARDICT);
 868         g_variant_builder_add(&builder, "{sv}", "station", g_variant_new_string("7c:dd:90:62:37:cf"));
 869         g_variant_builder_add(&builder, "{sv}", "inactive_time", g_variant_new_uint32(1685));
 870         g_variant_builder_add(&builder, "{sv}", "rx_bytes", g_variant_new_uint32(34174));
 871         g_variant_builder_add(&builder, "{sv}", "rx_packets", g_variant_new_uint32(1181));
 872         g_variant_builder_add(&builder, "{sv}", "tx_bytes", g_variant_new_uint32(6877));
 873         g_variant_builder_add(&builder, "{sv}", "tx_packets", g_variant_new_uint32(76));
 874         g_variant_builder_add(&builder, "{sv}", "tx_retries", g_variant_new_uint32(0));
 875         g_variant_builder_add(&builder, "{sv}", "tx_failed", g_variant_new_uint32(0));
 876         g_variant_builder_add(&builder, "{sv}", "beacon_loss", g_variant_new_uint32(0));
 877         g_variant_builder_add(&builder, "{sv}", "signal", g_variant_new_int32(-64));
 878         g_variant_builder_add(&builder, "{sv}", "signal_avg", g_variant_new_int32(-63));
 879         g_variant_builder_add(&builder, "{sv}", "tx_bitrate", g_variant_new_uint32(540)); /* 10 times */
 880         g_variant_builder_add(&builder, "{sv}", "rx_bitrate", g_variant_new_uint32(55)); /* 10 times */
 881         g_variant_builder_add(&builder, "{sv}", "mesh_llid", g_variant_new_uint32(51731));
 882         g_variant_builder_add(&builder, "{sv}", "mesh_plid", g_variant_new_uint32(35432));
 883         g_variant_builder_add(&builder, "{sv}", "mesh_plink", g_variant_new_uint32(1)); /* 0 : DISCON, 1 : ESTAB */
 884         g_variant_builder_add(&builder, "{sv}", "mesh_local_PS_mode", g_variant_new_uint32(1)); /* 0 : INACTIVE, 1 : ACTIVE */
 885         g_variant_builder_add(&builder, "{sv}", "mesh_peer_PS_mode", g_variant_new_uint32(1)); /* 0 : INACTIVE, 1 : ACTIVE */
 886         g_variant_builder_add(&builder, "{sv}", "mesh_none_peer_PS_mode", g_variant_new_uint32(1)); /* 0 : INACTIVE, 1 : ACTIVE */
 887         g_variant_builder_add(&builder, "{sv}", "authorized", g_variant_new_boolean(TRUE));
 888         g_variant_builder_add(&builder, "{sv}", "associated", g_variant_new_boolean(TRUE));
 889         g_variant_builder_add(&builder, "{sv}", "preamble",g_variant_new_string("long"));
 890         g_variant_builder_add(&builder, "{sv}", "WMM_WME", g_variant_new_boolean(TRUE));
 891         g_variant_builder_add(&builder, "{sv}", "MFP", g_variant_new_boolean(FALSE));
 892         g_variant_builder_add(&builder, "{sv}", "TDLS_peer", g_variant_new_boolean(FALSE));
 893         g_variant_builder_add(&builder, "{sv}", "DTIM_period", g_variant_new_uint32(0));
 894         g_variant_builder_add(&builder, "{sv}", "beacon_interval", g_variant_new_uint32(1000));
 895         g_variant_builder_add(&builder, "{sv}", "short_slot_time", g_variant_new_boolean(TRUE));
 896         g_variant_builder_add(&builder, "{sv}", "connected_time", g_variant_new_uint32(256));
 897         station = g_variant_builder_end(&builder);
 898
 899         net_mesh_complete_get_station_info(object, invocation, station, ret);
 900
 901         g_object_unref(station);
 902 #endif
 903         return TRUE;
 904 }
 905
 906 static gboolean _meshd_dbus_handle_get_mpath_info(NetMesh *object,
 907                 GDBusMethodInvocation *invocation,
 908                 gpointer user_data)
 909 {
 910         int ret = MESHD_ERROR_NONE;
 911         GVariantBuilder builder;
 912         GVariant* mpath_data;
 913         GList *iter = NULL;
 914
 915         mesh_service *service = (mesh_service *)user_data;
 916         mesh_interface_s *info = service->interface_info;
 917
 918         /* Clear mesh path list */
 919         g_list_free_full(service->mpath_list, _on_mpath_list_destroy);
 920         service->mpath_list = NULL;
 921
 922         ret = mesh_request_get_mpath_info(
 923                                 info->mesh_interface, &service->mpath_list);
 924         if (MESHD_ERROR_NONE != ret) {
 925                 MESH_LOGE("Failed to mesh_request_get_mpath_info");
 926
 927                 g_dbus_method_invocation_return_error(invocation,
 928                                 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
 929         } else {
 930         /*
 931          * Example) sh-3.2# iw mesh0 mpath dump
 932          * DEST ADDR         NEXT HOP          IFACE    SN      METRIC  QLEN    EXPTIME         DTIM    DRET    FLAGS
 933          * 7c:dd:90:62:37:cf 7c:dd:90:62:37:cf mesh0    221     152             0               10                      100             0               0x5
 934          */
 935                 /* Get mesh path information and make variant data */
 936                 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
 937
 938                 iter = service->mpath_list;
 939                 while (iter != NULL) {
 940                         mesh_mpath_info_s *item = (mesh_mpath_info_s*)iter->data;
 941
 942                         g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
 943                         g_variant_builder_add(&builder, "{sv}", "DEST_ADDR",
 944                                                 g_variant_new_string(item->dest_addr));
 945                         g_variant_builder_add(&builder, "{sv}", "NEXT_HOP",
 946                                                 g_variant_new_string(item->next_hop));
 947                         g_variant_builder_add(&builder, "{sv}", "IFACE",
 948                                                 g_variant_new_string(item->interface));
 949                         g_variant_builder_add(&builder, "{sv}", "SN",
 950                                                 g_variant_new_uint32(item->sn));
 951                         g_variant_builder_add(&builder, "{sv}", "METRIC",
 952                                                 g_variant_new_uint32(item->metric));
 953                         g_variant_builder_add(&builder, "{sv}", "QLEN",
 954                                                 g_variant_new_uint32(item->qlen));
 955                         g_variant_builder_add(&builder, "{sv}", "EXPTIME",
 956                                                 g_variant_new_uint32(item->exptime));
 957                         g_variant_builder_add(&builder, "{sv}", "DTIM",
 958                                                 g_variant_new_uint32(item->discovery_timeout));
 959                         g_variant_builder_add(&builder, "{sv}", "DRET",
 960                                                 g_variant_new_byte(item->discovery_retries));
 961                         g_variant_builder_add(&builder, "{sv}", "FLAGS",
 962                                                 g_variant_new_byte(item->flags));
 963                         g_variant_builder_close(&builder);
 964
 965                         iter = g_list_next(iter);
 966                 }
 967
 968                 mpath_data = g_variant_builder_end(&builder);
 969                 net_mesh_complete_get_mpath_info(object, invocation, mpath_data, ret);
 970
 971                 g_object_unref(mpath_data);
 972         }
 973
 974         return TRUE;
 975 }
 976
 977 static void _meshd_dbus_on_activator_bus_acquired(GDBusConnection *conn,
 978                 const gchar *name, gpointer user_data)
 979 {
 980         gboolean ret;
 981         GError *error = NULL;
 982         mesh_service *service = (mesh_service *)user_data;
 983
 984         NOTUSED(name);
 985
 986         meshd_activator_dbus_object = manager_skeleton_new();
 987         if (NULL == meshd_activator_dbus_object) {
 988                 MESH_LOGE("manager_skeleton_new() Fail");
 989                 return;
 990         }
 991
 992         g_signal_connect(meshd_activator_dbus_object, "handle-enable",
 993                         G_CALLBACK(_meshd_dbus_handle_enable), service);
 994         g_signal_connect(meshd_activator_dbus_object, "handle-disable",
 995                         G_CALLBACK(_meshd_dbus_handle_disable), service);
 996
 997         ret = g_dbus_interface_skeleton_export(
 998                                 G_DBUS_INTERFACE_SKELETON(meshd_activator_dbus_object),
 999                                 conn, MESH_DBUS_MANAGER_OBJPATH, &error);
1000         if (FALSE == ret) {
1001                 MESH_LOGE("g_dbus_interface_skeleton_export() Fail(%s)", error->message);
1002                 g_error_free(error);
1003         }
1004 }
1005
1006 static void _meshd_dbus_on_bus_acquired(GDBusConnection *conn, const gchar *name,
1007                 gpointer user_data)
1008 {
1009         gboolean ret;
1010         GError *error = NULL;
1011         mesh_service *service = (mesh_service *)user_data;
1012
1013         NOTUSED(name);
1014
1015         meshd_dbus_object = net_mesh_skeleton_new();
1016         if (NULL == meshd_dbus_object) {
1017                 MESH_LOGE("net_mesh_skeleton_new() Fail");
1018                 return;
1019         }
1020
1021         g_signal_connect(meshd_dbus_object, "handle-scan",
1022                         G_CALLBACK(_meshd_dbus_handle_scan), service);
1023         g_signal_connect(meshd_dbus_object, "handle-specific-scan",
1024                         G_CALLBACK(_meshd_dbus_handle_specific_scan), service);
1025         g_signal_connect(meshd_dbus_object, "handle-cancel-scan",
1026                         G_CALLBACK(_meshd_dbus_handle_cancel_scan), service);
1027         g_signal_connect(meshd_dbus_object, "handle-get-found-mesh-networks",
1028                         G_CALLBACK(_meshd_dbus_handle_get_found_mesh_networks), service);
1029         g_signal_connect(meshd_dbus_object, "handle-enable-mesh",
1030                         G_CALLBACK(_meshd_dbus_handle_enable_mesh), service);
1031         g_signal_connect(meshd_dbus_object, "handle-disable-mesh",
1032                         G_CALLBACK(_meshd_dbus_handle_disable_mesh), service);
1033         g_signal_connect(meshd_dbus_object, "handle-get-joined-mesh-network",
1034                         G_CALLBACK(_meshd_dbus_handle_get_joined_mesh_network), service);
1035         g_signal_connect(meshd_dbus_object, "handle-set-gate",
1036                         G_CALLBACK(_meshd_dbus_handle_set_gate), service);
1037         g_signal_connect(meshd_dbus_object, "handle-unset-gate",
1038                         G_CALLBACK(_meshd_dbus_handle_unset_gate), service);
1039         g_signal_connect(meshd_dbus_object, "handle-set-softap",
1040                         G_CALLBACK(_meshd_dbus_handle_set_softap), service);
1041         g_signal_connect(meshd_dbus_object, "handle-enable-softap",
1042                         G_CALLBACK(_meshd_dbus_handle_enable_softap), service);
1043         g_signal_connect(meshd_dbus_object, "handle-disable-softap",
1044                         G_CALLBACK(_meshd_dbus_handle_disable_softap), service);
1045         g_signal_connect(meshd_dbus_object, "handle-add-mesh-network",
1046                         G_CALLBACK(_meshd_dbus_handle_add_mesh_network), service);
1047         g_signal_connect(meshd_dbus_object, "handle-get-saved-mesh-network",
1048                         G_CALLBACK(_meshd_dbus_handle_get_saved_mesh_network), service);
1049         g_signal_connect(meshd_dbus_object, "handle-select-saved-mesh-network",
1050                         G_CALLBACK(_meshd_dbus_handle_select_saved_mesh_network), service);
1051         g_signal_connect(meshd_dbus_object, "handle-forget-saved-mesh-network",
1052                         G_CALLBACK(_meshd_dbus_handle_forget_saved_mesh_network), service);
1053         g_signal_connect(meshd_dbus_object, "handle-set-interfaces",
1054                         G_CALLBACK(_meshd_dbus_handle_set_interfaces), service);
1055         g_signal_connect(meshd_dbus_object, "handle-get-station-info",
1056                         G_CALLBACK(_meshd_dbus_handle_get_station_info), service);
1057         g_signal_connect(meshd_dbus_object, "handle-get-mpath-info",
1058                         G_CALLBACK(_meshd_dbus_handle_get_mpath_info), service);
1059
1060         ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(meshd_dbus_object),
1061                         conn, MESH_DBUS_OBJPATH, &error);
1062         if (FALSE == ret) {
1063                 MESH_LOGE("g_dbus_interface_skeleton_export() Fail(%s)", error->message);
1064                 g_error_free(error);
1065         }
1066
1067         ret = _meshd_dbus_subscribe_name_owner_changed(conn);
1068         if (MESHD_ERROR_NONE != ret) {
1069                 MESH_LOGE("_meshd_dbus_subscribe_name_owner_changed() Fail(%d)", ret);
1070                 return;
1071         }
1072 }
1073
1074 static void _meshd_dbus_on_name_lost(GDBusConnection *conn, const gchar *name,
1075                 gpointer user_data)
1076 {
1077         NOTUSED(conn);
1078         NOTUSED(user_data);
1079
1080         MESH_LOGD("Lost the name %s", name);
1081 }
1082
1083 static void _meshd_dbus_on_name_acquired(GDBusConnection *conn, const gchar *name,
1084                 gpointer user_data)
1085 {
1086         NOTUSED(conn);
1087         NOTUSED(user_data);
1088
1089         MESH_LOGD("Acquired the name %s", name);
1090 }
1091
1092 static gboolean _meshd_dbus_interface_init(mesh_service *service)
1093 {
1094         guint id;
1095         guint activation_dbus_id;
1096         meshd_check_null_ret_error("service", service, FALSE);
1097
1098         id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
1099                         MESH_DBUS_INTERFACE,
1100                         G_BUS_NAME_OWNER_FLAGS_REPLACE,
1101                         _meshd_dbus_on_bus_acquired,
1102                         _meshd_dbus_on_name_acquired,
1103                         _meshd_dbus_on_name_lost,
1104                         service,
1105                         NULL);
1106         if (0 == id) {
1107                 MESH_LOGE("g_bus_own_name() Fail");
1108                 return FALSE;
1109         }
1110
1111         /* Get D-Bus owner to activate zigbee-daemon */
1112         activation_dbus_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
1113                         MESH_DBUS_INTERFACE".manager",
1114                         G_BUS_NAME_OWNER_FLAGS_REPLACE,
1115                         _meshd_dbus_on_activator_bus_acquired,
1116                         NULL,
1117                         NULL,
1118                         service,
1119                         NULL);
1120
1121         service->dbus_id = id;
1122         service->activation_dbus_id = activation_dbus_id;
1123         service->interface_info = g_new0(mesh_interface_s, 1);
1124         service->scanned_mesh_network = NULL;
1125
1126         return TRUE;
1127 }
1128
1129 static void _meshd_dbus_deinit(mesh_service *service)
1130 {
1131         mesh_interface_s *info = NULL;
1132         meshd_check_null_ret("service", service);
1133
1134         g_bus_unown_name(service->dbus_id);
1135
1136         g_bus_unown_name(service->activation_dbus_id);
1137
1138         info = service->interface_info;
1139         meshd_check_null_ret("info", info);
1140         if (info->bridge_interface)
1141                 g_free(info->bridge_interface);
1142         if (info->base_interface)
1143                 g_free(info->base_interface);
1144         if (info->mesh_interface)
1145                 g_free(info->mesh_interface);
1146         if (info->softap_interface)
1147                 g_free(info->softap_interface);
1148         if (info->external_interface)
1149                 g_free(info->external_interface);
1150
1151         if (service->joined_network) {
1152                 g_free(service->joined_network->mesh_id);
1153                 g_free(service->joined_network);
1154                 service->joined_network = NULL;
1155         }
1156         mesh_request_clear_saved_mesh_network(&service->saved_mesh_network);
1157
1158         /* Clear scan list */
1159         g_list_free_full(service->scanned_mesh_network, _on_scan_result_destroy);
1160         service->scanned_mesh_network = NULL;
1161
1162         g_free(service->interface_info);
1163         service->interface_info = NULL;
1164 }
1165
1166  /**< mesh service interface initialization */
1167 gboolean meshd_service_interface_init(mesh_service *service)
1168 {
1169         guint ret;
1170         meshd_check_null_ret_error("service", service, FALSE);
1171
1172         /* Initialize dbus interface */
1173         ret = _meshd_dbus_interface_init(service);
1174         if (FALSE == ret) {
1175                 MESH_LOGE("zigbee_service_dbus_interface_init failed!!!");
1176                 return FALSE;
1177         }
1178
1179         return TRUE;
1180 }
1181
1182 /**< Zigbee service interface de-initialization */
1183 void meshd_service_interface_deinit(mesh_service *service)
1184 {
1185         meshd_check_null_ret("service", service);
1186
1187         /* De-initialize dbus interface */
1188         _meshd_dbus_deinit(service);
1189 }