| /****************************************************************************** |
| * |
| * 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 generic SNEP implementation file for the NFA SNEP. |
| * |
| ******************************************************************************/ |
| #include <string.h> |
| #include "nfa_api.h" |
| #include "nfa_sys.h" |
| #include "nfa_sys_int.h" |
| #include "llcp_defs.h" |
| #include "nfa_p2p_int.h" |
| #include "nfa_snep_int.h" |
| #include "nfa_mem_co.h" |
| #include "trace_api.h" |
| |
| /***************************************************************************** |
| ** Global Variables |
| *****************************************************************************/ |
| |
| /***************************************************************************** |
| ** Static Functions |
| *****************************************************************************/ |
| |
| /* debug functions type */ |
| #if (BT_TRACE_VERBOSE == TRUE) |
| static char *nfa_snep_opcode (UINT8 opcode); |
| #endif |
| |
| /***************************************************************************** |
| ** Constants |
| *****************************************************************************/ |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_sap_to_index |
| ** |
| ** Description find a connection control block with SAP |
| ** |
| ** |
| ** Returns index of connection control block if success |
| ** NFA_SNEP_MAX_CONN, otherwise |
| ** |
| *******************************************************************************/ |
| UINT8 nfa_snep_sap_to_index (UINT8 local_sap, UINT8 remote_sap, UINT8 flags) |
| { |
| UINT8 xx; |
| |
| for (xx = 0; xx < NFA_SNEP_MAX_CONN; xx++) |
| { |
| if ( (nfa_snep_cb.conn[xx].p_cback) |
| &&(nfa_snep_cb.conn[xx].local_sap == local_sap) |
| &&((remote_sap == NFA_SNEP_ANY_SAP) || (nfa_snep_cb.conn[xx].remote_sap == remote_sap)) |
| &&((nfa_snep_cb.conn[xx].flags & flags) == flags) ) |
| { |
| return xx; |
| } |
| } |
| return NFA_SNEP_MAX_CONN; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_allocate_cb |
| ** |
| ** Description Allocate a connection control block |
| ** |
| ** |
| ** Returns index of connection control block if success |
| ** NFA_SNEP_MAX_CONN, otherwise |
| ** |
| *******************************************************************************/ |
| UINT8 nfa_snep_allocate_cb (void) |
| { |
| UINT8 xx; |
| |
| for (xx = 0; xx < NFA_SNEP_MAX_CONN; xx++) |
| { |
| if (nfa_snep_cb.conn[xx].p_cback == NULL) |
| { |
| memset (&nfa_snep_cb.conn[xx], 0x00, sizeof (tNFA_SNEP_CONN)); |
| return xx; |
| } |
| } |
| return NFA_SNEP_MAX_CONN; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_deallocate_cb |
| ** |
| ** Description Deallocate a connection control block |
| ** |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void nfa_snep_deallocate_cb (UINT8 xx) |
| { |
| nfa_snep_cb.conn[xx].p_cback = NULL; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_timer_cback |
| ** |
| ** Description Process timeout event when timer expires |
| ** |
| ** |
| ** Returns None |
| ** |
| *******************************************************************************/ |
| static void nfa_snep_timer_cback (void *p_tle) |
| { |
| UINT8 dlink = (UINT8) ((TIMER_LIST_ENT*)p_tle)->event; |
| |
| SNEP_TRACE_DEBUG1 ("nfa_snep_timer_cback () dlink = %d", dlink); |
| |
| /* application will free buffer when receiving NFA_SNEP_DISC_EVT */ |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| LLCP_DisconnectReq (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, TRUE); |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_get_efficent_miu |
| ** |
| ** Description Calculate best MIU to send data for throughput |
| ** |
| ** |
| ** Returns most efficent MIU for throughput |
| ** |
| *******************************************************************************/ |
| static UINT16 nfa_snep_get_efficent_miu (UINT16 remote_miu, UINT8 remote_rw) |
| { |
| UINT16 local_link_miu, remote_link_miu; |
| UINT16 max_num_pdu_in_agf; |
| UINT16 efficent_miu; |
| |
| SNEP_TRACE_DEBUG2 ("nfa_snep_get_efficent_miu () remote_miu = %d, remote_rw = %d", |
| remote_miu, remote_rw); |
| |
| LLCP_GetLinkMIU (&local_link_miu, &remote_link_miu); |
| |
| /* local buffer size is small than max receiving size of peer */ |
| if (local_link_miu < remote_link_miu) |
| { |
| remote_link_miu = local_link_miu; |
| } |
| |
| /* |
| ** 9 bytes overhead if AGF is used |
| ** - 2 byts AGF header |
| ** - at least two of 2 bytes length field for I-PDU |
| ** - 3 bytes header for I-PDU |
| */ |
| if (remote_link_miu - remote_miu > 9) |
| { |
| /* |
| ** 5 bytes overhead for each I-PDU in AGF |
| ** - 2 bytes length field |
| ** - 3 bytes header for I-PDU |
| */ |
| max_num_pdu_in_agf = remote_link_miu / (remote_miu + 5); |
| |
| if (remote_link_miu % (remote_miu + 5)) |
| { |
| max_num_pdu_in_agf += 1; |
| } |
| |
| /* if local devie can put all I-PDU in one AGF */ |
| if (max_num_pdu_in_agf <= remote_rw) |
| { |
| efficent_miu = (remote_link_miu - max_num_pdu_in_agf*5)/max_num_pdu_in_agf; |
| } |
| else |
| { |
| efficent_miu = remote_miu; |
| } |
| } |
| else |
| { |
| efficent_miu = remote_miu; |
| } |
| |
| SNEP_TRACE_DEBUG2 ("nfa_snep_get_efficent_miu () remote_link_miu = %d, efficent_miu = %d", |
| remote_link_miu, efficent_miu); |
| |
| return efficent_miu; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_check_version |
| ** |
| ** Description Check version of SNEP |
| ** |
| ** |
| ** Returns TRUE if supported |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_check_version (UINT8 version) |
| { |
| /* if major version is matched */ |
| if ((version & 0xF0) == (NFA_SNEP_VERSION & 0xF0)) |
| return TRUE; |
| else |
| return FALSE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_send_msg |
| ** |
| ** Description Send complete or the first fragment of SNEP message with or |
| ** without information. |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void nfa_snep_send_msg (UINT8 opcode, UINT8 dlink) |
| { |
| BT_HDR *p_msg; |
| UINT32 length; |
| UINT8 *p; |
| tLLCP_STATUS status = LLCP_STATUS_FAIL; |
| |
| #if (BT_TRACE_VERBOSE == TRUE) |
| SNEP_TRACE_DEBUG4 ("nfa_snep_send_msg () [0x%x, 0x%x]: %s (0x%02x)", |
| nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, |
| nfa_snep_opcode (opcode), opcode); |
| #else |
| SNEP_TRACE_DEBUG3 ("nfa_snep_send_msg () [0x%x, 0x%x]: opcode 0x%02x", |
| nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, |
| opcode); |
| #endif |
| |
| /* if there is pending SNEP message and opcode can have information */ |
| if ( (nfa_snep_cb.conn[dlink].p_ndef_buff) |
| &&((opcode == NFA_SNEP_REQ_CODE_GET) || (opcode == NFA_SNEP_REQ_CODE_PUT) || (opcode == NFA_SNEP_RESP_CODE_SUCCESS)) ) |
| { |
| length = NFA_SNEP_HEADER_SIZE + nfa_snep_cb.conn[dlink].ndef_length; |
| |
| if (opcode == NFA_SNEP_REQ_CODE_GET) |
| { |
| length += NFA_SNEP_ACCEPT_LEN_SIZE; /* add acceptable length field */ |
| } |
| |
| /* if message is bigger than peer's MIU, send the first fragment */ |
| if (length > nfa_snep_cb.conn[dlink].tx_miu) |
| { |
| length = nfa_snep_cb.conn[dlink].tx_miu; |
| } |
| |
| if ((p_msg = (BT_HDR *) GKI_getpoolbuf (LLCP_POOL_ID)) != NULL) |
| { |
| p_msg->len = (UINT16) length; |
| p_msg->offset = LLCP_MIN_OFFSET; |
| |
| p = (UINT8*) (p_msg + 1) + p_msg->offset; |
| |
| /* add SNEP header */ |
| UINT8_TO_BE_STREAM (p, NFA_SNEP_VERSION); |
| UINT8_TO_BE_STREAM (p, opcode); |
| |
| if (opcode == NFA_SNEP_REQ_CODE_GET) |
| { |
| /* add acceptable length field in information field*/ |
| UINT32_TO_BE_STREAM (p, nfa_snep_cb.conn[dlink].ndef_length + NFA_SNEP_ACCEPT_LEN_SIZE); |
| UINT32_TO_BE_STREAM (p, nfa_snep_cb.conn[dlink].acceptable_length); |
| length -= NFA_SNEP_ACCEPT_LEN_SIZE; |
| } |
| else |
| { |
| UINT32_TO_BE_STREAM (p, nfa_snep_cb.conn[dlink].ndef_length); |
| } |
| |
| length -= NFA_SNEP_HEADER_SIZE; |
| |
| |
| /* add the first fragment or complete of NDEF message */ |
| memcpy (p, nfa_snep_cb.conn[dlink].p_ndef_buff, length); |
| |
| #if (BT_TRACE_PROTOCOL == TRUE) |
| DispSNEP (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, |
| (UINT8*)(p_msg + 1) + p_msg->offset, |
| NFA_SNEP_HEADER_SIZE, |
| FALSE); |
| #endif |
| status = LLCP_SendData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, p_msg); |
| |
| if (status != LLCP_STATUS_FAIL) |
| { |
| SNEP_TRACE_DEBUG2 ("nfa_snep_send_msg (): sending %d out of %d", |
| length, nfa_snep_cb.conn[dlink].ndef_length); |
| |
| /* if sent complete SNEP message */ |
| if (length == nfa_snep_cb.conn[dlink].ndef_length) |
| { |
| nfa_snep_cb.conn[dlink].cur_length = 0; |
| |
| if ( (opcode == NFA_SNEP_RESP_CODE_SUCCESS) |
| &&(nfa_snep_cb.conn[dlink].rx_code == NFA_SNEP_REQ_CODE_GET) ) |
| { |
| /* Set LLCP to send LLCP_SAP_EVT_TX_COMPLETE */ |
| LLCP_SetTxCompleteNtf (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap); |
| } |
| } |
| else |
| { |
| /* update sent length */ |
| nfa_snep_cb.conn[dlink].cur_length = length; |
| |
| if ((opcode == NFA_SNEP_REQ_CODE_GET) || (opcode == NFA_SNEP_REQ_CODE_PUT)) |
| { |
| nfa_snep_cb.conn[dlink].flags |= NFA_SNEP_FLAG_W4_RESP_CONTINUE; |
| } |
| else /* (opcode == NFA_SNEP_RESP_CODE_SUCCESS) */ |
| { |
| nfa_snep_cb.conn[dlink].flags |= NFA_SNEP_FLAG_W4_REQ_CONTINUE; |
| } |
| } |
| } |
| } |
| } |
| else /* opcode without information */ |
| { |
| if ((p_msg = (BT_HDR *) GKI_getpoolbuf (LLCP_POOL_ID)) != NULL) |
| { |
| p_msg->len = NFA_SNEP_HEADER_SIZE; |
| p_msg->offset = LLCP_MIN_OFFSET; |
| |
| p = (UINT8*) (p_msg + 1) + p_msg->offset; |
| |
| /* add SNEP header without information */ |
| UINT8_TO_BE_STREAM (p, NFA_SNEP_VERSION); |
| UINT8_TO_BE_STREAM (p, opcode); |
| UINT32_TO_BE_STREAM (p, 0); |
| |
| #if (BT_TRACE_PROTOCOL == TRUE) |
| DispSNEP(nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, |
| (UINT8*)(p_msg + 1) + p_msg->offset, |
| NFA_SNEP_HEADER_SIZE, |
| FALSE); |
| #endif |
| status = LLCP_SendData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, p_msg); |
| } |
| } |
| |
| if (status == LLCP_STATUS_FAIL) |
| { |
| SNEP_TRACE_ERROR0 ("Cannot allocate buffer or failed to send data"); |
| |
| /* upper layer will free buffer when NFA_SNEP_DISC_EVT is received */ |
| nfa_snep_cb.conn[dlink].p_ndef_buff = 0; |
| |
| LLCP_DisconnectReq (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, TRUE); |
| } |
| else if (status == LLCP_STATUS_CONGESTED) |
| { |
| nfa_snep_cb.conn[dlink].congest = TRUE; |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_send_remaining |
| ** |
| ** Description Send remaining fragments of SNEP message |
| ** |
| ** |
| ** Returns void |
| ** |
| *******************************************************************************/ |
| void nfa_snep_send_remaining (UINT8 dlink) |
| { |
| BT_HDR *p_msg; |
| UINT8 *p_src, *p_dst; |
| UINT32 length; |
| tLLCP_STATUS status; |
| |
| SNEP_TRACE_DEBUG1 ("nfa_snep_send_remaining (): dlink:0x%02X", dlink); |
| |
| /* while data link connection is not congested */ |
| while ( (nfa_snep_cb.conn[dlink].congest == FALSE) |
| &&(nfa_snep_cb.conn[dlink].cur_length > 0) /* if any fragment was sent */ |
| &&(nfa_snep_cb.conn[dlink].cur_length < nfa_snep_cb.conn[dlink].ndef_length) ) |
| { |
| /* start of remaining fragments */ |
| p_src = nfa_snep_cb.conn[dlink].p_ndef_buff + nfa_snep_cb.conn[dlink].cur_length; |
| |
| length = nfa_snep_cb.conn[dlink].ndef_length - nfa_snep_cb.conn[dlink].cur_length; |
| |
| /* sending up to peer's MIU */ |
| if (length > nfa_snep_cb.conn[dlink].tx_miu) |
| { |
| length = nfa_snep_cb.conn[dlink].tx_miu; |
| } |
| |
| status = LLCP_STATUS_FAIL; |
| |
| if ((p_msg = (BT_HDR *) GKI_getpoolbuf (LLCP_POOL_ID)) != NULL) |
| { |
| p_msg->len = (UINT16) length; |
| p_msg->offset = LLCP_MIN_OFFSET; |
| |
| p_dst = (UINT8*) (p_msg + 1) + p_msg->offset; |
| |
| memcpy (p_dst, p_src, length); |
| |
| status = LLCP_SendData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, p_msg); |
| |
| if (status != LLCP_STATUS_FAIL) |
| { |
| /* update sent length */ |
| nfa_snep_cb.conn[dlink].cur_length += length; |
| |
| SNEP_TRACE_DEBUG2 ("nfa_snep_send_remaining (): sending %d out of %d", |
| nfa_snep_cb.conn[dlink].cur_length, |
| nfa_snep_cb.conn[dlink].ndef_length); |
| |
| /* if sent the last fragment */ |
| if (nfa_snep_cb.conn[dlink].cur_length == nfa_snep_cb.conn[dlink].ndef_length) |
| { |
| nfa_snep_cb.conn[dlink].cur_length = 0; |
| |
| if ( (nfa_snep_cb.conn[dlink].tx_code == NFA_SNEP_RESP_CODE_SUCCESS) |
| &&(nfa_snep_cb.conn[dlink].rx_code == NFA_SNEP_REQ_CODE_CONTINUE) ) |
| { |
| /* Set LLCP to send LLCP_SAP_EVT_TX_COMPLETE */ |
| LLCP_SetTxCompleteNtf (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap); |
| } |
| } |
| } |
| } |
| |
| if (status == LLCP_STATUS_CONGESTED) |
| { |
| nfa_snep_cb.conn[dlink].congest = TRUE; |
| |
| /* wait for uncongested event from LLCP */ |
| break; |
| } |
| else if (status == LLCP_STATUS_FAIL) |
| { |
| SNEP_TRACE_ERROR0 ("Cannot allocate buffer or failed to send data"); |
| |
| /* upper layer will free buffer when NFA_SNEP_DISC_EVT is received */ |
| nfa_snep_cb.conn[dlink].p_ndef_buff = 0; |
| |
| LLCP_DisconnectReq (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, TRUE); |
| return; |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_llcp_cback |
| ** |
| ** Description Processing event from LLCP |
| ** |
| ** |
| ** Returns None |
| ** |
| *******************************************************************************/ |
| void nfa_snep_llcp_cback (tLLCP_SAP_CBACK_DATA *p_data) |
| { |
| SNEP_TRACE_DEBUG2 ("nfa_snep_llcp_cback (): event:0x%02X, local_sap:0x%02X", p_data->hdr.event, p_data->hdr.local_sap); |
| |
| switch (p_data->hdr.event) |
| { |
| case LLCP_SAP_EVT_DATA_IND: |
| nfa_snep_proc_llcp_data_ind (p_data); |
| break; |
| |
| case LLCP_SAP_EVT_CONNECT_IND: |
| nfa_snep_proc_llcp_connect_ind (p_data); |
| break; |
| |
| case LLCP_SAP_EVT_CONNECT_RESP: |
| nfa_snep_proc_llcp_connect_resp (p_data); |
| break; |
| |
| case LLCP_SAP_EVT_DISCONNECT_IND: |
| nfa_snep_proc_llcp_disconnect_ind (p_data); |
| break; |
| |
| case LLCP_SAP_EVT_DISCONNECT_RESP: |
| nfa_snep_proc_llcp_disconnect_resp (p_data); |
| break; |
| |
| case LLCP_SAP_EVT_CONGEST: |
| /* congestion start/end */ |
| nfa_snep_proc_llcp_congest (p_data); |
| break; |
| |
| case LLCP_SAP_EVT_LINK_STATUS: |
| nfa_snep_proc_llcp_link_status (p_data); |
| break; |
| |
| case LLCP_SAP_EVT_TX_COMPLETE: |
| nfa_snep_proc_llcp_tx_complete (p_data); |
| break; |
| |
| default: |
| SNEP_TRACE_ERROR1 ("Unknown event:0x%02X", p_data->hdr.event); |
| return; |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_validate_rx_msg |
| ** |
| ** Description Validate version, opcode, length in received message |
| ** |
| ** |
| ** Returns TRUE if message is valid |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_validate_rx_msg (UINT8 dlink) |
| { |
| UINT32 length; |
| UINT8 buffer[NFA_SNEP_HEADER_SIZE], *p; |
| BOOLEAN more; |
| UINT8 version, opcode; |
| UINT32 info_len; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_validate_rx_msg ()"); |
| |
| more = LLCP_ReadDataLinkData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, |
| NFA_SNEP_HEADER_SIZE, |
| &length, buffer); |
| |
| #if (BT_TRACE_PROTOCOL == TRUE) |
| DispSNEP(nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, |
| buffer, |
| (UINT16)length, |
| TRUE); |
| #endif |
| |
| /* check if it has minimum header, |
| ** the first fragment shall include at least the entier SNEP header |
| */ |
| if (length < NFA_SNEP_HEADER_SIZE) |
| { |
| SNEP_TRACE_ERROR0 ("The first fragment shall include at least the entire SNEP header"); |
| |
| /* application will free buffer when receiving NFA_SNEP_DISC_EVT */ |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| LLCP_DisconnectReq (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, TRUE); |
| return FALSE; |
| } |
| |
| p = buffer; |
| |
| /* parse SNEP header */ |
| BE_STREAM_TO_UINT8 (version, p); |
| BE_STREAM_TO_UINT8 (opcode, p); |
| BE_STREAM_TO_UINT32 (info_len, p); |
| |
| /* check version of SNEP */ |
| if (!nfa_snep_check_version (version)) |
| { |
| nfa_snep_send_msg (NFA_SNEP_RESP_CODE_UNSUPP_VER, dlink); |
| return FALSE; |
| } |
| |
| /* check valid opcode for server */ |
| if (nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_SERVER) |
| { |
| /* if this is response message */ |
| if (opcode & NFA_SNEP_RESP_CODE_CONTINUE) |
| { |
| SNEP_TRACE_ERROR0 ("Invalid opcode for server"); |
| |
| /* application will free buffer when receiving NFA_SNEP_DISC_EVT */ |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| LLCP_DisconnectReq (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, TRUE); |
| return FALSE; |
| } |
| else if ( (opcode != NFA_SNEP_REQ_CODE_CONTINUE) |
| &&(opcode != NFA_SNEP_REQ_CODE_GET) |
| &&(opcode != NFA_SNEP_REQ_CODE_PUT) |
| &&(opcode != NFA_SNEP_REQ_CODE_REJECT) ) |
| { |
| SNEP_TRACE_ERROR0 ("Not supported opcode for server"); |
| nfa_snep_send_msg (NFA_SNEP_RESP_CODE_NOT_IMPLM, dlink); |
| return FALSE; |
| } |
| } |
| /* check valid opcode for client */ |
| else |
| { |
| if ( (opcode != NFA_SNEP_RESP_CODE_CONTINUE) |
| &&(opcode != NFA_SNEP_RESP_CODE_SUCCESS) |
| &&(opcode != NFA_SNEP_RESP_CODE_NOT_FOUND) |
| &&(opcode != NFA_SNEP_RESP_CODE_EXCESS_DATA) |
| &&(opcode != NFA_SNEP_RESP_CODE_BAD_REQ) |
| &&(opcode != NFA_SNEP_RESP_CODE_NOT_IMPLM) |
| &&(opcode != NFA_SNEP_RESP_CODE_UNSUPP_VER) |
| &&(opcode != NFA_SNEP_RESP_CODE_REJECT) ) |
| { |
| SNEP_TRACE_ERROR0 ("Invalid opcode for client"); |
| /* client cannot send error code so disconnect */ |
| /* application will free buffer when receiving NFA_SNEP_DISC_EVT */ |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| LLCP_DisconnectReq (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, TRUE); |
| return FALSE; |
| } |
| } |
| |
| if (opcode == NFA_SNEP_REQ_CODE_GET) |
| { |
| more = LLCP_ReadDataLinkData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, |
| NFA_SNEP_ACCEPT_LEN_SIZE, |
| &length, buffer); |
| |
| if (length < NFA_SNEP_ACCEPT_LEN_SIZE) |
| { |
| /* |
| ** Including acceptable length in the first segment is not mandated in spec |
| ** but MIU is always big enough to include acceptable length field. |
| */ |
| nfa_snep_send_msg (NFA_SNEP_RESP_CODE_BAD_REQ, dlink); |
| return FALSE; |
| } |
| |
| p = buffer; |
| BE_STREAM_TO_UINT32 (nfa_snep_cb.conn[dlink].acceptable_length, p); |
| |
| /* store expected NDEF message length */ |
| nfa_snep_cb.conn[dlink].ndef_length = info_len - NFA_SNEP_ACCEPT_LEN_SIZE; |
| } |
| else if ( (opcode == NFA_SNEP_REQ_CODE_PUT) |
| ||((opcode == NFA_SNEP_RESP_CODE_SUCCESS) && (nfa_snep_cb.conn[dlink].tx_code == NFA_SNEP_REQ_CODE_GET))) |
| { |
| /* store expected NDEF message length */ |
| nfa_snep_cb.conn[dlink].ndef_length = info_len; |
| } |
| else |
| { |
| if (more) |
| { |
| SNEP_TRACE_ERROR0 ("The information field shall not be transmitted with this request or response"); |
| |
| if (nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_SERVER) |
| { |
| nfa_snep_send_msg (NFA_SNEP_RESP_CODE_BAD_REQ, dlink); |
| } |
| /* client cannot send error code so disconnect */ |
| /* application will free buffer when receiving NFA_SNEP_DISC_EVT */ |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| LLCP_DisconnectReq (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, TRUE); |
| return FALSE; |
| } |
| } |
| |
| /* store received opcode */ |
| nfa_snep_cb.conn[dlink].rx_code = opcode; |
| |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_store_first_rx_msg |
| ** |
| ** Description Allocate buffer and store the first fragment |
| ** |
| ** |
| ** Returns TRUE if the received fragment is successfully stored |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_store_first_rx_msg (UINT8 dlink) |
| { |
| tNFA_SNEP_EVT_DATA evt_data; |
| BOOLEAN more; |
| UINT32 length; |
| |
| /* send event to upper layer of this data link connection to allocate buffer */ |
| evt_data.alloc.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| evt_data.alloc.req_code = nfa_snep_cb.conn[dlink].rx_code; |
| evt_data.alloc.ndef_length = nfa_snep_cb.conn[dlink].ndef_length; |
| evt_data.alloc.p_buff = NULL; |
| |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_ALLOC_BUFF_EVT, &evt_data); |
| nfa_snep_cb.conn[dlink].p_ndef_buff = evt_data.alloc.p_buff; |
| |
| /* store information into application buffer */ |
| if (nfa_snep_cb.conn[dlink].p_ndef_buff) |
| { |
| /* store buffer size */ |
| nfa_snep_cb.conn[dlink].buff_length = evt_data.alloc.ndef_length; |
| |
| more = LLCP_ReadDataLinkData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, |
| nfa_snep_cb.conn[dlink].buff_length, |
| &length, |
| nfa_snep_cb.conn[dlink].p_ndef_buff); |
| |
| /* store received message length */ |
| nfa_snep_cb.conn[dlink].cur_length = (UINT32) length; |
| |
| SNEP_TRACE_DEBUG2 ("Received NDEF on SNEP, %d ouf of %d", |
| nfa_snep_cb.conn[dlink].cur_length, |
| nfa_snep_cb.conn[dlink].ndef_length); |
| |
| /* if fragmented */ |
| if (nfa_snep_cb.conn[dlink].ndef_length > nfa_snep_cb.conn[dlink].cur_length) |
| { |
| nfa_snep_cb.conn[dlink].rx_fragments = TRUE; |
| } |
| else if (more) |
| { |
| /* ignore extra bytes in the message */ |
| length = LLCP_FlushDataLinkRxData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap); |
| |
| SNEP_TRACE_WARNING1 ("Received extra %d bytes on SNEP", length); |
| } |
| |
| return TRUE; |
| } |
| else |
| { |
| SNEP_TRACE_ERROR1 ("Upper layer cannot allocate buffer for %d bytes", |
| nfa_snep_cb.conn[dlink].ndef_length); |
| |
| /* clear data in data link connection */ |
| length = LLCP_FlushDataLinkRxData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap); |
| |
| /* if fragmented */ |
| if (nfa_snep_cb.conn[dlink].ndef_length > nfa_snep_cb.conn[dlink].cur_length) |
| { |
| /* notify peer not to send any more fragment */ |
| if (evt_data.alloc.resp_code != NFA_SNEP_RESP_CODE_NOT_IMPLM) |
| { |
| /* Set proper code */ |
| evt_data.alloc.resp_code = NFA_SNEP_REQ_CODE_REJECT; |
| } |
| } |
| else |
| { |
| if (evt_data.alloc.resp_code != NFA_SNEP_RESP_CODE_NOT_IMPLM) |
| { |
| /* Set proper code */ |
| evt_data.alloc.resp_code = NFA_SNEP_RESP_CODE_NOT_FOUND; |
| } |
| } |
| |
| nfa_snep_send_msg (evt_data.alloc.resp_code, dlink); |
| |
| return FALSE; |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_proc_first_rx_msg |
| ** |
| ** Description Process the first part of received message |
| ** |
| ** |
| ** Returns TRUE if it is not fragmented message |
| ** FALSE if it is fragmented or found error |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_proc_first_rx_msg (UINT8 dlink) |
| { |
| UINT32 length; |
| tNFA_SNEP_EVT_DATA evt_data; |
| BOOLEAN more; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_proc_first_rx_msg ()"); |
| |
| /* if version, opcode or length is not valid in received message */ |
| if (!nfa_snep_validate_rx_msg (dlink)) |
| { |
| /* clear data in data link connection */ |
| LLCP_FlushDataLinkRxData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap); |
| return FALSE; |
| } |
| |
| if (nfa_snep_cb.conn[dlink].rx_code == NFA_SNEP_REQ_CODE_GET) |
| { |
| /* if failed to allocate buffer */ |
| if (!nfa_snep_store_first_rx_msg (dlink)) |
| { |
| return FALSE; |
| } |
| else |
| { |
| if (nfa_snep_cb.conn[dlink].rx_fragments == TRUE) |
| { |
| /* let peer send remaining fragments */ |
| nfa_snep_send_msg (NFA_SNEP_RESP_CODE_CONTINUE, dlink); |
| |
| return FALSE; |
| } |
| } |
| } |
| else if (nfa_snep_cb.conn[dlink].rx_code == NFA_SNEP_REQ_CODE_PUT) |
| { |
| /* if failed to allocate buffer */ |
| if (!nfa_snep_store_first_rx_msg (dlink)) |
| { |
| return FALSE; |
| } |
| else |
| { |
| if (nfa_snep_cb.conn[dlink].rx_fragments == TRUE) |
| { |
| /* let peer send remaining fragments */ |
| nfa_snep_send_msg (NFA_SNEP_RESP_CODE_CONTINUE, dlink); |
| return FALSE; |
| } |
| } |
| } |
| /* if we got response of GET request from server */ |
| else if ( (nfa_snep_cb.conn[dlink].rx_code == NFA_SNEP_RESP_CODE_SUCCESS) |
| &&(nfa_snep_cb.conn[dlink].tx_code == NFA_SNEP_REQ_CODE_GET) ) |
| { |
| /* if server is sending more than acceptable length */ |
| if (nfa_snep_cb.conn[dlink].ndef_length > nfa_snep_cb.conn[dlink].acceptable_length) |
| { |
| SNEP_TRACE_ERROR0 ("Server is sending more than acceptable length"); |
| |
| length = LLCP_FlushDataLinkRxData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap); |
| |
| /* if fragmented */ |
| if (nfa_snep_cb.conn[dlink].ndef_length > length) |
| { |
| nfa_snep_send_msg (NFA_SNEP_REQ_CODE_REJECT, dlink); |
| nfa_snep_cb.conn[dlink].rx_fragments = FALSE; |
| } |
| |
| /* return error to client so buffer can be freed */ |
| evt_data.get_resp.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| evt_data.get_resp.resp_code = NFA_SNEP_RESP_CODE_EXCESS_DATA; |
| evt_data.get_resp.ndef_length = 0; |
| evt_data.get_resp.p_ndef = nfa_snep_cb.conn[dlink].p_ndef_buff; |
| |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_GET_RESP_EVT, &evt_data); |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| return FALSE; |
| } |
| |
| more = LLCP_ReadDataLinkData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, |
| nfa_snep_cb.conn[dlink].buff_length, |
| &length, |
| nfa_snep_cb.conn[dlink].p_ndef_buff); |
| |
| /* store received message length */ |
| nfa_snep_cb.conn[dlink].cur_length = length; |
| |
| SNEP_TRACE_DEBUG2 ("Received NDEF on SNEP, %d ouf of %d", |
| nfa_snep_cb.conn[dlink].cur_length, |
| nfa_snep_cb.conn[dlink].ndef_length); |
| |
| if (nfa_snep_cb.conn[dlink].ndef_length > nfa_snep_cb.conn[dlink].cur_length) |
| { |
| nfa_snep_cb.conn[dlink].rx_fragments = TRUE; |
| } |
| else if (more) |
| { |
| /* ignore extra bytes in the message */ |
| length = LLCP_FlushDataLinkRxData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap); |
| |
| SNEP_TRACE_WARNING1 ("Received extra %d bytes on SNEP", length); |
| } |
| |
| if (nfa_snep_cb.conn[dlink].rx_fragments == TRUE) |
| { |
| /* let peer send remaining fragments */ |
| nfa_snep_send_msg (NFA_SNEP_REQ_CODE_CONTINUE, dlink); |
| |
| /* start timer for next fragment */ |
| nfa_sys_start_timer (&nfa_snep_cb.conn[dlink].timer, dlink, NFA_SNEP_CLIENT_TIMEOUT); |
| |
| return FALSE; |
| } |
| } |
| |
| /* other than above cases, there is no inforamtion field */ |
| |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_assemble_fragments |
| ** |
| ** Description Assemble fragments of SNEP message |
| ** |
| ** |
| ** Returns TRUE if it is not fragmented message |
| ** FALSE if it is fragmented or found error |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_assemble_fragments (UINT8 dlink) |
| { |
| BOOLEAN more; |
| UINT32 length; |
| |
| more = LLCP_ReadDataLinkData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, |
| nfa_snep_cb.conn[dlink].buff_length - nfa_snep_cb.conn[dlink].cur_length, |
| &length, |
| nfa_snep_cb.conn[dlink].p_ndef_buff + nfa_snep_cb.conn[dlink].cur_length); |
| |
| nfa_snep_cb.conn[dlink].cur_length += length; |
| |
| SNEP_TRACE_DEBUG2 ("Received NDEF on SNEP, %d ouf of %d", |
| nfa_snep_cb.conn[dlink].cur_length, |
| nfa_snep_cb.conn[dlink].ndef_length); |
| |
| /* if received the last fragment */ |
| if (nfa_snep_cb.conn[dlink].ndef_length == nfa_snep_cb.conn[dlink].cur_length) |
| { |
| nfa_snep_cb.conn[dlink].rx_fragments = FALSE; |
| |
| if (more) |
| { |
| length = LLCP_FlushDataLinkRxData (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap); |
| |
| SNEP_TRACE_ERROR2 ("Received extra %d bytes more than NDEF length (%d)", |
| length, |
| nfa_snep_cb.conn[dlink].ndef_length); |
| |
| /* application will free buffer when receiving NFA_SNEP_DISC_EVT */ |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| LLCP_DisconnectReq (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, TRUE); |
| |
| return FALSE; |
| } |
| } |
| else |
| { |
| if (nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_CLIENT) |
| { |
| /* wait for more fragments */ |
| nfa_sys_start_timer (&nfa_snep_cb.conn[dlink].timer, dlink, NFA_SNEP_CLIENT_TIMEOUT); |
| } |
| |
| return FALSE; |
| } |
| |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_proc_llcp_data_ind |
| ** |
| ** Description Processing incoming data from LLCP |
| ** |
| ** |
| ** Returns None |
| ** |
| *******************************************************************************/ |
| void nfa_snep_proc_llcp_data_ind (tLLCP_SAP_CBACK_DATA *p_data) |
| { |
| UINT8 dlink; |
| tNFA_SNEP_EVT_DATA evt_data; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_proc_llcp_data_ind ()"); |
| |
| /* find connection control block with SAP */ |
| dlink = nfa_snep_sap_to_index (p_data->data_ind.local_sap, |
| p_data->data_ind.remote_sap, |
| NFA_SNEP_FLAG_ANY); |
| |
| /* if found */ |
| if ( (dlink < NFA_SNEP_MAX_CONN) |
| &&(nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_CONNECTED) ) |
| { |
| if (nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_CLIENT) |
| { |
| /* stop timer for response from server */ |
| nfa_sys_stop_timer (&nfa_snep_cb.conn[dlink].timer); |
| } |
| |
| /* if received the first fragment or complete SNEP message */ |
| if (nfa_snep_cb.conn[dlink].rx_fragments == FALSE) |
| { |
| if (!nfa_snep_proc_first_rx_msg (dlink)) |
| { |
| /* need more data or found error */ |
| return; |
| } |
| } |
| /* if received other than the first fragment */ |
| else |
| { |
| if (!nfa_snep_assemble_fragments (dlink)) |
| { |
| /* need more data or found error */ |
| return; |
| } |
| } |
| |
| /* processing complete SNEP message */ |
| switch (nfa_snep_cb.conn[dlink].rx_code) |
| { |
| case NFA_SNEP_REQ_CODE_CONTINUE: |
| if (nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_W4_REQ_CONTINUE) |
| { |
| nfa_snep_cb.conn[dlink].flags &= ~NFA_SNEP_FLAG_W4_REQ_CONTINUE; |
| |
| /* send remaining fragments of GET response */ |
| nfa_snep_send_remaining (dlink); |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Received invalid NFA_SNEP_REQ_CODE_CONTINUE"); |
| |
| /* application will free buffer when receiving NFA_SNEP_DISC_EVT */ |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| LLCP_DisconnectReq (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, TRUE); |
| } |
| break; |
| |
| case NFA_SNEP_REQ_CODE_GET: |
| evt_data.get_req.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| evt_data.get_req.acceptable_length = nfa_snep_cb.conn[dlink].acceptable_length; |
| |
| /* NDEF message */ |
| evt_data.get_req.ndef_length = nfa_snep_cb.conn[dlink].ndef_length; |
| evt_data.get_req.p_ndef = nfa_snep_cb.conn[dlink].p_ndef_buff; |
| |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| /* send event to server of this data link connection */ |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_GET_REQ_EVT, &evt_data); |
| break; |
| |
| case NFA_SNEP_REQ_CODE_PUT: |
| evt_data.put_req.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| |
| /* NDEF message */ |
| evt_data.put_req.ndef_length = nfa_snep_cb.conn[dlink].ndef_length; |
| evt_data.put_req.p_ndef = nfa_snep_cb.conn[dlink].p_ndef_buff; |
| |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| /* send event to server of this data link connection */ |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_PUT_REQ_EVT, &evt_data); |
| break; |
| |
| case NFA_SNEP_RESP_CODE_CONTINUE: |
| if (nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_W4_RESP_CONTINUE) |
| { |
| nfa_snep_cb.conn[dlink].flags &= ~NFA_SNEP_FLAG_W4_RESP_CONTINUE; |
| /* send remaining fragments GET/PUT request */ |
| nfa_snep_send_remaining (dlink); |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Received invalid NFA_SNEP_RESP_CODE_CONTINUE"); |
| |
| /* application will free buffer when receiving NFA_SNEP_DISC_EVT */ |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| LLCP_DisconnectReq (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, TRUE); |
| } |
| break; |
| |
| case NFA_SNEP_RESP_CODE_SUCCESS: |
| if (nfa_snep_cb.conn[dlink].tx_code == NFA_SNEP_REQ_CODE_GET) |
| { |
| evt_data.get_resp.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| evt_data.get_resp.resp_code = NFA_SNEP_RESP_CODE_SUCCESS; |
| evt_data.get_resp.ndef_length = nfa_snep_cb.conn[dlink].ndef_length; |
| evt_data.get_resp.p_ndef = nfa_snep_cb.conn[dlink].p_ndef_buff; |
| |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| |
| /* send event to client of this data link connection */ |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_GET_RESP_EVT, &evt_data); |
| } |
| else |
| { |
| evt_data.put_resp.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| evt_data.put_resp.resp_code = NFA_SNEP_RESP_CODE_SUCCESS; |
| |
| /* send event to client of this data link connection */ |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_PUT_RESP_EVT, &evt_data); |
| } |
| break; |
| |
| case NFA_SNEP_RESP_CODE_NOT_FOUND: |
| case NFA_SNEP_RESP_CODE_EXCESS_DATA: |
| case NFA_SNEP_RESP_CODE_BAD_REQ: |
| case NFA_SNEP_RESP_CODE_NOT_IMPLM: |
| case NFA_SNEP_RESP_CODE_UNSUPP_VER: |
| case NFA_SNEP_RESP_CODE_REJECT: |
| /* if client sent GET request */ |
| if (nfa_snep_cb.conn[dlink].tx_code == NFA_SNEP_REQ_CODE_GET) |
| { |
| evt_data.get_resp.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| evt_data.get_resp.resp_code = nfa_snep_cb.conn[dlink].rx_code; |
| evt_data.get_resp.ndef_length = 0; |
| evt_data.get_resp.p_ndef = nfa_snep_cb.conn[dlink].p_ndef_buff; |
| |
| /* send event to client of this data link connection */ |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_GET_RESP_EVT, &evt_data); |
| } |
| /* if client sent PUT request */ |
| else if (nfa_snep_cb.conn[dlink].tx_code == NFA_SNEP_REQ_CODE_PUT) |
| { |
| evt_data.put_resp.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| evt_data.put_resp.resp_code = nfa_snep_cb.conn[dlink].rx_code; |
| |
| /* send event to client of this data link connection */ |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_PUT_RESP_EVT, &evt_data); |
| } |
| |
| /* if there is remaining SNEP message */ |
| if (nfa_snep_cb.conn[dlink].p_ndef_buff) |
| { |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| } |
| break; |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_proc_llcp_connect_ind |
| ** |
| ** Description Processing connection request from peer |
| ** |
| ** |
| ** Returns None |
| ** |
| *******************************************************************************/ |
| void nfa_snep_proc_llcp_connect_ind (tLLCP_SAP_CBACK_DATA *p_data) |
| { |
| UINT8 server, dlink; |
| tLLCP_CONNECTION_PARAMS params; |
| tNFA_SNEP_EVT_DATA evt_data; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_proc_llcp_connect_ind ()"); |
| |
| server = nfa_snep_sap_to_index (p_data->connect_ind.server_sap, |
| NFA_SNEP_ANY_SAP, |
| NFA_SNEP_FLAG_SERVER); |
| |
| /* if found valid server */ |
| if (server < NFA_SNEP_MAX_CONN) |
| { |
| /* allocate connection control block for data link connection */ |
| dlink = nfa_snep_allocate_cb (); |
| |
| if (dlink < NFA_SNEP_MAX_CONN) |
| { |
| /* set data link connection's callback to server's callback */ |
| /* request will be sent to this server */ |
| nfa_snep_cb.conn[dlink].local_sap = p_data->connect_ind.local_sap; |
| nfa_snep_cb.conn[dlink].remote_sap = p_data->connect_ind.remote_sap; |
| nfa_snep_cb.conn[dlink].p_cback = nfa_snep_cb.conn[server].p_cback; |
| nfa_snep_cb.conn[dlink].flags = NFA_SNEP_FLAG_SERVER|NFA_SNEP_FLAG_CONNECTED; |
| |
| nfa_snep_cb.conn[dlink].tx_miu = nfa_snep_get_efficent_miu (p_data->connect_ind.miu, |
| p_data->connect_ind.rw); |
| |
| /* accept connection request */ |
| params.miu = NFA_SNEP_MIU; |
| params.rw = NFA_SNEP_RW; |
| params.sn[0] = 0; |
| |
| LLCP_ConnectCfm (p_data->connect_ind.local_sap, |
| p_data->connect_ind.remote_sap, ¶ms); |
| |
| evt_data.connect.reg_handle = (NFA_HANDLE_GROUP_SNEP | server); |
| evt_data.connect.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_CONNECTED_EVT, &evt_data); |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Cannot allocate connection control block"); |
| LLCP_ConnectReject (p_data->connect_ind.local_sap, |
| p_data->connect_ind.remote_sap, |
| LLCP_SAP_DM_REASON_TEMP_REJECT_THIS); |
| } |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Cannot find SNEP server"); |
| LLCP_ConnectReject (p_data->connect_ind.local_sap, |
| p_data->connect_ind.remote_sap, |
| LLCP_SAP_DM_REASON_NO_SERVICE); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_proc_llcp_connect_resp |
| ** |
| ** Description Processing connection response from peer |
| ** |
| ** |
| ** Returns None |
| ** |
| *******************************************************************************/ |
| void nfa_snep_proc_llcp_connect_resp (tLLCP_SAP_CBACK_DATA *p_data) |
| { |
| UINT8 dlink; |
| tNFA_SNEP_EVT_DATA evt_data; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_proc_llcp_connect_resp ()"); |
| |
| /* find client by SAP */ |
| dlink = nfa_snep_sap_to_index (p_data->connect_resp.local_sap, |
| NFA_SNEP_ANY_SAP, |
| NFA_SNEP_FLAG_CLIENT|NFA_SNEP_FLAG_CONNECTING); |
| |
| /* if found client */ |
| if (dlink < NFA_SNEP_MAX_CONN) |
| { |
| nfa_snep_cb.conn[dlink].remote_sap = p_data->connect_resp.remote_sap; |
| nfa_snep_cb.conn[dlink].flags = NFA_SNEP_FLAG_CLIENT|NFA_SNEP_FLAG_CONNECTED; |
| |
| nfa_snep_cb.conn[dlink].tx_miu = nfa_snep_get_efficent_miu (p_data->connect_resp.miu, |
| p_data->connect_resp.rw); |
| |
| evt_data.connect.reg_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| evt_data.connect.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_CONNECTED_EVT, &evt_data); |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Cannot find SNEP client"); |
| LLCP_DisconnectReq (p_data->connect_resp.local_sap, |
| p_data->connect_resp.remote_sap, TRUE); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_proc_llcp_disconnect_ind |
| ** |
| ** Description Processing disconnection request from peer |
| ** |
| ** |
| ** Returns None |
| ** |
| *******************************************************************************/ |
| void nfa_snep_proc_llcp_disconnect_ind (tLLCP_SAP_CBACK_DATA *p_data) |
| { |
| UINT8 dlink; |
| tNFA_SNEP_EVT_DATA evt_data; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_proc_llcp_disconnect_ind ()"); |
| |
| /* find connection control block by SAP */ |
| dlink = nfa_snep_sap_to_index (p_data->disconnect_ind.local_sap, |
| p_data->disconnect_ind.remote_sap, |
| NFA_SNEP_FLAG_ANY); |
| |
| /* if found */ |
| if (dlink < NFA_SNEP_MAX_CONN) |
| { |
| evt_data.disc.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_DISC_EVT, &evt_data); |
| |
| if (nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_CLIENT) |
| { |
| /* clear other flags */ |
| nfa_snep_cb.conn[dlink].flags = NFA_SNEP_FLAG_CLIENT; |
| nfa_snep_cb.conn[dlink].remote_sap = LLCP_INVALID_SAP; |
| } |
| else |
| { |
| nfa_snep_deallocate_cb (dlink); |
| } |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Cannot find SNEP connection"); |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_proc_llcp_disconnect_resp |
| ** |
| ** Description Processing rejected connection from peer |
| ** |
| ** |
| ** Returns None |
| ** |
| *******************************************************************************/ |
| void nfa_snep_proc_llcp_disconnect_resp (tLLCP_SAP_CBACK_DATA *p_data) |
| { |
| UINT8 dlink, flags; |
| UINT8 remote_sap; |
| tNFA_SNEP_EVT_DATA evt_data; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_proc_llcp_disconnect_resp ()"); |
| |
| /* if remote sent response to disconnection requested by local */ |
| if (p_data->disconnect_resp.reason == LLCP_SAP_DM_REASON_RESP_DISC) |
| { |
| remote_sap = p_data->disconnect_resp.remote_sap; |
| flags = NFA_SNEP_FLAG_CLIENT|NFA_SNEP_FLAG_CONNECTED; |
| } |
| else /* connection failed so we don't have remote SAP */ |
| { |
| remote_sap = NFA_SNEP_ANY_SAP; |
| flags = NFA_SNEP_FLAG_CLIENT|NFA_SNEP_FLAG_CONNECTING; |
| } |
| |
| /* find connection control block by SAP */ |
| dlink = nfa_snep_sap_to_index (p_data->disconnect_resp.local_sap, |
| remote_sap, |
| flags); |
| |
| /* if found client */ |
| if (dlink < NFA_SNEP_MAX_CONN) |
| { |
| evt_data.disc.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_DISC_EVT, &evt_data); |
| |
| /* clear other flags */ |
| nfa_snep_cb.conn[dlink].flags = NFA_SNEP_FLAG_CLIENT; |
| nfa_snep_cb.conn[dlink].remote_sap = LLCP_INVALID_SAP; |
| } |
| else |
| { |
| /* find server connection control block by SAP */ |
| dlink = nfa_snep_sap_to_index (p_data->disconnect_resp.local_sap, |
| remote_sap, |
| NFA_SNEP_FLAG_SERVER|NFA_SNEP_FLAG_CONNECTED); |
| |
| /* if found server connection */ |
| if (dlink < NFA_SNEP_MAX_CONN) |
| { |
| evt_data.disc.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_DISC_EVT, &evt_data); |
| |
| nfa_snep_deallocate_cb (dlink); |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Cannot find SNEP connection"); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_proc_llcp_congest |
| ** |
| ** Description Processing LLCP congestion event |
| ** |
| ** |
| ** Returns None |
| ** |
| *******************************************************************************/ |
| void nfa_snep_proc_llcp_congest (tLLCP_SAP_CBACK_DATA *p_data) |
| { |
| UINT8 dlink; |
| |
| SNEP_TRACE_DEBUG3 ("nfa_snep_proc_llcp_congest () local_sap=0x%x, remote_sap=0x%x, is_congested=%d", |
| p_data->congest.local_sap, |
| p_data->congest.remote_sap, |
| p_data->congest.is_congested); |
| |
| /* if data link connection is congested */ |
| if (p_data->congest.link_type == LLCP_LINK_TYPE_DATA_LINK_CONNECTION) |
| { |
| dlink = nfa_snep_sap_to_index (p_data->congest.local_sap, |
| p_data->congest.remote_sap, |
| NFA_SNEP_FLAG_ANY); |
| |
| if ( (dlink < NFA_SNEP_MAX_CONN) |
| &&(nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_CONNECTED) ) |
| { |
| nfa_snep_cb.conn[dlink].congest = p_data->congest.is_congested; |
| |
| if (!nfa_snep_cb.conn[dlink].congest) |
| { |
| /* if received CONTINUE then continue to send remaining fragments */ |
| if ( (nfa_snep_cb.conn[dlink].rx_code == NFA_SNEP_REQ_CODE_CONTINUE) |
| ||(nfa_snep_cb.conn[dlink].rx_code == NFA_SNEP_RESP_CODE_CONTINUE) ) |
| { |
| nfa_snep_send_remaining (dlink); |
| } |
| } |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_proc_llcp_link_status |
| ** |
| ** Description Processing LLCP link status |
| ** |
| ** |
| ** Returns none |
| ** |
| *******************************************************************************/ |
| void nfa_snep_proc_llcp_link_status (tLLCP_SAP_CBACK_DATA *p_data) |
| { |
| UINT8 xx; |
| tNFA_SNEP_EVT_DATA evt_data; |
| |
| SNEP_TRACE_DEBUG1 ("nfa_snep_proc_llcp_link_status () is_activated:%d", |
| p_data->link_status.is_activated); |
| |
| xx = nfa_snep_sap_to_index (p_data->link_status.local_sap, |
| NFA_SNEP_ANY_SAP, |
| NFA_SNEP_FLAG_CLIENT); |
| |
| if (xx < NFA_SNEP_MAX_CONN) |
| { |
| evt_data.activated.client_handle = (NFA_HANDLE_GROUP_SNEP | xx); |
| |
| /* if LLCP link is activated */ |
| if (p_data->link_status.is_activated == TRUE) |
| { |
| /* notify only client which may want to connect */ |
| nfa_snep_cb.conn[xx].p_cback (NFA_SNEP_ACTIVATED_EVT, &evt_data); |
| } |
| else |
| { |
| /* LLCP link is deactivated */ |
| nfa_snep_cb.conn[xx].p_cback (NFA_SNEP_DEACTIVATED_EVT, &evt_data); |
| } |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_proc_llcp_tx_complete |
| ** |
| ** Description Processing LLCP tx complete event |
| ** |
| ** |
| ** Returns none |
| ** |
| *******************************************************************************/ |
| void nfa_snep_proc_llcp_tx_complete (tLLCP_SAP_CBACK_DATA *p_data) |
| { |
| UINT8 dlink; |
| tNFA_SNEP_EVT_DATA evt_data; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_proc_llcp_tx_complete ()"); |
| |
| dlink = nfa_snep_sap_to_index (p_data->tx_complete.local_sap, |
| p_data->tx_complete.remote_sap, |
| NFA_SNEP_FLAG_SERVER|NFA_SNEP_FLAG_CONNECTED); |
| |
| if (dlink < NFA_SNEP_MAX_CONN) |
| { |
| /* notify upper layer that transmission is complete */ |
| evt_data.get_resp_cmpl.conn_handle = (NFA_HANDLE_GROUP_SNEP | dlink); |
| evt_data.get_resp_cmpl.p_buff = nfa_snep_cb.conn[dlink].p_ndef_buff; |
| |
| nfa_snep_cb.conn[dlink].p_cback (NFA_SNEP_GET_RESP_CMPL_EVT, &evt_data); |
| nfa_snep_cb.conn[dlink].p_ndef_buff = NULL; |
| } |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_reg_server |
| ** |
| ** Description Allocate a connection control block as server and register to LLCP |
| ** |
| ** |
| ** Returns TRUE to deallocate message |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_reg_server (tNFA_SNEP_MSG *p_msg) |
| { |
| tNFA_SNEP_EVT_DATA evt_data; |
| UINT8 xx, local_sap = LLCP_INVALID_SAP; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_reg_server ()"); |
| |
| xx = nfa_snep_allocate_cb (); |
| |
| if (xx < NFA_SNEP_MAX_CONN) |
| { |
| local_sap = LLCP_RegisterServer (p_msg->api_reg_server.server_sap, |
| LLCP_LINK_TYPE_DATA_LINK_CONNECTION, |
| p_msg->api_reg_server.service_name, |
| nfa_snep_llcp_cback); |
| } |
| |
| BCM_STRNCPY_S (evt_data.reg.service_name, sizeof (evt_data.reg.service_name), |
| p_msg->api_reg_server.service_name, LLCP_MAX_SN_LEN); |
| evt_data.reg.service_name[LLCP_MAX_SN_LEN] = 0x00; |
| |
| if ((xx == NFA_SNEP_MAX_CONN) || (local_sap == LLCP_INVALID_SAP)) |
| { |
| SNEP_TRACE_ERROR0 ("Cannot allocate or register SNEP server"); |
| |
| evt_data.reg.status = NFA_STATUS_FAILED; |
| p_msg->api_reg_server.p_cback (NFA_SNEP_REG_EVT, &evt_data); |
| return TRUE; |
| } |
| |
| if (!nfa_snep_cb.is_dta_mode) |
| { |
| /* if need to update WKS in LLCP Gen bytes */ |
| if (local_sap <= LLCP_UPPER_BOUND_WK_SAP) |
| { |
| nfa_p2p_enable_listening (NFA_ID_SNEP, TRUE); |
| nfa_snep_cb.listen_enabled = TRUE; |
| } |
| else if (!nfa_snep_cb.listen_enabled) |
| { |
| nfa_p2p_enable_listening (NFA_ID_SNEP, FALSE); |
| nfa_snep_cb.listen_enabled = TRUE; |
| } |
| } |
| |
| nfa_snep_cb.conn[xx].local_sap = local_sap; |
| nfa_snep_cb.conn[xx].remote_sap = LLCP_INVALID_SAP; |
| nfa_snep_cb.conn[xx].p_cback = p_msg->api_reg_server.p_cback; |
| nfa_snep_cb.conn[xx].flags = NFA_SNEP_FLAG_SERVER; |
| |
| evt_data.reg.status = NFA_STATUS_OK; |
| evt_data.reg.reg_handle = (NFA_HANDLE_GROUP_SNEP | xx); |
| |
| /* notify NFA_SNEP_REG_EVT to application */ |
| nfa_snep_cb.conn[xx].p_cback (NFA_SNEP_REG_EVT, &evt_data); |
| |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_reg_client |
| ** |
| ** Description Allocate a connection control block as client and register to LLCP |
| ** |
| ** |
| ** Returns TRUE to deallocate message |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_reg_client (tNFA_SNEP_MSG *p_msg) |
| { |
| tNFA_SNEP_EVT_DATA evt_data; |
| UINT8 xx, local_sap = LLCP_INVALID_SAP; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_reg_client ()"); |
| |
| xx = nfa_snep_allocate_cb (); |
| |
| if (xx < NFA_SNEP_MAX_CONN) |
| { |
| local_sap = LLCP_RegisterClient (LLCP_LINK_TYPE_DATA_LINK_CONNECTION, |
| nfa_snep_llcp_cback); |
| } |
| |
| evt_data.reg.service_name[0] = 0x00; |
| |
| if ((xx == NFA_SNEP_MAX_CONN) || (local_sap == LLCP_INVALID_SAP)) |
| { |
| SNEP_TRACE_ERROR0 ("Cannot allocate or register SNEP client"); |
| |
| evt_data.reg.status = NFA_STATUS_FAILED; |
| p_msg->api_reg_client.p_cback (NFA_SNEP_REG_EVT, &evt_data); |
| return TRUE; |
| } |
| |
| nfa_snep_cb.conn[xx].local_sap = local_sap; |
| nfa_snep_cb.conn[xx].remote_sap = LLCP_INVALID_SAP; |
| nfa_snep_cb.conn[xx].p_cback = p_msg->api_reg_client.p_cback; |
| nfa_snep_cb.conn[xx].flags = NFA_SNEP_FLAG_CLIENT; |
| |
| /* initialize timer callback */ |
| nfa_snep_cb.conn[xx].timer.p_cback = nfa_snep_timer_cback; |
| |
| evt_data.reg.status = NFA_STATUS_OK; |
| evt_data.reg.reg_handle = (NFA_HANDLE_GROUP_SNEP | xx); |
| |
| /* notify NFA_SNEP_REG_EVT to application */ |
| nfa_snep_cb.conn[xx].p_cback (NFA_SNEP_REG_EVT, &evt_data); |
| |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_dereg |
| ** |
| ** Description Deallocate a connection control block and deregister to LLCP |
| ** LLCP will deallocate any data link connection created for this |
| ** |
| ** Returns TRUE to deallocate message |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_dereg (tNFA_SNEP_MSG *p_msg) |
| { |
| UINT8 xx; |
| UINT8 local_sap; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_dereg ()"); |
| |
| xx = (UINT8) (p_msg->api_dereg.reg_handle & NFA_HANDLE_MASK); |
| |
| if ( (xx < NFA_SNEP_MAX_CONN) |
| &&(nfa_snep_cb.conn[xx].p_cback) |
| &&(nfa_snep_cb.conn[xx].flags & (NFA_SNEP_FLAG_SERVER|NFA_SNEP_FLAG_CLIENT)) ) |
| { |
| local_sap = nfa_snep_cb.conn[xx].local_sap; |
| LLCP_Deregister (local_sap); |
| nfa_snep_deallocate_cb (xx); |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Cannot find SNEP server/client"); |
| return TRUE; |
| } |
| |
| if (!nfa_snep_cb.is_dta_mode) |
| { |
| if (nfa_snep_cb.listen_enabled) |
| { |
| for (xx = 0; xx < NFA_SNEP_MAX_CONN; xx++) |
| { |
| if ( (nfa_snep_cb.conn[xx].p_cback) |
| &&(nfa_snep_cb.conn[xx].flags & NFA_SNEP_FLAG_SERVER) ) |
| { |
| break; |
| } |
| } |
| |
| if (xx >= NFA_SNEP_MAX_CONN) |
| { |
| /* if need to update WKS in LLCP Gen bytes */ |
| if (local_sap <= LLCP_UPPER_BOUND_WK_SAP) |
| nfa_p2p_disable_listening (NFA_ID_SNEP, TRUE); |
| else |
| nfa_p2p_disable_listening (NFA_ID_SNEP, FALSE); |
| |
| nfa_snep_cb.listen_enabled = FALSE; |
| } |
| /* if need to update WKS in LLCP Gen bytes */ |
| else if (local_sap <= LLCP_UPPER_BOUND_WK_SAP) |
| { |
| nfa_p2p_enable_listening (NFA_ID_SNEP, TRUE); |
| } |
| } |
| } |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_connect |
| ** |
| ** Description Create data link connection for client |
| ** |
| ** Returns TRUE to deallocate message |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_connect (tNFA_SNEP_MSG *p_msg) |
| { |
| tLLCP_CONNECTION_PARAMS conn_params; |
| UINT8 xx; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_connect ()"); |
| |
| xx = (UINT8) (p_msg->api_connect.client_handle & NFA_HANDLE_MASK); |
| |
| if (xx < NFA_SNEP_MAX_CONN) |
| { |
| nfa_snep_cb.conn[xx].congest = FALSE; |
| |
| /* Set remote_sap to SDP to find callback in case that link is deactivted before connected */ |
| nfa_snep_cb.conn[xx].remote_sap = LLCP_SAP_SDP; |
| |
| /* in order to send NFA_SNEP_DISC_EVT in case of connection failure */ |
| nfa_snep_cb.conn[xx].flags = NFA_SNEP_FLAG_CLIENT|NFA_SNEP_FLAG_CONNECTING; |
| |
| /* create data link connection with server name */ |
| conn_params.miu = NFA_SNEP_MIU; |
| conn_params.rw = NFA_SNEP_RW; |
| BCM_STRNCPY_S (conn_params.sn, sizeof (conn_params.sn), |
| p_msg->api_connect.service_name, LLCP_MAX_SN_LEN); |
| conn_params.sn[LLCP_MAX_SN_LEN] = 0; |
| |
| LLCP_ConnectReq (nfa_snep_cb.conn[xx].local_sap, LLCP_SAP_SDP, &conn_params); |
| } |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_get_req |
| ** |
| ** Description Send SNEP GET request on data link connection |
| ** |
| ** Returns TRUE to deallocate message |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_get_req (tNFA_SNEP_MSG *p_msg) |
| { |
| UINT8 dlink; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_get_req ()"); |
| |
| dlink = (UINT8) (p_msg->api_get_req.conn_handle & NFA_HANDLE_MASK); |
| |
| if ( (dlink < NFA_SNEP_MAX_CONN) |
| &&(nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_CONNECTED) ) |
| { |
| nfa_snep_cb.conn[dlink].tx_code = NFA_SNEP_REQ_CODE_GET; |
| nfa_snep_cb.conn[dlink].buff_length = p_msg->api_get_req.buff_length; |
| nfa_snep_cb.conn[dlink].ndef_length = p_msg->api_get_req.ndef_length; |
| nfa_snep_cb.conn[dlink].p_ndef_buff = p_msg->api_get_req.p_ndef_buff; |
| nfa_snep_cb.conn[dlink].acceptable_length = p_msg->api_get_req.buff_length; |
| |
| nfa_snep_send_msg (NFA_SNEP_REQ_CODE_GET, dlink); |
| |
| /* start timer for response from server */ |
| nfa_sys_start_timer (&nfa_snep_cb.conn[dlink].timer, dlink, NFA_SNEP_CLIENT_TIMEOUT); |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Data link connection is not established"); |
| } |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_put_req |
| ** |
| ** Description Send SNEP PUT request on data link connection |
| ** |
| ** Returns TRUE to deallocate message |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_put_req (tNFA_SNEP_MSG *p_msg) |
| { |
| UINT8 dlink; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_put_req ()"); |
| |
| dlink = (UINT8) (p_msg->api_put_req.conn_handle & NFA_HANDLE_MASK); |
| |
| if ( (dlink < NFA_SNEP_MAX_CONN) |
| &&(nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_CONNECTED) ) |
| { |
| nfa_snep_cb.conn[dlink].tx_code = NFA_SNEP_REQ_CODE_PUT; |
| nfa_snep_cb.conn[dlink].buff_length = p_msg->api_put_req.ndef_length; |
| nfa_snep_cb.conn[dlink].ndef_length = p_msg->api_put_req.ndef_length; |
| nfa_snep_cb.conn[dlink].p_ndef_buff = p_msg->api_put_req.p_ndef_buff; |
| |
| nfa_snep_send_msg (NFA_SNEP_REQ_CODE_PUT, dlink); |
| |
| /* start timer for response from server */ |
| nfa_sys_start_timer (&nfa_snep_cb.conn[dlink].timer, dlink, NFA_SNEP_CLIENT_TIMEOUT); |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Data link connection is not established"); |
| } |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_get_resp |
| ** |
| ** Description Server responds to GET request |
| ** |
| ** |
| ** Returns TRUE to deallocate message |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_get_resp (tNFA_SNEP_MSG *p_msg) |
| { |
| UINT8 dlink; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_get_resp ()"); |
| |
| dlink = (UINT8) (p_msg->api_get_resp.conn_handle & NFA_HANDLE_MASK); |
| |
| if ( (dlink < NFA_SNEP_MAX_CONN) |
| &&(nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_CONNECTED) ) |
| { |
| nfa_snep_cb.conn[dlink].buff_length = p_msg->api_get_resp.ndef_length; |
| nfa_snep_cb.conn[dlink].ndef_length = p_msg->api_get_resp.ndef_length; |
| nfa_snep_cb.conn[dlink].p_ndef_buff = p_msg->api_get_resp.p_ndef_buff; |
| |
| nfa_snep_cb.conn[dlink].tx_code = p_msg->api_get_resp.resp_code; |
| |
| nfa_snep_send_msg (p_msg->api_get_resp.resp_code, dlink); |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Data link connection is not established"); |
| } |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_put_resp |
| ** |
| ** Description Server responds to PUT request |
| ** |
| ** |
| ** Returns TRUE to deallocate message |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_put_resp (tNFA_SNEP_MSG *p_msg) |
| { |
| UINT8 dlink; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_put_resp ()"); |
| |
| dlink = (UINT8) (p_msg->api_put_resp.conn_handle & NFA_HANDLE_MASK); |
| |
| if ( (dlink < NFA_SNEP_MAX_CONN) |
| &&(nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_CONNECTED) ) |
| { |
| nfa_snep_cb.conn[dlink].tx_code = p_msg->api_put_resp.resp_code; |
| |
| nfa_snep_send_msg (p_msg->api_put_resp.resp_code, dlink); |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Data link connection is not established"); |
| } |
| return TRUE; |
| } |
| |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_disconnect |
| ** |
| ** Description Disconnect data link connection |
| ** |
| ** |
| ** Returns TRUE to deallocate message |
| ** |
| *******************************************************************************/ |
| BOOLEAN nfa_snep_disconnect (tNFA_SNEP_MSG *p_msg) |
| { |
| UINT8 dlink; |
| |
| SNEP_TRACE_DEBUG0 ("nfa_snep_disconnect ()"); |
| |
| dlink = (UINT8) (p_msg->api_disc.conn_handle & NFA_HANDLE_MASK); |
| |
| if ( (dlink < NFA_SNEP_MAX_CONN) |
| &&(nfa_snep_cb.conn[dlink].flags & NFA_SNEP_FLAG_CONNECTED) ) |
| { |
| LLCP_DisconnectReq (nfa_snep_cb.conn[dlink].local_sap, |
| nfa_snep_cb.conn[dlink].remote_sap, |
| p_msg->api_disc.flush); |
| } |
| else |
| { |
| SNEP_TRACE_ERROR0 ("Data link connection is not established"); |
| } |
| return TRUE; |
| } |
| |
| #if (BT_TRACE_VERBOSE == TRUE) |
| /******************************************************************************* |
| ** |
| ** Function nfa_snep_opcode |
| ** |
| ** Description |
| ** |
| ** Returns string of event |
| ** |
| *******************************************************************************/ |
| static char *nfa_snep_opcode (UINT8 opcode) |
| { |
| switch (opcode) |
| { |
| case NFA_SNEP_REQ_CODE_CONTINUE: |
| return "REQ_CONTINUE"; |
| case NFA_SNEP_REQ_CODE_GET: |
| return "REQ_GET"; |
| case NFA_SNEP_REQ_CODE_PUT: |
| return "REQ_PUT"; |
| case NFA_SNEP_REQ_CODE_REJECT: |
| return "REQ_REJECT"; |
| |
| case NFA_SNEP_RESP_CODE_CONTINUE: |
| return "RESP_CONTINUE"; |
| case NFA_SNEP_RESP_CODE_SUCCESS: |
| return "RESP_SUCCESS"; |
| case NFA_SNEP_RESP_CODE_NOT_FOUND: |
| return "RESP_NOT_FOUND"; |
| case NFA_SNEP_RESP_CODE_EXCESS_DATA: |
| return "RESP_EXCESS_DATA"; |
| case NFA_SNEP_RESP_CODE_BAD_REQ: |
| return "RESP_BAD_REQ"; |
| case NFA_SNEP_RESP_CODE_NOT_IMPLM: |
| return "RESP_NOT_IMPLM"; |
| case NFA_SNEP_RESP_CODE_UNSUPP_VER: |
| return "RESP_UNSUPP_VER"; |
| case NFA_SNEP_RESP_CODE_REJECT: |
| return "RESP_REJECT"; |
| |
| default: |
| return "Reserved opcode"; |
| } |
| } |
| |
| #endif /* Debug Functions */ |
| |
