xref: /freebsd/contrib/wpa/src/nan/nan_i.h (revision 71e72c9e91c4b8007a4292e09669e8b549c29e97)

/*
 * Wi-Fi Aware - Internal definitions for NAN module
 * Copyright (C) 2025 Intel Corporation
 *
 * This software may be distributed under the terms of the BSD license.
 * See README for more details.
 */

#ifndef NAN_I_H
#define NAN_I_H

#include "list.h"
#include "common/ieee802_11_defs.h"
#include "common/nan_defs.h"
#include "common/wpa_common.h"
#include "nan.h"

struct bitfield;
struct nan_config;

#define NAN_INVALID_MAP_ID 0xff

#define NAN_KCK_MAX_LEN 24
#define NAN_KEK_MAX_LEN 32
#define NAN_TK_MAX_LEN  32
#define NAN_NPK_LEN  32

#define NAN_ELEMENT_MAX_SIZE 1024

/**
 * struct nan_ptk - NAN Pairwise Transient Key
 * @kck: Key Confirmation Key
 * @kek: Key Encryption Key
 * @tk: Transient Key
 * @kck_len: Length of &kck in octets
 * @kek_len: Length of &kek in octets
 * @tk_len: Length of &tk in octets
 */
struct nan_ptk {
	u8 kck[NAN_KCK_MAX_LEN];
	u8 kek[NAN_KEK_MAX_LEN];
	u8 tk[NAN_TK_MAX_LEN];

	size_t kck_len;
	size_t kek_len;
	size_t tk_len;
};

/**
 * struct nan_ndp_sec - NAN ndp security state
 * @present: Whether NDP setup exchange includes security
 * @valid: Whether the security configuration is valid
 * @replaycnt_ok: Whether replay count ok
 * @replaycnt: Current replay count
 * @i_nonce: Initiator nonce
 * @i_capab: Initiator capabilities
 * @i_csid: Initiator cipher suite ID
 * @i_instance_id: Initiator publish instance ID
 * @i_pmkid: Initiator PMKID
 * @r_nonce: Responder nonce
 * @r_capab: Responder capabilities
 * @r_csid: Responder cipher suite ID
 * @r_instance_id: Responder instance ID
 * @r_pmkid: Responder PMKID
 * @auth_token: Authentication token
 * @pmk: PMK used for the secure NDP establishment
 * @ptk: Derived PTK
 * @local_gtk: Group Temporal Key information of the local NDI
 * @peer_gtk: Group Temporal Key information of the peer NDI
 * @peer_gtk_rsc: Receive sequence counter of the peer NDI GTK
 */
struct nan_ndp_sec {
	bool present;
	bool valid;

	bool replaycnt_ok;
	u8 replaycnt[8];

	/* Initiator data */
	u8 i_nonce[WPA_NONCE_LEN];
	u8 i_capab;
	u8 i_csid;
	u8 i_instance_id;
	u8 i_pmkid[PMKID_LEN];

	/* Responder data */
	u8 r_nonce[WPA_NONCE_LEN];
	u8 r_capab;
	u8 r_csid;
	u8 r_instance_id;
	u8 r_pmkid[PMKID_LEN];

	u8 auth_token[NAN_AUTH_TOKEN_LEN];
	u8 pmk[PMK_LEN];

	struct nan_ptk ptk;

	struct nan_gtk local_gtk;
	struct nan_gtk peer_gtk;
	u8 peer_gtk_rsc[WPA_KEY_RSC_LEN];
};

/*
 * enum nan_ndp_state - State of NDP establishment
 * @NAN_NDP_STATE_NONE: No NDP establishment in progress
 * @NAN_NDP_STATE_START: Starting NDP establishment
 * @NAN_NDP_STATE_REQ_SENT: NDP request was sent
 * @NAN_NDP_STATE_REQ_RECV: NDP response was received and processed
 * @NAN_NDP_STATE_RES_SENT: NDP response was sent and NDP is not accepted yet
 * @NAN_NDP_STATE_RES_RECV: NDP response was received and NDP was not accepted
 *     yet (security is negotiated or confirmation is required)
 * @NAN_NDP_STATE_CON_SENT: NDP confirm was sent and NDP was not done yet, as
 *     security is negotiated
 * @NAN_NDP_STATE_CON_RECV: NDP confirm received and NDP was not done yet, as
 *     security is negotiated
 * @NAN_NDP_STATE_DONE: NDP establishment is done (either success or reject).
 *     In this state the NAN module handles actions such as notification to the
 *     encapsulating logic, etc. Once processing is done the NDP should either
 *     be cleared (rejected) or moved to the list of NDPs associated with the
 *     peer.
 */
