src/libnetwork.c

   1 /*
   2  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <stdio.h>
  18 #include <string.h>
  19 #include <ctype.h>
  20 #include <glib.h>
  21 #include "net_wifi_private.h"
  22
  23 static GSList *ap_handle_list = NULL;
  24
  25 struct _wifi_cb_s {
  26         wifi_device_state_changed_cb device_state_cb;
  27         void *device_state_user_data;
  28         wifi_scan_finished_cb bg_scan_cb;
  29         void *bg_scan_user_data;
  30         wifi_scan_finished_cb scan_request_cb;
  31         void *scan_request_user_data;
  32         wifi_scan_finished_cb scan_hidden_ap_cb;
  33         void *scan_hidden_ap_user_data;
  34         wifi_connection_state_changed_cb connection_state_cb;
  35         void *connection_state_user_data;
  36         wifi_activated_cb activated_cb;
  37         void *activated_user_data;
  38         wifi_deactivated_cb deactivated_cb;
  39         void *deactivated_user_data;
  40         wifi_connected_cb connected_cb;
  41         void *connected_user_data;
  42         wifi_disconnected_cb disconnected_cb;
  43         void *disconnected_user_data;
  44 };
  45
  46 struct _profile_list_s {
  47         int count;
  48         net_profile_info_t *profiles;
  49 };
  50
  51 static struct _wifi_cb_s wifi_callbacks = {0,};
  52 static struct _profile_list_s profile_iterator = {0, NULL};
  53 static struct _profile_list_s hidden_profile_iterator = {0, NULL};
  54
  55
  56 static wifi_error_e __libnet_convert_to_ap_error_type(net_err_t err_type)
  57 {
  58         switch (err_type) {
  59         case NET_ERR_NONE:
  60                 return WIFI_ERROR_NONE;
  61         case NET_ERR_APP_ALREADY_REGISTERED:
  62                 return WIFI_ERROR_INVALID_OPERATION;
  63         case NET_ERR_APP_NOT_REGISTERED:
  64                 return WIFI_ERROR_INVALID_OPERATION;
  65         case NET_ERR_NO_ACTIVE_CONNECTIONS:
  66                 return WIFI_ERROR_NO_CONNECTION;
  67         case NET_ERR_ACTIVE_CONNECTION_EXISTS:
  68                 return WIFI_ERROR_ALREADY_EXISTS;
  69         case NET_ERR_CONNECTION_DHCP_FAILED:
  70                 return WIFI_ERROR_DHCP_FAILED;
  71         case NET_ERR_CONNECTION_INVALID_KEY:
  72                 return WIFI_ERROR_INVALID_KEY;
  73         case NET_ERR_IN_PROGRESS:
  74                 return WIFI_ERROR_NOW_IN_PROGRESS;
  75         case NET_ERR_OPERATION_ABORTED:
  76                 return WIFI_ERROR_OPERATION_ABORTED;
  77         case NET_ERR_TIME_OUT:
  78                 return WIFI_ERROR_NO_REPLY;
  79         default:
  80                 return WIFI_ERROR_OPERATION_FAILED;
  81         }
  82 }
  83
  84 static const char *__libnet_convert_ap_error_type_to_string(wifi_error_e err_type)
  85 {
  86         switch (err_type) {
  87         case WIFI_ERROR_NONE:
  88                 return "NONE";
  89         case WIFI_ERROR_INVALID_PARAMETER:
  90                 return "INVALID_PARAMETER";
  91         case WIFI_ERROR_OUT_OF_MEMORY:
  92                 return "OUT_OF_MEMORY";
  93         case WIFI_ERROR_INVALID_OPERATION:
  94                 return "INVALID_OPERATION";
  95         case WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED:
  96                 return "ADDRESS_FAMILY_NOT_SUPPORTED";
  97         case WIFI_ERROR_OPERATION_FAILED:
  98                 return "OPERATION_FAILED";
  99         case WIFI_ERROR_NO_CONNECTION:
 100                 return "NO_CONNECTION";
 101         case WIFI_ERROR_NOW_IN_PROGRESS:
 102                 return "NOW_IN_PROGRESS";
 103         case WIFI_ERROR_ALREADY_EXISTS:
 104                 return "ALREADY_EXISTS";
 105         case WIFI_ERROR_OPERATION_ABORTED:
 106                 return "OPERATION_ABORTED";
 107         case WIFI_ERROR_DHCP_FAILED:
 108                 return "DHCP_FAILED";
 109         case WIFI_ERROR_INVALID_KEY:
 110                 return "INVALID_KEY";
 111         case WIFI_ERROR_NO_REPLY:
 112                 return "NO_REPLY";
 113         case WIFI_ERROR_SECURITY_RESTRICTED:
 114                 return "SECURITY_RESTRICTED";
 115         }
 116
 117         return "UNKNOWN";
 118 }
 119
 120 static const char *__libnet_convert_ap_state_to_string(wifi_connection_state_e state)
 121 {
 122         switch (state) {
 123         case WIFI_CONNECTION_STATE_DISCONNECTED:
 124                 return "DISCONNECTED";
 125         case WIFI_CONNECTION_STATE_ASSOCIATION:
 126                 return "ASSOCIATION";
 127         case WIFI_CONNECTION_STATE_CONFIGURATION:
 128                 return "CONFIGURATION";
 129         case WIFI_CONNECTION_STATE_CONNECTED:
 130                 return "CONNECTED";
 131         default:
 132                 return "UNKNOWN";
 133         }
 134 }
 135
 136 static void __libnet_clear_profile_list(struct _profile_list_s *profile_list)
 137 {
 138         if (profile_list->count > 0)
 139                 g_free(profile_list->profiles);
 140
 141         profile_list->count = 0;
 142         profile_list->profiles = NULL;
 143 }
 144
 145 static void __libnet_update_profile_iterator(void)
 146 {
 147         struct _profile_list_s wifi_profiles = {0, NULL};
 148
 149         __libnet_clear_profile_list(&profile_iterator);
 150
 151         net_get_profile_list(NET_DEVICE_WIFI, &wifi_profiles.profiles, &wifi_profiles.count);
 152         WIFI_LOG(WIFI_INFO, "Wifi profile count : %d\n", wifi_profiles.count);
 153
 154         if (wifi_profiles.count == 0)
 155                 return;
 156
 157         profile_iterator.count = wifi_profiles.count;
 158         profile_iterator.profiles = wifi_profiles.profiles;
 159 }
 160
 161 static void __libnet_update_hidden_profile_iterator(GSList *ap_list)
 162 {
 163         int count;
 164         GSList *list = ap_list;
 165
 166         for (count = 0; list; list = list->next)
 167                 count++;
 168
 169         if (count == 0) {
 170                 WIFI_LOG(WIFI_INFO, "No hidden AP found\n");
 171                 return;
 172         }
 173
 174         hidden_profile_iterator.count = count;
 175         hidden_profile_iterator.profiles = g_try_new0(net_profile_info_t, count);
 176
 177         list = ap_list;
 178         for (count = 0; list; list = list->next) {
 179                 net_wifi_connection_info_t *ap = list->data;
 180                 net_profile_info_t *profile = &hidden_profile_iterator.profiles[count];
 181
 182                 g_strlcpy(profile->ProfileInfo.Wlan.essid, ap->essid, NET_WLAN_ESSID_LEN+1);
 183                 profile->ProfileInfo.Wlan.security_info.sec_mode = ap->security_info.sec_mode;
 184                 count++;
 185         }
 186
 187         WIFI_LOG(WIFI_INFO, "Hidden AP count : %d\n", count);
 188 }
 189
 190 static void __libnet_convert_profile_info_to_wifi_info(net_wifi_connection_info_t *wifi_info,
 191                                                                 net_profile_info_t *ap_info)
 192 {
 193         g_strlcpy(wifi_info->essid, ap_info->ProfileInfo.Wlan.essid, NET_WLAN_ESSID_LEN+1);
 194         wifi_info->wlan_mode = ap_info->ProfileInfo.Wlan.wlan_mode;
 195         memcpy(&wifi_info->security_info, &ap_info->ProfileInfo.Wlan.security_info, sizeof(wlan_security_info_t));
 196 }
 197
 198 static int __libnet_connect_with_wifi_info(net_profile_info_t *ap_info)
 199 {
 200         net_wifi_connection_info_t wifi_info;
 201         memset(&wifi_info, 0, sizeof(net_wifi_connection_info_t));
 202
 203         __libnet_convert_profile_info_to_wifi_info(&wifi_info, ap_info);
 204
 205         if (net_open_connection_with_wifi_info(&wifi_info) != NET_ERR_NONE)
 206                 return WIFI_ERROR_OPERATION_FAILED;
 207
 208         return WIFI_ERROR_NONE;
 209 }
 210
 211 static void __libnet_state_changed_cb(char *profile_name, net_profile_info_t *profile_info,
 212                                                         wifi_connection_state_e state)
 213 {
 214         if (profile_name == NULL)
 215                 return;
 216
 217         if (profile_info == NULL) {
 218                 WIFI_LOG(WIFI_ERROR, "Error!! Profile info not found! : %s\n", profile_name);
 219                 return;
 220         }
 221
 222         ap_handle_list = g_slist_append(ap_handle_list, (wifi_ap_h)profile_info);
 223
 224         if (wifi_callbacks.connection_state_cb)
 225                 wifi_callbacks.connection_state_cb(state, (wifi_ap_h)profile_info,
 226                                         wifi_callbacks.connection_state_user_data);
 227
 228         ap_handle_list = g_slist_remove(ap_handle_list, (wifi_ap_h)profile_info);
 229 }
 230
 231 static void __libnet_set_activated_cb(wifi_activated_cb user_cb, void *user_data)
 232 {
 233         if (user_cb) {
 234                 wifi_callbacks.activated_cb = user_cb;
 235                 wifi_callbacks.activated_user_data = user_data;
 236         }
 237 }
 238
 239 static void __libnet_activated_cb(wifi_error_e result)
 240 {
 241         if (wifi_callbacks.activated_cb)
 242                 wifi_callbacks.activated_cb(result, wifi_callbacks.activated_user_data);
 243
 244         wifi_callbacks.activated_cb = NULL;
 245         wifi_callbacks.activated_user_data = NULL;
 246 }
 247
 248 static void __libnet_set_deactivated_cb(wifi_disconnected_cb user_cb, void *user_data)
 249 {
 250         if (user_cb) {
 251                 wifi_callbacks.deactivated_cb = user_cb;
 252                 wifi_callbacks.deactivated_user_data = user_data;
 253         }
 254 }
 255
 256 static void __libnet_deactivated_cb(wifi_error_e result)
 257 {
 258         if (wifi_callbacks.deactivated_cb)
 259                 wifi_callbacks.deactivated_cb(result, wifi_callbacks.deactivated_user_data);
 260
 261         wifi_callbacks.deactivated_cb = NULL;
 262         wifi_callbacks.deactivated_user_data = NULL;
 263 }
 264
 265 static void __libnet_power_on_off_cb(net_event_info_t *event_cb, bool is_requested)
 266 {
 267         if (wifi_callbacks.device_state_cb == NULL &&
 268             wifi_callbacks.activated_cb == NULL &&
 269             wifi_callbacks.deactivated_cb == NULL)
 270                 return;
 271
 272         wifi_error_e error_code = WIFI_ERROR_NONE;
 273         wifi_device_state_e state;
 274         net_wifi_state_t *wifi_state = (net_wifi_state_t*)event_cb->Data;
 275
 276         if (event_cb->Error == NET_ERR_NONE &&
 277             event_cb->Datalength == sizeof(net_wifi_state_t)) {
 278
 279                 if (*wifi_state == WIFI_ON) {
 280                         WIFI_LOG(WIFI_INFO, "Wi-Fi State : Power ON\n");
 281                         state = WIFI_DEVICE_STATE_ACTIVATED;
 282                 } else if (*wifi_state == WIFI_OFF) {
 283                         WIFI_LOG(WIFI_INFO, "Wi-Fi State : Power OFF\n");
 284                         state = WIFI_DEVICE_STATE_DEACTIVATED;
 285                         __libnet_clear_profile_list(&profile_iterator);
 286                         __libnet_clear_profile_list(&hidden_profile_iterator);
 287                 } else {
 288                         WIFI_LOG(WIFI_INFO, "Wi-Fi State : Unknown\n");
 289                         error_code = WIFI_ERROR_OPERATION_FAILED;
 290                         state = WIFI_DEVICE_STATE_DEACTIVATED;
 291                 }
 292         } else {
 293                 WIFI_LOG(WIFI_ERROR, "Wi-Fi Power on/off request failed! Error [%d]\n", event_cb->Error);
 294                 error_code = WIFI_ERROR_OPERATION_FAILED;
 295                 state = WIFI_DEVICE_STATE_DEACTIVATED;
 296         }
 297
 298         __libnet_activated_cb(error_code);
 299         __libnet_deactivated_cb(error_code);
 300
 301         if (wifi_callbacks.device_state_cb)
 302                 wifi_callbacks.device_state_cb(state, wifi_callbacks.device_state_user_data);
 303 }
 304
 305 static void __libnet_scan_cb(net_event_info_t *event_cb)
 306 {
 307         wifi_error_e error_code = WIFI_ERROR_NONE;
 308
 309         if (event_cb->Error != NET_ERR_NONE) {
 310                 WIFI_LOG(WIFI_ERROR, "Scan failed!, Error [%d]\n", event_cb->Error);
 311                 error_code = WIFI_ERROR_OPERATION_FAILED;
 312         }
 313
 314         if (wifi_callbacks.scan_request_cb) {
 315                 wifi_callbacks.scan_request_cb(error_code, wifi_callbacks.scan_request_user_data);
 316                 wifi_callbacks.scan_request_cb = NULL;
 317                 wifi_callbacks.scan_request_user_data = NULL;
 318                 return;
 319         }
 320
 321         if (wifi_callbacks.bg_scan_cb != NULL)
 322                 wifi_callbacks.bg_scan_cb(error_code, wifi_callbacks.bg_scan_user_data);
 323 }
 324
 325 static void __libnet_hidden_scan_cb(net_event_info_t *event_cb)
 326 {
 327         wifi_error_e error_code = WIFI_ERROR_NONE;
 328
 329         __libnet_clear_profile_list(&hidden_profile_iterator);
 330
 331         if (event_cb->Error != NET_ERR_NONE) {
 332                 WIFI_LOG(WIFI_ERROR, "Hidden scan failed!, Error [%d]\n", event_cb->Error);
 333                 error_code = WIFI_ERROR_OPERATION_FAILED;
 334         } else if (event_cb->Data) {
 335                 GSList *ap_list = event_cb->Data;
 336                 __libnet_update_hidden_profile_iterator(ap_list);
 337         }
 338
 339         if (wifi_callbacks.scan_hidden_ap_cb) {
 340                 wifi_callbacks.scan_hidden_ap_cb(error_code, wifi_callbacks.scan_hidden_ap_user_data);
 341                 wifi_callbacks.scan_hidden_ap_cb = NULL;
 342                 wifi_callbacks.scan_hidden_ap_user_data = NULL;
 343         }
 344 }
 345
 346 static void __libnet_set_connected_cb(wifi_connected_cb user_cb, void *user_data)
 347 {
 348         if (user_cb) {
 349                 wifi_callbacks.connected_cb = user_cb;
 350                 wifi_callbacks.connected_user_data = user_data;
 351         }
 352 }
 353
 354 static void __libnet_connected_cb(wifi_error_e result)
 355 {
 356         if (wifi_callbacks.connected_cb)
 357                 wifi_callbacks.connected_cb(result, wifi_callbacks.connected_user_data);
 358
 359         wifi_callbacks.connected_cb = NULL;
 360         wifi_callbacks.connected_user_data = NULL;
 361 }
 362
 363 static void __libnet_set_disconnected_cb(wifi_disconnected_cb user_cb, void *user_data)
 364 {
 365         if (user_cb) {
 366                 wifi_callbacks.disconnected_cb = user_cb;
 367                 wifi_callbacks.disconnected_user_data = user_data;
 368         }
 369 }
 370
 371 static void __libnet_disconnected_cb(wifi_error_e result)
 372 {
 373         if (wifi_callbacks.disconnected_cb)
 374                 wifi_callbacks.disconnected_cb(result, wifi_callbacks.disconnected_user_data);
 375
 376         wifi_callbacks.disconnected_cb = NULL;
 377         wifi_callbacks.disconnected_user_data = NULL;
 378 }
 379
 380 static void __libnet_evt_cb(net_event_info_t *event_cb, void *user_data)
 381 {
 382         bool is_requested = false;
 383         net_profile_info_t *prof_info_p = NULL;
 384         net_profile_info_t prof_info;
 385         wifi_error_e result = WIFI_ERROR_NONE;
 386
 387         switch (event_cb->Event) {
 388         case NET_EVENT_OPEN_RSP:
 389         case NET_EVENT_WIFI_WPS_RSP:
 390                 is_requested = true;
 391                 /* fall through */
 392         case NET_EVENT_OPEN_IND:
 393                 if (strstr(event_cb->ProfileName, "/wifi_") == NULL) return;
 394
 395                 result = __libnet_convert_to_ap_error_type(event_cb->Error);
 396                 WIFI_LOG(WIFI_INFO, "Got Open RSP/IND : %s\n",
 397                         __libnet_convert_ap_error_type_to_string(result));
 398
 399                 if (is_requested)
 400                         __libnet_connected_cb(result);
 401
 402                 switch (event_cb->Error) {
 403                 case NET_ERR_NONE:
 404                         WIFI_LOG(WIFI_INFO, "Connection open succeeded\n");
 405
 406                         if (event_cb->Datalength == sizeof(net_profile_info_t))
 407                                 prof_info_p = (net_profile_info_t*)event_cb->Data;
 408
 409                         __libnet_state_changed_cb(event_cb->ProfileName, prof_info_p,
 410                                                         WIFI_CONNECTION_STATE_CONNECTED);
 411                         return;
 412                 default :
 413                         WIFI_LOG(WIFI_ERROR, "Connection open failed!\n");
 414                         break;
 415                 }
 416
 417                 if (net_get_profile_info(event_cb->ProfileName, &prof_info) == NET_ERR_NONE)
 418                         __libnet_state_changed_cb(event_cb->ProfileName, &prof_info,
 419                                                 WIFI_CONNECTION_STATE_DISCONNECTED);
 420                 else
 421                         __libnet_state_changed_cb(event_cb->ProfileName, NULL,
 422                                                 WIFI_CONNECTION_STATE_DISCONNECTED);
 423
 424                 break;
 425         case NET_EVENT_CLOSE_RSP:
 426                 is_requested = true;
 427                 /* fall through */
 428         case NET_EVENT_CLOSE_IND:
 429                 if (strstr(event_cb->ProfileName, "/wifi_") == NULL) return;
 430
 431                 result = __libnet_convert_to_ap_error_type(event_cb->Error);
 432                 WIFI_LOG(WIFI_INFO, "Got Close RSP/IND : %s\n",
 433                         __libnet_convert_ap_error_type_to_string(result));
 434
 435                 if (is_requested)
 436                         __libnet_disconnected_cb(result);
 437
 438                 switch (event_cb->Error) {
 439                 case NET_ERR_NONE:
 440                         /* Successful PDP Deactivation */
 441                         WIFI_LOG(WIFI_INFO, "Connection close succeeded!\n");
 442                         if (net_get_profile_info(event_cb->ProfileName, &prof_info) == NET_ERR_NONE)
 443                                 __libnet_state_changed_cb(event_cb->ProfileName, &prof_info,
 444                                                         WIFI_CONNECTION_STATE_DISCONNECTED);
 445                         else
 446                                 __libnet_state_changed_cb(event_cb->ProfileName, NULL,
 447                                                         WIFI_CONNECTION_STATE_DISCONNECTED);
 448                         return;
 449                 default:
 450                         WIFI_LOG(WIFI_ERROR, "Connection close failed!\n");
 451                         break;
 452                 }
 453
 454                 break;
 455         case NET_EVENT_NET_STATE_IND:
 456                 if (strstr(event_cb->ProfileName, "/wifi_") == NULL) return;
 457
 458                 WIFI_LOG(WIFI_INFO, "Got State changed IND\n");
 459
 460                 if (event_cb->Datalength != sizeof(net_state_type_t))
 461                         return;
 462
 463                 net_state_type_t *profile_state = (net_state_type_t*)event_cb->Data;
 464                 wifi_connection_state_e ap_state = _wifi_convert_to_ap_state(*profile_state);
 465
 466                 WIFI_LOG(WIFI_INFO,
 467                         "Profile State : %s, profile name : %s\n",
 468                         __libnet_convert_ap_state_to_string(ap_state),
 469                         event_cb->ProfileName);
 470
 471                 if (net_get_profile_info(event_cb->ProfileName, &prof_info) == NET_ERR_NONE)
 472                         __libnet_state_changed_cb(event_cb->ProfileName, &prof_info, ap_state);
 473                 else
 474                         __libnet_state_changed_cb(event_cb->ProfileName, NULL, ap_state);
 475
 476
 477                 break;
 478         case NET_EVENT_WIFI_SCAN_RSP:
 479         case NET_EVENT_WIFI_SCAN_IND:
 480                 WIFI_LOG(WIFI_INFO, "Got wifi scan IND\n");
 481                 __libnet_scan_cb(event_cb);
 482                 break;
 483         case NET_EVENT_SPECIFIC_SCAN_RSP:
 484                 WIFI_LOG(WIFI_INFO, "Got wifi hidden scan RSP\n");
 485                 break;
 486         case NET_EVENT_SPECIFIC_SCAN_IND:
 487                 WIFI_LOG(WIFI_INFO, "Got wifi hidden scan IND\n");
 488                 __libnet_hidden_scan_cb(event_cb);
 489                 break;
 490         case NET_EVENT_WIFI_POWER_RSP:
 491                 is_requested = true;
 492                 /* fall through */
 493         case NET_EVENT_WIFI_POWER_IND:
 494                 WIFI_LOG(WIFI_INFO, "Got wifi power IND\n");
 495                 __libnet_power_on_off_cb(event_cb, is_requested);
 496                 break;
 497         default :
 498                 WIFI_LOG(WIFI_INFO, "Error! Unknown Event\n\n");
 499         }
 500 }
 501
 502 bool _wifi_libnet_init(void)
 503 {
 504         int rv;
 505
 506         rv = net_register_client_ext((net_event_cb_t)__libnet_evt_cb, NET_DEVICE_WIFI, NULL);
 507         if (rv != NET_ERR_NONE)
 508                 return false;
 509
 510         return true;
 511 }
 512
 513 bool _wifi_libnet_deinit(void)
 514 {
 515         if (net_deregister_client_ext(NET_DEVICE_WIFI) != NET_ERR_NONE)
 516                 return false;
 517
 518         __libnet_clear_profile_list(&profile_iterator);
 519         __libnet_clear_profile_list(&hidden_profile_iterator);
 520         g_slist_free_full(ap_handle_list, g_free);
 521         ap_handle_list = NULL;
 522         memset(&wifi_callbacks, 0, sizeof(struct _wifi_cb_s));
 523
 524         return true;
 525 }
 526
 527 int _wifi_activate(wifi_activated_cb callback, void* user_data)
 528 {
 529         int rv;
 530
 531         rv = net_wifi_power_on();
 532         if (rv == NET_ERR_NONE) {
 533                 __libnet_set_activated_cb(callback, user_data);
 534                 return WIFI_ERROR_NONE;
 535         } else if (rv == NET_ERR_INVALID_OPERATION)
 536                 return WIFI_ERROR_INVALID_OPERATION;
 537
 538         return WIFI_ERROR_OPERATION_FAILED;
 539 }
 540
 541 int _wifi_deactivate(wifi_deactivated_cb callback, void* user_data)
 542 {
 543         int rv;
 544
 545         rv = net_wifi_power_off();
 546         if (rv == NET_ERR_NONE) {
 547                 __libnet_set_deactivated_cb(callback, user_data);
 548                 return WIFI_ERROR_NONE;
 549         } else if (rv == NET_ERR_INVALID_OPERATION)
 550                 return WIFI_ERROR_INVALID_OPERATION;
 551
 552         return WIFI_ERROR_OPERATION_FAILED;
 553 }
 554
 555 bool _wifi_libnet_check_ap_validity(wifi_ap_h ap_h)
 556 {
 557         GSList *list;
 558         int i = 0;
 559
 560         for (list = ap_handle_list; list; list = list->next)
 561                 if (ap_h == list->data) return true;
 562
 563         for (; i < profile_iterator.count; i++)
 564                 if (ap_h == &profile_iterator.profiles[i]) return true;
 565
 566         for (i = 0; i < hidden_profile_iterator.count; i++)
 567                 if (ap_h == &hidden_profile_iterator.profiles[i]) return true;
 568
 569         return false;
 570 }
 571
 572 void _wifi_libnet_add_to_ap_list(wifi_ap_h ap_h)
 573 {
 574         ap_handle_list = g_slist_append(ap_handle_list, ap_h);
 575 }
 576
 577 void _wifi_libnet_remove_from_ap_list(wifi_ap_h ap_h)
 578 {
 579         ap_handle_list = g_slist_remove(ap_handle_list, ap_h);
 580         g_free(ap_h);
 581 }
 582
 583 bool _wifi_libnet_check_profile_name_validity(const char *profile_name)
 584 {
 585         const char *profile_header = "/net/connman/service/wifi_";
 586         int i = 0;
 587         int string_len = 0;
 588
 589         if (profile_name == NULL || strlen(profile_name) <= strlen(profile_header)) {
 590                 WIFI_LOG(WIFI_ERROR, "Error!!! Profile name is invalid\n");
 591                 return false;
 592         }
 593
 594         string_len = strlen(profile_name);
 595
 596         if (strncmp(profile_header, profile_name, strlen(profile_header)) == 0) {
 597                 for (;i < string_len;i++) {
 598                         if (isgraph(profile_name[i]) == 0) {
 599                                 WIFI_LOG(WIFI_ERROR, "Error!!! Profile name is invalid\n");
 600                                 return false;
 601                         }
 602                 }
 603         } else {
 604                 WIFI_LOG(WIFI_ERROR, "Error!!! Profile name is invalid\n");
 605                 return false;
 606         }
 607
 608         return true;
 609 }
 610
 611 bool _wifi_libnet_get_wifi_device_state(wifi_device_state_e *device_state)
 612 {
 613         net_wifi_state_t wlan_state;
 614         net_profile_name_t profile_name;
 615
 616         if (net_get_wifi_state(&wlan_state, &profile_name) != NET_ERR_NONE) {
 617                 WIFI_LOG(WIFI_ERROR, "Error!! net_get_wifi_state() failed.\n");
 618                 return false;
 619         }
 620
 621         switch (wlan_state) {
 622         case WIFI_OFF:
 623                 *device_state = WIFI_DEVICE_STATE_DEACTIVATED;
 624                 break;
 625         case WIFI_ON:
 626         case WIFI_CONNECTING:
 627         case WIFI_CONNECTED:
 628         case WIFI_DISCONNECTING:
 629                 *device_state = WIFI_DEVICE_STATE_ACTIVATED;
 630                 break;
 631         default :
 632                 WIFI_LOG(WIFI_ERROR, "Error!! Unknown state\n");
 633                 return false;
 634         }
 635
 636         return true;
 637 }
 638
 639 bool _wifi_libnet_get_wifi_state(wifi_connection_state_e* connection_state)
 640 {
 641         net_wifi_state_t wlan_state = 0;
 642         net_profile_name_t profile_name;
 643
 644         if (net_get_wifi_state(&wlan_state, &profile_name) != NET_ERR_NONE) {
 645                 WIFI_LOG(WIFI_ERROR, "Error!! net_get_wifi_state() failed.\n");
 646                 return false;
 647         }
 648
 649         switch (wlan_state) {
 650         case WIFI_OFF:
 651         case WIFI_ON:
 652                 *connection_state = WIFI_CONNECTION_STATE_DISCONNECTED;
 653                 break;
 654         case WIFI_CONNECTING:
 655                 *connection_state = WIFI_CONNECTION_STATE_ASSOCIATION;
 656                 break;
 657         case WIFI_CONNECTED:
 658                 *connection_state = WIFI_CONNECTION_STATE_CONNECTED;
 659                 break;
 660         case WIFI_DISCONNECTING:
 661                 *connection_state = WIFI_CONNECTION_STATE_CONNECTED;
 662                 break;
 663         default :
 664                 WIFI_LOG(WIFI_ERROR, "Error!! Unknown state\n");
 665                 return false;
 666         }
 667
 668         return true;
 669 }
 670
 671 int _wifi_libnet_get_intf_name(char** name)
 672 {
 673         if (profile_iterator.count == 0)
 674                 __libnet_update_profile_iterator();
 675
 676         if (profile_iterator.count == 0) {
 677                 WIFI_LOG(WIFI_ERROR, "Error!! There is no AP\n");
 678                 return WIFI_ERROR_OPERATION_FAILED;
 679         }
 680
 681         *name = g_strdup(profile_iterator.profiles->ProfileInfo.Wlan.net_info.DevName);
 682         if (*name == NULL)
 683                 return WIFI_ERROR_OUT_OF_MEMORY;
 684
 685         return WIFI_ERROR_NONE;
 686 }
 687
 688 int _wifi_libnet_scan_request(wifi_scan_finished_cb callback, void* user_data)
 689 {
 690         int rv;
 691         rv = net_scan_wifi();
 692
 693         if (rv == NET_ERR_NONE) {
 694                 wifi_callbacks.scan_request_cb = callback;
 695                 wifi_callbacks.scan_request_user_data = user_data;
 696                 return WIFI_ERROR_NONE;
 697         } else if (rv == NET_ERR_INVALID_OPERATION)
 698                 return WIFI_ERROR_INVALID_OPERATION;
 699
 700         return WIFI_ERROR_OPERATION_FAILED;
 701 }
 702
 703 int _wifi_libnet_scan_hidden_ap(const char *essid,
 704                                         wifi_scan_finished_cb callback, void* user_data)
 705 {
 706         int rv;
 707         rv = net_specific_scan_wifi(essid);
 708
 709         if (rv == NET_ERR_NONE) {
 710                 wifi_callbacks.scan_hidden_ap_cb = callback;
 711                 wifi_callbacks.scan_hidden_ap_user_data = user_data;
 712                 return WIFI_ERROR_NONE;
 713         } else if (rv == NET_ERR_INVALID_OPERATION)
 714                 return WIFI_ERROR_INVALID_OPERATION;
 715
 716         return WIFI_ERROR_OPERATION_FAILED;
 717 }
 718
 719 int _wifi_libnet_get_connected_profile(wifi_ap_h *ap)
 720 {
 721         int i = 0;
 722         wifi_ap_h ap_h = NULL;
 723
 724         __libnet_update_profile_iterator();
 725
 726         for (;i < profile_iterator.count;i++) {
 727                 if (profile_iterator.profiles[i].ProfileState == NET_STATE_TYPE_ONLINE ||
 728                     profile_iterator.profiles[i].ProfileState == NET_STATE_TYPE_READY) {
 729                         ap_h = (wifi_ap_h)(&profile_iterator.profiles[i]);
 730                         break;
 731                 }
 732         }
 733
 734         if (ap_h == NULL) {
 735                 WIFI_LOG(WIFI_ERROR, "Error!! There is no connected AP.\n");
 736                 return WIFI_ERROR_NO_CONNECTION;
 737         }
 738
 739         *ap = g_try_malloc0(sizeof(net_profile_info_t));
 740         if (*ap == NULL)
 741                 return WIFI_ERROR_OUT_OF_MEMORY;
 742
 743         memcpy(*ap, ap_h, sizeof(net_profile_info_t));
 744
 745         _wifi_libnet_add_to_ap_list(*ap);
 746
 747         return WIFI_ERROR_NONE;
 748 }
 749
 750 bool _wifi_libnet_foreach_found_aps(wifi_found_ap_cb callback, void *user_data)
 751 {
 752         int i = 0;
 753         bool rv = true;
 754
 755         __libnet_update_profile_iterator();
 756
 757         if (profile_iterator.count == 0) {
 758                 WIFI_LOG(WIFI_INFO, "There is no APs.\n");
 759                 return true;
 760         }
 761
 762         for (;i < profile_iterator.count;i++) {
 763                 rv = callback((wifi_ap_h)(&profile_iterator.profiles[i]), user_data);
 764                 if (rv == false) break;
 765         }
 766
 767         return true;
 768 }
 769
 770 bool _wifi_libnet_foreach_found_hidden_aps(wifi_found_ap_cb callback, void *user_data)
 771 {
 772         int i = 0;
 773         bool rv = true;
 774
 775         if (hidden_profile_iterator.count == 0) {
 776                 WIFI_LOG(WIFI_INFO, "There is no hidden APs.\n");
 777                 return true;
 778         }
 779
 780         for (;i < hidden_profile_iterator.count;i++) {
 781                 rv = callback((wifi_ap_h)(&hidden_profile_iterator.profiles[i]), user_data);
 782                 if (rv == false) break;
 783         }
 784
 785         return true;
 786 }
 787
 788 int _wifi_libnet_open_profile(wifi_ap_h ap_h, wifi_connected_cb callback, void* user_data)
 789 {
 790         net_profile_info_t *ap_info = ap_h;
 791         net_profile_name_t profile_name;
 792         int rv;
 793
 794         g_strlcpy(profile_name.ProfileName, ap_info->ProfileName, NET_PROFILE_NAME_LEN_MAX+1);
 795
 796         if (ap_info->ProfileInfo.Wlan.security_info.sec_mode == WLAN_SEC_MODE_IEEE8021X)
 797                 rv = __libnet_connect_with_wifi_info(ap_info);
 798         else if (_wifi_libnet_check_profile_name_validity(ap_info->ProfileName) == false)
 799                 rv = __libnet_connect_with_wifi_info(ap_info);
 800         else
 801                 rv = net_open_connection_with_profile(profile_name.ProfileName);
 802
 803         if (rv != NET_ERR_NONE)
 804                 return WIFI_ERROR_OPERATION_FAILED;
 805
 806         __libnet_set_connected_cb(callback, user_data);
 807
 808         return WIFI_ERROR_NONE;
 809 }
 810
 811 int _wifi_libnet_close_profile(wifi_ap_h ap_h, wifi_disconnected_cb callback, void* user_data)
 812 {
 813         net_profile_info_t *ap_info = ap_h;
 814         net_profile_name_t profile_name;
 815
 816         g_strlcpy(profile_name.ProfileName, ap_info->ProfileName, NET_PROFILE_NAME_LEN_MAX+1);
 817
 818         if (net_close_connection(profile_name.ProfileName) != NET_ERR_NONE)
 819                 return WIFI_ERROR_OPERATION_FAILED;
 820
 821         __libnet_set_disconnected_cb(callback, user_data);
 822
 823         return WIFI_ERROR_NONE;
 824 }
 825
 826 int _wifi_libnet_connect_with_wps(wifi_ap_h ap_h, wifi_connected_cb callback, void* user_data)
 827 {
 828         net_profile_info_t *ap_info = ap_h;
 829         net_wifi_wps_info_t wps_info;
 830         net_profile_name_t profile_name;
 831
 832         memset(&wps_info, 0 , sizeof(net_wifi_wps_info_t));
 833         g_strlcpy(profile_name.ProfileName, ap_info->ProfileName, NET_PROFILE_NAME_LEN_MAX+1);
 834
 835         wps_info.type = WIFI_WPS_PBC;
 836
 837         if (net_wifi_enroll_wps(profile_name.ProfileName, &wps_info) != NET_ERR_NONE)
 838                 return WIFI_ERROR_OPERATION_FAILED;
 839
 840         __libnet_set_connected_cb(callback, user_data);
 841
 842         return WIFI_ERROR_NONE;
 843 }
 844
 845 int _wifi_libnet_forget_ap(wifi_ap_h ap)
 846 {
 847         int rv = 0;
 848         net_profile_name_t profile_name;
 849         net_profile_info_t *ap_info = ap;
 850
 851         g_strlcpy(profile_name.ProfileName, ap_info->ProfileName, NET_PROFILE_NAME_LEN_MAX+1);
 852
 853         rv = net_delete_profile(profile_name.ProfileName);
 854         if (rv != NET_ERR_NONE)
 855                 return WIFI_ERROR_OPERATION_FAILED;
 856
 857         return WIFI_ERROR_NONE;
 858 }
 859
 860 int _wifi_set_power_on_off_cb(wifi_device_state_changed_cb callback, void *user_data)
 861 {
 862         if (wifi_callbacks.device_state_cb)
 863                 return WIFI_ERROR_INVALID_OPERATION;
 864
 865         wifi_callbacks.device_state_cb = callback;
 866         wifi_callbacks.device_state_user_data = user_data;
 867
 868         return WIFI_ERROR_NONE;
 869 }
 870
 871 int _wifi_unset_power_on_off_cb(void)
 872 {
 873         if (wifi_callbacks.device_state_cb == NULL)
 874                 return WIFI_ERROR_INVALID_OPERATION;
 875
 876         wifi_callbacks.device_state_cb = NULL;
 877         wifi_callbacks.device_state_user_data = NULL;
 878
 879         return WIFI_ERROR_NONE;
 880 }
 881
 882 int _wifi_set_background_scan_cb(wifi_scan_finished_cb callback, void *user_data)
 883 {
 884         if (wifi_callbacks.bg_scan_cb)
 885                 return WIFI_ERROR_INVALID_OPERATION;
 886
 887         wifi_callbacks.bg_scan_cb = callback;
 888         wifi_callbacks.bg_scan_user_data = user_data;
 889
 890         return WIFI_ERROR_NONE;
 891 }
 892
 893 int _wifi_unset_background_scan_cb(void)
 894 {
 895         if (wifi_callbacks.bg_scan_cb == NULL)
 896                 return WIFI_ERROR_INVALID_OPERATION;
 897
 898         wifi_callbacks.bg_scan_cb = NULL;
 899         wifi_callbacks.bg_scan_user_data = NULL;
 900
 901         return WIFI_ERROR_NONE;
 902 }
 903
 904 int _wifi_set_connection_state_cb(wifi_connection_state_changed_cb callback, void *user_data)
 905 {
 906         if (wifi_callbacks.connection_state_cb)
 907                 return WIFI_ERROR_INVALID_OPERATION;
 908
 909         wifi_callbacks.connection_state_cb = callback;
 910         wifi_callbacks.connection_state_user_data = user_data;
 911
 912         return WIFI_ERROR_NONE;
 913 }
 914
 915 int _wifi_unset_connection_state_cb()
 916 {
 917         if (wifi_callbacks.connection_state_cb == NULL)
 918                 return WIFI_ERROR_INVALID_OPERATION;
 919
 920         wifi_callbacks.connection_state_cb = NULL;
 921         wifi_callbacks.connection_state_user_data = NULL;
 922
 923         return WIFI_ERROR_NONE;
 924 }
 925
 926 int _wifi_update_ap_info(net_profile_info_t *ap_info)
 927 {
 928         if (net_modify_profile(ap_info->ProfileName, ap_info) != NET_ERR_NONE)
 929                 return WIFI_ERROR_OPERATION_FAILED;
 930
 931         return WIFI_ERROR_NONE;
 932 }
 933