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 <stdio.h>
  18 #include <string.h>
  19 #include <stdlib.h>
  20 #include <arpa/inet.h>
  21 #include <glib.h>
  22 #include <vconf/vconf.h>
  23 #include "net_connection_private.h"
  24
  25 #define HTTP_PROXY "http_proxy"
  26
  27 static net_dev_info_t* __profile_get_net_info(net_profile_info_t *profile_info)
  28 {
  29         switch (profile_info->profile_type) {
  30         case NET_DEVICE_CELLULAR:
  31                 return &profile_info->ProfileInfo.Pdp.net_info;
  32         case NET_DEVICE_WIFI:
  33                 return &profile_info->ProfileInfo.Wlan.net_info;
  34         case NET_DEVICE_ETHERNET:
  35                 return &profile_info->ProfileInfo.Ethernet.net_info;
  36         case NET_DEVICE_BLUETOOTH:
  37                 return &profile_info->ProfileInfo.Bluetooth.net_info;
  38         case NET_DEVICE_DEFAULT:
  39         case NET_DEVICE_USB:
  40         case NET_DEVICE_UNKNOWN:
  41         case NET_DEVICE_MAX:
  42         default:
  43                 return NULL;
  44         }
  45 }
  46
  47 static char* __profile_convert_ip_to_string(net_addr_t *ip_addr)
  48 {
  49         unsigned char *ipaddr = (unsigned char *)&ip_addr->Data.Ipv4.s_addr;
  50
  51         char *ipstr = g_try_malloc0(16);
  52         if (ipstr == NULL)
  53                 return NULL;
  54
  55         snprintf(ipstr, 16, "%d.%d.%d.%d", ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
  56
  57         return ipstr;
  58 }
  59
  60 static void __profile_init_cellular_profile(net_profile_info_t *profile_info, const char *keyword)
  61 {
  62         profile_info->profile_type = NET_DEVICE_CELLULAR;
  63         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  64         profile_info->ProfileInfo.Pdp.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  65         profile_info->ProfileInfo.Pdp.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  66         g_strlcpy(profile_info->ProfileInfo.Pdp.Keyword, keyword, NET_PDP_APN_LEN_MAX);
  67 }
  68
  69 static void __profile_init_wifi_profile(net_profile_info_t *profile_info)
  70 {
  71         profile_info->profile_type = NET_DEVICE_WIFI;
  72         profile_info->ProfileState = NET_STATE_TYPE_IDLE;
  73         profile_info->ProfileInfo.Wlan.net_info.IpConfigType = NET_IP_CONFIG_TYPE_OFF;
  74         profile_info->ProfileInfo.Wlan.net_info.ProxyMethod = NET_PROXY_TYPE_DIRECT;
  75         profile_info->ProfileInfo.Wlan.wlan_mode = NETPM_WLAN_CONNMODE_AUTO;
  76         profile_info->ProfileInfo.Wlan.security_info.sec_mode = WLAN_SEC_MODE_NONE;
  77         profile_info->ProfileInfo.Wlan.security_info.enc_mode = WLAN_ENC_MODE_NONE;
  78 }
  79
  80 static const char* __profile_get_ethernet_proxy(void)
  81 {
  82         char *proxy;
  83
  84         proxy = getenv(HTTP_PROXY);
  85
  86         if(proxy == NULL) {
  87                 CONNECTION_LOG(CONNECTION_ERROR, "Fail to get system proxy");
  88                 return NULL;
  89         }
  90
  91         CONNECTION_LOG(CONNECTION_INFO, "Get system proxy: %s", proxy);
  92         return proxy;
  93 }
  94
  95 connection_cellular_service_type_e _profile_convert_to_connection_cellular_service_type(net_service_type_t svc_type)
  96 {
  97         switch (svc_type) {
  98         case NET_SERVICE_INTERNET:
  99                 return CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
 100         case NET_SERVICE_MMS:
 101                 return CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
 102         case NET_SERVICE_PREPAID_INTERNET:
 103                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
 104         case NET_SERVICE_PREPAID_MMS:
 105                 return CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
 106         case NET_SERVICE_TETHERING:
 107                 return CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
 108         case NET_SERVICE_APPLICATION:
 109                 return CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
 110         default:
 111                 return CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN;
 112         }
 113 }
 114
 115 connection_profile_state_e _profile_convert_to_cp_state(net_state_type_t state)
 116 {
 117         connection_profile_state_e cp_state;
 118
 119         switch (state) {
 120         case NET_STATE_TYPE_ONLINE:
 121         case NET_STATE_TYPE_READY:
 122                 cp_state = CONNECTION_PROFILE_STATE_CONNECTED;
 123                 break;
 124         case NET_STATE_TYPE_IDLE:
 125         case NET_STATE_TYPE_FAILURE:
 126         case NET_STATE_TYPE_DISCONNECT:
 127                 cp_state = CONNECTION_PROFILE_STATE_DISCONNECTED;
 128                 break;
 129         case NET_STATE_TYPE_ASSOCIATION:
 130                 cp_state = CONNECTION_PROFILE_STATE_ASSOCIATION;
 131                 break;
 132         case NET_STATE_TYPE_CONFIGURATION:
 133                 cp_state = CONNECTION_PROFILE_STATE_CONFIGURATION;
 134                 break;
 135         default:
 136                 cp_state = -1;
 137         }
 138
 139         return cp_state;
 140 }
 141
 142 net_service_type_t _connection_profile_convert_to_libnet_cellular_service_type(connection_cellular_service_type_e svc_type)
 143 {
 144         switch (svc_type) {
 145         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
 146                 return NET_SERVICE_INTERNET;
 147         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
 148                 return NET_SERVICE_MMS;
 149         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
 150                 return NET_SERVICE_PREPAID_INTERNET;
 151         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
 152                 return NET_SERVICE_PREPAID_MMS;
 153         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
 154                 return NET_SERVICE_TETHERING;
 155         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
 156                 return NET_SERVICE_APPLICATION;
 157         default:
 158                 return NET_SERVICE_UNKNOWN;
 159         }
 160 }
 161
 162 net_state_type_t _connection_profile_convert_to_net_state(connection_profile_state_e state)
 163 {
 164         net_state_type_t libnet_state = NET_STATE_TYPE_UNKNOWN;
 165
 166         switch (state) {
 167         case CONNECTION_PROFILE_STATE_CONNECTED:
 168                 libnet_state = NET_STATE_TYPE_ONLINE;
 169                 break;
 170         case CONNECTION_PROFILE_STATE_DISCONNECTED:
 171                 libnet_state = NET_STATE_TYPE_IDLE;
 172                 break;
 173         case CONNECTION_PROFILE_STATE_ASSOCIATION:
 174                 libnet_state = NET_STATE_TYPE_ASSOCIATION;
 175                 break;
 176         case CONNECTION_PROFILE_STATE_CONFIGURATION:
 177                 libnet_state = NET_STATE_TYPE_CONFIGURATION;
 178                 break;
 179         }
 180
 181         return libnet_state;
 182 }
 183
 184
 185 /* Connection profile module *********************************************************************/
 186
 187 int connection_profile_create(connection_profile_type_e type, const char* keyword, connection_profile_h* profile)
 188 {
 189         if ((type != CONNECTION_PROFILE_TYPE_CELLULAR &&
 190              type != CONNECTION_PROFILE_TYPE_WIFI) || profile == NULL) {
 191                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 192                 return CONNECTION_ERROR_INVALID_PARAMETER;
 193         }
 194
 195         net_profile_info_t *profile_info = g_try_malloc0(sizeof(net_profile_info_t));
 196         if (profile_info == NULL)
 197                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 198
 199         switch (type) {
 200         case CONNECTION_PROFILE_TYPE_CELLULAR:
 201                 if (keyword == NULL) {
 202                         CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 203                         return CONNECTION_ERROR_INVALID_PARAMETER;
 204                 }
 205                 __profile_init_cellular_profile(profile_info, keyword);
 206                 break;
 207         case CONNECTION_PROFILE_TYPE_WIFI:
 208                 __profile_init_wifi_profile(profile_info);
 209                 break;
 210         default:
 211                 break;
 212         }
 213
 214         *profile = (connection_profile_h)profile_info;
 215         _connection_libnet_add_to_profile_list(*profile);
 216
 217         return CONNECTION_ERROR_NONE;
 218 }
 219
 220 int connection_profile_destroy(connection_profile_h profile)
 221 {
 222         if (!(_connection_libnet_check_profile_validity(profile))) {
 223                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 224                 return CONNECTION_ERROR_INVALID_PARAMETER;
 225         }
 226
 227         _connection_libnet_remove_from_profile_list(profile);
 228
 229         return CONNECTION_ERROR_NONE;
 230 }
 231
 232 int connection_profile_clone(connection_profile_h* cloned_profile, connection_profile_h origin_profile)
 233 {
 234         if (!(_connection_libnet_check_profile_validity(origin_profile)) || cloned_profile == NULL) {
 235                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 236                 return CONNECTION_ERROR_INVALID_PARAMETER;
 237         }
 238
 239         *cloned_profile = g_try_malloc0(sizeof(net_profile_info_t));
 240         if (*cloned_profile == NULL)
 241                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 242
 243         memcpy(*cloned_profile, origin_profile, sizeof(net_profile_info_t));
 244         _connection_libnet_add_to_profile_list(*cloned_profile);
 245
 246         return CONNECTION_ERROR_NONE;
 247 }
 248
 249 int connection_profile_get_id(connection_profile_h profile, char** profile_id)
 250 {
 251         if (!(_connection_libnet_check_profile_validity(profile)) || profile_id == NULL) {
 252                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 253                 return CONNECTION_ERROR_INVALID_PARAMETER;
 254         }
 255
 256         net_profile_info_t *profile_info = profile;
 257
 258         char *prof_id = strrchr(profile_info->ProfileName, '/');
 259         if (prof_id == NULL)
 260                 return CONNECTION_ERROR_INVALID_PARAMETER;
 261
 262         prof_id++;
 263         *profile_id = g_strdup(prof_id);
 264
 265         if (*profile_id == NULL)
 266                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 267
 268         return CONNECTION_ERROR_NONE;
 269 }
 270
 271 int connection_profile_get_name(connection_profile_h profile, char** profile_name)
 272 {
 273         if (!(_connection_libnet_check_profile_validity(profile)) || profile_name == NULL) {
 274                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 275                 return CONNECTION_ERROR_INVALID_PARAMETER;
 276         }
 277
 278         net_profile_info_t *profile_info = profile;
 279
 280         switch (profile_info->profile_type) {
 281         case NET_DEVICE_CELLULAR:
 282                 *profile_name = g_strdup(profile_info->ProfileInfo.Pdp.Keyword);
 283                 break;
 284         case NET_DEVICE_WIFI:
 285                 *profile_name = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 286                 break;
 287         case NET_DEVICE_ETHERNET:
 288                 *profile_name = g_strdup(profile_info->ProfileInfo.Ethernet.net_info.DevName);
 289                 break;
 290         case NET_DEVICE_BLUETOOTH: {
 291                 char *bt_name = strrchr(profile_info->ProfileName, '/');
 292                 if (bt_name == NULL)
 293                         return CONNECTION_ERROR_INVALID_PARAMETER;
 294
 295                 bt_name++;
 296                 *profile_name = g_strdup(bt_name);
 297         } break;
 298         default:
 299                 return CONNECTION_ERROR_INVALID_PARAMETER;
 300         }
 301
 302         if (*profile_name == NULL)
 303                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 304
 305         return CONNECTION_ERROR_NONE;
 306 }
 307
 308 int connection_profile_get_type(connection_profile_h profile, connection_profile_type_e* type)
 309 {
 310         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 311                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 312                 return CONNECTION_ERROR_INVALID_PARAMETER;
 313         }
 314
 315         net_profile_info_t *profile_info = profile;
 316
 317         switch (profile_info->profile_type) {
 318         case NET_DEVICE_CELLULAR:
 319                 *type = CONNECTION_PROFILE_TYPE_CELLULAR;
 320                 break;
 321         case NET_DEVICE_WIFI:
 322                 *type = CONNECTION_PROFILE_TYPE_WIFI;
 323                 break;
 324         case NET_DEVICE_ETHERNET:
 325                 *type = CONNECTION_PROFILE_TYPE_ETHERNET;
 326                 break;
 327         case NET_DEVICE_BLUETOOTH:
 328                 *type = CONNECTION_PROFILE_TYPE_BT;
 329                 break;
 330         default:
 331                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type\n");
 332                 return CONNECTION_ERROR_OPERATION_FAILED;
 333         }
 334
 335         return CONNECTION_ERROR_NONE;
 336 }
 337
 338 int connection_profile_get_network_interface_name(connection_profile_h profile, char** interface_name)
 339 {
 340         if (!(_connection_libnet_check_profile_validity(profile)) || interface_name == NULL) {
 341                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 342                 return CONNECTION_ERROR_INVALID_PARAMETER;
 343         }
 344
 345         net_profile_info_t *profile_info = profile;
 346         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 347         if (net_info == NULL)
 348                 return CONNECTION_ERROR_INVALID_PARAMETER;
 349
 350         *interface_name = g_strdup(net_info->DevName);
 351         if (*interface_name == NULL)
 352                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 353
 354         return CONNECTION_ERROR_NONE;
 355 }
 356
 357 int connection_profile_refresh(connection_profile_h profile)
 358 {
 359         if (!(_connection_libnet_check_profile_validity(profile))) {
 360                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 361                 return CONNECTION_ERROR_INVALID_PARAMETER;
 362         }
 363
 364         net_profile_info_t profile_info_local;
 365         net_profile_info_t *profile_info = profile;
 366
 367         if (net_get_profile_info(profile_info->ProfileName, &profile_info_local) != NET_ERR_NONE) {
 368                 CONNECTION_LOG(CONNECTION_ERROR, "Error!!! net_get_profile_info() failed\n");
 369                 return CONNECTION_ERROR_OPERATION_FAILED;
 370         }
 371
 372         memcpy(profile, &profile_info_local, sizeof(net_profile_info_t));
 373
 374         return CONNECTION_ERROR_NONE;
 375 }
 376
 377 int connection_profile_get_state(connection_profile_h profile, connection_profile_state_e* state)
 378 {
 379         if (!(_connection_libnet_check_profile_validity(profile)) || state == NULL) {
 380                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 381                 return CONNECTION_ERROR_INVALID_PARAMETER;
 382         }
 383
 384         net_profile_info_t *profile_info = profile;
 385         *state = _profile_convert_to_cp_state(profile_info->ProfileState);
 386         if (*state < 0)
 387                 return CONNECTION_ERROR_OPERATION_FAILED;
 388
 389         return CONNECTION_ERROR_NONE;
 390 }
 391
 392 int connection_profile_get_ip_config_type(connection_profile_h profile,
 393                 connection_address_family_e address_family, connection_ip_config_type_e* type)
 394 {
 395         if (!(_connection_libnet_check_profile_validity(profile)) ||
 396             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 397              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 398             type == NULL) {
 399                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 400                 return CONNECTION_ERROR_INVALID_PARAMETER;
 401         }
 402
 403         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 404                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 405
 406         net_profile_info_t *profile_info = profile;
 407         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 408         if (net_info == NULL)
 409                 return CONNECTION_ERROR_OPERATION_FAILED;
 410
 411         switch (net_info->IpConfigType) {
 412         case NET_IP_CONFIG_TYPE_STATIC:
 413                 *type = CONNECTION_IP_CONFIG_TYPE_STATIC;
 414                 break;
 415         case NET_IP_CONFIG_TYPE_DYNAMIC:
 416                 *type = CONNECTION_IP_CONFIG_TYPE_DYNAMIC;
 417                 break;
 418         case NET_IP_CONFIG_TYPE_AUTO_IP:
 419                 *type = CONNECTION_IP_CONFIG_TYPE_AUTO;
 420                 break;
 421         case NET_IP_CONFIG_TYPE_FIXED:
 422                 *type = CONNECTION_IP_CONFIG_TYPE_FIXED;
 423                 break;
 424         case NET_IP_CONFIG_TYPE_OFF:
 425                 *type = CONNECTION_IP_CONFIG_TYPE_NONE;
 426                 break;
 427         default:
 428                 return CONNECTION_ERROR_OPERATION_FAILED;
 429         }
 430
 431         return CONNECTION_ERROR_NONE;
 432 }
 433
 434 int connection_profile_get_ip_address(connection_profile_h profile,
 435                 connection_address_family_e address_family, char** ip_address)
 436 {
 437         if (!(_connection_libnet_check_profile_validity(profile)) ||
 438             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 439              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 440             ip_address == NULL) {
 441                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 442                 return CONNECTION_ERROR_INVALID_PARAMETER;
 443         }
 444
 445         net_profile_info_t *profile_info = profile;
 446         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 447         if (net_info == NULL)
 448                 return CONNECTION_ERROR_OPERATION_FAILED;
 449
 450         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 451                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 452
 453         *ip_address = __profile_convert_ip_to_string(&net_info->IpAddr);
 454         if (*ip_address == NULL)
 455                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 456
 457         return CONNECTION_ERROR_NONE;
 458 }
 459
 460 int connection_profile_get_subnet_mask(connection_profile_h profile,
 461                 connection_address_family_e address_family, char** subnet_mask)
 462 {
 463         if (!(_connection_libnet_check_profile_validity(profile)) ||
 464             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 465              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 466             subnet_mask == NULL) {
 467                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 468                 return CONNECTION_ERROR_INVALID_PARAMETER;
 469         }
 470
 471         net_profile_info_t *profile_info = profile;
 472         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 473         if (net_info == NULL)
 474                 return CONNECTION_ERROR_OPERATION_FAILED;
 475
 476         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 477                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 478
 479         *subnet_mask = __profile_convert_ip_to_string(&net_info->SubnetMask);
 480         if (*subnet_mask == NULL)
 481                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 482
 483         return CONNECTION_ERROR_NONE;
 484 }
 485
 486 int connection_profile_get_gateway_address(connection_profile_h profile,
 487                 connection_address_family_e address_family, char** gateway_address)
 488 {
 489         if (!(_connection_libnet_check_profile_validity(profile)) ||
 490             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 491              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 492             gateway_address == NULL) {
 493                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 494                 return CONNECTION_ERROR_INVALID_PARAMETER;
 495         }
 496
 497         net_profile_info_t *profile_info = profile;
 498         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 499         if (net_info == NULL)
 500                 return CONNECTION_ERROR_OPERATION_FAILED;
 501
 502         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 503                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 504
 505         *gateway_address = __profile_convert_ip_to_string(&net_info->GatewayAddr);
 506         if (*gateway_address == NULL)
 507                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 508
 509         return CONNECTION_ERROR_NONE;
 510 }
 511
 512 int connection_profile_get_dns_address(connection_profile_h profile, int order,
 513                 connection_address_family_e address_family, char** dns_address)
 514 {
 515         if (!(_connection_libnet_check_profile_validity(profile)) ||
 516             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 517              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 518             dns_address == NULL ||
 519             order <= 0 ||
 520             order > NET_DNS_ADDR_MAX) {
 521                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 522                 return CONNECTION_ERROR_INVALID_PARAMETER;
 523         }
 524
 525         net_profile_info_t *profile_info = profile;
 526         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 527         if (net_info == NULL)
 528                 return CONNECTION_ERROR_OPERATION_FAILED;
 529
 530         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 531                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 532
 533         *dns_address = __profile_convert_ip_to_string(&net_info->DnsAddr[order-1]);
 534         if (*dns_address == NULL)
 535                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 536
 537         return CONNECTION_ERROR_NONE;
 538 }
 539
 540 int connection_profile_get_proxy_type(connection_profile_h profile, connection_proxy_type_e* type)
 541 {
 542         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 543                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 544                 return CONNECTION_ERROR_INVALID_PARAMETER;
 545         }
 546
 547         const char *proxy;
 548         net_profile_info_t *profile_info = profile;
 549         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 550         if (net_info == NULL)
 551                 return CONNECTION_ERROR_OPERATION_FAILED;
 552
 553         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 554                 proxy = __profile_get_ethernet_proxy();
 555                 if (proxy == NULL)
 556                         *type = CONNECTION_PROXY_TYPE_DIRECT;
 557                 else
 558                         *type = CONNECTION_PROXY_TYPE_MANUAL;
 559
 560                 return CONNECTION_ERROR_NONE;
 561         }
 562
 563         switch (net_info->ProxyMethod) {
 564         case NET_PROXY_TYPE_DIRECT:
 565                 *type = CONNECTION_PROXY_TYPE_DIRECT;
 566                 break;
 567         case NET_PROXY_TYPE_AUTO:
 568                 *type = CONNECTION_PROXY_TYPE_AUTO;
 569                 break;
 570         case NET_PROXY_TYPE_MANUAL:
 571                 *type = CONNECTION_PROXY_TYPE_MANUAL;
 572                 break;
 573         case NET_PROXY_TYPE_UNKNOWN:
 574         default:
 575                 return CONNECTION_ERROR_OPERATION_FAILED;
 576         }
 577
 578         return CONNECTION_ERROR_NONE;
 579 }
 580
 581 int connection_profile_get_proxy_address(connection_profile_h profile,
 582                 connection_address_family_e address_family, char** proxy_address)
 583 {
 584         if (!(_connection_libnet_check_profile_validity(profile)) ||
 585             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 586              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 587              proxy_address == NULL) {
 588                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 589                 return CONNECTION_ERROR_INVALID_PARAMETER;
 590         }
 591
 592         const char *proxy;
 593         net_profile_info_t *profile_info = profile;
 594         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 595         if (net_info == NULL)
 596                 return CONNECTION_ERROR_OPERATION_FAILED;
 597
 598         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 599                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 600
 601         if (profile_info->profile_type == NET_DEVICE_ETHERNET) {
 602                 proxy = __profile_get_ethernet_proxy();
 603                 if (proxy == NULL)
 604                         return CONNECTION_ERROR_OPERATION_FAILED;
 605
 606                 *proxy_address = g_strdup(proxy);
 607         } else
 608                 *proxy_address = g_strdup(net_info->ProxyAddr);
 609
 610         if (*proxy_address == NULL)
 611                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 612
 613         return CONNECTION_ERROR_NONE;
 614 }
 615
 616 int connection_profile_set_ip_config_type(connection_profile_h profile,
 617                 connection_address_family_e address_family, connection_ip_config_type_e type)
 618 {
 619         if (!(_connection_libnet_check_profile_validity(profile)) ||
 620             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 621              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 622                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 623                 return CONNECTION_ERROR_INVALID_PARAMETER;
 624         }
 625
 626         net_profile_info_t *profile_info = profile;
 627         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 628         if (net_info == NULL)
 629                 return CONNECTION_ERROR_OPERATION_FAILED;
 630
 631         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 632                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 633
 634         switch (type) {
 635         case CONNECTION_IP_CONFIG_TYPE_STATIC:
 636                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_STATIC;
 637                 net_info->IpAddr.Data.Ipv4.s_addr = 0;
 638                 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 639                 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
 640                 break;
 641         case CONNECTION_IP_CONFIG_TYPE_DYNAMIC:
 642                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_DYNAMIC;
 643                 break;
 644         case CONNECTION_IP_CONFIG_TYPE_AUTO:
 645                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_AUTO_IP;
 646                 break;
 647         case CONNECTION_IP_CONFIG_TYPE_FIXED:
 648                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_FIXED;
 649                 break;
 650         case CONNECTION_IP_CONFIG_TYPE_NONE:
 651                 net_info->IpConfigType = NET_IP_CONFIG_TYPE_OFF;
 652                 break;
 653         default:
 654                 return CONNECTION_ERROR_INVALID_PARAMETER;
 655         }
 656
 657         return CONNECTION_ERROR_NONE;
 658 }
 659
 660 int connection_profile_set_ip_address(connection_profile_h profile,
 661                 connection_address_family_e address_family, const char* ip_address)
 662 {
 663         if (!(_connection_libnet_check_profile_validity(profile)) ||
 664             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 665              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 666                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 667                 return CONNECTION_ERROR_INVALID_PARAMETER;
 668         }
 669
 670         net_profile_info_t *profile_info = profile;
 671         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 672         if (net_info == NULL)
 673                 return CONNECTION_ERROR_OPERATION_FAILED;
 674
 675         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 676                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 677
 678         if (ip_address == NULL)
 679                 net_info->IpAddr.Data.Ipv4.s_addr = 0;
 680         else if (inet_aton(ip_address, &(net_info->IpAddr.Data.Ipv4)) == 0)
 681                 return CONNECTION_ERROR_INVALID_PARAMETER;
 682
 683         return CONNECTION_ERROR_NONE;
 684 }
 685
 686 int connection_profile_set_subnet_mask(connection_profile_h profile,
 687                 connection_address_family_e address_family, const char* subnet_mask)
 688 {
 689         if (!(_connection_libnet_check_profile_validity(profile)) ||
 690             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 691              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 692                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 693                 return CONNECTION_ERROR_INVALID_PARAMETER;
 694         }
 695
 696         net_profile_info_t *profile_info = profile;
 697         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 698         if (net_info == NULL)
 699                 return CONNECTION_ERROR_OPERATION_FAILED;
 700
 701         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 702                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 703
 704         if (subnet_mask == NULL)
 705                 net_info->SubnetMask.Data.Ipv4.s_addr = 0;
 706         else if (inet_aton(subnet_mask, &(net_info->SubnetMask.Data.Ipv4)) == 0)
 707                 return CONNECTION_ERROR_INVALID_PARAMETER;
 708
 709         return CONNECTION_ERROR_NONE;
 710 }
 711
 712 int connection_profile_set_gateway_address(connection_profile_h profile,
 713                 connection_address_family_e address_family, const char* gateway_address)
 714 {
 715         if (!(_connection_libnet_check_profile_validity(profile)) ||
 716             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 717              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 718                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 719                 return CONNECTION_ERROR_INVALID_PARAMETER;
 720         }
 721
 722         net_profile_info_t *profile_info = profile;
 723         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 724         if (net_info == NULL)
 725                 return CONNECTION_ERROR_OPERATION_FAILED;
 726
 727         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 728                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 729
 730         if (gateway_address == NULL)
 731                 net_info->GatewayAddr.Data.Ipv4.s_addr = 0;
 732         else if (inet_aton(gateway_address, &(net_info->GatewayAddr.Data.Ipv4)) == 0)
 733                 return CONNECTION_ERROR_INVALID_PARAMETER;
 734
 735         return CONNECTION_ERROR_NONE;
 736 }
 737
 738 int connection_profile_set_dns_address(connection_profile_h profile, int order,
 739                 connection_address_family_e address_family, const char* dns_address)
 740 {
 741         if (!(_connection_libnet_check_profile_validity(profile)) ||
 742             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 743              address_family != CONNECTION_ADDRESS_FAMILY_IPV6) ||
 744             order <= 0 ||
 745             order > NET_DNS_ADDR_MAX) {
 746                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 747                 return CONNECTION_ERROR_INVALID_PARAMETER;
 748         }
 749
 750         net_profile_info_t *profile_info = profile;
 751         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 752         if (net_info == NULL)
 753                 return CONNECTION_ERROR_OPERATION_FAILED;
 754
 755         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 756                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 757
 758         if (dns_address == NULL)
 759                 net_info->DnsAddr[order-1].Data.Ipv4.s_addr = 0;
 760         else if (inet_aton(dns_address, &(net_info->DnsAddr[order-1].Data.Ipv4)) == 0)
 761                 return CONNECTION_ERROR_INVALID_PARAMETER;
 762
 763         return CONNECTION_ERROR_NONE;
 764 }
 765
 766 int connection_profile_set_proxy_type(connection_profile_h profile, connection_proxy_type_e type)
 767 {
 768         if (!(_connection_libnet_check_profile_validity(profile))) {
 769                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 770                 return CONNECTION_ERROR_INVALID_PARAMETER;
 771         }
 772
 773         net_profile_info_t *profile_info = profile;
 774         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 775         if (net_info == NULL)
 776                 return CONNECTION_ERROR_OPERATION_FAILED;
 777
 778         switch (type) {
 779         case CONNECTION_PROXY_TYPE_DIRECT:
 780                 net_info->ProxyMethod = NET_PROXY_TYPE_DIRECT;
 781                 break;
 782         case CONNECTION_PROXY_TYPE_AUTO:
 783                 net_info->ProxyMethod = NET_PROXY_TYPE_AUTO;
 784                 break;
 785         case CONNECTION_PROXY_TYPE_MANUAL:
 786                 net_info->ProxyMethod = NET_PROXY_TYPE_MANUAL;
 787                 break;
 788         default:
 789                 return CONNECTION_ERROR_INVALID_PARAMETER;
 790         }
 791
 792         return CONNECTION_ERROR_NONE;
 793 }
 794
 795 int connection_profile_set_proxy_address(connection_profile_h profile,
 796                 connection_address_family_e address_family, const char* proxy_address)
 797 {
 798         if (!(_connection_libnet_check_profile_validity(profile)) ||
 799             (address_family != CONNECTION_ADDRESS_FAMILY_IPV4 &&
 800              address_family != CONNECTION_ADDRESS_FAMILY_IPV6)) {
 801                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 802                 return CONNECTION_ERROR_INVALID_PARAMETER;
 803         }
 804
 805         net_profile_info_t *profile_info = profile;
 806         net_dev_info_t *net_info = __profile_get_net_info(profile_info);
 807         if (net_info == NULL)
 808                 return CONNECTION_ERROR_OPERATION_FAILED;
 809
 810         if (address_family == CONNECTION_ADDRESS_FAMILY_IPV6)
 811                 return CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED;
 812
 813         if (proxy_address == NULL)
 814                 net_info->ProxyAddr[0] = '\0';
 815         else
 816                 g_strlcpy(net_info->ProxyAddr, proxy_address, NET_PROXY_LEN_MAX);
 817
 818         return CONNECTION_ERROR_NONE;
 819 }
 820
 821 int connection_profile_set_state_changed_cb(connection_profile_h profile,
 822                 connection_profile_state_changed_cb callback, void* user_data)
 823 {
 824         if (!(_connection_libnet_check_profile_validity(profile)) || callback == NULL) {
 825                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 826                 return CONNECTION_ERROR_INVALID_PARAMETER;
 827         }
 828
 829         if (_connection_libnet_add_to_profile_cb_list(profile, callback, user_data))
 830                 return CONNECTION_ERROR_NONE;
 831
 832         return CONNECTION_ERROR_OPERATION_FAILED;
 833 }
 834
 835 int connection_profile_unset_state_changed_cb(connection_profile_h profile)
 836 {
 837         if (!(_connection_libnet_check_profile_cb_validity(profile))) {
 838                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 839                 return CONNECTION_ERROR_INVALID_PARAMETER;
 840         }
 841
 842         _connection_libnet_remove_from_profile_cb_list(profile);
 843
 844         return CONNECTION_ERROR_NONE;
 845 }
 846
 847
 848 /* Wi-Fi profile module **************************************************************************/
 849
 850 int connection_profile_get_wifi_essid(connection_profile_h profile, char** essid)
 851 {
 852         if (!(_connection_libnet_check_profile_validity(profile)) || essid == NULL) {
 853                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 854                 return CONNECTION_ERROR_INVALID_PARAMETER;
 855         }
 856
 857         net_profile_info_t *profile_info = profile;
 858
 859         if (profile_info->profile_type != NET_DEVICE_WIFI)
 860                 return CONNECTION_ERROR_INVALID_PARAMETER;
 861
 862         *essid = g_strdup(profile_info->ProfileInfo.Wlan.essid);
 863         if (*essid == NULL)
 864                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 865
 866         return CONNECTION_ERROR_NONE;
 867 }
 868
 869 int connection_profile_get_wifi_bssid(connection_profile_h profile, char** bssid)
 870 {
 871         if (!(_connection_libnet_check_profile_validity(profile)) || bssid == NULL) {
 872                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 873                 return CONNECTION_ERROR_INVALID_PARAMETER;
 874         }
 875
 876         net_profile_info_t *profile_info = profile;
 877
 878         if (profile_info->profile_type != NET_DEVICE_WIFI)
 879                 return CONNECTION_ERROR_INVALID_PARAMETER;
 880
 881         *bssid = g_strdup(profile_info->ProfileInfo.Wlan.bssid);
 882         if (*bssid == NULL)
 883                 return CONNECTION_ERROR_OUT_OF_MEMORY;
 884
 885         return CONNECTION_ERROR_NONE;
 886 }
 887
 888 int connection_profile_get_wifi_rssi(connection_profile_h profile, int* rssi)
 889 {
 890         if (!(_connection_libnet_check_profile_validity(profile)) || rssi == NULL) {
 891                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 892                 return CONNECTION_ERROR_INVALID_PARAMETER;
 893         }
 894
 895         net_profile_info_t *profile_info = profile;
 896
 897         if (profile_info->profile_type != NET_DEVICE_WIFI)
 898                 return CONNECTION_ERROR_INVALID_PARAMETER;
 899
 900         *rssi = (int)profile_info->ProfileInfo.Wlan.Strength;
 901
 902         return CONNECTION_ERROR_NONE;
 903 }
 904
 905 int connection_profile_get_wifi_frequency(connection_profile_h profile, int* frequency)
 906 {
 907         if (!(_connection_libnet_check_profile_validity(profile)) || frequency == NULL) {
 908                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 909                 return CONNECTION_ERROR_INVALID_PARAMETER;
 910         }
 911
 912         net_profile_info_t *profile_info = profile;
 913
 914         if (profile_info->profile_type != NET_DEVICE_WIFI)
 915                 return CONNECTION_ERROR_INVALID_PARAMETER;
 916
 917         *frequency = (int)profile_info->ProfileInfo.Wlan.frequency;
 918
 919         return CONNECTION_ERROR_NONE;
 920 }
 921
 922 int connection_profile_get_wifi_max_speed(connection_profile_h profile, int* max_speed)
 923 {
 924         if (!(_connection_libnet_check_profile_validity(profile)) || max_speed == NULL) {
 925                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 926                 return CONNECTION_ERROR_INVALID_PARAMETER;
 927         }
 928
 929         net_profile_info_t *profile_info = profile;
 930
 931         if (profile_info->profile_type != NET_DEVICE_WIFI)
 932                 return CONNECTION_ERROR_INVALID_PARAMETER;
 933
 934         *max_speed = (int)profile_info->ProfileInfo.Wlan.max_rate;
 935
 936         return CONNECTION_ERROR_NONE;
 937 }
 938
 939 int connection_profile_get_wifi_security_type(connection_profile_h profile, connection_wifi_security_type_e* type)
 940 {
 941         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 942                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 943                 return CONNECTION_ERROR_INVALID_PARAMETER;
 944         }
 945
 946         net_profile_info_t *profile_info = profile;
 947
 948         if (profile_info->profile_type != NET_DEVICE_WIFI)
 949                 return CONNECTION_ERROR_INVALID_PARAMETER;
 950
 951         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
 952         case WLAN_SEC_MODE_NONE:
 953                 *type = CONNECTION_WIFI_SECURITY_TYPE_NONE;
 954                 break;
 955         case WLAN_SEC_MODE_WEP:
 956                 *type = CONNECTION_WIFI_SECURITY_TYPE_WEP;
 957                 break;
 958         case WLAN_SEC_MODE_IEEE8021X:
 959                 *type = CONNECTION_WIFI_SECURITY_TYPE_EAP;
 960                 break;
 961         case WLAN_SEC_MODE_WPA_PSK:
 962                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA_PSK;
 963                 break;
 964         case WLAN_SEC_MODE_WPA2_PSK:
 965                 *type = CONNECTION_WIFI_SECURITY_TYPE_WPA2_PSK;
 966                 break;
 967         default:
 968                 return CONNECTION_ERROR_OPERATION_FAILED;
 969         }
 970
 971         return CONNECTION_ERROR_NONE;
 972 }
 973
 974 int connection_profile_get_wifi_encryption_type(connection_profile_h profile, connection_wifi_encryption_type_e* type)
 975 {
 976         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
 977                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
 978                 return CONNECTION_ERROR_INVALID_PARAMETER;
 979         }
 980
 981         net_profile_info_t *profile_info = profile;
 982
 983         if (profile_info->profile_type != NET_DEVICE_WIFI)
 984                 return CONNECTION_ERROR_INVALID_PARAMETER;
 985
 986         switch (profile_info->ProfileInfo.Wlan.security_info.enc_mode) {
 987         case WLAN_ENC_MODE_NONE:
 988                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_NONE;
 989                 break;
 990         case WLAN_ENC_MODE_WEP:
 991                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_WEP;
 992                 break;
 993         case WLAN_ENC_MODE_TKIP:
 994                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP;
 995                 break;
 996         case WLAN_ENC_MODE_AES:
 997                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_AES;
 998                 break;
 999         case WLAN_ENC_MODE_TKIP_AES_MIXED:
1000                 *type = CONNECTION_WIFI_ENCRYPTION_TYPE_TKIP_AES_MIXED;
1001                 break;
1002         default:
1003                 return CONNECTION_ERROR_OPERATION_FAILED;
1004         }
1005
1006         return CONNECTION_ERROR_NONE;
1007 }
1008
1009 int connection_profile_is_wifi_passphrase_required(connection_profile_h profile, bool* required)
1010 {
1011         if (!(_connection_libnet_check_profile_validity(profile)) || required == NULL) {
1012                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1013                 return CONNECTION_ERROR_INVALID_PARAMETER;
1014         }
1015
1016         net_profile_info_t *profile_info = profile;
1017
1018         if (profile_info->profile_type != NET_DEVICE_WIFI)
1019                 return CONNECTION_ERROR_INVALID_PARAMETER;
1020
1021         if (profile_info->Favourite) {
1022                 *required = false;
1023                 return CONNECTION_ERROR_NONE;
1024         }
1025
1026         switch (profile_info->ProfileInfo.Wlan.security_info.sec_mode) {
1027         case WLAN_SEC_MODE_NONE:
1028                 *required = false;
1029                 break;
1030         case WLAN_SEC_MODE_WEP:
1031         case WLAN_SEC_MODE_IEEE8021X:
1032         case WLAN_SEC_MODE_WPA_PSK:
1033         case WLAN_SEC_MODE_WPA2_PSK:
1034                 *required = true;
1035                 break;
1036         default:
1037                 return CONNECTION_ERROR_OPERATION_FAILED;
1038         }
1039
1040         return CONNECTION_ERROR_NONE;
1041 }
1042
1043 int connection_profile_set_wifi_passphrase(connection_profile_h profile, const char* passphrase)
1044 {
1045         if (!(_connection_libnet_check_profile_validity(profile)) || passphrase == NULL) {
1046                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1047                 return CONNECTION_ERROR_INVALID_PARAMETER;
1048         }
1049
1050         net_profile_info_t *profile_info = profile;
1051
1052         if (profile_info->profile_type != NET_DEVICE_WIFI)
1053                 return CONNECTION_ERROR_INVALID_PARAMETER;
1054
1055         g_strlcpy(profile_info->ProfileInfo.Wlan.security_info.authentication.psk.pskKey,
1056                                                 passphrase, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN);
1057
1058         return CONNECTION_ERROR_NONE;
1059 }
1060
1061 int connection_profile_is_wifi_wps_supported(connection_profile_h profile, bool* supported)
1062 {
1063         if (!(_connection_libnet_check_profile_validity(profile)) || supported == NULL) {
1064                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1065                 return CONNECTION_ERROR_INVALID_PARAMETER;
1066         }
1067
1068         net_profile_info_t *profile_info = profile;
1069
1070         if (profile_info->profile_type != NET_DEVICE_WIFI)
1071                 return CONNECTION_ERROR_INVALID_PARAMETER;
1072
1073         if (profile_info->ProfileInfo.Wlan.security_info.wps_support)
1074                 *supported = true;
1075         else
1076                 *supported = false;
1077
1078         return CONNECTION_ERROR_NONE;
1079 }
1080
1081
1082 /* Cellular profile module ***********************************************************************/
1083
1084 int connection_profile_get_cellular_network_type(connection_profile_h profile, connection_cellular_network_type_e* type)
1085 {
1086         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1087                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1088                 return CONNECTION_ERROR_INVALID_PARAMETER;
1089         }
1090
1091         int network_type;
1092         net_profile_info_t *profile_info = profile;
1093
1094         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1095                 return CONNECTION_ERROR_INVALID_PARAMETER;
1096
1097         if (vconf_get_int(VCONFKEY_TELEPHONY_SVC_ACT, &network_type)) {
1098                 CONNECTION_LOG(CONNECTION_ERROR, "vconf_get_int Failed\n");
1099                 return CONNECTION_ERROR_OPERATION_FAILED;
1100         }
1101
1102         CONNECTION_LOG(CONNECTION_INFO, "Cellular network type = %d\n", network_type);
1103
1104         switch (network_type) {
1105         case VCONFKEY_TELEPHONY_SVC_ACT_NONE:
1106                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UNKNOWN;
1107                 break;
1108         case VCONFKEY_TELEPHONY_SVC_ACT_GPRS:
1109                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_GPRS;
1110                 break;
1111         case VCONFKEY_TELEPHONY_SVC_ACT_EGPRS:
1112                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_EDGE;
1113                 break;
1114         case VCONFKEY_TELEPHONY_SVC_ACT_UMTS:
1115                 *type = CONNECTION_CELLULAR_NETWORK_TYPE_UMTS;
1116                 break;
1117         default:
1118                 return CONNECTION_ERROR_OPERATION_FAILED;
1119         }
1120
1121         return CONNECTION_ERROR_NONE;
1122 }
1123
1124 int connection_profile_get_cellular_service_type(connection_profile_h profile,
1125                                                 connection_cellular_service_type_e* type)
1126 {
1127         if (!(_connection_libnet_check_profile_validity(profile)) || type == NULL) {
1128                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1129                 return CONNECTION_ERROR_INVALID_PARAMETER;
1130         }
1131
1132         net_profile_info_t *profile_info = profile;
1133
1134         if (profile_info->profile_type != NET_DEVICE_CELLULAR) {
1135                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid profile type Passed\n");
1136                 return CONNECTION_ERROR_INVALID_PARAMETER;
1137         }
1138
1139         *type = _profile_convert_to_connection_cellular_service_type(profile_info->ProfileInfo.Pdp.ServiceType);
1140
1141         if (*type == CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN) {
1142                 CONNECTION_LOG(CONNECTION_ERROR, "Invalid service type Passed\n");
1143                 return CONNECTION_ERROR_OPERATION_FAILED;
1144         }
1145
1146         return CONNECTION_ERROR_NONE;
1147 }
1148
1149 int connection_profile_get_cellular_apn(connection_profile_h profile, char** apn)
1150 {
1151         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1152                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1153                 return CONNECTION_ERROR_INVALID_PARAMETER;
1154         }
1155
1156         net_profile_info_t *profile_info = profile;
1157
1158         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1159                 return CONNECTION_ERROR_INVALID_PARAMETER;
1160
1161         *apn = g_strdup(profile_info->ProfileInfo.Pdp.Apn);
1162         if (*apn == NULL)
1163                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1164
1165         return CONNECTION_ERROR_NONE;
1166 }
1167
1168 int connection_profile_get_cellular_auth_info(connection_profile_h profile,
1169                 connection_cellular_auth_type_e* type, char** user_name, char** password)
1170 {
1171         if (!(_connection_libnet_check_profile_validity(profile)) ||
1172             type == NULL || user_name == NULL || password == NULL) {
1173                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1174                 return CONNECTION_ERROR_INVALID_PARAMETER;
1175         }
1176
1177         net_profile_info_t *profile_info = profile;
1178
1179         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1180                 return CONNECTION_ERROR_INVALID_PARAMETER;
1181
1182         switch (profile_info->ProfileInfo.Pdp.AuthInfo.AuthType) {
1183         case NET_PDP_AUTH_NONE:
1184                 *type = CONNECTION_CELLULAR_AUTH_TYPE_NONE;
1185                 break;
1186         case NET_PDP_AUTH_PAP:
1187                 *type = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
1188                 break;
1189         case NET_PDP_AUTH_CHAP:
1190                 *type = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
1191                 break;
1192         default:
1193                 return CONNECTION_ERROR_OPERATION_FAILED;
1194         }
1195
1196         *user_name = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.UserName);
1197         if (*user_name == NULL)
1198                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1199
1200         *password = g_strdup(profile_info->ProfileInfo.Pdp.AuthInfo.Password);
1201         if (*password == NULL) {
1202                 g_free(*user_name);
1203                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1204         }
1205
1206         return CONNECTION_ERROR_NONE;
1207 }
1208
1209 int connection_profile_get_cellular_home_url(connection_profile_h profile, char** home_url)
1210 {
1211         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1212                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1213                 return CONNECTION_ERROR_INVALID_PARAMETER;
1214         }
1215
1216         net_profile_info_t *profile_info = profile;
1217
1218         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1219                 return CONNECTION_ERROR_INVALID_PARAMETER;
1220
1221         *home_url = g_strdup(profile_info->ProfileInfo.Pdp.HomeURL);
1222         if (*home_url == NULL)
1223                 return CONNECTION_ERROR_OUT_OF_MEMORY;
1224
1225         return CONNECTION_ERROR_NONE;
1226 }
1227
1228 int connection_profile_is_cellular_roaming(connection_profile_h profile, bool* is_roaming)
1229 {
1230         if (!(_connection_libnet_check_profile_validity(profile)) || is_roaming == NULL) {
1231                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1232                 return CONNECTION_ERROR_INVALID_PARAMETER;
1233         }
1234
1235         net_profile_info_t *profile_info = profile;
1236
1237         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1238                 return CONNECTION_ERROR_INVALID_PARAMETER;
1239
1240         if (profile_info->ProfileInfo.Pdp.Roaming)
1241                 *is_roaming = true;
1242         else
1243                 *is_roaming = false;
1244
1245         return CONNECTION_ERROR_NONE;
1246 }
1247
1248 int connection_profile_set_cellular_service_type(connection_profile_h profile,
1249                 connection_cellular_service_type_e service_type)
1250 {
1251         if (!(_connection_libnet_check_profile_validity(profile))) {
1252                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1253                 return CONNECTION_ERROR_INVALID_PARAMETER;
1254         }
1255
1256         net_profile_info_t *profile_info = profile;
1257
1258         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1259                 return CONNECTION_ERROR_INVALID_PARAMETER;
1260
1261         switch (service_type) {
1262         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
1263                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_INTERNET;
1264                 break;
1265         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
1266                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_MMS;
1267                 break;
1268         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
1269                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_INTERNET;
1270                 break;
1271         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
1272                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_PREPAID_MMS;
1273                 break;
1274         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
1275                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_TETHERING;
1276                 break;
1277         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
1278                 profile_info->ProfileInfo.Pdp.ServiceType = NET_SERVICE_APPLICATION;
1279                 break;
1280         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
1281         default:
1282                 return CONNECTION_ERROR_INVALID_PARAMETER;
1283         }
1284
1285         return CONNECTION_ERROR_NONE;
1286 }
1287
1288 int connection_profile_set_cellular_apn(connection_profile_h profile, const char* apn)
1289 {
1290         if (!(_connection_libnet_check_profile_validity(profile)) || apn == NULL) {
1291                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1292                 return CONNECTION_ERROR_INVALID_PARAMETER;
1293         }
1294
1295         net_profile_info_t *profile_info = profile;
1296
1297         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1298                 return CONNECTION_ERROR_INVALID_PARAMETER;
1299
1300         g_strlcpy(profile_info->ProfileInfo.Pdp.Apn, apn, NET_PDP_APN_LEN_MAX+1);
1301
1302         return CONNECTION_ERROR_NONE;
1303 }
1304
1305 int connection_profile_set_cellular_auth_info(connection_profile_h profile,
1306                 connection_cellular_auth_type_e type, const char* user_name, const char* password)
1307 {
1308         if (!(_connection_libnet_check_profile_validity(profile)) ||
1309             user_name == NULL || password == NULL) {
1310                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1311                 return CONNECTION_ERROR_INVALID_PARAMETER;
1312         }
1313
1314         net_profile_info_t *profile_info = profile;
1315
1316         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1317                 return CONNECTION_ERROR_INVALID_PARAMETER;
1318
1319         switch (type) {
1320         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
1321                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_NONE;
1322                 break;
1323         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
1324                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_PAP;
1325                 break;
1326         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
1327                 profile_info->ProfileInfo.Pdp.AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
1328                 break;
1329         default:
1330                 return CONNECTION_ERROR_INVALID_PARAMETER;
1331         }
1332
1333         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.UserName, user_name, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
1334         g_strlcpy(profile_info->ProfileInfo.Pdp.AuthInfo.Password, password, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
1335
1336         return CONNECTION_ERROR_NONE;
1337 }
1338
1339 int connection_profile_set_cellular_home_url(connection_profile_h profile, const char* home_url)
1340 {
1341         if (!(_connection_libnet_check_profile_validity(profile)) || home_url == NULL) {
1342                 CONNECTION_LOG(CONNECTION_ERROR, "Wrong Parameter Passed\n");
1343                 return CONNECTION_ERROR_INVALID_PARAMETER;
1344         }
1345
1346         net_profile_info_t *profile_info = profile;
1347
1348         if (profile_info->profile_type != NET_DEVICE_CELLULAR)
1349                 return CONNECTION_ERROR_INVALID_PARAMETER;
1350
1351         g_strlcpy(profile_info->ProfileInfo.Pdp.HomeURL, home_url, NET_HOME_URL_LEN_MAX);
1352
1353         return CONNECTION_ERROR_NONE;
1354 }
1355