2 * Wi-Fi Direct - P2P module
3 * Copyright (c) 2009-2010, Atheros Communications
5 * This program is free software; you can redistribute it and/or modify
6 * it under the terms of the GNU General Public License version 2 as
7 * published by the Free Software Foundation.
9 * Alternatively, this software may be distributed under the terms of BSD
12 * See README and COPYING for more details.
19 * P2P_MAX_REG_CLASSES - Maximum number of regulatory classes
21 #define P2P_MAX_REG_CLASSES 10
24 * P2P_MAX_REG_CLASS_CHANNELS - Maximum number of channels per regulatory class
26 #define P2P_MAX_REG_CLASS_CHANNELS 20
29 * struct p2p_channels - List of supported channels
33 * struct p2p_reg_class - Supported regulatory class
35 struct p2p_reg_class {
37 * reg_class - Regulatory class (IEEE 802.11-2007, Annex J)
42 * channel - Supported channels
44 u8 channel[P2P_MAX_REG_CLASS_CHANNELS];
47 * channels - Number of channel entries in use
50 } reg_class[P2P_MAX_REG_CLASSES];
53 * reg_classes - Number of reg_class entries in use
59 WPS_NOT_READY, WPS_PIN_LABEL, WPS_PIN_DISPLAY, WPS_PIN_KEYPAD, WPS_PBC
63 * struct p2p_go_neg_results - P2P Group Owner Negotiation results
65 struct p2p_go_neg_results {
67 * status - Negotiation result (Status Code)
69 * 0 (P2P_SC_SUCCESS) indicates success. Non-zero values indicate
75 * role_go - Whether local end is Group Owner
80 * freq - Frequency of the group operational channel in MHz
85 * ssid - SSID of the group
90 * ssid_len - Length of SSID in octets
95 * passphrase - WPA2-Personal passphrase for the group (GO only)
100 * peer_device_addr - P2P Device Address of the peer
102 u8 peer_device_addr[ETH_ALEN];
105 * peer_interface_addr - P2P Interface Address of the peer
107 u8 peer_interface_addr[ETH_ALEN];
110 * wps_method - WPS method to be used during provisioning
112 enum p2p_wps_method wps_method;
114 #define P2P_MAX_CHANNELS 50
117 * freq_list - Zero-terminated list of possible operational channels
119 int freq_list[P2P_MAX_CHANNELS];
122 * persistent_group - Whether the group should be made persistent
124 int persistent_group;
127 * peer_config_timeout - Peer configuration timeout (in 10 msec units)
129 unsigned int peer_config_timeout;
138 P2P_SCAN_SOCIAL_PLUS_ONE
142 * struct p2p_config - P2P configuration
144 * This configuration is provided to the P2P module during initialization with
149 * country - Country code to use in P2P operations
154 * reg_class - Regulatory class for own listen channel
159 * channel - Own listen channel
164 * Regulatory class for own operational channel
169 * op_channel - Own operational channel
174 * channels - Own supported regulatory classes and channels
176 * List of supposerted channels per regulatory class. The regulatory
177 * classes are defined in IEEE Std 802.11-2007 Annex J and the
178 * numbering of the clases depends on the configured country code.
180 struct p2p_channels channels;
183 * pri_dev_type - Primary Device Type (see WPS)
188 * P2P_SEC_DEVICE_TYPES - Maximum number of secondary device types
190 #define P2P_SEC_DEVICE_TYPES 5
193 * sec_dev_type - Optional secondary device types
195 u8 sec_dev_type[P2P_SEC_DEVICE_TYPES][8];
198 * dev_addr - P2P Device Address
200 u8 dev_addr[ETH_ALEN];
203 * dev_name - Device Name
208 * num_sec_dev_types - Number of sec_dev_type entries
210 size_t num_sec_dev_types;
213 * concurrent_operations - Whether concurrent operations are supported
215 int concurrent_operations;
218 * max_peers - Maximum number of discovered peers to remember
220 * If more peers are discovered, older entries will be removed to make
221 * room for the new ones.
226 * p2p_intra_bss - Intra BSS communication is supported
231 * ssid_postfix - Postfix data to add to the SSID
233 * This data will be added to the end of the SSID after the
234 * DIRECT-<random two octets> prefix.
236 u8 ssid_postfix[32 - 9];
239 * ssid_postfix_len - Length of the ssid_postfix data
241 size_t ssid_postfix_len;
244 * msg_ctx - Context to use with wpa_msg() calls
249 * cb_ctx - Context to use with callback functions
254 /* Callbacks to request lower layer driver operations */
257 * p2p_scan - Request a P2P scan/search
258 * @ctx: Callback context from cb_ctx
260 * @freq: Specific frequency (MHz) to scan or 0 for no restriction
261 * Returns: 0 on success, -1 on failure
263 * This callback function is used to request a P2P scan or search
264 * operation to be completed. Type type argument specifies which type
265 * of scan is to be done. @P2P_SCAN_SOCIAL indicates that only the
266 * social channels (1, 6, 11) should be scanned. @P2P_SCAN_FULL
267 * indicates that all channels are to be scanned. @P2P_SCAN_SPECIFIC
268 * request a scan of a single channel specified by freq.
269 * @P2P_SCAN_SOCIAL_PLUS_ONE request scan of all the social channels
270 * plus one extra channel specified by freq.
272 * The full scan is used for the initial scan to find group owners from
273 * all. The other types are used during search phase scan of the social
274 * channels (with potential variation if the Listen channel of the
275 * target peer is known or if other channels are scanned in steps).
277 * The scan results are returned after this call by calling
278 * p2p_scan_res_handler() for each scan result that has a P2P IE and
279 * then calling p2p_scan_res_handled() to indicate that all scan
280 * results have been indicated.
282 int (*p2p_scan)(void *ctx, enum p2p_scan_type type, int freq);
285 * send_probe_resp - Transmit a Probe Response frame
286 * @ctx: Callback context from cb_ctx
287 * @buf: Probe Response frame (including the header and body)
288 * Returns: 0 on success, -1 on failure
290 * This function is used to reply to Probe Request frames that were
291 * indicated with a call to p2p_probe_req_rx(). The response is to be
292 * sent on the same channel or to be dropped if the driver is not
293 * anymore listening to Probe Request frames.
295 * Alternatively, the responsibility for building the Probe Response
296 * frames in Listen state may be in another system component in which
297 * case this function need to be implemented (i.e., the function
298 * pointer can be %NULL). The WPS and P2P IEs to be added for Probe
299 * Response frames in such a case are available from the
300 * start_listen() callback. It should be noted that the received Probe
301 * Request frames must be indicated by calling p2p_probe_req_rx() even
302 * if this send_probe_resp() is not used.
304 int (*send_probe_resp)(void *ctx, const struct wpabuf *buf);
307 * send_action - Transmit an Action frame
308 * @ctx: Callback context from cb_ctx
309 * @freq: Frequency in MHz for the channel on which to transmit
310 * @dst: Destination MAC address (Address 1)
311 * @src: Source MAC address (Address 2)
312 * @bssid: BSSID (Address 3)
313 * @buf: Frame body (starting from Category field)
314 * @len: Length of buf in octets
315 * @wait_time: How many msec to wait for a response frame
316 * Returns: 0 on success, -1 on failure
318 * The Action frame may not be transmitted immediately and the status
319 * of the transmission must be reported by calling
320 * p2p_send_action_cb() once the frame has either been transmitted or
321 * it has been dropped due to excessive retries or other failure to
324 int (*send_action)(void *ctx, unsigned int freq, const u8 *dst,
325 const u8 *src, const u8 *bssid, const u8 *buf,
326 size_t len, unsigned int wait_time);
329 * send_action_done - Notify that Action frame sequence was completed
330 * @ctx: Callback context from cb_ctx
332 * This function is called when the Action frame sequence that was
333 * started with send_action() has been completed, i.e., when there is
334 * no need to wait for a response from the destination peer anymore.
336 void (*send_action_done)(void *ctx);
339 * start_listen - Start Listen state
340 * @ctx: Callback context from cb_ctx
341 * @freq: Frequency of the listen channel in MHz
342 * @duration: Duration for the Listen state in milliseconds
343 * @probe_resp_ie: IE(s) to be added to Probe Response frames
344 * Returns: 0 on success, -1 on failure
346 * This Listen state may not start immediately since the driver may
347 * have other pending operations to complete first. Once the Listen
348 * state has started, p2p_listen_cb() must be called to notify the P2P
349 * module. Once the Listen state is stopped, p2p_listen_end() must be
350 * called to notify the P2P module that the driver is not in the Listen
353 * If the send_probe_resp() is not used for generating the response,
354 * the IEs from probe_resp_ie need to be added to the end of the Probe
355 * Response frame body. If send_probe_resp() is used, the probe_resp_ie
356 * information can be ignored.
358 int (*start_listen)(void *ctx, unsigned int freq,
359 unsigned int duration,
360 const struct wpabuf *probe_resp_ie);
362 * stop_listen - Stop Listen state
363 * @ctx: Callback context from cb_ctx
365 * This callback can be used to stop a Listen state operation that was
366 * previously requested with start_listen().
368 void (*stop_listen)(void *ctx);
371 * get_noa - Get current Notice of Absence attribute payload
372 * @ctx: Callback context from cb_ctx
373 * @interface_addr: P2P Interface Address of the GO
374 * @buf: Buffer for returning NoA
375 * @buf_len: Buffer length in octets
376 * Returns: Number of octets used in buf, 0 to indicate no NoA is being
377 * advertized, or -1 on failure
379 * This function is used to fetch the current Notice of Absence
380 * attribute value from GO.
382 int (*get_noa)(void *ctx, const u8 *interface_addr, u8 *buf,
385 /* Callbacks to notify events to upper layer management entity */
388 * dev_found - Notification of a found P2P Device
389 * @ctx: Callback context from cb_ctx
390 * @addr: Source address of the message triggering this notification
391 * @dev_addr: P2P Device Address of the found P2P Device
392 * @pri_dev_type: Primary Device Type
393 * @dev_name: Device Name
394 * @config_methods: Configuration Methods
395 * @dev_capab: Device Capabilities
396 * @group_capab: Group Capabilities
398 * This callback is used to notify that a new P2P Device has been
399 * found. This may happen, e.g., during Search state based on scan
400 * results or during Listen state based on receive Probe Request and
401 * Group Owner Negotiation Request.
403 void (*dev_found)(void *ctx, const u8 *addr, const u8 *dev_addr,
404 const u8 *pri_dev_type, const char *dev_name,
405 u16 config_methods, u8 dev_capab, u8 group_capab);
408 * go_neg_req_rx - Notification of a receive GO Negotiation Request
409 * @ctx: Callback context from cb_ctx
410 * @src: Source address of the message triggering this notification
411 * @dev_passwd_id: WPS Device Password ID
413 * This callback is used to notify that a P2P Device is requesting
414 * group owner negotiation with us, but we do not have all the
415 * necessary information to start GO Negotiation. This indicates that
416 * the local user has not authorized the connection yet by providing a
417 * PIN or PBC button press. This information can be provided with a
418 * call to p2p_connect().
420 void (*go_neg_req_rx)(void *ctx, const u8 *src, u16 dev_passwd_id);
423 * go_neg_completed - Notification of GO Negotiation results
424 * @ctx: Callback context from cb_ctx
425 * @res: GO Negotiation results
427 * This callback is used to notify that Group Owner Negotiation has
428 * been completed. Non-zero struct p2p_go_neg_results::status indicates
429 * failed negotiation. In case of success, this function is responsible
430 * for creating a new group interface (or using the existing interface
431 * depending on driver features), setting up the group interface in
432 * proper mode based on struct p2p_go_neg_results::role_go and
433 * initializing WPS provisioning either as a Registrar (if GO) or as an
434 * Enrollee. Successful WPS provisioning must be indicated by calling
435 * p2p_wps_success_cb(). The callee is responsible for timing out group
436 * formation if WPS provisioning cannot be completed successfully
439 void (*go_neg_completed)(void *ctx, struct p2p_go_neg_results *res);
442 * sd_request - Callback on Service Discovery Request
443 * @ctx: Callback context from cb_ctx
444 * @freq: Frequency (in MHz) of the channel
445 * @sa: Source address of the request
446 * @dialog_token: Dialog token
447 * @update_indic: Service Update Indicator from the source of request
448 * @tlvs: P2P Service Request TLV(s)
449 * @tlvs_len: Length of tlvs buffer in octets
451 * This callback is used to indicate reception of a service discovery
452 * request. Response to the query must be indicated by calling
453 * p2p_sd_response() with the context information from the arguments to
454 * this callback function.
456 * This callback handler can be set to %NULL to indicate that service
457 * discovery is not supported.
459 void (*sd_request)(void *ctx, int freq, const u8 *sa, u8 dialog_token,
460 u16 update_indic, const u8 *tlvs, size_t tlvs_len);
463 * sd_response - Callback on Service Discovery Response
464 * @ctx: Callback context from cb_ctx
465 * @sa: Source address of the request
466 * @update_indic: Service Update Indicator from the source of response
467 * @tlvs: P2P Service Response TLV(s)
468 * @tlvs_len: Length of tlvs buffer in octets
470 * This callback is used to indicate reception of a service discovery
471 * response. This callback handler can be set to %NULL if no service
472 * discovery requests are used. The information provided with this call
473 * is replies to the queries scheduled with p2p_sd_request().
475 void (*sd_response)(void *ctx, const u8 *sa, u16 update_indic,
476 const u8 *tlvs, size_t tlvs_len);
479 * prov_disc_req - Callback on Provisiong Discovery Request
480 * @ctx: Callback context from cb_ctx
481 * @peer: Source address of the request
482 * @config_methods: Requested WPS Config Method
483 * @dev_addr: P2P Device Address of the found P2P Device
484 * @pri_dev_type: Primary Device Type
485 * @dev_name: Device Name
486 * @supp_config_methods: Supported configuration Methods
487 * @dev_capab: Device Capabilities
488 * @group_capab: Group Capabilities
490 * This callback is used to indicate reception of a Provision Discovery
491 * Request frame that the P2P module accepted.
493 void (*prov_disc_req)(void *ctx, const u8 *peer, u16 config_methods,
494 const u8 *dev_addr, const u8 *pri_dev_type,
495 const char *dev_name, u16 supp_config_methods,
496 u8 dev_capab, u8 group_capab);
499 * prov_disc_resp - Callback on Provisiong Discovery Response
500 * @ctx: Callback context from cb_ctx
501 * @peer: Source address of the response
502 * @config_methods: Value from p2p_prov_disc_req() or 0 on failure
504 * This callback is used to indicate reception of a Provision Discovery
505 * Response frame for a pending request scheduled with
506 * p2p_prov_disc_req(). This callback handler can be set to %NULL if
507 * provision discovery is not used.
509 void (*prov_disc_resp)(void *ctx, const u8 *peer, u16 config_methods);
512 * invitation_process - Optional callback for processing Invitations
513 * @ctx: Callback context from cb_ctx
514 * @sa: Source address of the Invitation Request
515 * @bssid: P2P Group BSSID from the request or %NULL if not included
516 * @go_dev_addr: GO Device Address from P2P Group ID
517 * @ssid: SSID from P2P Group ID
518 * @ssid_len: Length of ssid buffer in octets
519 * @go: Variable for returning whether the local end is GO in the group
520 * @group_bssid: Buffer for returning P2P Group BSSID (if local end GO)
521 * @force_freq: Variable for returning forced frequency for the group
522 * @persistent_group: Whether this is an invitation to reinvoke a
523 * persistent group (instead of invitation to join an active
525 * Returns: Status code (P2P_SC_*)
527 * This optional callback can be used to implement persistent reconnect
528 * by allowing automatic restarting of persistent groups without user
529 * interaction. If this callback is not implemented (i.e., is %NULL),
530 * the received Invitation Request frames are replied with
531 * %P2P_SC_REQ_RECEIVED status and indicated to upper layer with the
532 * invitation_result() callback.
534 * If the requested parameters are acceptable and the group is known,
535 * %P2P_SC_SUCCESS may be returned. If the requested group is unknown,
536 * %P2P_SC_FAIL_UNKNOWN_GROUP should be returned. %P2P_SC_REQ_RECEIVED
537 * can be returned if there is not enough data to provide immediate
538 * response, i.e., if some sort of user interaction is needed. The
539 * invitation_received() callback will be called in that case
540 * immediately after this call.
542 u8 (*invitation_process)(void *ctx, const u8 *sa, const u8 *bssid,
543 const u8 *go_dev_addr, const u8 *ssid,
544 size_t ssid_len, int *go, u8 *group_bssid,
545 int *force_freq, int persistent_group);
548 * invitation_received - Callback on Invitation Request RX
549 * @ctx: Callback context from cb_ctx
550 * @sa: Source address of the Invitation Request
551 * @bssid: P2P Group BSSID or %NULL if not received
552 * @ssid: SSID of the group
553 * @ssid_len: Length of ssid in octets
554 * @go_dev_addr: GO Device Address
555 * @status: Response Status
556 * @op_freq: Operational frequency for the group
558 * This callback is used to indicate sending of an Invitation Response
559 * for a received Invitation Request. If status == 0 (success), the
560 * upper layer code is responsible for starting the group. status == 1
561 * indicates need to get user authorization for the group. Other status
562 * values indicate that the invitation request was rejected.
564 void (*invitation_received)(void *ctx, const u8 *sa, const u8 *bssid,
565 const u8 *ssid, size_t ssid_len,
566 const u8 *go_dev_addr, u8 status,
570 * invitation_result - Callback on Invitation result
571 * @ctx: Callback context from cb_ctx
572 * @status: Negotiation result (Status Code)
573 * @bssid: P2P Group BSSID or %NULL if not received
575 * This callback is used to indicate result of an Invitation procedure
576 * started with a call to p2p_invite(). The indicated status code is
577 * the value received from the peer in Invitation Response with 0
578 * (P2P_SC_SUCCESS) indicating success or -1 to indicate a timeout or a
579 * local failure in transmitting the Invitation Request.
581 void (*invitation_result)(void *ctx, int status, const u8 *bssid);
585 /* P2P module initialization/deinitialization */
588 * p2p_init - Initialize P2P module
589 * @cfg: P2P module configuration
590 * Returns: Pointer to private data or %NULL on failure
592 * This function is used to initialize global P2P module context (one per
593 * device). The P2P module will keep a copy of the configuration data, so the
594 * caller does not need to maintain this structure. However, the callback
595 * functions and the context parameters to them must be kept available until
596 * the P2P module is deinitialized with p2p_deinit().
598 struct p2p_data * p2p_init(const struct p2p_config *cfg);
601 * p2p_deinit - Deinitialize P2P module
602 * @p2p: P2P module context from p2p_init()
604 void p2p_deinit(struct p2p_data *p2p);
607 * p2p_flush - Flush P2P module state
608 * @p2p: P2P module context from p2p_init()
610 * This command removes the P2P module state like peer device entries.
612 void p2p_flush(struct p2p_data *p2p);
615 * p2p_set_dev_name - Set device name
616 * @p2p: P2P module context from p2p_init()
617 * Returns: 0 on success, -1 on failure
619 * This function can be used to update the P2P module configuration with
620 * information that was not available at the time of the p2p_init() call.
622 int p2p_set_dev_name(struct p2p_data *p2p, const char *dev_name);
625 * p2p_set_pri_dev_type - Set primary device type
626 * @p2p: P2P module context from p2p_init()
627 * Returns: 0 on success, -1 on failure
629 * This function can be used to update the P2P module configuration with
630 * information that was not available at the time of the p2p_init() call.
632 int p2p_set_pri_dev_type(struct p2p_data *p2p, const u8 *pri_dev_type);
635 * p2p_set_sec_dev_types - Set secondary device types
636 * @p2p: P2P module context from p2p_init()
637 * Returns: 0 on success, -1 on failure
639 * This function can be used to update the P2P module configuration with
640 * information that was not available at the time of the p2p_init() call.
642 int p2p_set_sec_dev_types(struct p2p_data *p2p, const u8 dev_types[][8],
643 size_t num_dev_types);
645 int p2p_set_country(struct p2p_data *p2p, const char *country);
648 /* Commands from upper layer management entity */
650 enum p2p_discovery_type {
651 P2P_FIND_START_WITH_FULL,
652 P2P_FIND_ONLY_SOCIAL,
657 * p2p_find - Start P2P Find (Device Discovery)
658 * @p2p: P2P module context from p2p_init()
659 * @timeout: Timeout for find operation in seconds or 0 for no timeout
660 * @type: Device Discovery type
661 * Returns: 0 on success, -1 on failure
663 int p2p_find(struct p2p_data *p2p, unsigned int timeout,
664 enum p2p_discovery_type type);
667 * p2p_stop_find - Stop P2P Find (Device Discovery)
668 * @p2p: P2P module context from p2p_init()
670 void p2p_stop_find(struct p2p_data *p2p);
673 * p2p_listen - Start P2P Listen state for specified duration
674 * @p2p: P2P module context from p2p_init()
675 * @timeout: Listen state duration in milliseconds
676 * Returns: 0 on success, -1 on failure
678 * This function can be used to request the P2P module to keep the device
679 * discoverable on the listen channel for an extended set of time. At least in
680 * its current form, this is mainly used for testing purposes and may not be of
681 * much use for normal P2P operations.
683 int p2p_listen(struct p2p_data *p2p, unsigned int timeout);
686 * p2p_connect - Start P2P group formation (GO negotiation)
687 * @p2p: P2P module context from p2p_init()
688 * @peer_addr: MAC address of the peer P2P client
689 * @wps_method: WPS method to be used in provisioning
690 * @go_intent: Local GO intent value (1..15)
691 * @own_interface_addr: Intended interface address to use with the group
692 * @force_freq: The only allowed channel frequency in MHz or 0
693 * @persistent_group: Whether to create a persistent group
694 * Returns: 0 on success, -1 on failure
696 int p2p_connect(struct p2p_data *p2p, const u8 *peer_addr,
697 enum p2p_wps_method wps_method,
698 int go_intent, const u8 *own_interface_addr,
699 unsigned int force_freq, int persistent_group);
702 * p2p_authorize - Authorize P2P group formation (GO negotiation)
703 * @p2p: P2P module context from p2p_init()
704 * @peer_addr: MAC address of the peer P2P client
705 * @wps_method: WPS method to be used in provisioning
706 * @go_intent: Local GO intent value (1..15)
707 * @own_interface_addr: Intended interface address to use with the group
708 * @force_freq: The only allowed channel frequency in MHz or 0
709 * @persistent_group: Whether to create a persistent group
710 * Returns: 0 on success, -1 on failure
712 * This is like p2p_connect(), but the actual group negotiation is not
713 * initiated automatically, i.e., the other end is expected to do that.
715 int p2p_authorize(struct p2p_data *p2p, const u8 *peer_addr,
716 enum p2p_wps_method wps_method,
717 int go_intent, const u8 *own_interface_addr,
718 unsigned int force_freq, int persistent_group);
721 * p2p_reject - Reject peer device (explicitly block connection attempts)
722 * @p2p: P2P module context from p2p_init()
723 * @peer_addr: MAC address of the peer P2P client
724 * Returns: 0 on success, -1 on failure
726 int p2p_reject(struct p2p_data *p2p, const u8 *peer_addr);
729 * p2p_prov_disc_req - Send Provision Discovery Request
730 * @p2p: P2P module context from p2p_init()
731 * @peer_addr: MAC address of the peer P2P client
732 * @config_methods: WPS Config Methods value (only one bit set)
733 * @join: Whether this is used by a client joining an active group
734 * Returns: 0 on success, -1 on failure
736 * This function can be used to request a discovered P2P peer to display a PIN
737 * (config_methods = WPS_CONFIG_DISPLAY) or be prepared to enter a PIN from us
738 * (config_methods = WPS_CONFIG_KEYPAD). The Provision Discovery Request frame
739 * is transmitted once immediately and if no response is received, the frame
740 * will be sent again whenever the target device is discovered during device
741 * dsicovery (start with a p2p_find() call). Response from the peer is
742 * indicated with the p2p_config::prov_disc_resp() callback.
744 int p2p_prov_disc_req(struct p2p_data *p2p, const u8 *peer_addr,
745 u16 config_methods, int join);
748 * p2p_sd_request - Schedule a service discovery query
749 * @p2p: P2P module context from p2p_init()
750 * @dst: Destination peer or %NULL to apply for all peers
751 * @tlvs: P2P Service Query TLV(s)
752 * Returns: Reference to the query or %NULL on failure
754 * Response to the query is indicated with the p2p_config::sd_response()
757 void * p2p_sd_request(struct p2p_data *p2p, const u8 *dst,
758 const struct wpabuf *tlvs);
761 * p2p_sd_cancel_request - Cancel a pending service discovery query
762 * @p2p: P2P module context from p2p_init()
763 * @req: Query reference from p2p_sd_request()
764 * Returns: 0 if request for cancelled; -1 if not found
766 int p2p_sd_cancel_request(struct p2p_data *p2p, void *req);
769 * p2p_sd_response - Send response to a service discovery query
770 * @p2p: P2P module context from p2p_init()
771 * @freq: Frequency from p2p_config::sd_request() callback
772 * @dst: Destination address from p2p_config::sd_request() callback
773 * @dialog_token: Dialog token from p2p_config::sd_request() callback
774 * @resp_tlvs: P2P Service Response TLV(s)
776 * This function is called as a response to the request indicated with
777 * p2p_config::sd_request() callback.
779 void p2p_sd_response(struct p2p_data *p2p, int freq, const u8 *dst,
780 u8 dialog_token, const struct wpabuf *resp_tlvs);
783 * p2p_sd_service_update - Indicate a change in local services
784 * @p2p: P2P module context from p2p_init()
786 * This function needs to be called whenever there is a change in availability
787 * of the local services. This will increment the Service Update Indicator
788 * value which will be used in SD Request and Response frames.
790 void p2p_sd_service_update(struct p2p_data *p2p);
793 enum p2p_invite_role {
795 P2P_INVITE_ROLE_ACTIVE_GO,
796 P2P_INVITE_ROLE_CLIENT
800 * p2p_invite - Invite a P2P Device into a group
801 * @p2p: P2P module context from p2p_init()
802 * @peer: Device Address of the peer P2P Device
803 * @role: Local role in the group
804 * @bssid: Group BSSID or %NULL if not known
806 * @ssid_len: Length of ssid in octets
807 * @force_freq: The only allowed channel frequency in MHz or 0
808 * @go_dev_addr: Forced GO Device Address or %NULL if none
809 * @persistent_group: Whether this is to reinvoke a persistent group
810 * Returns: 0 on success, -1 on failure
812 int p2p_invite(struct p2p_data *p2p, const u8 *peer, enum p2p_invite_role role,
813 const u8 *bssid, const u8 *ssid, size_t ssid_len,
814 unsigned int force_freq, const u8 *go_dev_addr,
815 int persistent_group);
818 * p2p_presence_req - Request GO presence
819 * @p2p: P2P module context from p2p_init()
820 * @go_interface_addr: GO P2P Interface Address
821 * @own_interface_addr: Own P2P Interface Address for this group
822 * @freq: Group operating frequence (in MHz)
823 * @duration1: Preferred presence duration in microseconds
824 * @interval1: Preferred presence interval in microseconds
825 * @duration2: Acceptable presence duration in microseconds
826 * @interval2: Acceptable presence interval in microseconds
827 * Returns: 0 on success, -1 on failure
829 * If both duration and interval values are zero, the parameter pair is not
830 * specified (i.e., to remove Presence Request, use duration1 = interval1 = 0).
832 int p2p_presence_req(struct p2p_data *p2p, const u8 *go_interface_addr,
833 const u8 *own_interface_addr, unsigned int freq,
834 u32 duration1, u32 interval1, u32 duration2,
838 * p2p_ext_listen - Set Extended Listen Timing
839 * @p2p: P2P module context from p2p_init()
840 * @freq: Group operating frequence (in MHz)
841 * @period: Availability period in milliseconds (1-65535; 0 to disable)
842 * @interval: Availability interval in milliseconds (1-65535; 0 to disable)
843 * Returns: 0 on success, -1 on failure
845 * This function can be used to enable or disable (period = interval = 0)
846 * Extended Listen Timing. When enabled, the P2P Device will become
847 * discoverable (go into Listen State) every @interval milliseconds for at
848 * least @period milliseconds.
850 int p2p_ext_listen(struct p2p_data *p2p, unsigned int period,
851 unsigned int interval);
853 /* Event notifications from upper layer management operations */
856 * p2p_wps_success_cb - Report successfully completed WPS provisioning
857 * @p2p: P2P module context from p2p_init()
858 * @mac_addr: Peer address
860 * This function is used to report successfully completed WPS provisioning
861 * during group formation in both GO/Registrar and client/Enrollee roles.
863 void p2p_wps_success_cb(struct p2p_data *p2p, const u8 *mac_addr);
866 * p2p_group_formation_failed - Report failed WPS provisioning
867 * @p2p: P2P module context from p2p_init()
869 * This function is used to report failed group formation. This can happen
870 * either due to failed WPS provisioning or due to 15 second timeout during
871 * the provisioning phase.
873 void p2p_group_formation_failed(struct p2p_data *p2p);
876 /* Event notifications from lower layer driver operations */
879 * p2p_probe_req_rx - Report reception of a Probe Request frame
880 * @p2p: P2P module context from p2p_init()
881 * @addr: Source MAC address
882 * @ie: Information elements from the Probe Request frame body
883 * @ie_len: Length of ie buffer in octets
884 * Returns: 0 to indicate the frame was not processed or 1 if it was
886 int p2p_probe_req_rx(struct p2p_data *p2p, const u8 *addr, const u8 *ie,
890 * p2p_rx_action - Report received Action frame
891 * @p2p: P2P module context from p2p_init()
892 * @da: Destination address of the received Action frame
893 * @sa: Source address of the received Action frame
894 * @bssid: Address 3 of the received Action frame
895 * @category: Category of the received Action frame
896 * @data: Action frame body after the Category field
897 * @len: Length of the data buffer in octets
898 * @freq: Frequency (in MHz) on which the frame was received
900 void p2p_rx_action(struct p2p_data *p2p, const u8 *da, const u8 *sa,
901 const u8 *bssid, u8 category,
902 const u8 *data, size_t len, int freq);
905 * p2p_scan_res_handler - Indicate a P2P scan results
906 * @p2p: P2P module context from p2p_init()
907 * @bssid: BSSID of the scan result
908 * @freq: Frequency of the channel on which the device was found in MHz
909 * @level: Signal level (signal strength of the received Beacon/Probe Response
911 * @ies: Pointer to IEs from the scan result
912 * @ies_len: Length of the ies buffer
913 * Returns: 0 to continue or 1 to stop scan result indication
915 * This function is called to indicate a scan result entry with P2P IE from a
916 * scan requested with struct p2p_config::p2p_scan(). This can be called during
917 * the actual scan process (i.e., whenever a new device is found) or as a
918 * sequence of calls after the full scan has been completed. The former option
919 * can result in optimized operations, but may not be supported by all
920 * driver/firmware designs. The ies buffer need to include at least the P2P IE,
921 * but it is recommended to include all IEs received from the device. The
922 * caller does not need to check that the IEs contain a P2P IE before calling
923 * this function since frames will be filtered internally if needed.
925 * This function will return 1 if it wants to stop scan result iteration (and
926 * scan in general if it is still in progress). This is used to allow faster
927 * start of a pending operation, e.g., to start a pending GO negotiation.
929 int p2p_scan_res_handler(struct p2p_data *p2p, const u8 *bssid, int freq,
930 int level, const u8 *ies, size_t ies_len);
933 * p2p_scan_res_handled - Indicate end of scan results
934 * @p2p: P2P module context from p2p_init()
936 * This function is called to indicate that all P2P scan results from a scan
937 * have been reported with zero or more calls to p2p_scan_res_handler(). This
938 * function must be called as a response to successful
939 * struct p2p_config::p2p_scan() call if none of the p2p_scan_res_handler()
940 * calls stopped iteration.
942 void p2p_scan_res_handled(struct p2p_data *p2p);
945 * p2p_send_action_cb - Notify TX status of an Action frame
946 * @p2p: P2P module context from p2p_init()
947 * @freq: Channel frequency in MHz
948 * @dst: Destination MAC address (Address 1)
949 * @src: Source MAC address (Address 2)
950 * @bssid: BSSID (Address 3)
951 * @success: Whether the transmission succeeded
953 * This function is used to indicate the result of an Action frame transmission
954 * that was requested with struct p2p_config::send_action() callback.
956 void p2p_send_action_cb(struct p2p_data *p2p, unsigned int freq, const u8 *dst,
957 const u8 *src, const u8 *bssid, int success);
960 * p2p_listen_cb - Indicate the start of a requested Listen state
961 * @p2p: P2P module context from p2p_init()
962 * @freq: Listen channel frequency in MHz
963 * @duration: Duration for the Listen state in milliseconds
965 * This function is used to indicate that a Listen state requested with
966 * struct p2p_config::start_listen() callback has started.
968 void p2p_listen_cb(struct p2p_data *p2p, unsigned int freq,
969 unsigned int duration);
972 * p2p_listen_end - Indicate the end of a requested Listen state
973 * @p2p: P2P module context from p2p_init()
974 * @freq: Listen channel frequency in MHz
975 * Returns: 0 if no operations were started, 1 if an operation was started
977 * This function is used to indicate that a Listen state requested with
978 * struct p2p_config::start_listen() callback has ended.
980 int p2p_listen_end(struct p2p_data *p2p, unsigned int freq);
982 void p2p_deauth_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
983 const u8 *ie, size_t ie_len);
985 void p2p_disassoc_notif(struct p2p_data *p2p, const u8 *bssid, u16 reason_code,
986 const u8 *ie, size_t ie_len);
989 /* Per-group P2P state for GO */
994 * struct p2p_group_config - P2P group configuration
996 * This configuration is provided to the P2P module during initialization of
997 * the per-group information with p2p_group_init().
999 struct p2p_group_config {
1001 * persistent_group - Whether the group is persistent
1003 int persistent_group;
1006 * interface_addr - P2P Interface Address of the group
1008 u8 interface_addr[ETH_ALEN];
1011 * cb_ctx - Context to use with callback functions
1016 * ie_update - Notification of IE update
1017 * @ctx: Callback context from cb_ctx
1018 * @beacon_ies: P2P IE for Beacon frames or %NULL if no change
1019 * @proberesp_ies: P2P Ie for Probe Response frames
1021 * P2P module uses this callback function to notify whenever the P2P IE
1022 * in Beacon or Probe Response frames should be updated based on group
1025 * The callee is responsible for freeing the returned buffer(s) with
1028 void (*ie_update)(void *ctx, struct wpabuf *beacon_ies,
1029 struct wpabuf *proberesp_ies);
1033 * p2p_group_init - Initialize P2P group
1034 * @p2p: P2P module context from p2p_init()
1035 * @config: P2P group configuration (will be freed by p2p_group_deinit())
1036 * Returns: Pointer to private data or %NULL on failure
1038 * This function is used to initialize per-group P2P module context. Currently,
1039 * this is only used to manage GO functionality and P2P clients do not need to
1040 * create an instance of this per-group information.
1042 struct p2p_group * p2p_group_init(struct p2p_data *p2p,
1043 struct p2p_group_config *config);
1046 * p2p_group_deinit - Deinitialize P2P group
1047 * @group: P2P group context from p2p_group_init()
1049 void p2p_group_deinit(struct p2p_group *group);
1052 * p2p_group_notif_assoc - Notification of P2P client association with GO
1053 * @group: P2P group context from p2p_group_init()
1054 * @addr: Interface address of the P2P client
1055 * @ie: IEs from the (Re)association Request frame
1056 * @len: Length of the ie buffer in octets
1057 * Returns: 0 on success, -1 on failure
1059 int p2p_group_notif_assoc(struct p2p_group *group, const u8 *addr,
1060 const u8 *ie, size_t len);
1063 * p2p_group_assoc_resp_ie - Build P2P IE for (re)association response
1064 * @group: P2P group context from p2p_group_init()
1065 * @status: Status value (P2P_SC_SUCCESS if association succeeded)
1066 * Returns: P2P IE for (Re)association Response or %NULL on failure
1068 * The caller is responsible for freeing the returned buffer with
1071 struct wpabuf * p2p_group_assoc_resp_ie(struct p2p_group *group, u8 status);
1074 * p2p_group_notif_disassoc - Notification of P2P client disassociation from GO
1075 * @group: P2P group context from p2p_group_init()
1076 * @addr: Interface address of the P2P client
1078 void p2p_group_notif_disassoc(struct p2p_group *group, const u8 *addr);
1081 * p2p_group_notif_formation_done - Notification of completed group formation
1082 * @group: P2P group context from p2p_group_init()
1084 void p2p_group_notif_formation_done(struct p2p_group *group);
1087 * p2p_group_notif_noa - Notification of NoA change
1088 * @group: P2P group context from p2p_group_init()
1089 * @noa: Notice of Absence attribute payload, %NULL if none
1090 * @noa_len: Length of noa buffer in octets
1091 * Returns: 0 on success, -1 on failure
1093 * Notify the P2P group management about a new NoA contents. This will be
1094 * inserted into the P2P IEs in Beacon and Probe Response frames with rest of
1095 * the group information.
1097 int p2p_group_notif_noa(struct p2p_group *group, const u8 *noa,
1101 * p2p_group_match_dev_type - Match device types in group with requested type
1102 * @group: P2P group context from p2p_group_init()
1103 * @wps: WPS TLVs from Probe Request frame (concatenated WPS IEs)
1104 * Returns: 1 on match, 0 on mismatch
1106 * This function can be used to match the Requested Device Type attribute in
1107 * WPS IE with the device types of a group member for deciding whether a GO
1108 * should reply to a Probe Request frame. Match will be reported if the WPS IE
1109 * is not requested any specific device type.
1111 int p2p_group_match_dev_type(struct p2p_group *group, struct wpabuf *wps);
1114 * p2p_group_go_discover - Send GO Discoverability Request to a group client
1115 * @group: P2P group context from p2p_group_init()
1116 * Returns: 0 on success (frame scheduled); -1 if client was not found
1118 int p2p_group_go_discover(struct p2p_group *group, const u8 *dev_id,
1119 const u8 *searching_dev, int rx_freq);
1122 /* Generic helper functions */
1125 * p2p_ie_text - Build text format description of P2P IE
1127 * @buf: Buffer for returning text
1128 * @end: Pointer to the end of the buf area
1129 * Returns: Number of octets written to the buffer or -1 on failure
1131 * This function can be used to parse P2P IE contents into text format
1132 * field=value lines.
1134 int p2p_ie_text(struct wpabuf *p2p_ie, char *buf, char *end);
1137 * p2p_scan_result_text - Build text format description of P2P IE
1138 * @ies: Information elements from scan results
1139 * @ies_len: ies buffer length in octets
1140 * @buf: Buffer for returning text
1141 * @end: Pointer to the end of the buf area
1142 * Returns: Number of octets written to the buffer or -1 on failure
1144 * This function can be used to parse P2P IE contents into text format
1145 * field=value lines.
1147 int p2p_scan_result_text(const u8 *ies, size_t ies_len, char *buf, char *end);
1150 * p2p_assoc_req_ie - Build P2P IE for (Re)Association Request frame
1151 * @p2p: P2P module context from p2p_init()
1153 * @buf: Buffer for writing the P2P IE
1154 * @len: Maximum buf length in octets
1155 * @p2p_group: Whether this is for association with a P2P GO
1156 * @p2p_ie: Reassembled P2P IE data from scan results or %NULL if none
1157 * Returns: Number of octets written into buf or -1 on failure
1159 int p2p_assoc_req_ie(struct p2p_data *p2p, const u8 *bssid, u8 *buf,
1160 size_t len, int p2p_group, struct wpabuf *p2p_ie);
1163 * p2p_scan_ie - Build P2P IE for Probe Request
1164 * @p2p: P2P module context from p2p_init()
1165 * @ies: Buffer for writing P2P IE
1167 void p2p_scan_ie(struct p2p_data *p2p, struct wpabuf *ies);
1170 * p2p_go_params - Generate random P2P group parameters
1171 * @p2p: P2P module context from p2p_init()
1172 * @params: Buffer for parameters
1173 * Returns: 0 on success, -1 on failure
1175 int p2p_go_params(struct p2p_data *p2p, struct p2p_go_neg_results *params);
1178 * p2p_get_group_capab - Get Group Capability from P2P IE data
1179 * @p2p_ie: P2P IE(s) contents
1180 * Returns: Group Capability
1182 u8 p2p_get_group_capab(const struct wpabuf *p2p_ie);
1185 * p2p_get_cross_connect_disallowed - Does WLAN AP disallows cross connection
1186 * @p2p_ie: P2P IE(s) contents
1187 * Returns: 0 if cross connection is allow, 1 if not
1189 int p2p_get_cross_connect_disallowed(const struct wpabuf *p2p_ie);
1192 * p2p_get_go_dev_addr - Get P2P Device Address from P2P IE data
1193 * @p2p_ie: P2P IE(s) contents
1194 * Returns: Pointer to P2P Device Address or %NULL if not included
1196 const u8 * p2p_get_go_dev_addr(const struct wpabuf *p2p_ie);
1199 * p2p_get_peer_info - Get P2P peer information in text format
1200 * @p2p: P2P module context from p2p_init()
1201 * @addr: P2P Device Address of the peer or %NULL to indicate the first peer
1202 * @next: Whether to select the peer entry following the one indicated by addr
1203 * @buf: Buffer for returning text
1204 * @buflen: Maximum buffer length
1205 * Returns: Number of octets written to the buffer or -1 on failure
1207 int p2p_get_peer_info(struct p2p_data *p2p, const u8 *addr, int next,
1208 char *buf, size_t buflen);
1211 * p2p_set_client_discoverability - Set client discoverability capability
1212 * @p2p: P2P module context from p2p_init()
1213 * @enabled: Whether client discoverability will be enabled
1215 * This function can be used to disable (and re-enable) client discoverability.
1216 * This capability is enabled by default and should not be disabled in normal
1217 * use cases, i.e., this is mainly for testing purposes.
1219 void p2p_set_client_discoverability(struct p2p_data *p2p, int enabled);
1222 * p2p_set_manageD_oper - Set managed P2P Device operations capability
1223 * @p2p: P2P module context from p2p_init()
1224 * @enabled: Whether managed P2P Device operations will be enabled
1226 void p2p_set_managed_oper(struct p2p_data *p2p, int enabled);
1228 int p2p_set_listen_channel(struct p2p_data *p2p, u8 reg_class, u8 channel);
1230 int p2p_set_ssid_postfix(struct p2p_data *p2p, const u8 *postfix, size_t len);
1232 int p2p_get_interface_addr(struct p2p_data *p2p, const u8 *dev_addr,
1234 int p2p_get_dev_addr(struct p2p_data *p2p, const u8 *iface_addr,
1237 void p2p_set_peer_filter(struct p2p_data *p2p, const u8 *addr);
1240 * p2p_set_cross_connect - Set cross connection capability
1241 * @p2p: P2P module context from p2p_init()
1242 * @enabled: Whether cross connection will be enabled
1244 void p2p_set_cross_connect(struct p2p_data *p2p, int enabled);
1246 int p2p_get_oper_freq(struct p2p_data *p2p, const u8 *iface_addr);
1248 int p2p_add_device(struct p2p_data *p2p, const u8 *addr, int freq, int level,
1249 const u8 *ies, size_t ies_len);
1252 * p2p_set_intra_bss_dist - Set intra BSS distribution
1253 * @p2p: P2P module context from p2p_init()
1254 * @enabled: Whether intra BSS distribution will be enabled
1256 void p2p_set_intra_bss_dist(struct p2p_data *p2p, int enabled);
1259 * p2p_supported_freq - Check whether channel is supported for P2P
1260 * @p2p: P2P module context from p2p_init()
1261 * @freq: Channel frequency in MHz
1262 * Returns: 0 if channel not usable for P2P, 1 if usable for P2P
1264 int p2p_supported_freq(struct p2p_data *p2p, unsigned int freq);
1266 void p2p_update_channel_list(struct p2p_data *p2p, struct p2p_channels *chan);