src/mesh-gdbus.c

   1 /*
   2  * Copyright (c) 2017 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "mesh-log.h"
  18 #include "mesh-util.h"
  19 #include "mesh-gdbus.h"
  20 #include "mesh-request.h"
  21
  22 #include "nl80211.h"
  23
  24 static GDBusProxy *_gproxy_connman = NULL;
  25 static GDBusProxy *_gproxy_connman_mesh = NULL;
  26 static GDBusProxy *_gproxy_connman_technology = NULL;
  27
  28 static int _meshd_close_gdbus_call(mesh_service *service);
  29
  30 static int __channel_to_frequency(int channel, enum nl80211_band band)
  31 {
  32         if (channel <= 0)
  33                 return 0;
  34
  35         switch (band) {
  36         case NL80211_BAND_2GHZ:
  37                 if (channel == 14)
  38                         return 2484;
  39                 else if (channel < 14)
  40                         return 2407 + channel * 5;
  41                 break;
  42         case NL80211_BAND_5GHZ:
  43                 if (channel >= 182 && channel <= 196)
  44                         return 4000 + channel * 5;
  45                 else
  46                         return 5000 + channel * 5;
  47                 break;
  48         default:
  49                 break;
  50         }
  51
  52         /* not supported */
  53         return 0;
  54 }
  55
  56 static int __frequency_to_channel(int freq)
  57 {
  58         if (freq == 2484)
  59                 return 14;
  60         else if (freq < 2484)
  61                 return (freq - 2407) / 5;
  62         else if (freq >= 4910 && freq <= 4980)
  63                 return (freq - 4000) / 5;
  64         else if (freq <= 45000)
  65                 return (freq - 5000) / 5;
  66         else if (freq >= 58320 && freq <= 64800)
  67                 return (freq - 56160) / 2160;
  68         else
  69                 return 0;
  70 }
  71
  72 static GDBusProxy *_proxy_get_connman(mesh_service *service)
  73 {
  74         GDBusProxy *proxy = NULL;
  75         meshd_check_null_ret_error("service", service, NULL);
  76
  77         if (NULL == _gproxy_connman) {
  78                 proxy = g_dbus_proxy_new_sync(service->connection,
  79                         G_DBUS_PROXY_FLAGS_NONE, NULL,
  80                         CONNMAN_SERVER_NAME,
  81                         CONNMAN_OBJECT_PATH,
  82                         CONNMAN_INTERFACE_MANAGER,
  83                         NULL, NULL);
  84         } else
  85                 proxy = _gproxy_connman;
  86
  87         return proxy;
  88 }
  89
  90 static GDBusProxy *_proxy_get_connman_mesh(mesh_service *service)
  91 {
  92         GDBusProxy *proxy = NULL;
  93         meshd_check_null_ret_error("service", service, NULL);
  94
  95         if (NULL == _gproxy_connman_mesh) {
  96                 proxy = g_dbus_proxy_new_sync(service->connection,
  97                         G_DBUS_PROXY_FLAGS_NONE, NULL,
  98                         CONNMAN_SERVER_NAME,
  99                         CONNMAN_OBJECT_PATH_MESH,
 100                         CONNMAN_INTERFACE_MESH,
 101                         NULL, NULL);
 102         } else
 103                 proxy = _gproxy_connman_mesh;
 104
 105         return proxy;
 106 }
 107
 108 static GDBusProxy *_proxy_get_connman_technology(mesh_service *service)
 109 {
 110         GDBusProxy *proxy = NULL;
 111         meshd_check_null_ret_error("service", service, NULL);
 112
 113         if (NULL == _gproxy_connman_technology) {
 114                 proxy = g_dbus_proxy_new_sync(service->connection,
 115                         G_DBUS_PROXY_FLAGS_NONE, NULL,
 116                         CONNMAN_SERVER_NAME,
 117                         CONNMAN_OBJECT_PATH_TECH_MESH,
 118                         CONNMAN_INTERFACE_TECH,
 119                         NULL, NULL);
 120         } else
 121                 proxy = _gproxy_connman_technology;
 122
 123         return proxy;
 124 }
 125
 126 static void _dbus_name_owner_notify(GObject *object, GParamSpec *pspec,
 127                 gpointer *user_data)
 128 {
 129         GDBusProxy *proxy = G_DBUS_PROXY(object);
 130         gchar *name_owner = g_dbus_proxy_get_name_owner(proxy);
 131         mesh_service *service = (mesh_service*)user_data;
 132
 133         NOTUSED(pspec);
 134
 135         if (NULL == name_owner) {
 136                 MESH_LOGE("name_owner is not exists !");
 137                 _meshd_close_gdbus_call(service);
 138         }
 139
 140         g_free(name_owner);
 141 }
 142
 143 static int _meshd_create_gdbus_call(mesh_service *service)
 144 {
 145         int id;
 146         GError *error = NULL;
 147
 148         if (NULL == service)
 149                 return MESHD_ERROR_INVALID_PARAMETER;
 150
 151         if (NULL != service->connection)
 152                 return MESHD_ERROR_ALREADY_REGISTERED;
 153
 154         service->connection = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
 155         if (service->connection == NULL) {
 156                 if (error != NULL) {
 157                         MESH_LOGE("Failed to connect to the D-BUS daemon [%s]", error->message);
 158                         g_error_free(error);
 159                 }
 160                 return MESHD_ERROR_IO_ERROR;
 161         }
 162
 163         id = g_signal_connect(service->connection, "notify::g-name-owner",
 164                         G_CALLBACK(_dbus_name_owner_notify), service);
 165         if (0 == id) {
 166                 MESH_LOGE("g_signal_connect() Fail");
 167                 g_object_unref(service->connection);
 168                 service->connection = NULL;
 169                 return MESHD_ERROR_IO_ERROR;
 170         }
 171
 172         return MESHD_ERROR_NONE;
 173 }
 174
 175 static int _meshd_close_gdbus_call(mesh_service *service)
 176 {
 177         /* CHECK: is connection ref count required? */
 178         g_object_unref(service->connection);
 179         service->connection = NULL;
 180
 181         return MESHD_ERROR_NONE;
 182 }
 183
 184 static void _meshd_signal_handler(GDBusConnection *connection,
 185                 const gchar *sender_name, const gchar *object_path, const gchar *interface_name,
 186                 const gchar *signal_name, GVariant *parameters, gpointer user_data)
 187 {
 188         mesh_service *service = (mesh_service*)user_data;
 189
 190         meshd_check_null_ret("user_data", user_data);
 191         //meshd_check_null_ret("event_handler", service->event_handler);
 192         NOTUSED(connection);
 193         NOTUSED(sender_name);
 194         NOTUSED(object_path);
 195         NOTUSED(interface_name);
 196         NOTUSED(signal_name);
 197         NOTUSED(parameters);
 198
 199         NOTUSED(service);
 200
 201         MESH_LOGD("signal received = %s", signal_name);
 202         if (0 == g_strcmp0(signal_name, "ScanDone")) {
 203                 /* TODO: Handle event */
 204                 mesh_notify_scan_done();
 205         }
 206 }
 207
 208 static void _meshd_subscribe_event(mesh_service *service)
 209 {
 210         unsigned int id;
 211
 212         id = g_dbus_connection_signal_subscribe(
 213                         (GDBusConnection *)service->connection,
 214                         CONNMAN_SERVER_NAME, CONNMAN_INTERFACE_MANAGER,
 215                         "ScanDone", "/", NULL,
 216                         G_DBUS_CALL_FLAGS_NONE, _meshd_signal_handler, service, NULL);
 217         if (0 == id) {
 218                 MESH_LOGE("g_dbus_connection_signal_subscribe(ScanDone) Fail(%d)", errno);
 219                 return;
 220         }
 221         service->dbus_sub_ids = g_list_append(service->dbus_sub_ids, GUINT_TO_POINTER(id));
 222         MESH_LOGD("[Signal subscribe] : ScanDone (%d)", id);
 223
 224         /* End of subscription */
 225 }
 226
 227 int meshd_dbus_start(mesh_service *service)
 228 {
 229         int rv;
 230
 231         rv = _meshd_create_gdbus_call(service);
 232         if (MESHD_ERROR_NONE != rv)
 233                 return rv;
 234
 235         service->ca = g_cancellable_new();
 236
 237         /* Create all required proxies here */
 238         _gproxy_connman = _proxy_get_connman(service);
 239         meshd_check_null_ret_error("_gproxy_connman", _gproxy_connman,
 240                                 MESHD_ERROR_IO_ERROR);
 241         g_dbus_proxy_set_default_timeout(
 242                         G_DBUS_PROXY(_gproxy_connman), MESH_DBUS_PROXY_TIMEOUT);
 243
 244         _gproxy_connman_mesh = _proxy_get_connman_mesh(service);
 245         meshd_check_null_ret_error("_gproxy_connman_mesh", _gproxy_connman_mesh,
 246                                 MESHD_ERROR_IO_ERROR);
 247         g_dbus_proxy_set_default_timeout(
 248                         G_DBUS_PROXY(_gproxy_connman_mesh), MESH_DBUS_PROXY_TIMEOUT);
 249
 250         _gproxy_connman_technology = _proxy_get_connman_technology(service);
 251         meshd_check_null_ret_error("_gproxy_connman_technology", _gproxy_connman_technology,
 252                                 MESHD_ERROR_IO_ERROR);
 253         g_dbus_proxy_set_default_timeout(
 254                         G_DBUS_PROXY(_gproxy_connman_technology), MESH_DBUS_PROXY_TIMEOUT);
 255
 256         /* Subscribe events */
 257         _meshd_subscribe_event(service);
 258
 259         return MESHD_ERROR_NONE;
 260 }
 261
 262 int meshd_dbus_stop(mesh_service *service)
 263 {
 264         int rv;
 265
 266         if (NULL == service)
 267                 return MESHD_ERROR_INVALID_PARAMETER;
 268
 269         /* Unref all proxies here */
 270         if (_gproxy_connman) {
 271                 g_object_unref(_gproxy_connman);
 272                 _gproxy_connman = NULL;
 273         }
 274         if (_gproxy_connman_mesh) {
 275                 g_object_unref(_gproxy_connman_mesh);
 276                 _gproxy_connman_mesh = NULL;
 277         }
 278         if (_gproxy_connman_technology) {
 279                 g_object_unref(_gproxy_connman_technology);
 280                 _gproxy_connman_technology = NULL;
 281         }
 282
 283         g_cancellable_cancel(service->ca);
 284         g_object_unref(service->ca);
 285         service->ca = NULL;
 286
 287         rv = _meshd_close_gdbus_call(service);
 288         return rv;
 289 }
 290
 291 int mesh_ipc_create_mesh_interface(mesh_service *service)
 292 {
 293         GVariant *variant = NULL;
 294         GError *error = NULL;
 295         GVariant *var_dict = NULL;
 296         GVariantDict dict;
 297         mesh_interface_s *info = NULL;
 298
 299         meshd_check_null_ret_error("service", service, MESHD_ERROR_INVALID_PARAMETER);
 300         meshd_check_null_ret_error("connection", service->connection,
 301                         MESHD_ERROR_INVALID_PARAMETER);
 302         meshd_check_null_ret_error("_gproxy_connman_technology",
 303                         _gproxy_connman_technology, MESHD_ERROR_IO_ERROR);
 304
 305         info = service->interface_info;
 306
 307         g_variant_dict_init(&dict, NULL);
 308         g_variant_dict_insert(&dict, "Ifname", "s", info->mesh_interface);
 309         g_variant_dict_insert(&dict, "ParentIfname", "s", info->base_interface);
 310         g_variant_dict_insert(&dict, "BridgeIfname", "s", info->bridge_interface);
 311         var_dict = g_variant_dict_end(&dict);
 312
 313         variant = g_dbus_proxy_call_sync(_gproxy_connman_technology, "MeshCommands",
 314                                 g_variant_new("(sv)", "MeshInterfaceAdd", var_dict),
 315                                 G_DBUS_CALL_FLAGS_NONE,
 316                                 -1, NULL, &error);
 317         if (variant) {
 318                 MESH_LOGD("Successfully requested. [MeshInterfaceAdd]");
 319         } else if (error) {
 320                 MESH_LOGE("Failed DBus call [%s]", error->message);
 321                 g_error_free(error);
 322                 return MESHD_ERROR_IO_ERROR;
 323         }
 324
 325         return MESHD_ERROR_NONE;
 326 }
 327
 328 int mesh_ipc_remove_mesh_interface(mesh_service *service)
 329 {
 330         GVariant *variant = NULL;
 331         GError *error = NULL;
 332         GVariant *var_dict = NULL;
 333         GVariantDict dict;
 334         mesh_interface_s *info = NULL;
 335
 336         meshd_check_null_ret_error("service", service, MESHD_ERROR_INVALID_PARAMETER);
 337         meshd_check_null_ret_error("connection", service->connection,
 338                         MESHD_ERROR_INVALID_PARAMETER);
 339         meshd_check_null_ret_error("_gproxy_connman_technology",
 340                         _gproxy_connman_technology, MESHD_ERROR_IO_ERROR);
 341
 342         info = service->interface_info;
 343
 344         g_variant_dict_init(&dict, NULL);
 345         g_variant_dict_insert(&dict, "Ifname", "s", info->mesh_interface);
 346         var_dict = g_variant_dict_end(&dict);
 347
 348         variant = g_dbus_proxy_call_sync(_gproxy_connman_technology, "MeshCommands",
 349                                 g_variant_new("(sv)", "MeshInterfaceRemove", var_dict),
 350                                 G_DBUS_CALL_FLAGS_NONE,
 351                                 -1, NULL, &error);
 352         if (variant) {
 353                 MESH_LOGD("Successfully requested. [MeshInterfaceRemove]");
 354         } else if (error) {
 355                 MESH_LOGE("Failed DBus call [%s]", error->message);
 356                 g_error_free(error);
 357                 return MESHD_ERROR_IO_ERROR;
 358         }
 359
 360         return MESHD_ERROR_NONE;
 361 }
 362
 363 int mesh_ipc_mesh_scan(mesh_service *service)
 364 {
 365         GVariant *variant = NULL;
 366         GError *error = NULL;
 367
 368         meshd_check_null_ret_error("service", service, MESHD_ERROR_INVALID_PARAMETER);
 369         meshd_check_null_ret_error("connection", service->connection,
 370                         MESHD_ERROR_INVALID_PARAMETER);
 371         meshd_check_null_ret_error("_gproxy_connman_technology",
 372                         _gproxy_connman_technology, MESHD_ERROR_IO_ERROR);
 373
 374         variant = g_dbus_proxy_call_sync(_gproxy_connman_technology, "Scan",
 375                                 NULL,
 376                                 G_DBUS_CALL_FLAGS_NONE,
 377                                 -1, NULL, &error);
 378         if (variant) {
 379                 MESH_LOGD("Successfully requested. [Scan]");
 380         } else if (error) {
 381                 MESH_LOGE("Failed DBus call [%s]", error->message);
 382                 g_error_free(error);
 383                 return MESHD_ERROR_IO_ERROR;
 384         }
 385
 386         return MESHD_ERROR_NONE;
 387 }
 388
 389 int mesh_ipc_mesh_specific_scan(mesh_service *service, gchar *mesh_id,
 390         gint channel)
 391 {
 392         GVariant *variant = NULL;
 393         GError *error = NULL;
 394         GVariant *var_dict = NULL;
 395         GVariantDict dict;
 396
 397         enum nl80211_band band = (channel <= 14) ? NL80211_BAND_2GHZ : NL80211_BAND_5GHZ;
 398         gushort freq = __channel_to_frequency(channel, band);
 399
 400         meshd_check_null_ret_error("service", service, MESHD_ERROR_INVALID_PARAMETER);
 401         meshd_check_null_ret_error("connection", service->connection,
 402                         MESHD_ERROR_INVALID_PARAMETER);
 403         meshd_check_null_ret_error("_gproxy_connman_technology",
 404                         _gproxy_connman_technology, MESHD_ERROR_IO_ERROR);
 405
 406         g_variant_dict_init(&dict, NULL);
 407         g_variant_dict_insert(&dict, "Name", "s", mesh_id);
 408         g_variant_dict_insert(&dict, "Frequency", "q", freq);
 409         var_dict = g_variant_dict_end(&dict);
 410
 411         variant = g_dbus_proxy_call_sync(_gproxy_connman_technology, "MeshCommands",
 412                                 g_variant_new("(sv)", "MeshSpecificScan", var_dict),
 413                                 G_DBUS_CALL_FLAGS_NONE,
 414                                 -1, NULL, &error);
 415         if (variant) {
 416                 MESH_LOGD("Successfully requested. [MeshSpecificScan]");
 417         } else if (error) {
 418                 MESH_LOGE("Failed DBus call [%s]", error->message);
 419                 g_error_free(error);
 420                 return MESHD_ERROR_IO_ERROR;
 421         }
 422
 423         return MESHD_ERROR_NONE;
 424 }
 425
 426 static void _on_scan_result_destroy(gpointer data)
 427 {
 428         mesh_scan_result_s *scan_item = (mesh_scan_result_s *)data;
 429
 430         if (scan_item) {
 431                 g_free(scan_item->mesh_id);
 432                 g_free(scan_item->bssid);
 433                 g_free(scan_item->object_path);
 434         }
 435 }
 436
 437 static void _get_mesh_peers(mesh_service *service, GVariant *variant)
 438 {
 439         GVariantIter *peer = NULL;
 440         GVariantIter *property = NULL;
 441         gchar *key = NULL;
 442         GVariant *val = NULL;
 443         gsize len = 0;
 444         GVariant *child;
 445         gchar *var_string = NULL;
 446         const gchar* obj_path = NULL;
 447
 448         g_variant_get(variant, "(a(oa{sv}))", &peer);
 449         //while (g_variant_iter_next(peer, "oa{sv}", &tmp, &property)) {
 450         while ((child = g_variant_iter_next_value(peer))) {
 451                 mesh_scan_result_s *scan_info = NULL;
 452
 453                 scan_info = g_try_new0(mesh_scan_result_s, 1);
 454                 if (NULL == scan_info) {
 455                         MESH_LOGE("Failed to allocate !");
 456                         return;
 457                 }
 458
 459                 MESH_LOGD("    Child : [%s]", g_variant_get_type_string(child));
 460                 var_string = g_variant_print(child, FALSE);
 461                 MESH_LOGD("    %s", var_string);
 462                 g_free(var_string);
 463
 464                 g_variant_get(child, "(oa{sv})", &obj_path, &property);
 465                 if (NULL == obj_path) {
 466                         MESH_LOGE("Null object");
 467                         continue;
 468                 }
 469                 MESH_LOGD("    Obj path : [%s]", obj_path);
 470                 scan_info->object_path = g_strdup(obj_path);
 471
 472                 while (g_variant_iter_loop(property, "{sv}", &key, &val)) {
 473                         if (strcasecmp(key, "Name") == 0)  {
 474                                 const char *buf = g_variant_get_string(val, &len);
 475                                 scan_info->mesh_id = g_strdup(buf);
 476                                 MESH_LOGD("    Mesh ID : %s", scan_info->mesh_id);
 477                         }
 478                         else if (strcasecmp(key, "Address") == 0)  {
 479                                 const char *buf = g_variant_get_string(val, &len);
 480                                 scan_info->bssid = g_strdup(buf);
 481                                 MESH_LOGD("    BSSID : %s", scan_info->bssid);
 482                         }
 483                         else if (strcasecmp(key, "Frequency") == 0)  {
 484                                 scan_info->channel = __frequency_to_channel(g_variant_get_uint16(val));
 485                                 MESH_LOGD("    Channel : %d", scan_info->channel);
 486                         }
 487                         else if (strcasecmp(key, "Strength") == 0)  {
 488                                 scan_info->rssi = (gint)g_variant_get_byte(val);
 489                                 MESH_LOGD("    RSSI : %d", scan_info->rssi);
 490
 491                                 /* Last element */
 492                                 service->scanned_mesh_network =
 493                                         g_list_prepend(service->scanned_mesh_network, scan_info);
 494                         }
 495                 }
 496                 g_variant_iter_free(property);
 497         }
 498         g_variant_iter_free(peer);
 499 }
 500
 501 int mesh_ipc_get_mesh_peers(mesh_service *service)
 502 {
 503         GVariant *variant = NULL;
 504         GError *error = NULL;
 505
 506         meshd_check_null_ret_error("service", service, MESHD_ERROR_INVALID_PARAMETER);
 507         meshd_check_null_ret_error("connection", service->connection,
 508                         MESHD_ERROR_INVALID_PARAMETER);
 509         meshd_check_null_ret_error("_gproxy_connman",
 510                         _gproxy_connman, MESHD_ERROR_IO_ERROR);
 511
 512         variant = g_dbus_proxy_call_sync(_gproxy_connman, "GetMeshPeers",
 513                                 NULL,
 514                                 G_DBUS_CALL_FLAGS_NONE,
 515                                 -1, NULL, &error);
 516         if (variant) {
 517                 MESH_LOGD("Successfully requested. [GetMeshPeers]");
 518
 519                 if (service->scanned_mesh_network) {
 520                         g_list_free_full(service->scanned_mesh_network, _on_scan_result_destroy);
 521                         service->scanned_mesh_network = NULL;
 522                 }
 523
 524                 _get_mesh_peers(service, variant);
 525
 526                 /* List item is saved with reversed order for efficiency. */
 527                 service->scanned_mesh_network =
 528                                 g_list_reverse(service->scanned_mesh_network);
 529         } else if (error) {
 530                 MESH_LOGE("Failed DBus call [%s]", error->message);
 531                 g_error_free(error);
 532                 return MESHD_ERROR_IO_ERROR;
 533         }
 534
 535         return MESHD_ERROR_NONE;
 536 }
 537
 538 int mesh_ipc_connect_network(mesh_service *service, mesh_scan_result_s *info)
 539 {
 540         GVariant *variant = NULL;
 541         GError *error = NULL;
 542
 543         meshd_check_null_ret_error("service", service, MESHD_ERROR_INVALID_PARAMETER);
 544         meshd_check_null_ret_error("info", info, MESHD_ERROR_INVALID_PARAMETER);
 545
 546         variant = g_dbus_connection_call_sync(service->connection,
 547                         CONNMAN_SERVER_NAME,
 548                         info->object_path,
 549                         CONNMAN_INTERFACE_MESH,
 550                         "Connect",
 551                         NULL, NULL,
 552                         G_DBUS_CALL_FLAGS_NONE,
 553                         -1, NULL, &error);
 554         if (variant) {
 555                 MESH_LOGD("Successfully requested. [Connect]");
 556         } else if (error) {
 557                 LOGE("Failed DBus call [%s]", error->message);
 558                 g_error_free(error);
 559                 return MESHD_ERROR_IO_ERROR;
 560         }
 561
 562         return MESHD_ERROR_NONE;
 563 }
 564
 565 int mesh_ipc_disconnect_network(mesh_service *service, mesh_scan_result_s *info)
 566 {
 567         GVariant *variant = NULL;
 568         GError *error = NULL;
 569
 570         meshd_check_null_ret_error("service", service, MESHD_ERROR_INVALID_PARAMETER);
 571         meshd_check_null_ret_error("info", info, MESHD_ERROR_INVALID_PARAMETER);
 572
 573         variant = g_dbus_connection_call_sync(service->connection,
 574                         CONNMAN_SERVER_NAME,
 575                         info->object_path,
 576                         CONNMAN_INTERFACE_MESH,
 577                         "Disconnect",
 578                         NULL, NULL,
 579                         G_DBUS_CALL_FLAGS_NONE,
 580                         -1, NULL, &error);
 581         if (variant) {
 582                 MESH_LOGD("Successfully requested. [Disconnect]");
 583         } else if (error) {
 584                 LOGE("Failed DBus call [%s]", error->message);
 585                 g_error_free(error);
 586                 return MESHD_ERROR_IO_ERROR;
 587         }
 588
 589         return MESHD_ERROR_NONE;
 590 }
 591
 592 int mesh_ipc_remove_network(mesh_service *service, mesh_scan_result_s *info)
 593 {
 594         GVariant *variant = NULL;
 595         GError *error = NULL;
 596
 597         meshd_check_null_ret_error("service", service, MESHD_ERROR_INVALID_PARAMETER);
 598         meshd_check_null_ret_error("info", info, MESHD_ERROR_INVALID_PARAMETER);
 599
 600         variant = g_dbus_connection_call_sync(service->connection,
 601                         CONNMAN_SERVER_NAME,
 602                         info->object_path,
 603                         CONNMAN_INTERFACE_MESH,
 604                         "Remove",
 605                         NULL, NULL,
 606                         G_DBUS_CALL_FLAGS_NONE,
 607                         -1, NULL, &error);
 608         if (variant) {
 609                 MESH_LOGD("Successfully requested. [Remove]");
 610         } else if (error) {
 611                 LOGE("Failed DBus call [%s]", error->message);
 612                 g_error_free(error);
 613                 return MESHD_ERROR_IO_ERROR;
 614         }
 615
 616         return MESHD_ERROR_NONE;
 617 }