driver.h revision 5605286c30e1701491bd3af974ae423727750edd
1/* 2 * Driver interface definition 3 * Copyright (c) 2003-2012, 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 * This file defines a driver interface used by both %wpa_supplicant and 9 * hostapd. The first part of the file defines data structures used in various 10 * driver operations. This is followed by the struct wpa_driver_ops that each 11 * driver wrapper will beed to define with callback functions for requesting 12 * driver operations. After this, there are definitions for driver event 13 * reporting with wpa_supplicant_event() and some convenience helper functions 14 * that can be used to report events. 15 */ 16 17#ifndef DRIVER_H 18#define DRIVER_H 19 20#define WPA_SUPPLICANT_DRIVER_VERSION 4 21 22#include "common/defs.h" 23#include "utils/list.h" 24 25#define HOSTAPD_CHAN_DISABLED 0x00000001 26#define HOSTAPD_CHAN_PASSIVE_SCAN 0x00000002 27#define HOSTAPD_CHAN_NO_IBSS 0x00000004 28#define HOSTAPD_CHAN_RADAR 0x00000008 29#define HOSTAPD_CHAN_HT40PLUS 0x00000010 30#define HOSTAPD_CHAN_HT40MINUS 0x00000020 31#define HOSTAPD_CHAN_HT40 0x00000040 32#define HOSTAPD_CHAN_SURVEY_LIST_INITIALIZED 0x00000080 33 34#define HOSTAPD_CHAN_DFS_UNKNOWN 0x00000000 35#define HOSTAPD_CHAN_DFS_USABLE 0x00000100 36#define HOSTAPD_CHAN_DFS_UNAVAILABLE 0x00000200 37#define HOSTAPD_CHAN_DFS_AVAILABLE 0x00000300 38#define HOSTAPD_CHAN_DFS_MASK 0x00000300 39 40/** 41 * struct hostapd_channel_data - Channel information 42 */ 43struct hostapd_channel_data { 44 /** 45 * chan - Channel number (IEEE 802.11) 46 */ 47 short chan; 48 49 /** 50 * freq - Frequency in MHz 51 */ 52 int freq; 53 54 /** 55 * flag - Channel flags (HOSTAPD_CHAN_*) 56 */ 57 int flag; 58 59 /** 60 * max_tx_power - Maximum transmit power in dBm 61 */ 62 u8 max_tx_power; 63 64 /* 65 * survey_list - Linked list of surveys 66 */ 67 struct dl_list survey_list; 68 69 /** 70 * min_nf - Minimum observed noise floor, in dBm, based on all 71 * surveyed channel data 72 */ 73 s8 min_nf; 74 75#ifdef CONFIG_ACS 76 /** 77 * interference_factor - Computed interference factor on this 78 * channel (used internally in src/ap/acs.c; driver wrappers do not 79 * need to set this) 80 */ 81 long double interference_factor; 82#endif /* CONFIG_ACS */ 83}; 84 85#define HOSTAPD_MODE_FLAG_HT_INFO_KNOWN BIT(0) 86#define HOSTAPD_MODE_FLAG_VHT_INFO_KNOWN BIT(1) 87 88/** 89 * struct hostapd_hw_modes - Supported hardware mode information 90 */ 91struct hostapd_hw_modes { 92 /** 93 * mode - Hardware mode 94 */ 95 enum hostapd_hw_mode mode; 96 97 /** 98 * num_channels - Number of entries in the channels array 99 */ 100 int num_channels; 101 102 /** 103 * channels - Array of supported channels 104 */ 105 struct hostapd_channel_data *channels; 106 107 /** 108 * num_rates - Number of entries in the rates array 109 */ 110 int num_rates; 111 112 /** 113 * rates - Array of supported rates in 100 kbps units 114 */ 115 int *rates; 116 117 /** 118 * ht_capab - HT (IEEE 802.11n) capabilities 119 */ 120 u16 ht_capab; 121 122 /** 123 * mcs_set - MCS (IEEE 802.11n) rate parameters 124 */ 125 u8 mcs_set[16]; 126 127 /** 128 * a_mpdu_params - A-MPDU (IEEE 802.11n) parameters 129 */ 130 u8 a_mpdu_params; 131 132 /** 133 * vht_capab - VHT (IEEE 802.11ac) capabilities 134 */ 135 u32 vht_capab; 136 137 /** 138 * vht_mcs_set - VHT MCS (IEEE 802.11ac) rate parameters 139 */ 140 u8 vht_mcs_set[8]; 141 142 unsigned int flags; /* HOSTAPD_MODE_FLAG_* */ 143}; 144 145 146#define IEEE80211_MODE_INFRA 0 147#define IEEE80211_MODE_IBSS 1 148#define IEEE80211_MODE_AP 2 149 150#define IEEE80211_CAP_ESS 0x0001 151#define IEEE80211_CAP_IBSS 0x0002 152#define IEEE80211_CAP_PRIVACY 0x0010 153 154/* DMG (60 GHz) IEEE 802.11ad */ 155/* type - bits 0..1 */ 156#define IEEE80211_CAP_DMG_MASK 0x0003 157#define IEEE80211_CAP_DMG_IBSS 0x0001 /* Tx by: STA */ 158#define IEEE80211_CAP_DMG_PBSS 0x0002 /* Tx by: PCP */ 159#define IEEE80211_CAP_DMG_AP 0x0003 /* Tx by: AP */ 160 161#define WPA_SCAN_QUAL_INVALID BIT(0) 162#define WPA_SCAN_NOISE_INVALID BIT(1) 163#define WPA_SCAN_LEVEL_INVALID BIT(2) 164#define WPA_SCAN_LEVEL_DBM BIT(3) 165#define WPA_SCAN_AUTHENTICATED BIT(4) 166#define WPA_SCAN_ASSOCIATED BIT(5) 167 168/** 169 * struct wpa_scan_res - Scan result for an BSS/IBSS 170 * @flags: information flags about the BSS/IBSS (WPA_SCAN_*) 171 * @bssid: BSSID 172 * @freq: frequency of the channel in MHz (e.g., 2412 = channel 1) 173 * @beacon_int: beacon interval in TUs (host byte order) 174 * @caps: capability information field in host byte order 175 * @qual: signal quality 176 * @noise: noise level 177 * @level: signal level 178 * @tsf: Timestamp 179 * @age: Age of the information in milliseconds (i.e., how many milliseconds 180 * ago the last Beacon or Probe Response frame was received) 181 * @ie_len: length of the following IE field in octets 182 * @beacon_ie_len: length of the following Beacon IE field in octets 183 * 184 * This structure is used as a generic format for scan results from the 185 * driver. Each driver interface implementation is responsible for converting 186 * the driver or OS specific scan results into this format. 187 * 188 * If the driver does not support reporting all IEs, the IE data structure is 189 * constructed of the IEs that are available. This field will also need to 190 * include SSID in IE format. All drivers are encouraged to be extended to 191 * report all IEs to make it easier to support future additions. 192 */ 193struct wpa_scan_res { 194 unsigned int flags; 195 u8 bssid[ETH_ALEN]; 196 int freq; 197 u16 beacon_int; 198 u16 caps; 199 int qual; 200 int noise; 201 int level; 202 u64 tsf; 203 unsigned int age; 204 size_t ie_len; 205 size_t beacon_ie_len; 206 /* 207 * Followed by ie_len octets of IEs from Probe Response frame (or if 208 * the driver does not indicate source of IEs, these may also be from 209 * Beacon frame). After the first set of IEs, another set of IEs may 210 * follow (with beacon_ie_len octets of data) if the driver provides 211 * both IE sets. 212 */ 213}; 214 215/** 216 * struct wpa_scan_results - Scan results 217 * @res: Array of pointers to allocated variable length scan result entries 218 * @num: Number of entries in the scan result array 219 * @fetch_time: Time when the results were fetched from the driver 220 */ 221struct wpa_scan_results { 222 struct wpa_scan_res **res; 223 size_t num; 224 struct os_time fetch_time; 225}; 226 227/** 228 * struct wpa_interface_info - Network interface information 229 * @next: Pointer to the next interface or NULL if this is the last one 230 * @ifname: Interface name that can be used with init() or init2() 231 * @desc: Human readable adapter description (e.g., vendor/model) or NULL if 232 * not available 233 * @drv_name: struct wpa_driver_ops::name (note: unlike other strings, this one 234 * is not an allocated copy, i.e., get_interfaces() caller will not free 235 * this) 236 */ 237struct wpa_interface_info { 238 struct wpa_interface_info *next; 239 char *ifname; 240 char *desc; 241 const char *drv_name; 242}; 243 244#define WPAS_MAX_SCAN_SSIDS 16 245 246/** 247 * struct wpa_driver_scan_params - Scan parameters 248 * Data for struct wpa_driver_ops::scan2(). 249 */ 250struct wpa_driver_scan_params { 251 /** 252 * ssids - SSIDs to scan for 253 */ 254 struct wpa_driver_scan_ssid { 255 /** 256 * ssid - specific SSID to scan for (ProbeReq) 257 * %NULL or zero-length SSID is used to indicate active scan 258 * with wildcard SSID. 259 */ 260 const u8 *ssid; 261 /** 262 * ssid_len: Length of the SSID in octets 263 */ 264 size_t ssid_len; 265 } ssids[WPAS_MAX_SCAN_SSIDS]; 266 267 /** 268 * num_ssids - Number of entries in ssids array 269 * Zero indicates a request for a passive scan. 270 */ 271 size_t num_ssids; 272 273 /** 274 * extra_ies - Extra IE(s) to add into Probe Request or %NULL 275 */ 276 const u8 *extra_ies; 277 278 /** 279 * extra_ies_len - Length of extra_ies in octets 280 */ 281 size_t extra_ies_len; 282 283 /** 284 * freqs - Array of frequencies to scan or %NULL for all frequencies 285 * 286 * The frequency is set in MHz. The array is zero-terminated. 287 */ 288 int *freqs; 289 290 /** 291 * filter_ssids - Filter for reporting SSIDs 292 * 293 * This optional parameter can be used to request the driver wrapper to 294 * filter scan results to include only the specified SSIDs. %NULL 295 * indicates that no filtering is to be done. This can be used to 296 * reduce memory needs for scan results in environments that have large 297 * number of APs with different SSIDs. 298 * 299 * The driver wrapper is allowed to take this allocated buffer into its 300 * own use by setting the pointer to %NULL. In that case, the driver 301 * wrapper is responsible for freeing the buffer with os_free() once it 302 * is not needed anymore. 303 */ 304 struct wpa_driver_scan_filter { 305 u8 ssid[32]; 306 size_t ssid_len; 307 } *filter_ssids; 308 309 /** 310 * num_filter_ssids - Number of entries in filter_ssids array 311 */ 312 size_t num_filter_ssids; 313 314 /** 315 * filter_rssi - Filter by RSSI 316 * 317 * The driver may filter scan results in firmware to reduce host 318 * wakeups and thereby save power. Specify the RSSI threshold in s32 319 * dBm. 320 */ 321 s32 filter_rssi; 322 323 /** 324 * p2p_probe - Used to disable CCK (802.11b) rates for P2P probes 325 * 326 * When set, the driver is expected to remove rates 1, 2, 5.5, and 11 327 * Mbps from the support rates element(s) in the Probe Request frames 328 * and not to transmit the frames at any of those rates. 329 */ 330 u8 p2p_probe; 331}; 332 333/** 334 * struct wpa_driver_auth_params - Authentication parameters 335 * Data for struct wpa_driver_ops::authenticate(). 336 */ 337struct wpa_driver_auth_params { 338 int freq; 339 const u8 *bssid; 340 const u8 *ssid; 341 size_t ssid_len; 342 int auth_alg; 343 const u8 *ie; 344 size_t ie_len; 345 const u8 *wep_key[4]; 346 size_t wep_key_len[4]; 347 int wep_tx_keyidx; 348 int local_state_change; 349 350 /** 351 * p2p - Whether this connection is a P2P group 352 */ 353 int p2p; 354 355 const u8 *sae_data; 356 size_t sae_data_len; 357 358}; 359 360enum wps_mode { 361 WPS_MODE_NONE /* no WPS provisioning being used */, 362 WPS_MODE_OPEN /* WPS provisioning with AP that is in open mode */, 363 WPS_MODE_PRIVACY /* WPS provisioning with AP that is using protection 364 */ 365}; 366 367/** 368 * struct wpa_driver_associate_params - Association parameters 369 * Data for struct wpa_driver_ops::associate(). 370 */ 371struct wpa_driver_associate_params { 372 /** 373 * bssid - BSSID of the selected AP 374 * This can be %NULL, if ap_scan=2 mode is used and the driver is 375 * responsible for selecting with which BSS to associate. */ 376 const u8 *bssid; 377 378 /** 379 * ssid - The selected SSID 380 */ 381 const u8 *ssid; 382 383 /** 384 * ssid_len - Length of the SSID (1..32) 385 */ 386 size_t ssid_len; 387 388 /** 389 * freq - Frequency of the channel the selected AP is using 390 * Frequency that the selected AP is using (in MHz as 391 * reported in the scan results) 392 */ 393 int freq; 394 395 /** 396 * bg_scan_period - Background scan period in seconds, 0 to disable 397 * background scan, or -1 to indicate no change to default driver 398 * configuration 399 */ 400 int bg_scan_period; 401 402 /** 403 * wpa_ie - WPA information element for (Re)Association Request 404 * WPA information element to be included in (Re)Association 405 * Request (including information element id and length). Use 406 * of this WPA IE is optional. If the driver generates the WPA 407 * IE, it can use pairwise_suite, group_suite, and 408 * key_mgmt_suite to select proper algorithms. In this case, 409 * the driver has to notify wpa_supplicant about the used WPA 410 * IE by generating an event that the interface code will 411 * convert into EVENT_ASSOCINFO data (see below). 412 * 413 * When using WPA2/IEEE 802.11i, wpa_ie is used for RSN IE 414 * instead. The driver can determine which version is used by 415 * looking at the first byte of the IE (0xdd for WPA, 0x30 for 416 * WPA2/RSN). 417 * 418 * When using WPS, wpa_ie is used for WPS IE instead of WPA/RSN IE. 419 */ 420 const u8 *wpa_ie; 421 422 /** 423 * wpa_ie_len - length of the wpa_ie 424 */ 425 size_t wpa_ie_len; 426 427 /** 428 * wpa_proto - Bitfield of WPA_PROTO_* values to indicate WPA/WPA2 429 */ 430 unsigned int wpa_proto; 431 432 /** 433 * pairwise_suite - Selected pairwise cipher suite 434 * 435 * This is usually ignored if @wpa_ie is used. 436 */ 437 enum wpa_cipher pairwise_suite; 438 439 /** 440 * group_suite - Selected group cipher suite 441 * 442 * This is usually ignored if @wpa_ie is used. 443 */ 444 enum wpa_cipher group_suite; 445 446 /** 447 * key_mgmt_suite - Selected key management suite 448 * 449 * This is usually ignored if @wpa_ie is used. 450 */ 451 enum wpa_key_mgmt key_mgmt_suite; 452 453 /** 454 * auth_alg - Allowed authentication algorithms 455 * Bit field of WPA_AUTH_ALG_* 456 */ 457 int auth_alg; 458 459 /** 460 * mode - Operation mode (infra/ibss) IEEE80211_MODE_* 461 */ 462 int mode; 463 464 /** 465 * wep_key - WEP keys for static WEP configuration 466 */ 467 const u8 *wep_key[4]; 468 469 /** 470 * wep_key_len - WEP key length for static WEP configuration 471 */ 472 size_t wep_key_len[4]; 473 474 /** 475 * wep_tx_keyidx - WEP TX key index for static WEP configuration 476 */ 477 int wep_tx_keyidx; 478 479 /** 480 * mgmt_frame_protection - IEEE 802.11w management frame protection 481 */ 482 enum mfp_options mgmt_frame_protection; 483 484 /** 485 * ft_ies - IEEE 802.11r / FT information elements 486 * If the supplicant is using IEEE 802.11r (FT) and has the needed keys 487 * for fast transition, this parameter is set to include the IEs that 488 * are to be sent in the next FT Authentication Request message. 489 * update_ft_ies() handler is called to update the IEs for further 490 * FT messages in the sequence. 491 * 492 * The driver should use these IEs only if the target AP is advertising 493 * the same mobility domain as the one included in the MDIE here. 494 * 495 * In ap_scan=2 mode, the driver can use these IEs when moving to a new 496 * AP after the initial association. These IEs can only be used if the 497 * target AP is advertising support for FT and is using the same MDIE 498 * and SSID as the current AP. 499 * 500 * The driver is responsible for reporting the FT IEs received from the 501 * AP's response using wpa_supplicant_event() with EVENT_FT_RESPONSE 502 * type. update_ft_ies() handler will then be called with the FT IEs to 503 * include in the next frame in the authentication sequence. 504 */ 505 const u8 *ft_ies; 506 507 /** 508 * ft_ies_len - Length of ft_ies in bytes 509 */ 510 size_t ft_ies_len; 511 512 /** 513 * ft_md - FT Mobility domain (6 octets) (also included inside ft_ies) 514 * 515 * This value is provided to allow the driver interface easier access 516 * to the current mobility domain. This value is set to %NULL if no 517 * mobility domain is currently active. 518 */ 519 const u8 *ft_md; 520 521 /** 522 * passphrase - RSN passphrase for PSK 523 * 524 * This value is made available only for WPA/WPA2-Personal (PSK) and 525 * only for drivers that set WPA_DRIVER_FLAGS_4WAY_HANDSHAKE. This is 526 * the 8..63 character ASCII passphrase, if available. Please note that 527 * this can be %NULL if passphrase was not used to generate the PSK. In 528 * that case, the psk field must be used to fetch the PSK. 529 */ 530 const char *passphrase; 531 532 /** 533 * psk - RSN PSK (alternative for passphrase for PSK) 534 * 535 * This value is made available only for WPA/WPA2-Personal (PSK) and 536 * only for drivers that set WPA_DRIVER_FLAGS_4WAY_HANDSHAKE. This is 537 * the 32-octet (256-bit) PSK, if available. The driver wrapper should 538 * be prepared to handle %NULL value as an error. 539 */ 540 const u8 *psk; 541 542 /** 543 * drop_unencrypted - Enable/disable unencrypted frame filtering 544 * 545 * Configure the driver to drop all non-EAPOL frames (both receive and 546 * transmit paths). Unencrypted EAPOL frames (ethertype 0x888e) must 547 * still be allowed for key negotiation. 548 */ 549 int drop_unencrypted; 550 551 /** 552 * prev_bssid - Previously used BSSID in this ESS 553 * 554 * When not %NULL, this is a request to use reassociation instead of 555 * association. 556 */ 557 const u8 *prev_bssid; 558 559 /** 560 * wps - WPS mode 561 * 562 * If the driver needs to do special configuration for WPS association, 563 * this variable provides more information on what type of association 564 * is being requested. Most drivers should not need ot use this. 565 */ 566 enum wps_mode wps; 567 568 /** 569 * p2p - Whether this connection is a P2P group 570 */ 571 int p2p; 572 573 /** 574 * uapsd - UAPSD parameters for the network 575 * -1 = do not change defaults 576 * AP mode: 1 = enabled, 0 = disabled 577 * STA mode: bits 0..3 UAPSD enabled for VO,VI,BK,BE 578 */ 579 int uapsd; 580 581 /** 582 * fixed_bssid - Whether to force this BSSID in IBSS mode 583 * 1 = Fix this BSSID and prevent merges. 584 * 0 = Do not fix BSSID. 585 */ 586 int fixed_bssid; 587 588 /** 589 * disable_ht - Disable HT (IEEE 802.11n) for this connection 590 */ 591 int disable_ht; 592 593 /** 594 * HT Capabilities over-rides. Only bits set in the mask will be used, 595 * and not all values are used by the kernel anyway. Currently, MCS, 596 * MPDU and MSDU fields are used. 597 */ 598 const u8 *htcaps; /* struct ieee80211_ht_capabilities * */ 599 const u8 *htcaps_mask; /* struct ieee80211_ht_capabilities * */ 600 601#ifdef CONFIG_VHT_OVERRIDES 602 /** 603 * disable_vht - Disable VHT for this connection 604 */ 605 int disable_vht; 606 607 /** 608 * VHT capability overrides. 609 */ 610 const struct ieee80211_vht_capabilities *vhtcaps; 611 const struct ieee80211_vht_capabilities *vhtcaps_mask; 612#endif /* CONFIG_VHT_OVERRIDES */ 613}; 614 615enum hide_ssid { 616 NO_SSID_HIDING, 617 HIDDEN_SSID_ZERO_LEN, 618 HIDDEN_SSID_ZERO_CONTENTS 619}; 620 621struct wpa_driver_ap_params { 622 /** 623 * head - Beacon head from IEEE 802.11 header to IEs before TIM IE 624 */ 625 const u8 *head; 626 627 /** 628 * head_len - Length of the head buffer in octets 629 */ 630 size_t head_len; 631 632 /** 633 * tail - Beacon tail following TIM IE 634 */ 635 const u8 *tail; 636 637 /** 638 * tail_len - Length of the tail buffer in octets 639 */ 640 size_t tail_len; 641 642 /** 643 * dtim_period - DTIM period 644 */ 645 int dtim_period; 646 647 /** 648 * beacon_int - Beacon interval 649 */ 650 int beacon_int; 651 652 /** 653 * basic_rates: -1 terminated array of basic rates in 100 kbps 654 * 655 * This parameter can be used to set a specific basic rate set for the 656 * BSS. If %NULL, default basic rate set is used. 657 */ 658 int *basic_rates; 659 660 /** 661 * proberesp - Probe Response template 662 * 663 * This is used by drivers that reply to Probe Requests internally in 664 * AP mode and require the full Probe Response template. 665 */ 666 const u8 *proberesp; 667 668 /** 669 * proberesp_len - Length of the proberesp buffer in octets 670 */ 671 size_t proberesp_len; 672 673 /** 674 * ssid - The SSID to use in Beacon/Probe Response frames 675 */ 676 const u8 *ssid; 677 678 /** 679 * ssid_len - Length of the SSID (1..32) 680 */ 681 size_t ssid_len; 682 683 /** 684 * hide_ssid - Whether to hide the SSID 685 */ 686 enum hide_ssid hide_ssid; 687 688 /** 689 * pairwise_ciphers - WPA_CIPHER_* bitfield 690 */ 691 unsigned int pairwise_ciphers; 692 693 /** 694 * group_cipher - WPA_CIPHER_* 695 */ 696 unsigned int group_cipher; 697 698 /** 699 * key_mgmt_suites - WPA_KEY_MGMT_* bitfield 700 */ 701 unsigned int key_mgmt_suites; 702 703 /** 704 * auth_algs - WPA_AUTH_ALG_* bitfield 705 */ 706 unsigned int auth_algs; 707 708 /** 709 * wpa_version - WPA_PROTO_* bitfield 710 */ 711 unsigned int wpa_version; 712 713 /** 714 * privacy - Whether privacy is used in the BSS 715 */ 716 int privacy; 717 718 /** 719 * beacon_ies - WPS/P2P IE(s) for Beacon frames 720 * 721 * This is used to add IEs like WPS IE and P2P IE by drivers that do 722 * not use the full Beacon template. 723 */ 724 const struct wpabuf *beacon_ies; 725 726 /** 727 * proberesp_ies - P2P/WPS IE(s) for Probe Response frames 728 * 729 * This is used to add IEs like WPS IE and P2P IE by drivers that 730 * reply to Probe Request frames internally. 731 */ 732 const struct wpabuf *proberesp_ies; 733 734 /** 735 * assocresp_ies - WPS IE(s) for (Re)Association Response frames 736 * 737 * This is used to add IEs like WPS IE by drivers that reply to 738 * (Re)Association Request frames internally. 739 */ 740 const struct wpabuf *assocresp_ies; 741 742 /** 743 * isolate - Whether to isolate frames between associated stations 744 * 745 * If this is non-zero, the AP is requested to disable forwarding of 746 * frames between associated stations. 747 */ 748 int isolate; 749 750 /** 751 * cts_protect - Whether CTS protection is enabled 752 */ 753 int cts_protect; 754 755 /** 756 * preamble - Whether short preamble is enabled 757 */ 758 int preamble; 759 760 /** 761 * short_slot_time - Whether short slot time is enabled 762 * 763 * 0 = short slot time disable, 1 = short slot time enabled, -1 = do 764 * not set (e.g., when 802.11g mode is not in use) 765 */ 766 int short_slot_time; 767 768 /** 769 * ht_opmode - HT operation mode or -1 if HT not in use 770 */ 771 int ht_opmode; 772 773 /** 774 * interworking - Whether Interworking is enabled 775 */ 776 int interworking; 777 778 /** 779 * hessid - Homogeneous ESS identifier or %NULL if not set 780 */ 781 const u8 *hessid; 782 783 /** 784 * access_network_type - Access Network Type (0..15) 785 * 786 * This is used for filtering Probe Request frames when Interworking is 787 * enabled. 788 */ 789 u8 access_network_type; 790 791 /** 792 * ap_max_inactivity - Timeout in seconds to detect STA's inactivity 793 * 794 * This is used by driver which advertises this capability. 795 */ 796 int ap_max_inactivity; 797 798 /** 799 * disable_dgaf - Whether group-addressed frames are disabled 800 */ 801 int disable_dgaf; 802}; 803 804/** 805 * struct wpa_driver_capa - Driver capability information 806 */ 807struct wpa_driver_capa { 808#define WPA_DRIVER_CAPA_KEY_MGMT_WPA 0x00000001 809#define WPA_DRIVER_CAPA_KEY_MGMT_WPA2 0x00000002 810#define WPA_DRIVER_CAPA_KEY_MGMT_WPA_PSK 0x00000004 811#define WPA_DRIVER_CAPA_KEY_MGMT_WPA2_PSK 0x00000008 812#define WPA_DRIVER_CAPA_KEY_MGMT_WPA_NONE 0x00000010 813#define WPA_DRIVER_CAPA_KEY_MGMT_FT 0x00000020 814#define WPA_DRIVER_CAPA_KEY_MGMT_FT_PSK 0x00000040 815#define WPA_DRIVER_CAPA_KEY_MGMT_WAPI_PSK 0x00000080 816 unsigned int key_mgmt; 817 818#define WPA_DRIVER_CAPA_ENC_WEP40 0x00000001 819#define WPA_DRIVER_CAPA_ENC_WEP104 0x00000002 820#define WPA_DRIVER_CAPA_ENC_TKIP 0x00000004 821#define WPA_DRIVER_CAPA_ENC_CCMP 0x00000008 822#define WPA_DRIVER_CAPA_ENC_WEP128 0x00000010 823#define WPA_DRIVER_CAPA_ENC_GCMP 0x00000020 824 unsigned int enc; 825 826#define WPA_DRIVER_AUTH_OPEN 0x00000001 827#define WPA_DRIVER_AUTH_SHARED 0x00000002 828#define WPA_DRIVER_AUTH_LEAP 0x00000004 829 unsigned int auth; 830 831/* Driver generated WPA/RSN IE */ 832#define WPA_DRIVER_FLAGS_DRIVER_IE 0x00000001 833/* Driver needs static WEP key setup after association command */ 834#define WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC 0x00000002 835/* unused: 0x00000004 */ 836/* Driver takes care of RSN 4-way handshake internally; PMK is configured with 837 * struct wpa_driver_ops::set_key using alg = WPA_ALG_PMK */ 838#define WPA_DRIVER_FLAGS_4WAY_HANDSHAKE 0x00000008 839#define WPA_DRIVER_FLAGS_WIRED 0x00000010 840/* Driver provides separate commands for authentication and association (SME in 841 * wpa_supplicant). */ 842#define WPA_DRIVER_FLAGS_SME 0x00000020 843/* Driver supports AP mode */ 844#define WPA_DRIVER_FLAGS_AP 0x00000040 845/* Driver needs static WEP key setup after association has been completed */ 846#define WPA_DRIVER_FLAGS_SET_KEYS_AFTER_ASSOC_DONE 0x00000080 847/* Driver takes care of P2P management operations */ 848#define WPA_DRIVER_FLAGS_P2P_MGMT 0x00000100 849/* Driver supports concurrent P2P operations */ 850#define WPA_DRIVER_FLAGS_P2P_CONCURRENT 0x00000200 851/* 852 * Driver uses the initial interface as a dedicated management interface, i.e., 853 * it cannot be used for P2P group operations or non-P2P purposes. 854 */ 855#define WPA_DRIVER_FLAGS_P2P_DEDICATED_INTERFACE 0x00000400 856/* This interface is P2P capable (P2P GO or P2P Client) */ 857#define WPA_DRIVER_FLAGS_P2P_CAPABLE 0x00000800 858/* unused: 0x00001000 */ 859/* 860 * Driver uses the initial interface for P2P management interface and non-P2P 861 * purposes (e.g., connect to infra AP), but this interface cannot be used for 862 * P2P group operations. 863 */ 864#define WPA_DRIVER_FLAGS_P2P_MGMT_AND_NON_P2P 0x00002000 865/* 866 * Driver is known to use sane error codes, i.e., when it indicates that 867 * something (e.g., association) fails, there was indeed a failure and the 868 * operation does not end up getting completed successfully later. 869 */ 870#define WPA_DRIVER_FLAGS_SANE_ERROR_CODES 0x00004000 871/* Driver supports off-channel TX */ 872#define WPA_DRIVER_FLAGS_OFFCHANNEL_TX 0x00008000 873/* Driver indicates TX status events for EAPOL Data frames */ 874#define WPA_DRIVER_FLAGS_EAPOL_TX_STATUS 0x00010000 875/* Driver indicates TX status events for Deauth/Disassoc frames */ 876#define WPA_DRIVER_FLAGS_DEAUTH_TX_STATUS 0x00020000 877/* Driver supports roaming (BSS selection) in firmware */ 878#define WPA_DRIVER_FLAGS_BSS_SELECTION 0x00040000 879/* Driver supports operating as a TDLS peer */ 880#define WPA_DRIVER_FLAGS_TDLS_SUPPORT 0x00080000 881/* Driver requires external TDLS setup/teardown/discovery */ 882#define WPA_DRIVER_FLAGS_TDLS_EXTERNAL_SETUP 0x00100000 883/* Driver indicates support for Probe Response offloading in AP mode */ 884#define WPA_DRIVER_FLAGS_PROBE_RESP_OFFLOAD 0x00200000 885/* Driver supports U-APSD in AP mode */ 886#define WPA_DRIVER_FLAGS_AP_UAPSD 0x00400000 887/* Driver supports inactivity timer in AP mode */ 888#define WPA_DRIVER_FLAGS_INACTIVITY_TIMER 0x00800000 889/* Driver expects user space implementation of MLME in AP mode */ 890#define WPA_DRIVER_FLAGS_AP_MLME 0x01000000 891/* Driver supports SAE with user space SME */ 892#define WPA_DRIVER_FLAGS_SAE 0x02000000 893/* Driver makes use of OBSS scan mechanism in wpa_supplicant */ 894#define WPA_DRIVER_FLAGS_OBSS_SCAN 0x04000000 895/* Driver supports IBSS (Ad-hoc) mode */ 896#define WPA_DRIVER_FLAGS_IBSS 0x08000000 897/* Driver supports radar detection */ 898#define WPA_DRIVER_FLAGS_RADAR 0x10000000 899/* Driver supports a dedicated interface for P2P Device */ 900#define WPA_DRIVER_FLAGS_DEDICATED_P2P_DEVICE 0x20000000 901 unsigned int flags; 902 903 int max_scan_ssids; 904 int max_sched_scan_ssids; 905 int sched_scan_supported; 906 int max_match_sets; 907 908 /** 909 * max_remain_on_chan - Maximum remain-on-channel duration in msec 910 */ 911 unsigned int max_remain_on_chan; 912 913 /** 914 * max_stations - Maximum number of associated stations the driver 915 * supports in AP mode 916 */ 917 unsigned int max_stations; 918 919 /** 920 * probe_resp_offloads - Bitmap of supported protocols by the driver 921 * for Probe Response offloading. 922 */ 923/* Driver Probe Response offloading support for WPS ver. 1 */ 924#define WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS 0x00000001 925/* Driver Probe Response offloading support for WPS ver. 2 */ 926#define WPA_DRIVER_PROBE_RESP_OFFLOAD_WPS2 0x00000002 927/* Driver Probe Response offloading support for P2P */ 928#define WPA_DRIVER_PROBE_RESP_OFFLOAD_P2P 0x00000004 929/* Driver Probe Response offloading support for IEEE 802.11u (Interworking) */ 930#define WPA_DRIVER_PROBE_RESP_OFFLOAD_INTERWORKING 0x00000008 931 unsigned int probe_resp_offloads; 932 933 unsigned int max_acl_mac_addrs; 934 935 /** 936 * Number of supported concurrent channels 937 */ 938 unsigned int num_multichan_concurrent; 939 940 /** 941 * extended_capa - extended capabilities in driver/device 942 * 943 * Must be allocated and freed by driver and the pointers must be 944 * valid for the lifetime of the driver, i.e., freed in deinit() 945 */ 946 const u8 *extended_capa, *extended_capa_mask; 947 unsigned int extended_capa_len; 948}; 949 950 951struct hostapd_data; 952 953struct hostap_sta_driver_data { 954 unsigned long rx_packets, tx_packets, rx_bytes, tx_bytes; 955 unsigned long current_tx_rate; 956 unsigned long inactive_msec; 957 unsigned long flags; 958 unsigned long num_ps_buf_frames; 959 unsigned long tx_retry_failed; 960 unsigned long tx_retry_count; 961 int last_rssi; 962 int last_ack_rssi; 963}; 964 965struct hostapd_sta_add_params { 966 const u8 *addr; 967 u16 aid; 968 u16 capability; 969 const u8 *supp_rates; 970 size_t supp_rates_len; 971 u16 listen_interval; 972 const struct ieee80211_ht_capabilities *ht_capabilities; 973 const struct ieee80211_vht_capabilities *vht_capabilities; 974 u32 flags; /* bitmask of WPA_STA_* flags */ 975 int set; /* Set STA parameters instead of add */ 976 u8 qosinfo; 977 const u8 *ext_capab; 978 size_t ext_capab_len; 979}; 980 981struct hostapd_freq_params { 982 int mode; 983 int freq; 984 int channel; 985 /* for HT */ 986 int ht_enabled; 987 int sec_channel_offset; /* 0 = HT40 disabled, -1 = HT40 enabled, 988 * secondary channel below primary, 1 = HT40 989 * enabled, secondary channel above primary */ 990 991 /* for VHT */ 992 int vht_enabled; 993 994 /* valid for both HT and VHT, center_freq2 is non-zero 995 * only for bandwidth 80 and an 80+80 channel */ 996 int center_freq1, center_freq2; 997 int bandwidth; 998}; 999 1000struct mac_address { 1001 u8 addr[ETH_ALEN]; 1002}; 1003 1004struct hostapd_acl_params { 1005 u8 acl_policy; 1006 unsigned int num_mac_acl; 1007 struct mac_address mac_acl[0]; 1008}; 1009 1010enum wpa_driver_if_type { 1011 /** 1012 * WPA_IF_STATION - Station mode interface 1013 */ 1014 WPA_IF_STATION, 1015 1016 /** 1017 * WPA_IF_AP_VLAN - AP mode VLAN interface 1018 * 1019 * This interface shares its address and Beacon frame with the main 1020 * BSS. 1021 */ 1022 WPA_IF_AP_VLAN, 1023 1024 /** 1025 * WPA_IF_AP_BSS - AP mode BSS interface 1026 * 1027 * This interface has its own address and Beacon frame. 1028 */ 1029 WPA_IF_AP_BSS, 1030 1031 /** 1032 * WPA_IF_P2P_GO - P2P Group Owner 1033 */ 1034 WPA_IF_P2P_GO, 1035 1036 /** 1037 * WPA_IF_P2P_CLIENT - P2P Client 1038 */ 1039 WPA_IF_P2P_CLIENT, 1040 1041 /** 1042 * WPA_IF_P2P_GROUP - P2P Group interface (will become either 1043 * WPA_IF_P2P_GO or WPA_IF_P2P_CLIENT, but the role is not yet known) 1044 */ 1045 WPA_IF_P2P_GROUP, 1046 1047 /** 1048 * WPA_IF_P2P_DEVICE - P2P Device interface is used to indentify the 1049 * abstracted P2P Device function in the driver 1050 */ 1051 WPA_IF_P2P_DEVICE 1052}; 1053 1054struct wpa_init_params { 1055 void *global_priv; 1056 const u8 *bssid; 1057 const char *ifname; 1058 const u8 *ssid; 1059 size_t ssid_len; 1060 const char *test_socket; 1061 int use_pae_group_addr; 1062 char **bridge; 1063 size_t num_bridge; 1064 1065 u8 *own_addr; /* buffer for writing own MAC address */ 1066}; 1067 1068 1069struct wpa_bss_params { 1070 /** Interface name (for multi-SSID/VLAN support) */ 1071 const char *ifname; 1072 /** Whether IEEE 802.1X or WPA/WPA2 is enabled */ 1073 int enabled; 1074 1075 int wpa; 1076 int ieee802_1x; 1077 int wpa_group; 1078 int wpa_pairwise; 1079 int wpa_key_mgmt; 1080 int rsn_preauth; 1081 enum mfp_options ieee80211w; 1082}; 1083 1084#define WPA_STA_AUTHORIZED BIT(0) 1085#define WPA_STA_WMM BIT(1) 1086#define WPA_STA_SHORT_PREAMBLE BIT(2) 1087#define WPA_STA_MFP BIT(3) 1088#define WPA_STA_TDLS_PEER BIT(4) 1089 1090/** 1091 * struct p2p_params - P2P parameters for driver-based P2P management 1092 */ 1093struct p2p_params { 1094 const char *dev_name; 1095 u8 pri_dev_type[8]; 1096#define DRV_MAX_SEC_DEV_TYPES 5 1097 u8 sec_dev_type[DRV_MAX_SEC_DEV_TYPES][8]; 1098 size_t num_sec_dev_types; 1099}; 1100 1101enum tdls_oper { 1102 TDLS_DISCOVERY_REQ, 1103 TDLS_SETUP, 1104 TDLS_TEARDOWN, 1105 TDLS_ENABLE_LINK, 1106 TDLS_DISABLE_LINK, 1107 TDLS_ENABLE, 1108 TDLS_DISABLE 1109}; 1110 1111enum wnm_oper { 1112 WNM_SLEEP_ENTER_CONFIRM, 1113 WNM_SLEEP_ENTER_FAIL, 1114 WNM_SLEEP_EXIT_CONFIRM, 1115 WNM_SLEEP_EXIT_FAIL, 1116 WNM_SLEEP_TFS_REQ_IE_ADD, /* STA requests driver to add TFS req IE */ 1117 WNM_SLEEP_TFS_REQ_IE_NONE, /* STA requests empty TFS req IE */ 1118 WNM_SLEEP_TFS_REQ_IE_SET, /* AP requests driver to set TFS req IE for 1119 * a STA */ 1120 WNM_SLEEP_TFS_RESP_IE_ADD, /* AP requests driver to add TFS resp IE 1121 * for a STA */ 1122 WNM_SLEEP_TFS_RESP_IE_NONE, /* AP requests empty TFS resp IE */ 1123 WNM_SLEEP_TFS_RESP_IE_SET, /* AP requests driver to set TFS resp IE 1124 * for a STA */ 1125 WNM_SLEEP_TFS_IE_DEL /* AP delete the TFS IE */ 1126}; 1127 1128/* enum chan_width - Channel width definitions */ 1129enum chan_width { 1130 CHAN_WIDTH_20_NOHT, 1131 CHAN_WIDTH_20, 1132 CHAN_WIDTH_40, 1133 CHAN_WIDTH_80, 1134 CHAN_WIDTH_80P80, 1135 CHAN_WIDTH_160, 1136 CHAN_WIDTH_UNKNOWN 1137}; 1138 1139/** 1140 * struct wpa_signal_info - Information about channel signal quality 1141 */ 1142struct wpa_signal_info { 1143 u32 frequency; 1144 int above_threshold; 1145 int current_signal; 1146 int avg_signal; 1147 int current_noise; 1148 int current_txrate; 1149 enum chan_width chanwidth; 1150 int center_frq1; 1151 int center_frq2; 1152}; 1153 1154/** 1155 * struct wpa_driver_ops - Driver interface API definition 1156 * 1157 * This structure defines the API that each driver interface needs to implement 1158 * for core wpa_supplicant code. All driver specific functionality is captured 1159 * in this wrapper. 1160 */ 1161struct wpa_driver_ops { 1162 /** Name of the driver interface */ 1163 const char *name; 1164 /** One line description of the driver interface */ 1165 const char *desc; 1166 1167 /** 1168 * get_bssid - Get the current BSSID 1169 * @priv: private driver interface data 1170 * @bssid: buffer for BSSID (ETH_ALEN = 6 bytes) 1171 * 1172 * Returns: 0 on success, -1 on failure 1173 * 1174 * Query kernel driver for the current BSSID and copy it to bssid. 1175 * Setting bssid to 00:00:00:00:00:00 is recommended if the STA is not 1176 * associated. 1177 */ 1178 int (*get_bssid)(void *priv, u8 *bssid); 1179 1180 /** 1181 * get_ssid - Get the current SSID 1182 * @priv: private driver interface data 1183 * @ssid: buffer for SSID (at least 32 bytes) 1184 * 1185 * Returns: Length of the SSID on success, -1 on failure 1186 * 1187 * Query kernel driver for the current SSID and copy it to ssid. 1188 * Returning zero is recommended if the STA is not associated. 1189 * 1190 * Note: SSID is an array of octets, i.e., it is not nul terminated and 1191 * can, at least in theory, contain control characters (including nul) 1192 * and as such, should be processed as binary data, not a printable 1193 * string. 1194 */ 1195 int (*get_ssid)(void *priv, u8 *ssid); 1196 1197 /** 1198 * set_key - Configure encryption key 1199 * @ifname: Interface name (for multi-SSID/VLAN support) 1200 * @priv: private driver interface data 1201 * @alg: encryption algorithm (%WPA_ALG_NONE, %WPA_ALG_WEP, 1202 * %WPA_ALG_TKIP, %WPA_ALG_CCMP, %WPA_ALG_IGTK, %WPA_ALG_PMK, 1203 * %WPA_ALG_GCMP); 1204 * %WPA_ALG_NONE clears the key. 1205 * @addr: Address of the peer STA (BSSID of the current AP when setting 1206 * pairwise key in station mode), ff:ff:ff:ff:ff:ff for 1207 * broadcast keys, %NULL for default keys that are used both for 1208 * broadcast and unicast; when clearing keys, %NULL is used to 1209 * indicate that both the broadcast-only and default key of the 1210 * specified key index is to be cleared 1211 * @key_idx: key index (0..3), usually 0 for unicast keys; 0..4095 for 1212 * IGTK 1213 * @set_tx: configure this key as the default Tx key (only used when 1214 * driver does not support separate unicast/individual key 1215 * @seq: sequence number/packet number, seq_len octets, the next 1216 * packet number to be used for in replay protection; configured 1217 * for Rx keys (in most cases, this is only used with broadcast 1218 * keys and set to zero for unicast keys); %NULL if not set 1219 * @seq_len: length of the seq, depends on the algorithm: 1220 * TKIP: 6 octets, CCMP/GCMP: 6 octets, IGTK: 6 octets 1221 * @key: key buffer; TKIP: 16-byte temporal key, 8-byte Tx Mic key, 1222 * 8-byte Rx Mic Key 1223 * @key_len: length of the key buffer in octets (WEP: 5 or 13, 1224 * TKIP: 32, CCMP/GCMP: 16, IGTK: 16) 1225 * 1226 * Returns: 0 on success, -1 on failure 1227 * 1228 * Configure the given key for the kernel driver. If the driver 1229 * supports separate individual keys (4 default keys + 1 individual), 1230 * addr can be used to determine whether the key is default or 1231 * individual. If only 4 keys are supported, the default key with key 1232 * index 0 is used as the individual key. STA must be configured to use 1233 * it as the default Tx key (set_tx is set) and accept Rx for all the 1234 * key indexes. In most cases, WPA uses only key indexes 1 and 2 for 1235 * broadcast keys, so key index 0 is available for this kind of 1236 * configuration. 1237 * 1238 * Please note that TKIP keys include separate TX and RX MIC keys and 1239 * some drivers may expect them in different order than wpa_supplicant 1240 * is using. If the TX/RX keys are swapped, all TKIP encrypted packets 1241 * will trigger Michael MIC errors. This can be fixed by changing the 1242 * order of MIC keys by swapping te bytes 16..23 and 24..31 of the key 1243 * in driver_*.c set_key() implementation, see driver_ndis.c for an 1244 * example on how this can be done. 1245 */ 1246 int (*set_key)(const char *ifname, void *priv, enum wpa_alg alg, 1247 const u8 *addr, int key_idx, int set_tx, 1248 const u8 *seq, size_t seq_len, 1249 const u8 *key, size_t key_len); 1250 1251 /** 1252 * init - Initialize driver interface 1253 * @ctx: context to be used when calling wpa_supplicant functions, 1254 * e.g., wpa_supplicant_event() 1255 * @ifname: interface name, e.g., wlan0 1256 * 1257 * Returns: Pointer to private data, %NULL on failure 1258 * 1259 * Initialize driver interface, including event processing for kernel 1260 * driver events (e.g., associated, scan results, Michael MIC failure). 1261 * This function can allocate a private configuration data area for 1262 * @ctx, file descriptor, interface name, etc. information that may be 1263 * needed in future driver operations. If this is not used, non-NULL 1264 * value will need to be returned because %NULL is used to indicate 1265 * failure. The returned value will be used as 'void *priv' data for 1266 * all other driver_ops functions. 1267 * 1268 * The main event loop (eloop.c) of wpa_supplicant can be used to 1269 * register callback for read sockets (eloop_register_read_sock()). 1270 * 1271 * See below for more information about events and 1272 * wpa_supplicant_event() function. 1273 */ 1274 void * (*init)(void *ctx, const char *ifname); 1275 1276 /** 1277 * deinit - Deinitialize driver interface 1278 * @priv: private driver interface data from init() 1279 * 1280 * Shut down driver interface and processing of driver events. Free 1281 * private data buffer if one was allocated in init() handler. 1282 */ 1283 void (*deinit)(void *priv); 1284 1285 /** 1286 * set_param - Set driver configuration parameters 1287 * @priv: private driver interface data from init() 1288 * @param: driver specific configuration parameters 1289 * 1290 * Returns: 0 on success, -1 on failure 1291 * 1292 * Optional handler for notifying driver interface about configuration 1293 * parameters (driver_param). 1294 */ 1295 int (*set_param)(void *priv, const char *param); 1296 1297 /** 1298 * set_countermeasures - Enable/disable TKIP countermeasures 1299 * @priv: private driver interface data 1300 * @enabled: 1 = countermeasures enabled, 0 = disabled 1301 * 1302 * Returns: 0 on success, -1 on failure 1303 * 1304 * Configure TKIP countermeasures. When these are enabled, the driver 1305 * should drop all received and queued frames that are using TKIP. 1306 */ 1307 int (*set_countermeasures)(void *priv, int enabled); 1308 1309 /** 1310 * deauthenticate - Request driver to deauthenticate 1311 * @priv: private driver interface data 1312 * @addr: peer address (BSSID of the AP) 1313 * @reason_code: 16-bit reason code to be sent in the deauthentication 1314 * frame 1315 * 1316 * Returns: 0 on success, -1 on failure 1317 */ 1318 int (*deauthenticate)(void *priv, const u8 *addr, int reason_code); 1319 1320 /** 1321 * associate - Request driver to associate 1322 * @priv: private driver interface data 1323 * @params: association parameters 1324 * 1325 * Returns: 0 on success, -1 on failure 1326 */ 1327 int (*associate)(void *priv, 1328 struct wpa_driver_associate_params *params); 1329 1330 /** 1331 * add_pmkid - Add PMKSA cache entry to the driver 1332 * @priv: private driver interface data 1333 * @bssid: BSSID for the PMKSA cache entry 1334 * @pmkid: PMKID for the PMKSA cache entry 1335 * 1336 * Returns: 0 on success, -1 on failure 1337 * 1338 * This function is called when a new PMK is received, as a result of 1339 * either normal authentication or RSN pre-authentication. 1340 * 1341 * If the driver generates RSN IE, i.e., it does not use wpa_ie in 1342 * associate(), add_pmkid() can be used to add new PMKSA cache entries 1343 * in the driver. If the driver uses wpa_ie from wpa_supplicant, this 1344 * driver_ops function does not need to be implemented. Likewise, if 1345 * the driver does not support WPA, this function is not needed. 1346 */ 1347 int (*add_pmkid)(void *priv, const u8 *bssid, const u8 *pmkid); 1348 1349 /** 1350 * remove_pmkid - Remove PMKSA cache entry to the driver 1351 * @priv: private driver interface data 1352 * @bssid: BSSID for the PMKSA cache entry 1353 * @pmkid: PMKID for the PMKSA cache entry 1354 * 1355 * Returns: 0 on success, -1 on failure 1356 * 1357 * This function is called when the supplicant drops a PMKSA cache 1358 * entry for any reason. 1359 * 1360 * If the driver generates RSN IE, i.e., it does not use wpa_ie in 1361 * associate(), remove_pmkid() can be used to synchronize PMKSA caches 1362 * between the driver and wpa_supplicant. If the driver uses wpa_ie 1363 * from wpa_supplicant, this driver_ops function does not need to be 1364 * implemented. Likewise, if the driver does not support WPA, this 1365 * function is not needed. 1366 */ 1367 int (*remove_pmkid)(void *priv, const u8 *bssid, const u8 *pmkid); 1368 1369 /** 1370 * flush_pmkid - Flush PMKSA cache 1371 * @priv: private driver interface data 1372 * 1373 * Returns: 0 on success, -1 on failure 1374 * 1375 * This function is called when the supplicant drops all PMKSA cache 1376 * entries for any reason. 1377 * 1378 * If the driver generates RSN IE, i.e., it does not use wpa_ie in 1379 * associate(), remove_pmkid() can be used to synchronize PMKSA caches 1380 * between the driver and wpa_supplicant. If the driver uses wpa_ie 1381 * from wpa_supplicant, this driver_ops function does not need to be 1382 * implemented. Likewise, if the driver does not support WPA, this 1383 * function is not needed. 1384 */ 1385 int (*flush_pmkid)(void *priv); 1386 1387 /** 1388 * get_capa - Get driver capabilities 1389 * @priv: private driver interface data 1390 * 1391 * Returns: 0 on success, -1 on failure 1392 * 1393 * Get driver/firmware/hardware capabilities. 1394 */ 1395 int (*get_capa)(void *priv, struct wpa_driver_capa *capa); 1396 1397 /** 1398 * poll - Poll driver for association information 1399 * @priv: private driver interface data 1400 * 1401 * This is an option callback that can be used when the driver does not 1402 * provide event mechanism for association events. This is called when 1403 * receiving WPA EAPOL-Key messages that require association 1404 * information. The driver interface is supposed to generate associnfo 1405 * event before returning from this callback function. In addition, the 1406 * driver interface should generate an association event after having 1407 * sent out associnfo. 1408 */ 1409 void (*poll)(void *priv); 1410 1411 /** 1412 * get_ifname - Get interface name 1413 * @priv: private driver interface data 1414 * 1415 * Returns: Pointer to the interface name. This can differ from the 1416 * interface name used in init() call. Init() is called first. 1417 * 1418 * This optional function can be used to allow the driver interface to 1419 * replace the interface name with something else, e.g., based on an 1420 * interface mapping from a more descriptive name. 1421 */ 1422 const char * (*get_ifname)(void *priv); 1423 1424 /** 1425 * get_mac_addr - Get own MAC address 1426 * @priv: private driver interface data 1427 * 1428 * Returns: Pointer to own MAC address or %NULL on failure 1429 * 1430 * This optional function can be used to get the own MAC address of the 1431 * device from the driver interface code. This is only needed if the 1432 * l2_packet implementation for the OS does not provide easy access to 1433 * a MAC address. */ 1434 const u8 * (*get_mac_addr)(void *priv); 1435 1436 /** 1437 * send_eapol - Optional function for sending EAPOL packets 1438 * @priv: private driver interface data 1439 * @dest: Destination MAC address 1440 * @proto: Ethertype 1441 * @data: EAPOL packet starting with IEEE 802.1X header 1442 * @data_len: Size of the EAPOL packet 1443 * 1444 * Returns: 0 on success, -1 on failure 1445 * 1446 * This optional function can be used to override l2_packet operations 1447 * with driver specific functionality. If this function pointer is set, 1448 * l2_packet module is not used at all and the driver interface code is 1449 * responsible for receiving and sending all EAPOL packets. The 1450 * received EAPOL packets are sent to core code with EVENT_EAPOL_RX 1451 * event. The driver interface is required to implement get_mac_addr() 1452 * handler if send_eapol() is used. 1453 */ 1454 int (*send_eapol)(void *priv, const u8 *dest, u16 proto, 1455 const u8 *data, size_t data_len); 1456 1457 /** 1458 * set_operstate - Sets device operating state to DORMANT or UP 1459 * @priv: private driver interface data 1460 * @state: 0 = dormant, 1 = up 1461 * Returns: 0 on success, -1 on failure 1462 * 1463 * This is an optional function that can be used on operating systems 1464 * that support a concept of controlling network device state from user 1465 * space applications. This function, if set, gets called with 1466 * state = 1 when authentication has been completed and with state = 0 1467 * when connection is lost. 1468 */ 1469 int (*set_operstate)(void *priv, int state); 1470 1471 /** 1472 * mlme_setprotection - MLME-SETPROTECTION.request primitive 1473 * @priv: Private driver interface data 1474 * @addr: Address of the station for which to set protection (may be 1475 * %NULL for group keys) 1476 * @protect_type: MLME_SETPROTECTION_PROTECT_TYPE_* 1477 * @key_type: MLME_SETPROTECTION_KEY_TYPE_* 1478 * Returns: 0 on success, -1 on failure 1479 * 1480 * This is an optional function that can be used to set the driver to 1481 * require protection for Tx and/or Rx frames. This uses the layer 1482 * interface defined in IEEE 802.11i-2004 clause 10.3.22.1 1483 * (MLME-SETPROTECTION.request). Many drivers do not use explicit 1484 * set protection operation; instead, they set protection implicitly 1485 * based on configured keys. 1486 */ 1487 int (*mlme_setprotection)(void *priv, const u8 *addr, int protect_type, 1488 int key_type); 1489 1490 /** 1491 * get_hw_feature_data - Get hardware support data (channels and rates) 1492 * @priv: Private driver interface data 1493 * @num_modes: Variable for returning the number of returned modes 1494 * flags: Variable for returning hardware feature flags 1495 * Returns: Pointer to allocated hardware data on success or %NULL on 1496 * failure. Caller is responsible for freeing this. 1497 */ 1498 struct hostapd_hw_modes * (*get_hw_feature_data)(void *priv, 1499 u16 *num_modes, 1500 u16 *flags); 1501 1502 /** 1503 * send_mlme - Send management frame from MLME 1504 * @priv: Private driver interface data 1505 * @data: IEEE 802.11 management frame with IEEE 802.11 header 1506 * @data_len: Size of the management frame 1507 * @noack: Do not wait for this frame to be acked (disable retries) 1508 * Returns: 0 on success, -1 on failure 1509 */ 1510 int (*send_mlme)(void *priv, const u8 *data, size_t data_len, 1511 int noack); 1512 1513 /** 1514 * update_ft_ies - Update FT (IEEE 802.11r) IEs 1515 * @priv: Private driver interface data 1516 * @md: Mobility domain (2 octets) (also included inside ies) 1517 * @ies: FT IEs (MDIE, FTIE, ...) or %NULL to remove IEs 1518 * @ies_len: Length of FT IEs in bytes 1519 * Returns: 0 on success, -1 on failure 1520 * 1521 * The supplicant uses this callback to let the driver know that keying 1522 * material for FT is available and that the driver can use the 1523 * provided IEs in the next message in FT authentication sequence. 1524 * 1525 * This function is only needed for driver that support IEEE 802.11r 1526 * (Fast BSS Transition). 1527 */ 1528 int (*update_ft_ies)(void *priv, const u8 *md, const u8 *ies, 1529 size_t ies_len); 1530 1531 /** 1532 * send_ft_action - Send FT Action frame (IEEE 802.11r) 1533 * @priv: Private driver interface data 1534 * @action: Action field value 1535 * @target_ap: Target AP address 1536 * @ies: FT IEs (MDIE, FTIE, ...) (FT Request action frame body) 1537 * @ies_len: Length of FT IEs in bytes 1538 * Returns: 0 on success, -1 on failure 1539 * 1540 * The supplicant uses this callback to request the driver to transmit 1541 * an FT Action frame (action category 6) for over-the-DS fast BSS 1542 * transition. 1543 */ 1544 int (*send_ft_action)(void *priv, u8 action, const u8 *target_ap, 1545 const u8 *ies, size_t ies_len); 1546 1547 /** 1548 * get_scan_results2 - Fetch the latest scan results 1549 * @priv: private driver interface data 1550 * 1551 * Returns: Allocated buffer of scan results (caller is responsible for 1552 * freeing the data structure) on success, NULL on failure 1553 */ 1554 struct wpa_scan_results * (*get_scan_results2)(void *priv); 1555 1556 /** 1557 * set_country - Set country 1558 * @priv: Private driver interface data 1559 * @alpha2: country to which to switch to 1560 * Returns: 0 on success, -1 on failure 1561 * 1562 * This function is for drivers which support some form 1563 * of setting a regulatory domain. 1564 */ 1565 int (*set_country)(void *priv, const char *alpha2); 1566 1567 /** 1568 * global_init - Global driver initialization 1569 * Returns: Pointer to private data (global), %NULL on failure 1570 * 1571 * This optional function is called to initialize the driver wrapper 1572 * for global data, i.e., data that applies to all interfaces. If this 1573 * function is implemented, global_deinit() will also need to be 1574 * implemented to free the private data. The driver will also likely 1575 * use init2() function instead of init() to get the pointer to global 1576 * data available to per-interface initializer. 1577 */ 1578 void * (*global_init)(void); 1579 1580 /** 1581 * global_deinit - Global driver deinitialization 1582 * @priv: private driver global data from global_init() 1583 * 1584 * Terminate any global driver related functionality and free the 1585 * global data structure. 1586 */ 1587 void (*global_deinit)(void *priv); 1588 1589 /** 1590 * init2 - Initialize driver interface (with global data) 1591 * @ctx: context to be used when calling wpa_supplicant functions, 1592 * e.g., wpa_supplicant_event() 1593 * @ifname: interface name, e.g., wlan0 1594 * @global_priv: private driver global data from global_init() 1595 * Returns: Pointer to private data, %NULL on failure 1596 * 1597 * This function can be used instead of init() if the driver wrapper 1598 * uses global data. 1599 */ 1600 void * (*init2)(void *ctx, const char *ifname, void *global_priv); 1601 1602 /** 1603 * get_interfaces - Get information about available interfaces 1604 * @global_priv: private driver global data from global_init() 1605 * Returns: Allocated buffer of interface information (caller is 1606 * responsible for freeing the data structure) on success, NULL on 1607 * failure 1608 */ 1609 struct wpa_interface_info * (*get_interfaces)(void *global_priv); 1610 1611 /** 1612 * scan2 - Request the driver to initiate scan 1613 * @priv: private driver interface data 1614 * @params: Scan parameters 1615 * 1616 * Returns: 0 on success, -1 on failure 1617 * 1618 * Once the scan results are ready, the driver should report scan 1619 * results event for wpa_supplicant which will eventually request the 1620 * results with wpa_driver_get_scan_results2(). 1621 */ 1622 int (*scan2)(void *priv, struct wpa_driver_scan_params *params); 1623 1624 /** 1625 * authenticate - Request driver to authenticate 1626 * @priv: private driver interface data 1627 * @params: authentication parameters 1628 * Returns: 0 on success, -1 on failure 1629 * 1630 * This is an optional function that can be used with drivers that 1631 * support separate authentication and association steps, i.e., when 1632 * wpa_supplicant can act as the SME. If not implemented, associate() 1633 * function is expected to take care of IEEE 802.11 authentication, 1634 * too. 1635 */ 1636 int (*authenticate)(void *priv, 1637 struct wpa_driver_auth_params *params); 1638 1639 /** 1640 * set_ap - Set Beacon and Probe Response information for AP mode 1641 * @priv: Private driver interface data 1642 * @params: Parameters to use in AP mode 1643 * 1644 * This function is used to configure Beacon template and/or extra IEs 1645 * to add for Beacon and Probe Response frames for the driver in 1646 * AP mode. The driver is responsible for building the full Beacon 1647 * frame by concatenating the head part with TIM IE generated by the 1648 * driver/firmware and finishing with the tail part. Depending on the 1649 * driver architectue, this can be done either by using the full 1650 * template or the set of additional IEs (e.g., WPS and P2P IE). 1651 * Similarly, Probe Response processing depends on the driver design. 1652 * If the driver (or firmware) takes care of replying to Probe Request 1653 * frames, the extra IEs provided here needs to be added to the Probe 1654 * Response frames. 1655 * 1656 * Returns: 0 on success, -1 on failure 1657 */ 1658 int (*set_ap)(void *priv, struct wpa_driver_ap_params *params); 1659 1660 /** 1661 * set_acl - Set ACL in AP mode 1662 * @priv: Private driver interface data 1663 * @params: Parameters to configure ACL 1664 * Returns: 0 on success, -1 on failure 1665 * 1666 * This is used only for the drivers which support MAC address ACL. 1667 */ 1668 int (*set_acl)(void *priv, struct hostapd_acl_params *params); 1669 1670 /** 1671 * hapd_init - Initialize driver interface (hostapd only) 1672 * @hapd: Pointer to hostapd context 1673 * @params: Configuration for the driver wrapper 1674 * Returns: Pointer to private data, %NULL on failure 1675 * 1676 * This function is used instead of init() or init2() when the driver 1677 * wrapper is used with hostapd. 1678 */ 1679 void * (*hapd_init)(struct hostapd_data *hapd, 1680 struct wpa_init_params *params); 1681 1682 /** 1683 * hapd_deinit - Deinitialize driver interface (hostapd only) 1684 * @priv: Private driver interface data from hapd_init() 1685 */ 1686 void (*hapd_deinit)(void *priv); 1687 1688 /** 1689 * set_ieee8021x - Enable/disable IEEE 802.1X support (AP only) 1690 * @priv: Private driver interface data 1691 * @params: BSS parameters 1692 * Returns: 0 on success, -1 on failure 1693 * 1694 * This is an optional function to configure the kernel driver to 1695 * enable/disable IEEE 802.1X support and set WPA/WPA2 parameters. This 1696 * can be left undefined (set to %NULL) if IEEE 802.1X support is 1697 * always enabled and the driver uses set_ap() to set WPA/RSN IE 1698 * for Beacon frames. 1699 * 1700 * DEPRECATED - use set_ap() instead 1701 */ 1702 int (*set_ieee8021x)(void *priv, struct wpa_bss_params *params); 1703 1704 /** 1705 * set_privacy - Enable/disable privacy (AP only) 1706 * @priv: Private driver interface data 1707 * @enabled: 1 = privacy enabled, 0 = disabled 1708 * Returns: 0 on success, -1 on failure 1709 * 1710 * This is an optional function to configure privacy field in the 1711 * kernel driver for Beacon frames. This can be left undefined (set to 1712 * %NULL) if the driver uses the Beacon template from set_ap(). 1713 * 1714 * DEPRECATED - use set_ap() instead 1715 */ 1716 int (*set_privacy)(void *priv, int enabled); 1717 1718 /** 1719 * get_seqnum - Fetch the current TSC/packet number (AP only) 1720 * @ifname: The interface name (main or virtual) 1721 * @priv: Private driver interface data 1722 * @addr: MAC address of the station or %NULL for group keys 1723 * @idx: Key index 1724 * @seq: Buffer for returning the latest used TSC/packet number 1725 * Returns: 0 on success, -1 on failure 1726 * 1727 * This function is used to fetch the last used TSC/packet number for 1728 * a TKIP, CCMP, GCMP, or BIP/IGTK key. It is mainly used with group 1729 * keys, so there is no strict requirement on implementing support for 1730 * unicast keys (i.e., addr != %NULL). 1731 */ 1732 int (*get_seqnum)(const char *ifname, void *priv, const u8 *addr, 1733 int idx, u8 *seq); 1734 1735 /** 1736 * flush - Flush all association stations (AP only) 1737 * @priv: Private driver interface data 1738 * Returns: 0 on success, -1 on failure 1739 * 1740 * This function requests the driver to disassociate all associated 1741 * stations. This function does not need to be implemented if the 1742 * driver does not process association frames internally. 1743 */ 1744 int (*flush)(void *priv); 1745 1746 /** 1747 * set_generic_elem - Add IEs into Beacon/Probe Response frames (AP) 1748 * @priv: Private driver interface data 1749 * @elem: Information elements 1750 * @elem_len: Length of the elem buffer in octets 1751 * Returns: 0 on success, -1 on failure 1752 * 1753 * This is an optional function to add information elements in the 1754 * kernel driver for Beacon and Probe Response frames. This can be left 1755 * undefined (set to %NULL) if the driver uses the Beacon template from 1756 * set_ap(). 1757 * 1758 * DEPRECATED - use set_ap() instead 1759 */ 1760 int (*set_generic_elem)(void *priv, const u8 *elem, size_t elem_len); 1761 1762 /** 1763 * read_sta_data - Fetch station data 1764 * @priv: Private driver interface data 1765 * @data: Buffer for returning station information 1766 * @addr: MAC address of the station 1767 * Returns: 0 on success, -1 on failure 1768 */ 1769 int (*read_sta_data)(void *priv, struct hostap_sta_driver_data *data, 1770 const u8 *addr); 1771 1772 /** 1773 * hapd_send_eapol - Send an EAPOL packet (AP only) 1774 * @priv: private driver interface data 1775 * @addr: Destination MAC address 1776 * @data: EAPOL packet starting with IEEE 802.1X header 1777 * @data_len: Length of the EAPOL packet in octets 1778 * @encrypt: Whether the frame should be encrypted 1779 * @own_addr: Source MAC address 1780 * @flags: WPA_STA_* flags for the destination station 1781 * 1782 * Returns: 0 on success, -1 on failure 1783 */ 1784 int (*hapd_send_eapol)(void *priv, const u8 *addr, const u8 *data, 1785 size_t data_len, int encrypt, 1786 const u8 *own_addr, u32 flags); 1787 1788 /** 1789 * sta_deauth - Deauthenticate a station (AP only) 1790 * @priv: Private driver interface data 1791 * @own_addr: Source address and BSSID for the Deauthentication frame 1792 * @addr: MAC address of the station to deauthenticate 1793 * @reason: Reason code for the Deauthentiation frame 1794 * Returns: 0 on success, -1 on failure 1795 * 1796 * This function requests a specific station to be deauthenticated and 1797 * a Deauthentication frame to be sent to it. 1798 */ 1799 int (*sta_deauth)(void *priv, const u8 *own_addr, const u8 *addr, 1800 int reason); 1801 1802 /** 1803 * sta_disassoc - Disassociate a station (AP only) 1804 * @priv: Private driver interface data 1805 * @own_addr: Source address and BSSID for the Disassociation frame 1806 * @addr: MAC address of the station to disassociate 1807 * @reason: Reason code for the Disassociation frame 1808 * Returns: 0 on success, -1 on failure 1809 * 1810 * This function requests a specific station to be disassociated and 1811 * a Disassociation frame to be sent to it. 1812 */ 1813 int (*sta_disassoc)(void *priv, const u8 *own_addr, const u8 *addr, 1814 int reason); 1815 1816 /** 1817 * sta_remove - Remove a station entry (AP only) 1818 * @priv: Private driver interface data 1819 * @addr: MAC address of the station to be removed 1820 * Returns: 0 on success, -1 on failure 1821 */ 1822 int (*sta_remove)(void *priv, const u8 *addr); 1823 1824 /** 1825 * hapd_get_ssid - Get the current SSID (AP only) 1826 * @priv: Private driver interface data 1827 * @buf: Buffer for returning the SSID 1828 * @len: Maximum length of the buffer 1829 * Returns: Length of the SSID on success, -1 on failure 1830 * 1831 * This function need not be implemented if the driver uses Beacon 1832 * template from set_ap() and does not reply to Probe Request frames. 1833 */ 1834 int (*hapd_get_ssid)(void *priv, u8 *buf, int len); 1835 1836 /** 1837 * hapd_set_ssid - Set SSID (AP only) 1838 * @priv: Private driver interface data 1839 * @buf: SSID 1840 * @len: Length of the SSID in octets 1841 * Returns: 0 on success, -1 on failure 1842 * 1843 * DEPRECATED - use set_ap() instead 1844 */ 1845 int (*hapd_set_ssid)(void *priv, const u8 *buf, int len); 1846 1847 /** 1848 * hapd_set_countermeasures - Enable/disable TKIP countermeasures (AP) 1849 * @priv: Private driver interface data 1850 * @enabled: 1 = countermeasures enabled, 0 = disabled 1851 * Returns: 0 on success, -1 on failure 1852 * 1853 * This need not be implemented if the driver does not take care of 1854 * association processing. 1855 */ 1856 int (*hapd_set_countermeasures)(void *priv, int enabled); 1857 1858 /** 1859 * sta_add - Add a station entry 1860 * @priv: Private driver interface data 1861 * @params: Station parameters 1862 * Returns: 0 on success, -1 on failure 1863 * 1864 * This function is used to add a station entry to the driver once the 1865 * station has completed association. This is only used if the driver 1866 * does not take care of association processing. 1867 * 1868 * With TDLS, this function is also used to add or set (params->set 1) 1869 * TDLS peer entries. 1870 */ 1871 int (*sta_add)(void *priv, struct hostapd_sta_add_params *params); 1872 1873 /** 1874 * get_inact_sec - Get station inactivity duration (AP only) 1875 * @priv: Private driver interface data 1876 * @addr: Station address 1877 * Returns: Number of seconds station has been inactive, -1 on failure 1878 */ 1879 int (*get_inact_sec)(void *priv, const u8 *addr); 1880 1881 /** 1882 * sta_clear_stats - Clear station statistics (AP only) 1883 * @priv: Private driver interface data 1884 * @addr: Station address 1885 * Returns: 0 on success, -1 on failure 1886 */ 1887 int (*sta_clear_stats)(void *priv, const u8 *addr); 1888 1889 /** 1890 * set_freq - Set channel/frequency (AP only) 1891 * @priv: Private driver interface data 1892 * @freq: Channel parameters 1893 * Returns: 0 on success, -1 on failure 1894 */ 1895 int (*set_freq)(void *priv, struct hostapd_freq_params *freq); 1896 1897 /** 1898 * set_rts - Set RTS threshold 1899 * @priv: Private driver interface data 1900 * @rts: RTS threshold in octets 1901 * Returns: 0 on success, -1 on failure 1902 */ 1903 int (*set_rts)(void *priv, int rts); 1904 1905 /** 1906 * set_frag - Set fragmentation threshold 1907 * @priv: Private driver interface data 1908 * @frag: Fragmentation threshold in octets 1909 * Returns: 0 on success, -1 on failure 1910 */ 1911 int (*set_frag)(void *priv, int frag); 1912 1913 /** 1914 * sta_set_flags - Set station flags (AP only) 1915 * @priv: Private driver interface data 1916 * @addr: Station address 1917 * @total_flags: Bitmap of all WPA_STA_* flags currently set 1918 * @flags_or: Bitmap of WPA_STA_* flags to add 1919 * @flags_and: Bitmap of WPA_STA_* flags to us as a mask 1920 * Returns: 0 on success, -1 on failure 1921 */ 1922 int (*sta_set_flags)(void *priv, const u8 *addr, 1923 int total_flags, int flags_or, int flags_and); 1924 1925 /** 1926 * set_tx_queue_params - Set TX queue parameters 1927 * @priv: Private driver interface data 1928 * @queue: Queue number (0 = VO, 1 = VI, 2 = BE, 3 = BK) 1929 * @aifs: AIFS 1930 * @cw_min: cwMin 1931 * @cw_max: cwMax 1932 * @burst_time: Maximum length for bursting in 0.1 msec units 1933 */ 1934 int (*set_tx_queue_params)(void *priv, int queue, int aifs, int cw_min, 1935 int cw_max, int burst_time); 1936 1937 /** 1938 * if_add - Add a virtual interface 1939 * @priv: Private driver interface data 1940 * @type: Interface type 1941 * @ifname: Interface name for the new virtual interface 1942 * @addr: Local address to use for the interface or %NULL to use the 1943 * parent interface address 1944 * @bss_ctx: BSS context for %WPA_IF_AP_BSS interfaces 1945 * @drv_priv: Pointer for overwriting the driver context or %NULL if 1946 * not allowed (applies only to %WPA_IF_AP_BSS type) 1947 * @force_ifname: Buffer for returning an interface name that the 1948 * driver ended up using if it differs from the requested ifname 1949 * @if_addr: Buffer for returning the allocated interface address 1950 * (this may differ from the requested addr if the driver cannot 1951 * change interface address) 1952 * @bridge: Bridge interface to use or %NULL if no bridge configured 1953 * Returns: 0 on success, -1 on failure 1954 */ 1955 int (*if_add)(void *priv, enum wpa_driver_if_type type, 1956 const char *ifname, const u8 *addr, void *bss_ctx, 1957 void **drv_priv, char *force_ifname, u8 *if_addr, 1958 const char *bridge); 1959 1960 /** 1961 * if_remove - Remove a virtual interface 1962 * @priv: Private driver interface data 1963 * @type: Interface type 1964 * @ifname: Interface name of the virtual interface to be removed 1965 * Returns: 0 on success, -1 on failure 1966 */ 1967 int (*if_remove)(void *priv, enum wpa_driver_if_type type, 1968 const char *ifname); 1969 1970 /** 1971 * set_sta_vlan - Bind a station into a specific interface (AP only) 1972 * @priv: Private driver interface data 1973 * @ifname: Interface (main or virtual BSS or VLAN) 1974 * @addr: MAC address of the associated station 1975 * @vlan_id: VLAN ID 1976 * Returns: 0 on success, -1 on failure 1977 * 1978 * This function is used to bind a station to a specific virtual 1979 * interface. It is only used if when virtual interfaces are supported, 1980 * e.g., to assign stations to different VLAN interfaces based on 1981 * information from a RADIUS server. This allows separate broadcast 1982 * domains to be used with a single BSS. 1983 */ 1984 int (*set_sta_vlan)(void *priv, const u8 *addr, const char *ifname, 1985 int vlan_id); 1986 1987 /** 1988 * commit - Optional commit changes handler (AP only) 1989 * @priv: driver private data 1990 * Returns: 0 on success, -1 on failure 1991 * 1992 * This optional handler function can be registered if the driver 1993 * interface implementation needs to commit changes (e.g., by setting 1994 * network interface up) at the end of initial configuration. If set, 1995 * this handler will be called after initial setup has been completed. 1996 */ 1997 int (*commit)(void *priv); 1998 1999 /** 2000 * send_ether - Send an ethernet packet (AP only) 2001 * @priv: private driver interface data 2002 * @dst: Destination MAC address 2003 * @src: Source MAC address 2004 * @proto: Ethertype 2005 * @data: EAPOL packet starting with IEEE 802.1X header 2006 * @data_len: Length of the EAPOL packet in octets 2007 * Returns: 0 on success, -1 on failure 2008 */ 2009 int (*send_ether)(void *priv, const u8 *dst, const u8 *src, u16 proto, 2010 const u8 *data, size_t data_len); 2011 2012 /** 2013 * set_radius_acl_auth - Notification of RADIUS ACL change 2014 * @priv: Private driver interface data 2015 * @mac: MAC address of the station 2016 * @accepted: Whether the station was accepted 2017 * @session_timeout: Session timeout for the station 2018 * Returns: 0 on success, -1 on failure 2019 */ 2020 int (*set_radius_acl_auth)(void *priv, const u8 *mac, int accepted, 2021 u32 session_timeout); 2022 2023 /** 2024 * set_radius_acl_expire - Notification of RADIUS ACL expiration 2025 * @priv: Private driver interface data 2026 * @mac: MAC address of the station 2027 * Returns: 0 on success, -1 on failure 2028 */ 2029 int (*set_radius_acl_expire)(void *priv, const u8 *mac); 2030 2031 /** 2032 * set_ap_wps_ie - Add WPS IE(s) into Beacon/Probe Response frames (AP) 2033 * @priv: Private driver interface data 2034 * @beacon: WPS IE(s) for Beacon frames or %NULL to remove extra IE(s) 2035 * @proberesp: WPS IE(s) for Probe Response frames or %NULL to remove 2036 * extra IE(s) 2037 * @assocresp: WPS IE(s) for (Re)Association Response frames or %NULL 2038 * to remove extra IE(s) 2039 * Returns: 0 on success, -1 on failure 2040 * 2041 * This is an optional function to add WPS IE in the kernel driver for 2042 * Beacon and Probe Response frames. This can be left undefined (set 2043 * to %NULL) if the driver uses the Beacon template from set_ap() 2044 * and does not process Probe Request frames. If the driver takes care 2045 * of (Re)Association frame processing, the assocresp buffer includes 2046 * WPS IE(s) that need to be added to (Re)Association Response frames 2047 * whenever a (Re)Association Request frame indicated use of WPS. 2048 * 2049 * This will also be used to add P2P IE(s) into Beacon/Probe Response 2050 * frames when operating as a GO. The driver is responsible for adding 2051 * timing related attributes (e.g., NoA) in addition to the IEs 2052 * included here by appending them after these buffers. This call is 2053 * also used to provide Probe Response IEs for P2P Listen state 2054 * operations for drivers that generate the Probe Response frames 2055 * internally. 2056 * 2057 * DEPRECATED - use set_ap() instead 2058 */ 2059 int (*set_ap_wps_ie)(void *priv, const struct wpabuf *beacon, 2060 const struct wpabuf *proberesp, 2061 const struct wpabuf *assocresp); 2062 2063 /** 2064 * set_supp_port - Set IEEE 802.1X Supplicant Port status 2065 * @priv: Private driver interface data 2066 * @authorized: Whether the port is authorized 2067 * Returns: 0 on success, -1 on failure 2068 */ 2069 int (*set_supp_port)(void *priv, int authorized); 2070 2071 /** 2072 * set_wds_sta - Bind a station into a 4-address WDS (AP only) 2073 * @priv: Private driver interface data 2074 * @addr: MAC address of the associated station 2075 * @aid: Association ID 2076 * @val: 1 = bind to 4-address WDS; 0 = unbind 2077 * @bridge_ifname: Bridge interface to use for the WDS station or %NULL 2078 * to indicate that bridge is not to be used 2079 * @ifname_wds: Buffer to return the interface name for the new WDS 2080 * station or %NULL to indicate name is not returned. 2081 * Returns: 0 on success, -1 on failure 2082 */ 2083 int (*set_wds_sta)(void *priv, const u8 *addr, int aid, int val, 2084 const char *bridge_ifname, char *ifname_wds); 2085 2086 /** 2087 * send_action - Transmit an Action frame 2088 * @priv: Private driver interface data 2089 * @freq: Frequency (in MHz) of the channel 2090 * @wait: Time to wait off-channel for a response (in ms), or zero 2091 * @dst: Destination MAC address (Address 1) 2092 * @src: Source MAC address (Address 2) 2093 * @bssid: BSSID (Address 3) 2094 * @data: Frame body 2095 * @data_len: data length in octets 2096 @ @no_cck: Whether CCK rates must not be used to transmit this frame 2097 * Returns: 0 on success, -1 on failure 2098 * 2099 * This command can be used to request the driver to transmit an action 2100 * frame to the specified destination. 2101 * 2102 * If the %WPA_DRIVER_FLAGS_OFFCHANNEL_TX flag is set, the frame will 2103 * be transmitted on the given channel and the device will wait for a 2104 * response on that channel for the given wait time. 2105 * 2106 * If the flag is not set, the wait time will be ignored. In this case, 2107 * if a remain-on-channel duration is in progress, the frame must be 2108 * transmitted on that channel; alternatively the frame may be sent on 2109 * the current operational channel (if in associated state in station 2110 * mode or while operating as an AP.) 2111 */ 2112 int (*send_action)(void *priv, unsigned int freq, unsigned int wait, 2113 const u8 *dst, const u8 *src, const u8 *bssid, 2114 const u8 *data, size_t data_len, int no_cck); 2115 2116 /** 2117 * send_action_cancel_wait - Cancel action frame TX wait 2118 * @priv: Private driver interface data 2119 * 2120 * This command cancels the wait time associated with sending an action 2121 * frame. It is only available when %WPA_DRIVER_FLAGS_OFFCHANNEL_TX is 2122 * set in the driver flags. 2123 */ 2124 void (*send_action_cancel_wait)(void *priv); 2125 2126 /** 2127 * remain_on_channel - Remain awake on a channel 2128 * @priv: Private driver interface data 2129 * @freq: Frequency (in MHz) of the channel 2130 * @duration: Duration in milliseconds 2131 * Returns: 0 on success, -1 on failure 2132 * 2133 * This command is used to request the driver to remain awake on the 2134 * specified channel for the specified duration and report received 2135 * Action frames with EVENT_RX_ACTION events. Optionally, received 2136 * Probe Request frames may also be requested to be reported by calling 2137 * probe_req_report(). These will be reported with EVENT_RX_PROBE_REQ. 2138 * 2139 * The driver may not be at the requested channel when this function 2140 * returns, i.e., the return code is only indicating whether the 2141 * request was accepted. The caller will need to wait until the 2142 * EVENT_REMAIN_ON_CHANNEL event indicates that the driver has 2143 * completed the channel change. This may take some time due to other 2144 * need for the radio and the caller should be prepared to timing out 2145 * its wait since there are no guarantees on when this request can be 2146 * executed. 2147 */ 2148 int (*remain_on_channel)(void *priv, unsigned int freq, 2149 unsigned int duration); 2150 2151 /** 2152 * cancel_remain_on_channel - Cancel remain-on-channel operation 2153 * @priv: Private driver interface data 2154 * 2155 * This command can be used to cancel a remain-on-channel operation 2156 * before its originally requested duration has passed. This could be 2157 * used, e.g., when remain_on_channel() is used to request extra time 2158 * to receive a response to an Action frame and the response is 2159 * received when there is still unneeded time remaining on the 2160 * remain-on-channel operation. 2161 */ 2162 int (*cancel_remain_on_channel)(void *priv); 2163 2164 /** 2165 * probe_req_report - Request Probe Request frames to be indicated 2166 * @priv: Private driver interface data 2167 * @report: Whether to report received Probe Request frames 2168 * Returns: 0 on success, -1 on failure (or if not supported) 2169 * 2170 * This command can be used to request the driver to indicate when 2171 * Probe Request frames are received with EVENT_RX_PROBE_REQ events. 2172 * Since this operation may require extra resources, e.g., due to less 2173 * optimal hardware/firmware RX filtering, many drivers may disable 2174 * Probe Request reporting at least in station mode. This command is 2175 * used to notify the driver when the Probe Request frames need to be 2176 * reported, e.g., during remain-on-channel operations. 2177 */ 2178 int (*probe_req_report)(void *priv, int report); 2179 2180 /** 2181 * deinit_ap - Deinitialize AP mode 2182 * @priv: Private driver interface data 2183 * Returns: 0 on success, -1 on failure (or if not supported) 2184 * 2185 * This optional function can be used to disable AP mode related 2186 * configuration. If the interface was not dynamically added, 2187 * change the driver mode to station mode to allow normal station 2188 * operations like scanning to be completed. 2189 */ 2190 int (*deinit_ap)(void *priv); 2191 2192 /** 2193 * deinit_p2p_cli - Deinitialize P2P client mode 2194 * @priv: Private driver interface data 2195 * Returns: 0 on success, -1 on failure (or if not supported) 2196 * 2197 * This optional function can be used to disable P2P client mode. If the 2198 * interface was not dynamically added, change the interface type back 2199 * to station mode. 2200 */ 2201 int (*deinit_p2p_cli)(void *priv); 2202 2203 /** 2204 * suspend - Notification on system suspend/hibernate event 2205 * @priv: Private driver interface data 2206 */ 2207 void (*suspend)(void *priv); 2208 2209 /** 2210 * resume - Notification on system resume/thaw event 2211 * @priv: Private driver interface data 2212 */ 2213 void (*resume)(void *priv); 2214 2215 /** 2216 * signal_monitor - Set signal monitoring parameters 2217 * @priv: Private driver interface data 2218 * @threshold: Threshold value for signal change events; 0 = disabled 2219 * @hysteresis: Minimum change in signal strength before indicating a 2220 * new event 2221 * Returns: 0 on success, -1 on failure (or if not supported) 2222 * 2223 * This function can be used to configure monitoring of signal strength 2224 * with the current AP. Whenever signal strength drops below the 2225 * %threshold value or increases above it, EVENT_SIGNAL_CHANGE event 2226 * should be generated assuming the signal strength has changed at 2227 * least %hysteresis from the previously indicated signal change event. 2228 */ 2229 int (*signal_monitor)(void *priv, int threshold, int hysteresis); 2230 2231 /** 2232 * send_frame - Send IEEE 802.11 frame (testing use only) 2233 * @priv: Private driver interface data 2234 * @data: IEEE 802.11 frame with IEEE 802.11 header 2235 * @data_len: Size of the frame 2236 * @encrypt: Whether to encrypt the frame (if keys are set) 2237 * Returns: 0 on success, -1 on failure 2238 * 2239 * This function is only used for debugging purposes and is not 2240 * required to be implemented for normal operations. 2241 */ 2242 int (*send_frame)(void *priv, const u8 *data, size_t data_len, 2243 int encrypt); 2244 2245 /** 2246 * shared_freq - Get operating frequency of shared interface(s) 2247 * @priv: Private driver interface data 2248 * Returns: Operating frequency in MHz, 0 if no shared operation in 2249 * use, or -1 on failure 2250 * 2251 * This command can be used to request the current operating frequency 2252 * of any virtual interface that shares the same radio to provide 2253 * information for channel selection for other virtual interfaces. 2254 */ 2255 int (*shared_freq)(void *priv); 2256 2257 /** 2258 * get_noa - Get current Notice of Absence attribute payload 2259 * @priv: Private driver interface data 2260 * @buf: Buffer for returning NoA 2261 * @buf_len: Buffer length in octets 2262 * Returns: Number of octets used in buf, 0 to indicate no NoA is being 2263 * advertized, or -1 on failure 2264 * 2265 * This function is used to fetch the current Notice of Absence 2266 * attribute value from GO. 2267 */ 2268 int (*get_noa)(void *priv, u8 *buf, size_t buf_len); 2269 2270 /** 2271 * set_noa - Set Notice of Absence parameters for GO (testing) 2272 * @priv: Private driver interface data 2273 * @count: Count 2274 * @start: Start time in ms from next TBTT 2275 * @duration: Duration in ms 2276 * Returns: 0 on success or -1 on failure 2277 * 2278 * This function is used to set Notice of Absence parameters for GO. It 2279 * is used only for testing. To disable NoA, all parameters are set to 2280 * 0. 2281 */ 2282 int (*set_noa)(void *priv, u8 count, int start, int duration); 2283 2284 /** 2285 * set_p2p_powersave - Set P2P power save options 2286 * @priv: Private driver interface data 2287 * @legacy_ps: 0 = disable, 1 = enable, 2 = maximum PS, -1 = no change 2288 * @opp_ps: 0 = disable, 1 = enable, -1 = no change 2289 * @ctwindow: 0.. = change (msec), -1 = no change 2290 * Returns: 0 on success or -1 on failure 2291 */ 2292 int (*set_p2p_powersave)(void *priv, int legacy_ps, int opp_ps, 2293 int ctwindow); 2294 2295 /** 2296 * ampdu - Enable/disable aggregation 2297 * @priv: Private driver interface data 2298 * @ampdu: 1/0 = enable/disable A-MPDU aggregation 2299 * Returns: 0 on success or -1 on failure 2300 */ 2301 int (*ampdu)(void *priv, int ampdu); 2302 2303 /** 2304 * get_radio_name - Get physical radio name for the device 2305 * @priv: Private driver interface data 2306 * Returns: Radio name or %NULL if not known 2307 * 2308 * The returned data must not be modified by the caller. It is assumed 2309 * that any interface that has the same radio name as another is 2310 * sharing the same physical radio. This information can be used to 2311 * share scan results etc. information between the virtual interfaces 2312 * to speed up various operations. 2313 */ 2314 const char * (*get_radio_name)(void *priv); 2315 2316 /** 2317 * p2p_find - Start P2P Device Discovery 2318 * @priv: Private driver interface data 2319 * @timeout: Timeout for find operation in seconds or 0 for no timeout 2320 * @type: Device Discovery type (enum p2p_discovery_type) 2321 * Returns: 0 on success, -1 on failure 2322 * 2323 * This function is only used if the driver implements P2P management, 2324 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2325 * struct wpa_driver_capa. 2326 */ 2327 int (*p2p_find)(void *priv, unsigned int timeout, int type); 2328 2329 /** 2330 * p2p_stop_find - Stop P2P Device Discovery 2331 * @priv: Private driver interface data 2332 * Returns: 0 on success, -1 on failure 2333 * 2334 * This function is only used if the driver implements P2P management, 2335 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2336 * struct wpa_driver_capa. 2337 */ 2338 int (*p2p_stop_find)(void *priv); 2339 2340 /** 2341 * p2p_listen - Start P2P Listen state for specified duration 2342 * @priv: Private driver interface data 2343 * @timeout: Listen state duration in milliseconds 2344 * Returns: 0 on success, -1 on failure 2345 * 2346 * This function can be used to request the P2P module to keep the 2347 * device discoverable on the listen channel for an extended set of 2348 * time. At least in its current form, this is mainly used for testing 2349 * purposes and may not be of much use for normal P2P operations. 2350 * 2351 * This function is only used if the driver implements P2P management, 2352 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2353 * struct wpa_driver_capa. 2354 */ 2355 int (*p2p_listen)(void *priv, unsigned int timeout); 2356 2357 /** 2358 * p2p_connect - Start P2P group formation (GO negotiation) 2359 * @priv: Private driver interface data 2360 * @peer_addr: MAC address of the peer P2P client 2361 * @wps_method: enum p2p_wps_method value indicating config method 2362 * @go_intent: Local GO intent value (1..15) 2363 * @own_interface_addr: Intended interface address to use with the 2364 * group 2365 * @force_freq: The only allowed channel frequency in MHz or 0 2366 * @persistent_group: Whether to create persistent group 2367 * Returns: 0 on success, -1 on failure 2368 * 2369 * This function is only used if the driver implements P2P management, 2370 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2371 * struct wpa_driver_capa. 2372 */ 2373 int (*p2p_connect)(void *priv, const u8 *peer_addr, int wps_method, 2374 int go_intent, const u8 *own_interface_addr, 2375 unsigned int force_freq, int persistent_group); 2376 2377 /** 2378 * wps_success_cb - Report successfully completed WPS provisioning 2379 * @priv: Private driver interface data 2380 * @peer_addr: Peer address 2381 * Returns: 0 on success, -1 on failure 2382 * 2383 * This function is used to report successfully completed WPS 2384 * provisioning during group formation in both GO/Registrar and 2385 * client/Enrollee roles. 2386 * 2387 * This function is only used if the driver implements P2P management, 2388 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2389 * struct wpa_driver_capa. 2390 */ 2391 int (*wps_success_cb)(void *priv, const u8 *peer_addr); 2392 2393 /** 2394 * p2p_group_formation_failed - Report failed WPS provisioning 2395 * @priv: Private driver interface data 2396 * Returns: 0 on success, -1 on failure 2397 * 2398 * This function is used to report failed group formation. This can 2399 * happen either due to failed WPS provisioning or due to 15 second 2400 * timeout during the provisioning phase. 2401 * 2402 * This function is only used if the driver implements P2P management, 2403 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2404 * struct wpa_driver_capa. 2405 */ 2406 int (*p2p_group_formation_failed)(void *priv); 2407 2408 /** 2409 * p2p_set_params - Set P2P parameters 2410 * @priv: Private driver interface data 2411 * @params: P2P parameters 2412 * Returns: 0 on success, -1 on failure 2413 * 2414 * This function is only used if the driver implements P2P management, 2415 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2416 * struct wpa_driver_capa. 2417 */ 2418 int (*p2p_set_params)(void *priv, const struct p2p_params *params); 2419 2420 /** 2421 * p2p_prov_disc_req - Send Provision Discovery Request 2422 * @priv: Private driver interface data 2423 * @peer_addr: MAC address of the peer P2P client 2424 * @config_methods: WPS Config Methods value (only one bit set) 2425 * Returns: 0 on success, -1 on failure 2426 * 2427 * This function can be used to request a discovered P2P peer to 2428 * display a PIN (config_methods = WPS_CONFIG_DISPLAY) or be prepared 2429 * to enter a PIN from us (config_methods = WPS_CONFIG_KEYPAD). The 2430 * Provision Discovery Request frame is transmitted once immediately 2431 * and if no response is received, the frame will be sent again 2432 * whenever the target device is discovered during device dsicovery 2433 * (start with a p2p_find() call). Response from the peer is indicated 2434 * with the EVENT_P2P_PROV_DISC_RESPONSE event. 2435 * 2436 * This function is only used if the driver implements P2P management, 2437 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2438 * struct wpa_driver_capa. 2439 */ 2440 int (*p2p_prov_disc_req)(void *priv, const u8 *peer_addr, 2441 u16 config_methods, int join); 2442 2443 /** 2444 * p2p_sd_request - Schedule a service discovery query 2445 * @priv: Private driver interface data 2446 * @dst: Destination peer or %NULL to apply for all peers 2447 * @tlvs: P2P Service Query TLV(s) 2448 * Returns: Reference to the query or 0 on failure 2449 * 2450 * Response to the query is indicated with the 2451 * EVENT_P2P_SD_RESPONSE driver event. 2452 * 2453 * This function is only used if the driver implements P2P management, 2454 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2455 * struct wpa_driver_capa. 2456 */ 2457 u64 (*p2p_sd_request)(void *priv, const u8 *dst, 2458 const struct wpabuf *tlvs); 2459 2460 /** 2461 * p2p_sd_cancel_request - Cancel a pending service discovery query 2462 * @priv: Private driver interface data 2463 * @req: Query reference from p2p_sd_request() 2464 * Returns: 0 on success, -1 on failure 2465 * 2466 * This function is only used if the driver implements P2P management, 2467 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2468 * struct wpa_driver_capa. 2469 */ 2470 int (*p2p_sd_cancel_request)(void *priv, u64 req); 2471 2472 /** 2473 * p2p_sd_response - Send response to a service discovery query 2474 * @priv: Private driver interface data 2475 * @freq: Frequency from EVENT_P2P_SD_REQUEST event 2476 * @dst: Destination address from EVENT_P2P_SD_REQUEST event 2477 * @dialog_token: Dialog token from EVENT_P2P_SD_REQUEST event 2478 * @resp_tlvs: P2P Service Response TLV(s) 2479 * Returns: 0 on success, -1 on failure 2480 * 2481 * This function is called as a response to the request indicated with 2482 * the EVENT_P2P_SD_REQUEST driver event. 2483 * 2484 * This function is only used if the driver implements P2P management, 2485 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2486 * struct wpa_driver_capa. 2487 */ 2488 int (*p2p_sd_response)(void *priv, int freq, const u8 *dst, 2489 u8 dialog_token, 2490 const struct wpabuf *resp_tlvs); 2491 2492 /** 2493 * p2p_service_update - Indicate a change in local services 2494 * @priv: Private driver interface data 2495 * Returns: 0 on success, -1 on failure 2496 * 2497 * This function needs to be called whenever there is a change in 2498 * availability of the local services. This will increment the 2499 * Service Update Indicator value which will be used in SD Request and 2500 * Response frames. 2501 * 2502 * This function is only used if the driver implements P2P management, 2503 * i.e., if it sets WPA_DRIVER_FLAGS_P2P_MGMT in 2504 * struct wpa_driver_capa. 2505 */ 2506 int (*p2p_service_update)(void *priv); 2507 2508 /** 2509 * p2p_reject - Reject peer device (explicitly block connections) 2510 * @priv: Private driver interface data 2511 * @addr: MAC address of the peer 2512 * Returns: 0 on success, -1 on failure 2513 */ 2514 int (*p2p_reject)(void *priv, const u8 *addr); 2515 2516 /** 2517 * p2p_invite - Invite a P2P Device into a group 2518 * @priv: Private driver interface data 2519 * @peer: Device Address of the peer P2P Device 2520 * @role: Local role in the group 2521 * @bssid: Group BSSID or %NULL if not known 2522 * @ssid: Group SSID 2523 * @ssid_len: Length of ssid in octets 2524 * @go_dev_addr: Forced GO Device Address or %NULL if none 2525 * @persistent_group: Whether this is to reinvoke a persistent group 2526 * Returns: 0 on success, -1 on failure 2527 */ 2528 int (*p2p_invite)(void *priv, const u8 *peer, int role, 2529 const u8 *bssid, const u8 *ssid, size_t ssid_len, 2530 const u8 *go_dev_addr, int persistent_group); 2531 2532 /** 2533 * send_tdls_mgmt - for sending TDLS management packets 2534 * @priv: private driver interface data 2535 * @dst: Destination (peer) MAC address 2536 * @action_code: TDLS action code for the mssage 2537 * @dialog_token: Dialog Token to use in the message (if needed) 2538 * @status_code: Status Code or Reason Code to use (if needed) 2539 * @buf: TDLS IEs to add to the message 2540 * @len: Length of buf in octets 2541 * Returns: 0 on success, negative (<0) on failure 2542 * 2543 * This optional function can be used to send packet to driver which is 2544 * responsible for receiving and sending all TDLS packets. 2545 */ 2546 int (*send_tdls_mgmt)(void *priv, const u8 *dst, u8 action_code, 2547 u8 dialog_token, u16 status_code, 2548 const u8 *buf, size_t len); 2549 2550 /** 2551 * tdls_oper - Ask the driver to perform high-level TDLS operations 2552 * @priv: Private driver interface data 2553 * @oper: TDLS high-level operation. See %enum tdls_oper 2554 * @peer: Destination (peer) MAC address 2555 * Returns: 0 on success, negative (<0) on failure 2556 * 2557 * This optional function can be used to send high-level TDLS commands 2558 * to the driver. 2559 */ 2560 int (*tdls_oper)(void *priv, enum tdls_oper oper, const u8 *peer); 2561 2562 /** 2563 * wnm_oper - Notify driver of the WNM frame reception 2564 * @priv: Private driver interface data 2565 * @oper: WNM operation. See %enum wnm_oper 2566 * @peer: Destination (peer) MAC address 2567 * @buf: Buffer for the driver to fill in (for getting IE) 2568 * @buf_len: Return the len of buf 2569 * Returns: 0 on success, negative (<0) on failure 2570 */ 2571 int (*wnm_oper)(void *priv, enum wnm_oper oper, const u8 *peer, 2572 u8 *buf, u16 *buf_len); 2573 2574 /** 2575 * signal_poll - Get current connection information 2576 * @priv: Private driver interface data 2577 * @signal_info: Connection info structure 2578 */ 2579 int (*signal_poll)(void *priv, struct wpa_signal_info *signal_info); 2580 2581 /** 2582 * set_authmode - Set authentication algorithm(s) for static WEP 2583 * @priv: Private driver interface data 2584 * @authmode: 1=Open System, 2=Shared Key, 3=both 2585 * Returns: 0 on success, -1 on failure 2586 * 2587 * This function can be used to set authentication algorithms for AP 2588 * mode when static WEP is used. If the driver uses user space MLME/SME 2589 * implementation, there is no need to implement this function. 2590 * 2591 * DEPRECATED - use set_ap() instead 2592 */ 2593 int (*set_authmode)(void *priv, int authmode); 2594#ifdef ANDROID 2595 /** 2596 * driver_cmd - execute driver-specific command 2597 * @priv: private driver interface data 2598 * @cmd: command to execute 2599 * @buf: return buffer 2600 * @buf_len: buffer length 2601 * 2602 * Returns: 0 on success, -1 on failure 2603 */ 2604 int (*driver_cmd)(void *priv, char *cmd, char *buf, size_t buf_len); 2605#endif 2606 /** 2607 * set_rekey_info - Set rekey information 2608 * @priv: Private driver interface data 2609 * @kek: Current KEK 2610 * @kck: Current KCK 2611 * @replay_ctr: Current EAPOL-Key Replay Counter 2612 * 2613 * This optional function can be used to provide information for the 2614 * driver/firmware to process EAPOL-Key frames in Group Key Handshake 2615 * while the host (including wpa_supplicant) is sleeping. 2616 */ 2617 void (*set_rekey_info)(void *priv, const u8 *kek, const u8 *kck, 2618 const u8 *replay_ctr); 2619 2620 /** 2621 * sta_assoc - Station association indication 2622 * @priv: Private driver interface data 2623 * @own_addr: Source address and BSSID for association frame 2624 * @addr: MAC address of the station to associate 2625 * @reassoc: flag to indicate re-association 2626 * @status: association response status code 2627 * @ie: assoc response ie buffer 2628 * @len: ie buffer length 2629 * Returns: 0 on success, -1 on failure 2630 * 2631 * This function indicates the driver to send (Re)Association 2632 * Response frame to the station. 2633 */ 2634 int (*sta_assoc)(void *priv, const u8 *own_addr, const u8 *addr, 2635 int reassoc, u16 status, const u8 *ie, size_t len); 2636 2637 /** 2638 * sta_auth - Station authentication indication 2639 * @priv: Private driver interface data 2640 * @own_addr: Source address and BSSID for authentication frame 2641 * @addr: MAC address of the station to associate 2642 * @seq: authentication sequence number 2643 * @status: authentication response status code 2644 * @ie: authentication frame ie buffer 2645 * @len: ie buffer length 2646 * 2647 * This function indicates the driver to send Authentication frame 2648 * to the station. 2649 */ 2650 int (*sta_auth)(void *priv, const u8 *own_addr, const u8 *addr, 2651 u16 seq, u16 status, const u8 *ie, size_t len); 2652 2653 /** 2654 * add_tspec - Add traffic stream 2655 * @priv: Private driver interface data 2656 * @addr: MAC address of the station to associate 2657 * @tspec_ie: tspec ie buffer 2658 * @tspec_ielen: tspec ie length 2659 * Returns: 0 on success, -1 on failure 2660 * 2661 * This function adds the traffic steam for the station 2662 * and fills the medium_time in tspec_ie. 2663 */ 2664 int (*add_tspec)(void *priv, const u8 *addr, u8 *tspec_ie, 2665 size_t tspec_ielen); 2666 2667 /** 2668 * add_sta_node - Add a station node in the driver 2669 * @priv: Private driver interface data 2670 * @addr: MAC address of the station to add 2671 * @auth_alg: authentication algorithm used by the station 2672 * Returns: 0 on success, -1 on failure 2673 * 2674 * This function adds the station node in the driver, when 2675 * the station gets added by FT-over-DS. 2676 */ 2677 int (*add_sta_node)(void *priv, const u8 *addr, u16 auth_alg); 2678 2679 /** 2680 * sched_scan - Request the driver to initiate scheduled scan 2681 * @priv: Private driver interface data 2682 * @params: Scan parameters 2683 * @interval: Interval between scan cycles in milliseconds 2684 * Returns: 0 on success, -1 on failure 2685 * 2686 * This operation should be used for scheduled scan offload to 2687 * the hardware. Every time scan results are available, the 2688 * driver should report scan results event for wpa_supplicant 2689 * which will eventually request the results with 2690 * wpa_driver_get_scan_results2(). This operation is optional 2691 * and if not provided or if it returns -1, we fall back to 2692 * normal host-scheduled scans. 2693 */ 2694 int (*sched_scan)(void *priv, struct wpa_driver_scan_params *params, 2695 u32 interval); 2696 2697 /** 2698 * stop_sched_scan - Request the driver to stop a scheduled scan 2699 * @priv: Private driver interface data 2700 * Returns: 0 on success, -1 on failure 2701 * 2702 * This should cause the scheduled scan to be stopped and 2703 * results should stop being sent. Must be supported if 2704 * sched_scan is supported. 2705 */ 2706 int (*stop_sched_scan)(void *priv); 2707 2708 /** 2709 * poll_client - Probe (null data or such) the given station 2710 * @priv: Private driver interface data 2711 * @own_addr: MAC address of sending interface 2712 * @addr: MAC address of the station to probe 2713 * @qos: Indicates whether station is QoS station 2714 * 2715 * This function is used to verify whether an associated station is 2716 * still present. This function does not need to be implemented if the 2717 * driver provides such inactivity polling mechanism. 2718 */ 2719 void (*poll_client)(void *priv, const u8 *own_addr, 2720 const u8 *addr, int qos); 2721 2722 /** 2723 * radio_disable - Disable/enable radio 2724 * @priv: Private driver interface data 2725 * @disabled: 1=disable 0=enable radio 2726 * Returns: 0 on success, -1 on failure 2727 * 2728 * This optional command is for testing purposes. It can be used to 2729 * disable the radio on a testbed device to simulate out-of-radio-range 2730 * conditions. 2731 */ 2732 int (*radio_disable)(void *priv, int disabled); 2733 2734 /** 2735 * switch_channel - Announce channel switch and migrate the GO to the 2736 * given frequency 2737 * @priv: Private driver interface data 2738 * @freq: Frequency in MHz 2739 * Returns: 0 on success, -1 on failure 2740 * 2741 * This function is used to move the GO to the legacy STA channel to 2742 * avoid frequency conflict in single channel concurrency. 2743 */ 2744 int (*switch_channel)(void *priv, unsigned int freq); 2745 2746 /** 2747 * start_dfs_cac - Listen for radar interference on the channel 2748 * @priv: Private driver interface data 2749 * @freq: Frequency (in MHz) of the channel 2750 * Returns: 0 on success, -1 on failure 2751 */ 2752 int (*start_dfs_cac)(void *priv, int freq); 2753 2754 /** 2755 * stop_ap - Removes beacon from AP 2756 * @priv: Private driver interface data 2757 * Returns: 0 on success, -1 on failure (or if not supported) 2758 * 2759 * This optional function can be used to disable AP mode related 2760 * configuration. Unlike deinit_ap, it does not change to station 2761 * mode. 2762 */ 2763 int (*stop_ap)(void *priv); 2764 2765 /** 2766 * get_survey - Retrieve survey data 2767 * @priv: Private driver interface data 2768 * @freq: If set, survey data for the specified frequency is only 2769 * being requested. If not set, all survey data is requested. 2770 * Returns: 0 on success, -1 on failure 2771 * 2772 * Use this to retrieve: 2773 * 2774 * - the observed channel noise floor 2775 * - the amount of time we have spent on the channel 2776 * - the amount of time during which we have spent on the channel that 2777 * the radio has determined the medium is busy and we cannot 2778 * transmit 2779 * - the amount of time we have spent receiving data 2780 * - the amount of time we have spent transmitting data 2781 * 2782 * This data can be used for spectrum heuristics. One example is 2783 * Automatic Channel Selection (ACS). The channel survey data is 2784 * kept on a linked list on the channel data, one entry is added 2785 * for each survey. The min_nf of the channel is updated for each 2786 * survey. 2787 */ 2788 int (*get_survey)(void *priv, unsigned int freq); 2789 2790 /** 2791 * status - Get driver interface status information 2792 * @priv: Private driver interface data 2793 * @buf: Buffer for printing tou the status information 2794 * @buflen: Maximum length of the buffer 2795 * Returns: Length of written status information or -1 on failure 2796 */ 2797 int (*status)(void *priv, char *buf, size_t buflen); 2798}; 2799 2800 2801/** 2802 * enum wpa_event_type - Event type for wpa_supplicant_event() calls 2803 */ 2804enum wpa_event_type { 2805 /** 2806 * EVENT_ASSOC - Association completed 2807 * 2808 * This event needs to be delivered when the driver completes IEEE 2809 * 802.11 association or reassociation successfully. 2810 * wpa_driver_ops::get_bssid() is expected to provide the current BSSID 2811 * after this event has been generated. In addition, optional 2812 * EVENT_ASSOCINFO may be generated just before EVENT_ASSOC to provide 2813 * more information about the association. If the driver interface gets 2814 * both of these events at the same time, it can also include the 2815 * assoc_info data in EVENT_ASSOC call. 2816 */ 2817 EVENT_ASSOC, 2818 2819 /** 2820 * EVENT_DISASSOC - Association lost 2821 * 2822 * This event should be called when association is lost either due to 2823 * receiving deauthenticate or disassociate frame from the AP or when 2824 * sending either of these frames to the current AP. If the driver 2825 * supports separate deauthentication event, EVENT_DISASSOC should only 2826 * be used for disassociation and EVENT_DEAUTH for deauthentication. 2827 * In AP mode, union wpa_event_data::disassoc_info is required. 2828 */ 2829 EVENT_DISASSOC, 2830 2831 /** 2832 * EVENT_MICHAEL_MIC_FAILURE - Michael MIC (TKIP) detected 2833 * 2834 * This event must be delivered when a Michael MIC error is detected by 2835 * the local driver. Additional data for event processing is 2836 * provided with union wpa_event_data::michael_mic_failure. This 2837 * information is used to request new encyption key and to initiate 2838 * TKIP countermeasures if needed. 2839 */ 2840 EVENT_MICHAEL_MIC_FAILURE, 2841 2842 /** 2843 * EVENT_SCAN_RESULTS - Scan results available 2844 * 2845 * This event must be called whenever scan results are available to be 2846 * fetched with struct wpa_driver_ops::get_scan_results(). This event 2847 * is expected to be used some time after struct wpa_driver_ops::scan() 2848 * is called. If the driver provides an unsolicited event when the scan 2849 * has been completed, this event can be used to trigger 2850 * EVENT_SCAN_RESULTS call. If such event is not available from the 2851 * driver, the driver wrapper code is expected to use a registered 2852 * timeout to generate EVENT_SCAN_RESULTS call after the time that the 2853 * scan is expected to be completed. Optional information about 2854 * completed scan can be provided with union wpa_event_data::scan_info. 2855 */ 2856 EVENT_SCAN_RESULTS, 2857 2858 /** 2859 * EVENT_ASSOCINFO - Report optional extra information for association 2860 * 2861 * This event can be used to report extra association information for 2862 * EVENT_ASSOC processing. This extra information includes IEs from 2863 * association frames and Beacon/Probe Response frames in union 2864 * wpa_event_data::assoc_info. EVENT_ASSOCINFO must be send just before 2865 * EVENT_ASSOC. Alternatively, the driver interface can include 2866 * assoc_info data in the EVENT_ASSOC call if it has all the 2867 * information available at the same point. 2868 */ 2869 EVENT_ASSOCINFO, 2870 2871 /** 2872 * EVENT_INTERFACE_STATUS - Report interface status changes 2873 * 2874 * This optional event can be used to report changes in interface 2875 * status (interface added/removed) using union 2876 * wpa_event_data::interface_status. This can be used to trigger 2877 * wpa_supplicant to stop and re-start processing for the interface, 2878 * e.g., when a cardbus card is ejected/inserted. 2879 */ 2880 EVENT_INTERFACE_STATUS, 2881 2882 /** 2883 * EVENT_PMKID_CANDIDATE - Report a candidate AP for pre-authentication 2884 * 2885 * This event can be used to inform wpa_supplicant about candidates for 2886 * RSN (WPA2) pre-authentication. If wpa_supplicant is not responsible 2887 * for scan request (ap_scan=2 mode), this event is required for 2888 * pre-authentication. If wpa_supplicant is performing scan request 2889 * (ap_scan=1), this event is optional since scan results can be used 2890 * to add pre-authentication candidates. union 2891 * wpa_event_data::pmkid_candidate is used to report the BSSID of the 2892 * candidate and priority of the candidate, e.g., based on the signal 2893 * strength, in order to try to pre-authenticate first with candidates 2894 * that are most likely targets for re-association. 2895 * 2896 * EVENT_PMKID_CANDIDATE can be called whenever the driver has updates 2897 * on the candidate list. In addition, it can be called for the current 2898 * AP and APs that have existing PMKSA cache entries. wpa_supplicant 2899 * will automatically skip pre-authentication in cases where a valid 2900 * PMKSA exists. When more than one candidate exists, this event should 2901 * be generated once for each candidate. 2902 * 2903 * Driver will be notified about successful pre-authentication with 2904 * struct wpa_driver_ops::add_pmkid() calls. 2905 */ 2906 EVENT_PMKID_CANDIDATE, 2907 2908 /** 2909 * EVENT_STKSTART - Request STK handshake (MLME-STKSTART.request) 2910 * 2911 * This event can be used to inform wpa_supplicant about desire to set 2912 * up secure direct link connection between two stations as defined in 2913 * IEEE 802.11e with a new PeerKey mechanism that replaced the original 2914 * STAKey negotiation. The caller will need to set peer address for the 2915 * event. 2916 */ 2917 EVENT_STKSTART, 2918 2919 /** 2920 * EVENT_TDLS - Request TDLS operation 2921 * 2922 * This event can be used to request a TDLS operation to be performed. 2923 */ 2924 EVENT_TDLS, 2925 2926 /** 2927 * EVENT_FT_RESPONSE - Report FT (IEEE 802.11r) response IEs 2928 * 2929 * The driver is expected to report the received FT IEs from 2930 * FT authentication sequence from the AP. The FT IEs are included in 2931 * the extra information in union wpa_event_data::ft_ies. 2932 */ 2933 EVENT_FT_RESPONSE, 2934 2935 /** 2936 * EVENT_IBSS_RSN_START - Request RSN authentication in IBSS 2937 * 2938 * The driver can use this event to inform wpa_supplicant about a STA 2939 * in an IBSS with which protected frames could be exchanged. This 2940 * event starts RSN authentication with the other STA to authenticate 2941 * the STA and set up encryption keys with it. 2942 */ 2943 EVENT_IBSS_RSN_START, 2944 2945 /** 2946 * EVENT_AUTH - Authentication result 2947 * 2948 * This event should be called when authentication attempt has been 2949 * completed. This is only used if the driver supports separate 2950 * authentication step (struct wpa_driver_ops::authenticate). 2951 * Information about authentication result is included in 2952 * union wpa_event_data::auth. 2953 */ 2954 EVENT_AUTH, 2955 2956 /** 2957 * EVENT_DEAUTH - Authentication lost 2958 * 2959 * This event should be called when authentication is lost either due 2960 * to receiving deauthenticate frame from the AP or when sending that 2961 * frame to the current AP. 2962 * In AP mode, union wpa_event_data::deauth_info is required. 2963 */ 2964 EVENT_DEAUTH, 2965 2966 /** 2967 * EVENT_ASSOC_REJECT - Association rejected 2968 * 2969 * This event should be called when (re)association attempt has been 2970 * rejected by the AP. Information about the association response is 2971 * included in union wpa_event_data::assoc_reject. 2972 */ 2973 EVENT_ASSOC_REJECT, 2974 2975 /** 2976 * EVENT_AUTH_TIMED_OUT - Authentication timed out 2977 */ 2978 EVENT_AUTH_TIMED_OUT, 2979 2980 /** 2981 * EVENT_ASSOC_TIMED_OUT - Association timed out 2982 */ 2983 EVENT_ASSOC_TIMED_OUT, 2984 2985 /** 2986 * EVENT_FT_RRB_RX - FT (IEEE 802.11r) RRB frame received 2987 */ 2988 EVENT_FT_RRB_RX, 2989 2990 /** 2991 * EVENT_WPS_BUTTON_PUSHED - Report hardware push button press for WPS 2992 */ 2993 EVENT_WPS_BUTTON_PUSHED, 2994 2995 /** 2996 * EVENT_TX_STATUS - Report TX status 2997 */ 2998 EVENT_TX_STATUS, 2999 3000 /** 3001 * EVENT_RX_FROM_UNKNOWN - Report RX from unknown STA 3002 */ 3003 EVENT_RX_FROM_UNKNOWN, 3004 3005 /** 3006 * EVENT_RX_MGMT - Report RX of a management frame 3007 */ 3008 EVENT_RX_MGMT, 3009 3010 /** 3011 * EVENT_RX_ACTION - Action frame received 3012 * 3013 * This event is used to indicate when an Action frame has been 3014 * received. Information about the received frame is included in 3015 * union wpa_event_data::rx_action. 3016 */ 3017 EVENT_RX_ACTION, 3018 3019 /** 3020 * EVENT_REMAIN_ON_CHANNEL - Remain-on-channel duration started 3021 * 3022 * This event is used to indicate when the driver has started the 3023 * requested remain-on-channel duration. Information about the 3024 * operation is included in union wpa_event_data::remain_on_channel. 3025 */ 3026 EVENT_REMAIN_ON_CHANNEL, 3027 3028 /** 3029 * EVENT_CANCEL_REMAIN_ON_CHANNEL - Remain-on-channel timed out 3030 * 3031 * This event is used to indicate when the driver has completed 3032 * remain-on-channel duration, i.e., may noot be available on the 3033 * requested channel anymore. Information about the 3034 * operation is included in union wpa_event_data::remain_on_channel. 3035 */ 3036 EVENT_CANCEL_REMAIN_ON_CHANNEL, 3037 3038 /** 3039 * EVENT_MLME_RX - Report reception of frame for MLME (test use only) 3040 * 3041 * This event is used only by driver_test.c and userspace MLME. 3042 */ 3043 EVENT_MLME_RX, 3044 3045 /** 3046 * EVENT_RX_PROBE_REQ - Indicate received Probe Request frame 3047 * 3048 * This event is used to indicate when a Probe Request frame has been 3049 * received. Information about the received frame is included in 3050 * union wpa_event_data::rx_probe_req. The driver is required to report 3051 * these events only after successfully completed probe_req_report() 3052 * commands to request the events (i.e., report parameter is non-zero) 3053 * in station mode. In AP mode, Probe Request frames should always be 3054 * reported. 3055 */ 3056 EVENT_RX_PROBE_REQ, 3057 3058 /** 3059 * EVENT_NEW_STA - New wired device noticed 3060 * 3061 * This event is used to indicate that a new device has been detected 3062 * in a network that does not use association-like functionality (i.e., 3063 * mainly wired Ethernet). This can be used to start EAPOL 3064 * authenticator when receiving a frame from a device. The address of 3065 * the device is included in union wpa_event_data::new_sta. 3066 */ 3067 EVENT_NEW_STA, 3068 3069 /** 3070 * EVENT_EAPOL_RX - Report received EAPOL frame 3071 * 3072 * When in AP mode with hostapd, this event is required to be used to 3073 * deliver the receive EAPOL frames from the driver. With 3074 * %wpa_supplicant, this event is used only if the send_eapol() handler 3075 * is used to override the use of l2_packet for EAPOL frame TX. 3076 */ 3077 EVENT_EAPOL_RX, 3078 3079 /** 3080 * EVENT_SIGNAL_CHANGE - Indicate change in signal strength 3081 * 3082 * This event is used to indicate changes in the signal strength 3083 * observed in frames received from the current AP if signal strength 3084 * monitoring has been enabled with signal_monitor(). 3085 */ 3086 EVENT_SIGNAL_CHANGE, 3087 3088 /** 3089 * EVENT_INTERFACE_ENABLED - Notify that interface was enabled 3090 * 3091 * This event is used to indicate that the interface was enabled after 3092 * having been previously disabled, e.g., due to rfkill. 3093 */ 3094 EVENT_INTERFACE_ENABLED, 3095 3096 /** 3097 * EVENT_INTERFACE_DISABLED - Notify that interface was disabled 3098 * 3099 * This event is used to indicate that the interface was disabled, 3100 * e.g., due to rfkill. 3101 */ 3102 EVENT_INTERFACE_DISABLED, 3103 3104 /** 3105 * EVENT_CHANNEL_LIST_CHANGED - Channel list changed 3106 * 3107 * This event is used to indicate that the channel list has changed, 3108 * e.g., because of a regulatory domain change triggered by scan 3109 * results including an AP advertising a country code. 3110 */ 3111 EVENT_CHANNEL_LIST_CHANGED, 3112 3113 /** 3114 * EVENT_INTERFACE_UNAVAILABLE - Notify that interface is unavailable 3115 * 3116 * This event is used to indicate that the driver cannot maintain this 3117 * interface in its operation mode anymore. The most likely use for 3118 * this is to indicate that AP mode operation is not available due to 3119 * operating channel would need to be changed to a DFS channel when 3120 * the driver does not support radar detection and another virtual 3121 * interfaces caused the operating channel to change. Other similar 3122 * resource conflicts could also trigger this for station mode 3123 * interfaces. 3124 */ 3125 EVENT_INTERFACE_UNAVAILABLE, 3126 3127 /** 3128 * EVENT_BEST_CHANNEL 3129 * 3130 * Driver generates this event whenever it detects a better channel 3131 * (e.g., based on RSSI or channel use). This information can be used 3132 * to improve channel selection for a new AP/P2P group. 3133 */ 3134 EVENT_BEST_CHANNEL, 3135 3136 /** 3137 * EVENT_UNPROT_DEAUTH - Unprotected Deauthentication frame received 3138 * 3139 * This event should be called when a Deauthentication frame is dropped 3140 * due to it not being protected (MFP/IEEE 802.11w). 3141 * union wpa_event_data::unprot_deauth is required to provide more 3142 * details of the frame. 3143 */ 3144 EVENT_UNPROT_DEAUTH, 3145 3146 /** 3147 * EVENT_UNPROT_DISASSOC - Unprotected Disassociation frame received 3148 * 3149 * This event should be called when a Disassociation frame is dropped 3150 * due to it not being protected (MFP/IEEE 802.11w). 3151 * union wpa_event_data::unprot_disassoc is required to provide more 3152 * details of the frame. 3153 */ 3154 EVENT_UNPROT_DISASSOC, 3155 3156 /** 3157 * EVENT_STATION_LOW_ACK 3158 * 3159 * Driver generates this event whenever it detected that a particular 3160 * station was lost. Detection can be through massive transmission 3161 * failures for example. 3162 */ 3163 EVENT_STATION_LOW_ACK, 3164 3165 /** 3166 * EVENT_P2P_DEV_FOUND - Report a discovered P2P device 3167 * 3168 * This event is used only if the driver implements P2P management 3169 * internally. Event data is stored in 3170 * union wpa_event_data::p2p_dev_found. 3171 */ 3172 EVENT_P2P_DEV_FOUND, 3173 3174 /** 3175 * EVENT_P2P_GO_NEG_REQ_RX - Report reception of GO Negotiation Request 3176 * 3177 * This event is used only if the driver implements P2P management 3178 * internally. Event data is stored in 3179 * union wpa_event_data::p2p_go_neg_req_rx. 3180 */ 3181 EVENT_P2P_GO_NEG_REQ_RX, 3182 3183 /** 3184 * EVENT_P2P_GO_NEG_COMPLETED - Report completion of GO Negotiation 3185 * 3186 * This event is used only if the driver implements P2P management 3187 * internally. Event data is stored in 3188 * union wpa_event_data::p2p_go_neg_completed. 3189 */ 3190 EVENT_P2P_GO_NEG_COMPLETED, 3191 3192 EVENT_P2P_PROV_DISC_REQUEST, 3193 EVENT_P2P_PROV_DISC_RESPONSE, 3194 EVENT_P2P_SD_REQUEST, 3195 EVENT_P2P_SD_RESPONSE, 3196 3197 /** 3198 * EVENT_IBSS_PEER_LOST - IBSS peer not reachable anymore 3199 */ 3200 EVENT_IBSS_PEER_LOST, 3201 3202 /** 3203 * EVENT_DRIVER_GTK_REKEY - Device/driver did GTK rekey 3204 * 3205 * This event carries the new replay counter to notify wpa_supplicant 3206 * of the current EAPOL-Key Replay Counter in case the driver/firmware 3207 * completed Group Key Handshake while the host (including 3208 * wpa_supplicant was sleeping). 3209 */ 3210 EVENT_DRIVER_GTK_REKEY, 3211 3212 /** 3213 * EVENT_SCHED_SCAN_STOPPED - Scheduled scan was stopped 3214 */ 3215 EVENT_SCHED_SCAN_STOPPED, 3216 3217 /** 3218 * EVENT_DRIVER_CLIENT_POLL_OK - Station responded to poll 3219 * 3220 * This event indicates that the station responded to the poll 3221 * initiated with @poll_client. 3222 */ 3223 EVENT_DRIVER_CLIENT_POLL_OK, 3224 3225 /** 3226 * EVENT_EAPOL_TX_STATUS - notify of EAPOL TX status 3227 */ 3228 EVENT_EAPOL_TX_STATUS, 3229 3230 /** 3231 * EVENT_CH_SWITCH - AP or GO decided to switch channels 3232 * 3233 * Described in wpa_event_data.ch_switch 3234 * */ 3235 EVENT_CH_SWITCH, 3236 3237 /** 3238 * EVENT_WNM - Request WNM operation 3239 * 3240 * This event can be used to request a WNM operation to be performed. 3241 */ 3242 EVENT_WNM, 3243 3244 /** 3245 * EVENT_CONNECT_FAILED_REASON - Connection failure reason in AP mode 3246 * 3247 * This event indicates that the driver reported a connection failure 3248 * with the specified client (for example, max client reached, etc.) in 3249 * AP mode. 3250 */ 3251 EVENT_CONNECT_FAILED_REASON, 3252 3253 /** 3254 * EVENT_RADAR_DETECTED - Notify of radar detection 3255 * 3256 * A radar has been detected on the supplied frequency, hostapd should 3257 * react accordingly (e.g., change channel). 3258 */ 3259 EVENT_DFS_RADAR_DETECTED, 3260 3261 /** 3262 * EVENT_CAC_FINISHED - Notify that channel availability check has been completed 3263 * 3264 * After a successful CAC, the channel can be marked clear and used. 3265 */ 3266 EVENT_DFS_CAC_FINISHED, 3267 3268 /** 3269 * EVENT_CAC_ABORTED - Notify that channel availability check has been aborted 3270 * 3271 * The CAC was not successful, and the channel remains in the previous 3272 * state. This may happen due to a radar beeing detected or other 3273 * external influences. 3274 */ 3275 EVENT_DFS_CAC_ABORTED, 3276 3277 /** 3278 * EVENT_DFS_CAC_NOP_FINISHED - Notify that non-occupancy period is over 3279 * 3280 * The channel which was previously unavailable is now available again. 3281 */ 3282 EVENT_DFS_NOP_FINISHED, 3283 3284 /* 3285 * EVENT_SURVEY - Received survey data 3286 * 3287 * This event gets triggered when a driver query is issued for survey 3288 * data and the requested data becomes available. The returned data is 3289 * stored in struct survey_results. The results provide at most one 3290 * survey entry for each frequency and at minimum will provide one survey 3291 * entry for one frequency. The survey data can be os_malloc()'d and 3292 * then os_free()'d, so the event callback must only copy data. 3293 */ 3294 EVENT_SURVEY 3295}; 3296 3297 3298/** 3299 * struct freq_survey - Channel survey info 3300 * 3301 * @ifidx: Interface index in which this survey was observed 3302 * @freq: Center of frequency of the surveyed channel 3303 * @nf: Channel noise floor in dBm 3304 * @channel_time: Amount of time in ms the radio spent on the channel 3305 * @channel_time_busy: Amount of time in ms the radio detected some signal 3306 * that indicated to the radio the channel was not clear 3307 * @channel_time_rx: Amount of time the radio spent receiving data 3308 * @channel_time_tx: Amount of time the radio spent transmitting data 3309 * @filled: bitmask indicating which fields have been reported, see 3310 * SURVEY_HAS_* defines. 3311 * @list: Internal list pointers 3312 */ 3313struct freq_survey { 3314 u32 ifidx; 3315 unsigned int freq; 3316 s8 nf; 3317 u64 channel_time; 3318 u64 channel_time_busy; 3319 u64 channel_time_rx; 3320 u64 channel_time_tx; 3321 unsigned int filled; 3322 struct dl_list list; 3323}; 3324 3325#define SURVEY_HAS_NF BIT(0) 3326#define SURVEY_HAS_CHAN_TIME BIT(1) 3327#define SURVEY_HAS_CHAN_TIME_BUSY BIT(2) 3328#define SURVEY_HAS_CHAN_TIME_RX BIT(3) 3329#define SURVEY_HAS_CHAN_TIME_TX BIT(4) 3330 3331 3332/** 3333 * union wpa_event_data - Additional data for wpa_supplicant_event() calls 3334 */ 3335union wpa_event_data { 3336 /** 3337 * struct assoc_info - Data for EVENT_ASSOC and EVENT_ASSOCINFO events 3338 * 3339 * This structure is optional for EVENT_ASSOC calls and required for 3340 * EVENT_ASSOCINFO calls. By using EVENT_ASSOC with this data, the 3341 * driver interface does not need to generate separate EVENT_ASSOCINFO 3342 * calls. 3343 */ 3344 struct assoc_info { 3345 /** 3346 * reassoc - Flag to indicate association or reassociation 3347 */ 3348 int reassoc; 3349 3350 /** 3351 * req_ies - (Re)Association Request IEs 3352 * 3353 * If the driver generates WPA/RSN IE, this event data must be 3354 * returned for WPA handshake to have needed information. If 3355 * wpa_supplicant-generated WPA/RSN IE is used, this 3356 * information event is optional. 3357 * 3358 * This should start with the first IE (fixed fields before IEs 3359 * are not included). 3360 */ 3361 const u8 *req_ies; 3362 3363 /** 3364 * req_ies_len - Length of req_ies in bytes 3365 */ 3366 size_t req_ies_len; 3367 3368 /** 3369 * resp_ies - (Re)Association Response IEs 3370 * 3371 * Optional association data from the driver. This data is not 3372 * required WPA, but may be useful for some protocols and as 3373 * such, should be reported if this is available to the driver 3374 * interface. 3375 * 3376 * This should start with the first IE (fixed fields before IEs 3377 * are not included). 3378 */ 3379 const u8 *resp_ies; 3380 3381 /** 3382 * resp_ies_len - Length of resp_ies in bytes 3383 */ 3384 size_t resp_ies_len; 3385 3386 /** 3387 * beacon_ies - Beacon or Probe Response IEs 3388 * 3389 * Optional Beacon/ProbeResp data: IEs included in Beacon or 3390 * Probe Response frames from the current AP (i.e., the one 3391 * that the client just associated with). This information is 3392 * used to update WPA/RSN IE for the AP. If this field is not 3393 * set, the results from previous scan will be used. If no 3394 * data for the new AP is found, scan results will be requested 3395 * again (without scan request). At this point, the driver is 3396 * expected to provide WPA/RSN IE for the AP (if WPA/WPA2 is 3397 * used). 3398 * 3399 * This should start with the first IE (fixed fields before IEs 3400 * are not included). 3401 */ 3402 const u8 *beacon_ies; 3403 3404 /** 3405 * beacon_ies_len - Length of beacon_ies */ 3406 size_t beacon_ies_len; 3407 3408 /** 3409 * freq - Frequency of the operational channel in MHz 3410 */ 3411 unsigned int freq; 3412 3413 /** 3414 * addr - Station address (for AP mode) 3415 */ 3416 const u8 *addr; 3417 } assoc_info; 3418 3419 /** 3420 * struct disassoc_info - Data for EVENT_DISASSOC events 3421 */ 3422 struct disassoc_info { 3423 /** 3424 * addr - Station address (for AP mode) 3425 */ 3426 const u8 *addr; 3427 3428 /** 3429 * reason_code - Reason Code (host byte order) used in 3430 * Deauthentication frame 3431 */ 3432 u16 reason_code; 3433 3434 /** 3435 * ie - Optional IE(s) in Disassociation frame 3436 */ 3437 const u8 *ie; 3438 3439 /** 3440 * ie_len - Length of ie buffer in octets 3441 */ 3442 size_t ie_len; 3443 3444 /** 3445 * locally_generated - Whether the frame was locally generated 3446 */ 3447 int locally_generated; 3448 } disassoc_info; 3449 3450 /** 3451 * struct deauth_info - Data for EVENT_DEAUTH events 3452 */ 3453 struct deauth_info { 3454 /** 3455 * addr - Station address (for AP mode) 3456 */ 3457 const u8 *addr; 3458 3459 /** 3460 * reason_code - Reason Code (host byte order) used in 3461 * Deauthentication frame 3462 */ 3463 u16 reason_code; 3464 3465 /** 3466 * ie - Optional IE(s) in Deauthentication frame 3467 */ 3468 const u8 *ie; 3469 3470 /** 3471 * ie_len - Length of ie buffer in octets 3472 */ 3473 size_t ie_len; 3474 3475 /** 3476 * locally_generated - Whether the frame was locally generated 3477 */ 3478 int locally_generated; 3479 } deauth_info; 3480 3481 /** 3482 * struct michael_mic_failure - Data for EVENT_MICHAEL_MIC_FAILURE 3483 */ 3484 struct michael_mic_failure { 3485 int unicast; 3486 const u8 *src; 3487 } michael_mic_failure; 3488 3489 /** 3490 * struct interface_status - Data for EVENT_INTERFACE_STATUS 3491 */ 3492 struct interface_status { 3493 char ifname[100]; 3494 enum { 3495 EVENT_INTERFACE_ADDED, EVENT_INTERFACE_REMOVED 3496 } ievent; 3497 } interface_status; 3498 3499 /** 3500 * struct pmkid_candidate - Data for EVENT_PMKID_CANDIDATE 3501 */ 3502 struct pmkid_candidate { 3503 /** BSSID of the PMKID candidate */ 3504 u8 bssid[ETH_ALEN]; 3505 /** Smaller the index, higher the priority */ 3506 int index; 3507 /** Whether RSN IE includes pre-authenticate flag */ 3508 int preauth; 3509 } pmkid_candidate; 3510 3511 /** 3512 * struct stkstart - Data for EVENT_STKSTART 3513 */ 3514 struct stkstart { 3515 u8 peer[ETH_ALEN]; 3516 } stkstart; 3517 3518 /** 3519 * struct tdls - Data for EVENT_TDLS 3520 */ 3521 struct tdls { 3522 u8 peer[ETH_ALEN]; 3523 enum { 3524 TDLS_REQUEST_SETUP, 3525 TDLS_REQUEST_TEARDOWN 3526 } oper; 3527 u16 reason_code; /* for teardown */ 3528 } tdls; 3529 3530 /** 3531 * struct wnm - Data for EVENT_WNM 3532 */ 3533 struct wnm { 3534 u8 addr[ETH_ALEN]; 3535 enum { 3536 WNM_OPER_SLEEP, 3537 } oper; 3538 enum { 3539 WNM_SLEEP_ENTER, 3540 WNM_SLEEP_EXIT 3541 } sleep_action; 3542 int sleep_intval; 3543 u16 reason_code; 3544 u8 *buf; 3545 u16 buf_len; 3546 } wnm; 3547 3548 /** 3549 * struct ft_ies - FT information elements (EVENT_FT_RESPONSE) 3550 * 3551 * During FT (IEEE 802.11r) authentication sequence, the driver is 3552 * expected to use this event to report received FT IEs (MDIE, FTIE, 3553 * RSN IE, TIE, possible resource request) to the supplicant. The FT 3554 * IEs for the next message will be delivered through the 3555 * struct wpa_driver_ops::update_ft_ies() callback. 3556 */ 3557 struct ft_ies { 3558 const u8 *ies; 3559 size_t ies_len; 3560 int ft_action; 3561 u8 target_ap[ETH_ALEN]; 3562 /** Optional IE(s), e.g., WMM TSPEC(s), for RIC-Request */ 3563 const u8 *ric_ies; 3564 /** Length of ric_ies buffer in octets */ 3565 size_t ric_ies_len; 3566 } ft_ies; 3567 3568 /** 3569 * struct ibss_rsn_start - Data for EVENT_IBSS_RSN_START 3570 */ 3571 struct ibss_rsn_start { 3572 u8 peer[ETH_ALEN]; 3573 } ibss_rsn_start; 3574 3575 /** 3576 * struct auth_info - Data for EVENT_AUTH events 3577 */ 3578 struct auth_info { 3579 u8 peer[ETH_ALEN]; 3580 u8 bssid[ETH_ALEN]; 3581 u16 auth_type; 3582 u16 auth_transaction; 3583 u16 status_code; 3584 const u8 *ies; 3585 size_t ies_len; 3586 } auth; 3587 3588 /** 3589 * struct assoc_reject - Data for EVENT_ASSOC_REJECT events 3590 */ 3591 struct assoc_reject { 3592 /** 3593 * bssid - BSSID of the AP that rejected association 3594 */ 3595 const u8 *bssid; 3596 3597 /** 3598 * resp_ies - (Re)Association Response IEs 3599 * 3600 * Optional association data from the driver. This data is not 3601 * required WPA, but may be useful for some protocols and as 3602 * such, should be reported if this is available to the driver 3603 * interface. 3604 * 3605 * This should start with the first IE (fixed fields before IEs 3606 * are not included). 3607 */ 3608 const u8 *resp_ies; 3609 3610 /** 3611 * resp_ies_len - Length of resp_ies in bytes 3612 */ 3613 size_t resp_ies_len; 3614 3615 /** 3616 * status_code - Status Code from (Re)association Response 3617 */ 3618 u16 status_code; 3619 } assoc_reject; 3620 3621 struct timeout_event { 3622 u8 addr[ETH_ALEN]; 3623 } timeout_event; 3624 3625 /** 3626 * struct ft_rrb_rx - Data for EVENT_FT_RRB_RX events 3627 */ 3628 struct ft_rrb_rx { 3629 const u8 *src; 3630 const u8 *data; 3631 size_t data_len; 3632 } ft_rrb_rx; 3633 3634 /** 3635 * struct tx_status - Data for EVENT_TX_STATUS events 3636 */ 3637 struct tx_status { 3638 u16 type; 3639 u16 stype; 3640 const u8 *dst; 3641 const u8 *data; 3642 size_t data_len; 3643 int ack; 3644 } tx_status; 3645 3646 /** 3647 * struct rx_from_unknown - Data for EVENT_RX_FROM_UNKNOWN events 3648 */ 3649 struct rx_from_unknown { 3650 const u8 *bssid; 3651 const u8 *addr; 3652 int wds; 3653 } rx_from_unknown; 3654 3655 /** 3656 * struct rx_mgmt - Data for EVENT_RX_MGMT events 3657 */ 3658 struct rx_mgmt { 3659 const u8 *frame; 3660 size_t frame_len; 3661 u32 datarate; 3662 int ssi_signal; /* dBm */ 3663 } rx_mgmt; 3664 3665 /** 3666 * struct rx_action - Data for EVENT_RX_ACTION events 3667 */ 3668 struct rx_action { 3669 /** 3670 * da - Destination address of the received Action frame 3671 */ 3672 const u8 *da; 3673 3674 /** 3675 * sa - Source address of the received Action frame 3676 */ 3677 const u8 *sa; 3678 3679 /** 3680 * bssid - Address 3 of the received Action frame 3681 */ 3682 const u8 *bssid; 3683 3684 /** 3685 * category - Action frame category 3686 */ 3687 u8 category; 3688 3689 /** 3690 * data - Action frame body after category field 3691 */ 3692 const u8 *data; 3693 3694 /** 3695 * len - Length of data in octets 3696 */ 3697 size_t len; 3698 3699 /** 3700 * freq - Frequency (in MHz) on which the frame was received 3701 */ 3702 int freq; 3703 } rx_action; 3704 3705 /** 3706 * struct remain_on_channel - Data for EVENT_REMAIN_ON_CHANNEL events 3707 * 3708 * This is also used with EVENT_CANCEL_REMAIN_ON_CHANNEL events. 3709 */ 3710 struct remain_on_channel { 3711 /** 3712 * freq - Channel frequency in MHz 3713 */ 3714 unsigned int freq; 3715 3716 /** 3717 * duration - Duration to remain on the channel in milliseconds 3718 */ 3719 unsigned int duration; 3720 } remain_on_channel; 3721 3722 /** 3723 * struct scan_info - Optional data for EVENT_SCAN_RESULTS events 3724 * @aborted: Whether the scan was aborted 3725 * @freqs: Scanned frequencies in MHz (%NULL = all channels scanned) 3726 * @num_freqs: Number of entries in freqs array 3727 * @ssids: Scanned SSIDs (%NULL or zero-length SSID indicates wildcard 3728 * SSID) 3729 * @num_ssids: Number of entries in ssids array 3730 */ 3731 struct scan_info { 3732 int aborted; 3733 const int *freqs; 3734 size_t num_freqs; 3735 struct wpa_driver_scan_ssid ssids[WPAS_MAX_SCAN_SSIDS]; 3736 size_t num_ssids; 3737 } scan_info; 3738 3739 /** 3740 * struct mlme_rx - Data for EVENT_MLME_RX events 3741 */ 3742 struct mlme_rx { 3743 const u8 *buf; 3744 size_t len; 3745 int freq; 3746 int channel; 3747 int ssi; 3748 } mlme_rx; 3749 3750 /** 3751 * struct rx_probe_req - Data for EVENT_RX_PROBE_REQ events 3752 */ 3753 struct rx_probe_req { 3754 /** 3755 * sa - Source address of the received Probe Request frame 3756 */ 3757 const u8 *sa; 3758 3759 /** 3760 * da - Destination address of the received Probe Request frame 3761 * or %NULL if not available 3762 */ 3763 const u8 *da; 3764 3765 /** 3766 * bssid - BSSID of the received Probe Request frame or %NULL 3767 * if not available 3768 */ 3769 const u8 *bssid; 3770 3771 /** 3772 * ie - IEs from the Probe Request body 3773 */ 3774 const u8 *ie; 3775 3776 /** 3777 * ie_len - Length of ie buffer in octets 3778 */ 3779 size_t ie_len; 3780 3781 /** 3782 * signal - signal strength in dBm (or 0 if not available) 3783 */ 3784 int ssi_signal; 3785 } rx_probe_req; 3786 3787 /** 3788 * struct new_sta - Data for EVENT_NEW_STA events 3789 */ 3790 struct new_sta { 3791 const u8 *addr; 3792 } new_sta; 3793 3794 /** 3795 * struct eapol_rx - Data for EVENT_EAPOL_RX events 3796 */ 3797 struct eapol_rx { 3798 const u8 *src; 3799 const u8 *data; 3800 size_t data_len; 3801 } eapol_rx; 3802 3803 /** 3804 * signal_change - Data for EVENT_SIGNAL_CHANGE events 3805 */ 3806 struct wpa_signal_info signal_change; 3807 3808 /** 3809 * struct best_channel - Data for EVENT_BEST_CHANNEL events 3810 * @freq_24: Best 2.4 GHz band channel frequency in MHz 3811 * @freq_5: Best 5 GHz band channel frequency in MHz 3812 * @freq_overall: Best channel frequency in MHz 3813 * 3814 * 0 can be used to indicate no preference in either band. 3815 */ 3816 struct best_channel { 3817 int freq_24; 3818 int freq_5; 3819 int freq_overall; 3820 } best_chan; 3821 3822 struct unprot_deauth { 3823 const u8 *sa; 3824 const u8 *da; 3825 u16 reason_code; 3826 } unprot_deauth; 3827 3828 struct unprot_disassoc { 3829 const u8 *sa; 3830 const u8 *da; 3831 u16 reason_code; 3832 } unprot_disassoc; 3833 3834 /** 3835 * struct low_ack - Data for EVENT_STATION_LOW_ACK events 3836 * @addr: station address 3837 */ 3838 struct low_ack { 3839 u8 addr[ETH_ALEN]; 3840 } low_ack; 3841 3842 /** 3843 * struct p2p_dev_found - Data for EVENT_P2P_DEV_FOUND 3844 */ 3845 struct p2p_dev_found { 3846 const u8 *addr; 3847 const u8 *dev_addr; 3848 const u8 *pri_dev_type; 3849 const char *dev_name; 3850 u16 config_methods; 3851 u8 dev_capab; 3852 u8 group_capab; 3853 } p2p_dev_found; 3854 3855 /** 3856 * struct p2p_go_neg_req_rx - Data for EVENT_P2P_GO_NEG_REQ_RX 3857 */ 3858 struct p2p_go_neg_req_rx { 3859 const u8 *src; 3860 u16 dev_passwd_id; 3861 } p2p_go_neg_req_rx; 3862 3863 /** 3864 * struct p2p_go_neg_completed - Data for EVENT_P2P_GO_NEG_COMPLETED 3865 */ 3866 struct p2p_go_neg_completed { 3867 struct p2p_go_neg_results *res; 3868 } p2p_go_neg_completed; 3869 3870 struct p2p_prov_disc_req { 3871 const u8 *peer; 3872 u16 config_methods; 3873 const u8 *dev_addr; 3874 const u8 *pri_dev_type; 3875 const char *dev_name; 3876 u16 supp_config_methods; 3877 u8 dev_capab; 3878 u8 group_capab; 3879 } p2p_prov_disc_req; 3880 3881 struct p2p_prov_disc_resp { 3882 const u8 *peer; 3883 u16 config_methods; 3884 } p2p_prov_disc_resp; 3885 3886 struct p2p_sd_req { 3887 int freq; 3888 const u8 *sa; 3889 u8 dialog_token; 3890 u16 update_indic; 3891 const u8 *tlvs; 3892 size_t tlvs_len; 3893 } p2p_sd_req; 3894 3895 struct p2p_sd_resp { 3896 const u8 *sa; 3897 u16 update_indic; 3898 const u8 *tlvs; 3899 size_t tlvs_len; 3900 } p2p_sd_resp; 3901 3902 /** 3903 * struct ibss_peer_lost - Data for EVENT_IBSS_PEER_LOST 3904 */ 3905 struct ibss_peer_lost { 3906 u8 peer[ETH_ALEN]; 3907 } ibss_peer_lost; 3908 3909 /** 3910 * struct driver_gtk_rekey - Data for EVENT_DRIVER_GTK_REKEY 3911 */ 3912 struct driver_gtk_rekey { 3913 const u8 *bssid; 3914 const u8 *replay_ctr; 3915 } driver_gtk_rekey; 3916 3917 /** 3918 * struct client_poll - Data for EVENT_DRIVER_CLIENT_POLL_OK events 3919 * @addr: station address 3920 */ 3921 struct client_poll { 3922 u8 addr[ETH_ALEN]; 3923 } client_poll; 3924 3925 /** 3926 * struct eapol_tx_status 3927 * @dst: Original destination 3928 * @data: Data starting with IEEE 802.1X header (!) 3929 * @data_len: Length of data 3930 * @ack: Indicates ack or lost frame 3931 * 3932 * This corresponds to hapd_send_eapol if the frame sent 3933 * there isn't just reported as EVENT_TX_STATUS. 3934 */ 3935 struct eapol_tx_status { 3936 const u8 *dst; 3937 const u8 *data; 3938 int data_len; 3939 int ack; 3940 } eapol_tx_status; 3941 3942 /** 3943 * struct ch_switch 3944 * @freq: Frequency of new channel in MHz 3945 * @ht_enabled: Whether this is an HT channel 3946 * @ch_offset: Secondary channel offset 3947 */ 3948 struct ch_switch { 3949 int freq; 3950 int ht_enabled; 3951 int ch_offset; 3952 } ch_switch; 3953 3954 /** 3955 * struct connect_failed - Data for EVENT_CONNECT_FAILED_REASON 3956 * @addr: Remote client address 3957 * @code: Reason code for connection failure 3958 */ 3959 struct connect_failed_reason { 3960 u8 addr[ETH_ALEN]; 3961 enum { 3962 MAX_CLIENT_REACHED, 3963 BLOCKED_CLIENT 3964 } code; 3965 } connect_failed_reason; 3966 3967 /** 3968 * struct dfs_event - Data for radar detected events 3969 * @freq: Frequency of the channel in MHz 3970 */ 3971 struct dfs_event { 3972 int freq; 3973 } dfs_event; 3974 3975 /** 3976 * survey_results - Survey result data for EVENT_SURVEY 3977 * @freq_filter: Requested frequency survey filter, 0 if request 3978 * was for all survey data 3979 * @survey_list: Linked list of survey data 3980 */ 3981 struct survey_results { 3982 unsigned int freq_filter; 3983 struct dl_list survey_list; /* struct freq_survey */ 3984 } survey_results; 3985}; 3986 3987/** 3988 * wpa_supplicant_event - Report a driver event for wpa_supplicant 3989 * @ctx: Context pointer (wpa_s); this is the ctx variable registered 3990 * with struct wpa_driver_ops::init() 3991 * @event: event type (defined above) 3992 * @data: possible extra data for the event 3993 * 3994 * Driver wrapper code should call this function whenever an event is received 3995 * from the driver. 3996 */ 3997void wpa_supplicant_event(void *ctx, enum wpa_event_type event, 3998 union wpa_event_data *data); 3999 4000 4001/* 4002 * The following inline functions are provided for convenience to simplify 4003 * event indication for some of the common events. 4004 */ 4005 4006static inline void drv_event_assoc(void *ctx, const u8 *addr, const u8 *ie, 4007 size_t ielen, int reassoc) 4008{ 4009 union wpa_event_data event; 4010 os_memset(&event, 0, sizeof(event)); 4011 event.assoc_info.reassoc = reassoc; 4012 event.assoc_info.req_ies = ie; 4013 event.assoc_info.req_ies_len = ielen; 4014 event.assoc_info.addr = addr; 4015 wpa_supplicant_event(ctx, EVENT_ASSOC, &event); 4016} 4017 4018static inline void drv_event_disassoc(void *ctx, const u8 *addr) 4019{ 4020 union wpa_event_data event; 4021 os_memset(&event, 0, sizeof(event)); 4022 event.disassoc_info.addr = addr; 4023 wpa_supplicant_event(ctx, EVENT_DISASSOC, &event); 4024} 4025 4026static inline void drv_event_eapol_rx(void *ctx, const u8 *src, const u8 *data, 4027 size_t data_len) 4028{ 4029 union wpa_event_data event; 4030 os_memset(&event, 0, sizeof(event)); 4031 event.eapol_rx.src = src; 4032 event.eapol_rx.data = data; 4033 event.eapol_rx.data_len = data_len; 4034 wpa_supplicant_event(ctx, EVENT_EAPOL_RX, &event); 4035} 4036 4037/* driver_common.c */ 4038void wpa_scan_results_free(struct wpa_scan_results *res); 4039 4040/* Convert wpa_event_type to a string for logging */ 4041const char * event_to_string(enum wpa_event_type event); 4042 4043#endif /* DRIVER_H */ 4044