test/connection_test.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 <errno.h>
  19 #include <stdlib.h>
  20 #include <string.h>
  21 #include <unistd.h>
  22 #include <glib.h>
  23
  24 #include "net_connection.h"
  25 #include "connection_extension.h"
  26
  27 #include <tizen_error.h>
  28
  29 #define LOG_RED "\033[0;31m"
  30 #define LOG_GREEN "\033[0;32m"
  31 #define LOG_BROWN "\033[0;33m"
  32 #define LOG_BLUE "\033[0;34m"
  33 #define LOG_END "\033[0;m"
  34
  35 #define RETURN_FAIL_DESTROY(x) {connection_profile_destroy(x); return -1; }
  36
  37 gboolean test_thread(GIOChannel *source, GIOCondition condition, gpointer data);
  38
  39 connection_h connection = NULL;
  40 static GSList *state_cb_list = NULL;
  41
  42
  43 static bool test_get_user_string(const char *msg, char *buf, int buf_size)
  44 {
  45         if (msg == NULL || buf == NULL || buf_size < 2)
  46                 return false;
  47
  48         int rv;
  49         printf("%s\n", msg);
  50         memset(buf, 0, buf_size);
  51         rv = read(0, buf, buf_size - 1);
  52
  53         if (rv < 0 || buf[0] == '\0' || buf[0] == '\n' || buf[0] == '\r') {
  54                 buf[0] = '\0';
  55                 return false;
  56         }
  57
  58         buf[rv-1] = '\0';
  59         return true;
  60 }
  61
  62 static bool test_get_user_int(const char *msg, int *num)
  63 {
  64         if (msg == NULL || num == NULL)
  65                 return false;
  66
  67         int rv;
  68         char buf[32] = {0,};
  69         printf("%s\n", msg);
  70         rv = read(0, buf, 32);
  71
  72         if (rv < 0 || *buf == 0 || *buf == '\n' || *buf == '\r')
  73                 return false;
  74
  75         *num = atoi(buf);
  76         return true;
  77 }
  78
  79 static const char *test_print_state(connection_profile_state_e state)
  80 {
  81         switch (state) {
  82         case CONNECTION_PROFILE_STATE_DISCONNECTED:
  83                 return "Disconnected";
  84         case CONNECTION_PROFILE_STATE_ASSOCIATION:
  85                 return "Association";
  86         case CONNECTION_PROFILE_STATE_CONFIGURATION:
  87                 return "Configuration";
  88         case CONNECTION_PROFILE_STATE_CONNECTED:
  89                 return "Connected";
  90         default:
  91                 return "Unknown";
  92         }
  93 }
  94
  95 static const char *test_print_connection_type(connection_type_e type)
  96 {
  97         switch (type) {
  98         case CONNECTION_TYPE_DISCONNECTED:
  99                 return "Disconnected";
 100         case CONNECTION_TYPE_WIFI:
 101                 return "Wifi";
 102         case CONNECTION_TYPE_CELLULAR:
 103                 return "Cellular";
 104         case CONNECTION_TYPE_ETHERNET:
 105                 return "Ethernet";
 106         case CONNECTION_TYPE_BT:
 107                 return "BT";
 108         case CONNECTION_TYPE_NET_PROXY:
 109                 return "Net_Proxy";
 110         default:
 111                 return "Unknown";
 112         }
 113 }
 114
 115 static const char *test_print_cellular_state(connection_cellular_state_e state)
 116 {
 117         switch (state) {
 118         case CONNECTION_CELLULAR_STATE_OUT_OF_SERVICE:
 119                 return "Out of service";
 120         case CONNECTION_CELLULAR_STATE_FLIGHT_MODE:
 121                 return "Flight mode";
 122         case CONNECTION_CELLULAR_STATE_ROAMING_OFF:
 123                 return "Roaming off";
 124         case CONNECTION_CELLULAR_STATE_CALL_ONLY_AVAILABLE:
 125                 return "Call only available";
 126         case CONNECTION_CELLULAR_STATE_AVAILABLE:
 127                 return "Available";
 128         case CONNECTION_CELLULAR_STATE_CONNECTED:
 129                 return "Connected";
 130         default:
 131                 return "Unknown";
 132         }
 133 }
 134
 135 static const char *test_print_wifi_state(connection_wifi_state_e state)
 136 {
 137         switch (state) {
 138         case CONNECTION_WIFI_STATE_DEACTIVATED:
 139                 return "Deactivated";
 140         case CONNECTION_WIFI_STATE_DISCONNECTED:
 141                 return "Disconnected";
 142         case CONNECTION_WIFI_STATE_CONNECTED:
 143                 return "Connected";
 144         default:
 145                 return "Unknown";
 146         }
 147 }
 148
 149 static const char *test_print_cellular_service_type(connection_cellular_service_type_e type)
 150 {
 151         switch (type) {
 152         case CONNECTION_CELLULAR_SERVICE_TYPE_UNKNOWN:
 153                 return "Unknown";
 154         case CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET:
 155                 return "Internet";
 156         case CONNECTION_CELLULAR_SERVICE_TYPE_MMS:
 157                 return "MMS";
 158         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET:
 159                 return "Prepaid internet";
 160         case CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS:
 161                 return "Prepaid MMS";
 162         case CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING:
 163                 return "Tethering";
 164         case CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION:
 165                 return "Application";
 166         default:
 167                 return "Unknown";
 168         }
 169 }
 170
 171 static const char* test_print_cellular_auth_type(connection_cellular_auth_type_e type)
 172 {
 173         switch (type) {
 174         case CONNECTION_CELLULAR_AUTH_TYPE_PAP:
 175                 return "PAP";
 176         case CONNECTION_CELLULAR_AUTH_TYPE_CHAP:
 177                 return "CHAP";
 178         case CONNECTION_CELLULAR_AUTH_TYPE_NONE:
 179         default:
 180                 return "None";
 181         }
 182 }
 183
 184 static const char* test_print_cellular_pdn_type(connection_cellular_pdn_type_e type)
 185 {
 186         switch (type) {
 187         case CONNECTION_CELLULAR_PDN_TYPE_IPV4:
 188                 return "IPv4";
 189         case CONNECTION_CELLULAR_PDN_TYPE_IPV6:
 190                 return "IPv6";
 191         case CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6:
 192                 return "Dual";
 193         case CONNECTION_CELLULAR_PDN_TYPE_UNKNOWN:
 194         default:
 195                 return "Unknown";
 196         }
 197 }
 198
 199 static const char *test_print_error(connection_error_e error)
 200 {
 201         switch (error) {
 202         case CONNECTION_ERROR_NONE:
 203                 return "CONNECTION_ERROR_NONE";
 204         case CONNECTION_ERROR_INVALID_PARAMETER:
 205                 return "CONNECTION_ERROR_INVALID_PARAMETER";
 206         case CONNECTION_ERROR_OUT_OF_MEMORY:
 207                 return "CONNECTION_ERROR_OUT_OF_MEMORY";
 208         case CONNECTION_ERROR_INVALID_OPERATION:
 209                 return "CONNECTION_ERROR_INVALID_OPERATION";
 210         case CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED:
 211                 return "CONNECTION_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED";
 212         case CONNECTION_ERROR_OPERATION_FAILED:
 213                 return "CONNECTION_ERROR_OPERATION_FAILED";
 214         case CONNECTION_ERROR_ITERATOR_END:
 215                 return "CONNECTION_ERROR_ITERATOR_END";
 216         case CONNECTION_ERROR_NO_CONNECTION:
 217                 return "CONNECTION_ERROR_NO_CONNECTION";
 218         case CONNECTION_ERROR_NOW_IN_PROGRESS:
 219                 return "CONNECTION_ERROR_NOW_IN_PROGRESS";
 220         case CONNECTION_ERROR_ALREADY_EXISTS:
 221                 return "CONNECTION_ERROR_ALREADY_EXISTS";
 222         case CONNECTION_ERROR_OPERATION_ABORTED:
 223                 return "CONNECTION_ERROR_OPERATION_ABORTED";
 224         case CONNECTION_ERROR_DHCP_FAILED:
 225                 return "CONNECTION_ERROR_DHCP_FAILED";
 226         case CONNECTION_ERROR_INVALID_KEY:
 227                 return "CONNECTION_ERROR_INVALID_KEY";
 228         case CONNECTION_ERROR_NO_REPLY:
 229                 return "CONNECTION_ERROR_NO_REPLY";
 230         case CONNECTION_ERROR_PERMISSION_DENIED:
 231                 return "CONNECTION_ERROR_PERMISSION_DENIED";
 232         case CONNECTION_ERROR_NOT_SUPPORTED:
 233                 return "CONNECTION_ERROR_NOT_SUPPORTED";
 234         default:
 235                 return "CONNECTION_ERROR_UNKNOWN";
 236         }
 237 }
 238
 239 static void test_type_changed_callback(connection_type_e type, void* user_data)
 240 {
 241         printf("Type changed callback, connection type : %d\n", type);
 242 }
 243
 244 static void test_ip_changed_callback(const char* ipv4_address, const char* ipv6_address, void* user_data)
 245 {
 246         printf("IP changed callback, IPv4 address : %s, IPv6 address : %s\n",
 247                         ipv4_address, (ipv6_address ? ipv6_address : "NULL"));
 248 }
 249
 250 static void test_proxy_changed_callback(const char* ipv4_address, const char* ipv6_address, void* user_data)
 251 {
 252         printf("Proxy changed callback, IPv4 address : %s, IPv6 address : %s\n",
 253                         ipv4_address, (ipv6_address ? ipv6_address : "NULL"));
 254 }
 255
 256 static void test_profile_state_callback(connection_profile_state_e state, void* user_data)
 257 {
 258         char *profile_name;
 259         connection_profile_h profile = user_data;
 260
 261         if (profile == NULL)
 262                 return;
 263
 264         if (connection_profile_get_name(profile, &profile_name) != CONNECTION_ERROR_NONE)
 265                 return;
 266
 267         printf("[%s] : %s\n", test_print_state(state), profile_name);
 268         g_free(profile_name);
 269 }
 270
 271 static void test_connection_opened_callback(connection_error_e result, void* user_data)
 272 {
 273         if (result ==  CONNECTION_ERROR_NONE)
 274                 printf("Connection open Succeeded\n");
 275         else
 276                 printf("Connection open Failed, err : [%s]\n", test_print_error(result));
 277 }
 278
 279 static void test_connection_closed_callback(connection_error_e result, void* user_data)
 280 {
 281         if (result ==  CONNECTION_ERROR_NONE)
 282                 printf("Connection close Succeeded\n");
 283         else
 284                 printf("Connection close Failed, err : [%s]\n", test_print_error(result));
 285 }
 286
 287 static void test_connection_reset_profile_callback(connection_error_e result, void* user_data)
 288 {
 289         if (result ==  CONNECTION_ERROR_NONE)
 290                 printf("Reset profile Succeeded\n");
 291         else
 292                 printf("Reset profile Failed, err : [%s]\n", test_print_error(result));
 293 }
 294
 295 static void test_connection_set_default_callback(connection_error_e result, void* user_data)
 296 {
 297         if (result ==  CONNECTION_ERROR_NONE)
 298                 printf("Default profile setting Succeeded\n");
 299         else
 300                 printf("Default profile setting Failed, err : [%s]\n", test_print_error(result));
 301 }
 302
 303 void test_get_ethernet_cable_state_callback(connection_ethernet_cable_state_e state,
 304                                                                 void* user_data)
 305 {
 306         if (state == CONNECTION_ETHERNET_CABLE_ATTACHED)
 307                 printf("Ethernet Cable Connected\n");
 308         else if (state == CONNECTION_ETHERNET_CABLE_DETACHED)
 309                 printf("Ethernet Cable Disconnected\n");
 310 }
 311
 312 static bool test_get_user_selected_profile(connection_profile_h *profile, bool select)
 313 {
 314         int rv = 0;
 315         int input = 0;
 316         char *profile_name;
 317         connection_profile_type_e profile_type;
 318         connection_profile_state_e profile_state;
 319         connection_profile_iterator_h profile_iter;
 320         connection_profile_h profile_h;
 321
 322         connection_profile_h profile_list[100] = {0,};
 323         int profile_count = 0;
 324
 325         rv = connection_get_profile_iterator(connection, CONNECTION_ITERATOR_TYPE_REGISTERED, &profile_iter);
 326         if (rv != CONNECTION_ERROR_NONE) {
 327                 printf("Fail to get profile iterator [%s]\n", test_print_error(rv));
 328                 return false;
 329         }
 330
 331         while (connection_profile_iterator_has_next(profile_iter)) {
 332                 if (connection_profile_iterator_next(profile_iter, &profile_h) != CONNECTION_ERROR_NONE) {
 333                         printf("Fail to get profile handle\n");
 334                         return false;
 335                 }
 336
 337                 if (connection_profile_get_name(profile_h, &profile_name) != CONNECTION_ERROR_NONE) {
 338                         printf("Fail to get profile name\n");
 339                         return false;
 340                 }
 341
 342                 if (connection_profile_get_type(profile_h, &profile_type) != CONNECTION_ERROR_NONE) {
 343                         printf("Fail to get profile type\n");
 344                         g_free(profile_name);
 345                         return false;
 346                 }
 347
 348                 if (connection_profile_get_state(profile_h, &profile_state) != CONNECTION_ERROR_NONE) {
 349                         printf("Fail to get profile state\n");
 350                         g_free(profile_name);
 351                         return false;
 352                 }
 353
 354                 printf("%d. state:[%s], profile name:%s", profile_count,
 355                                 test_print_state(profile_state), profile_name);
 356                 if (profile_type == CONNECTION_PROFILE_TYPE_CELLULAR) {
 357                         connection_cellular_service_type_e service_type;
 358                         if (connection_profile_get_cellular_service_type(
 359                                 profile_h, &service_type) !=
 360                                 CONNECTION_ERROR_NONE)
 361                                 printf("Fail to get cellular service type!\n");
 362
 363                         printf("[%s]",
 364                                 test_print_cellular_service_type(service_type));
 365                 }
 366                 printf("\n");
 367
 368                 profile_list[profile_count] = profile_h;
 369                 profile_count++;
 370
 371                 g_free(profile_name);
 372                 if (profile_count >= 100)
 373                         break;
 374         }
 375
 376         if (select == false)
 377                 return true;
 378
 379         if (test_get_user_int("Input profile number(Enter for cancel) :", &input) == false ||
 380             input >= profile_count ||
 381             input < 0) {
 382                 printf("Wrong number!!\n");
 383                 return false;
 384         }
 385
 386         if (profile)
 387                 *profile = profile_list[input];
 388
 389         return true;
 390 }
 391
 392 static int test_update_cellular_info(connection_profile_h profile)
 393 {
 394         int rv = 0;
 395         char input_str1[100] = {0,};
 396         char input_str2[100] = {0,};
 397         int input_int = 0;
 398         int type_val = 0;
 399
 400         if (test_get_user_int("Input Network Type (internet:1, MMS:2, Prepaid internet:3, "
 401                         "Prepaid MMS:4, Tethering:5, Application:6)"
 402                         " - (Enter for skip) :", &input_int)) {
 403                 switch (input_int) {
 404                 case 1:
 405                         rv = connection_profile_set_cellular_service_type(profile,
 406                                         CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET);
 407                         break;
 408                 case 2:
 409                         rv = connection_profile_set_cellular_service_type(profile,
 410                                         CONNECTION_CELLULAR_SERVICE_TYPE_MMS);
 411                         break;
 412                 case 3:
 413                         rv = connection_profile_set_cellular_service_type(profile,
 414                                         CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET);
 415                         break;
 416                 case 4:
 417                         rv = connection_profile_set_cellular_service_type(profile,
 418                                         CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS);
 419                         break;
 420                 case 5:
 421                         rv = connection_profile_set_cellular_service_type(profile,
 422                                         CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING);
 423                         break;
 424                 case 6:
 425                         rv = connection_profile_set_cellular_service_type(profile,
 426                                         CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION);
 427                         break;
 428                 default:
 429                         return -1;
 430                 }
 431
 432                 if (rv != CONNECTION_ERROR_NONE)
 433                         return -1;
 434         } else
 435                 return -1;
 436
 437         if (test_get_user_string("Input Apn - (Enter for skip) :", input_str1, 100)) {
 438                 g_strstrip(input_str1);
 439                 rv = connection_profile_set_cellular_apn(profile, input_str1);
 440                 if (rv != CONNECTION_ERROR_NONE)
 441                         return -1;
 442         }
 443
 444         if (test_get_user_string("Input Proxy - (Enter for skip) :", input_str1, 100)) {
 445                 g_strstrip(input_str1);
 446                 rv = connection_profile_set_proxy_address(profile, CONNECTION_ADDRESS_FAMILY_IPV4, input_str1);
 447                 if (rv != CONNECTION_ERROR_NONE)
 448                         return -1;
 449         }
 450
 451         if (test_get_user_string("Input HomeURL - (Enter for skip) :", input_str1, 100)) {
 452                 g_strstrip(input_str1);
 453                 rv = connection_profile_set_cellular_home_url(profile, input_str1);
 454                 if (rv != CONNECTION_ERROR_NONE)
 455                         return -1;
 456         }
 457
 458         if (test_get_user_int("Input AuthType(0:NONE 1:PAP 2:CHAP) - (Enter for skip) :", &input_int)) {
 459                 switch (input_int) {
 460                 case 0:
 461                         rv = connection_profile_set_cellular_auth_info(profile,
 462                                         CONNECTION_CELLULAR_AUTH_TYPE_NONE, "", "");
 463                         if (rv != CONNECTION_ERROR_NONE)
 464                                 return -1;
 465
 466                         break;
 467                 case 1:
 468                         type_val = CONNECTION_CELLULAR_AUTH_TYPE_PAP;
 469                         /* fall through */
 470                 case 2:
 471                         if (input_int == 2) type_val = CONNECTION_CELLULAR_AUTH_TYPE_CHAP;
 472
 473                         if (test_get_user_string("Input AuthId(Enter for skip) :", input_str1, 100) == false)
 474                                 input_str1[0] = 0;
 475                         if (test_get_user_string("Input AuthPwd(Enter for skip) :", input_str2, 100) == false)
 476                                 input_str2[0] = 0;
 477
 478                         g_strstrip(input_str1);
 479                         g_strstrip(input_str2);
 480                         rv = connection_profile_set_cellular_auth_info(profile, type_val, input_str1, input_str2);
 481                         if (rv != CONNECTION_ERROR_NONE)
 482                                 return -1;
 483                 }
 484         }
 485
 486         if (test_get_user_int("Input PdnType(1:IPv4 2:IPv6 3:IPv4v6) - (Enter for skip) :", &input_int)) {
 487                 switch (input_int) {
 488                 case 1:
 489                         rv = connection_profile_set_cellular_pdn_type(profile, CONNECTION_CELLULAR_PDN_TYPE_IPV4);
 490                         break;
 491                 case 2:
 492                         rv = connection_profile_set_cellular_pdn_type(profile, CONNECTION_CELLULAR_PDN_TYPE_IPV6);
 493                         break;
 494                 case 3:
 495                         rv = connection_profile_set_cellular_pdn_type(profile, CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6);
 496                         break;
 497                 }
 498
 499                 if (rv != CONNECTION_ERROR_NONE)
 500                         return -1;
 501         }
 502
 503         if (test_get_user_int("Input RoamPdnType(1:IPv4 2:IPv6 3:IPv4v6) - (Enter for skip) :", &input_int)) {
 504                 switch (input_int) {
 505                 case 1:
 506                         rv = connection_profile_set_cellular_roam_pdn_type(profile, CONNECTION_CELLULAR_PDN_TYPE_IPV4);
 507                         break;
 508                 case 2:
 509                         rv = connection_profile_set_cellular_roam_pdn_type(profile, CONNECTION_CELLULAR_PDN_TYPE_IPV6);
 510                         break;
 511                 case 3:
 512                         rv = connection_profile_set_cellular_roam_pdn_type(profile, CONNECTION_CELLULAR_PDN_TYPE_IPV4_IPv6);
 513                         break;
 514                 }
 515
 516                 if (rv != CONNECTION_ERROR_NONE)
 517                         return -1;
 518         }
 519
 520         return 1;
 521 }
 522
 523 static int test_update_wifi_info(connection_profile_h profile)
 524 {
 525         int rv = 0;
 526         char input_str[100] = {0,};
 527
 528         if (test_get_user_string("Input Passphrase - (Enter for skip) :", input_str, 100)) {
 529                 rv = connection_profile_set_wifi_passphrase(profile, input_str);
 530                 if (rv != CONNECTION_ERROR_NONE)
 531                         return -1;
 532         }
 533
 534         return 1;
 535 }
 536
 537 static int test_update_dns_info(connection_profile_h profile,
 538                 connection_address_family_e address_family)
 539 {
 540         int rv = 0;
 541         char input_str[100] = {0,};
 542         if (test_get_user_string("Input DNS 1 Address - (Enter for skip) :", input_str, 100)) {
 543                 rv = connection_profile_set_dns_address(profile,
 544                                 1,
 545                                 address_family,
 546                                 input_str);
 547                 if (rv != CONNECTION_ERROR_NONE)
 548                         return -1;
 549
 550                 if (test_get_user_string("Input DNS 2 Address - (Enter for skip) :", input_str, 100)) {
 551                         rv = connection_profile_set_dns_address(profile,
 552                                         2,
 553                                         address_family,
 554                                         input_str);
 555                         if (rv != CONNECTION_ERROR_NONE)
 556                                 return -1;
 557                 }
 558         }
 559         return 1;
 560 }
 561
 562 static int test_update_ip_info(connection_profile_h profile, connection_address_family_e address_family)
 563 {
 564         int rv = 0;
 565         int input_int = 0;
 566         char input_str[100] = {0,};
 567
 568         if (test_get_user_string("Input IP Address - (Enter for skip) :", input_str, 100)) {
 569                 rv = connection_profile_set_ip_address(profile,
 570                                                         address_family,
 571                                                         input_str);
 572                 if (rv != CONNECTION_ERROR_NONE)
 573                         return -1;
 574         }
 575
 576         if (test_get_user_string("Input Netmask - (Enter for skip) :", input_str, 100)) {
 577                 rv = connection_profile_set_subnet_mask(profile,
 578                                                         address_family,
 579                                                         input_str);
 580                 if (rv != CONNECTION_ERROR_NONE)
 581                         return -1;
 582         }
 583
 584         if (test_get_user_int("Input Prefix Length - (Enter for skip) :", &input_int)) {
 585                 rv = connection_profile_set_prefix_length(profile,
 586                                                         address_family,
 587                                                         input_int);
 588                 if (rv != CONNECTION_ERROR_NONE)
 589                         return -1;
 590         }
 591
 592         if (test_get_user_string("Input Gateway - (Enter for skip) :", input_str, 100)) {
 593                 rv = connection_profile_set_gateway_address(profile,
 594                                                         address_family,
 595                                                         input_str);
 596                 if (rv != CONNECTION_ERROR_NONE)
 597                         return -1;
 598         }
 599
 600         if (test_update_dns_info(profile, address_family) < 0)
 601                 return -1;
 602
 603         return 1;
 604 }
 605
 606 static int test_update_proxy_info(connection_profile_h profile, connection_address_family_e address_family)
 607 {
 608         int rv = 0;
 609         int input_int = 0;
 610         char input_str[100] = {0,};
 611
 612         if (test_get_user_int("Input Proxy Type (1:direct, 2:auto, 3:manual)"
 613                                         " - (Enter for skip) :", &input_int)) {
 614                 switch (input_int) {
 615                 case 1:
 616                         rv = connection_profile_set_proxy_type(profile,
 617                                         CONNECTION_PROXY_TYPE_DIRECT);
 618
 619                         if (rv != CONNECTION_ERROR_NONE)
 620                                 return -1;
 621                         else
 622                                 return 1;
 623                 case 2:
 624                         rv = connection_profile_set_proxy_type(profile,
 625                                         CONNECTION_PROXY_TYPE_AUTO);
 626                         break;
 627                 case 3:
 628                         rv = connection_profile_set_proxy_type(profile,
 629                                         CONNECTION_PROXY_TYPE_MANUAL);
 630                         break;
 631                 default:
 632                         return -1;
 633                 }
 634
 635                 if (rv != CONNECTION_ERROR_NONE)
 636                         return -1;
 637
 638                 if (test_get_user_string("Input auto Proxy URL or Proxy address"
 639                                         " - (Enter for skip) :", input_str, 100)) {
 640                         rv = connection_profile_set_proxy_address(profile,
 641                                                                 address_family,
 642                                                                 input_str);
 643                         if (rv != CONNECTION_ERROR_NONE)
 644                                 return -1;
 645                 }
 646
 647         } else
 648                 return -1;
 649
 650         return 1;
 651 }
 652
 653
 654
 655 static int test_update_network_info(connection_profile_h profile)
 656 {
 657         int rv = 0;
 658         int input_int = 0;
 659         int dns_input = 0;
 660         int address_family = 0;
 661
 662         test_get_user_int("Input Address Family (0:IPv4 1:IPv6) :", &address_family);
 663
 664         if (test_get_user_int("Input IPv4/IPv6 Address Type (DHCP:1, Static:2, Auto:3)"
 665                                 " - (Enter for skip) :", &input_int)) {
 666                 switch (input_int) {
 667                 case 1:
 668                         rv = connection_profile_set_ip_config_type(profile,
 669                                         address_family,
 670                                         CONNECTION_IP_CONFIG_TYPE_DYNAMIC);
 671                         if (test_get_user_int("Input DNS Address Type (Static:1, DHCP:2)"
 672                                                 " - (Enter for skip) :", &dns_input)) {
 673                                 switch (dns_input) {
 674                                 case CONNECTION_DNS_CONFIG_TYPE_STATIC:
 675                                         rv = connection_profile_set_dns_config_type(
 676                                                         profile,
 677                                                         address_family,
 678                                                         CONNECTION_DNS_CONFIG_TYPE_STATIC);
 679                                         if (rv != CONNECTION_ERROR_NONE)
 680                                                 return -1;
 681                                         if (test_update_dns_info(profile,
 682                                                                 address_family) == -1)
 683                                                 return -1;
 684                                         break;
 685                                 case CONNECTION_DNS_CONFIG_TYPE_DYNAMIC:
 686                                         rv = connection_profile_set_dns_config_type(
 687                                                         profile,
 688                                                         address_family,
 689                                                         CONNECTION_DNS_CONFIG_TYPE_DYNAMIC);
 690                                         if (rv != CONNECTION_ERROR_NONE)
 691                                                 return -1;
 692                                         break;
 693                                 }
 694                         }
 695                         break;
 696                 case 2:
 697                         rv = connection_profile_set_ip_config_type(profile,
 698                                                                    address_family,
 699                                                                    CONNECTION_IP_CONFIG_TYPE_STATIC);
 700                         if (rv != CONNECTION_ERROR_NONE)
 701                                 return -1;
 702
 703                         if (test_update_ip_info(profile, address_family) == -1)
 704                                 return -1;
 705
 706                         if (test_update_proxy_info(profile, address_family) == -1)
 707                                 return -1;
 708                         break;
 709                 case 3:
 710                         rv = connection_profile_set_ip_config_type(profile,
 711                                                                 address_family,
 712                                                                 CONNECTION_IP_CONFIG_TYPE_AUTO);
 713                         break;
 714                 default:
 715                         return -1;
 716                 }
 717
 718                 if (rv != CONNECTION_ERROR_NONE)
 719                         return -1;
 720         } else
 721                 return -1;
 722
 723         return 1;
 724 }
 725
 726 static void test_print_cellular_info(connection_profile_h profile)
 727 {
 728         connection_cellular_service_type_e service_type;
 729         connection_cellular_pdn_type_e pdn_type;
 730         connection_cellular_pdn_type_e roam_pdn_type;
 731         char *apn = NULL;
 732         connection_cellular_auth_type_e auth_type;
 733         char *user_name = NULL;
 734         char *password = NULL;
 735         char *home_url = NULL;
 736         bool roaming = false;
 737         bool hidden = false;
 738         bool editable = false;
 739
 740         if (connection_profile_get_cellular_service_type(profile, &service_type) != CONNECTION_ERROR_NONE)
 741                 printf("Fail to get cellular service type!\n");
 742         else
 743                 printf("Cellular service type : %s\n", test_print_cellular_service_type(service_type));
 744
 745         if (connection_profile_get_cellular_pdn_type(profile, &pdn_type) != CONNECTION_ERROR_NONE)
 746                 printf("Fail to get cellular pdn type!\n");
 747         else
 748                 printf("Cellular pdn type : %s\n", test_print_cellular_pdn_type(pdn_type));
 749
 750         if (connection_profile_get_cellular_roam_pdn_type(profile, &roam_pdn_type) != CONNECTION_ERROR_NONE)
 751                 printf("Fail to get cellular roam pdn type!\n");
 752         else
 753                 printf("Cellular roam pdn type : %s\n", test_print_cellular_pdn_type(roam_pdn_type));
 754
 755         if (connection_profile_get_cellular_apn(profile, &apn) != CONNECTION_ERROR_NONE)
 756                 printf("Fail to get cellular APN!\n");
 757         else {
 758                 printf("Cellular APN : %s\n", apn);
 759                 g_free(apn);
 760         }
 761
 762         if (connection_profile_get_cellular_auth_info(profile, &auth_type, &user_name, &password) != CONNECTION_ERROR_NONE)
 763                 printf("Fail to get auth info!\n");
 764         else {
 765                 printf("Cellular auth type : %s\n", test_print_cellular_auth_type(auth_type));
 766                 printf("Cellular user_name : %s\n", user_name);
 767                 printf("Cellular password : %s\n", password);
 768                 g_free(user_name);
 769                 g_free(password);
 770         }
 771
 772         if (connection_profile_get_cellular_home_url(profile, &home_url) != CONNECTION_ERROR_NONE)
 773                 printf("Fail to get cellular home url!\n");
 774         else {
 775                 printf("Cellular home url : %s\n", home_url);
 776                 g_free(home_url);
 777         }
 778
 779         if (connection_profile_is_cellular_roaming(profile, &roaming) != CONNECTION_ERROR_NONE)
 780                 printf("Fail to get cellular roaming state!\n");
 781         else
 782                 printf("Cellular roaming : %s\n", roaming ? "true" : "false");
 783
 784         if (connection_profile_is_cellular_hidden(profile, &hidden) != CONNECTION_ERROR_NONE)
 785                 printf("Fail to get cellular hidden state!\n");
 786         else
 787                 printf("Cellular hidden : %s\n", hidden ? "true" : "false");
 788
 789         if (connection_profile_is_cellular_editable(profile, &editable) != CONNECTION_ERROR_NONE)
 790                 printf("Fail to get cellular editing state!\n");
 791         else
 792                 printf("Cellular editable : %s\n", editable ? "true" : "false");
 793 }
 794
 795 static void test_print_wifi_info(connection_profile_h profile)
 796 {
 797         char *essid = NULL;
 798         char *bssid = NULL;
 799         int rssi = 0;
 800         int frequency = 0;
 801         int max_speed = 0;
 802         connection_wifi_security_type_e security_type;
 803         connection_wifi_encryption_type_e encryption_type;
 804         bool pass_required = false;
 805         bool wps_supported = false;
 806
 807         if (connection_profile_get_wifi_essid(profile, &essid) != CONNECTION_ERROR_NONE)
 808                 printf("Fail to get Wi-Fi essid!\n");
 809         else {
 810                 printf("Wi-Fi essid : %s\n", essid);
 811                 g_free(essid);
 812         }
 813
 814         if (connection_profile_get_wifi_bssid(profile, &bssid) != CONNECTION_ERROR_NONE)
 815                 printf("Fail to get Wi-Fi bssid!\n");
 816         else {
 817                 printf("Wi-Fi bssid : %s\n", bssid);
 818                 g_free(bssid);
 819         }
 820
 821         if (connection_profile_get_wifi_rssi(profile, &rssi) != CONNECTION_ERROR_NONE)
 822                 printf("Fail to get Wi-Fi rssi!\n");
 823         else
 824                 printf("Wi-Fi rssi : %d\n", rssi);
 825
 826         if (connection_profile_get_wifi_frequency(profile, &frequency) != CONNECTION_ERROR_NONE)
 827                 printf("Fail to get Wi-Fi frequency!\n");
 828         else
 829                 printf("Wi-Fi frequency : %d\n", frequency);
 830
 831         if (connection_profile_get_wifi_max_speed(profile, &max_speed) != CONNECTION_ERROR_NONE)
 832                 printf("Fail to get Wi-Fi max speed!\n");
 833         else
 834                 printf("Wi-Fi max speed : %d\n", max_speed);
 835
 836         if (connection_profile_get_wifi_security_type(profile, &security_type) != CONNECTION_ERROR_NONE)
 837                 printf("Fail to get Wi-Fi security type!\n");
 838         else
 839                 printf("Wi-Fi security type : %d\n", security_type);
 840
 841         if (connection_profile_get_wifi_encryption_type(profile, &encryption_type) != CONNECTION_ERROR_NONE)
 842                 printf("Fail to get Wi-Fi encryption type!\n");
 843         else
 844                 printf("Wi-Fi encryption type : %d\n", encryption_type);
 845
 846         if (connection_profile_is_wifi_passphrase_required(profile, &pass_required) != CONNECTION_ERROR_NONE)
 847                 printf("Fail to get Wi-Fi passphrase required!\n");
 848         else
 849                 printf("Wi-Fi passphrase required : %s\n", pass_required ? "true" : "false");
 850
 851         if (connection_profile_is_wifi_wps_supported(profile, &wps_supported) != CONNECTION_ERROR_NONE)
 852                 printf("Fail to get Wi-Fi wps info\n");
 853         else
 854                 printf("Wi-Fi wps supported : %s\n", wps_supported ? "true" : "false");
 855 }
 856
 857 static void test_print_network_info(connection_profile_h profile, connection_address_family_e address_family)
 858 {
 859         char *interface_name = NULL;
 860         char *ip = NULL;
 861         char *subnet = NULL;
 862         char *gateway = NULL;
 863         char *dhcp_server = NULL;
 864         int dhcp_lease_duration = 0;
 865         char *dns1 = NULL;
 866         char *dns2 = NULL;
 867         char *proxy = NULL;
 868         int prefix_len;
 869         connection_ip_config_type_e ip_type;
 870         connection_proxy_type_e proxy_type;
 871         connection_dns_config_type_e dns_type;
 872
 873         if (connection_profile_get_network_interface_name(profile, &interface_name) != CONNECTION_ERROR_NONE)
 874                 printf("Fail to get interface name!\n");
 875         else {
 876                 printf("Interface name : %s\n", interface_name);
 877                 g_free(interface_name);
 878         }
 879
 880         if (connection_profile_get_ip_config_type(profile, address_family, &ip_type) != CONNECTION_ERROR_NONE)
 881                 printf("Fail to get ipconfig type!\n");
 882         else {
 883                 if (ip_type == CONNECTION_IP_CONFIG_TYPE_STATIC)
 884                         printf("ip type : %s\n", "CONNECTION_IP_CONFIG_TYPE_STATIC");
 885                 else if (ip_type == CONNECTION_IP_CONFIG_TYPE_DYNAMIC)
 886                         printf("ip type : %s\n", "CONNECTION_IP_CONFIG_TYPE_DYNAMIC");
 887                 else if (ip_type == CONNECTION_IP_CONFIG_TYPE_AUTO)
 888                         printf("ip type : %s\n", "CONNECTION_IP_CONFIG_TYPE_AUTO");
 889                 else if (ip_type == CONNECTION_IP_CONFIG_TYPE_FIXED)
 890                         printf("ip type : %s\n", "CONNECTION_IP_CONFIG_TYPE_FIXED");
 891                 else
 892                         printf("ip type : %s\n", "CONNECTION_IP_CONFIG_TYPE_NONE");
 893         }
 894
 895         if (connection_profile_get_ip_address(profile, address_family, &ip) != CONNECTION_ERROR_NONE)
 896                 printf("Fail to get IP address!\n");
 897         else {
 898                 printf("IP address : %s\n", ip);
 899                 g_free(ip);
 900         }
 901
 902         if (connection_profile_get_gateway_address(profile, address_family, &gateway) != CONNECTION_ERROR_NONE)
 903                 printf("Fail to get gateway!\n");
 904         else {
 905                 printf("Gateway : %s\n", gateway);
 906                 g_free(gateway);
 907         }
 908
 909         if (connection_profile_get_dhcp_server_address(profile, address_family, &dhcp_server) != CONNECTION_ERROR_NONE)
 910                 printf("Fail to get DHCP Server address!\n");
 911         else {
 912                 printf("DHCP Server : %s\n", dhcp_server);
 913                 g_free(dhcp_server);
 914         }
 915
 916         if (connection_profile_get_dhcp_lease_duration(profile, address_family, &dhcp_lease_duration) != CONNECTION_ERROR_NONE)
 917                 printf("Fail to get DHCP lease duration!\n");
 918         else {
 919                 printf("DHCP lease duration : %d\n", dhcp_lease_duration);
 920         }
 921
 922         if (connection_profile_get_subnet_mask(profile, address_family, &subnet) != CONNECTION_ERROR_NONE)
 923                 printf("Fail to get subnet mask!\n");
 924         else {
 925                 printf("Subnet mask : %s\n", subnet);
 926                 g_free(subnet);
 927         }
 928
 929         if (connection_profile_get_prefix_length(profile, address_family, &prefix_len) != CONNECTION_ERROR_NONE)
 930                 printf("Fail to get prefix length!\n");
 931         else
 932                 printf("Prefix length : %d\n", prefix_len);
 933
 934         if (connection_profile_get_dns_config_type(profile, address_family, &dns_type) != CONNECTION_ERROR_NONE)
 935                 printf("Fail to get DNS configuration type!\n");
 936         else {
 937                 if (dns_type == CONNECTION_DNS_CONFIG_TYPE_STATIC)
 938                         printf("DNS config type : %s\n", "CONNECTION_DNS_CONFIG_TYPE_STATIC");
 939                 else if (dns_type == CONNECTION_DNS_CONFIG_TYPE_DYNAMIC)
 940                         printf("DNS config type : %s\n", "CONNECTION_DNS_CONFIG_TYPE_DYNAMIC");
 941                 else
 942                         printf("DNS config type : %s\n", "CONNECTION_DNS_CONFIG_TYPE_NONE");
 943         }
 944
 945         if (connection_profile_get_dns_address(profile, 1, address_family, &dns1) != CONNECTION_ERROR_NONE)
 946                 printf("Fail to get DNS1!\n");
 947         else {
 948                 printf("DNS1 : %s\n", dns1);
 949                 g_free(dns1);
 950         }
 951
 952         if (connection_profile_get_dns_address(profile, 2, address_family, &dns2) != CONNECTION_ERROR_NONE)
 953                 printf("Fail to get DNS2!\n");
 954         else {
 955                 printf("DNS2 : %s\n", dns2);
 956                 g_free(dns2);
 957         }
 958
 959         if (connection_profile_get_proxy_type(profile, &proxy_type) != CONNECTION_ERROR_NONE)
 960                 printf("Fail to get proxy type!\n");
 961         else {
 962                 if (proxy_type == CONNECTION_PROXY_TYPE_DIRECT)
 963                         printf("proxy type : %s\n", "CONNECTION_PROXY_TYPE_DIRECT");
 964                 else if (proxy_type == CONNECTION_PROXY_TYPE_AUTO)
 965                         printf("proxy type : %s\n", "CONNECTION_PROXY_TYPE_AUTO");
 966                 else
 967                         printf("proxy type : %s\n", "CONNECTION_PROXY_TYPE_MANUAL");
 968         }
 969
 970         if (connection_profile_get_proxy_address(profile, address_family, &proxy) != CONNECTION_ERROR_NONE)
 971                 printf("Fail to get proxy!\n");
 972         else {
 973                 printf("Proxy : %s\n", proxy);
 974                 g_free(proxy);
 975         }
 976 }
 977
 978 int test_register_client(void)
 979 {
 980
 981         int err = connection_create(&connection);
 982
 983         if (CONNECTION_ERROR_NONE == err) {
 984                 connection_set_type_changed_cb(connection, test_type_changed_callback, NULL);
 985                 connection_set_ip_address_changed_cb(connection, test_ip_changed_callback, NULL);
 986                 connection_set_proxy_address_changed_cb(connection, test_proxy_changed_callback, NULL);
 987                 connection_set_ethernet_cable_state_chaged_cb(connection,
 988                                         test_get_ethernet_cable_state_callback, NULL);
 989         } else {
 990                 printf("Client registration failed [%s]\n", test_print_error(err));
 991                 return -1;
 992         }
 993
 994         printf("Client registration success\n");
 995         return 1;
 996 }
 997
 998 int  test_deregister_client(void)
 999 {
1000         int rv = 0;
1001         GSList *list;
1002         connection_profile_h profile;
1003
1004         if (connection != NULL)
1005                 rv = connection_destroy(connection);
1006         else {
1007                 printf("Cannot deregister : Handle is NULL\n");
1008                 rv = CONNECTION_ERROR_INVALID_OPERATION;
1009         }
1010
1011         if (rv != CONNECTION_ERROR_NONE) {
1012                 printf("Client deregistration fail [%s]\n", test_print_error(rv));
1013                 return -1;
1014         }
1015
1016         if (state_cb_list) {
1017                 for (list = state_cb_list; list; list = list->next) {
1018                         profile = list->data;
1019                         connection_profile_destroy(profile);
1020                 }
1021
1022                 g_slist_free(state_cb_list);
1023                 state_cb_list = NULL;
1024         }
1025
1026         connection = NULL;
1027         printf("Client deregistration success\n");
1028
1029         return 1;
1030 }
1031
1032 int test_get_network_state(void)
1033 {
1034         int rv = 0;
1035         connection_type_e net_state;
1036
1037         rv = connection_get_type(connection, &net_state);
1038
1039         if (rv != CONNECTION_ERROR_NONE) {
1040                 printf("Fail to get network state [%s]\n", test_print_error(rv));
1041                 return -1;
1042         }
1043
1044         printf("Retval = [%s] network connection state [%s]\n",
1045                 test_print_error(rv), test_print_connection_type(net_state));
1046
1047         return 1;
1048 }
1049
1050 int test_get_cellular_state(void)
1051 {
1052         int rv = 0;
1053         connection_cellular_state_e cellular_state;
1054
1055         rv = connection_get_cellular_state(connection, &cellular_state);
1056
1057         if (rv != CONNECTION_ERROR_NONE) {
1058                 printf("Fail to get Cellular state [%s]\n", test_print_error(rv));
1059                 return -1;
1060         }
1061
1062         printf("Retval = [%s] Cellular state [%s]\n",
1063                 test_print_error(rv), test_print_cellular_state(cellular_state));
1064
1065         return 1;
1066 }
1067
1068 int test_get_wifi_state(void)
1069 {
1070         int rv = 0;
1071         connection_wifi_state_e wifi_state;
1072
1073         rv = connection_get_wifi_state(connection, &wifi_state);
1074
1075         if (rv != CONNECTION_ERROR_NONE) {
1076                 printf("Fail to get WiFi state [%s]\n", test_print_error(rv));
1077                 return -1;
1078         }
1079
1080         printf("Retval = [%s] WiFi state [%s]\n",
1081                 test_print_error(rv), test_print_wifi_state(wifi_state));
1082
1083         return 1;
1084 }
1085
1086 int test_get_current_proxy(void)
1087 {
1088         char *proxy_addr = NULL;
1089
1090         connection_get_proxy(connection, CONNECTION_ADDRESS_FAMILY_IPV4, &proxy_addr);
1091
1092         if (proxy_addr == NULL) {
1093                 printf("Proxy address does not exist\n");
1094                 return -1;
1095         }
1096
1097         printf("Current Proxy [%s]\n", proxy_addr);
1098         g_free(proxy_addr);
1099
1100         return 1;
1101 }
1102
1103 int test_get_current_ip(void)
1104 {
1105         char *ip_addr = NULL;
1106         int input;
1107         bool rv;
1108
1109         rv = test_get_user_int("Input Address type to get"
1110                 "(1:IPV4, 2:IPV6):", &input);
1111
1112         if (rv == false) {
1113                 printf("Invalid input!!\n");
1114                 return -1;
1115         }
1116
1117         switch (input) {
1118         case 1:
1119                 connection_get_ip_address(connection, CONNECTION_ADDRESS_FAMILY_IPV4, &ip_addr);
1120                 if (ip_addr == NULL) {
1121                         printf("IPv4 address does not exist\n");
1122                         return -1;
1123                 }
1124                 printf("IPv4 address : %s\n", ip_addr);
1125                 break;
1126
1127         case 2:
1128                 connection_get_ip_address(connection, CONNECTION_ADDRESS_FAMILY_IPV6, &ip_addr);
1129                 if (ip_addr == NULL) {
1130                         printf("IPv6 address does not exist\n");
1131                         return -1;
1132                 }
1133                 printf("IPv6 address : %s\n", ip_addr);
1134                 break;
1135         default:
1136                 printf("Wrong IP address family!!\n");
1137                 return -1;
1138         }
1139
1140         g_free(ip_addr);
1141         return 1;
1142 }
1143
1144 int test_get_call_statistics_info(void)
1145 {
1146         long long rv = 0;
1147
1148         connection_get_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA, &rv);
1149         printf("last recv data size [%lld]\n", rv);
1150         connection_get_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA, &rv);
1151         printf("last sent data size [%lld]\n", rv);
1152         connection_get_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA, &rv);
1153         printf("total received data size [%lld]\n", rv);
1154         connection_get_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA, &rv);
1155         printf("total sent data size [%lld]\n", rv);
1156
1157         return 1;
1158 }
1159
1160 int test_get_wifi_call_statistics_info(void)
1161 {
1162         long long rv = 0;
1163
1164         connection_get_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA, &rv);
1165         printf("WiFi last recv data size [%lld]\n", rv);
1166         connection_get_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA, &rv);
1167         printf("WiFi last sent data size [%lld]\n", rv);
1168         connection_get_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA, &rv);
1169         printf("WiFi total received data size [%lld]\n", rv);
1170         connection_get_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA, &rv);
1171         printf("WiFi total sent data size [%lld]\n", rv);
1172
1173         return 1;
1174 }
1175
1176 int test_get_profile_list(void)
1177 {
1178         if (test_get_user_selected_profile(NULL, false) == false)
1179                 return -1;
1180
1181         return 1;
1182 }
1183
1184 int test_get_default_profile_list(void)
1185 {
1186         int rv = 0;
1187         char *profile_name = NULL;
1188         connection_profile_iterator_h profile_iter;
1189         connection_profile_h profile_h;
1190         connection_cellular_service_type_e service_type;
1191         bool is_default = false;
1192
1193         rv = connection_get_profile_iterator(connection, CONNECTION_ITERATOR_TYPE_DEFAULT, &profile_iter);
1194         if (rv != CONNECTION_ERROR_NONE) {
1195                 printf("Fail to get profile iterator [%s]\n", test_print_error(rv));
1196                 return -1;
1197         }
1198
1199         while (connection_profile_iterator_has_next(profile_iter)) {
1200                 if (connection_profile_iterator_next(profile_iter, &profile_h) != CONNECTION_ERROR_NONE) {
1201                         printf("Fail to get profile handle\n");
1202                         return -1;
1203                 }
1204
1205                 if (connection_profile_get_name(profile_h, &profile_name) != CONNECTION_ERROR_NONE) {
1206                         printf("Fail to get profile name\n");
1207                         return -1;
1208                 }
1209                 printf("profile name : %s\n", profile_name);
1210                 g_free(profile_name);
1211
1212                 if (connection_profile_get_cellular_service_type(profile_h, &service_type) != CONNECTION_ERROR_NONE) {
1213                         printf("Fail to get profile service type\n");
1214                         return -1;
1215                 }
1216                 printf("service type : %d\n", service_type);
1217
1218                 if (connection_profile_is_cellular_default(profile_h, &is_default) != CONNECTION_ERROR_NONE) {
1219                         printf("Fail to get profile subscriber id\n");
1220                         return -1;
1221                 }
1222                 printf("Default : %d\n", is_default);
1223         }
1224
1225         return 1;
1226 }
1227
1228 int test_get_connected_profile_list(void)
1229 {
1230         int rv = 0;
1231         char *profile_name = NULL;
1232         connection_profile_iterator_h profile_iter;
1233         connection_profile_h profile_h;
1234         bool is_default = false;
1235         connection_profile_type_e type;
1236
1237         rv = connection_get_profile_iterator(connection, CONNECTION_ITERATOR_TYPE_CONNECTED, &profile_iter);
1238         if (rv != CONNECTION_ERROR_NONE) {
1239                 printf("Fail to get profile iterator [%s]\n", test_print_error(rv));
1240                 return -1;
1241         }
1242
1243         while (connection_profile_iterator_has_next(profile_iter)) {
1244                 if (connection_profile_iterator_next(profile_iter, &profile_h) != CONNECTION_ERROR_NONE) {
1245                         printf("Fail to get profile handle\n");
1246                         return -1;
1247                 }
1248
1249                 if (connection_profile_get_name(profile_h, &profile_name) != CONNECTION_ERROR_NONE) {
1250                         printf("Fail to get profile name\n");
1251                         return -1;
1252                 }
1253                 printf("profile name is %s\n", profile_name);
1254                 g_free(profile_name);
1255
1256                 if (connection_profile_get_type(profile_h, &type) != CONNECTION_ERROR_NONE) {
1257                         printf("Fail to get profile type\n");
1258                         return -1;
1259                 }
1260                 printf("profile type is %d\n", type);
1261
1262                 if (type == CONNECTION_PROFILE_TYPE_CELLULAR) {
1263                 if (connection_profile_is_cellular_default(profile_h, &is_default) != CONNECTION_ERROR_NONE) {
1264                         printf("Fail to get profile is default\n");
1265                         return -1;
1266                 }
1267                         printf("[%s]\n", is_default ? "default" : "not default");
1268                 }
1269         }
1270
1271         return 1;
1272 }
1273
1274 int test_get_current_profile(void)
1275 {
1276         int rv = 0;
1277         char *profile_name = NULL;
1278         connection_profile_h profile_h;
1279
1280         rv = connection_get_current_profile(connection, &profile_h);
1281         if (rv != CONNECTION_ERROR_NONE) {
1282                 printf("Fail to get profile iterator [%s]\n", test_print_error(rv));
1283                 return -1;
1284         }
1285
1286         if (connection_profile_get_name(profile_h, &profile_name) != CONNECTION_ERROR_NONE) {
1287                 printf("Fail to get profile name\n");
1288                 return -1;
1289         }
1290         printf("profile name : %s\n", profile_name);
1291         g_free(profile_name);
1292
1293         connection_profile_destroy(profile_h);
1294
1295         return 1;
1296 }
1297
1298 int test_open_profile(void)
1299 {
1300         connection_profile_h profile;
1301
1302         printf("\n** Choose a profile to open. **\n");
1303
1304         if (test_get_user_selected_profile(&profile, true) == false)
1305                 return -1;
1306
1307         if (connection_open_profile(connection, profile, test_connection_opened_callback, NULL) != CONNECTION_ERROR_NONE) {
1308                 printf("Connection open Failed!!\n");
1309                 return -1;
1310         }
1311
1312         return 1;
1313 }
1314
1315 int test_get_default_cellular_service_type(void)
1316 {
1317         int input;
1318         int rv;
1319         int service_type;
1320         connection_profile_h profile;
1321         char *profile_name = NULL;
1322
1323         rv = test_get_user_int("Input profile type to get"
1324                         "(1:Internet, 2:MMS, 3:Prepaid internet, 4:Prepaid MMS, 5:Tethering, 6:Application):", &input);
1325
1326         if (rv == false) {
1327                 printf("Invalid input!!\n");
1328                 return -1;
1329         }
1330
1331         switch (input) {
1332         case 1:
1333                 service_type = CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
1334                 break;
1335         case 2:
1336                 service_type = CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
1337                 break;
1338         case 3:
1339                 service_type = CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
1340                 break;
1341         case 4:
1342                 service_type = CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
1343                 break;
1344         case 5:
1345                 service_type = CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
1346                 break;
1347         case 6:
1348                 service_type =  CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
1349                 break;
1350         default:
1351                 printf("Wrong number!!\n");
1352                 return -1;
1353         }
1354
1355         if (connection_get_default_cellular_service_profile(connection, service_type, &profile) != CONNECTION_ERROR_NONE)
1356                 return -1;
1357
1358         if (connection_profile_get_name(profile, &profile_name) != CONNECTION_ERROR_NONE) {
1359                 printf("Fail to get profile name\n");
1360                 connection_profile_destroy(profile);
1361                 return -1;
1362         }
1363         printf("Default profile name : %s\n", profile_name);
1364         g_free(profile_name);
1365
1366         connection_profile_destroy(profile);
1367
1368         return 1;
1369 }
1370
1371 int test_set_default_cellular_service_type(void)
1372 {
1373         connection_profile_h profile;
1374         connection_cellular_service_type_e type;
1375         int input, rv;
1376
1377         rv = test_get_user_int("Input API type (1:sync, 2:async)", &input);
1378
1379         if (rv == false || (input != 1 && input != 2)) {
1380                 printf("Invalid input!!\n");
1381                 return -1;
1382         }
1383
1384         printf("\n** Choose a profile to set default service(internet or prepaid internet type only). **\n");
1385
1386         if (test_get_user_selected_profile(&profile, true) == false)
1387                 return -1;
1388
1389         if (connection_profile_get_cellular_service_type(profile, &type) != CONNECTION_ERROR_NONE) {
1390                 printf("Fail to get cellular service type\n");
1391                 return -1;
1392         }
1393
1394         if (input == 1) {
1395                 if (connection_set_default_cellular_service_profile(connection, type, profile) != CONNECTION_ERROR_NONE)
1396                         return -1;
1397         } else {
1398                 if (connection_set_default_cellular_service_profile_async(connection,
1399                                 type, profile, test_connection_set_default_callback, NULL) != CONNECTION_ERROR_NONE)
1400                         return -1;
1401         }
1402
1403         return 1;
1404 }
1405
1406 int test_close_profile(void)
1407 {
1408         connection_profile_h profile;
1409
1410         printf("\n** Choose a profile to close. **\n");
1411
1412         if (test_get_user_selected_profile(&profile, true) == false)
1413                 return -1;
1414
1415         if (connection_close_profile(connection, profile, test_connection_closed_callback, NULL) != CONNECTION_ERROR_NONE) {
1416                 printf("Connection close Failed!!\n");
1417                 return -1;
1418         }
1419
1420         return 1;
1421 }
1422
1423 int test_add_profile(void)
1424 {
1425         int rv = 0;
1426         connection_profile_h profile;
1427         char input_str[100] = {0,};
1428
1429         if (test_get_user_string("Input Keyword - (Enter for skip) :", input_str, 100) == false)
1430                 return -1;
1431
1432         g_strstrip(input_str);
1433         rv = connection_profile_create(CONNECTION_PROFILE_TYPE_CELLULAR, input_str, &profile);
1434         if (rv != CONNECTION_ERROR_NONE)
1435                 RETURN_FAIL_DESTROY(profile);
1436
1437         if (test_update_cellular_info(profile) == -1)
1438                 RETURN_FAIL_DESTROY(profile);
1439
1440         rv = connection_add_profile(connection, profile);
1441         if (rv != CONNECTION_ERROR_NONE)
1442                 RETURN_FAIL_DESTROY(profile);
1443
1444         connection_profile_destroy(profile);
1445         return 1;
1446 }
1447
1448 int test_remove_profile(void)
1449 {
1450         connection_profile_h profile;
1451
1452         printf("\n** Choose a profile to remove. **\n");
1453         if (test_get_user_selected_profile(&profile, true) == false)
1454                 return -1;
1455
1456         if (connection_remove_profile(connection, profile) != CONNECTION_ERROR_NONE) {
1457                 printf("Remove profile Failed!!\n");
1458                 return -1;
1459         }
1460
1461         return 1;
1462 }
1463
1464 int test_update_profile(void)
1465 {
1466         int rv = 0;
1467
1468         connection_profile_type_e prof_type;
1469         connection_profile_h profile;
1470
1471         printf("\n** Choose a profile to update. **\n");
1472         if (test_get_user_selected_profile(&profile, true) == false)
1473                 return -1;
1474
1475         if (connection_profile_get_type(profile, &prof_type) != CONNECTION_ERROR_NONE)
1476                 return -1;
1477
1478         switch (prof_type) {
1479         case CONNECTION_PROFILE_TYPE_CELLULAR:
1480                 if (test_update_cellular_info(profile) == -1)
1481                         return -1;
1482
1483                 break;
1484         case CONNECTION_PROFILE_TYPE_WIFI:
1485                 if (test_update_wifi_info(profile) == -1)
1486                         return -1;
1487
1488                 if (test_update_network_info(profile) == -1)
1489                         return -1;
1490
1491                 break;
1492         case CONNECTION_PROFILE_TYPE_ETHERNET:
1493                 if (test_update_network_info(profile) == -1)
1494                         return -1;
1495                 break;
1496
1497         case CONNECTION_PROFILE_TYPE_BT:
1498                 printf("Not supported!\n");
1499                 /* fall through */
1500         default:
1501                 return -1;
1502         }
1503
1504         rv = connection_update_profile(connection, profile);
1505         if (rv != CONNECTION_ERROR_NONE)
1506                 return -1;
1507
1508         return 1;
1509 }
1510
1511 int test_get_profile_info(void)
1512 {
1513         connection_profile_type_e prof_type;
1514         connection_profile_state_e profile_state;
1515         connection_profile_state_e profile_ipv6_state;
1516         connection_profile_h profile;
1517         char *profile_name = NULL;
1518         int address_family = 0;
1519
1520         printf("\n** Choose a profile to print. **\n");
1521         if (test_get_user_selected_profile(&profile, true) == false)
1522                 return -1;
1523
1524         if (connection_profile_get_name(profile, &profile_name) != CONNECTION_ERROR_NONE) {
1525                 printf("Fail to get profile name\n");
1526                 return -1;
1527         } else {
1528                 printf("Profile Name : %s\n", profile_name);
1529                 g_free(profile_name);
1530         }
1531
1532         if (connection_profile_get_state(profile, &profile_state) != CONNECTION_ERROR_NONE) {
1533                 printf("Fail to get profile IPv4 state\n");
1534                 return -1;
1535         } else
1536                 printf("Profile State : %s\n", test_print_state(profile_state));
1537
1538         if (connection_profile_get_ipv6_state(profile, &profile_ipv6_state) != CONNECTION_ERROR_NONE) {
1539                 printf("Fail to get profile IPv6 state\n");
1540                 return -1;
1541         } else
1542                 printf("Profile IPv6 State : %s\n", test_print_state(profile_ipv6_state));
1543
1544
1545         if (connection_profile_get_type(profile, &prof_type) != CONNECTION_ERROR_NONE)
1546                 return -1;
1547
1548         test_get_user_int("Input Address Family (0:IPv4 1:IPv6) :", &address_family);
1549
1550         switch (prof_type) {
1551         case CONNECTION_PROFILE_TYPE_CELLULAR:
1552                 printf("Profile Type : Cellular\n");
1553                 test_print_cellular_info(profile);
1554                 break;
1555         case CONNECTION_PROFILE_TYPE_WIFI:
1556                 printf("Profile Type : Wi-Fi\n");
1557                 test_print_wifi_info(profile);
1558                 break;
1559         case CONNECTION_PROFILE_TYPE_ETHERNET:
1560                 printf("Profile Type : Ethernet\n");
1561                 break;
1562         case CONNECTION_PROFILE_TYPE_BT:
1563                 printf("Profile Type : Bluetooth\n");
1564                 break;
1565         default:
1566                 return -1;
1567         }
1568
1569         test_print_network_info(profile, address_family);
1570
1571         return 1;
1572 }
1573
1574 int test_refresh_profile_info(void)
1575 {
1576         connection_profile_type_e prof_type;
1577         connection_profile_state_e profile_state;
1578         connection_profile_h profile;
1579         char *profile_name = NULL;
1580         int address_family = 0;
1581
1582         printf("\n** Choose a profile to refresh. **\n");
1583         if (test_get_user_selected_profile(&profile, true) == false)
1584                 return -1;
1585
1586         if (connection_profile_refresh(profile) != CONNECTION_ERROR_NONE)
1587                 return -1;
1588
1589         if (connection_profile_get_name(profile, &profile_name) != CONNECTION_ERROR_NONE) {
1590                 printf("Fail to get profile name\n");
1591                 return -1;
1592         } else {
1593                 printf("Profile Name : %s\n", profile_name);
1594                 g_free(profile_name);
1595         }
1596
1597         if (connection_profile_get_state(profile, &profile_state) != CONNECTION_ERROR_NONE) {
1598                 printf("Fail to get profile state\n");
1599                 return -1;
1600         } else
1601                 printf("Profile State : %s\n", test_print_state(profile_state));
1602
1603
1604         if (connection_profile_get_type(profile, &prof_type) != CONNECTION_ERROR_NONE)
1605                 return -1;
1606
1607         test_get_user_int("Input Address Family (0:IPv4 1:IPv6) :", &address_family);
1608
1609         switch (prof_type) {
1610         case CONNECTION_PROFILE_TYPE_CELLULAR:
1611                 printf("Profile Type : Cellular\n");
1612                 test_print_cellular_info(profile);
1613                 break;
1614         case CONNECTION_PROFILE_TYPE_WIFI:
1615                 printf("Profile Type : Wi-Fi\n");
1616                 test_print_wifi_info(profile);
1617                 break;
1618         case CONNECTION_PROFILE_TYPE_ETHERNET:
1619                 printf("Profile Type : Ethernet\n");
1620                 break;
1621         case CONNECTION_PROFILE_TYPE_BT:
1622                 printf("Profile Type : Bluetooth\n");
1623                 break;
1624         default:
1625                 return -1;
1626         }
1627
1628         test_print_network_info(profile, address_family);
1629
1630         return 1;
1631 }
1632
1633 int test_set_state_changed_callback()
1634 {
1635         connection_profile_h profile;
1636         connection_profile_h profile_clone;
1637
1638         printf("\n** Choose a profile to set callback. **\n");
1639         if (test_get_user_selected_profile(&profile, true) == false)
1640                 return -1;
1641
1642         if (connection_profile_clone(&profile_clone, profile) != CONNECTION_ERROR_NONE)
1643                 return -1;
1644
1645         if (connection_profile_set_state_changed_cb(profile,
1646                         test_profile_state_callback, profile_clone) != CONNECTION_ERROR_NONE) {
1647                 connection_profile_destroy(profile_clone);
1648                 return -1;
1649         }
1650
1651         state_cb_list = g_slist_append(state_cb_list, profile_clone);
1652
1653         return 1;
1654 }
1655
1656 int test_unset_state_changed_callback()
1657 {
1658         connection_profile_h profile;
1659         GSList *list;
1660         char *profile_name = NULL;
1661         int count = 0;
1662         int input = 0;
1663
1664         printf("\n** Choose a profile to unset callback. **\n");
1665         for (list = state_cb_list; list; list = list->next) {
1666                 profile = list->data;
1667                 if (connection_profile_get_name(profile, &profile_name) != CONNECTION_ERROR_NONE) {
1668                         printf("Fail to get profile name!\n");
1669                         return -1;
1670                 } else {
1671                         printf("%d. %s\n", count, profile_name);
1672                         g_free(profile_name);
1673                 }
1674
1675                 count++;
1676         }
1677
1678         if (test_get_user_int("Input profile number(Enter for cancel) :", &input) == false ||
1679             input >= count ||
1680             input < 0) {
1681                 printf("Wrong number!!\n");
1682                 return -1;
1683         }
1684
1685         count = 0;
1686         for (list = state_cb_list; list; list = list->next) {
1687                 if (count == input) {
1688                         profile = list->data;
1689                         goto unset;
1690                 }
1691
1692                 count++;
1693         }
1694
1695         return -1;
1696
1697 unset:
1698         if (connection_profile_unset_state_changed_cb(profile) != CONNECTION_ERROR_NONE)
1699                 return -1;
1700
1701         state_cb_list = g_slist_remove(state_cb_list, profile);
1702         connection_profile_destroy(profile);
1703
1704         return 1;
1705 }
1706
1707 int test_reset_call_statistics_info(void)
1708 {
1709         int ret = CONNECTION_ERROR_NONE;
1710
1711         ret = connection_reset_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA);
1712         printf("reset last recv data size [%d]\n", ret);
1713         ret = connection_reset_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA);
1714         printf("last sent data size [%d]\n", ret);
1715         ret = connection_reset_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA);
1716         printf("total received data size [%d]\n", ret);
1717         ret = connection_reset_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA);
1718         printf("total sent data size [%d]\n", ret);
1719
1720         return 1;
1721 }
1722
1723 int test_reset_wifi_call_statistics_info(void)
1724 {
1725         int ret = CONNECTION_ERROR_NONE;
1726
1727         ret = connection_reset_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA);
1728         printf("WiFi last sent data size [%d]\n", ret);
1729         ret = connection_reset_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA);
1730         printf("WiFi last recv data size [%d]\n", ret);
1731         ret = connection_reset_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA);
1732         printf("WiFi total sent data size [%d]\n", ret);
1733         ret = connection_reset_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA);
1734         printf("WiFi total received data size [%d]\n", ret);
1735
1736         return 1;
1737 }
1738
1739 int test_add_route(void)
1740 {
1741         int rv = 0;
1742         char ip_addr[100] = {0};
1743         char if_name[40] = {0};
1744
1745         if (test_get_user_string("Input IP - (Enter for skip) :", ip_addr, 100) == false)
1746                 return -1;
1747
1748         if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1749                 return -1;
1750
1751         g_strstrip(ip_addr);
1752         g_strstrip(if_name);
1753         rv = connection_add_route(connection, if_name, ip_addr);
1754         if (rv != CONNECTION_ERROR_NONE) {
1755                 printf("Fail to get add new route [%d]\n", rv);
1756                 return -1;
1757         }
1758         printf("Add Route successfully\n");
1759
1760         return 1;
1761 }
1762
1763 int test_remove_route(void)
1764 {
1765         int rv = 0;
1766         char ip_addr[100] = {0};
1767         char if_name[40] = {0};
1768
1769         if (test_get_user_string("Input IP - (Enter for skip) :", ip_addr, 100) == false)
1770                 return -1;
1771
1772         if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1773                 return -1;
1774
1775         g_strstrip(ip_addr);
1776         g_strstrip(if_name);
1777         rv = connection_remove_route(connection, if_name, ip_addr);
1778         if (rv != CONNECTION_ERROR_NONE) {
1779                 printf("Fail to remove the route [%s]\n", test_print_error(rv));
1780                 return -1;
1781         }
1782         printf("Remove Route successfully\n");
1783
1784         return 1;
1785 }
1786
1787 int test_add_route_ipv6(void)
1788 {
1789         int rv = 0;
1790         char ip_addr[100] = {0};
1791         char gateway[100] = {0};
1792         char if_name[40] = {0};
1793
1794         if (test_get_user_string("Input IPv6 - (Enter for skip) :", ip_addr, 100) == false)
1795                 return -1;
1796
1797         if (test_get_user_string("Input Gateway - (Enter for skip) :", gateway, 100) == false)
1798                 return -1;
1799
1800         if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1801                 return -1;
1802
1803         g_strstrip(ip_addr);
1804         g_strstrip(gateway);
1805         g_strstrip(if_name);
1806         rv = connection_add_route_ipv6(connection, if_name, ip_addr, gateway);
1807         if (rv != CONNECTION_ERROR_NONE) {
1808                 printf("Fail to get add new route [%d]\n", rv);
1809                 return -1;
1810         }
1811         printf("Add Route successfully\n");
1812
1813         return 1;
1814 }
1815
1816 int test_remove_route_ipv6(void)
1817 {
1818         int rv = 0;
1819         char ip_addr[100] = {0};
1820         char gateway[100] = {0};
1821         char if_name[40] = {0};
1822
1823         if (test_get_user_string("Input IPv6 - (Enter for skip) :", ip_addr, 100) == false)
1824                 return -1;
1825
1826         if (test_get_user_string("Input Gateway - (Enter for skip) :", gateway, 100) == false)
1827                 return -1;
1828
1829         if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1830                 return -1;
1831
1832         g_strstrip(ip_addr);
1833         g_strstrip(gateway);
1834         g_strstrip(if_name);
1835         rv = connection_remove_route_ipv6(connection, if_name, ip_addr, gateway);
1836         if (rv != CONNECTION_ERROR_NONE) {
1837                 printf("Fail to remove the route [%d]\n", rv);
1838                 return -1;
1839         }
1840         printf("Remove Route successfully\n");
1841
1842         return 1;
1843 }
1844
1845 int test_add_route_entry(void)
1846 {
1847         char ip_addr[100] = {0};
1848         char gateway[100] = {0};
1849         char if_name[40] = {0};
1850         int input;
1851         bool input_rv;
1852         int rv = 0;
1853
1854         input_rv = test_get_user_int("Input Address type to get"
1855                 "(1:IPV4, 2:IPV6):", &input);
1856
1857         if (input_rv == false) {
1858                 printf("Invalid input!!\n");
1859                 return -1;
1860         }
1861
1862         switch (input) {
1863         case 1:
1864                 if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1865                         return -1;
1866
1867                 if (test_get_user_string("Input IP - (Enter for skip) :", ip_addr, 100) == false)
1868                         return -1;
1869
1870                 if (test_get_user_string("Input Gateway - (Enter for skip) :", gateway, 100) == false)
1871                         return -1;
1872
1873                 g_strstrip(ip_addr);
1874                 g_strstrip(gateway);
1875                 g_strstrip(if_name);
1876                 rv = connection_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4, if_name, ip_addr, gateway);
1877                 if (rv != CONNECTION_ERROR_NONE) {
1878                         printf("Fail to get add new route [%d]\n", rv);
1879                         return -1;
1880                 }
1881                 printf("Add Route successfully\n");
1882                 break;
1883
1884         case 2:
1885                 if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1886                         return -1;
1887
1888                 if (test_get_user_string("Input IP - (Enter for skip) :", ip_addr, 100) == false)
1889                         return -1;
1890
1891                 if (test_get_user_string("Input Gateway - (Enter for skip) :", gateway, 100) == false)
1892                         return -1;
1893
1894                 g_strstrip(ip_addr);
1895                 g_strstrip(gateway);
1896                 g_strstrip(if_name);
1897                 rv = connection_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6, if_name, ip_addr, gateway);
1898                 if (rv != CONNECTION_ERROR_NONE) {
1899                         printf("Fail to get add new route [%d]\n", rv);
1900                         return -1;
1901                 }
1902                 printf("Add Route successfully\n");
1903                 break;
1904
1905         default:
1906                 printf("Wrong IP address family!!\n");
1907                 return -1;
1908
1909         }
1910
1911         return 1;
1912
1913 }
1914
1915 int test_remove_route_entry(void)
1916 {
1917         char ip_addr[100] = {0};
1918         char gateway[100] = {0};
1919         char if_name[40] = {0};
1920         int input;
1921         bool input_rv;
1922         int rv = 0;
1923
1924         input_rv = test_get_user_int("Input Address type to get"
1925                 "(1:IPV4, 2:IPV6):", &input);
1926
1927         if (input_rv == false) {
1928                 printf("Invalid input!!\n");
1929                 return -1;
1930         }
1931
1932         switch (input) {
1933         case 1:
1934                 if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1935                         return -1;
1936
1937                 if (test_get_user_string("Input IP - (Enter for skip) :", ip_addr, 100) == false)
1938                         return -1;
1939
1940                 if (test_get_user_string("Input Gateway - (Enter for skip) :", gateway, 100) == false)
1941                         return -1;
1942
1943                 g_strstrip(ip_addr);
1944                 g_strstrip(gateway);
1945                 g_strstrip(if_name);
1946                 rv = connection_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4, if_name, ip_addr, gateway);
1947                 if (rv != CONNECTION_ERROR_NONE) {
1948                         printf("Fail to remove the route [%s]\n", test_print_error(rv));
1949                         return -1;
1950                 }
1951                 printf("Remove Route successfully\n");
1952
1953                 break;
1954
1955         case 2:
1956                 if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1957                         return -1;
1958
1959                 if (test_get_user_string("Input IP - (Enter for skip) :", ip_addr, 100) == false)
1960                         return -1;
1961
1962                 if (test_get_user_string("Input Gateway - (Enter for skip) :", gateway, 100) == false)
1963                         return -1;
1964
1965                 g_strstrip(ip_addr);
1966                 g_strstrip(gateway);
1967                 g_strstrip(if_name);
1968                 rv = connection_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6, if_name, ip_addr, gateway);
1969                 if (rv != CONNECTION_ERROR_NONE) {
1970                         printf("Fail to remove the route [%d]\n", rv);
1971                         return -1;
1972                 }
1973                 printf("Remove Route successfully\n");
1974                 break;
1975
1976         default:
1977                 printf("Wrong IP address family!!\n");
1978                 return -1;
1979
1980         }
1981
1982         return 1;
1983
1984 }
1985
1986 int test_get_bt_state(void)
1987 {
1988         int rv = 0;
1989         connection_bt_state_e bt_state;
1990
1991         rv = connection_get_bt_state(connection, &bt_state);
1992
1993         if (rv != CONNECTION_ERROR_NONE) {
1994                 printf("Fail to get Bluetooth state [%s]\n", test_print_error(rv));
1995                 return -1;
1996         }
1997
1998         printf("Retval = [%s], Bluetooth state [%d]\n", test_print_error(rv), bt_state);
1999
2000         return 1;
2001 }
2002
2003 int test_get_profile_id(void)
2004 {
2005         connection_profile_h profile;
2006         char *profile_id;
2007
2008         printf("\n** Choose a profile to see profile id. **\n");
2009         if (test_get_user_selected_profile(&profile, true) == false)
2010                 return -1;
2011
2012         if (connection_profile_get_id(profile, &profile_id) != CONNECTION_ERROR_NONE) {
2013                 printf("Fail to get profile name\n");
2014                 return -1;
2015         } else {
2016                 printf("Profile id : %s\n", profile_id);
2017                 g_free(profile_id);
2018         }
2019
2020         return 1;
2021 }
2022
2023 int test_get_mac_address(void)
2024 {
2025         int rv = 0, type = 0;
2026         connection_type_e conn_type;
2027         char *mac_addr = NULL;
2028
2029         test_get_user_int("Input connection type (1:wifi, 2:ethernet)", &type);
2030
2031         switch (type) {
2032         case 1:
2033                 conn_type = CONNECTION_TYPE_WIFI;
2034                 break;
2035         case 2:
2036                 conn_type = CONNECTION_TYPE_ETHERNET;
2037                 break;
2038         default:
2039                 printf("Wrong number!!\n");
2040                 return -1;
2041         }
2042
2043         rv = connection_get_mac_address(connection, conn_type, &mac_addr);
2044
2045         if (rv != CONNECTION_ERROR_NONE) {
2046                 printf("Fail to get MAC address [%s]\n", test_print_error(rv));
2047                 return -1;
2048         }
2049
2050         printf("mac address is %s\n", mac_addr);
2051
2052         g_free(mac_addr);
2053
2054         return 1;
2055 }
2056
2057 int test_get_ethernet_cable_state(void)
2058 {
2059         int rv = 0;
2060         connection_ethernet_cable_state_e cable_state;
2061
2062         rv = connection_get_ethernet_cable_state(connection, &cable_state);
2063
2064         if (rv != CONNECTION_ERROR_NONE) {
2065                 printf("Fail to get ethernet cable state [%s]\n", test_print_error(rv));
2066                 return -1;
2067         }
2068
2069         printf("Retval = [%s], Ethernet cable state [%d]\n", test_print_error(rv), cable_state);
2070
2071         return 1;
2072 }
2073
2074 int test_reset_profile(void)
2075 {
2076         int type, sim_id, rv;
2077
2078         rv = test_get_user_int("Input reset type (0:default profile reset, 1:delete profile reset)", &type);
2079
2080         if (rv == false || (type != 0 && type != 1)) {
2081                 printf("Invalid input!!\n");
2082                 return -1;
2083         }
2084
2085         rv = test_get_user_int("Input SIM id to reset (0:SIM1, 1:SIM2)", &sim_id);
2086
2087         if (rv == false || (sim_id != 0 && sim_id != 1)) {
2088                 printf("Invalid input!!\n");
2089                 return -1;
2090         }
2091
2092         if (connection_reset_profile(connection, type, sim_id, test_connection_reset_profile_callback, NULL) != CONNECTION_ERROR_NONE)
2093                 return -1;
2094
2095         return 1;
2096 }
2097
2098 static bool test_get_ipv6_address_callback(char *ipv6_address, void* user_data)
2099 {
2100         printf("IPv6 Address : %s\n", ipv6_address);
2101         return true;
2102 }
2103
2104 int test_foreach_ipv6_address(void)
2105 {
2106         int rv = 0;
2107         int type;
2108         connection_type_e conn_type;
2109
2110         test_get_user_int("Input Connection Type(1: WiFi 2: Ethernet) :", &type);
2111
2112         switch (type) {
2113         case 1:
2114                 conn_type = CONNECTION_TYPE_WIFI;
2115                 break;
2116         case 2:
2117                 conn_type = CONNECTION_TYPE_ETHERNET;
2118                 break;
2119         default:
2120                 printf("Wrong number!!\n");
2121                 return -1;
2122         }
2123
2124         rv = connection_foreach_ipv6_address(connection, conn_type, test_get_ipv6_address_callback, NULL);
2125         if (rv != CONNECTION_ERROR_NONE) {
2126                 printf("Fail to get IPv6 address\n");
2127                 return -1;
2128         }
2129
2130         return 1;
2131 }
2132
2133 int test_is_metered_network(void)
2134 {
2135         int rv = 0;
2136         bool metered_state;
2137
2138         rv = connection_is_metered_network(connection, &metered_state);
2139
2140         if (rv != CONNECTION_ERROR_NONE) {
2141                 printf("Fail to get metered state [%s]\n", test_print_error(rv));
2142                 return -1;
2143         }
2144
2145         printf("Retval = [%s] metered state [%s]\n",
2146                 test_print_error(rv), metered_state ? "TRUE" : "FALSE");
2147
2148         return 1;
2149 }
2150
2151 int test_start_tcpdump(void)
2152 {
2153         if (connection_profile_start_tcpdump(connection) != CONNECTION_ERROR_NONE) {
2154                 return -1;
2155         }
2156
2157         printf("Successfully started tcpdump\n");
2158
2159         return 1;
2160 }
2161
2162 int test_stop_tcpdump(void)
2163 {
2164         if (connection_profile_stop_tcpdump(connection) != CONNECTION_ERROR_NONE) {
2165                 return -1;
2166         }
2167
2168         printf("Successfully stopped tcpdump\n");
2169
2170         return 1;
2171 }
2172
2173 int test_get_tcpdump_state(void)
2174 {
2175         gboolean tcpdump_state = FALSE;
2176
2177         if (connection_profile_get_tcpdump_state(connection, &tcpdump_state) != CONNECTION_ERROR_NONE) {
2178                 return -1;
2179         }
2180
2181         printf("tcpdump %s running\n", tcpdump_state ? "is" : "is not");
2182
2183         return 1;
2184 }
2185
2186 int test_mptcp_enable(void)
2187 {
2188         int rv = 0;
2189         rv = connection_mptcp_enable(CONNECTION_MPTCP_ENABLE_ALL);
2190
2191         if (rv != CONNECTION_ERROR_NONE) {
2192                 printf("Failure[%s]\n", test_print_error(rv));
2193                 return -1;
2194         }
2195         return 1;
2196 }
2197
2198 int test_mptcp_disable(void)
2199 {
2200         int rv = 0;
2201         rv = connection_mptcp_disable();
2202
2203         if (rv != CONNECTION_ERROR_NONE) {
2204                 printf("Failure[%s]\n", test_print_error(rv));
2205                 return -1;
2206         }
2207         return 1;
2208 }
2209
2210 int test_mptcp_set_path_manager(void)
2211 {
2212         int rv = 0;
2213         int input = 0;
2214         rv = test_get_user_int("Input Path Manager (1: default, 2: fullmesh)", &input);
2215
2216         switch (input) {
2217         case 1:
2218                 rv = connection_mptcp_set_path_manager(CONNECTION_MPTCP_PM_DEFAULT);
2219                 break;
2220         case 2:
2221                 rv = connection_mptcp_set_path_manager(CONNECTION_MPTCP_PM_FULLMESH);
2222                 break;
2223         default:
2224                 printf("Invalid input!!\n");
2225                 return -1;
2226         }
2227
2228         if (rv != CONNECTION_ERROR_NONE) {
2229                 printf("Failure[%s]\n", test_print_error(rv));
2230                 return -1;
2231         }
2232
2233         return 1;
2234 }
2235
2236 int test_mptcp_get_path_manager(void)
2237 {
2238         int rv = 0;
2239         connection_mptcp_path_manager_e pm;
2240
2241         rv = connection_mptcp_get_path_manager(&pm);
2242         if (rv != CONNECTION_ERROR_NONE) {
2243                 printf("Failure[%s]\n", test_print_error(rv));
2244                 return -1;
2245         }
2246
2247         switch (pm) {
2248         case CONNECTION_MPTCP_PM_DEFAULT:
2249                 printf("Path Manager: Default\n");
2250                 break;
2251         case CONNECTION_MPTCP_PM_FULLMESH:
2252                 printf("Path Manager: FullMesh\n");
2253                 break;
2254         default:
2255                 printf("Error: Invalid Path Manager\n");
2256                 return -1;
2257         }
2258
2259         return 1;
2260 }
2261
2262 int test_mptcp_set_scheduler(void)
2263 {
2264         int rv = 0;
2265         int input = 0;
2266         rv = test_get_user_int("Input Scheduler (1: default, 2: roundrobin)", &input);
2267
2268         switch (input) {
2269         case 1:
2270                 rv = connection_mptcp_set_scheduler(CONNECTION_MPTCP_SCHEDULER_DEFAULT);
2271                 break;
2272         case 2:
2273                 rv = connection_mptcp_set_scheduler(CONNECTION_MPTCP_SCHEDULER_ROUNDROBIN);
2274                 break;
2275         default:
2276                 printf("Invalid input!!\n");
2277                 return -1;
2278         }
2279
2280         if (rv != CONNECTION_ERROR_NONE) {
2281                 printf("Failure[%s]\n", test_print_error(rv));
2282                 return -1;
2283         }
2284
2285         return 1;
2286 }
2287
2288 int test_mptcp_get_scheduler(void)
2289 {
2290         int rv = 0;
2291         connection_mptcp_scheduler_e scheduler;
2292
2293         rv = connection_mptcp_get_scheduler(&scheduler);
2294         if (rv != CONNECTION_ERROR_NONE) {
2295                 printf("Failure[%s]\n", test_print_error(rv));
2296                 return -1;
2297         }
2298
2299         switch (scheduler) {
2300         case CONNECTION_MPTCP_SCHEDULER_DEFAULT:
2301                 printf("Scheduler: Default\n");
2302                 break;
2303         case CONNECTION_MPTCP_SCHEDULER_ROUNDROBIN:
2304                 printf("Scheduler: RountRobin\n");
2305                 break;
2306         default:
2307                 printf("Error: Invalid Scheduler\n");
2308                 return -1;
2309         }
2310
2311         return 1;
2312 }
2313
2314 int main(int argc, char **argv)
2315 {
2316         GMainLoop *mainloop;
2317         mainloop = g_main_loop_new(NULL, FALSE);
2318
2319         GIOChannel *channel = g_io_channel_unix_new(0);
2320         g_io_add_watch(channel, (G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL), test_thread, NULL);
2321
2322         printf("Test Thread created...\n");
2323
2324         g_main_loop_run(mainloop);
2325
2326         return 0;
2327 }
2328
2329 gboolean test_thread(GIOChannel *source, GIOCondition condition, gpointer data)
2330 {
2331         int rv = 0;
2332         char a[100];
2333
2334         memset(a, '\0', 100);
2335         printf("Event received from stdin\n");
2336
2337         rv = read(0, a, 100);
2338
2339         if (rv < 0 || a[0] == '0') {
2340                 if (connection != NULL)
2341                         test_deregister_client();
2342
2343                 exit(1);
2344         }
2345
2346         if (*a == '\n' || *a == '\r') {
2347 /* Public API */
2348                 printf("\n\n Network Connection API Test App\n\n");
2349                 printf("Options..\n");
2350                 printf(LOG_BLUE "[Public APIs]\n" LOG_END);
2351                 printf(LOG_GREEN "1   - Create Handle and set callbacks\n" LOG_END);
2352                 printf("2   - Destroy Handle(unset callbacks automatically)\n");
2353                 printf(LOG_GREEN "3   - Get network state\n" LOG_END);
2354                 printf(LOG_GREEN "4   - Get cellular state (please insert SIM Card)\n" LOG_END);
2355                 printf(LOG_GREEN "5   - Get wifi state (please turn on WiFi)\n" LOG_END);
2356                 printf("6   - Get current proxy address \n");
2357                 printf("7   - Get current Ip address\n");
2358                 printf("8   - Get cellular data call statistics\n");
2359                 printf("9   - Get WiFi data call statistics\n");
2360                 printf(LOG_GREEN "a   - Get Profile list\n" LOG_END);
2361                 printf(LOG_GREEN "b   - Get Connected Profile list\n" LOG_END);
2362                 printf(LOG_GREEN "c   - Get Current profile\n" LOG_END);
2363                 printf("d   - Open connection with profile\n");
2364                 printf("e   - Get default cellular service by type\n");
2365                 printf("f   - Set default cellular service by type\n");
2366                 printf("g   - Close connection with profile\n");
2367                 printf("h   - Add profile(Cellular and Wifi only)\n");
2368                 printf("i   - Remove profile(Cellular:delete, WiFi:forgot)\n");
2369                 printf("j   - Update profile\n");
2370                 printf("k   - Get profile info\n");
2371                 printf("l   - Refresh profile info\n");
2372                 printf("m   - Set state changed callback\n");
2373                 printf("n   - Unset state changed callback\n");
2374                 printf("o   - Reset cellular data call statistics\n");
2375                 printf("p   - Reset WiFi data call statistics\n");
2376                 printf("q   - Add new route\n");
2377                 printf("r   - Remove a route\n");
2378                 printf("s   - Get Bluetooth state\n");
2379                 printf("t   - Get profile id\n");
2380                 printf("u   - Reset profile\n");
2381                 printf("v   - Get all cellular default profiles\n");
2382                 printf("w   - Get mac address\n");
2383                 printf("x   - Get ethernet cable state\n");
2384                 printf("B   - Add IPv6 new route\n");
2385                 printf("C   - Remove IPv6 route\n");
2386                 printf("D   - Add new route entry\n");
2387                 printf("E   - Remove route entry\n");
2388                 printf("F   - Get all IPv6 address\n");
2389                 printf("G   - Get metered state\n");
2390 /* Extension API */
2391                 printf(LOG_BLUE "[Extension API]\n" LOG_END);
2392                 printf("H   - Start TCP Dump\n");
2393                 printf("I   - Stop TCP Dump\n");
2394                 printf("J   - Get TCP Dump State\n");
2395                 printf("K   - Enable MPTCP (internal)\n");
2396                 printf("L   - Disable MPTCP (internal)\n");
2397                 printf("M   - Set MPTCP Path Manager (internal)\n");
2398                 printf("N   - Get MPTCP Path Manager (internal)\n");
2399                 printf("O   - Set MPTCP Scheduler (internal)\n");
2400                 printf("P   - Get MPTCP Scheduler (internal)\n");
2401                 printf(LOG_RED "0   - Exit \n" LOG_END);
2402                 printf("ENTER   - Show options menu.......\n");
2403         }
2404
2405         switch (a[0]) {
2406 /* Public API */
2407         case '1':
2408                 rv = test_register_client();
2409                 break;
2410         case '2':
2411                 rv = test_deregister_client();
2412                 break;
2413         case '3':
2414                 rv = test_get_network_state();
2415                 break;
2416         case '4':
2417                 rv = test_get_cellular_state();
2418                 break;
2419         case '5':
2420                 rv = test_get_wifi_state();
2421                 break;
2422         case '6':
2423                 rv = test_get_current_proxy();
2424                 break;
2425         case '7':
2426                 rv = test_get_current_ip();
2427                 break;
2428         case '8':
2429                 rv = test_get_call_statistics_info();
2430                 break;
2431         case '9':
2432                 rv = test_get_wifi_call_statistics_info();
2433                 break;
2434         case 'a':
2435                 rv = test_get_profile_list();
2436                 break;
2437         case 'b':
2438                 rv = test_get_connected_profile_list();
2439                 break;
2440         case 'c':
2441                 rv = test_get_current_profile();
2442                 break;
2443         case 'd':
2444                 rv = test_open_profile();
2445                 break;
2446         case 'e':
2447                 rv = test_get_default_cellular_service_type();
2448                 break;
2449         case 'f':
2450                 rv = test_set_default_cellular_service_type();
2451                 break;
2452         case 'g':
2453                 rv = test_close_profile();
2454                 break;
2455         case 'h':
2456                 rv = test_add_profile();
2457                 break;
2458         case 'i':
2459                 rv = test_remove_profile();
2460                 break;
2461         case 'j':
2462                 rv = test_update_profile();
2463                 break;
2464         case 'k':
2465                 rv = test_get_profile_info();
2466                 break;
2467         case 'l':
2468                 rv = test_refresh_profile_info();
2469                 break;
2470         case 'm':
2471                 rv = test_set_state_changed_callback();
2472                 break;
2473         case 'n':
2474                 rv = test_unset_state_changed_callback();
2475                 break;
2476         case 'o':
2477                 rv = test_reset_call_statistics_info();
2478                 break;
2479         case 'p':
2480                 rv = test_reset_wifi_call_statistics_info();
2481                 break;
2482         case 'q':
2483                 rv = test_add_route();
2484                 break;
2485         case 'r':
2486                 rv = test_remove_route();
2487                 break;
2488         case 's':
2489                 rv = test_get_bt_state();
2490                 break;
2491         case 't':
2492                 rv = test_get_profile_id();
2493                 break;
2494         case 'u':
2495                 rv = test_reset_profile();
2496                 break;
2497         case 'v':
2498                 rv = test_get_default_profile_list();
2499                 break;
2500         case 'w':
2501                 rv = test_get_mac_address();
2502                 break;
2503         case 'x':
2504                 rv = test_get_ethernet_cable_state();
2505                 break;
2506         case 'B':
2507                 rv = test_add_route_ipv6();
2508                 break;
2509         case 'C':
2510                 rv = test_remove_route_ipv6();
2511                 break;
2512         case 'D':
2513                 rv = test_add_route_entry();
2514                 break;
2515         case 'E':
2516                 rv = test_remove_route_entry();
2517                 break;
2518         case 'F':
2519                 rv = test_foreach_ipv6_address();
2520                 break;
2521         case 'G':
2522                 rv = test_is_metered_network();
2523                 break;
2524 /* Extension API */
2525         case 'H':
2526                 rv = test_start_tcpdump();
2527                 break;
2528         case 'I':
2529                 rv = test_stop_tcpdump();
2530                 break;
2531         case 'J':
2532                 rv = test_get_tcpdump_state();
2533                 break;
2534         case 'K':
2535                 rv = test_mptcp_enable();
2536                 break;
2537         case 'L':
2538                 rv = test_mptcp_disable();
2539                 break;
2540         case 'M':
2541                 rv = test_mptcp_set_path_manager();
2542                 break;
2543         case 'N':
2544                 rv = test_mptcp_get_path_manager();
2545                 break;
2546         case 'O':
2547                 rv = test_mptcp_set_scheduler();
2548                 break;
2549         case 'P':
2550                 rv = test_mptcp_get_scheduler();
2551                 break;
2552
2553         }
2554
2555         if (rv == 1)
2556                 printf("Operation succeeded!\n");
2557         else
2558                 printf("Operation failed!\n");
2559
2560         return TRUE;
2561 }