src/network-cm-intf.c

   1 /*
   2  * Network Client Library
   3  *
   4  * Copyright 2012 Samsung Electronics Co., Ltd
   5  *
   6  * Licensed under the Flora License, Version 1.1 (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.tizenopensource.org/license
  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
  20 #include "network-info.h"
  21 #include "network-internal.h"
  22 #include "network-dbus-request.h"
  23 #include "network-signal-handler.h"
  24
  25 /*****************************************************************************
  26  * Extern Variables
  27  *****************************************************************************/
  28
  29 /*****************************************************************************
  30  * Global Variables
  31  *****************************************************************************/
  32
  33 /* LCOV_EXCL_START */
  34 static int __net_get_default_profile(network_info_t *network_info,
  35                 void *param, net_profile_info_t *active_profile_info)
  36 {
  37         __NETWORK_FUNC_ENTER__;
  38
  39         net_err_t Error = NET_ERR_NONE;
  40
  41         if (param == NULL) {
  42                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
  43                 __NETWORK_FUNC_EXIT__;
  44                 return NET_ERR_INVALID_PARAM;
  45         }
  46
  47         Error = _net_get_default_profile_info(network_info, active_profile_info);
  48         if (Error != NET_ERR_NONE) {
  49                 NETWORK_LOG(NETWORK_ERROR,
  50                                 "_net_get_default_profile_info() failed. Error [%s]",
  51                                 _net_print_error(Error));
  52
  53                 __NETWORK_FUNC_EXIT__;
  54                 return Error;
  55         }
  56
  57         __NETWORK_FUNC_EXIT__;
  58         return NET_ERR_NONE;
  59 }
  60 /* LCOV_EXCL_STOP */
  61
  62 static int __net_add_route(network_info_t *network_info, const char *ip_addr,
  63                 const char *interface, int address_family)
  64 {
  65         __NETWORK_FUNC_ENTER__;
  66
  67         net_err_t Error = NET_ERR_NONE;
  68         GVariant *message = NULL;
  69         char dest_ip[INET6_ADDRSTRLEN] = { '\0' };
  70         char netmask[INET_ADDRSTRLEN] = { '\0' };
  71         char if_name[40] = { '\0' };
  72         GVariant *params = NULL;
  73
  74         g_snprintf(dest_ip, INET6_ADDRSTRLEN, "%s", ip_addr);
  75         g_snprintf(if_name, strlen(interface) + 1, "%s", interface);
  76
  77         if (address_family == AF_INET) {
  78                 g_snprintf(netmask, INET_ADDRSTRLEN, "255.255.255.255");
  79                 params = g_variant_new("(ssssi)", dest_ip, netmask, if_name, "", address_family);
  80         }
  81
  82         message = _net_invoke_dbus_method(network_info,
  83                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
  84                         NETCONFIG_NETWORK_INTERFACE, "AddRoute", params, &Error);
  85
  86         if (message == NULL) {
  87                 NETWORK_LOG(NETWORK_ERROR, "Failed to add route"); //LCOV_EXCL_LINE
  88                 goto done;
  89         }
  90
  91         /** Check Reply */
  92         gboolean add_result = FALSE;
  93
  94         g_variant_get(message, "(b)", &add_result);
  95         NETWORK_LOG(NETWORK_HIGH, "Add route, result : %d", add_result);
  96
  97         if (add_result)
  98                 Error = NET_ERR_NONE; //LCOV_EXCL_LINE
  99         else
 100                 Error = NET_ERR_UNKNOWN; //LCOV_EXCL_LINE
 101
 102         g_variant_unref(message);
 103
 104 done:
 105         __NETWORK_FUNC_EXIT__;
 106         return Error;
 107 }
 108
 109 static int __net_remove_route(network_info_t *network_info, const char *ip_addr,
 110                         const char *interface, int address_family)
 111 {
 112         __NETWORK_FUNC_ENTER__;
 113
 114         net_err_t Error = NET_ERR_NONE;
 115         GVariant *message = NULL;
 116         char dest_ip[INET6_ADDRSTRLEN] = { '\0' };
 117         char netmask[INET_ADDRSTRLEN] = { '\0' };
 118         char if_name[40] = { '\0' };
 119         GVariant *params = NULL;
 120
 121         g_snprintf(dest_ip, INET6_ADDRSTRLEN, "%s", ip_addr);
 122         g_snprintf(if_name, strlen(interface) + 1, "%s", interface);
 123
 124         if (address_family == AF_INET) {
 125                 g_snprintf(netmask, INET_ADDRSTRLEN, "255.255.255.255");
 126                 params = g_variant_new("(ssssi)", dest_ip, netmask, if_name, "", address_family);
 127         }
 128
 129         message = _net_invoke_dbus_method(network_info,
 130                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
 131                         NETCONFIG_NETWORK_INTERFACE, "RemoveRoute", params, &Error);
 132
 133         /* LCOV_EXCL_START */
 134         if (message == NULL) {
 135                 NETWORK_LOG(NETWORK_ERROR, "Failed to remove route");
 136                 goto done;
 137         }
 138         /* LCOV_EXCL_STOP */
 139
 140         /** Check Reply */
 141         gboolean remove_result = FALSE;
 142
 143         g_variant_get(message, "(b)", &remove_result);
 144         NETWORK_LOG(NETWORK_HIGH, "Remove route, result : %d", remove_result);
 145
 146         if (remove_result)
 147                 Error = NET_ERR_NONE; //LCOV_EXCL_LINE
 148         else
 149                 Error = NET_ERR_UNKNOWN; //LCOV_EXCL_LINE
 150
 151         g_variant_unref(message);
 152
 153 done:
 154         __NETWORK_FUNC_EXIT__;
 155         return Error;
 156 }
 157
 158 static int __net_add_route_entry(network_info_t *network_info, const char *ip_addr,
 159                         const char *interface, int address_family, const char *gateway)
 160 {
 161         __NETWORK_FUNC_ENTER__;
 162
 163         net_err_t Error = NET_ERR_NONE;
 164         GVariant *message = NULL;
 165         char dest_ip[INET6_ADDRSTRLEN] = { '\0' };
 166         char netmask[INET_ADDRSTRLEN] = { '\0' };
 167         char if_name[40] = { '\0' };
 168         GVariant *params = NULL;
 169
 170         g_snprintf(dest_ip, INET6_ADDRSTRLEN, "%s", ip_addr);
 171         g_snprintf(if_name, strlen(interface) + 1, "%s", interface);
 172
 173         if (address_family == AF_INET) {
 174                 g_snprintf(netmask, INET_ADDRSTRLEN, "255.255.255.255");
 175                 params = g_variant_new("(ssssi)", dest_ip, netmask, if_name, gateway, address_family);
 176         } else {
 177                 params = g_variant_new("(ssssi)", dest_ip, netmask, if_name, gateway, address_family); //LCOV_EXCL_LINE
 178         }
 179
 180         message = _net_invoke_dbus_method(network_info,
 181                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
 182                         NETCONFIG_NETWORK_INTERFACE, "AddRoute", params, &Error);
 183
 184         /* LCOV_EXCL_START */
 185         if (message == NULL) {
 186                 NETWORK_LOG(NETWORK_ERROR, "Failed to add route");
 187                 goto done;
 188         }
 189         /* LCOV_EXCL_STOP */
 190
 191         /** Check Reply */
 192         gboolean add_result = FALSE;
 193
 194         g_variant_get(message, "(b)", &add_result);
 195         NETWORK_LOG(NETWORK_HIGH, "Add route, result : %d", add_result);
 196
 197         if (add_result)
 198                 Error = NET_ERR_NONE; //LCOV_EXCL_LINE
 199         else
 200                 Error = NET_ERR_UNKNOWN; //LCOV_EXCL_LINE
 201
 202         g_variant_unref(message);
 203
 204 done:
 205         __NETWORK_FUNC_EXIT__;
 206         return Error;
 207 }
 208
 209 static int __net_remove_route_entry(network_info_t *network_info, const char *ip_addr,
 210                         const char *interface, int address_family, const char *gateway)
 211 {
 212         __NETWORK_FUNC_ENTER__;
 213
 214         net_err_t Error = NET_ERR_NONE;
 215         GVariant *message = NULL;
 216         char dest_ip[INET6_ADDRSTRLEN] = { '\0' };
 217         char netmask[INET_ADDRSTRLEN] = { '\0' };
 218         char if_name[40] = { '\0' };
 219         GVariant *params = NULL;
 220
 221         g_snprintf(dest_ip, INET6_ADDRSTRLEN, "%s", ip_addr);
 222         g_snprintf(if_name, strlen(interface) + 1, "%s", interface);
 223
 224         if (address_family == AF_INET) {
 225                 g_snprintf(netmask, INET_ADDRSTRLEN, "255.255.255.255");
 226                 params = g_variant_new("(ssssi)", dest_ip, netmask, if_name, gateway, address_family);
 227         } else {
 228                 params = g_variant_new("(ssssi)", dest_ip, netmask, if_name, gateway, address_family); //LCOV_EXCL_LINE
 229         }
 230
 231         message = _net_invoke_dbus_method(network_info,
 232                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
 233                         NETCONFIG_NETWORK_INTERFACE, "RemoveRoute", params, &Error);
 234
 235         /* LCOV_EXCL_START */
 236         if (message == NULL) {
 237                 NETWORK_LOG(NETWORK_ERROR, "Failed to remove route");
 238                 goto done;
 239         }
 240         /* LCOV_EXCL_STOP */
 241
 242         /** Check Reply */
 243         gboolean remove_result = FALSE;
 244
 245         g_variant_get(message, "(b)", &remove_result);
 246         NETWORK_LOG(NETWORK_HIGH, "Remove route, result : %d", remove_result);
 247
 248         if (remove_result)
 249                 Error = NET_ERR_NONE; //LCOV_EXCL_LINE
 250         else
 251                 Error = NET_ERR_UNKNOWN; //LCOV_EXCL_LINE
 252
 253         g_variant_unref(message);
 254
 255 done:
 256         __NETWORK_FUNC_EXIT__;
 257         return Error;
 258 }
 259
 260 static int __net_add_route_ipv6(network_info_t *network_info, const char *ip_addr,
 261                         const char *interface, int address_family, const char *gateway)
 262 {
 263         __NETWORK_FUNC_ENTER__;
 264
 265         net_err_t Error = NET_ERR_NONE;
 266         GVariant *message = NULL;
 267         char dest_ip[INET6_ADDRSTRLEN] = { '\0' };
 268         char netmask[INET_ADDRSTRLEN] = { '\0' };
 269         char if_name[40] = { '\0' };
 270         GVariant *params = NULL;
 271
 272         g_snprintf(dest_ip, INET6_ADDRSTRLEN, "%s", ip_addr);
 273         g_snprintf(if_name, strlen(interface) + 1, "%s", interface);
 274
 275         if (address_family == AF_INET6)
 276                 params = g_variant_new("(ssssi)", dest_ip, netmask, if_name, gateway, address_family);
 277
 278         message = _net_invoke_dbus_method(network_info,
 279                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
 280                         NETCONFIG_NETWORK_INTERFACE, "AddRoute", params, &Error);
 281
 282         /* LCOV_EXCL_START */
 283         if (message == NULL) {
 284                 NETWORK_LOG(NETWORK_ERROR, "Failed to add route");
 285                 goto done;
 286         }
 287         /* LCOV_EXCL_STOP */
 288
 289         /** Check Reply */
 290         gboolean add_result = FALSE;
 291
 292         g_variant_get(message, "(b)", &add_result);
 293         NETWORK_LOG(NETWORK_HIGH, "Add route, result : %d", add_result);
 294
 295         if (add_result)
 296                 Error = NET_ERR_NONE;
 297         else
 298                 Error = NET_ERR_UNKNOWN; //LCOV_EXCL_LINE
 299
 300         g_variant_unref(message);
 301
 302 done:
 303         __NETWORK_FUNC_EXIT__;
 304         return Error;
 305 }
 306
 307 static int __net_remove_route_ipv6(network_info_t *network_info, const char *ip_addr,
 308                         const char *interface, int address_family, const char *gateway)
 309 {
 310         __NETWORK_FUNC_ENTER__;
 311
 312         net_err_t Error = NET_ERR_NONE;
 313         GVariant *message = NULL;
 314         char dest_ip[INET6_ADDRSTRLEN] = { '\0' };
 315         char netmask[INET_ADDRSTRLEN] = { '\0' };
 316         char if_name[40] = { '\0' };
 317         GVariant *params = NULL;
 318
 319         g_snprintf(dest_ip, INET6_ADDRSTRLEN, "%s", ip_addr);
 320         g_snprintf(if_name, strlen(interface) + 1, "%s", interface);
 321
 322         if (address_family == AF_INET6)
 323                 params = g_variant_new("(ssssi)", dest_ip, netmask, if_name, gateway, address_family);
 324
 325         message = _net_invoke_dbus_method(network_info,
 326                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
 327                         NETCONFIG_NETWORK_INTERFACE, "RemoveRoute", params, &Error);
 328
 329         if (message == NULL) {
 330                 NETWORK_LOG(NETWORK_ERROR, "Failed to remove route"); //LCOV_EXCL_LINE
 331                 goto done;
 332         }
 333
 334         /** Check Reply */
 335         gboolean remove_result = FALSE;
 336
 337         g_variant_get(message, "(b)", &remove_result);
 338         NETWORK_LOG(NETWORK_HIGH, "Remove route, result : %d", remove_result);
 339
 340         if (remove_result)
 341                 Error = NET_ERR_NONE; //LCOV_EXCL_LINE
 342         else
 343                 Error = NET_ERR_UNKNOWN; //LCOV_EXCL_LINE
 344
 345         g_variant_unref(message);
 346
 347 done:
 348         __NETWORK_FUNC_EXIT__;
 349         return Error;
 350 }
 351
 352 static gboolean __net_is_connecting(network_info_t *network_info, const char *profile_name)
 353 {
 354         __NETWORK_FUNC_ENTER__;
 355
 356         char *svc_name1 = NULL;
 357         char *svc_name2 = NULL;
 358
 359         if (network_info == NULL) {
 360                 __NETWORK_FUNC_EXIT__;
 361                 return FALSE;
 362         }
 363
 364         svc_name1 = network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].profile_name;
 365         svc_name2 = network_info->request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].profile_name;
 366
 367         if (network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE &&
 368                         g_strcmp0(profile_name, svc_name1) == 0) {
 369                 __NETWORK_FUNC_EXIT__;
 370                 return TRUE;
 371                 /* LCOV_EXCL_START */
 372         } else if (network_info->request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE &&
 373                         g_strcmp0(profile_name, svc_name2) == 0) {
 374                 __NETWORK_FUNC_EXIT__;
 375                 return TRUE;
 376         }
 377         /* LCOV_EXCL_STOP */
 378
 379         __NETWORK_FUNC_EXIT__;
 380         return FALSE;
 381 }
 382
 383 static void __net_abort_open_connection(network_info_t *network_info, const char *profile_name)
 384 {
 385         __NETWORK_FUNC_ENTER__;
 386
 387         net_event_info_t *event_data = NULL;
 388         char event_string[64];
 389
 390         char *svc_name1 = NULL;
 391         char *svc_name2 = NULL;
 392
 393         if (network_info == NULL) {
 394                 __NETWORK_FUNC_EXIT__;
 395                 return;
 396         }
 397
 398         event_data = g_try_new0(net_event_info_t, 1);
 399         if (event_data == NULL) {
 400                 __NETWORK_FUNC_EXIT__;
 401                 return;
 402         }
 403
 404         svc_name1 = network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].profile_name;
 405         svc_name2 = network_info->request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].profile_name;
 406
 407         if (network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE &&
 408                         g_strcmp0(profile_name, svc_name1) == 0) {
 409                 memset(&(network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION]), 0,
 410                                 sizeof(network_request_table_t));
 411
 412                 event_data->event = NET_EVENT_OPEN_RSP;
 413                 g_strlcpy(event_string, "Sending NET_EVENT_OPEN_RSP", 64);
 414                 /* LCOV_EXCL_START */
 415         } else if (network_info->request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE &&
 416                         g_strcmp0(profile_name, svc_name2) == 0) {
 417                 memset(&(network_info->request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS]), 0,
 418                                 sizeof(network_request_table_t));
 419
 420                 event_data->event = NET_EVENT_WIFI_WPS_RSP;
 421                 g_strlcpy(event_string, "Sending NET_EVENT_WIFI_WPS_RSP", 64);
 422         } else {
 423                 __NETWORK_FUNC_EXIT__;
 424                 g_free(event_data);
 425                 return;
 426         }
 427         /* LCOV_EXCL_STOP */
 428
 429         g_strlcpy(event_data->profile_name, profile_name, NET_PROFILE_NAME_LEN_MAX+1);
 430         event_data->Error = NET_ERR_OPERATION_ABORTED;
 431         event_data->datalength = 0;
 432         event_data->data = NULL;
 433
 434         NETWORK_LOG(NETWORK_LOW, "%s, Error: %d", event_string, event_data->Error);
 435         if (network_info && network_info->event_callback)
 436                 network_info->event_callback(event_data, network_info->user_data);
 437         g_free(event_data);
 438
 439         __NETWORK_FUNC_EXIT__;
 440 }
 441
 442 /*****************************************************************************
 443  * ConnMan Client Common Interface API Definition
 444  *****************************************************************************/
 445 EXPORT_API int net_register_client(void **handle, net_event_cb_t event_cb, void *user_data)
 446 {
 447         __NETWORK_FUNC_ENTER__;
 448
 449         net_err_t Error = NET_ERR_NONE;
 450         network_info_t *network_info = NULL;
 451
 452         if (event_cb == NULL) {
 453                 NETWORK_LOG(NETWORK_ERROR, "Invalid EventCb parameter");
 454                 __NETWORK_FUNC_EXIT__;
 455                 return NET_ERR_INVALID_PARAM;
 456         }
 457
 458         network_info = g_try_malloc0(sizeof(network_info_t));
 459         if (network_info == NULL) {
 460                 NETWORK_LOG(NETWORK_ERROR, "Out of memory");
 461                 __NETWORK_FUNC_EXIT__;
 462                 return NET_ERR_OUT_OF_MEMORY;
 463         }
 464
 465         _network_info_ref(network_info);
 466
 467         Error = _net_dbus_create_gdbus_call(network_info);
 468         if (Error != NET_ERR_NONE) {
 469                 _network_info_unref(network_info);
 470                 __NETWORK_FUNC_EXIT__;
 471                 return Error;
 472         }
 473
 474         Error = _net_register_signal(network_info);
 475         /* LCOV_EXCL_START */
 476         if (Error != NET_ERR_NONE) {
 477                 NETWORK_LOG(NETWORK_ERROR, "Failed to register DBus signal [%s]",
 478                                 _net_print_error(Error));
 479                 _net_dbus_close_gdbus_call(network_info);
 480                 _network_info_unref(network_info);
 481                 __NETWORK_FUNC_EXIT__;
 482                 return Error;
 483         }
 484         /* LCOV_EXCL_STOP */
 485
 486         Error = _net_init_service_state_table(network_info);
 487         /* LCOV_EXCL_START */
 488         if (Error != NET_ERR_NONE) {
 489                 NETWORK_LOG(NETWORK_ERROR, "Failed to init service state table [%s]",
 490                                 _net_print_error(Error));
 491                 _net_deregister_signal(network_info);
 492                 _net_dbus_close_gdbus_call(network_info);
 493                 _network_info_unref(network_info);
 494                 __NETWORK_FUNC_EXIT__;
 495                 return Error;
 496         }
 497         /* LCOV_EXCL_STOP */
 498
 499         network_info->event_callback = event_cb;
 500         network_info->user_data = user_data;
 501
 502         *handle = network_info;
 503
 504         __NETWORK_FUNC_EXIT__;
 505         return NET_ERR_NONE;
 506 }
 507
 508 EXPORT_API void net_deregister_client(void *handle)
 509 {
 510         __NETWORK_FUNC_ENTER__;
 511
 512         network_info_t *network_info = (network_info_t *)handle;
 513
 514         if (network_info) {
 515                 network_info->event_callback = NULL;
 516                 network_info->user_data = NULL;
 517
 518                 _net_deregister_signal(network_info);
 519                 _net_dbus_close_gdbus_call(network_info);
 520                 _net_clear_request_table(network_info);
 521
 522                 _network_info_unref(network_info);
 523         }
 524
 525         __NETWORK_FUNC_EXIT__;
 526 }
 527
 528 /**
 529  * @fn  EXPORT_API int net_get_active_net_info(net_profile_info_t *active_profile_info)
 530  *
 531  * This API returns the information of active(default) network profile.
 532  * This is Sync API.
 533  *
 534  * @return       int - NET_ERR_NONE on success, negative values for errors
 535  * @param[in]    none
 536  * @param[out]   active_profile_info The information of active(default) network profile.
 537  */
 538 /* LCOV_EXCL_START */
 539 EXPORT_API int net_get_active_net_info(void *handle, net_profile_info_t *active_profile_info)
 540 {
 541         __NETWORK_FUNC_ENTER__;
 542
 543         net_err_t Error = NET_ERR_NONE;
 544         network_info_t *network_info = (network_info_t *)handle;
 545
 546         Error = __net_get_default_profile(network_info, active_profile_info, active_profile_info);
 547
 548         __NETWORK_FUNC_EXIT__;
 549         return Error;
 550 }
 551 /* LCOV_EXCL_STOP */
 552
 553 /**
 554  * @fn   EXPORT_API int net_get_network_status(net_service_type_t network_type, net_cm_network_status_t* pNetworkStatus)
 555  *
 556  * This function requests wifi/pdp network status
 557  * This is Sync API.
 558  *
 559  * @return       int - NET_ERR_NONE on success, negative values for errors
 560  * @param[in]    net_service_type_t network_type - Network type (wlan/pdp/default), of whose status to be checked.
 561  * @param[out]   net_cm_network_status_t* pNetworkStatus - Status of the requested network.
 562  */
 563
 564 EXPORT_API int net_get_network_status(void *handle, net_device_t device_type,
 565                 net_cm_network_status_t *network_status)
 566 {
 567         net_err_t Error = NET_ERR_NONE;
 568         network_info_t *network_info = (network_info_t *)handle;
 569
 570         __NETWORK_FUNC_ENTER__;
 571
 572         /* LCOV_EXCL_START */
 573         if (network_status == NULL) {
 574                 __NETWORK_FUNC_EXIT__;
 575                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
 576                 return NET_ERR_INVALID_PARAM;
 577         }
 578         /* LCOV_EXCL_STOP */
 579
 580         if ((Error = _net_dbus_get_network_status(network_info, device_type, network_status)) != NET_ERR_NONE) {
 581                 /* LCOV_EXCL_START */
 582                 NETWORK_LOG(NETWORK_ERROR, "Failed to get network status. Error [%s]",
 583                                 _net_print_error(Error));
 584                 __NETWORK_FUNC_EXIT__;
 585                 return Error;
 586                 /* LCOV_EXCL_STOP */
 587         }
 588
 589         __NETWORK_FUNC_EXIT__;
 590         return NET_ERR_NONE;
 591 }
 592
 593 EXPORT_API int net_get_statistics(void *handle, net_device_t device_type,
 594                         net_statistics_type_e statistics_type, unsigned long long *size)
 595 {
 596         net_err_t Error = NET_ERR_NONE;
 597         network_info_t *network_info = (network_info_t *)handle;
 598
 599         if (size == NULL)
 600                 return NET_ERR_INVALID_PARAM;
 601
 602         if ((Error = _net_dbus_get_statistics(network_info, device_type, statistics_type, size)) != NET_ERR_NONE)
 603                 NETWORK_LOG(NETWORK_ERROR, "Failed to get statistics. error: %s", //LCOV_EXCL_LINE
 604                                 _net_print_error(Error));
 605
 606         return Error;
 607 }
 608
 609 EXPORT_API int net_set_statistics(void *handle, net_device_t device_type,
 610                         net_statistics_type_e statistics_type)
 611 {
 612         net_err_t Error = NET_ERR_NONE;
 613         network_info_t *network_info = (network_info_t *)handle;
 614
 615         if ((Error = _net_dbus_set_statistics(network_info, device_type, statistics_type)) != NET_ERR_NONE)
 616                 NETWORK_LOG(NETWORK_ERROR, "Failed to set statistics. error: %s",
 617                                 _net_print_error(Error));
 618
 619         return Error;
 620 }
 621
 622 EXPORT_API int net_add_route(void *handle, const char *ip_addr, const char *interface, int address_family)
 623 {
 624         net_err_t Error = NET_ERR_NONE;
 625         network_info_t *network_info = (network_info_t *)handle;
 626
 627         if (ip_addr == NULL || strlen(ip_addr) < 7 || interface == NULL || strlen(interface) == 0) {
 628                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
 629                 __NETWORK_FUNC_EXIT__;
 630                 return NET_ERR_INVALID_PARAM;
 631         }
 632
 633         Error = __net_add_route(network_info, ip_addr, interface, address_family);
 634         /* LCOV_EXCL_START */
 635         if (Error != NET_ERR_NONE) {
 636                 NETWORK_LOG(NETWORK_ERROR, "Failed to add route. Error [%s]",
 637                                 _net_print_error(Error));
 638
 639                 return Error;
 640         }
 641         /* LCOV_EXCL_STOP */
 642
 643         return Error;
 644 }
 645
 646 EXPORT_API int net_remove_route(void *handle, const char *ip_addr, const char *interface, int address_family)
 647 {
 648         net_err_t Error = NET_ERR_NONE;
 649         network_info_t *network_info = (network_info_t *)handle;
 650
 651         if (ip_addr == NULL || strlen(ip_addr) < 7 ||
 652                 interface == NULL || strlen(interface) == 0) {
 653                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
 654
 655                 __NETWORK_FUNC_EXIT__;
 656                 return NET_ERR_INVALID_PARAM;
 657         }
 658
 659         Error = __net_remove_route(network_info, ip_addr, interface, address_family);
 660         /* LCOV_EXCL_START */
 661         if (Error != NET_ERR_NONE) {
 662                 NETWORK_LOG(NETWORK_ERROR, "Failed to remove route. Error [%s]",
 663                                 _net_print_error(Error));
 664
 665                 return Error;
 666         }
 667         /* LCOV_EXCL_STOP */
 668
 669         return Error;
 670 }
 671
 672 EXPORT_API int net_add_route_entry(void *handle, const char *ip_addr,
 673                         const char *interface, int address_family, const char *gateway)
 674 {
 675         net_err_t Error = NET_ERR_NONE;
 676         network_info_t *network_info = (network_info_t *)handle;
 677
 678         if (ip_addr == NULL || strlen(ip_addr) < 7 || interface == NULL ||
 679                 gateway == NULL || strlen(interface) == 0) {
 680                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
 681                 __NETWORK_FUNC_EXIT__;
 682                 return NET_ERR_INVALID_PARAM;
 683         }
 684
 685         Error = __net_add_route_entry(network_info, ip_addr, interface, address_family, gateway);
 686         /* LCOV_EXCL_START */
 687         if (Error != NET_ERR_NONE) {
 688                 NETWORK_LOG(NETWORK_ERROR, "Failed to add route. Error [%s]",
 689                                 _net_print_error(Error));
 690
 691                 return Error;
 692         }
 693         /* LCOV_EXCL_STOP */
 694
 695         return Error;
 696 }
 697
 698 EXPORT_API int net_remove_route_entry(void *handle, const char *ip_addr,
 699                         const char *interface, int address_family, const char *gateway)
 700 {
 701         net_err_t Error = NET_ERR_NONE;
 702         network_info_t *network_info = (network_info_t *)handle;
 703
 704         if (ip_addr == NULL || strlen(ip_addr) < 7 || interface == NULL ||
 705                 gateway == NULL || strlen(interface) == 0) {
 706                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
 707
 708                 __NETWORK_FUNC_EXIT__;
 709                 return NET_ERR_INVALID_PARAM;
 710         }
 711
 712         Error = __net_remove_route_entry(network_info, ip_addr, interface, address_family, gateway);
 713         /* LCOV_EXCL_START */
 714         if (Error != NET_ERR_NONE) {
 715                 NETWORK_LOG(NETWORK_ERROR, "Failed to remove route. Error [%s]",
 716                                 _net_print_error(Error));
 717
 718                 return Error;
 719         }
 720         /* LCOV_EXCL_STOP */
 721
 722         return Error;
 723 }
 724
 725
 726 EXPORT_API int net_add_route_ipv6(void *handle, const char *ip_addr,
 727                         const char *interface, int address_family, const char *gateway)
 728 {
 729         net_err_t Error = NET_ERR_NONE;
 730         network_info_t *network_info = (network_info_t *)handle;
 731
 732         if (ip_addr == NULL || strlen(ip_addr) < 3 || interface == NULL || gateway == NULL || strlen(interface) == 0) {
 733                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
 734                 __NETWORK_FUNC_EXIT__;
 735                 return NET_ERR_INVALID_PARAM;
 736         }
 737
 738         Error = __net_add_route_ipv6(network_info, ip_addr, interface, address_family, gateway);
 739         /* LCOV_EXCL_START */
 740         if (Error != NET_ERR_NONE) {
 741                 NETWORK_LOG(NETWORK_ERROR, "Failed to add route. Error [%s]",
 742                                 _net_print_error(Error));
 743
 744                 return Error;
 745         }
 746         /* LCOV_EXCL_STOP */
 747
 748         return Error;
 749 }
 750
 751 EXPORT_API int net_remove_route_ipv6(void *handle, const char *ip_addr,
 752                         const char *interface, int address_family, const char *gateway)
 753 {
 754         net_err_t Error = NET_ERR_NONE;
 755         network_info_t *network_info = (network_info_t *)handle;
 756
 757         if (ip_addr == NULL || strlen(ip_addr) < 3 || interface == NULL || gateway == NULL || strlen(interface) == 0) {
 758                 NETWORK_LOG(NETWORK_ERROR, "Invalid parameter");
 759
 760                 __NETWORK_FUNC_EXIT__;
 761                 return NET_ERR_INVALID_PARAM;
 762         }
 763
 764         Error = __net_remove_route_ipv6(network_info, ip_addr, interface, address_family, gateway);
 765         if (Error != NET_ERR_NONE) {
 766                 NETWORK_LOG(NETWORK_ERROR, "Failed to remove route. Error [%s]",
 767                                 _net_print_error(Error));
 768
 769                 return Error;
 770         }
 771
 772         return Error;
 773 }
 774
 775 /**
 776  * @fn   EXPORT_API int net_get_ethernet_module(int *state)
 777  *
 778  * This function is to get ethernet plug in/out state.
 779  * This is Sync API.
 780  *
 781  * @return       0 - on success, negative values for errors
 782  * @param[in]    int *state - state of ethernet cable
 783  * @param[out]   none
 784  */
 785 EXPORT_API int net_get_ethernet_cable_state(void *handle, int *state)
 786 {
 787         __NETWORK_FUNC_ENTER__;
 788         net_err_t Error = NET_ERR_NONE;
 789         network_info_t *network_info = (network_info_t *)handle;
 790
 791         Error = _net_dbus_get_ethernet_cable_state(network_info, state);
 792
 793         if (Error != NET_ERR_NONE)
 794                 NETWORK_LOG(NETWORK_ERROR, "_net_dbus_get_ethernet_cable_state failed");
 795
 796         __NETWORK_FUNC_EXIT__;
 797         return Error;
 798 }
 799
 800 EXPORT_API int net_get_metered_state(void *handle, int *state)
 801 {
 802         __NETWORK_FUNC_ENTER__;
 803         net_err_t Error = NET_ERR_NONE;
 804         network_info_t *network_info = (network_info_t *)handle;
 805
 806         Error = _net_dbus_get_metered_state(network_info, state);
 807
 808         if (Error != NET_ERR_NONE)
 809                 NETWORK_LOG(NETWORK_ERROR, "net_get_metered_state failed\n");
 810
 811         __NETWORK_FUNC_EXIT__;
 812         return Error;
 813 }
 814
 815 EXPORT_API int net_ethernet_eap_enable(gboolean enable, const char *profilename)
 816 {
 817         __NETWORK_FUNC_ENTER__;
 818         net_err_t Error = NET_ERR_NONE;
 819
 820         Error = _net_dbus_ethernet_eap_enable(enable, profilename);
 821
 822         if (Error != NET_ERR_NONE)
 823                 NETWORK_LOG(NETWORK_ERROR, "_net_dbus_ethernet_eap_enable failed");
 824
 825         __NETWORK_FUNC_EXIT__;
 826         return Error;
 827 }
 828
 829 EXPORT_API int net_ethernet_eap_enabled(const char *profilename, gboolean *enabled)
 830 {
 831         __NETWORK_FUNC_ENTER__;
 832         net_err_t Error = NET_ERR_NONE;
 833
 834         Error = _net_dbus_ethernet_eap_enabled(profilename, enabled);
 835
 836         if (Error != NET_ERR_NONE)
 837                 NETWORK_LOG(NETWORK_ERROR, "_net_dbus_ethernet_eap_supported failed");
 838
 839         __NETWORK_FUNC_EXIT__;
 840         return Error;
 841 }
 842
 843 EXPORT_API int net_save_ethernet_eap_config(void *handle, net_dev_info_t *net_info)
 844 {
 845         __NETWORK_FUNC_ENTER__;
 846
 847         net_err_t Error = NET_ERR_NONE;
 848         network_info_t *network_info = (network_info_t *)handle;
 849         const char *profile_name = net_info->profile_name;
 850
 851         NETWORK_LOG(NETWORK_LOW, "Save eap config for profile: %s", profile_name);
 852
 853         if (_net_check_profile_name(profile_name) != NET_ERR_NONE) {
 854                 NETWORK_LOG(NETWORK_ERROR, "Invalid profile name");
 855                 __NETWORK_FUNC_EXIT__;
 856                 return NET_ERR_INVALID_PARAM;
 857         }
 858
 859         Error = _net_dbus_save_ethernet_eap_connection(network_info, net_info);
 860         if (Error != NET_ERR_NONE) {
 861                 NETWORK_LOG(NETWORK_ERROR,
 862                                 "Failed to save ethernet eap config, Error [%s]",
 863                                 _net_print_error(Error));
 864
 865                 __NETWORK_FUNC_EXIT__;
 866                 return Error;
 867         }
 868
 869         __NETWORK_FUNC_EXIT__;
 870         return NET_ERR_NONE;
 871 }
 872
 873 /*****************************************************************************
 874  * ConnMan Mesh Client Interface Async Function Definition
 875  *****************************************************************************/
 876 /**
 877  * @fn   EXPORT_API int net_open_mesh_connection_with_profile(const char *profile_name)
 878  *
 879  * This function request open connection for the given profile name.
 880  * This is Async API.
 881  *
 882  * @return       int - NET_ERR_NONE on success, negative values for errors
 883  * @param[in]    char *profile_name - Profile Name to be connected
 884  * @param[out]   none
 885  */
 886 /* LCOV_EXCL_START */
 887 EXPORT_API int net_open_mesh_connection_with_profile(void *handle, const char *profile_name)
 888 {
 889         __NETWORK_FUNC_ENTER__;
 890
 891         net_err_t Error = NET_ERR_NONE;
 892         network_info_t *network_info = (network_info_t *)handle;
 893
 894         NETWORK_LOG(NETWORK_LOW, "Open: %s", profile_name);
 895
 896         if (_net_check_profile_name(profile_name) != NET_ERR_NONE) {
 897                 NETWORK_LOG(NETWORK_ERROR, "Invalid profile name");
 898                 __NETWORK_FUNC_EXIT__;
 899                 return NET_ERR_INVALID_PARAM;
 900         }
 901
 902         if (network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE) {
 903                 NETWORK_LOG(NETWORK_ERROR, "Request in progress");
 904                 __NETWORK_FUNC_EXIT__;
 905                 return NET_ERR_IN_PROGRESS;
 906         }
 907
 908         network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag = TRUE;
 909         g_strlcpy(network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].profile_name,
 910                         profile_name, NET_PROFILE_NAME_LEN_MAX+1);
 911
 912         Error = _net_dbus_open_mesh_connection(network_info, profile_name);
 913         if (Error != NET_ERR_NONE) {
 914                 NETWORK_LOG(NETWORK_ERROR,
 915                                 "Failed to request open connection, Error [%s]",
 916                                 _net_print_error(Error));
 917
 918                 memset(&(network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION]),
 919                                 0, sizeof(network_request_table_t));
 920
 921                 __NETWORK_FUNC_EXIT__;
 922                 return Error;
 923         }
 924
 925         __NETWORK_FUNC_EXIT__;
 926         return NET_ERR_NONE;
 927 }
 928 /* LCOV_EXCL_STOP */
 929
 930 /*****************************************************************************
 931  * ConnMan Wi-Fi Client Interface Async Function Definition
 932  *****************************************************************************/
 933 /**
 934  * @fn   EXPORT_API int net_open_connection_with_profile(const char *profile_name)
 935  *
 936  * This function request open connection for the given profile name.
 937  * This is Async API.
 938  *
 939  * @return       int - NET_ERR_NONE on success, negative values for errors
 940  * @param[in]    char *profile_name - Profile Name to be connected
 941  * @param[out]   none
 942  */
 943 EXPORT_API int net_open_connection_with_profile(void *handle, const char *profile_name)
 944 {
 945         __NETWORK_FUNC_ENTER__;
 946
 947         net_err_t Error = NET_ERR_NONE;
 948         network_info_t *network_info = (network_info_t *)handle;
 949
 950         NETWORK_LOG(NETWORK_LOW, "Open: %s", profile_name);
 951
 952         /* LCOV_EXCL_START */
 953         if (_net_check_profile_name(profile_name) != NET_ERR_NONE) {
 954                 NETWORK_LOG(NETWORK_ERROR, "Invalid profile name");
 955                 __NETWORK_FUNC_EXIT__;
 956                 return NET_ERR_INVALID_PARAM;
 957         }
 958
 959         if (network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE) {
 960                 NETWORK_LOG(NETWORK_ERROR, "Request in progress");
 961                 __NETWORK_FUNC_EXIT__;
 962                 return NET_ERR_IN_PROGRESS;
 963         }
 964         /* LCOV_EXCL_STOP */
 965
 966         network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag = TRUE;
 967         g_strlcpy(network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].profile_name,
 968                         profile_name, NET_PROFILE_NAME_LEN_MAX+1);
 969
 970         Error = _net_dbus_open_connection(network_info, profile_name);
 971
 972         if (Error != NET_ERR_NONE) {
 973                 /* LCOV_EXCL_START */
 974                 NETWORK_LOG(NETWORK_ERROR,
 975                                 "Failed to request open connection, Error [%s]",
 976                                 _net_print_error(Error));
 977
 978                 memset(&(network_info->request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION]),
 979                                 0, sizeof(network_request_table_t));
 980
 981                 __NETWORK_FUNC_EXIT__;
 982                 return Error;
 983                 /* LCOV_EXCL_STOP */
 984         }
 985
 986         __NETWORK_FUNC_EXIT__;
 987         return NET_ERR_NONE;
 988 }
 989
 990 /* LCOV_EXCL_STOP */
 991
 992 /**
 993  * @fn   EXPORT_API int net_close_connection(const char *profile_name)
 994  *
 995  * This function requests close connection for the given profile name.
 996  * This is Async API.
 997  *
 998  * @return       int - NET_ERR_NONE on success, negative values for errors
 999  * @param[in]    char *profile_name - Connected profile Name
1000  * @param[out]   none
1001  */
1002 EXPORT_API int net_close_connection(void *handle, const char *profile_name)
1003 {
1004         __NETWORK_FUNC_ENTER__;
1005
1006         net_err_t Error = NET_ERR_NONE;
1007         gboolean is_connecting = FALSE;
1008         network_info_t *network_info = (network_info_t *)handle;
1009
1010         NETWORK_LOG(NETWORK_LOW, "profile_name [%s] passed", profile_name);
1011
1012         if (_net_check_profile_name(profile_name) != NET_ERR_NONE) {
1013                 NETWORK_LOG(NETWORK_ERROR, "Invalid profile name");
1014                 __NETWORK_FUNC_EXIT__;
1015                 return NET_ERR_INVALID_PARAM;
1016         }
1017
1018         if (network_info->request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag == TRUE) {
1019                 /* LCOV_EXCL_START */
1020                 NETWORK_LOG(NETWORK_ERROR, "Request in progress");
1021                 __NETWORK_FUNC_EXIT__;
1022                 return NET_ERR_IN_PROGRESS;
1023                 /* LCOV_EXCL_STOP */
1024         }
1025
1026         is_connecting = __net_is_connecting(network_info, profile_name);
1027
1028         network_info->request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag = TRUE;
1029         g_strlcpy(network_info->request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].profile_name,
1030                         profile_name, NET_PROFILE_NAME_LEN_MAX+1);
1031
1032         Error = _net_dbus_close_connection(network_info, profile_name);
1033         /* LCOV_EXCL_START */
1034         if (Error != NET_ERR_NONE) {
1035                 NETWORK_LOG(NETWORK_ERROR,
1036                                 "Failed to request close connection, Error [%s]",
1037                                 _net_print_error(Error));
1038
1039                 memset(&(network_info->request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION]),
1040                                 0, sizeof(network_request_table_t));
1041
1042                 __NETWORK_FUNC_EXIT__;
1043                 return Error;
1044         }
1045         /* LCOV_EXCL_STOP */
1046
1047         if (is_connecting == TRUE)
1048                 __net_abort_open_connection(network_info, profile_name);
1049
1050         __NETWORK_FUNC_EXIT__;
1051         return NET_ERR_NONE;
1052 }
1053
1054 EXPORT_API int net_start_tcpdump(void *handle)
1055 {
1056         __NETWORK_FUNC_ENTER__;
1057
1058         net_err_t Error = NET_ERR_NONE;
1059         GVariant *message = NULL;
1060         const char *method = "StartTCPDump";
1061         network_info_t *network_info = (network_info_t *)handle;
1062
1063         message = _net_invoke_dbus_method(network_info,
1064                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
1065                         NETCONFIG_TCPDUMP_INTERFACE, method, NULL, &Error);
1066
1067         /* LCOV_EXCL_START */
1068         if (message == NULL) {
1069                 NETWORK_LOG(NETWORK_ERROR, "Failed to start tcpdump\n");
1070                 __NETWORK_FUNC_EXIT__;
1071                 return Error;
1072         }
1073         /* LCOV_EXCL_STOP */
1074
1075         g_variant_unref(message);
1076
1077         __NETWORK_FUNC_EXIT__;
1078
1079         return Error;
1080 }
1081
1082 EXPORT_API int net_stop_tcpdump(void *handle)
1083 {
1084         __NETWORK_FUNC_ENTER__;
1085
1086         net_err_t Error = NET_ERR_NONE;
1087         GVariant *message = NULL;
1088         const char *method = "StopTCPDump";
1089         network_info_t *network_info = (network_info_t *)handle;
1090
1091         message = _net_invoke_dbus_method(network_info,
1092                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
1093                         NETCONFIG_TCPDUMP_INTERFACE, method, NULL, &Error);
1094
1095         /* LCOV_EXCL_START */
1096         if (message == NULL) {
1097                 NETWORK_LOG(NETWORK_ERROR, "Failed to stop tcpdump\n");
1098                 __NETWORK_FUNC_EXIT__;
1099                 return Error;
1100         }
1101         /* LCOV_EXCL_STOP */
1102
1103         g_variant_unref(message);
1104
1105         __NETWORK_FUNC_EXIT__;
1106
1107         return Error;
1108 }
1109
1110 EXPORT_API gboolean net_get_tcpdump_state(void *handle, gboolean *is_tcpdump_running)
1111 {
1112         __NETWORK_FUNC_ENTER__;
1113
1114         if (is_tcpdump_running == NULL) {
1115                 __NETWORK_FUNC_EXIT__;
1116                 return NET_ERR_INVALID_PARAM;
1117         }
1118
1119         net_err_t Error = NET_ERR_NONE;
1120         GVariant *message = NULL;
1121         const char *method = "GetTCPDumpState";
1122         network_info_t *network_info = (network_info_t *)handle;
1123
1124         message = _net_invoke_dbus_method(network_info,
1125                         NETCONFIG_SERVICE, NETCONFIG_NETWORK_PATH,
1126                         NETCONFIG_TCPDUMP_INTERFACE, method, NULL, &Error);
1127
1128         /* LCOV_EXCL_START */
1129         if (message == NULL) {
1130                 NETWORK_LOG(NETWORK_ERROR, "Failed to get tcpdump\n");
1131                 __NETWORK_FUNC_EXIT__;
1132                 return Error;
1133         }
1134         /* LCOV_EXCL_STOP */
1135
1136         g_variant_get(message, "(b)", is_tcpdump_running);
1137         g_variant_unref(message);
1138
1139         __NETWORK_FUNC_EXIT__;
1140
1141         return Error;
1142 }
1143
1144 EXPORT_API int net_get_vconf_value(void *handle, const char *key, const char *type,
1145                 int *ret, int *int_value, char **str_value)
1146 {
1147         __NETWORK_FUNC_ENTER__;
1148         net_err_t ret_error = NET_ERR_NONE;
1149         network_info_t *network_info = (network_info_t *)handle;
1150
1151         ret_error = _net_dbus_get_vconf_value(network_info, key, type, ret, int_value, str_value);
1152
1153         if (ret_error != NET_ERR_NONE)
1154                 NETWORK_LOG(NETWORK_ERROR, "net_get_vconf_value failed");
1155
1156         __NETWORK_FUNC_EXIT__;
1157         return ret_error;
1158 }
1159
1160 /**
1161  * @fn   EXPORT_API int net_close_mesh_connection(const char *profile_name)
1162  *
1163  * This function requests close connection for the given profile name.
1164  * This is Async API.
1165  *
1166  * @return       int - NET_ERR_NONE on success, negative values for errors
1167  * @param[in]    char *profile_name - Connected profile Name
1168  * @param[out]   none
1169  */
1170 /* LCOV_EXCL_START */
1171 EXPORT_API int net_close_mesh_connection(void *handle, const char *profile_name)
1172 {
1173         __NETWORK_FUNC_ENTER__;
1174
1175         net_err_t Error = NET_ERR_NONE;
1176         gboolean is_connecting = FALSE;
1177         network_info_t *network_info = (network_info_t *)handle;
1178
1179         NETWORK_LOG(NETWORK_LOW, "profile_name [%s] passed", profile_name);
1180
1181         if (_net_check_profile_name(profile_name) != NET_ERR_NONE) {
1182                 NETWORK_LOG(NETWORK_ERROR, "Invalid profile name");
1183                 __NETWORK_FUNC_EXIT__;
1184                 return NET_ERR_INVALID_PARAM;
1185         }
1186
1187         if (network_info->request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag == TRUE) {
1188                 NETWORK_LOG(NETWORK_ERROR, "Request in progress");
1189                 __NETWORK_FUNC_EXIT__;
1190                 return NET_ERR_IN_PROGRESS;
1191         }
1192
1193         is_connecting = __net_is_connecting(network_info, profile_name);
1194         if (is_connecting == FALSE) {
1195                 NETWORK_LOG(NETWORK_ERROR, "pending call in progress");
1196
1197                 __NETWORK_FUNC_EXIT__;
1198                 return NET_ERR_IN_PROGRESS;
1199         }
1200
1201         network_info->request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag = TRUE;
1202         g_strlcpy(network_info->request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].profile_name,
1203                         profile_name, NET_PROFILE_NAME_LEN_MAX+1);
1204
1205         Error = _net_dbus_close_mesh_connection(network_info, profile_name);
1206         if (Error != NET_ERR_NONE) {
1207                 NETWORK_LOG(NETWORK_ERROR,
1208                                 "Failed to request close connection, Error [%s]",
1209                                 _net_print_error(Error));
1210
1211                 memset(&(network_info->request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION]),
1212                                 0, sizeof(network_request_table_t));
1213
1214                 __NETWORK_FUNC_EXIT__;
1215                 return Error;
1216         }
1217
1218         if (is_connecting == TRUE)
1219                 __net_abort_open_connection(network_info, profile_name);
1220
1221         __NETWORK_FUNC_EXIT__;
1222         return NET_ERR_NONE;
1223 }
1224
1225 EXPORT_API int net_get_clock_update_info(void *handle, bool *state)
1226 {
1227         __NETWORK_FUNC_ENTER__;
1228         net_err_t Error = NET_ERR_NONE;
1229         network_info_t *network_info = (network_info_t *)handle;
1230
1231         Error = _net_dbus_get_clock_updated(network_info, state);
1232
1233         if (Error != NET_ERR_NONE)
1234                 NETWORK_LOG(NETWORK_ERROR, "net_get_clock_update_info failed\n");
1235
1236         __NETWORK_FUNC_EXIT__;
1237         return Error;
1238 }
1239
1240 EXPORT_API void net_set_cs_tid(int tid, void *handle)
1241 {
1242         network_info_t *network_info = (network_info_t *)handle;
1243
1244         _net_set_cs_tid(tid, network_info);
1245 }
1246
1247 EXPORT_API void net_unset_cs_tid(int tid, void *handle)
1248 {
1249         network_info_t *network_info = (network_info_t *)handle;
1250
1251         _net_unset_cs_tid(tid, network_info);
1252 }
1253 /* LCOV_EXCL_STOP */