src/network-wifi-intf.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 __cplusplus
  22 extern "C"
  23 {
  24 #endif /* __cplusplus */
  25
  26
  27 /*****************************************************************************
  28  *      Standard headers
  29  *****************************************************************************/
  30 #include <stdio.h>
  31 #include <errno.h>
  32 #include <stdlib.h>
  33 #include <string.h>
  34 #include <glib.h>
  35
  36 #include <vconf.h>
  37 #include <dbus/dbus.h>
  38
  39 /*****************************************************************************
  40  *      Platform headers
  41  *****************************************************************************/
  42
  43 #include "network-internal.h"
  44 #include "network-signal-handler.h"
  45 #include "network-dbus-request.h"
  46
  47 /*****************************************************************************
  48  *      Macros and Typedefs
  49  *****************************************************************************/
  50
  51 /*****************************************************************************
  52  *      Local Functions Declaration
  53  *****************************************************************************/
  54
  55 static net_wifi_state_t __net_get_wifi_service_state();
  56
  57 /*****************************************************************************
  58  *      Global Functions
  59  *****************************************************************************/
  60
  61
  62 /*****************************************************************************
  63  *      Extern Variables
  64  *****************************************************************************/
  65
  66 extern network_info_t NetworkInfo;
  67 extern network_request_table_t request_table[NETWORK_REQUEST_TYPE_MAX];
  68
  69 /*****************************************************************************
  70  *      Global Variables
  71  *****************************************************************************/
  72
  73 /*****************************************************************************
  74  *      Local Functions Definition
  75  *****************************************************************************/
  76
  77 static net_wifi_state_t __net_get_wifi_service_state(char *profile_name)
  78 {
  79         __NETWORK_FUNC_ENTER__;
  80
  81         net_err_t Error = NET_ERR_NONE;
  82         net_wifi_state_t wifi_state = NetworkInfo.wifi_state;
  83         int profile_count = 0;
  84         int i = 0;
  85         net_profile_info_t* profile_info = NULL;
  86
  87         Error = _net_get_profile_list(NET_DEVICE_WIFI, &profile_info, &profile_count);
  88
  89         if (Error != NET_ERR_NONE) {
  90                 NETWORK_LOG(NETWORK_ERROR,
  91                                 "Error!!! failed to get service(profile) list. Error [%s]\n",
  92                                 _net_print_error(Error));
  93
  94                 NET_MEMFREE(profile_info);
  95
  96                 __NETWORK_FUNC_EXIT__;
  97                 return wifi_state;
  98         }
  99
 100         for (i = 0;i < profile_count;i++) {
 101                 switch (profile_info->ProfileState) {
 102                 case NET_STATE_TYPE_ASSOCIATION :
 103                 case NET_STATE_TYPE_CONFIGURATION :
 104                         wifi_state = WIFI_CONNECTING;
 105                         g_strlcpy(profile_name, profile_info->ProfileName,
 106                                         sizeof(profile_info->ProfileName));
 107                         break;
 108                 case NET_STATE_TYPE_READY :
 109                 case NET_STATE_TYPE_ONLINE :
 110                         wifi_state = WIFI_CONNECTED;
 111                         g_strlcpy(profile_name, profile_info->ProfileName,
 112                                         sizeof(profile_info->ProfileName));
 113                         break;
 114                 case NET_STATE_TYPE_UNKNOWN :
 115                 case NET_STATE_TYPE_IDLE :
 116                 case NET_STATE_TYPE_FAILURE :
 117                 case NET_STATE_TYPE_DISCONNECT :
 118                         break;
 119                 }
 120                 profile_info++;
 121         }
 122
 123         if (wifi_state == WIFI_CONNECTED &&
 124             request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag == TRUE)
 125                 wifi_state = WIFI_DISCONNECTING;
 126
 127         __NETWORK_FUNC_EXIT__;
 128         return wifi_state;
 129 }
 130
 131 /*****************************************************************************
 132  *      ConnMan Wi-Fi Client Interface Async API Definition
 133  *****************************************************************************/
 134
 135 EXPORT_API int net_specific_scan_wifi(const char *ssid)
 136 {
 137         __NETWORK_FUNC_ENTER__;
 138
 139         net_err_t Error = NET_ERR_NONE;
 140
 141         if (ssid == NULL) {
 142                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Invalid parameter\n");
 143                 __NETWORK_FUNC_EXIT__;
 144                 return NET_ERR_INVALID_PARAM;
 145         }
 146
 147         if (g_atomic_int_get(&NetworkInfo.ref_count) == 0) {
 148                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Application was not registered\n");
 149                 __NETWORK_FUNC_EXIT__;
 150                 return NET_ERR_APP_NOT_REGISTERED;
 151         }
 152
 153         if (request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag == TRUE) {
 154                 NETWORK_LOG(NETWORK_ASSERT, "Error!! Find hidden AP request already in progress\n");
 155                 __NETWORK_FUNC_EXIT__;
 156                 return NET_ERR_IN_PROGRESS;
 157         }
 158
 159         if (_net_dbus_is_pending_call_used() == TRUE) {
 160                 NETWORK_LOG(NETWORK_ASSERT, "Error!! pending call already in progress\n");
 161                 __NETWORK_FUNC_EXIT__;
 162                 return NET_ERR_IN_PROGRESS;
 163         }
 164
 165         if (_net_get_wifi_state() != WIFI_ON) {
 166                 NETWORK_LOG( NETWORK_ERROR, "Error!!! wifi is powered off!\n");
 167                 __NETWORK_FUNC_EXIT__;
 168                 return NET_ERR_INVALID_OPERATION;
 169         }
 170
 171         request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN].flag = TRUE;
 172         Error = _net_dbus_specific_scan_request(ssid);
 173         if (Error != NET_ERR_NONE) {
 174                 NETWORK_LOG(NETWORK_ERROR, "Error!!! _net_dbus_specific_scan_request() failed. Error [%s]\n",
 175                                 _net_print_error(Error));
 176
 177                 memset(&request_table[NETWORK_REQUEST_TYPE_SPECIFIC_SCAN], 0, sizeof(network_request_table_t));
 178         }
 179
 180         __NETWORK_FUNC_EXIT__;
 181         return Error;
 182 }
 183
 184
 185 EXPORT_API int net_open_connection_with_wifi_info(const net_wifi_connection_info_t *wifi_info)
 186 {
 187         __NETWORK_FUNC_ENTER__;
 188
 189         net_err_t Error = NET_ERR_NONE;
 190
 191         if (wifi_info == NULL) {
 192                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Invalid parameter\n");
 193                 __NETWORK_FUNC_EXIT__;
 194                 return NET_ERR_INVALID_PARAM;
 195         }
 196
 197         if (g_atomic_int_get(&NetworkInfo.ref_count) == 0) {
 198                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Application was not registered\n");
 199                 __NETWORK_FUNC_EXIT__;
 200                 return NET_ERR_APP_NOT_REGISTERED;
 201         }
 202
 203         if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE) {
 204                 NETWORK_LOG(NETWORK_ASSERT, "Error!! Connection open request already in progress\n");
 205                 __NETWORK_FUNC_EXIT__;
 206                 return NET_ERR_IN_PROGRESS;
 207         }
 208
 209         if (_net_dbus_is_pending_call_used() == TRUE) {
 210                 NETWORK_LOG(NETWORK_ASSERT, "Error!! pending call already in progress\n");
 211                 __NETWORK_FUNC_EXIT__;
 212                 return NET_ERR_IN_PROGRESS;
 213         }
 214
 215         if (_net_get_wifi_state() != WIFI_ON) {
 216                 NETWORK_LOG( NETWORK_ERROR, "Error!!! wifi is powered off!\n");
 217                 __NETWORK_FUNC_EXIT__;
 218                 return NET_ERR_INVALID_OPERATION;
 219         }
 220
 221         request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag = TRUE;
 222         Error = _net_open_connection_with_wifi_info(wifi_info);
 223         if (Error != NET_ERR_NONE) {
 224                 NETWORK_LOG(NETWORK_ERROR, "Error!!! net_open_connection_with_wifi_info() failed. Error [%s]\n",
 225                                 _net_print_error(Error));
 226
 227                 memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION], 0, sizeof(network_request_table_t));
 228
 229                 __NETWORK_FUNC_EXIT__;
 230                 return Error;
 231         }
 232
 233         __NETWORK_FUNC_EXIT__;
 234         return NET_ERR_NONE;
 235 }
 236
 237
 238 EXPORT_API int net_wifi_power_on(void)
 239 {
 240         __NETWORK_FUNC_ENTER__;
 241
 242         net_err_t Error = NET_ERR_NONE;
 243         int hotspot_state = 0;
 244
 245         if (g_atomic_int_get(&NetworkInfo.ref_count) == 0) {
 246                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Application was not registered\n");
 247                 __NETWORK_FUNC_EXIT__;
 248                 return NET_ERR_APP_NOT_REGISTERED;
 249         }
 250
 251         vconf_get_int(VCONFKEY_MOBILE_HOTSPOT_MODE, &hotspot_state);
 252         if (hotspot_state & VCONFKEY_MOBILE_HOTSPOT_MODE_WIFI) {
 253                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Wi-Fi hotspot is enabled!\n");
 254                 __NETWORK_FUNC_EXIT__;
 255                 return NET_ERR_INVALID_OPERATION;
 256         }
 257
 258         if (NetworkInfo.wifi_state != WIFI_OFF) {
 259                 NETWORK_LOG(NETWORK_ERROR, "Error!!! wifi is powered on already!\n");
 260                 __NETWORK_FUNC_EXIT__;
 261                 return NET_ERR_INVALID_OPERATION;
 262         }
 263
 264         if (request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag == TRUE) {
 265                 NETWORK_LOG(NETWORK_ASSERT, "Error!! Request already in progress\n");
 266                 __NETWORK_FUNC_EXIT__;
 267                 return NET_ERR_IN_PROGRESS;
 268         }
 269
 270         if (_net_dbus_is_pending_call_used() == TRUE) {
 271                 NETWORK_LOG(NETWORK_ASSERT, "Error!! pending call already in progress\n");
 272                 __NETWORK_FUNC_EXIT__;
 273                 return NET_ERR_IN_PROGRESS;
 274         }
 275
 276         request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag = TRUE;
 277
 278         Error = _net_dbus_load_wifi_driver();
 279         if (Error != NET_ERR_NONE) {
 280                 NETWORK_LOG(NETWORK_EXCEPTION,
 281                                 "Error!!! Failed to request wifi power on/off. Error [%s]\n",
 282                                 _net_print_error(Error));
 283                 memset(&request_table[NETWORK_REQUEST_TYPE_WIFI_POWER], 0, sizeof(network_request_table_t));
 284                 __NETWORK_FUNC_EXIT__;
 285                 return Error;
 286         }
 287
 288         __NETWORK_FUNC_EXIT__;
 289         return NET_ERR_NONE;
 290 }
 291
 292
 293 EXPORT_API int net_wifi_power_off(void)
 294 {
 295         __NETWORK_FUNC_ENTER__;
 296
 297         net_err_t Error = NET_ERR_NONE;
 298
 299         if(g_atomic_int_get(&NetworkInfo.ref_count) == 0) {
 300                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Application was not registered\n");
 301                 __NETWORK_FUNC_EXIT__;
 302                 return NET_ERR_APP_NOT_REGISTERED;
 303         }
 304
 305         if(NetworkInfo.wifi_state == WIFI_OFF) {
 306                 NETWORK_LOG(NETWORK_ERROR, "Error!!! wifi is powered off already!\n");
 307                 __NETWORK_FUNC_EXIT__;
 308                 return NET_ERR_INVALID_OPERATION;
 309         }
 310
 311         if (request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag == TRUE) {
 312                 NETWORK_LOG(NETWORK_ASSERT, "Error!! Request already in progress\n");
 313                 __NETWORK_FUNC_EXIT__;
 314                 return NET_ERR_IN_PROGRESS;
 315         }
 316
 317         if (_net_dbus_is_pending_call_used() == TRUE) {
 318                 if (request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION].flag == TRUE) {
 319                         _net_dbus_clear_pending_call();
 320                         memset(&request_table[NETWORK_REQUEST_TYPE_OPEN_CONNECTION],
 321                                                         0, sizeof(network_request_table_t));
 322                 } else if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE) {
 323                         _net_dbus_clear_pending_call();
 324                         memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS],
 325                                                         0, sizeof(network_request_table_t));
 326                 } else if (request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION].flag == TRUE) {
 327                         _net_dbus_clear_pending_call();
 328                         memset(&request_table[NETWORK_REQUEST_TYPE_CLOSE_CONNECTION],
 329                                                         0, sizeof(network_request_table_t));
 330                 } else {
 331                         NETWORK_LOG(NETWORK_ASSERT, "Error!! pending call already in progress\n");
 332                         __NETWORK_FUNC_EXIT__;
 333                         return NET_ERR_IN_PROGRESS;
 334                 }
 335         }
 336
 337         request_table[NETWORK_REQUEST_TYPE_WIFI_POWER].flag = TRUE;
 338
 339         Error = _net_dbus_remove_wifi_driver();
 340         if (Error != NET_ERR_NONE ) {
 341                 NETWORK_LOG(NETWORK_EXCEPTION,
 342                                 "Error!!! Failed to request wifi power on/off. Error [%s]\n",
 343                                 _net_print_error(Error));
 344                 memset(&request_table[NETWORK_REQUEST_TYPE_WIFI_POWER], 0, sizeof(network_request_table_t));
 345                 __NETWORK_FUNC_EXIT__;
 346                 return Error;
 347         }
 348
 349         NETWORK_LOG(NETWORK_HIGH, "Driver remove successfully\n");
 350
 351         __NETWORK_FUNC_EXIT__;
 352         return NET_ERR_NONE;
 353 }
 354
 355
 356 EXPORT_API int net_scan_wifi(void)
 357 {
 358         __NETWORK_FUNC_ENTER__;
 359
 360         net_err_t Error = NET_ERR_NONE;
 361
 362         if(g_atomic_int_get(&NetworkInfo.ref_count) == 0) {
 363                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Application was not registered\n");
 364                 __NETWORK_FUNC_EXIT__;
 365                 return NET_ERR_APP_NOT_REGISTERED;
 366         }
 367
 368         if(request_table[NETWORK_REQUEST_TYPE_SCAN].flag == TRUE) {
 369                 NETWORK_LOG(NETWORK_ASSERT, "Error!! Request already in progress\n");
 370                 __NETWORK_FUNC_EXIT__;
 371                 return NET_ERR_IN_PROGRESS;
 372         }
 373
 374         if (_net_get_wifi_state() != WIFI_ON) {
 375                 NETWORK_LOG( NETWORK_ERROR, "Error!!! wifi is powered off!\n");
 376                 __NETWORK_FUNC_EXIT__;
 377                 return NET_ERR_INVALID_OPERATION;
 378         }
 379
 380         request_table[NETWORK_REQUEST_TYPE_SCAN].flag = TRUE;
 381
 382         if ((Error = _net_dbus_scan_request()) != NET_ERR_NONE ) {
 383                 NETWORK_LOG(NETWORK_EXCEPTION,
 384                                 "Error!!! Failed to request scan. Error [%s]\n",
 385                                 _net_print_error(Error));
 386                 memset(&request_table[NETWORK_REQUEST_TYPE_SCAN], 0, sizeof(network_request_table_t));
 387                 __NETWORK_FUNC_EXIT__;
 388                 return Error;;
 389         }
 390
 391         NETWORK_LOG(NETWORK_HIGH, "ConnMan successfully finished Wi-Fi scanning\n");
 392
 393         __NETWORK_FUNC_EXIT__;
 394         return NET_ERR_NONE;
 395 }
 396
 397
 398 EXPORT_API int net_wifi_enroll_wps(const char *profile_name, net_wifi_wps_info_t *wps_info)
 399 {
 400         __NETWORK_FUNC_ENTER__;
 401
 402         net_err_t Error = NET_ERR_NONE;
 403
 404         if (_net_check_profile_name(profile_name) != NET_ERR_NONE) {
 405                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Invalid ProfileName passed\n");
 406                 __NETWORK_FUNC_EXIT__;
 407                 return NET_ERR_INVALID_PARAM;
 408         }
 409
 410         if (g_atomic_int_get(&NetworkInfo.ref_count) == 0) {
 411                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Application was not registered\n");
 412                 __NETWORK_FUNC_EXIT__;
 413                 return NET_ERR_APP_NOT_REGISTERED;
 414         }
 415
 416         if (request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag == TRUE) {
 417                 NETWORK_LOG(NETWORK_ASSERT, "Error!! Request already in progress\n");
 418                 __NETWORK_FUNC_EXIT__;
 419                 return NET_ERR_IN_PROGRESS;
 420         }
 421
 422         if (_net_dbus_is_pending_call_used() == TRUE) {
 423                 NETWORK_LOG(NETWORK_ASSERT, "Error!! pending call already in progress\n");
 424                 __NETWORK_FUNC_EXIT__;
 425                 return NET_ERR_IN_PROGRESS;
 426         }
 427
 428         if (_net_get_wifi_state() != WIFI_ON) {
 429                 NETWORK_LOG( NETWORK_ERROR, "Error!!! wifi is powered off!\n");
 430                 __NETWORK_FUNC_EXIT__;
 431                 return NET_ERR_INVALID_OPERATION;
 432         }
 433
 434         request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].flag = TRUE;
 435         snprintf(request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS].ProfileName,
 436                         NET_PROFILE_NAME_LEN_MAX+1, "%s", profile_name);
 437
 438         if(wps_info->type == WIFI_WPS_PBC) {
 439                 Error = _net_dbus_open_connection(profile_name);
 440                 if(Error != NET_ERR_NONE)
 441                 {
 442                         NETWORK_LOG(NETWORK_ERROR,
 443                                         "Error!! Failed to request open connection, Error [%s]\n",
 444                                         _net_print_error(Error));
 445
 446                         memset(&request_table[NETWORK_REQUEST_TYPE_ENROLL_WPS], 0, sizeof(network_request_table_t));
 447
 448                         __NETWORK_FUNC_EXIT__;
 449                         return Error;
 450                 }
 451         }
 452         else if(wps_info->type == WIFI_WPS_PIN) {
 453                 // TODO: handle wps pin
 454         }
 455         else {
 456                 __NETWORK_FUNC_EXIT__;
 457                 return NET_ERR_INVALID_PARAM;
 458         }
 459
 460         __NETWORK_FUNC_EXIT__;
 461         return NET_ERR_NONE;
 462 }
 463
 464
 465 /*****************************************************************************
 466  *      ConnMan Wi-Fi Client Interface Sync Function Definition
 467  *****************************************************************************/
 468
 469
 470 EXPORT_API int net_get_wifi_state(net_wifi_state_t *current_state, net_profile_name_t *profile_name)
 471 {
 472         __NETWORK_FUNC_ENTER__;
 473
 474         net_wifi_state_t wifi_state;
 475
 476         if (g_atomic_int_get(&NetworkInfo.ref_count) == 0) {
 477                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Application was not registered\n");
 478                 __NETWORK_FUNC_EXIT__;
 479                 return NET_ERR_APP_NOT_REGISTERED;
 480         }
 481
 482         if (profile_name == NULL) {
 483                 NETWORK_LOG(NETWORK_ERROR, "Error!!! profile_name is NULL\n");
 484                 return NET_ERR_INVALID_PARAM;
 485         }
 486
 487         memset(profile_name, 0, sizeof(net_profile_name_t));
 488
 489         wifi_state = _net_get_wifi_state();
 490
 491         if (wifi_state == WIFI_OFF) {
 492                 *current_state = WIFI_OFF;
 493                 __NETWORK_FUNC_EXIT__;
 494                 return NET_ERR_NONE;
 495         }
 496
 497         *current_state = __net_get_wifi_service_state(profile_name->ProfileName);
 498
 499         NETWORK_LOG(NETWORK_HIGH, "current state : %d, profile name : %s\n",
 500                         *current_state, profile_name->ProfileName);
 501
 502         __NETWORK_FUNC_EXIT__;
 503         return NET_ERR_NONE;
 504 }
 505
 506
 507 EXPORT_API int net_wifi_set_background_scan_mode(net_wifi_background_scan_mode_t scan_mode)
 508 {
 509         __NETWORK_FUNC_ENTER__;
 510
 511         net_err_t Error = NET_ERR_NONE;
 512
 513         if (g_atomic_int_get(&NetworkInfo.ref_count) == 0) {
 514                 NETWORK_LOG(NETWORK_ERROR, "Error!!! Application not registered\n");
 515                 __NETWORK_FUNC_EXIT__;
 516                 return NET_ERR_APP_NOT_REGISTERED;
 517         }
 518
 519         if (_net_get_wifi_state() != WIFI_ON) {
 520                 NETWORK_LOG( NETWORK_ERROR, "Error!!! wifi is powered off!\n");
 521                 __NETWORK_FUNC_EXIT__;
 522                 return NET_ERR_INVALID_OPERATION;
 523         }
 524
 525         NETWORK_LOG(NETWORK_HIGH,  "BGScan Mode [%d]\n", scan_mode);
 526
 527         if ((Error = _net_dbus_set_bgscan_mode(scan_mode)) != NET_ERR_NONE) {
 528                 NETWORK_LOG(NETWORK_EXCEPTION,
 529                                 "Error!!! Failed to set bgscan mode. Error [%s]\n",
 530                                 _net_print_error(Error));
 531
 532                 __NETWORK_FUNC_EXIT__;
 533                 return Error;
 534         }
 535
 536         NETWORK_LOG(NETWORK_HIGH, "Set BGScan mode Request to connman is successfull\n");
 537
 538         __NETWORK_FUNC_EXIT__;
 539         return NET_ERR_NONE;
 540 }
 541
 542 #ifdef __cplusplus
 543 }
 544 #endif /* __cplusplus */
 545