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                 printf("Ipconfig type : %d\n", ip_type);
 884
 885         if (connection_profile_get_ip_address(profile, address_family, &ip) != CONNECTION_ERROR_NONE)
 886                 printf("Fail to get IP address!\n");
 887         else {
 888                 printf("IP address : %s\n", ip);
 889                 g_free(ip);
 890         }
 891
 892         if (connection_profile_get_gateway_address(profile, address_family, &gateway) != CONNECTION_ERROR_NONE)
 893                 printf("Fail to get gateway!\n");
 894         else {
 895                 printf("Gateway : %s\n", gateway);
 896                 g_free(gateway);
 897         }
 898
 899         if (connection_profile_get_dhcp_server_address(profile, address_family, &dhcp_server) != CONNECTION_ERROR_NONE)
 900                 printf("Fail to get DHCP Server address!\n");
 901         else {
 902                 printf("DHCP Server : %s\n", dhcp_server);
 903                 g_free(dhcp_server);
 904         }
 905
 906         if (connection_profile_get_dhcp_lease_duration(profile, address_family, &dhcp_lease_duration) != CONNECTION_ERROR_NONE)
 907                 printf("Fail to get DHCP lease duration!\n");
 908         else {
 909                 printf("DHCP lease duration : %d\n", dhcp_lease_duration);
 910         }
 911
 912         if (connection_profile_get_subnet_mask(profile, address_family, &subnet) != CONNECTION_ERROR_NONE)
 913                 printf("Fail to get subnet mask!\n");
 914         else {
 915                 printf("Subnet mask : %s\n", subnet);
 916                 g_free(subnet);
 917         }
 918
 919         if (connection_profile_get_prefix_length(profile, address_family, &prefix_len) != CONNECTION_ERROR_NONE)
 920                 printf("Fail to get prefix length!\n");
 921         else
 922                 printf("Prefix length : %d\n", prefix_len);
 923
 924         if (connection_profile_get_dns_config_type(profile, address_family, &dns_type) != CONNECTION_ERROR_NONE)
 925                 printf("Fail to get DNS configuration type!\n");
 926         else
 927                 printf("DNS configuration type : %d\n", dns_type);
 928
 929         if (connection_profile_get_dns_address(profile, 1, address_family, &dns1) != CONNECTION_ERROR_NONE)
 930                 printf("Fail to get DNS1!\n");
 931         else {
 932                 printf("DNS1 : %s\n", dns1);
 933                 g_free(dns1);
 934         }
 935
 936         if (connection_profile_get_dns_address(profile, 2, address_family, &dns2) != CONNECTION_ERROR_NONE)
 937                 printf("Fail to get DNS2!\n");
 938         else {
 939                 printf("DNS2 : %s\n", dns2);
 940                 g_free(dns2);
 941         }
 942
 943         if (connection_profile_get_proxy_type(profile, &proxy_type) != CONNECTION_ERROR_NONE)
 944                 printf("Fail to get proxy type!\n");
 945         else
 946                 printf("Proxy type : %d\n", proxy_type);
 947
 948         if (connection_profile_get_proxy_address(profile, address_family, &proxy) != CONNECTION_ERROR_NONE)
 949                 printf("Fail to get proxy!\n");
 950         else {
 951                 printf("Proxy : %s\n", proxy);
 952                 g_free(proxy);
 953         }
 954 }
 955
 956 int test_register_client(void)
 957 {
 958
 959         int err = connection_create(&connection);
 960
 961         if (CONNECTION_ERROR_NONE == err) {
 962                 connection_set_type_changed_cb(connection, test_type_changed_callback, NULL);
 963                 connection_set_ip_address_changed_cb(connection, test_ip_changed_callback, NULL);
 964                 connection_set_proxy_address_changed_cb(connection, test_proxy_changed_callback, NULL);
 965                 connection_set_ethernet_cable_state_chaged_cb(connection,
 966                                         test_get_ethernet_cable_state_callback, NULL);
 967         } else {
 968                 printf("Client registration failed [%s]\n", test_print_error(err));
 969                 return -1;
 970         }
 971
 972         printf("Client registration success\n");
 973         return 1;
 974 }
 975
 976 int  test_deregister_client(void)
 977 {
 978         int rv = 0;
 979         GSList *list;
 980         connection_profile_h profile;
 981
 982         if (connection != NULL)
 983                 rv = connection_destroy(connection);
 984         else {
 985                 printf("Cannot deregister : Handle is NULL\n");
 986                 rv = CONNECTION_ERROR_INVALID_OPERATION;
 987         }
 988
 989         if (rv != CONNECTION_ERROR_NONE) {
 990                 printf("Client deregistration fail [%s]\n", test_print_error(rv));
 991                 return -1;
 992         }
 993
 994         if (state_cb_list) {
 995                 for (list = state_cb_list; list; list = list->next) {
 996                         profile = list->data;
 997                         connection_profile_destroy(profile);
 998                 }
 999
1000                 g_slist_free(state_cb_list);
1001                 state_cb_list = NULL;
1002         }
1003
1004         connection = NULL;
1005         printf("Client deregistration success\n");
1006
1007         return 1;
1008 }
1009
1010 int test_get_network_state(void)
1011 {
1012         int rv = 0;
1013         connection_type_e net_state;
1014
1015         rv = connection_get_type(connection, &net_state);
1016
1017         if (rv != CONNECTION_ERROR_NONE) {
1018                 printf("Fail to get network state [%s]\n", test_print_error(rv));
1019                 return -1;
1020         }
1021
1022         printf("Retval = [%s] network connection state [%s]\n",
1023                 test_print_error(rv), test_print_connection_type(net_state));
1024
1025         return 1;
1026 }
1027
1028 int test_get_cellular_state(void)
1029 {
1030         int rv = 0;
1031         connection_cellular_state_e cellular_state;
1032
1033         rv = connection_get_cellular_state(connection, &cellular_state);
1034
1035         if (rv != CONNECTION_ERROR_NONE) {
1036                 printf("Fail to get Cellular state [%s]\n", test_print_error(rv));
1037                 return -1;
1038         }
1039
1040         printf("Retval = [%s] Cellular state [%s]\n",
1041                 test_print_error(rv), test_print_cellular_state(cellular_state));
1042
1043         return 1;
1044 }
1045
1046 int test_get_wifi_state(void)
1047 {
1048         int rv = 0;
1049         connection_wifi_state_e wifi_state;
1050
1051         rv = connection_get_wifi_state(connection, &wifi_state);
1052
1053         if (rv != CONNECTION_ERROR_NONE) {
1054                 printf("Fail to get WiFi state [%s]\n", test_print_error(rv));
1055                 return -1;
1056         }
1057
1058         printf("Retval = [%s] WiFi state [%s]\n",
1059                 test_print_error(rv), test_print_wifi_state(wifi_state));
1060
1061         return 1;
1062 }
1063
1064 int test_get_current_proxy(void)
1065 {
1066         char *proxy_addr = NULL;
1067
1068         connection_get_proxy(connection, CONNECTION_ADDRESS_FAMILY_IPV4, &proxy_addr);
1069
1070         if (proxy_addr == NULL) {
1071                 printf("Proxy address does not exist\n");
1072                 return -1;
1073         }
1074
1075         printf("Current Proxy [%s]\n", proxy_addr);
1076         g_free(proxy_addr);
1077
1078         return 1;
1079 }
1080
1081 int test_get_current_ip(void)
1082 {
1083         char *ip_addr = NULL;
1084         int input;
1085         bool rv;
1086
1087         rv = test_get_user_int("Input Address type to get"
1088                 "(1:IPV4, 2:IPV6):", &input);
1089
1090         if (rv == false) {
1091                 printf("Invalid input!!\n");
1092                 return -1;
1093         }
1094
1095         switch (input) {
1096         case 1:
1097                 connection_get_ip_address(connection, CONNECTION_ADDRESS_FAMILY_IPV4, &ip_addr);
1098                 if (ip_addr == NULL) {
1099                         printf("IPv4 address does not exist\n");
1100                         return -1;
1101                 }
1102                 printf("IPv4 address : %s\n", ip_addr);
1103                 break;
1104
1105         case 2:
1106                 connection_get_ip_address(connection, CONNECTION_ADDRESS_FAMILY_IPV6, &ip_addr);
1107                 if (ip_addr == NULL) {
1108                         printf("IPv6 address does not exist\n");
1109                         return -1;
1110                 }
1111                 printf("IPv6 address : %s\n", ip_addr);
1112                 break;
1113         default:
1114                 printf("Wrong IP address family!!\n");
1115                 return -1;
1116         }
1117
1118         g_free(ip_addr);
1119         return 1;
1120 }
1121
1122 int test_get_call_statistics_info(void)
1123 {
1124         long long rv = 0;
1125
1126         connection_get_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA, &rv);
1127         printf("last recv data size [%lld]\n", rv);
1128         connection_get_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA, &rv);
1129         printf("last sent data size [%lld]\n", rv);
1130         connection_get_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA, &rv);
1131         printf("total received data size [%lld]\n", rv);
1132         connection_get_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA, &rv);
1133         printf("total sent data size [%lld]\n", rv);
1134
1135         return 1;
1136 }
1137
1138 int test_get_wifi_call_statistics_info(void)
1139 {
1140         long long rv = 0;
1141
1142         connection_get_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA, &rv);
1143         printf("WiFi last recv data size [%lld]\n", rv);
1144         connection_get_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA, &rv);
1145         printf("WiFi last sent data size [%lld]\n", rv);
1146         connection_get_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA, &rv);
1147         printf("WiFi total received data size [%lld]\n", rv);
1148         connection_get_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA, &rv);
1149         printf("WiFi total sent data size [%lld]\n", rv);
1150
1151         return 1;
1152 }
1153
1154 int test_get_profile_list(void)
1155 {
1156         if (test_get_user_selected_profile(NULL, false) == false)
1157                 return -1;
1158
1159         return 1;
1160 }
1161
1162 int test_get_default_profile_list(void)
1163 {
1164         int rv = 0;
1165         char *profile_name = NULL;
1166         connection_profile_iterator_h profile_iter;
1167         connection_profile_h profile_h;
1168         connection_cellular_service_type_e service_type;
1169         bool is_default = false;
1170
1171         rv = connection_get_profile_iterator(connection, CONNECTION_ITERATOR_TYPE_DEFAULT, &profile_iter);
1172         if (rv != CONNECTION_ERROR_NONE) {
1173                 printf("Fail to get profile iterator [%s]\n", test_print_error(rv));
1174                 return -1;
1175         }
1176
1177         while (connection_profile_iterator_has_next(profile_iter)) {
1178                 if (connection_profile_iterator_next(profile_iter, &profile_h) != CONNECTION_ERROR_NONE) {
1179                         printf("Fail to get profile handle\n");
1180                         return -1;
1181                 }
1182
1183                 if (connection_profile_get_name(profile_h, &profile_name) != CONNECTION_ERROR_NONE) {
1184                         printf("Fail to get profile name\n");
1185                         return -1;
1186                 }
1187                 printf("profile name : %s\n", profile_name);
1188                 g_free(profile_name);
1189
1190                 if (connection_profile_get_cellular_service_type(profile_h, &service_type) != CONNECTION_ERROR_NONE) {
1191                         printf("Fail to get profile service type\n");
1192                         return -1;
1193                 }
1194                 printf("service type : %d\n", service_type);
1195
1196                 if (connection_profile_is_cellular_default(profile_h, &is_default) != CONNECTION_ERROR_NONE) {
1197                         printf("Fail to get profile subscriber id\n");
1198                         return -1;
1199                 }
1200                 printf("Default : %d\n", is_default);
1201         }
1202
1203         return 1;
1204 }
1205
1206 int test_get_connected_profile_list(void)
1207 {
1208         int rv = 0;
1209         char *profile_name = NULL;
1210         connection_profile_iterator_h profile_iter;
1211         connection_profile_h profile_h;
1212         bool is_default = false;
1213         connection_profile_type_e type;
1214
1215         rv = connection_get_profile_iterator(connection, CONNECTION_ITERATOR_TYPE_CONNECTED, &profile_iter);
1216         if (rv != CONNECTION_ERROR_NONE) {
1217                 printf("Fail to get profile iterator [%s]\n", test_print_error(rv));
1218                 return -1;
1219         }
1220
1221         while (connection_profile_iterator_has_next(profile_iter)) {
1222                 if (connection_profile_iterator_next(profile_iter, &profile_h) != CONNECTION_ERROR_NONE) {
1223                         printf("Fail to get profile handle\n");
1224                         return -1;
1225                 }
1226
1227                 if (connection_profile_get_name(profile_h, &profile_name) != CONNECTION_ERROR_NONE) {
1228                         printf("Fail to get profile name\n");
1229                         return -1;
1230                 }
1231                 printf("profile name is %s\n", profile_name);
1232                 g_free(profile_name);
1233
1234                 if (connection_profile_get_type(profile_h, &type) != CONNECTION_ERROR_NONE) {
1235                         printf("Fail to get profile type\n");
1236                         return -1;
1237                 }
1238                 printf("profile type is %d\n", type);
1239
1240                 if (type == CONNECTION_PROFILE_TYPE_CELLULAR) {
1241                 if (connection_profile_is_cellular_default(profile_h, &is_default) != CONNECTION_ERROR_NONE) {
1242                         printf("Fail to get profile is default\n");
1243                         return -1;
1244                 }
1245                         printf("[%s]\n", is_default ? "default" : "not default");
1246                 }
1247         }
1248
1249         return 1;
1250 }
1251
1252 int test_get_current_profile(void)
1253 {
1254         int rv = 0;
1255         char *profile_name = NULL;
1256         connection_profile_h profile_h;
1257
1258         rv = connection_get_current_profile(connection, &profile_h);
1259         if (rv != CONNECTION_ERROR_NONE) {
1260                 printf("Fail to get profile iterator [%s]\n", test_print_error(rv));
1261                 return -1;
1262         }
1263
1264         if (connection_profile_get_name(profile_h, &profile_name) != CONNECTION_ERROR_NONE) {
1265                 printf("Fail to get profile name\n");
1266                 return -1;
1267         }
1268         printf("profile name : %s\n", profile_name);
1269         g_free(profile_name);
1270
1271         connection_profile_destroy(profile_h);
1272
1273         return 1;
1274 }
1275
1276 int test_open_profile(void)
1277 {
1278         connection_profile_h profile;
1279
1280         printf("\n** Choose a profile to open. **\n");
1281
1282         if (test_get_user_selected_profile(&profile, true) == false)
1283                 return -1;
1284
1285         if (connection_open_profile(connection, profile, test_connection_opened_callback, NULL) != CONNECTION_ERROR_NONE) {
1286                 printf("Connection open Failed!!\n");
1287                 return -1;
1288         }
1289
1290         return 1;
1291 }
1292
1293 int test_get_default_cellular_service_type(void)
1294 {
1295         int input;
1296         int rv;
1297         int service_type;
1298         connection_profile_h profile;
1299         char *profile_name = NULL;
1300
1301         rv = test_get_user_int("Input profile type to get"
1302                         "(1:Internet, 2:MMS, 3:Prepaid internet, 4:Prepaid MMS, 5:Tethering, 6:Application):", &input);
1303
1304         if (rv == false) {
1305                 printf("Invalid input!!\n");
1306                 return -1;
1307         }
1308
1309         switch (input) {
1310         case 1:
1311                 service_type = CONNECTION_CELLULAR_SERVICE_TYPE_INTERNET;
1312                 break;
1313         case 2:
1314                 service_type = CONNECTION_CELLULAR_SERVICE_TYPE_MMS;
1315                 break;
1316         case 3:
1317                 service_type = CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_INTERNET;
1318                 break;
1319         case 4:
1320                 service_type = CONNECTION_CELLULAR_SERVICE_TYPE_PREPAID_MMS;
1321                 break;
1322         case 5:
1323                 service_type = CONNECTION_CELLULAR_SERVICE_TYPE_TETHERING;
1324                 break;
1325         case 6:
1326                 service_type =  CONNECTION_CELLULAR_SERVICE_TYPE_APPLICATION;
1327                 break;
1328         default:
1329                 printf("Wrong number!!\n");
1330                 return -1;
1331         }
1332
1333         if (connection_get_default_cellular_service_profile(connection, service_type, &profile) != CONNECTION_ERROR_NONE)
1334                 return -1;
1335
1336         if (connection_profile_get_name(profile, &profile_name) != CONNECTION_ERROR_NONE) {
1337                 printf("Fail to get profile name\n");
1338                 connection_profile_destroy(profile);
1339                 return -1;
1340         }
1341         printf("Default profile name : %s\n", profile_name);
1342         g_free(profile_name);
1343
1344         connection_profile_destroy(profile);
1345
1346         return 1;
1347 }
1348
1349 int test_set_default_cellular_service_type(void)
1350 {
1351         connection_profile_h profile;
1352         connection_cellular_service_type_e type;
1353         int input, rv;
1354
1355         rv = test_get_user_int("Input API type (1:sync, 2:async)", &input);
1356
1357         if (rv == false || (input != 1 && input != 2)) {
1358                 printf("Invalid input!!\n");
1359                 return -1;
1360         }
1361
1362         printf("\n** Choose a profile to set default service(internet or prepaid internet type only). **\n");
1363
1364         if (test_get_user_selected_profile(&profile, true) == false)
1365                 return -1;
1366
1367         if (connection_profile_get_cellular_service_type(profile, &type) != CONNECTION_ERROR_NONE) {
1368                 printf("Fail to get cellular service type\n");
1369                 return -1;
1370         }
1371
1372         if (input == 1) {
1373                 if (connection_set_default_cellular_service_profile(connection, type, profile) != CONNECTION_ERROR_NONE)
1374                         return -1;
1375         } else {
1376                 if (connection_set_default_cellular_service_profile_async(connection,
1377                                 type, profile, test_connection_set_default_callback, NULL) != CONNECTION_ERROR_NONE)
1378                         return -1;
1379         }
1380
1381         return 1;
1382 }
1383
1384 int test_close_profile(void)
1385 {
1386         connection_profile_h profile;
1387
1388         printf("\n** Choose a profile to close. **\n");
1389
1390         if (test_get_user_selected_profile(&profile, true) == false)
1391                 return -1;
1392
1393         if (connection_close_profile(connection, profile, test_connection_closed_callback, NULL) != CONNECTION_ERROR_NONE) {
1394                 printf("Connection close Failed!!\n");
1395                 return -1;
1396         }
1397
1398         return 1;
1399 }
1400
1401 int test_add_profile(void)
1402 {
1403         int rv = 0;
1404         connection_profile_h profile;
1405         char input_str[100] = {0,};
1406
1407         if (test_get_user_string("Input Keyword - (Enter for skip) :", input_str, 100) == false)
1408                 return -1;
1409
1410         g_strstrip(input_str);
1411         rv = connection_profile_create(CONNECTION_PROFILE_TYPE_CELLULAR, input_str, &profile);
1412         if (rv != CONNECTION_ERROR_NONE)
1413                 RETURN_FAIL_DESTROY(profile);
1414
1415         if (test_update_cellular_info(profile) == -1)
1416                 RETURN_FAIL_DESTROY(profile);
1417
1418         rv = connection_add_profile(connection, profile);
1419         if (rv != CONNECTION_ERROR_NONE)
1420                 RETURN_FAIL_DESTROY(profile);
1421
1422         connection_profile_destroy(profile);
1423         return 1;
1424 }
1425
1426 int test_remove_profile(void)
1427 {
1428         connection_profile_h profile;
1429
1430         printf("\n** Choose a profile to remove. **\n");
1431         if (test_get_user_selected_profile(&profile, true) == false)
1432                 return -1;
1433
1434         if (connection_remove_profile(connection, profile) != CONNECTION_ERROR_NONE) {
1435                 printf("Remove profile Failed!!\n");
1436                 return -1;
1437         }
1438
1439         return 1;
1440 }
1441
1442 int test_update_profile(void)
1443 {
1444         int rv = 0;
1445
1446         connection_profile_type_e prof_type;
1447         connection_profile_h profile;
1448
1449         printf("\n** Choose a profile to update. **\n");
1450         if (test_get_user_selected_profile(&profile, true) == false)
1451                 return -1;
1452
1453         if (connection_profile_get_type(profile, &prof_type) != CONNECTION_ERROR_NONE)
1454                 return -1;
1455
1456         switch (prof_type) {
1457         case CONNECTION_PROFILE_TYPE_CELLULAR:
1458                 if (test_update_cellular_info(profile) == -1)
1459                         return -1;
1460
1461                 break;
1462         case CONNECTION_PROFILE_TYPE_WIFI:
1463                 if (test_update_wifi_info(profile) == -1)
1464                         return -1;
1465
1466                 if (test_update_network_info(profile) == -1)
1467                         return -1;
1468
1469                 break;
1470         case CONNECTION_PROFILE_TYPE_ETHERNET:
1471                 if (test_update_network_info(profile) == -1)
1472                         return -1;
1473                 break;
1474
1475         case CONNECTION_PROFILE_TYPE_BT:
1476                 printf("Not supported!\n");
1477                 /* fall through */
1478         default:
1479                 return -1;
1480         }
1481
1482         rv = connection_update_profile(connection, profile);
1483         if (rv != CONNECTION_ERROR_NONE)
1484                 return -1;
1485
1486         return 1;
1487 }
1488
1489 int test_get_profile_info(void)
1490 {
1491         connection_profile_type_e prof_type;
1492         connection_profile_state_e profile_state;
1493         connection_profile_state_e profile_ipv6_state;
1494         connection_profile_h profile;
1495         char *profile_name = NULL;
1496         int address_family = 0;
1497
1498         printf("\n** Choose a profile to print. **\n");
1499         if (test_get_user_selected_profile(&profile, true) == false)
1500                 return -1;
1501
1502         if (connection_profile_get_name(profile, &profile_name) != CONNECTION_ERROR_NONE) {
1503                 printf("Fail to get profile name\n");
1504                 return -1;
1505         } else {
1506                 printf("Profile Name : %s\n", profile_name);
1507                 g_free(profile_name);
1508         }
1509
1510         if (connection_profile_get_state(profile, &profile_state) != CONNECTION_ERROR_NONE) {
1511                 printf("Fail to get profile IPv4 state\n");
1512                 return -1;
1513         } else
1514                 printf("Profile State : %s\n", test_print_state(profile_state));
1515
1516         if (connection_profile_get_ipv6_state(profile, &profile_ipv6_state) != CONNECTION_ERROR_NONE) {
1517                 printf("Fail to get profile IPv6 state\n");
1518                 return -1;
1519         } else
1520                 printf("Profile IPv6 State : %s\n", test_print_state(profile_ipv6_state));
1521
1522
1523         if (connection_profile_get_type(profile, &prof_type) != CONNECTION_ERROR_NONE)
1524                 return -1;
1525
1526         test_get_user_int("Input Address Family (0:IPv4 1:IPv6) :", &address_family);
1527
1528         switch (prof_type) {
1529         case CONNECTION_PROFILE_TYPE_CELLULAR:
1530                 printf("Profile Type : Cellular\n");
1531                 test_print_cellular_info(profile);
1532                 break;
1533         case CONNECTION_PROFILE_TYPE_WIFI:
1534                 printf("Profile Type : Wi-Fi\n");
1535                 test_print_wifi_info(profile);
1536                 break;
1537         case CONNECTION_PROFILE_TYPE_ETHERNET:
1538                 printf("Profile Type : Ethernet\n");
1539                 break;
1540         case CONNECTION_PROFILE_TYPE_BT:
1541                 printf("Profile Type : Bluetooth\n");
1542                 break;
1543         default:
1544                 return -1;
1545         }
1546
1547         test_print_network_info(profile, address_family);
1548
1549         return 1;
1550 }
1551
1552 int test_refresh_profile_info(void)
1553 {
1554         connection_profile_type_e prof_type;
1555         connection_profile_state_e profile_state;
1556         connection_profile_h profile;
1557         char *profile_name = NULL;
1558         int address_family = 0;
1559
1560         printf("\n** Choose a profile to refresh. **\n");
1561         if (test_get_user_selected_profile(&profile, true) == false)
1562                 return -1;
1563
1564         if (connection_profile_refresh(profile) != CONNECTION_ERROR_NONE)
1565                 return -1;
1566
1567         if (connection_profile_get_name(profile, &profile_name) != CONNECTION_ERROR_NONE) {
1568                 printf("Fail to get profile name\n");
1569                 return -1;
1570         } else {
1571                 printf("Profile Name : %s\n", profile_name);
1572                 g_free(profile_name);
1573         }
1574
1575         if (connection_profile_get_state(profile, &profile_state) != CONNECTION_ERROR_NONE) {
1576                 printf("Fail to get profile state\n");
1577                 return -1;
1578         } else
1579                 printf("Profile State : %s\n", test_print_state(profile_state));
1580
1581
1582         if (connection_profile_get_type(profile, &prof_type) != CONNECTION_ERROR_NONE)
1583                 return -1;
1584
1585         test_get_user_int("Input Address Family (0:IPv4 1:IPv6) :", &address_family);
1586
1587         switch (prof_type) {
1588         case CONNECTION_PROFILE_TYPE_CELLULAR:
1589                 printf("Profile Type : Cellular\n");
1590                 test_print_cellular_info(profile);
1591                 break;
1592         case CONNECTION_PROFILE_TYPE_WIFI:
1593                 printf("Profile Type : Wi-Fi\n");
1594                 test_print_wifi_info(profile);
1595                 break;
1596         case CONNECTION_PROFILE_TYPE_ETHERNET:
1597                 printf("Profile Type : Ethernet\n");
1598                 break;
1599         case CONNECTION_PROFILE_TYPE_BT:
1600                 printf("Profile Type : Bluetooth\n");
1601                 break;
1602         default:
1603                 return -1;
1604         }
1605
1606         test_print_network_info(profile, address_family);
1607
1608         return 1;
1609 }
1610
1611 int test_set_state_changed_callback()
1612 {
1613         connection_profile_h profile;
1614         connection_profile_h profile_clone;
1615
1616         printf("\n** Choose a profile to set callback. **\n");
1617         if (test_get_user_selected_profile(&profile, true) == false)
1618                 return -1;
1619
1620         if (connection_profile_clone(&profile_clone, profile) != CONNECTION_ERROR_NONE)
1621                 return -1;
1622
1623         if (connection_profile_set_state_changed_cb(profile,
1624                         test_profile_state_callback, profile_clone) != CONNECTION_ERROR_NONE) {
1625                 connection_profile_destroy(profile_clone);
1626                 return -1;
1627         }
1628
1629         state_cb_list = g_slist_append(state_cb_list, profile_clone);
1630
1631         return 1;
1632 }
1633
1634 int test_unset_state_changed_callback()
1635 {
1636         connection_profile_h profile;
1637         GSList *list;
1638         char *profile_name = NULL;
1639         int count = 0;
1640         int input = 0;
1641
1642         printf("\n** Choose a profile to unset callback. **\n");
1643         for (list = state_cb_list; list; list = list->next) {
1644                 profile = list->data;
1645                 if (connection_profile_get_name(profile, &profile_name) != CONNECTION_ERROR_NONE) {
1646                         printf("Fail to get profile name!\n");
1647                         return -1;
1648                 } else {
1649                         printf("%d. %s\n", count, profile_name);
1650                         g_free(profile_name);
1651                 }
1652
1653                 count++;
1654         }
1655
1656         if (test_get_user_int("Input profile number(Enter for cancel) :", &input) == false ||
1657             input >= count ||
1658             input < 0) {
1659                 printf("Wrong number!!\n");
1660                 return -1;
1661         }
1662
1663         count = 0;
1664         for (list = state_cb_list; list; list = list->next) {
1665                 if (count == input) {
1666                         profile = list->data;
1667                         goto unset;
1668                 }
1669
1670                 count++;
1671         }
1672
1673         return -1;
1674
1675 unset:
1676         if (connection_profile_unset_state_changed_cb(profile) != CONNECTION_ERROR_NONE)
1677                 return -1;
1678
1679         state_cb_list = g_slist_remove(state_cb_list, profile);
1680         connection_profile_destroy(profile);
1681
1682         return 1;
1683 }
1684
1685 int test_reset_call_statistics_info(void)
1686 {
1687         int ret = CONNECTION_ERROR_NONE;
1688
1689         ret = connection_reset_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA);
1690         printf("reset last recv data size [%d]\n", ret);
1691         ret = connection_reset_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA);
1692         printf("last sent data size [%d]\n", ret);
1693         ret = connection_reset_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA);
1694         printf("total received data size [%d]\n", ret);
1695         ret = connection_reset_statistics(connection, CONNECTION_TYPE_CELLULAR, CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA);
1696         printf("total sent data size [%d]\n", ret);
1697
1698         return 1;
1699 }
1700
1701 int test_reset_wifi_call_statistics_info(void)
1702 {
1703         int ret = CONNECTION_ERROR_NONE;
1704
1705         ret = connection_reset_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_LAST_SENT_DATA);
1706         printf("WiFi last sent data size [%d]\n", ret);
1707         ret = connection_reset_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_LAST_RECEIVED_DATA);
1708         printf("WiFi last recv data size [%d]\n", ret);
1709         ret = connection_reset_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_TOTAL_SENT_DATA);
1710         printf("WiFi total sent data size [%d]\n", ret);
1711         ret = connection_reset_statistics(connection, CONNECTION_TYPE_WIFI, CONNECTION_STATISTICS_TYPE_TOTAL_RECEIVED_DATA);
1712         printf("WiFi total received data size [%d]\n", ret);
1713
1714         return 1;
1715 }
1716
1717 int test_add_route(void)
1718 {
1719         int rv = 0;
1720         char ip_addr[100] = {0};
1721         char if_name[40] = {0};
1722
1723         if (test_get_user_string("Input IP - (Enter for skip) :", ip_addr, 100) == false)
1724                 return -1;
1725
1726         if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1727                 return -1;
1728
1729         g_strstrip(ip_addr);
1730         g_strstrip(if_name);
1731         rv = connection_add_route(connection, if_name, ip_addr);
1732         if (rv != CONNECTION_ERROR_NONE) {
1733                 printf("Fail to get add new route [%d]\n", rv);
1734                 return -1;
1735         }
1736         printf("Add Route successfully\n");
1737
1738         return 1;
1739 }
1740
1741 int test_remove_route(void)
1742 {
1743         int rv = 0;
1744         char ip_addr[100] = {0};
1745         char if_name[40] = {0};
1746
1747         if (test_get_user_string("Input IP - (Enter for skip) :", ip_addr, 100) == false)
1748                 return -1;
1749
1750         if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1751                 return -1;
1752
1753         g_strstrip(ip_addr);
1754         g_strstrip(if_name);
1755         rv = connection_remove_route(connection, if_name, ip_addr);
1756         if (rv != CONNECTION_ERROR_NONE) {
1757                 printf("Fail to remove the route [%s]\n", test_print_error(rv));
1758                 return -1;
1759         }
1760         printf("Remove Route successfully\n");
1761
1762         return 1;
1763 }
1764
1765 int test_add_route_ipv6(void)
1766 {
1767         int rv = 0;
1768         char ip_addr[100] = {0};
1769         char gateway[100] = {0};
1770         char if_name[40] = {0};
1771
1772         if (test_get_user_string("Input IPv6 - (Enter for skip) :", ip_addr, 100) == false)
1773                 return -1;
1774
1775         if (test_get_user_string("Input Gateway - (Enter for skip) :", gateway, 100) == false)
1776                 return -1;
1777
1778         if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1779                 return -1;
1780
1781         g_strstrip(ip_addr);
1782         g_strstrip(gateway);
1783         g_strstrip(if_name);
1784         rv = connection_add_route_ipv6(connection, if_name, ip_addr, gateway);
1785         if (rv != CONNECTION_ERROR_NONE) {
1786                 printf("Fail to get add new route [%d]\n", rv);
1787                 return -1;
1788         }
1789         printf("Add Route successfully\n");
1790
1791         return 1;
1792 }
1793
1794 int test_remove_route_ipv6(void)
1795 {
1796         int rv = 0;
1797         char ip_addr[100] = {0};
1798         char gateway[100] = {0};
1799         char if_name[40] = {0};
1800
1801         if (test_get_user_string("Input IPv6 - (Enter for skip) :", ip_addr, 100) == false)
1802                 return -1;
1803
1804         if (test_get_user_string("Input Gateway - (Enter for skip) :", gateway, 100) == false)
1805                 return -1;
1806
1807         if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1808                 return -1;
1809
1810         g_strstrip(ip_addr);
1811         g_strstrip(gateway);
1812         g_strstrip(if_name);
1813         rv = connection_remove_route_ipv6(connection, if_name, ip_addr, gateway);
1814         if (rv != CONNECTION_ERROR_NONE) {
1815                 printf("Fail to remove the route [%d]\n", rv);
1816                 return -1;
1817         }
1818         printf("Remove Route successfully\n");
1819
1820         return 1;
1821 }
1822
1823 int test_add_route_entry(void)
1824 {
1825         char ip_addr[100] = {0};
1826         char gateway[100] = {0};
1827         char if_name[40] = {0};
1828         int input;
1829         bool input_rv;
1830         int rv = 0;
1831
1832         input_rv = test_get_user_int("Input Address type to get"
1833                 "(1:IPV4, 2:IPV6):", &input);
1834
1835         if (input_rv == false) {
1836                 printf("Invalid input!!\n");
1837                 return -1;
1838         }
1839
1840         switch (input) {
1841         case 1:
1842                 if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1843                         return -1;
1844
1845                 if (test_get_user_string("Input IP - (Enter for skip) :", ip_addr, 100) == false)
1846                         return -1;
1847
1848                 if (test_get_user_string("Input Gateway - (Enter for skip) :", gateway, 100) == false)
1849                         return -1;
1850
1851                 g_strstrip(ip_addr);
1852                 g_strstrip(gateway);
1853                 g_strstrip(if_name);
1854                 rv = connection_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4, if_name, ip_addr, gateway);
1855                 if (rv != CONNECTION_ERROR_NONE) {
1856                         printf("Fail to get add new route [%d]\n", rv);
1857                         return -1;
1858                 }
1859                 printf("Add Route successfully\n");
1860                 break;
1861
1862         case 2:
1863                 if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1864                         return -1;
1865
1866                 if (test_get_user_string("Input IP - (Enter for skip) :", ip_addr, 100) == false)
1867                         return -1;
1868
1869                 if (test_get_user_string("Input Gateway - (Enter for skip) :", gateway, 100) == false)
1870                         return -1;
1871
1872                 g_strstrip(ip_addr);
1873                 g_strstrip(gateway);
1874                 g_strstrip(if_name);
1875                 rv = connection_add_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV6, if_name, ip_addr, gateway);
1876                 if (rv != CONNECTION_ERROR_NONE) {
1877                         printf("Fail to get add new route [%d]\n", rv);
1878                         return -1;
1879                 }
1880                 printf("Add Route successfully\n");
1881                 break;
1882
1883         default:
1884                 printf("Wrong IP address family!!\n");
1885                 return -1;
1886
1887         }
1888
1889         return 1;
1890
1891 }
1892
1893 int test_remove_route_entry(void)
1894 {
1895         char ip_addr[100] = {0};
1896         char gateway[100] = {0};
1897         char if_name[40] = {0};
1898         int input;
1899         bool input_rv;
1900         int rv = 0;
1901
1902         input_rv = test_get_user_int("Input Address type to get"
1903                 "(1:IPV4, 2:IPV6):", &input);
1904
1905         if (input_rv == false) {
1906                 printf("Invalid input!!\n");
1907                 return -1;
1908         }
1909
1910         switch (input) {
1911         case 1:
1912                 if (test_get_user_string("Input Interface name - (Enter for skip) :", if_name, 40) == false)
1913                         return -1;
1914
1915                 if (test_get_user_string("Input IP - (Enter for skip) :", ip_addr, 100) == false)
1916                         return -1;
1917
1918                 if (test_get_user_string("Input Gateway - (Enter for skip) :", gateway, 100) == false)
1919                         return -1;
1920
1921                 g_strstrip(ip_addr);
1922                 g_strstrip(gateway);
1923                 g_strstrip(if_name);
1924                 rv = connection_remove_route_entry(connection, CONNECTION_ADDRESS_FAMILY_IPV4, if_name, ip_addr, gateway);
1925                 if (rv != CONNECTION_ERROR_NONE) {
1926                         printf("Fail to remove the route [%s]\n", test_print_error(rv));
1927                         return -1;
1928                 }
1929                 printf("Remove Route successfully\n");
1930
1931                 break;
1932
1933         case 2:
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_IPV6, if_name, ip_addr, gateway);
1947                 if (rv != CONNECTION_ERROR_NONE) {
1948                         printf("Fail to remove the route [%d]\n", rv);
1949                         return -1;
1950                 }
1951                 printf("Remove Route successfully\n");
1952                 break;
1953
1954         default:
1955                 printf("Wrong IP address family!!\n");
1956                 return -1;
1957
1958         }
1959
1960         return 1;
1961
1962 }
1963
1964 int test_get_bt_state(void)
1965 {
1966         int rv = 0;
1967         connection_bt_state_e bt_state;
1968
1969         rv = connection_get_bt_state(connection, &bt_state);
1970
1971         if (rv != CONNECTION_ERROR_NONE) {
1972                 printf("Fail to get Bluetooth state [%s]\n", test_print_error(rv));
1973                 return -1;
1974         }
1975
1976         printf("Retval = [%s], Bluetooth state [%d]\n", test_print_error(rv), bt_state);
1977
1978         return 1;
1979 }
1980
1981 int test_get_profile_id(void)
1982 {
1983         connection_profile_h profile;
1984         char *profile_id;
1985
1986         printf("\n** Choose a profile to see profile id. **\n");
1987         if (test_get_user_selected_profile(&profile, true) == false)
1988                 return -1;
1989
1990         if (connection_profile_get_id(profile, &profile_id) != CONNECTION_ERROR_NONE) {
1991                 printf("Fail to get profile name\n");
1992                 return -1;
1993         } else {
1994                 printf("Profile id : %s\n", profile_id);
1995                 g_free(profile_id);
1996         }
1997
1998         return 1;
1999 }
2000
2001 int test_get_mac_address(void)
2002 {
2003         int rv = 0, type = 0;
2004         connection_type_e conn_type;
2005         char *mac_addr = NULL;
2006
2007         test_get_user_int("Input connection type (1:wifi, 2:ethernet)", &type);
2008
2009         switch (type) {
2010         case 1:
2011                 conn_type = CONNECTION_TYPE_WIFI;
2012                 break;
2013         case 2:
2014                 conn_type = CONNECTION_TYPE_ETHERNET;
2015                 break;
2016         default:
2017                 printf("Wrong number!!\n");
2018                 return -1;
2019         }
2020
2021         rv = connection_get_mac_address(connection, conn_type, &mac_addr);
2022
2023         if (rv != CONNECTION_ERROR_NONE) {
2024                 printf("Fail to get MAC address [%s]\n", test_print_error(rv));
2025                 return -1;
2026         }
2027
2028         printf("mac address is %s\n", mac_addr);
2029
2030         g_free(mac_addr);
2031
2032         return 1;
2033 }
2034
2035 int test_get_ethernet_cable_state(void)
2036 {
2037         int rv = 0;
2038         connection_ethernet_cable_state_e cable_state;
2039
2040         rv = connection_get_ethernet_cable_state(connection, &cable_state);
2041
2042         if (rv != CONNECTION_ERROR_NONE) {
2043                 printf("Fail to get ethernet cable state [%s]\n", test_print_error(rv));
2044                 return -1;
2045         }
2046
2047         printf("Retval = [%s], Ethernet cable state [%d]\n", test_print_error(rv), cable_state);
2048
2049         return 1;
2050 }
2051
2052 int test_reset_profile(void)
2053 {
2054         int type, sim_id, rv;
2055
2056         rv = test_get_user_int("Input reset type (0:default profile reset, 1:delete profile reset)", &type);
2057
2058         if (rv == false || (type != 0 && type != 1)) {
2059                 printf("Invalid input!!\n");
2060                 return -1;
2061         }
2062
2063         rv = test_get_user_int("Input SIM id to reset (0:SIM1, 1:SIM2)", &sim_id);
2064
2065         if (rv == false || (sim_id != 0 && sim_id != 1)) {
2066                 printf("Invalid input!!\n");
2067                 return -1;
2068         }
2069
2070         if (connection_reset_profile(connection, type, sim_id, test_connection_reset_profile_callback, NULL) != CONNECTION_ERROR_NONE)
2071                 return -1;
2072
2073         return 1;
2074 }
2075
2076 static bool test_get_ipv6_address_callback(char *ipv6_address, void* user_data)
2077 {
2078         printf("IPv6 Address : %s\n", ipv6_address);
2079         return true;
2080 }
2081
2082 int test_foreach_ipv6_address(void)
2083 {
2084         int rv = 0;
2085         int type;
2086         connection_type_e conn_type;
2087
2088         test_get_user_int("Input Connection Type(1: WiFi 2: Ethernet) :", &type);
2089
2090         switch (type) {
2091         case 1:
2092                 conn_type = CONNECTION_TYPE_WIFI;
2093                 break;
2094         case 2:
2095                 conn_type = CONNECTION_TYPE_ETHERNET;
2096                 break;
2097         default:
2098                 printf("Wrong number!!\n");
2099                 return -1;
2100         }
2101
2102         rv = connection_foreach_ipv6_address(connection, conn_type, test_get_ipv6_address_callback, NULL);
2103         if (rv != CONNECTION_ERROR_NONE) {
2104                 printf("Fail to get IPv6 address\n");
2105                 return -1;
2106         }
2107
2108         return 1;
2109 }
2110
2111 int test_is_metered_network(void)
2112 {
2113         int rv = 0;
2114         bool metered_state;
2115
2116         rv = connection_is_metered_network(connection, &metered_state);
2117
2118         if (rv != CONNECTION_ERROR_NONE) {
2119                 printf("Fail to get metered state [%s]\n", test_print_error(rv));
2120                 return -1;
2121         }
2122
2123         printf("Retval = [%s] metered state [%s]\n",
2124                 test_print_error(rv), metered_state ? "TRUE" : "FALSE");
2125
2126         return 1;
2127 }
2128
2129 int test_start_tcpdump(void)
2130 {
2131         if (connection_profile_start_tcpdump(connection) != CONNECTION_ERROR_NONE) {
2132                 return -1;
2133         }
2134
2135         printf("Successfully started tcpdump\n");
2136
2137         return 1;
2138 }
2139
2140 int test_stop_tcpdump(void)
2141 {
2142         if (connection_profile_stop_tcpdump(connection) != CONNECTION_ERROR_NONE) {
2143                 return -1;
2144         }
2145
2146         printf("Successfully stopped tcpdump\n");
2147
2148         return 1;
2149 }
2150
2151 int test_get_tcpdump_state(void)
2152 {
2153         gboolean tcpdump_state = FALSE;
2154
2155         if (connection_profile_get_tcpdump_state(connection, &tcpdump_state) != CONNECTION_ERROR_NONE) {
2156                 return -1;
2157         }
2158
2159         printf("tcpdump %s running\n", tcpdump_state ? "is" : "is not");
2160
2161         return 1;
2162 }
2163
2164 int main(int argc, char **argv)
2165 {
2166         GMainLoop *mainloop;
2167         mainloop = g_main_loop_new(NULL, FALSE);
2168
2169         GIOChannel *channel = g_io_channel_unix_new(0);
2170         g_io_add_watch(channel, (G_IO_IN|G_IO_ERR|G_IO_HUP|G_IO_NVAL), test_thread, NULL);
2171
2172         printf("Test Thread created...\n");
2173
2174         g_main_loop_run(mainloop);
2175
2176         return 0;
2177 }
2178
2179 gboolean test_thread(GIOChannel *source, GIOCondition condition, gpointer data)
2180 {
2181         int rv = 0;
2182         char a[100];
2183
2184         memset(a, '\0', 100);
2185         printf("Event received from stdin\n");
2186
2187         rv = read(0, a, 100);
2188
2189         if (rv < 0 || a[0] == '0') {
2190                 if (connection != NULL)
2191                         test_deregister_client();
2192
2193                 exit(1);
2194         }
2195
2196         if (*a == '\n' || *a == '\r') {
2197 /* Public API */
2198                 printf("\n\n Network Connection API Test App\n\n");
2199                 printf("Options..\n");
2200                 printf(LOG_BLUE "[Public APIs]\n" LOG_END);
2201                 printf(LOG_GREEN "1   - Create Handle and set callbacks\n" LOG_END);
2202                 printf("2   - Destroy Handle(unset callbacks automatically)\n");
2203                 printf(LOG_GREEN "3   - Get network state\n" LOG_END);
2204                 printf(LOG_GREEN "4   - Get cellular state (please insert SIM Card)\n" LOG_END);
2205                 printf(LOG_GREEN "5   - Get wifi state (please turn on WiFi)\n" LOG_END);
2206                 printf("6   - Get current proxy address \n");
2207                 printf("7   - Get current Ip address\n");
2208                 printf("8   - Get cellular data call statistics\n");
2209                 printf("9   - Get WiFi data call statistics\n");
2210                 printf(LOG_GREEN "a   - Get Profile list\n" LOG_END);
2211                 printf(LOG_GREEN "b   - Get Connected Profile list\n" LOG_END);
2212                 printf(LOG_GREEN "c   - Get Current profile\n" LOG_END);
2213                 printf("d   - Open connection with profile\n");
2214                 printf("e   - Get default cellular service by type\n");
2215                 printf("f   - Set default cellular service by type\n");
2216                 printf("g   - Close connection with profile\n");
2217                 printf("h   - Add profile(Cellular and Wifi only)\n");
2218                 printf("i   - Remove profile(Cellular:delete, WiFi:forgot)\n");
2219                 printf("j   - Update profile\n");
2220                 printf("k   - Get profile info\n");
2221                 printf("l   - Refresh profile info\n");
2222                 printf("m   - Set state changed callback\n");
2223                 printf("n   - Unset state changed callback\n");
2224                 printf("o   - Reset cellular data call statistics\n");
2225                 printf("p   - Reset WiFi data call statistics\n");
2226                 printf("q   - Add new route\n");
2227                 printf("r   - Remove a route\n");
2228                 printf("s   - Get Bluetooth state\n");
2229                 printf("t   - Get profile id\n");
2230                 printf("u   - Reset profile\n");
2231                 printf("v   - Get all cellular default profiles\n");
2232                 printf("w   - Get mac address\n");
2233                 printf("x   - Get ethernet cable state\n");
2234                 printf("B   - Add IPv6 new route\n");
2235                 printf("C   - Remove IPv6 route\n");
2236                 printf("D   - Add new route entry\n");
2237                 printf("E   - Remove route entry\n");
2238                 printf("F   - Get all IPv6 address\n");
2239                 printf("G   - Get metered state\n");
2240 /* Extension API */
2241                 printf(LOG_BLUE "[Extension API]\n" LOG_END);
2242                 printf("H   - Start TCP Dump\n");
2243                 printf("I   - Stop TCP Dump\n");
2244                 printf("J   - Get TCP Dump State\n");
2245                 printf(LOG_RED "0   - Exit \n" LOG_END);
2246                 printf("ENTER   - Show options menu.......\n");
2247         }
2248
2249         switch (a[0]) {
2250 /* Public API */
2251         case '1':
2252                 rv = test_register_client();
2253                 break;
2254         case '2':
2255                 rv = test_deregister_client();
2256                 break;
2257         case '3':
2258                 rv = test_get_network_state();
2259                 break;
2260         case '4':
2261                 rv = test_get_cellular_state();
2262                 break;
2263         case '5':
2264                 rv = test_get_wifi_state();
2265                 break;
2266         case '6':
2267                 rv = test_get_current_proxy();
2268                 break;
2269         case '7':
2270                 rv = test_get_current_ip();
2271                 break;
2272         case '8':
2273                 rv = test_get_call_statistics_info();
2274                 break;
2275         case '9':
2276                 rv = test_get_wifi_call_statistics_info();
2277                 break;
2278         case 'a':
2279                 rv = test_get_profile_list();
2280                 break;
2281         case 'b':
2282                 rv = test_get_connected_profile_list();
2283                 break;
2284         case 'c':
2285                 rv = test_get_current_profile();
2286                 break;
2287         case 'd':
2288                 rv = test_open_profile();
2289                 break;
2290         case 'e':
2291                 rv = test_get_default_cellular_service_type();
2292                 break;
2293         case 'f':
2294                 rv = test_set_default_cellular_service_type();
2295                 break;
2296         case 'g':
2297                 rv = test_close_profile();
2298                 break;
2299         case 'h':
2300                 rv = test_add_profile();
2301                 break;
2302         case 'i':
2303                 rv = test_remove_profile();
2304                 break;
2305         case 'j':
2306                 rv = test_update_profile();
2307                 break;
2308         case 'k':
2309                 rv = test_get_profile_info();
2310                 break;
2311         case 'l':
2312                 rv = test_refresh_profile_info();
2313                 break;
2314         case 'm':
2315                 rv = test_set_state_changed_callback();
2316                 break;
2317         case 'n':
2318                 rv = test_unset_state_changed_callback();
2319                 break;
2320         case 'o':
2321                 rv = test_reset_call_statistics_info();
2322                 break;
2323         case 'p':
2324                 rv = test_reset_wifi_call_statistics_info();
2325                 break;
2326         case 'q':
2327                 rv = test_add_route();
2328                 break;
2329         case 'r':
2330                 rv = test_remove_route();
2331                 break;
2332         case 's':
2333                 rv = test_get_bt_state();
2334                 break;
2335         case 't':
2336                 rv = test_get_profile_id();
2337                 break;
2338         case 'u':
2339                 rv = test_reset_profile();
2340                 break;
2341         case 'v':
2342                 rv = test_get_default_profile_list();
2343                 break;
2344         case 'w':
2345                 rv = test_get_mac_address();
2346                 break;
2347         case 'x':
2348                 rv = test_get_ethernet_cable_state();
2349                 break;
2350         case 'B':
2351                 rv = test_add_route_ipv6();
2352                 break;
2353         case 'C':
2354                 rv = test_remove_route_ipv6();
2355                 break;
2356         case 'D':
2357                 rv = test_add_route_entry();
2358                 break;
2359         case 'E':
2360                 rv = test_remove_route_entry();
2361                 break;
2362         case 'F':
2363                 rv = test_foreach_ipv6_address();
2364                 break;
2365         case 'G':
2366                 rv = test_is_metered_network();
2367                 break;
2368 /* Extension API */
2369         case 'H':
2370                 rv = test_start_tcpdump();
2371                 break;
2372         case 'I':
2373                 rv = test_stop_tcpdump();
2374                 break;
2375         case 'J':
2376                 rv = test_get_tcpdump_state();
2377                 break;
2378
2379         }
2380
2381         if (rv == 1)
2382                 printf("Operation succeeded!\n");
2383         else
2384                 printf("Operation failed!\n");
2385
2386         return TRUE;
2387 }