enum nan_ndp_state {
	NAN_NDP_STATE_NONE,
	NAN_NDP_STATE_START,
	NAN_NDP_STATE_REQ_SENT,
	NAN_NDP_STATE_REQ_RECV,
	NAN_NDP_STATE_RES_SENT,
	NAN_NDP_STATE_RES_RECV,
	NAN_NDP_STATE_CON_SENT,
	NAN_NDP_STATE_CON_RECV,
	NAN_NDP_STATE_DONE,
};

/*
 * struct nan_ndp - NDP information
 *
 * Used to maintain the NDP as an object in a peer's list of NDPs.
 *
 * @list: Used for linking in the NDPs list
 * @peer: Pointer to the peer data structure
 * @initiator: True iff the local device is the initiator
 * @ndp_id: NDP ID
 * @init_ndi: Initiator NDI
 * @resp_ndi: Responder NDI. Might not always be set (as this depends on the
 *     state of NDP establishment and the status).
 * @qos: QoS requirements for this NDP
 * @gtk_id: GTK key ID used for this NDP; 0 if GTK is not used
 */
struct nan_ndp {
	/* for nan_peer ndps list */
	struct dl_list list;
	struct nan_peer *peer;
	bool initiator;
	u8 ndp_id;
	u8 init_ndi[ETH_ALEN];
	u8 resp_ndi[ETH_ALEN];

	struct nan_qos qos;
	u8 gtk_id;
};

/*
 * struct nan_ndp_setup - Holds the state of the NDP setup
 * @ndp: NDP information
 * @state: Current state
 * @status: Current status
 * @dialog_token: Setup dialog token
 * @publisher_inst_id: Publish function instance ID
 * @conf_req: True iff the NDP exchange requires confirm message
 * @reason: Reject reason. Only valid when status is rejected.
 * @ssi: Service specific information
 * @ssi_len: Service specific information length
 * @service_id: Service ID of the service used for NDP setup
 * @sec: NDP security data
 * @local_interface_id_valid: Indicates whether the &local_interface_id
 *      field is valid.
 * @local_interface_id: The local interface identifier to be used for the NDP
 * @peer_interface_id_valid: Indicates whether the &peer_interface_id
 *      field is valid.
 * @peer_interface_id: The peer interface identifier to be used for the NDP
 */
struct nan_ndp_setup {
	struct nan_ndp *ndp;
	enum nan_ndp_state state;
	enum nan_ndp_status status;
	u8 dialog_token;
	u8 publish_inst_id;
	bool conf_req;
	enum nan_reason reason;
	u8 *ssi;
	u16 ssi_len;

	u8 service_id[NAN_SERVICE_ID_LEN];
	struct nan_ndp_sec sec;

	bool local_interface_id_valid;
	u8 local_interface_id[NAN_NDPE_TLV_IPV6_LINK_LOCAL_LEN];
	bool peer_interface_id_valid;
	u8 peer_interface_id[NAN_NDPE_TLV_IPV6_LINK_LOCAL_LEN];
};

/**
 * struct nan_band_chan - NAN channel/band entry
 *
 * @band_id: Band ID as specified by enum nan_band_entry
 * @chan: Channel entry as specified by &struct nan_chan_entry
 */
struct nan_band_chan {
	union {
		u8 band_id;
		struct nan_chan_entry chan;
	} u;
};

/**
 * enum nan_band_chan_type - NAN band or channel
 *
 * @NAN_TYPE_BAND: The entry is a band entry
 * @NAN_TYPE_CHANNEL: The entry is a channel entry
 */
enum nan_band_chan_type {
	NAN_TYPE_BAND,
	NAN_TYPE_CHANNEL,
};

/* Default availability entry parameter values */
#define NAN_AVAIL_ENTRY_DEF_UTIL NAN_AVAIL_ENTRY_CTRL_UTIL_UNKNOWN
#define NAN_AVAIL_ENTRY_DEF_NSS  2
#define NAN_AVAIL_ENTRY_DEF_PREF 3

/**
 * struct nan_avail_entry - NAN availability entry
 *
 * @list: Used for linking in the availability entries list
 * @map_id: Map ID of the availability attribute that this entry belongs to
 * @type: Availability type. One of NAN_AVAIL_ENTRY_CTRL_TYPE_*.
 * @preference: Preference of being available in the NAN slots specified by
 *	the associated time bitmap. The preference is higher when the value is
 *	set larger. Valid values are 0 - 3.
 * @utilization: Indicating proportion within the NAN slots specified by the
 *	associated time bitmap that are already utilized for other purposes,
 *	quantized to 20%. Valid values are 0 - 5.
 * @rx_nss: Maximum number of special streams the NAN device can receive during
 *	the NAN slots specified by the associated time bitmap
 * @tbm: Time bitmap specifying the NAN slots in which the device will be
 *	available for NAN operations
 * @band_chan_type: Type of entries in &band_chan array, as specified by
 *	enum nan_band_chan_type
 * @n_band_chan: Number of entries in &band_chan array
 * @band_chan: Array of bands/channels on which the NAN device will be
 *	available
 */
