wpa_supplicant/notify.c

   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 "binder/binder.h"
  17 #include "dbus/dbus_common.h"
  18 #include "dbus/dbus_old.h"
  19 #include "dbus/dbus_new.h"
  20 #include "rsn_supp/wpa.h"
  21 #include "fst/fst.h"
  22 #include "driver_i.h"
  23 #include "scan.h"
  24 #include "p2p_supplicant.h"
  25 #include "sme.h"
  26 #include "notify.h"
  27
  28 int wpas_notify_supplicant_initialized(struct wpa_global *global)
  29 {
  30 #ifdef CONFIG_DBUS
  31         if (global->params.dbus_ctrl_interface) {
  32                 global->dbus = wpas_dbus_init(global);
  33                 if (global->dbus == NULL)
  34                         return -1;
  35         }
  36 #endif /* CONFIG_DBUS */
  37
  38 #ifdef CONFIG_BINDER
  39         global->binder = wpas_binder_init(global);
  40         if (!global->binder)
  41                 return -1;
  42 #endif /* CONFIG_BINDER */
  43
  44         return 0;
  45 }
  46
  47
  48 void wpas_notify_supplicant_deinitialized(struct wpa_global *global)
  49 {
  50 #ifdef CONFIG_DBUS
  51         if (global->dbus)
  52                 wpas_dbus_deinit(global->dbus);
  53 #endif /* CONFIG_DBUS */
  54
  55 #ifdef CONFIG_BINDER
  56         if (global->binder)
  57                 wpas_binder_deinit(global->binder);
  58 #endif /* CONFIG_BINDER */
  59 }
  60
  61
  62 int wpas_notify_iface_added(struct wpa_supplicant *wpa_s)
  63 {
  64         if (wpa_s->p2p_mgmt)
  65                 return 0;
  66
  67         if (wpas_dbus_register_iface(wpa_s))
  68                 return -1;
  69
  70         if (wpas_dbus_register_interface(wpa_s))
  71                 return -1;
  72
  73         return 0;
  74 }
  75
  76
  77 void wpas_notify_iface_removed(struct wpa_supplicant *wpa_s)
  78 {
  79         if (wpa_s->p2p_mgmt)
  80                 return;
  81
  82         /* unregister interface in old DBus ctrl iface */
  83         wpas_dbus_unregister_iface(wpa_s);
  84
  85         /* unregister interface in new DBus ctrl iface */
  86         wpas_dbus_unregister_interface(wpa_s);
  87 }
  88
  89
  90 void wpas_notify_state_changed(struct wpa_supplicant *wpa_s,
  91                                enum wpa_states new_state,
  92                                enum wpa_states old_state)
  93 {
  94         if (wpa_s->p2p_mgmt)
  95                 return;
  96
  97         /* notify the old DBus API */
  98         wpa_supplicant_dbus_notify_state_change(wpa_s, new_state,
  99                                                 old_state);
 100
 101         /* notify the new DBus API */
 102         wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_STATE);
 103
 104 #ifdef CONFIG_FST
 105         if (wpa_s->fst && !is_zero_ether_addr(wpa_s->bssid)) {
 106                 if (new_state == WPA_COMPLETED)
 107                         fst_notify_peer_connected(wpa_s->fst, wpa_s->bssid);
 108                 else if (old_state >= WPA_ASSOCIATED &&
 109                          new_state < WPA_ASSOCIATED)
 110                         fst_notify_peer_disconnected(wpa_s->fst, wpa_s->bssid);
 111         }
 112 #endif /* CONFIG_FST */
 113
 114         if (new_state == WPA_COMPLETED)
 115                 wpas_p2p_notif_connected(wpa_s);
 116         else if (old_state >= WPA_ASSOCIATED && new_state < WPA_ASSOCIATED)
 117                 wpas_p2p_notif_disconnected(wpa_s);
 118
 119         sme_state_changed(wpa_s);
 120
 121 #ifdef ANDROID
 122         wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_STATE_CHANGE
 123                      "id=%d state=%d BSSID=" MACSTR " SSID=%s",
 124                      wpa_s->current_ssid ? wpa_s->current_ssid->id : -1,
 125                      new_state,
 126                      MAC2STR(wpa_s->bssid),
 127                      wpa_s->current_ssid && wpa_s->current_ssid->ssid ?
 128                      wpa_ssid_txt(wpa_s->current_ssid->ssid,
 129                                   wpa_s->current_ssid->ssid_len) : "");
 130 #endif /* ANDROID */
 131 }
 132
 133
 134 void wpas_notify_disconnect_reason(struct wpa_supplicant *wpa_s)
 135 {
 136         if (wpa_s->p2p_mgmt)
 137                 return;
 138
 139         wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_DISCONNECT_REASON);
 140 }
 141
 142
 143 void wpas_notify_assoc_status_code(struct wpa_supplicant *wpa_s)
 144 {
 145         if (wpa_s->p2p_mgmt)
 146                 return;
 147
 148         wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_ASSOC_STATUS_CODE);
 149 }
 150
 151
 152 void wpas_notify_network_changed(struct wpa_supplicant *wpa_s)
 153 {
 154         if (wpa_s->p2p_mgmt)
 155                 return;
 156
 157         wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_CURRENT_NETWORK);
 158 }
 159
 160
 161 void wpas_notify_ap_scan_changed(struct wpa_supplicant *wpa_s)
 162 {
 163         if (wpa_s->p2p_mgmt)
 164                 return;
 165
 166         wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_AP_SCAN);
 167 }
 168
 169
 170 void wpas_notify_bssid_changed(struct wpa_supplicant *wpa_s)
 171 {
 172         if (wpa_s->p2p_mgmt)
 173                 return;
 174
 175         wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_CURRENT_BSS);
 176 }
 177
 178
 179 void wpas_notify_auth_changed(struct wpa_supplicant *wpa_s)
 180 {
 181         if (wpa_s->p2p_mgmt)
 182                 return;
 183
 184         wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_CURRENT_AUTH_MODE);
 185 }
 186
 187
 188 void wpas_notify_network_enabled_changed(struct wpa_supplicant *wpa_s,
 189                                          struct wpa_ssid *ssid)
 190 {
 191         if (wpa_s->p2p_mgmt)
 192                 return;
 193
 194         wpas_dbus_signal_network_enabled_changed(wpa_s, ssid);
 195 }
 196
 197
 198 void wpas_notify_network_selected(struct wpa_supplicant *wpa_s,
 199                                   struct wpa_ssid *ssid)
 200 {
 201         if (wpa_s->p2p_mgmt)
 202                 return;
 203
 204         wpas_dbus_signal_network_selected(wpa_s, ssid->id);
 205 }
 206
 207
 208 void wpas_notify_network_request(struct wpa_supplicant *wpa_s,
 209                                  struct wpa_ssid *ssid,
 210                                  enum wpa_ctrl_req_type rtype,
 211                                  const char *default_txt)
 212 {
 213         if (wpa_s->p2p_mgmt)
 214                 return;
 215
 216         wpas_dbus_signal_network_request(wpa_s, ssid, rtype, default_txt);
 217 }
 218
 219
 220 void wpas_notify_scanning(struct wpa_supplicant *wpa_s)
 221 {
 222         if (wpa_s->p2p_mgmt)
 223                 return;
 224
 225         /* notify the old DBus API */
 226         wpa_supplicant_dbus_notify_scanning(wpa_s);
 227
 228         /* notify the new DBus API */
 229         wpas_dbus_signal_prop_changed(wpa_s, WPAS_DBUS_PROP_SCANNING);
 230 }
 231
 232
 233 void wpas_notify_scan_done(struct wpa_supplicant *wpa_s, int success)
 234 {
 235         if (wpa_s->p2p_mgmt)
 236                 return;
 237
 238         wpas_dbus_signal_scan_done(wpa_s, success);
 239 }
 240
 241
 242 void wpas_notify_scan_results(struct wpa_supplicant *wpa_s)
 243 {
 244         if (wpa_s->p2p_mgmt)
 245                 return;
 246
 247         /* notify the old DBus API */
 248         wpa_supplicant_dbus_notify_scan_results(wpa_s);
 249
 250         wpas_wps_notify_scan_results(wpa_s);
 251 }
 252
 253
 254 void wpas_notify_wps_credential(struct wpa_supplicant *wpa_s,
 255                                 const struct wps_credential *cred)
 256 {
 257         if (wpa_s->p2p_mgmt)
 258                 return;
 259
 260 #ifdef CONFIG_WPS
 261         /* notify the old DBus API */
 262         wpa_supplicant_dbus_notify_wps_cred(wpa_s, cred);
 263         /* notify the new DBus API */
 264         wpas_dbus_signal_wps_cred(wpa_s, cred);
 265 #endif /* CONFIG_WPS */
 266 }
 267
 268
 269 void wpas_notify_wps_event_m2d(struct wpa_supplicant *wpa_s,
 270                                struct wps_event_m2d *m2d)
 271 {
 272         if (wpa_s->p2p_mgmt)
 273                 return;
 274
 275 #ifdef CONFIG_WPS
 276         wpas_dbus_signal_wps_event_m2d(wpa_s, m2d);
 277 #endif /* CONFIG_WPS */
 278 }
 279
 280
 281 void wpas_notify_wps_event_fail(struct wpa_supplicant *wpa_s,
 282                                 struct wps_event_fail *fail)
 283 {
 284         if (wpa_s->p2p_mgmt)
 285                 return;
 286
 287 #ifdef CONFIG_WPS
 288         wpas_dbus_signal_wps_event_fail(wpa_s, fail);
 289 #endif /* CONFIG_WPS */
 290 }
 291
 292
 293 void wpas_notify_wps_event_success(struct wpa_supplicant *wpa_s)
 294 {
 295         if (wpa_s->p2p_mgmt)
 296                 return;
 297
 298 #ifdef CONFIG_WPS
 299         wpas_dbus_signal_wps_event_success(wpa_s);
 300 #endif /* CONFIG_WPS */
 301 }
 302
 303 void wpas_notify_wps_event_pbc_overlap(struct wpa_supplicant *wpa_s)
 304 {
 305         if (wpa_s->p2p_mgmt)
 306                 return;
 307
 308 #ifdef CONFIG_WPS
 309         wpas_dbus_signal_wps_event_pbc_overlap(wpa_s);
 310 #endif /* CONFIG_WPS */
 311 }
 312
 313
 314 void wpas_notify_network_added(struct wpa_supplicant *wpa_s,
 315                                struct wpa_ssid *ssid)
 316 {
 317         if (wpa_s->p2p_mgmt)
 318                 return;
 319
 320         /*
 321          * Networks objects created during any P2P activities should not be
 322          * exposed out. They might/will confuse certain non-P2P aware
 323          * applications since these network objects won't behave like
 324          * regular ones.
 325          */
 326         if (!ssid->p2p_group && wpa_s->global->p2p_group_formation != wpa_s)
 327                 wpas_dbus_register_network(wpa_s, ssid);
 328 }
 329
 330
 331 void wpas_notify_persistent_group_added(struct wpa_supplicant *wpa_s,
 332                                         struct wpa_ssid *ssid)
 333 {
 334 #ifdef CONFIG_P2P
 335         wpas_dbus_register_persistent_group(wpa_s, ssid);
 336 #endif /* CONFIG_P2P */
 337 }
 338
 339
 340 void wpas_notify_persistent_group_removed(struct wpa_supplicant *wpa_s,
 341                                           struct wpa_ssid *ssid)
 342 {
 343 #ifdef CONFIG_P2P
 344         wpas_dbus_unregister_persistent_group(wpa_s, ssid->id);
 345 #endif /* CONFIG_P2P */
 346 }
 347
 348
 349 void wpas_notify_network_removed(struct wpa_supplicant *wpa_s,
 350                                  struct wpa_ssid *ssid)
 351 {
 352         if (wpa_s->next_ssid == ssid)
 353                 wpa_s->next_ssid = NULL;
 354         if (wpa_s->wpa)
 355                 wpa_sm_pmksa_cache_flush(wpa_s->wpa, ssid);
 356         if (!ssid->p2p_group && wpa_s->global->p2p_group_formation != wpa_s &&
 357             !wpa_s->p2p_mgmt)
 358                 wpas_dbus_unregister_network(wpa_s, ssid->id);
 359         if (network_is_persistent_group(ssid))
 360                 wpas_notify_persistent_group_removed(wpa_s, ssid);
 361
 362         wpas_p2p_network_removed(wpa_s, ssid);
 363 }
 364
 365
 366 void wpas_notify_bss_added(struct wpa_supplicant *wpa_s,
 367                            u8 bssid[], unsigned int id)
 368 {
 369         if (wpa_s->p2p_mgmt)
 370                 return;
 371
 372         wpas_dbus_register_bss(wpa_s, bssid, id);
 373         wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_BSS_ADDED "%u " MACSTR,
 374                      id, MAC2STR(bssid));
 375 }
 376
 377
 378 void wpas_notify_bss_removed(struct wpa_supplicant *wpa_s,
 379                              u8 bssid[], unsigned int id)
 380 {
 381         if (wpa_s->p2p_mgmt)
 382                 return;
 383
 384         wpas_dbus_unregister_bss(wpa_s, bssid, id);
 385         wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_BSS_REMOVED "%u " MACSTR,
 386                      id, MAC2STR(bssid));
 387 }
 388
 389
 390 void wpas_notify_bss_freq_changed(struct wpa_supplicant *wpa_s,
 391                                   unsigned int id)
 392 {
 393         if (wpa_s->p2p_mgmt)
 394                 return;
 395
 396         wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_FREQ, id);
 397 }
 398
 399
 400 void wpas_notify_bss_signal_changed(struct wpa_supplicant *wpa_s,
 401                                     unsigned int id)
 402 {
 403         if (wpa_s->p2p_mgmt)
 404                 return;
 405
 406         wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_SIGNAL,
 407                                           id);
 408 }
 409
 410
 411 void wpas_notify_bss_privacy_changed(struct wpa_supplicant *wpa_s,
 412                                      unsigned int id)
 413 {
 414         if (wpa_s->p2p_mgmt)
 415                 return;
 416
 417         wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_PRIVACY,
 418                                           id);
 419 }
 420
 421
 422 void wpas_notify_bss_mode_changed(struct wpa_supplicant *wpa_s,
 423                                   unsigned int id)
 424 {
 425         if (wpa_s->p2p_mgmt)
 426                 return;
 427
 428         wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_MODE, id);
 429 }
 430
 431
 432 void wpas_notify_bss_wpaie_changed(struct wpa_supplicant *wpa_s,
 433                                    unsigned int id)
 434 {
 435         if (wpa_s->p2p_mgmt)
 436                 return;
 437
 438         wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_WPA, id);
 439 }
 440
 441
 442 void wpas_notify_bss_rsnie_changed(struct wpa_supplicant *wpa_s,
 443                                    unsigned int id)
 444 {
 445         if (wpa_s->p2p_mgmt)
 446                 return;
 447
 448         wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_RSN, id);
 449 }
 450
 451
 452 void wpas_notify_bss_wps_changed(struct wpa_supplicant *wpa_s,
 453                                  unsigned int id)
 454 {
 455         if (wpa_s->p2p_mgmt)
 456                 return;
 457
 458 #ifdef CONFIG_WPS
 459         wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_WPS, id);
 460 #endif /* CONFIG_WPS */
 461 }
 462
 463
 464 void wpas_notify_bss_ies_changed(struct wpa_supplicant *wpa_s,
 465                                    unsigned int id)
 466 {
 467         if (wpa_s->p2p_mgmt)
 468                 return;
 469
 470         wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_IES, id);
 471 }
 472
 473
 474 void wpas_notify_bss_rates_changed(struct wpa_supplicant *wpa_s,
 475                                    unsigned int id)
 476 {
 477         if (wpa_s->p2p_mgmt)
 478                 return;
 479
 480         wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_RATES, id);
 481 }
 482
 483
 484 void wpas_notify_bss_seen(struct wpa_supplicant *wpa_s, unsigned int id)
 485 {
 486         if (wpa_s->p2p_mgmt)
 487                 return;
 488
 489         wpas_dbus_bss_signal_prop_changed(wpa_s, WPAS_DBUS_BSS_PROP_AGE, id);
 490 }
 491
 492
 493 void wpas_notify_blob_added(struct wpa_supplicant *wpa_s, const char *name)
 494 {
 495         if (wpa_s->p2p_mgmt)
 496                 return;
 497
 498         wpas_dbus_signal_blob_added(wpa_s, name);
 499 }
 500
 501
 502 void wpas_notify_blob_removed(struct wpa_supplicant *wpa_s, const char *name)
 503 {
 504         if (wpa_s->p2p_mgmt)
 505                 return;
 506
 507         wpas_dbus_signal_blob_removed(wpa_s, name);
 508 }
 509
 510
 511 void wpas_notify_debug_level_changed(struct wpa_global *global)
 512 {
 513         wpas_dbus_signal_debug_level_changed(global);
 514 }
 515
 516
 517 void wpas_notify_debug_timestamp_changed(struct wpa_global *global)
 518 {
 519         wpas_dbus_signal_debug_timestamp_changed(global);
 520 }
 521
 522
 523 void wpas_notify_debug_show_keys_changed(struct wpa_global *global)
 524 {
 525         wpas_dbus_signal_debug_show_keys_changed(global);
 526 }
 527
 528
 529 void wpas_notify_suspend(struct wpa_global *global)
 530 {
 531         struct wpa_supplicant *wpa_s;
 532
 533         os_get_time(&global->suspend_time);
 534         wpa_printf(MSG_DEBUG, "System suspend notification");
 535         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next)
 536                 wpa_drv_suspend(wpa_s);
 537 }
 538
 539
 540 void wpas_notify_resume(struct wpa_global *global)
 541 {
 542         struct os_time now;
 543         int slept;
 544         struct wpa_supplicant *wpa_s;
 545
 546         if (global->suspend_time.sec == 0)
 547                 slept = -1;
 548         else {
 549                 os_get_time(&now);
 550                 slept = now.sec - global->suspend_time.sec;
 551         }
 552         wpa_printf(MSG_DEBUG, "System resume notification (slept %d seconds)",
 553                    slept);
 554
 555         for (wpa_s = global->ifaces; wpa_s; wpa_s = wpa_s->next) {
 556                 wpa_drv_resume(wpa_s);
 557                 if (wpa_s->wpa_state == WPA_DISCONNECTED)
 558                         wpa_supplicant_req_scan(wpa_s, 0, 100000);
 559         }
 560 }
 561
 562
 563 #ifdef CONFIG_P2P
 564
 565 void wpas_notify_p2p_find_stopped(struct wpa_supplicant *wpa_s)
 566 {
 567         /* Notify P2P find has stopped */
 568         wpas_dbus_signal_p2p_find_stopped(wpa_s);
 569 }
 570
 571
 572 void wpas_notify_p2p_device_found(struct wpa_supplicant *wpa_s,
 573                                   const u8 *dev_addr, int new_device)
 574 {
 575         if (new_device) {
 576                 /* Create the new peer object */
 577                 wpas_dbus_register_peer(wpa_s, dev_addr);
 578         }
 579
 580         /* Notify a new peer has been detected*/
 581         wpas_dbus_signal_peer_device_found(wpa_s, dev_addr);
 582 }
 583
 584
 585 void wpas_notify_p2p_device_lost(struct wpa_supplicant *wpa_s,
 586                                  const u8 *dev_addr)
 587 {
 588         wpas_dbus_unregister_peer(wpa_s, dev_addr);
 589
 590         /* Create signal on interface object*/
 591         wpas_dbus_signal_peer_device_lost(wpa_s, dev_addr);
 592 }
 593
 594
 595 void wpas_notify_p2p_group_removed(struct wpa_supplicant *wpa_s,
 596                                    const struct wpa_ssid *ssid,
 597                                    const char *role)
 598 {
 599         wpas_dbus_signal_p2p_group_removed(wpa_s, role);
 600
 601         wpas_dbus_unregister_p2p_group(wpa_s, ssid);
 602 }
 603
 604
 605 void wpas_notify_p2p_go_neg_req(struct wpa_supplicant *wpa_s,
 606                                 const u8 *src, u16 dev_passwd_id, u8 go_intent)
 607 {
 608         wpas_dbus_signal_p2p_go_neg_req(wpa_s, src, dev_passwd_id, go_intent);
 609 }
 610
 611
 612 void wpas_notify_p2p_go_neg_completed(struct wpa_supplicant *wpa_s,
 613                                       struct p2p_go_neg_results *res)
 614 {
 615         wpas_dbus_signal_p2p_go_neg_resp(wpa_s, res);
 616 }
 617
 618
 619 void wpas_notify_p2p_invitation_result(struct wpa_supplicant *wpa_s,
 620                                        int status, const u8 *bssid)
 621 {
 622         wpas_dbus_signal_p2p_invitation_result(wpa_s, status, bssid);
 623 }
 624
 625
 626 void wpas_notify_p2p_sd_request(struct wpa_supplicant *wpa_s,
 627                                 int freq, const u8 *sa, u8 dialog_token,
 628                                 u16 update_indic, const u8 *tlvs,
 629                                 size_t tlvs_len)
 630 {
 631         wpas_dbus_signal_p2p_sd_request(wpa_s, freq, sa, dialog_token,
 632                                         update_indic, tlvs, tlvs_len);
 633 }
 634
 635
 636 void wpas_notify_p2p_sd_response(struct wpa_supplicant *wpa_s,
 637                                  const u8 *sa, u16 update_indic,
 638                                  const u8 *tlvs, size_t tlvs_len)
 639 {
 640         wpas_dbus_signal_p2p_sd_response(wpa_s, sa, update_indic,
 641                                          tlvs, tlvs_len);
 642 }
 643
 644
 645 /**
 646  * wpas_notify_p2p_provision_discovery - Notification of provision discovery
 647  * @dev_addr: Who sent the request or responded to our request.
 648  * @request: Will be 1 if request, 0 for response.
 649  * @status: Valid only in case of response (0 in case of success)
 650  * @config_methods: WPS config methods
 651  * @generated_pin: PIN to be displayed in case of WPS_CONFIG_DISPLAY method
 652  *
 653  * This can be used to notify:
 654  * - Requests or responses
 655  * - Various config methods
 656  * - Failure condition in case of response
 657  */
 658 void wpas_notify_p2p_provision_discovery(struct wpa_supplicant *wpa_s,
 659                                          const u8 *dev_addr, int request,
 660                                          enum p2p_prov_disc_status status,
 661                                          u16 config_methods,
 662                                          unsigned int generated_pin)
 663 {
 664         wpas_dbus_signal_p2p_provision_discovery(wpa_s, dev_addr, request,
 665                                                  status, config_methods,
 666                                                  generated_pin);
 667 }
 668
 669
 670 void wpas_notify_p2p_group_started(struct wpa_supplicant *wpa_s,
 671                                    struct wpa_ssid *ssid, int persistent,
 672                                    int client, const u8 *ip)
 673 {
 674         /* Notify a group has been started */
 675         wpas_dbus_register_p2p_group(wpa_s, ssid);
 676
 677         wpas_dbus_signal_p2p_group_started(wpa_s, client, persistent, ip);
 678 }
 679
 680
 681 void wpas_notify_p2p_group_formation_failure(struct wpa_supplicant *wpa_s,
 682                                              const char *reason)
 683 {
 684         /* Notify a group formation failed */
 685         wpas_dbus_signal_p2p_group_formation_failure(wpa_s, reason);
 686 }
 687
 688
 689 void wpas_notify_p2p_wps_failed(struct wpa_supplicant *wpa_s,
 690                                 struct wps_event_fail *fail)
 691 {
 692         wpas_dbus_signal_p2p_wps_failed(wpa_s, fail);
 693 }
 694
 695
 696 void wpas_notify_p2p_invitation_received(struct wpa_supplicant *wpa_s,
 697                                          const u8 *sa, const u8 *go_dev_addr,
 698                                          const u8 *bssid, int id, int op_freq)
 699 {
 700         /* Notify a P2P Invitation Request */
 701         wpas_dbus_signal_p2p_invitation_received(wpa_s, sa, go_dev_addr, bssid,
 702                                                  id, op_freq);
 703 }
 704
 705 #endif /* CONFIG_P2P */
 706
 707
 708 static void wpas_notify_ap_sta_authorized(struct wpa_supplicant *wpa_s,
 709                                           const u8 *sta,
 710                                           const u8 *p2p_dev_addr)
 711 {
 712 #ifdef CONFIG_P2P
 713         wpas_p2p_notify_ap_sta_authorized(wpa_s, p2p_dev_addr);
 714
 715         /*
 716          * Create 'peer-joined' signal on group object -- will also
 717          * check P2P itself.
 718          */
 719         if (p2p_dev_addr)
 720                 wpas_dbus_signal_p2p_peer_joined(wpa_s, p2p_dev_addr);
 721 #endif /* CONFIG_P2P */
 722
 723         /* Notify listeners a new station has been authorized */
 724         wpas_dbus_signal_sta_authorized(wpa_s, sta);
 725 }
 726
 727
 728 static void wpas_notify_ap_sta_deauthorized(struct wpa_supplicant *wpa_s,
 729                                             const u8 *sta,
 730                                             const u8 *p2p_dev_addr)
 731 {
 732 #ifdef CONFIG_P2P
 733         /*
 734          * Create 'peer-disconnected' signal on group object if this
 735          * is a P2P group.
 736          */
 737         if (p2p_dev_addr)
 738                 wpas_dbus_signal_p2p_peer_disconnected(wpa_s, p2p_dev_addr);
 739 #endif /* CONFIG_P2P */
 740
 741         /* Notify listeners a station has been deauthorized */
 742         wpas_dbus_signal_sta_deauthorized(wpa_s, sta);
 743 }
 744
 745
 746 void wpas_notify_sta_authorized(struct wpa_supplicant *wpa_s,
 747                                 const u8 *mac_addr, int authorized,
 748                                 const u8 *p2p_dev_addr)
 749 {
 750         if (authorized)
 751                 wpas_notify_ap_sta_authorized(wpa_s, mac_addr, p2p_dev_addr);
 752         else
 753                 wpas_notify_ap_sta_deauthorized(wpa_s, mac_addr, p2p_dev_addr);
 754 }
 755
 756
 757 void wpas_notify_certification(struct wpa_supplicant *wpa_s, int depth,
 758                                const char *subject, const char *altsubject[],
 759                                int num_altsubject, const char *cert_hash,
 760                                const struct wpabuf *cert)
 761 {
 762         wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_EAP_PEER_CERT
 763                 "depth=%d subject='%s'%s%s",
 764                 depth, subject, cert_hash ? " hash=" : "",
 765                 cert_hash ? cert_hash : "");
 766
 767         if (cert) {
 768                 char *cert_hex;
 769                 size_t len = wpabuf_len(cert) * 2 + 1;
 770                 cert_hex = os_malloc(len);
 771                 if (cert_hex) {
 772                         wpa_snprintf_hex(cert_hex, len, wpabuf_head(cert),
 773                                          wpabuf_len(cert));
 774                         wpa_msg_ctrl(wpa_s, MSG_INFO,
 775                                      WPA_EVENT_EAP_PEER_CERT
 776                                      "depth=%d subject='%s' cert=%s",
 777                                      depth, subject, cert_hex);
 778                         os_free(cert_hex);
 779                 }
 780         }
 781
 782         if (altsubject) {
 783                 int i;
 784
 785                 for (i = 0; i < num_altsubject; i++)
 786                         wpa_msg(wpa_s, MSG_INFO, WPA_EVENT_EAP_PEER_ALT
 787                                 "depth=%d %s", depth, altsubject[i]);
 788         }
 789
 790         /* notify the old DBus API */
 791         wpa_supplicant_dbus_notify_certification(wpa_s, depth, subject,
 792                                                  cert_hash, cert);
 793         /* notify the new DBus API */
 794         wpas_dbus_signal_certification(wpa_s, depth, subject, altsubject,
 795                                        num_altsubject, cert_hash, cert);
 796 }
 797
 798
 799 void wpas_notify_preq(struct wpa_supplicant *wpa_s,
 800                       const u8 *addr, const u8 *dst, const u8 *bssid,
 801                       const u8 *ie, size_t ie_len, u32 ssi_signal)
 802 {
 803 #ifdef CONFIG_AP
 804         wpas_dbus_signal_preq(wpa_s, addr, dst, bssid, ie, ie_len, ssi_signal);
 805 #endif /* CONFIG_AP */
 806 }
 807
 808
 809 void wpas_notify_eap_status(struct wpa_supplicant *wpa_s, const char *status,
 810                             const char *parameter)
 811 {
 812         wpas_dbus_signal_eap_status(wpa_s, status, parameter);
 813         wpa_msg_ctrl(wpa_s, MSG_INFO, WPA_EVENT_EAP_STATUS
 814                      "status='%s' parameter='%s'",
 815                      status, parameter);
 816 }
 817
 818
 819 void wpas_notify_network_bssid_set_changed(struct wpa_supplicant *wpa_s,
 820                                            struct wpa_ssid *ssid)
 821 {
 822         if (wpa_s->current_ssid != ssid)
 823                 return;
 824
 825         wpa_dbg(wpa_s, MSG_DEBUG,
 826                 "Network bssid config changed for the current network - within-ESS roaming %s",
 827                 ssid->bssid_set ? "disabled" : "enabled");
 828
 829         wpa_drv_roaming(wpa_s, !ssid->bssid_set,
 830                         ssid->bssid_set ? ssid->bssid : NULL);
 831 }
 832
 833
 834 void wpas_notify_network_type_changed(struct wpa_supplicant *wpa_s,
 835                                       struct wpa_ssid *ssid)
 836 {
 837 #ifdef CONFIG_P2P
 838         if (ssid->disabled == 2) {
 839                 /* Changed from normal network profile to persistent group */
 840                 ssid->disabled = 0;
 841                 wpas_dbus_unregister_network(wpa_s, ssid->id);
 842                 ssid->disabled = 2;
 843                 ssid->p2p_persistent_group = 1;
 844                 wpas_dbus_register_persistent_group(wpa_s, ssid);
 845         } else {
 846                 /* Changed from persistent group to normal network profile */
 847                 wpas_dbus_unregister_persistent_group(wpa_s, ssid->id);
 848                 ssid->p2p_persistent_group = 0;
 849                 wpas_dbus_register_network(wpa_s, ssid);
 850         }
 851 #endif /* CONFIG_P2P */
 852 }
 853
 854
 855 #ifdef CONFIG_MESH
 856
 857 void wpas_notify_mesh_group_started(struct wpa_supplicant *wpa_s,
 858                                     struct wpa_ssid *ssid)
 859 {
 860         if (wpa_s->p2p_mgmt)
 861                 return;
 862
 863         wpas_dbus_signal_mesh_group_started(wpa_s, ssid);
 864 }
 865
 866
 867 void wpas_notify_mesh_group_removed(struct wpa_supplicant *wpa_s,
 868                                     const u8 *meshid, u8 meshid_len,
 869                                     int reason_code)
 870 {
 871         if (wpa_s->p2p_mgmt)
 872                 return;
 873
 874         wpas_dbus_signal_mesh_group_removed(wpa_s, meshid, meshid_len,
 875                                             reason_code);
 876 }
 877
 878
 879 void wpas_notify_mesh_peer_connected(struct wpa_supplicant *wpa_s,
 880                                      const u8 *peer_addr)
 881 {
 882         if (wpa_s->p2p_mgmt)
 883                 return;
 884
 885         wpas_dbus_signal_mesh_peer_connected(wpa_s, peer_addr);
 886 }
 887
 888
 889 void wpas_notify_mesh_peer_disconnected(struct wpa_supplicant *wpa_s,
 890                                         const u8 *peer_addr, int reason_code)
 891 {
 892         if (wpa_s->p2p_mgmt)
 893                 return;
 894
 895         wpas_dbus_signal_mesh_peer_disconnected(wpa_s, peer_addr, reason_code);
 896 }
 897
 898 #endif /* CONFIG_MESH */