1 /* 2 * Wi-Fi Direct - P2P module 3 * Copyright (c) 2009-2010, Atheros Communications 4 * 5 * This software may be distributed under the terms of the BSD license. 6 * See README for more details. 7 */ 8 9 #ifndef P2P_H 10 #define P2P_H 11 12 /** 13 * P2P_MAX_REG_CLASSES - Maximum number of regulatory classes 14 */ 15 #define P2P_MAX_REG_CLASSES 10 16 17 /** 18 * P2P_MAX_REG_CLASS_CHANNELS - Maximum number of channels per regulatory class 19 */ 20 #define P2P_MAX_REG_CLASS_CHANNELS 20 21 22 /** 23 * struct p2p_channels - List of supported channels 24 */ 25 struct p2p_channels { 26 /** 27 * struct p2p_reg_class - Supported regulatory class 28 */ 29 struct p2p_reg_class { 30 /** 31 * reg_class - Regulatory class (IEEE 802.11-2007, Annex J) 32 */ 33 u8 reg_class; 34 35 /** 36 * channel - Supported channels 37 */ 38 u8 channel[P2P_MAX_REG_CLASS_CHANNELS]; 39 40 /** 41 * channels - Number of channel entries in use 42 */ 43 size_t channels; 44 } reg_class[P2P_MAX_REG_CLASSES]; 45 46 /** 47 * reg_classes - Number of reg_class entries in use 48 */ 49 size_t reg_classes; 50 }; 51 52 enum p2p_wps_method { 53 WPS_NOT_READY, WPS_PIN_DISPLAY, WPS_PIN_KEYPAD, WPS_PBC 54 }; 55 56 /** 57 * struct p2p_go_neg_results - P2P Group Owner Negotiation results 58 */ 59 struct p2p_go_neg_results { 60 /** 61 * status - Negotiation result (Status Code) 62 * 63 * 0 (P2P_SC_SUCCESS) indicates success. Non-zero values indicate 64 * failed negotiation. 65 */ 66 int status; 67 68 /** 69 * role_go - Whether local end is Group Owner 70 */ 71 int role_go; 72 73 /** 74 * freq - Frequency of the group operational channel in MHz 75 */ 76 int freq; 77 78 /** 79 * ssid - SSID of the group 80 */ 81 u8 ssid[32]; 82 83 /** 84 * ssid_len - Length of SSID in octets 85 */ 86 size_t ssid_len; 87 88 /** 89 * passphrase - WPA2-Personal passphrase for the group (GO only) 90 */ 91 char passphrase[64]; 92 93 /** 94 * peer_device_addr - P2P Device Address of the peer 95 */ 96 u8 peer_device_addr[ETH_ALEN]; 97 98 /** 99 * peer_interface_addr - P2P Interface Address of the peer 100 */ 101 u8 peer_interface_addr[ETH_ALEN]; 102 103 /** 104 * wps_method - WPS method to be used during provisioning 105 */ 106 enum p2p_wps_method wps_method; 107 108 #define P2P_MAX_CHANNELS 50 109 110 /** 111 * freq_list - Zero-terminated list of possible operational channels 112 */ 113 int freq_list[P2P_MAX_CHANNELS]; 114 115 /** 116 * persistent_group - Whether the group should be made persistent 117 * 0 = not persistent 118 * 1 = persistent group without persistent reconnect 119 * 2 = persistent group with persistent reconnect 120 */ 121 int persistent_group; 122 123 /** 124 * peer_config_timeout - Peer configuration timeout (in 10 msec units) 125 */ 126 unsigned int peer_config_timeout; 127 }; 128 129 struct p2p_data; 130 131 enum p2p_scan_type { 132 P2P_SCAN_SOCIAL, 133 P2P_SCAN_FULL, 134 P2P_SCAN_SPECIFIC, 135 P2P_SCAN_SOCIAL_PLUS_ONE 136 }; 137 138 #define P2P_MAX_WPS_VENDOR_EXT 10 139 140 /** 141 * struct p2p_peer_info - P2P peer information 142 */ 143 struct p2p_peer_info { 144 /** 145 * p2p_device_addr - P2P Device Address of the peer 146 */ 147 u8 p2p_device_addr[ETH_ALEN]; 148 149 /** 150 * pri_dev_type - Primary Device Type 151 */ 152 u8 pri_dev_type[8]; 153 154 /** 155 * device_name - Device Name (0..32 octets encoded in UTF-8) 156 */ 157 char device_name[33]; 158 159 /** 160 * manufacturer - Manufacturer (0..64 octets encoded in UTF-8) 161 */ 162 char manufacturer[65]; 163 164 /** 165 * model_name - Model Name (0..32 octets encoded in UTF-8) 166 */ 167 char model_name[33]; 168 169 /** 170 * model_number - Model Number (0..32 octets encoded in UTF-8) 171 */ 172 char model_number[33]; 173 174 /** 175 * serial_number - Serial Number (0..32 octets encoded in UTF-8) 176 */ 177 char serial_number[33]; 178 179 /** 180 * level - Signal level 181 */ 182 int level; 183 184 /** 185 * config_methods - WPS Configuration Methods 186 */ 187 u16 config_methods; 188 189 /** 190 * dev_capab - Device Capabilities 191 */ 192 u8 dev_capab; 193 194 /** 195 * group_capab - Group Capabilities 196 */ 197 u8 group_capab; 198 199 /** 200 * wps_sec_dev_type_list - WPS secondary device type list 201 * 202 * This list includes from 0 to 16 Secondary Device Types as indicated 203 * by wps_sec_dev_type_list_len (8 * number of types). 204 */ 205 u8 wps_sec_dev_type_list[128]; 206 207 /** 208 * wps_sec_dev_type_list_len - Length of secondary device type list 209 */ 210 size_t wps_sec_dev_type_list_len; 211 212 struct wpabuf *wps_vendor_ext[P2P_MAX_WPS_VENDOR_EXT]; 213 }; 214 215 enum p2p_prov_disc_status { 216 P2P_PROV_DISC_SUCCESS, 217 P2P_PROV_DISC_TIMEOUT, 218 P2P_PROV_DISC_REJECTED, 219 }; 220 221 /** 222 * struct p2p_config - P2P configuration 223 * 224 * This configuration is provided to the P2P module during initialization with 225 * p2p_init(). 226 */ 227 struct p2p_config { 228 /** 229 * country - Country code to use in P2P operations 230 */ 231 char country[3]; 232 233 /** 234 * reg_class - Regulatory class for own listen channel 235 */ 236 u8 reg_class; 237 238 /** 239 * channel - Own listen channel 240 */ 241 u8 channel; 242 243 /** 244 * Regulatory class for own operational channel 245 */ 246 u8 op_reg_class; 247 248 /** 249 * op_channel - Own operational channel 250 */ 251 u8 op_channel; 252 253 /** 254 * cfg_op_channel - Whether op_channel is hardcoded in configuration 255 */ 256 u8 cfg_op_channel; 257 258 /** 259 * channels - Own supported regulatory classes and channels 260 * 261 * List of supposerted channels per regulatory class. The regulatory 262 * classes are defined in IEEE Std 802.11-2007 Annex J and the 263 * numbering of the clases depends on the configured country code. 264 */ 265 struct p2p_channels channels; 266 267 /** 268 * pri_dev_type - Primary Device Type (see WPS) 269 */ 270 u8 pri_dev_type[8]; 271 272 /** 273 * P2P_SEC_DEVICE_TYPES - Maximum number of secondary device types 274 */ 275 #define P2P_SEC_DEVICE_TYPES 5 276 277 /** 278 * sec_dev_type - Optional secondary device types 279 */ 280 u8 sec_dev_type[P2P_SEC_DEVICE_TYPES][8]; 281 282 /** 283 * num_sec_dev_types - Number of sec_dev_type entries 284 */ 285 size_t num_sec_dev_types; 286 287 /** 288 * dev_addr - P2P Device Address 289 */ 290 u8 dev_addr[ETH_ALEN]; 291 292 /** 293 * dev_name - Device Name 294 */ 295 char *dev_name; 296 297 char *manufacturer; 298 char *model_name; 299 char *model_number; 300 char *serial_number; 301 302 u8 uuid[16]; 303 u16 config_methods; 304 305 /** 306 * concurrent_operations - Whether concurrent operations are supported 307 */ 308 int concurrent_operations; 309 310 /** 311 * max_peers - Maximum number of discovered peers to remember 312 * 313 * If more peers are discovered, older entries will be removed to make 314 * room for the new ones. 315 */ 316 size_t max_peers; 317 318 /** 319 * p2p_intra_bss - Intra BSS communication is supported 320 */ 321 int p2p_intra_bss; 322 323 /** 324 * ssid_postfix - Postfix data to add to the SSID 325 * 326 * This data will be added to the end of the SSID after the 327 * DIRECT-<random two octets> prefix. 328 */ 329 u8 ssid_postfix[32 - 9]; 330 331 /** 332 * ssid_postfix_len - Length of the ssid_postfix data 333 */ 334 size_t ssid_postfix_len; 335 336 /** 337 * msg_ctx - Context to use with wpa_msg() calls 338 */ 339 void *msg_ctx; 340 341 /** 342 * cb_ctx - Context to use with callback functions 343 */ 344 void *cb_ctx; 345 346 347 /* Callbacks to request lower layer driver operations */ 348 349 /** 350 * p2p_scan - Request a P2P scan/search 351 * @ctx: Callback context from cb_ctx 352 * @type: Scan type 353 * @freq: Specific frequency (MHz) to scan or 0 for no restriction 354 * @num_req_dev_types: Number of requested device types 355 * @req_dev_types: Array containing requested device types 356 * @dev_id: Device ID to search for or %NULL to find all devices 357 * Returns: 0 on success, -1 on failure 358 * 359 * This callback function is used to request a P2P scan or search 360 * operation to be completed. Type type argument specifies which type 361 * of scan is to be done. @P2P_SCAN_SOCIAL indicates that only the 362 * social channels (1, 6, 11) should be scanned. @P2P_SCAN_FULL 363 * indicates that all channels are to be scanned. @P2P_SCAN_SPECIFIC 364 * request a scan of a single channel specified by freq. 365 * @P2P_SCAN_SOCIAL_PLUS_ONE request scan of all the social channels 366 * plus one extra channel specified by freq. 367 * 368 * The full scan is used for the initial scan to find group owners from 369 * all. The other types are used during search phase scan of the social 370 * channels (with potential variation if the Listen channel of the 371 * target peer is known or if other channels are scanned in steps). 372 * 373 * The scan results are returned after this call by calling 374 * p2p_scan_res_handler() for each scan result that has a P2P IE and 375 * then calling p2p_scan_res_handled() to indicate that all scan 376 * results have been indicated. 377 */ 378 int (*p2p_scan)(void *ctx, enum p2p_scan_type type, int freq, 379 unsigned int num_req_dev_types, 380 const u8 *req_dev_types, const u8 *dev_id); 381 382 /** 383 * send_probe_resp - Transmit a Probe Response frame 384 * @ctx: Callback context from cb_ctx 385 * @buf: Probe Response frame (including the header and body) 386 * Returns: 0 on success, -1 on failure 387 * 388 * This function is used to reply to Probe Request frames that were 389 * indicated with a call to p2p_probe_req_rx(). The response is to be 390 * sent on the same channel or to be dropped if the driver is not 391 * anymore listening to Probe Request frames. 392 * 393 * Alternatively, the responsibility for building the Probe Response 394 * frames in Listen state may be in another system component in which 395 * case this function need to be implemented (i.e., the function 396 * pointer can be %NULL). The WPS and P2P IEs to be added for Probe 397 * Response frames in such a case are available from the 398 * start_listen() callback. It should be noted that the received Probe 399 * Request frames must be indicated by calling p2p_probe_req_rx() even 400 * if this send_probe_resp() is not used. 401 */ 402 int (*send_probe_resp)(void *ctx, const struct wpabuf *buf); 403 404 /** 405 * send_action - Transmit an Action frame 406 * @ctx: Callback context from cb_ctx 407 * @freq: Frequency in MHz for the channel on which to transmit 408 * @dst: Destination MAC address (Address 1) 409 * @src: Source MAC address (Address 2) 410 * @bssid: BSSID (Address 3) 411 * @buf: Frame body (starting from Category field) 412 * @len: Length of buf in octets 413 * @wait_time: How many msec to wait for a response frame 414 * Returns: 0 on success, -1 on failure 415 * 416 * The Action frame may not be transmitted immediately and the status 417 * of the transmission must be reported by calling 418 * p2p_send_action_cb() once the frame has either been transmitted or 419 * it has been dropped due to excessive retries or other failure to 420 * transmit. 421 */ 422 int (*send_action)(void *ctx, unsigned int freq, const u8 *dst, 423 const u8 *src, const u8 *bssid, const u8 *buf, 424 size_t len, unsigned int wait_time); 425 426 /** 427 * send_action_done - Notify that Action frame sequence was completed 428 * @ctx: Callback context from cb_ctx 429 * 430 * This function is called when the Action frame sequence that was 431 * started with send_action() has been completed, i.e., when there is 432 * no need to wait for a response from the destination peer anymore. 433 */ 434 void (*send_action_done)(void *ctx); 435 436 /** 437 * start_listen - Start Listen state 438 * @ctx: Callback context from cb_ctx 439 * @freq: Frequency of the listen channel in MHz 440 * @duration: Duration for the Listen state in milliseconds 441 * @probe_resp_ie: IE(s) to be added to Probe Response frames 442 * Returns: 0 on success, -1 on failure 443 * 444 * This Listen state may not start immediately since the driver may 445 * have other pending operations to complete first. Once the Listen 446 * state has started, p2p_listen_cb() must be called to notify the P2P 447 * module. Once the Listen state is stopped, p2p_listen_end() must be 448 * called to notify the P2P module that the driver is not in the Listen 449 * state anymore. 450 * 451 * If the send_probe_resp() is not used for generating the response, 452 * the IEs from probe_resp_ie need to be added to the end of the Probe 453 * Response frame body. If send_probe_resp() is used, the probe_resp_ie 454 * information can be ignored. 455 */ 456 int (*start_listen)(void *ctx, unsigned int freq, 457 unsigned int duration, 458 const struct wpabuf *probe_resp_ie); 459 /** 460 * stop_listen - Stop Listen state 461 * @ctx: Callback context from cb_ctx 462 * 463 * This callback can be used to stop a Listen state operation that was 464 * previously requested with start_listen(). 465 */ 466 void (*stop_listen)(void *ctx); 467 468 /** 469 * get_noa - Get current Notice of Absence attribute payload 470 * @ctx: Callback context from cb_ctx 471 * @interface_addr: P2P Interface Address of the GO 472 * @buf: Buffer for returning NoA 473 * @buf_len: Buffer length in octets 474 * Returns: Number of octets used in buf, 0 to indicate no NoA is being 475 * advertized, or -1 on failure 476 * 477 * This function is used to fetch the current Notice of Absence 478 * attribute value from GO. 479 */ 480 int (*get_noa)(void *ctx, const u8 *interface_addr, u8 *buf, 481 size_t buf_len); 482 483 /* Callbacks to notify events to upper layer management entity */ 484 485 /** 486 * dev_found - Notification of a found P2P Device 487 * @ctx: Callback context from cb_ctx 488 * @addr: Source address of the message triggering this notification 489 * @info: P2P peer information 490 * @new_device: Inform if the peer is newly found 491 * 492 * This callback is used to notify that a new P2P Device has been 493 * found. This may happen, e.g., during Search state based on scan 494 * results or during Listen state based on receive Probe Request and 495 * Group Owner Negotiation Request. 496 */ 497 void (*dev_found)(void *ctx, const u8 *addr, 498 const struct p2p_peer_info *info, 499 int new_device); 500 501 /** 502 * dev_lost - Notification of a lost P2P Device 503 * @ctx: Callback context from cb_ctx 504 * @dev_addr: P2P Device Address of the lost P2P Device 505 * 506 * This callback is used to notify that a P2P Device has been deleted. 507 */ 508 void (*dev_lost)(void *ctx, const u8 *dev_addr); 509 510 /** 511 * go_neg_req_rx - Notification of a receive GO Negotiation Request 512 * @ctx: Callback context from cb_ctx 513 * @src: Source address of the message triggering this notification 514 * @dev_passwd_id: WPS Device Password ID 515 * 516 * This callback is used to notify that a P2P Device is requesting 517 * group owner negotiation with us, but we do not have all the 518 * necessary information to start GO Negotiation. This indicates that 519 * the local user has not authorized the connection yet by providing a 520 * PIN or PBC button press. This information can be provided with a 521 * call to p2p_connect(). 522 */ 523 void (*go_neg_req_rx)(void *ctx, const u8 *src, u16 dev_passwd_id); 524 525 /** 526 * go_neg_completed - Notification of GO Negotiation results 527 * @ctx: Callback context from cb_ctx 528 * @res: GO Negotiation results 529 * 530 * This callback is used to notify that Group Owner Negotiation has 531 * been completed. Non-zero struct p2p_go_neg_results::status indicates 532 * failed negotiation. In case of success, this function is responsible 533 * for creating a new group interface (or using the existing interface 534 * depending on driver features), setting up the group interface in 535 * proper mode based on struct p2p_go_neg_results::role_go and 536 * initializing WPS provisioning either as a Registrar (if GO) or as an 537 * Enrollee. Successful WPS provisioning must be indicated by calling 538 * p2p_wps_success_cb(). The callee is responsible for timing out group 539 * formation if WPS provisioning cannot be completed successfully 540 * within 15 seconds. 541 */ 542 void (*go_neg_completed)(void *ctx, struct p2p_go_neg_results *res); 543 544 /** 545 * sd_request - Callback on Service Discovery Request 546 * @ctx: Callback context from cb_ctx 547 * @freq: Frequency (in MHz) of the channel 548 * @sa: Source address of the request 549 * @dialog_token: Dialog token 550 * @update_indic: Service Update Indicator from the source of request 551 * @tlvs: P2P Service Request TLV(s) 552 * @tlvs_len: Length of tlvs buffer in octets 553 * 554 * This callback is used to indicate reception of a service discovery 555 * request. Response to the query must be indicated by calling 556 * p2p_sd_response() with the context information from the arguments to 557 * this callback function. 558 * 559 * This callback handler can be set to %NULL to indicate that service 560 * discovery is not supported. 561 */ 562 void (*sd_request)(void *ctx, int freq, const u8 *sa, u8 dialog_token, 563 u16 update_indic, const u8 *tlvs, size_t tlvs_len); 564 565 /** 566 * sd_response - Callback on Service Discovery Response 567 * @ctx: Callback context from cb_ctx 568 * @sa: Source address of the request 569 * @update_indic: Service Update Indicator from the source of response 570 * @tlvs: P2P Service Response TLV(s) 571 * @tlvs_len: Length of tlvs buffer in octets 572 * 573 * This callback is used to indicate reception of a service discovery 574 * response. This callback handler can be set to %NULL if no service 575 * discovery requests are used. The information provided with this call 576 * is replies to the queries scheduled with p2p_sd_request(). 577 */ 578 void (*sd_response)(void *ctx, const u8 *sa, u16 update_indic, 579 const u8 *tlvs, size_t tlvs_len); 580 581 /** 582 * prov_disc_req - Callback on Provisiong Discovery Request 583 * @ctx: Callback context from cb_ctx 584 * @peer: Source address of the request 585 * @config_methods: Requested WPS Config Method 586 * @dev_addr: P2P Device Address of the found P2P Device 587 * @pri_dev_type: Primary Device Type 588 * @dev_name: Device Name 589 * @supp_config_methods: Supported configuration Methods 590 * @dev_capab: Device Capabilities 591 * @group_capab: Group Capabilities 592 * @group_id: P2P Group ID (or %NULL if not included) 593 * @group_id_len: Length of P2P Group ID 594 * 595 * This callback is used to indicate reception of a Provision Discovery 596 * Request frame that the P2P module accepted. 597 */ 598 void (*prov_disc_req)(void *ctx, const u8 *peer, u16 config_methods, 599 const u8 *dev_addr, const u8 *pri_dev_type, 600 const char *dev_name, u16 supp_config_methods, 601 u8 dev_capab, u8 group_capab, 602 const u8 *group_id, size_t group_id_len); 603 604 /** 605 * prov_disc_resp - Callback on Provisiong Discovery Response 606 * @ctx: Callback context from cb_ctx 607 * @peer: Source address of the response 608 * @config_methods: Value from p2p_prov_disc_req() or 0 on failure 609 * 610 * This callback is used to indicate reception of a Provision Discovery 611 * Response frame for a pending request scheduled with 612 * p2p_prov_disc_req(). This callback handler can be set to %NULL if 613 * provision discovery is not used. 614 */ 615 void (*prov_disc_resp)(void *ctx, const u8 *peer, u16 config_methods); 616 617 /** 618 * prov_disc_fail - Callback on Provision Discovery failure 619 * @ctx: Callback context from cb_ctx 620 * @peer: Source address of the response 621 * @status: Cause of failure, will not be %P2P_PROV_DISC_SUCCESS 622 * 623 * This callback is used to indicate either a failure or no response 624 * to an earlier provision discovery request. 625 * 626 * This callback handler can be set to %NULL if provision discovery 627 * is not used or failures do not need to be indicated. 628 */ 629 void (*prov_disc_fail)(void *ctx, const u8 *peer, 630 enum p2p_prov_disc_status status); 631 632 /** 633 * invitation_process - Optional callback for processing Invitations 634 * @ctx: Callback context from cb_ctx 635 * @sa: Source address of the Invitation Request 636 * @bssid: P2P Group BSSID from the request or %NULL if not included 637 * @go_dev_addr: GO Device Address from P2P Group ID 638 * @ssid: SSID from P2P Group ID 639 * @ssid_len: Length of ssid buffer in octets 640 * @go: Variable for returning whether the local end is GO in the group 641 * @group_bssid: Buffer for returning P2P Group BSSID (if local end GO) 642 * @force_freq: Variable for returning forced frequency for the group 643 * @persistent_group: Whether this is an invitation to reinvoke a 644 * persistent group (instead of invitation to join an active 645 * group) 646 * Returns: Status code (P2P_SC_*) 647 * 648 * This optional callback can be used to implement persistent reconnect 649 * by allowing automatic restarting of persistent groups without user 650 * interaction. If this callback is not implemented (i.e., is %NULL), 651 * the received Invitation Request frames are replied with 652 * %P2P_SC_REQ_RECEIVED status and indicated to upper layer with the 653 * invitation_result() callback. 654 * 655 * If the requested parameters are acceptable and the group is known, 656 * %P2P_SC_SUCCESS may be returned. If the requested group is unknown, 657 * %P2P_SC_FAIL_UNKNOWN_GROUP should be returned. %P2P_SC_REQ_RECEIVED 658 * can be returned if there is not enough data to provide immediate 659 * response, i.e., if some sort of user interaction is needed. The 660 * invitation_received() callback will be called in that case 661 * immediately after this call. 662 */ 663 u8 (*invitation_process)(void *ctx, const u8 *sa, const u8 *bssid, 664 const u8 *go_dev_addr, const u8 *ssid, 665 size_t ssid_len, int *go, u8 *group_bssid, 666 int *force_freq, int persistent_group); 667 668 /** 669 * invitation_received - Callback on Invitation Request RX 670 * @ctx: Callback context from cb_ctx 671 * @sa: Source address of the Invitation Request 672 * @bssid: P2P Group BSSID or %NULL if not received 673 * @ssid: SSID of the group 674 * @ssid_len: Length of ssid in octets 675 * @go_dev_addr: GO Device Address 676 * @status: Response Status 677 * @op_freq: Operational frequency for the group 678 * 679 * This callback is used to indicate sending of an Invitation Response 680 * for a received Invitation Request. If status == 0 (success), the 681 * upper layer code is responsible for starting the group. status == 1 682 * indicates need to get user authorization for the group. Other status 683 * values indicate that the invitation request was rejected. 684 */ 685 void (*invitation_received)(void *ctx, const u8 *sa, const u8 *bssid, 686 const u8 *ssid, size_t ssid_len, 687 const u8 *go_dev_addr, u8 status, 688 int op_freq); 689 690 /** 691 * invitation_result - Callback on Invitation result 692 * @ctx: Callback context from cb_ctx 693 * @status: Negotiation result (Status Code) 694 * @bssid: P2P Group BSSID or %NULL if not received 695 * 696 * This callback is used to indicate result of an Invitation procedure 697 * started with a call to p2p_invite(). The indicated status code is 698 * the value received from the peer in Invitation Response with 0 699 * (P2P_SC_SUCCESS) indicating success or -1 to indicate a timeout or a 700 * local failure in transmitting the Invitation Request. 701 */ 702 void (*invitation_result)(void *ctx, int status, const u8 *bssid); 703 704 /** 705 * go_connected - Check whether we are connected to a GO 706 * @ctx: Callback context from cb_ctx 707 * @dev_addr: P2P Device Address of a GO 708 * Returns: 1 if we are connected as a P2P client to the specified GO 709 * or 0 if not. 710 */ 711 int (*go_connected)(void *ctx, const u8 *dev_addr); 712 }; 713 714 715 /* P2P module initialization/deinitialization */ 716 717 /** 718 * p2p_init - Initialize P2P module 719 * @cfg: P2P module configuration 720 * Returns: Pointer to private data or %NULL on failure 721 * 722 * This function is used to initialize global P2P module context (one per 723 * device). The P2P module will keep a copy of the configuration data, so the 724 * caller does not need to maintain this structure. However, the callback 725 * functions and the context parameters to them must be kept available until 726 * the P2P module is deinitialized with p2p_deinit(). 727 */ 728 struct p2p_data * p2p_init(const struct p2p_config *cfg); 729 730 /** 731 * p2p_deinit - Deinitialize P2P module 732 * @p2p: P2P module context from p2p_init() 733 */ 734 void p2p_deinit(struct p2p_data *p2p); 735 736 /** 737 * p2p_flush - Flush P2P module state 738 * @p2p: P2P module context from p2p_init() 739 * 740 * This command removes the P2P module state like peer device entries. 741 */ 742 void p2p_flush(struct p2p_data *p2p); 743 744 /** 745 * p2p_unauthorize - Unauthorize the specified peer device 746 * @p2p: P2P module context from p2p_init() 747 * @addr: P2P peer entry to be unauthorized 748 * Returns: 0 on success, -1 on failure 749 * 750 * This command removes any connection authorization from the specified P2P 751 * peer device address. This can be used, e.g., to cancel effect of a previous 752 * p2p_authorize() or p2p_connect() call that has not yet resulted in completed 753 * GO Negotiation. 754 */ 755 int p2p_unauthorize(struct p2p_data *p2p, const u8 *addr); 756 757 /** 758 * p2p_set_dev_name - Set device name 759 * @p2p: P2P module context from p2p_init() 760 * Returns: 0 on success, -1 on failure 761 * 762 * This function can be used to update the P2P module configuration with 763 * information that was not available at the time of the p2p_init() call. 764 */ 765 int p2p_set_dev_name(struct p2p_data *p2p, const char *dev_name); 766 767 int p2p_set_manufacturer(struct p2p_data *p2p, const char *manufacturer); 768 int p2p_set_model_name(struct p2p_data *p2p, const char *model_name); 769 int p2p_set_model_number(struct p2p_data *p2p, const char *model_number); 770 int p2p_set_serial_number(struct p2p_data *p2p, const char *serial_number); 771 772 void p2p_set_config_methods(struct p2p_data *p2p, u16 config_methods); 773 void p2p_set_uuid(struct p2p_data *p2p, const u8 *uuid); 774 775 /** 776 * p2p_set_pri_dev_type - Set primary device type 777 * @p2p: P2P module context from p2p_init() 778 * Returns: 0 on success, -1 on failure 779 * 780 * This function can be used to update the P2P module configuration with 781 * information that was not available at the time of the p2p_init() call. 782 */ 783 int p2p_set_pri_dev_type(struct p2p_data *p2p, const u8 *pri_dev_type); 784 785 /** 786 * p2p_set_sec_dev_types - Set secondary device types 787 * @p2p: P2P module context from p2p_init() 788 * Returns: 0 on success, -1 on failure 789 * 790 * This function can be used to update the P2P module configuration with 791 * information that was not available at the time of the p2p_init() call. 792 */ 793 int p2p_set_sec_dev_types(struct p2p_data *p2p, const u8 dev_types[][8], 794 size_t num_dev_types); 795 796 int p2p_set_country(struct p2p_data *p2p, const char *country); 797 798 799 /* Commands from upper layer management entity */ 800 801 enum p2p_discovery_type { 802 P2P_FIND_START_WITH_FULL, 803 P2P_FIND_ONLY_SOCIAL, 804 P2P_FIND_PROGRESSIVE 805 }; 806 807 /** 808 * p2p_find - Start P2P Find (Device Discovery) 809 * @p2p: P2P module context from p2p_init() 810 * @timeout: Timeout for find operation in seconds or 0 for no timeout 811 * @type: Device Discovery type 812 * @num_req_dev_types: Number of requested device types 813 * @req_dev_types: Requested device types array, must be an array 814 * containing num_req_dev_types * WPS_DEV_TYPE_LEN bytes; %NULL if no 815 * requested device types. 816 * @dev_id: Device ID to search for or %NULL to find all devices 817 * Returns: 0 on success, -1 on failure 818 */ 819 int p2p_find(struct p2p_data *p2p, unsigned int timeout, 820 enum p2p_discovery_type type, 821 unsigned int num_req_dev_types, const u8 *req_dev_types, 822 const u8 *dev_id); 823 824 /** 825 * p2p_stop_find - Stop P2P Find (Device Discovery) 826 * @p2p: P2P module context from p2p_init() 827 */ 828 void p2p_stop_find(struct p2p_data *p2p); 829 830 /** 831 * p2p_stop_find_for_freq - Stop P2P Find for next oper on specific freq 832 * @p2p: P2P module context from p2p_init() 833 * @freq: Frequency in MHz for next operation 834 * 835 * This is like p2p_stop_find(), but Listen state is not stopped if we are 836 * already on the same frequency. 837 */ 838 void p2p_stop_find_for_freq(struct p2p_data *p2p, int freq); 839 840 /** 841 * p2p_listen - Start P2P Listen state for specified duration 842 * @p2p: P2P module context from p2p_init() 843 * @timeout: Listen state duration in milliseconds 844 * Returns: 0 on success, -1 on failure 845 * 846 * This function can be used to request the P2P module to keep the device 847 * discoverable on the listen channel for an extended set of time. At least in 848 * its current form, this is mainly used for testing purposes and may not be of 849 * much use for normal P2P operations. 850 */ 851 int p2p_listen(struct p2p_data *p2p, unsigned int timeout); 852 853 /** 854 * p2p_connect - Start P2P group formation (GO negotiation) 855 * @p2p: P2P module context from p2p_init() 856 * @peer_addr: MAC address of the peer P2P client 857 * @wps_method: WPS method to be used in provisioning 858 * @go_intent: Local GO intent value (1..15) 859 * @own_interface_addr: Intended interface address to use with the group 860 * @force_freq: The only allowed channel frequency in MHz or 0 861 * @persistent_group: Whether to create a persistent group (0 = no, 1 = 862 * persistent group without persistent reconnect, 2 = persistent group with 863 * persistent reconnect) 864 * Returns: 0 on success, -1 on failure 865 */ 866 int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr, 867 enum p2p_wps_method wps_method, 868 int go_intent, const u8 *own_interface_addr, 869 unsigned int force_freq, int persistent_group); 870 871 /** 872 * p2p_authorize - Authorize P2P group formation (GO negotiation) 873 * @p2p: P2P module context from p2p_init() 874 * @peer_addr: MAC address of the peer P2P client 875 * @wps_method: WPS method to be used in provisioning 876 * @go_intent: Local GO intent value (1..15) 877 * @own_interface_addr: Intended interface address to use with the group 878 * @force_freq: The only allowed channel frequency in MHz or 0 879 * @persistent_group: Whether to create a persistent group (0 = no, 1 = 880 * persistent group without persistent reconnect, 2 = persistent group with 881 * persistent reconnect) 882 * Returns: 0 on success, -1 on failure 883 * 884 * This is like p2p_connect(), but the actual group negotiation is not 885 * initiated automatically, i.e., the other end is expected to do that. 886 */ 887 int p2p_authorize(struct p2p_data *p2p, const u8 *peer_addr, 888 enum p2p_wps_method wps_method, 889 int go_intent, const u8 *own_interface_addr, 890 unsigned int force_freq, int persistent_group); 891 892 /** 893 * p2p_reject - Reject peer device (explicitly block connection attempts) 894 * @p2p: P2P module context from p2p_init() 895 * @peer_addr: MAC address of the peer P2P client 896 * Returns: 0 on success, -1 on failure 897 */ 898 int p2p_reject(struct p2p_data *p2p, const u8 *peer_addr); 899 900 /** 901 * p2p_prov_disc_req - Send Provision Discovery Request 902 * @p2p: P2P module context from p2p_init() 903 * @peer_addr: MAC address of the peer P2P client 904 * @config_methods: WPS Config Methods value (only one bit set) 905 * @join: Whether this is used by a client joining an active group 906 * @force_freq: Forced TX frequency for the frame (mainly for the join case) 907 * Returns: 0 on success, -1 on failure 908 * 909 * This function can be used to request a discovered P2P peer to display a PIN 910 * (config_methods = WPS_CONFIG_DISPLAY) or be prepared to enter a PIN from us 911 * (config_methods = WPS_CONFIG_KEYPAD). The Provision Discovery Request frame 912 * is transmitted once immediately and if no response is received, the frame 913 * will be sent again whenever the target device is discovered during device 914 * dsicovery (start with a p2p_find() call). Response from the peer is 915 * indicated with the p2p_config::prov_disc_resp() callback. 916 */ 917 int p2p_prov_disc_req(struct p2p_data *p2p, const u8 *peer_addr, 918 u16 config_methods, int join, int force_freq); 919 920 /** 921 * p2p_sd_request - Schedule a service discovery query 922 * @p2p: P2P module context from p2p_init() 923 * @dst: Destination peer or %NULL to apply for all peers 924 * @tlvs: P2P Service Query TLV(s) 925 * Returns: Reference to the query or %NULL on failure 926 * 927 * Response to the query is indicated with the p2p_config::sd_response() 928 * callback. 929 */ 930 void * p2p_sd_request(struct p2p_data *p2p, const u8 *dst, 931 const struct wpabuf *tlvs); 932 933 /** 934 * p2p_sd_cancel_request - Cancel a pending service discovery query 935 * @p2p: P2P module context from p2p_init() 936 * @req: Query reference from p2p_sd_request() 937 * Returns: 0 if request for cancelled; -1 if not found 938 */ 939 int p2p_sd_cancel_request(struct p2p_data *p2p, void *req); 940 941 /** 942 * p2p_sd_response - Send response to a service discovery query 943 * @p2p: P2P module context from p2p_init() 944 * @freq: Frequency from p2p_config::sd_request() callback 945 * @dst: Destination address from p2p_config::sd_request() callback 946 * @dialog_token: Dialog token from p2p_config::sd_request() callback 947 * @resp_tlvs: P2P Service Response TLV(s) 948 * 949 * This function is called as a response to the request indicated with 950 * p2p_config::sd_request() callback. 951 */ 952 void p2p_sd_response(struct p2p_data *p2p, int freq, const u8 *dst, 953 u8 dialog_token, const struct wpabuf *resp_tlvs); 954 955 /** 956 * p2p_sd_service_update - Indicate a change in local services 957 * @p2p: P2P module context from p2p_init() 958 * 959 * This function needs to be called whenever there is a change in availability 960 * of the local services. This will increment the Service Update Indicator 961 * value which will be used in SD Request and Response frames. 962 */ 963 void p2p_sd_service_update(struct p2p_data *p2p); 964 965 966 enum p2p_invite_role { 967 P2P_INVITE_ROLE_GO, 968 P2P_INVITE_ROLE_ACTIVE_GO, 969 P2P_INVITE_ROLE_CLIENT 970 }; 971 972 /** 973 * p2p_invite - Invite a P2P Device into a group 974 * @p2p: P2P module context from p2p_init() 975 * @peer: Device Address of the peer P2P Device 976 * @role: Local role in the group 977 * @bssid: Group BSSID or %NULL if not known 978 * @ssid: Group SSID 979 * @ssid_len: Length of ssid in octets 980 * @force_freq: The only allowed channel frequency in MHz or 0 981 * @go_dev_addr: Forced GO Device Address or %NULL if none 982 * @persistent_group: Whether this is to reinvoke a persistent group 983 * Returns: 0 on success, -1 on failure 984 */ 985 int p2p_invite(struct p2p_data *p2p, const u8 *peer, enum p2p_invite_role role, 986 const u8 *bssid, const u8 *ssid, size_t ssid_len, 987 unsigned int force_freq, const u8 *go_dev_addr, 988 int persistent_group); 989 990 /** 991 * p2p_presence_req - Request GO presence 992 * @p2p: P2P module context from p2p_init() 993 * @go_interface_addr: GO P2P Interface Address 994 * @own_interface_addr: Own P2P Interface Address for this group 995 * @freq: Group operating frequence (in MHz) 996 * @duration1: Preferred presence duration in microseconds 997 * @interval1: Preferred presence interval in microseconds 998 * @duration2: Acceptable presence duration in microseconds 999 * @interval2: Acceptable presence interval in microseconds 1000 * Returns: 0 on success, -1 on failure 1001 * 1002 * If both duration and interval values are zero, the parameter pair is not 1003 * specified (i.e., to remove Presence Request, use duration1 = interval1 = 0). 1004 */ 1005 int p2p_presence_req(struct p2p_data *p2p, const u8 *go_interface_addr, 1006 const u8 *own_interface_addr, unsigned int freq, 1007 u32 duration1, u32 interval1, u32 duration2, 1008 u32 interval2); 1009 1010 /** 1011 * p2p_ext_listen - Set Extended Listen Timing 1012 * @p2p: P2P module context from p2p_init() 1013 * @freq: Group operating frequence (in MHz) 1014 * @period: Availability period in milliseconds (1-65535; 0 to disable) 1015 * @interval: Availability interval in milliseconds (1-65535; 0 to disable) 1016 * Returns: 0 on success, -1 on failure 1017 * 1018 * This function can be used to enable or disable (period = interval = 0) 1019 * Extended Listen Timing. When enabled, the P2P Device will become 1020 * discoverable (go into Listen State) every @interval milliseconds for at 1021 * least @period milliseconds. 1022 */ 1023 int p2p_ext_listen(struct p2p_data *p2p, unsigned int period, 1024 unsigned int interval); 1025 1026 /* Event notifications from upper layer management operations */ 1027 1028 /** 1029 * p2p_wps_success_cb - Report successfully completed WPS provisioning 1030 * @p2p: P2P module context from p2p_init() 1031 * @mac_addr: Peer address 1032 * 1033 * This function is used to report successfully completed WPS provisioning 1034 * during group formation in both GO/Registrar and client/Enrollee roles. 1035 */ 1036 void p2p_wps_success_cb(struct p2p_data *p2p, const u8 *mac_addr); 1037 1038 /** 1039 * p2p_group_formation_failed - Report failed WPS provisioning 1040 * @p2p: P2P module context from p2p_init() 1041 * 1042 * This function is used to report failed group formation. This can happen 1043 * either due to failed WPS provisioning or due to 15 second timeout during 1044 * the provisioning phase. 1045 */ 1046 void p2p_group_formation_failed(struct p2p_data *p2p); 1047 1048 /** 1049 * p2p_get_provisioning_info - Get any stored provisioning info 1050 * @p2p: P2P module context from p2p_init() 1051 * @addr: Peer P2P Device Address 1052 * Returns: WPS provisioning information (WPS config method) or 0 if no 1053 * information is available 1054 * 1055 * This function is used to retrieve stored WPS provisioning info for the given 1056 * peer. 1057 */ 1058 u16 p2p_get_provisioning_info(struct p2p_data *p2p, const u8 *addr); 1059 1060 /** 1061 * p2p_clear_provisioning_info - Clear any stored provisioning info 1062 * @p2p: P2P module context from p2p_init() 1063 * @iface_addr: Peer P2P Interface Address 1064 * 1065 * This function is used to clear stored WPS provisioning info for the given 1066 * peer. 1067 */ 1068 void p2p_clear_provisioning_info(struct p2p_data *p2p, const u8 *iface_addr); 1069 1070 1071 /* Event notifications from lower layer driver operations */ 1072 1073 /** 1074 * p2p_probe_req_rx - Report reception of a Probe Request frame 1075 * @p2p: P2P module context from p2p_init() 1076 * @addr: Source MAC address 1077 * @dst: Destination MAC address if available or %NULL 1078 * @bssid: BSSID if available or %NULL 1079 * @ie: Information elements from the Probe Request frame body 1080 * @ie_len: Length of ie buffer in octets 1081 * Returns: 0 to indicate the frame was not processed or 1 if it was 1082 */ 1083 int p2p_probe_req_rx(struct p2p_data *p2p, const u8 *addr, const u8 *dst, 1084 const u8 *bssid, const u8 *ie, size_t ie_len); 1085 1086 /** 1087 * p2p_rx_action - Report received Action frame 1088 * @p2p: P2P module context from p2p_init() 1089 * @da: Destination address of the received Action frame 1090 * @sa: Source address of the received Action frame 1091 * @bssid: Address 3 of the received Action frame 1092 * @category: Category of the received Action frame 1093 * @data: Action frame body after the Category field 1094 * @len: Length of the data buffer in octets 1095 * @freq: Frequency (in MHz) on which the frame was received 1096 */ 1097 void p2p_rx_action(struct p2p_data *p2p, const u8 *da, const u8 *sa, 1098 const u8 *bssid, u8 category, 1099 const u8 *data, size_t len, int freq); 1100 1101 /** 1102 * p2p_scan_res_handler - Indicate a P2P scan results 1103 * @p2p: P2P module context from p2p_init() 1104 * @bssid: BSSID of the scan result 1105 * @freq: Frequency of the channel on which the device was found in MHz 1106 * @level: Signal level (signal strength of the received Beacon/Probe Response 1107 * frame) 1108 * @ies: Pointer to IEs from the scan result 1109 * @ies_len: Length of the ies buffer 1110 * Returns: 0 to continue or 1 to stop scan result indication 1111 * 1112 * This function is called to indicate a scan result entry with P2P IE from a 1113 * scan requested with struct p2p_config::p2p_scan(). This can be called during 1114 * the actual scan process (i.e., whenever a new device is found) or as a 1115 * sequence of calls after the full scan has been completed. The former option 1116 * can result in optimized operations, but may not be supported by all 1117 * driver/firmware designs. The ies buffer need to include at least the P2P IE, 1118 * but it is recommended to include all IEs received from the device. The 1119 * caller does not need to check that the IEs contain a P2P IE before calling 1120 * this function since frames will be filtered internally if needed. 1121 * 1122 * This function will return 1 if it wants to stop scan result iteration (and 1123 * scan in general if it is still in progress). This is used to allow faster 1124 * start of a pending operation, e.g., to start a pending GO negotiation. 1125 */ 1126 int p2p_scan_res_handler(struct p2p_data *p2p, const u8 *bssid, int freq, 1127 int level, const u8 *ies, size_t ies_len); 1128 1129 /** 1130 * p2p_scan_res_handled - Indicate end of scan results 1131 * @p2p: P2P module context from p2p_init() 1132 * 1133 * This function is called to indicate that all P2P scan results from a scan 1134 * have been reported with zero or more calls to p2p_scan_res_handler(). This 1135 * function must be called as a response to successful 1136 * struct p2p_config::p2p_scan() call if none of the p2p_scan_res_handler() 1137 * calls stopped iteration. 1138 */ 1139 void p2p_scan_res_handled(struct p2p_data *p2p); 1140 1141 enum p2p_send_action_result { 1142 P2P_SEND_ACTION_SUCCESS /* Frame was send and acknowledged */, 1143 P2P_SEND_ACTION_NO_ACK /* Frame was sent, but not acknowledged */, 1144 P2P_SEND_ACTION_FAILED /* Frame was not sent due to a failure */ 1145 }; 1146 1147 /** 1148 * p2p_send_action_cb - Notify TX status of an Action frame 1149 * @p2p: P2P module context from p2p_init() 1150 * @freq: Channel frequency in MHz 1151 * @dst: Destination MAC address (Address 1) 1152 * @src: Source MAC address (Address 2) 1153 * @bssid: BSSID (Address 3) 1154 * @result: Result of the transmission attempt 1155 * 1156 * This function is used to indicate the result of an Action frame transmission 1157 * that was requested with struct p2p_config::send_action() callback. 1158 */ 1159 void p2p_send_action_cb(struct p2p_data *p2p, unsigned int freq, const u8 *dst, 1160 const u8 *src, const u8 *bssid, 1161 enum p2p_send_action_result result); 1162 1163 /** 1164 * p2p_listen_cb - Indicate the start of a requested Listen state 1165 * @p2p: P2P module context from p2p_init() 1166 * @freq: Listen channel frequency in MHz 1167 * @duration: Duration for the Listen state in milliseconds 1168 * 1169 * This function is used to indicate that a Listen state requested with 1170 * struct p2p_config::start_listen() callback has started. 1171 */ 1172 void p2p_listen_cb(struct p2p_data *p2p, unsigned int freq, 1173 unsigned int duration); 1174 1175 /** 1176 * p2p_listen_end - Indicate the end of a requested Listen state 1177 * @p2p: P2P module context from p2p_init() 1178 * @freq: Listen channel frequency in MHz 1179 * Returns: 0 if no operations were started, 1 if an operation was started 1180 * 1181 * This function is used to indicate that a Listen state requested with 1182 * struct p2p_config::start_listen() callback has ended. 1183 */ 1184 int p2p_listen_end(struct p2p_data *p2p, unsigned int freq); 1185 1186 void p2p_deauth_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code, 1187 const u8 *ie, size_t ie_len); 1188 1189 void p2p_disassoc_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code, 1190 const u8 *ie, size_t ie_len); 1191 1192 1193 /* Per-group P2P state for GO */ 1194 1195 struct p2p_group; 1196 1197 /** 1198 * struct p2p_group_config - P2P group configuration 1199 * 1200 * This configuration is provided to the P2P module during initialization of 1201 * the per-group information with p2p_group_init(). 1202 */ 1203 struct p2p_group_config { 1204 /** 1205 * persistent_group - Whether the group is persistent 1206 * 0 = not a persistent group 1207 * 1 = persistent group without persistent reconnect 1208 * 2 = persistent group with persistent reconnect 1209 */ 1210 int persistent_group; 1211 1212 /** 1213 * interface_addr - P2P Interface Address of the group 1214 */ 1215 u8 interface_addr[ETH_ALEN]; 1216 1217 /** 1218 * max_clients - Maximum number of clients in the group 1219 */ 1220 unsigned int max_clients; 1221 1222 /** 1223 * cb_ctx - Context to use with callback functions 1224 */ 1225 void *cb_ctx; 1226 1227 /** 1228 * ie_update - Notification of IE update 1229 * @ctx: Callback context from cb_ctx 1230 * @beacon_ies: P2P IE for Beacon frames or %NULL if no change 1231 * @proberesp_ies: P2P Ie for Probe Response frames 1232 * 1233 * P2P module uses this callback function to notify whenever the P2P IE 1234 * in Beacon or Probe Response frames should be updated based on group 1235 * events. 1236 * 1237 * The callee is responsible for freeing the returned buffer(s) with 1238 * wpabuf_free(). 1239 */ 1240 void (*ie_update)(void *ctx, struct wpabuf *beacon_ies, 1241 struct wpabuf *proberesp_ies); 1242 1243 /** 1244 * idle_update - Notification of changes in group idle state 1245 * @ctx: Callback context from cb_ctx 1246 * @idle: Whether the group is idle (no associated stations) 1247 */ 1248 void (*idle_update)(void *ctx, int idle); 1249 }; 1250 1251 /** 1252 * p2p_group_init - Initialize P2P group 1253 * @p2p: P2P module context from p2p_init() 1254 * @config: P2P group configuration (will be freed by p2p_group_deinit()) 1255 * Returns: Pointer to private data or %NULL on failure 1256 * 1257 * This function is used to initialize per-group P2P module context. Currently, 1258 * this is only used to manage GO functionality and P2P clients do not need to 1259 * create an instance of this per-group information. 1260 */ 1261 struct p2p_group * p2p_group_init(struct p2p_data *p2p, 1262 struct p2p_group_config *config); 1263 1264 /** 1265 * p2p_group_deinit - Deinitialize P2P group 1266 * @group: P2P group context from p2p_group_init() 1267 */ 1268 void p2p_group_deinit(struct p2p_group *group); 1269 1270 /** 1271 * p2p_group_notif_assoc - Notification of P2P client association with GO 1272 * @group: P2P group context from p2p_group_init() 1273 * @addr: Interface address of the P2P client 1274 * @ie: IEs from the (Re)association Request frame 1275 * @len: Length of the ie buffer in octets 1276 * Returns: 0 on success, -1 on failure 1277 */ 1278 int p2p_group_notif_assoc(struct p2p_group *group, const u8 *addr, 1279 const u8 *ie, size_t len); 1280 1281 /** 1282 * p2p_group_assoc_resp_ie - Build P2P IE for (re)association response 1283 * @group: P2P group context from p2p_group_init() 1284 * @status: Status value (P2P_SC_SUCCESS if association succeeded) 1285 * Returns: P2P IE for (Re)association Response or %NULL on failure 1286 * 1287 * The caller is responsible for freeing the returned buffer with 1288 * wpabuf_free(). 1289 */ 1290 struct wpabuf * p2p_group_assoc_resp_ie(struct p2p_group *group, u8 status); 1291 1292 /** 1293 * p2p_group_notif_disassoc - Notification of P2P client disassociation from GO 1294 * @group: P2P group context from p2p_group_init() 1295 * @addr: Interface address of the P2P client 1296 */ 1297 void p2p_group_notif_disassoc(struct p2p_group *group, const u8 *addr); 1298 1299 /** 1300 * p2p_group_notif_formation_done - Notification of completed group formation 1301 * @group: P2P group context from p2p_group_init() 1302 */ 1303 void p2p_group_notif_formation_done(struct p2p_group *group); 1304 1305 /** 1306 * p2p_group_notif_noa - Notification of NoA change 1307 * @group: P2P group context from p2p_group_init() 1308 * @noa: Notice of Absence attribute payload, %NULL if none 1309 * @noa_len: Length of noa buffer in octets 1310 * Returns: 0 on success, -1 on failure 1311 * 1312 * Notify the P2P group management about a new NoA contents. This will be 1313 * inserted into the P2P IEs in Beacon and Probe Response frames with rest of 1314 * the group information. 1315 */ 1316 int p2p_group_notif_noa(struct p2p_group *group, const u8 *noa, 1317 size_t noa_len); 1318 1319 /** 1320 * p2p_group_match_dev_type - Match device types in group with requested type 1321 * @group: P2P group context from p2p_group_init() 1322 * @wps: WPS TLVs from Probe Request frame (concatenated WPS IEs) 1323 * Returns: 1 on match, 0 on mismatch 1324 * 1325 * This function can be used to match the Requested Device Type attribute in 1326 * WPS IE with the device types of a group member for deciding whether a GO 1327 * should reply to a Probe Request frame. Match will be reported if the WPS IE 1328 * is not requested any specific device type. 1329 */ 1330 int p2p_group_match_dev_type(struct p2p_group *group, struct wpabuf *wps); 1331 1332 /** 1333 * p2p_group_match_dev_id - Match P2P Device Address in group with requested device id 1334 */ 1335 int p2p_group_match_dev_id(struct p2p_group *group, struct wpabuf *p2p); 1336 1337 /** 1338 * p2p_group_go_discover - Send GO Discoverability Request to a group client 1339 * @group: P2P group context from p2p_group_init() 1340 * Returns: 0 on success (frame scheduled); -1 if client was not found 1341 */ 1342 int p2p_group_go_discover(struct p2p_group *group, const u8 *dev_id, 1343 const u8 *searching_dev, int rx_freq); 1344 1345 1346 /* Generic helper functions */ 1347 1348 /** 1349 * p2p_ie_text - Build text format description of P2P IE 1350 * @p2p_ie: P2P IE 1351 * @buf: Buffer for returning text 1352 * @end: Pointer to the end of the buf area 1353 * Returns: Number of octets written to the buffer or -1 on failure 1354 * 1355 * This function can be used to parse P2P IE contents into text format 1356 * field=value lines. 1357 */ 1358 int p2p_ie_text(struct wpabuf *p2p_ie, char *buf, char *end); 1359 1360 /** 1361 * p2p_scan_result_text - Build text format description of P2P IE 1362 * @ies: Information elements from scan results 1363 * @ies_len: ies buffer length in octets 1364 * @buf: Buffer for returning text 1365 * @end: Pointer to the end of the buf area 1366 * Returns: Number of octets written to the buffer or -1 on failure 1367 * 1368 * This function can be used to parse P2P IE contents into text format 1369 * field=value lines. 1370 */ 1371 int p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf, char *end); 1372 1373 /** 1374 * p2p_parse_dev_addr - Parse P2P Device Address from P2P IE(s) 1375 * @ies: Information elements from scan results 1376 * @ies_len: ies buffer length in octets 1377 * @dev_addr: Buffer for returning P2P Device Address 1378 * Returns: 0 on success or -1 if P2P Device Address could not be parsed 1379 */ 1380 int p2p_parse_dev_addr(const u8 *ies, size_t ies_len, u8 *dev_addr); 1381 1382 /** 1383 * p2p_assoc_req_ie - Build P2P IE for (Re)Association Request frame 1384 * @p2p: P2P module context from p2p_init() 1385 * @bssid: BSSID 1386 * @buf: Buffer for writing the P2P IE 1387 * @len: Maximum buf length in octets 1388 * @p2p_group: Whether this is for association with a P2P GO 1389 * @p2p_ie: Reassembled P2P IE data from scan results or %NULL if none 1390 * Returns: Number of octets written into buf or -1 on failure 1391 */ 1392 int p2p_assoc_req_ie(struct p2p_data *p2p, const u8 *bssid, u8 *buf, 1393 size_t len, int p2p_group, struct wpabuf *p2p_ie); 1394 1395 /** 1396 * p2p_scan_ie - Build P2P IE for Probe Request 1397 * @p2p: P2P module context from p2p_init() 1398 * @ies: Buffer for writing P2P IE 1399 * @dev_id: Device ID to search for or %NULL for any 1400 */ 1401 void p2p_scan_ie(struct p2p_data *p2p, struct wpabuf *ies, const u8 *dev_id); 1402 1403 /** 1404 * p2p_scan_ie_buf_len - Get maximum buffer length needed for p2p_scan_ie 1405 * @p2p: P2P module context from p2p_init() 1406 * Returns: Number of octets that p2p_scan_ie() may add to the buffer 1407 */ 1408 size_t p2p_scan_ie_buf_len(struct p2p_data *p2p); 1409 1410 /** 1411 * p2p_go_params - Generate random P2P group parameters 1412 * @p2p: P2P module context from p2p_init() 1413 * @params: Buffer for parameters 1414 * Returns: 0 on success, -1 on failure 1415 */ 1416 int p2p_go_params(struct p2p_data *p2p, struct p2p_go_neg_results *params); 1417 1418 /** 1419 * p2p_get_group_capab - Get Group Capability from P2P IE data 1420 * @p2p_ie: P2P IE(s) contents 1421 * Returns: Group Capability 1422 */ 1423 u8 p2p_get_group_capab(const struct wpabuf *p2p_ie); 1424 1425 /** 1426 * p2p_get_cross_connect_disallowed - Does WLAN AP disallows cross connection 1427 * @p2p_ie: P2P IE(s) contents 1428 * Returns: 0 if cross connection is allow, 1 if not 1429 */ 1430 int p2p_get_cross_connect_disallowed(const struct wpabuf *p2p_ie); 1431 1432 /** 1433 * p2p_get_go_dev_addr - Get P2P Device Address from P2P IE data 1434 * @p2p_ie: P2P IE(s) contents 1435 * Returns: Pointer to P2P Device Address or %NULL if not included 1436 */ 1437 const u8 * p2p_get_go_dev_addr(const struct wpabuf *p2p_ie); 1438 1439 /** 1440 * p2p_get_peer_info - Get P2P peer information 1441 * @p2p: P2P module context from p2p_init() 1442 * @addr: P2P Device Address of the peer or %NULL to indicate the first peer 1443 * @next: Whether to select the peer entry following the one indicated by addr 1444 * Returns: Pointer to peer info or %NULL if not found 1445 */ 1446 const struct p2p_peer_info * p2p_get_peer_info(struct p2p_data *p2p, 1447 const u8 *addr, int next); 1448 1449 /** 1450 * p2p_get_peer_info_txt - Get internal P2P peer information in text format 1451 * @info: Pointer to P2P peer info from p2p_get_peer_info() 1452 * @buf: Buffer for returning text 1453 * @buflen: Maximum buffer length 1454 * Returns: Number of octets written to the buffer or -1 on failure 1455 * 1456 * Note: This information is internal to the P2P module and subject to change. 1457 * As such, this should not really be used by external programs for purposes 1458 * other than debugging. 1459 */ 1460 int p2p_get_peer_info_txt(const struct p2p_peer_info *info, 1461 char *buf, size_t buflen); 1462 1463 /** 1464 * p2p_peer_known - Check whether P2P peer is known 1465 * @p2p: P2P module context from p2p_init() 1466 * @addr: P2P Device Address of the peer 1467 * Returns: 1 if the specified device is in the P2P peer table or 0 if not 1468 */ 1469 int p2p_peer_known(struct p2p_data *p2p, const u8 *addr); 1470 1471 /** 1472 * p2p_set_client_discoverability - Set client discoverability capability 1473 * @p2p: P2P module context from p2p_init() 1474 * @enabled: Whether client discoverability will be enabled 1475 * 1476 * This function can be used to disable (and re-enable) client discoverability. 1477 * This capability is enabled by default and should not be disabled in normal 1478 * use cases, i.e., this is mainly for testing purposes. 1479 */ 1480 void p2p_set_client_discoverability(struct p2p_data *p2p, int enabled); 1481 1482 /** 1483 * p2p_set_managed_oper - Set managed P2P Device operations capability 1484 * @p2p: P2P module context from p2p_init() 1485 * @enabled: Whether managed P2P Device operations will be enabled 1486 */ 1487 void p2p_set_managed_oper(struct p2p_data *p2p, int enabled); 1488 1489 int p2p_set_listen_channel(struct p2p_data *p2p, u8 reg_class, u8 channel); 1490 1491 int p2p_set_ssid_postfix(struct p2p_data *p2p, const u8 *postfix, size_t len); 1492 1493 int p2p_get_interface_addr(struct p2p_data *p2p, const u8 *dev_addr, 1494 u8 *iface_addr); 1495 int p2p_get_dev_addr(struct p2p_data *p2p, const u8 *iface_addr, 1496 u8 *dev_addr); 1497 1498 void p2p_set_peer_filter(struct p2p_data *p2p, const u8 *addr); 1499 1500 /** 1501 * p2p_set_cross_connect - Set cross connection capability 1502 * @p2p: P2P module context from p2p_init() 1503 * @enabled: Whether cross connection will be enabled 1504 */ 1505 void p2p_set_cross_connect(struct p2p_data *p2p, int enabled); 1506 1507 int p2p_get_oper_freq(struct p2p_data *p2p, const u8 *iface_addr); 1508 1509 /** 1510 * p2p_set_intra_bss_dist - Set intra BSS distribution 1511 * @p2p: P2P module context from p2p_init() 1512 * @enabled: Whether intra BSS distribution will be enabled 1513 */ 1514 void p2p_set_intra_bss_dist(struct p2p_data *p2p, int enabled); 1515 1516 /** 1517 * p2p_supported_freq - Check whether channel is supported for P2P 1518 * @p2p: P2P module context from p2p_init() 1519 * @freq: Channel frequency in MHz 1520 * Returns: 0 if channel not usable for P2P, 1 if usable for P2P 1521 */ 1522 int p2p_supported_freq(struct p2p_data *p2p, unsigned int freq); 1523 1524 void p2p_update_channel_list(struct p2p_data *p2p, struct p2p_channels *chan); 1525 1526 /** 1527 * p2p_set_best_channels - Update best channel information 1528 * @p2p: P2P module context from p2p_init() 1529 * @freq_24: Frequency (MHz) of best channel in 2.4 GHz band 1530 * @freq_5: Frequency (MHz) of best channel in 5 GHz band 1531 * @freq_overall: Frequency (MHz) of best channel overall 1532 */ 1533 void p2p_set_best_channels(struct p2p_data *p2p, int freq_24, int freq_5, 1534 int freq_overall); 1535 1536 const u8 * p2p_get_go_neg_peer(struct p2p_data *p2p); 1537 1538 /** 1539 * p2p_get_group_num_members - Get number of members in group 1540 * @group: P2P group context from p2p_group_init() 1541 * Returns: Number of members in the group 1542 */ 1543 unsigned int p2p_get_group_num_members(struct p2p_group *group); 1544 1545 /** 1546 * p2p_iterate_group_members - Iterate group members 1547 * @group: P2P group context from p2p_group_init() 1548 * @next: iteration pointer, must be a pointer to a void * that is set to %NULL 1549 * on the first call and not modified later 1550 * Returns: A P2P Interface Address for each call and %NULL for no more members 1551 */ 1552 const u8 * p2p_iterate_group_members(struct p2p_group *group, void **next); 1553 1554 /** 1555 * p2p_group_get_dev_addr - Get a P2P Device Address of a client in a group 1556 * @group: P2P group context from p2p_group_init() 1557 * @addr: P2P Interface Address of the client 1558 * Returns: P2P Device Address of the client if found or %NULL if no match 1559 * found 1560 */ 1561 const u8 * p2p_group_get_dev_addr(struct p2p_group *group, const u8 *addr); 1562 1563 /** 1564 * p2p_group_is_client_connected - Check whether a specific client is connected 1565 * @group: P2P group context from p2p_group_init() 1566 * @addr: P2P Device Address of the client 1567 * Returns: 1 if client is connected or 0 if not 1568 */ 1569 int p2p_group_is_client_connected(struct p2p_group *group, const u8 *dev_addr); 1570 1571 /** 1572 * p2p_get_peer_found - Get P2P peer info structure of a found peer 1573 * @p2p: P2P module context from p2p_init() 1574 * @addr: P2P Device Address of the peer or %NULL to indicate the first peer 1575 * @next: Whether to select the peer entry following the one indicated by addr 1576 * Returns: The first P2P peer info available or %NULL if no such peer exists 1577 */ 1578 const struct p2p_peer_info * 1579 p2p_get_peer_found(struct p2p_data *p2p, const u8 *addr, int next); 1580 1581 /** 1582 * p2p_remove_wps_vendor_extensions - Remove WPS vendor extensions 1583 * @p2p: P2P module context from p2p_init() 1584 */ 1585 void p2p_remove_wps_vendor_extensions(struct p2p_data *p2p); 1586 1587 /** 1588 * p2p_add_wps_vendor_extension - Add a WPS vendor extension 1589 * @p2p: P2P module context from p2p_init() 1590 * @vendor_ext: The vendor extensions to add 1591 * Returns: 0 on success, -1 on failure 1592 * 1593 * The wpabuf structures in the array are owned by the P2P 1594 * module after this call. 1595 */ 1596 int p2p_add_wps_vendor_extension(struct p2p_data *p2p, 1597 const struct wpabuf *vendor_ext); 1598 1599 /** 1600 * p2p_set_oper_channel - Set the P2P operating channel 1601 * @p2p: P2P module context from p2p_init() 1602 * @op_reg_class: Operating regulatory class to set 1603 * @op_channel: operating channel to set 1604 * @cfg_op_channel : Whether op_channel is hardcoded in configuration 1605 * Returns: 0 on success, -1 on failure 1606 */ 1607 int p2p_set_oper_channel(struct p2p_data *p2p, u8 op_reg_class, u8 op_channel, 1608 int cfg_op_channel); 1609 1610 /** 1611 * p2p_in_progress - Check whether a P2P operation is progress 1612 * @p2p: P2P module context from p2p_init() 1613 * Returns: 0 if P2P module is idle or 1 if an operation is in progress 1614 */ 1615 int p2p_in_progress(struct p2p_data *p2p); 1616 1617 #ifdef ANDROID_P2P 1618 /** 1619 * p2p_search_in_progress - Check whether a P2P SEARCH is in progress 1620 * @p2p: P2P module context from p2p_init() 1621 * Returns: 0 if P2P module is idle or 1 if an operation is in progress 1622 */ 1623 int p2p_search_in_progress(struct p2p_data *p2p); 1624 1625 /** 1626 * p2p_search_pending - Check whether there is a deferred P2P SEARCH 1627 * @p2p: P2P module context from p2p_init() 1628 * Returns: 0 if there is no deferred P2P search or 1 if there is one 1629 */ 1630 int p2p_search_pending(struct p2p_data *p2p); 1631 #endif 1632 1633 /** 1634 * p2p_other_scan_completed - Notify completion of non-P2P scan 1635 * @p2p: P2P module context from p2p_init() 1636 * Returns: 0 if P2P module is idle or 1 if an operation was started 1637 */ 1638 int p2p_other_scan_completed(struct p2p_data *p2p); 1639 1640 const char * p2p_wps_method_text(enum p2p_wps_method method); 1641 1642 #endif /* P2P_H */ 1643