struct nan_avail_entry {
	struct dl_list list;
	u8 map_id;
	u8 type;
	u8 preference;
	u8 utilization;
	u8 rx_nss;
	struct nan_time_bitmap tbm;
	enum nan_band_chan_type band_chan_type;
	u8 n_band_chan;
	struct nan_band_chan *band_chan;
};

/**
 * struct nan_dev_capa_entry - NAN Device Capability entry
 *
 * @list: Used for linking in the device capabilities list
 *	(in struct nan_peer_info::dev_capa)
 * @map_id: Map ID of the device capabilities
 * @capa: Device capabilities as specified by &struct nan_device_capabilities
 */
struct nan_dev_capa_entry {
	struct dl_list list;
	u8 map_id;
	struct nan_device_capabilities capa;
};

/**
 * struct nan_elem_container_entry - NAN element container entry
 *
 * @list: Used for linking in the element container entries list
 *	(in struct nan_peer_info::element_container)
 * @map_id: Map ID of the element container
 * @len: Length of data
 * @data: Pointer to the data
 */
struct nan_elem_container_entry {
	struct dl_list list;
	u8 map_id;
	u16 len;
	u8 data[];
};

/**
 * struct nan_ulw_entry - NAN Unaligned Schedule attribute entry
 * @list: Used for linking in the ULW entries list in struct nan_peer_info::ulw
 * @len: Length of the ULW attribute payload
 * @data: Pointer to the ULW attribute payload
 */
struct nan_ulw_entry {
	struct dl_list list;
	u16 len;
	u8 data[];
};

/**
 * struct nan_peer_sec_info_entry - NAN peer security information entry
 *
 * Maintains the latest security information for an NDI pair.
 *
 * @list: Used for linking in the peer security info list
 *	(struct nan_peer_info::sec)
 * @peer_ndi: Peer NDI address
 * @local_ndi: Local NDI address
 * @csid: Cipher Suite ID used for the secure NAN communication
 * @pmk: PMK shared with the peer
 * @pmkid: PMKID shared with the peer
 * @ptk: PTK shared with the peer
 * @pairing_akmp: AKMP used for the pairing (see See WPA_KEY_MGMT_*) or
 * 	zero if PASN pairing was not used for NDP establishment
 */
struct nan_peer_sec_info_entry {
	struct dl_list list;

	u8 peer_ndi[ETH_ALEN];
	u8 local_ndi[ETH_ALEN];

	enum nan_cipher_suite_id csid;
	u8 pmk[PMK_LEN];
	u8 pmkid[PMKID_LEN];
	struct nan_ptk ptk;
	int pairing_akmp;
};

/**
 * struct nan_peer_info - NAN peer information
 *
 * @last_seen: Timestamp of the last update of the peer info
 * @seq_id: Sequence id of the last availability update
 * @avail_entries: List of availability entries of the peer
 * @ulw: List of Unaligned Schedule attribute payloads of the peer
 *	(struct nan_ulw_entry::list entries)
 * @dev_capa: List of device capabilities of the peer
 *	(struct nan_dev_capa_entry::list entries)
 * @element_container: List of element container entries of the peer
 *	(struct nan_elem_container_entry::list entries)
 * @sec: List of security information entries of the peer
 *	(struct nan_peer_sec_info_entry::list entries)
 */
struct nan_peer_info {
	struct os_reltime last_seen;
	u8 seq_id;
	struct dl_list avail_entries;
	struct dl_list ulw;
	struct dl_list dev_capa;
	struct dl_list element_container;
	struct dl_list sec;
};

/**
 * enum nan_ndl_state - State of NDL establishment
 *
 * @NAN_NDL_STATE_NONE: No NDL with the peer
 * @NAN_NDL_STATE_START: NDL setup initiated by local device
 * @NAN_NDL_STATE_REQ_SENT: Sent NDL request
 * @NAN_NDL_STATE_REQ_RECV: Got NDL request
 * @NAN_NDL_STATE_RES_SENT: Sent NDL response
 * @NAN_NDL_STATE_RES_RECV: Got NDL response
 * @NAN_NDL_STATE_CON_SENT: Sent NDL confirm
 * @NAN_NDL_STATE_CON_RECV: Got NDL confirm
 * @NAN_NDL_STATE_DONE: NDL establishment is done (either success or reject).
 */
