test/main.c

   1 /*
   2  *  Network Client Library
   3  *
   4 * Copyright 2012  Samsung Electronics Co., Ltd
   5
   6 * Licensed under the Flora License, Version 1.0 (the "License");
   7 * you may not use this file except in compliance with the License.
   8 * You may obtain a copy of the License at
   9
  10 * http://www.tizenopensource.org/license
  11
  12 * Unless required by applicable law or agreed to in writing, software
  13 * distributed under the License is distributed on an "AS IS" BASIS,
  14 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  15 * See the License for the specific language governing permissions and
  16 * limitations under the License.
  17  *
  18  */
  19
  20
  21 #ifdef HAVE_CONFIG_H
  22 #include <config.h>
  23 #endif
  24
  25 #include <stdio.h>
  26 #include <errno.h>
  27 #include <stdlib.h>
  28 #include <string.h>
  29 #include <glib.h>
  30
  31 #include <dbus/dbus.h>
  32
  33 #include <network-pm-config.h>
  34 #include <network-cm-intf.h>
  35 #include <network-pm-intf.h>
  36 #include <network-wifi-intf.h>
  37
  38 #define debug_print(format, args...) printf("[%s][Ln: %d] " format, __FILE__, __LINE__, ##args)
  39
  40 #define Convert_time2double(timevar) ((double)timevar.tv_sec+(double)timevar.tv_usec/1000000.0)
  41
  42 #define MAIN_MEMFREE(x) do {if (x != NULL) free(x); x = NULL;} while(0)
  43
  44 typedef enum {
  45         PROFILE_FULL_INFO = 0x01,
  46         PROFILE_PARTIAL_INFO,
  47         PROFILE_BASIC_INFO
  48 } profile_print_type_t;
  49
  50 double start_time = 0;
  51 double finish_time = 0;
  52 double async_time = 0;
  53 struct timeval timevar;
  54
  55 GMainLoop *mainloop = NULL;
  56
  57 static void __print_profile_list(int num_of_profile,
  58                 net_profile_info_t* profile_table, profile_print_type_t print_type);
  59 static void __network_print_profile(net_profile_info_t* ProfInfo, profile_print_type_t print_type);
  60 static void __network_print_ipaddress(net_addr_t* ip_address);
  61
  62 static void __network_evt_cb (net_event_info_t*  event_cb, void* user_data);
  63
  64 static void __network_print_ipaddress(net_addr_t* ip_address)
  65 {
  66         unsigned char *ipaddr;
  67         ipaddr = (unsigned char *)&ip_address->Data.Ipv4.s_addr;
  68         debug_print("Profile IP Address = [%d.%d.%d.%d]\n",
  69                         ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
  70 }
  71
  72 static void __network_print_profile(net_profile_info_t* ProfInfo, profile_print_type_t print_type)
  73 {
  74         net_pdp_profile_info_t *pdp_info = &ProfInfo->ProfileInfo.Pdp;
  75         net_wifi_profile_info_t *wlan_info = &ProfInfo->ProfileInfo.Wlan;
  76         net_eth_profile_info_t *eth_info = &ProfInfo->ProfileInfo.Ethernet;
  77
  78         int di = 0;
  79         unsigned char *ipaddr;
  80         unsigned char *netmaskaddr;
  81         unsigned char *gwaddr;
  82         net_dev_info_t *net_info;
  83
  84         if (ProfInfo->profile_type == NET_DEVICE_WIFI) {
  85                 ipaddr = (unsigned char *)&wlan_info->net_info.IpAddr.Data.Ipv4.s_addr;
  86                 netmaskaddr = (unsigned char *)&wlan_info->net_info.SubnetMask.Data.Ipv4.s_addr;
  87                 gwaddr = (unsigned char *)&wlan_info->net_info.GatewayAddr.Data.Ipv4.s_addr;
  88                 net_info = &(wlan_info->net_info);
  89         } else if (ProfInfo->profile_type == NET_DEVICE_CELLULAR) {
  90                 ipaddr = (unsigned char *)&pdp_info->net_info.IpAddr.Data.Ipv4.s_addr;
  91                 netmaskaddr = (unsigned char *)&pdp_info->net_info.SubnetMask.Data.Ipv4.s_addr;
  92                 gwaddr = (unsigned char *)&pdp_info->net_info.GatewayAddr.Data.Ipv4.s_addr;
  93                 net_info = &(pdp_info->net_info);
  94         } else if (ProfInfo->profile_type == NET_DEVICE_ETHERNET) {
  95                 ipaddr = (unsigned char *)&eth_info->net_info.IpAddr.Data.Ipv4.s_addr;
  96                 netmaskaddr = (unsigned char *)&eth_info->net_info.SubnetMask.Data.Ipv4.s_addr;
  97                 gwaddr = (unsigned char *)&eth_info->net_info.GatewayAddr.Data.Ipv4.s_addr;
  98                 net_info = &(eth_info->net_info);
  99         } else {
 100                 debug_print("Error!!! Invalid profile type\n");
 101                 return ;
 102         }
 103
 104         debug_print("Profile Name = [%s]\n", ProfInfo->ProfileName);
 105
 106         if (ProfInfo->ProfileState == NET_STATE_TYPE_IDLE)
 107                 debug_print("Profile State = [idle]\n");
 108         else if (ProfInfo->ProfileState == NET_STATE_TYPE_FAILURE)
 109                 debug_print("Profile State = [failure]\n");
 110         else if (ProfInfo->ProfileState == NET_STATE_TYPE_ASSOCIATION)
 111                 debug_print("Profile State = [association]\n");
 112         else if (ProfInfo->ProfileState == NET_STATE_TYPE_CONFIGURATION)
 113                 debug_print("Profile State = [configuration]\n");
 114         else if (ProfInfo->ProfileState == NET_STATE_TYPE_READY)
 115                 debug_print("Profile State = [ready]\n");
 116         else if (ProfInfo->ProfileState == NET_STATE_TYPE_ONLINE)
 117                 debug_print("Profile State = [online]\n");
 118         else if (ProfInfo->ProfileState == NET_STATE_TYPE_DISCONNECT)
 119                 debug_print("Profile State = [disconnect]\n");
 120         else
 121                 debug_print("Profile State = [unknown]\n");
 122
 123         if (ProfInfo->profile_type == NET_DEVICE_WIFI) {
 124                 debug_print("Profile Type = [wifi]\n");
 125                 debug_print("Profile ESSID = [%s]\n", wlan_info->essid);
 126                 debug_print("Profile BSSID = [%s]\n", wlan_info->bssid);
 127
 128                 if (print_type == PROFILE_PARTIAL_INFO ||
 129                     print_type == PROFILE_FULL_INFO) {
 130                         debug_print("Profile Strength = [%d]\n", (int)wlan_info->Strength);
 131                         debug_print("Profile Frequency = [%d]\n", (int)wlan_info->frequency);
 132                         debug_print("Profile Max Rate = [%d]\n", (int)wlan_info->max_rate);
 133                         debug_print("Profile Passphrase Required = [%d]\n",
 134                                         (int)wlan_info->PassphraseRequired);
 135
 136                         if (wlan_info->wlan_mode == NETPM_WLAN_CONNMODE_INFRA)
 137                                 debug_print("Profile Wlan mode = [NETPM_WLAN_CONNMODE_INFRA]\n");
 138                         else if (wlan_info->wlan_mode == NETPM_WLAN_CONNMODE_ADHOC)
 139                                 debug_print("Profile Wlan mode = [NETPM_WLAN_CONNMODE_ADHOC]\n");
 140                         else
 141                                 debug_print("Profile Wlan mode = [NETPM_WLAN_CONNMODE_AUTO]\n");
 142
 143                         debug_print("Profile Security mode = [%d]\n",
 144                                         (int)wlan_info->security_info.sec_mode);
 145                         debug_print("Profile Encryption mode = [%d]\n",
 146                                         (int)wlan_info->security_info.enc_mode);
 147                         debug_print("Profile Security key = [%s]\n",
 148                                         wlan_info->security_info.authentication.psk.pskKey);
 149                         debug_print("Profile WPS support = [%d]\n",
 150                                         (int)wlan_info->security_info.wps_support);
 151                 }
 152         } else if (ProfInfo->profile_type == NET_DEVICE_CELLULAR) {
 153                 debug_print("Profile Type = [pdp]\n");
 154
 155                 if (print_type == PROFILE_PARTIAL_INFO ||
 156                     print_type == PROFILE_FULL_INFO) {
 157
 158                         if (pdp_info->ProtocolType == NET_PDP_TYPE_GPRS)
 159                                 debug_print("Profile Protocol Type = [GPRS]\n");
 160                         else if (pdp_info->ProtocolType == NET_PDP_TYPE_EDGE)
 161                                 debug_print("Profile Protocol Type = [EDGE]\n");
 162                         else if (pdp_info->ProtocolType == NET_PDP_TYPE_UMTS)
 163                                 debug_print("Profile Protocol Type = [UMTS]\n");
 164                         else
 165                                 debug_print("Profile Protocol Type = [NONE]\n");
 166
 167                         if (pdp_info->ServiceType == NET_SERVICE_INTERNET)
 168                                 debug_print("Profile Service Type = [Internet]\n");
 169                         else if (pdp_info->ServiceType == NET_SERVICE_MMS)
 170                                 debug_print("Profile Service Type = [MMS]\n");
 171                         else if (pdp_info->ServiceType == NET_SERVICE_WAP)
 172                                 debug_print("Profile Service Type = [WAP]\n");
 173                         else if (pdp_info->ServiceType == NET_SERVICE_PREPAID_INTERNET)
 174                                 debug_print("Profile Service Type = [Prepaid Internet]\n");
 175                         else if (pdp_info->ServiceType == NET_SERVICE_PREPAID_MMS)
 176                                 debug_print("Profile Service Type = [Prepaid MMS]\n");
 177                         else
 178                                 debug_print("Profile Service Type = [Unknown]\n");
 179
 180                         debug_print("Profile APN = [%s]\n", pdp_info->Apn);
 181
 182                         if (pdp_info->AuthInfo.AuthType == NET_PDP_AUTH_PAP)
 183                                 debug_print("Profile Auth Type = [PAP]\n");
 184                         else if (pdp_info->AuthInfo.AuthType == NET_PDP_AUTH_CHAP)
 185                                 debug_print("Profile Auth Type = [CHAP]\n");
 186                         else
 187                                 debug_print("Profile Auth Type = [NONE]\n");
 188
 189                         debug_print("Profile Auth UserName = [%s]\n", pdp_info->AuthInfo.UserName);
 190                         debug_print("Profile Auth Password = [%s]\n", pdp_info->AuthInfo.Password);
 191
 192                         debug_print("Profile Home URL = [%s]\n", pdp_info->HomeURL);
 193                         debug_print("Profile MCC = [%s]\n", pdp_info->Mcc);
 194                         debug_print("Profile MNC = [%s]\n", pdp_info->Mnc);
 195                         debug_print("Profile Roaming = [%d]\n", (int)pdp_info->Roaming);
 196                         debug_print("Profile Setup Required = [%d]\n",
 197                                         (int)pdp_info->SetupRequired);
 198                 }
 199         } else if (ProfInfo->profile_type == NET_DEVICE_ETHERNET) {
 200                 debug_print("Profile Type = [ethernet]\n");
 201         }
 202
 203         if (print_type == PROFILE_FULL_INFO) {
 204                 unsigned char *dns = (unsigned char *)&net_info->DnsAddr[di].Data.Ipv4.s_addr;
 205
 206                 debug_print("Profile Favourite = [%d]\n", (int)ProfInfo->Favourite);
 207                 debug_print("Profile Device Name = [%s]\n", net_info->DevName);
 208                 debug_print("Profile DNS Count = [%d]\n", net_info->DnsCount);
 209
 210                 for (di = 0;di < net_info->DnsCount;di++)
 211                         debug_print("Profile DNS Address %d = [%d.%d.%d.%d]\n",
 212                                         di+1, dns[0], dns[1], dns[2], dns[3]);
 213
 214                 if (net_info->IpConfigType == NET_IP_CONFIG_TYPE_DYNAMIC)
 215                         debug_print("Profile IPv4 Method = [NET_IP_CONFIG_TYPE_DYNAMIC]\n");
 216                 else if (net_info->IpConfigType == NET_IP_CONFIG_TYPE_STATIC)
 217                         debug_print("Profile IPv4 Method = [NET_IP_CONFIG_TYPE_STATIC]\n");
 218                 else if (net_info->IpConfigType == NET_IP_CONFIG_TYPE_FIXED)
 219                         debug_print("Profile IPv4 Method = [NET_IP_CONFIG_TYPE_FIXED]\n");
 220                 else if (net_info->IpConfigType == NET_IP_CONFIG_TYPE_OFF)
 221                         debug_print("Profile IPv4 Method = [NET_IP_CONFIG_TYPE_OFF]\n");
 222                 else
 223                         debug_print("Profile IPv4 Method = [UNKNOWN]\n");
 224
 225                 debug_print("Profile IP Address = [%d.%d.%d.%d]\n",
 226                                 ipaddr[0], ipaddr[1], ipaddr[2], ipaddr[3]);
 227                 debug_print("Profile Netmask = [%d.%d.%d.%d]\n",
 228                                 netmaskaddr[0], netmaskaddr[1], netmaskaddr[2], netmaskaddr[3]);
 229                 debug_print("Profile Gateway = [%d.%d.%d.%d]\n",
 230                                 gwaddr[0], gwaddr[1], gwaddr[2], gwaddr[3]);
 231
 232                 if (net_info->ProxyMethod == NET_PROXY_TYPE_DIRECT)
 233                         debug_print("Proxy Method = [direct]\n");
 234                 else if (net_info->ProxyMethod == NET_PROXY_TYPE_AUTO)
 235                         debug_print("Proxy Method = [auto]\n");
 236                 else if (net_info->ProxyMethod == NET_PROXY_TYPE_MANUAL)
 237                         debug_print("Proxy Method = [manual]\n");
 238                 else
 239                         debug_print("Proxy Method = [unknown]\n");
 240
 241                 debug_print("Profile Proxy = [%s]\n", net_info->ProxyAddr);
 242                 debug_print("Profile MAC = [%s]\n", net_info->MacAddr);
 243         }
 244 }
 245
 246 static void __print_profile_list(int num_of_profile,
 247                 net_profile_info_t* profile_table, profile_print_type_t print_type)
 248 {
 249         debug_print("num_of_profile [%d], Profiles [%p]\n",
 250                         num_of_profile, profile_table);
 251
 252         if (num_of_profile > 0 && profile_table != NULL) {
 253                 int ci = 0;
 254                 for (ci = 0;ci < num_of_profile;ci++)
 255                         __network_print_profile(profile_table + ci, print_type);
 256         }
 257 }
 258
 259 static void __network_evt_cb (net_event_info_t*  event_cb, void* user_data)
 260 {
 261         net_profile_info_t *prof_info = NULL;
 262
 263         debug_print("==CM Event callback==\n");
 264
 265         switch (event_cb->Event)        {
 266         case NET_EVENT_WIFI_SCAN_IND:
 267                 if (event_cb->Error != NET_ERR_NONE) {
 268                         debug_print("Got NET_EVENT_WIFI_SCAN_IND. Scan failed!, Error [%d]\n",
 269                                         event_cb->Error);
 270                         break;
 271                 }
 272
 273                 debug_print("Got NET_EVENT_WIFI_SCAN_IND\n");
 274                 break;
 275
 276         case NET_EVENT_WIFI_SCAN_RSP:
 277                 if (event_cb->Error != NET_ERR_NONE) {
 278                         debug_print("Got NET_EVENT_WIFI_SCAN_RSP. Scan failed!, Error [%d]\n",
 279                                         event_cb->Error);
 280                         break;
 281                 }
 282
 283                 debug_print("Got NET_EVENT_WIFI_SCAN_RSP\n");
 284
 285                 int num_of_profile = 0;
 286                 int Error;
 287                 net_profile_info_t* Profiles = NULL;
 288
 289                 Error = net_get_profile_list(NET_DEVICE_WIFI, &Profiles, &num_of_profile);
 290                 if (Error != NET_ERR_NONE) {
 291                         debug_print("Error!!! failed to get service(profile) list. Error [%d]\n",
 292                                         Error);
 293                 } else {
 294                         debug_print("network_dbus_get_scan_result() successfull\n");
 295                         debug_print("........................Scan Table.......................\n");
 296                         __print_profile_list(num_of_profile, Profiles, PROFILE_BASIC_INFO);
 297                         debug_print(".........................................................\n");
 298                 }
 299
 300                 MAIN_MEMFREE(Profiles);
 301
 302                 gettimeofday(&timevar, NULL);
 303                 async_time = Convert_time2double(timevar);
 304                 debug_print("Async Resp total time taken = [%f]\n", async_time - finish_time);
 305
 306                 break;
 307
 308         case NET_EVENT_IP_CHANGE_IND:
 309                 debug_print("Got IP Change Indication.\n");
 310                 break;
 311
 312         case NET_EVENT_OPEN_IND:
 313         case NET_EVENT_OPEN_RSP:
 314                 if (event_cb->Event == NET_EVENT_OPEN_RSP)
 315                         debug_print("Got Open RSP\n");
 316                 else
 317                         debug_print("Got Open Indication. Auto Joined\n");
 318
 319                 gettimeofday(&timevar, NULL);
 320                 async_time = Convert_time2double(timevar);
 321                 debug_print("Async Resp total time taken = [%f]\n", async_time - finish_time);
 322
 323                 debug_print("Received ACTIVATION response: %d \n", event_cb->Error);
 324
 325                 switch (event_cb->Error) {
 326                 case NET_ERR_NONE:
 327                         /* Successful PDP Activation */
 328                         if (event_cb->Datalength != sizeof(net_profile_info_t)) {
 329                                 debug_print("Activation succeeded, but can't get profile info\n");
 330                         } else {
 331                                 prof_info = (net_profile_info_t*)event_cb->Data;
 332                                 __network_print_profile(prof_info, PROFILE_FULL_INFO);
 333                         }
 334                         break;
 335                 case NET_ERR_TIME_OUT:
 336                         debug_print("Request time out!\n");
 337                         break;
 338                 case NET_ERR_IN_PROGRESS:
 339                         debug_print("Connction is in progress!\n");
 340                         break;
 341                 case NET_ERR_ACTIVE_CONNECTION_EXISTS:
 342                         /* Successful PDP Activation(share the existing connection) */
 343                         if (event_cb->Datalength != sizeof(net_profile_info_t)) {
 344                                 debug_print("Activation succeeded, but can't get profile info\n");
 345                         } else {
 346                                 prof_info = (net_profile_info_t*)event_cb->Data;
 347                                 __network_print_profile(prof_info, PROFILE_FULL_INFO);
 348                         }
 349                         break;
 350                 case NET_ERR_OPERATION_ABORTED:
 351                         debug_print("Connction is aborted!\n");
 352                         break;
 353                 case NET_ERR_UNKNOWN_METHOD:
 354                         debug_print("Service not found!\n");
 355                         break;
 356                 case NET_ERR_UNKNOWN:
 357                         debug_print("Activation Failed!\n");
 358                         break;
 359                 default:
 360                         debug_print("Unknown Error!\n");
 361                         break;
 362                 }
 363
 364                 break;
 365
 366         case NET_EVENT_CLOSE_RSP:
 367                 debug_print("Got Close RSP\n");
 368
 369                 gettimeofday(&timevar, NULL);
 370                 async_time = Convert_time2double(timevar);
 371                 debug_print("Async Resp total time taken = [%f]\n", async_time - finish_time);
 372
 373                 switch (event_cb->Error) {
 374                 case NET_ERR_NONE:
 375                         /* Successful PDP Deactivation */
 376                         debug_print("Deactivation succeeded!\n");
 377                         break;
 378                 case NET_ERR_TIME_OUT:
 379                         debug_print("Request time out!\n");
 380                         break;
 381                 case NET_ERR_IN_PROGRESS:
 382                         debug_print("Disconncting is in progress!\n");
 383                         break;
 384                 case NET_ERR_OPERATION_ABORTED:
 385                         debug_print("Disconnction is aborted!\n");
 386                         break;
 387                 case NET_ERR_UNKNOWN_METHOD:
 388                         debug_print("Service not found!\n");
 389                         break;
 390                 case NET_ERR_UNKNOWN:
 391                         debug_print("Deactivation Failed!\n");
 392                         break;
 393                 default:
 394                         debug_print("Unknown Error!\n");
 395                         break;
 396                 }
 397
 398                 break;
 399
 400         case NET_EVENT_CLOSE_IND:
 401                 debug_print("Got Close IND\n");
 402                 break;
 403
 404         case NET_EVENT_WIFI_POWER_IND:
 405         case NET_EVENT_WIFI_POWER_RSP:
 406                 if (event_cb->Event == NET_EVENT_WIFI_POWER_RSP)
 407                         debug_print("Got Wi-Fi Power RSP\n");
 408                 else
 409                         debug_print("Got Wi-Fi Power IND\n");
 410
 411                 net_wifi_state_t *wifi_state = (net_wifi_state_t*)event_cb->Data;
 412
 413                 if (event_cb->Error == NET_ERR_NONE &&
 414                     event_cb->Datalength == sizeof(net_wifi_state_t)) {
 415                         if (*wifi_state == WIFI_ON)
 416                                 debug_print("Wi-Fi State : Power ON\n");
 417                         else if (*wifi_state == WIFI_OFF)
 418                                 debug_print("Wi-Fi State : Power OFF\n");
 419                         else
 420                                 debug_print("Wi-Fi State : Unknown\n");
 421                 } else
 422                         debug_print("Wi-Fi Power on/off request failed! Error [%d]\n",
 423                                         event_cb->Error);
 424
 425                 break;
 426
 427         case NET_EVENT_NET_STATE_IND:
 428                 debug_print("Got State changed IND\n");
 429                 net_state_type_t *profile_state = (net_state_type_t*)event_cb->Data;
 430
 431                 if (event_cb->Error == NET_ERR_NONE &&
 432                     event_cb->Datalength == sizeof(net_state_type_t)) {
 433                         switch (*profile_state) {
 434                         case NET_STATE_TYPE_IDLE:
 435                                 debug_print("Wi-Fi State : Idle, profile name : %s\n",
 436                                                 event_cb->ProfileName);
 437                                 break;
 438                         case NET_STATE_TYPE_FAILURE:
 439                                 debug_print("Wi-Fi State : Failure, profile name : %s\n",
 440                                                 event_cb->ProfileName);
 441                                 break;
 442                         case NET_STATE_TYPE_ASSOCIATION:
 443                                 debug_print("Wi-Fi State : Association, profile name : %s\n",
 444                                                 event_cb->ProfileName);
 445                                 break;
 446                         case NET_STATE_TYPE_CONFIGURATION:
 447                                 debug_print("Wi-Fi State : Configuration, profile name : %s\n",
 448                                                 event_cb->ProfileName);
 449                                 break;
 450                         case NET_STATE_TYPE_READY:
 451                                 debug_print("Wi-Fi State : Ready, profile name : %s\n",
 452                                                 event_cb->ProfileName);
 453                                 break;
 454                         case NET_STATE_TYPE_ONLINE:
 455                                 debug_print("Wi-Fi State : Online, profile name : %s\n",
 456                                                 event_cb->ProfileName);
 457                                 break;
 458                         case NET_STATE_TYPE_DISCONNECT:
 459                                 debug_print("Wi-Fi State : Disconnect, profile name : %s\n",
 460                                                 event_cb->ProfileName);
 461                                 break;
 462                         default :
 463                                 debug_print("Wi-Fi State : unknown\n");
 464                                 break;
 465                         }
 466                 }
 467                 break;
 468
 469         case NET_EVENT_WIFI_WPS_RSP:
 470                 debug_print("Got WPS Rsp\n");
 471                 break;
 472
 473         default :
 474                 debug_print("Error! Unknown Event\n\n");
 475                 break;
 476         }
 477
 478 }
 479
 480 int __network_modify_profile_info(net_profile_info_t *profile_info)
 481 {
 482         net_dev_info_t *net_info2 = &profile_info->ProfileInfo.Wlan.net_info;
 483         wlan_security_info_t *security_info2 =
 484                         &profile_info->ProfileInfo.Wlan.security_info;
 485         net_pdp_profile_info_t *pdp_info = &profile_info->ProfileInfo.Pdp;
 486         char input_str[100] = {0,};
 487         int ei = 0;
 488
 489         if (profile_info->profile_type == NET_DEVICE_WIFI) {
 490                 debug_print("\nInput Passphrase(Enter for skip) :\n");
 491
 492                 memset(input_str, '\0', 100);
 493                 read(0, input_str, 100);
 494
 495                 input_str[strlen(input_str) - 1] = '\0';
 496
 497                 if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r')
 498                         g_strlcpy(security_info2->authentication.psk.pskKey,
 499                                         input_str, NETPM_WLAN_MAX_PSK_PASSPHRASE_LEN + 1);
 500
 501                 debug_print("\nInput Proxy Type(1:direct, 2:auto, 3:manual - current:%d)"
 502                                 " - (Enter for skip) :\n", net_info2->ProxyMethod);
 503
 504                 memset(input_str, '\0', 100);
 505                 read(0, input_str, 100);
 506
 507                 input_str[strlen(input_str) - 1] = '\0';
 508
 509                 if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r') {
 510                         int proxyType = 0;
 511                         proxyType = atoi(input_str);
 512
 513                         if (proxyType == NET_PROXY_TYPE_DIRECT)
 514                                 net_info2->ProxyMethod = NET_PROXY_TYPE_DIRECT;
 515                         else if (proxyType == NET_PROXY_TYPE_AUTO)
 516                                 net_info2->ProxyMethod = NET_PROXY_TYPE_AUTO;
 517                         else if (proxyType == NET_PROXY_TYPE_MANUAL)
 518                                 net_info2->ProxyMethod = NET_PROXY_TYPE_MANUAL;
 519
 520                         if (net_info2->ProxyMethod == NET_PROXY_TYPE_AUTO ||
 521                             net_info2->ProxyMethod == NET_PROXY_TYPE_MANUAL) {
 522
 523                                 if (net_info2->ProxyMethod == NET_PROXY_TYPE_AUTO)
 524                                         debug_print("\nInput auto Proxy URL - "
 525                                                         "(Enter for DHCP/WPAD auto-discover) :\n");
 526                                 else
 527                                         debug_print("\nInput manual Proxy address - "
 528                                                         "(Enter for skip) :\n");
 529
 530                                 memset(input_str, '\0', 100);
 531                                 read(0, input_str, 100);
 532
 533                                 if (input_str[0] != '\0' &&
 534                                     *input_str != '\n' &&
 535                                     *input_str != '\r') {
 536                                         input_str[strlen(input_str)-1] = '\0';
 537                                         g_strlcpy(net_info2->ProxyAddr,
 538                                                         input_str, NET_PROXY_LEN_MAX + 1);
 539                                 } else {
 540                                         net_info2->ProxyAddr[0] = '\0';
 541                                 }
 542                         }
 543                 }
 544
 545                 debug_print("\nInput IPv4 Address Type dhcp/manual (Enter for skip) :\n");
 546
 547                 memset(input_str, '\0', 100);
 548                 read(0, input_str, 100);
 549
 550                 input_str[strlen(input_str) - 1] = '\0';
 551
 552                 if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r') {
 553                         if (strcmp(input_str, "dhcp") == 0) {
 554                                 net_info2->IpConfigType = NET_IP_CONFIG_TYPE_DYNAMIC;
 555                         } else if (strcmp(input_str, "manual") == 0) {
 556                                 net_info2->IpConfigType = NET_IP_CONFIG_TYPE_STATIC;
 557
 558                                 debug_print("\nInput IP Address (Enter for skip) :\n");
 559
 560                                 memset(input_str, '\0', 100);
 561                                 read(0, input_str, 100);
 562
 563                                 input_str[strlen(input_str) - 1] = '\0';
 564
 565                                 if ((input_str[0] != '\0' &&
 566                                      *input_str != '\n' &&
 567                                      *input_str != '\r') &&
 568                                     strlen(input_str) >= NETPM_IPV4_STR_LEN_MIN) {
 569                                         inet_aton(input_str, &(net_info2->IpAddr.Data.Ipv4));
 570                                 }
 571
 572                                 debug_print("\nInput Netmask (Enter for skip) :\n");
 573
 574                                 memset(input_str, '\0', 100);
 575                                 read(0, input_str, 100);
 576
 577                                 input_str[strlen(input_str) - 1] = '\0';
 578
 579                                 if ((input_str[0] != '\0' &&
 580                                      *input_str != '\n' &&
 581                                      *input_str != '\r') &&
 582                                     strlen(input_str) >= NETPM_IPV4_STR_LEN_MIN) {
 583                                         inet_aton(input_str, &(net_info2->SubnetMask.Data.Ipv4));
 584                                 }
 585
 586                                 debug_print("\nInput Gateway (Enter for skip) :\n");
 587
 588                                 memset(input_str, '\0', 100);
 589                                 read(0, input_str, 100);
 590
 591                                 input_str[strlen(input_str)-1] = '\0';
 592
 593                                 if ((input_str[0] != '\0' &&
 594                                      *input_str != '\n' &&
 595                                      *input_str != '\r') &&
 596                                     strlen(input_str) >= NETPM_IPV4_STR_LEN_MIN) {
 597                                         inet_aton(input_str, &(net_info2->GatewayAddr.Data.Ipv4));
 598                                 }
 599                         }
 600                 }
 601
 602                 if (net_info2->IpConfigType == NET_IP_CONFIG_TYPE_STATIC) {
 603                         for (ei = 0;ei < NET_DNS_ADDR_MAX;ei++) {
 604                                 debug_print("\nInput DNS %d Address(Enter for skip) :\n", ei);
 605
 606                                 memset(input_str, '\0', 100);
 607                                 read(0, input_str, 100);
 608
 609                                 input_str[strlen(input_str)-1] = '\0';
 610
 611                                 if (input_str[0] != '\0' &&
 612                                     *input_str != '\n' &&
 613                                     *input_str != '\r') {
 614                                         inet_aton(input_str, &(net_info2->DnsAddr[ei].Data.Ipv4));
 615                                         net_info2->DnsCount = ei+1;
 616                                 } else {
 617                                         return FALSE;
 618                                 }
 619                         }
 620                 }
 621         } else if (profile_info->profile_type == NET_DEVICE_CELLULAR) {
 622                 debug_print("\nInput Apn(current:%s) - (Enter for skip) :\n", pdp_info->Apn);
 623
 624                 memset(input_str, '\0', 100);
 625                 read(0, input_str, 100);
 626
 627                 input_str[strlen(input_str)-1] = '\0';
 628
 629                 if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r')
 630                         g_strlcpy(pdp_info->Apn, input_str, NET_PDP_APN_LEN_MAX+1);
 631
 632                 debug_print("\nInput Proxy(current:%s) - (Enter for skip) :\n",
 633                                 pdp_info->net_info.ProxyAddr);
 634
 635                 memset(input_str, '\0', 100);
 636                 read(0, input_str, 100);
 637
 638                 input_str[strlen(input_str)-1] = '\0';
 639
 640                 if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r')
 641                         g_strlcpy(pdp_info->net_info.ProxyAddr, input_str, NET_PROXY_LEN_MAX+1);
 642
 643                 debug_print("\nInput HomeURL(current:%s) - (Enter for skip) :\n",
 644                                 pdp_info->HomeURL);
 645
 646                 memset(input_str, '\0', 100);
 647                 read(0, input_str, 100);
 648
 649                 input_str[strlen(input_str)-1] = '\0';
 650
 651                 if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r')
 652                         g_strlcpy(pdp_info->HomeURL, input_str, NET_HOME_URL_LEN_MAX+1);
 653
 654                 debug_print("\nInput AuthType(0:None, 1:PAP, 2:CHAP - current:%d)"
 655                                 " - (Enter for skip) :\n", pdp_info->AuthInfo.AuthType);
 656
 657                 memset(input_str, '\0', 100);
 658                 read(0, input_str, 100);
 659
 660                 if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r') {
 661                         int typeValue = 0;
 662                         typeValue = atoi(input_str);
 663
 664                         if(typeValue == NET_PDP_AUTH_PAP)
 665                                 pdp_info->AuthInfo.AuthType = NET_PDP_AUTH_PAP;
 666                         else if(typeValue == NET_PDP_AUTH_CHAP)
 667                                 pdp_info->AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
 668                         else
 669                                 pdp_info->AuthInfo.AuthType = NET_PDP_AUTH_NONE;
 670                 }
 671
 672                 if (pdp_info->AuthInfo.AuthType == NET_PDP_AUTH_PAP ||
 673                     pdp_info->AuthInfo.AuthType == NET_PDP_AUTH_CHAP) {
 674                         debug_print("\nInput AuthId(current:%s) - (Enter for skip) :\n",
 675                                         pdp_info->AuthInfo.UserName);
 676
 677                         memset(input_str, '\0', 100);
 678                         read(0, input_str, 100);
 679
 680                         input_str[strlen(input_str)-1] = '\0';
 681
 682                         if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r')
 683                                 g_strlcpy(pdp_info->AuthInfo.UserName,
 684                                                 input_str, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
 685
 686                         debug_print("\nInput AuthPwd(current:%s) - (Enter for skip) :\n",
 687                                         pdp_info->AuthInfo.Password);
 688
 689                         memset(input_str, '\0', 100);
 690                         read(0, input_str, 100);
 691
 692                         input_str[strlen(input_str)-1] = '\0';
 693
 694                         if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r')
 695                                 g_strlcpy(pdp_info->AuthInfo.Password,
 696                                                 input_str, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
 697                 }
 698         }
 699         return TRUE;
 700 }
 701
 702 int __network_add_profile_info(net_profile_info_t *profile_info)
 703 {
 704         net_pdp_profile_info_t *pdp_info = &profile_info->ProfileInfo.Pdp;
 705         char input_str[100] = {0,};
 706
 707         debug_print("\nInput Apn - (Enter for skip) :\n");
 708
 709         memset(input_str, '\0', 100);
 710         read(0, input_str, 100);
 711
 712         input_str[strlen(input_str)-1] = '\0';
 713
 714         if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r')
 715                 g_strlcpy(pdp_info->Apn, input_str, NET_PDP_APN_LEN_MAX+1);
 716         else
 717                 pdp_info->Apn[0] = '\0';
 718
 719         debug_print("\nInput Proxy - (Enter for skip) :\n");
 720
 721         memset(input_str, '\0', 100);
 722         read(0, input_str, 100);
 723
 724         input_str[strlen(input_str)-1] = '\0';
 725
 726         if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r')
 727                 g_strlcpy(pdp_info->net_info.ProxyAddr, input_str, NET_PROXY_LEN_MAX+1);
 728         else
 729                 pdp_info->net_info.ProxyAddr[0] = '\0';
 730
 731         debug_print("\nInput HomeURL - (Enter for skip) :\n");
 732
 733         memset(input_str, '\0', 100);
 734         read(0, input_str, 100);
 735
 736         input_str[strlen(input_str)-1] = '\0';
 737
 738         if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r')
 739                 g_strlcpy(pdp_info->HomeURL, input_str, NET_HOME_URL_LEN_MAX+1);
 740         else
 741                 pdp_info->HomeURL[0] = '\0';
 742
 743         debug_print("\nInput AuthType(0:NONE 1:PAP 2:CHAP) - (Enter for skip) :\n");
 744
 745         memset(input_str, '\0', 100);
 746         read(0, input_str, 100);
 747
 748         if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r') {
 749                 int typeValue = 0;
 750                 typeValue = atoi(input_str);
 751
 752                 if (typeValue == NET_PDP_AUTH_PAP)
 753                         pdp_info->AuthInfo.AuthType = NET_PDP_AUTH_PAP;
 754                 else if (typeValue == NET_PDP_AUTH_CHAP)
 755                         pdp_info->AuthInfo.AuthType = NET_PDP_AUTH_CHAP;
 756                 else
 757                         pdp_info->AuthInfo.AuthType = NET_PDP_AUTH_NONE;
 758         } else {
 759                 pdp_info->AuthInfo.AuthType = NET_PDP_AUTH_NONE;
 760         }
 761
 762         if (pdp_info->AuthInfo.AuthType == NET_PDP_AUTH_PAP ||
 763             pdp_info->AuthInfo.AuthType == NET_PDP_AUTH_CHAP) {
 764                 debug_print("\nInput AuthId - (Enter for skip) :\n");
 765
 766                 memset(input_str, '\0', 100);
 767                 read(0, input_str, 100);
 768
 769                 input_str[strlen(input_str)-1] = '\0';
 770
 771                 if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r')
 772                         g_strlcpy(pdp_info->AuthInfo.UserName,
 773                                         input_str, NET_PDP_AUTH_USERNAME_LEN_MAX+1);
 774                 else
 775                         pdp_info->AuthInfo.UserName[0] = '\0';
 776
 777                 debug_print("\nInput AuthPwd - (Enter for skip) :\n");
 778
 779                 memset(input_str, '\0', 100);
 780                 read(0, input_str, 100);
 781
 782                 input_str[strlen(input_str)-1] = '\0';
 783
 784                 if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r')
 785                         g_strlcpy(pdp_info->AuthInfo.Password,
 786                                         input_str, NET_PDP_AUTH_PASSWORD_LEN_MAX+1);
 787                 else
 788                         pdp_info->AuthInfo.Password[0] = '\0';
 789         }
 790
 791         return TRUE;
 792 }
 793
 794 static gpointer network_main_gthread(gpointer data)
 795 {
 796         char ProfileName[NET_PROFILE_NAME_LEN_MAX+1] = {0,};
 797         int input_int = 0;
 798         char input_str[100] = {0,};
 799         int net_error = 0;
 800         net_profile_info_t profile_info;
 801
 802         if (net_register_client ((net_event_cb_t) __network_evt_cb, NULL) != NET_ERR_NONE) {
 803                 debug_print("Error!! net_register_client() failed.\n");
 804                 return NULL;
 805         }
 806
 807         debug_print( "net_register_client() successfull\n");
 808
 809         while (TRUE) {
 810                 fd_set rfds;
 811
 812                 int retval;
 813                 FD_ZERO(&rfds);
 814                 FD_SET(0, &rfds);
 815
 816                 retval = select((0+1), &rfds, NULL, NULL, NULL);
 817
 818                 if (retval <= 0)
 819                         continue;
 820
 821                 if (!FD_ISSET(0, &rfds))
 822                         continue;
 823
 824                 debug_print("Event received from stdin \n");
 825                 char user_input[100];
 826
 827                 memset(user_input, '\0', 100);
 828                 read(0, user_input, 100);
 829
 830                 if (user_input[0] == '9')
 831                         exit(1);
 832
 833                 if (*user_input == '\n' || *user_input == '\r') {
 834                         debug_print("\nDatanetworking Test .......\n\n");
 835                         debug_print("Options..\n");
 836                         debug_print("0  - WLAN Power On request\n");
 837                         debug_print("1  - WLAN Power Off request\n");
 838                         debug_print("2  - WLAN Start scan request\n");
 839                         debug_print("3  - WLAN Set BG Scan Mode\n");
 840                         debug_print("4  - Open Connection with service type\n");
 841                         debug_print("5  - Open Connection with profile name\n");
 842                         debug_print("6  - Close Connection\n");
 843                         debug_print("7  - Get WiFi State\n");
 844                         debug_print("a  - Check whether connected?\n");
 845                         debug_print("b  - Get Network Status\n");
 846                         debug_print("c  - Get Active(default) profile information\n");
 847                         debug_print("d  - Get Profile list\n");
 848                         debug_print("e  - Get Profile info\n");
 849                         debug_print("f  - Modify Profile info\n");
 850                         debug_print("g  - Delete Profile(PDP:delete, WiFi:forgot) \n");
 851                         debug_print("h  - Add Profile(PDP only) \n");
 852                         debug_print("i  - Connect to Specific SSID\n");
 853                         debug_print("k  - Enroll WPS PBC \n");
 854                         debug_print("l  - Connect with EAP\n");
 855                         debug_print("z  - Exit \n");
 856
 857                         debug_print("ENTER      - Show options menu.......\n");
 858                 }
 859
 860                 switch (user_input[0]) {
 861                 case '0':
 862                         gettimeofday(&timevar, NULL);
 863                         start_time = Convert_time2double(timevar);
 864
 865                         if (net_wifi_power_on() != NET_ERR_NONE) {
 866                                 debug_print("Error!! net_wifi_power_on() failed.\n");
 867                                 break;
 868                         }
 869
 870                         gettimeofday(&timevar, NULL);
 871                         finish_time = Convert_time2double(timevar);
 872                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
 873
 874                         debug_print("net_wifi_power_on() success\n");
 875                         break;
 876
 877                 case '1':
 878                         gettimeofday(&timevar, NULL);
 879                         start_time = Convert_time2double(timevar);
 880
 881                         if (net_wifi_power_off() != NET_ERR_NONE ) {
 882                                 debug_print("Error!! net_wifi_power_off() failed.\n");
 883                                 break;
 884                         }
 885
 886                         gettimeofday(&timevar, NULL);
 887                         finish_time = Convert_time2double(timevar);
 888                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
 889
 890                         debug_print("net_wifi_power_off() success\n");
 891                         break;
 892
 893                 case '2':
 894                         gettimeofday(&timevar, NULL);
 895                         start_time = Convert_time2double(timevar);
 896
 897                         if (net_scan_wifi() != NET_ERR_NONE ) {
 898                                 debug_print("Error!! net_scan_wifi() failed.\n");
 899                                 break;
 900                         }
 901
 902                         gettimeofday(&timevar, NULL);
 903                         finish_time = Convert_time2double(timevar);
 904                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
 905
 906                         debug_print("net_scan_wifi() success\n");
 907                         break;
 908
 909                 case '3':
 910                         debug_print("Enter BG Scan Mode(0:default, 1:periodic, 2:exponential):");
 911                         scanf("%d", &input_int);
 912
 913                         gettimeofday(&timevar, NULL);
 914                         start_time = Convert_time2double(timevar);
 915
 916                         if (net_wifi_set_background_scan_mode(input_int) != NET_ERR_NONE) {
 917                                 debug_print(
 918                                         "Error!! network_wifi_set_scan_interval() failed.\n");
 919                                 break;
 920                         }
 921
 922                         gettimeofday(&timevar, NULL);
 923                         finish_time = Convert_time2double(timevar);
 924                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
 925
 926                         debug_print("network_wifi_set_background_scan_mode() success\n");
 927                         break;
 928
 929                 case '4':
 930                         debug_print( "Enter Service Type(1:Internet, 2:MMS, 3:WAP): \n");
 931                         scanf("%d", &input_int);
 932
 933                         net_service_type_t service_type = NET_SERVICE_UNKNOWN;
 934
 935                         gettimeofday(&timevar, NULL);
 936                         start_time = Convert_time2double(timevar);
 937
 938                         switch (input_int) {
 939                         case 1:
 940                                 service_type = NET_SERVICE_INTERNET;
 941                                 break;
 942                         case 2:
 943                                 service_type = NET_SERVICE_MMS;
 944                                 break;
 945                         case 3:
 946                                 service_type = NET_SERVICE_WAP;
 947                                 break;
 948                         }
 949
 950                         if (service_type != NET_SERVICE_UNKNOWN) {
 951                                 net_error = net_open_connection_with_preference(service_type);
 952                                 if (net_error != NET_ERR_NONE) {
 953                                         debug_print(
 954                                           "Error!! net_open_connection_with_profile() failed.\n");
 955                                         break;
 956                                 }
 957                         }
 958
 959                         gettimeofday(&timevar, NULL);
 960                         finish_time = Convert_time2double(timevar);
 961                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
 962
 963                         debug_print("net_open_connection_with_profile() success\n");
 964                         break;
 965
 966                 case '5':
 967                         debug_print( "Enter Profile Name: \n");
 968                         scanf("%s", ProfileName);
 969
 970                         gettimeofday(&timevar, NULL);
 971                         start_time = Convert_time2double(timevar);
 972
 973                         if (net_open_connection_with_profile(ProfileName) != NET_ERR_NONE) {
 974                                 debug_print(
 975                                         "Error!! net_open_connection_with_profile() failed.\n");
 976                                 break;
 977                         }
 978
 979                         gettimeofday(&timevar, NULL);
 980                         finish_time = Convert_time2double(timevar);
 981                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
 982
 983                         debug_print("net_open_connection_with_profile() success\n");
 984                         break;
 985
 986                 case '6':
 987                         debug_print( "Enter Profile Name: \n");
 988                         scanf("%s", ProfileName);
 989
 990                         gettimeofday(&timevar, NULL);
 991                         start_time = Convert_time2double(timevar);
 992
 993                         if (net_close_connection(ProfileName) != NET_ERR_NONE) {
 994                                 debug_print(
 995                                         "Error!! net_close_connection() failed.\n");
 996                                 break;
 997                         }
 998
 999                         gettimeofday(&timevar, NULL);
1000                         finish_time = Convert_time2double(timevar);
1001                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1002
1003                         debug_print("net_close_connection() success\n");
1004                         break;
1005
1006                 case '7':
1007                         gettimeofday(&timevar, NULL);
1008                         start_time = Convert_time2double(timevar);
1009
1010                         net_wifi_state_t wlanstate = 0;
1011                         net_profile_name_t profile_name;
1012
1013                         if (net_get_wifi_state(&wlanstate, &profile_name) != NET_ERR_NONE) {
1014                                 debug_print("Error!! net_get_wifi_state() failed.\n");
1015                                 break;
1016                         }
1017
1018                         gettimeofday(&timevar, NULL);
1019                         finish_time = Convert_time2double(timevar);
1020                         debug_print("net_get_wifi_state() success. wlanstate [%d]\n", wlanstate);
1021                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1022
1023                         switch (wlanstate) {
1024                         case WIFI_OFF:
1025                                 debug_print("wlanstate : WIFI_OFF\n");
1026                                 break;
1027                         case WIFI_ON:
1028                                 debug_print("wlanstate : WIFI_ON\n");
1029                                 break;
1030                         case WIFI_CONNECTING:
1031                                 debug_print("wlanstate : WIFI_CONNECTING, profile name : %s\n",
1032                                                 profile_name.ProfileName);
1033                                 break;
1034                         case WIFI_CONNECTED:
1035                                 debug_print("wlanstate : WIFI_CONNECTED, profile name : %s\n",
1036                                                 profile_name.ProfileName);
1037                                 break;
1038                         case WIFI_DISCONNECTING:
1039                                 debug_print("wlanstate : WIFI_DISCONNECTING, profile name : %s\n",
1040                                                 profile_name.ProfileName);
1041                                 break;
1042                         default :
1043                                 debug_print("wlanstate : Unknown\n");
1044                         }
1045                         break;
1046
1047                 case 'a':
1048                         gettimeofday(&timevar, NULL);
1049                         start_time = Convert_time2double(timevar);
1050
1051                         int flag = FALSE;
1052
1053                         flag = net_is_connected();
1054                         debug_print("[%s]\n", (flag == TRUE)? "connected":"not connected");
1055
1056                         gettimeofday(&timevar, NULL);
1057                         finish_time = Convert_time2double(timevar);
1058                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1059
1060                         break;
1061
1062                 case 'b':
1063                         debug_print("Enter network type (wifi/pdp): \n");
1064                         scanf("%s", input_str);
1065
1066                         net_device_t device_type = NET_DEVICE_UNKNOWN;
1067                         net_cm_network_status_t NetworkStatus;
1068
1069                         if (strcmp(input_str, "wifi") == 0)
1070                                 device_type = NET_DEVICE_WIFI;
1071                         else
1072                                 device_type = NET_DEVICE_CELLULAR;
1073
1074                         gettimeofday(&timevar, NULL);
1075                         start_time = Convert_time2double(timevar);
1076
1077                         if (net_get_network_status(device_type, &NetworkStatus) != NET_ERR_NONE) {
1078                                 debug_print("Error!!! net_get_network_status() failed\n");
1079                                 break;
1080                         }
1081
1082                         debug_print("[%s]\n", (NET_STATUS_AVAILABLE == NetworkStatus) ?
1083                                         "NET_STATUS_AVAILABLE":"NET_STATUS_UNAVAILABLE");
1084
1085                         gettimeofday(&timevar, NULL);
1086                         finish_time = Convert_time2double(timevar);
1087                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1088
1089                         break;
1090
1091                 case 'c':
1092                         debug_print("Enter info Type(1:Full, 2:ip, 3:netmask, 4:gateway,"
1093                                                    " 5:DNS, 6:ESSID, 7:Proxy):\n");
1094                         scanf("%d", &input_int);
1095
1096                         memset(&profile_info, 0, sizeof(net_profile_info_t));
1097
1098                         net_addr_t ip_address;
1099                         net_essid_t essid;
1100                         net_proxy_t proxy;
1101
1102                         gettimeofday(&timevar, NULL);
1103                         start_time = Convert_time2double(timevar);
1104
1105                         switch (input_int) {
1106                         case 1:
1107                                 if (net_get_active_net_info(&profile_info) != NET_ERR_NONE)
1108                                         debug_print("Error!!! net_get_active_net_info() failed\n");
1109                                 else
1110                                         __network_print_profile(&profile_info, PROFILE_FULL_INFO);
1111                                 break;
1112                         case 2:
1113                                 if (net_get_active_ipaddress(&ip_address) != NET_ERR_NONE)
1114                                         debug_print("Error!!! net_get_active_ipaddress() failed\n");
1115                                 else
1116                                         __network_print_ipaddress(&ip_address);
1117                                 break;
1118                         case 3:
1119                                 if (net_get_active_netmask(&ip_address) != NET_ERR_NONE)
1120                                         debug_print("Error!!! net_get_active_netmask() failed\n");
1121                                 else
1122                                         __network_print_ipaddress(&ip_address);
1123                                 break;
1124                         case 4:
1125                                 if (net_get_active_gateway(&ip_address) != NET_ERR_NONE)
1126                                         debug_print("Error!!! net_get_active_gateway() failed\n");
1127                                 else
1128                                         __network_print_ipaddress(&ip_address);
1129                                 break;
1130                         case 5:
1131                                 if (net_get_active_dns(&ip_address) != NET_ERR_NONE)
1132                                         debug_print("Error!!! net_get_active_dns() failed\n");
1133                                 else
1134                                         __network_print_ipaddress(&ip_address);
1135                                 break;
1136                         case 6:
1137                                 if (net_get_active_essid(&essid) != NET_ERR_NONE)
1138                                         debug_print("Error!!! net_get_active_essid() failed\n");
1139                                 else
1140                                         debug_print("Profile ESSID = [%s]\n", essid.essid);
1141                                 break;
1142                         case 7:
1143                                 if (net_get_active_proxy(&proxy) != NET_ERR_NONE)
1144                                         debug_print("Error!!! net_get_active_proxy() failed\n");
1145                                 else
1146                                         debug_print("Profile Proxy = [%s]\n", proxy.proxy_addr);
1147                                 break;
1148                         }
1149
1150                         gettimeofday(&timevar, NULL);
1151                         finish_time = Convert_time2double(timevar);
1152                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1153                         break;
1154
1155                 case 'd':
1156                         debug_print("\nInput profile type - 1:wifi, 2:mobile 3:ethernet(Enter for skip):\n");
1157                         memset(input_str, 0, 100);
1158                         read(0, input_str, 100);
1159
1160                         net_device_t deviceType = NET_DEVICE_UNKNOWN;
1161                         int profListCount = 0;
1162                         net_profile_info_t *profList;
1163
1164                         gettimeofday(&timevar, NULL);
1165                         start_time = Convert_time2double(timevar);
1166
1167                         if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r') {
1168                                 input_str[strlen(input_str)-1] = '\0';
1169
1170                                 if (strcmp(input_str, "1") == 0)
1171                                         deviceType = NET_DEVICE_WIFI;
1172                                 else if (strcmp(input_str, "2") == 0)
1173                                         deviceType = NET_DEVICE_CELLULAR;
1174                                 else if (strcmp(input_str, "3") == 0)
1175                                         deviceType = NET_DEVICE_ETHERNET;
1176
1177                                 net_error = net_get_profile_list(deviceType,
1178                                                 &profList, &profListCount);
1179
1180                                 if (net_error != NET_ERR_NONE) {
1181                                         debug_print("Error!!! net_get_profile_list() failed\n");
1182                                         break;
1183                                 }
1184
1185                                 __print_profile_list(profListCount, profList, PROFILE_BASIC_INFO);
1186                                 MAIN_MEMFREE(profList);
1187                         }
1188
1189                         gettimeofday(&timevar, NULL);
1190                         finish_time = Convert_time2double(timevar);
1191                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1192
1193                         break;
1194
1195                 case 'e':
1196                         debug_print("\nInput profile Name((Enter for skip) :\n");
1197                         memset(ProfileName, 0, NET_PROFILE_NAME_LEN_MAX);
1198                         read(0, ProfileName, NET_PROFILE_NAME_LEN_MAX);
1199
1200                         if (ProfileName[0] == '\0' || *ProfileName == '\n' || *ProfileName == '\r')
1201                                 debug_print("\nCanceled!\n\n");
1202
1203                         ProfileName[strlen(ProfileName)-1] = '\0';
1204
1205                         gettimeofday(&timevar, NULL);
1206                         start_time = Convert_time2double(timevar);
1207
1208                         if (net_get_profile_info(ProfileName, &profile_info) != NET_ERR_NONE) {
1209                                 debug_print("Error!!! net_get_profile_info() failed\n");
1210                                 break;
1211                         }
1212
1213                         __network_print_profile(&profile_info, PROFILE_FULL_INFO);
1214
1215                         gettimeofday(&timevar, NULL);
1216                         finish_time = Convert_time2double(timevar);
1217                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1218
1219                         break;
1220
1221                 case 'f':
1222                         debug_print("\nInput profile Name(Enter for skip) :\n");
1223                         memset(ProfileName, '\0', NET_PROFILE_NAME_LEN_MAX);
1224                         read(0, ProfileName, NET_PROFILE_NAME_LEN_MAX);
1225
1226                         if (ProfileName[0] != '\0' &&
1227                             *ProfileName != '\n' &&
1228                             *ProfileName != '\r') {
1229                                 ProfileName[strlen(ProfileName) - 1] = '\0';
1230
1231                                 net_error = net_get_profile_info(ProfileName, &profile_info);
1232                                 if (net_error != NET_ERR_NONE) {
1233                                         debug_print("Error!!! net_get_profile_info() failed\n");
1234                                         break;
1235                                 }
1236                         } else {
1237                                 debug_print("\nCanceled!\n\n");
1238                                 break;
1239                         }
1240
1241                         if (!__network_modify_profile_info(&profile_info))
1242                                 continue;
1243
1244                         gettimeofday(&timevar, NULL);
1245                         start_time = Convert_time2double(timevar);
1246
1247                         if (net_modify_profile(ProfileName, &profile_info) != NET_ERR_NONE) {
1248                                 debug_print("Error!!! net_modify_profile() failed\n");
1249                                 break;
1250                         }
1251
1252                         gettimeofday(&timevar, NULL);
1253                         finish_time = Convert_time2double(timevar);
1254                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1255
1256                         break;
1257
1258                 case 'g':
1259                         debug_print("\nInput profile Name(Enter for skip) :\n");
1260
1261                         memset(ProfileName, '\0', NET_PROFILE_NAME_LEN_MAX);
1262                         read(0, ProfileName, NET_PROFILE_NAME_LEN_MAX);
1263
1264                         gettimeofday(&timevar, NULL);
1265                         start_time = Convert_time2double(timevar);
1266
1267                         if (ProfileName[0] == '\0' || *ProfileName == '\n' || *ProfileName == '\r')
1268                                 debug_print("\nCanceled!\n\n");
1269
1270                         ProfileName[strlen(ProfileName)-1] = '\0';
1271
1272                         if (net_delete_profile(ProfileName) != NET_ERR_NONE) {
1273                                 debug_print("Error!!! net_delete_profile() failed\n");
1274                                 break;
1275                         }
1276
1277                         gettimeofday(&timevar, NULL);
1278                         finish_time = Convert_time2double(timevar);
1279                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1280
1281                         break;
1282
1283                 case 'h':
1284                         debug_print("\nInput Network Type(internet:1, MMS:2, WAP:3)"
1285                                         " - (Enter for skip) :\n");
1286
1287                         memset(input_str, '\0', 100);
1288                         read(0, input_str, 100);
1289
1290                         net_service_type_t network_type = NET_SERVICE_INTERNET;
1291                         memset(&profile_info, 0, sizeof(net_profile_info_t));
1292
1293                         if (input_str[0] != '\0' && *input_str != '\n' && *input_str != '\r') {
1294                                 int typeValue = 0;
1295                                 typeValue = atoi(input_str);
1296
1297                                 if (typeValue > NET_SERVICE_UNKNOWN &&
1298                                     typeValue <= NET_SERVICE_PREPAID_MMS)
1299                                         network_type = typeValue;
1300                                 else
1301                                         break;
1302                         } else {
1303                                 break;
1304                         }
1305
1306                         __network_add_profile_info(&profile_info);
1307
1308                         gettimeofday(&timevar, NULL);
1309                         start_time = Convert_time2double(timevar);
1310
1311                         if (net_add_profile(network_type, &profile_info) != NET_ERR_NONE) {
1312                                 debug_print("Error!!! net_add_profile() failed\n");
1313                                 break;
1314                         }
1315
1316                         gettimeofday(&timevar, NULL);
1317                         finish_time = Convert_time2double(timevar);
1318                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1319
1320                         break;
1321
1322                 case 'i': {
1323                         net_wifi_connection_info_t wifi_info = {{0,}, };
1324
1325                         debug_print("Enter essid:\n");
1326                         scanf("%s", wifi_info.essid);
1327
1328                         wifi_info.wlan_mode = NETPM_WLAN_CONNMODE_INFRA;
1329                         wifi_info.security_info.sec_mode = WLAN_SEC_MODE_WPA_PSK;
1330
1331                         debug_print("Enter psk key:\n");
1332                         scanf("%s", wifi_info.security_info.authentication.psk.pskKey);
1333
1334                         gettimeofday(&timevar, NULL);
1335                         start_time = Convert_time2double(timevar);
1336
1337                         net_error = net_open_connection_with_wifi_info(&wifi_info);
1338
1339                         if (net_error != NET_ERR_NONE) {
1340                                 debug_print("Error!!! "
1341                                             "net_open_connection_with_wifi_info() failed.\n");
1342                                 break;
1343                         }
1344
1345                         gettimeofday(&timevar, NULL);
1346                         finish_time = Convert_time2double(timevar);
1347                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1348
1349                         debug_print("net_open_connection_with_wifi_info() success\n");
1350                 }
1351
1352                         break;
1353
1354                 case 'k': {
1355                         debug_print( "Enter Profile Name: \n");
1356                         scanf("%s", ProfileName);
1357
1358                         gettimeofday(&timevar, NULL);
1359                         start_time = Convert_time2double(timevar);
1360                         net_wifi_wps_info_t wps_info;
1361                         memset(&wps_info, 0, sizeof(net_wifi_wps_info_t));
1362
1363                         wps_info.type = WIFI_WPS_PBC;
1364
1365                         if (net_wifi_enroll_wps(ProfileName, &wps_info) != NET_ERR_NONE) {
1366                                 debug_print("Error!! net_wifi_enroll_wps() failed.\n");
1367                                 break;
1368                         }
1369
1370                         gettimeofday(&timevar, NULL);
1371                         finish_time = Convert_time2double(timevar);
1372                         debug_print("Total time taken = [%f]\n", finish_time - start_time);
1373
1374                         debug_print("net_wifi_enroll_wps() success\n");
1375                 }
1376                         break;
1377
1378                 case 'l': {
1379                         int eap_type = 0;
1380                         int eap_auth = 0;
1381                         net_wifi_connection_info_t info;
1382                         memset(&info, 0, sizeof(net_wifi_connection_info_t));
1383
1384                         info.wlan_mode = NETPM_WLAN_CONNMODE_INFRA;
1385                         info.security_info.sec_mode = WLAN_SEC_MODE_IEEE8021X;
1386
1387                         debug_print("Enter essid:\n");
1388                         scanf("%s", info.essid);
1389
1390                         debug_print("Enter EAP type PEAP 1, TLS 2, TTLS 3, SIM 4, AKA 5:\n");
1391                         scanf("%d", &eap_type);
1392                         info.security_info.authentication.eap.eap_type = (wlan_eap_type_t) eap_type;
1393
1394                         debug_print("Enter EAP auth None 1, PAP 2, MSCHAP 3, MSCHAPV2 4, GTC 5, MD5 6:\n");
1395                         scanf("%d", &eap_auth);
1396                         info.security_info.authentication.eap.eap_auth = (wlan_eap_auth_type_t) eap_auth;
1397
1398                         debug_print("Enter user name:\n");
1399                         scanf("%s", info.security_info.authentication.eap.username);
1400
1401                         debug_print("Enter password:\n");
1402                         scanf("%s", info.security_info.authentication.eap.password);
1403
1404                         debug_print("Enter CA Cert filename:\n");
1405                         scanf("%s", info.security_info.authentication.eap.ca_cert_filename);
1406
1407                         debug_print("Enter Client Cert filename:\n");
1408                         scanf("%s", info.security_info.authentication.eap.client_cert_filename);
1409
1410                         debug_print("Enter private key filename:\n");
1411                         scanf("%s", info.security_info.authentication.eap.private_key_filename);
1412
1413                         debug_print("Enter private key password:\n");
1414                         scanf("%s", info.security_info.authentication.eap.private_key_passwd);
1415
1416                         net_open_connection_with_wifi_info(&info);
1417                 }
1418                         break;
1419
1420                 case 'z':
1421                         debug_print( "Exiting...!!!\n");
1422
1423                         if (net_deregister_client () != NET_ERR_NONE) {
1424                                 debug_print("Error!! net_deregister_client() failed.\n");
1425                                 return NULL;
1426                         }
1427
1428                         debug_print( "net_deregister_client() success\n");
1429
1430                         exit(0);
1431
1432                 default:
1433                         debug_print( "default...!!!\n");
1434                         break;
1435                 }
1436         }
1437
1438         if (net_deregister_client () != NET_ERR_NONE) {
1439                 debug_print("Error!! net_deregister_client() failed.\n");
1440                 return NULL;
1441         }
1442
1443         debug_print( "net_deregister_client() success\n");
1444
1445         return NULL;
1446 }
1447
1448
1449 int main(int argc, char *argv[])
1450 {
1451         GMainLoop* mainloop = NULL;
1452         GThread * main_gthread_ptr = NULL;
1453
1454         /* First thing initialze the thread system */
1455         g_thread_init(NULL);
1456
1457         /** This thread is used to recieve signals from ConnMan */
1458         main_gthread_ptr = g_thread_create(network_main_gthread, NULL, FALSE, NULL);
1459         if (main_gthread_ptr == NULL) {
1460                 debug_print("Error!!! g_thread_create() failed.\n");
1461                 return -1;
1462         }
1463
1464         debug_print("Entering gmainloop\n");
1465         mainloop = g_main_loop_new(NULL, FALSE);
1466         g_main_loop_run(mainloop);
1467
1468         debug_print("Returned from gmainloop\n");
1469
1470         return 0;
1471 }
1472