src/libnetwork.c

   1 /*
   2  * Copyright (c) 2011-2013 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 <glib.h>
  18 #include <stdio.h>
  19 #include <stdarg.h>
  20 #include <string.h>
  21 #include <vconf/vconf.h>
  22 #include <system_info.h>
  23 #include <arpa/inet.h>
  24
  25 #include "net_connection_private.h"
  26
  27 static GSList *prof_handle_list = NULL;
  28 static GHashTable *profile_cb_table = NULL;
  29 static pthread_mutex_t g_conn_thread_mutex = PTHREAD_MUTEX_INITIALIZER;
  30
  31 struct _profile_cb_s {
  32         connection_profile_state_changed_cb callback;
  33         connection_profile_state_e state;
  34         void *user_data;
  35 };
  36
  37 struct _profile_list_s {
  38         int next;
  39         int count;
  40         net_profile_info_t *profiles;
  41 };
  42
  43 static struct _profile_list_s profile_iterator = {0, 0, NULL};
  44 static bool connection_is_feature_checked[CONNECTION_SUPPORTED_FEATURE_MAX] = {0, };
  45 static bool connection_feature_supported[CONNECTION_SUPPORTED_FEATURE_MAX] = {0, };
  46
  47 //LCOV_EXCL_START
  48 static connection_error_e __libnet_convert_to_cp_error_type(net_err_t err_type)
  49 {
  50         switch (err_type) {
  51         case NET_ERR_NONE:
  52                 return CONNECTION_ERROR_NONE;
  53         case NET_ERR_APP_ALREADY_REGISTERED:
  54                 return CONNECTION_ERROR_INVALID_OPERATION;
  55         case NET_ERR_APP_NOT_REGISTERED:
  56                 return CONNECTION_ERROR_INVALID_OPERATION;
  57         case NET_ERR_NO_ACTIVE_CONNECTIONS:
  58                 return CONNECTION_ERROR_NO_CONNECTION;
  59         case NET_ERR_ACTIVE_CONNECTION_EXISTS:
  60                 return CONNECTION_ERROR_ALREADY_EXISTS;
  61         case NET_ERR_CONNECTION_DHCP_FAILED:
  62                 return CONNECTION_ERROR_DHCP_FAILED;
  63         case NET_ERR_CONNECTION_INVALID_KEY:
  64                 return CONNECTION_ERROR_INVALID_KEY;
  65         case NET_ERR_IN_PROGRESS:
  66                 return CONNECTION_ERROR_NOW_IN_PROGRESS;
  67         case NET_ERR_OPERATION_ABORTED:
  68                 return CONNECTION_ERROR_OPERATION_ABORTED;
  69         case NET_ERR_TIME_OUT:
  70                 return CONNECTION_ERROR_NO_REPLY;
  71         case NET_ERR_ACCESS_DENIED:
  72                 return CONNECTION_ERROR_PERMISSION_DENIED;
  73         default:
  74                 return CONNECTION_ERROR_OPERATION_FAILED;
  75         }
  76 }
  77
  78 static const char *__libnet_convert_cp_error_type_to_string(connection_error_e err_type)
  79 {
  80         switch (err_type) {
  81         case CONNECTION_ERROR_NONE:
  82                 return "NONE";
  83         case CONNECTION_ERROR_INVALID_PARAMETER:
  84                 return "INVALID_PARAMETER";
  85         case CONNECTION_ERROR_OUT_OF_MEMORY:
  86                 return "OUT_OF_MEMORY";
  87         case CONNECTION_ERROR_INVALID_OPERATION:
  88                 return "INVALID_OPERATION";
  89         case CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED:
  90                 return "ADDRESS_FAMILY_NOT_SUPPORTED";
  91         case CONNECTION_ERROR_OPERATION_FAILED:
  92                 return "OPERATION_FAILED";
  93         case CONNECTION_ERROR_ITERATOR_END:
  94                 return "ITERATOR_END";
  95         case CONNECTION_ERROR_NO_CONNECTION:
  96                 return "NO_CONNECTION";
  97         case CONNECTION_ERROR_NOW_IN_PROGRESS:
  98                 return "NOW_IN_PROGRESS";
  99         case CONNECTION_ERROR_ALREADY_EXISTS:
 100                 return "ALREADY_EXISTS";
 101         case CONNECTION_ERROR_OPERATION_ABORTED:
 102                 return "OPERATION_ABORTED";
 103         case CONNECTION_ERROR_DHCP_FAILED:
 104                 return "DHCP_FAILED";
 105         case CONNECTION_ERROR_INVALID_KEY:
 106                 return "INVALID_KEY";
 107         case CONNECTION_ERROR_NO_REPLY:
 108                 return "NO_REPLY";
 109         case CONNECTION_ERROR_PERMISSION_DENIED:
 110                 return "PERMISSION_DENIED";
 111         case CONNECTION_ERROR_NOT_SUPPORTED:
 112                 return "NOT_SUPPORTED";
 113         case CONNECTION_ERROR_ALREADY_INITIALIZED:
 114                 return "ALREADY_INITIALIZED";
 115         case CONNECTION_ERROR_NOT_INITIALIZED:
 116                 return "NOT_INITIALIZED";
 117         }
 118
 119         return "UNKNOWN";
 120 }
 121
 122 static const char *__libnet_convert_cp_state_to_string(connection_profile_state_e state)
 123 {
 124         switch (state) {
 125         case CONNECTION_PROFILE_STATE_DISCONNECTED:
 126                 return "DISCONNECTED";
 127         case CONNECTION_PROFILE_STATE_ASSOCIATION:
 128                 return "ASSOCIATION";
 129         case CONNECTION_PROFILE_STATE_CONFIGURATION:
 130                 return "CONFIGURATION";
 131         case CONNECTION_PROFILE_STATE_CONNECTED:
 132                 return "CONNECTED";
 133         default:
 134                 return "UNKNOWN";
 135         }
 136 }
 137
 138 static void __libnet_state_changed_cb(char *profile_name, connection_profile_state_e state)
 139 {
 140         struct _profile_cb_s *cb_info;
 141
 142         if (profile_name == NULL)
 143                 return;
 144
 145         cb_info = g_hash_table_lookup(profile_cb_table, profile_name);
 146         if (cb_info == NULL)
 147                 return;
 148
 149         if (cb_info->state == state)
 150                 return;
 151
 152         cb_info->state = state;
 153
 154         if (state < 0 || cb_info->callback == NULL)
 155                 return;
 156
 157         cb_info->callback(cb_info->state, cb_info->user_data);
 158 }
 159
 160 static void __libnet_clear_profile_list(struct _profile_list_s *profile_list)
 161 {
 162         if (profile_list->count > 0)
 163                 g_free(profile_list->profiles);
 164
 165         profile_list->count = 0;
 166         profile_list->next = 0;
 167         profile_list->profiles = NULL;
 168 }
 169
 170 static void __libnet_evt_cb(net_event_info_t *event_cb, void *user_data)
 171 {
 172         bool is_requested = false;
 173         connection_error_e result = CONNECTION_ERROR_NONE;
 174         connection_handle_s *conn_handle = (connection_handle_s *)user_data;
 175
 176         switch (event_cb->Event) {
 177         case NET_EVENT_OPEN_RSP:
 178                 is_requested = true;
 179                 /* fall through */
 180         case NET_EVENT_OPEN_IND:
 181                 result = __libnet_convert_to_cp_error_type(event_cb->Error);
 182                 CONNECTION_LOG(CONNECTION_INFO, "Connection opened %s[%s]",
 183                                         (is_requested) ? "RSP" : "IND",
 184                                         __libnet_convert_cp_error_type_to_string(result));
 185
 186                 if (is_requested) {
 187                         if (conn_handle->opened_callback) {
 188                                 conn_handle->opened_callback(result,
 189                                         conn_handle->opened_user_data);
 190
 191                                 conn_handle->opened_callback = NULL;
 192                                 conn_handle->opened_user_data = NULL;
 193                         }
 194                 }
 195
 196                 switch (event_cb->Error) {
 197                 case NET_ERR_NONE:
 198                 case NET_ERR_ACTIVE_CONNECTION_EXISTS:
 199                         CONNECTION_LOG(CONNECTION_INFO, "Successfully open connection");
 200
 201                         __libnet_state_changed_cb(event_cb->ProfileName, CONNECTION_PROFILE_STATE_CONNECTED);
 202                         return;
 203                 default:
 204                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to open connection[%s]",
 205                                                 __libnet_convert_cp_error_type_to_string(result));
 206                 }
 207
 208                 __libnet_state_changed_cb(event_cb->ProfileName, CONNECTION_PROFILE_STATE_DISCONNECTED);
 209
 210                 break;
 211         case NET_EVENT_CLOSE_RSP:
 212                 is_requested = true;
 213                 /* fall through */
 214         case NET_EVENT_CLOSE_IND:
 215                 result = __libnet_convert_to_cp_error_type(event_cb->Error);
 216                 CONNECTION_LOG(CONNECTION_INFO, "Connection closed %s[%s]",
 217                                         (is_requested) ? "RSP" : "IND",
 218                                         __libnet_convert_cp_error_type_to_string(result));
 219
 220                 if (is_requested) {
 221                         if (conn_handle->closed_callback) {
 222                                 conn_handle->closed_callback(result,
 223                                         conn_handle->closed_user_data);
 224
 225                                 conn_handle->closed_callback = NULL;
 226                                 conn_handle->closed_user_data = NULL;
 227                         }
 228                 }
 229
 230                 switch (event_cb->Error) {
 231                 case NET_ERR_NONE:
 232                         CONNECTION_LOG(CONNECTION_INFO, "Successfully closed connection");
 233
 234                         __libnet_state_changed_cb(event_cb->ProfileName, CONNECTION_PROFILE_STATE_DISCONNECTED);
 235                         return;
 236                 default:
 237                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to close connection[%s]",
 238                                                         __libnet_convert_cp_error_type_to_string(result));
 239                 }
 240
 241                 break;
 242         case NET_EVENT_NET_STATE_IND:
 243                 CONNECTION_LOG(CONNECTION_INFO, "State changed IND");
 244
 245                 if (event_cb->Datalength != sizeof(net_state_type_t))
 246                         return;
 247
 248                 net_state_type_t *profile_state = (net_state_type_t *)event_cb->Data;
 249                 connection_profile_state_e cp_state = _profile_convert_to_cp_state(*profile_state);
 250
 251                 CONNECTION_LOG(CONNECTION_INFO, "state: %s", __libnet_convert_cp_state_to_string(cp_state));
 252                 SECURE_CONNECTION_LOG(CONNECTION_INFO, "profile name: %s", event_cb->ProfileName);
 253
 254                 __libnet_state_changed_cb(event_cb->ProfileName, cp_state);
 255
 256                 break;
 257         case NET_EVENT_CELLULAR_SET_DEFAULT_RSP:
 258                 result = __libnet_convert_to_cp_error_type(event_cb->Error);
 259                 CONNECTION_LOG(CONNECTION_INFO, "Got set default profile RSP %d", result);
 260                 if (conn_handle->set_default_callback) {
 261                         conn_handle->set_default_callback(result,
 262                                 conn_handle->set_default_user_data);
 263
 264                         conn_handle->set_default_callback = NULL;
 265                         conn_handle->set_default_user_data = NULL;
 266                 }
 267                 break;
 268         case NET_EVENT_CELLULAR_RESET_DEFAULT_RSP:
 269                 result = __libnet_convert_to_cp_error_type(event_cb->Error);
 270                 CONNECTION_LOG(CONNECTION_INFO, "Got reset default profile RSP %d", result);
 271                 if (conn_handle->reset_callback) {
 272                         conn_handle->reset_callback(result,
 273                                 conn_handle->reset_user_data);
 274
 275                         conn_handle->reset_callback = NULL;
 276                         conn_handle->reset_user_data = NULL;
 277                 }
 278                 break;
 279         case NET_EVENT_ETHERNET_CABLE_ATTACHED:
 280                 CONNECTION_LOG(CONNECTION_INFO, "Got Ethernet cable Attached Indication\n");
 281                 if (conn_handle->ethernet_cable_state_changed_callback) {
 282                         conn_handle->ethernet_cable_state_changed_callback(CONNECTION_ETHERNET_CABLE_ATTACHED,
 283                                 conn_handle->ethernet_cable_state_changed_user_data);
 284                 }
 285                 break;
 286         case NET_EVENT_ETHERNET_CABLE_DETACHED:
 287                 CONNECTION_LOG(CONNECTION_INFO, "Got Ethernet cable detached Indication\n");
 288                 if (conn_handle->ethernet_cable_state_changed_callback) {
 289                         conn_handle->ethernet_cable_state_changed_callback(CONNECTION_ETHERNET_CABLE_DETACHED,
 290                                 conn_handle->ethernet_cable_state_changed_user_data);
 291                 }
 292                 break;
 293         case NET_EVENT_NETWORK_TYPE_CHANGED:
 294                 CONNECTION_LOG(CONNECTION_INFO, "Got Network Type Changed Indication");
 295                 int *state = (int *) event_cb->Data;
 296                 if (conn_handle->type_changed_callback) {
 297                         int type = CONNECTION_TYPE_DISCONNECTED;
 298
 299                         switch (*state) {
 300                         case VCONFKEY_NETWORK_CELLULAR:
 301                                 type = CONNECTION_TYPE_CELLULAR;
 302                                 break;
 303                         case VCONFKEY_NETWORK_WIFI:
 304                                 type = CONNECTION_TYPE_WIFI;
 305                                 break;
 306                         case VCONFKEY_NETWORK_ETHERNET:
 307                                 type = CONNECTION_TYPE_ETHERNET;
 308                                 break;
 309                         case VCONFKEY_NETWORK_BLUETOOTH:
 310                                 type = CONNECTION_TYPE_BT;
 311                                 break;
 312                         case VCONFKEY_NETWORK_DEFAULT_PROXY:
 313                                 type = CONNECTION_TYPE_NET_PROXY;
 314                                 break;
 315                         default:
 316                                 type = CONNECTION_TYPE_DISCONNECTED;
 317                                 break;
 318                         }
 319
 320                         conn_handle->type_changed_callback(type,
 321                                 conn_handle->type_changed_user_data);
 322                 }
 323                 break;
 324         case NET_EVENT_IPV4_ADDRESS_CHANGED:
 325                 CONNECTION_LOG(CONNECTION_INFO, "Got IPv4 Address Changed Indication");
 326                 if (conn_handle->ip_changed_callback) {
 327                         char *ipv4_addr = NULL;
 328                         char *ipv6_addr = NULL;
 329                         char *addr = (char *)event_cb->Data;
 330
 331                         ipv4_addr = g_strdup(addr);
 332                         ipv6_addr = vconf_get_str(VCONFKEY_NETWORK_IP6);
 333                         if (ipv6_addr == NULL)
 334                                 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
 335                                                 "vconf_get_str(VCONFKEY_NETWORK_IP6) failed");
 336
 337                         conn_handle->ip_changed_callback(ipv4_addr, ipv6_addr,
 338                                 conn_handle->ip_changed_user_data);
 339
 340                         g_free(ipv4_addr);
 341                         g_free(ipv6_addr);
 342                 }
 343                 break;
 344         case NET_EVENT_IPV6_ADDRESS_CHANGED:
 345                 CONNECTION_LOG(CONNECTION_INFO, "Got IPv6 Address Changed Indication");
 346                 if (conn_handle->ip_changed_callback) {
 347                         char *ipv4_addr = NULL;
 348                         char *ipv6_addr = NULL;
 349                         char *addr = (char *)event_cb->Data;
 350
 351                         ipv6_addr = g_strdup(addr);
 352                         ipv4_addr = vconf_get_str(VCONFKEY_NETWORK_IP);
 353                         if (ipv4_addr == NULL)
 354                                 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
 355                                                 "vconf_get_str(VCONFKEY_NETWORK_IP) failed");
 356
 357                         conn_handle->ip_changed_callback(ipv4_addr, ipv6_addr,
 358                                 conn_handle->ip_changed_user_data);
 359
 360                         g_free(ipv4_addr);
 361                         g_free(ipv6_addr);
 362                 }
 363                 break;
 364         case NET_EVENT_PROXY_ADDRESS_CHANGED:
 365                 CONNECTION_LOG(CONNECTION_INFO, "Got Proxy Changed Indication");
 366                 char *proxy_addr = (char *)event_cb->Data;
 367
 368                 if (conn_handle->proxy_changed_callback) {
 369                         conn_handle->proxy_changed_callback(proxy_addr, NULL,
 370                                 conn_handle->proxy_changed_user_data);
 371                 }
 372                 break;
 373         case NET_EVENT_INTERNET_ONLINE_IND:
 374         case NET_EVENT_INTERNET_OFFLINE_IND:
 375                 CONNECTION_LOG(CONNECTION_INFO, "Got Internet State Changed Indication: %s",
 376                                 event_cb->Event == NET_EVENT_INTERNET_ONLINE_IND ? "Online" : "Offline");
 377                 net_device_t *device_type = (net_device_t *) event_cb->Data;
 378
 379                 if (conn_handle->internet_state_changed_callback) {
 380                         net_profile_info_t active_profile;
 381                         int rv;
 382
 383                         rv = net_get_active_net_info(conn_handle->network_info_handle, &active_profile);
 384
 385                         if (rv == NET_ERR_NO_SERVICE && event_cb->Event == NET_EVENT_INTERNET_OFFLINE_IND) {
 386                                 conn_handle->internet_state_changed_callback(CONNECTION_INTERNET_STATE_OFFLINE,
 387                                         conn_handle->internet_state_changed_user_data); //LCOV_EXCL_LINE
 388                                 break;
 389                         } else if (rv == NET_ERR_ACCESS_DENIED) {
 390                                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 391                                 break;
 392                         } else if (rv != NET_ERR_NONE) {
 393                                 CONNECTION_LOG(CONNECTION_ERROR, "Unable to get Default profile handle"); //LCOV_EXCL_LINE
 394                                 break; //LCOV_EXCL_LINE
 395                         }
 396
 397                         if (event_cb->Event == NET_EVENT_INTERNET_ONLINE_IND) {
 398                                 if (active_profile.ProfileState == NET_STATE_TYPE_ONLINE &&
 399                                                 active_profile.profile_type == *device_type)
 400                                         conn_handle->internet_state_changed_callback(CONNECTION_INTERNET_STATE_ONLINE,
 401                                                         conn_handle->internet_state_changed_user_data);
 402                         } else {
 403                                 if (active_profile.ProfileState != NET_STATE_TYPE_ONLINE)
 404                                         conn_handle->internet_state_changed_callback(CONNECTION_INTERNET_STATE_OFFLINE,
 405                                                         conn_handle->internet_state_changed_user_data);
 406                         }
 407                 }
 408                 break;
 409
 410         default:
 411                 break;
 412         }
 413 }
 414 //LCOV_EXCL_STOP
 415
 416 static int __libnet_get_connected_count(struct _profile_list_s *profile_list)
 417 {
 418         int count = 0;
 419         int i = 0;
 420
 421         for (; i < profile_list->count; i++) {
 422                 if (profile_list->profiles[i].ProfileState == NET_STATE_TYPE_ONLINE ||
 423                     profile_list->profiles[i].ProfileState == NET_STATE_TYPE_READY)
 424                         count++;
 425         }
 426
 427         return count;
 428 }
 429
 430 static void __libnet_copy_connected_profile(net_profile_info_t **dest, struct _profile_list_s *source)
 431 {
 432         int i = 0;
 433
 434         for (; i < source->count; i++) {
 435                 if (source->profiles[i].ProfileState == NET_STATE_TYPE_ONLINE ||
 436                     source->profiles[i].ProfileState == NET_STATE_TYPE_READY) {
 437                         memcpy(*dest, &source->profiles[i], sizeof(net_profile_info_t));
 438                         (*dest)++;
 439                 }
 440         }
 441 }
 442
 443 //LCOV_EXCL_START
 444 static int __libnet_get_default_count(struct _profile_list_s *profile_list)
 445 {
 446         int count = 0;
 447         int i = 0;
 448
 449         for (; i < profile_list->count; i++) {
 450                 if (profile_list->profiles[i].profile_type == NET_DEVICE_CELLULAR) {
 451                         if (profile_list->profiles[i].ProfileInfo.Pdp.DefaultConn == TRUE)
 452                                 count++;
 453                 }
 454         }
 455
 456         return count;
 457 }
 458
 459 static void __libnet_copy_default_profile(net_profile_info_t **dest, struct _profile_list_s *source)
 460 {
 461         int i = 0;
 462
 463         for (; i < source->count; i++) {
 464                 if (source->profiles[i].profile_type == NET_DEVICE_CELLULAR) {
 465                         if (source->profiles[i].ProfileInfo.Pdp.DefaultConn == TRUE) {
 466                                 memcpy(*dest, &source->profiles[i], sizeof(net_profile_info_t));
 467                                 (*dest)++;
 468                         }
 469                 }
 470         }
 471 }
 472 //LCOV_EXCL_STOP
 473
 474 int _connection_libnet_init(connection_handle_s *conn_handle)
 475 {
 476         int rv;
 477
 478         rv = net_register_client(&(conn_handle->network_info_handle),
 479                                 (net_event_cb_t)__libnet_evt_cb, conn_handle);
 480         if (rv != NET_ERR_NONE)
 481                 return rv;
 482
 483         if (profile_cb_table == NULL)
 484                 profile_cb_table = g_hash_table_new_full(g_str_hash, g_str_equal, g_free, g_free);
 485
 486         return NET_ERR_NONE;
 487 }
 488
 489 bool _connection_libnet_deinit(connection_handle_s *conn_handle)
 490 {
 491         net_deregister_client(conn_handle->network_info_handle);
 492
 493         if (profile_cb_table) {
 494                 g_hash_table_destroy(profile_cb_table);
 495                 profile_cb_table = NULL;
 496         }
 497
 498         __libnet_clear_profile_list(&profile_iterator);
 499
 500         if (prof_handle_list) {
 501                 g_slist_free_full(prof_handle_list, g_free);
 502                 prof_handle_list = NULL;
 503         }
 504
 505         return true;
 506 }
 507
 508 void _connection_set_cs_tid(int tid, connection_handle_s *conn_handle)
 509 {
 510         net_set_cs_tid(tid, conn_handle->network_info_handle);
 511 }
 512
 513 void _connection_unset_cs_tid(int tid, connection_handle_s *conn_handle)
 514 {
 515         net_unset_cs_tid(tid, conn_handle->network_info_handle);
 516 }
 517
 518 bool _connection_libnet_check_profile_validity(connection_profile_h profile)
 519 {
 520         GSList *list;
 521         int i = 0;
 522
 523         if (profile == NULL)
 524                 return false;
 525
 526         for (list = prof_handle_list; list; list = list->next)
 527                 if (profile == list->data) return true;
 528
 529         for (; i < profile_iterator.count; i++)
 530                 if (profile == &profile_iterator.profiles[i]) return true;
 531
 532         return false;
 533 }
 534
 535 int _connection_libnet_get_metered_state(connection_handle_s *conn_handle, bool* is_metered)
 536 {
 537         int rv = 0;
 538         int status = 0;
 539
 540         rv = net_get_metered_state(conn_handle->network_info_handle, &status);
 541         if (rv == NET_ERR_ACCESS_DENIED) {
 542                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 543                 return CONNECTION_ERROR_PERMISSION_DENIED;
 544         } else if (rv != NET_ERR_NONE) {
 545                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get metered state[%d]", rv);
 546                 return CONNECTION_ERROR_OPERATION_FAILED;
 547         }
 548
 549         if (status == 1)
 550                 *is_metered = true;
 551         else
 552                 *is_metered = false;
 553         return CONNECTION_ERROR_NONE;
 554 }
 555
 556 int _connection_libnet_get_wifi_state(connection_handle_s *conn_handle, connection_wifi_state_e *state)
 557 {
 558         int rv;
 559         net_wifi_state_t wlan_state;
 560
 561         rv = net_get_wifi_state(conn_handle->network_info_handle, &wlan_state);
 562         if (rv == NET_ERR_ACCESS_DENIED) {
 563                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 564                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 565         } else if (rv != NET_ERR_NONE) {
 566                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get Wi-Fi state[%d]", rv); //LCOV_EXCL_LINE
 567                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 568         }
 569
 570         switch (wlan_state) {
 571         case WIFI_OFF:
 572                 *state = CONNECTION_WIFI_STATE_DEACTIVATED;
 573                 break;
 574         case WIFI_ON:
 575         case WIFI_ASSOCIATION:
 576         case WIFI_CONFIGURATION:
 577                 *state = CONNECTION_WIFI_STATE_DISCONNECTED;
 578                 break;
 579         case WIFI_CONNECTED:
 580         case WIFI_DISCONNECTING:
 581                 *state = CONNECTION_WIFI_STATE_CONNECTED;
 582                 break;
 583         default:
 584                 CONNECTION_LOG(CONNECTION_ERROR, "Unknown Wi-Fi state"); //LCOV_EXCL_LINE
 585                 return CONNECTION_ERROR_INVALID_OPERATION; //LCOV_EXCL_LINE
 586         }
 587
 588         return CONNECTION_ERROR_NONE;
 589 }
 590
 591 //LCOV_EXCL_START
 592 int _connection_libnet_get_ethernet_state(connection_handle_s *conn_handle,
 593                         connection_ethernet_state_e *state)
 594 {
 595         int rv;
 596         struct _profile_list_s ethernet_profiles = {0, 0, NULL};
 597         rv = net_get_profile_list(conn_handle->network_info_handle,
 598                         NET_DEVICE_ETHERNET, &ethernet_profiles.profiles,
 599                         &ethernet_profiles.count);
 600         if (rv == NET_ERR_ACCESS_DENIED) {
 601                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 602                 return CONNECTION_ERROR_PERMISSION_DENIED;
 603         }
 604
 605         if (ethernet_profiles.count == 0) {
 606                 *state = CONNECTION_ETHERNET_STATE_DEACTIVATED;
 607                 return CONNECTION_ERROR_NONE;
 608         }
 609
 610         switch (ethernet_profiles.profiles->ProfileState) {
 611         case NET_STATE_TYPE_ONLINE:
 612         case NET_STATE_TYPE_READY:
 613                 *state = CONNECTION_ETHERNET_STATE_CONNECTED;
 614                 break;
 615         case NET_STATE_TYPE_IDLE:
 616         case NET_STATE_TYPE_FAILURE:
 617         case NET_STATE_TYPE_ASSOCIATION:
 618         case NET_STATE_TYPE_CONFIGURATION:
 619         case NET_STATE_TYPE_DISCONNECT:
 620                 *state = CONNECTION_ETHERNET_STATE_DISCONNECTED;
 621                 break;
 622         default:
 623                 __libnet_clear_profile_list(&ethernet_profiles);
 624                 return CONNECTION_ERROR_OPERATION_FAILED;
 625         }
 626
 627         __libnet_clear_profile_list(&ethernet_profiles);
 628
 629         return CONNECTION_ERROR_NONE;
 630 }
 631
 632 int _connection_libnet_get_ethernet_cable_state(connection_handle_s *conn_handle,
 633                         connection_ethernet_cable_state_e* state)
 634 {
 635         int rv = 0;
 636         int status = 0;
 637
 638         rv = net_get_ethernet_cable_state(conn_handle->network_info_handle, &status);
 639         if (rv == NET_ERR_ACCESS_DENIED) {
 640                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied");
 641                 return CONNECTION_ERROR_PERMISSION_DENIED;
 642         } else if (rv != NET_ERR_NONE) {
 643                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get ethernet cable state[%d]", rv);
 644                 return CONNECTION_ERROR_OPERATION_FAILED;
 645         }
 646
 647         if (status == 1)
 648                 *state = CONNECTION_ETHERNET_CABLE_ATTACHED;
 649         else
 650                 *state = CONNECTION_ETHERNET_CABLE_DETACHED;
 651         return CONNECTION_ERROR_NONE;
 652 }
 653 //LCOV_EXCL_STOP
 654
 655 int _connection_libnet_get_bluetooth_state(connection_handle_s *conn_handle, connection_bt_state_e *state)
 656 {
 657         int i = 0;
 658         int rv = 0;
 659         struct _profile_list_s bluetooth_profiles = {0, 0, NULL};
 660         rv = net_get_profile_list(conn_handle->network_info_handle,
 661                         NET_DEVICE_BLUETOOTH, &bluetooth_profiles.profiles,
 662                         &bluetooth_profiles.count);
 663         if (rv == NET_ERR_ACCESS_DENIED) {
 664                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 665                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 666         }
 667
 668         if (bluetooth_profiles.count == 0) {
 669                 *state = CONNECTION_BT_STATE_DEACTIVATED;
 670                 return CONNECTION_ERROR_NONE;
 671         }
 672
 673         //LCOV_EXCL_START
 674         for (; i < bluetooth_profiles.count; i++) {
 675                 switch (bluetooth_profiles.profiles[i].ProfileState) {
 676                 case NET_STATE_TYPE_ONLINE:
 677                 case NET_STATE_TYPE_READY:
 678                         *state = CONNECTION_BT_STATE_CONNECTED;
 679                         goto done;
 680                 case NET_STATE_TYPE_IDLE:
 681                 case NET_STATE_TYPE_FAILURE:
 682                 case NET_STATE_TYPE_ASSOCIATION:
 683                 case NET_STATE_TYPE_CONFIGURATION:
 684                 case NET_STATE_TYPE_DISCONNECT:
 685                         *state = CONNECTION_BT_STATE_DISCONNECTED;
 686                         break;
 687                 default:
 688                         __libnet_clear_profile_list(&bluetooth_profiles);
 689                         return CONNECTION_ERROR_OPERATION_FAILED;
 690                 }
 691         }
 692         //LCOV_EXCL_STOP
 693
 694 done:
 695         __libnet_clear_profile_list(&bluetooth_profiles);
 696
 697         return CONNECTION_ERROR_NONE;
 698 }
 699
 700 int _connection_libnet_get_profile_iterator(connection_handle_s *conn_handle,
 701                         connection_iterator_type_e type, connection_profile_iterator_h* profile_iter_h)
 702 {
 703         int count = 0;
 704         int rv;
 705         net_profile_info_t *profiles = NULL;
 706
 707         struct _profile_list_s profile_list = {0, 0, NULL};
 708
 709         __libnet_clear_profile_list(&profile_iterator);
 710
 711         rv = net_get_all_profile_list(conn_handle->network_info_handle,
 712                         &profile_list.profiles, &profile_list.count);
 713         if (rv == NET_ERR_ACCESS_DENIED) {
 714                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 715                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 716         } else if (rv != NET_ERR_NO_SERVICE && rv != NET_ERR_NONE)
 717                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 718
 719         *profile_iter_h = &profile_iterator;
 720
 721         switch (type) {
 722         case CONNECTION_ITERATOR_TYPE_REGISTERED:
 723                 count = profile_list.count;
 724                 CONNECTION_LOG(CONNECTION_INFO, "Total profile count : %d", count);
 725                 if (count == 0)
 726                         return CONNECTION_ERROR_NONE;
 727
 728                 profiles = g_try_new0(net_profile_info_t, count);
 729                 if (profiles == NULL) {
 730                         __libnet_clear_profile_list(&profile_list);
 731                         return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 732                 }
 733
 734                 profile_iterator.profiles = profiles;
 735
 736                 memcpy(profiles, profile_list.profiles, sizeof(net_profile_info_t) * count);
 737
 738                 break;
 739         case CONNECTION_ITERATOR_TYPE_CONNECTED:
 740                 count = __libnet_get_connected_count(&profile_list);
 741                 CONNECTION_LOG(CONNECTION_INFO, "Total connected profile count : %d", count);
 742                 if (count == 0)
 743                         return CONNECTION_ERROR_NONE;
 744
 745                 profiles = g_try_new0(net_profile_info_t, count);
 746                 if (profiles == NULL) {
 747                         __libnet_clear_profile_list(&profile_list);
 748                         return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 749                 }
 750
 751                 profile_iterator.profiles = profiles;
 752
 753                 __libnet_copy_connected_profile(&profiles, &profile_list);
 754
 755                 break;
 756         case CONNECTION_ITERATOR_TYPE_DEFAULT:
 757                 count = __libnet_get_default_count(&profile_list);
 758                 CONNECTION_LOG(CONNECTION_INFO, "Total default profile count : %d", count); //LCOV_EXCL_LINE
 759                 if (count == 0)
 760                         return CONNECTION_ERROR_NONE;
 761
 762                 profiles = g_try_new0(net_profile_info_t, count);
 763                 if (profiles == NULL) {
 764                         __libnet_clear_profile_list(&profile_list);
 765                         return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 766                 }
 767
 768                 profile_iterator.profiles = profiles;
 769
 770                 __libnet_copy_default_profile(&profiles, &profile_list);
 771
 772                 break;
 773         }
 774
 775         __libnet_clear_profile_list(&profile_list);
 776
 777         profile_iterator.count = count;
 778
 779         return CONNECTION_ERROR_NONE;
 780 }
 781
 782 int _connection_libnet_get_iterator_next(connection_profile_iterator_h profile_iter_h, connection_profile_h *profile)
 783 {
 784         if (profile_iter_h != &profile_iterator)
 785                 return CONNECTION_ERROR_INVALID_PARAMETER;
 786
 787         if (profile_iterator.count <= profile_iterator.next)
 788                 return CONNECTION_ERROR_ITERATOR_END;
 789
 790         *profile = &profile_iterator.profiles[profile_iterator.next];
 791         profile_iterator.next++;
 792
 793         return CONNECTION_ERROR_NONE;
 794 }
 795
 796 bool _connection_libnet_iterator_has_next(connection_profile_iterator_h profile_iter_h)
 797 {
 798         if (profile_iter_h != &profile_iterator)
 799                 return false;
 800
 801         if (profile_iterator.count <= profile_iterator.next)
 802                 return false;
 803
 804         return true;
 805 }
 806
 807 int _connection_libnet_destroy_iterator(connection_profile_iterator_h profile_iter_h)
 808 {
 809         if (profile_iter_h != &profile_iterator)
 810                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 811
 812         __libnet_clear_profile_list(&profile_iterator);
 813
 814         return CONNECTION_ERROR_NONE;
 815 }
 816
 817 int _connection_libnet_get_current_profile(connection_handle_s *conn_handle,
 818                         connection_profile_h *profile)
 819 {
 820         net_profile_info_t active_profile;
 821         int rv;
 822
 823         rv = net_get_active_net_info(conn_handle->network_info_handle, &active_profile);
 824         if (rv == NET_ERR_NO_SERVICE)
 825                 return CONNECTION_ERROR_NO_CONNECTION; //LCOV_EXCL_LINE
 826         else if (rv == NET_ERR_ACCESS_DENIED) {
 827                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 828                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 829         } else if (rv != NET_ERR_NONE)
 830                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 831
 832         *profile = g_try_malloc0(sizeof(net_profile_info_t));
 833         if (*profile == NULL)
 834                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 835
 836         memcpy(*profile, &active_profile, sizeof(net_profile_info_t));
 837         prof_handle_list = g_slist_append(prof_handle_list, *profile);
 838
 839         return CONNECTION_ERROR_NONE;
 840 }
 841
 842 int _connection_libnet_reset_profile(connection_handle_s *conn_handle,
 843                 connection_reset_option_e type, connection_cellular_subscriber_id_e id)
 844 {
 845         int rv;
 846
 847         rv = net_reset_profile(conn_handle->network_info_handle, type, id);
 848         if (rv == NET_ERR_ACCESS_DENIED)
 849                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 850         else if (rv != NET_ERR_NONE)
 851                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 852
 853         return CONNECTION_ERROR_NONE;
 854 }
 855
 856 int _connection_libnet_open_profile(connection_handle_s *conn_handle,
 857                         connection_profile_h profile)
 858 {
 859         int rv;
 860
 861         if (!(_connection_libnet_check_profile_validity(profile))) {
 862                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 863                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 864         }
 865
 866         net_profile_info_t *profile_info = profile;
 867
 868         if (profile_info->profile_type == NET_DEVICE_MESH)
 869                 rv = net_open_mesh_connection_with_profile(conn_handle->network_info_handle,
 870                                 profile_info->ProfileName);
 871         else
 872                 rv = net_open_connection_with_profile(conn_handle->network_info_handle,
 873                                 profile_info->ProfileName);
 874
 875         if (rv == NET_ERR_ACCESS_DENIED)
 876                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 877         else if (rv != NET_ERR_NONE)
 878                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 879
 880         return CONNECTION_ERROR_NONE;
 881 }
 882
 883 int _connection_libnet_get_cellular_service_profile(connection_handle_s *conn_handle,
 884                 connection_cellular_service_type_e type, connection_profile_h *profile)
 885 {
 886         int i = 0, j = 0;
 887         int rv = NET_ERR_NONE;
 888 #if defined TIZEN_DUALSIM_ENABLE
 889         int default_subscriber_id = 0;
 890         char subscriber_id[3];
 891 #endif
 892
 893         struct _profile_list_s cellular_profiles = { 0, 0, NULL };
 894         net_service_type_t service_type = _connection_profile_convert_to_libnet_cellular_service_type(type);
 895
 896         rv = net_get_profile_list(conn_handle->network_info_handle,
 897                         NET_DEVICE_CELLULAR, &cellular_profiles.profiles,
 898                         &cellular_profiles.count);
 899         if (rv == NET_ERR_ACCESS_DENIED) {
 900                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 901                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 902         } else if (rv != NET_ERR_NONE) {
 903                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile list (%d)", rv); //LCOV_EXCL_LINE
 904                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 905         }
 906
 907 #if defined TIZEN_DUALSIM_ENABLE
 908         if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
 909                                                 &default_subscriber_id) != 0) {
 910                 CONNECTION_LOG(CONNECTION_ERROR,
 911                                                 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
 912                 __libnet_clear_profile_list(&cellular_profiles); //LCOV_EXCL_LINE
 913                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 914         }
 915
 916         g_snprintf(subscriber_id, sizeof(subscriber_id), "%d", default_subscriber_id);
 917 #endif
 918
 919         for (i = 0; i < cellular_profiles.count; i++)
 920                 if (cellular_profiles.profiles[i].ProfileInfo.Pdp.ServiceType == service_type)
 921 #if defined TIZEN_DUALSIM_ENABLE
 922                         if (g_str_has_suffix(
 923                                         cellular_profiles.profiles[i].ProfileInfo.Pdp.PSModemPath,
 924                                         subscriber_id) == TRUE)
 925 #endif
 926                                 break;
 927
 928         if (i >= cellular_profiles.count) {
 929                 __libnet_clear_profile_list(&cellular_profiles); //LCOV_EXCL_LINE
 930                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 931         }
 932
 933         *profile = g_try_malloc0(sizeof(net_profile_info_t));
 934         if (*profile == NULL) {
 935                 __libnet_clear_profile_list(&cellular_profiles); //LCOV_EXCL_LINE
 936                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
 937         }
 938
 939         memcpy(*profile, &cellular_profiles.profiles[i], sizeof(net_profile_info_t));
 940
 941         if (cellular_profiles.profiles[i].ProfileInfo.Pdp.DefaultConn)
 942                 goto done;
 943
 944         //LCOV_EXCL_START
 945         if (type != CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET &&
 946             type != CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET)
 947                 goto done;
 948
 949         for (j = 0; j < cellular_profiles.count; j++) {
 950                 if (i == j)
 951                         continue;
 952
 953                 if (cellular_profiles.profiles[j].ProfileInfo.Pdp.ServiceType != service_type)
 954                         continue;
 955
 956                 if (cellular_profiles.profiles[j].ProfileInfo.Pdp.DefaultConn) {
 957                         memcpy(*profile, &cellular_profiles.profiles[j], sizeof(net_profile_info_t));
 958                         goto done;
 959                 }
 960         }
 961         //LCOV_EXCL_STOP
 962
 963 done:
 964         __libnet_clear_profile_list(&cellular_profiles);
 965         prof_handle_list = g_slist_append(prof_handle_list, *profile);
 966
 967         return CONNECTION_ERROR_NONE;
 968 }
 969
 970 int _connection_libnet_set_cellular_service_profile_sync(connection_handle_s *conn_handle,
 971                         connection_cellular_service_type_e type, connection_profile_h profile)
 972 {
 973         int rv;
 974
 975         if (!(_connection_libnet_check_profile_validity(profile))) {
 976                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
 977                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 978         }
 979
 980         net_profile_info_t *profile_info = profile;
 981         connection_cellular_service_type_e service_type;
 982
 983         service_type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
 984
 985         if (service_type != type)
 986                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
 987
 988         rv = net_set_default_cellular_service_profile(conn_handle->network_info_handle,
 989                                 profile_info->ProfileName);
 990         if (rv == NET_ERR_ACCESS_DENIED) {
 991                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 992                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 993         } else if (rv != NET_ERR_NONE)
 994                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 995
 996         return CONNECTION_ERROR_NONE;
 997 }
 998
 999 int _connection_libnet_set_cellular_service_profile_async(connection_handle_s *conn_handle,
1000                         connection_cellular_service_type_e type, connection_profile_h profile)
1001 {
1002         int rv;
1003
1004         if (!(_connection_libnet_check_profile_validity(profile))) {
1005                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1006                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1007         }
1008
1009         net_profile_info_t *profile_info = profile;
1010         connection_cellular_service_type_e service_type;
1011
1012         service_type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1013
1014         if (service_type != type)
1015                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1016
1017         rv = net_set_default_cellular_service_profile_async(conn_handle->network_info_handle,
1018                                 profile_info->ProfileName);
1019         if (rv == NET_ERR_ACCESS_DENIED) {
1020                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1021         } else if (rv != NET_ERR_NONE)
1022                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1023
1024         return CONNECTION_ERROR_NONE;
1025 }
1026
1027 int _connection_libnet_close_profile(connection_handle_s *conn_handle, connection_profile_h profile)
1028 {
1029         int rv;
1030
1031         if (!(_connection_libnet_check_profile_validity(profile))) {
1032                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1033                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1034         }
1035
1036         net_profile_info_t *profile_info = profile;
1037
1038         if (profile_info->profile_type == NET_DEVICE_MESH)
1039                 rv = net_close_mesh_connection(conn_handle->network_info_handle, profile_info->ProfileName);
1040         else
1041                 rv = net_close_connection(conn_handle->network_info_handle, profile_info->ProfileName);
1042
1043         if (rv == NET_ERR_ACCESS_DENIED)
1044                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1045         else if (rv != NET_ERR_NONE)
1046                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1047
1048         return CONNECTION_ERROR_NONE;
1049 }
1050
1051 int _connection_libnet_add_route(connection_handle_s *conn_handle,
1052                         const char *interface_name, const char *host_address)
1053 {
1054         int rv;
1055         char *endstr = NULL;
1056         int address_family = 0;
1057
1058         address_family = AF_INET;
1059
1060         endstr = strrchr(host_address, '.');
1061         if (endstr == NULL ||
1062                         strcmp(endstr, ".0") == 0 ||
1063                         strncmp(host_address, "0.", 2) == 0 ||
1064                         strstr(host_address, "255") != NULL) {
1065                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed\n"); //LCOV_EXCL_LINE
1066                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1067         }
1068
1069         rv = net_add_route(conn_handle->network_info_handle,
1070                                 host_address, interface_name, address_family);
1071         if (rv == NET_ERR_ACCESS_DENIED) {
1072                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1073                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1074         } else if (rv != NET_ERR_NONE)
1075                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1076
1077         return CONNECTION_ERROR_NONE;
1078 }
1079
1080 int _connection_libnet_remove_route(connection_handle_s *conn_handle,
1081                         const char *interface_name, const char *host_address)
1082 {
1083         int rv;
1084         char *endstr = strrchr(host_address, '.');
1085         int address_family = 0;
1086
1087         address_family = AF_INET;
1088
1089         endstr = strrchr(host_address, '.');
1090         if (endstr == NULL ||
1091                 strcmp(endstr, ".0") == 0 ||
1092                 strncmp(host_address, "0.", 2) == 0 ||
1093                 strstr(host_address, ".0.") != NULL || strstr(host_address, "255") != NULL) {
1094                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed"); //LCOV_EXCL_LINE
1095                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1096         }
1097
1098         rv = net_remove_route(conn_handle->network_info_handle,
1099                                 host_address, interface_name, address_family);
1100         if (rv == NET_ERR_ACCESS_DENIED) {
1101                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1102                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1103         } else if (rv != NET_ERR_NONE)
1104                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1105
1106         return CONNECTION_ERROR_NONE;
1107 }
1108
1109 int _connection_libnet_add_route_ipv6(connection_handle_s *conn_handle,
1110                         const char *interface_name, const char *host_address, const char *gateway)
1111 {
1112         int rv;
1113         int address_family = 0;
1114
1115         address_family = AF_INET6;
1116
1117         if (strncmp(host_address, "fe80:", 5) == 0 ||
1118                 strncmp(host_address, "ff00:", 5) == 0 ||
1119                 strncmp(host_address, "::", 2) == 0) {
1120                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed\n"); //LCOV_EXCL_LINE
1121                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1122         }
1123
1124         rv = net_add_route_ipv6(conn_handle->network_info_handle,
1125                                 host_address, interface_name, address_family, gateway);
1126         if (rv == NET_ERR_ACCESS_DENIED) {
1127                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1128                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1129         } else if (rv != NET_ERR_NONE)
1130                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1131
1132         return CONNECTION_ERROR_NONE;
1133 }
1134
1135 int _connection_libnet_remove_route_ipv6(connection_handle_s *conn_handle,
1136                         const char *interface_name, const char *host_address, const char *gateway)
1137 {
1138         int rv;
1139         int address_family = 0;
1140
1141         address_family = AF_INET6;
1142
1143         if (strncmp(host_address, "fe80:", 5) == 0 ||
1144                 strncmp(host_address, "ff00:", 5) == 0 ||
1145                 strncmp(host_address, "::", 2) == 0) {
1146                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed\n"); //LCOV_EXCL_LINE
1147                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1148         }
1149
1150         rv = net_remove_route_ipv6(conn_handle->network_info_handle,
1151                                 host_address, interface_name, address_family, gateway);
1152         if (rv == NET_ERR_ACCESS_DENIED) {
1153                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1154                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1155         } else if (rv != NET_ERR_NONE)
1156                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1157
1158         return CONNECTION_ERROR_NONE;
1159 }
1160
1161 int _connection_libnet_add_route_entry(connection_handle_s *conn_handle,
1162                 connection_address_family_e address_family, const char *interface_name,
1163                 const char *host_address, const char *gateway)
1164 {
1165         int rv;
1166         char *endstr = NULL;
1167         int address_family_type = 0;
1168
1169         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1170                 address_family_type = AF_INET;
1171         else
1172                 address_family_type = AF_INET6;
1173
1174         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1175
1176                 endstr = strrchr(host_address, '.');
1177                 if (endstr == NULL ||
1178                                 strcmp(endstr, ".0") == 0 ||
1179                                 strncmp(host_address, "0.", 2) == 0 ||
1180                                 strstr(host_address, "255") != NULL) {
1181                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed\n"); //LCOV_EXCL_LINE
1182                         return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1183                 }
1184
1185                 rv = net_add_route_entry(conn_handle->network_info_handle,
1186                                 host_address, interface_name, address_family_type, gateway);
1187                 if (rv == NET_ERR_ACCESS_DENIED) {
1188                         CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1189                         return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1190                 } else if (rv != NET_ERR_NONE)
1191                         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1192
1193         } else {
1194
1195                 if (strncmp(host_address, "fe80:", 5) == 0 ||
1196                         strncmp(host_address, "ff00:", 5) == 0 ||
1197                         strncmp(host_address, "::", 2) == 0) {
1198                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed\n"); //LCOV_EXCL_LINE
1199                         return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1200                 }
1201
1202                 rv = net_add_route_ipv6(conn_handle->network_info_handle,
1203                                 host_address, interface_name, address_family_type, gateway);
1204                 if (rv == NET_ERR_ACCESS_DENIED) {
1205                         CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1206                         return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1207                 } else if (rv != NET_ERR_NONE)
1208                         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1209         }
1210
1211         return CONNECTION_ERROR_NONE;
1212 }
1213
1214 int _connection_libnet_remove_route_entry(connection_handle_s *conn_handle,
1215                 connection_address_family_e address_family, const char *interface_name,
1216                 const char *host_address, const char *gateway)
1217 {
1218         int rv;
1219         char *endstr = strrchr(host_address, '.');
1220         int address_family_type = 0;
1221
1222         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
1223                 address_family_type = AF_INET;
1224         else
1225                 address_family_type = AF_INET6;
1226
1227         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1228                 endstr = strrchr(host_address, '.');
1229                 if (endstr == NULL ||
1230                         strcmp(endstr, ".0") == 0 ||
1231                         strncmp(host_address, "0.", 2) == 0 ||
1232                         strstr(host_address, ".0.") != NULL || strstr(host_address, "255") != NULL) {
1233                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed"); //LCOV_EXCL_LINE
1234                         return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1235                 }
1236
1237                 rv = net_remove_route_entry(conn_handle->network_info_handle, host_address,
1238                                         interface_name, address_family_type, gateway);
1239                 if (rv == NET_ERR_ACCESS_DENIED) {
1240                         CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1241                         return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1242                 } else if (rv != NET_ERR_NONE)
1243                         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1244
1245         } else {
1246
1247                 if (strncmp(host_address, "fe80:", 5) == 0 ||
1248                         strncmp(host_address, "ff00:", 5) == 0 ||
1249                         strncmp(host_address, "::", 2) == 0) {
1250                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid IP address Passed\n"); //LCOV_EXCL_LINE
1251                         return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1252                 }
1253
1254                 rv = net_remove_route_ipv6(conn_handle->network_info_handle, host_address,
1255                                         interface_name, address_family_type, gateway);
1256                 if (rv == NET_ERR_ACCESS_DENIED) {
1257                         CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1258                         return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1259                 } else if (rv != NET_ERR_NONE)
1260                         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1261         }
1262
1263         return CONNECTION_ERROR_NONE;
1264 }
1265
1266 void _connection_libnet_add_to_profile_list(connection_profile_h profile)
1267 {
1268         prof_handle_list = g_slist_append(prof_handle_list, profile);
1269 }
1270
1271 void _connection_libnet_remove_from_profile_list(connection_profile_h profile)
1272 {
1273         prof_handle_list = g_slist_remove(prof_handle_list, profile);
1274         g_free(profile);
1275 }
1276
1277 bool _connection_libnet_add_to_profile_cb_list(connection_profile_h profile,
1278                 connection_profile_state_changed_cb callback, void *user_data)
1279 {
1280         net_profile_info_t *profile_info = profile;
1281         char *profile_name = g_strdup(profile_info->ProfileName);
1282
1283         struct _profile_cb_s *profile_cb_info = g_try_malloc0(sizeof(struct _profile_cb_s));
1284         if (profile_cb_info == NULL) {
1285                 g_free(profile_name); //LCOV_EXCL_LINE
1286                 return false; //LCOV_EXCL_LINE
1287         }
1288
1289         profile_cb_info->callback = callback;
1290         profile_cb_info->user_data = user_data;
1291         profile_cb_info->state = _profile_convert_to_cp_state(profile_info->ProfileState);
1292
1293         g_hash_table_replace(profile_cb_table, profile_name, profile_cb_info);
1294
1295         return true;
1296 }
1297
1298 bool _connection_libnet_remove_from_profile_cb_list(connection_profile_h profile)
1299 {
1300         net_profile_info_t *profile_info = profile;
1301
1302         if (g_hash_table_remove(profile_cb_table, profile_info->ProfileName) == TRUE)
1303                 return true;
1304
1305         return false; //LCOV_EXCL_LINE
1306 }
1307
1308 int _connection_libnet_set_statistics(connection_handle_s *conn_handle,
1309                         net_device_t device_type, net_statistics_type_e statistics_type)
1310 {
1311         int rv;
1312         rv = net_set_statistics(conn_handle->network_info_handle,
1313                                 device_type, statistics_type);
1314         if (rv == NET_ERR_ACCESS_DENIED) {
1315                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1316                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1317         } else if (rv != NET_ERR_NONE)
1318                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1319
1320         return CONNECTION_ERROR_NONE;
1321 }
1322
1323 int _connection_libnet_get_statistics(connection_handle_s *conn_handle,
1324                         net_statistics_type_e statistics_type, unsigned long long *size)
1325 {
1326         int rv;
1327         rv = net_get_statistics(conn_handle->network_info_handle,
1328                                 NET_DEVICE_WIFI, statistics_type, size);
1329         if (rv == NET_ERR_ACCESS_DENIED) {
1330                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1331                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1332         } else if (rv != NET_ERR_NONE)
1333                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1334
1335         return CONNECTION_ERROR_NONE;
1336 }
1337
1338 int _connection_libnet_set_cellular_subscriber_id(connection_profile_h profile,
1339                 connection_cellular_subscriber_id_e sim_id)
1340 {
1341         char *modem_path = NULL;
1342         net_profile_info_t *profile_info = (net_profile_info_t *)profile;
1343
1344         if (net_get_cellular_modem_object_path(&modem_path, sim_id) != NET_ERR_NONE) {
1345                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get subscriber[%d]", sim_id); //LCOV_EXCL_LINE
1346                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1347         }
1348
1349         if (!modem_path) {
1350                 CONNECTION_LOG(CONNECTION_ERROR, "NULL modem object path"); //LCOV_EXCL_LINE
1351                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1352         }
1353
1354         g_strlcpy(profile_info->ProfileInfo.Pdp.PSModemPath, modem_path,
1355                                 NET_PROFILE_NAME_LEN_MAX);
1356         g_free(modem_path);
1357
1358         return CONNECTION_ERROR_NONE;
1359 }
1360
1361 int _connection_libnet_check_get_privilege(void)
1362 {
1363         int rv;
1364
1365         rv = net_check_get_privilege();
1366         if (rv == NET_ERR_ACCESS_DENIED) {
1367                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1368                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1369         } else if (rv != NET_ERR_NONE)
1370                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1371
1372         return CONNECTION_ERROR_NONE;
1373 }
1374
1375 int _connection_libnet_check_profile_privilege(void)
1376 {
1377         int rv;
1378
1379         rv = net_check_profile_privilege();
1380         if (rv == NET_ERR_ACCESS_DENIED) {
1381                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
1382                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
1383         } else if (rv != NET_ERR_NONE)
1384                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1385
1386         return CONNECTION_ERROR_NONE;
1387 }
1388
1389 bool __libnet_check_feature_supported(const char *key, connection_supported_feature_e feature)
1390 {
1391         if (!connection_is_feature_checked[feature]) {
1392                 if (system_info_get_platform_bool(key, &connection_feature_supported[feature]) < 0) {
1393                         CONNECTION_LOG(CONNECTION_ERROR, "Error - Feature getting from System Info"); //LCOV_EXCL_LINE
1394                         set_last_result(CONNECTION_ERROR_OPERATION_FAILED); //LCOV_EXCL_LINE
1395                         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1396                 }
1397                 connection_is_feature_checked[feature] = true;
1398         }
1399         return connection_feature_supported[feature];
1400 }
1401
1402 int _connection_check_feature_supported(const char *feature_name, ...)
1403 {
1404         va_list list;
1405         const char *key;
1406         bool value = false;
1407         bool feature_supported = false;
1408
1409         va_start(list, feature_name);
1410         key = feature_name;
1411         while (1) {
1412                 if (strcmp(key, TELEPHONY_FEATURE) == 0)
1413                         value = __libnet_check_feature_supported(key, CONNECTION_SUPPORTED_FEATURE_TELEPHONY);
1414                 if (strcmp(key, WIFI_FEATURE) == 0)
1415                         value = __libnet_check_feature_supported(key, CONNECTION_SUPPORTED_FEATURE_WIFI);
1416                 if (strcmp(key, TETHERING_BLUETOOTH_FEATURE) == 0)
1417                         value = __libnet_check_feature_supported(key, CONNECTION_SUPPORTED_FEATURE_TETHERING_BLUETOOTH);
1418                 if (strcmp(key, ETHERNET_FEATURE) == 0)
1419                         value = __libnet_check_feature_supported(key, CONNECTION_SUPPORTED_FEATURE_ETHERNET);
1420
1421                 feature_supported |= value;
1422                 key = va_arg(list, const char *);
1423                 if (!key) break;
1424         }
1425         if (!feature_supported) {
1426                 CONNECTION_LOG(CONNECTION_ERROR, "Error - Feature is not supported");
1427                 set_last_result(CONNECTION_ERROR_NOT_SUPPORTED);
1428                 va_end(list);
1429                 return CONNECTION_ERROR_NOT_SUPPORTED;
1430         }
1431
1432         va_end(list);
1433         set_last_result(CONNECTION_ERROR_NONE);
1434         return CONNECTION_ERROR_NONE;
1435 }
1436
1437 int _connection_libnet_start_tcpdump(connection_handle_s *conn_handle)
1438 {
1439         connection_error_e result = CONNECTION_ERROR_NONE;
1440         net_err_t ret = NET_ERR_NONE;
1441
1442         ret = net_start_tcpdump(conn_handle->network_info_handle);
1443         result = __libnet_convert_to_cp_error_type(ret);
1444
1445         return result;
1446 }
1447
1448 int _connection_libnet_stop_tcpdump(connection_handle_s *conn_handle)
1449 {
1450         connection_error_e result = CONNECTION_ERROR_NONE;
1451         net_err_t ret = NET_ERR_NONE;
1452
1453         ret = net_stop_tcpdump(conn_handle->network_info_handle);
1454         result = __libnet_convert_to_cp_error_type(ret);
1455
1456         return result;
1457 }
1458
1459 int _connection_libnet_get_tcpdump_state(connection_handle_s *conn_handle,
1460                         gboolean *tcpdump_state)
1461 {
1462         connection_error_e result = CONNECTION_ERROR_NONE;
1463         net_err_t ret = NET_ERR_NONE;
1464
1465         ret = net_get_tcpdump_state(conn_handle->network_info_handle, tcpdump_state);
1466         result = __libnet_convert_to_cp_error_type(ret);
1467
1468         return result;
1469 }
1470
1471 void _connection_lock(void)
1472 {
1473         pthread_mutex_lock(&g_conn_thread_mutex);
1474 }
1475
1476 void _connection_unlock(void)
1477 {
1478         pthread_mutex_unlock(&g_conn_thread_mutex);
1479 }