enum nan_ndl_state {
	NAN_NDL_STATE_NONE,
	NAN_NDL_STATE_START,
	NAN_NDL_STATE_REQ_SENT,
	NAN_NDL_STATE_REQ_RECV,
	NAN_NDL_STATE_RES_SENT,
	NAN_NDL_STATE_RES_RECV,
	NAN_NDL_STATE_CON_SENT,
	NAN_NDL_STATE_CON_RECV,
	NAN_NDL_STATE_DONE,
};

/**
 * enum nan_ndl_setup_reason - NAN NDL setup reason
 * @NAN_NDL_SETUP_REASON_NONE: none
 * @NAN_NDL_SETUP_REASON_NDP: NDL setup request for NDP operation
 */
enum nan_ndl_setup_reason {
	NAN_NDL_SETUP_REASON_NONE,
	NAN_NDL_SETUP_REASON_NDP,
};

/**
 * struct nan_ndl - NAN NDL data
 *
 * @state: Current state
 * @status: Current status
 * @send_naf_on_error: When set, indicates that in case that the NDL processing
 *     returned an error, a NAF still needs to be sent to the peer, i.e., the
 *     error cannot be silently ignored.
 * @reason: In case of status == NAN_NDL_STATUS_REJECTED, indicates the reason.
 * @dialog_token: The dialog token for the current NDL negotiation.
 * @max_idle_period: Indicate a period of time in units of 1024 TU during which
 *     the peer device can refrain from transmitting over the NDL without
 *     being terminated.
 * @setup_reason: The reason for the NDL setup
 * @ndc_id: NDC identifier
 * @peer_qos: Peer QoS requirements
 * @local_qos: Local QoS requirements (for the current NDP establishment)
 * @ndc_sched: The NDC schedule entries. See &struct nan_sched_entry
 * @ndc_sched_len: The length in octets of ndc_sched.
 * @immut_sched: The immutable schedule entries. See &enum nan_sched_entry
 * @immut_sched_len: The length in octets of immut_sched.
 */
struct nan_ndl {
	enum nan_ndl_state state;
	enum nan_ndl_status status;
	u8 send_naf_on_error;
	enum nan_reason reason;

	u8 dialog_token;
	u16 max_idle_period;
	enum nan_ndl_setup_reason setup_reason;

	u8 ndc_id[ETH_ALEN];

	struct nan_qos peer_qos, local_qos;

	u8 *ndc_sched;
	u16 ndc_sched_len;

	u8 *immut_sched;
	u16 immut_sched_len;
};

/**
 * struct nan_bootstrap - NAN bootstrap information
 * @supported_methods: Bitmap of supported bootstrap methods. See
 *     &enum nan_pairing_bootstrapping_method.
 * @initiator: Whether this device is the initiator
 * @requested_pbm: Bitmap of requested bootstrap methods. See
 *     &enum nan_pairing_bootstrapping_method.
 * @dialog_token: Dialog token of the bootstrap exchange
 * @status: Status of the bootstrap exchange. See &enum nan_pba_status.
 * @reason_code: Reason code for the bootstrap exchange. See &enum nan_reason.
 * @comeback_required: Whether the peer requested a comeback
 * @comeback_after: Time after which the comeback is requested
 * @cookie: Pointer to the cookie received from the peer
 * @cookie_len: Length of the cookie
 * @authorized: Authorized bootstrap method. See &enum
 *     nan_pairing_bootstrapping_method.
 * @in_progress: Whether a bootstrap exchange is in progress
 * @handle: Follow-up context handle for the ongoing bootstrap request
 * @req_instance_id: Instance ID of the bootstrap request
 * @npba: The NPBA from the last successful bootstrap
 */
struct nan_bootstrap {
	u16 supported_methods;
	bool initiator;
	u16 requested_pbm;
	u8 dialog_token;
	u8 status;
	u8 reason_code;

	bool comeback_required;
	u16 comeback_after;
	u8 *cookie;
	u8 cookie_len;

	u16 authorized;
	bool in_progress;

	int handle;
	u8 req_instance_id;

	struct wpabuf *npba;
};

/**
 * enum nan_pasn_auth_mode - NAN pairing authentication modes
 * @NAN_PASN_AUTH_MODE_PASN: Unauthenticated PASN
 * @NAN_PASN_AUTH_MODE_SAE: PASN authentication with SAE tunneling
 * @NAN_PASN_AUTH_MODE_PMK: PASN authentication with PMK caching
 */
