1/*
2 * wpa_supplicant - Event notifications
3 * Copyright (c) 2009-2010, Jouni Malinen <j@w1.fi>
4 *
5 * This software may be distributed under the terms of the BSD license.
6 * See README for more details.
7 */
8
9#include "utils/includes.h"
10
11#include "utils/common.h"
12#include "common/wpa_ctrl.h"
13#include "config.h"
14#include "wpa_supplicant_i.h"
15#include "wps_supplicant.h"
16#include "dbus/dbus_common.h"
17#include "dbus/dbus_old.h"
18#include "dbus/dbus_new.h"
19#include "rsn_supp/wpa.h"
20#include "driver_i.h"
21#include "scan.h"
22#include "p2p_supplicant.h"
23#include "sme.h"
24#include "notify.h"
25
26int wpas_notify_supplicant_initialized(struct wpa_global *global)
27{
28#ifdef CONFIG_DBUS
29	if (global->params.dbus_ctrl_interface) {
30		global->dbus = wpas_dbus_init(global);
31		if (global->dbus == NULL)
32			return -1;
33	}
34#endif /* CONFIG_DBUS */
35
36	return 0;
37}
38
39
40void wpas_notify_supplicant_deinitialized(struct wpa_global *global)
41{
42#ifdef CONFIG_DBUS
43	if (global->dbus)
44		wpas_dbus_deinit(global->dbus);
45#endif /* CONFIG_DBUS */
46}
47
48
49int wpas_notify_iface_added(struct wpa_supplicant *wpa_s)
50{
51	if (wpas_dbus_register_iface(wpa_s))
52		return -1;
53
54	if (wpas_dbus_register_interface(wpa_s))
55		return -1;
56
57	return 0;
58}
59
60
61void wpas_notify_iface_removed(struct wpa_supplicant *wpa_s)
62{
63	/* unregister interface in old DBus ctrl iface */
64	wpas_dbus_unregister_iface(wpa_s);
65
66	/* unregister interface in new DBus ctrl iface */
67	wpas_dbus_unregister_interface(wpa_s);
68}
69
70
71void wpas_notify_state_changed(struct wpa_supplicant *wpa_s,
72			       enum wpa_states new_state,
73			       enum wpa_states old_state)
74{
75	/* notify the old DBus API */
76	wpa_supplicant_dbus_notify_state_change(wpa_s, new_state,
77						old_state);
78
79	/* notify the new DBus API */
80	wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_STATE);
81
82	if (new_state == WPA_COMPLETED)
83		wpas_p2p_notif_connected(wpa_s);
84	else if (old_state >= WPA_ASSOCIATED && new_state < WPA_ASSOCIATED)
85		wpas_p2p_notif_disconnected(wpa_s);
86
87	sme_state_changed(wpa_s);
88
89#ifdef ANDROID
90	wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_STATE_CHANGE
91		     "id=%d state=%d BSSID=" MACSTR " SSID=%s",
92		     wpa_s->current_ssid ? wpa_s->current_ssid->id : -1,
93		     new_state,
94		     MAC2STR(wpa_s->bssid),
95		     wpa_s->current_ssid && wpa_s->current_ssid->ssid ?
96		     wpa_ssid_txt(wpa_s->current_ssid->ssid,
97				  wpa_s->current_ssid->ssid_len) : "");
98#endif /* ANDROID */
99}
100
101
102void wpas_notify_disconnect_reason(struct wpa_supplicant *wpa_s)
103{
104	wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_DISCONNECT_REASON);
105}
106
107
108void wpas_notify_network_changed(struct wpa_supplicant *wpa_s)
109{
110	wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_CURRENT_NETWORK);
111}
112
113
114void wpas_notify_ap_scan_changed(struct wpa_supplicant *wpa_s)
115{
116	wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_AP_SCAN);
117}
118
119
120void wpas_notify_bssid_changed(struct wpa_supplicant *wpa_s)
121{
122	wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_CURRENT_BSS);
123}
124
125
126void wpas_notify_auth_changed(struct wpa_supplicant *wpa_s)
127{
128	wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_CURRENT_AUTH_MODE);
129}
130
131
132void wpas_notify_network_enabled_changed(struct wpa_supplicant *wpa_s,
133					 struct wpa_ssid *ssid)
134{
135	wpas_dbus_signal_network_enabled_changed(wpa_s, ssid);
136}
137
138
139void wpas_notify_network_selected(struct wpa_supplicant *wpa_s,
140				  struct wpa_ssid *ssid)
141{
142	wpas_dbus_signal_network_selected(wpa_s, ssid->id);
143}
144
145
146void wpas_notify_network_request(struct wpa_supplicant *wpa_s,
147				 struct wpa_ssid *ssid,
148				 enum wpa_ctrl_req_type rtype,
149				 const char *default_txt)
150{
151	wpas_dbus_signal_network_request(wpa_s, ssid, rtype, default_txt);
152}
153
154
155void wpas_notify_scanning(struct wpa_supplicant *wpa_s)
156{
157	/* notify the old DBus API */
158	wpa_supplicant_dbus_notify_scanning(wpa_s);
159
160	/* notify the new DBus API */
161	wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_SCANNING);
162}
163
164
165void wpas_notify_scan_done(struct wpa_supplicant *wpa_s, int success)
166{
167	wpas_dbus_signal_scan_done(wpa_s, success);
168}
169
170
171void wpas_notify_scan_results(struct wpa_supplicant *wpa_s)
172{
173	/* notify the old DBus API */
174	wpa_supplicant_dbus_notify_scan_results(wpa_s);
175
176	wpas_wps_notify_scan_results(wpa_s);
177}
178
179
180void wpas_notify_wps_credential(struct wpa_supplicant *wpa_s,
181				const struct wps_credential *cred)
182{
183#ifdef CONFIG_WPS
184	/* notify the old DBus API */
185	wpa_supplicant_dbus_notify_wps_cred(wpa_s, cred);
186	/* notify the new DBus API */
187	wpas_dbus_signal_wps_cred(wpa_s, cred);
188#endif /* CONFIG_WPS */
189}
190
191
192void wpas_notify_wps_event_m2d(struct wpa_supplicant *wpa_s,
193			       struct wps_event_m2d *m2d)
194{
195#ifdef CONFIG_WPS
196	wpas_dbus_signal_wps_event_m2d(wpa_s, m2d);
197#endif /* CONFIG_WPS */
198}
199
200
201void wpas_notify_wps_event_fail(struct wpa_supplicant *wpa_s,
202				struct wps_event_fail *fail)
203{
204#ifdef CONFIG_WPS
205	wpas_dbus_signal_wps_event_fail(wpa_s, fail);
206#endif /* CONFIG_WPS */
207}
208
209
210void wpas_notify_wps_event_success(struct wpa_supplicant *wpa_s)
211{
212#ifdef CONFIG_WPS
213	wpas_dbus_signal_wps_event_success(wpa_s);
214#endif /* CONFIG_WPS */
215}
216
217
218void wpas_notify_network_added(struct wpa_supplicant *wpa_s,
219			       struct wpa_ssid *ssid)
220{
221	/*
222	 * Networks objects created during any P2P activities should not be
223	 * exposed out. They might/will confuse certain non-P2P aware
224	 * applications since these network objects won't behave like
225	 * regular ones.
226	 */
227	if (!ssid->p2p_group && wpa_s->global->p2p_group_formation != wpa_s)
228		wpas_dbus_register_network(wpa_s, ssid);
229}
230
231
232void wpas_notify_persistent_group_added(struct wpa_supplicant *wpa_s,
233					struct wpa_ssid *ssid)
234{
235#ifdef CONFIG_P2P
236	wpas_dbus_register_persistent_group(wpa_s, ssid);
237#endif /* CONFIG_P2P */
238}
239
240
241void wpas_notify_persistent_group_removed(struct wpa_supplicant *wpa_s,
242					  struct wpa_ssid *ssid)
243{
244#ifdef CONFIG_P2P
245	wpas_dbus_unregister_persistent_group(wpa_s, ssid->id);
246#endif /* CONFIG_P2P */
247}
248
249
250void wpas_notify_network_removed(struct wpa_supplicant *wpa_s,
251				 struct wpa_ssid *ssid)
252{
253	if (wpa_s->next_ssid == ssid)
254		wpa_s->next_ssid = NULL;
255	if (wpa_s->wpa)
256		wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
257	if (!ssid->p2p_group && wpa_s->global->p2p_group_formation != wpa_s)
258		wpas_dbus_unregister_network(wpa_s, ssid->id);
259	wpas_p2p_network_removed(wpa_s, ssid);
260}
261
262
263void wpas_notify_bss_added(struct wpa_supplicant *wpa_s,
264			   u8 bssid[], unsigned int id)
265{
266	wpas_dbus_register_bss(wpa_s, bssid, id);
267	wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_BSS_ADDED "%u " MACSTR,
268		     id, MAC2STR(bssid));
269}
270
271
272void wpas_notify_bss_removed(struct wpa_supplicant *wpa_s,
273			     u8 bssid[], unsigned int id)
274{
275	wpas_dbus_unregister_bss(wpa_s, bssid, id);
276	wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_BSS_REMOVED "%u " MACSTR,
277		     id, MAC2STR(bssid));
278}
279
280
281void wpas_notify_bss_freq_changed(struct wpa_supplicant *wpa_s,
282				  unsigned int id)
283{
284	wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_FREQ, id);
285}
286
287
288void wpas_notify_bss_signal_changed(struct wpa_supplicant *wpa_s,
289				    unsigned int id)
290{
291	wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_SIGNAL,
292					  id);
293}
294
295
296void wpas_notify_bss_privacy_changed(struct wpa_supplicant *wpa_s,
297				     unsigned int id)
298{
299	wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_PRIVACY,
300					  id);
301}
302
303
304void wpas_notify_bss_mode_changed(struct wpa_supplicant *wpa_s,
305				  unsigned int id)
306{
307	wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_MODE, id);
308}
309
310
311void wpas_notify_bss_wpaie_changed(struct wpa_supplicant *wpa_s,
312				   unsigned int id)
313{
314	wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_WPA, id);
315}
316
317
318void wpas_notify_bss_rsnie_changed(struct wpa_supplicant *wpa_s,
319				   unsigned int id)
320{
321	wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_RSN, id);
322}
323
324
325void wpas_notify_bss_wps_changed(struct wpa_supplicant *wpa_s,
326				 unsigned int id)
327{
328#ifdef CONFIG_WPS
329	wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_WPS, id);
330#endif /* CONFIG_WPS */
331}
332
333
334void wpas_notify_bss_ies_changed(struct wpa_supplicant *wpa_s,
335				   unsigned int id)
336{
337	wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_IES, id);
338}
339
340
341void wpas_notify_bss_rates_changed(struct wpa_supplicant *wpa_s,
342				   unsigned int id)
343{
344	wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_RATES, id);
345}
346
347
348void wpas_notify_bss_seen(struct wpa_supplicant *wpa_s, unsigned int id)
349{
350	wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_AGE, id);
351}
352
353
354void wpas_notify_blob_added(struct wpa_supplicant *wpa_s, const char *name)
355{
356	wpas_dbus_signal_blob_added(wpa_s, name);
357}
358
359
360void wpas_notify_blob_removed(struct wpa_supplicant *wpa_s, const char *name)
361{
362	wpas_dbus_signal_blob_removed(wpa_s, name);
363}
364
365
366void wpas_notify_debug_level_changed(struct wpa_global *global)
367{
368	wpas_dbus_signal_debug_level_changed(global);
369}
370
371
372void wpas_notify_debug_timestamp_changed(struct wpa_global *global)
373{
374	wpas_dbus_signal_debug_timestamp_changed(global);
375}
376
377
378void wpas_notify_debug_show_keys_changed(struct wpa_global *global)
379{
380	wpas_dbus_signal_debug_show_keys_changed(global);
381}
382
383
384void wpas_notify_suspend(struct wpa_global *global)
385{
386	struct wpa_supplicant *wpa_s;
387
388	os_get_time(&global->suspend_time);
389	wpa_printf(MSG_DEBUG, "System suspend notification");
390	for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
391		wpa_drv_suspend(wpa_s);
392}
393
394
395void wpas_notify_resume(struct wpa_global *global)
396{
397	struct os_time now;
398	int slept;
399	struct wpa_supplicant *wpa_s;
400
401	if (global->suspend_time.sec == 0)
402		slept = -1;
403	else {
404		os_get_time(&now);
405		slept = now.sec - global->suspend_time.sec;
406	}
407	wpa_printf(MSG_DEBUG, "System resume notification (slept %d seconds)",
408		   slept);
409
410	for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
411		wpa_drv_resume(wpa_s);
412		if (wpa_s->wpa_state == WPA_DISCONNECTED)
413			wpa_supplicant_req_scan(wpa_s, 0, 100000);
414	}
415}
416
417
418#ifdef CONFIG_P2P
419
420void wpas_notify_p2p_device_found(struct wpa_supplicant *wpa_s,
421				  const u8 *dev_addr, int new_device)
422{
423	if (new_device) {
424		/* Create the new peer object */
425		wpas_dbus_register_peer(wpa_s, dev_addr);
426	}
427
428	/* Notify a new peer has been detected*/
429	wpas_dbus_signal_peer_device_found(wpa_s, dev_addr);
430}
431
432
433void wpas_notify_p2p_device_lost(struct wpa_supplicant *wpa_s,
434				 const u8 *dev_addr)
435{
436	wpas_dbus_unregister_peer(wpa_s, dev_addr);
437
438	/* Create signal on interface object*/
439	wpas_dbus_signal_peer_device_lost(wpa_s, dev_addr);
440}
441
442
443void wpas_notify_p2p_group_removed(struct wpa_supplicant *wpa_s,
444				   const struct wpa_ssid *ssid,
445				   const char *role)
446{
447	wpas_dbus_signal_p2p_group_removed(wpa_s, role);
448
449	wpas_dbus_unregister_p2p_group(wpa_s, ssid);
450}
451
452
453void wpas_notify_p2p_go_neg_req(struct wpa_supplicant *wpa_s,
454				const u8 *src, u16 dev_passwd_id)
455{
456	wpas_dbus_signal_p2p_go_neg_req(wpa_s, src, dev_passwd_id);
457}
458
459
460void wpas_notify_p2p_go_neg_completed(struct wpa_supplicant *wpa_s,
461				      struct p2p_go_neg_results *res)
462{
463	wpas_dbus_signal_p2p_go_neg_resp(wpa_s, res);
464}
465
466
467void wpas_notify_p2p_invitation_result(struct wpa_supplicant *wpa_s,
468				       int status, const u8 *bssid)
469{
470	wpas_dbus_signal_p2p_invitation_result(wpa_s, status, bssid);
471}
472
473
474void wpas_notify_p2p_sd_request(struct wpa_supplicant *wpa_s,
475				int freq, const u8 *sa, u8 dialog_token,
476				u16 update_indic, const u8 *tlvs,
477				size_t tlvs_len)
478{
479	wpas_dbus_signal_p2p_sd_request(wpa_s, freq, sa, dialog_token,
480					update_indic, tlvs, tlvs_len);
481}
482
483
484void wpas_notify_p2p_sd_response(struct wpa_supplicant *wpa_s,
485				 const u8 *sa, u16 update_indic,
486				 const u8 *tlvs, size_t tlvs_len)
487{
488	wpas_dbus_signal_p2p_sd_response(wpa_s, sa, update_indic,
489					 tlvs, tlvs_len);
490}
491
492
493/**
494 * wpas_notify_p2p_provision_discovery - Notification of provision discovery
495 * @dev_addr: Who sent the request or responded to our request.
496 * @request: Will be 1 if request, 0 for response.
497 * @status: Valid only in case of response (0 in case of success)
498 * @config_methods: WPS config methods
499 * @generated_pin: PIN to be displayed in case of WPS_CONFIG_DISPLAY method
500 *
501 * This can be used to notify:
502 * - Requests or responses
503 * - Various config methods
504 * - Failure condition in case of response
505 */
506void wpas_notify_p2p_provision_discovery(struct wpa_supplicant *wpa_s,
507					 const u8 *dev_addr, int request,
508					 enum p2p_prov_disc_status status,
509					 u16 config_methods,
510					 unsigned int generated_pin)
511{
512	wpas_dbus_signal_p2p_provision_discovery(wpa_s, dev_addr, request,
513						 status, config_methods,
514						 generated_pin);
515}
516
517
518void wpas_notify_p2p_group_started(struct wpa_supplicant *wpa_s,
519				   struct wpa_ssid *ssid, int network_id,
520				   int client)
521{
522	/* Notify a group has been started */
523	wpas_dbus_register_p2p_group(wpa_s, ssid);
524
525	wpas_dbus_signal_p2p_group_started(wpa_s, ssid, client, network_id);
526}
527
528
529void wpas_notify_p2p_wps_failed(struct wpa_supplicant *wpa_s,
530				struct wps_event_fail *fail)
531{
532	wpas_dbus_signal_p2p_wps_failed(wpa_s, fail);
533}
534
535#endif /* CONFIG_P2P */
536
537
538static void wpas_notify_ap_sta_authorized(struct wpa_supplicant *wpa_s,
539					  const u8 *sta,
540					  const u8 *p2p_dev_addr)
541{
542#ifdef CONFIG_P2P
543	wpas_p2p_notify_ap_sta_authorized(wpa_s, p2p_dev_addr);
544
545	/*
546	 * Create 'peer-joined' signal on group object -- will also
547	 * check P2P itself.
548	 */
549	wpas_dbus_signal_p2p_peer_joined(wpa_s, p2p_dev_addr);
550#endif /* CONFIG_P2P */
551
552	/* Notify listeners a new station has been authorized */
553	wpas_dbus_signal_sta_authorized(wpa_s, sta);
554}
555
556
557static void wpas_notify_ap_sta_deauthorized(struct wpa_supplicant *wpa_s,
558					    const u8 *sta,
559					    const u8 *p2p_dev_addr)
560{
561#ifdef CONFIG_P2P
562	/*
563	 * Create 'peer-disconnected' signal on group object if this
564	 * is a P2P group.
565	 */
566	wpas_dbus_signal_p2p_peer_disconnected(wpa_s, p2p_dev_addr);
567#endif /* CONFIG_P2P */
568
569	/* Notify listeners a station has been deauthorized */
570	wpas_dbus_signal_sta_deauthorized(wpa_s, sta);
571}
572
573
574void wpas_notify_sta_authorized(struct wpa_supplicant *wpa_s,
575				const u8 *mac_addr, int authorized,
576				const u8 *p2p_dev_addr)
577{
578	if (authorized)
579		wpas_notify_ap_sta_authorized(wpa_s, mac_addr, p2p_dev_addr);
580	else
581		wpas_notify_ap_sta_deauthorized(wpa_s, mac_addr, p2p_dev_addr);
582}
583
584
585void wpas_notify_certification(struct wpa_supplicant *wpa_s, int depth,
586			       const char *subject, const char *cert_hash,
587			       const struct wpabuf *cert)
588{
589	wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_EAP_PEER_CERT
590		"depth=%d subject='%s'%s%s",
591		depth, subject,
592		cert_hash ? " hash=" : "",
593		cert_hash ? cert_hash : "");
594
595	if (cert) {
596		char *cert_hex;
597		size_t len = wpabuf_len(cert) * 2 + 1;
598		cert_hex = os_malloc(len);
599		if (cert_hex) {
600			wpa_snprintf_hex(cert_hex, len, wpabuf_head(cert),
601					 wpabuf_len(cert));
602			wpa_msg_ctrl(wpa_s, MSG_INFO,
603				     WPA_EVENT_EAP_PEER_CERT
604				     "depth=%d subject='%s' cert=%s",
605				     depth, subject, cert_hex);
606			os_free(cert_hex);
607		}
608	}
609
610	/* notify the old DBus API */
611	wpa_supplicant_dbus_notify_certification(wpa_s, depth, subject,
612						 cert_hash, cert);
613	/* notify the new DBus API */
614	wpas_dbus_signal_certification(wpa_s, depth, subject, cert_hash, cert);
615}
616
617
618void wpas_notify_preq(struct wpa_supplicant *wpa_s,
619		      const u8 *addr, const u8 *dst, const u8 *bssid,
620		      const u8 *ie, size_t ie_len, u32 ssi_signal)
621{
622#ifdef CONFIG_AP
623	wpas_dbus_signal_preq(wpa_s, addr, dst, bssid, ie, ie_len, ssi_signal);
624#endif /* CONFIG_AP */
625}
626
627
628void wpas_notify_eap_status(struct wpa_supplicant *wpa_s, const char *status,
629			    const char *parameter)
630{
631	wpas_dbus_signal_eap_status(wpa_s, status, parameter);
632	wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_EAP_STATUS
633		     "status='%s' parameter='%s'",
634		     status, parameter);
635}
636
637
638void wpas_notify_network_bssid_set_changed(struct wpa_supplicant *wpa_s,
639					   struct wpa_ssid *ssid)
640{
641	if (wpa_s->current_ssid != ssid)
642		return;
643
644	wpa_dbg(wpa_s, MSG_DEBUG,
645		"Network bssid config changed for the current network - within-ESS roaming %s",
646		ssid->bssid_set ? "disabled" : "enabled");
647
648	wpa_drv_roaming(wpa_s, !ssid->bssid_set,
649			ssid->bssid_set ? ssid->bssid : NULL);
650}
651