sources/wearable/src/net/wifi_manager.c

   1 /*
   2  * Copyright (c) 2014 - 2015 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * PROPRIETARY/CONFIDENTIAL
   5  *
   6  * This software is the confidential and proprietary information of
   7  * SAMSUNG ELECTRONICS (Confidential Information).
   8  * You shall not disclose such Confidential Information and shall
   9  * use it only in accordance with the terms of the license agreement
  10  * you entered into with SAMSUNG ELECTRONICS.  SAMSUNG make no
  11  * representations or warranties about the suitability
  12  * of the software, either express or implied, including but not
  13  * limited to the implied warranties of merchantability, fitness for a particular purpose, or non-
  14  * infringement. SAMSUNG shall not be liable for any damages suffered by licensee as
  15  * a result of using, modifying or distributing this software or its derivatives.
  16  */
  17
  18
  19 #include <dlog.h>
  20 #include <glib.h>
  21
  22 #include "util.h"
  23 #include "net/util/vconf_helper.h"
  24 #include "net/wifi_manager.h"
  25 #include "net/wifi_generate_pin.h"
  26
  27 typedef enum {
  28         WIFI_MANAGER_CB_DEVICE_STATE_CHANGED,
  29         WIFI_MANAGER_CB_CONNECTION_STATE_CHANGED,
  30         WIFI_MANAGER_CB_BACKGROUND_SCAN
  31 } wifi_manager_cb_type;
  32
  33 struct _wifi_manager_object {
  34         GList *cb_data_list;
  35         GList *config_list;
  36 };
  37
  38 struct _wifi_ap_object {
  39         wifi_ap_h ap;
  40         gint rssi;
  41         bool wps_mode;
  42
  43         wifi_error_e last_connection_error;
  44         gboolean is_captiveportal;
  45 };
  46
  47 typedef struct _wifi_config_object {
  48         wifi_config_h handle;
  49         gchar *name;
  50         gchar *passphrase;
  51         wifi_security_type_e security_type;
  52         wifi_error_e last_error;
  53 } wifi_config_object;
  54
  55 typedef struct {
  56         wifi_manager_object *manager;
  57         wifi_ap_object *ap;
  58         wifi_manager_cb_type type;
  59         wifi_manager_generic_cb cb;
  60         wifi_manager_generic_state_changed_cb state_changed_cb;
  61         gpointer user_data;
  62 } wifi_manager_cb_data;
  63
  64 static wifi_manager_object *_last_initailized_wifi_manager;
  65
  66 static void            _update_wifi_config_list(wifi_manager_object *manager);
  67 static wifi_ap_object *_create_ap_object_by_ap_h(wifi_ap_h ap);
  68
  69 static void __wifi_common_cb(wifi_error_e error_code, gpointer user_data)
  70 {
  71         wifi_manager_cb_data *cb_data = (wifi_manager_cb_data *)user_data;
  72         WIFI_RET_IF_FAIL(cb_data);
  73
  74     WIFI_LOG_INFO("common cb");
  75
  76         if (cb_data->cb)
  77                 cb_data->cb(cb_data->manager, cb_data->ap, error_code, cb_data->user_data);
  78
  79         g_free(cb_data);
  80 }
  81
  82 static void __wifi_background_scan_cb(wifi_error_e error_code, gpointer user_data)
  83 {
  84         wifi_manager_cb_data *cb_data = (wifi_manager_cb_data *)user_data;
  85         WIFI_RET_IF_FAIL(cb_data != NULL);
  86
  87         if (cb_data->cb)
  88                 cb_data->cb(cb_data->manager, cb_data->ap, error_code, cb_data->user_data);
  89 }
  90
  91 static void __wifi_device_state_changed_cb(wifi_device_state_e state, void *user_data)
  92 {
  93         wifi_manager_cb_data *cb_data = (wifi_manager_cb_data *)user_data;
  94         WIFI_RET_IF_FAIL(cb_data);
  95
  96         if (state == WIFI_DEVICE_STATE_ACTIVATED) {
  97                 _update_wifi_config_list(cb_data->manager);
  98         }
  99
 100         if (cb_data->state_changed_cb)
 101                 cb_data->state_changed_cb(cb_data->manager,
 102                                           state,
 103                                           WIFI_CONNECTION_STATE_FAILURE, NULL,
 104                                           WIFI_RSSI_LEVEL_0, cb_data->user_data);
 105 }
 106
 107 static void __wifi_connection_state_changed_cb(wifi_connection_state_e state,
 108                                                wifi_ap_h ap, void *user_data)
 109 {
 110         wifi_manager_cb_data *cb_data = (wifi_manager_cb_data *)user_data;
 111         WIFI_RET_IF_FAIL(cb_data);
 112
 113         if (state == WIFI_CONNECTION_STATE_CONNECTED ||
 114             state == WIFI_CONNECTION_STATE_DISCONNECTED ||
 115             state == WIFI_CONNECTION_STATE_FAILURE) {
 116                 _update_wifi_config_list(cb_data->manager);
 117         }
 118
 119         if (cb_data->state_changed_cb) {
 120                 wifi_ap_object *ap_obj = _create_ap_object_by_ap_h(ap);
 121                 cb_data->state_changed_cb(cb_data->manager,
 122                                           WIFI_DEVICE_STATE_DEACTIVATED,
 123                                           state, ap_obj,
 124                                           WIFI_RSSI_LEVEL_0, cb_data->user_data);
 125                 wifi_manager_ap_destroy(ap_obj);
 126         }
 127 }
 128
 129 static bool __wifi_config_list_cb(const wifi_config_h config, void *user_data)
 130 {
 131
 132     __WIFI_FUNC_ENTER__;
 133         wifi_manager_object *manager = user_data;
 134         wifi_config_object *config_obj;
 135         WIFI_RET_VAL_IF_FAIL(config != NULL, true);
 136         WIFI_RET_VAL_IF_FAIL(manager != NULL, true);
 137
 138         config_obj = g_new0(wifi_config_object, 1);
 139         WIFI_RET_VAL_IF_FAIL(config_obj != NULL, true);
 140
 141         wifi_config_clone(config, &(config_obj->handle));
 142         wifi_config_get_name(config, &(config_obj->name));
 143         wifi_config_get_security_type(config, &(config_obj->security_type));
 144         manager->config_list = g_list_append(manager->config_list, config_obj);
 145
 146     __WIFI_FUNC_EXIT__;
 147         return true;
 148 }
 149
 150 static void _wifi_config_destory(gpointer data)
 151 {
 152         wifi_config_object *config = data;
 153         if (config->handle) {
 154                 wifi_config_destroy(config->handle);
 155         }
 156         if (config->name) {
 157                 g_free(config->name);
 158         }
 159         if (config->passphrase) {
 160                 g_free(config->passphrase);
 161         }
 162         g_free(config);
 163 }
 164
 165 static void _clear_wifi_config_list(wifi_manager_object *manager)
 166 {
 167
 168     __WIFI_FUNC_ENTER__;
 169         WIFI_RET_IF_FAIL(manager != NULL);
 170         WIFI_RET_IF_FAIL(manager->config_list != NULL);
 171
 172         g_list_free_full(manager->config_list, _wifi_config_destory);
 173         manager->config_list = NULL;
 174
 175     __WIFI_FUNC_EXIT__;
 176 }
 177
 178 static void _update_wifi_config_list(wifi_manager_object *manager)
 179 {
 180         wifi_error_e err;
 181         WIFI_RET_IF_FAIL(manager);
 182
 183         __WIFI_FUNC_ENTER__;
 184
 185         if (manager->config_list) {
 186                 _clear_wifi_config_list(manager);
 187         }
 188
 189         err = wifi_config_foreach_configuration(__wifi_config_list_cb, manager);
 190         if (err != WIFI_ERROR_NONE) {
 191                 WIFI_LOG_ERR("wifi_config_foreach_configuration() is failed. error = %s",
 192                              wifi_error_to_string(err));
 193         }
 194
 195     __WIFI_FUNC_EXIT__;
 196 }
 197
 198 static bool __compare_wifi_security_type(wifi_security_type_e sec_type1, wifi_security_type_e sec_type2)
 199 {
 200         if (sec_type1 == sec_type2)
 201                 return true;
 202
 203         if ((sec_type1 == WIFI_SECURITY_TYPE_WPA_PSK || sec_type1 == WIFI_SECURITY_TYPE_WPA2_PSK)
 204             && (sec_type2 == WIFI_SECURITY_TYPE_WPA_PSK || sec_type2 == WIFI_SECURITY_TYPE_WPA2_PSK))
 205                 return true;
 206
 207         return false;
 208 }
 209
 210 static wifi_config_object *_find_wifi_config_by_wifi_ap(wifi_manager_object *manager,
 211                                                         wifi_ap_object *ap)
 212 {
 213         GList *config_list;
 214         gchar *ssid;
 215         wifi_security_type_e sec_type;
 216         WIFI_RET_VAL_IF_FAIL(manager, NULL);
 217         WIFI_RET_VAL_IF_FAIL(ap, NULL);
 218
 219         ssid = wifi_manager_ap_get_ssid(ap);
 220         WIFI_RET_VAL_IF_FAIL(ssid, NULL);
 221         sec_type = wifi_manager_ap_get_security_type(ap);
 222
 223         config_list = manager->config_list;
 224         while (config_list) {
 225                 wifi_config_object *config = config_list->data;
 226                 if (!g_strcmp0(config->name, ssid) && __compare_wifi_security_type(config->security_type, sec_type)) {
 227                         g_free(ssid);
 228                         return config;
 229                 }
 230                 config_list = config_list->next;
 231         }
 232         g_free(ssid);
 233         return NULL;
 234 }
 235
 236 static wifi_ap_object *_create_ap_object_by_ap_h(wifi_ap_h ap)
 237 {
 238         wifi_ap_object *ap_obj = g_new0(wifi_ap_object, 1);
 239         gboolean is_create_failed = FALSE;
 240         if (!ap_obj) {
 241                 return NULL;
 242         }
 243         if (WIFI_ERROR_NONE != wifi_ap_clone(&(ap_obj->ap), ap)) {
 244                 is_create_failed = TRUE;
 245         } else if (WIFI_ERROR_NONE != wifi_ap_get_rssi(ap, &(ap_obj->rssi))) {
 246                 is_create_failed = TRUE;
 247         } else if (WIFI_ERROR_NONE != wifi_ap_is_wps_supported(ap, &(ap_obj->wps_mode))) {
 248                 is_create_failed = TRUE;
 249         }
 250
 251         if (is_create_failed) {
 252                 wifi_manager_ap_destroy(ap_obj);
 253                 return NULL;
 254         }
 255         ap_obj->last_connection_error = WIFI_ERROR_NONE;
 256         ap_obj->is_captiveportal = FALSE;
 257         return ap_obj;
 258 }
 259
 260 gint wifi_manager_default_compare_ap(gconstpointer a, gconstpointer b)
 261 {
 262         wifi_ap_object *ap_obj1 = (wifi_ap_object *)a;
 263         wifi_ap_object *ap_obj2 = (wifi_ap_object *)b;
 264         wifi_connection_state_e state1 = WIFI_CONNECTION_STATE_DISCONNECTED;
 265         wifi_connection_state_e state2 = WIFI_CONNECTION_STATE_DISCONNECTED;
 266         bool favorite1 = false;
 267         bool favorite2 = false;
 268
 269         wifi_ap_get_connection_state(ap_obj1->ap, &state1);
 270         wifi_ap_get_connection_state(ap_obj2->ap, &state2);
 271         if (state1 != state2) {
 272                 if (state1 == WIFI_CONNECTION_STATE_CONNECTED)
 273                         return -1;
 274                 if (state2 == WIFI_CONNECTION_STATE_CONNECTED)
 275                         return 1;
 276
 277                 if (state1 == WIFI_CONNECTION_STATE_CONFIGURATION)
 278                         return -1;
 279                 if (state2 == WIFI_CONNECTION_STATE_CONFIGURATION)
 280                         return 1;
 281
 282                 if (state1 == WIFI_CONNECTION_STATE_ASSOCIATION)
 283                         return -1;
 284                 if (state2 == WIFI_CONNECTION_STATE_ASSOCIATION)
 285                         return 1;
 286         }
 287
 288         favorite1 = wifi_manager_ap_is_favorite(
 289                 _last_initailized_wifi_manager, ap_obj1);
 290         favorite2 = wifi_manager_ap_is_favorite(
 291                 _last_initailized_wifi_manager, ap_obj2);
 292         if (favorite1 != favorite2) {
 293                 if (favorite1)
 294                         return -1;
 295                 if (favorite2)
 296                         return 1;
 297         }
 298
 299         /* Alphabetical order */
 300         /*
 301         return strcasecmp((const char *) wifi_device1->ssid,
 302                         (const char *) wifi_device2->ssid);
 303         */
 304         /* RSSI preferred */
 305         return((ap_obj1->rssi >= ap_obj2->rssi) ? -1 : 1);
 306 }
 307
 308 #ifdef TIZEN_TELEPHONY_ENABLE
 309 static bool __update_ap_list_foreach(wifi_ap_h ap, void *user_data)
 310 {
 311         GList **ap_list = user_data;
 312         wifi_ap_object *ap_obj = NULL;
 313         WIFI_RET_VAL_IF_FAIL(ap_list, true);
 314
 315         ap_obj = _create_ap_object_by_ap_h(ap);
 316         WIFI_RET_VAL_IF_FAIL(ap_obj, true);
 317
 318         *ap_list = g_list_insert_sorted(*ap_list, ap_obj, wifi_manager_default_compare_ap);
 319         return true;
 320 }
 321 #else
 322 // Find AP list except EAP type when WC1-S Bluetooth model(No SIM).
 323 static bool __update_ap_list_foreach(wifi_ap_h ap, void *user_data)
 324 {
 325         GList **ap_list = user_data;
 326         wifi_security_type_e sec_type = WIFI_SECURITY_TYPE_NONE;
 327         wifi_error_e err;
 328         wifi_ap_object *ap_obj = NULL;
 329         WIFI_RET_VAL_IF_FAIL(ap_list != NULL, true);
 330
 331         err = wifi_ap_get_security_type(ap, &sec_type);
 332         WIFI_RET_VAL_IF_FAIL(err == WIFI_ERROR_NONE, true);
 333         if (sec_type == WIFI_SECURITY_TYPE_EAP) {
 334                 WIFI_LOG_INFO("EAP type AP skip(No SIM model).");
 335                 return true;
 336         }
 337
 338         ap_obj = _create_ap_object_by_ap_h(ap);
 339         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, true);
 340
 341         *ap_list = g_list_insert_sorted(*ap_list, ap_obj, wifi_manager_default_compare_ap);
 342         return true;
 343 }
 344 #endif
 345
 346 static void _delete_cb_data_by_type(wifi_manager_object *manager, wifi_manager_cb_type type)
 347 {
 348         GList *cb_data_list = manager->cb_data_list;
 349         while (cb_data_list) {
 350                 GList *next = cb_data_list->next;
 351                 wifi_manager_cb_data *cb_data = cb_data_list->data;
 352                 if (cb_data->type == type) {
 353                         manager->cb_data_list =
 354                                 g_list_delete_link(manager->cb_data_list, cb_data_list);
 355                         g_free(cb_data);
 356                 }
 357                 cb_data_list = next;
 358         }
 359 }
 360
 361 static gchar *_ap_get_proxy_address(wifi_ap_object *ap_obj)
 362 {
 363         gchar *proxy_address = NULL;
 364         wifi_error_e err;
 365         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, NULL);
 366
 367         err = wifi_ap_get_proxy_address(ap_obj->ap,
 368                                         WIFI_ADDRESS_FAMILY_IPV4, &proxy_address);
 369         if (err != WIFI_ERROR_NONE) {
 370                 WIFI_LOG_ERR("wifi_ap_get_proxy_address() is failed. error = %s",
 371                              wifi_error_to_string(err));
 372                 if (proxy_address) {
 373                         g_free(proxy_address);
 374                 }
 375                 return NULL;
 376         }
 377         if (!proxy_address || strlen(proxy_address) == 0) {
 378                 WIFI_LOG_INFO("proxy_address is NULL.");
 379                 if (proxy_address) {
 380                         g_free(proxy_address);
 381                 }
 382                 return NULL;
 383         }
 384         return proxy_address;
 385 }
 386
 387 /*
 388  * Wi-Fi Manager API
 389  */
 390 wifi_manager_object *wifi_manager_new()
 391 {
 392         return g_new0(wifi_manager_object, 1);
 393 }
 394
 395 void wifi_manager_free(wifi_manager_object *manager)
 396 {
 397         if (manager)
 398                 g_free(manager);
 399 }
 400
 401 wifi_error_e wifi_manager_init(wifi_manager_object *manager)
 402 {
 403         wifi_error_e err;
 404         bool is_activate;
 405         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 406
 407         err = wifi_initialize();
 408         if (err != WIFI_ERROR_NONE) {
 409                 return err;
 410         }
 411         err = wifi_manager_is_activated(manager, &is_activate);
 412         if (err == WIFI_ERROR_NONE) {
 413                 if (is_activate) {
 414                         _update_wifi_config_list(manager);
 415                 }
 416         } else {
 417                 WIFI_LOG_ERR("wifi_manager_is_activated() is failed. error = %s",
 418                              wifi_error_to_string(err));
 419         }
 420         _last_initailized_wifi_manager = manager;
 421         return err;
 422 }
 423
 424 wifi_error_e wifi_manager_deinit(wifi_manager_object *manager)
 425 {
 426         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 427
 428         _clear_wifi_config_list(manager);
 429         if (manager->cb_data_list) {
 430                 GList *cb_data_list = manager->cb_data_list;
 431                 while (cb_data_list) {
 432                         wifi_manager_cb_data *cb_data = cb_data_list->data;
 433                         if (cb_data->type == WIFI_MANAGER_CB_DEVICE_STATE_CHANGED) {
 434                                 wifi_unset_device_state_changed_cb();
 435                         } else if (cb_data->type == WIFI_MANAGER_CB_CONNECTION_STATE_CHANGED) {
 436                                 wifi_unset_connection_state_changed_cb();
 437                         } else if (cb_data->type == WIFI_MANAGER_CB_BACKGROUND_SCAN) {
 438                                 wifi_unset_background_scan_cb();
 439                         }
 440
 441                         cb_data_list = cb_data_list->next;
 442                 }
 443                 g_list_free_full(manager->cb_data_list, g_free);
 444         }
 445         return wifi_deinitialize();
 446 }
 447
 448 wifi_error_e wifi_manager_generate_wps_pin(wifi_manager_object *manager, char **pin)
 449 {
 450         WIFI_RET_VAL_IF_FAIL(manager != NULL, WIFI_ERROR_INVALID_PARAMETER);
 451         WIFI_RET_VAL_IF_FAIL(pin != NULL, WIFI_ERROR_INVALID_PARAMETER);
 452         unsigned int rpin = 0;
 453         char npin[9] = { '\0' };
 454         int pin_len = 0;
 455
 456         rpin = wifi_generate_pin();
 457         if (rpin > 0)
 458                 g_snprintf(npin, sizeof(npin), "%08d", rpin);
 459
 460         pin_len = strlen(npin);
 461         if (pin_len != 8) {
 462                 WIFI_LOG_ERR("Invalid PIN");
 463                 return WIFI_ERROR_OPERATION_FAILED;
 464         }
 465         *pin = g_strdup(npin);
 466
 467         return WIFI_ERROR_NONE;
 468 }
 469
 470 wifi_manager_object *wifi_manager_new_with_init(wifi_error_e *error)
 471 {
 472         wifi_manager_object *manager = wifi_manager_new();
 473         *error = WIFI_ERROR_NONE;
 474         if (manager) {
 475                 *error = wifi_manager_init(manager);
 476                 if (*error != WIFI_ERROR_NONE) {
 477                         wifi_manager_free(manager);
 478                 }
 479         } else
 480                 *error = WIFI_ERROR_OUT_OF_MEMORY;
 481         return manager;
 482 }
 483
 484 wifi_error_e wifi_manager_free_with_deinit(wifi_manager_object *manager)
 485 {
 486         wifi_error_e error = wifi_manager_deinit(manager);
 487         wifi_manager_free(manager);
 488         return error;
 489 }
 490
 491 wifi_error_e wifi_manager_get_csccode(wifi_manager_object *manager, wifi_manager_csccode *code)
 492 {
 493         WIFI_RET_VAL_IF_FAIL(manager != NULL, WIFI_ERROR_INVALID_PARAMETER);
 494         WIFI_RET_VAL_IF_FAIL(code != NULL, WIFI_ERROR_INVALID_PARAMETER);
 495
 496         *code = WIFI_MANAGER_CSC_UNKNOWN;
 497         return WIFI_ERROR_NONE;
 498 }
 499
 500 wifi_error_e wifi_manager_scan(wifi_manager_object *manager,
 501                                wifi_manager_generic_cb callback, gpointer user_data)
 502 {
 503         wifi_manager_cb_data *cb_data = NULL;
 504         WIFI_RET_VAL_IF_FAIL(manager != NULL, WIFI_ERROR_INVALID_PARAMETER);
 505
 506         cb_data = g_new0(wifi_manager_cb_data, 1);
 507         if (cb_data) {
 508                 cb_data->manager = manager;
 509                 cb_data->cb = callback;
 510                 cb_data->user_data = user_data;
 511
 512                 WIFI_LOG_INFO("Wi-Fi Scan start.");
 513                 return wifi_scan(__wifi_common_cb, cb_data);
 514         }
 515         return WIFI_ERROR_OUT_OF_MEMORY;
 516 }
 517
 518 wifi_error_e wifi_manager_get_found_ap_list(wifi_manager_object *manager,
 519                                             GList **ap_list)
 520 {
 521         wifi_error_e error = WIFI_ERROR_INVALID_PARAMETER;
 522         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 523
 524         error = wifi_foreach_found_aps(__update_ap_list_foreach, ap_list);
 525         if (error != WIFI_ERROR_NONE) {
 526                 if (*ap_list) {
 527                         g_list_free(*ap_list);
 528                         *ap_list = NULL;
 529                 }
 530         }
 531         return error;
 532 }
 533
 534 wifi_error_e wifi_manager_activate(wifi_manager_object *manager,
 535                                    wifi_manager_generic_cb callback, gpointer user_data)
 536 {
 537         wifi_manager_cb_data *cb_data = NULL;
 538         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 539
 540     WIFI_LOG_ERR("+");
 541
 542         cb_data = g_new0(wifi_manager_cb_data, 1);
 543         if (cb_data) {
 544                 cb_data->manager = manager;
 545                 cb_data->cb = callback;
 546                 cb_data->user_data = user_data;
 547                 return wifi_activate(__wifi_common_cb, cb_data);
 548         }
 549         return WIFI_ERROR_OUT_OF_MEMORY;
 550 }
 551
 552 wifi_error_e wifi_manager_deactivate(wifi_manager_object *manager,
 553                     wifi_manager_generic_cb callback, gpointer user_data)
 554 {
 555         wifi_manager_cb_data *cb_data = NULL;
 556         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 557
 558     WIFI_LOG_ERR("+");
 559
 560         cb_data = g_new0(wifi_manager_cb_data, 1);
 561         if (cb_data) {
 562                 cb_data->manager = manager;
 563                 cb_data->cb = callback;
 564                 cb_data->user_data = user_data;
 565                 return wifi_deactivate(__wifi_common_cb, cb_data);
 566         }
 567         return WIFI_ERROR_OUT_OF_MEMORY;
 568 }
 569
 570 wifi_error_e wifi_manager_is_activated(wifi_manager_object *manager, bool *activated)
 571 {
 572         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 573         return wifi_is_activated(activated);
 574 }
 575
 576 wifi_error_e wifi_manager_set_device_state_changed_cb(wifi_manager_object *manager,
 577                                                       wifi_manager_generic_state_changed_cb callback, void *user_data)
 578 {
 579         wifi_manager_cb_data *cb_data = NULL;
 580         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 581         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 582
 583         cb_data = g_new0(wifi_manager_cb_data, 1);
 584         WIFI_RET_VAL_IF_FAIL(cb_data, WIFI_ERROR_OUT_OF_MEMORY);
 585
 586         cb_data->manager = manager;
 587         cb_data->type = WIFI_MANAGER_CB_DEVICE_STATE_CHANGED;
 588         cb_data->state_changed_cb = callback;
 589         cb_data->user_data = user_data;
 590         err = wifi_set_device_state_changed_cb(
 591                 __wifi_device_state_changed_cb, cb_data);
 592         if (err == WIFI_ERROR_NONE)
 593                 manager->cb_data_list = g_list_append(manager->cb_data_list, cb_data);
 594         return err;
 595 }
 596
 597 wifi_error_e wifi_manager_unset_device_state_changed_cb(wifi_manager_object *manager)
 598 {
 599         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 600         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 601
 602         err = wifi_unset_device_state_changed_cb();
 603         _delete_cb_data_by_type(manager, WIFI_MANAGER_CB_DEVICE_STATE_CHANGED);
 604         return err;
 605 }
 606
 607 wifi_error_e wifi_manager_set_background_scan_cb(wifi_manager_object *manager,
 608                                                  wifi_manager_generic_cb callback, void *user_data)
 609 {
 610         wifi_manager_cb_data *cb_data = NULL;
 611         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 612         WIFI_RET_VAL_IF_FAIL(manager != NULL, WIFI_ERROR_INVALID_PARAMETER);
 613
 614         cb_data = g_new0(wifi_manager_cb_data, 1);
 615         WIFI_RET_VAL_IF_FAIL(cb_data != NULL, WIFI_ERROR_OUT_OF_MEMORY);
 616
 617         cb_data->manager = manager;
 618         cb_data->type = WIFI_MANAGER_CB_BACKGROUND_SCAN;
 619         cb_data->cb = callback;
 620         cb_data->user_data = user_data;
 621         err = wifi_set_background_scan_cb(__wifi_background_scan_cb, cb_data);
 622         if (err == WIFI_ERROR_NONE)
 623                 manager->cb_data_list = g_list_append(manager->cb_data_list, cb_data);
 624         return err;
 625 }
 626
 627 wifi_error_e wifi_manager_unset_background_scan_cb(wifi_manager_object *manager)
 628 {
 629         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 630         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 631
 632         err = wifi_unset_background_scan_cb();
 633         _delete_cb_data_by_type(manager, WIFI_MANAGER_CB_BACKGROUND_SCAN);
 634         return err;
 635 }
 636
 637 wifi_error_e wifi_manager_set_connection_state_changed_cb(wifi_manager_object *manager,
 638                                                           wifi_manager_generic_state_changed_cb callback, void *user_data)
 639 {
 640         wifi_manager_cb_data *cb_data = NULL;
 641         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 642         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 643
 644         cb_data = g_new0(wifi_manager_cb_data, 1);
 645         WIFI_RET_VAL_IF_FAIL(cb_data, WIFI_ERROR_OUT_OF_MEMORY);
 646
 647         cb_data->manager = manager;
 648         cb_data->type = WIFI_MANAGER_CB_CONNECTION_STATE_CHANGED;
 649         cb_data->state_changed_cb = callback;
 650         cb_data->user_data = user_data;
 651         err = wifi_set_connection_state_changed_cb(
 652                 __wifi_connection_state_changed_cb, cb_data);
 653         if (err == WIFI_ERROR_NONE)
 654                 manager->cb_data_list = g_list_append(manager->cb_data_list, cb_data);
 655         return err;
 656 }
 657
 658 wifi_error_e wifi_manager_unset_connection_state_changed_cb(wifi_manager_object *manager)
 659 {
 660         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 661         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 662
 663         err = wifi_unset_connection_state_changed_cb();
 664         _delete_cb_data_by_type(manager, WIFI_MANAGER_CB_CONNECTION_STATE_CHANGED);
 665         return err;
 666 }
 667
 668 wifi_error_e wifi_manager_get_connection_state(wifi_manager_object *manager,
 669                                                wifi_connection_state_e *connection_state)
 670 {
 671         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 672         return wifi_get_connection_state(connection_state);
 673 }
 674
 675 wifi_error_e wifi_manager_connect(wifi_manager_object *manager,
 676                                   wifi_ap_object *ap, wifi_manager_generic_cb callback, gpointer user_data)
 677 {
 678         wifi_manager_cb_data *cb_data = NULL;
 679         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 680         WIFI_RET_VAL_IF_FAIL(ap, WIFI_ERROR_INVALID_PARAMETER);
 681
 682         cb_data = g_new0(wifi_manager_cb_data, 1);
 683         if (cb_data) {
 684                 cb_data->manager = manager;
 685                 cb_data->ap = ap;
 686                 cb_data->cb = callback;
 687                 cb_data->user_data = user_data;
 688                 return wifi_connect(ap->ap, __wifi_common_cb, cb_data);
 689         }
 690         return WIFI_ERROR_OUT_OF_MEMORY;
 691 }
 692
 693 wifi_error_e wifi_manager_connect_by_wps_pbc(wifi_manager_object *manager,
 694                                              wifi_ap_object *ap, wifi_manager_generic_cb callback, gpointer user_data)
 695 {
 696         wifi_manager_cb_data *cb_data = NULL;
 697         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 698         WIFI_RET_VAL_IF_FAIL(ap, WIFI_ERROR_INVALID_PARAMETER);
 699
 700         cb_data = g_new0(wifi_manager_cb_data, 1);
 701         if (cb_data) {
 702                 cb_data->manager = manager;
 703                 cb_data->ap = ap;
 704                 cb_data->cb = callback;
 705                 cb_data->user_data = user_data;
 706                 return wifi_connect_by_wps_pbc(ap->ap, __wifi_common_cb, cb_data);
 707         }
 708         return WIFI_ERROR_OUT_OF_MEMORY;
 709 }
 710
 711 wifi_error_e wifi_manager_connect_by_wps_pin(wifi_manager_object *manager,
 712                                              wifi_ap_object *ap, const gchar *pin,
 713                                              wifi_manager_generic_cb callback, gpointer user_data)
 714 {
 715         wifi_manager_cb_data *cb_data = NULL;
 716         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 717         WIFI_RET_VAL_IF_FAIL(ap, WIFI_ERROR_INVALID_PARAMETER);
 718
 719         cb_data = g_new0(wifi_manager_cb_data, 1);
 720         if (cb_data) {
 721                 cb_data->manager = manager;
 722                 cb_data->ap = ap;
 723                 cb_data->cb = callback;
 724                 cb_data->user_data = user_data;
 725                 return wifi_connect_by_wps_pin(ap->ap, pin, __wifi_common_cb, cb_data);
 726         }
 727         return WIFI_ERROR_OUT_OF_MEMORY;
 728 }
 729
 730 wifi_error_e wifi_manager_disconnect(wifi_manager_object *manager,
 731                                      wifi_ap_object *ap, wifi_manager_generic_cb callback, gpointer user_data)
 732 {
 733         wifi_manager_cb_data *cb_data = NULL;
 734         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 735         WIFI_RET_VAL_IF_FAIL(ap, WIFI_ERROR_INVALID_PARAMETER);
 736
 737         cb_data = g_new0(wifi_manager_cb_data, 1);
 738         if (cb_data) {
 739                 cb_data->manager = manager;
 740                 cb_data->ap = ap;
 741                 cb_data->cb = callback;
 742                 cb_data->user_data = user_data;
 743                 return wifi_disconnect(ap->ap, __wifi_common_cb, cb_data);
 744         }
 745         return WIFI_ERROR_OUT_OF_MEMORY;
 746 }
 747
 748 wifi_error_e wifi_manager_get_connected_ap(wifi_manager_object *manager,
 749                                            wifi_ap_object **ap)
 750 {
 751         wifi_ap_h ap_h = NULL;
 752         wifi_error_e err = WIFI_ERROR_INVALID_PARAMETER;
 753         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 754
 755         err = wifi_get_connected_ap(&ap_h);
 756         if (err != WIFI_ERROR_NONE) {
 757                 if (ap_h) {
 758                         wifi_ap_destroy(ap_h);
 759                 }
 760                 return err;
 761         }
 762         *ap = _create_ap_object_by_ap_h(ap_h);
 763         wifi_ap_destroy(ap_h);
 764         if (!(*ap))
 765                 return WIFI_ERROR_OUT_OF_MEMORY;
 766         return WIFI_ERROR_NONE;
 767 }
 768
 769 /*
 770  * Wi-Fi AP API
 771  */
 772 wifi_ap_object *wifi_manager_ap_clone(wifi_ap_object *ap_obj)
 773 {
 774         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, NULL);
 775
 776         return _create_ap_object_by_ap_h(ap_obj->ap);
 777 }
 778
 779 void wifi_manager_ap_destroy(wifi_ap_object *ap_obj)
 780 {
 781         WIFI_RET_IF_FAIL(ap_obj != NULL);
 782
 783         wifi_ap_destroy(ap_obj->ap);
 784         g_free(ap_obj);
 785 }
 786
 787 gboolean wifi_manager_ap_is_equals(wifi_ap_object *ap_obj1, wifi_ap_object *ap_obj2)
 788 {
 789         gchar *ssid1, *ssid2;
 790         wifi_security_type_e sec_type1, sec_type2;
 791         gboolean is_equals = FALSE;
 792         WIFI_RET_VAL_IF_FAIL(ap_obj1 != NULL, FALSE);
 793         WIFI_RET_VAL_IF_FAIL(ap_obj2 != NULL, FALSE);
 794
 795         ssid1 = wifi_manager_ap_get_ssid(ap_obj1);
 796         ssid2 = wifi_manager_ap_get_ssid(ap_obj2);
 797
 798         sec_type1 = wifi_manager_ap_get_security_type(ap_obj1);
 799         sec_type2 = wifi_manager_ap_get_security_type(ap_obj2);
 800
 801         is_equals = (!g_strcmp0(ssid1, ssid2)) && (sec_type1 == sec_type2);
 802
 803         g_free(ssid1);
 804         g_free(ssid2);
 805
 806         return is_equals;
 807 }
 808
 809 void wifi_manager_ap_refresh(wifi_ap_object *ap_obj)
 810 {
 811         WIFI_RET_IF_FAIL(ap_obj);
 812
 813         wifi_error_e err = wifi_ap_refresh(ap_obj->ap);
 814         if (err != WIFI_ERROR_NONE) {
 815                 WIFI_LOG_ERR("wifi_ap_refresh() is failed. error = %s",
 816                              wifi_error_to_string(err));
 817         }
 818 }
 819
 820 wifi_ap_h wifi_manager_ap_get_ap_h(wifi_ap_object *ap_obj)
 821 {
 822         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
 823
 824         return ap_obj->ap;
 825 }
 826
 827 wifi_error_e wifi_manager_ap_get_last_connection_error(wifi_manager_object *manager,
 828                                                        wifi_ap_object *ap_obj)
 829 {
 830         WIFI_RET_VAL_IF_FAIL(manager, WIFI_ERROR_INVALID_PARAMETER);
 831         WIFI_RET_VAL_IF_FAIL(ap_obj, WIFI_ERROR_INVALID_PARAMETER);
 832
 833         if (wifi_manager_ap_is_favorite(manager, ap_obj)) {
 834                 wifi_config_object *config = _find_wifi_config_by_wifi_ap(manager, ap_obj);
 835                 if (config) {
 836                         // Favorite ap's last connection error
 837                         return config->last_error;
 838                 }
 839         }
 840         // Connection failed ap's last connection error
 841         return ap_obj->last_connection_error;
 842 }
 843
 844 void wifi_manager_ap_set_last_connection_error(wifi_ap_object *ap_obj, wifi_error_e error)
 845 {
 846         WIFI_RET_IF_FAIL(ap_obj);
 847
 848         ap_obj->last_connection_error = error;
 849 }
 850
 851 gboolean wifi_manager_ap_is_captiveportal(wifi_manager_object *manager, wifi_ap_object *ap_obj)
 852 {
 853         WIFI_RET_VAL_IF_FAIL(manager != NULL, FALSE);
 854         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, FALSE);
 855
 856         return ap_obj->is_captiveportal;
 857 }
 858
 859 void wifi_manager_ap_set_captiveportal(wifi_ap_object *ap_obj, gboolean is_captiveportal)
 860 {
 861         WIFI_RET_IF_FAIL(ap_obj != NULL);
 862
 863         ap_obj->is_captiveportal = is_captiveportal;
 864 }
 865
 866 wifi_error_e wifi_manager_ap_forget(wifi_ap_object *ap_obj)
 867 {
 868         wifi_error_e err;
 869         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, WIFI_ERROR_INVALID_PARAMETER);
 870
 871         err = wifi_forget_ap(ap_obj->ap);
 872         if (err != WIFI_ERROR_NONE) {
 873                 WIFI_LOG_ERR("wifi_forget_ap() is failed. error = %s",
 874                              wifi_error_to_string(err));
 875         }
 876         return err;
 877 }
 878
 879 gchar *wifi_manager_ap_get_ssid(wifi_ap_object *ap_obj)
 880 {
 881         gchar *ssid = NULL;
 882         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
 883
 884         wifi_error_e err = wifi_ap_get_essid(ap_obj->ap, &ssid);
 885         if (err != WIFI_ERROR_NONE) {
 886                 WIFI_LOG_ERR("wifi_ap_get_essid() is failed. error = %s",
 887                              wifi_error_to_string(err));
 888                 if (ssid) {
 889                         g_free(ssid);
 890                 }
 891                 return NULL;
 892         }
 893         return ssid;
 894 }
 895
 896 gint wifi_manager_ap_get_rssi(wifi_ap_object *ap_obj)
 897 {
 898         WIFI_RET_VAL_IF_FAIL(ap_obj, 0);
 899
 900         return ap_obj->rssi;
 901 }
 902
 903 wifi_manager_ap_signal_strength wifi_manager_ap_get_signal_strength(wifi_ap_object *ap_obj)
 904 {
 905         WIFI_RET_VAL_IF_FAIL(ap_obj, WIFI_MANAGER_SIGNAL_STRENGTH_NULL);
 906
 907         /* Wi-Fi Signal Strength Display (dB / ConnMan normalized value)
 908          *
 909          * Excellent : -63 ~     / 57 ~
 910          * Good:       -74 ~ -64 / 46 ~ 56
 911          * Weak:       -82 ~ -75 / 38 ~ 45
 912          * Very weak:      ~ -83 /    ~ 37
 913          */
 914         if (ap_obj->rssi >= -63)
 915                 return WIFI_MANAGER_SIGNAL_STRENGTH_EXCELLENT;
 916         else if (ap_obj->rssi >= -74)
 917                 return WIFI_MANAGER_SIGNAL_STRENGTH_GOOD;
 918         else if (ap_obj->rssi >= -82)
 919                 return WIFI_MANAGER_SIGNAL_STRENGTH_WEAK;
 920         else if (ap_obj->rssi >= -92)
 921                 return WIFI_MANAGER_SIGNAL_STRENGTH_VERY_WEAK;
 922         else
 923                 return WIFI_MANAGER_SIGNAL_STRENGTH_NULL;
 924 }
 925
 926 gint wifi_manager_ap_get_max_speed(wifi_ap_object *ap_obj)
 927 {
 928         gint max_speed = 0;
 929         WIFI_RET_VAL_IF_FAIL(ap_obj, 0);
 930
 931         wifi_error_e err = wifi_ap_get_max_speed(ap_obj->ap, &max_speed);
 932         if (err != WIFI_ERROR_NONE) {
 933                 WIFI_LOG_ERR("wifi_ap_get_max_speed() is failed. error = %s",
 934                              wifi_error_to_string(err));
 935                 return 0;
 936         }
 937         return max_speed;
 938 }
 939
 940 void wifi_manager_ap_set_password(wifi_ap_object *ap_obj, const gchar *password)
 941 {
 942         wifi_error_e err;
 943         WIFI_RET_IF_FAIL(ap_obj);
 944
 945         err = wifi_ap_set_passphrase(ap_obj->ap, password);
 946         if (err != WIFI_ERROR_NONE) {
 947                 WIFI_LOG_ERR("wifi_ap_set_passphrase() is failed. error = %s",
 948                              wifi_error_to_string(err));
 949         }
 950 }
 951
 952 wifi_eap_type_e wifi_manager_ap_get_eap_type(wifi_ap_object *ap_obj)
 953 {
 954         wifi_eap_type_e eap_type = WIFI_EAP_TYPE_AKA;
 955         wifi_error_e err;
 956         WIFI_RET_VAL_IF_FAIL(ap_obj, eap_type);
 957
 958         err = wifi_ap_get_eap_type(ap_obj->ap, &eap_type);
 959         if (err != WIFI_ERROR_NONE) {
 960                 WIFI_LOG_ERR("wifi_ap_get_eap_type() is failed. error = %s",
 961                              wifi_error_to_string(err));
 962         }
 963         return eap_type;
 964 }
 965
 966 void wifi_manager_ap_set_eap_type(wifi_ap_object *ap_obj, wifi_eap_type_e type)
 967 {
 968         wifi_error_e err;
 969         WIFI_RET_IF_FAIL(ap_obj);
 970
 971         err = wifi_ap_set_eap_type(ap_obj->ap, type);
 972         if (err != WIFI_ERROR_NONE) {
 973                 WIFI_LOG_ERR("wifi_ap_set_eap_type() is failed. error = %s",
 974                              wifi_error_to_string(err));
 975         }
 976 }
 977
 978 wifi_security_type_e wifi_manager_ap_get_security_type(wifi_ap_object *ap_obj)
 979 {
 980         wifi_security_type_e sec_type = WIFI_SECURITY_TYPE_NONE;
 981         wifi_error_e err;
 982         WIFI_RET_VAL_IF_FAIL(ap_obj, sec_type);
 983
 984         err = wifi_ap_get_security_type(ap_obj->ap, &sec_type);
 985         if (err != WIFI_ERROR_NONE) {
 986                 WIFI_LOG_ERR("wifi_ap_get_security_type() is failed. error = %s",
 987                              wifi_error_to_string(err));
 988         }
 989         return sec_type;
 990 }
 991
 992 gchar *wifi_manager_ap_get_security_type_text(wifi_ap_object *ap_obj)
 993 {
 994         switch (wifi_manager_ap_get_security_type(ap_obj)) {
 995         case WIFI_SECURITY_TYPE_NONE:
 996                 return g_strdup(STR_OPEN);
 997
 998         case WIFI_SECURITY_TYPE_WEP:
 999         case WIFI_SECURITY_TYPE_WPA_PSK:
1000         case WIFI_SECURITY_TYPE_WPA2_PSK:
1001                 return g_strdup(STR_SECURED);
1002
1003         case WIFI_SECURITY_TYPE_EAP:
1004                 return g_strdup(STR_SECURED_EAP);
1005
1006 #if defined TIZEN_WLAN_CHINA_WAPI
1007         case WIFI_SECURITY_TYPE_WAPI_PSK:
1008                 return g_strdup(STR_WAPI_PSK);
1009
1010         case WIFI_SECURITY_TYPE_WAPI_CERT:
1011                 return g_strdup(STR_WAPI_CERT);
1012 #endif
1013         default:
1014                 return g_strdup("");
1015         }
1016 }
1017
1018 wifi_connection_state_e wifi_manager_ap_get_connection_state(wifi_ap_object *ap_obj)
1019 {
1020         wifi_connection_state_e conn_state = WIFI_CONNECTION_STATE_FAILURE;
1021         wifi_error_e err;
1022         WIFI_RET_VAL_IF_FAIL(ap_obj, WIFI_CONNECTION_STATE_FAILURE);
1023         err = wifi_ap_get_connection_state(ap_obj->ap, &conn_state);
1024         if (err != WIFI_ERROR_NONE) {
1025                 WIFI_LOG_ERR("wifi_ap_get_connection_state() is failed. error = %s",
1026                              wifi_error_to_string(err));
1027         }
1028         return conn_state;
1029 }
1030
1031 gchar *wifi_manager_ap_get_ip_address(wifi_ap_object *ap_obj)
1032 {
1033         gchar *ip_address = NULL;
1034         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
1035
1036         wifi_error_e err = wifi_ap_get_ip_address(ap_obj->ap,
1037                                                   WIFI_ADDRESS_FAMILY_IPV4, &ip_address);
1038         if (err != WIFI_ERROR_NONE) {
1039                 WIFI_LOG_ERR("wifi_ap_get_ip_address() is failed. error = %s",
1040                              wifi_error_to_string(err));
1041                 if (ip_address) {
1042                         g_free(ip_address);
1043                 }
1044                 return NULL;
1045         }
1046         return ip_address;
1047 }
1048
1049 void wifi_manager_ap_set_ip_address(wifi_ap_object *ap_obj, const gchar *ip_address)
1050 {
1051         wifi_error_e err;
1052         WIFI_RET_IF_FAIL(ap_obj);
1053
1054         err = wifi_ap_set_ip_address(ap_obj->ap, WIFI_ADDRESS_FAMILY_IPV4, ip_address);
1055         if (err != WIFI_ERROR_NONE) {
1056                 WIFI_LOG_ERR("wifi_ap_set_ip_address() is failed. error = %s",
1057                              wifi_error_to_string(err));
1058         }
1059 }
1060
1061 gchar *wifi_manager_ap_get_gateway_address(wifi_ap_object *ap_obj)
1062 {
1063         gchar *gateway = NULL;
1064         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
1065
1066         wifi_error_e err = wifi_ap_get_gateway_address(ap_obj->ap,
1067                                                        WIFI_ADDRESS_FAMILY_IPV4, &gateway);
1068         if (err != WIFI_ERROR_NONE) {
1069                 WIFI_LOG_ERR("wifi_ap_get_gateway_address() is failed. error = %s",
1070                              wifi_error_to_string(err));
1071                 if (gateway) {
1072                         g_free(gateway);
1073                 }
1074                 return NULL;
1075         }
1076         return gateway;
1077 }
1078
1079 void wifi_manager_ap_set_gateway_address(wifi_ap_object *ap_obj, const gchar *gateway_address)
1080 {
1081         wifi_error_e err;
1082         WIFI_RET_IF_FAIL(ap_obj);
1083
1084         err = wifi_ap_set_gateway_address(ap_obj->ap, WIFI_ADDRESS_FAMILY_IPV4, gateway_address);
1085         if (err != WIFI_ERROR_NONE) {
1086                 WIFI_LOG_ERR("wifi_ap_set_gateway_address() is failed. error = %s",
1087                              wifi_error_to_string(err));
1088         }
1089 }
1090
1091 gchar *wifi_manager_ap_get_subnet_mask(wifi_ap_object *ap_obj)
1092 {
1093         gchar *subnet_mask = NULL;
1094         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
1095
1096         wifi_error_e err = wifi_ap_get_subnet_mask(ap_obj->ap,
1097                                                    WIFI_ADDRESS_FAMILY_IPV4, &subnet_mask);
1098         if (err != WIFI_ERROR_NONE) {
1099                 WIFI_LOG_ERR("wifi_ap_get_subnet_mask() is failed. error = %s",
1100                              wifi_error_to_string(err));
1101                 if (subnet_mask) {
1102                         g_free(subnet_mask);
1103                 }
1104                 return NULL;
1105         }
1106         return subnet_mask;
1107 }
1108
1109 void wifi_manager_ap_set_subnet_mask(wifi_ap_object *ap_obj, const gchar *subnet_mask)
1110 {
1111         wifi_error_e err;
1112         WIFI_RET_IF_FAIL(ap_obj);
1113
1114         err = wifi_ap_set_subnet_mask(ap_obj->ap, WIFI_ADDRESS_FAMILY_IPV4, subnet_mask);
1115         if (err != WIFI_ERROR_NONE) {
1116                 WIFI_LOG_ERR("wifi_ap_set_subnet_mask() is failed. error = %s",
1117                              wifi_error_to_string(err));
1118         }
1119 }
1120
1121 gchar *wifi_manager_ap_get_dns_address(wifi_ap_object *ap_obj, gint order)
1122 {
1123         gchar *dns_address = NULL;
1124         WIFI_RET_VAL_IF_FAIL(ap_obj, NULL);
1125
1126         wifi_error_e err = wifi_ap_get_dns_address(ap_obj->ap,
1127                                                    order, WIFI_ADDRESS_FAMILY_IPV4, &dns_address);
1128         if (err != WIFI_ERROR_NONE) {
1129                 WIFI_LOG_ERR("wifi_ap_get_dns_address() is failed. error = %s",
1130                              wifi_error_to_string(err));
1131                 if (dns_address) {
1132                         g_free(dns_address);
1133                 }
1134                 return NULL;
1135         }
1136         return dns_address;
1137 }
1138
1139 void wifi_manager_ap_set_dns_address(wifi_ap_object *ap_obj, const gchar *dns_address, gint order)
1140 {
1141         wifi_error_e err;
1142         WIFI_RET_IF_FAIL(ap_obj);
1143
1144         err = wifi_ap_set_dns_address(ap_obj->ap, order, WIFI_ADDRESS_FAMILY_IPV4, dns_address);
1145         if (err != WIFI_ERROR_NONE) {
1146                 WIFI_LOG_ERR("wifi_ap_set_dns_address() is failed. error = %s",
1147                              wifi_error_to_string(err));
1148         }
1149 }
1150
1151 wifi_ip_config_type_e wifi_manager_ap_get_ip_config(wifi_ap_object *ap_obj)
1152 {
1153         wifi_ip_config_type_e config_type = WIFI_IP_CONFIG_TYPE_NONE;
1154         wifi_error_e err;
1155         WIFI_RET_VAL_IF_FAIL(ap_obj, WIFI_IP_CONFIG_TYPE_NONE);
1156
1157         err = wifi_ap_get_ip_config_type(ap_obj->ap,
1158                                          WIFI_ADDRESS_FAMILY_IPV4, &config_type);
1159         if (err != WIFI_ERROR_NONE) {
1160                 WIFI_LOG_ERR("wifi_ap_get_ip_config_type() is failed. error = %s",
1161                              wifi_error_to_string(err));
1162         }
1163         return config_type;
1164 }
1165
1166 void wifi_manager_ap_set_ip_config(wifi_ap_object *ap_obj, wifi_ip_config_type_e config_type)
1167 {
1168         wifi_error_e err;
1169         WIFI_RET_IF_FAIL(ap_obj);
1170         err = wifi_ap_set_ip_config_type(ap_obj->ap,
1171                                          WIFI_ADDRESS_FAMILY_IPV4, config_type);
1172         if (err != WIFI_ERROR_NONE) {
1173                 WIFI_LOG_ERR("wifi_ap_set_ip_config_type() is failed. error = %s",
1174                              wifi_error_to_string(err));
1175         }
1176 }
1177
1178 bool wifi_manager_ap_is_ip_config_static(wifi_ap_object *ap_obj)
1179 {
1180         return wifi_manager_ap_get_ip_config(ap_obj) == WIFI_IP_CONFIG_TYPE_STATIC;
1181 }
1182
1183 void wifi_manager_ap_set_ip_config_static(wifi_ap_object *ap_obj)
1184 {
1185         wifi_manager_ap_set_ip_config(ap_obj, WIFI_IP_CONFIG_TYPE_STATIC);
1186 }
1187
1188 wifi_proxy_type_e wifi_manager_ap_get_proxy_type(wifi_ap_object *ap_obj)
1189 {
1190         wifi_proxy_type_e proxy_type = WIFI_PROXY_TYPE_AUTO;
1191         wifi_error_e err;
1192         WIFI_RET_VAL_IF_FAIL(ap_obj, WIFI_PROXY_TYPE_AUTO);
1193
1194         err = wifi_ap_get_proxy_type(ap_obj->ap, &proxy_type);
1195         if (err != WIFI_ERROR_NONE) {
1196                 WIFI_LOG_ERR("wifi_ap_get_proxy_type() is failed. error = %s",
1197                              wifi_error_to_string(err));
1198         }
1199         return proxy_type;
1200 }
1201
1202 void wifi_manager_ap_set_proxy_type(wifi_ap_object *ap_obj, wifi_proxy_type_e proxy_type)
1203 {
1204         wifi_error_e err;
1205         WIFI_RET_IF_FAIL(ap_obj);
1206
1207         err = wifi_ap_set_proxy_type(ap_obj->ap, proxy_type);
1208         if (err != WIFI_ERROR_NONE) {
1209                 WIFI_LOG_ERR("wifi_ap_set_proxy_type() is failed. error = %s",
1210                              wifi_error_to_string(err));
1211         }
1212 }
1213
1214 bool wifi_manager_ap_is_proxy_manual(wifi_ap_object *ap_obj)
1215 {
1216         return wifi_manager_ap_get_proxy_type(ap_obj) == WIFI_PROXY_TYPE_MANUAL;
1217 }
1218
1219 void wifi_manager_ap_set_proxy_manual(wifi_ap_object *ap_obj)
1220 {
1221         wifi_manager_ap_set_proxy_type(ap_obj, WIFI_PROXY_TYPE_MANUAL);
1222 }
1223
1224 gchar *wifi_manager_ap_get_proxy_address(wifi_ap_object *ap_obj)
1225 {
1226         gchar *proxy_address = NULL;
1227         char *saveptr = NULL;
1228         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, NULL);
1229
1230         proxy_address = _ap_get_proxy_address(ap_obj);
1231         if (proxy_address == NULL) {
1232                 WIFI_LOG_INFO("Proxy address is NULL.");
1233                 return NULL;
1234         }
1235
1236         return g_strdup(strtok_r(proxy_address, ":", &saveptr));
1237 }
1238
1239 gchar *wifi_manager_ap_get_proxy_port(wifi_ap_object *ap_obj)
1240 {
1241         gchar *proxy_address = NULL;
1242         char *saveptr = NULL;
1243         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, NULL);
1244
1245         proxy_address = _ap_get_proxy_address(ap_obj);
1246         if (proxy_address == NULL) {
1247                 WIFI_LOG_INFO("Proxy address is NULL.");
1248                 return NULL;
1249         }
1250
1251         strtok_r(proxy_address, ":", &saveptr);
1252         return g_strdup(strtok_r(NULL, ":", &saveptr));
1253 }
1254
1255 void wifi_manager_ap_set_proxy_address(wifi_ap_object *ap_obj, const gchar *proxy_address)
1256 {
1257         wifi_error_e err;
1258         WIFI_RET_IF_FAIL(ap_obj);
1259
1260         err = wifi_ap_set_proxy_address(ap_obj->ap, WIFI_ADDRESS_FAMILY_IPV4, proxy_address);
1261         if (err != WIFI_ERROR_NONE) {
1262                 WIFI_LOG_ERR("wifi_ap_set_proxy_type() is failed. error = %s",
1263                              wifi_error_to_string(err));
1264         }
1265 }
1266
1267 bool wifi_manager_ap_is_wps_mode(wifi_ap_object *ap_obj)
1268 {
1269         return ap_obj->wps_mode;
1270 }
1271
1272 bool wifi_manager_ap_is_favorite(wifi_manager_object *manager, wifi_ap_object *ap_obj)
1273 {
1274         bool is_favorite = false;
1275         wifi_error_e err;
1276         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, false);
1277
1278         err = wifi_ap_is_favorite(ap_obj->ap, &is_favorite);
1279         if (err != WIFI_ERROR_NONE) {
1280                 WIFI_LOG_ERR("wifi_ap_is_favorite() is failed. error = %d", err);
1281         }
1282         return is_favorite;
1283 }
1284
1285 gboolean wifi_manager_ap_has_configuration(wifi_manager_object *manager,
1286                                            wifi_ap_object *ap_obj)
1287 {
1288         WIFI_RET_VAL_IF_FAIL(manager != NULL, FALSE);
1289         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, FALSE);
1290
1291         if (_find_wifi_config_by_wifi_ap(manager, ap_obj) == NULL) {
1292                 WIFI_LOG_INFO("AP config profile not found.");
1293                 return FALSE;
1294         }
1295         WIFI_LOG_INFO("AP has config profile.");
1296         return TRUE;
1297 }
1298
1299 wifi_error_e wifi_manager_ap_remove_configuration(wifi_manager_object *manager,
1300                                                   wifi_ap_object *ap_obj)
1301 {
1302         wifi_config_object *config;
1303         wifi_error_e error = WIFI_ERROR_NONE;
1304         WIFI_RET_VAL_IF_FAIL(manager != NULL, WIFI_ERROR_INVALID_PARAMETER);
1305         WIFI_RET_VAL_IF_FAIL(ap_obj != NULL, WIFI_ERROR_INVALID_PARAMETER);
1306
1307         config = _find_wifi_config_by_wifi_ap(manager, ap_obj);
1308         WIFI_RET_VAL_IF_FAIL(config != NULL, WIFI_ERROR_INVALID_OPERATION);
1309
1310         _update_wifi_config_list(manager);
1311         return error;
1312 }
1313
1314 wifi_error_e wifi_manager_update_wifi_config_list(wifi_manager_object *manager)
1315 {
1316         wifi_error_e error = WIFI_ERROR_NONE;
1317
1318         WIFI_RET_VAL_IF_FAIL(manager != NULL, WIFI_ERROR_INVALID_PARAMETER);
1319
1320         _update_wifi_config_list(manager);
1321
1322         return error;
1323 }
1324
1325 /*
1326  * Wearable connection API (weconn feature)
1327  */
1328
1329 gboolean wifi_manager_set_wifi_use(wifi_manager_object *manager, gboolean is_wifi_use)
1330 {
1331         WIFI_RET_VAL_IF_FAIL(manager, FALSE);
1332         return vconf_set_wifi_use(is_wifi_use ? 1 : 0);
1333 }
1334
1335 gboolean wifi_manager_is_wifi_use(wifi_manager_object *manager)
1336 {
1337         WIFI_RET_VAL_IF_FAIL(manager, FALSE);
1338         return vconf_is_wifi_use();
1339 }
1340
1341 gboolean wifi_manager_set_wifi_use_changed_cb(wifi_manager_object *manager,
1342                                               vconf_callback_fn callback, void *data)
1343 {
1344         WIFI_RET_VAL_IF_FAIL(manager, FALSE);
1345     WIFI_LOG_INFO("VCONF_WIFI_USE - notify wifi key changed");
1346         return vconf_notify_wifi_key_changed(callback, data);
1347 }