src/wmesh-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 #include <wifi-manager.h>
  25
  26 #include "wmesh.h"
  27 #include "wmesh-log.h"
  28 #include "wmesh-util.h"
  29 #include "wmesh-gdbus.h"
  30 #include "wmesh-service.h"
  31 #include "wmesh-peer-monitor.h"
  32 #include "wmesh-service-interface.h"
  33 #include "wmesh-generated-code.h"
  34
  35 #include "wmesh-request.h"
  36 #include "wmesh-interface.h"
  37
  38 static NetWmesh *meshd_dbus_object;
  39 static Manager *meshd_activator_dbus_object;
  40
  41 /* global list to care resource handle for each client */
  42 static GList *meshd_dbus_client_list;
  43 static GMutex meshd_dbus_client_list_mutex;
  44
  45 typedef struct _meshd_dbus_client_s {
  46         gchar *bus_name;
  47 } meshd_dbus_client_s;
  48
  49 #define CASE_TO_STR(x) case x: return #x;
  50
  51 /* LCOV_EXCL_START */
  52 static const char* wifi_error_to_string(wifi_manager_error_e err)
  53 {
  54         switch (err) {
  55         /* CHECK: List all enum values here */
  56         CASE_TO_STR(WIFI_MANAGER_ERROR_NONE)
  57         CASE_TO_STR(WIFI_MANAGER_ERROR_INVALID_PARAMETER)
  58         CASE_TO_STR(WIFI_MANAGER_ERROR_OUT_OF_MEMORY)
  59         CASE_TO_STR(WIFI_MANAGER_ERROR_INVALID_OPERATION)
  60         CASE_TO_STR(WIFI_MANAGER_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED)
  61         CASE_TO_STR(WIFI_MANAGER_ERROR_OPERATION_FAILED)
  62         CASE_TO_STR(WIFI_MANAGER_ERROR_NO_CONNECTION)
  63         CASE_TO_STR(WIFI_MANAGER_ERROR_NOW_IN_PROGRESS)
  64         CASE_TO_STR(WIFI_MANAGER_ERROR_ALREADY_EXISTS)
  65         CASE_TO_STR(WIFI_MANAGER_ERROR_OPERATION_ABORTED)
  66         CASE_TO_STR(WIFI_MANAGER_ERROR_DHCP_FAILED)
  67         CASE_TO_STR(WIFI_MANAGER_ERROR_INVALID_KEY)
  68         CASE_TO_STR(WIFI_MANAGER_ERROR_NO_REPLY)
  69         CASE_TO_STR(WIFI_MANAGER_ERROR_SECURITY_RESTRICTED)
  70         CASE_TO_STR(WIFI_MANAGER_ERROR_ALREADY_INITIALIZED)
  71         CASE_TO_STR(WIFI_MANAGER_ERROR_PERMISSION_DENIED)
  72         CASE_TO_STR(WIFI_MANAGER_ERROR_NOT_SUPPORTED)
  73         default :
  74                 return "WIFI_MANAGER_ERROR_UNKNOWN";
  75         }
  76 }
  77 /* LCOV_EXCL_STOP */
  78
  79 NetWmesh* wmeshd_dbus_get_object()
  80 {
  81         return meshd_dbus_object;
  82 }
  83
  84 /* LCOV_EXCL_START */
  85 int64_t wmeshd_dbus_generate_signal_number()
  86 {
  87         static int64_t i = 0;
  88
  89         return i++;
  90 }
  91
  92 static int _wmeshd_dbus_client_list_cleanup(GList *client_list)
  93 {
  94         meshd_dbus_client_s *client;
  95
  96         wmeshd_check_null_ret_error("client_list", client_list, FALSE);
  97
  98         client = client_list->data;
  99
 100         free(client->bus_name);
 101         client->bus_name = NULL;
 102         free(client);
 103         g_list_free(client_list);
 104
 105         return WMESHD_ERROR_NONE;
 106 }
 107
 108 static int _wmeshd_dbus_client_list_compare_bus_name(const void *a, const void *b)
 109 {
 110         const meshd_dbus_client_s *client = a;
 111
 112         return g_strcmp0(client->bus_name, b);
 113 }
 114 /* LCOV_EXCL_STOP */
 115
 116 static inline GList* _wmeshd_dbus_client_list_find_client(const gchar *owner)
 117 {
 118         return g_list_find_custom(meshd_dbus_client_list, owner,
 119                         _wmeshd_dbus_client_list_compare_bus_name);
 120 }
 121
 122 static void _wmeshd_dbus_name_owner_changed_cb(GDBusConnection *conn,
 123                 const gchar *sender_name,
 124                 const gchar *object_path,
 125                 const gchar *interface_name,
 126                 const gchar *signal_name,
 127                 GVariant *parameters,
 128                 gpointer user_data)
 129 {
 130         int ret;
 131         GList *client = NULL;
 132         gchar *name, *old_owner, *new_owner;
 133
 134         NOTUSED(conn);
 135         NOTUSED(sender_name);
 136         NOTUSED(object_path);
 137         NOTUSED(interface_name);
 138         NOTUSED(signal_name);
 139         NOTUSED(user_data);
 140
 141         g_variant_get(parameters, "(&s&s&s)", &name, &old_owner, &new_owner);
 142
 143         if (0 == strlen(new_owner)) {
 144                 g_mutex_lock(&meshd_dbus_client_list_mutex);
 145                 client = _wmeshd_dbus_client_list_find_client(old_owner);
 146                 if (client) { /* found bus name in our bus list */
 147                         /* LCOV_EXCL_START */
 148                         WMESH_LOGD("bus(%s) stopped", old_owner);
 149                         meshd_dbus_client_list = g_list_remove_link(meshd_dbus_client_list, client);
 150                         /* LCOV_EXCL_STOP */
 151                 }
 152                 g_mutex_unlock(&meshd_dbus_client_list_mutex);
 153
 154                 if (client) {
 155                         /* LCOV_EXCL_START */
 156                         ret = _wmeshd_dbus_client_list_cleanup(client);
 157                         if (WMESHD_ERROR_NONE != ret)
 158                                 WMESH_LOGE("_wmeshd_dbus_client_list_cleanup() Fail(%d)", ret);
 159                         /* LCOV_EXCL_STOP */
 160                 }
 161         }
 162 }
 163
 164 static int _wmeshd_dbus_subscribe_name_owner_changed(GDBusConnection *conn)
 165 {
 166         unsigned int id;
 167
 168         id = g_dbus_connection_signal_subscribe(conn,
 169                         "org.freedesktop.DBus", /* bus name */
 170                         "org.freedesktop.DBus", /* interface */
 171                         "NameOwnerChanged", /* member */
 172                         "/org/freedesktop/DBus", /* path */
 173                         NULL, /* arg0 */
 174                         G_DBUS_SIGNAL_FLAGS_NONE,
 175                         _wmeshd_dbus_name_owner_changed_cb,
 176                         NULL,
 177                         NULL);
 178         if (0 == id) {
 179                 /* LCOV_EXCL_START */
 180                 WMESH_LOGE("g_dbus_connection_signal_subscribe() Fail");
 181                 return WMESHD_ERROR_IO_ERROR;
 182                 /* LCOV_EXCL_STOP */
 183         }
 184
 185         return WMESHD_ERROR_NONE;
 186 }
 187
 188 static gboolean _wmeshd_dbus_handle_enable(Manager *object,
 189                 GDBusMethodInvocation *invocation,
 190                 gpointer user_data)
 191 {
 192         int ret = WMESHD_ERROR_NONE;
 193         wmesh_service *service = (wmesh_service *)user_data;
 194         wmesh_interface_s *info = service->interface_info;
 195
 196         wifi_manager_h wifi_handle = NULL;
 197         bool wifi_activated = false;
 198
 199         /* Initialize Wi-Fi driver */
 200         ret = wifi_manager_initialize(&wifi_handle);
 201         if (WIFI_MANAGER_ERROR_NONE != ret) {
 202                 /* LCOV_EXCL_START */
 203                 WMESH_LOGE("Failed to get wifi manager handle ! [%s(%X)]",
 204                         wifi_error_to_string(ret), ret);
 205                 /* LCOV_EXCL_STOP */
 206         }
 207
 208         wifi_manager_is_activated(wifi_handle, &wifi_activated);
 209         if (false == wifi_activated) {
 210                 /* LCOV_EXCL_START */
 211                 ret = wifi_manager_activate(wifi_handle, NULL, NULL);
 212                 if (WIFI_MANAGER_ERROR_NONE != ret)
 213                         WMESH_LOGE("Failed to activate wifi ! [%s(%X)]",
 214                                 wifi_error_to_string(ret), ret);
 215                 /* LCOV_EXCL_STOP */
 216         }
 217         wifi_manager_deinitialize(wifi_handle);
 218
 219         if (service->mesh_activated) {
 220                 /* LCOV_EXCL_START */
 221                 /* Already activated */
 222                 manager_complete_enable(object, invocation, WMESHD_ERROR_NONE);
 223                 goto FINISH;
 224                 /* LCOV_EXCL_STOP */
 225         }
 226
 227         /* Do API response first */
 228         manager_complete_enable(object, invocation, ret);
 229         service->mesh_activated = TRUE;
 230
 231         wmeshd_check_null_ret_error("info", info, FALSE);
 232
 233         /* Register event handler first */
 234         ret = wmesh_request_register_event_handler(service);
 235         if (WMESHD_ERROR_IN_PROGRESS == ret) {
 236                 /* LCOV_EXCL_START */
 237                 WMESH_LOGE("Currently set netlink event handler !! [%d]", ret);
 238                 ret = WMESHD_ERROR_NONE;
 239                 /* LCOV_EXCL_STOP */
 240         } else if (WMESHD_ERROR_NONE != ret) {
 241                 WMESH_LOGE("Failed to register mesh event handler !! [%d]", ret); //LCOV_EXCL_LINE
 242         }
 243
 244         ret = wmesh_interface_initialize(service->interface_info);
 245         if (WMESHD_ERROR_NONE != ret) {
 246                 /* LCOV_EXCL_START */
 247                 WMESH_LOGE("Failed to wmesh_interface_initialize [%d]", ret);
 248                 goto FINISH;
 249                 /* LCOV_EXCL_STOP */
 250         }
 251
 252 FINISH:
 253         net_wmesh_emit_mesh_enabled(wmeshd_dbus_get_object(), ret);
 254
 255         return TRUE;
 256 }
 257
 258 static gboolean _wmeshd_dbus_handle_disable(Manager *object,
 259                 GDBusMethodInvocation *invocation,
 260                 gpointer user_data)
 261 {
 262         int ret = WMESHD_ERROR_NONE;
 263         wmesh_service *service = (wmesh_service *)user_data;
 264         wmesh_interface_s *info = service->interface_info;
 265
 266         wmeshd_check_null_ret_error("info", info, FALSE);
 267
 268         /* Make response first */
 269         manager_complete_disable(object, invocation, ret);
 270
 271         ret = wmesh_request_unregister_event_handler();
 272         if (WMESHD_ERROR_NONE != ret)
 273                 WMESH_LOGE("Failed to unregister mesh event handler !! [%d]", ret); //LCOV_EXCL_LINE
 274
 275         /* Terminate daemon */
 276         wmeshd_service_exit(service);
 277
 278         return TRUE;
 279 }
 280
 281 static gboolean _wmeshd_dbus_handle_scan(NetWmesh *object,
 282                 GDBusMethodInvocation *invocation,
 283                 gpointer user_data)
 284 {
 285         int ret = WMESHD_ERROR_NONE;
 286         wmesh_service *service = (wmesh_service *)user_data;
 287         wmesh_interface_s *info = service->interface_info;
 288
 289         wmeshd_check_null_ret_error("info", info, FALSE);
 290
 291         ret = wmesh_request_scan(service);
 292         if (WMESHD_ERROR_NONE != ret)
 293                 WMESH_LOGE("Failed to wmesh_request_scan !"); //LCOV_EXCL_LINE
 294
 295         net_wmesh_complete_scan(object, invocation, ret);
 296
 297         return TRUE;
 298 }
 299
 300 static gboolean _wmeshd_dbus_handle_specific_scan(NetWmesh *object,
 301                 GDBusMethodInvocation *invocation,
 302                 gchar *mesh_id,
 303                 gint channel,
 304                 gpointer user_data)
 305 {
 306         int ret = WMESHD_ERROR_NONE;
 307         wmesh_service *service = (wmesh_service *)user_data;
 308         wmesh_interface_s *info = service->interface_info;
 309
 310         wmeshd_check_null_ret_error("info", info, FALSE);
 311
 312         ret = wmesh_request_specific_scan(service, mesh_id, channel);
 313         if (WMESHD_ERROR_NONE != ret)
 314                 WMESH_LOGE("Failed to wmesh_request_specific_scan !"); //LCOV_EXCL_LINE
 315
 316         net_wmesh_complete_specific_scan(object, invocation, ret);
 317
 318         return TRUE;
 319 }
 320
 321 static gboolean _wmeshd_dbus_handle_cancel_scan(NetWmesh *object,
 322                 GDBusMethodInvocation *invocation,
 323                 gpointer user_data)
 324 {
 325         int ret = WMESHD_ERROR_NONE;
 326         wmesh_service *service = (wmesh_service *)user_data;
 327
 328         ret = wmesh_request_cancel_scan(service);
 329         if (WMESHD_ERROR_NONE != ret)
 330                 WMESH_LOGE("Failed to wmesh_request_cancel_scan"); //LCOV_EXCL_LINE
 331
 332         net_wmesh_complete_cancel_scan(object, invocation, ret);
 333
 334         return TRUE;
 335 }
 336
 337 /* LCOV_EXCL_START */
 338 static void _on_scan_result_destroy(gpointer data)
 339 {
 340         wmesh_scan_result_s *scan_item = (wmesh_scan_result_s *)data;
 341
 342         if (scan_item) {
 343                 g_free(scan_item->mesh_id);
 344                 g_free(scan_item->bssid);
 345                 g_free(scan_item->object_path);
 346         }
 347         g_free(scan_item);
 348 }
 349
 350 static void _on_peer_info_destroy(gpointer data)
 351 {
 352         wmesh_peer_info_s *peer = (wmesh_peer_info_s *)data;
 353         if (peer)
 354                 g_free(peer->address);
 355         g_free(peer);
 356 }
 357
 358 static void _on_station_list_destroy(gpointer data)
 359 {
 360         wmesh_station_info_s *info = (wmesh_station_info_s*)data;
 361
 362         if (info) {
 363                 g_free(info->bssid);
 364                 g_free(info);
 365         }
 366 }
 367
 368 static void _on_mpath_list_destroy(gpointer data)
 369 {
 370         wmesh_mpath_info_s *info = (wmesh_mpath_info_s*)data;
 371
 372         if (info) {
 373                 g_free(info->dest_addr);
 374                 g_free(info->next_hop);
 375                 g_free(info->interface);
 376                 g_free(info);
 377         }
 378 }
 379 /* LCOV_EXCL_STOP */
 380
 381 static gboolean _wmeshd_dbus_handle_get_found_mesh_networks(NetWmesh *object,
 382                 GDBusMethodInvocation *invocation,
 383                 gpointer user_data)
 384 {
 385         int ret = WMESHD_ERROR_NONE;
 386         wmesh_service *service = (wmesh_service *)user_data;
 387
 388         GVariantBuilder builder;
 389         GVariant* networks;
 390         GList *iter = NULL;
 391         wmesh_scan_result_s *scan_item = NULL;
 392
 393         WMESH_LOGD("Request to get scanned mesh network list");
 394
 395         ret = wmesh_request_get_networks(service);
 396         if (WMESHD_ERROR_NONE != ret)
 397                 WMESH_LOGE("Failed to wmesh_request_get_networks"); //LCOV_EXCL_LINE
 398
 399         g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
 400
 401         /* scanned_mesh_network would be filled above request */
 402         iter = service->scanned_mesh_network;
 403         while (iter != NULL) {
 404                 /* LCOV_EXCL_START */
 405                 scan_item = (wmesh_scan_result_s*)iter->data;
 406
 407                 g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
 408                 g_variant_builder_add(&builder, "{sv}", "mesh_id",
 409                                 g_variant_new_string(scan_item->mesh_id));
 410                 g_variant_builder_add(&builder, "{sv}", "bssid",
 411                                 g_variant_new_string(scan_item->bssid));
 412                 g_variant_builder_add(&builder, "{sv}", "rssi",
 413                                 g_variant_new_int32(scan_item->rssi));
 414                 g_variant_builder_add(&builder, "{sv}", "channel",
 415                                 g_variant_new_uint32(scan_item->channel));
 416                 g_variant_builder_add(&builder, "{sv}", "data_rate",
 417                                 g_variant_new_int32(scan_item->data_rate));
 418                 g_variant_builder_add(&builder, "{sv}", "security",
 419                                 g_variant_new_uint32((int)scan_item->security));
 420                 g_variant_builder_add(&builder, "{sv}", "state",
 421                                 g_variant_new_uint32(scan_item->state));
 422                 g_variant_builder_close(&builder);
 423
 424                 iter = g_list_next(iter);
 425                 /* LCOV_EXCL_STOP */
 426         }
 427
 428         networks = g_variant_builder_end(&builder);
 429
 430         net_wmesh_complete_get_found_mesh_networks(object, invocation, networks, ret);
 431
 432         return TRUE;
 433 }
 434
 435 static gboolean _wmeshd_dbus_handle_enable_mesh(NetWmesh *object,
 436                 GDBusMethodInvocation *invocation,
 437                 gpointer user_data)
 438 {
 439         int ret = WMESHD_ERROR_NONE;
 440         wmesh_service *service = (wmesh_service *)user_data;
 441
 442         /* It handles creating virtual network and bridge */
 443         ret = wmesh_request_enable_network(service);
 444         if (WMESHD_ERROR_NONE != ret)
 445                 WMESH_LOGE("Failed to wmesh_request_enable_network [%d]", ret); //LCOV_EXCL_LINE
 446
 447         wmesh_start_monitor_service(service);
 448
 449         net_wmesh_complete_enable_mesh(object, invocation, ret);
 450
 451         return TRUE;
 452 }
 453
 454 static gboolean _wmeshd_dbus_handle_disable_mesh(NetWmesh *object,
 455                 GDBusMethodInvocation *invocation,
 456                 gpointer user_data)
 457 {
 458         int ret = WMESHD_ERROR_NONE;
 459         wmesh_service *service = (wmesh_service *)user_data;
 460         wmesh_interface_s *info = service->interface_info;
 461
 462         wmeshd_check_null_ret_error("info", info, FALSE);
 463
 464         if (FALSE == service->mesh_activated) {
 465                 /* LCOV_EXCL_START */
 466                 WMESH_LOGD("Mesh network is not activated yet");
 467                 ret = WMESHD_ERROR_OPERATION_FAILED;
 468                 net_wmesh_complete_disable_mesh(object, invocation, ret);
 469                 return TRUE;
 470                 /* LCOV_EXCL_STOP */
 471         }
 472
 473         ret = wmesh_request_disable_network(service);
 474         if (WMESHD_ERROR_NONE != ret)
 475                 WMESH_LOGE("Failed to disable mesh network !"); //LCOV_EXCL_LINE
 476
 477         /* Stop Mesh Node Monitoring Service */
 478         wmesh_stop_monitor_service(service);
 479         /* Make response */
 480         net_wmesh_complete_disable_mesh(object, invocation, ret);
 481
 482         return TRUE;
 483 }
 484
 485 static gboolean _wmeshd_dbus_handle_is_mesh_enabled(NetWmesh *object,
 486                 GDBusMethodInvocation *invocation,
 487                 gpointer user_data)
 488 {
 489         int ret = WMESHD_ERROR_NONE;
 490         gboolean state = TRUE;
 491         wmesh_service *service = (wmesh_service *)user_data;
 492
 493         /* It handles creating virtual network and bridge */
 494         ret = wmesh_interface_check(service->interface_info->mesh_interface);
 495         if (WMESHD_ERROR_NONE != ret) {
 496                 /* LCOV_EXCL_START */
 497                 WMESH_LOGE("Mesh Interface doesn't exists");
 498                 state = FALSE;
 499                 /* LCOV_EXCL_STOP */
 500         }
 501
 502         net_wmesh_complete_is_mesh_enabled(object, invocation, state);
 503
 504         return TRUE;
 505 }
 506
 507 static gboolean _wmeshd_dbus_handle_is_joined(NetWmesh *object,
 508                 GDBusMethodInvocation *invocation,
 509                 gpointer user_data)
 510 {
 511         int ret = WMESHD_ERROR_NONE;
 512         gboolean state = FALSE;
 513         wmesh_service *service = (wmesh_service *)user_data;
 514
 515         ret = wmesh_request_get_joined_network(service);
 516         if (WMESHD_ERROR_NONE == ret) {
 517                 /* LCOV_EXCL_START */
 518                 if (service->joined_network)
 519                         state = TRUE;
 520                 /* LCOV_EXCL_STOP */
 521         }
 522
 523         net_wmesh_complete_is_joined(object, invocation, state, ret);
 524
 525         return TRUE;
 526 }
 527
 528 static gboolean _wmeshd_dbus_handle_get_joined_mesh_network(NetWmesh *object,
 529                 GDBusMethodInvocation *invocation,
 530                 gpointer user_data)
 531 {
 532         int ret = WMESHD_ERROR_NONE;
 533         wmesh_service *service = (wmesh_service *)user_data;
 534         wmesh_network_info_s *joined = NULL;
 535
 536         ret = wmesh_request_get_joined_network(service);
 537         if (WMESHD_ERROR_NONE == ret) {
 538                 joined = service->joined_network;
 539                 if (joined) {
 540                         /* LCOV_EXCL_START */
 541                         net_wmesh_complete_get_joined_mesh_network(object, invocation,
 542                                 joined->mesh_id, joined->bssid,
 543                                 joined->channel, (int)joined->security,
 544                                 joined->state, joined->ipv4_type, joined->ipv4_address,
 545                                 joined->ipv4_netmask, ret);
 546                         /* LCOV_EXCL_STOP */
 547                 } else {
 548                         net_wmesh_complete_get_joined_mesh_network(object, invocation,
 549                                 "", "", 0, 0, 0, 0, "", "", WMESHD_ERROR_NO_DATA); /* LCOV_EXCL_LINE */
 550                 }
 551         } else {
 552                 net_wmesh_complete_get_joined_mesh_network(object, invocation,
 553                         "", "", 0, 0, 0, 0, "", "", ret); /* LCOV_EXCL_LINE */
 554         }
 555
 556         return TRUE;
 557 }
 558
 559 static gboolean _wmeshd_dbus_handle_get_connected_peers(NetWmesh *object,
 560                 GDBusMethodInvocation *invocation,
 561                 gpointer user_data)
 562 {
 563         int ret = WMESHD_ERROR_NONE;
 564         wmesh_service *service = (wmesh_service *)user_data;
 565
 566         GVariantBuilder builder;
 567         GVariant* peer_list;
 568         GList *iter = NULL;
 569         wmesh_peer_info_s *peer = NULL;
 570
 571         WMESH_LOGD("Request to get connected peers");
 572
 573         ret = wmesh_request_get_connected_peers(service);
 574         if (WMESHD_ERROR_NONE != ret)
 575                 WMESH_LOGE("Failed to wmesh_request_get_connected_peers"); //LCOV_EXCL_LINE
 576         g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
 577
 578         iter = service->connected_mesh_peers;
 579         while (iter != NULL) {
 580                 /* LCOV_EXCL_START */
 581                 peer = (wmesh_peer_info_s*)iter->data;
 582
 583                 g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
 584                 g_variant_builder_add(&builder, "{sv}", "Address",
 585                                 g_variant_new_string(peer->address));
 586                 g_variant_builder_close(&builder);
 587
 588                 iter = g_list_next(iter);
 589                 /* LCOV_EXCL_STOP */
 590         }
 591
 592         peer_list = g_variant_builder_end(&builder);
 593
 594         net_wmesh_complete_get_connected_peers(object, invocation, peer_list, ret);
 595
 596         return TRUE;
 597 }
 598
 599 static gboolean _wmeshd_dbus_handle_set_gate(NetWmesh *object,
 600                 GDBusMethodInvocation *invocation, gint16 gate_announce, guint hwmp_root_mode,
 601                 gboolean stp, gpointer user_data)
 602 {
 603         int ret = WMESHD_ERROR_NONE;
 604         wmesh_service *service = (wmesh_service *)user_data;
 605         wmesh_interface_s *info = service->interface_info;
 606
 607         WMESH_LOGD("gate_announce = %d", gate_announce);
 608         WMESH_LOGD("HWMP_Root_Mode = %d", hwmp_root_mode);
 609         WMESH_LOGD("STP = %d", stp);
 610
 611         info->gate_announce = gate_announce;
 612         info->hwmp_root_mode = hwmp_root_mode;
 613         info->stp = stp;
 614
 615         /* Set STP and gate_announce for connmand */
 616         ret = wmesh_gdbus_set_mesh_gate(service);
 617         if (WMESHD_ERROR_NONE != ret)
 618                 WMESH_LOGE("Failed to wmesh_gdbus_set_mesh_gate [%d]", ret); //LCOV_EXCL_LINE
 619
 620         /* Set STP and gate_announce right now */
 621         ret = wmesh_request_set_mesh_gate(info->bridge_interface,
 622                         info->mesh_interface, info->external_interface);
 623         if (WMESHD_ERROR_NONE != ret)
 624                 WMESH_LOGE("Failed to wmesh_gdbus_set_mesh_gate [%d]", ret); //LCOV_EXCL_LINE
 625
 626
 627         net_wmesh_complete_set_gate(object, invocation, ret);
 628
 629         return TRUE;
 630 }
 631
 632 static gboolean _wmeshd_dbus_handle_unset_gate(NetWmesh *object,
 633                 GDBusMethodInvocation *invocation,
 634                 gpointer user_data)
 635 {
 636         int ret = WMESHD_ERROR_NONE;
 637         wmesh_service *service = (wmesh_service *)user_data;
 638         wmesh_interface_s *info = service->interface_info;
 639
 640         info->gate_announce = 0;
 641         info->hwmp_root_mode = 0;
 642         info->stp = 0;
 643
 644         /* Set STP and gate_announce for connmand */
 645         ret = wmesh_gdbus_set_mesh_gate(service);
 646         if (WMESHD_ERROR_NONE != ret)
 647                 WMESH_LOGE("Failed to wmesh_gdbus_set_mesh_gate [%d]", ret); //LCOV_EXCL_LINE
 648
 649         /* Unset STP and Gate Annouce right now */
 650         ret = wmesh_request_unset_mesh_gate(info->bridge_interface,
 651                         info->mesh_interface, info->external_interface);
 652         if (WMESHD_ERROR_NONE != ret)
 653                 WMESH_LOGE("Failed to wmesh_request_unset_mesh_gate [%d]", ret); //LCOV_EXCL_LINE
 654
 655         net_wmesh_complete_unset_gate(object, invocation, ret);
 656
 657         return TRUE;
 658 }
 659
 660 static gboolean _wmeshd_dbus_handle_set_softap(NetWmesh *object,
 661                 GDBusMethodInvocation *invocation,
 662                 gchar *ssid, gchar *passphrase,
 663                 gchar *mode, gint channel, gint visibility, gint max_sta,
 664                 gint security, gpointer user_data)
 665 {
 666         int ret = WMESHD_ERROR_NONE;
 667         wmesh_service *service = (wmesh_service *)user_data;
 668         wmesh_interface_s *info = service->interface_info;
 669
 670         WMESH_LOGD("SSID      : %s", ssid);
 671         WMESH_LOGD("mode      : %s", mode);
 672         WMESH_LOGD("channel   : %d", channel);
 673         WMESH_LOGD("visibility: %d", visibility);
 674         WMESH_LOGD("max_sta   : %d", max_sta);
 675         WMESH_LOGD("security  : %d", security);
 676
 677         /* Save softAP information */
 678         ret = wmesh_request_set_softap_config(info->softap_interface,
 679                 ssid, mode, channel, visibility, max_sta,
 680                 security, passphrase);
 681         if (WMESHD_ERROR_NONE != ret)
 682                 WMESH_LOGE("Failed to wmesh_request_set_softap_config [%d]", ret); //LCOV_EXCL_LINE
 683
 684         net_wmesh_complete_set_softap(object, invocation, ret);
 685
 686         return TRUE;
 687 }
 688
 689 static gboolean _wmeshd_dbus_handle_get_softap(NetWmesh *object,
 690                 GDBusMethodInvocation *invocation, gpointer user_data)
 691 {
 692         int ret = WMESHD_ERROR_NONE;
 693         wmesh_service *service = (wmesh_service *)user_data;
 694         char *interface, *ssid, *mode, *passphrase;
 695         int channel, visibility, max_sta, security;
 696         (void) service; // unused
 697
 698         /* Get softAP information */
 699         ret = wmesh_request_get_softap_config(&interface, &ssid, &mode, &channel,
 700                                                 &visibility, &max_sta, &security, &passphrase);
 701         if (WMESHD_ERROR_NONE != ret) {
 702                 /* LCOV_EXCL_START */
 703                 WMESH_LOGE("Failed to wmesh_request_get_softap_config [%d]", ret);
 704                 net_wmesh_complete_get_softap(object, invocation, "", "", 0, 0, 0, 0,
 705                                                                 "", ret);
 706                 return FALSE;
 707                 /* LCOV_EXCL_STOP */
 708         }
 709
 710         WMESH_LOGD("SSID      : %s", ssid);
 711         WMESH_LOGD("mode      : %s", mode);
 712         WMESH_LOGD("channel   : %d", channel);
 713         WMESH_LOGD("visibility: %d", visibility);
 714         WMESH_LOGD("max_sta   : %d", max_sta);
 715         WMESH_LOGD("security  : %d", security);
 716         WMESH_LOGD("Passphrase  : %s", passphrase ? passphrase : "NULL");
 717
 718         if (security == 1)
 719                 net_wmesh_complete_get_softap(object, invocation, ssid, mode, channel,
 720                                                                 visibility, max_sta, security, passphrase, ret); /* LCOV_EXCL_LINE */
 721         else
 722                 net_wmesh_complete_get_softap(object, invocation, ssid, mode, channel,
 723                                                                 visibility, max_sta, security, "", ret); /* LCOV_EXCL_LINE */
 724
 725         return TRUE;
 726 }
 727
 728 static gboolean _wmeshd_dbus_handle_enable_softap(NetWmesh *object,
 729                 GDBusMethodInvocation *invocation, gpointer user_data)
 730 {
 731         int ret = WMESHD_ERROR_NONE;
 732         wmesh_service *service = (wmesh_service *)user_data;
 733         wmesh_interface_s *info = service->interface_info;
 734
 735         /* Check softAP interface and execute it */
 736         ret = wmesh_request_enable_softap(info->bridge_interface, info->softap_interface);
 737         if (WMESHD_ERROR_NONE != ret)
 738                 WMESH_LOGE("Failed to wmesh_request_enable_softap [%d]", ret); //LCOV_EXCL_LINE
 739
 740         net_wmesh_complete_enable_softap(object, invocation, ret);
 741
 742         return TRUE;
 743 }
 744
 745 static gboolean _wmeshd_dbus_handle_disable_softap(NetWmesh *object,
 746                 GDBusMethodInvocation *invocation, gpointer user_data)
 747 {
 748         int ret = WMESHD_ERROR_NONE;
 749         wmesh_service *service = (wmesh_service *)user_data;
 750         wmesh_interface_s *info = service->interface_info;
 751
 752         /* Destroy softAP */
 753         ret = wmesh_request_disable_softap(info->bridge_interface, info->softap_interface);
 754         if (WMESHD_ERROR_NONE != ret)
 755                 WMESH_LOGE("Failed to wmesh_request_disable_softap [%d]", ret); //LCOV_EXCL_LINE
 756
 757         net_wmesh_complete_disable_softap(object, invocation, ret);
 758
 759         return TRUE;
 760 }
 761
 762 static gboolean _wmeshd_dbus_handle_is_softap_enabled(NetWmesh *object,
 763                 GDBusMethodInvocation *invocation, gpointer user_data)
 764 {
 765         bool status;
 766         (void) user_data;
 767
 768         /* Check SoftAP status */
 769         status = wmesh_request_check_softap_status();
 770         WMESH_LOGD("SoftAP is %s", status ? "enabled" : "disabled");
 771
 772         net_wmesh_complete_is_softap_enabled(object, invocation, status);
 773
 774         return TRUE;
 775 }
 776
 777 static gboolean _wmeshd_dbus_handle_create_mesh_network(NetWmesh *object,
 778                 GDBusMethodInvocation *invocation,
 779                 gchar *mesh_id, gint channel, gint security,
 780                 gpointer user_data)
 781 {
 782         int ret = WMESHD_ERROR_NONE;
 783         wmesh_service *service = (wmesh_service *)user_data;
 784         wmeshd_security_type_e sec = (1 == security) ? WMESHD_SECURITY_SAE : WMESHD_SECURITY_NONE;
 785
 786         ret = wmesh_request_create_mesh_network(service, mesh_id, channel, sec);
 787
 788         net_wmesh_complete_create_mesh_network(object, invocation, ret);
 789
 790         return TRUE;
 791 }
 792
 793 static gboolean _wmeshd_dbus_handle_connect_mesh_network(NetWmesh *object,
 794                 GDBusMethodInvocation *invocation,
 795                 gchar *mesh_id, gint channel, gint security, gchar *passphrase,
 796                 gpointer user_data)
 797 {
 798         int ret = WMESHD_ERROR_NONE;
 799         wmesh_service *service = (wmesh_service *)user_data;
 800         wmeshd_security_type_e sec = (1 == security) ? WMESHD_SECURITY_SAE : WMESHD_SECURITY_NONE;
 801
 802         ret = wmesh_request_connect_mesh_network(service, mesh_id, channel, sec, passphrase);
 803
 804         net_wmesh_complete_connect_mesh_network(object, invocation, ret);
 805
 806         return TRUE;
 807 }
 808 static gboolean _wmeshd_dbus_handle_disconnect_mesh_network(NetWmesh *object,
 809                 GDBusMethodInvocation *invocation,
 810                 gchar *mesh_id, gint channel, gint security,
 811                 gpointer user_data)
 812 {
 813         int ret = WMESHD_ERROR_NONE;
 814         wmesh_service *service = (wmesh_service *)user_data;
 815         wmeshd_security_type_e sec = (1 == security) ? WMESHD_SECURITY_SAE : WMESHD_SECURITY_NONE;
 816
 817         ret = wmesh_request_disconnect_mesh_network(service, mesh_id, channel, sec);
 818
 819         net_wmesh_complete_disconnect_mesh_network(object, invocation, ret);
 820
 821         return TRUE;
 822 }
 823
 824 static gboolean _wmeshd_dbus_handle_forget_mesh_network(NetWmesh *object,
 825                 GDBusMethodInvocation *invocation,
 826                 gchar *mesh_id, gint channel, gint security,
 827                 gpointer user_data)
 828 {
 829         int ret = WMESHD_ERROR_NONE;
 830         wmesh_service *service = (wmesh_service *)user_data;
 831         wmeshd_security_type_e sec = (1 == security) ? WMESHD_SECURITY_SAE : WMESHD_SECURITY_NONE;
 832
 833         ret = wmesh_request_remove_mesh_network(service, mesh_id, channel, sec);
 834
 835         net_wmesh_complete_forget_mesh_network(object, invocation, ret);
 836
 837         return TRUE;
 838 }
 839
 840 static gboolean _wmeshd_dbus_handle_set_interfaces(NetWmesh *object,
 841                 GDBusMethodInvocation *invocation,
 842                 gchar *mesh, gchar *gate, gchar *softap,
 843                 gpointer user_data)
 844 {
 845         int ret = WMESHD_ERROR_NONE;
 846         wmesh_service *service = (wmesh_service *)user_data;
 847         wmesh_interface_s *info = service->interface_info;
 848
 849         g_free(info->mesh_interface);
 850         info->mesh_interface = g_strdup(mesh);
 851
 852         g_free(info->external_interface);
 853         info->external_interface = g_strdup(gate);
 854
 855         g_free(info->softap_interface);
 856         info->softap_interface = g_strdup(softap);
 857
 858         WMESH_LOGD("Interface configuration for mesh network :");
 859         WMESH_LOGD("  Base    : [%s]", info->base_interface);
 860         WMESH_LOGD("  Mesh    : [%s]", info->mesh_interface);
 861         WMESH_LOGD("  Bridge  : [%s]", info->bridge_interface);
 862         WMESH_LOGD("  SoftAP  : [%s]", info->softap_interface);
 863         WMESH_LOGD("  External: [%s]", info->external_interface);
 864
 865         net_wmesh_complete_set_interfaces(object, invocation, ret);
 866
 867         return TRUE;
 868 }
 869
 870 static gboolean _wmeshd_dbus_handle_get_station_info(NetWmesh *object,
 871                 GDBusMethodInvocation *invocation, gint station_type,
 872                 gpointer user_data)
 873 {
 874         int ret = WMESHD_ERROR_NONE;
 875
 876         GVariantBuilder builder;
 877         GVariant* station;
 878         GList *iter = NULL;
 879
 880         wmesh_service *service = (wmesh_service *)user_data;
 881         wmesh_interface_s *info = service->interface_info;
 882
 883         if (station_type == WMESHD_STATION_TYPE_MESH_POINT) {
 884                 /* LCOV_EXCL_START */
 885                 /* Clear mesh station list */
 886                 g_list_free_full(service->station_list, _on_station_list_destroy);
 887                 service->station_list = NULL;
 888
 889                 ret = wmesh_request_get_station_info(
 890                                                                 info->mesh_interface, &service->station_list);
 891         } else if (station_type == WMESHD_STATION_TYPE_SOFTAP) {
 892                 /* Clear softAP station list */
 893                 g_list_free_full(service->softap_station_list,
 894                                                  _on_station_list_destroy);
 895                 service->softap_station_list = NULL;
 896
 897                 ret = wmesh_request_get_station_info(
 898                                                                 info->softap_interface,
 899                                                                 &service->softap_station_list);
 900         } else {
 901                 WMESH_LOGE("Invalid station type");
 902
 903                 g_dbus_method_invocation_return_error(invocation,
 904                                 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Invalid station type");
 905
 906                 return FALSE;
 907                 /* LCOV_EXCL_STOP */
 908         }
 909
 910         if (WMESHD_ERROR_NONE != ret) {
 911                 /* LCOV_EXCL_START */
 912                 WMESH_LOGE("Failed to wmesh_request_get_station_info");
 913
 914                 g_dbus_method_invocation_return_error(invocation,
 915                                 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
 916                 /* LCOV_EXCL_STOP */
 917         } else {
 918                 /*
 919                  * sh-3.2#  iw mesh0 station dump
 920                  * Station 7c:dd:90:62:37:cf (on mesh0)
 921                  * inactive time:       1685 ms
 922                  * rx bytes:    34174
 923                  * rx packets:  1181
 924                  * tx bytes:    6877
 925                  * tx packets:  76
 926                  * tx retries:  0
 927                  * tx failed:   0
 928                  * beacon loss: 0
 929                  * signal:              -64 dBm
 930                  * signal avg:  -63 dBm
 931                  * tx bitrate:  54.0 MBit/s
 932                  * rx bitrate:  5.5 MBit/s
 933                  * mesh llid:   51731
 934                  * mesh plid:   35432
 935                  * mesh plink:  ESTAB
 936                  * mesh local PS mode:  ACTIVE
 937                  * mesh peer PS mode:   ACTIVE
 938                  * mesh non-peer PS mode:       ACTIVE
 939                  * authorized:  yes
 940                  * authenticated:       yes
 941                  * associated:  yes
 942                  * preamble:    long
 943                  * WMM/WME:     yes
 944                  * MFP:         no
 945                  * TDLS peer:   no
 946                  * DTIM period: 0
 947                  * beacon interval:1000
 948                  * short slot time:yes
 949                  * connected time:      256 seconds
 950                  */
 951
 952                 /* LCOV_EXCL_START */
 953                 /* Get station information and make variant data */
 954                 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
 955
 956                 if (station_type == WMESHD_STATION_TYPE_MESH_POINT)
 957                         iter = service->station_list;
 958                 else
 959                         iter = service->softap_station_list;
 960
 961                 while (iter != NULL) {
 962                         wmesh_station_info_s *item = (wmesh_station_info_s*)iter->data;
 963
 964                         g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
 965                         g_variant_builder_add(&builder, "{sv}", "bssid",
 966                                                 g_variant_new_string(item->bssid));
 967                         g_variant_builder_add(&builder, "{sv}", "inactive_time",
 968                                                 g_variant_new_uint32(item->inactive_time));
 969                         g_variant_builder_add(&builder, "{sv}", "rx_bytes",
 970                                                 g_variant_new_uint64(item->rx_bytes));
 971                         g_variant_builder_add(&builder, "{sv}", "rx_packets",
 972                                                 g_variant_new_uint32(item->rx_packets));
 973                         g_variant_builder_add(&builder, "{sv}", "tx_bytes",
 974                                                 g_variant_new_uint64(item->tx_bytes));
 975                         g_variant_builder_add(&builder, "{sv}", "tx_packets",
 976                                                 g_variant_new_uint32(item->tx_packets));
 977                         g_variant_builder_add(&builder, "{sv}", "tx_retries",
 978                                                 g_variant_new_uint32(item->tx_retries));
 979                         g_variant_builder_add(&builder, "{sv}", "tx_failed",
 980                                                 g_variant_new_uint32(item->tx_failed));
 981                         g_variant_builder_add(&builder, "{sv}", "beacon_loss",
 982                                                 g_variant_new_uint32(item->beacon_loss));
 983                         g_variant_builder_add(&builder, "{sv}", "beacon_rx",
 984                                                 g_variant_new_uint64(item->beacon_rx));
 985                         g_variant_builder_add(&builder, "{sv}", "rx_drop_misc",
 986                                                 g_variant_new_uint64(item->rx_drop_misc));
 987                         g_variant_builder_add(&builder, "{sv}", "signal",
 988                                                 g_variant_new_int32(item->rssi));
 989                         g_variant_builder_add(&builder, "{sv}", "signal_avg",
 990                                                 g_variant_new_int32(item->rssi_avg));
 991                         g_variant_builder_add(&builder, "{sv}", "tx_bitrate",
 992                                                 g_variant_new_uint32(item->tx_bitrate)); /* 10 times */
 993                         g_variant_builder_add(&builder, "{sv}", "rx_bitrate",
 994                                                 g_variant_new_uint32(item->rx_bitrate)); /* 10 times */
 995                         if (station_type == WMESHD_STATION_TYPE_MESH_POINT) {
 996                                 g_variant_builder_add(&builder, "{sv}", "mesh_llid",
 997                                                                 g_variant_new_uint16(item->llid));
 998                                 g_variant_builder_add(&builder, "{sv}", "mesh_plid",
 999                                                                 g_variant_new_uint16(item->plid));
1000                                 g_variant_builder_add(&builder, "{sv}", "mesh_plink",
1001                                                                 g_variant_new_byte(item->mesh_plink)); /* 0 : DISCON, 1 : ESTAB */
1002                                 g_variant_builder_add(&builder, "{sv}", "local_ps_mode",
1003                                                                 g_variant_new_uint32(item->local_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
1004                                 g_variant_builder_add(&builder, "{sv}", "peer_ps_mode",
1005                                                                 g_variant_new_uint32(item->peer_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
1006                                 g_variant_builder_add(&builder, "{sv}", "non_peer_ps_mode",
1007                                                                 g_variant_new_uint32(item->non_peer_ps_mode)); /* 0 : INACTIVE, 1 : ACTIVE */
1008                         }
1009                         g_variant_builder_add(&builder, "{sv}", "authorized",
1010                                                 g_variant_new_boolean(item->authorized));
1011                         g_variant_builder_add(&builder, "{sv}", "authenticated",
1012                                                 g_variant_new_boolean(item->authenticated));
1013                         g_variant_builder_add(&builder, "{sv}", "associated",
1014                                                 g_variant_new_boolean(item->associated));
1015                         g_variant_builder_add(&builder, "{sv}", "preamble",
1016                                                 g_variant_new_boolean(item->preamble));
1017                         g_variant_builder_add(&builder, "{sv}", "WMM_WME",
1018                                                 g_variant_new_boolean(item->wme));
1019                         g_variant_builder_add(&builder, "{sv}", "MFP",
1020                                                 g_variant_new_boolean(item->mfp));
1021                         g_variant_builder_add(&builder, "{sv}", "TDLS_peer",
1022                                                 g_variant_new_boolean(item->tdls_peer));
1023                         g_variant_builder_add(&builder, "{sv}", "DTIM_period",
1024                                                 g_variant_new_byte(item->dtim_period));
1025                         g_variant_builder_add(&builder, "{sv}", "beacon_interval",
1026                                                 g_variant_new_uint16(item->beacon_interval));
1027                         g_variant_builder_add(&builder, "{sv}", "short_slot_time",
1028                                                 g_variant_new_boolean(item->short_slot_time));
1029                         g_variant_builder_add(&builder, "{sv}", "connected_time",
1030                                                 g_variant_new_uint32(item->connected_time));
1031                         g_variant_builder_close(&builder);
1032
1033                         iter = g_list_next(iter);
1034                 }
1035
1036                 station = g_variant_builder_end(&builder);
1037                 net_wmesh_complete_get_station_info(object, invocation, station, ret);
1038
1039                 g_object_unref(station);
1040         }
1041         /* LCOV_EXCL_STOP */
1042
1043         return TRUE;
1044 }
1045
1046 static gboolean _wmeshd_dbus_handle_get_mpath_info(NetWmesh *object,
1047                 GDBusMethodInvocation *invocation,
1048                 gpointer user_data)
1049 {
1050         int ret = WMESHD_ERROR_NONE;
1051         GVariantBuilder builder;
1052         GVariant* mpath_data;
1053         GList *iter = NULL;
1054
1055         wmesh_service *service = (wmesh_service *)user_data;
1056         wmesh_interface_s *info = service->interface_info;
1057
1058         /* Clear mesh path list */
1059         g_list_free_full(service->mpath_list, _on_mpath_list_destroy);
1060         service->mpath_list = NULL;
1061
1062         ret = wmesh_request_get_mpath_info(
1063                                 info->mesh_interface, &service->mpath_list);
1064         if (WMESHD_ERROR_NONE != ret) {
1065                 /* LCOV_EXCL_START */
1066                 WMESH_LOGE("Failed to wmesh_request_get_mpath_info");
1067
1068                 g_dbus_method_invocation_return_error(invocation,
1069                                 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
1070                 /* LCOV_EXCL_STOP */
1071         } else {
1072                 /*
1073                  * Example) sh-3.2# iw mesh0 mpath dump
1074                  * DEST ADDR         NEXT HOP          IFACE    SN      METRIC  QLEN    EXPTIME         DTIM    DRET    FLAGS
1075                  * 7c:dd:90:62:37:cf 7c:dd:90:62:37:cf mesh0    221     152             0               10                      100             0               0x5
1076                  */
1077
1078                 /* LCOV_EXCL_START */
1079                 /* Get mesh path information and make variant data */
1080                 g_variant_builder_init(&builder, G_VARIANT_TYPE("aa{sv}"));
1081
1082                 iter = service->mpath_list;
1083                 while (iter != NULL) {
1084                         wmesh_mpath_info_s *item = (wmesh_mpath_info_s*)iter->data;
1085
1086                         g_variant_builder_open(&builder, G_VARIANT_TYPE_VARDICT);
1087                         g_variant_builder_add(&builder, "{sv}", "DEST_ADDR",
1088                                                 g_variant_new_string(item->dest_addr));
1089                         g_variant_builder_add(&builder, "{sv}", "NEXT_HOP",
1090                                                 g_variant_new_string(item->next_hop));
1091                         g_variant_builder_add(&builder, "{sv}", "IFACE",
1092                                                 g_variant_new_string(item->interface));
1093                         g_variant_builder_add(&builder, "{sv}", "SN",
1094                                                 g_variant_new_uint32(item->sn));
1095                         g_variant_builder_add(&builder, "{sv}", "METRIC",
1096                                                 g_variant_new_uint32(item->metric));
1097                         g_variant_builder_add(&builder, "{sv}", "QLEN",
1098                                                 g_variant_new_uint32(item->qlen));
1099                         g_variant_builder_add(&builder, "{sv}", "EXPTIME",
1100                                                 g_variant_new_uint32(item->exptime));
1101                         g_variant_builder_add(&builder, "{sv}", "DTIM",
1102                                                 g_variant_new_uint32(item->discovery_timeout));
1103                         g_variant_builder_add(&builder, "{sv}", "DRET",
1104                                                 g_variant_new_byte(item->discovery_retries));
1105                         g_variant_builder_add(&builder, "{sv}", "FLAGS",
1106                                                 g_variant_new_byte(item->flags));
1107                         g_variant_builder_close(&builder);
1108
1109                         iter = g_list_next(iter);
1110                 }
1111
1112                 mpath_data = g_variant_builder_end(&builder);
1113                 net_wmesh_complete_get_mpath_info(object, invocation, mpath_data, ret);
1114
1115                 g_object_unref(mpath_data);
1116                 /* LCOV_EXCL_STOP */
1117         }
1118
1119         return TRUE;
1120 }
1121
1122 static gboolean _wmeshd_dbus_handle_get_meshconf_info(NetWmesh *object,
1123                 GDBusMethodInvocation *invocation,
1124                 gpointer user_data)
1125 {
1126         int ret = WMESHD_ERROR_NONE;
1127         GVariantBuilder builder;
1128         GVariant* meshconf_data;
1129         wmesh_meshconf_info_s *item;
1130
1131         wmesh_service *service = (wmesh_service *)user_data;
1132
1133         ret = wmesh_request_get_meshconf_info(service);
1134         if (WMESHD_ERROR_NONE != ret) {
1135                 /* LCOV_EXCL_START */
1136                 WMESH_LOGE("Failed to wmesh_request_get_mpath_info");
1137
1138                 g_dbus_method_invocation_return_error(invocation,
1139                                 G_DBUS_ERROR, G_DBUS_ERROR_FAILED, "Request Failed");
1140                 /* LCOV_EXCL_STOP */
1141         } else {
1142                 /* Get mesh path information and make variant data */
1143                 g_variant_builder_init(&builder, G_VARIANT_TYPE("a{sv}"));
1144
1145                 item = service->meshconf;
1146
1147                 g_variant_builder_add(&builder, "{sv}", "RETRY_TIMEOUT",
1148                                                           g_variant_new_uint16(item->retry_timeout));
1149                 g_variant_builder_add(&builder, "{sv}", "HWMP_MAX_PREQ_RETRIES",
1150                                                         g_variant_new_byte(item->hwmp_max_preq_retries));
1151                 g_variant_builder_add(&builder, "{sv}", "CONFIRM_TIMEOUT",
1152                                                           g_variant_new_uint16(item->confirm_timeout));
1153                 g_variant_builder_add(&builder, "{sv}", "PATH_REFRESH_TIME",
1154                                                           g_variant_new_uint32(item->path_refresh_time));
1155                 g_variant_builder_add(&builder, "{sv}", "HOLDING_TIMEOUT",
1156                                                           g_variant_new_uint16(item->holding_timeout));
1157                 g_variant_builder_add(&builder, "{sv}", "MIN_DISC_TIMEOUT",
1158                                                           g_variant_new_uint16(item->min_disc_timeout));
1159                 g_variant_builder_add(&builder, "{sv}", "MAX_PEER_LINKS",
1160                                                           g_variant_new_uint16(item->max_peer_links));
1161                 g_variant_builder_add(&builder, "{sv}", "HWMP_PREQ_MIN_INTERVAL",
1162                                                         g_variant_new_uint16(item->hwmp_preq_min_interval));
1163                 g_variant_builder_add(&builder, "{sv}", "TTL",
1164                                                           g_variant_new_byte(item->ttl));
1165                 g_variant_builder_add(&builder, "{sv}", "HWMP_ACTIVE_PATH_TIMEOUT",
1166                                                 g_variant_new_uint32(item->hwmp_active_path_timeout));
1167                 g_variant_builder_add(&builder, "{sv}", "ELEMENT_TTL",
1168                                                           g_variant_new_byte(item->element_ttl));
1169                 g_variant_builder_add(&builder, "{sv}", "HWMP_RANN_INTERVAL",
1170                                                           g_variant_new_uint16(item->hwmp_rann_interval));
1171                 g_variant_builder_add(&builder, "{sv}", "GATE_ANNOUNCEMENTS",
1172                                                           g_variant_new_byte(item->gate_announcements));
1173
1174
1175                 meshconf_data = g_variant_builder_end(&builder);
1176                 net_wmesh_complete_get_meshconf_info(object, invocation, meshconf_data,
1177                                                                         ret);
1178
1179                 g_object_unref(meshconf_data);
1180         }
1181
1182         g_free(service->meshconf);
1183
1184         return TRUE;
1185 }
1186
1187 static void _wmeshd_dbus_on_activator_bus_acquired(GDBusConnection *conn,
1188                 const gchar *name, gpointer user_data)
1189 {
1190         gboolean ret;
1191         GError *error = NULL;
1192         wmesh_service *service = (wmesh_service *)user_data;
1193
1194         NOTUSED(name);
1195
1196         meshd_activator_dbus_object = manager_skeleton_new();
1197         if (NULL == meshd_activator_dbus_object) {
1198                 /* LCOV_EXCL_START */
1199                 WMESH_LOGE("manager_skeleton_new() Fail");
1200                 return;
1201                 /* LCOV_EXCL_STOP */
1202         }
1203
1204         g_signal_connect(meshd_activator_dbus_object, "handle-enable",
1205                         G_CALLBACK(_wmeshd_dbus_handle_enable), service);
1206         g_signal_connect(meshd_activator_dbus_object, "handle-disable",
1207                         G_CALLBACK(_wmeshd_dbus_handle_disable), service);
1208
1209         ret = g_dbus_interface_skeleton_export(
1210                                 G_DBUS_INTERFACE_SKELETON(meshd_activator_dbus_object),
1211                                 conn, WMESH_DBUS_MANAGER_OBJPATH, &error);
1212         if (FALSE == ret) {
1213                 /* LCOV_EXCL_START */
1214                 WMESH_LOGE("g_dbus_interface_skeleton_export() Fail(%s)", error->message);
1215                 g_error_free(error);
1216                 /* LCOV_EXCL_STOP */
1217         }
1218 }
1219
1220 static void _wmeshd_dbus_on_bus_acquired(GDBusConnection *conn, const gchar *name,
1221                 gpointer user_data)
1222 {
1223         gboolean ret;
1224         GError *error = NULL;
1225         wmesh_service *service = (wmesh_service *)user_data;
1226
1227         NOTUSED(name);
1228
1229         meshd_dbus_object = net_wmesh_skeleton_new();
1230         if (NULL == meshd_dbus_object) {
1231                 /* LCOV_EXCL_START */
1232                 WMESH_LOGE("net_wmesh_skeleton_new() Fail");
1233                 return;
1234                 /* LCOV_EXCL_STOP */
1235         }
1236
1237         g_signal_connect(meshd_dbus_object, "handle-scan",
1238                         G_CALLBACK(_wmeshd_dbus_handle_scan), service);
1239         g_signal_connect(meshd_dbus_object, "handle-specific-scan",
1240                         G_CALLBACK(_wmeshd_dbus_handle_specific_scan), service);
1241         g_signal_connect(meshd_dbus_object, "handle-cancel-scan",
1242                         G_CALLBACK(_wmeshd_dbus_handle_cancel_scan), service);
1243         g_signal_connect(meshd_dbus_object, "handle-get-found-mesh-networks",
1244                         G_CALLBACK(_wmeshd_dbus_handle_get_found_mesh_networks), service);
1245         g_signal_connect(meshd_dbus_object, "handle-enable-mesh",
1246                         G_CALLBACK(_wmeshd_dbus_handle_enable_mesh), service);
1247         g_signal_connect(meshd_dbus_object, "handle-disable-mesh",
1248                         G_CALLBACK(_wmeshd_dbus_handle_disable_mesh), service);
1249         g_signal_connect(meshd_dbus_object, "handle-is-mesh-enabled",
1250                         G_CALLBACK(_wmeshd_dbus_handle_is_mesh_enabled), service);
1251         g_signal_connect(meshd_dbus_object, "handle-is-joined",
1252                         G_CALLBACK(_wmeshd_dbus_handle_is_joined), service);
1253         g_signal_connect(meshd_dbus_object, "handle-get-joined-mesh-network",
1254                         G_CALLBACK(_wmeshd_dbus_handle_get_joined_mesh_network), service);
1255         g_signal_connect(meshd_dbus_object, "handle-get-connected-peers",
1256                         G_CALLBACK(_wmeshd_dbus_handle_get_connected_peers), service);
1257         g_signal_connect(meshd_dbus_object, "handle-set-gate",
1258                         G_CALLBACK(_wmeshd_dbus_handle_set_gate), service);
1259         g_signal_connect(meshd_dbus_object, "handle-unset-gate",
1260                         G_CALLBACK(_wmeshd_dbus_handle_unset_gate), service);
1261         g_signal_connect(meshd_dbus_object, "handle-set-softap",
1262                         G_CALLBACK(_wmeshd_dbus_handle_set_softap), service);
1263         g_signal_connect(meshd_dbus_object, "handle-get-softap",
1264                         G_CALLBACK(_wmeshd_dbus_handle_get_softap), service);
1265         g_signal_connect(meshd_dbus_object, "handle-enable-softap",
1266                         G_CALLBACK(_wmeshd_dbus_handle_enable_softap), service);
1267         g_signal_connect(meshd_dbus_object, "handle-disable-softap",
1268                         G_CALLBACK(_wmeshd_dbus_handle_disable_softap), service);
1269         g_signal_connect(meshd_dbus_object, "handle-is-softap-enabled",
1270                         G_CALLBACK(_wmeshd_dbus_handle_is_softap_enabled), NULL);
1271         g_signal_connect(meshd_dbus_object, "handle-create-mesh-network",
1272                         G_CALLBACK(_wmeshd_dbus_handle_create_mesh_network), service);
1273         g_signal_connect(meshd_dbus_object, "handle-connect-mesh-network",
1274                         G_CALLBACK(_wmeshd_dbus_handle_connect_mesh_network), service);
1275         g_signal_connect(meshd_dbus_object, "handle-disconnect-mesh-network",
1276                         G_CALLBACK(_wmeshd_dbus_handle_disconnect_mesh_network), service);
1277         g_signal_connect(meshd_dbus_object, "handle-forget-mesh-network",
1278                         G_CALLBACK(_wmeshd_dbus_handle_forget_mesh_network), service);
1279         g_signal_connect(meshd_dbus_object, "handle-set-interfaces",
1280                         G_CALLBACK(_wmeshd_dbus_handle_set_interfaces), service);
1281         g_signal_connect(meshd_dbus_object, "handle-get-station-info",
1282                         G_CALLBACK(_wmeshd_dbus_handle_get_station_info), service);
1283         g_signal_connect(meshd_dbus_object, "handle-get-mpath-info",
1284                         G_CALLBACK(_wmeshd_dbus_handle_get_mpath_info), service);
1285         g_signal_connect(meshd_dbus_object, "handle-get-meshconf-info",
1286                         G_CALLBACK(_wmeshd_dbus_handle_get_meshconf_info), service);
1287
1288         ret = g_dbus_interface_skeleton_export(G_DBUS_INTERFACE_SKELETON(meshd_dbus_object),
1289                         conn, WMESH_DBUS_OBJPATH, &error);
1290         if (FALSE == ret) {
1291                 /* LCOV_EXCL_START */
1292                 WMESH_LOGE("g_dbus_interface_skeleton_export() Fail(%s)", error->message);
1293                 g_error_free(error);
1294                 /* LCOV_EXCL_STOP */
1295         }
1296
1297         ret = _wmeshd_dbus_subscribe_name_owner_changed(conn);
1298         if (WMESHD_ERROR_NONE != ret) {
1299                 /* LCOV_EXCL_START */
1300                 WMESH_LOGE("_wmeshd_dbus_subscribe_name_owner_changed() Fail(%d)", ret);
1301                 return;
1302                 /* LCOV_EXCL_STOP */
1303         }
1304 }
1305
1306 /* LCOV_EXCL_START */
1307 static void _wmeshd_dbus_on_name_lost(GDBusConnection *conn, const gchar *name,
1308                 gpointer user_data)
1309 {
1310         NOTUSED(conn);
1311         NOTUSED(user_data);
1312
1313         WMESH_LOGD("Lost the name %s", name);
1314 }
1315 /* LCOV_EXCL_STOP */
1316
1317 static void _wmeshd_dbus_on_name_acquired(GDBusConnection *conn, const gchar *name,
1318                 gpointer user_data)
1319 {
1320         NOTUSED(conn);
1321         NOTUSED(user_data);
1322
1323         WMESH_LOGD("Acquired the name %s", name);
1324 }
1325
1326 static gboolean _wmeshd_dbus_interface_init(wmesh_service *service)
1327 {
1328         guint id;
1329         guint activation_dbus_id;
1330         wmeshd_check_null_ret_error("service", service, FALSE);
1331
1332         id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
1333                         WMESH_DBUS_INTERFACE,
1334                         G_BUS_NAME_OWNER_FLAGS_REPLACE,
1335                         _wmeshd_dbus_on_bus_acquired,
1336                         _wmeshd_dbus_on_name_acquired,
1337                         _wmeshd_dbus_on_name_lost,
1338                         service,
1339                         NULL);
1340         if (0 == id) {
1341                 /* LCOV_EXCL_START */
1342                 WMESH_LOGE("g_bus_own_name() Fail");
1343                 return FALSE;
1344                 /* LCOV_EXCL_STOP */
1345         }
1346
1347         /* Get D-Bus owner to activate mesh service daemon */
1348         activation_dbus_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
1349                         WMESH_DBUS_INTERFACE".manager",
1350                         G_BUS_NAME_OWNER_FLAGS_REPLACE,
1351                         _wmeshd_dbus_on_activator_bus_acquired,
1352                         NULL,
1353                         NULL,
1354                         service,
1355                         NULL);
1356
1357         service->dbus_id = id;
1358         service->activation_dbus_id = activation_dbus_id;
1359         service->interface_info = g_new0(wmesh_interface_s, 1);
1360         service->scanned_mesh_network = NULL;
1361
1362         /* Initialize DBus sendor logic */
1363         wmeshd_dbus_start(service);
1364
1365         return TRUE;
1366 }
1367
1368 static void _wmeshd_dbus_deinit(wmesh_service *service)
1369 {
1370         wmesh_interface_s *info = NULL;
1371         wmeshd_check_null_ret("service", service);
1372
1373         /* De-Initialize DBus sendor logic */
1374         wmeshd_dbus_stop(service);
1375
1376         g_bus_unown_name(service->dbus_id);
1377         g_bus_unown_name(service->activation_dbus_id);
1378
1379         info = service->interface_info;
1380         wmeshd_check_null_ret("info", info);
1381         if (info->bridge_interface)
1382                 g_free(info->bridge_interface);
1383         if (info->base_interface)
1384                 g_free(info->base_interface);
1385         if (info->mesh_interface)
1386                 g_free(info->mesh_interface);
1387         if (info->softap_interface)
1388                 g_free(info->softap_interface);
1389         if (info->external_interface)
1390                 g_free(info->external_interface);
1391
1392         if (service->joined_network) {
1393                 /* LCOV_EXCL_START */
1394                 g_free(service->joined_network->mesh_id);
1395                 g_free(service->joined_network->bssid);
1396                 g_free(service->joined_network);
1397                 service->joined_network = NULL;
1398                 /* LCOV_EXCL_STOP */
1399         }
1400
1401         /* Clear scan list */
1402         if (service->scanned_mesh_network)
1403                 g_list_free_full(service->scanned_mesh_network, _on_scan_result_destroy); /* LCOV_EXCL_LINE */
1404         service->scanned_mesh_network = NULL;
1405
1406         /* Clear connected peers list */
1407         if (service->connected_mesh_peers)
1408                 g_list_free_full(service->connected_mesh_peers, _on_peer_info_destroy); /* LCOV_EXCL_LINE */
1409         service->connected_mesh_peers = NULL;
1410
1411         /* Clear mesh path list */
1412         if (service->mpath_list)
1413                 g_list_free_full(service->mpath_list, _on_mpath_list_destroy); /* LCOV_EXCL_LINE */
1414         service->mpath_list = NULL;
1415
1416         /* Clear mesh station list */
1417         if (service->station_list)
1418                 g_list_free_full(service->station_list, _on_station_list_destroy); /* LCOV_EXCL_LINE */
1419         service->station_list = NULL;
1420
1421         /* Clear mesh station list */
1422         if (service->softap_station_list)
1423                 g_list_free_full(service->softap_station_list, _on_station_list_destroy); /* LCOV_EXCL_LINE */
1424         service->softap_station_list = NULL;
1425
1426         g_free(service->interface_info);
1427         service->interface_info = NULL;
1428 }
1429
1430 /**< Mesh service interface initialization */
1431 gboolean wmeshd_service_interface_init(wmesh_service *service)
1432 {
1433         guint ret;
1434         wmeshd_check_null_ret_error("service", service, FALSE);
1435
1436         /* Initialize dbus interface */
1437         ret = _wmeshd_dbus_interface_init(service);
1438         if (FALSE == ret) {
1439                 /* LCOV_EXCL_START */
1440                 WMESH_LOGE("_wmeshd_dbus_interface_init failed!!!");
1441                 return FALSE;
1442                 /* LCOV_EXCL_STOP */
1443         }
1444
1445         return TRUE;
1446 }
1447
1448 /**< Mesh service interface de-initialization */
1449 void wmeshd_service_interface_deinit(wmesh_service *service)
1450 {
1451         wmeshd_check_null_ret("service", service);
1452
1453         /* De-initialize dbus interface */
1454         _wmeshd_dbus_deinit(service);
1455 }