enum nan_pasn_auth_mode {
	NAN_PASN_AUTH_MODE_PASN = 0,
	NAN_PASN_AUTH_MODE_SAE = 1,
	NAN_PASN_AUTH_MODE_PMK = 2,
};

/**
 * enum nan_pairing_role - NAN pairing role types
 * @NAN_PAIRING_ROLE_IDLE: No active pairing role
 * @NAN_PAIRING_ROLE_INITIATOR: Device acting as pairing initiator
 * @NAN_PAIRING_ROLE_RESPONDER: Device acting as pairing responder
 */
enum nan_pairing_role {
	NAN_PAIRING_ROLE_IDLE,
	NAN_PAIRING_ROLE_INITIATOR,
	NAN_PAIRING_ROLE_RESPONDER,
};


/* Current pairing uses pairing verification */
#define NAN_PAIRING_FLAG_NPK_VERIFICATION BIT(0)
/* Peer is paired */
#define NAN_PAIRING_FLAG_PAIRED BIT(1)

/**
 * struct nan_pairing_peer_data - NAN pairing peer information
 * @pairing_cfg: NAN pairing configuration parameters
 * @self_pairing_role: Role of this device in the pairing process
 * @pasn: Pointer to PASN data
 * @handle: Handle of the local service instance
 * @peer_instance_id: Instance ID of the peer service
 * @nonce_tag_valid: Indicates if the nonce and tag fields are valid
 * @nonce: Nonce from peer's NIRA
 * @tag: Tag from peer's NIRA
 * @flags: Bitmap of pairing flags. See NAN_PAIRING_FLAG_*
 * @pending_auth1: Pending PASN Authentication frame 1 to be processed
 * @pairing_csid: Cipher suite ID used for the pairing
 * @pairing_akmp: AKMP used for the pairing. See WPA_KEY_MGMT_*.
 */
struct nan_pairing_peer_data {
	struct nan_pairing_cfg pairing_cfg;
	enum nan_pairing_role self_pairing_role;
	struct pasn_data *pasn;
	int handle;
	int peer_instance_id;
	bool nonce_tag_valid;
	u8 nonce[NAN_NIRA_NONCE_LEN];
	u8 tag[NAN_NIRA_TAG_LEN];
	u32 flags;
	struct wpabuf *pending_auth1;
	enum nan_cipher_suite_id pairing_csid;
	int pairing_akmp;
};

/**
 * struct nan_peer - Represents a known NAN peer
 * @list: List node for linking peers
 * @nmi_addr: NMI of the peer
 * @configured: Indicates if the peer has been configured to the device
 * @last_seen: Timestamp of the last time this peer was seen
 * @info: Information about the peer
 * @ndps: List of NDPs associated with this peer
 * @ndp_setup: Used to hold an NDP object while NDP establishment is in
 *     progress
 * @ndl: NDL data associated with this peer
 * @bootstrap: Bootstrap information of the peer
 * @pairing: Pairing data associated with this peer
 * @igtk_id: IGTK key ID used with this peer. Zero if IGTK is not used.
 * @bigtk_id: BIGTK key ID used with this peer. Zero if BIGTK is not used.
 */
struct nan_peer {
	struct dl_list list;
	u8 nmi_addr[ETH_ALEN];
	bool configured;
	struct os_reltime last_seen;
	struct nan_peer_info info;

	struct dl_list ndps;

	struct nan_ndp_setup ndp_setup;

	struct nan_ndl *ndl;

	struct nan_bootstrap bootstrap;

	struct nan_pairing_peer_data pairing;

	u8 igtk_id;
	u8 bigtk_id;
};

/**
 * struct nan_data - Internal data structure for NAN
 * @cfg: Pointer to the NAN configuration structure
 * @nan_started: Flag indicating if NAN has been started
 * @sched_update_pending: Local schedule update is pending driver confirmation
 * @peer_list: List of known peers
 * @ndp_id_counter: NDP identifier counter. Incremented for each NDP request,
 *     and is used to set ndp_id in &struct nan_ndp.
 * @next_dialog_token: Dialog token for NDP and NDL negotiations. Incremented
 *     for each NDP and NDL request.
 * @sched: The local schedule
 * @cluster_id: Current cluster ID
 * @nira_nonce: Nonce for NAN Identity Resolution attribute (NIRA)
 * @nira_tag: Tag for NAN Identity Resolution attribute (NIRA)
 * @initiator_pmksa: PMKSA cache for PASN-PMK authentication as an initiator
 * @responder_pmksa: PMKSA cache for PASN-PMK authentication as a responder
 * @igtk: IGTK for NAN secure NDP
 * @igtk_id: Key ID of the IGTK
 * @bigtk: BIGTK for NAN secure NDP
 * @bigtk_id: Key ID of the BIGTK
 */
