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