src/connection_profile.c

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