struct nan_data {
	struct nan_config *cfg;
	u8 nan_started:1;
	u8 sched_update_pending:1;
	struct dl_list peer_list;

	u8 ndp_id_counter;
	u8 next_dialog_token;
	struct nan_schedule sched;

	u8 cluster_id[ETH_ALEN];

	u8 nira_nonce[NAN_NIRA_NONCE_LEN];
	u8 nira_tag[NAN_NIRA_TAG_LEN];

	struct rsn_pmksa_cache *initiator_pmksa;
	struct rsn_pmksa_cache *responder_pmksa;

	struct wpa_igtk igtk;
	u8 igtk_id;

	struct wpa_bigtk bigtk;
	u8 bigtk_id;
};

struct nan_attrs_entry {
	struct dl_list list;
	const u8 *ptr;
	u16 len;
};

struct nan_attrs {
	struct dl_list serv_desc_ext;
	struct dl_list avail;
	struct dl_list ndc;
	struct dl_list ulw;
	struct dl_list dev_capa;
	struct dl_list element_container;

	const u8 *ndp;
	const u8 *ndl;
	const u8 *ndl_qos;
	const u8 *cipher_suite_info;
	const u8 *sec_ctxt_info;
	const u8 *shared_key_desc;
	const u8 *dev_capa_ext;
	const u8 *npba;
	const u8 *nira;
	const u8 *ndpe;

	u16 ndp_len;
	u16 ndl_len;
	u16 ndl_qos_len;
	u16 cipher_suite_info_len;
	u16 sec_ctxt_info_len;
	u16 shared_key_desc_len;
	u16 dev_capa_ext_len;
	u16 npba_len;
	u16 nira_len;
	u16 ndpe_len;
};

struct nan_msg {
	u8 oui_type;
	u8 oui_subtype;
	struct nan_attrs attrs;

	/* The full frame is required for the NDP security flows, that compute
	 * the NDP authentication token over the entire frame body. */
	const struct ieee80211_mgmt *mgmt;
	size_t len;
};


/**
 * nan_get_next_dialog_token - Allocate the next nonzero dialog token
 *
 * Wi-Fi Aware Specification v4.0, Tables 82, 86, 105: Dialog Token must be
 * set to a nonzero value.
 */
static inline u8 nan_get_next_dialog_token(struct nan_data *nan)
{
	if (++nan->next_dialog_token == 0)
		nan->next_dialog_token++;
	return nan->next_dialog_token;
}


/**
 * nan_get_next_ndp_id - Allocate next nonzero NDP identifier
 *
 * Wi-Fi Aware Specification v4.0, Table 82: NDP ID range is 1-255,
 * value zero is reserved.
 */
static inline u8 nan_get_next_ndp_id(struct nan_data *nan)
{
	if (++nan->ndp_id_counter == 0)
		nan->ndp_id_counter++;
	return nan->ndp_id_counter;
}


struct nan_peer * nan_get_peer(struct nan_data *nan, const u8 *addr);
bool nan_is_naf(const struct ieee80211_mgmt *mgmt, size_t len);
int nan_parse_attrs(struct nan_data *nan, const u8 *data, size_t len,
		    struct nan_attrs *attrs);
int nan_parse_naf(struct nan_data *nan, const struct ieee80211_mgmt *mgmt,
		  size_t len, struct nan_msg *msg);
void nan_attrs_clear(struct nan_data *nan, struct nan_attrs *attrs);

int nan_ndp_setup_req(struct nan_data *nan, struct nan_peer *peer,
		      struct nan_ndp_params *params);
int nan_ndp_setup_resp(struct nan_data *nan, struct nan_peer *peer,
		       struct nan_ndp_params *params);
int nan_ndp_handle_ndp_attr(struct nan_data *nan, struct nan_peer *peer,
			    struct nan_msg *msg);
int nan_ndp_add_ndp_attr(struct nan_data *nan, struct nan_peer *peer,
			 struct wpabuf *buf);
void nan_ndp_setup_reset(struct nan_data *nan, struct nan_peer *peer);
void nan_ndp_setup_failure(struct nan_data *nan, struct nan_peer *peer,
			   enum nan_reason reason, bool reset_state);
int nan_ndp_naf_sent(struct nan_data *nan, struct nan_peer *peer,
		     enum nan_subtype subtype);
