2 * Copyright (c) 2012-2013 Samsung Electronics Co., Ltd All Rights Reserved
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
22 #include "wifi_dbus_private.h"
23 #include "net_wifi_private.h"
25 static __thread bool is_init = false;
26 static __thread GSList *ap_handle_list = NULL;
29 wifi_device_state_changed_cb device_state_cb;
30 void *device_state_user_data;
31 wifi_scan_finished_cb bg_scan_cb;
32 void *bg_scan_user_data;
33 wifi_scan_finished_cb scan_request_cb;
34 void *scan_request_user_data;
35 wifi_scan_finished_cb specific_scan_cb;
36 void *specific_scan_user_data;
37 wifi_connection_state_changed_cb connection_state_cb;
38 void *connection_state_user_data;
39 wifi_activated_cb activated_cb;
40 void *activated_user_data;
41 wifi_deactivated_cb deactivated_cb;
42 void *deactivated_user_data;
43 wifi_connected_cb connected_cb;
44 void *connected_user_data;
45 wifi_disconnected_cb disconnected_cb;
46 void *disconnected_user_data;
49 struct _profile_list_s {
51 net_profile_info_t *profiles;
54 struct _wifi_state_notify {
55 net_profile_info_t *ap_info;
56 wifi_connection_state_e state;
59 struct managed_idle_data {
65 static __thread struct _wifi_cb_s wifi_callbacks = { 0, };
66 static __thread struct _profile_list_s profile_iterator = { 0, NULL };
67 static __thread struct _profile_list_s specific_profile_iterator = {0, NULL};
68 static __thread char specific_profile_essid[NET_WLAN_ESSID_LEN + 1] = { 0, };
69 static __thread bool is_feature_checked = false;
70 static __thread bool feature_supported = false;
71 static __thread GSList *managed_idler_list = NULL;
73 wifi_dbus *g_dbus_h = NULL;
75 bool _wifi_is_init(void)
80 static void __wifi_set_init(bool tag)
85 static wifi_error_e __libnet_convert_to_ap_error_type(net_err_t err_type)
89 return WIFI_ERROR_NONE;
90 case NET_ERR_APP_ALREADY_REGISTERED:
91 return WIFI_ERROR_INVALID_OPERATION;
92 case NET_ERR_APP_NOT_REGISTERED:
93 return WIFI_ERROR_INVALID_OPERATION;
94 case NET_ERR_NO_ACTIVE_CONNECTIONS:
95 return WIFI_ERROR_NO_CONNECTION;
96 case NET_ERR_ACTIVE_CONNECTION_EXISTS:
97 return WIFI_ERROR_ALREADY_EXISTS;
98 case NET_ERR_CONNECTION_DHCP_FAILED:
99 return WIFI_ERROR_DHCP_FAILED;
100 case NET_ERR_CONNECTION_INVALID_KEY:
101 return WIFI_ERROR_INVALID_KEY;
102 case NET_ERR_IN_PROGRESS:
103 return WIFI_ERROR_NOW_IN_PROGRESS;
104 case NET_ERR_OPERATION_ABORTED:
105 return WIFI_ERROR_OPERATION_ABORTED;
106 case NET_ERR_TIME_OUT:
107 return WIFI_ERROR_NO_REPLY;
108 case NET_ERR_ACCESS_DENIED:
109 return WIFI_ERROR_PERMISSION_DENIED;
111 return WIFI_ERROR_OPERATION_FAILED;
115 static const char *__libnet_convert_ap_error_type_to_string(wifi_error_e err_type)
118 case WIFI_ERROR_NONE:
120 case WIFI_ERROR_INVALID_PARAMETER:
121 return "INVALID_PARAMETER";
122 case WIFI_ERROR_OUT_OF_MEMORY:
123 return "OUT_OF_MEMORY";
124 case WIFI_ERROR_INVALID_OPERATION:
125 return "INVALID_OPERATION";
126 case WIFI_ERROR_ADDRESS_FAMILY_NOT_SUPPORTED:
127 return "ADDRESS_FAMILY_NOT_SUPPORTED";
128 case WIFI_ERROR_OPERATION_FAILED:
129 return "OPERATION_FAILED";
130 case WIFI_ERROR_NO_CONNECTION:
131 return "NO_CONNECTION";
132 case WIFI_ERROR_NOW_IN_PROGRESS:
133 return "NOW_IN_PROGRESS";
134 case WIFI_ERROR_ALREADY_EXISTS:
135 return "ALREADY_EXISTS";
136 case WIFI_ERROR_OPERATION_ABORTED:
137 return "OPERATION_ABORTED";
138 case WIFI_ERROR_DHCP_FAILED:
139 return "DHCP_FAILED";
140 case WIFI_ERROR_INVALID_KEY:
141 return "INVALID_KEY";
142 case WIFI_ERROR_NO_REPLY:
144 case WIFI_ERROR_SECURITY_RESTRICTED:
145 return "SECURITY_RESTRICTED";
146 case WIFI_ERROR_PERMISSION_DENIED:
147 return "PERMISSION_DENIED";
148 case WIFI_ERROR_NOT_SUPPORTED:
149 return "NOT_SUPPROTED";
155 static const char *__libnet_convert_ap_state_to_string(wifi_connection_state_e state)
158 case WIFI_CONNECTION_STATE_FAILURE:
160 case WIFI_CONNECTION_STATE_DISCONNECTED:
161 return "DISCONNECTED";
162 case WIFI_CONNECTION_STATE_ASSOCIATION:
163 return "ASSOCIATION";
164 case WIFI_CONNECTION_STATE_CONFIGURATION:
165 return "CONFIGURATION";
166 case WIFI_CONNECTION_STATE_CONNECTED:
173 static void __libnet_clear_profile_list(struct _profile_list_s *profile_list)
175 if (profile_list->count > 0)
176 g_free(profile_list->profiles);
178 profile_list->count = 0;
179 profile_list->profiles = NULL;
182 static int __libnet_update_profile_iterator(void)
185 struct _profile_list_s wifi_profiles = { 0, NULL };
187 __libnet_clear_profile_list(&profile_iterator);
189 rv = net_get_profile_list(NET_DEVICE_WIFI, &wifi_profiles.profiles, &wifi_profiles.count);
190 WIFI_LOG(WIFI_INFO, "Wi-Fi profile count: %d", wifi_profiles.count);
192 if (rv == NET_ERR_ACCESS_DENIED) {
193 WIFI_LOG(WIFI_ERROR, "Access denied");
194 return WIFI_ERROR_PERMISSION_DENIED;
197 if (wifi_profiles.count == 0)
198 return WIFI_ERROR_NONE;
200 profile_iterator.count = wifi_profiles.count;
201 profile_iterator.profiles = wifi_profiles.profiles;
203 return WIFI_ERROR_NONE;
206 static void __libnet_update_specific_profile_iterator(GSList *ap_list)
209 GSList *list = ap_list;
211 for (count = 0; list; list = list->next)
215 WIFI_LOG(WIFI_INFO, "No hidden AP found\n");
219 specific_profile_iterator.count = count;
220 specific_profile_iterator.profiles = g_try_new0(net_profile_info_t, count);
223 for (count = 0; list; list = list->next) {
224 struct ssid_scan_bss_info_t *ap = (struct ssid_scan_bss_info_t *)list->data;
225 net_profile_info_t *profile = &specific_profile_iterator.profiles[count];
227 g_strlcpy(profile->ProfileInfo.Wlan.essid, ap->ssid, NET_WLAN_ESSID_LEN+1);
228 profile->ProfileInfo.Wlan.security_info.sec_mode = ap->security;
233 WIFI_LOG(WIFI_INFO, "Specific AP count : %d\n", count);
236 static void __libnet_convert_profile_info_to_wifi_info(net_wifi_connection_info_t *wifi_info,
237 net_profile_info_t *ap_info)
239 g_strlcpy(wifi_info->essid, ap_info->ProfileInfo.Wlan.essid, NET_WLAN_ESSID_LEN+1);
240 wifi_info->wlan_mode = ap_info->ProfileInfo.Wlan.wlan_mode;
241 memcpy(&wifi_info->security_info, &ap_info->ProfileInfo.Wlan.security_info, sizeof(wlan_security_info_t));
242 wifi_info->is_hidden = ap_info->ProfileInfo.Wlan.is_hidden;
245 static int __libnet_connect_with_wifi_info(net_profile_info_t *ap_info)
248 net_wifi_connection_info_t wifi_info;
249 memset(&wifi_info, 0, sizeof(net_wifi_connection_info_t));
251 __libnet_convert_profile_info_to_wifi_info(&wifi_info, ap_info);
253 rv = net_open_connection_with_wifi_info(&wifi_info);
254 if (rv == NET_ERR_ACCESS_DENIED) {
255 WIFI_LOG(WIFI_ERROR, "Access denied");
256 return WIFI_ERROR_PERMISSION_DENIED;
257 } else if (rv != NET_ERR_NONE)
258 return WIFI_ERROR_OPERATION_FAILED;
260 return WIFI_ERROR_NONE;
263 static gboolean __wifi_state_changed_cb(gpointer data)
266 struct _wifi_state_notify *notify = (struct _wifi_state_notify *)data;
271 if (notify->ap_info == NULL) {
276 ap_info = (wifi_ap_h)notify->ap_info;
278 _wifi_libnet_add_to_ap_list(ap_info);
280 if (wifi_callbacks.connection_state_cb != NULL)
281 wifi_callbacks.connection_state_cb(notify->state, ap_info,
282 wifi_callbacks.connection_state_user_data);
284 _wifi_libnet_remove_from_ap_list(ap_info);
291 static void __libnet_state_changed_cb(char *profile_name, net_profile_info_t *profile_info,
292 wifi_connection_state_e state)
295 net_profile_info_t *ap_info = NULL;
296 struct _wifi_state_notify *notify = NULL;
298 if (_wifi_is_init() != true) {
299 WIFI_LOG(WIFI_ERROR, "Application is not registered"
300 "If multi-threaded, thread integrity be broken.");
304 if (wifi_callbacks.connection_state_cb == NULL)
307 if (profile_name == NULL)
310 if (profile_info == NULL) {
311 SECURE_WIFI_LOG(WIFI_ERROR, "Failed to find: %s", profile_name);
315 ap_info = g_try_malloc0(sizeof(net_profile_info_t));
316 if (ap_info == NULL) {
317 WIFI_LOG(WIFI_ERROR, "Memory allocation error");
321 memcpy(ap_info, profile_info, sizeof(net_profile_info_t));
323 notify = g_try_new0(struct _wifi_state_notify, 1);
324 if (notify == NULL) {
329 notify->ap_info = ap_info;
330 notify->state = state;
332 id = _wifi_callback_add(__wifi_state_changed_cb, (gpointer)notify);
337 static void __libnet_set_activated_cb(wifi_activated_cb user_cb, void *user_data)
339 if (user_cb != NULL) {
340 wifi_callbacks.activated_cb = user_cb;
341 wifi_callbacks.activated_user_data = user_data;
345 static gboolean __activated_cb_idle(gpointer data)
347 wifi_error_e result = (wifi_error_e)data;
349 if (wifi_callbacks.activated_cb != NULL)
350 wifi_callbacks.activated_cb(result, wifi_callbacks.activated_user_data);
352 wifi_callbacks.activated_cb = NULL;
353 wifi_callbacks.activated_user_data = NULL;
358 static void __libnet_set_deactivated_cb(wifi_deactivated_cb user_cb, void *user_data)
360 if (user_cb != NULL) {
361 wifi_callbacks.deactivated_cb = user_cb;
362 wifi_callbacks.deactivated_user_data = user_data;
366 static gboolean __deactivated_cb_idle(gpointer data)
368 wifi_error_e result = (wifi_error_e)data;
370 if (wifi_callbacks.deactivated_cb != NULL)
371 wifi_callbacks.deactivated_cb(result, wifi_callbacks.deactivated_user_data);
373 wifi_callbacks.deactivated_cb = NULL;
374 wifi_callbacks.deactivated_user_data = NULL;
379 static gboolean __device_state_cb_idle(gpointer data)
381 wifi_device_state_e state = (wifi_device_state_e)data;
383 if (wifi_callbacks.device_state_cb != NULL)
384 wifi_callbacks.device_state_cb(state, wifi_callbacks.device_state_user_data);
389 static void __libnet_power_on_off_cb(net_event_info_t *event_cb, bool is_requested)
391 if (_wifi_is_init() != true) {
392 WIFI_LOG(WIFI_ERROR, "Application is not registered"
393 "If multi-threaded, thread integrity be broken.");
397 if (wifi_callbacks.device_state_cb == NULL &&
398 wifi_callbacks.activated_cb == NULL &&
399 wifi_callbacks.deactivated_cb == NULL)
402 wifi_error_e error_code = WIFI_ERROR_NONE;
403 wifi_device_state_e state = WIFI_DEVICE_STATE_DEACTIVATED;
404 net_wifi_state_t *wifi_state = (net_wifi_state_t *)event_cb->Data;
406 if (event_cb->Error == NET_ERR_NONE &&
407 event_cb->Datalength == sizeof(net_wifi_state_t)) {
408 if (*wifi_state == WIFI_ON) {
409 WIFI_LOG(WIFI_INFO, "Wi-Fi power on");
410 state = WIFI_DEVICE_STATE_ACTIVATED;
411 } else if (*wifi_state == WIFI_OFF) {
412 WIFI_LOG(WIFI_INFO, "Wi-Fi power off");
413 state = WIFI_DEVICE_STATE_DEACTIVATED;
414 __libnet_clear_profile_list(&profile_iterator);
416 WIFI_LOG(WIFI_ERROR, "Error Wi-Fi state %d", *wifi_state);
417 error_code = WIFI_ERROR_OPERATION_FAILED;
418 state = WIFI_DEVICE_STATE_DEACTIVATED;
421 WIFI_LOG(WIFI_ERROR, "Wi-Fi power request failed(%d)", event_cb->Error);
423 if (event_cb->Error == NET_ERR_SECURITY_RESTRICTED)
424 error_code = WIFI_ERROR_SECURITY_RESTRICTED;
426 error_code = WIFI_ERROR_OPERATION_FAILED;
428 state = WIFI_DEVICE_STATE_DEACTIVATED;
431 if (wifi_callbacks.activated_cb != NULL)
432 _wifi_callback_add(__activated_cb_idle, (gpointer)error_code);
434 if (wifi_callbacks.deactivated_cb != NULL)
435 _wifi_callback_add(__deactivated_cb_idle, (gpointer)error_code);
437 if (wifi_callbacks.device_state_cb != NULL)
438 _wifi_callback_add(__device_state_cb_idle, (gpointer)state);
441 static gboolean __scan_request_cb_idle(gpointer data)
443 wifi_error_e error_code = (wifi_error_e)data;
445 if (wifi_callbacks.scan_request_cb != NULL)
446 wifi_callbacks.scan_request_cb(error_code, wifi_callbacks.scan_request_user_data);
448 wifi_callbacks.scan_request_cb = NULL;
449 wifi_callbacks.scan_request_user_data = NULL;
454 static void __libnet_set_specific_scan_cb(wifi_scan_finished_cb user_cb, void *user_data)
456 if (user_cb != NULL) {
457 wifi_callbacks.specific_scan_cb = user_cb;
458 wifi_callbacks.specific_scan_user_data = user_data;
462 static gboolean __specific_scan_cb_idle(gpointer data)
464 wifi_error_e error_code = (wifi_error_e)data;
466 if (wifi_callbacks.specific_scan_cb != NULL)
467 wifi_callbacks.specific_scan_cb(error_code, wifi_callbacks.specific_scan_user_data);
469 wifi_callbacks.specific_scan_cb = NULL;
470 wifi_callbacks.specific_scan_user_data = NULL;
475 static gboolean __bgscan_cb_idle(gpointer data)
477 wifi_error_e error_code = (wifi_error_e)data;
479 if (wifi_callbacks.bg_scan_cb != NULL)
480 wifi_callbacks.bg_scan_cb(error_code, wifi_callbacks.bg_scan_user_data);
485 static void __libnet_scan_cb(net_event_info_t *event_cb, bool is_requested)
487 wifi_error_e error_code = WIFI_ERROR_NONE;
489 if (_wifi_is_init() != true) {
490 WIFI_LOG(WIFI_ERROR, "Application is not registered"
491 "If multi-threaded, thread integrity be broken.");
495 if (event_cb->Error != NET_ERR_NONE) {
496 WIFI_LOG(WIFI_ERROR, "Scan failed[%d]", event_cb->Error);
497 error_code = WIFI_ERROR_OPERATION_FAILED;
500 if (wifi_callbacks.scan_request_cb != NULL) {
501 _wifi_callback_add(__scan_request_cb_idle, (gpointer)error_code);
505 if (wifi_callbacks.bg_scan_cb != NULL)
506 _wifi_callback_add(__bgscan_cb_idle, (gpointer)error_code);
509 static void __libnet_specific_scan_cb(net_event_info_t *event_cb)
511 wifi_error_e error_code = WIFI_ERROR_NONE;
513 __libnet_clear_profile_list(&specific_profile_iterator);
515 if (event_cb->Error != NET_ERR_NONE) {
516 WIFI_LOG(WIFI_ERROR, "Specific scan failed!, Error [%d]\n", event_cb->Error);
517 error_code = WIFI_ERROR_OPERATION_FAILED;
518 } else if (event_cb->Data) {
519 GSList *ap_list = (GSList *)event_cb->Data;
520 __libnet_update_specific_profile_iterator(ap_list);
523 if (wifi_callbacks.specific_scan_cb != NULL)
524 _wifi_callback_add(__specific_scan_cb_idle, (gpointer)error_code);
527 static void __libnet_set_connected_cb(wifi_connected_cb user_cb, void *user_data)
529 if (user_cb != NULL) {
530 wifi_callbacks.connected_cb = user_cb;
531 wifi_callbacks.connected_user_data = user_data;
535 static gboolean __connected_cb_idle(gpointer data)
537 wifi_error_e result = (wifi_error_e)data;
539 if (wifi_callbacks.connected_cb != NULL)
540 wifi_callbacks.connected_cb(result, wifi_callbacks.connected_user_data);
542 wifi_callbacks.connected_cb = NULL;
543 wifi_callbacks.connected_user_data = NULL;
548 static void __libnet_connected_cb(wifi_error_e result)
550 if (_wifi_is_init() != true) {
551 WIFI_LOG(WIFI_ERROR, "Application is not registered"
552 "If multi-threaded, thread integrity be broken.");
556 if (wifi_callbacks.connected_cb != NULL)
557 _wifi_callback_add(__connected_cb_idle, (gpointer)result);
560 static void __libnet_set_disconnected_cb(wifi_disconnected_cb user_cb, void *user_data)
562 if (user_cb != NULL) {
563 wifi_callbacks.disconnected_cb = user_cb;
564 wifi_callbacks.disconnected_user_data = user_data;
568 static gboolean __disconnected_cb_idle(gpointer data)
570 wifi_error_e result = (wifi_error_e)data;
572 if (wifi_callbacks.disconnected_cb != NULL)
573 wifi_callbacks.disconnected_cb(result, wifi_callbacks.disconnected_user_data);
575 wifi_callbacks.disconnected_cb = NULL;
576 wifi_callbacks.disconnected_user_data = NULL;
581 static void __libnet_disconnected_cb(wifi_error_e result)
583 if (_wifi_is_init() != true) {
584 WIFI_LOG(WIFI_ERROR, "Application is not registered"
585 "If multi-threaded, thread integrity be broken.");
589 if (wifi_callbacks.disconnected_cb != NULL)
590 _wifi_callback_add(__disconnected_cb_idle, (gpointer)result);
593 static void __libnet_evt_cb(net_event_info_t *event_cb, void *user_data)
595 bool is_requested = false;
596 net_profile_info_t *prof_info_p = NULL;
597 net_profile_info_t prof_info;
598 wifi_error_e result = WIFI_ERROR_NONE;
600 bool is_profile_exists = false;
602 switch (event_cb->Event) {
603 case NET_EVENT_OPEN_RSP:
604 case NET_EVENT_WIFI_WPS_RSP:
607 case NET_EVENT_OPEN_IND:
608 if (_wifi_libnet_check_profile_name_validity(event_cb->ProfileName) != true)
611 result = __libnet_convert_to_ap_error_type(event_cb->Error);
612 WIFI_LOG(WIFI_INFO, "Connection open error %s",
613 __libnet_convert_ap_error_type_to_string(result));
616 __libnet_connected_cb(result);
618 switch (event_cb->Error) {
620 if (event_cb->Datalength == sizeof(net_profile_info_t))
621 prof_info_p = (net_profile_info_t *)event_cb->Data;
623 __libnet_state_changed_cb(event_cb->ProfileName, prof_info_p,
624 WIFI_CONNECTION_STATE_CONNECTED);
626 case NET_ERR_ACTIVE_CONNECTION_EXISTS:
632 if (net_get_profile_info(event_cb->ProfileName, &prof_info) == NET_ERR_NONE)
633 __libnet_state_changed_cb(event_cb->ProfileName, &prof_info,
634 WIFI_CONNECTION_STATE_DISCONNECTED);
636 __libnet_state_changed_cb(event_cb->ProfileName, NULL,
637 WIFI_CONNECTION_STATE_DISCONNECTED);
640 case NET_EVENT_CLOSE_RSP:
643 case NET_EVENT_CLOSE_IND:
644 if (_wifi_libnet_check_profile_name_validity(event_cb->ProfileName) != true)
647 result = __libnet_convert_to_ap_error_type(event_cb->Error);
648 WIFI_LOG(WIFI_ERROR, "Connection close error %s",
649 __libnet_convert_ap_error_type_to_string(result));
652 __libnet_disconnected_cb(result);
654 switch (event_cb->Error) {
656 if (net_get_profile_info(event_cb->ProfileName, &prof_info) == NET_ERR_NONE)
657 __libnet_state_changed_cb(event_cb->ProfileName, &prof_info,
658 WIFI_CONNECTION_STATE_DISCONNECTED);
660 __libnet_state_changed_cb(event_cb->ProfileName, NULL,
661 WIFI_CONNECTION_STATE_DISCONNECTED);
668 case NET_EVENT_NET_STATE_IND:
669 if (_wifi_libnet_check_profile_name_validity(event_cb->ProfileName) != true)
672 if (event_cb->Datalength != sizeof(net_state_type_t))
675 net_state_type_t *profile_state = (net_state_type_t *)event_cb->Data;
676 wifi_connection_state_e ap_state = _wifi_convert_to_ap_state(*profile_state);
678 WIFI_LOG(WIFI_INFO, "state: %s", __libnet_convert_ap_state_to_string(ap_state));
679 SECURE_WIFI_LOG(WIFI_INFO, "profile name: %s", event_cb->ProfileName);
681 if (net_get_profile_info(event_cb->ProfileName, &prof_info) == NET_ERR_NONE)
682 __libnet_state_changed_cb(event_cb->ProfileName, &prof_info, ap_state);
683 else if (ap_state == WIFI_CONNECTION_STATE_DISCONNECTED) {
684 for (i = 0; i < profile_iterator.count; i++) {
685 if (!g_strcmp0(event_cb->ProfileName,
686 profile_iterator.profiles[i].ProfileName)) {
687 is_profile_exists = true;
692 if (is_profile_exists == true) {
693 profile_iterator.profiles[i].ProfileState = *profile_state;
694 __libnet_state_changed_cb(event_cb->ProfileName,
695 &profile_iterator.profiles[i], ap_state);
697 __libnet_state_changed_cb(event_cb->ProfileName,
700 __libnet_state_changed_cb(event_cb->ProfileName, NULL, ap_state);
703 case NET_EVENT_WIFI_SCAN_RSP:
704 case NET_EVENT_WIFI_SCAN_IND:
705 __libnet_scan_cb(event_cb, is_requested);
707 case NET_EVENT_SPECIFIC_SCAN_RSP:
708 WIFI_LOG(WIFI_INFO, "Got Wi-Fi specific scan RSP\n");
710 case NET_EVENT_SPECIFIC_SCAN_IND:
711 WIFI_LOG(WIFI_INFO, "Got Wi-Fi specific scan IND\n");
712 __libnet_specific_scan_cb(event_cb);
714 case NET_EVENT_WIFI_POWER_RSP:
717 case NET_EVENT_WIFI_POWER_IND:
718 __libnet_power_on_off_cb(event_cb, is_requested);
725 int _wifi_libnet_init(void)
729 rv = net_register_client_ext((net_event_cb_t)__libnet_evt_cb, NET_DEVICE_WIFI, NULL);
730 if (rv != NET_ERR_NONE)
733 __wifi_set_init(true);
738 bool _wifi_libnet_deinit(void)
740 if (net_deregister_client_ext(NET_DEVICE_WIFI) != NET_ERR_NONE)
743 __libnet_clear_profile_list(&profile_iterator);
744 g_slist_free_full(ap_handle_list, g_free);
745 ap_handle_list = NULL;
746 memset(&wifi_callbacks, 0, sizeof(struct _wifi_cb_s));
748 __wifi_set_init(false);
753 int _wifi_activate(wifi_activated_cb callback, gboolean wifi_picker_test,
756 int rv = NET_ERR_NONE;
758 rv = net_wifi_power_on(wifi_picker_test);
759 if (rv == NET_ERR_NONE) {
760 __libnet_set_activated_cb(callback, user_data);
761 return WIFI_ERROR_NONE;
762 } else if (rv == NET_ERR_ACCESS_DENIED) {
763 WIFI_LOG(WIFI_ERROR, "Access denied");
764 return WIFI_ERROR_PERMISSION_DENIED;
765 } else if (rv == NET_ERR_INVALID_OPERATION)
766 return WIFI_ERROR_INVALID_OPERATION;
767 else if (rv == NET_ERR_ALREADY_EXISTS)
768 return WIFI_ERROR_ALREADY_EXISTS;
769 else if (rv == NET_ERR_IN_PROGRESS)
770 return WIFI_ERROR_NOW_IN_PROGRESS;
771 else if (rv == NET_ERR_SECURITY_RESTRICTED)
772 return WIFI_ERROR_SECURITY_RESTRICTED;
774 return WIFI_ERROR_OPERATION_FAILED;
777 int _wifi_deactivate(wifi_deactivated_cb callback, void *user_data)
779 int rv = NET_ERR_NONE;
781 rv = net_wifi_power_off();
782 if (rv == NET_ERR_NONE) {
783 __libnet_set_deactivated_cb(callback, user_data);
784 return WIFI_ERROR_NONE;
785 } else if (rv == NET_ERR_ACCESS_DENIED) {
786 WIFI_LOG(WIFI_ERROR, "Access denied");
787 return WIFI_ERROR_PERMISSION_DENIED;
788 } else if (rv == NET_ERR_INVALID_OPERATION)
789 return WIFI_ERROR_INVALID_OPERATION;
790 else if (rv == NET_ERR_ALREADY_EXISTS)
791 return WIFI_ERROR_ALREADY_EXISTS;
792 else if (rv == NET_ERR_IN_PROGRESS)
793 return WIFI_ERROR_NOW_IN_PROGRESS;
794 else if (rv == NET_ERR_SECURITY_RESTRICTED)
795 return WIFI_ERROR_SECURITY_RESTRICTED;
797 return WIFI_ERROR_OPERATION_FAILED;
800 bool _wifi_libnet_check_ap_validity(wifi_ap_h ap_h)
808 for (list = ap_handle_list; list; list = list->next)
809 if (ap_h == list->data) return true;
811 for (i = 0; i < profile_iterator.count; i++)
812 if (ap_h == &profile_iterator.profiles[i]) return true;
814 for (i = 0; i < specific_profile_iterator.count; i++)
815 if (ap_h == &specific_profile_iterator.profiles[i]) return true;
820 void _wifi_libnet_add_to_ap_list(wifi_ap_h ap_h)
822 ap_handle_list = g_slist_append(ap_handle_list, ap_h);
825 void _wifi_libnet_remove_from_ap_list(wifi_ap_h ap_h)
827 ap_handle_list = g_slist_remove(ap_handle_list, ap_h);
831 bool _wifi_libnet_check_profile_name_validity(const char *profile_name)
833 const char *profile_prefix = "/net/connman/service/wifi_";
836 if (profile_name == NULL ||
837 g_str_has_prefix(profile_name, profile_prefix) != TRUE) {
838 WIFI_LOG(WIFI_INFO, "The profile is a hidden or not a regular Wi-Fi profile");
842 while (profile_name[i] != '\0') {
843 if (isgraph(profile_name[i]) == 0) {
844 WIFI_LOG(WIFI_INFO, "Invalid format: %s", profile_name);
853 int _wifi_libnet_get_wifi_device_state(wifi_device_state_e *device_state)
855 net_tech_info_t tech_info;
857 int rv = NET_ERR_NONE;
858 rv = net_get_technology_properties(NET_DEVICE_WIFI, &tech_info);
859 if (rv == NET_ERR_ACCESS_DENIED) {
860 WIFI_LOG(WIFI_ERROR, "Access denied");
861 return WIFI_ERROR_PERMISSION_DENIED;
862 } else if (rv != NET_ERR_NONE) {
863 WIFI_LOG(WIFI_ERROR, "Failed to get technology properties");
864 return WIFI_ERROR_OPERATION_FAILED;
867 if (tech_info.powered)
868 *device_state = WIFI_DEVICE_STATE_ACTIVATED;
870 *device_state = WIFI_DEVICE_STATE_DEACTIVATED;
872 return WIFI_ERROR_NONE;
875 int _wifi_libnet_get_wifi_state(wifi_connection_state_e *connection_state)
877 wifi_dbus *dbus_h = NULL;
878 GError *error = NULL;
879 GVariant *result = NULL;
882 dbus_h = _wifi_get_dbus_handle();
883 if (dbus_h == NULL) {
884 WIFI_LOG(WIFI_ERROR, "Not initialized for wifi dbus connection");
885 return WIFI_ERROR_INVALID_OPERATION;
888 result = g_dbus_connection_call_sync(dbus_h->dbus_conn,
894 NULL, G_DBUS_CALL_FLAGS_NONE,
895 DBUS_REPLY_TIMEOUT, dbus_h->ca,
899 WIFI_LOG(WIFI_ERROR, "Fail to GetWifiState [%d: %s]", error->code, error->message);
901 return WIFI_ERROR_OPERATION_FAILED;
904 if (result != NULL) {
905 g_variant_get(result, "(i)", &state);
906 g_variant_unref(result);
909 *connection_state = state;
911 return WIFI_ERROR_NONE;
914 int _wifi_libnet_get_intf_name(char** name)
918 if (profile_iterator.count == 0) {
919 rv = __libnet_update_profile_iterator();
920 if (rv == NET_ERR_ACCESS_DENIED) {
921 WIFI_LOG(WIFI_ERROR, "Access denied");
922 return WIFI_ERROR_PERMISSION_DENIED;
926 if (profile_iterator.count == 0) {
927 WIFI_LOG(WIFI_ERROR, "There is no AP");
928 return WIFI_ERROR_OPERATION_FAILED;
931 *name = g_strdup(profile_iterator.profiles->ProfileInfo.Wlan.net_info.DevName);
933 return WIFI_ERROR_OUT_OF_MEMORY;
935 return WIFI_ERROR_NONE;
938 int _wifi_libnet_scan_request(wifi_scan_finished_cb callback, void *user_data)
941 rv = net_scan_wifi();
943 if (rv == NET_ERR_NONE) {
944 wifi_callbacks.scan_request_cb = callback;
945 wifi_callbacks.scan_request_user_data = user_data;
946 return WIFI_ERROR_NONE;
947 } else if (rv == NET_ERR_ACCESS_DENIED) {
948 WIFI_LOG(WIFI_ERROR, "Access denied");
949 return WIFI_ERROR_PERMISSION_DENIED;
950 } else if (rv == NET_ERR_INVALID_OPERATION)
951 return WIFI_ERROR_INVALID_OPERATION;
953 return WIFI_ERROR_OPERATION_FAILED;
956 int _wifi_libnet_scan_specific_ap(const char *essid,
957 wifi_scan_finished_cb callback, void *user_data)
960 rv = net_specific_scan_wifi(essid);
962 if (rv == NET_ERR_NONE) {
963 g_strlcpy(specific_profile_essid, essid, NET_WLAN_ESSID_LEN+1);
964 __libnet_set_specific_scan_cb(callback, user_data);
965 return WIFI_ERROR_NONE;
966 } else if (rv == NET_ERR_ACCESS_DENIED) {
967 WIFI_LOG(WIFI_ERROR, "Access denied");
968 return WIFI_ERROR_PERMISSION_DENIED;
969 } else if (rv == NET_ERR_INVALID_OPERATION)
970 return WIFI_ERROR_INVALID_OPERATION;
972 return WIFI_ERROR_OPERATION_FAILED;
975 int _wifi_libnet_get_connected_profile(wifi_ap_h *ap)
978 wifi_ap_h ap_h = NULL;
980 rv = __libnet_update_profile_iterator();
981 if (rv == NET_ERR_ACCESS_DENIED) {
982 WIFI_LOG(WIFI_ERROR, "Access denied");
983 return WIFI_ERROR_PERMISSION_DENIED;
986 for (i = 0; i < profile_iterator.count; i++) {
987 if (profile_iterator.profiles[i].ProfileState == NET_STATE_TYPE_ONLINE ||
988 profile_iterator.profiles[i].ProfileState == NET_STATE_TYPE_READY) {
989 ap_h = (wifi_ap_h)(&profile_iterator.profiles[i]);
995 WIFI_LOG(WIFI_ERROR, "There is no connected AP");
996 return WIFI_ERROR_NO_CONNECTION;
999 *ap = g_try_malloc0(sizeof(net_profile_info_t));
1001 return WIFI_ERROR_OUT_OF_MEMORY;
1003 memcpy(*ap, ap_h, sizeof(net_profile_info_t));
1005 _wifi_libnet_add_to_ap_list(*ap);
1007 return WIFI_ERROR_NONE;
1010 int _wifi_libnet_foreach_found_aps(wifi_found_ap_cb callback, void *user_data)
1014 rv = __libnet_update_profile_iterator();
1015 if (rv == NET_ERR_ACCESS_DENIED) {
1016 WIFI_LOG(WIFI_ERROR, "Access denied");
1017 return WIFI_ERROR_PERMISSION_DENIED;
1020 if (profile_iterator.count == 0) {
1021 WIFI_LOG(WIFI_WARN, "There is no AP");
1022 return WIFI_ERROR_NONE;
1025 for (i = 0; i < profile_iterator.count; i++) {
1026 if (profile_iterator.profiles[i].ProfileInfo.Wlan.is_hidden == TRUE)
1029 rv = callback((wifi_ap_h)(&profile_iterator.profiles[i]), user_data);
1030 if (rv == false) break;
1033 return WIFI_ERROR_NONE;
1036 int _wifi_libnet_foreach_found_specific_aps(wifi_found_ap_cb callback, void *user_data)
1040 if (specific_profile_iterator.count == 0) {
1041 WIFI_LOG(WIFI_WARN, "There is no specific APs");
1043 rv = __libnet_update_profile_iterator();
1044 if (rv == NET_ERR_ACCESS_DENIED) {
1045 WIFI_LOG(WIFI_ERROR, "Access denied");
1046 return WIFI_ERROR_PERMISSION_DENIED;
1049 if (profile_iterator.count == 0) {
1050 WIFI_LOG(WIFI_WARN, "There is no APs");
1051 return WIFI_ERROR_NONE;
1054 for (i = 0; i < profile_iterator.count; i++) {
1055 if (!g_strcmp0(specific_profile_essid,
1056 profile_iterator.profiles[i].ProfileInfo.Wlan.essid)) {
1057 rv = callback((wifi_ap_h)(&profile_iterator.profiles[i]), user_data);
1058 if (rv == false) break;
1061 return WIFI_ERROR_NONE;
1064 for (i = 0; i < specific_profile_iterator.count; i++) {
1065 rv = callback((wifi_ap_h)(&specific_profile_iterator.profiles[i]), user_data);
1066 if (rv == false) break;
1069 return WIFI_ERROR_NONE;
1072 int _wifi_libnet_open_profile(wifi_ap_h ap_h, wifi_connected_cb callback, void *user_data)
1076 net_profile_info_t *ap_info = ap_h;
1079 _wifi_libnet_check_profile_name_validity(ap_info->ProfileName);
1081 if (valid_profile == true && ap_info->Favourite)
1082 rv = net_open_connection_with_profile(ap_info->ProfileName);
1083 else if (valid_profile == true &&
1084 ap_info->ProfileInfo.Wlan.is_hidden != TRUE &&
1085 ap_info->ProfileInfo.Wlan.security_info.sec_mode ==
1087 rv = net_open_connection_with_profile(ap_info->ProfileName);
1089 rv = __libnet_connect_with_wifi_info(ap_info);
1091 rv = __libnet_convert_to_ap_error_type(rv);
1092 if (rv == WIFI_ERROR_NONE)
1093 __libnet_set_connected_cb(callback, user_data);
1098 int _wifi_libnet_close_profile(wifi_ap_h ap_h, wifi_disconnected_cb callback, void *user_data)
1101 net_profile_info_t *ap_info = ap_h;
1103 rv = net_close_connection(ap_info->ProfileName);
1104 if (rv == NET_ERR_ACCESS_DENIED) {
1105 WIFI_LOG(WIFI_ERROR, "Access denied");
1106 return WIFI_ERROR_PERMISSION_DENIED;
1107 } else if (rv != NET_ERR_NONE)
1108 return WIFI_ERROR_OPERATION_FAILED;
1110 __libnet_set_disconnected_cb(callback, user_data);
1112 return WIFI_ERROR_NONE;
1115 int _wifi_libnet_connect_with_wps_pbc(wifi_ap_h ap_h, wifi_connected_cb callback, void *user_data)
1118 net_profile_info_t *ap_info = ap_h;
1119 net_wifi_wps_info_t wps_info;
1120 memset(&wps_info, 0, sizeof(net_wifi_wps_info_t));
1122 wps_info.type = WIFI_WPS_PBC;
1124 rv = net_wifi_enroll_wps(ap_info->ProfileName, &wps_info);
1125 if (rv == NET_ERR_ACCESS_DENIED) {
1126 WIFI_LOG(WIFI_ERROR, "Access denied");
1127 return WIFI_ERROR_PERMISSION_DENIED;
1128 } else if (rv != NET_ERR_NONE)
1129 return WIFI_ERROR_OPERATION_FAILED;
1131 __libnet_set_connected_cb(callback, user_data);
1133 return WIFI_ERROR_NONE;
1136 int _wifi_libnet_connect_with_wps_pin(wifi_ap_h ap_h, const char *pin,
1137 wifi_connected_cb callback, void *user_data)
1140 net_profile_info_t *ap_info = ap_h;
1141 net_wifi_wps_info_t wps_info;
1143 if (ap_info == NULL) {
1144 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1145 return WIFI_ERROR_INVALID_PARAMETER;
1148 wps_info.type = WIFI_WPS_PIN;
1149 g_strlcpy(wps_info.pin, pin, NET_WLAN_MAX_WPSPIN_LEN + 1);
1151 rv = net_wifi_enroll_wps(ap_info->ProfileName, &wps_info);
1152 if (rv == NET_ERR_ACCESS_DENIED) {
1153 WIFI_LOG(WIFI_ERROR, "Access denied");
1154 return WIFI_ERROR_PERMISSION_DENIED;
1155 } else if (rv != NET_ERR_NONE)
1156 return WIFI_ERROR_OPERATION_FAILED;
1158 __libnet_set_connected_cb(callback, user_data);
1160 return WIFI_ERROR_NONE;
1163 int _wifi_libnet_forget_ap(wifi_ap_h ap)
1166 net_profile_info_t *ap_info = ap;
1168 if (ap_info == NULL) {
1169 WIFI_LOG(WIFI_ERROR, "Invalid parameter");
1170 return WIFI_ERROR_INVALID_PARAMETER;
1173 rv = net_delete_profile(ap_info->ProfileName);
1174 if (rv == NET_ERR_ACCESS_DENIED) {
1175 WIFI_LOG(WIFI_ERROR, "Access denied");
1176 return WIFI_ERROR_PERMISSION_DENIED;
1177 } else if (rv != NET_ERR_NONE)
1178 return WIFI_ERROR_OPERATION_FAILED;
1180 ap_info->Favourite = (char)FALSE;
1182 return WIFI_ERROR_NONE;
1185 int _wifi_set_power_on_off_cb(wifi_device_state_changed_cb callback, void *user_data)
1187 if (wifi_callbacks.device_state_cb != NULL)
1188 return WIFI_ERROR_INVALID_OPERATION;
1190 wifi_callbacks.device_state_cb = callback;
1191 wifi_callbacks.device_state_user_data = user_data;
1193 WIFI_LOG(WIFI_INFO, "Wi-Fi registered device state changed callback");
1195 return WIFI_ERROR_NONE;
1198 int _wifi_unset_power_on_off_cb(void)
1200 if (wifi_callbacks.device_state_cb == NULL)
1201 return WIFI_ERROR_INVALID_OPERATION;
1203 wifi_callbacks.device_state_cb = NULL;
1204 wifi_callbacks.device_state_user_data = NULL;
1206 return WIFI_ERROR_NONE;
1209 int _wifi_set_background_scan_cb(wifi_scan_finished_cb callback, void *user_data)
1211 if (wifi_callbacks.bg_scan_cb != NULL)
1212 return WIFI_ERROR_INVALID_OPERATION;
1214 wifi_callbacks.bg_scan_cb = callback;
1215 wifi_callbacks.bg_scan_user_data = user_data;
1217 return WIFI_ERROR_NONE;
1220 int _wifi_unset_background_scan_cb(void)
1222 if (wifi_callbacks.bg_scan_cb == NULL)
1223 return WIFI_ERROR_INVALID_OPERATION;
1225 wifi_callbacks.bg_scan_cb = NULL;
1226 wifi_callbacks.bg_scan_user_data = NULL;
1228 return WIFI_ERROR_NONE;
1231 int _wifi_set_connection_state_cb(wifi_connection_state_changed_cb callback, void *user_data)
1233 if (wifi_callbacks.connection_state_cb != NULL)
1234 return WIFI_ERROR_INVALID_OPERATION;
1236 wifi_callbacks.connection_state_cb = callback;
1237 wifi_callbacks.connection_state_user_data = user_data;
1239 return WIFI_ERROR_NONE;
1242 int _wifi_unset_connection_state_cb()
1244 if (wifi_callbacks.connection_state_cb == NULL)
1245 return WIFI_ERROR_INVALID_OPERATION;
1247 wifi_callbacks.connection_state_cb = NULL;
1248 wifi_callbacks.connection_state_user_data = NULL;
1250 return WIFI_ERROR_NONE;
1253 int _wifi_update_ap_info(net_profile_info_t *ap_info)
1255 int rv = NET_ERR_NONE;
1256 rv = net_modify_profile(ap_info->ProfileName, ap_info);
1258 if (rv == NET_ERR_ACCESS_DENIED) {
1259 WIFI_LOG(WIFI_ERROR, "Access denied");
1260 return WIFI_ERROR_PERMISSION_DENIED;
1261 } else if (rv != NET_ERR_NONE)
1262 return WIFI_ERROR_OPERATION_FAILED;
1264 return WIFI_ERROR_NONE;
1267 static void __wifi_idle_destroy_cb(gpointer data)
1272 managed_idler_list = g_slist_remove(managed_idler_list, data);
1276 static gboolean __wifi_idle_cb(gpointer user_data)
1278 struct managed_idle_data *data = (struct managed_idle_data *)user_data;
1283 return data->func(data->user_data);
1286 guint _wifi_callback_add(GSourceFunc func, gpointer user_data)
1289 struct managed_idle_data *data;
1294 data = g_try_new0(struct managed_idle_data, 1);
1299 data->user_data = user_data;
1301 id = g_idle_add_full(G_PRIORITY_DEFAULT_IDLE, __wifi_idle_cb, data,
1302 __wifi_idle_destroy_cb);
1310 managed_idler_list = g_slist_append(managed_idler_list, data);
1315 void _wifi_callback_cleanup(void)
1317 GSList *cur = managed_idler_list;
1319 struct managed_idle_data *data;
1322 GSList *next = cur->next;
1323 data = (struct managed_idle_data *)cur->data;
1325 src = g_main_context_find_source_by_id(g_main_context_default(), data->id);
1327 g_source_destroy(src);
1328 cur = managed_idler_list;
1333 g_slist_free(managed_idler_list);
1334 managed_idler_list = NULL;
1337 int _wifi_check_feature_supported(const char *feature_name)
1339 if (is_feature_checked) {
1340 if (!feature_supported) {
1341 LOGE("%s feature is disabled", feature_name);
1342 return WIFI_ERROR_NOT_SUPPORTED;
1345 if (!system_info_get_platform_bool(feature_name, &feature_supported)) {
1346 is_feature_checked = true;
1347 if (!feature_supported) {
1348 LOGE("%s feature is disabled", feature_name);
1349 return WIFI_ERROR_NOT_SUPPORTED;
1352 LOGE("Error - Feature getting from System Info");
1353 return WIFI_ERROR_OPERATION_FAILED;
1357 return WIFI_ERROR_NONE;
1360 int _wifi_dbus_init(void)
1364 rv = wifi_dbus_init(&g_dbus_h);
1365 if (rv != NET_ERR_NONE)
1368 return NET_ERR_NONE;
1371 int _wifi_dbus_deinit(void)
1373 wifi_dbus_deinit(g_dbus_h);
1376 return NET_ERR_NONE;
1379 wifi_dbus *_wifi_get_dbus_handle(void)
1381 if (g_dbus_h == NULL) {
1382 WIFI_LOG(WIFI_ERROR, "g_dbus_h is NULL");