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