int nan_parse_device_attrs(struct nan_data *nan, struct nan_peer *peer,
			   const u8 *attrs_data, size_t attrs_len);
int nan_ndp_term_req(struct nan_data *nan, struct nan_peer *peer,
		     struct nan_ndp_id *ndp_id);
int nan_ndl_setup(struct nan_data *nan, struct nan_peer *peer,
		  const struct nan_ndp_params *params, u8 dialog_token);
void nan_ndl_setup_failure(struct nan_data *nan, struct nan_peer *peer,
			   enum nan_reason reason, bool reset_state);
void nan_ndl_reset(struct nan_data *nan, struct nan_peer *peer);
int nan_ndl_handle_ndl_attr(struct nan_data *nan, struct nan_peer *peer,
			    struct nan_msg *msg);
int nan_ndl_add_ndl_attr(struct nan_data *nan, const struct nan_peer *peer,
			 struct wpabuf *buf);
int nan_ndl_add_ndc_attr(struct nan_data *nan, const struct nan_peer *peer,
			 struct wpabuf *buf);
int nan_ndl_add_qos_attr(struct nan_data *nan, const struct nan_peer *peer,
			 struct wpabuf *buf);
int nan_chan_to_chan_idx_map(struct nan_data *nan,
			     u8 op_class, u8 channel, u16 *chan_idx_map);
int nan_ndl_naf_sent(struct nan_data *nan, struct nan_peer *peer,
		     enum nan_subtype subtype);
int nan_ndl_add_avail_attrs(struct nan_data *nan, const struct nan_peer *peer,
			    struct wpabuf *buf);
void nan_ndl_add_elem_container_attr(const struct nan_data *nan,
				     const struct nan_peer *peer,
				     struct wpabuf *buf);
struct bitfield * nan_peer_schedule_intersection(
	struct nan_data *nan, const struct nan_peer *peer,
	const struct nan_schedule *sched);
bool nan_ndl_meets_qos(struct nan_data *nan, const struct nan_peer *peer,
		       const struct bitfield *common_bf);
bool nan_ndl_validate_peer_avail(struct nan_data *nan, struct nan_peer *peer);
int nan_convert_chan_sched_to_bf(struct nan_data *nan,
				 const struct nan_chan_schedule *chan,
				 struct bitfield **avail_bf, u8 *map_id,
				 u8 *op_class, u16 *cbm, u16 *pcbm);
int nan_get_chan_bm(struct nan_data *nan, const struct nan_sched_chan *chan,
		    u8 *op_class, u16 *chan_bm, u16 *pri_chan_bm);
int nan_add_avail_attrs(struct nan_data *nan, u8 sequence_id,
			u32 map_ids_bitmap, u8 type_for_conditional,
			size_t n_chans, struct nan_chan_schedule *chans,
			struct wpabuf *buf, bool include_potential);
void nan_del_avail_entry(struct nan_avail_entry *entry);
void nan_flush_avail_entries(struct dl_list *avail_entries);
int nan_sched_entries_to_avail_entries(struct nan_data *nan,
				       struct dl_list *avail_entries,
				       const u8 *sched_entries,
				       u16 sched_entries_len);
struct bitfield * nan_tbm_to_bf(struct nan_data *nan,
				const struct nan_time_bitmap *tbm);
struct bitfield * nan_sched_to_bf(struct nan_data *nan, struct dl_list *sched,
				  u8 *map_id, enum nan_reason *reason);
bool nan_sched_covered_by_avail_entry(struct nan_data *nan,
				      struct nan_avail_entry *avail,
				      struct bitfield *sched_bf, u8 map_id);
bool nan_sched_covered_by_avail_entries(struct nan_data *nan,
					struct dl_list *avail_entries,
					const u8 *sched, size_t sched_len);
bool nan_sched_bf_covered_by_avail_entries_and_chan(
	struct nan_data *nan, const struct dl_list *avail_entries,
	struct bitfield *sched_bf, u8 map_id, u8 op_class, u16 cbm);
struct bitfield * nan_avail_entries_to_bf(struct nan_data *nan,
					  const struct dl_list *avail_entries,
					  u8 op_class, u16 cbm, u16 pri_cbm);
void nan_ndp_terminated(struct nan_data *nan, struct nan_peer *peer,
			struct nan_ndp_id *ndp_id, const u8 *local_ndi,
			const u8 *peer_ndi, enum nan_reason reason, u8 gtk_id);
int nan_crypto_pmk_to_ptk(const u8 *pmk, const u8 *iaddr, const u8 *raddr,
			  const u8 *inonce, const u8 *rnonce,
			  struct nan_ptk *ptk,
			  enum nan_cipher_suite_id cipher);
