src/net_wifi.c

   1 /*
   2  * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include "net_wifi_private.h"
  18
  19 typedef struct {
  20         wifi_activated_cb activated_cb;
  21         void *activated_ud;
  22         wifi_deactivated_cb deactivated_cb;
  23         void *deactivated_ud;
  24         wifi_scan_finished_cb scan_finished_cb;
  25         void *scan_finished_ud;
  26         wifi_scan_finished_cb specific_scan_finished_cb;
  27         void *specific_scan_finished_ud;
  28         wifi_connected_cb connected_cb;
  29         void *connected_ud;
  30         wifi_connected_cb specific_connected_cb;
  31         void *specific_connected_ud;
  32         wifi_disconnected_cb disconnected_cb;
  33         void *disconnected_ud;
  34         wifi_connected_cb wps_pbc_connected_cb;
  35         void *wps_pbc_connected_ud;
  36         wifi_connected_cb wps_pin_connected_cb;
  37         void *wps_pin_connected_ud;
  38         wifi_scan_finished_cb background_scan_finished_cb;
  39         void *background_scan_finished_ud;
  40 } wifi_user_callback_s;
  41
  42 wifi_user_callback_s g_user_callback = { 0, };
  43 wifi_manager_h g_wifi_manager_handle = NULL;
  44
  45 static void __activated_callback(wifi_manager_error_e result, void *user_data)
  46 {
  47         if (g_user_callback.activated_cb) {
  48                 g_user_callback.activated_cb(convert_to_wifi_error(result), g_user_callback.activated_ud);
  49                 g_user_callback.activated_cb = NULL;
  50                 g_user_callback.activated_ud = NULL;
  51         }
  52 }
  53
  54 static void __deactivated_callback(wifi_manager_error_e result, void *user_data)
  55 {
  56         if (g_user_callback.deactivated_cb) {
  57                 g_user_callback.deactivated_cb(convert_to_wifi_error(result), g_user_callback.deactivated_ud);
  58                 g_user_callback.deactivated_cb = NULL;
  59                 g_user_callback.deactivated_ud = NULL;
  60         }
  61 }
  62
  63 static void __scan_finished_callback(wifi_manager_error_e error_code, void* user_data)
  64 {
  65         if (g_user_callback.scan_finished_cb) {
  66                 g_user_callback.scan_finished_cb(convert_to_wifi_error(error_code), g_user_callback.scan_finished_ud);
  67                 g_user_callback.scan_finished_cb = NULL;
  68                 g_user_callback.scan_finished_ud = NULL;
  69         }
  70 }
  71
  72 static void __specific_scan_finished_callback(wifi_manager_error_e error_code, void *user_data)
  73 {
  74         if (g_user_callback.specific_scan_finished_cb) {
  75                 g_user_callback.specific_scan_finished_cb(convert_to_wifi_error(error_code), g_user_callback.specific_scan_finished_ud);
  76                 g_user_callback.specific_scan_finished_cb = NULL;
  77                 g_user_callback.specific_scan_finished_ud = NULL;
  78         }
  79 }
  80
  81 static void __connected_callback(wifi_manager_error_e result, void *user_data)
  82 {
  83         if (g_user_callback.connected_cb) {
  84                 g_user_callback.connected_cb(convert_to_wifi_error(result), g_user_callback.connected_ud);
  85                 g_user_callback.connected_cb = NULL;
  86                 g_user_callback.connected_ud = NULL;
  87         }
  88 }
  89
  90 static void __specific_connected_callback(wifi_manager_error_e result, void *user_data)
  91 {
  92         if (g_user_callback.specific_connected_cb) {
  93                 g_user_callback.specific_connected_cb(convert_to_wifi_error(result), g_user_callback.specific_connected_ud);
  94                 g_user_callback.specific_connected_cb = NULL;
  95                 g_user_callback.specific_connected_ud = NULL;
  96         }
  97 }
  98
  99 static void __disconnected_callback(wifi_manager_error_e result, void *user_data)
 100 {
 101         if (g_user_callback.disconnected_cb) {
 102                 g_user_callback.disconnected_cb(convert_to_wifi_error(result), g_user_callback.disconnected_ud);
 103                 g_user_callback.disconnected_cb = NULL;
 104                 g_user_callback.disconnected_ud = NULL;
 105         }
 106 }
 107
 108 static void __wps_pbc_connected_callback(wifi_manager_error_e result, void *user_data)
 109 {
 110         if (g_user_callback.wps_pbc_connected_cb) {
 111                 g_user_callback.wps_pbc_connected_cb(convert_to_wifi_error(result), g_user_callback.wps_pbc_connected_ud);
 112                 g_user_callback.wps_pbc_connected_cb = NULL;
 113                 g_user_callback.wps_pbc_connected_ud = NULL;
 114         }
 115 }
 116
 117 static void __wps_pin_connected_callback(wifi_manager_error_e result, void *user_data)
 118 {
 119         if (g_user_callback.wps_pin_connected_cb) {
 120                 g_user_callback.wps_pin_connected_cb(convert_to_wifi_error(result), g_user_callback.wps_pin_connected_ud);
 121                 g_user_callback.wps_pin_connected_cb = NULL;
 122                 g_user_callback.wps_pin_connected_ud = NULL;
 123         }
 124 }
 125
 126 static void __background_scan_completed_callback(wifi_manager_error_e error_code, void *user_data)
 127 {
 128         if (g_user_callback.background_scan_finished_cb)
 129                 g_user_callback.background_scan_finished_cb(convert_to_wifi_error(error_code), g_user_callback.background_scan_finished_ud);
 130 }
 131
 132 EXPORT_API int wifi_initialize(void)
 133 {
 134         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_initialize");
 135
 136         return convert_to_wifi_error(wifi_manager_initialize(&g_wifi_manager_handle));
 137 }
 138
 139 EXPORT_API int wifi_deinitialize(void)
 140 {
 141         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_deinitialize");
 142
 143         return convert_to_wifi_error(wifi_manager_deinitialize(g_wifi_manager_handle));
 144 }
 145
 146 EXPORT_API int wifi_activate(wifi_activated_cb callback, void *user_data)
 147 {
 148         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_activate");
 149
 150         g_user_callback.activated_cb = callback;
 151         g_user_callback.activated_ud = user_data;
 152
 153         return convert_to_wifi_error(wifi_manager_activate(g_wifi_manager_handle, __activated_callback, NULL));
 154 }
 155
 156 EXPORT_API int wifi_activate_with_wifi_picker_tested(
 157                 wifi_activated_cb callback, void *user_data)
 158 {
 159         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_activate_with_wifi_picker_tested");
 160
 161         g_user_callback.activated_cb = callback;
 162         g_user_callback.activated_ud = user_data;
 163
 164         return convert_to_wifi_error(wifi_manager_activate_with_wifi_picker_tested(g_wifi_manager_handle, __activated_callback, NULL));
 165 }
 166
 167 EXPORT_API int wifi_deactivate(wifi_deactivated_cb callback, void *user_data)
 168 {
 169         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_deactivate");
 170
 171         g_user_callback.deactivated_cb = callback;
 172         g_user_callback.deactivated_ud = user_data;
 173
 174         return convert_to_wifi_error(wifi_manager_deactivate(g_wifi_manager_handle, __deactivated_callback, NULL));
 175 }
 176
 177 EXPORT_API int wifi_is_activated(bool *activated)
 178 {
 179         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_is_activated");
 180
 181         return convert_to_wifi_error(wifi_manager_is_activated(g_wifi_manager_handle, activated));
 182 }
 183
 184 EXPORT_API int wifi_get_mac_address(char **mac_address)
 185 {
 186         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_get_mac_address");
 187
 188         return convert_to_wifi_error(wifi_manager_get_mac_address(g_wifi_manager_handle, mac_address));
 189 }
 190
 191 EXPORT_API int wifi_get_network_interface_name(char **name)
 192 {
 193         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_get_network_interface_name");
 194
 195         return convert_to_wifi_error(wifi_manager_get_network_interface_name(g_wifi_manager_handle, name));
 196 }
 197
 198 EXPORT_API int wifi_scan(wifi_scan_finished_cb callback, void *user_data)
 199 {
 200         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_scan");
 201
 202         g_user_callback.scan_finished_cb = callback;
 203         g_user_callback.scan_finished_ud = user_data;
 204
 205         return convert_to_wifi_error(wifi_manager_scan(g_wifi_manager_handle, __scan_finished_callback, NULL));
 206 }
 207
 208 EXPORT_API int wifi_scan_specific_ap(const char *essid, wifi_scan_finished_cb callback, void *user_data)
 209 {
 210         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_scan_specific_ap");
 211
 212         g_user_callback.specific_scan_finished_cb = callback;
 213         g_user_callback.specific_scan_finished_ud = user_data;
 214
 215         return convert_to_wifi_error(wifi_manager_scan_specific_ap(g_wifi_manager_handle, essid, __specific_scan_finished_callback, NULL));
 216 }
 217
 218 EXPORT_API int wifi_get_connected_ap(wifi_ap_h *ap)
 219 {
 220         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_get_connected_ap");
 221
 222         return convert_to_wifi_error(wifi_manager_get_connected_ap(g_wifi_manager_handle, (wifi_manager_ap_h *)ap));
 223 }
 224
 225 EXPORT_API int wifi_foreach_found_aps(wifi_found_ap_cb callback, void *user_data)
 226 {
 227         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_foreach_found_ap");
 228
 229         return convert_to_wifi_error(wifi_manager_foreach_found_ap(g_wifi_manager_handle,
 230                         (wifi_manager_found_ap_cb)callback, user_data));
 231 }
 232
 233 EXPORT_API int wifi_foreach_found_specific_aps(wifi_found_ap_cb callback, void *user_data)
 234 {
 235         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_foreach_found_specific_ap");
 236
 237         return convert_to_wifi_error(wifi_manager_foreach_found_specific_ap(g_wifi_manager_handle,
 238                         (wifi_manager_found_ap_cb)callback, user_data));
 239 }
 240
 241 EXPORT_API int wifi_connect(wifi_ap_h ap, wifi_connected_cb callback, void *user_data)
 242 {
 243         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_connect");
 244
 245         g_user_callback.connected_cb = callback;
 246         g_user_callback.connected_ud = user_data;
 247
 248         return convert_to_wifi_error(wifi_manager_connect(g_wifi_manager_handle,
 249                         (wifi_manager_ap_h)ap, __connected_callback, NULL));
 250 }
 251
 252 EXPORT_API int wifi_connect_specific_ap(const char *essid,
 253                                         wifi_security_type_e sec_type, const char *passphrase,
 254                                         wifi_connected_cb callback, void* user_data)
 255 {
 256         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_connect_hidden_ap");
 257
 258         g_user_callback.specific_connected_cb = callback;
 259         g_user_callback.specific_connected_ud = user_data;
 260
 261         return convert_to_wifi_error(wifi_manager_connect_hidden_ap(g_wifi_manager_handle,
 262                         essid, (wifi_manager_security_type_e)sec_type,
 263                         passphrase, __specific_connected_callback, NULL));
 264 }
 265
 266 EXPORT_API int wifi_disconnect(wifi_ap_h ap, wifi_disconnected_cb callback, void *user_data)
 267 {
 268         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_disconnect");
 269
 270         g_user_callback.disconnected_cb = callback;
 271         g_user_callback.disconnected_ud = user_data;
 272
 273         return convert_to_wifi_error(wifi_manager_disconnect(g_wifi_manager_handle,
 274                         (wifi_manager_ap_h)ap, __disconnected_callback, NULL));
 275 }
 276
 277 EXPORT_API int wifi_connect_by_wps_pbc(wifi_ap_h ap, wifi_connected_cb callback, void *user_data)
 278 {
 279         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_connect_by_wps_pbc");
 280
 281         g_user_callback.wps_pbc_connected_cb = callback;
 282         g_user_callback.wps_pbc_connected_ud = user_data;
 283
 284         return convert_to_wifi_error(wifi_manager_connect_by_wps_pbc(g_wifi_manager_handle,
 285                         (wifi_manager_ap_h)ap, __wps_pbc_connected_callback, NULL));
 286 }
 287
 288 EXPORT_API int wifi_connect_by_wps_pin(wifi_ap_h ap, const char *pin, wifi_connected_cb callback, void* user_data)
 289 {
 290         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_connect_by_wps_pin");
 291
 292         g_user_callback.wps_pin_connected_cb = callback;
 293         g_user_callback.wps_pin_connected_ud = user_data;
 294
 295         return convert_to_wifi_error(wifi_manager_connect_by_wps_pin(g_wifi_manager_handle,
 296                         (wifi_manager_ap_h)ap, pin, __wps_pin_connected_callback, NULL));
 297 }
 298
 299 EXPORT_API int wifi_forget_ap(wifi_ap_h ap)
 300 {
 301         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_forget_ap");
 302
 303         return convert_to_wifi_error(wifi_manager_forget_ap(g_wifi_manager_handle, (wifi_manager_ap_h)ap));
 304 }
 305
 306 EXPORT_API int wifi_get_connection_state(wifi_connection_state_e *connection_state)
 307 {
 308         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_get_connection_state");
 309         return convert_to_wifi_error(wifi_manager_get_connection_state(g_wifi_manager_handle,
 310                         (wifi_manager_connection_state_e *)connection_state));
 311 }
 312
 313 EXPORT_API int wifi_set_device_state_changed_cb(wifi_device_state_changed_cb callback, void *user_data)
 314 {
 315         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_set_device_state_changed_cb");
 316
 317         return convert_to_wifi_error(wifi_manager_set_device_state_changed_cb(g_wifi_manager_handle,
 318                         (wifi_manager_device_state_changed_cb)callback, user_data));
 319 }
 320
 321 EXPORT_API int wifi_unset_device_state_changed_cb(void)
 322 {
 323         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_unset_device_state_changed_cb");
 324
 325         return convert_to_wifi_error(wifi_manager_unset_device_state_changed_cb(g_wifi_manager_handle));
 326 }
 327
 328 EXPORT_API int wifi_set_background_scan_cb(wifi_scan_finished_cb callback, void *user_data)
 329 {
 330         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_set_background_scan_cb");
 331
 332         g_user_callback.background_scan_finished_cb = callback;
 333         g_user_callback.background_scan_finished_ud = user_data;
 334
 335         return convert_to_wifi_error(wifi_manager_set_background_scan_cb(g_wifi_manager_handle, __background_scan_completed_callback, NULL));
 336 }
 337
 338 EXPORT_API int wifi_unset_background_scan_cb(void)
 339 {
 340         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_unset_background_scan_cb");
 341
 342         g_user_callback.background_scan_finished_cb = NULL;
 343         g_user_callback.background_scan_finished_ud = NULL;
 344
 345         return convert_to_wifi_error(wifi_manager_unset_background_scan_cb(g_wifi_manager_handle));
 346 }
 347
 348 EXPORT_API int wifi_set_connection_state_changed_cb(wifi_connection_state_changed_cb callback, void *user_data)
 349 {
 350         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_set_connection_state_changed_cb");
 351
 352         return convert_to_wifi_error(wifi_manager_set_connection_state_changed_cb(g_wifi_manager_handle,
 353                         (wifi_manager_connection_state_changed_cb)callback, user_data));
 354 }
 355
 356 EXPORT_API int wifi_unset_connection_state_changed_cb(void)
 357 {
 358         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_unset_connection_state_changed_cb");
 359
 360         return convert_to_wifi_error(wifi_manager_unset_connection_state_changed_cb(g_wifi_manager_handle));
 361 }
 362
 363 EXPORT_API int wifi_set_rssi_level_changed_cb(wifi_rssi_level_changed_cb callback, void* user_data)
 364 {
 365         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_set_rssi_level_changed_cb");
 366
 367         return convert_to_wifi_error(wifi_manager_set_rssi_level_changed_cb(g_wifi_manager_handle,
 368                         (wifi_manager_rssi_level_changed_cb)callback, user_data));
 369 }
 370
 371 EXPORT_API int wifi_unset_rssi_level_changed_cb(void)
 372 {
 373         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_unset_rssi_level_changed_cb");
 374
 375         return convert_to_wifi_error(wifi_manager_unset_rssi_level_changed_cb(g_wifi_manager_handle));
 376 }
 377
 378 EXPORT_API int wifi_tdls_disconnect(const char *peer_mac_addr)
 379 {
 380         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_tdls_disconnect");
 381
 382         return convert_to_wifi_error(wifi_manager_tdls_disconnect(g_wifi_manager_handle, peer_mac_addr));
 383 }
 384
 385 EXPORT_API int wifi_tdls_get_connected_peer(char **peer_mac_addr)
 386 {
 387         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_tdls_get_connected_peer");
 388
 389         return convert_to_wifi_error(wifi_manager_tdls_get_connected_peer(g_wifi_manager_handle, peer_mac_addr));
 390 }
 391
 392 EXPORT_API int wifi_tdls_set_state_changed_cb(wifi_tdls_state_changed_cb callback, void *user_data)
 393 {
 394         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_tdls_set_state_changed_cb");
 395
 396         return convert_to_wifi_error(wifi_manager_tdls_set_state_changed_cb(g_wifi_manager_handle,
 397                         (wifi_manager_tdls_state_changed_cb)callback, user_data));
 398 }
 399
 400 EXPORT_API int wifi_tdls_unset_state_changed_cb(void)
 401 {
 402         DEPRECATED_LOG(__FUNCTION__, "wifi_manager_tdls_unset_state_changed_cb");
 403
 404         return convert_to_wifi_error(wifi_manager_tdls_unset_state_changed_cb(g_wifi_manager_handle));
 405 }