/******************************************************************************
*
* Copyright (C) 2010-2012 Broadcom Corporation
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at:
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
******************************************************************************/
/******************************************************************************
*
* This is the utilities implementation file for the NFA Connection
* Handover.
*
******************************************************************************/
#include "string.h"
#include "nfa_sys.h"
#include "llcp_api.h"
#include "llcp_defs.h"
#include "nfa_p2p_int.h"
#include "nfa_cho_api.h"
#include "nfa_cho_int.h"
#include "trace_api.h"
#include "nfa_mem_co.h"
/*****************************************************************************
** Constants
*****************************************************************************/
/* Handover server name on LLCP */
static char *p_cho_service_name = "urn:nfc:sn:handover";
/* Handover Request Record Type */
static UINT8 hr_rec_type[HR_REC_TYPE_LEN] = { 0x48, 0x72 }; /* "Hr" */
/* Handover Select Record Type */
static UINT8 hs_rec_type[HS_REC_TYPE_LEN] = { 0x48, 0x73 }; /* "Hs" */
/* Handover Carrier recrod Type */
/* static UINT8 hc_rec_type[HC_REC_TYPE_LEN] = { 0x48, 0x63 }; "Hc" */
/* Collision Resolution Record Type */
static UINT8 cr_rec_type[CR_REC_TYPE_LEN] = { 0x63, 0x72 }; /* "cr" */
/* Alternative Carrier Record Type */
static UINT8 ac_rec_type[AC_REC_TYPE_LEN] = { 0x61, 0x63 }; /* "ac" */
/* Error Record Type */
static UINT8 err_rec_type[ERR_REC_TYPE_LEN] = { 0x65, 0x72, 0x72 }; /* "err" */
/* Bluetooth OOB Data Type */
static UINT8 *p_bt_oob_rec_type = (UINT8 *) "application/vnd.bluetooth.ep.oob";
/* WiFi Data Type */
static UINT8 *p_wifi_rec_type = (UINT8 *) "application/vnd.wfa.wsc";
/*****************************************************************************
** Global Variables
*****************************************************************************/
/*****************************************************************************
** Static Functions
*****************************************************************************/
static void nfa_cho_ndef_cback (tNFA_NDEF_EVT event, tNFA_NDEF_EVT_DATA *p_data);
/*******************************************************************************
**
** Function nfa_cho_ndef_cback
**
** Description callback function from NDEF handler
** Post NDEF handler callback event to NFA Connection Handover module
**
** Returns None
**
*******************************************************************************/
static void nfa_cho_ndef_cback (tNFA_NDEF_EVT event, tNFA_NDEF_EVT_DATA *p_data)
{
tNFA_CHO_NDEF_TYPE_HDLR_EVT *p_msg;
tNFA_CHO_MSG_TYPE msg_type;
CHO_TRACE_DEBUG1 ("nfa_cho_ndef_cback () event=%d", event);
if ((p_msg = (tNFA_CHO_NDEF_TYPE_HDLR_EVT *) GKI_getbuf (sizeof (tNFA_CHO_NDEF_TYPE_HDLR_EVT))) != NULL)
{
p_msg->hdr.event = NFA_CHO_NDEF_TYPE_HANDLER_EVT;
/* copy NDEF handler callback event and data */
p_msg->event = event;
memcpy (&(p_msg->data), p_data, sizeof (tNFA_NDEF_EVT_DATA));
/* if it has NDEF message */
if (event == NFA_NDEF_DATA_EVT)
{
if (p_data->ndef_data.ndef_type_handle == nfa_cho_cb.bt_ndef_type_handle )
{
msg_type = nfa_cho_get_msg_type (p_data->ndef_data.len,
p_data->ndef_data.p_data);
if (msg_type != NFA_CHO_MSG_BT_OOB)
{
/* This is not simplified BT OOB Message. It contains BT OOB Message. */
GKI_freebuf (p_msg);
return;
}
}
else if (p_data->ndef_data.ndef_type_handle == nfa_cho_cb.wifi_ndef_type_handle )
{
msg_type = nfa_cho_get_msg_type (p_data->ndef_data.len,
p_data->ndef_data.p_data);
if (msg_type != NFA_CHO_MSG_WIFI)
{
/* This is not simplified WiFi Message. It contains WiFi Message. */
GKI_freebuf (p_msg);
return;
}
}
/*
** NDEF message could be bigger than max GKI buffer
** so allocate memory from platform.
*/
p_msg->data.ndef_data.p_data = (UINT8 *) nfa_mem_co_alloc (p_msg->data.ndef_data.len);
if (p_msg->data.ndef_data.p_data)
{
memcpy (p_msg->data.ndef_data.p_data,
p_data->ndef_data.p_data,
p_msg->data.ndef_data.len);
}
else
{
CHO_TRACE_ERROR1 ("Failed nfa_mem_co_alloc () for %d bytes", p_msg->data.ndef_data.len);
GKI_freebuf (p_msg);
return;
}
}
nfa_sys_sendmsg (p_msg);
}
}
/*******************************************************************************
**
** Function nfa_cho_proc_ndef_type_handler_evt
**
** Description Process events (registration and NDEF data) from NFA NDEF
** Type Handler
**
** Returns tNFA_STATUS
**
*******************************************************************************/
void nfa_cho_proc_ndef_type_handler_evt (tNFA_CHO_INT_EVENT_DATA *p_evt_data)
{
tNFA_CHO_MSG_TYPE msg_type;
if (p_evt_data->ndef_type_hdlr.event == NFA_NDEF_REGISTER_EVT)
{
if (p_evt_data->ndef_type_hdlr.data.ndef_reg.status == NFA_STATUS_OK)
{
/* store handle for deregistration */
if (nfa_cho_cb.hs_ndef_type_handle == NFA_HANDLE_INVALID)
{
nfa_cho_cb.hs_ndef_type_handle = p_evt_data->ndef_type_hdlr.data.ndef_reg.ndef_type_handle;
}
else if (nfa_cho_cb.bt_ndef_type_handle == NFA_HANDLE_INVALID)
{
nfa_cho_cb.bt_ndef_type_handle = p_evt_data->ndef_type_hdlr.data.ndef_reg.ndef_type_handle;
}
else if (nfa_cho_cb.wifi_ndef_type_handle == NFA_HANDLE_INVALID)
{
nfa_cho_cb.wifi_ndef_type_handle = p_evt_data->ndef_type_hdlr.data.ndef_reg.ndef_type_handle;
}
}
}
else if (p_evt_data->ndef_type_hdlr.event == NFA_NDEF_DATA_EVT)
{
/* if negotiated handover is on going, then ignore static handover */
if (nfa_cho_cb.state != NFA_CHO_ST_CONNECTED)
{
#if (BT_TRACE_PROTOCOL == TRUE)
DispNDEFMsg (p_evt_data->ndef_type_hdlr.data.ndef_data.p_data,
p_evt_data->ndef_type_hdlr.data.ndef_data.len, TRUE);
#endif
msg_type = nfa_cho_get_msg_type (p_evt_data->ndef_type_hdlr.data.ndef_data.len,
p_evt_data->ndef_type_hdlr.data.ndef_data.p_data);
if (msg_type == NFA_CHO_MSG_HS)
{
nfa_cho_proc_hs (p_evt_data->ndef_type_hdlr.data.ndef_data.len,
p_evt_data->ndef_type_hdlr.data.ndef_data.p_data);
}
else if ( (msg_type == NFA_CHO_MSG_BT_OOB)
||(msg_type == NFA_CHO_MSG_WIFI) )
{
/* simplified BT OOB/Wifi Message */
nfa_cho_proc_simplified_format (p_evt_data->ndef_type_hdlr.data.ndef_data.len,
p_evt_data->ndef_type_hdlr.data.ndef_data.p_data);
}
else
{
CHO_TRACE_ERROR0 ("Unexpected CHO Message Type");
}
}
nfa_mem_co_free (p_evt_data->ndef_type_hdlr.data.ndef_data.p_data);
}
}
/*******************************************************************************
**
** Function nfa_cho_proc_api_reg
**
** Description Process registeration request from application
** Register Handover server on LLCP for negotiated handover
** Register handover select records on NDEF handler for static handover
**
** Returns tNFA_STATUS
**
*******************************************************************************/
tNFA_STATUS nfa_cho_proc_api_reg (tNFA_CHO_INT_EVENT_DATA *p_evt_data)
{
CHO_TRACE_DEBUG1 ("nfa_cho_proc_api_reg (): enable_server=%d",
p_evt_data->api_reg.enable_server);
if (p_evt_data->api_reg.enable_server == TRUE)
{
/* Register Handover server on LLCP for negotiated handover */
nfa_cho_cb.server_sap = LLCP_RegisterServer (LLCP_INVALID_SAP,
LLCP_LINK_TYPE_DATA_LINK_CONNECTION,
p_cho_service_name,
nfa_cho_sm_llcp_cback);
if (nfa_cho_cb.server_sap == LLCP_INVALID_SAP)
{
CHO_TRACE_ERROR0 ("Cannot register CHO server");
return NFA_STATUS_FAILED;
}
else
{
nfa_p2p_enable_listening (NFA_ID_CHO, FALSE);
}
}
else
{
/*
** Register Handover client on LLCP for negotiated handover
** LLCP will notify link status through callback
*/
nfa_cho_cb.client_sap = LLCP_RegisterClient (LLCP_LINK_TYPE_DATA_LINK_CONNECTION,
nfa_cho_sm_llcp_cback);
if (nfa_cho_cb.client_sap == LLCP_INVALID_SAP)
{
CHO_TRACE_ERROR0 ("Cannot register CHO client");
return NFA_STATUS_FAILED;
}
/* set flag not to deregister client when disconnected */
nfa_cho_cb.flags |= NFA_CHO_FLAGS_CLIENT_ONLY;
}
/* Register handover select record on NDEF handler for static handover */
if (nfa_cho_cb.hs_ndef_type_handle == NFA_HANDLE_INVALID)
{
NFA_RegisterNDefTypeHandler (TRUE, NFA_TNF_WKT, hs_rec_type, HS_REC_TYPE_LEN,
nfa_cho_ndef_cback);
}
if (nfa_cho_cb.bt_ndef_type_handle == NFA_HANDLE_INVALID)
{
NFA_RegisterNDefTypeHandler (TRUE, NFA_TNF_RFC2046_MEDIA,
p_bt_oob_rec_type, (UINT8) strlen ((char *) p_bt_oob_rec_type),
nfa_cho_ndef_cback);
}
if (nfa_cho_cb.wifi_ndef_type_handle == NFA_HANDLE_INVALID)
{
NFA_RegisterNDefTypeHandler (TRUE, NFA_TNF_RFC2046_MEDIA,
p_wifi_rec_type, (UINT8) strlen ((char *) p_wifi_rec_type),
nfa_cho_ndef_cback);
}
nfa_cho_cb.p_cback = p_evt_data->api_reg.p_cback;
return NFA_STATUS_OK;
}
/*******************************************************************************
**
** Function nfa_cho_proc_api_dereg
**
** Description Process deregisteration request from application
** Disconnect LLCP connection if any
** Deregister callback from NDEF handler and NFA P2P
**
** Returns None
**
*******************************************************************************/
void nfa_cho_proc_api_dereg (void)
{
CHO_TRACE_DEBUG0 ("nfa_cho_proc_api_dereg ()");
/* Deregister outgoing connection, data link will be disconnected if any */
if (nfa_cho_cb.client_sap != LLCP_INVALID_SAP)
{
LLCP_Deregister (nfa_cho_cb.client_sap);
nfa_cho_cb.client_sap = LLCP_INVALID_SAP;
}
/* Close Connection Handover server in LLCP, data link will be disconnected if any */
if (nfa_cho_cb.server_sap != LLCP_INVALID_SAP)
{
LLCP_Deregister (nfa_cho_cb.server_sap);
nfa_cho_cb.server_sap = LLCP_INVALID_SAP;
}
/* Deregister type handler if any */
if (nfa_cho_cb.hs_ndef_type_handle != NFA_HANDLE_INVALID)
{
NFA_DeregisterNDefTypeHandler (nfa_cho_cb.hs_ndef_type_handle);
nfa_cho_cb.hs_ndef_type_handle = NFA_HANDLE_INVALID;
}
if (nfa_cho_cb.bt_ndef_type_handle != NFA_HANDLE_INVALID)
{
NFA_DeregisterNDefTypeHandler (nfa_cho_cb.bt_ndef_type_handle);
nfa_cho_cb.bt_ndef_type_handle = NFA_HANDLE_INVALID;
}
if (nfa_cho_cb.wifi_ndef_type_handle != NFA_HANDLE_INVALID)
{
NFA_DeregisterNDefTypeHandler (nfa_cho_cb.wifi_ndef_type_handle);
nfa_cho_cb.wifi_ndef_type_handle = NFA_HANDLE_INVALID;
}
nfa_sys_stop_timer (&nfa_cho_cb.timer);
nfa_cho_cb.p_cback = NULL;
nfa_cho_cb.flags = 0;
nfa_p2p_disable_listening (NFA_ID_CHO, FALSE);
}
/*******************************************************************************
**
** Function nfa_cho_create_connection
**
** Description Create data link connection with handover server in remote
**
**
** Returns None
**
*******************************************************************************/
tNFA_STATUS nfa_cho_create_connection (void)
{
tLLCP_CONNECTION_PARAMS conn_params;
tNFA_STATUS status = NFA_STATUS_FAILED;
CHO_TRACE_DEBUG0 ("nfa_cho_create_connection ()");
if (nfa_cho_cb.client_sap == LLCP_INVALID_SAP)
{
nfa_cho_cb.client_sap = LLCP_RegisterClient (LLCP_LINK_TYPE_DATA_LINK_CONNECTION,
nfa_cho_sm_llcp_cback);
}
if (nfa_cho_cb.client_sap == LLCP_INVALID_SAP)
{
CHO_TRACE_ERROR0 ("Cannot register CHO client");
}
else
{
/* create data link connection with server name */
conn_params.miu = (UINT16) (nfa_cho_cb.local_link_miu >= NFA_CHO_MIU ? NFA_CHO_MIU : nfa_cho_cb.local_link_miu);
conn_params.rw = NFA_CHO_RW;
BCM_STRNCPY_S (conn_params.sn, sizeof (conn_params.sn),
p_cho_service_name, LLCP_MAX_SN_LEN);
conn_params.sn[LLCP_MAX_SN_LEN] = 0;
if (LLCP_ConnectReq (nfa_cho_cb.client_sap, LLCP_SAP_SDP, &conn_params) == LLCP_STATUS_SUCCESS)
status = NFA_STATUS_OK;
}
return status;
}
/*******************************************************************************
**
** Function nfa_cho_process_disconnection
**
** Description Clean up buffers and notify disconnection to application
**
**
** Returns None
**
*******************************************************************************/
void nfa_cho_process_disconnection (tNFA_CHO_DISC_REASON disc_reason)
{
tNFA_CHO_EVT_DATA evt_data;
nfa_sys_stop_timer (&nfa_cho_cb.timer);
/* free buffer for Tx/Rx NDEF message */
if (nfa_cho_cb.p_tx_ndef_msg)
{
GKI_freebuf (nfa_cho_cb.p_tx_ndef_msg);
nfa_cho_cb.p_tx_ndef_msg = NULL;
}
if (nfa_cho_cb.p_rx_ndef_msg)
{
GKI_freebuf (nfa_cho_cb.p_rx_ndef_msg);
nfa_cho_cb.p_rx_ndef_msg = NULL;
}
/* if no server is registered on LLCP, do not deregister client to get link statue from LLCP */
if (!(nfa_cho_cb.flags & NFA_CHO_FLAGS_CLIENT_ONLY))
{
if (nfa_cho_cb.client_sap != LLCP_INVALID_SAP)
{
LLCP_Deregister (nfa_cho_cb.client_sap);
nfa_cho_cb.client_sap = LLCP_INVALID_SAP;
}
}
nfa_cho_cb.flags &= ~NFA_CHO_FLAGS_CONN_COLLISION;
evt_data.disconnected.reason = disc_reason;
nfa_cho_cb.p_cback (NFA_CHO_DISCONNECTED_EVT, &evt_data);
}
/*******************************************************************************
**
** Function nfa_cho_notify_tx_fail_evt
**
** Description Notify application of NFA_CHO_TX_FAIL_EVT
**
**
** Returns None
**
*******************************************************************************/
void nfa_cho_notify_tx_fail_evt (tNFA_STATUS status)
{
tNFA_CHO_EVT_DATA evt_data;
CHO_TRACE_DEBUG0 ("nfa_cho_notify_tx_fail_evt ()");
evt_data.status = status;
if (nfa_cho_cb.p_cback)
nfa_cho_cb.p_cback (NFA_CHO_TX_FAIL_EVT, &evt_data);
}
/*******************************************************************************
**
** Function nfa_cho_reassemble_ho_msg
**
** Description Reassemble received data for handover message
**
**
** Returns tNFA_CHO_RX_NDEF_STATUS
**
*******************************************************************************/
tNFA_CHO_RX_NDEF_STATUS nfa_cho_reassemble_ho_msg (UINT8 local_sap, UINT8 remote_sap)
{
tNFA_CHO_RX_NDEF_STATUS rx_status;
nfa_sys_stop_timer (&nfa_cho_cb.timer);
/*
** allocate memory for NDEF message for the first segment
** validate NDEF message to check if received complete message
*/
rx_status = nfa_cho_read_ndef_msg (local_sap, remote_sap);
/* if Temporary Memory Constraint */
if (rx_status == NFA_CHO_RX_NDEF_TEMP_MEM)
{
CHO_TRACE_ERROR0 ("Failed due to Temporary Memory Constraint");
/* if we are expecting Hr then send Hs Error record */
if (nfa_cho_cb.substate == NFA_CHO_SUBSTATE_W4_REMOTE_HR)
{
/* ask retry later, handover request will disconnect */
nfa_cho_send_hs_error (NFA_CHO_ERROR_TEMP_MEM, NFA_CHO_TIMEOUT_FOR_RETRY);
}
else
{
/* we cannot send error record, so disconnect */
nfa_cho_cb.disc_reason = NFA_CHO_DISC_REASON_INTERNAL_ERROR;
LLCP_DisconnectReq (nfa_cho_cb.local_sap, nfa_cho_cb.remote_sap, FALSE);
}
}
/* Permanent Memory Constraint */
else if (rx_status == NFA_CHO_RX_NDEF_PERM_MEM)
{
CHO_TRACE_ERROR0 ("Failed due to Permanent Memory Constraint");
/* if we are expecting Hr then send Hs Error record */
if (nfa_cho_cb.substate == NFA_CHO_SUBSTATE_W4_REMOTE_HR)
{
/*
** notify our buffer size and ask retry with modified message later
** handover request will disconnect
*/
nfa_cho_send_hs_error (NFA_CHO_ERROR_PERM_MEM, nfa_cho_cb.rx_ndef_buf_size);
}
else
{
/* we cannot send error record, so disconnect */
nfa_cho_cb.disc_reason = NFA_CHO_DISC_REASON_INTERNAL_ERROR;
LLCP_DisconnectReq (nfa_cho_cb.local_sap, nfa_cho_cb.remote_sap, FALSE);
}
}
/* Invalid NDEF message */
else if (rx_status == NFA_CHO_RX_NDEF_INVALID)
{
CHO_TRACE_ERROR0 ("Failed due to invalid NDEF message");
if (nfa_cho_cb.substate == NFA_CHO_SUBSTATE_W4_REMOTE_HR)
{
/* let Handover Requester got timeout */
}
else
{
/* we cannot send error record, so disconnect */
nfa_cho_cb.disc_reason = NFA_CHO_DISC_REASON_INVALID_MSG;
LLCP_DisconnectReq (nfa_cho_cb.local_sap, nfa_cho_cb.remote_sap, FALSE);
}
}
/* need more segment */
else if (rx_status == NFA_CHO_RX_NDEF_INCOMPLTE)
{
/* wait for next segment */
if (nfa_cho_cb.substate == NFA_CHO_SUBSTATE_W4_REMOTE_HR)
{
nfa_sys_start_timer (&nfa_cho_cb.timer, 0, NFA_CHO_TIMEOUT_SEGMENTED_HR);
}
/* don't update running timer if we are waiting Hs */
}
else /* NFA_CHO_RX_NDEF_COMPLETE */
{
/* Received complete NDEF message */
}
return rx_status;
}
/*******************************************************************************
**
** Function nfa_cho_send_handover_msg
**
** Description Send segmented or whole Handover Message on LLCP
** if congested then wait for uncongested event from LLCP
**
** Returns tNFA_STATUS
**
*******************************************************************************/
tNFA_STATUS nfa_cho_send_handover_msg (void)
{
tNFA_STATUS status = NFA_STATUS_FAILED;
tLLCP_STATUS llcp_status;
UINT16 tx_size;
BT_HDR *p_msg;
UINT8 *p_src, *p_dst;
CHO_TRACE_DEBUG2 ("nfa_cho_send_handover_msg () size=%d, sent=%d",
nfa_cho_cb.tx_ndef_cur_size, nfa_cho_cb.tx_ndef_sent_size);
/* while data link connection is not congested */
while ((!nfa_cho_cb.congested) && (nfa_cho_cb.tx_ndef_sent_size < nfa_cho_cb.tx_ndef_cur_size))
{
/* select segment size as min (MIU of remote, remaining NDEF size) */
if (nfa_cho_cb.tx_ndef_cur_size - nfa_cho_cb.tx_ndef_sent_size > nfa_cho_cb.remote_miu)
{
tx_size = nfa_cho_cb.remote_miu;
}
else
{
tx_size = (UINT16) (nfa_cho_cb.tx_ndef_cur_size - nfa_cho_cb.tx_ndef_sent_size);
}
/* transmit a segment on LLCP */
if ((p_msg = (BT_HDR *) GKI_getpoolbuf (LLCP_POOL_ID)) != NULL)
{
p_msg->len = (UINT16) tx_size;
p_msg->offset = LLCP_MIN_OFFSET;
p_dst = (UINT8*) (p_msg + 1) + p_msg->offset;
p_src = nfa_cho_cb.p_tx_ndef_msg + nfa_cho_cb.tx_ndef_sent_size;
memcpy (p_dst, p_src, tx_size);
llcp_status = LLCP_SendData (nfa_cho_cb.local_sap, nfa_cho_cb.remote_sap, p_msg);
nfa_cho_cb.tx_ndef_sent_size += tx_size;
}
else
{
llcp_status = LLCP_STATUS_FAIL;
}
if (llcp_status == LLCP_STATUS_SUCCESS)
{
status = NFA_STATUS_OK;
}
else if (llcp_status == LLCP_STATUS_CONGESTED)
{
status = NFA_STATUS_CONGESTED;
CHO_TRACE_DEBUG0 ("Data link connection is congested");
/* wait for uncongested event */
nfa_cho_cb.congested = TRUE;
break;
}
else
{
status = NFA_STATUS_FAILED;
GKI_freebuf (nfa_cho_cb.p_tx_ndef_msg);
nfa_cho_cb.p_tx_ndef_msg = NULL;
break;
}
}
/*
** free buffer when receiving response or disconnected because we may need to send
** Hr message again due to collision
*/
return status;
}
/*******************************************************************************
**
** Function nfa_cho_read_ndef_msg
**
** Description allocate memory for NDEF message for the first segment
** validate NDEF message to check if received complete message
**
** Returns None
**
*******************************************************************************/
tNFA_CHO_RX_NDEF_STATUS nfa_cho_read_ndef_msg (UINT8 local_sap, UINT8 remote_sap)
{
tNDEF_STATUS ndef_status;
tNFA_CHO_RX_NDEF_STATUS rx_status;
BOOLEAN more;
UINT32 length;
CHO_TRACE_DEBUG2 ("nfa_cho_read_ndef_msg () local_sap=0x%x, remote_sap=0x%x",
local_sap, remote_sap);
/* if this is the first segment */
if (!nfa_cho_cb.p_rx_ndef_msg)
{
nfa_cho_cb.p_rx_ndef_msg = (UINT8 *) GKI_getpoolbuf (LLCP_POOL_ID);
if (!nfa_cho_cb.p_rx_ndef_msg)
{
CHO_TRACE_ERROR0 ("Failed to allocate buffer");
return NFA_CHO_RX_NDEF_TEMP_MEM;
}
nfa_cho_cb.rx_ndef_buf_size = LLCP_POOL_BUF_SIZE;
nfa_cho_cb.rx_ndef_cur_size = 0;
}
more = TRUE;
while (more)
{
more = LLCP_ReadDataLinkData (local_sap,
remote_sap,
(UINT16)(nfa_cho_cb.rx_ndef_buf_size - nfa_cho_cb.rx_ndef_cur_size),
&length,
nfa_cho_cb.p_rx_ndef_msg + nfa_cho_cb.rx_ndef_cur_size);
nfa_cho_cb.rx_ndef_cur_size += length;
/* if it doesn't fit into allocated memory */
if ((nfa_cho_cb.rx_ndef_cur_size >= nfa_cho_cb.rx_ndef_buf_size)
&&(more))
{
CHO_TRACE_ERROR0 ("Failed to store too much data");
LLCP_FlushDataLinkRxData (local_sap, remote_sap);
GKI_freebuf (nfa_cho_cb.p_rx_ndef_msg);
nfa_cho_cb.p_rx_ndef_msg = NULL;
return NFA_CHO_RX_NDEF_PERM_MEM;
}
}
/* check NDEF message */
ndef_status = NDEF_MsgValidate (nfa_cho_cb.p_rx_ndef_msg, nfa_cho_cb.rx_ndef_cur_size, FALSE);
switch (ndef_status)
{
case NDEF_OK:
rx_status = NFA_CHO_RX_NDEF_COMPLETE;
break;
case NDEF_MSG_TOO_SHORT:
case NDEF_MSG_NO_MSG_END:
case NDEF_MSG_LENGTH_MISMATCH:
rx_status = NFA_CHO_RX_NDEF_INCOMPLTE;
break;
default:
rx_status = NFA_CHO_RX_NDEF_INVALID;
break;
}
if (rx_status == NFA_CHO_RX_NDEF_COMPLETE)
{
#if (BT_TRACE_PROTOCOL == TRUE)
DispCHO (nfa_cho_cb.p_rx_ndef_msg, nfa_cho_cb.rx_ndef_cur_size, TRUE);
#endif
}
else if (rx_status == NFA_CHO_RX_NDEF_INCOMPLTE)
{
CHO_TRACE_DEBUG0 ("Need more data to complete NDEF message");
}
else /* if (rx_status == NFA_CHO_RX_NDEF_INVALID) */
{
CHO_TRACE_ERROR1 ("Failed to validate NDEF message error=0x%x", ndef_status);
GKI_freebuf (nfa_cho_cb.p_rx_ndef_msg);
nfa_cho_cb.p_rx_ndef_msg = NULL;
}
return rx_status;
}
/*******************************************************************************
**
** Function nfa_cho_add_cr_record
**
** Description Adding Collision Resolution record
**
**
** Returns NDEF_OK if success
**
*******************************************************************************/
tNDEF_STATUS nfa_cho_add_cr_record (UINT8 *p_msg, UINT32 max_size, UINT32 *p_cur_size)
{
tNDEF_STATUS status;
UINT32 temp32;
CHO_TRACE_DEBUG1 ("nfa_cho_add_cr_record () cur_size = %d", *p_cur_size);
/* Get random number from timer */
temp32 = GKI_get_tick_count ();
nfa_cho_cb.tx_random_number = (UINT16) ((temp32 >> 16) ^ (temp32));
#if (defined (NFA_CHO_TEST_INCLUDED) && (NFA_CHO_TEST_INCLUDED == TRUE))
if (nfa_cho_cb.test_enabled & NFA_CHO_TEST_RANDOM)
{
nfa_cho_cb.tx_random_number = nfa_cho_cb.test_random_number;
}
#endif
CHO_TRACE_DEBUG1 ("tx_random_number = 0x%04x", nfa_cho_cb.tx_random_number);
/* Add Well-Known Type:Collistion Resolution Record */
status = NDEF_MsgAddWktCr (p_msg, max_size, p_cur_size,
nfa_cho_cb.tx_random_number);
return status;
}
/*******************************************************************************
**
** Function nfa_cho_add_ac_record
**
** Description Adding Alternative Carrier record
**
**
** Returns NDEF_OK if success
**
*******************************************************************************/
tNDEF_STATUS nfa_cho_add_ac_record (UINT8 *p_msg, UINT32 max_size, UINT32 *p_cur_size,
UINT8 num_ac_info, tNFA_CHO_AC_INFO *p_ac_info,
UINT8 *p_ndef, UINT32 max_ndef_size, UINT32 *p_cur_ndef_size)
{
tNDEF_STATUS status = NDEF_OK;
UINT8 xx, yy;
UINT8 *p_rec, *p_id, id_len;
char carrier_data_ref_str[NFA_CHO_MAX_REF_NAME_LEN];
char *aux_data_ref[NFA_CHO_MAX_AUX_DATA_COUNT];
char aux_data_ref_str[NFA_CHO_MAX_AUX_DATA_COUNT][NFA_CHO_MAX_REF_NAME_LEN];
CHO_TRACE_DEBUG1 ("nfa_cho_add_ac_record (): num_ac_info = %d", num_ac_info);
/* initialize auxilary data reference */
for (xx = 0; xx < NFA_CHO_MAX_AUX_DATA_COUNT; xx++)
{
aux_data_ref[xx] = aux_data_ref_str[xx];
}
p_rec = p_ndef;
/* Alternative Carrier Records */
for (xx = 0; (xx < num_ac_info) && (status == NDEF_OK); xx++)
{
if (!p_rec)
{
status = NDEF_REC_NOT_FOUND;
break;
}
p_id = NDEF_RecGetId (p_rec, &id_len);
if ((p_id) && (id_len > 0) && (id_len <= NFA_CHO_MAX_REF_NAME_LEN))
{
memcpy (carrier_data_ref_str, p_id, id_len);
carrier_data_ref_str[id_len] = 0x00;
}
else
{
CHO_TRACE_ERROR1 ("nfa_cho_add_ac_record ():id_len=%d", id_len);
status = NDEF_REC_NOT_FOUND;
break;
}
p_rec = NDEF_MsgGetNextRec (p_rec);
/* auxilary data reference */
for (yy = 0; yy < p_ac_info[xx].num_aux_data; yy++)
{
if (!p_rec)
{
status = NDEF_REC_NOT_FOUND;
break;
}
p_id = NDEF_RecGetId (p_rec, &id_len);
if ((p_id) && (id_len > 0) && (id_len <= NFA_CHO_MAX_REF_NAME_LEN))
{
memcpy (aux_data_ref_str[yy], p_id, id_len);
aux_data_ref_str[yy][id_len] = 0x00;
}
else
{
CHO_TRACE_ERROR1 ("nfa_cho_add_ac_record ():id_len=%d", id_len);
status = NDEF_REC_NOT_FOUND;
break;
}
p_rec = NDEF_MsgGetNextRec (p_rec);
}
if (status == NDEF_OK)
{
/* Add Well-Known Type:Alternative Carrier Record */
status = NDEF_MsgAddWktAc (p_msg, max_size, p_cur_size,
p_ac_info[xx].cps, carrier_data_ref_str,
p_ac_info[xx].num_aux_data, aux_data_ref);
}
if (status != NDEF_OK)
{
break;
}
}
return status;
}
/*******************************************************************************
**
** Function nfa_cho_send_hr
**
** Description Sending Handover Request Message
** It may send one from AC list to select a specific AC.
**
** Returns NFA_STATUS_OK if success
**
*******************************************************************************/
tNFA_STATUS nfa_cho_send_hr (tNFA_CHO_API_SEND_HR *p_api_send_hr)
{
tNDEF_STATUS status;
UINT8 *p_msg_cr_ac;
UINT32 cur_size_cr_ac, max_size;
UINT8 version;
CHO_TRACE_DEBUG0 ("nfa_cho_send_hr ()");
/* Collistion Resolution Record and Alternative Carrier Records */
p_msg_cr_ac = (UINT8 *) GKI_getpoolbuf (LLCP_POOL_ID);
if (!p_msg_cr_ac)
{
CHO_TRACE_ERROR0 ("Failed to allocate buffer");
return NFA_STATUS_NO_BUFFERS;
}
max_size = LLCP_POOL_BUF_SIZE;
NDEF_MsgInit (p_msg_cr_ac, max_size, &cur_size_cr_ac);
/* Collistion Resolution Record */
if (NDEF_OK != nfa_cho_add_cr_record (p_msg_cr_ac, max_size, &cur_size_cr_ac))
{
CHO_TRACE_ERROR0 ("Failed to add cr record");
GKI_freebuf (p_msg_cr_ac);
return NFA_STATUS_FAILED;
}
/* Alternative Carrier Records */
if (NDEF_OK != nfa_cho_add_ac_record (p_msg_cr_ac, max_size, &cur_size_cr_ac,
p_api_send_hr->num_ac_info, p_api_send_hr->p_ac_info,
p_api_send_hr->p_ndef, p_api_send_hr->max_ndef_size,
&(p_api_send_hr->cur_ndef_size)))
{
CHO_TRACE_ERROR0 ("Failed to add ac record");
GKI_freebuf (p_msg_cr_ac);
return NFA_STATUS_FAILED;
}
/* Handover Request Message */
nfa_cho_cb.p_tx_ndef_msg = (UINT8 *) GKI_getpoolbuf (LLCP_POOL_ID);
if (!nfa_cho_cb.p_tx_ndef_msg)
{
CHO_TRACE_ERROR0 ("Failed to allocate buffer");
GKI_freebuf (p_msg_cr_ac);
return NFA_STATUS_FAILED;
}
max_size = LLCP_POOL_BUF_SIZE;
/* Handover Request Record */
version = NFA_CHO_VERSION;
#if (defined (NFA_CHO_TEST_INCLUDED) && (NFA_CHO_TEST_INCLUDED == TRUE))
if (nfa_cho_cb.test_enabled & NFA_CHO_TEST_VERSION)
{
version = nfa_cho_cb.test_version;
}
#endif
status = NDEF_MsgCreateWktHr (nfa_cho_cb.p_tx_ndef_msg, max_size, &nfa_cho_cb.tx_ndef_cur_size,
version);
if (status != NDEF_OK)
{
CHO_TRACE_ERROR0 ("Failed to create Hr");
GKI_freebuf (nfa_cho_cb.p_tx_ndef_msg);
nfa_cho_cb.p_tx_ndef_msg = NULL;
GKI_freebuf (p_msg_cr_ac);
return NFA_STATUS_FAILED;
}
/* Append Collistion Resolution Record and Alternative Carrier Records */
status = NDEF_MsgAppendPayload (nfa_cho_cb.p_tx_ndef_msg, max_size, &nfa_cho_cb.tx_ndef_cur_size,
nfa_cho_cb.p_tx_ndef_msg, p_msg_cr_ac, cur_size_cr_ac);
GKI_freebuf (p_msg_cr_ac);
if (status != NDEF_OK)
{
CHO_TRACE_ERROR0 ("Failed to add cr/ac record");
GKI_freebuf (nfa_cho_cb.p_tx_ndef_msg);
nfa_cho_cb.p_tx_ndef_msg = NULL;
return NFA_STATUS_FAILED;
}
/* Append Alternative Carrier Reference Data or Handover Carrier Record */
status = NDEF_MsgAppendRec (nfa_cho_cb.p_tx_ndef_msg, max_size, &nfa_cho_cb.tx_ndef_cur_size,
p_api_send_hr->p_ndef, p_api_send_hr->cur_ndef_size);
if (status != NDEF_OK)
{
CHO_TRACE_ERROR0 ("Failed to add ac reference data or Hc record");
GKI_freebuf (nfa_cho_cb.p_tx_ndef_msg);
nfa_cho_cb.p_tx_ndef_msg = NULL;
return NFA_STATUS_FAILED;
}
#if (BT_TRACE_PROTOCOL == TRUE)
DispCHO (nfa_cho_cb.p_tx_ndef_msg, nfa_cho_cb.tx_ndef_cur_size, FALSE);
#endif
/* Send it to peer */
nfa_cho_cb.tx_ndef_sent_size = 0;
status = nfa_cho_send_handover_msg ();
if (status == NFA_STATUS_CONGESTED)
{
status = NFA_STATUS_OK;
}
return status;
}
/*******************************************************************************
**
** Function nfa_cho_send_hs
**
** Description Send Handover Select Message
**
**
** Returns NFA_STATUS_OK if success
**
*******************************************************************************/
tNFA_STATUS nfa_cho_send_hs (tNFA_CHO_API_SEND_HS *p_api_select)
{
tNDEF_STATUS status;
UINT8 *p_msg_ac;
UINT32 cur_size_ac = 0, max_size;
UINT8 version;
CHO_TRACE_DEBUG1 ("nfa_cho_send_hs () num_ac_info=%d", p_api_select->num_ac_info);
if (p_api_select->num_ac_info > 0)
{
/* Alternative Carrier Records */
p_msg_ac = (UINT8 *) GKI_getpoolbuf (LLCP_POOL_ID);
if (!p_msg_ac)
{
CHO_TRACE_ERROR0 ("Failed to allocate buffer");
return NFA_STATUS_FAILED;
}
max_size = LLCP_POOL_BUF_SIZE;
NDEF_MsgInit (p_msg_ac, max_size, &cur_size_ac);
if (NDEF_OK != nfa_cho_add_ac_record (p_msg_ac, max_size, &cur_size_ac,
p_api_select->num_ac_info, p_api_select->p_ac_info,
p_api_select->p_ndef, p_api_select->max_ndef_size,
&(p_api_select->cur_ndef_size)))
{
CHO_TRACE_ERROR0 ("Failed to add ac record");
GKI_freebuf (p_msg_ac);
return NFA_STATUS_FAILED;
}
}
else
{
p_msg_ac = NULL;
}
/* Handover Select Message */
nfa_cho_cb.p_tx_ndef_msg = (UINT8 *) GKI_getpoolbuf (LLCP_POOL_ID);
if (!nfa_cho_cb.p_tx_ndef_msg)
{
CHO_TRACE_ERROR0 ("Failed to allocate buffer");
if (p_msg_ac)
GKI_freebuf (p_msg_ac);
return NFA_STATUS_FAILED;
}
max_size = LLCP_POOL_BUF_SIZE;
/* Handover Select Record */
version = NFA_CHO_VERSION;
#if (defined (NFA_CHO_TEST_INCLUDED) && (NFA_CHO_TEST_INCLUDED == TRUE))
if (nfa_cho_cb.test_enabled & NFA_CHO_TEST_VERSION)
{
version = nfa_cho_cb.test_version;
}
#endif
status = NDEF_MsgCreateWktHs (nfa_cho_cb.p_tx_ndef_msg, max_size, &nfa_cho_cb.tx_ndef_cur_size,
version);
if (status != NDEF_OK)
{
CHO_TRACE_ERROR0 ("Failed to create Hs");
GKI_freebuf (nfa_cho_cb.p_tx_ndef_msg);
nfa_cho_cb.p_tx_ndef_msg = NULL;
if (p_msg_ac)
GKI_freebuf (p_msg_ac);
return NFA_STATUS_FAILED;
}
if (p_api_select->num_ac_info > 0)
{
/* Append Alternative Carrier Records */
status = NDEF_MsgAppendPayload (nfa_cho_cb.p_tx_ndef_msg, max_size, &nfa_cho_cb.tx_ndef_cur_size,
nfa_cho_cb.p_tx_ndef_msg, p_msg_ac, cur_size_ac);
if (p_msg_ac)
GKI_freebuf (p_msg_ac);
if (status != NDEF_OK)
{
CHO_TRACE_ERROR0 ("Failed to add cr record");
GKI_freebuf (nfa_cho_cb.p_tx_ndef_msg);
nfa_cho_cb.p_tx_ndef_msg = NULL;
return NFA_STATUS_FAILED;
}
/* Append Alternative Carrier Reference Data */
status = NDEF_MsgAppendRec (nfa_cho_cb.p_tx_ndef_msg, max_size, &nfa_cho_cb.tx_ndef_cur_size,
p_api_select->p_ndef, p_api_select->cur_ndef_size);
if (status != NDEF_OK)
{
CHO_TRACE_ERROR0 ("Failed to add ac reference data record");
GKI_freebuf (nfa_cho_cb.p_tx_ndef_msg);
nfa_cho_cb.p_tx_ndef_msg = NULL;
return NFA_STATUS_FAILED;
}
}
#if (BT_TRACE_PROTOCOL == TRUE)
DispCHO (nfa_cho_cb.p_tx_ndef_msg, nfa_cho_cb.tx_ndef_cur_size, FALSE);
#endif
/* Send it to peer */
nfa_cho_cb.tx_ndef_sent_size = 0;
status = nfa_cho_send_handover_msg ();
if (status == NFA_STATUS_CONGESTED)
{
status = NFA_STATUS_OK;
}
return status;
}
/*******************************************************************************
**
** Function nfa_cho_send_hs_error
**
** Description Sending Handover Select Message with error record
**
**
** Returns NFA_STATUS_OK if success
**
*******************************************************************************/
tNFA_STATUS nfa_cho_send_hs_error (UINT8 error_reason, UINT32 error_data)
{
tNDEF_STATUS status;
UINT8 version;
UINT32 max_size;
CHO_TRACE_DEBUG2 ("nfa_cho_send_hs_error () error_reason=0x%x, error_data=0x%x",
error_reason, error_data);
/* Handover Select Message */
nfa_cho_cb.p_tx_ndef_msg = (UINT8 *) GKI_getpoolbuf (LLCP_POOL_ID);
if (!nfa_cho_cb.p_tx_ndef_msg)
{
CHO_TRACE_ERROR0 ("Failed to allocate buffer");
return NFA_STATUS_FAILED;
}
max_size = LLCP_POOL_BUF_SIZE;
/* Handover Select Record with Version */
version = NFA_CHO_VERSION;
#if (defined (NFA_CHO_TEST_INCLUDED) && (NFA_CHO_TEST_INCLUDED == TRUE))
if (nfa_cho_cb.test_enabled & NFA_CHO_TEST_VERSION)
{
version = nfa_cho_cb.test_version;
}
#endif
status = NDEF_MsgCreateWktHs (nfa_cho_cb.p_tx_ndef_msg, max_size, &nfa_cho_cb.tx_ndef_cur_size,
version);
if (status != NDEF_OK)
{
CHO_TRACE_ERROR0 ("Failed to create Hs");
GKI_freebuf (nfa_cho_cb.p_tx_ndef_msg);
nfa_cho_cb.p_tx_ndef_msg = NULL;
return NFA_STATUS_FAILED;
}
/* Add Error Records */
status = NDEF_MsgAddWktErr (nfa_cho_cb.p_tx_ndef_msg, max_size, &nfa_cho_cb.tx_ndef_cur_size,
error_reason, error_data);
if (status != NDEF_OK)
{
CHO_TRACE_ERROR0 ("Failed to add err record");
GKI_freebuf (nfa_cho_cb.p_tx_ndef_msg);
nfa_cho_cb.p_tx_ndef_msg = NULL;
return NFA_STATUS_FAILED;
}
#if (BT_TRACE_PROTOCOL == TRUE)
DispCHO (nfa_cho_cb.p_tx_ndef_msg, nfa_cho_cb.tx_ndef_cur_size, FALSE);
#endif
/* Send it to peer */
nfa_cho_cb.tx_ndef_sent_size = 0;
status = nfa_cho_send_handover_msg ();
if (status == NFA_STATUS_CONGESTED)
{
status = NFA_STATUS_OK;
}
return status;
}
/*******************************************************************************
**
** Function nfa_cho_get_random_number
**
** Description Return random number in Handover Request message
**
**
** Returns random number in "cr" record
**
*******************************************************************************/
UINT16 nfa_cho_get_random_number (UINT8 *p_ndef_msg)
{
UINT16 random_number;
UINT8 *p_cr_record, *p_cr_payload;
UINT32 cr_payload_len;
CHO_TRACE_DEBUG0 ("nfa_cho_get_random_number ()");
/* find Collision Resolution record */
p_cr_record = NDEF_MsgGetFirstRecByType (p_ndef_msg, NDEF_TNF_WKT, cr_rec_type, CR_REC_TYPE_LEN);
if (!p_cr_record)
{
CHO_TRACE_ERROR0 ("Failed to find cr record");
return 0;
}
/* get start of payload in Collision Resolution record */
p_cr_payload = NDEF_RecGetPayload (p_cr_record, &cr_payload_len);
if ((!p_cr_payload) || (cr_payload_len != 2))
{
CHO_TRACE_ERROR0 ("Failed to get cr payload (random number)");
return 0;
}
/* get random number from payload */
BE_STREAM_TO_UINT16 (random_number, p_cr_payload);
return random_number;
}
/*******************************************************************************
**
** Function nfa_cho_parse_ac_records
**
** Description Parsing NDEF message to retrieve Alternative Carrier records
** and store into tNFA_CHO_AC_REC
**
** Returns tNFA_STATUS
**
*******************************************************************************/
tNFA_STATUS nfa_cho_parse_ac_records (UINT8 *p_ndef_msg, UINT8 *p_num_ac_rec, tNFA_CHO_AC_REC *p_ac_rec)
{
UINT8 *p_ac_record, *p_ac_payload;
UINT32 ac_payload_len;
UINT8 xx, yy;
CHO_TRACE_DEBUG0 ("nfa_cho_parse_ac_records ()");
/* get Alternative Carrier record */
p_ac_record = NDEF_MsgGetFirstRecByType (p_ndef_msg, NDEF_TNF_WKT, ac_rec_type, AC_REC_TYPE_LEN);
xx = 0;
while ((p_ac_record) && (xx < NFA_CHO_MAX_AC_INFO))
{
/* get payload */
p_ac_payload = NDEF_RecGetPayload (p_ac_record, &ac_payload_len);
if ((!p_ac_payload) || (ac_payload_len < 3))
{
CHO_TRACE_ERROR0 ("Failed to get ac payload");
return NFA_STATUS_FAILED;
}
/* Carrier Power State */
BE_STREAM_TO_UINT8 (p_ac_rec->cps, p_ac_payload);
/* Carrier Data Reference Length and Characters */
BE_STREAM_TO_UINT8 (p_ac_rec->carrier_data_ref.ref_len, p_ac_payload);
ac_payload_len -= 2;
/* remaining must have carrier data ref and Auxiliary Data Reference Count at least */
if (ac_payload_len > p_ac_rec->carrier_data_ref.ref_len)
{
if (p_ac_rec->carrier_data_ref.ref_len > NFA_CHO_MAX_REF_NAME_LEN)
{
CHO_TRACE_ERROR1 ("Too many bytes for carrier_data_ref, ref_len = %d",
p_ac_rec->carrier_data_ref.ref_len);
return NFA_STATUS_FAILED;
}
BE_STREAM_TO_ARRAY (p_ac_payload,
p_ac_rec->carrier_data_ref.ref_name,
p_ac_rec->carrier_data_ref.ref_len);
ac_payload_len -= p_ac_rec->carrier_data_ref.ref_len;
}
else
{
CHO_TRACE_ERROR0 ("Failed to parse carrier_data_ref.ref_len");
return NFA_STATUS_FAILED;
}
/* Auxiliary Data Reference Count */
BE_STREAM_TO_UINT8 (p_ac_rec->aux_data_ref_count, p_ac_payload);
ac_payload_len--;
/* Auxiliary Data Reference Length and Characters */
for (yy = 0; (yy < p_ac_rec->aux_data_ref_count) && (yy < NFA_CHO_MAX_AUX_DATA_COUNT); yy++)
{
if (ac_payload_len > 0)
{
BE_STREAM_TO_UINT8 (p_ac_rec->aux_data_ref[yy].ref_len, p_ac_payload);
ac_payload_len--;
if (ac_payload_len >= p_ac_rec->aux_data_ref[yy].ref_len)
{
if (p_ac_rec->aux_data_ref[yy].ref_len > NFA_CHO_MAX_REF_NAME_LEN)
{
CHO_TRACE_ERROR2 ("Too many bytes for aux_data_ref[%d], ref_len=%d",
yy, p_ac_rec->aux_data_ref[yy].ref_len);
return NFA_STATUS_FAILED;
}
BE_STREAM_TO_ARRAY (p_ac_payload,
p_ac_rec->aux_data_ref[yy].ref_name,
p_ac_rec->aux_data_ref[yy].ref_len);
ac_payload_len -= p_ac_rec->aux_data_ref[yy].ref_len;
}
else
{
CHO_TRACE_ERROR1 ("Failed to parse ref_name for aux_data_ref[%d]", yy);
return NFA_STATUS_FAILED;
}
}
else
{
CHO_TRACE_ERROR1 ("Failed to parse ref_len for aux_data_ref[%d]", yy);
return NFA_STATUS_FAILED;
}
}
if (ac_payload_len != 0)
{
CHO_TRACE_WARNING1 ("Found extra data in AC record[%d]", xx);
}
xx++;
p_ac_rec++;
/* get next Alternative Carrier record */
p_ac_record = NDEF_MsgGetNextRecByType (p_ac_record, NDEF_TNF_WKT, ac_rec_type, AC_REC_TYPE_LEN);
}
*p_num_ac_rec = xx;
return NFA_STATUS_OK;
}
/*******************************************************************************
**
** Function nfa_cho_parse_hr_record
**
** Description Parsing Handover Request message to retrieve version, random number,
** Alternative Carrier records and store into tNFA_CHO_AC_REC
**
**
** Returns tNFA_STATUS
**
*******************************************************************************/
tNFA_STATUS nfa_cho_parse_hr_record (UINT8 *p_ndef_msg,
UINT8 *p_version,
UINT16 *p_random_number,
UINT8 *p_num_ac_rec,
tNFA_CHO_AC_REC *p_ac_rec)
{
UINT8 *p_hr_record, *p_hr_payload;
UINT32 hr_payload_len;
CHO_TRACE_DEBUG0 ("nfa_cho_parse_hr_record ()");
/* get Handover Request record */
p_hr_record = NDEF_MsgGetFirstRecByType (p_ndef_msg, NDEF_TNF_WKT, hr_rec_type, HR_REC_TYPE_LEN);
if (!p_hr_record)
{
CHO_TRACE_ERROR0 ("Failed to find Hr record");
return NFA_STATUS_FAILED;
}
p_hr_payload = NDEF_RecGetPayload (p_hr_record, &hr_payload_len);
if ((!p_hr_payload) || (hr_payload_len < 7))
{
CHO_TRACE_ERROR0 ("Failed to get Hr payload (version, cr/ac record)");
return NFA_STATUS_FAILED;
}
/* Version */
STREAM_TO_UINT8 ((*p_version), p_hr_payload);
hr_payload_len--;
/* NDEF message for Collision Resolution record and Alternative Carrier records */
if (NDEF_OK != NDEF_MsgValidate (p_hr_payload, hr_payload_len, FALSE))
{
CHO_TRACE_ERROR0 ("Failed to validate NDEF message for cr/ac records");
return NFA_STATUS_FAILED;
}
/* Collision Resolution record */
if (p_random_number)
{
*p_random_number = nfa_cho_get_random_number (p_hr_payload);
}
/* Alternative Carrier records */
if (p_ac_rec)
{
return (nfa_cho_parse_ac_records (p_hr_payload, p_num_ac_rec, p_ac_rec));
}
return NFA_STATUS_OK;
}
/*******************************************************************************
**
** Function nfa_cho_parse_carrier_config
**
** Description Parse Alternative Carrier Configuration and Aux Data
**
**
** Returns tNFA_STATUS
**
*******************************************************************************/
tNFA_STATUS nfa_cho_parse_carrier_config (UINT8 *p_ndef_msg, UINT8 num_ac_rec, tNFA_CHO_AC_REC *p_ac_rec)
{
UINT8 *p_record;
UINT8 xx, yy;
CHO_TRACE_DEBUG1 ("nfa_cho_parse_carrier_config () num_ac_rec = %d", num_ac_rec);
/* Parse Alternative Carrier Configuration and Aux Data */
for (xx = 0; xx < num_ac_rec; xx++)
{
p_record = NDEF_MsgGetFirstRecById (p_ndef_msg,
p_ac_rec->carrier_data_ref.ref_name,
p_ac_rec->carrier_data_ref.ref_len);
if (!p_record)
{
CHO_TRACE_ERROR2 ("Failed to find Payload ID: len=%d, [0x%x ...]",
p_ac_rec->carrier_data_ref.ref_len,
p_ac_rec->carrier_data_ref.ref_name[0]);
return NFA_STATUS_FAILED;
}
for (yy = 0; yy < p_ac_rec->aux_data_ref_count; yy++)
{
/* Get aux data record by Payload ID */
p_record = NDEF_MsgGetFirstRecById (p_ndef_msg,
p_ac_rec->aux_data_ref[yy].ref_name,
p_ac_rec->aux_data_ref[yy].ref_len);
if (!p_record)
{
CHO_TRACE_ERROR2 ("Failed to find Payload ID for Aux: len=%d, [0x%x ...]",
p_ac_rec->aux_data_ref[yy].ref_len,
p_ac_rec->aux_data_ref[yy].ref_name[0]);
return NFA_STATUS_FAILED;
}
}
p_ac_rec++;
}
return NFA_STATUS_OK;
}
/*******************************************************************************
**
** Function nfa_cho_proc_hr
**
** Description Parse Handover Request Message
** In case of parsing error, let peer got timeout (1 sec).
**
**
** Returns None
**
*******************************************************************************/
void nfa_cho_proc_hr (UINT32 length, UINT8 *p_ndef_msg)
{
tNFA_CHO_EVT_DATA evt_data;
tNFA_CHO_API_SEND_HS select;
UINT8 version;
UINT16 random_number;
CHO_TRACE_DEBUG1 ("nfa_cho_proc_hr () length=%d", length);
/* Parse Handover Request record */
if (NDEF_OK != nfa_cho_parse_hr_record (p_ndef_msg, &version, &random_number,
&evt_data.request.num_ac_rec,
&evt_data.request.ac_rec[0]))
{
CHO_TRACE_ERROR0 ("Failed to parse hr record");
return;
}
if (version != NFA_CHO_VERSION)
{
CHO_TRACE_DEBUG1 ("Version (0x%02x) not matched", version);
/* For the future, */
/* if we have higher major then support peer's version */
/* if we have lower major then send empty handover select message */
if (NFA_CHO_GET_MAJOR_VERSION (version) > NFA_CHO_GET_MAJOR_VERSION (NFA_CHO_VERSION))
{
select.num_ac_info = 0;
nfa_cho_send_hs (&select);
return;
}
}
if (NFA_STATUS_OK != nfa_cho_parse_carrier_config (p_ndef_msg,
evt_data.request.num_ac_rec,
&evt_data.request.ac_rec[0]))
{
CHO_TRACE_ERROR0 ("Failed to parse carrier configuration");
evt_data.request.status = NFA_STATUS_FAILED;
evt_data.request.num_ac_rec = 0;
evt_data.request.p_ref_ndef = NULL;
evt_data.request.ref_ndef_len = 0;
nfa_cho_cb.p_cback (NFA_CHO_REQUEST_EVT, &evt_data);
return;
}
if (evt_data.request.num_ac_rec)
{
/* passing alternative carrier references */
evt_data.request.p_ref_ndef = NDEF_MsgGetNextRec (p_ndef_msg);
*evt_data.request.p_ref_ndef |= NDEF_MB_MASK;
evt_data.request.ref_ndef_len = (UINT32)(length - (evt_data.request.p_ref_ndef - p_ndef_msg));
}
else
{
evt_data.request.p_ref_ndef = NULL;
evt_data.request.ref_ndef_len = 0;
}
evt_data.request.status = NFA_STATUS_OK;
nfa_cho_cb.p_cback (NFA_CHO_REQUEST_EVT, &evt_data);
}
/*******************************************************************************
**
** Function nfa_cho_get_error
**
** Description Search Error record and parse it
**
**
** Returns tNFA_STATUS
**
*******************************************************************************/
tNFA_STATUS nfa_cho_get_error (UINT8 *p_ndef_msg, UINT8 *p_error_reason, UINT32 *p_error_data)
{
UINT8 *p_err_record, *p_err_payload, u8;
UINT32 err_payload_len;
CHO_TRACE_DEBUG0 ("nfa_cho_get_error ()");
p_err_record = NDEF_MsgGetFirstRecByType (p_ndef_msg, NDEF_TNF_WKT, err_rec_type, ERR_REC_TYPE_LEN);
if (!p_err_record)
{
CHO_TRACE_DEBUG0 ("Found no err record");
return NFA_STATUS_FAILED;
}
p_err_payload = NDEF_RecGetPayload (p_err_record, &err_payload_len);
if (!p_err_payload)
{
CHO_TRACE_ERROR0 ("Failed to get err payload");
return NFA_STATUS_SYNTAX_ERROR;
}
BE_STREAM_TO_UINT8 (*p_error_reason, p_err_payload);
if ( (err_payload_len == 2)
&&( (*p_error_reason == NFA_CHO_ERROR_TEMP_MEM)
||(*p_error_reason == NFA_CHO_ERROR_CARRIER) ) )
{
BE_STREAM_TO_UINT8 (u8, p_err_payload);
*p_error_data = (UINT32)u8;
}
else if ( (err_payload_len == 5)
&&(*p_error_reason == NFA_CHO_ERROR_PERM_MEM) )
{
BE_STREAM_TO_UINT32 (*p_error_data, p_err_payload);
}
else
{
CHO_TRACE_ERROR2 ("Unknown error reason = %d, err_payload_len = %d",
*p_error_reason, err_payload_len);
return NFA_STATUS_SYNTAX_ERROR;
}
CHO_TRACE_DEBUG2 ("error_reason=0x%x, error_data=0x%x", *p_error_reason, *p_error_data);
return NFA_STATUS_OK;
}
/*******************************************************************************
**
** Function nfa_cho_parse_hs_record
**
** Description Parse Handover Select record
**
**
** Returns tNFA_STATUS
**
*******************************************************************************/
tNFA_STATUS nfa_cho_parse_hs_record (UINT8 *p_ndef_msg,
UINT8 *p_version,
UINT8 *p_num_ac_rec,
tNFA_CHO_AC_REC *p_ac_rec,
UINT8 *p_error_reason,
UINT32 *p_error_data)
{
tNFA_STATUS status;
UINT8 *p_hs_record, *p_hs_payload;
UINT32 hs_payload_len;
CHO_TRACE_DEBUG0 ("nfa_cho_parse_hs_record ()");
/* get Handover Select record */
p_hs_record = NDEF_MsgGetFirstRecByType (p_ndef_msg, NDEF_TNF_WKT, hs_rec_type, HS_REC_TYPE_LEN);
if (!p_hs_record)
{
CHO_TRACE_ERROR0 ("Failed to find Hs record");
return NFA_STATUS_FAILED;
}
p_hs_payload = NDEF_RecGetPayload (p_hs_record, &hs_payload_len);
if ((!p_hs_payload) || (hs_payload_len < 1)) /* at least version */
{
CHO_TRACE_ERROR0 ("Failed to get Hs payload (version, ac record)");
return NFA_STATUS_FAILED;
}
STREAM_TO_UINT8 ((*p_version), p_hs_payload);
hs_payload_len--;
/* Check if error record is sent */
status = nfa_cho_get_error (p_ndef_msg, p_error_reason, p_error_data);
if (status == NFA_STATUS_SYNTAX_ERROR)
{
return NFA_STATUS_FAILED;
}
else if (status == NFA_STATUS_OK)
{
return NFA_STATUS_OK;
}
if (hs_payload_len >= 3 )
{
/* NDEF message for Alternative Carrier records */
if (NDEF_OK != NDEF_MsgValidate (p_hs_payload, hs_payload_len, FALSE))
{
CHO_TRACE_ERROR0 ("Failed to validate NDEF message for ac records");
return NFA_STATUS_FAILED;
}
/* Alternative Carrier records */
if (p_ac_rec)
{
if (NFA_STATUS_OK != nfa_cho_parse_ac_records (p_hs_payload, p_num_ac_rec, p_ac_rec))
{
return NFA_STATUS_FAILED;
}
CHO_TRACE_DEBUG1 ("Found %d ac record", *p_num_ac_rec);
}
}
else
{
CHO_TRACE_DEBUG0 ("Empty Handover Select Message");
*p_num_ac_rec = 0;
}
return NFA_STATUS_OK;
}
/*******************************************************************************
**
** Function nfa_cho_proc_hs
**
** Description Parse Handover Select Message
**
**
** Returns FALSE if we need to select one from inactive ACs
**
*******************************************************************************/
void nfa_cho_proc_hs (UINT32 length, UINT8 *p_ndef_msg)
{
tNFA_CHO_EVT_DATA evt_data;
UINT8 version, error_reason = 0;
UINT32 error_data;
CHO_TRACE_DEBUG0 ("nfa_cho_proc_hs ()");
evt_data.select.status = NFA_STATUS_OK;
/* Parse Handover Select record */
if (NFA_STATUS_OK != nfa_cho_parse_hs_record (p_ndef_msg, &version,
&evt_data.select.num_ac_rec,
&evt_data.select.ac_rec[0],
&error_reason, &error_data))
{
CHO_TRACE_ERROR0 ("Failed to parse hs record");
evt_data.select.status = NFA_STATUS_FAILED;
}
if ( (evt_data.select.status == NFA_STATUS_OK)
&&(error_reason != 0) )
{
/* We got error records */
evt_data.sel_err.error_reason = error_reason;
evt_data.sel_err.error_data = error_data;
nfa_cho_cb.p_cback (NFA_CHO_SEL_ERR_EVT, &evt_data);
return;
}
if ( (evt_data.select.status == NFA_STATUS_OK)
&&(version != NFA_CHO_VERSION) )
{
CHO_TRACE_ERROR1 ("Version (0x%02x) not matched", version);
evt_data.select.status = NFA_STATUS_FAILED;
}
/* parse Alternative Carrier information */
if ( (evt_data.select.status == NFA_STATUS_OK)
&&(NFA_STATUS_OK != nfa_cho_parse_carrier_config (p_ndef_msg,
evt_data.select.num_ac_rec,
&evt_data.select.ac_rec[0])) )
{
CHO_TRACE_ERROR0 ("Failed to parse carrier configuration");
evt_data.select.status = NFA_STATUS_FAILED;
}
if (evt_data.select.status == NFA_STATUS_OK)
{
if (evt_data.select.num_ac_rec)
{
/* passing alternative carrier references */
evt_data.select.p_ref_ndef = NDEF_MsgGetNextRec (p_ndef_msg);
*evt_data.select.p_ref_ndef |= NDEF_MB_MASK;
evt_data.select.ref_ndef_len = (UINT32)(length - (evt_data.select.p_ref_ndef - p_ndef_msg));
}
else
{
evt_data.select.p_ref_ndef = NULL;
evt_data.select.ref_ndef_len = 0;
}
}
else
{
evt_data.select.num_ac_rec = 0;
evt_data.select.p_ref_ndef = NULL;
evt_data.select.ref_ndef_len = 0;
}
nfa_cho_cb.p_cback (NFA_CHO_SELECT_EVT, &evt_data);
}
/*******************************************************************************
**
** Function nfa_cho_proc_simplified_format
**
** Description Parse simplified BT OOB/Wifi Message
**
**
** Returns void
**
*******************************************************************************/
void nfa_cho_proc_simplified_format (UINT32 length, UINT8 *p_ndef_msg)
{
tNFA_CHO_EVT_DATA evt_data;
CHO_TRACE_DEBUG0 ("nfa_cho_proc_simplified_format ()");
evt_data.select.status = NFA_STATUS_OK;
evt_data.select.num_ac_rec = 1;
evt_data.select.ac_rec[0].cps = NFA_CHO_CPS_UNKNOWN;
evt_data.select.ac_rec[0].carrier_data_ref.ref_len = 0;
evt_data.select.ac_rec[0].aux_data_ref_count = 0;
evt_data.select.p_ref_ndef = p_ndef_msg;
evt_data.select.ref_ndef_len = length;
nfa_cho_cb.p_cback (NFA_CHO_SELECT_EVT, &evt_data);
}
/*******************************************************************************
**
** Function nfa_cho_get_msg_type
**
** Description Get handover message type to check collision
**
**
** Returns NFA_CHO_MSG_HR if it has Handover Request record
** NFA_CHO_MSG_HS if it has Handover Select record
** NFA_CHO_MSG_BT_OOB if it has simplified BT OOB record
** NFA_CHO_MSG_WIFI if it has simplified WiFi record
** NFA_CHO_MSG_UNKNOWN, otherwise
**
*******************************************************************************/
tNFA_CHO_MSG_TYPE nfa_cho_get_msg_type (UINT32 length, UINT8 *p_ndef_msg)
{
UINT8 *p_record;
CHO_TRACE_DEBUG1 ("nfa_cho_get_msg_type () length=%d", length);
p_record = NDEF_MsgGetFirstRecByType (p_ndef_msg, NDEF_TNF_WKT, hr_rec_type, HR_REC_TYPE_LEN);
if (p_record)
{
CHO_TRACE_DEBUG0 ("Found Hr record");
return NFA_CHO_MSG_HR;
}
p_record = NDEF_MsgGetFirstRecByType (p_ndef_msg, NDEF_TNF_WKT, hs_rec_type, HS_REC_TYPE_LEN);
if (p_record)
{
CHO_TRACE_DEBUG0 ("Found Hs record");
return NFA_CHO_MSG_HS;
}
p_record = NDEF_MsgGetFirstRecByType (p_ndef_msg, NDEF_TNF_MEDIA,
p_bt_oob_rec_type, BT_OOB_REC_TYPE_LEN);
if (p_record)
{
CHO_TRACE_DEBUG0 ("Found simplified BT OOB record");
return NFA_CHO_MSG_BT_OOB;
}
p_record = NDEF_MsgGetFirstRecByType (p_ndef_msg, NDEF_TNF_MEDIA,
p_wifi_rec_type, (UINT8) strlen ((char *) p_wifi_rec_type));
if (p_record)
{
CHO_TRACE_DEBUG0 ("Found simplified WiFi record");
return NFA_CHO_MSG_WIFI;
}
CHO_TRACE_ERROR0 ("Failed to find Hr/Hs record");
return NFA_CHO_MSG_UNKNOWN;
}
/*******************************************************************************
**
** Function nfa_cho_get_local_device_role
**
** Description Resolve collision and get role of local device
**
**
** Returns tNFA_CHO_ROLE_TYPE
**
*******************************************************************************/
tNFA_CHO_ROLE_TYPE nfa_cho_get_local_device_role (UINT32 length, UINT8 *p_ndef_msg)
{
UINT16 rx_random_number;
UINT8 version;
CHO_TRACE_DEBUG1 ("nfa_cho_get_local_device_role () length=%d", length);
/* Get random number in Handover Request record */
if (NDEF_OK != nfa_cho_parse_hr_record (p_ndef_msg, &version, &rx_random_number, NULL, NULL))
{
CHO_TRACE_ERROR0 ("Failed to parse hr record");
return NFA_CHO_ROLE_UNDECIDED;
}
CHO_TRACE_DEBUG2 ("tx_random_number=0x%x, rx_random_number=0x%x",
nfa_cho_cb.tx_random_number, rx_random_number);
if (nfa_cho_cb.tx_random_number == rx_random_number)
{
return NFA_CHO_ROLE_UNDECIDED;
}
/* if the least significant bits are same */
else if (((nfa_cho_cb.tx_random_number ^ rx_random_number) & 0x0001) == 0)
{
if (nfa_cho_cb.tx_random_number > rx_random_number)
return NFA_CHO_ROLE_SELECTOR;
else
return NFA_CHO_ROLE_REQUESTER;
}
else
{
if (nfa_cho_cb.tx_random_number > rx_random_number)
return NFA_CHO_ROLE_REQUESTER;
else
return NFA_CHO_ROLE_SELECTOR;
}
}
/*******************************************************************************
**
** Function nfa_cho_update_random_number
**
** Description Replace random number
**
**
** Returns tNFA_STATUS
**
*******************************************************************************/
tNFA_STATUS nfa_cho_update_random_number (UINT8 *p_ndef_msg)
{
UINT8 *p_hr_record, *p_hr_payload;
UINT8 *p_cr_record, *p_cr_payload;
UINT32 hr_payload_len, cr_payload_len;
UINT32 temp32;
CHO_TRACE_DEBUG0 ("nfa_cho_update_random_number ()");
/* get Handover Request record */
p_hr_record = NDEF_MsgGetFirstRecByType (p_ndef_msg, NDEF_TNF_WKT, hr_rec_type, HR_REC_TYPE_LEN);
if (!p_hr_record)
{
CHO_TRACE_ERROR0 ("Failed to find Hr record");
return NFA_STATUS_FAILED;
}
p_hr_payload = NDEF_RecGetPayload (p_hr_record, &hr_payload_len);
/* Skip Version */
p_hr_payload++;
hr_payload_len--;
/* NDEF message for Collision Resolution record and Alternative Carrier records */
/* find Collision Resolution record */
p_cr_record = NDEF_MsgGetFirstRecByType (p_hr_payload, NDEF_TNF_WKT, cr_rec_type, CR_REC_TYPE_LEN);
if (!p_cr_record)
{
CHO_TRACE_ERROR0 ("Failed to find cr record");
return NFA_STATUS_FAILED;
}
/* get start of payload in Collision Resolution record */
p_cr_payload = NDEF_RecGetPayload (p_cr_record, &cr_payload_len);
/* Get random number from timer */
temp32 = GKI_get_tick_count ();
nfa_cho_cb.tx_random_number = (UINT16) ((temp32 >> 16) ^ (temp32));
#if (defined (NFA_CHO_TEST_INCLUDED) && (NFA_CHO_TEST_INCLUDED == TRUE))
if (nfa_cho_cb.test_enabled & NFA_CHO_TEST_RANDOM)
{
nfa_cho_cb.tx_random_number = nfa_cho_cb.test_random_number;
}
#endif
CHO_TRACE_DEBUG1 ("tx_random_number = 0x%04x", nfa_cho_cb.tx_random_number);
/* update random number in payload */
UINT16_TO_BE_STREAM (p_cr_payload, nfa_cho_cb.tx_random_number);
return NFA_STATUS_OK;
}