int nan_crypto_calc_pmkid(const u8 *pmk, const u8 *iaddr, const u8 *raddr,
			  const u8 *serv_id,
			  enum nan_cipher_suite_id cipher, u8 *pmkid);
int nan_crypto_calc_auth_token(enum nan_cipher_suite_id cipher,
			       const u8 *buf, size_t len, u8 *token);
int nan_crypto_key_mic(const u8 *buf, size_t len, const u8 *kck,
		       size_t kck_len, u8 cipher, u8 *mic);
int nan_crypto_derive_npk(const u8 *kdk, size_t kdk_len,
			  enum nan_cipher_suite_id cipher,
			  const u8 *initiator_nmi, const u8 *responder_nmi,
			  u8 *buf, size_t buf_len);
int nan_crypto_derive_kek(const u8 *kdk, size_t kdk_len,
			  enum nan_cipher_suite_id cipher,
			  const u8 *initiator_nmi, const u8 *responder_nmi,
			  struct wpa_ptk *ptk);
int nan_crypto_derive_nd_pmk_from_kdk(const u8 *kdk, size_t kdk_len,
				      enum nan_cipher_suite_id cipher,
				      const u8 *initiator_nmi,
				      const u8 *responder_nmi, u8 *nd_pmk);
struct wpabuf * nan_crypto_encrypt_key_data(const struct wpabuf *key_data,
					    const u8 *kek, size_t kek_len);
struct wpabuf * nan_crypto_decrypt_key_data(const u8 *kek, size_t kek_len,
					    const u8 *encrypted_data,
					    size_t encrypted_len);
void nan_sec_reset(struct nan_data *nan, struct nan_ndp_sec *ndp_sec);
int nan_sec_rx(struct nan_data *nan, struct nan_peer *peer,
	       struct nan_msg *msg);
int nan_add_csia(struct wpabuf *buf, u8 capab, size_t cs_list_len,
		 const struct nan_cipher_suite *cs_list);
int nan_sec_add_attrs(struct nan_data *nan, struct nan_peer *peer,
		      enum nan_subtype subtype, struct wpabuf *buf);
int nan_sec_init_resp(struct nan_data *nan, struct nan_peer *peer);
int nan_sec_pre_tx(struct nan_data *nan, struct nan_peer *peer,
		   struct wpabuf *buf);
bool nan_sec_ndp_store_keys(struct nan_data *nan, struct nan_peer *peer,
			    const u8 *peer_ndi, const u8 *local_ndi);
int nan_sec_get_tk(struct nan_data *nan, struct nan_peer *peer,
		   const u8 *peer_ndi, const u8 *local_ndi,
		   u8 *tk, size_t *tk_len, enum nan_cipher_suite_id *csid);
void nan_add_dev_capa_ext_attr(struct nan_data *nan, struct wpabuf *buf);

void nan_bootstrap_reset(struct nan_data *nan, struct nan_peer *peer);
bool nan_bootstrap_handle_rx(struct nan_data *nan, const u8 *peer_nmi,
			     const u8 *npba, u16 npba_len,
			     const u8 *buf, size_t len,
			     int handle, u8 req_instance_id);
int nan_add_nira(struct wpabuf *buf, const u8 *tag, const u8 *nonce);
void nan_parse_peer_dev_capa_ext(struct nan_data *nan, struct nan_peer *peer,
				 struct nan_attrs *attrs);
int nan_configure_peer_schedule(struct nan_data *nan, struct nan_peer *peer,
				const struct nan_schedule *local_sched);
bool nan_is_ndpe_supported(struct nan_data *nan, const struct nan_peer *peer);
void nan_add_kde_hdr(struct wpabuf *buf, u32 kde, size_t data_len);
int nan_clear_peer_schedule(struct nan_data *nan, struct nan_peer *peer);
#ifdef CONFIG_PASN
int nan_nira_get_tag_nonce(const struct nan_config *nan, u8 *nonce, u8 *tag);
void nan_pairing_deinit_peer(struct nan_peer *peer);
bool nan_pairing_followup_rx(struct nan_data *nan_data, const u8 *peer_addr,
			     const struct nan_shared_key *shared_key_descr,
			     size_t attr_len);
#else /* CONFIG_PASN */
static inline
int nan_nira_get_tag_nonce(const struct nan_config *nan, u8 *nonce, u8 *tag)
{
	return -1;
}

static inline void nan_pairing_deinit_peer(struct nan_peer *peer)
{
}
#endif /* CONFIG_PASN */

#endif /* NAN_I_H */