src/connection_profile.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 <stdlib.h>
  20 #include <string.h>
  21 #include <arpa/inet.h>
  22 #include <vconf/vconf.h>
  23
  24 #include "net_connection_private.h"
  25 #include "connection_extension.h"
  26
  27 #define HTTP_PROXY "http_proxy"
  28 #define MAX_PREFIX_LENGTH 6
  29
  30 static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
  31 {
  32         switch (profile_info->profile_type) {
  33         case NET_DEVICE_CELLULAR:
  34                 return &profile_info->ProfileInfo.Pdp.net_info;
  35         case NET_DEVICE_WIFI:
  36                 return &profile_info->ProfileInfo.Wlan.net_info;
  37         case NET_DEVICE_ETHERNET:
  38                 return &profile_info->ProfileInfo.Ethernet.net_info; //LCOV_EXCL_LINE
  39         case NET_DEVICE_BLUETOOTH:
  40                 return &profile_info->ProfileInfo.Bluetooth.net_info;
  41         case NET_DEVICE_MESH:
  42                 return &profile_info->ProfileInfo.Mesh.net_info;
  43         case NET_DEVICE_DEFAULT:
  44         case NET_DEVICE_USB:
  45         case NET_DEVICE_UNKNOWN:
  46         case NET_DEVICE_MAX:
  47         default:
  48                 return NULL;
  49         }
  50 }
  51
  52 static char *__profile_convert_ip_to_string(net_addr_t *ip_addr, connection_address_family_e address_family)
  53 {
  54         unsigned char *ipaddr = NULL;
  55         char *ipstr = NULL;
  56
  57         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
  58                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
  59                 ipstr = g_try_malloc0(INET_ADDRSTRLEN);
  60                 if (ipstr == NULL)
  61                         return NULL;
  62
  63                 inet_ntop(AF_INET, ipaddr, ipstr, INET_ADDRSTRLEN);
  64         } else {
  65                 //LCOV_EXCL_START
  66                 ipaddr = (unsigned char *)&ip_addr->Data.Ipv6.s6_addr;
  67                 ipstr = g_try_malloc0(INET6_ADDRSTRLEN);
  68                 if (ipstr == NULL)
  69                                 return NULL;
  70
  71                 inet_ntop(AF_INET6, ipaddr, ipstr, INET6_ADDRSTRLEN);
  72                 //LCOV_EXCL_STOP
  73         }
  74
  75         return ipstr;
  76 }
  77
  78 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
  79 {
  80         int default_subscriber_id = 0;
  81         connection_profile_h profile = NULL;
  82
  83         profile_info->profile_type = NET_DEVICE_CELLULAR;
  84         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  85         profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_UNKNOWN;
  86         profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_UNKNOWN;
  87         profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  88         profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  89         g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
  90
  91         if (vconf_get_int(VCONF_TELEPHONY_DEFAULT_DATA_SERVICE,
  92                                         &default_subscriber_id) != 0)
  93                 CONNECTION_LOG(CONNECTION_ERROR, //LCOV_EXCL_LINE
  94                                                 "Failed to get VCONF_TELEPHONY_DEFAULT_DATA_SERVICE");
  95
  96         profile = (connection_profile_h)profile_info;
  97         _connection_libnet_set_cellular_subscriber_id(profile, default_subscriber_id);
  98 }
  99
 100 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
 101 {
 102         profile_info->profile_type = NET_DEVICE_WIFI;
 103         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
 104         profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
 105         profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
 106         profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
 107         profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
 108         profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
 109 }
 110
 111 //LCOV_EXCL_START
 112 static char* __profile_get_ethernet_proxy(void)
 113 {
 114         char *proxy;
 115
 116         proxy = vconf_get_str(VCONFKEY_NETWORK_PROXY);
 117
 118         if (proxy == NULL) {
 119                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
 120                 return NULL;
 121         }
 122
 123         return proxy;
 124 }
 125 //LCOV_EXCL_STOP
 126
 127 static unsigned char __profile_convert_netmask_to_prefix_len(const char *netmask)
 128 {
 129         if (netmask == NULL)
 130                 return 0;
 131
 132         in_addr_t mask = inet_network(netmask);
 133         in_addr_t host = ~mask;
 134         unsigned char prefix_len = 0;
 135
 136         /* a valid netmask must be 2^n - 1 */
 137         if ((host & (host + 1)) != 0)
 138                 return -1;
 139
 140         for (; mask; mask <<= 1)
 141                 ++prefix_len;
 142
 143         return prefix_len;
 144 }
 145
 146 static in_addr_t __profile_convert_prefix_len_to_netmask(int prefix_len)
 147 {
 148         return (prefix_len ? (in_addr_t) 0xFFFFFFFFu >> (32 - prefix_len) : 0);
 149 }
 150
 151 //LCOV_EXCL_START
 152 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
 153 {
 154         switch (svc_type) {
 155         case NET_SERVICE_INTERNET:
 156                 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
 157         case NET_SERVICE_MMS:
 158                 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
 159         case NET_SERVICE_PREPAID_INTERNET:
 160                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
 161         case NET_SERVICE_PREPAID_MMS:
 162                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
 163         case NET_SERVICE_TETHERING:
 164                 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
 165         case NET_SERVICE_APPLICATION:
 166                 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
 167         default:
 168                 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
 169         }
 170 }
 171
 172 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
 173 {
 174         connection_profile_state_e cp_state;
 175
 176         switch (state) {
 177         case NET_STATE_TYPE_ONLINE:
 178         case NET_STATE_TYPE_READY:
 179                 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
 180                 break;
 181         case NET_STATE_TYPE_IDLE:
 182         case NET_STATE_TYPE_FAILURE:
 183         case NET_STATE_TYPE_DISCONNECT:
 184                 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
 185                 break;
 186         case NET_STATE_TYPE_ASSOCIATION:
 187                 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
 188                 break;
 189         case NET_STATE_TYPE_CONFIGURATION:
 190                 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
 191                 break;
 192         default:
 193                 cp_state = -1;
 194         }
 195
 196         return cp_state;
 197 }
 198
 199 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
 200 {
 201         switch (svc_type) {
 202         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
 203                 return NET_SERVICE_INTERNET;
 204         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
 205                 return NET_SERVICE_MMS;
 206         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
 207                 return NET_SERVICE_PREPAID_INTERNET;
 208         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
 209                 return NET_SERVICE_PREPAID_MMS;
 210         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
 211                 return NET_SERVICE_TETHERING;
 212         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
 213                 return NET_SERVICE_APPLICATION;
 214         default:
 215                 return NET_SERVICE_UNKNOWN;
 216         }
 217 }
 218
 219 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
 220 {
 221         net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
 222
 223         switch (state) {
 224         case CONNECTION_PROFILE_STATE_CONNECTED:
 225                 libnet_state = NET_STATE_TYPE_ONLINE;
 226                 break;
 227         case CONNECTION_PROFILE_STATE_DISCONNECTED:
 228                 libnet_state = NET_STATE_TYPE_IDLE;
 229                 break;
 230         case CONNECTION_PROFILE_STATE_ASSOCIATION:
 231                 libnet_state = NET_STATE_TYPE_ASSOCIATION;
 232                 break;
 233         case CONNECTION_PROFILE_STATE_CONFIGURATION:
 234                 libnet_state = NET_STATE_TYPE_CONFIGURATION;
 235                 break;
 236         }
 237
 238         return libnet_state;
 239 }
 240 //LCOV_EXCL_STOP
 241
 242 /* Connection profile ********************************************************/
 243 EXPORT_API int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
 244 {
 245         CONN_LOCK;
 246
 247         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE);
 248
 249         if (type == CONNECTION_PROFILE_TYPE_CELLULAR)
 250                 CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
 251         else if (type == CONNECTION_PROFILE_TYPE_WIFI)
 252                 CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
 253
 254         if (type != CONNECTION_PROFILE_TYPE_CELLULAR &&
 255              type != CONNECTION_PROFILE_TYPE_WIFI) {
 256                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 257                 CONN_UNLOCK;
 258                 return CONNECTION_ERROR_INVALID_PARAMETER;
 259         }
 260
 261         if (profile == NULL) {
 262                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 263                 CONN_UNLOCK;
 264                 return CONNECTION_ERROR_INVALID_PARAMETER;
 265         }
 266
 267         int rv  = _connection_libnet_check_profile_privilege();
 268         if (rv == CONNECTION_ERROR_PERMISSION_DENIED) {
 269                 CONN_UNLOCK;
 270                 return rv;
 271         } else if (rv != CONNECTION_ERROR_NONE) {
 272                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to create profile"); //LCOV_EXCL_LINE
 273                 CONN_UNLOCK;
 274                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 275         }
 276
 277         net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
 278         if (profile_info == NULL) {
 279                 CONN_UNLOCK;
 280                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 281         }
 282
 283         if (type == CONNECTION_PROFILE_TYPE_CELLULAR) {
 284                 if (keyword == NULL) {
 285                         CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 286                         g_free(profile_info);
 287                         CONN_UNLOCK;
 288                         return CONNECTION_ERROR_INVALID_PARAMETER;
 289                 }
 290                 __profile_init_cellular_profile(profile_info, keyword);
 291         } else if (type ==  CONNECTION_PROFILE_TYPE_WIFI) {
 292                 __profile_init_wifi_profile(profile_info);
 293         }
 294
 295         *profile = (connection_profile_h)profile_info;
 296         _connection_libnet_add_to_profile_list(*profile);
 297
 298         CONN_UNLOCK;
 299         return CONNECTION_ERROR_NONE;
 300 }
 301
 302 EXPORT_API int connection_profile_destroy(connection_profile_h profile)
 303 {
 304         CONN_LOCK;
 305
 306         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 307
 308         if (!(_connection_libnet_check_profile_validity(profile))) {
 309                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 310                 CONN_UNLOCK;
 311                 return CONNECTION_ERROR_INVALID_PARAMETER;
 312         }
 313
 314         _connection_libnet_remove_from_profile_list(profile);
 315
 316         CONN_UNLOCK;
 317         return CONNECTION_ERROR_NONE;
 318 }
 319
 320 EXPORT_API int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
 321 {
 322         CONN_LOCK;
 323
 324         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 325
 326         if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
 327                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 328                 CONN_UNLOCK;
 329                 return CONNECTION_ERROR_INVALID_PARAMETER;
 330         }
 331
 332         *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
 333         if (*cloned_profile == NULL) {
 334                 CONN_UNLOCK;
 335                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 336         }
 337
 338         memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
 339         _connection_libnet_add_to_profile_list(*cloned_profile);
 340
 341         CONN_UNLOCK;
 342         return CONNECTION_ERROR_NONE;
 343 }
 344
 345 EXPORT_API int connection_profile_get_id(connection_profile_h profile, char** profile_id)
 346 {
 347         CONN_LOCK;
 348
 349         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 350
 351         if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
 352                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 353                 CONN_UNLOCK;
 354                 return CONNECTION_ERROR_INVALID_PARAMETER;
 355         }
 356
 357         net_profile_info_t *profile_info = profile;
 358
 359         char *prof_id = strrchr(profile_info->ProfileName, '/');
 360         if (prof_id == NULL) {
 361                 CONN_UNLOCK;
 362                 return CONNECTION_ERROR_INVALID_PARAMETER;
 363         }
 364
 365         prof_id++;
 366         *profile_id = g_strdup(prof_id);
 367
 368         if (*profile_id == NULL) {
 369                 CONN_UNLOCK;
 370                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 371         }
 372
 373         CONN_UNLOCK;
 374         return CONNECTION_ERROR_NONE;
 375 }
 376
 377 EXPORT_API int connection_profile_get_name(connection_profile_h profile, char** profile_name)
 378 {
 379         CONN_LOCK;
 380
 381         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 382
 383         if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
 384                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 385                 CONN_UNLOCK;
 386                 return CONNECTION_ERROR_INVALID_PARAMETER;
 387         }
 388
 389         net_profile_info_t *profile_info = profile;
 390
 391         switch (profile_info->profile_type) {
 392         case NET_DEVICE_CELLULAR:
 393                 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
 394                 break;
 395         case NET_DEVICE_WIFI:
 396                 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 397                 break;
 398         case NET_DEVICE_ETHERNET:
 399                 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName); //LCOV_EXCL_LINE
 400                 break; //LCOV_EXCL_LINE
 401         case NET_DEVICE_BLUETOOTH: {
 402                 char *bt_name = strrchr(profile_info->ProfileName, '/');
 403                 if (bt_name == NULL) {
 404                         CONN_UNLOCK;
 405                         return CONNECTION_ERROR_INVALID_PARAMETER;
 406                 }
 407
 408                 bt_name++;
 409                 *profile_name = g_strdup(bt_name);
 410         } break;
 411         case NET_DEVICE_MESH:
 412                 *profile_name = g_strdup(profile_info->ProfileInfo.Mesh.essid);
 413                 break;
 414         default:
 415                 CONN_UNLOCK;
 416                 return CONNECTION_ERROR_INVALID_PARAMETER;
 417         }
 418
 419         if (*profile_name == NULL) {
 420                 CONN_UNLOCK;
 421                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 422         }
 423
 424         CONN_UNLOCK;
 425         return CONNECTION_ERROR_NONE;
 426 }
 427
 428 EXPORT_API int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e *type)
 429 {
 430         CONN_LOCK;
 431
 432         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 433
 434         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 435                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 436                 CONN_UNLOCK;
 437                 return CONNECTION_ERROR_INVALID_PARAMETER;
 438         }
 439
 440         net_profile_info_t *profile_info = profile;
 441
 442         switch (profile_info->profile_type) {
 443         case NET_DEVICE_CELLULAR:
 444                 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
 445                 break;
 446         case NET_DEVICE_WIFI:
 447                 *type = CONNECTION_PROFILE_TYPE_WIFI;
 448                 break;
 449         case NET_DEVICE_ETHERNET:
 450                 *type = CONNECTION_PROFILE_TYPE_ETHERNET; //LCOV_EXCL_LINE
 451                 break; //LCOV_EXCL_LINE
 452         case NET_DEVICE_BLUETOOTH:
 453                 *type = CONNECTION_PROFILE_TYPE_BT;
 454                 break;
 455         case NET_DEVICE_MESH:
 456                 *type = CONNECTION_PROFILE_TYPE_MESH;
 457                 break;
 458         default:
 459                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type");
 460                 CONN_UNLOCK;
 461                 return CONNECTION_ERROR_OPERATION_FAILED;
 462         }
 463
 464         CONN_UNLOCK;
 465         return CONNECTION_ERROR_NONE;
 466 }
 467
 468 EXPORT_API int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
 469 {
 470         CONN_LOCK;
 471
 472         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 473
 474         if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
 475                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 476                 CONN_UNLOCK;
 477                 return CONNECTION_ERROR_INVALID_PARAMETER;
 478         }
 479
 480         net_profile_info_t *profile_info = profile;
 481         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 482         if (net_info == NULL) {
 483                 CONN_UNLOCK;
 484                 return CONNECTION_ERROR_INVALID_PARAMETER;
 485         }
 486
 487         *interface_name = g_strdup(net_info->DevName);
 488         if (*interface_name == NULL) {
 489                 CONN_UNLOCK;
 490                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 491         }
 492
 493         CONN_UNLOCK;
 494         return CONNECTION_ERROR_NONE;
 495 }
 496
 497 EXPORT_API int connection_profile_refresh(connection_profile_h profile)
 498 {
 499         int rv;
 500
 501         CONN_LOCK;
 502
 503         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 504
 505         if (!(_connection_libnet_check_profile_validity(profile))) {
 506                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 507                 CONN_UNLOCK;
 508                 return CONNECTION_ERROR_INVALID_PARAMETER;
 509         }
 510
 511         net_profile_info_t profile_info_local;
 512         net_profile_info_t *profile_info = profile;
 513
 514         rv = net_get_profile_info(NULL, profile_info->ProfileName, &profile_info_local);
 515         if (rv == NET_ERR_ACCESS_DENIED) {
 516                 CONNECTION_LOG(CONNECTION_ERROR, "Access denied"); //LCOV_EXCL_LINE
 517                 CONN_UNLOCK;
 518                 return CONNECTION_ERROR_PERMISSION_DENIED; //LCOV_EXCL_LINE
 519         } else if (rv != NET_ERR_NONE) {
 520                 CONNECTION_LOG(CONNECTION_ERROR, "Failed to get profile information"); //LCOV_EXCL_LINE
 521                 CONN_UNLOCK;
 522                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
 523         }
 524
 525         memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
 526
 527         CONN_UNLOCK;
 528         return CONNECTION_ERROR_NONE;
 529 }
 530
 531 EXPORT_API int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
 532 {
 533         CONN_LOCK;
 534
 535         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 536
 537         if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
 538                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 539                 CONN_UNLOCK;
 540                 return CONNECTION_ERROR_INVALID_PARAMETER;
 541         }
 542
 543         net_profile_info_t *profile_info = profile;
 544         *state = _profile_convert_to_cp_state(profile_info->ProfileState);
 545
 546         CONN_UNLOCK;
 547         return CONNECTION_ERROR_NONE;
 548 }
 549
 550 EXPORT_API int connection_profile_get_ip_config_type(connection_profile_h profile,
 551                 connection_address_family_e address_family, connection_ip_config_type_e *type)
 552 {
 553         net_ip_config_type_t profile_type;
 554
 555         CONN_LOCK;
 556
 557         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 558
 559         if (!(_connection_libnet_check_profile_validity(profile)) ||
 560             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 561              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 562             type == NULL) {
 563                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 564                 CONN_UNLOCK;
 565                 return CONNECTION_ERROR_INVALID_PARAMETER;
 566         }
 567
 568         net_profile_info_t *profile_info = profile;
 569         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 570         if (net_info == NULL) {
 571                 CONN_UNLOCK;
 572                 return CONNECTION_ERROR_OPERATION_FAILED;
 573         }
 574
 575         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 576                 profile_type = net_info->IpConfigType;
 577         else
 578                 profile_type = net_info->IpConfigType6;
 579
 580         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 581                 switch (profile_type) {
 582                 //LCOV_EXCL_START
 583                 case NET_IP_CONFIG_TYPE_STATIC:
 584                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 585                         break;
 586
 587                 case NET_IP_CONFIG_TYPE_DYNAMIC:
 588                         *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
 589                         break;
 590
 591                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 592                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 593                         break;
 594
 595                 case NET_IP_CONFIG_TYPE_FIXED:
 596                         *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
 597                         break;
 598
 599                 case NET_IP_CONFIG_TYPE_OFF:
 600                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 601                         break;
 602                 default:
 603                         CONN_UNLOCK;
 604                         return CONNECTION_ERROR_OPERATION_FAILED;
 605                 //LCOV_EXCL_STOP
 606                 }
 607         } else {
 608                 //LCOV_EXCL_START
 609                 switch (profile_type) {
 610                 case NET_IP_CONFIG_TYPE_STATIC:
 611                         *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 612                         break;
 613
 614                 case NET_IP_CONFIG_TYPE_AUTO_IP:
 615                         *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 616                         break;
 617
 618                 case NET_IP_CONFIG_TYPE_OFF:
 619                         *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 620                         break;
 621
 622                 default:
 623                         CONN_UNLOCK;
 624                         return  CONNECTION_ERROR_OPERATION_FAILED;
 625
 626                 }
 627                 //LCOV_EXCL_STOP
 628         }
 629
 630         CONN_UNLOCK;
 631         return CONNECTION_ERROR_NONE;
 632 }
 633
 634 EXPORT_API int connection_profile_get_ip_address(connection_profile_h profile,
 635                 connection_address_family_e address_family, char** ip_address)
 636 {
 637         CONN_LOCK;
 638
 639         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 640
 641         if (!(_connection_libnet_check_profile_validity(profile)) ||
 642             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 643              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 644             ip_address == NULL) {
 645                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 646                 CONN_UNLOCK;
 647                 return CONNECTION_ERROR_INVALID_PARAMETER;
 648         }
 649
 650         net_profile_info_t *profile_info = profile;
 651         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 652         if (net_info == NULL) {
 653                 CONN_UNLOCK;
 654                 return CONNECTION_ERROR_OPERATION_FAILED;
 655         }
 656
 657         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
 658                 *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr,
 659                                 address_family);
 660         } else {
 661                 if (net_get_preferred_ipv6_address(net_info->ProfileName, ip_address) != NET_ERR_NONE) {
 662                         CONNECTION_LOG(CONNECTION_ERROR, "Failed to get preferred ipv6 address");
 663                         *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr6,
 664                                         address_family);
 665                 }
 666         }
 667
 668         if (*ip_address == NULL) {
 669                 CONN_UNLOCK;
 670                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 671         }
 672
 673         CONN_UNLOCK;
 674         return CONNECTION_ERROR_NONE;
 675 }
 676
 677 EXPORT_API int connection_profile_get_subnet_mask(connection_profile_h profile,
 678                 connection_address_family_e address_family, char** subnet_mask)
 679 {
 680         CONN_LOCK;
 681
 682         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 683
 684         if (!(_connection_libnet_check_profile_validity(profile)) ||
 685             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 686              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 687             subnet_mask == NULL) {
 688                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 689                 CONN_UNLOCK;
 690                 return CONNECTION_ERROR_INVALID_PARAMETER;
 691         }
 692
 693         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 694                 CONNECTION_LOG(CONNECTION_ERROR,
 695                                 "Please uses connection_profile_get_prefix_length()");
 696                 CONN_UNLOCK;
 697                 return CONNECTION_ERROR_NOT_SUPPORTED;
 698         }
 699
 700         net_profile_info_t *profile_info = profile;
 701         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 702         if (net_info == NULL) {
 703                 CONN_UNLOCK;
 704                 return CONNECTION_ERROR_OPERATION_FAILED;
 705         }
 706
 707         *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask,
 708                                 address_family);
 709
 710         if (*subnet_mask == NULL) {
 711                 CONN_UNLOCK;
 712                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 713         }
 714
 715         CONN_UNLOCK;
 716         return CONNECTION_ERROR_NONE;
 717 }
 718
 719 EXPORT_API int connection_profile_get_gateway_address(connection_profile_h profile,
 720                 connection_address_family_e address_family, char** gateway_address)
 721 {
 722         CONN_LOCK;
 723
 724         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 725
 726         if (!(_connection_libnet_check_profile_validity(profile)) ||
 727             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 728              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 729             gateway_address == NULL) {
 730                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 731                 CONN_UNLOCK;
 732                 return CONNECTION_ERROR_INVALID_PARAMETER;
 733         }
 734
 735         net_profile_info_t *profile_info = profile;
 736         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 737         if (net_info == NULL) {
 738                 CONN_UNLOCK;
 739                 return CONNECTION_ERROR_OPERATION_FAILED;
 740         }
 741
 742         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 743                 *gateway_address = __profile_convert_ip_to_string(
 744                                         &net_info->GatewayAddr6, address_family);
 745         else
 746                 *gateway_address = __profile_convert_ip_to_string(
 747                                         &net_info->GatewayAddr, address_family);
 748
 749         if (*gateway_address == NULL) {
 750                 CONN_UNLOCK;
 751                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 752         }
 753
 754         CONN_UNLOCK;
 755         return CONNECTION_ERROR_NONE;
 756 }
 757
 758 EXPORT_API int connection_profile_get_dhcp_server_address(
 759                 connection_profile_h profile,
 760                 connection_address_family_e address_family, char** dhcp_server)
 761 {
 762         CONN_LOCK;
 763
 764         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 765
 766         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 767                 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
 768                 CONN_UNLOCK;
 769                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 770         }
 771
 772         if (!(_connection_libnet_check_profile_validity(profile)) ||
 773             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4) ||
 774             dhcp_server == NULL) {
 775                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 776                 CONN_UNLOCK;
 777                 return CONNECTION_ERROR_INVALID_PARAMETER;
 778         }
 779
 780         net_profile_info_t *profile_info = profile;
 781         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 782         if (net_info == NULL) {
 783                 CONN_UNLOCK;
 784                 return CONNECTION_ERROR_OPERATION_FAILED;
 785         }
 786
 787         CONNECTION_LOG(CONNECTION_INFO, "IP Config %d, DHCP Server Address %s",
 788                         net_info->IpConfigType, (net_info->BServerAddr ? "TRUE" : "FALSE"));
 789
 790         *dhcp_server = __profile_convert_ip_to_string(&net_info->ServerAddr,
 791                         address_family);
 792
 793         if (*dhcp_server == NULL) {
 794                 CONN_UNLOCK;
 795                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 796         }
 797
 798         CONN_UNLOCK;
 799         return CONNECTION_ERROR_NONE;
 800 }
 801
 802 EXPORT_API int connection_profile_get_dhcp_lease_duration(
 803                 connection_profile_h profile,
 804                 connection_address_family_e address_family, int* dhcp_lease_duration)
 805 {
 806         CONN_LOCK;
 807
 808         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 809
 810         if (!(_connection_libnet_check_profile_validity(profile)) ||
 811             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 812                 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 813                 dhcp_lease_duration == NULL) {
 814                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 815                 CONN_UNLOCK;
 816                 return CONNECTION_ERROR_INVALID_PARAMETER;
 817         }
 818
 819         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
 820                 CONNECTION_LOG(CONNECTION_ERROR, "Not supported");
 821                 CONN_UNLOCK;
 822                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 823         }
 824
 825         net_profile_info_t *profile_info = profile;
 826         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 827         if (net_info == NULL) {
 828                 CONN_UNLOCK;
 829                 return CONNECTION_ERROR_OPERATION_FAILED;
 830         }
 831
 832         CONNECTION_LOG(CONNECTION_INFO, "Lease duration : %d",
 833                         net_info->DHCPLeaseDuration);
 834
 835         *dhcp_lease_duration = net_info->DHCPLeaseDuration;
 836
 837         CONN_UNLOCK;
 838         return CONNECTION_ERROR_NONE;
 839 }
 840
 841 EXPORT_API int connection_profile_get_dns_address(connection_profile_h profile, int order,
 842                 connection_address_family_e address_family, char** dns_address)
 843 {
 844         CONN_LOCK;
 845
 846         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 847
 848         if (!(_connection_libnet_check_profile_validity(profile)) ||
 849             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 850              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 851             dns_address == NULL ||
 852             order <= 0 ||
 853             order > NET_DNS_ADDR_MAX) {
 854                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 855                 CONN_UNLOCK;
 856                 return CONNECTION_ERROR_INVALID_PARAMETER;
 857         }
 858
 859         net_profile_info_t *profile_info = profile;
 860         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 861         if (net_info == NULL) {
 862                 CONN_UNLOCK;
 863                 return CONNECTION_ERROR_OPERATION_FAILED;
 864         }
 865
 866         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 867                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1],
 868                                 address_family);
 869         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) //LCOV_EXCL_LINE
 870                 *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr6[order-1], //LCOV_EXCL_LINE
 871                                 address_family);
 872
 873         if (*dns_address == NULL) {
 874                 CONN_UNLOCK;
 875                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 876         }
 877
 878         CONN_UNLOCK;
 879         return CONNECTION_ERROR_NONE;
 880 }
 881
 882 EXPORT_API int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e *type)
 883 {
 884         CONN_LOCK;
 885
 886         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 887
 888         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 889                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 890                 CONN_UNLOCK;
 891                 return CONNECTION_ERROR_INVALID_PARAMETER;
 892         }
 893
 894         net_profile_info_t *profile_info = profile;
 895         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 896         if (net_info == NULL) {
 897                 CONN_UNLOCK;
 898                 return CONNECTION_ERROR_OPERATION_FAILED;
 899         }
 900
 901         //LCOV_EXCL_START
 902         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 903                 char *proxy = __profile_get_ethernet_proxy();
 904                 if (proxy == NULL) {
 905                         *type = CONNECTION_PROXY_TYPE_DIRECT;
 906                 } else {
 907                         *type = CONNECTION_PROXY_TYPE_MANUAL;
 908                         free(proxy);
 909                 }
 910
 911                 CONN_UNLOCK;
 912                 return CONNECTION_ERROR_NONE;
 913         }
 914         //LCOV_EXCL_STOP
 915
 916         switch (net_info->ProxyMethod) {
 917         //LCOV_EXCL_START
 918         case NET_PROXY_TYPE_DIRECT:
 919                 *type = CONNECTION_PROXY_TYPE_DIRECT;
 920                 break;
 921         case NET_PROXY_TYPE_AUTO:
 922                 *type = CONNECTION_PROXY_TYPE_AUTO;
 923                 break;
 924         case NET_PROXY_TYPE_MANUAL:
 925                 *type = CONNECTION_PROXY_TYPE_MANUAL;
 926                 break;
 927         case NET_PROXY_TYPE_UNKNOWN:
 928         default:
 929                 CONN_UNLOCK;
 930                 return CONNECTION_ERROR_OPERATION_FAILED;
 931         //LCOV_EXCL_STOP
 932         }
 933
 934         CONN_UNLOCK;
 935         return CONNECTION_ERROR_NONE;
 936 }
 937
 938 EXPORT_API int connection_profile_get_proxy_address(connection_profile_h profile,
 939                 connection_address_family_e address_family, char** proxy_address)
 940 {
 941         CONN_LOCK;
 942
 943         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 944
 945         if (!(_connection_libnet_check_profile_validity(profile)) ||
 946             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 947              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 948              proxy_address == NULL) {
 949                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 950                 CONN_UNLOCK;
 951                 return CONNECTION_ERROR_INVALID_PARAMETER;
 952         }
 953
 954         net_profile_info_t *profile_info = profile;
 955         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 956         if (net_info == NULL) {
 957                 CONN_UNLOCK;
 958                 return CONNECTION_ERROR_OPERATION_FAILED;
 959         }
 960
 961         *proxy_address = g_strdup(net_info->ProxyAddr);
 962
 963         if (*proxy_address == NULL) {
 964                 CONN_UNLOCK;
 965                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 966         }
 967
 968         CONN_UNLOCK;
 969         return CONNECTION_ERROR_NONE;
 970 }
 971
 972 EXPORT_API int connection_profile_set_ip_config_type(connection_profile_h profile,
 973                 connection_address_family_e address_family, connection_ip_config_type_e type)
 974 {
 975         net_ip_config_type_t *profile_type = NULL;
 976
 977         CONN_LOCK;
 978
 979         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
 980
 981         if (!(_connection_libnet_check_profile_validity(profile)) ||
 982             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 983              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 984                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
 985                 CONN_UNLOCK;
 986                 return CONNECTION_ERROR_INVALID_PARAMETER;
 987         }
 988
 989         net_profile_info_t *profile_info = profile;
 990         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 991         if (net_info == NULL) {
 992                 CONN_UNLOCK;
 993                 return CONNECTION_ERROR_OPERATION_FAILED;
 994         }
 995
 996         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
 997                 profile_type = &net_info->IpConfigType ;
 998         else
 999                 profile_type = &net_info->IpConfigType6 ;
1000
1001         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
1002                 switch (type) {
1003                 //LCOV_EXCL_START
1004                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
1005                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
1006                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
1007                         net_info->SubnetMask.Data.Ipv4.s_addr = 0;
1008                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0 ;
1009                         break;
1010
1011                 case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
1012                         *profile_type = NET_IP_CONFIG_TYPE_DYNAMIC;
1013                         break;
1014
1015                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
1016                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
1017                         break;
1018
1019                 case CONNECTION_IP_CONFIG_TYPE_FIXED:
1020                         net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
1021                         break;
1022
1023                 case CONNECTION_IP_CONFIG_TYPE_NONE:
1024                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
1025                         break;
1026
1027                 default:
1028                         CONN_UNLOCK;
1029                         return CONNECTION_ERROR_INVALID_PARAMETER;
1030                 //LCOV_EXCL_STOP
1031                 }
1032         } else {
1033                 //LCOV_EXCL_START
1034                 switch (type) {
1035                 case CONNECTION_IP_CONFIG_TYPE_STATIC:
1036                         *profile_type = NET_IP_CONFIG_TYPE_STATIC;
1037                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
1038                         net_info->PrefixLen6 = 0 ;
1039                         inet_pton(AF_INET6, "::",
1040                                         &net_info->GatewayAddr6.Data.Ipv6);
1041                         break;
1042
1043                 case CONNECTION_IP_CONFIG_TYPE_AUTO:
1044                         *profile_type = NET_IP_CONFIG_TYPE_AUTO_IP;
1045                         break;
1046
1047                 case CONNECTION_IP_CONFIG_TYPE_NONE:
1048                         *profile_type = NET_IP_CONFIG_TYPE_OFF;
1049                         break;
1050
1051                 default:
1052                         CONN_UNLOCK;
1053                         return CONNECTION_ERROR_INVALID_PARAMETER;
1054                 }
1055                 //LCOV_EXCL_STOP
1056         }
1057
1058         CONN_UNLOCK;
1059         return CONNECTION_ERROR_NONE;
1060 }
1061
1062 EXPORT_API int connection_profile_set_ip_address(connection_profile_h profile,
1063                 connection_address_family_e address_family, const char* ip_address)
1064 {
1065         CONN_LOCK;
1066
1067         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1068
1069         if (!(_connection_libnet_check_profile_validity(profile)) ||
1070             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1071              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1072                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1073                 CONN_UNLOCK;
1074                 return CONNECTION_ERROR_INVALID_PARAMETER;
1075         }
1076
1077         net_profile_info_t *profile_info = profile;
1078         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1079         if (net_info == NULL) {
1080                 CONN_UNLOCK;
1081                 return CONNECTION_ERROR_OPERATION_FAILED;
1082         }
1083
1084         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1085                 //LCOV_EXCL_START
1086                 if (ip_address == NULL)
1087                         inet_pton(AF_INET6, "::", &net_info->IpAddr6.Data.Ipv6);
1088                 else if (inet_pton(AF_INET6, ip_address, &net_info->IpAddr6.Data.Ipv6) < 1) {
1089                         CONN_UNLOCK;
1090                         return CONNECTION_ERROR_INVALID_PARAMETER;
1091                 }
1092                 //LCOV_EXCL_STOP
1093         } else {
1094                 if (ip_address == NULL)
1095                         net_info->IpAddr.Data.Ipv4.s_addr = 0;
1096                 else if (inet_pton(AF_INET, ip_address, &net_info->IpAddr.Data.Ipv4) < 1) {
1097                         CONN_UNLOCK;
1098                         return CONNECTION_ERROR_INVALID_PARAMETER;
1099                 }
1100         }
1101
1102         CONN_UNLOCK;
1103         return CONNECTION_ERROR_NONE;
1104 }
1105
1106 EXPORT_API int connection_profile_set_subnet_mask(connection_profile_h profile,
1107                 connection_address_family_e address_family, const char* subnet_mask)
1108 {
1109         CONN_LOCK;
1110
1111         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1112
1113         if (!(_connection_libnet_check_profile_validity(profile)) ||
1114                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1115                          address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1116                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1117                 CONN_UNLOCK;
1118                 return CONNECTION_ERROR_INVALID_PARAMETER;
1119         }
1120
1121         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1122                 CONNECTION_LOG(CONNECTION_ERROR,
1123                                 "Please uses connection_profile_set_prefix_length()");
1124                 CONN_UNLOCK;
1125                 return CONNECTION_ERROR_NOT_SUPPORTED;
1126         }
1127
1128         net_profile_info_t *profile_info = profile;
1129         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1130         if (net_info == NULL) {
1131                 CONN_UNLOCK;
1132                 return CONNECTION_ERROR_OPERATION_FAILED;
1133         }
1134
1135         if (subnet_mask == NULL)
1136                 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
1137         else if (inet_pton(AF_INET, subnet_mask , &net_info->SubnetMask.Data.Ipv4) < 1) {
1138                 CONN_UNLOCK;
1139                 return CONNECTION_ERROR_INVALID_PARAMETER;
1140         }
1141
1142         net_info->PrefixLen = __profile_convert_netmask_to_prefix_len(subnet_mask);
1143         if (net_info->PrefixLen <= 0 || net_info->PrefixLen > 31) {
1144                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid Prefix length: %d", net_info->PrefixLen);
1145                 CONN_UNLOCK;
1146                 return CONNECTION_ERROR_INVALID_PARAMETER;
1147         }
1148
1149         CONN_UNLOCK;
1150         return CONNECTION_ERROR_NONE;
1151 }
1152
1153 EXPORT_API int connection_profile_set_gateway_address(connection_profile_h profile,
1154                 connection_address_family_e address_family, const char* gateway_address)
1155 {
1156         CONN_LOCK;
1157
1158         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1159
1160         if (!(_connection_libnet_check_profile_validity(profile)) ||
1161             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1162              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1163                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1164                 CONN_UNLOCK;
1165                 return CONNECTION_ERROR_INVALID_PARAMETER;
1166         }
1167
1168         net_profile_info_t *profile_info = profile;
1169         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1170         if (net_info == NULL) {
1171                 CONN_UNLOCK;
1172                 return CONNECTION_ERROR_OPERATION_FAILED;
1173         }
1174
1175         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1176                 //LCOV_EXCL_START
1177                 if (gateway_address == NULL)
1178                         inet_pton(AF_INET6, "::", &net_info->GatewayAddr6.Data.Ipv6);
1179                 else if (inet_pton(AF_INET6, gateway_address, &net_info->GatewayAddr6.Data.Ipv6) < 1) {
1180                         CONN_UNLOCK;
1181                         return CONNECTION_ERROR_INVALID_PARAMETER;
1182                 }
1183                 //LCOV_EXCL_STOP
1184         } else {
1185                 if (gateway_address == NULL)
1186                         net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
1187                 else if (inet_pton(AF_INET, gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) < 1) {
1188                         CONN_UNLOCK;
1189                         return CONNECTION_ERROR_INVALID_PARAMETER;
1190                 }
1191         }
1192
1193         CONN_UNLOCK;
1194         return CONNECTION_ERROR_NONE;
1195 }
1196
1197 EXPORT_API int connection_profile_set_dns_address(connection_profile_h profile, int order,
1198                 connection_address_family_e address_family, const char* dns_address)
1199 {
1200         CONN_LOCK;
1201
1202         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1203
1204         if (!(_connection_libnet_check_profile_validity(profile)) ||
1205             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1206              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
1207             order <= 0 ||
1208             order > NET_DNS_ADDR_MAX) {
1209                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1210                 CONN_UNLOCK;
1211                 return CONNECTION_ERROR_INVALID_PARAMETER;
1212         }
1213
1214         net_profile_info_t *profile_info = profile;
1215         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1216         if (net_info == NULL) {
1217                 CONN_UNLOCK;
1218                 return CONNECTION_ERROR_OPERATION_FAILED;
1219         }
1220
1221         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6) {
1222                 //LCOV_EXCL_START
1223                 net_info->DnsAddr6[order-1].Type = NET_ADDR_IPV6;
1224                 if (dns_address == NULL)
1225                         inet_pton(AF_INET6, "::", &net_info->DnsAddr6[order-1].Data.Ipv6);
1226                 else if (inet_pton(AF_INET6, dns_address, &net_info->DnsAddr6[order-1].Data.Ipv6) < 1) {
1227                         CONN_UNLOCK;
1228                         return CONNECTION_ERROR_INVALID_PARAMETER;
1229                 }
1230                 if (net_info->DnsCount6 < order)
1231                         net_info->DnsCount6 = order;
1232                 //LCOV_EXCL_STOP
1233         } else {
1234                 net_info->DnsAddr[order-1].Type = NET_ADDR_IPV4;
1235                 if (dns_address == NULL)
1236                         net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
1237                 else if (inet_pton(AF_INET, dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) < 1) {
1238                         CONN_UNLOCK;
1239                         return CONNECTION_ERROR_INVALID_PARAMETER;
1240                 }
1241                 if (net_info->DnsCount < order)
1242                         net_info->DnsCount = order;
1243         }
1244
1245         CONN_UNLOCK;
1246         return CONNECTION_ERROR_NONE;
1247 }
1248
1249 EXPORT_API int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
1250 {
1251         CONN_LOCK;
1252
1253         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1254
1255         if (!(_connection_libnet_check_profile_validity(profile))) {
1256                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1257                 CONN_UNLOCK;
1258                 return CONNECTION_ERROR_INVALID_PARAMETER;
1259         }
1260
1261         net_profile_info_t *profile_info = profile;
1262         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1263         if (net_info == NULL) {
1264                 CONN_UNLOCK;
1265                 return CONNECTION_ERROR_OPERATION_FAILED;
1266         }
1267
1268         switch (type) {
1269         //LCOV_EXCL_START
1270         case CONNECTION_PROXY_TYPE_DIRECT:
1271                 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
1272                 break;
1273         case CONNECTION_PROXY_TYPE_AUTO:
1274                 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
1275                 break;
1276         case CONNECTION_PROXY_TYPE_MANUAL:
1277                 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
1278                 break;
1279         default:
1280                 CONN_UNLOCK;
1281                 return CONNECTION_ERROR_INVALID_PARAMETER;
1282         //LCOV_EXCL_STOP
1283         }
1284
1285         CONN_UNLOCK;
1286         return CONNECTION_ERROR_NONE;
1287 }
1288
1289 EXPORT_API int connection_profile_set_proxy_address(connection_profile_h profile,
1290                 connection_address_family_e address_family, const char* proxy_address)
1291 {
1292         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1293
1294         CONNECTION_LOG(CONNECTION_ERROR, "Address Family: %d", address_family);
1295         if (!(_connection_libnet_check_profile_validity(profile)) ||
1296             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
1297              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
1298                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1299                 CONN_UNLOCK;
1300                 return CONNECTION_ERROR_INVALID_PARAMETER;
1301         }
1302
1303         net_profile_info_t *profile_info = profile;
1304         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
1305         if (net_info == NULL) {
1306                 CONN_UNLOCK;
1307                 return CONNECTION_ERROR_OPERATION_FAILED;
1308         }
1309
1310         if (proxy_address == NULL)
1311                 net_info->ProxyAddr[0] = '\0';
1312         else
1313                 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
1314
1315         CONN_UNLOCK;
1316         return CONNECTION_ERROR_NONE;
1317 }
1318
1319 EXPORT_API int connection_profile_set_state_changed_cb(connection_profile_h profile,
1320                 connection_profile_state_changed_cb callback, void* user_data)
1321 {
1322         CONN_LOCK;
1323
1324         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1325
1326         if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
1327                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1328                 CONN_UNLOCK;
1329                 return CONNECTION_ERROR_INVALID_PARAMETER;
1330         }
1331
1332         if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data)) {
1333                 CONN_UNLOCK;
1334                 return CONNECTION_ERROR_NONE;
1335         }
1336
1337         CONN_UNLOCK;
1338         return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1339 }
1340
1341 EXPORT_API int connection_profile_unset_state_changed_cb(connection_profile_h profile)
1342 {
1343         CONN_LOCK;
1344
1345         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE, TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
1346
1347         if (!(_connection_libnet_check_profile_validity(profile))) {
1348                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1349                 CONN_UNLOCK;
1350                 return CONNECTION_ERROR_INVALID_PARAMETER;
1351         }
1352
1353         if (_connection_libnet_remove_from_profile_cb_list(profile) != true) {
1354                 CONN_UNLOCK;
1355                 return CONNECTION_ERROR_INVALID_PARAMETER;
1356         }
1357
1358         CONN_UNLOCK;
1359         return CONNECTION_ERROR_NONE;
1360 }
1361
1362
1363 /* Wi-Fi profile *************************************************************/
1364 EXPORT_API int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
1365 {
1366         CONN_LOCK;
1367
1368         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1369
1370         if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
1371                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1372                 CONN_UNLOCK;
1373                 return CONNECTION_ERROR_INVALID_PARAMETER;
1374         }
1375
1376         net_profile_info_t *profile_info = profile;
1377
1378         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1379                                 profile_info->profile_type != NET_DEVICE_MESH) {
1380                 CONN_UNLOCK;
1381                 return CONNECTION_ERROR_INVALID_PARAMETER;
1382         }
1383
1384         if (profile_info->profile_type == NET_DEVICE_WIFI)
1385                 *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
1386         else
1387                 *essid = g_strdup(profile_info->ProfileInfo.Mesh.essid);
1388
1389         if (*essid == NULL) {
1390                 CONN_UNLOCK;
1391                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1392         }
1393
1394         CONN_UNLOCK;
1395         return CONNECTION_ERROR_NONE;
1396 }
1397
1398 EXPORT_API int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
1399 {
1400         CONN_LOCK;
1401
1402         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1403
1404         if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
1405                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1406                 CONN_UNLOCK;
1407                 return CONNECTION_ERROR_INVALID_PARAMETER;
1408         }
1409
1410         net_profile_info_t *profile_info = profile;
1411
1412         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1413                                 profile_info->profile_type != NET_DEVICE_MESH) {
1414                 CONN_UNLOCK;
1415                 return CONNECTION_ERROR_INVALID_PARAMETER;
1416         }
1417
1418         if (profile_info->profile_type == NET_DEVICE_WIFI)
1419                 *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
1420         else
1421                 *bssid = g_strdup(profile_info->ProfileInfo.Mesh.bssid);
1422
1423         if (*bssid == NULL) {
1424                 CONN_UNLOCK;
1425                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1426         }
1427
1428         CONN_UNLOCK;
1429         return CONNECTION_ERROR_NONE;
1430 }
1431
1432 EXPORT_API int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
1433 {
1434         CONN_LOCK;
1435
1436         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1437
1438         if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
1439                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1440                 CONN_UNLOCK;
1441                 return CONNECTION_ERROR_INVALID_PARAMETER;
1442         }
1443
1444         net_profile_info_t *profile_info = profile;
1445
1446         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1447                                 profile_info->profile_type != NET_DEVICE_MESH) {
1448                 CONN_UNLOCK;
1449                 return CONNECTION_ERROR_INVALID_PARAMETER;
1450         }
1451
1452         if (profile_info->profile_type == NET_DEVICE_WIFI)
1453                 *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
1454         else
1455                 *rssi = (int)profile_info->ProfileInfo.Mesh.Strength;
1456
1457         CONN_UNLOCK;
1458         return CONNECTION_ERROR_NONE;
1459 }
1460
1461 EXPORT_API int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
1462 {
1463         CONN_LOCK;
1464
1465         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1466
1467         if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
1468                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1469                 CONN_UNLOCK;
1470                 return CONNECTION_ERROR_INVALID_PARAMETER;
1471         }
1472
1473         net_profile_info_t *profile_info = profile;
1474
1475         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1476                                 profile_info->profile_type != NET_DEVICE_MESH) {
1477                 CONN_UNLOCK;
1478                 return CONNECTION_ERROR_INVALID_PARAMETER;
1479         }
1480
1481         if (profile_info->profile_type == NET_DEVICE_WIFI)
1482                 *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
1483         else
1484                 *frequency = (int)profile_info->ProfileInfo.Mesh.frequency;
1485
1486         CONN_UNLOCK;
1487         return CONNECTION_ERROR_NONE;
1488 }
1489
1490 EXPORT_API int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
1491 {
1492         CONN_LOCK;
1493
1494         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1495
1496         if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
1497                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1498                 CONN_UNLOCK;
1499                 return CONNECTION_ERROR_INVALID_PARAMETER;
1500         }
1501
1502         net_profile_info_t *profile_info = profile;
1503
1504         if (profile_info->profile_type != NET_DEVICE_WIFI) {
1505                 CONN_UNLOCK;
1506                 return CONNECTION_ERROR_INVALID_PARAMETER;
1507         }
1508
1509         *max_speed = profile_info->ProfileInfo.Wlan.max_rate;
1510
1511         CONN_UNLOCK;
1512         return CONNECTION_ERROR_NONE;
1513 }
1514
1515 EXPORT_API int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e *type)
1516 {
1517         CONN_LOCK;
1518
1519         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1520
1521         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1522                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1523                 CONN_UNLOCK;
1524                 return CONNECTION_ERROR_INVALID_PARAMETER;
1525         }
1526
1527         net_profile_info_t *profile_info = profile;
1528
1529         wlan_security_mode_type_t sec_mode;
1530         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1531                                 profile_info->profile_type != NET_DEVICE_MESH) {
1532                 CONN_UNLOCK;
1533                 return CONNECTION_ERROR_INVALID_PARAMETER;
1534         }
1535
1536         if (profile_info->profile_type == NET_DEVICE_WIFI)
1537                 sec_mode = profile_info->ProfileInfo.Wlan.security_info.sec_mode;
1538         else
1539                 sec_mode = profile_info->ProfileInfo.Mesh.security_info.sec_mode;
1540
1541         switch (sec_mode) {
1542         //LCOV_EXCL_START
1543         case WLAN_SEC_MODE_NONE:
1544                 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
1545                 break;
1546         case WLAN_SEC_MODE_WEP:
1547                 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
1548                 break;
1549         case WLAN_SEC_MODE_IEEE8021X:
1550                 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
1551                 break;
1552         case WLAN_SEC_MODE_WPA_PSK:
1553                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
1554                 break;
1555         case WLAN_SEC_MODE_WPA2_PSK:
1556                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
1557                 break;
1558         case WLAN_SEC_MODE_SAE:
1559                 *type = CONNECTION_WIFI_SECURITY_TYPE_SAE;
1560                 break;
1561         default:
1562                 CONN_UNLOCK;
1563                 return CONNECTION_ERROR_OPERATION_FAILED;
1564         //LCOV_EXCL_STOP
1565         }
1566
1567         CONN_UNLOCK;
1568         return CONNECTION_ERROR_NONE;
1569 }
1570
1571 EXPORT_API int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e *type)
1572 {
1573         CONN_LOCK;
1574
1575         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1576
1577         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1578                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1579                 CONN_UNLOCK;
1580                 return CONNECTION_ERROR_INVALID_PARAMETER;
1581         }
1582
1583         net_profile_info_t *profile_info = profile;
1584
1585         if (profile_info->profile_type != NET_DEVICE_WIFI) {
1586                 CONN_UNLOCK;
1587                 return CONNECTION_ERROR_INVALID_PARAMETER;
1588         }
1589
1590         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
1591         //LCOV_EXCL_START
1592         case WLAN_ENC_MODE_NONE:
1593                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
1594                 break;
1595         case WLAN_ENC_MODE_WEP:
1596                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
1597                 break;
1598         case WLAN_ENC_MODE_TKIP:
1599                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
1600                 break;
1601         case WLAN_ENC_MODE_AES:
1602                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
1603                 break;
1604         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1605                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1606                 break;
1607         default:
1608                 CONN_UNLOCK;
1609                 return CONNECTION_ERROR_OPERATION_FAILED;
1610         //LCOV_EXCL_STOP
1611         }
1612
1613         CONN_UNLOCK;
1614         return CONNECTION_ERROR_NONE;
1615 }
1616
1617 EXPORT_API int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1618 {
1619         CONN_LOCK;
1620
1621         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1622
1623         if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1624                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1625                 CONN_UNLOCK;
1626                 return CONNECTION_ERROR_INVALID_PARAMETER;
1627         }
1628
1629         net_profile_info_t *profile_info = profile;
1630
1631         wlan_security_mode_type_t sec_mode;
1632         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1633                                 profile_info->profile_type != NET_DEVICE_MESH) {
1634                 CONN_UNLOCK;
1635                 return CONNECTION_ERROR_INVALID_PARAMETER;
1636         }
1637
1638         if (profile_info->Favourite) {
1639                 *required = false;
1640                 CONN_UNLOCK;
1641                 return CONNECTION_ERROR_NONE;
1642         }
1643
1644         if (profile_info->profile_type == NET_DEVICE_WIFI)
1645                 sec_mode = profile_info->ProfileInfo.Wlan.security_info.sec_mode;
1646         else
1647                 sec_mode = profile_info->ProfileInfo.Mesh.security_info.sec_mode;
1648
1649         switch (sec_mode) {
1650         //LCOV_EXCL_START
1651         case WLAN_SEC_MODE_NONE:
1652                 *required = false;
1653                 break;
1654         case WLAN_SEC_MODE_WEP:
1655         case WLAN_SEC_MODE_IEEE8021X:
1656         case WLAN_SEC_MODE_WPA_PSK:
1657         case WLAN_SEC_MODE_WPA2_PSK:
1658         case WLAN_SEC_MODE_SAE:
1659                 *required = true;
1660                 break;
1661         default:
1662                 CONN_UNLOCK;
1663                 return CONNECTION_ERROR_OPERATION_FAILED;
1664         //LCOV_EXCL_STOP
1665         }
1666
1667         CONN_UNLOCK;
1668         return CONNECTION_ERROR_NONE;
1669 }
1670
1671 EXPORT_API int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1672 {
1673         CONN_LOCK;
1674
1675         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1676
1677         if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1678                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1679                 CONN_UNLOCK;
1680                 return CONNECTION_ERROR_INVALID_PARAMETER;
1681         }
1682
1683         net_profile_info_t *profile_info = profile;
1684
1685         if (profile_info->profile_type != NET_DEVICE_WIFI &&
1686                                 profile_info->profile_type != NET_DEVICE_MESH) {
1687                 CONN_UNLOCK;
1688                 return CONNECTION_ERROR_INVALID_PARAMETER;
1689         }
1690
1691         if (profile_info->profile_type == NET_DEVICE_WIFI)
1692                 g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1693                                   passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1694         else
1695                 g_strlcpy(profile_info->ProfileInfo.Mesh.security_info.authentication.sae.saeKey,
1696                                   passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1697
1698         CONN_UNLOCK;
1699         return CONNECTION_ERROR_NONE;
1700 }
1701
1702 EXPORT_API int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1703 {
1704         CONN_LOCK;
1705
1706         CHECK_FEATURE_SUPPORTED(WIFI_FEATURE);
1707
1708         if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1709                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1710                 CONN_UNLOCK;
1711                 return CONNECTION_ERROR_INVALID_PARAMETER;
1712         }
1713
1714         net_profile_info_t *profile_info = profile;
1715
1716         if (profile_info->profile_type != NET_DEVICE_WIFI) {
1717                 CONN_UNLOCK;
1718                 return CONNECTION_ERROR_INVALID_PARAMETER;
1719         }
1720
1721         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1722                 *supported = true;
1723         else
1724                 *supported = false;
1725
1726         CONN_UNLOCK;
1727         return CONNECTION_ERROR_NONE;
1728 }
1729
1730
1731 /* Cellular profile **********************************************************/
1732 EXPORT_API int connection_profile_get_cellular_service_type(connection_profile_h profile,
1733                                                 connection_cellular_service_type_e* type)
1734 {
1735         CONN_LOCK;
1736
1737         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1738
1739         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1740                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1741                 CONN_UNLOCK;
1742                 return CONNECTION_ERROR_INVALID_PARAMETER;
1743         }
1744
1745         net_profile_info_t *profile_info = profile;
1746
1747         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1748                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1749                 CONN_UNLOCK;
1750                 return CONNECTION_ERROR_INVALID_PARAMETER;
1751         }
1752
1753         *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1754
1755         if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1756                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed"); //LCOV_EXCL_LINE
1757                 CONN_UNLOCK;
1758                 return CONNECTION_ERROR_OPERATION_FAILED; //LCOV_EXCL_LINE
1759         }
1760
1761         CONN_UNLOCK;
1762         return CONNECTION_ERROR_NONE;
1763 }
1764
1765 EXPORT_API int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1766 {
1767         CONN_LOCK;
1768
1769         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1770
1771         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1772                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1773                 CONN_UNLOCK;
1774                 return CONNECTION_ERROR_INVALID_PARAMETER;
1775         }
1776
1777         net_profile_info_t *profile_info = profile;
1778
1779         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1780                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter"); //LCOV_EXCL_LINE
1781                 CONN_UNLOCK;
1782                 return CONNECTION_ERROR_INVALID_PARAMETER; //LCOV_EXCL_LINE
1783         }
1784
1785         *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1786         if (*apn == NULL) {
1787                 CONN_UNLOCK;
1788                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1789         }
1790
1791         CONN_UNLOCK;
1792         return CONNECTION_ERROR_NONE;
1793 }
1794
1795 EXPORT_API int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1796                 connection_cellular_auth_type_e *type, char** user_name, char** password)
1797 {
1798         CONN_LOCK;
1799
1800         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1801
1802         if (!(_connection_libnet_check_profile_validity(profile)) ||
1803             type == NULL || user_name == NULL || password == NULL) {
1804                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1805                 CONN_UNLOCK;
1806                 return CONNECTION_ERROR_INVALID_PARAMETER;
1807         }
1808
1809         net_profile_info_t *profile_info = profile;
1810
1811         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1812                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1813                 CONN_UNLOCK;
1814                 return CONNECTION_ERROR_INVALID_PARAMETER;
1815         }
1816
1817         switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1818         //LCOV_EXCL_START
1819         case NET_PDP_AUTH_NONE:
1820                 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1821                 break;
1822         case NET_PDP_AUTH_PAP:
1823                 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1824                 break;
1825         case NET_PDP_AUTH_CHAP:
1826                 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1827                 break;
1828         default:
1829                 CONN_UNLOCK;
1830                 return CONNECTION_ERROR_OPERATION_FAILED;
1831         //LCOV_EXCL_STOP
1832         }
1833
1834         *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1835         if (*user_name == NULL) {
1836                 CONN_UNLOCK;
1837                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1838         }
1839
1840         *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1841         if (*password == NULL) {
1842                 g_free(*user_name); //LCOV_EXCL_LINE
1843                 CONN_UNLOCK;
1844                 return CONNECTION_ERROR_OUT_OF_MEMORY; //LCOV_EXCL_LINE
1845         }
1846
1847         CONN_UNLOCK;
1848         return CONNECTION_ERROR_NONE;
1849 }
1850
1851 EXPORT_API int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1852 {
1853         CONN_LOCK;
1854
1855         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1856
1857         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1858                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1859                 CONN_UNLOCK;
1860                 return CONNECTION_ERROR_INVALID_PARAMETER;
1861         }
1862
1863         net_profile_info_t *profile_info = profile;
1864
1865         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1866                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1867                 CONN_UNLOCK;
1868                 return CONNECTION_ERROR_INVALID_PARAMETER;
1869         }
1870
1871         *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1872         if (*home_url == NULL) {
1873                 CONN_UNLOCK;
1874                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1875         }
1876
1877         CONN_UNLOCK;
1878         return CONNECTION_ERROR_NONE;
1879 }
1880
1881 EXPORT_API int connection_profile_get_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1882 {
1883         CONN_LOCK;
1884
1885         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1886
1887         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1888                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1889                 CONN_UNLOCK;
1890                 return CONNECTION_ERROR_INVALID_PARAMETER;
1891         }
1892
1893         net_profile_info_t *profile_info = profile;
1894
1895         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1896                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1897                 CONN_UNLOCK;
1898                 return CONNECTION_ERROR_INVALID_PARAMETER;
1899         }
1900
1901         switch (profile_info->ProfileInfo.Pdp.PdnType) {
1902         //LCOV_EXCL_START
1903         case NET_PDN_TYPE_UNKNOWN:
1904                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1905                 break;
1906         case NET_PDN_TYPE_IPV4:
1907                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1908                 break;
1909         case NET_PDN_TYPE_IPV6:
1910                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1911                 break;
1912         case NET_PDN_TYPE_IPV4_IPV6:
1913                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1914                 break;
1915         default:
1916                 CONN_UNLOCK;
1917                 return CONNECTION_ERROR_OPERATION_FAILED;
1918         //LCOV_EXCL_STOP
1919         }
1920
1921         CONN_UNLOCK;
1922         return CONNECTION_ERROR_NONE;
1923 }
1924
1925 EXPORT_API int connection_profile_get_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e *type)
1926 {
1927         CONN_LOCK;
1928
1929         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1930
1931         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1932                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1933                 CONN_UNLOCK;
1934                 return CONNECTION_ERROR_INVALID_PARAMETER;
1935         }
1936
1937         net_profile_info_t *profile_info = profile;
1938
1939         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1940                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1941                 CONN_UNLOCK;
1942                 return CONNECTION_ERROR_INVALID_PARAMETER;
1943         }
1944
1945         switch (profile_info->ProfileInfo.Pdp.RoamPdnType) {
1946         //LCOV_EXCL_START
1947         case NET_PDN_TYPE_UNKNOWN:
1948                 *type = CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN;
1949                 break;
1950         case NET_PDN_TYPE_IPV4:
1951                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4;
1952                 break;
1953         case NET_PDN_TYPE_IPV6:
1954                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV6;
1955                 break;
1956         case NET_PDN_TYPE_IPV4_IPV6:
1957                 *type = CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6;
1958                 break;
1959         default:
1960                 CONN_UNLOCK;
1961                 return CONNECTION_ERROR_OPERATION_FAILED;
1962         //LCOV_EXCL_STOP
1963         }
1964
1965         CONN_UNLOCK;
1966         return CONNECTION_ERROR_NONE;
1967 }
1968
1969 EXPORT_API int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1970 {
1971         CONN_LOCK;
1972
1973         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
1974
1975         if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1976                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1977                 CONN_UNLOCK;
1978                 return CONNECTION_ERROR_INVALID_PARAMETER;
1979         }
1980
1981         net_profile_info_t *profile_info = profile;
1982
1983         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1984                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
1985                 CONN_UNLOCK;
1986                 return CONNECTION_ERROR_INVALID_PARAMETER;
1987         }
1988
1989         if (profile_info->ProfileInfo.Pdp.Roaming)
1990                 *is_roaming = true;
1991         else
1992                 *is_roaming = false;
1993
1994         CONN_UNLOCK;
1995         return CONNECTION_ERROR_NONE;
1996 }
1997
1998 EXPORT_API int connection_profile_is_cellular_hidden(connection_profile_h profile, bool* is_hidden)
1999 {
2000         CONN_LOCK;
2001
2002         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2003
2004         if (!(_connection_libnet_check_profile_validity(profile)) || is_hidden == NULL) {
2005                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2006                 CONN_UNLOCK;
2007                 return CONNECTION_ERROR_INVALID_PARAMETER;
2008         }
2009
2010         net_profile_info_t *profile_info = profile;
2011
2012         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2013                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2014                 CONN_UNLOCK;
2015                 return CONNECTION_ERROR_INVALID_PARAMETER;
2016         }
2017
2018         if (profile_info->ProfileInfo.Pdp.Hidden)
2019                 *is_hidden = true;
2020         else
2021                 *is_hidden = false;
2022
2023         CONN_UNLOCK;
2024         return CONNECTION_ERROR_NONE;
2025 }
2026
2027 EXPORT_API int connection_profile_is_cellular_editable(connection_profile_h profile, bool* is_editable)
2028 {
2029         CONN_LOCK;
2030
2031         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2032
2033         if (!(_connection_libnet_check_profile_validity(profile)) || is_editable == NULL) {
2034                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2035                 CONN_UNLOCK;
2036                 return CONNECTION_ERROR_INVALID_PARAMETER;
2037         }
2038
2039         net_profile_info_t *profile_info = profile;
2040
2041         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2042                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2043                 CONN_UNLOCK;
2044                 return CONNECTION_ERROR_INVALID_PARAMETER;
2045         }
2046
2047         if (profile_info->ProfileInfo.Pdp.Editable)
2048                 *is_editable = true;
2049         else
2050                 *is_editable = false;
2051
2052         CONN_UNLOCK;
2053         return CONNECTION_ERROR_NONE;
2054 }
2055
2056 EXPORT_API int connection_profile_is_cellular_default(connection_profile_h profile, bool* is_default)
2057 {
2058         CONN_LOCK;
2059
2060         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2061
2062         if (!(_connection_libnet_check_profile_validity(profile)) || is_default == NULL) {
2063                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2064                 CONN_UNLOCK;
2065                 return CONNECTION_ERROR_INVALID_PARAMETER;
2066         }
2067
2068         net_profile_info_t *profile_info = profile;
2069
2070         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2071                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2072                 CONN_UNLOCK;
2073                 return CONNECTION_ERROR_INVALID_PARAMETER;
2074         }
2075
2076         if (profile_info->ProfileInfo.Pdp.DefaultConn)
2077                 *is_default = true;
2078         else
2079                 *is_default = false;
2080
2081         CONN_UNLOCK;
2082         return CONNECTION_ERROR_NONE;
2083 }
2084
2085 EXPORT_API int connection_profile_set_cellular_service_type(connection_profile_h profile,
2086                 connection_cellular_service_type_e service_type)
2087 {
2088         CONN_LOCK;
2089
2090         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2091
2092         if (!(_connection_libnet_check_profile_validity(profile))) {
2093                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2094                 CONN_UNLOCK;
2095                 return CONNECTION_ERROR_INVALID_PARAMETER;
2096         }
2097
2098         net_profile_info_t *profile_info = profile;
2099
2100         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2101                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2102                 CONN_UNLOCK;
2103                 return CONNECTION_ERROR_INVALID_PARAMETER;
2104         }
2105
2106         switch (service_type) {
2107         //LCOV_EXCL_START
2108         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
2109                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
2110                 break;
2111         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
2112                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
2113                 break;
2114         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
2115                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
2116                 break;
2117         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
2118                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
2119                 break;
2120         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
2121                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
2122                 break;
2123         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
2124                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
2125                 break;
2126         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
2127         default:
2128                 CONN_UNLOCK;
2129                 return CONNECTION_ERROR_INVALID_PARAMETER;
2130         //LCOV_EXCL_STOP
2131         }
2132
2133         CONN_UNLOCK;
2134         return CONNECTION_ERROR_NONE;
2135 }
2136
2137 EXPORT_API int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
2138 {
2139         CONN_LOCK;
2140
2141         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2142
2143         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
2144                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2145                 CONN_UNLOCK;
2146                 return CONNECTION_ERROR_INVALID_PARAMETER;
2147         }
2148
2149         net_profile_info_t *profile_info = profile;
2150
2151         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2152                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2153                 CONN_UNLOCK;
2154                 return CONNECTION_ERROR_INVALID_PARAMETER;
2155         }
2156
2157         g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
2158
2159         CONN_UNLOCK;
2160         return CONNECTION_ERROR_NONE;
2161 }
2162
2163 EXPORT_API int connection_profile_set_cellular_auth_info(connection_profile_h profile,
2164                 connection_cellular_auth_type_e type, const char* user_name, const char* password)
2165 {
2166         CONN_LOCK;
2167
2168         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2169
2170         if (!(_connection_libnet_check_profile_validity(profile)) ||
2171             user_name == NULL || password == NULL) {
2172                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2173                 CONN_UNLOCK;
2174                 return CONNECTION_ERROR_INVALID_PARAMETER;
2175         }
2176
2177         net_profile_info_t *profile_info = profile;
2178
2179         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2180                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2181                 CONN_UNLOCK;
2182                 return CONNECTION_ERROR_INVALID_PARAMETER;
2183         }
2184
2185         switch (type) {
2186         //LCOV_EXCL_START
2187         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
2188                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
2189                 break;
2190         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
2191                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
2192                 break;
2193         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
2194                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
2195                 break;
2196         default:
2197                 CONN_UNLOCK;
2198                 return CONNECTION_ERROR_INVALID_PARAMETER;
2199         //LCOV_EXCL_STOP
2200         }
2201
2202         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
2203         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
2204
2205         CONN_UNLOCK;
2206         return CONNECTION_ERROR_NONE;
2207 }
2208
2209 EXPORT_API int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
2210 {
2211         CONN_LOCK;
2212
2213         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2214
2215         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
2216                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2217                 CONN_UNLOCK;
2218                 return CONNECTION_ERROR_INVALID_PARAMETER;
2219         }
2220
2221         net_profile_info_t *profile_info = profile;
2222
2223         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2224                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2225                 CONN_UNLOCK;
2226                 return CONNECTION_ERROR_INVALID_PARAMETER;
2227         }
2228
2229         g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
2230
2231         CONN_UNLOCK;
2232         return CONNECTION_ERROR_NONE;
2233 }
2234
2235 EXPORT_API int connection_profile_set_cellular_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
2236 {
2237         CONN_LOCK;
2238
2239         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2240
2241         if (!(_connection_libnet_check_profile_validity(profile))) {
2242                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2243                 CONN_UNLOCK;
2244                 return CONNECTION_ERROR_INVALID_PARAMETER;
2245         }
2246
2247         net_profile_info_t *profile_info = profile;
2248
2249         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2250                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2251                 CONN_UNLOCK;
2252                 return CONNECTION_ERROR_INVALID_PARAMETER;
2253         }
2254
2255         switch (type) {
2256         //LCOV_EXCL_START
2257         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
2258                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4;
2259                 break;
2260         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
2261                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV6;
2262                 break;
2263         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
2264                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
2265                 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
2266                                                 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
2267                 break;
2268         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
2269                 profile_info->ProfileInfo.Pdp.PdnType = NET_PDN_TYPE_IPV4_IPV6;
2270                 break;
2271         default:
2272                 CONN_UNLOCK;
2273                 return CONNECTION_ERROR_INVALID_PARAMETER;
2274         //LCOV_EXCL_STOP
2275         }
2276
2277         CONN_UNLOCK;
2278         return CONNECTION_ERROR_NONE;
2279 }
2280
2281 EXPORT_API int connection_profile_set_cellular_roam_pdn_type(connection_profile_h profile, connection_cellular_pdn_type_e type)
2282 {
2283         CONN_LOCK;
2284
2285         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE);
2286
2287         if (!(_connection_libnet_check_profile_validity(profile))) {
2288                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2289                 CONN_UNLOCK;
2290                 return CONNECTION_ERROR_INVALID_PARAMETER;
2291         }
2292
2293         net_profile_info_t *profile_info = profile;
2294
2295         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
2296                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2297                 CONN_UNLOCK;
2298                 return CONNECTION_ERROR_INVALID_PARAMETER;
2299         }
2300
2301         switch (type) {
2302         //LCOV_EXCL_START
2303         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
2304                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4;
2305                 break;
2306         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
2307                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV6;
2308                 break;
2309         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
2310                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
2311                 CONNECTION_LOG(CONNECTION_WARN, "DEPRECATION WARNINIG: CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6 " \
2312                                                 "from next release. Use CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6 instead");
2313                 break;
2314         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPV6:
2315                 profile_info->ProfileInfo.Pdp.RoamPdnType = NET_PDN_TYPE_IPV4_IPV6;
2316                 break;
2317         default:
2318                 CONN_UNLOCK;
2319                 return CONNECTION_ERROR_INVALID_PARAMETER;
2320         //LCOV_EXCL_STOP
2321         }
2322
2323         CONN_UNLOCK;
2324         return CONNECTION_ERROR_NONE;
2325 }
2326
2327 EXPORT_API int connection_profile_get_ipv6_state(connection_profile_h profile, connection_profile_state_e *state)
2328 {
2329         CONN_LOCK;
2330
2331         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2332                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2333
2334         if (!(_connection_libnet_check_profile_validity(profile)) ||
2335                         state == NULL) {
2336                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2337                 CONN_UNLOCK;
2338                 return CONNECTION_ERROR_INVALID_PARAMETER;
2339         }
2340
2341         net_profile_info_t *profile_info = profile;
2342         *state = _profile_convert_to_cp_state(profile_info->ProfileState6);
2343         if (*state < 0) {
2344                 CONN_UNLOCK;
2345                 return CONNECTION_ERROR_OPERATION_FAILED;
2346         }
2347
2348         CONN_UNLOCK;
2349         return CONNECTION_ERROR_NONE;
2350 }
2351
2352 EXPORT_API int connection_profile_set_dns_config_type(connection_profile_h profile,
2353                 connection_address_family_e address_family, connection_dns_config_type_e type)
2354 {
2355         CONN_LOCK;
2356
2357         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2358                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2359
2360         if (!(_connection_libnet_check_profile_validity(profile))) {
2361                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2362                 CONN_UNLOCK;
2363                 return CONNECTION_ERROR_INVALID_PARAMETER;
2364         }
2365
2366         if ((address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2367                                 address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2368                         (type != CONNECTION_DNS_CONFIG_TYPE_STATIC &&
2369                          type != CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)) {
2370                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2371                 CONN_UNLOCK;
2372                 return CONNECTION_ERROR_INVALID_PARAMETER;
2373         }
2374
2375         net_dns_config_type_t *profileType = NULL;
2376         net_dns_config_type_t *profileType6 = NULL;
2377         net_profile_info_t *profile_info = profile;
2378
2379         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2380         if (net_info == NULL) {
2381                 CONN_UNLOCK;
2382                 return CONNECTION_ERROR_OPERATION_FAILED;
2383         }
2384
2385         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2386                 profileType = &net_info->DnsConfigType;
2387                 net_info->DnsAddr[0].Data.Ipv4.s_addr = 0;
2388                 net_info->DnsAddr[1].Data.Ipv4.s_addr = 0;
2389                 *profileType = type;
2390         } else {
2391                 profileType6 = &net_info->DnsConfigType6;
2392                 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[0].Data.Ipv6);
2393                 inet_pton(AF_INET6, "::", &net_info->DnsAddr6[1].Data.Ipv6);
2394                 *profileType6 = type;
2395         }
2396
2397         CONN_UNLOCK;
2398         return CONNECTION_ERROR_NONE;
2399 }
2400
2401 EXPORT_API int connection_profile_get_dns_config_type(connection_profile_h profile,
2402                 connection_address_family_e address_family, connection_dns_config_type_e *type)
2403 {
2404         CONN_LOCK;
2405
2406         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2407                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2408
2409         if (!(_connection_libnet_check_profile_validity(profile)) ||
2410                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2411                          address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2412                         type == NULL) {
2413                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2414                 CONN_UNLOCK;
2415                 return CONNECTION_ERROR_INVALID_PARAMETER;
2416         }
2417
2418         net_dns_config_type_t profileType;
2419         net_profile_info_t *profile_info = profile;
2420         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2421         if (net_info == NULL) {
2422                 CONN_UNLOCK;
2423                 return CONNECTION_ERROR_OPERATION_FAILED;
2424         }
2425
2426         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2427                 profileType = net_info->DnsConfigType;
2428         else
2429                 profileType = net_info->DnsConfigType6;
2430
2431         switch (profileType) {
2432         case NET_DNS_CONFIG_TYPE_STATIC:
2433                 *type = CONNECTION_DNS_CONFIG_TYPE_STATIC;
2434                 break;
2435         case NET_DNS_CONFIG_TYPE_DYNAMIC:
2436                 *type = CONNECTION_DNS_CONFIG_TYPE_DYNAMIC;
2437                 break;
2438         default:
2439                 *type = CONNECTION_DNS_CONFIG_TYPE_NONE;
2440                 break;
2441         }
2442
2443         CONN_UNLOCK;
2444         return CONNECTION_ERROR_NONE;
2445 }
2446
2447 EXPORT_API int connection_profile_set_prefix_length(connection_profile_h profile,
2448                 connection_address_family_e address_family, int prefix_len)
2449 {
2450         CONN_LOCK;
2451
2452         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2453                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2454
2455         if (!(_connection_libnet_check_profile_validity(profile)) ||
2456                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2457                         address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
2458                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2459                 CONN_UNLOCK;
2460                 return CONNECTION_ERROR_INVALID_PARAMETER;
2461         }
2462
2463         net_profile_info_t *profile_info = profile;
2464         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2465         if (net_info == NULL) {
2466                 CONN_UNLOCK;
2467                 return CONNECTION_ERROR_OPERATION_FAILED;
2468         }
2469
2470         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4) {
2471                 net_info->PrefixLen = prefix_len;
2472                 net_info->SubnetMask.Data.Ipv4.s_addr = __profile_convert_prefix_len_to_netmask(prefix_len);
2473         } else
2474                 net_info->PrefixLen6 = prefix_len;
2475
2476         CONN_UNLOCK;
2477         return CONNECTION_ERROR_NONE;
2478 }
2479
2480 EXPORT_API int connection_profile_get_prefix_length(connection_profile_h profile,
2481                 connection_address_family_e address_family, int *prefix_len)
2482 {
2483         CONN_LOCK;
2484
2485         CHECK_FEATURE_SUPPORTED(TELEPHONY_FEATURE, WIFI_FEATURE,
2486                         TETHERING_BLUETOOTH_FEATURE, ETHERNET_FEATURE);
2487
2488         if (!(_connection_libnet_check_profile_validity(profile)) ||
2489                         (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
2490                         address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
2491                         prefix_len == NULL) {
2492                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid parameter");
2493                 CONN_UNLOCK;
2494                 return CONNECTION_ERROR_INVALID_PARAMETER;
2495         }
2496
2497         net_profile_info_t *profile_info = profile;
2498         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
2499         if (net_info == NULL) {
2500                 CONN_UNLOCK;
2501                 return CONNECTION_ERROR_OPERATION_FAILED;
2502         }
2503
2504         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV4)
2505                 *prefix_len =  net_info->PrefixLen;
2506         else if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
2507                 *prefix_len =  net_info->PrefixLen6;
2508
2509         CONN_UNLOCK;
2510         return CONNECTION_ERROR_NONE;
2511 }