dimoniche/changer
1
0
Fork 0
mirror of https://github.com/dimoniche/changer.git synced 2026-01-30 01:03:30 +03:00
Code Issues Packages Projects Releases Wiki Activity
changer/OS/uc/tcpip/Source/net_tcp.c
Dmitriy 5fe1e5d358 первый коммит 
первый коммит
2021-02-08 21:10:39 +03:00

25163 lines
1.3 MiB
Raw Permalink Blame History

This file contains invisible Unicode characters

This file contains invisible Unicode characters that are indistinguishable to humans but may be processed differently by a computer. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/*
*********************************************************************************************************
* uC/TCP-IP
* The Embedded TCP/IP Suite
*
* (c) Copyright 2003-2007; Micrium, Inc.; Weston, FL
*
* All rights reserved. Protected by international copyright laws.
*
* uC/TCP-IP is provided in source form for FREE evaluation, for educational
* use or peaceful research. If you plan on using uC/TCP-IP in a commercial
* product you need to contact Micrium to properly license its use in your
* product. We provide ALL the source code for your convenience and to help
* you experience uC/TCP-IP. The fact that the source code is provided does
* NOT mean that you can use it without paying a licensing fee.
*
* Knowledge of the source code may NOT be used to develop a similar product.
*
* Please help us continue to provide the Embedded community with the finest
* software available. Your honesty is greatly appreciated.
*********************************************************************************************************
*/
/*
*********************************************************************************************************
*
* NETWORK TCP LAYER
* (TRANSMISSION CONTROL PROTOCOL)
*
* Filename : net_tcp.c
* Version : V1.89
* Programmer(s) : ITJ
*********************************************************************************************************
* Note(s) : (1) Supports Transmission Control Protocol as described in RFC #793 with the following
* restrictions/constraints :
*
* (a) TCP Security & Precedence NOT supported RFC # 793, Section 3.6
*
* (b) TCP Urgent Data NOT supported RFC # 793, Section 3.7
* 'The Communication of
* Urgent Information'
*
* (c) The following TCP options NOT supported :
*
* (1) Window Scale RFC #1072, Section 2
* RFC #1323, Section 2
* (2) Selective Acknowledgement (SACK) RFC #1072, Section 3
* RFC #2018
* RFC #2883
* (3) TCP Echo RFC #1072, Section 4
* (4) Timestamp RFC #1323, Section 3.2
* (5) Protection Against Wrapped Sequences (PAWS) RFC #1323, Section 4
*
* (d) #### IP-Options-to-TCP-Connection RFC #1122, Section 4.2.3.8
* Handling NOT supported
*
* (e) #### ICMP-Error-Message-to-TCP-Connection RFC #1122, Section 4.2.3.9
* Handling NOT currently supported
*
* (2) TCP Layer assumes/requires Network Socket Layer (see 'net_sock.h MODULE Note #1a2').
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* INCLUDE FILES
*********************************************************************************************************
*/
#define NET_TCP_MODULE
#include <net.h>
/*
*********************************************************************************************************
* MODULE
*
* Note(s) : (1) See 'net_tcp.h MODULE'.
*********************************************************************************************************
*/
#ifdef NET_TCP_MODULE_PRESENT
/*$PAGE*/
/*
*********************************************************************************************************
* LOCAL DEFINES
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* TCP CONNECTION CONFIGURATION CODE DEFINES
*
* Note(s) : (1) (a) TCP connection configuration codes used as arguments for various NetTCP_ConnCfg() functions.
*
* (b) TCP connection configuration codes bit-field flags logically OR'd.
*********************************************************************************************************
*/
#define NET_TCP_CONN_CFG_NONE DEF_BIT_NONE
#define NET_TCP_CONN_CFG_MAX_SEG_SIZE_LOCAL DEF_BIT_00
#define NET_TCP_CONN_CFG_MAX_SEG_SIZE_REMOTE DEF_BIT_01
#define NET_TCP_CONN_CFG_MAX_SEG_SIZE_CONN DEF_BIT_02
#define NET_TCP_CONN_CFG_MAX_SEG_SIZE_ALL (NET_TCP_CONN_CFG_MAX_SEG_SIZE_LOCAL | \
NET_TCP_CONN_CFG_MAX_SEG_SIZE_REMOTE | \
NET_TCP_CONN_CFG_MAX_SEG_SIZE_CONN )
#define NET_TCP_CONN_CFG_MAX_SEG_SIZE_MASK NET_TCP_CONN_CFG_MAX_SEG_SIZE_ALL
#define NET_TCP_CONN_CFG_WIN_SIZE_RX DEF_BIT_02
#define NET_TCP_CONN_CFG_WIN_SIZE_TX DEF_BIT_03
#define NET_TCP_CONN_CFG_WIN_SIZE_CONN (NET_TCP_CONN_CFG_WIN_SIZE_RX | \
NET_TCP_CONN_CFG_WIN_SIZE_TX )
#define NET_TCP_CONN_CFG_WIN_SIZE_ALL NET_TCP_CONN_CFG_WIN_SIZE_CONN
#define NET_TCP_CONN_CFG_WIN_SIZE_MASK NET_TCP_CONN_CFG_WIN_SIZE_ALL
#define NET_TCP_CONN_CFG_TX_RTT_RTO DEF_BIT_04
#define NET_TCP_CONN_CFG_ALL (NET_TCP_CONN_CFG_NONE | \
NET_TCP_CONN_CFG_MAX_SEG_SIZE_ALL | \
NET_TCP_CONN_CFG_WIN_SIZE_ALL | \
NET_TCP_CONN_CFG_TX_RTT_RTO )
/*$PAGE*/
/*
*********************************************************************************************************
* TCP CONNECTION CLOSE/FREE CODE DEFINES
*
* Note(s) : (1) (a) TCP connection close codes used as arguments for various NetTCP_ConnClose() functions.
*
* (b) TCP connection close codes bit-field flags logically OR'd.
*
* (2) Available TCP connection free codes are identical to TCP connection close codes.
*********************************************************************************************************
*/
#define NET_TCP_CONN_CLOSE_NONE DEF_BIT_NONE
#define NET_TCP_CONN_CLOSE_CONN_NONE DEF_BIT_NONE
#define NET_TCP_CONN_CLOSE_CONN_TX_RESET DEF_BIT_00
#define NET_TCP_CONN_CLOSE_CONN_ALL (NET_TCP_CONN_CLOSE_CONN_NONE | \
NET_TCP_CONN_CLOSE_CONN_TX_RESET)
#define NET_TCP_CONN_CLOSE_CONN_MASK NET_TCP_CONN_CLOSE_CONN_ALL
#define NET_TCP_CONN_CLOSE_TMR_NONE DEF_BIT_NONE
#define NET_TCP_CONN_CLOSE_TMR_TX_IDLE DEF_BIT_04
#define NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN DEF_BIT_05
#define NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN DEF_BIT_06
#define NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY DEF_BIT_07
#define NET_TCP_CONN_CLOSE_TMR_RE_TX DEF_BIT_08
#define NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE DEF_BIT_09
#define NET_TCP_CONN_CLOSE_TMR_TIMEOUT DEF_BIT_10
#define NET_TCP_CONN_CLOSE_TMR_ALL (NET_TCP_CONN_CLOSE_TMR_NONE | \
NET_TCP_CONN_CLOSE_TMR_TX_IDLE | \
NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN | \
NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN | \
NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY | \
NET_TCP_CONN_CLOSE_TMR_RE_TX | \
NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE | \
NET_TCP_CONN_CLOSE_TMR_TIMEOUT )
#define NET_TCP_CONN_CLOSE_TMR_MASK NET_TCP_CONN_CLOSE_TMR_ALL
#define NET_TCP_CONN_CLOSE_ALL (NET_TCP_CONN_CLOSE_NONE | \
NET_TCP_CONN_CLOSE_CONN_ALL | \
NET_TCP_CONN_CLOSE_TMR_ALL )
#define NET_TCP_CONN_FREE_NONE NET_TCP_CONN_CLOSE_NONE
#define NET_TCP_CONN_FREE_TMR_NONE NET_TCP_CONN_CLOSE_TMR_NONE
#define NET_TCP_CONN_FREE_TMR_TX_IDLE NET_TCP_CONN_CLOSE_TMR_TX_IDLE
#define NET_TCP_CONN_FREE_TMR_TX_SILLY_WIN NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN
#define NET_TCP_CONN_FREE_TMR_TX_ZERO_WIN NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN
#define NET_TCP_CONN_FREE_TMR_TX_ACK_DLY NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY
#define NET_TCP_CONN_FREE_TMR_RE_TX NET_TCP_CONN_CLOSE_TMR_RE_TX
#define NET_TCP_CONN_FREE_TMR_KEEP_ALIVE NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE
#define NET_TCP_CONN_FREE_TMR_TIMEOUT NET_TCP_CONN_CLOSE_TMR_TIMEOUT
#define NET_TCP_CONN_FREE_TMR_ALL NET_TCP_CONN_CLOSE_TMR_ALL
#define NET_TCP_CONN_FREE_TMR_MASK NET_TCP_CONN_CLOSE_TMR_MASK
#define NET_TCP_CONN_FREE_ALL NET_TCP_CONN_CLOSE_ALL
/*
*********************************************************************************************************
* LOCAL CONSTANTS
*********************************************************************************************************
*/
/*$PAGE*/
/*
*********************************************************************************************************
* LOCAL DATA TYPES
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* TCP SEQUENCE CODE DATA TYPE
*********************************************************************************************************
*/
typedef CPU_INT08U NET_TCP_SEQ_CODE;
/*
*********************************************************************************************************
* TCP ACKNOWLEDGEMENT CODE DATA TYPE
*********************************************************************************************************
*/
typedef CPU_INT08U NET_TCP_ACK_CODE;
/*
*********************************************************************************************************
* TCP CONNECTION RESET CODE DATA TYPE
*********************************************************************************************************
*/
typedef CPU_INT08U NET_TCP_RESET_CODE;
/*
*********************************************************************************************************
* TCP WINDOW CODE DATA TYPE
*********************************************************************************************************
*/
typedef CPU_INT08U NET_TCP_WIN_CODE;
/*
*********************************************************************************************************
* TCP CALCULATION CODE DATA TYPE
*********************************************************************************************************
*/
typedef CPU_INT08U NET_TCP_CALC_CODE;
/*
*********************************************************************************************************
* TCP CONFIGURATION CODE DATA TYPE
*********************************************************************************************************
*/
typedef CPU_INT08U NET_TCP_CFG_CODE;
/*
*********************************************************************************************************
* TCP CLOSE CODE DATA TYPE
*********************************************************************************************************
*/
typedef CPU_INT16U NET_TCP_CLOSE_CODE;
/*
*********************************************************************************************************
* TCP FREE CODE DATA TYPE
*********************************************************************************************************
*/
typedef NET_TCP_CLOSE_CODE NET_TCP_FREE_CODE;
/*
*********************************************************************************************************
* LOCAL TABLES
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* LOCAL GLOBAL VARIABLES
*********************************************************************************************************
*/
/*$PAGE*/
/*
*********************************************************************************************************
* LOCAL FUNCTION PROTOTYPES
*********************************************************************************************************
*/
/* --------- RX FNCTS --------- */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
static void NetTCP_RxPktValidateBuf (NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
#endif
static void NetTCP_RxPktValidate (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_HDR *ptcp_hdr,
NET_ERR *perr);
static void NetTCP_RxPktValidateOpt (NET_BUF_HDR *pbuf_hdr,
NET_TCP_HDR *ptcp_hdr,
CPU_INT08U tcp_hdr_len_size,
NET_ERR *perr);
static CPU_BOOLEAN NetTCP_RxPktValidateOptMaxSegSize (NET_BUF_HDR *pbuf_hdr,
CPU_INT08U *popt,
CPU_INT08U *popt_len,
NET_ERR *perr);
static void NetTCP_RxPktDemuxSeg (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandler (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerListen (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerSyncRxd (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerSyncTxd (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerConn (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerFinWait1 (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerFinWait2 (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerClosing (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerTimeWait (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerCloseWait (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerLastAck (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
/*$PAGE*/
static void NetTCP_RxPktConnHandlerSeg (NET_TCP_CONN *pconn,
NET_TCP_ACK_CODE ack_code,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerCfgConn (NET_TCP_CONN *pconn);
static void NetTCP_RxPktConnHandlerRxQ_Sync (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerRxQ_Conn (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerRxQ_AppData (NET_TCP_CONN *pconn,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerTxWinRemote (NET_TCP_CONN *pconn,
NET_TCP_ACK_CODE ack_code,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerReTxQ (NET_TCP_CONN *pconn,
NET_TCP_ACK_CODE ack_code,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static CPU_BOOLEAN NetTCP_RxPktConnHandlerListenQ_IsAvail(NET_TCP_CONN *pconn,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerSignalConn (NET_TCP_CONN *pconn,
NET_TCP_CONN_STATE state,
NET_ERR *perr);
static void NetTCP_RxPktConnHandlerSignalClose (NET_TCP_CONN *pconn,
CPU_BOOLEAN data_avail,
NET_ERR *perr);
static NET_TCP_SEQ_CODE NetTCP_RxPktConnIsValidSeq (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static NET_TCP_ACK_CODE NetTCP_RxPktConnIsValidAck (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static NET_TCP_RESET_CODE NetTCP_RxPktConnIsValidReset (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_RxPktFree (NET_BUF *pbuf_q);
static void NetTCP_RxPktDiscard (NET_BUF *pbuf,
NET_ERR *perr);
static void NetTCP_RxConnWinSizeCfg (NET_TCP_CONN *pconn);
static void NetTCP_RxConnWinSizeCfgUpdateTh (NET_TCP_CONN *pconn);
static void NetTCP_RxConnWinSizeHandler (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_WIN_SIZE win_update_size,
NET_TCP_WIN_CODE win_update_code);
/*$PAGE*/
/* --------- TX FNCTS --------- */
static void NetTCP_TxConnWinSizeCfg (NET_TCP_CONN *pconn);
static void NetTCP_TxConnWinSizeCfgCongCtrl (NET_TCP_CONN *pconn);
static void NetTCP_TxConnWinSizeCfgMinTh (NET_TCP_CONN *pconn);
static void NetTCP_TxConnWinSizeHandlerCfgd (NET_TCP_CONN *pconn,
NET_TCP_WIN_SIZE win_update_size,
NET_TCP_WIN_CODE win_update_code,
NET_ERR *perr);
static void NetTCP_TxConnWinSizeHandlerCongCtrl (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_ACK_CODE ack_code,
NET_TCP_WIN_SIZE win_update_size,
NET_TCP_WIN_CODE win_update_code,
NET_ERR *perr);
static void NetTCP_TxConnWinSizeCalcSlowStartTh (NET_TCP_CONN *pconn);
static void NetTCP_TxConnWinSizeCongSet (NET_TCP_CONN *pconn,
NET_TCP_WIN_CODE win_inc_code);
static void NetTCP_TxConnWinSizeCongInc (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_WIN_SIZE win_update_size,
NET_TCP_WIN_CODE win_inc_code);
static void NetTCP_TxConnWinSizeUpdateAvail (NET_TCP_CONN *pconn);
static void NetTCP_TxConnWinSizeDupAckCtrlReset (NET_TCP_CONN *pconn);
static void NetTCP_TxConnWinSizeDupAckCtrlUpdate (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
CPU_BOOLEAN reset_ctr);
static void NetTCP_TxConnWinSizeZeroWinHandler (NET_TCP_CONN *pconn,
NET_TCP_WIN_CODE win_update_code,
NET_TCP_CLOSE_CODE close_code);
static void NetTCP_TxConnWinSizeZeroWinTimeout (void *pconn_timeout);
/*$PAGE*/
static void NetTCP_TxConnSync (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr);
static void NetTCP_TxConnClose (NET_TCP_CONN *pconn,
NET_ERR *perr);
static void NetTCP_TxConnAck (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_ACK_CODE tx_ack_code,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr);
static void NetTCP_TxConnAckDlyReset (NET_TCP_CONN *pconn,
CPU_BOOLEAN tmr_free);
static void NetTCP_TxConnAckDlyTimeout (void *pconn_timeout);
static void NetTCP_TxConnReset (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_RESET_CODE tx_reset_code,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr);
static void NetTCP_TxConnProbe (NET_TCP_CONN *pconn,
CPU_BOOLEAN tx_probe_data_octet,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr);
static void NetTCP_TxConnTxQ (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_ACK_CODE tx_ack_code,
CPU_BOOLEAN tx_q_timeout,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr);
static void NetTCP_TxConnTxQ_TimeoutIdle (void *pconn_timeout);
static void NetTCP_TxConnTxQ_TimeoutIdleSet (NET_TCP_CONN *pconn);
static void NetTCP_TxConnTxQ_TimeoutIdleClr (NET_TCP_CONN *pconn);
static void NetTCP_TxConnTxQ_TimeoutSillyWin (void *pconn_timeout);
static void NetTCP_TxConnReTxQ (NET_TCP_CONN *pconn,
CPU_BOOLEAN re_tx_q_timeout,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr);
static void NetTCP_TxConnReTxQ_Timeout (void *pconn_timeout);
static void NetTCP_TxConnReTxQ_TimeoutSet (NET_TCP_CONN *pconn,
CPU_BOOLEAN re_tx_q_timeout,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr);
static void NetTCP_TxConnPrepareSegAddrs (NET_TCP_CONN *pconn,
CPU_INT08U *psrc_port,
CPU_INT08U *psrc_addr,
CPU_INT16U src_port_len,
CPU_INT16U src_addr_len,
CPU_INT08U *pdest_port,
CPU_INT08U *pdest_addr,
CPU_INT16U dest_port_len,
CPU_INT16U dest_addr_len,
NET_ERR *perr);
/*$PAGE*/
static void NetTCP_TxConnRTT_Init (NET_TCP_CONN *pconn);
static void NetTCP_TxConnRTT_Reset (NET_TCP_CONN *pconn);
static void NetTCP_TxConnRTT_CalcUpdate (NET_TCP_CONN *pconn);
static void NetTCP_TxConnRTO_Init (NET_TCP_CONN *pconn);
static void NetTCP_TxConnRTO_CfgMaxTimeout (NET_TCP_CONN *pconn);
static void NetTCP_TxConnRTO_CalcUpdate (NET_TCP_CONN *pconn);
static NET_TCP_TIMEOUT_MS NetTCP_TxConnRTO_CalcBackOff (NET_TCP_CONN *pconn,
NET_TCP_TIMEOUT_MS rto_ms);
static void NetTCP_TxConnRTT_RTO_Init (NET_TCP_CONN *pconn);
static void NetTCP_TxConnRTT_RTO_Calc (NET_TCP_CONN *pconn,
NET_TCP_CALC_CODE calc_code,
NET_TCP_TX_RTT_TS_MS rtt_ts_txd_ms,
NET_TCP_TX_RTT_TS_MS rtt_ts_rxd_ms);
static void NetTCP_TxPktHandler (NET_BUF *pbuf,
NET_IP_ADDR src_addr,
NET_TCP_PORT_NBR src_port,
NET_IP_ADDR dest_addr,
NET_TCP_PORT_NBR dest_port,
NET_TCP_SEQ_NBR seq_nbr,
NET_TCP_SEQ_NBR ack_nbr,
NET_TCP_WIN_SIZE win_size,
NET_IP_TOS TOS,
NET_IP_TTL TTL,
CPU_INT16U flags_tcp,
CPU_INT16U flags_ip,
void *popts_tcp,
void *popts_ip,
NET_ERR *perr);
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
static void NetTCP_TxPktValidate (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_PORT_NBR src_port,
NET_TCP_PORT_NBR dest_port,
NET_TCP_SEQ_NBR seq_nbr,
NET_TCP_SEQ_NBR ack_nbr,
NET_TCP_WIN_SIZE win_size,
CPU_INT16U flags_tcp,
void *popts_tcp,
NET_ERR *perr);
static void NetTCP_TxPktValidateOpt (void *popts_tcp,
CPU_INT16U flags_tcp,
NET_ERR *perr);
static void NetTCP_TxPktValidateOptMaxSegSize (void *popt_tcp,
CPU_INT08U *popt_len,
void **popt_next,
CPU_INT16U flags_tcp,
NET_ERR *perr);
#endif
/*$PAGE*/
static void NetTCP_TxPkt (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_IP_ADDR src_addr,
NET_TCP_PORT_NBR src_port,
NET_IP_ADDR dest_addr,
NET_TCP_PORT_NBR dest_port,
NET_TCP_SEQ_NBR seq_nbr,
NET_TCP_SEQ_NBR ack_nbr,
NET_TCP_WIN_SIZE win_size,
NET_IP_TOS TOS,
NET_IP_TTL TTL,
CPU_INT16U flags_tcp,
CPU_INT16U flags_ip,
void *popts_tcp,
void *popts_ip,
NET_ERR *perr);
static CPU_INT08U NetTCP_TxPktPrepareOpt (void *popts_tcp,
CPU_INT08U *popt_hdr,
NET_ERR *perr);
static void NetTCP_TxPktPrepareOptMaxSegSize (void *popts_tcp,
CPU_INT08U *popt_hdr,
CPU_INT08U *popt_len,
void **popt_next,
NET_ERR *perr);
static void NetTCP_TxPktPrepareHdr (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
CPU_INT16U tcp_hdr_len_tot,
CPU_INT08U tcp_opt_len_tot,
NET_IP_ADDR src_addr,
NET_TCP_PORT_NBR src_port,
NET_IP_ADDR dest_addr,
NET_TCP_PORT_NBR dest_port,
NET_TCP_SEQ_NBR seq_nbr,
NET_TCP_SEQ_NBR ack_nbr,
NET_TCP_WIN_SIZE win_size,
CPU_INT16U flags_tcp,
CPU_INT32U *ptcp_hdr_opts,
NET_ERR *perr);
static void NetTCP_TxPktFree (NET_BUF *pbuf_q);
static void NetTCP_TxPktDiscard (NET_BUF *pbuf,
NET_ERR *perr);
/*$PAGE*/
/* ------ TCP CONN FNCTS ------ */
static void NetTCP_ConnCfg (NET_TCP_CONN *pconn,
NET_TCP_CFG_CODE cfg_code);
static void NetTCP_ConnCfgMaxSegSize (NET_TCP_CONN *pconn);
static void NetTCP_ConnClose (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
CPU_BOOLEAN close_conn_app,
NET_TCP_CLOSE_CODE close_code);
static void NetTCP_ConnCloseHandler (NET_TCP_CONN *pconn,
CPU_BOOLEAN close_conn_app,
NET_TCP_CLOSE_CODE close_code);
static void NetTCP_ConnCloseTimeout (void *pconn_timeout);
static void NetTCP_ConnClosingTimeoutDataAvail (void *pconn_timeout);
static void NetTCP_ConnFreeHandler (NET_TCP_CONN *pconn,
NET_TCP_FREE_CODE free_code);
static void NetTCP_ConnFreeTmr (NET_TCP_CONN *pconn,
NET_TCP_FREE_CODE free_code);
static void NetTCP_ConnFreeBufQ (NET_BUF **pbuf_q_head,
NET_BUF **pbuf_q_tail);
static void NetTCP_ConnClr (NET_TCP_CONN *pconn);
static void NetTCP_ConnCopy (NET_TCP_CONN *pconn_dest,
NET_TCP_CONN *pconn_src);
static void NetTCP_ConnDiscard (NET_TCP_CONN *pconn);
/*
*********************************************************************************************************
* LOCAL CONFIGURATION ERRORS
*********************************************************************************************************
*/
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_Init()
*
* Description : (1) Initialize Transmission Control Protocol Layer :
*
* (a) Perform TCP Module/OS initialization
* (b) Perform TCP Module/BSP initialization
* (c) Initialize TCP connection pool
* (d) Initialize TCP connection table
* (e) Initialize TCP statistics & error counters
*
*
* Argument(s) : perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP layer successfully initialized.
*
* - RETURNED BY NetOS_TCP_Init() : --
* NET_OS_ERR_INIT_TCP_RX_Q TCP receive queue(s) NOT
* successfully initialized.
* NET_OS_ERR_INIT_TCP_RX_Q_TIMEOUT TCP receive queue timeout(s) NOT
* successfully configured.
* NET_OS_ERR_INIT_TCP_TX_Q TCP transmit queue(s) NOT
* successfully initialized.
* NET_OS_ERR_INIT_TCP_TX_Q_TIMEOUT TCP transmit queue timeout(s) NOT
* successfully configured.
*
* Return(s) : none.
*
* Caller(s) : Net_Init().
*
* This function is an INTERNAL network protocol suite function & MUST NOT be called by
* application function(s).
*
* Note(s) : (2) TCP connection pool MUST be initialized PRIOR to initializing the pool with pointers to
* TCP connections.
*********************************************************************************************************
*/
void NetTCP_Init (NET_ERR *perr)
{
NET_TCP_CONN *pconn;
NET_TCP_CONN_QTY i;
NET_ERR stat_err;
/* --------------- PERFORM TCP/OS INIT --------------- */
NetOS_TCP_Init(perr); /* Create TCP obj(s). */
if (*perr != NET_OS_ERR_NONE) {
return;
}
/* --------------- PERFORM TCP/BSP INIT --------------- */
NetTCP_InitTxSeqNbr(); /* Init tx seq nbr ctr. */
/* ------------- INIT TCP CONN POOL/STATS ------------- */
NetTCP_ConnPoolPtr = (NET_TCP_CONN *)0; /* Init-clr TCP conn pool (see Note #2). */
NetStat_PoolInit((NET_STAT_POOL *)&NetTCP_ConnPoolStat,
(NET_STAT_POOL_QTY) NET_TCP_CFG_NBR_CONN,
(NET_ERR *)&stat_err);
/* ---------------- INIT TCP CONN TBL ----------------- */
pconn = &NetTCP_ConnTbl[0];
for (i = 0; i < NET_TCP_CFG_NBR_CONN; i++) {
pconn->Type = NET_TCP_TYPE_CONN; /* Init each TCP conn type/id--NEVER modify. */
pconn->ID = (NET_TCP_CONN_ID)i;
pconn->ConnState = NET_TCP_CONN_STATE_FREE; /* Init each TCP conn as free/NOT used. */
pconn->Flags = NET_TCP_FLAG_NONE;
#if (NET_DBG_CFG_MEM_CLR_EN == DEF_ENABLED)
NetTCP_ConnClr(pconn);
#endif
/* Free each TCP conn to TCP conn pool (see Note #2). */
pconn->NextPtr = (void *)NetTCP_ConnPoolPtr;
NetTCP_ConnPoolPtr = (NET_TCP_CONN *)pconn;
pconn++;
}
/*$PAGE*/
/* ------------- INIT TCP STAT & ERR CTRS ------------- */
#if (NET_CTR_CFG_STAT_EN == DEF_ENABLED)
NetTCP_StatRxPktCtr = 0;
NetTCP_StatRxSegProcessedCtr = 0;
NetTCP_StatTxSegCtr = 0;
NetTCP_StatTxSegConnSyncCtr = 0;
NetTCP_StatTxSegConnCloseCtr = 0;
NetTCP_StatTxSegConnAckCtr = 0;
NetTCP_StatTxSegConnResetCtr = 0;
NetTCP_StatTxSegConnProbeCtr = 0;
NetTCP_StatTxSegConnTxQ_Ctr = 0;
NetTCP_StatTxSegConnReTxQ_Ctr = 0;
#endif
#if (NET_CTR_CFG_ERR_EN == DEF_ENABLED)
NetTCP_ErrNullPtrCtr = 0;
NetTCP_ErrNoneAvailCtr = 0;
NetTCP_ErrNotUsedCtr = 0;
NetTCP_ErrRxHdrLenCtr = 0;
NetTCP_ErrRxHdrSegLenCtr = 0;
NetTCP_ErrRxHdrPortSrcCtr = 0;
NetTCP_ErrRxHdrPortDestCtr = 0;
NetTCP_ErrRxHdrFlagsCtr = 0;
NetTCP_ErrRxHdrChkSumCtr = 0;
NetTCP_ErrRxHdrOptsCtr = 0;
NetTCP_ErrRxDestCtr = 0;
NetTCP_ErrRxPktDiscardedCtr = 0;
NetTCP_ErrTxOptTypeCtr = 0;
NetTCP_ErrTxPktDiscardedCtr = 0;
NetTCP_ErrConnInvalidCtr = 0;
NetTCP_ErrConnInvalidOpCtr = 0;
NetTCP_ErrConnInvalidStateCtr = 0;
NetTCP_ErrConnCloseCtr = 0;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NetTCP_ErrRxInvalidBufIxCtr = 0;
NetTCP_ErrRxHdrDataLenCtr = 0;
NetTCP_ErrTxInvalidProtocolCtr = 0;
NetTCP_ErrTxInvalidSizeCtr = 0;
NetTCP_ErrTxInvalidBufIxCtr = 0;
NetTCP_ErrTxHdrDataLenCtr = 0;
NetTCP_ErrTxHdrPortSrcCtr = 0;
NetTCP_ErrTxHdrPortDestCtr = 0;
NetTCP_ErrTxHdrFlagsCtr = 0;
NetTCP_ErrTxHdrOptLenCtr = 0;
NetTCP_ErrTxHdrOptCfgCtr = 0;
NetTCP_ErrConnInvalidTypeCtr = 0;
#endif
#endif
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_Rx()
*
* Description : (1) Process received segments & demultiplex to socket or application layer connection :
*
* (a) Validate TCP packet
* (b) Demultiplex TCP packet to TCP connection
* (c) Handle/Process TCP segment
* (d) Return TCP error code(s)
*
* (2) Although TCP data units are typically referred to as 'segments' (see RFC #793, Section 3.1),
* the term 'TCP packet' (see RFC #1983, 'packet') is used for TCP Receive until the packet is
* validated as a TCP segment.
*
*
* Argument(s) : pbuf Pointer to network buffer that received TCP packet.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP segment successfully received & processed.
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
*
* ---- RETURNED BY NetTCP_RxPktDiscard() : -----
* NET_ERR_RX Receive error; packet discarded.
*
* Return(s) : none.
*
* Caller(s) : NetIP_RxPktDemuxDatagram().
*
* This function is an INTERNAL network protocol suite function & MUST NOT be called by
* application function(s).
*
* Note(s) : (3) NetTCP_Rx() blocked until network initialization completes.
*
* (4) TCP receive statistics updated in NetTCP_RxPktConnHandler(); do NOT re-update.
*
* (a) Network buffer already freed & error counter already incremented in previous
* function(s).
*
* See also 'NetTCP_RxPktConnHandler() Note #2'.
*********************************************************************************************************
*/
/*$PAGE*/
void NetTCP_Rx (NET_BUF *pbuf,
NET_ERR *perr)
{
#if ((((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED)) || \
(NET_CTR_CFG_STAT_EN == DEF_ENABLED)) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_BUF_HDR *pbuf_hdr;
NET_TCP_HDR *ptcp_hdr;
#if (NET_ERR_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (Net_InitDone != DEF_YES) { /* If init NOT complete, exit rx (see Note #3). */
*perr = NET_ERR_INIT_INCOMPLETE;
return;
}
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ------------------- VALIDATE PTR ------------------- */
if (pbuf == (NET_BUF *)0) {
NetTCP_RxPktDiscard(pbuf, perr);
NET_CTR_ERR_INC(NetTCP_ErrNullPtrCtr);
return;
}
#endif
NET_CTR_STAT_INC(NetTCP_StatRxPktCtr);
/* ----------------- VALIDATE TCP PKT ----------------- */
pbuf_hdr = &pbuf->Hdr;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NetTCP_RxPktValidateBuf(pbuf_hdr, perr); /* Validate rx'd buf. */
switch (*perr) {
case NET_TCP_ERR_NONE:
break;
case NET_ERR_INVALID_PROTOCOL:
case NET_BUF_ERR_INVALID_IX:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
ptcp_hdr = (NET_TCP_HDR *)&pbuf->Data[pbuf_hdr->TCP_UDP_HdrDataIx];
NetTCP_RxPktValidate(pbuf, pbuf_hdr, ptcp_hdr, perr); /* Validate rx'd pkt. */
/* -------------- DEMUX PKT TO TCP CONN --------------- */
switch (*perr) {
case NET_TCP_ERR_NONE:
NetTCP_RxPktDemuxSeg(pbuf, pbuf_hdr, perr);
break;
case NET_TCP_ERR_INVALID_PORT_NBR:
case NET_TCP_ERR_INVALID_LEN_HDR:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_INVALID_LEN_DATA:
case NET_TCP_ERR_INVALID_FLAG:
case NET_TCP_ERR_INVALID_CHK_SUM:
case NET_TCP_ERR_INVALID_OPT_LEN:
case NET_TCP_ERR_INVALID_OPT_END:
case NET_TCP_ERR_INVALID_OPT_NBR:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* --------------- HANDLE TCP PKT/CONN ---------------- */
switch (*perr) { /* Chk err from NetTCP_RxPktDemuxSeg(). */
case NET_TCP_ERR_NONE:
NetTCP_RxPktConnHandler(pbuf, pbuf_hdr, perr);
break;
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_CONN:
case NET_ERR_RX_DEST:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ---------------- RTN TCP ERR CODES ----------------- */
switch (*perr) { /* Chk err from NetTCP_RxPktConnHandler(). */
case NET_TCP_ERR_NONE:
/* See Note #4. */
break;
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
case NET_TCP_ERR_CONN_CLOSED:
case NET_TCP_ERR_CONN_RESET_VALID:
*perr = NET_TCP_ERR_NONE;
break;
case NET_ERR_RX:
/* See Note #4a. */
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_INVALID_CONN:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_INVALID_CONN_STATE:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxAppData()
*
* Description : (1) Deframe application data from TCP connection's enqueued TCP segment(s) :
*
* (a) Wait on TCP connection application receive queue for packet buffer(s)
* (b) Deframe application data from enqueued TCP segment(s)
* (c) Update TCP connection application receive queue
* (1) Free TCP packet buffer(s)
* (d) Update TCP connection receive window
*
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to receive application data.
*
* pdata_buf Pointer to application buffer to receive application data.
* --------- Argument validated in NetSock_RxDataHandlerStream().
*
* data_buf_len Size of application receive buffer (in octets).
* ------------ Argument validated in NetSock_RxDataHandlerStream().
*
* flags Flags to select receive options; bit-field flags logically OR'd :
* -----
* NET_TCP_FLAG_NONE No TCP receive flags selected.
* NET_TCP_FLAG_RX_DATA_PEEK Receive TCP application data without consuming
* the data; i.e. data NOT removed from TCP
* connection's application receive queue(s).
* NET_TCP_FLAG_RX_BLOCK Receive TCP application data with blocking,
* if flag set; without blocking, if clear.
*
* Argument validated in NetSock_RxDataHandlerStream().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection application data successfully
* deframed; check return value for number of
* data octets received.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
* NET_TCP_ERR_CONN_DATA_INVALID TCP connection application receive queue contains
* invalid or improperly sequenced data.
*
* NET_TCP_ERR_RX_Q_CLOSED TCP connection application receive queue closed
* (see Note #3e3B).
* NET_TCP_ERR_RX_Q_EMPTY TCP connection application receive queue empty
* (see Note #3e2B).
*
* ------- RETURNED BY NetTCP_ConnIsUsed() : -------
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_INVALID_CONN Invalid TCP connection number.
*
* ------ RETURNED BY NetOS_TCP_RxQ_Wait() : -------
* NET_TCP_ERR_RX_Q_SIGNAL_ABORT TCP connection receive queue signal aborted;
* TCP connection closed/aborted.
* NET_TCP_ERR_RX_Q_SIGNAL_FAULT TCP connection receive queue signal fault.
*
* ---------- RETURNED BY NetOS_Lock() : -----------
* NET_OS_ERR_LOCK Network access NOT acquired.
*
* Return(s) : Total application data octets deframed into receive buffer, if NO errors.
*
* 0, otherwise.
*
* Caller(s) : NetSock_RxDataHandlerStream().
*
* This function is an INTERNAL network protocol suite function & SHOULD NOT be called by
* application function(s).
*$PAGE*
* Note(s) : (2) NetTCP_RxAppData() blocked until network initialization completes.
*
* See 'NetTCP_ConnIsUsed() Note #1'.
*
* (3) RFC #793, Section 3.9 'Event Processing : RECEIVE Call' specifies how to handle receive
* data requests from the application layer :
*
* (a) For the "CLOSED STATE ... return 'error: connection does not exist'".
*
* (b) (1) For the "LISTEN STATE, SYN-SENT STATE, SYN-RECEIVED STATE ... queue for processing
* after entering ESTABLISHED state".
*
* (2) The application layer may request to receive application data before the TCP
* connection enters the connected state. Such requests will block or return
* no data.
*
* See also 'NetTCP_RxPktConnHandlerRxQ_AppData() Note #1bA'
* & Note #5b2.
*
* (c) For the "ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2 STATE" ...
*
* (1) ... that "if insufficient incoming segments are queued to satisfy the request,
* queue the request".
*
* (2) "Reassemble queued incoming segments into receive buffer and return to user."
*
* (d) For the "CLOSE-WAIT STATE ... since the remote side has already sent FIN, RECEIVEs
* must be satisfied by the text already on hand, but not yet delivered to the user.
* If no text is awaiting delivery, the RECEIVE will get a 'error: connection closing'
* response. Otherwise, any remaining text can be used to satisfy the RECEIVE".
*
* (e) (1) For the "CLOSING STATE, LAST-ACK STATE, TIME-WAIT STATE ... return 'error:
* connection closing'".
*
* (2) Typically, these states will have already received ALL remainining closing
* data from the closing remote host.
*
* (A) However, in case all receive data from the remote host has NOT yet been
* received, application layer receives from these states are permitted until
* the TCP connection's sequence receive state is closed & the TCP connection's
* application receive queue is empty.
*
* (B) If all receive data from the remote host has NOT yet been received but the
* application receive queue is currently empty, return application receive
* queue empty error(s).
*
* (3) Once a TCP connection has closed & ALL receive data has been received by the
* application layer :
*
* (A) Close the TCP connection;
* (B) Return application receive queue closed error.
*$PAGE*
* (4) (a) RFC #793, Section 3.3 states that :
*
* (1) "Every octet of data sent over a TCP connection has a sequence number."
* (2) In addition, "SYN and FIN ... control information ... [is] implicitly assign[ed]
* sequence numbers ... [but] is not physically carried in the segment data space".
*
* (A) "For sequence number purposes, the SYN is considered to occur before the
* first actual data octet of the segment in which it occurs," ...
* (B) "While the FIN is considered to occur after the last actual data octet in
* a segment in which it occurs."
*
* (3) "The segment length (SEG.LEN) includes both data and sequence space occupying
* controls.
*
*
* ----- ------------------------ Synchronization
* ^ | Initial SEQ # (SYN) | <--- Sequence Number
* | ------------------------ (see Note #4a2A)
* | | Data Octet # 1 | ---
* | | Data Octet # 2 | ^
* | Data Octet # 3 | |
* TCP Connection | . | | Data Octet
* Sequences | . | | Sequence Number(s)
* (see Note #4a) | . | | (see Note #4a1)
* | Data Octet # (N - 2) | |
* | | Data Octet # (N - 1) | v
* | | Data Octet # N | --- Closing
* | ------------------------ Sequence Number
* v | Close SEQ # (FIN) | <--- (see Note #4a2B)
* ----- ------------------------
*
*
* See also 'NetTCP_TxConnSync() Note #3'
* & 'NetTCP_TxConnClose() Note #2'.
*
* (b) Therefore, since TCP synchronization or close sequence numbers are NOT actual data
* sequences or octets that are transmitted or received; segments which include these
* TCP control sequence numbers MUST adjust TCP data sequence numbers & TCP segment
* lengths by these TCP control sequence numbers.
*
* (1) A TCP data segment MUST adjust its data index by the possible synchronization
* control sequence.
*
* (A) On a received TCP segment's first data read, the segment's base data index
* is NOT offset -- even though for a synchronization segment, this base data
* index starts on the sequence number following the synchronization control
* sequence.
*
* (B) On any additional received TCP segment data reads, the segment's base data
* index MUST be offset by possible synchronization control sequence.
*
* (2) TCP connections & TCP data segments MUST advance their sequence numbers & adjust
* their segment lengths by possible TCP control sequences.
*
* (A) A TCP connection MUST advance its sequence numbers by :
*
* (1) Possible synchronization sequence; but only on the first, initial access
* to a TCP synchronization segment; ...
* (2) All accessed data sequence(s); ...
* (3) Possible closing sequence; which SHOULD only occur once on the
* last access to a TCP closing segment.
*
* (B) (1) A received TCP segment MUST advance its sequence numbers by :
*
* (a) Possible synchronization sequence; but only on the first, initial
* access to a TCP synchronization segment; ...
* (b) All accessed data sequence(s).
*
* (2) (a) A received TCP segment MUST adjust its total segment length by :
*
* (1) Possible synchronization sequence; but only on the first, initial
* access to a TCP synchronization segment; ...
* (2) All accessed data sequence(s).
*
* (3) Possible closing sequence adjustment MAY be ignored since
* all effective segment data handling occurs prior to accessing any
* trailing closing sequence.
*
* (b) A received TCP segment MUST adjust its data segment length ONLY by :
*
* (b) All accessed data sequence(s).
*$PAGE*
* (5) (a) Stream-type connections receive all data octets in one or more non-distinct packets.
* In other words, the application data is NOT bounded by any specific packet(s); rather,
* it is contiguous & sequenced from one packet to the next.
*
* (b) Therefore, the TCP connection receive queue is signaled ONLY when data is received for
* a connection where data was previously unavailable.
*
* (c) Consequently, it is typical -- but NOT absolutely required -- that a single application
* task only receive or request to receive application data from a TCP connection.
*
* See also 'net_sock.c NetSock_RxDataHandlerStream() Note #2'.
*
* (6) Since pointer arithmetic is based on the specific pointer data type & inherent pointer
* data type size, pointer arithmetic operands :
*
* (a) MUST be in terms of the specific pointer data type & data type size; ...
* (b) SHOULD NOT & in some cases MUST NOT be cast to other data types or data type sizes.
*
* (7) RFC #793, Section 3.7 'Data Communication : Managing the Window' states that "the window
* sent in each segment indicates the range of sequence numbers the sender of the window
* (the data receiver) is currently prepared to accept. There is an assumption that this
* is related to the currently available data buffer space available for this connection
* ... One strategy would be to ... [update the] information when the window is larger".
*
* See also 'NetTCP_RxPktConnHandlerRxQ_Sync() Note #5',
* 'NetTCP_RxPktConnHandlerRxQ_Conn() Note #6',
* & 'NetTCP_RxConnWinSizeHandler() Note #2a'.
*
* (8) (a) #### Since segments enqueued to a TCP connection's application receive queue have
* already been acknowledged to the remote host & since no mechanism exists for a TCP
* connection to re-request previously acknowledged segments, any TCP connection whose
* application receive queue becomes corrupted MUST be closed to prevent the application
* layer from receiving the corrupted data.
*
* (b) For any internal errors where the TCP connection's application receive queue is NOT
* corrupted, the TCP connection is NOT closed. Thus, the application layer may try to
* re-receive the application data.
*
* However, a TCP connection may deadlock due to persistant internal errors -- i.e. the
* internal errors prevent the TCP connection from deframing application data from the
* application receive queue which also prevents the TCP connection from receiving
* additional application data (see Note ####). Thus, exception handling code in the
* application layer SHOULD eventually detect & close any TCP connection deadlocked due
* to internal errors.
*********************************************************************************************************
*/
/*$PAGE*/
CPU_INT16U NetTCP_RxAppData (NET_TCP_CONN_ID conn_id_tcp,
void *pdata_buf,
CPU_INT16U data_buf_len,
CPU_INT16U flags,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
CPU_INT16U seg_len_close;
NET_TCP_SEQ_NBR seq_nbr_cur;
#endif
CPU_BOOLEAN block;
CPU_BOOLEAN conn_closed;
CPU_BOOLEAN q_prevly_empty;
CPU_BOOLEAN peek;
CPU_BOOLEAN frag_adv;
NET_TCP_CONN *pconn;
NET_BUF *pbuf_head;
NET_BUF *pbuf_seg;
NET_BUF *pbuf_seg_prev;
NET_BUF *pbuf_seg_next;
NET_BUF *pbuf_frag;
NET_BUF *pbuf_frag_next;
NET_BUF_HDR *pbuf_seg_hdr;
NET_BUF_HDR *pbuf_seg_prev_hdr;
NET_BUF_HDR *pbuf_seg_next_hdr;
NET_BUF_HDR *pbuf_frag_hdr;
NET_BUF_SIZE seg_len_avail;
NET_BUF_SIZE data_ix_frag;
NET_BUF_SIZE data_ix_pkt;
NET_BUF_SIZE data_len_pkt;
CPU_INT16U data_len_buf_rem;
CPU_INT16U data_len_tot;
CPU_INT16U seg_len_data;
CPU_INT16U seg_len_data_rem;
CPU_INT16U seg_len_data_tot;
CPU_INT16U seg_len_sync;
CPU_INT16U seg_len_sync_init;
CPU_INT08U *p_data;
NET_TCP_SEQ_NBR seq_nbr_init;
NET_TCP_SEQ_NBR seq_nbr_ix;
NET_ERR err;
/*$PAGE*/
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* -------------- VALIDATE TCP CONN USED -------------- */
(void)NetTCP_ConnIsUsed(conn_id_tcp, perr);
if (*perr != NET_TCP_ERR_NONE) {
return (0);
}
#endif
/* ---------------- VALIDATE TCP CONN ----------------- */
pconn = &NetTCP_ConnTbl[conn_id_tcp];
conn_closed = DEF_NO;
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return (0); /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED: /* See Note #3a. */
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return (0); /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_LISTEN: /* See Note #3b. */
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_CONN: /* See Note #3c. */
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
break;
case NET_TCP_CONN_STATE_CLOSE_WAIT: /* See Note #3d. */
case NET_TCP_CONN_STATE_CLOSING: /* See Note #3e. */
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL: /* See Note #3e3. */
if (pconn->RxQ_State == NET_TCP_RX_Q_STATE_CONN_CLOSED) {
conn_closed = DEF_YES;
}
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return (0); /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ------------ WAIT ON TCP CONN APP RX Q ------------- */
if (pconn->RxQ_App_Head == (NET_BUF *)0) { /* If no rx'd data pkts; ... */
if (conn_closed != DEF_NO) { /* ... & conn closed (see Note #3e3), ... */
if (pconn->ConnState == NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL) {
/* ... close TCP conn (see Note #3e3A) ... */
NetTCP_ConnCloseHandler(pconn, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
}
*perr = NET_TCP_ERR_RX_Q_CLOSED; /* ... & rtn rx Q closed err (see Note #3e3B); ... */
return (0);
}
block = DEF_BIT_IS_SET(flags, NET_TCP_FLAG_RX_BLOCK);
if (block != DEF_YES) { /* ... & non-blocking rx ... */
*perr = NET_TCP_ERR_RX_Q_EMPTY; /* ... rtn rx Q empty err. */
return (0);
}
NetOS_Unlock();
NetOS_TCP_RxQ_Wait(conn_id_tcp, perr);
NetOS_Lock(&err);
if ( err != NET_OS_ERR_NONE) {
*perr = err; /* Rtn err from NetOS_Lock(). */
return (0);
}
if (*perr != NET_TCP_ERR_NONE) {
return (0); /* Rtn err from NetOS_TCP_RxQ_Wait(). */
}
if (pconn->RxQ_App_Head == (NET_BUF *)0) { /* If still NO rx'd data pkts, ... */
*perr = NET_TCP_ERR_RX_Q_EMPTY; /* ... rtn rx Q empty err. */
return (0);
}
q_prevly_empty = DEF_YES;
} else {
NetOS_TCP_RxQ_Clr(conn_id_tcp, &err); /* Clr any possible async rx Q signal. */
q_prevly_empty = DEF_NO;
}
/*$PAGE*/
/* ----------- DEFRAME TCP CONN RX APP DATA ----------- */
pbuf_head = (NET_BUF *) pconn->RxQ_App_Head;
pbuf_seg = (NET_BUF *) pbuf_head;
pbuf_seg_prev = (NET_BUF *) 0;
p_data = (CPU_INT08U *) pdata_buf;
data_len_buf_rem = (CPU_INT16U ) data_buf_len;
data_len_tot = (CPU_INT16U ) 0;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
pbuf_seg_hdr = (NET_BUF_HDR *)&pbuf_seg->Hdr;
seq_nbr_cur = (NET_TCP_SEQ_NBR) pbuf_seg_hdr->TCP_SeqNbr;
#endif
while ((pbuf_seg != (NET_BUF *)0) && /* Copy app rx data from TCP conn q'd seg(s). */
(data_len_buf_rem > 0)) {
pbuf_seg_hdr = (NET_BUF_HDR *)&pbuf_seg->Hdr;
pbuf_seg_next = (NET_BUF *) pbuf_seg_hdr->NextPrimListPtr;
pbuf_frag = (NET_BUF *) pbuf_seg;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (seq_nbr_cur != pbuf_seg_hdr->TCP_SeqNbr) { /* If next q'd seg's seq nbr NOT consecutive, ... */
/* ... close TCP conn (see Note #8a). */
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_DATA_INVALID;
return (0);
}
#endif
/* Init seg lens. */
seg_len_data = pbuf_seg_hdr->TCP_SegLenData;
seg_len_data_rem = seg_len_data;
seg_len_data_tot = 0;
seg_len_sync = 0;
seg_len_sync_init = 0;
if (pbuf_seg_hdr->TCP_SegSync == DEF_YES) {
seg_len_sync = NET_TCP_SEG_LEN_SYNC;
}
/* If still init seg len, cfg init sync seg len. */
if (pbuf_seg_hdr->TCP_SegLen == pbuf_seg_hdr->TCP_SegLenInit) {
seg_len_sync_init = seg_len_sync;
}
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
seg_len_close = 0;
if (pbuf_seg_hdr->TCP_SegClose == DEF_YES) {
seg_len_close = NET_TCP_SEG_LEN_CLOSE;
}
#endif
/* Calc start seq nbr ix into seg data (see Note #4b1). */
seq_nbr_init = (NET_TCP_SEQ_NBR)(pbuf_seg_hdr->TCP_SeqNbrInit + seg_len_sync - seg_len_sync_init);
seq_nbr_ix = (NET_TCP_SEQ_NBR)(pbuf_seg_hdr->TCP_SeqNbr - seq_nbr_init);
data_ix_frag = (NET_BUF_SIZE ) seq_nbr_ix;
frag_adv = DEF_YES;
while ((pbuf_frag != (NET_BUF *)0) &&
(frag_adv == DEF_YES)) {
pbuf_frag_hdr = (NET_BUF_HDR *)&pbuf_frag->Hdr;
/* While seg's frag data ix >= cur frag data len ... */
if (data_ix_frag >= (NET_BUF_SIZE)pbuf_frag_hdr->DataLen) {
data_ix_frag -= (NET_BUF_SIZE)pbuf_frag_hdr->DataLen;
pbuf_frag_next = (NET_BUF *)pbuf_frag_hdr->NextBufPtr;
pbuf_frag = (NET_BUF *)pbuf_frag_next; /* ... adv to next seg frag. */
} else {
frag_adv = DEF_NO;
}
}
/*$PAGE*/
while ((pbuf_frag != (NET_BUF *)0) && /* Copy app rx data from avail seg pkt buf(s). */
(data_len_buf_rem > 0) &&
(seg_len_data_rem > 0)) {
pbuf_frag_hdr = (NET_BUF_HDR *)&pbuf_frag->Hdr;
pbuf_frag_next = (NET_BUF *) pbuf_frag_hdr->NextBufPtr;
seg_len_avail = pbuf_frag_hdr->DataLen - data_ix_frag;
if (seg_len_avail > (NET_BUF_SIZE)seg_len_data_rem) { /* If seg frag pkt data len > rem seg len, ... */
seg_len_avail = (NET_BUF_SIZE)seg_len_data_rem; /* ... limit copy to rem seg len. */
}
if (data_len_buf_rem > seg_len_avail) { /* If rem data buf len > seg frag pkt data len, ... */
data_len_pkt = (NET_BUF_SIZE)seg_len_avail; /* ... copy all pkt buf data len. */
} else {
data_len_pkt = (NET_BUF_SIZE)data_len_buf_rem; /* Else limit copy to rem data buf len. */
}
/* Calc ix into seg frag's data. */
data_ix_pkt = (NET_BUF_SIZE)pbuf_frag_hdr->DataIx + data_ix_frag;
data_ix_frag = 0;
NetBuf_DataRd((NET_BUF *) pbuf_frag,
(NET_BUF_SIZE) data_ix_pkt,
(NET_BUF_SIZE) data_len_pkt,
(CPU_INT08U *) p_data,
(NET_ERR *)&err);
if ( err != NET_BUF_ERR_NONE) { /* See Note #7b. */
*perr = NET_TCP_ERR_CONN_FAIL;
return (0);
}
/* Update data ptr & lens. */
p_data += data_len_pkt; /* MUST NOT cast ptr operand (see Note #6b). */
data_len_tot += (CPU_INT16U)data_len_pkt;
data_len_buf_rem -= (CPU_INT16U)data_len_pkt;
seg_len_data_tot += (CPU_INT16U)data_len_pkt;
seg_len_data_rem -= (CPU_INT16U)data_len_pkt;
pbuf_frag = pbuf_frag_next;
}
if (data_len_buf_rem > 0) { /* If rem data buf len > 0, adv to next q'd seg. */
pbuf_seg_prev = pbuf_seg;
pbuf_seg = pbuf_seg_next;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (seg_len_data_tot != seg_len_data) { /* If calc'd seg data len != actual seg data len, ... */
/* ... close TCP conn (see Note #8a). */
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_DATA_INVALID;
return (0);
}
/* Adv seq nbr by cur seg's : ... */
seq_nbr_cur += (NET_TCP_SEQ_NBR)seg_len_sync_init; /* ... init sync seg len (see Note #4b2A1), ... */
seq_nbr_cur += (NET_TCP_SEQ_NBR)seg_len_data; /* ... data seg len (see Note #4b2A2), ... */
seq_nbr_cur += (NET_TCP_SEQ_NBR)seg_len_close; /* ... & close seg len (see Note #4b2A3). */
#endif
}
}
/*$PAGE*/
/* ----------- UPDATE TCP CONN APP RX Q ----------- */
peek = DEF_BIT_IS_SET(flags, NET_TCP_FLAG_RX_DATA_PEEK);
if (peek == DEF_YES) { /* If peek opt req'd ... */
if (q_prevly_empty == DEF_YES) { /* ... & TCP conn app rx Q prev'ly empty, ... */
NetOS_TCP_RxQ_Signal(conn_id_tcp, &err); /* ... signal app rx Q ... */
/* ... to negate non-consuming peek (see Note #5b). */
if (err != NET_TCP_ERR_NONE) { /* If app rx Q signal failed, ... */
peek = DEF_NO; /* ... consume pkt buf(s). */
}
}
}
if (peek != DEF_YES) { /* If peek opt NOT req'd, unlink ALL seg pkt buf(s) */
/* .. whose data was entirely consumed. */
if (pbuf_seg != (NET_BUF *)0) { /* If TCP conn app rx Q NOT empty after data rd(s) */
if (seg_len_data_rem > 0) { /* .. & cur seg's rem data len > 0; .. */
pbuf_seg_hdr->PrevPrimListPtr = (void *)0; /* .. unlink from prev q'd seg(s), .. */
pconn->RxQ_App_Head = (NET_BUF *)pbuf_seg;/* .. set new TCP conn app rx Q head, .. */
/* .. & update seg's seq nbr (see Note #4b2B1) .. */
pbuf_seg_hdr->TCP_SeqNbr += (CPU_INT32U)(seg_len_data_tot + seg_len_sync_init);
/* .. & seg's seg lens (see Note #4b2B2). */
pbuf_seg_hdr->TCP_SegLen -= (CPU_INT16U)(seg_len_data_tot + seg_len_sync_init);
pbuf_seg_hdr->TCP_SegLenData -= (CPU_INT16U) seg_len_data_tot;
if (pbuf_seg_prev != (NET_BUF *)0) { /* If prev q'd seg(s) avail, ... */
pbuf_seg_prev_hdr = &pbuf_seg_prev->Hdr;
pbuf_seg_prev_hdr->NextPrimListPtr = (void *)0; /* ... unlink from app rx Q ... */
NetTCP_RxPktFree(pbuf_head); /* ... & free ALL rd seg pkt buf(s). */
}
} else { /* Else if cur seg's rem data len = 0 ... */
if (pbuf_seg_next != (NET_BUF *)0) { /* ... & rem rx q'd seg(s) avail, ... */
/* ... unlink cur seg from rem q'd seg(s) ... */
pbuf_seg_next_hdr = &pbuf_seg_next->Hdr;
pbuf_seg_next_hdr->PrevPrimListPtr = (void *)0;
pbuf_seg_hdr->NextPrimListPtr = (void *)0;
/* ... set new TCP conn app rx Q head; ... */
pconn->RxQ_App_Head = (NET_BUF *)pbuf_seg_next;
} else { /* ... & NO rem rx q'd seg(s) avail, ... */
/* ... unlink ALL q'd seg(s); ... */
pconn->RxQ_App_Head = (NET_BUF *)0;
pconn->RxQ_App_Tail = (NET_BUF *)0;
}
NetTCP_RxPktFree(pbuf_head); /* ... & free rd seg pkt buf(s) from app rx Q. */
}
} else { /* Else clr app rx Q ... */
pconn->RxQ_App_Head = (NET_BUF *)0;
pconn->RxQ_App_Tail = (NET_BUF *)0;
NetTCP_RxPktFree(pbuf_head); /* ... & free ALL seg pkt buf(s) from app rx Q. */
}
/* --------- UPDATE TCP CONN RX WIN SIZE ---------- */
/* Inc TCP conn's rx win size (see Note #7). */
NetTCP_RxConnWinSizeHandler((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(NET_TCP_WIN_SIZE)data_len_tot,
(NET_TCP_WIN_CODE)NET_TCP_CONN_RX_WIN_INC);
}
*perr = NET_TCP_ERR_NONE;
return (data_len_tot);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnReq()
*
* Description : (1) Transmit TCP connection request :
*
* (a) Configure TCP connections' IP parameters
* (b) Transmit TCP connection request
* (c) Update TCP connection state
*
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to transmit connection request.
*
* TOS Specific TOS to transmit TCP/IP packet
* (see 'net_ip.h IP HEADER TYPE OF SERVICE (TOS) DEFINES').
*
* TTL Specific TTL to transmit TCP/IP packet (see RFC #1122, Section 3.2.1.7) :
*
* NET_IP_HDR_TTL_MIN 1 minimum TTL transmit value
* NET_IP_HDR_TTL_MAX 255 maximum TTL transmit value
* NET_IP_HDR_TTL_DFLT default TTL transmit value
* NET_IP_HDR_TTL_NONE 0 replace with default TTL
*
* flags_ip Flags to select IP transmit options; bit-field flags logically OR'd :
*
* NET_IP_FLAG_NONE No IP transmit flags selected.
* NET_IP_FLAG_TX_DONT_FRAG Set IP 'Don't Frag' flag.
*
* popts_ip Pointer to one or more IP options configuration data structures :
*
* NULL NO IP transmit options configuration.
* NET_IP_OPT_CFG_ROUTE_TS Route &/or Internet Timestamp options
* configuration.
* NET_IP_OPT_CFG_SECURITY Security options configuration
* (see 'net_ip.c Note #1f').
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* ---- RETURNED BY NetTCP_ConnIsUsed() : -----
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_INVALID_CONN Invalid TCP connection number.
*
* ---- RETURNED BY NetTCP_TxConnSync() : -----
* NET_TCP_ERR_NONE TCP connection request successfully
* transmitted.
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
* NET_TCP_ERR_TX TCP transmit error.
* NET_ERR_TX Transmit error.
*
* Return(s) : none.
*
* Caller(s) : NetSock_ConnHandlerStream().
*
* This function is an INTERNAL network protocol suite function & SHOULD NOT be called by
* application function(s).
*
* Note(s) : (2) NetTCP_TxConnReq() blocked until network initialization completes.
*
* See 'NetTCP_ConnIsUsed() Note #1'.
*
* (3) On ANY errors, return error to TCP connection caller & allow caller to retry or close
* connection(s) but do NOT close TCP connection.
*
* (4) #### IP options currently NOT implemented.
*********************************************************************************************************
*/
/*$PAGE*/
void NetTCP_TxConnReq (NET_TCP_CONN_ID conn_id_tcp,
NET_IP_TOS TOS,
NET_IP_TTL TTL,
CPU_INT16U flags_ip,
void *popts_ip,
NET_ERR *perr)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* -------------- VALIDATE TCP CONN USED -------------- */
(void)NetTCP_ConnIsUsed(conn_id_tcp, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
#endif
pconn = &NetTCP_ConnTbl[conn_id_tcp];
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ------------- VALIDATE TCP CONN STATE -------------- */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
break;
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_CONN_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
/* -------------- CFG TCP CONN IP PARAMS -------------- */
pconn->TxIP_TOS = TOS;
pconn->TxIP_TTL = TTL;
pconn->TxIP_Flags = flags_ip;
(void)&popts_ip; /* Prevent compiler warning (see Note #4). */
/* ----------------- TX TCP CONN REQ ------------------ */
NetTCP_TxConnSync((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(NET_ERR *)perr);
if (*perr != NET_TCP_ERR_NONE) { /* See Note #3. */
return;
}
/* -------------- UPDATE TCP CONN STATE --------------- */
pconn->ConnState = NET_TCP_CONN_STATE_SYNC_TXD;
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnAppData()
*
* Description : (1) Prepare & transmit data from Application layer(s) via TCP connection :
*
* (a) Validate application data
*
* (b) Transmit application data via TCP Transmit :
* (1) Validate TCP connection
* (2) Wait on TCP connection transmit queue
* (3) Prepare TCP data segment(s) :
* (A) TCP segment addresses
* (B) Prepare application data :
* (1) Get buffer(s) for application data
* (2) Copy application data into TCP packet buffer(s)
* (3) Update TCP segment data controls
* (4) Update application data controls
* (4) Update TCP connection transmit window
*
* (c) Update TCP connection :
* (1) Append TCP transmit segment(s) to TCP connection transmit queue
* (2) Update TCP connection sequence number(s)
*
* (d) Transmit TCP data segment(s) via TCP Transmit
*
*
* Argument(s) : conn_id_tcp Handle identifier of connection to transmit application data.
*
* p_data Pointer to application data.
* ------ Argument validated in NetSock_TxDataHandlerStream().
*
* data_len Length of application data (in octets) [see Note #5].
* -------- Argument validated in NetSock_TxDataHandlerStream().
*
* flags Flags to select transmit options; bit-field flags logically OR'd :
* -----
* NET_TCP_FLAG_NONE No TCP transmit flags selected.
* NET_TCP_FLAG_TX_BLOCK Transmit TCP application data with blocking,
* if flag set; without blocking, if clear.
*
* Argument validated in NetSock_TxDataHandlerStream().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE Application data successfully prepared &
* transmitted via TCP layer.
* NET_TCP_ERR_NULL_PTR Argument 'p_data' passed a NULL pointer.
* NET_TCP_ERR_INVALID_DATA_SIZE Argument 'data_len' passed an invalid size.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_CONN_DATA_INVALID TCP connection application transmit queue contains
* invalid or improperly sequenced data.
* NET_TCP_ERR_TX_Q_FULL TCP connection transmit queue full.
* NET_TCP_ERR_TX_Q_SUSPEND TCP connection transmit queue temporarily suspended.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
*
* -------- RETURNED BY NetTCP_ConnIsUsed() : ---------
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_INVALID_CONN Invalid TCP connection number.
*
* -------- RETURNED BY NetOS_TCP_TxQ_Wait() : --------
* NET_TCP_ERR_TX_Q_SIGNAL_ABORT TCP connection transmit queue signal aborted;
* TCP connection closed/aborted.
* NET_TCP_ERR_TX_Q_SIGNAL_FAULT TCP connection transmit queue signal fault.
*
* --------- RETURNED BY NetTCP_TxConnTxQ() : ---------
* NET_TCP_ERR_CONN_CLOSE TCP connection closed.
* NET_TCP_ERR_CONN_ACK_NONE TCP connection acknowledgement NOT requested.
* NET_TCP_ERR_CONN_ACK_DLYD TCP connection acknowledgement transmit delayed.
* NET_TCP_ERR_CONN_ACK_PREVLY_TXD TCP connection acknowledgement previously
* transmitted for segment.
* NET_TCP_ERR_CONN_ACK_INVALID TCP connection acknowledgement NOT valid for
* current TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
*
* NET_TCP_ERR_TX TCP transmit error.
* NET_ERR_TX Transmit error.
*
* ------------ RETURNED BY NetOS_Lock() : ------------
* NET_OS_ERR_LOCK Network access NOT acquired.
*
* Return(s) : Number of data octets transmitted, if NO errors.
*
* 0, otherwise.
*
* Caller(s) : NetSock_TxDataHandlerStream().
*
* This function is an INTERNAL network protocol suite function & SHOULD NOT be called by
* application function(s).
*$PAGE*
* Note(s) : (2) NetTCP_TxConnAppData() blocked until network initialization completes.
*
* See 'NetTCP_ConnIsUsed() Note #1'.
*
* (3) RFC #793, Section 3.9 'Event Processing : SEND Call' specifies how to handle transmit
* data requests from the application layer :
*
* (a) For the "CLOSED STATE ... return 'error: connection does not exist'".
*
* (b) For the "LISTEN STATE" ...
*
* (1) "If the foreign socket is specified, then" ...
*
* (A) "Change the connection from passive to active," ...
* (B) "select an ISS" ...
* (C) "Send a SYN segment," ...
* (D) "Set" ...
* (1) "SND.UNA to ISS," ...
* (2) "SND.NXT to ISS+1."
* (E) "Enter SYN-SENT state."
* (F) "Data associated with SEND may be" ...
* (1) "sent with SYN segment" ...
* (2) (a) "or queued for transmission after entering ESTABLISHED state."
* (b) "If there is no room to queue the request, respond with 'error:
* insufficient resources'."
*
* (2) "If Foreign [sic] socket was not specified, then return 'error: foreign socket
* unspecified'."
*
* (A) #### NOT yet implemented; see also
* 'net_sock.c NetSock_TxDataHandlerStream() Note #2aA'.
*
* (c) For the "SYN-SENT STATE, SYN-RECEIVED STATE" ...
*
* (1) "Queue the data for transmission after entering ESTABLISHED state."
* (2) "If no space to queue, respond with 'error: insufficient resources'."
*
* (d) For the "ESTABLISHED STATE, CLOSE-WAIT STATE" ...
*
* (1) (A) "Segmentize the buffer" ...
* (B) "and send it with a piggybacked ackknowledgment" ...
* (1) "(acknowledgment value = RCV.NXT)"
* (2) "If there is no insufficient space to remember this buffer, simply return
* 'error: insufficient resources'."
*
* (e) For the "FIN-WAIT-1 STATE, FIN-WAIT-2 STATE, CLOSING STATE, LAST-ACK STATE,
* TIME-WAIT STATE" ...
*
* (1) "return 'error: connection closing'" ...
* (2) "and do not service request."
*$PAGE*
* (4) TCP segments with transmit data are sequenced into the TCP connection's transmit
* queue to await transmission at the appropriate time(s) [see 'NetTCP_TxConnTxQ()
* Note #1b'].
*
* (a) Transmit TCP segments are inserted into a doubly-linked Transmit Queue, ordered
* consecutively by sequence number(s) [see also Note #4b].
*
* (1) 'TxQ_Head' points to the head of the Transmit Queue;
* 'TxQ_Tail' points to the tail of the Transmit Queue.
*
* (2) Segment buffers' 'PrevPrimListPtr' & 'NextPrimListPtr' doubly-link each
* segment to form the Transmit Queue.
*
* (b) Transmit data is packetized into TCP segments in sequence-order. Therefore, new
* transmit segments are sequenced after previously packetized segments starting at
* the tail of the Transmit Queue.
*
* (c) Segments at the head of the Transmit Queue are available & ready to be transmitted
* via the Internet Transmit Layer.
*
*
* | |
* |<------- TCP Connection Transmit Queue ------->|
* | (see Note #4) |
*
* Segments Ready Segments Sequenced
* to Transmit into Transmit Queue
* start at head starting at tail
* (see Note #4c) (see Note #4b)
*
* | NextPrimListPtr |
* | (see Note #4a2) |
* v | v
* |
* Head of ------- ------- v ------- ------- (see Note #4a1)
* Transmit ---->| |------>| |------>| |------>| |
* Queue | | | | | | | | Tail of
* | |<------| |<------| |<------| |<---- Transmit
* (see Note #4a1) | | | | ^ | | | | Queue
* | | | | | | | | |
* ------- ------- | ------- -------
* |
* PrevPrimListPtr
* (see Note #4a2)
*
*$PAGE*
* (5) 'data_len' of 0 octets NOT allowed.
*
* (6) Certain network connections MUST periodically suspend network transmit(s) to handle
* network receive packet(s). To protect TCP connections from transmit corruption while
* suspended, ALL TCP data transmits & TCP transmit queue handling MUST be blocked for
* suspended connections until the connection is no longer suspended.
*
* See also 'NetTCP_TxConnTxQ() Note #10b2A2'.
*
* (7) (a) RFC #793, Section 3.8 'Interfaces : User/TCP Interface : TCP User Commands : Send'
* states that :
*
* (1) "If the PUSH flag is set, the data must be transmitted promptly to the receiver,
* and the PUSH bit will be set in the last TCP segment created from the buffer."
*
* (2) "If the PUSH flag is not set, the data may be combined with data from subsequent
* SENDs for transmission efficiency."
*
* (b) RFC #1122, Section 4.2.2.2 states that :
*
* (1) "When an application issues a series of SEND calls without setting the PUSH
* flag, the TCP MAY aggregate the data internally without sending it."
*
* (2) "The PSH bit is not a record marker and is independent of segment boundaries.
* The transmitter SHOULD collapse successive PSH bits when it packetizes data,
* to send the largest possible segment.
*
* (3) (A) "A TCP MAY implement PUSH flags on SEND calls."
*
* (B) (1) "If PUSH flags are not implemented, then the sending TCP: ...
*
* (a) must not buffer data indefinitely, and ...
* (b) MUST set the PSH bit in the last buffered segment (i.e., when
* there is no more queued data to be sent)."
*
* (1) However, NO RFC specifies whether the PUSH bit should be
* set ONLY in the last buffered segment. Therefore, is is
* assumed that the PUSH bit MAY be set in the last buffered
* segment of each call to SEND.
*
* (2) "When the PUSH flag is not implemented on SEND calls, i.e., when
* the application/TCP interface uses a pure streaming model,
* responsibility for aggregating any tiny data fragments to form
* reasonable sized segments is partially borne by the application
* layer."
*
* (4) (A) "An application program is logically required to set the PUSH flag in a
* SEND call whenever it needs to force delivery of the data to avoid a
* communication deadlock. However, a TCP SHOULD send a maximum-sized
* segment whenever possible, to improve performance."
*
* (B) "Generally, an interactive application protocol must set the PUSH flag
* at least in the last SEND call in each command or response sequence."
*
* (8) Since pointer arithmetic is based on the specific pointer data type & inherent pointer
* data type size, pointer arithmetic operands :
*
* (a) MUST be in terms of the specific pointer data type & data type size; ...
* (b) SHOULD NOT & in some cases MUST NOT be cast to other data types or data type sizes.
*
* (9) Network buffers allocated for TCP connection transmit SHOULD be fully used even if
* the TCP connection's configured transmit window is zero.
*
* See also 'NetTCP_TxConnWinSizeHandlerCfgd() Note #2'.
*
* (10) (a) Since segments enqueued to a TCP connection's transmit queue have already been
* reported as transmitted to the application & since no mechanism exists for a TCP
* connection to re-request previously transmitted data, any TCP connection whose
* transmit queue becomes corrupted MUST be closed to force the application layer to
* abort &/or recover from the corrupted data.
*
* (b) For any internal errors where the TCP connection's transmit queue is NOT corrupted,
* the TCP connection is NOT closed. Thus, the application layer may try to re-transmit
* the application data.
*
* (c) On ANY transmit error, any remaining application data transmit is immediately aborted.
*
* See also 'NetTCP_TxConnTxQ() Note #12'.
* & 'NetTCP_TxConnReTxQ() Note #11'.
*********************************************************************************************************
*/
/*$PAGE*/
CPU_INT16U NetTCP_TxConnAppData (NET_TCP_CONN_ID conn_id_tcp,
void *p_data,
CPU_INT16U data_len,
CPU_INT16U flags,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
NET_IP_ADDR src_addr;
NET_IP_ADDR dest_addr;
NET_TCP_PORT_NBR src_port;
NET_TCP_PORT_NBR dest_port;
NET_BUF *pbuf;
NET_BUF *pbuf_head;
NET_BUF *pbuf_tail;
NET_BUF *pbuf_q_tail;
NET_BUF_HDR *pbuf_hdr;
NET_BUF_HDR *pbuf_hdr_head;
NET_BUF_HDR *pbuf_hdr_tail;
NET_BUF_HDR *pbuf_hdr_q_tail;
NET_BUF_SIZE buf_size_max;
NET_BUF_SIZE buf_size_max_data;
NET_BUF_SIZE buf_size_max_tail;
NET_BUF_SIZE buf_size_max_tail_data;
NET_BUF_SIZE data_ix_pkt;
NET_BUF_SIZE data_ix_pkt_tail;
NET_BUF_SIZE data_len_pkt_tail;
NET_BUF_SIZE data_len_pkt_rem;
NET_BUF_SIZE data_len_pkt;
NET_BUF_SIZE data_len_mss;
CPU_INT16U data_len_rem;
CPU_INT16U data_len_tot;
CPU_INT16U flags_tcp;
CPU_INT08U *p_data_pkt;
CPU_BOOLEAN tx_q_append;
CPU_BOOLEAN tx_data;
CPU_BOOLEAN tx_err;
CPU_BOOLEAN block;
NET_TCP_SEQ_NBR seq_nbr;
NET_ERR err;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
/* ---------------- VALIDATE APP DATA ----------------- */
if (p_data == (void *)0) {
*perr = NET_TCP_ERR_NULL_PTR;
return (0);
}
if (data_len < 1) { /* Validate data len (see Note #5). */
NET_CTR_ERR_INC(NetTCP_ErrTxInvalidSizeCtr);
*perr = NET_TCP_ERR_INVALID_DATA_SIZE;
return (0);
}
/* -------------- VALIDATE TCP CONN USED -------------- */
(void)NetTCP_ConnIsUsed(conn_id_tcp, perr);
if (*perr != NET_TCP_ERR_NONE) {
return (0);
}
#endif
/*$PAGE*/
/* ---------------- VALIDATE TCP CONN ----------------- */
pconn = &NetTCP_ConnTbl[conn_id_tcp];
switch (pconn->ConnState) { /* Validate conn state. */
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return (0); /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED: /* See Note #3a. */
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return (0); /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_LISTEN: /* See Note #3b. */
/* #### NOT yet implemented (see Note #3bA). */
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return (0); /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_SYNC_RXD: /* See Note #3c. */
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
tx_data = DEF_NO;
break;
case NET_TCP_CONN_STATE_CONN: /* See Note #3d. */
case NET_TCP_CONN_STATE_CLOSE_WAIT:
tx_data = DEF_YES;
break;
case NET_TCP_CONN_STATE_FIN_WAIT_1: /* See Note #3e. */
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return (0); /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return (0); /* Prevent 'break NOT reachable' compiler warning. */
}
switch (pconn->TxQ_State) { /* Validate tx Q state. */
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
break;
case NET_TCP_TX_Q_STATE_CONN_SUSPEND: /* See Note #6. */
*perr = NET_TCP_ERR_TX_Q_SUSPEND;
return (0); /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
default:
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return (0); /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* -------------- WAIT ON TCP CONN TX Q --------------- */
if (tx_data == DEF_YES) { /* If tx rdy, ... */
if (data_len < 1) { /* ... but NO tx data avail, ... */
/* ... tx q'd data OR immed ack; ... */
NetTCP_TxConnTxQ((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(NET_TCP_ACK_CODE )NET_TCP_CONN_TX_ACK_IMMED,
(CPU_BOOLEAN )DEF_NO,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL,
(NET_ERR *)perr);
return (0);
}
/* ... Else if tx data avail, ... */
if (pconn->TxWinSizeCfgdRem < 1) { /* ... but tx Q full ... */
block = DEF_BIT_IS_SET(flags, NET_TCP_FLAG_TX_BLOCK);
if (block != DEF_YES) { /* ... & non-blocking tx, ... */
*perr = NET_TCP_ERR_TX_Q_FULL; /* ... rtn tx Q full err. */
return (0);
}
NetOS_Unlock();
NetOS_TCP_TxQ_Wait(conn_id_tcp, perr);
NetOS_Lock(&err);
if ( err != NET_OS_ERR_NONE) {
*perr = err; /* Rtn err from NetOS_Lock(). */
return (0);
}
if (*perr != NET_TCP_ERR_NONE) {
return (0); /* Rtn err from NetOS_TCP_TxQ_Wait(). */
}
if (pconn->TxWinSizeCfgdRem < 1) { /* If tx Q still full, ... */
*perr = NET_TCP_ERR_TX_Q_FULL; /* ... rtn tx Q full err. */
return (0);
}
} else {
NetOS_TCP_TxQ_Clr(conn_id_tcp, &err); /* Clr any possible async tx Q signal. */
}
}
/* ------- PREPARE APP TX DATA INTO TCP SEG(S) -------- */
/* Prepare seg addrs. */
NetTCP_TxConnPrepareSegAddrs((NET_TCP_CONN *) pconn,
(CPU_INT08U *)&src_port,
(CPU_INT08U *)&src_addr,
(CPU_INT16U ) sizeof(src_port),
(CPU_INT16U ) sizeof(src_addr),
(CPU_INT08U *)&dest_port,
(CPU_INT08U *)&dest_addr,
(CPU_INT16U ) sizeof(dest_port),
(CPU_INT16U ) sizeof(dest_addr),
(NET_ERR *)&err);
if ( err != NET_TCP_ERR_NONE) {
*perr = NET_TCP_ERR_CONN_FAULT;
return (0);
}
/*$PAGE*/
pbuf_head = (NET_BUF *)0;
pbuf_tail = (NET_BUF *)0;
p_data_pkt = (CPU_INT08U *)p_data;
tx_q_append = (CPU_BOOLEAN )DEF_YES;
data_len_mss = (NET_BUF_SIZE)pconn->MaxSegSizeConn;
data_len_rem = (CPU_INT16U )data_len;
data_len_tot = (CPU_INT16U )0;
/* Prepare TCP tx seg hdr ctrls. */
seq_nbr = pconn->TxSeqNbrNextQ;
flags_tcp = NET_TCP_FLAG_NONE |
NET_TCP_FLAG_TX_ACK;
if (pconn->TxQ_Tail != (NET_BUF *)0) { /* If tx Q NOT empty; ... */
pbuf = pconn->TxQ_Tail;
pbuf_hdr = &pbuf->Hdr;
data_ix_pkt_tail = (NET_BUF_SIZE)pbuf_hdr->DataIx;
data_len_pkt_tail = (NET_BUF_SIZE)pbuf_hdr->TCP_SegLenData;
/* ... calc tail seg's max data size, ... */
buf_size_max_tail = NetBuf_GetMaxSize(pbuf, data_ix_pkt_tail);
buf_size_max_tail_data = DEF_MIN(buf_size_max_tail, data_len_mss);
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (data_len_pkt_tail > buf_size_max_tail_data) { /* If seg len > max data size, tx Q data seg invalid; */
/* ... close TCP conn (see Note #10a). */
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_DATA_INVALID;
return (0);
}
#endif
if (data_len_pkt_tail < buf_size_max_tail_data) { /* ... & if avail data space on tx Q's tail seg, ... */
/* ... append data on tx Q tail seg (see Note #7b1). */
data_ix_pkt = data_ix_pkt_tail + data_len_pkt_tail;
data_len_pkt_rem = buf_size_max_tail_data - data_len_pkt_tail;
if (data_len_rem > (NET_BUF_SIZE)data_len_pkt_rem) {/* If data len rem > pkt data len rem, ... */
data_len_pkt = (NET_BUF_SIZE)data_len_pkt_rem; /* ... limit pkt data len to pkt data len rem. */
} else {
data_len_pkt = (NET_BUF_SIZE)data_len_rem; /* Else limit pkt data len to data len rem. */
}
NetBuf_DataWr((NET_BUF *) pbuf, /* Wr app data into TCP tx buf. */
(NET_BUF_SIZE) data_ix_pkt,
(NET_BUF_SIZE) data_len_pkt,
(CPU_INT08U *) p_data_pkt,
(NET_ERR *)&err);
if ( err != NET_BUF_ERR_NONE) { /* If wr err, tx Q data corrupted; ... */
/* ... close TCP conn (see Note #10a). */
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAULT;
return (0);
}
/* Update TCP seg tx buf ctrls. */
pbuf_hdr->DataLen += (NET_BUF_SIZE)data_len_pkt;
pbuf_hdr->TotLen += (NET_BUF_SIZE)data_len_pkt;
pbuf_hdr->TCP_SegLenInit += (CPU_INT16U )data_len_pkt;
pbuf_hdr->TCP_SegLen += (CPU_INT16U )data_len_pkt;
pbuf_hdr->TCP_SegLenData += (CPU_INT16U )data_len_pkt;
pbuf_head = (NET_BUF *)pbuf; /* Set tx Q tail as first seg onto tx app data chain. */
pbuf_tail = (NET_BUF *)pbuf;
tx_q_append = (CPU_BOOLEAN)DEF_NO;
/* Update data ptr & lens. */
p_data_pkt += data_len_pkt; /* MUST NOT cast ptr operand (see Note #8b). */
data_len_tot += (CPU_INT16U)data_len_pkt;
data_len_rem -= (CPU_INT16U)data_len_pkt;
seq_nbr += (NET_TCP_SEQ_NBR)data_len_pkt;
/* Dec TCP conn's tx win size (see Note #9). */
NetTCP_TxConnWinSizeHandlerCfgd((NET_TCP_CONN *) pconn,
(NET_TCP_WIN_SIZE) data_len_pkt,
(NET_TCP_WIN_CODE) NET_TCP_CONN_TX_WIN_DEC,
(NET_ERR *)&err);
if ( err != NET_TCP_ERR_NONE) {
*perr = NET_TCP_ERR_CONN_FAULT;
return (0);
}
}
}
/*$PAGE*/
/* Calc max data size. */
data_ix_pkt = NET_BUF_DATA_TX_IX;
buf_size_max = NetBuf_GetMaxSize((NET_BUF *)0,
(NET_BUF_SIZE)data_ix_pkt);
buf_size_max_data = DEF_MIN(buf_size_max, data_len_mss);
tx_err = DEF_NO;
while ((data_len_rem > 0) && /* Prepare TCP seg(s) for ALL app data ... */
(pconn->TxWinSizeCfgdRem > 0) && /* ... as net rsrc(s)/err(s) permit. */
(tx_err == DEF_NO)) {
if (data_len_rem > (NET_BUF_SIZE)buf_size_max_data) { /* If data len rem > max data size, ... */
data_len_pkt = (NET_BUF_SIZE)buf_size_max_data; /* ... limit pkt data len to max data size. */
} else {
data_len_pkt = (NET_BUF_SIZE)data_len_rem; /* Else limit pkt data len to data len rem. */
}
pbuf = NetBuf_Get((NET_BUF_SIZE) data_len_pkt, /* Get app data tx buf. */
(NET_BUF_SIZE) data_ix_pkt,
(CPU_INT16U ) NET_BUF_FLAG_NONE,
(NET_ERR *)&err);
if (err != NET_BUF_ERR_NONE) {
tx_err = DEF_YES;
}
if (tx_err == DEF_NO) {
NetBuf_DataWr((NET_BUF *) pbuf, /* Wr app data into TCP tx buf. */
(NET_BUF_SIZE) data_ix_pkt,
(NET_BUF_SIZE) data_len_pkt,
(CPU_INT08U *) p_data_pkt,
(NET_ERR *)&err);
if (err != NET_BUF_ERR_NONE) {
NetTCP_TxPktDiscard(pbuf, &err);
tx_err = DEF_YES;
}
}
if (tx_err == DEF_NO) {
/* Init TCP seg(s) tx buf ctrls. */
pbuf_hdr = &pbuf->Hdr;
pbuf_hdr->DataIx = (CPU_INT16U )data_ix_pkt;
pbuf_hdr->DataLen = (NET_BUF_SIZE)data_len_pkt;
pbuf_hdr->TotLen = (NET_BUF_SIZE)pbuf_hdr->DataLen;
pbuf_hdr->ProtocolHdrType = NET_PROTOCOL_TYPE_APP;
pbuf_hdr->TCP_UDP_PortSrc = (NET_PORT_NBR)src_port;
pbuf_hdr->IP_AddrSrc = (CPU_INT32U )src_addr;
pbuf_hdr->TCP_UDP_PortDest = (NET_PORT_NBR)dest_port;
pbuf_hdr->IP_AddrDest = (CPU_INT32U )dest_addr;
pbuf_hdr->TCP_SegLenInit = (CPU_INT16U )data_len_pkt;
pbuf_hdr->TCP_SegLen = (CPU_INT16U )pbuf_hdr->TCP_SegLenInit;
pbuf_hdr->TCP_SegLenData = (CPU_INT16U )pbuf_hdr->TCP_SegLenInit;
pbuf_hdr->TCP_SegSync = (CPU_BOOLEAN )DEF_NO;
pbuf_hdr->TCP_SegClose = (CPU_BOOLEAN )DEF_NO;
pbuf_hdr->TCP_SegAck = (CPU_BOOLEAN )DEF_YES;
pbuf_hdr->TCP_SegReset = (CPU_BOOLEAN )DEF_NO;
pbuf_hdr->TCP_SeqNbrInit = (CPU_INT32U )seq_nbr;
pbuf_hdr->TCP_SeqNbr = (CPU_INT32U )pbuf_hdr->TCP_SeqNbrInit;
pbuf_hdr->TCP_Flags = (CPU_INT16U )flags_tcp;
if (pbuf_tail != (NET_BUF *)0) { /* If tx app data chain NOT empty, ... */
/* ... append seg(s) @ chain tail. */
pbuf_hdr_tail = (NET_BUF_HDR *)&pbuf_tail->Hdr;
pbuf_hdr_tail->NextPrimListPtr = (void *) pbuf;
pbuf_hdr->PrevPrimListPtr = (void *) pbuf_tail;
pbuf_tail = (NET_BUF *) pbuf;
} else { /* Else add seg as first seg onto tx app data chain. */
pbuf_head = (NET_BUF *) pbuf;
pbuf_tail = (NET_BUF *) pbuf;
}
/* Update data ptr & lens. */
p_data_pkt += data_len_pkt; /* MUST NOT cast ptr operand (see Note #8b). */
data_len_tot += (CPU_INT16U)data_len_pkt;
data_len_rem -= (CPU_INT16U)data_len_pkt;
seq_nbr += (NET_TCP_SEQ_NBR)data_len_pkt;
/* Dec TCP conn's tx win size (see Note #9). */
NetTCP_TxConnWinSizeHandlerCfgd((NET_TCP_CONN *) pconn,
(NET_TCP_WIN_SIZE) data_len_pkt,
(NET_TCP_WIN_CODE) NET_TCP_CONN_TX_WIN_DEC,
(NET_ERR *)&err);
if ( err != NET_TCP_ERR_NONE) {
*perr = NET_TCP_ERR_CONN_FAULT;
return (0);
}
}
}
/*$PAGE*/
if (pbuf_head == (NET_BUF *)0) { /* If NO data seg'd, rtn no rsrc(s) err ... */
*perr = NET_TCP_ERR_NONE_AVAIL; /* ... (see Notes #3b1F2b, #3c2, & #3d2). */
return (0);
}
DEF_BIT_SET(pbuf_hdr->TCP_Flags, NET_TCP_FLAG_TX_PUSH); /* Set PUSH flag in last q'd tx seg (see Note #7b3B1b). */
/* ----------------- UPDATE TCP CONN ------------------ */
if (pconn->TxQ_Tail != (NET_BUF *)0) { /* If tx Q NOT empty ... */
if (tx_q_append == DEF_YES) { /* ... & tx app data chain NOT already on tx Q, ... */
/* ... append seg(s) @ Q tail (see Note #4b). */
pbuf_q_tail = (NET_BUF *) pconn->TxQ_Tail;
pbuf_hdr_q_tail = (NET_BUF_HDR *)&pbuf_q_tail->Hdr;
pbuf_hdr_q_tail->NextPrimListPtr = (void *) pbuf_head;
pbuf_hdr_head = (NET_BUF_HDR *)&pbuf_head->Hdr;
pbuf_hdr_head->PrevPrimListPtr = (void *) pbuf_q_tail;
}
pconn->TxQ_Tail = (NET_BUF *)pbuf_tail;
} else { /* Else add seg(s) to empty tx Q. */
pconn->TxQ_Head = (NET_BUF *)pbuf_head;
pconn->TxQ_Tail = (NET_BUF *)pbuf_tail;
}
/* Update TCP conn tx seq nbr(s). */
pconn->TxSeqNbrNextQ = seq_nbr;
/* ---------------- TX TCP DATA SEG(S) ---------------- */
if (tx_data == DEF_YES) {
NetTCP_TxConnTxQ((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(NET_TCP_ACK_CODE )NET_TCP_CONN_TX_ACK_NONE,
(CPU_BOOLEAN )DEF_NO,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL,
(NET_ERR *)perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
return (0); /* Prevent 'break NOT reachable' compiler warning. */
}
}
*perr = NET_TCP_ERR_NONE;
return (data_len_tot);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnGet()
*
* Description : (1) Allocate & initialize a TCP connection :
*
* (a) Get a TCP connection
* (b) Validate TCP connection
* (c) Initialize TCP connection
* (d) Update TCP connection pool statistics
* (e) Return TCP connection handle identifier
* OR
* Null identifier & error code, on failure
*
* (2) The TCP connection pool is implemented as a stack :
*
* (a) 'NetTCP_ConnPoolPtr' points to the head of the TCP connection pool.
*
* (b) TCP connections' 'NextPtr's link each TCP connection to form the TCP connection pool stack.
*
* (c) TCP connections are inserted & removed at the head of the TCP connection pool stack.
*
*
* TCP connections are
* inserted & removed
* at the head
* (see Note #2c)
*
* | NextPtr
* | (see Note #2b)
* v |
* |
* ------- ------- v ------- -------
* TCP Connection ---->| |------>| |------>| |------>| |
* Pool Pointer | | | | | | | |
* | | | | | | | |
* (see Note #2a) ------- ------- ------- -------
*
* | |
* |<------- Pool of Free TCP Connections -------->|
* | (see Note #2) |
*
*
* Argument(s) : perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection successfully allocated &
* initialized.
* NET_TCP_ERR_NONE_AVAIL NO available TCP connections to allocate.
* NET_TCP_ERR_INVALID_CONN_TYPE TCP connection is NOT a valid type.
*
* Return(s) : TCP connection handle identifier, if NO errors.
*
* NET_TCP_CONN_ID_NONE, otherwise.
*
* Caller(s) : various.
*
* This function is an INTERNAL network protocol suite function & MUST NOT be called by
* application function(s).
*
* Note(s) : (3) (a) TCP connection pool is accessed by 'NetTCP_ConnPoolPtr' during execution of
*
* (1) NetTCP_Init()
* (2) NetTCP_ConnGet()
* (3) NetTCP_ConnFree()
*
* (b) Since the primary tasks of the network protocol suite are prevented from running
* concurrently (see 'net.h Note #2'), it is NOT necessary to protect the shared
* resources of the connection pool since no asynchronous access from other network
* tasks is possible.
*********************************************************************************************************
*/
/*$PAGE*/
NET_TCP_CONN_ID NetTCP_ConnGet (NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
NET_TCP_CONN_ID conn_id_tcp;
NET_ERR stat_err;
/* ------------------- GET TCP CONN ------------------- */
if (NetTCP_ConnPoolPtr != (NET_TCP_CONN *)0) { /* If TCP conn pool NOT empty, get TCP conn from pool. */
pconn = (NET_TCP_CONN *)NetTCP_ConnPoolPtr;
NetTCP_ConnPoolPtr = (NET_TCP_CONN *)pconn->NextPtr;
} else { /* If none avail, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrNoneAvailCtr);
*perr = NET_TCP_ERR_NONE_AVAIL;
return (NET_TCP_CONN_ID_NONE);
}
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ---------------- VALIDATE TCP CONN ----------------- */
if (pconn->Type != NET_TCP_TYPE_CONN) {
NetTCP_ConnDiscard(pconn);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidTypeCtr);
*perr = NET_TCP_ERR_INVALID_CONN_TYPE;
return (NET_TCP_CONN_ID_NONE);
}
#endif
/* ------------------ INIT TCP CONN ------------------- */
NetTCP_ConnClr(pconn);
DEF_BIT_SET(pconn->Flags, NET_TCP_FLAG_USED); /* Set TCP conn as used. */
pconn->ConnState = NET_TCP_CONN_STATE_CLOSED;
/* ------------ UPDATE TCP CONN POOL STATS ------------ */
NetStat_PoolEntryUsedInc(&NetTCP_ConnPoolStat, &stat_err);
/* ----------------- RTN TCP CONN ID ------------------ */
conn_id_tcp = pconn->ID;
*perr = NET_TCP_ERR_NONE;
return (conn_id_tcp);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnFree()
*
* Description : Free a TCP connection.
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to free.
*
* Return(s) : none.
*
* Caller(s) : NetSock_Listen(),
* NetSock_GetConnTransport().
*
* This function is an INTERNAL network protocol suite function & MUST NOT be called by
* application function(s).
*
* Note(s) : (1) #### To prevent freeing a TCP connection already freed via previous TCP connection
* free, NetTCP_ConnFree() checks if the TCP connection is used BEFORE freeing the
* TCP connection.
*
* This prevention is only best-effort since any invalid duplicate TCP connection frees
* MAY be asynchronous to potentially valid TCP connection gets. Thus the invalid TCP
* connection free(s) MAY corrupt the TCP connection's valid operation(s).
*
* However, since the primary tasks of the network protocol suite are prevented from
* running concurrently (see 'net.h Note #2'), it is NOT necessary to protect TCP
* connection resources from possible corruption since no asynchronous access from
* other network tasks is possible.
*********************************************************************************************************
*/
void NetTCP_ConnFree (NET_TCP_CONN_ID conn_id_tcp)
{
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NET_ERR err;
#endif
NET_TCP_CONN *pconn;
/* ---------------- VALIDATE TCP CONN ----------------- */
if (conn_id_tcp == NET_TCP_CONN_ID_NONE) {
return;
}
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* -------------- VALIDATE TCP CONN USED -------------- */
(void)NetTCP_ConnIsUsed(conn_id_tcp, &err);
if (err != NET_TCP_ERR_NONE) { /* If TCP conn NOT used, ... */
return; /* ... rtn but do NOT free (see Note #1). */
}
#endif
/* ------------------ FREE TCP CONN ------------------- */
pconn = &NetTCP_ConnTbl[conn_id_tcp];
NetTCP_ConnFreeHandler(pconn, NET_TCP_CONN_FREE_ALL);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnCloseFromConn()
*
* Description : Close a TCP connection via a network connection.
*
* (1) When a network connection closes a TCP connection, the TCP connection :
*
* (a) (1) Closes NO other network connection(s),
* (2) MUST NOT recursively re-close other network connection(s);
*
* (b) SHOULD clear network connection(s)' handle identifiers.
*
* See also 'net_sock.c NetSock_CloseFromConn() Note #1',
* & 'net_conn.c NetConn_CloseFromTransport() Note #1b'.
*
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to close.
*
* Return(s) : none.
*
* Caller(s) : NetConn_CloseTransport().
*
* This function is an INTERNAL network protocol suite function & MUST NOT be called by
* application function(s).
*
* Note(s) : (2) #### To prevent closing a TCP connection already closed via previous TCP connection
* close, NetTCP_ConnCloseFromConn() checks if the TCP connection is used BEFORE closing
* the TCP connection.
*
* This prevention is only best-effort since any invalid duplicate TCP connection closes
* MAY be asynchronous to potentially valid TCP connection gets. Thus the invalid TCP
* connection closes(s) MAY corrupt the TCP connection's valid operation(s).
*
* However, since the primary tasks of the network protocol suite are prevented from
* running concurrently (see 'net.h Note #2'), it is NOT necessary to protect TCP
* connection resources from possible corruption since no asynchronous access from
* other network tasks is possible.
*********************************************************************************************************
*/
void NetTCP_ConnCloseFromConn (NET_TCP_CONN_ID conn_id_tcp)
{
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NET_ERR err;
#endif
NET_TCP_CONN *pconn;
/* ---------------- VALIDATE TCP CONN ----------------- */
if (conn_id_tcp == NET_TCP_CONN_ID_NONE) {
return;
}
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* -------------- VALIDATE TCP CONN USED -------------- */
(void)NetTCP_ConnIsUsed(conn_id_tcp, &err);
if (err != NET_TCP_ERR_NONE) { /* If TCP conn NOT used, ... */
return; /* ... rtn but do NOT close (see Note #2). */
}
#endif
/* ------------------ CLOSE TCP CONN ------------------ */
pconn = &NetTCP_ConnTbl[conn_id_tcp];
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_NO, /* See Note #1. */
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnSetID_Conn()
*
* Description : Set a TCP connection's network connection handle identifier.
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to set.
*
* conn_id Handle identifier of network connection.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection's network connection handle
* identifier successfully set.
* NET_TCP_ERR_INVALID_CONN_ID Invalid network connection handle identifier.
*
* ----- RETURNED BY NetTCP_ConnIsUsed() : -----
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_INVALID_CONN Invalid TCP connection number.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
*
* ------ RETURNED BY NetConn_IsUsed() : -------
* NET_CONN_ERR_INVALID_CONN Invalid network connection number.
* NET_CONN_ERR_NOT_USED Network connection NOT currently used.
*
* Return(s) : none.
*
* Caller(s) : NetSock_GetConnTransport().
*
* This function is an INTERNAL network protocol suite function & MUST NOT be called by
* application function(s).
*
* Note(s) : none.
*********************************************************************************************************
*/
void NetTCP_ConnSetID_Conn (NET_TCP_CONN_ID conn_id_tcp,
NET_CONN_ID conn_id,
NET_ERR *perr)
{
NET_TCP_CONN *pconn;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
/* -------------- VALIDATE TCP CONN USED -------------- */
(void)NetTCP_ConnIsUsed(conn_id_tcp, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* --------------- VALIDATE NET CONN ID --------------- */
if (conn_id != NET_CONN_ID_NONE) {
(void)NetConn_IsUsed(conn_id, perr);
if (*perr != NET_CONN_ERR_NONE) {
return;
}
}
#endif
pconn = &NetTCP_ConnTbl[conn_id_tcp];
pconn->ID_Conn = conn_id; /* Set TCP conn's conn id. */
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnSetStateListen()
*
* Description : Set TCP connection to LISTEN state.
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to set LISTEN state.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection state successfully set to LISTEN.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_ID Invalid network connection handle identifier.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* ------ RETURNED BY NetTCP_ConnIsUsed() : -------
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_INVALID_CONN Invalid TCP connection number.
*
* Return(s) : none.
*
* Caller(s) : NetSock_Listen().
*
* This function is an INTERNAL network protocol suite function & SHOULD NOT be called by
* application function(s).
*
* Note(s) : none.
*********************************************************************************************************
*/
void NetTCP_ConnSetStateListen (NET_TCP_CONN_ID conn_id_tcp,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
CPU_BOOLEAN used;
NET_CONN_ID conn_id;
NET_CONN_ID conn_id_transport;
NET_ERR err;
#endif
NET_TCP_CONN *pconn;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* -------------- VALIDATE TCP CONN USED -------------- */
(void)NetTCP_ConnIsUsed(conn_id_tcp, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
#endif
pconn = &NetTCP_ConnTbl[conn_id_tcp];
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ---------------- VALIDATE CONN IDs ----------------- */
conn_id = pconn->ID_Conn;
used = NetConn_IsUsed(conn_id, &err);
if (used != DEF_YES) {
*perr = NET_TCP_ERR_INVALID_CONN_ID;
return;
}
conn_id_transport = NetConn_ID_TransportGet(conn_id, &err);
if (conn_id_tcp != (NET_TCP_CONN_ID)conn_id_transport) {
*perr = NET_TCP_ERR_INVALID_CONN_ID;
return;
}
#endif
/*$PAGE*/
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED:
pconn->ConnState = NET_TCP_CONN_STATE_LISTEN;
break;
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnReqClose()
*
* Description : (1) Request TCP connection close :
*
* (a) Handle TCP connection close See Note #2a
* (b) Update TCP connection timer See Note #2b
*
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to request close.
*
* conn_close_code Indicate whether to close transport connection :
*
* NET_CONN_CLOSE_FULL Close TCP connection but do NOT allow
* closing receive data to be available.
* NET_CONN_CLOSE_HALF Close TCP connection but allow
* closing receive data to be available.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection close successfully requested.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
* NET_TCP_ERR_INVALID_CONN_ID Invalid network connection handle identifier.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* ----- RETURNED BY NetTCP_ConnIsUsed() : -----
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_INVALID_CONN Invalid TCP connection number.
*
* ---- RETURNED BY NetTCP_TxConnClose() : -----
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
* NET_TCP_ERR_CONN_ACK_INVALID TCP connection acknowledgement NOT valid for
* current TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
* NET_TCP_ERR_TX TCP transmit error.
*
* Return(s) : none.
*
* Caller(s) : NetSock_CloseHandlerStream().
*
* This function is an INTERNAL network protocol suite function & SHOULD NOT be called by
* application function(s).
*$PAGE*
* Note(s) : (2) (a) RFC #793, Section 3.9 'Event Processing : CLOSE Call' specifies how to handle
* close requests from the application layer :
*
* (1) For the "CLOSED STATE ... return 'error: connection does not exist'".
*
* (2) For the "LISTEN STATE ... any outstanding RECEIVEs are returned with 'error:
* closing' responses. Delete TCB [and] enter CLOSED state".
*
* (3) For the "SYN-SENT STATE ... Delete the TCB and return 'error: closing'
* responses to any queued SENDs, or RECEIVEs".
*
* (4) For the "SYN-RECEIVED STATE" ...
*
* (A) "if no SENDs have been issued and there is no pending data to send," ...
* (1) "then form a FIN segment and send it," ...
* (2) "and enter FIN-WAIT-1 state;" ...
*
* (B) "otherwise queue for processing after entering ESTABLISHED state."
*
* (5) For the "ESTABLISHED STATE" ...
*
* (A) "Queue this until all preceding SENDs have been segmentized," ...
* (B) "then form a FIN segment and send it" ...
* (C) "In any case, enter FIN-WAIT-1 state."
*
* (6) For the "FIN-WAIT-1 STATE, FIN-WAIT-2 STATE" ...
*
* (A) "Strictly speaking, this is an error and should receive a 'error: connection
* closing' response."
*
* (B) "An 'ok' response would be acceptable, too, as long as a second FIN is not
* emitted (the first FIN may be retransmitted though)."
*
* (7) For the "CLOSE-WAIT STATE" ...
*
* (A) "Queue this request until all preceding SENDs have been segmentized;" ...
* (B) "then send a FIN segment," ...
* (C) (1) "enter CLOSING state."
* (2) RFC #1122, Section 4.2.2.20.(a) amends the state transition to "enter
* LAST-ACK state, not CLOSING".
*
* (8) For the "CLOSING STATE, LAST-ACK STATE, TIME-WAIT STATE ... respond with 'error:
* connection closing'".
*
* (b) RFC #793, Section 3.9 'Event Processing : CLOSE Call' does NOT specify which timeout
* values to set for each state transition to closing state(s).
*
* #### Therefore, the following timeout values will be used for the following close
* state transitions :
*
* (1) SYN-RECEIVED STATE -> FIN-WAIT-1 STATE TCP User/Connection timeout
* See also 'NetTCP_RxPktConnHandlerSyncRxd() Note #3'.
*
* (2) ESTABLISHED STATE -> FIN-WAIT-1 STATE TCP User/Connection timeout
* See also 'NetTCP_RxPktConnHandlerConn() Note #3'.
*
* (3) CLOSE-WAIT STATE -> LAST-ACK STATE TCP Time-Wait / Two TCP Maximum
* Segment Lifetimes timeout
* See also 'NetTCP_RxPktConnHandlerLastAck() Note #3'.
*
* (c) RFC #1122, Section 4.2.2.13 states that "a TCP connection may terminate in two ways" :
*
* (1) "The normal TCP close sequence using a FIN handshake."
* (2) "An 'abort' in which one or more RST segments are sent and the connection state
* is immediately discarded."
*
* (3) (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* FIN-WAIT-2 STATE' states that "if the retransmission queue is empty, the user's
* CLOSE can be acknowledged".
*
* (b) However, TCP connection should signal the application layer that "the user's close
* [is] acknowledged" whenever its re-transmit queue becomes &/or is empty :
*
* (1) Transition from LISTEN to CLOSED
* (2) Transition from SYN-SENT to CLOSED
*
* See also 'NetTCP_RxPktConnHandlerSignalClose() Note #1'.
*
* (4) On ANY errors, network resources MUST be appropriately freed :
*
* (a) Close the TCP connection.
* (b) #### Do NOT close the network or application connection(s); application layer
* responsible for closing remaining connection(s)?
*********************************************************************************************************
*/
/*$PAGE*/
void NetTCP_ConnReqClose (NET_TCP_CONN_ID conn_id_tcp,
CPU_INT08U conn_close_code,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
CPU_BOOLEAN used;
NET_CONN_ID conn_id;
NET_CONN_ID conn_id_transport;
#endif
NET_TCP_CONN *pconn;
NET_TCP_TIMEOUT_SEC timeout_sec;
NET_TMR_TICK timeout_tick;
NET_ERR err;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* -------------- VALIDATE TCP CONN USED -------------- */
(void)NetTCP_ConnIsUsed(conn_id_tcp, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
#endif
pconn = &NetTCP_ConnTbl[conn_id_tcp];
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ---------------- VALIDATE CONN IDs ----------------- */
conn_id = pconn->ID_Conn;
used = NetConn_IsUsed(conn_id, &err);
if (used != DEF_YES) {
*perr = NET_TCP_ERR_INVALID_CONN_ID;
return;
}
conn_id_transport = NetConn_ID_TransportGet(conn_id, &err);
if (conn_id_tcp != (NET_TCP_CONN_ID)conn_id_transport) {
*perr = NET_TCP_ERR_INVALID_CONN_ID;
return;
}
#endif
/*$PAGE*/
/* ---------------- HANDLE CONN CLOSE ----------------- */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED: /* See Note #2a1. */
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_LISTEN: /* See Note #2a2. */
case NET_TCP_CONN_STATE_SYNC_TXD: /* See Note #2a3. */
/* Signal app conn close (see Note #3b) ... */
NetTCP_RxPktConnHandlerSignalClose(pconn, DEF_NO, &err);
/* ... & close TCP conn. */
NetTCP_ConnCloseHandler(pconn, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_NONE;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_SYNC_RXD: /* See Note #2a4. */
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_CONN: /* See Note #2a5. */
NetTCP_TxConnClose(pconn, perr); /* Tx TCP conn close (see Note #2a5B), ... */
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* ... enter fin-wait-1 state (see Note #2a5C), ... */
pconn->ConnState = NET_TCP_CONN_STATE_FIN_WAIT_1;
pconn->TxQ_State = NET_TCP_TX_Q_STATE_CONN_CLOSING;
pconn->ConnCloseCode = conn_close_code;
timeout_sec = pconn->TimeoutConn_sec; /* ... & reset conn tmr (see Notes #2b1 & #2b2). */
break;
case NET_TCP_CONN_STATE_CLOSE_WAIT: /* See Note #2a7. */
NetTCP_TxConnClose(pconn, perr); /* Tx TCP conn close (see Note #2a7B), ... */
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* ... enter last-ack state (see Note #2a7C2), ... */
pconn->ConnState = NET_TCP_CONN_STATE_LAST_ACK;
pconn->TxQ_State = NET_TCP_TX_Q_STATE_CONN_CLOSING;
pconn->ConnCloseCode = conn_close_code;
/* ... & start time-wait tmr (see Note #2b3). */
timeout_sec = pconn->TimeoutMaxSeg_sec * NET_TCP_CONN_TIMEOUT_MAX_SEG_SCALAR;
break;
case NET_TCP_CONN_STATE_FIN_WAIT_1: /* See Note #2a6. */
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT: /* See Note #2a8. */
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_LAST_ACK:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* -------------------- UPDATE TMR -------------------- */
timeout_tick = (NET_TMR_TICK)timeout_sec * NET_TMR_TIME_TICK_PER_SEC;
if (pconn->TimeoutTmr != (NET_TMR *)0) {
NetTmr_Set((NET_TMR *) pconn->TimeoutTmr,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(NET_ERR *)&err);
} else {
pconn->TimeoutTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
}
if (err != NET_TMR_ERR_NONE) {
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )pconn->ConnCloseAppFlag,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnCfgMaxSegSizeLocal()
*
* Description : Configure TCP connection's local maximum segment size.
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to configure local maximum segment size.
*
* max_seg_size Desired maximum segment size.
*
* Return(s) : DEF_OK, Local maximum segment size successfully configured.
*
* DEF_FAIL, otherwise.
*
* Caller(s) : Application.
*
* This function is a network protocol suite application interface (API) function & MAY be
* called by application function(s).
*
* Note(s) : (1) RFC #793, Section 3.1 'Header Format : Options : Maximum Segment Size' states that
* a TCP connection advertises its "maximum receive segment size ... only ... in the
* initial connection request (i.e., in segments with the SYN control bit set)".
*
* Thus any configuration of the local receive maximum segment size MUST be performed
* by the application layer PRIOR to any TCP connection request/synchronization.
*********************************************************************************************************
*/
CPU_BOOLEAN NetTCP_ConnCfgMaxSegSizeLocal (NET_TCP_CONN_ID conn_id_tcp,
NET_TCP_SEG_SIZE max_seg_size)
{
#if (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL)
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
#if ((NET_ERR_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) || \
(NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED))
/* ---------------- VALIDATE TCP CONN ----------------- */
if (conn_id_tcp < NET_TCP_CONN_ID_MIN) {
return (DEF_FAIL);
}
if (conn_id_tcp > NET_TCP_CONN_ID_MAX) {
return (DEF_FAIL);
}
#endif
/* -------------- VALIDATE MAX SEG SIZE --------------- */
#if (NET_TCP_MAX_SEG_SIZE_MIN > 0)
if (max_seg_size < NET_TCP_MAX_SEG_SIZE_MIN) {
max_seg_size = NET_TCP_MAX_SEG_SIZE_MIN;
}
#endif
#if ((NET_TCP_MAX_SEG_SIZE_MAX < DEF_INT_08U_MAX_VAL) || \
((NET_TCP_MAX_SEG_SIZE_MAX < DEF_INT_16U_MAX_VAL) && (NET_TCP_MAX_SEG_SIZE_MAX > DEF_INT_08U_MAX_VAL)) || \
((NET_TCP_MAX_SEG_SIZE_MAX < DEF_INT_32U_MAX_VAL) && (NET_TCP_MAX_SEG_SIZE_MAX > DEF_INT_16U_MAX_VAL)))
if (max_seg_size > NET_TCP_MAX_SEG_SIZE_MAX) {
max_seg_size = NET_TCP_MAX_SEG_SIZE_MAX;
}
#endif
/* ------------ CFG TCP CONN MAX SEG SIZE ------------- */
pconn = &NetTCP_ConnTbl[conn_id_tcp];
CPU_CRITICAL_ENTER();
pconn->MaxSegSizeLocal = max_seg_size;
CPU_CRITICAL_EXIT();
return (DEF_OK);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnCfgRxWinSize()
*
* Description : Configure TCP connection's receive window size.
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to configure receive window size.
*
* win_size Desired receive window size.
*
* Return(s) : DEF_OK, Receive window size successfully configured.
*
* DEF_FAIL, otherwise.
*
* Caller(s) : Application.
*
* This function is a network protocol suite application interface (API) function & MAY be
* called by application function(s).
*
* Note(s) : (1) A TCP connection's receive window controls should NOT be updated until after the
* following TCP connection control(s) have been configured :
*
* (a) TCP connection's connection maximum segment size ('MaxSegSizeConn')
* [see 'NetTCP_RxConnWinSizeCfgUpdateTh() Note #2b']
*********************************************************************************************************
*/
CPU_BOOLEAN NetTCP_ConnCfgRxWinSize (NET_TCP_CONN_ID conn_id_tcp,
NET_TCP_WIN_SIZE win_size)
{
#if (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL)
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
#if ((NET_ERR_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) || \
(NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED))
/* ---------------- VALIDATE TCP CONN ----------------- */
if (conn_id_tcp < NET_TCP_CONN_ID_MIN) {
return (DEF_FAIL);
}
if (conn_id_tcp > NET_TCP_CONN_ID_MAX) {
return (DEF_FAIL);
}
#endif
/* --------------- VALIDATE RX WIN SIZE --------------- */
#if (NET_TCP_WIN_SIZE_MIN > 0)
if (win_size < NET_TCP_WIN_SIZE_MIN) {
win_size = NET_TCP_WIN_SIZE_MIN;
}
#endif
#if ((NET_TCP_WIN_SIZE_MAX < DEF_INT_08U_MAX_VAL) || \
((NET_TCP_WIN_SIZE_MAX < DEF_INT_16U_MAX_VAL) && (NET_TCP_WIN_SIZE_MAX > DEF_INT_08U_MAX_VAL)) || \
((NET_TCP_WIN_SIZE_MAX < DEF_INT_32U_MAX_VAL) && (NET_TCP_WIN_SIZE_MAX > DEF_INT_16U_MAX_VAL)))
if (win_size > NET_TCP_WIN_SIZE_MAX) {
win_size = NET_TCP_WIN_SIZE_MAX;
}
#endif
/* --------- CFG TCP CONN RX WIN SIZE --------- */
pconn = &NetTCP_ConnTbl[conn_id_tcp];
CPU_CRITICAL_ENTER();
if (pconn->MaxSegSizeConn == NET_TCP_MAX_SEG_SIZE_NONE) { /* If TCP conn MSS NOT cfg'd (see Note #1a), .. */
CPU_CRITICAL_EXIT();
return (DEF_FAIL); /* .. do NOT cfg TCP conn rx win. */
}
pconn->RxWinSizeCfgd = win_size; /* Cfg new rx win size. */
if (pconn->RxWinSizeCfgdActual <= pconn->RxWinSizeCfgd) { /* If actual <= cfg'd rx win size, ... */
pconn->RxWinSizeCfgdActual = pconn->RxWinSizeCfgd; /* ... update actual rx win size. */
pconn->RxWinSizeCfgdActualUpdateRem = 0;
} else { /* Else cfg rem'ing win size update val. */
pconn->RxWinSizeCfgdActualUpdateRem = pconn->RxWinSizeCfgdActual - pconn->RxWinSizeCfgd;
}
NetTCP_RxConnWinSizeCfg(pconn); /* Cfg rx win ctrls. */
CPU_CRITICAL_EXIT();
return (DEF_OK);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnCfgReTxMaxTh()
*
* Description : Configure TCP connection's maximum number of same segment retransmissions.
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to configure maximum number of
* same segment retransmissions.
*
* nbr_re_tx Desired maximum number of same segment retransmissions.
*
* Return(s) : DEF_OK, Maximum number of same segment retransmissions successfully configured.
*
* DEF_FAIL, otherwise.
*
* Caller(s) : Application.
*
* This function is a network protocol suite application interface (API) function & MAY be
* called by application function(s).
*
* Note(s) : none.
*********************************************************************************************************
*/
CPU_BOOLEAN NetTCP_ConnCfgReTxMaxTh (NET_TCP_CONN_ID conn_id_tcp,
CPU_INT16U nbr_max_re_tx)
{
#if (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL)
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
#if ((NET_ERR_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) || \
(NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED))
/* ---------------- VALIDATE TCP CONN ----------------- */
if (conn_id_tcp < NET_TCP_CONN_ID_MIN) {
return (DEF_FAIL);
}
if (conn_id_tcp > NET_TCP_CONN_ID_MAX) {
return (DEF_FAIL);
}
#endif
/* ---------------- VALIDATE RE-TX TH ----------------- */
#if (NET_TCP_RE_TX_TH_MIN > DEF_INT_16U_MIN_VAL)
if (nbr_max_re_tx < NET_TCP_RE_TX_TH_MIN) {
nbr_max_re_tx = NET_TCP_RE_TX_TH_MIN;
}
#endif
#if (NET_TCP_RE_TX_TH_MAX < DEF_INT_16U_MAX_VAL)
if (nbr_max_re_tx > NET_TCP_RE_TX_TH_MAX) {
nbr_max_re_tx = NET_TCP_RE_TX_TH_MAX;
}
#endif
/* -------------- CFG TCP CONN RE-TX TH --------------- */
pconn = &NetTCP_ConnTbl[conn_id_tcp];
CPU_CRITICAL_ENTER();
pconn->TxSegReTxTh = nbr_max_re_tx;
CPU_CRITICAL_EXIT();
return (DEF_OK);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnCfgReTxMaxTimeout()
*
* Description : Configure TCP connection's maximum retransmission timeout.
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to configure retransmission
* maximum timeout value.
*
* timeout_sec Desired value for TCP connection retransmission maximum timeout
* (in seconds).
*
* Return(s) : DEF_OK, TCP connection retransmission maximum timeout successfully configured.
*
* DEF_FAIL, otherwise.
*
* Caller(s) : Application.
*
* This function is a network protocol suite application interface (API) function & MAY be
* called by application function(s).
*
* Note(s) : (1) (a) RFC #2988, Section 2.4 states that "a maximum value MAY be placed on RTO
* provided it is at least 60 seconds".
*
* (b) RFC #1122, Section 4.2.3.1 states that "the recommended ... RTO ... upper
* bound should be 2*MSL".
*
* (c) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 21.2, Page 299
* states that "the timeout value ... [has] an upper limit of 64 seconds".
********************************************************************************************************
*/
CPU_BOOLEAN NetTCP_ConnCfgReTxMaxTimeout (NET_TCP_CONN_ID conn_id_tcp,
NET_TCP_TIMEOUT_SEC timeout_sec)
{
#if (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL)
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
#if ((NET_ERR_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) || \
(NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED))
/* ---------------- VALIDATE TCP CONN ----------------- */
if (conn_id_tcp < NET_TCP_CONN_ID_MIN) {
return (DEF_FAIL);
}
if (conn_id_tcp > NET_TCP_CONN_ID_MAX) {
return (DEF_FAIL);
}
#endif
/* ---------------- VALIDATE RTO MAX ------------------ */
/* See Note #1. */
#if (NET_TCP_TX_RTO_MAX_TIMEOUT_MIN_SEC > 0)
if (timeout_sec < NET_TCP_TX_RTO_MAX_TIMEOUT_MIN_SEC) {
timeout_sec = NET_TCP_TX_RTO_MAX_TIMEOUT_MIN_SEC;
}
#endif
#if ((NET_TCP_TX_RTO_MAX_TIMEOUT_MAX_SEC < DEF_INT_08U_MAX_VAL) || \
((NET_TCP_TX_RTO_MAX_TIMEOUT_MAX_SEC < DEF_INT_16U_MAX_VAL) && (NET_TCP_TX_RTO_MAX_TIMEOUT_MAX_SEC > DEF_INT_08U_MAX_VAL)) || \
((NET_TCP_TX_RTO_MAX_TIMEOUT_MAX_SEC < DEF_INT_32U_MAX_VAL) && (NET_TCP_TX_RTO_MAX_TIMEOUT_MAX_SEC > DEF_INT_16U_MAX_VAL)))
if (timeout_sec > NET_TCP_TX_RTO_MAX_TIMEOUT_MAX_SEC) {
timeout_sec = NET_TCP_TX_RTO_MAX_TIMEOUT_MAX_SEC;
}
#endif
/* --------------- CFG TCP CONN RTO MAX --------------- */
pconn = &NetTCP_ConnTbl[conn_id_tcp];
CPU_CRITICAL_ENTER();
pconn->TxRTT_RTO_Max_sec = timeout_sec;
NetTCP_TxConnRTO_CfgMaxTimeout(pconn); /* Cfg RTO ctrls. */
CPU_CRITICAL_EXIT();
return (DEF_OK);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnCfgTxAckImmedRxdPushEn()
*
* Description : Configure TCP connection's transmit immediate acknowledgement for received & pushed TCP
* segments enable.
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to configure transmit immediate
* acknowledgement for received & pushed TCP segments enable.
*
* tx_immed_ack_en Desired value for TCP connection transmit immediate acknowledgement
* for received & pushed TCP segments enable :
*
* DEF_ENABLED TCP connection acknowledgements
* immediately transmitted for any
* pushed TCP segments received.
*
* DEF_DISABLED TCP connection acknowledgements NOT
* immediately transmitted for any
* pushed TCP segments received.
*
*
* Return(s) : DEF_OK, TCP connection transmit immediate acknowledgement for received & pushed TCP
* segments enable successfully configured.
*
* DEF_FAIL, otherwise.
*
* Caller(s) : Application.
*
* This function is a network protocol suite application interface (API) function & MAY be
* called by application function(s).
*
* Note(s) : (1) See 'NetTCP_TxConnAck() Note #4a4A1'.
*********************************************************************************************************
*/
CPU_BOOLEAN NetTCP_ConnCfgTxAckImmedRxdPushEn (NET_TCP_CONN_ID conn_id_tcp,
CPU_BOOLEAN tx_immed_ack_en)
{
#if (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL)
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
#if ((NET_ERR_CFG_ARG_CHK_EXT_EN == DEF_ENABLED) || \
(NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED))
/* ---------------- VALIDATE TCP CONN ----------------- */
if (conn_id_tcp < NET_TCP_CONN_ID_MIN) {
return (DEF_FAIL);
}
if (conn_id_tcp > NET_TCP_CONN_ID_MAX) {
return (DEF_FAIL);
}
#endif
/* ------------- VALIDATE TX IMMED ACK EN ------------- */
switch (tx_immed_ack_en) {
case DEF_ENABLED:
case DEF_DISABLED:
break;
default:
tx_immed_ack_en = DEF_ENABLED; /* See Note #1. */
break;
}
/* ----------- CFG TCP CONN TX IMMED ACK EN ----------- */
pconn = &NetTCP_ConnTbl[conn_id_tcp];
CPU_CRITICAL_ENTER();
pconn->TxAckImmedRxdPushEn = tx_immed_ack_en;
CPU_CRITICAL_EXIT();
return (DEF_OK);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnIsUsed()
*
* Description : Validate TCP connection in use.
*
* Argument(s) : conn_id_tcp Handle identifier of TCP connection to validate.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection successfully validated as
* in use.
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_INVALID_CONN Invalid TCP connection number.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
*
* Return(s) : DEF_YES, TCP connection valid & in use.
*
* DEF_NO, TCP connection invalid or NOT in use.
*
* Caller(s) : various.
*
* This function is an INTERNAL network protocol suite function & SHOULD NOT be called by
* application function(s).
*
* Note(s) : (1) NetTCP_ConnIsUsed() blocked until network initialization completes.
*
* (2) NetTCP_ConnIsUsed() MUST be called with the global network lock already acquired.
*********************************************************************************************************
*/
CPU_BOOLEAN NetTCP_ConnIsUsed (NET_TCP_CONN_ID conn_id_tcp,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
CPU_BOOLEAN used;
#if (NET_ERR_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (Net_InitDone != DEF_YES) { /* If init NOT complete, exit (see Note #1). */
*perr = NET_ERR_INIT_INCOMPLETE;
return (DEF_NO);
}
#endif
/* --------------- VALIDATE TCP CONN ID --------------- */
if (conn_id_tcp < NET_TCP_CONN_ID_MIN) {
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidCtr);
*perr = NET_TCP_ERR_INVALID_CONN;
return (DEF_NO);
}
if (conn_id_tcp > NET_TCP_CONN_ID_MAX) {
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidCtr);
*perr = NET_TCP_ERR_INVALID_CONN;
return (DEF_NO);
}
/* -------------- VALIDATE TCP CONN USED -------------- */
pconn = &NetTCP_ConnTbl[conn_id_tcp];
used = DEF_BIT_IS_SET(pconn->Flags, NET_TCP_FLAG_USED);
if (used != DEF_YES) {
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return (DEF_NO);
}
*perr = NET_TCP_ERR_NONE;
return (DEF_YES);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnPoolStatGet()
*
* Description : Get TCP connection's statistics pool.
*
* Argument(s) : none.
*
* Return(s) : TCP connection statistics pool, if NO errors.
*
* NULL statistics pool, otherwise.
*
* Caller(s) : Application.
*
* This function is a network protocol suite application interface (API) function & MAY be
* called by application function(s).
*
* Note(s) : (1) NetTCP_ConnPoolStatGet() blocked until network initialization completes; return NULL
* statistics pool.
*********************************************************************************************************
*/
NET_STAT_POOL NetTCP_ConnPoolStatGet (void)
{
#if (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL)
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
NET_ERR err;
#endif
NET_STAT_POOL stat_pool;
#if (NET_ERR_CFG_ARG_CHK_EXT_EN == DEF_ENABLED)
if (Net_InitDone != DEF_YES) { /* If init NOT complete, ... */
NetStat_PoolClr(&stat_pool, &err);
return (stat_pool); /* ... rtn NULL stat pool (see Note #1). */
}
#endif
CPU_CRITICAL_ENTER();
stat_pool = NetTCP_ConnPoolStat;
CPU_CRITICAL_EXIT();
return (stat_pool);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnPoolStatResetMaxUsed()
*
* Description : Reset TCP connection's statistics pool's maximum number of entries used.
*
* Argument(s) : none.
*
* Return(s) : none.
*
* Caller(s) : Application.
*
* This function is a network protocol suite application interface (API) function & MAY be
* called by application function(s).
*
* Note(s) : none.
*********************************************************************************************************
*/
void NetTCP_ConnPoolStatResetMaxUsed (void)
{
NET_ERR err;
NetStat_PoolResetUsedMax(&NetTCP_ConnPoolStat, &err);
}
/*$PAGE*/
/*
*********************************************************************************************************
*********************************************************************************************************
* LOCAL FUNCTIONS
*********************************************************************************************************
*********************************************************************************************************
*/
/*
*********************************************************************************************************
* NetTCP_RxPktValidateBuf()
*
* Description : Validate received buffer header as TCP protocol.
*
* Argument(s) : pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE Received buffer's TCP header validated.
* NET_ERR_INVALID_PROTOCOL Buffer's protocol type is NOT TCP.
* NET_BUF_ERR_INVALID_IX Invalid buffer index.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_Rx().
*
* Note(s) : none.
*********************************************************************************************************
*/
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
static void NetTCP_RxPktValidateBuf (NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
/* --------------- VALIDATE TCP BUF HDR --------------- */
if (pbuf_hdr->ProtocolHdrType != NET_PROTOCOL_TYPE_TCP) {
NET_CTR_ERR_INC(Net_ErrInvalidProtocolCtr);
*perr = NET_ERR_INVALID_PROTOCOL;
return;
}
if (pbuf_hdr->TCP_UDP_HdrDataIx == NET_BUF_IX_NONE) {
NET_CTR_ERR_INC(NetTCP_ErrRxInvalidBufIxCtr);
*perr = NET_BUF_ERR_INVALID_IX;
return;
}
*perr = NET_TCP_ERR_NONE;
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktValidate()
*
* Description : (1) Validate received TCP packet :
*
* (a) Get TCP packet RTT timestamp received. See 'NetTCP_TxConnRTT_RTO_Calc()
* Note #2a2A2'
*
* (b) (1) Validate the received packet's following TCP header fields :
*
* (A) Source Port
* (B) Destination Port
* (C) Header Length
* (D) Segment Length See Note #3
* (E) Flags
* (F) Check-Sum See Note #4
* (G) Options
*
* (2) Validation ignores the following TCP header fields :
*
* (A) Sequence Number
* (B) Acknowledgement Number
* (C) Window Advertisement
* (D) Urgent Pointer See 'net_tcp.c Note #1b'
*
* (c) Convert the following TCP header fields from network-order to host-order :
*
* (1) Source Port See Note #1cB1
* (2) Destination Port See Note #1cB2
* (3) Sequence Number See Note #1cB3
* (4) Acknowledgement Number See Note #1cB4
* (5) Header Length/Flags See Note #1cB5
* (6) Window Advertisement See Note #1cB6
* (7) Check-Sum See Note #4f
* (8) Urgent Pointer See 'net_tcp.c Note #1b'
*
* (A) These fields are NOT converted directly in the received packet buffer's
* data area but are converted in local or network buffer variables ONLY.
*
* (B) The following TCP header fields are converted & stored in network buffer
* variables :
*
* (1) Source Port
* (2) Destination Port
* (3) Sequence Number
* (4) Acknowledgement Number
* (5) Header Length/Flags
* (6) Window Advertisement
*
* (d) Update network buffer's protocol controls.
*
*
* Argument(s) : pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header.
* -------- Argument validated in NetTCP_Rx().
*
* ptcp_hdr Pointer to received packet's TCP header.
* -------- Argument validated in NetTCP_Rx()/NetTCP_RxPktValidateBuf().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE Received packet validated.
* NET_TCP_ERR_INVALID_PORT_NBR Invalid TCP port number.
* NET_TCP_ERR_INVALID_LEN_HDR Invalid TCP header length.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP segment length.
* NET_TCP_ERR_INVALID_LEN_DATA Invalid TCP data length.
* NET_TCP_ERR_INVALID_FLAG Invalid TCP flags.
* NET_TCP_ERR_INVALID_CHK_SUM Invalid TCP check-sum.
*
* - RETURNED BY NetTCP_RxPktValidateOpt() : -
* NET_TCP_ERR_INVALID_OPT_LEN Invalid TCP option length.
* NET_TCP_ERR_INVALID_OPT_END Invalid TCP option list ending.
* NET_TCP_ERR_INVALID_OPT_NBR Invalid TCP option number of same option.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_Rx().
*$PAGE*
* Note(s) : (2) See 'net_tcp.h TCP HEADER' for TCP header format.
*
* (3) Since TCP segment headers do NOT contain a segment length field, the TCP Segment Length
* is assumed to be the remaining IP Datagram Length.
*
* (4) (a) TCP header Check-Sum field MUST be validated BEFORE (or AFTER) any multi-octet words
* are converted from network-order to host-order since "the sum of 16-bit integers can
* be computed in either byte order" [RFC #1071, Section 2.(B)].
*
* In other words, the TCP Segment Check-Sum CANNOT be validated AFTER SOME but NOT ALL
* multi-octet words have been converted from network-order to host-order.
*
* (b) However, ALL received packets' multi-octet words are converted in local or network
* buffer variables ONLY (see Note #1cA). Therefore, TCP Segment Check-Sum may be
* validated at any point.
*
* (c) The TCP Segment Check-Sum MUST be validated AFTER the TCP segment length has been
* validated so that the total TCP Segment Length (in octets) will already be calculated
* for the TCP Check-Sum calculation.
*
* For efficiency, the TCP Segment Check-Sum is validated AFTER all other TCP header
* fields have been validated. Thus, the iteration-intensive TCP Segment Check-Sum is
* calculated only after all other TCP header fields have been quickly validated.
*
* (d) (1) In addition to the TCP segment header & data, the TCP Check-Sum calculation
* includes "a 96-bit pseudo header conceptually prefixed to the TCP header ...
* [which] contains the Source Address, the Destination Address, the Protocol,
* and TCP length" (see RFC #793, Section 3.1 'Header Format : Checksum').
*
* (2) Since network check-sum functions REQUIRE that 16-bit one's-complement check-
* sum calculations be performed on headers & data arranged in network-order (see
* 'net_util.c NetUtil_16BitOnesCplChkSumDataVerify() Note #4'), TCP pseudo-header
* values MUST be set or converted to network-order.
*
* (e) RFC #793, Section 3.1 'Header Format : Checksum' specifies that "if a segment contains
* an odd number of header and text octets ... the last octet is padded ... with zeros to
* form a 16-bit word for checksum purposes".
*
* See also 'net_util.c NetUtil_16BitSumDataCalc() Note #8'.
*
* (f) After the TCP Segment Check-Sum is validated, it is NOT necessary to convert the Check-
* Sum from network-order to host-order since it is NOT required for further processing.
*
* (5) (a) Since the minimum network buffer size MUST be configured such that the entire TCP
* header MUST be received in a single packet (see 'net_buf.h NETWORK BUFFER INDEX &
* SIZE DEFINES Note #1c'), after the TCP header size is decremented from the first
* packet buffer's remaining number of data octets, any remaining octets MUST be user
* &/or application data octets.
*
* (1) Note that the 'Data' index is updated regardless of a null-size data length.
*
* (b) If additional packet buffers exist, the remaining IP datagram 'Data' MUST be user
* &/or application data. Therefore, the 'Data' length does NOT need to be adjusted
* but the 'Data' index MUST be updated.
*
* (c) #### Total TCP Segment Length & Data Length is duplicated in ALL fragmented packet
* buffers (may NOT be necessary; remove if unnecessary).
*
* (6) RFC #1122, Sections 3.2.1 & 3.2.2 require that IP & ICMP packets with certain invalid
* header fields be "silently discarded". However, NO RFC specifies how TCP should handle
* received segments with invalid header fields.
*
* Therefore, it is assumed that ALL TCP segments with ANY invalid header fields SHOULD
* be silently discarded.
*********************************************************************************************************
*/
static void NetTCP_RxPktValidate (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_HDR *ptcp_hdr,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
CPU_INT08U tcp_hdr_len_tot;
CPU_INT16U tcp_hdr_len;
CPU_INT16U tcp_tot_len;
CPU_INT16U tcp_data_len;
CPU_INT16U tcp_flags;
CPU_INT16U tcp_flags_reserved;
CPU_BOOLEAN tcp_chk_sum_valid;
NET_TCP_PSEUDO_HDR tcp_pseudo_hdr;
NET_BUF *pbuf_next;
NET_BUF_HDR *pbuf_next_hdr;
/*$PAGE*/
/* ---------------- GET TCP RTT RX TS ----------------- */
pbuf_hdr->TCP_RTT_TS_Rxd_ms = (CPU_INT32U)NetTCP_TxConnRTT_GetTS_ms();
/* ---------------- VALIDATE TCP PORTS ---------------- */
NET_UTIL_VAL_COPY_GET_NET_16(&pbuf_hdr->TCP_UDP_PortSrc, &ptcp_hdr->PortSrc);
if (pbuf_hdr->TCP_UDP_PortSrc == NET_TCP_PORT_NBR_RESERVED) {
NET_CTR_ERR_INC(NetTCP_ErrRxHdrPortSrcCtr);
*perr = NET_TCP_ERR_INVALID_PORT_NBR;
return;
}
NET_UTIL_VAL_COPY_GET_NET_16(&pbuf_hdr->TCP_UDP_PortDest, &ptcp_hdr->PortDest);
if (pbuf_hdr->TCP_UDP_PortDest == NET_TCP_PORT_NBR_RESERVED) {
NET_CTR_ERR_INC(NetTCP_ErrRxHdrPortDestCtr);
*perr = NET_TCP_ERR_INVALID_PORT_NBR;
return;
}
/* --------------- VALIDATE TCP HDR LEN --------------- */
/* See 'net_tcp.h TCP HEADER Note #2'. */
NET_UTIL_VAL_COPY_GET_NET_16(&pbuf_hdr->TCP_HdrLen_Flags, &ptcp_hdr->HdrLen_Flags);
tcp_hdr_len = pbuf_hdr->TCP_HdrLen_Flags & NET_TCP_HDR_LEN_MASK;
tcp_hdr_len >>= NET_TCP_HDR_LEN_SHIFT;
if (tcp_hdr_len < NET_TCP_HDR_LEN_MIN) { /* If hdr len < min hdr len, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrLenCtr);
*perr = NET_TCP_ERR_INVALID_LEN_HDR;
return;
}
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (tcp_hdr_len > NET_TCP_HDR_LEN_MAX) { /* If hdr len > max hdr len, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrLenCtr);
*perr = NET_TCP_ERR_INVALID_LEN_HDR;
return;
}
#endif
tcp_hdr_len_tot = tcp_hdr_len * NET_TCP_HDR_LEN_WORD_SIZE;
/* ------------- VALIDATE TCP SEG TOT LEN ------------- */
tcp_tot_len = pbuf_hdr->IP_DatagramLen; /* See Note #3. */
pbuf_hdr->TCP_UDP_TotLen = tcp_tot_len;
if (pbuf_hdr->TCP_UDP_TotLen < NET_TCP_TOT_LEN_MIN) { /* If seg tot len < min tot len, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrSegLenCtr);
*perr = NET_TCP_ERR_INVALID_LEN_SEG;
return;
}
if (pbuf_hdr->TCP_UDP_TotLen > NET_TCP_TOT_LEN_MAX) { /* If seg tot len > max tot len, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrSegLenCtr);
*perr = NET_TCP_ERR_INVALID_LEN_SEG;
return;
}
/* ---------------- VALIDATE TCP FLAGS ---------------- */
/* See 'net_tcp.h TCP HEADER Note #2'. */
#if 1 /* ???? Allow invalid reserved flags for rx'd segs? */
tcp_flags = pbuf_hdr->TCP_HdrLen_Flags & NET_TCP_HDR_FLAG_MASK;
tcp_flags_reserved = DEF_BIT_IS_SET_ANY(tcp_flags, NET_TCP_HDR_FLAG_RESERVED);
if (tcp_flags_reserved != DEF_NO) { /* If reserved flag bits set, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrFlagsCtr);
*perr = NET_TCP_ERR_INVALID_FLAG;
return;
}
#endif
pbuf_hdr->TCP_SegSync = DEF_BIT_IS_SET(pbuf_hdr->TCP_HdrLen_Flags, NET_TCP_HDR_FLAG_SYNC );
pbuf_hdr->TCP_SegClose = DEF_BIT_IS_SET(pbuf_hdr->TCP_HdrLen_Flags, NET_TCP_HDR_FLAG_CLOSE);
pbuf_hdr->TCP_SegAck = DEF_BIT_IS_SET(pbuf_hdr->TCP_HdrLen_Flags, NET_TCP_HDR_FLAG_ACK );
pbuf_hdr->TCP_SegReset = DEF_BIT_IS_SET(pbuf_hdr->TCP_HdrLen_Flags, NET_TCP_HDR_FLAG_RESET);
/*$PAGE*/
/* ---------------- VALIDATE TCP OPTS ----------------- */
if (tcp_hdr_len_tot > NET_TCP_HDR_SIZE_MIN) { /* If hdr len > min, validate/process TCP opts. */
NetTCP_RxPktValidateOpt(pbuf_hdr, ptcp_hdr, tcp_hdr_len_tot, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
}
/* --------------- VALIDATE TCP CHK SUM --------------- */
/* See Note #4. */
/* Prepare TCP chk sum pseudo-hdr (see Note #4d). */
tcp_pseudo_hdr.AddrSrc = (NET_IP_ADDR)NET_UTIL_HOST_TO_NET_32(pbuf_hdr->IP_AddrSrc);
tcp_pseudo_hdr.AddrDest = (NET_IP_ADDR)NET_UTIL_HOST_TO_NET_32(pbuf_hdr->IP_AddrDest);
tcp_pseudo_hdr.Zero = (CPU_INT08U )0x00;
tcp_pseudo_hdr.Protocol = (CPU_INT08U )NET_IP_HDR_PROTOCOL_TCP;
tcp_pseudo_hdr.TotLen = (CPU_INT16U )NET_UTIL_HOST_TO_NET_16(pbuf_hdr->TCP_UDP_TotLen);
tcp_chk_sum_valid = NetUtil_16BitOnesCplChkSumDataVerify((void *) pbuf,
(void *)&tcp_pseudo_hdr,
(CPU_INT16U) NET_TCP_PSEUDO_HDR_SIZE,
(NET_ERR *) perr);
if (tcp_chk_sum_valid != DEF_OK) {
NET_CTR_ERR_INC(NetTCP_ErrRxHdrChkSumCtr);
*perr = NET_TCP_ERR_INVALID_CHK_SUM;
return;
}
#if 0 /* See Note #4f. */
(void)NET_UTIL_VAL_GET_NET_16(&ptcp_hdr->ChkSum);
#endif
/* ---------------- CONVERT TCP FIELDS ---------------- */
/* See Note #1c. */
NET_UTIL_VAL_COPY_GET_NET_32(&pbuf_hdr->TCP_SeqNbr, &ptcp_hdr->SeqNbr);
NET_UTIL_VAL_COPY_GET_NET_32(&pbuf_hdr->TCP_AckNbr, &ptcp_hdr->AckNbr);
NET_UTIL_VAL_COPY_GET_NET_16(&pbuf_hdr->TCP_WinSize, &ptcp_hdr->WinSize);
/* ----------------- UPDATE BUF CTRLS ----------------- */
/* Calc TCP data len/ix (see Note #5a). */
pbuf_hdr->TCP_UDP_HdrLen = tcp_hdr_len_tot;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (pbuf_hdr->TCP_UDP_HdrLen > tcp_tot_len) {
NET_CTR_ERR_INC(NetTCP_ErrRxHdrDataLenCtr);
*perr = NET_TCP_ERR_INVALID_LEN_DATA;
return;
}
if (pbuf_hdr->TCP_UDP_HdrLen > pbuf_hdr->DataLen) {
NET_CTR_ERR_INC(NetTCP_ErrRxHdrDataLenCtr);
*perr = NET_TCP_ERR_INVALID_LEN_DATA;
return;
}
#endif
tcp_data_len = tcp_tot_len - pbuf_hdr->TCP_UDP_HdrLen;
pbuf_hdr->TCP_UDP_DataLen = tcp_data_len;
pbuf_hdr->TCP_SegLenInit = pbuf_hdr->TCP_UDP_DataLen;
pbuf_hdr->TCP_SegLen = pbuf_hdr->TCP_SegLenInit;
pbuf_hdr->TCP_SegLenData = pbuf_hdr->TCP_SegLenInit;
pbuf_hdr->TCP_SeqNbrInit = pbuf_hdr->TCP_SeqNbr;
pbuf_hdr->DataLen -= (NET_BUF_SIZE) pbuf_hdr->TCP_UDP_HdrLen;
pbuf_hdr->DataIx = (CPU_INT16U )(pbuf_hdr->TCP_UDP_HdrDataIx + pbuf_hdr->TCP_UDP_HdrLen);
pbuf_hdr->ProtocolHdrType = NET_PROTOCOL_TYPE_APP;
pbuf_next = (NET_BUF *)pbuf_hdr->NextBufPtr;
while (pbuf_next != (NET_BUF *)0) { /* Calc ALL pkt bufs' data len/ix (see Note #5b). */
pbuf_next_hdr = &pbuf_next->Hdr;
pbuf_next_hdr->DataIx = pbuf_next_hdr->TCP_UDP_HdrDataIx;
pbuf_next_hdr->TCP_UDP_HdrLen = 0; /* NULL TCP hdr len in each pkt buf. */
pbuf_next_hdr->TCP_UDP_TotLen = tcp_tot_len; /* Dup TCP tot len & ... */
pbuf_next_hdr->TCP_UDP_DataLen = tcp_data_len; /* ... data len in each pkt buf (see Note #5c). */
pbuf_next_hdr->TCP_SegLenInit = pbuf_next_hdr->TCP_UDP_DataLen;
pbuf_next_hdr->TCP_SegLen = pbuf_next_hdr->TCP_SegLenInit;
pbuf_next_hdr->TCP_SegLenData = pbuf_next_hdr->TCP_SegLenInit;
pbuf_hdr->ProtocolHdrType = NET_PROTOCOL_TYPE_APP;
pbuf_next = (NET_BUF *)pbuf_next_hdr->NextBufPtr;
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktValidateOpt()
*
* Description : Validate & process received packet's TCP options.
*
* Argument(s) : pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* ptcp_hdr Pointer to received packet's TCP header.
* -------- Argument validated in NetTCP_Rx()/NetTCP_RxPktValidateBuf().
*
* tcp_hdr_len_size Length of received packet's TCP header.
* ---------------- Argument validated in NetTCP_RxPktValidate().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP options validated & processed.
* NET_TCP_ERR_INVALID_OPT_LEN Invalid TCP option length.
* NET_TCP_ERR_INVALID_OPT_END Invalid TCP option list ending.
* NET_TCP_ERR_INVALID_OPT_NBR Invalid TCP option number of same option.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktValidate().
*
* Note(s) : (1) (a) See 'net_tcp.h TCP HEADER OPTIONS DEFINES' for supported TCP options' summary.
*
* (b) See 'net_tcp.c Note #1c' for unsupported TCP options.
*
* See also Note #2b3.
*
* (2) (a) RFC # 793, Section 3.1 'Options' states that each option is "a multiple of 8 bits
* in length" and "may begin on any octet boundary".
*
* (1) Since TCP options are NOT required or guaranteed to align multi-octet words on
* appropriate word boundaries, ALL TCP options are decoded & processed a single
* octet at a time.
*
* (b) RFC #1122, Section 4.2.2.5 states that ... :
*
* (1) "A TCP MUST be able to receive a TCP option in any segment."
*
* (2) "A TCP MUST ignore without error any TCP option it does not implement, assuming
* that the option has a field length" ...
*
* (3) "All TCP options defined in the future will have length fields."
*
* See also 'net_tcp.h TCP HEADER OPTIONS DEFINES Note #2b'.
*********************************************************************************************************
*/
static void NetTCP_RxPktValidateOpt (NET_BUF_HDR *pbuf_hdr,
NET_TCP_HDR *ptcp_hdr,
CPU_INT08U tcp_hdr_len_size,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
CPU_INT08U *popts;
CPU_INT08U *popt;
CPU_INT08U opt_list_len_size;
CPU_INT08U opt_list_len_rem;
CPU_INT08U opt_len;
CPU_INT08U opt_nbr_max_seg_size;
CPU_BOOLEAN opt_err;
CPU_BOOLEAN opt_list_end;
opt_list_len_size = tcp_hdr_len_size - NET_TCP_HDR_SIZE_MIN; /* Calc opt list len size. */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* -------- VALIDATE TCP HDR OPT LIST SIZE -------- */
if (opt_list_len_size > NET_TCP_HDR_OPT_SIZE_MAX) { /* If tot opt len > max opt size, ... */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrOptsCtr);
*perr = NET_TCP_ERR_INVALID_OPT_LEN; /* ... rtn err. */
return;
}
if ((opt_list_len_size % NET_TCP_HDR_OPT_SIZE_WORD) != 0) { /* If tot opt len NOT multiple of opt size, ... */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrOptsCtr);
*perr = NET_TCP_ERR_INVALID_OPT_LEN; /* ... rtn err. */
return;
}
#endif
/*$PAGE*/
opt_err = DEF_NO;
opt_list_end = DEF_NO;
opt_nbr_max_seg_size = 0;
popts = (CPU_INT08U *)&ptcp_hdr->Opts[0];
opt_list_len_rem = opt_list_len_size;
/* ------------- DECODE/VALIDATE TCP OPTS ------------- */
while (opt_list_len_rem > 0) { /* Process each opt in list (see Notes #1 & #2). */
switch (*popts) {
case NET_TCP_HDR_OPT_END_LIST: /* ------------------- END OPT LIST ------------------- */
opt_list_end = DEF_YES; /* Mark end of opt list. */
opt_len = NET_TCP_HDR_OPT_LEN_END_LIST;
break;
case NET_TCP_HDR_OPT_NOP: /* --------------------- NOP OPT ---------------------- */
#if 1 /* ???? NOP's invalid after END? */
if (opt_list_end != DEF_NO) { /* If opt found AFTER end of opt list, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrOptsCtr);
*perr = NET_TCP_ERR_INVALID_OPT_END;
return;
}
#endif
opt_len = NET_TCP_HDR_OPT_LEN_NOP;
break;
case NET_TCP_HDR_OPT_MAX_SEG_SIZE: /* ----------------- MAX SEG SIZE OPT ----------------- */
if (opt_list_end != DEF_NO) { /* If opt found AFTER end of opt list, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrOptsCtr);
*perr = NET_TCP_ERR_INVALID_OPT_END;
return;
}
if (opt_nbr_max_seg_size > 0) { /* If > 1 max seg size opt, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrOptsCtr);
*perr = NET_TCP_ERR_INVALID_OPT_NBR;
return;
}
opt_nbr_max_seg_size++;
opt_err = NetTCP_RxPktValidateOptMaxSegSize(pbuf_hdr, popts, &opt_len, perr);
break;
#if 0 /* --------------- UNSUPPORTED TCP OPTS --------------- */
/* See Notes #1b & #2b2. */
case NET_TCP_HDR_OPT_WIN_SCALE:
case NET_TCP_HDR_OPT_SACK_PERMIT:
case NET_TCP_HDR_OPT_SACK:
case NET_TCP_HDR_OPT_ECHO_REQ:
case NET_TCP_HDR_OPT_ECHO_REPLY:
case NET_TCP_HDR_OPT_TS:
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'default'. */
#endif
default: /* ----------------- UNKNOWN TCP OPTS ----------------- */
popt = popts;
popt++;
opt_len = *popt; /* Validate opt len (see Note #2b3). */
if (opt_len < NET_TCP_HDR_OPT_LEN_MIN_LEN) { /* If opt len < min opt len, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrOptsCtr);
*perr = NET_TCP_ERR_INVALID_OPT_LEN;
return;
}
break;
}
if (opt_err != DEF_NO) { /* If ANY opt errs, rtn err. */
return;
}
if (opt_len > opt_list_len_rem) { /* If opt len > rem opt list len, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrOptsCtr);
*perr = NET_TCP_ERR_INVALID_OPT_LEN;
return;
}
opt_list_len_rem -= opt_len;
popts += opt_len;
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktValidateOptMaxSegSize()
*
* Description : Validate & process received TCP Maximum Segment Size option.
*
* Argument(s) : pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* popt Pointer to Maximum Segment Size option.
* ---- Argument validated in NetTCP_RxPktValidateOpt().
*
* popt_len Pointer to variable that will receive the TCP option length (in octets).
* -------- Argument validated in NetTCP_RxPktValidateOpt().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP option validated & processed.
* NET_TCP_ERR_INVALID_OPT_LEN Invalid TCP option length.
*
* Return(s) : DEF_NO, NO Maximum Segment Size option error.
*
* DEF_YES, otherwise.
*
* Caller(s) : NetTCP_RxPktValidateOpt().
*
* Note(s) : (1) See 'net_tcp.h TCP HEADER OPTIONS DEFINES Note #2b1' for TCP Maximum Segment Size
* option summary.
*
* (2) (a) RFC # 793, Section 3.1 'Options' states that each option is "a multiple of 8 bits
* in length" and "may begin on any octet boundary".
*
* (b) Since TCP options are NOT required or guaranteed to align multi-octet words on
* appropriate word boundaries, ALL TCP options are decoded & processed a single
* octet at a time.
*********************************************************************************************************
*/
static CPU_BOOLEAN NetTCP_RxPktValidateOptMaxSegSize (NET_BUF_HDR *pbuf_hdr,
CPU_INT08U *popt,
CPU_INT08U *popt_len,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_SEG_SIZE max_seg_size;
*popt_len = NET_TCP_HDR_OPT_LEN_MAX_SEG_SIZE;
popt++;
if (*popt != *popt_len) { /* If opt len != max seg size opt len, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrOptsCtr);
*perr = NET_TCP_ERR_INVALID_OPT_LEN;
return (DEF_YES);
}
/* Calc max seg size (see Note #2b). */
popt++;
max_seg_size = *popt;
max_seg_size <<= DEF_OCTET_NBR_BITS;
popt++;
max_seg_size += *popt;
if (max_seg_size > NET_TCP_MAX_SEG_SIZE_MAX) { /* If max seg size > max, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrRxHdrOptsCtr);
*perr = NET_TCP_ERR_INVALID_OPT_LEN;
return (DEF_YES);
}
pbuf_hdr->TCP_MaxSegSize = (CPU_INT16U)max_seg_size;
*perr = NET_TCP_ERR_NONE;
return (DEF_NO);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktDemuxSeg()
*
* Description : (1) Demultiplex received packet to appropriate TCP connection :
*
* (a) Search connection lists for connection whose local &/or remote addresses are
* identical to the received packet's destination & source addresses.
*
* (b) Update network buffer's connection controls.
*
*
* Argument(s) : pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE Received packet successfully demultiplexed
* to appropriate TCP connection.
* NET_CONN_ERR_INVALID_FAMILY Invalid network connection family.
* NET_CONN_ERR_INVALID_CONN Invalid network connection number(s).
* NET_ERR_RX_DEST Invalid destination; no connection available
* for received packet.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_Rx().
*
* Note(s) : (2) The 'SRCH CONN LIST(S) FOR PKT/CONN ADDR(S)' pre-processor 'else'-conditional code will
* never be compiled/linked since 'net_conn.h' ensures that the family type configuration
* constant (NET_CONN_CFG_FAMILY) is configured with an appropriate family type value
* (see 'net_conn.h CONFIGURATION ERRORS'). The 'else'-conditional code is included for
* completeness & as an extra precaution in case 'net_conn.h' is incorrectly modified.
*
* (3) (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : CLOSED [State]' states
* that "an incoming segment ... causes a RST to be sent in response".
*
* (b) RFC #792, Section 'Destination Unreachable Message : Description' states that
* "if, in the destination host, the IP module cannot deliver the datagram because
* the indicated ... process port is not active, the destination host may send a
* destination unreachable message to the source host".
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_RxPktDemuxSeg (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
NET_IP_ADDR addr_ip;
#endif
CPU_INT08U addr_local[NET_CONN_CFG_ADDR_LEN];
CPU_INT08U addr_remote[NET_CONN_CFG_ADDR_LEN];
NET_TCP_PORT_NBR port_nbr;
NET_CONN_LIST_IX protocol_ix;
NET_CONN_FAMILY family;
NET_CONN_ID conn_id;
NET_CONN_ID conn_id_transport;
NET_CONN_ID conn_id_app;
NET_ERR err;
/* ---- SRCH CONN LIST(S) FOR PKT/CONN ADDR(S) ---- */
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
family = NET_CONN_FAMILY_IP_V4_SOCK;
protocol_ix = NET_CONN_LIST_IX_IP_V4_SOCK_TCP;
/* Cfg srch local addr as pkt dest addr. */
port_nbr = (NET_TCP_PORT_NBR)NET_UTIL_HOST_TO_NET_16(pbuf_hdr->TCP_UDP_PortDest);
addr_ip = (NET_IP_ADDR )NET_UTIL_HOST_TO_NET_32(pbuf_hdr->IP_AddrDest);
Mem_Copy((void *)&addr_local[NET_CONN_ADDR_IP_IX_PORT],
(void *)&port_nbr,
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_PORT);
Mem_Copy((void *)&addr_local[NET_CONN_ADDR_IP_IX_ADDR],
(void *)&addr_ip,
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_ADDR);
/* Cfg srch remote addr as pkt src addr. */
port_nbr = (NET_TCP_PORT_NBR)NET_UTIL_HOST_TO_NET_16(pbuf_hdr->TCP_UDP_PortSrc);
addr_ip = (NET_IP_ADDR )NET_UTIL_HOST_TO_NET_32(pbuf_hdr->IP_AddrSrc);
Mem_Copy((void *)&addr_remote[NET_CONN_ADDR_IP_IX_PORT],
(void *)&port_nbr,
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_PORT);
Mem_Copy((void *)&addr_remote[NET_CONN_ADDR_IP_IX_ADDR],
(void *)&addr_ip,
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_ADDR);
#else /* See Note #2. */
*perr = NET_CONN_ERR_INVALID_FAMILY;
return;
#endif
/*$PAGE*/
conn_id = NetConn_Srch((NET_CONN_FAMILY ) family, /* Srch for TCP conn whose local/remote addrs ... */
(NET_CONN_LIST_IX ) protocol_ix, /* ... are identical to pkt dest/src addrs. */
(NET_CONN_LIST_TYPE) NET_CONN_LIST_TYPE_ALL,
(CPU_BOOLEAN ) DEF_YES,
(CPU_INT08U *)&addr_local[0],
(CPU_INT08U *)&addr_remote[0],
(NET_CONN_ADDR_LEN ) NET_CONN_CFG_ADDR_LEN,
(NET_CONN_ID *)&conn_id_transport,
(NET_CONN_ID *)&conn_id_app);
if (conn_id == NET_CONN_ID_NONE) { /* If complete TCP conn NOT found, .. */
conn_id = NetConn_Srch((NET_CONN_FAMILY ) family, /* .. srch for TCP half-conn whose local addr .. */
(NET_CONN_LIST_IX ) protocol_ix, /* .. is identical to pkt dest addr. */
(NET_CONN_LIST_TYPE) NET_CONN_LIST_TYPE_ALL,
(CPU_BOOLEAN ) DEF_NO,
(CPU_INT08U *)&addr_local[0],
(CPU_INT08U *) 0,
(NET_CONN_ADDR_LEN ) NET_CONN_CFG_ADDR_LEN,
(NET_CONN_ID *)&conn_id_transport,
(NET_CONN_ID *)&conn_id_app);
if (conn_id == NET_CONN_ID_NONE) { /* If NO TCP conn found, ... */
NetTCP_TxConnReset((NET_TCP_CONN *) 0, /* ... tx TCP conn reset (see Note #3a), ... */
(NET_BUF_HDR *) pbuf_hdr,
(NET_TCP_RESET_CODE) NET_TCP_CONN_TX_RESET,
(NET_TCP_CLOSE_CODE) NET_TCP_CONN_CLOSE_ALL,
(NET_ERR *)&err);
NetICMP_TxMsgErr(pbuf, /* ... tx ICMP port unreach (see Note #3b), ... */
NET_ICMP_MSG_TYPE_DEST_UNREACH,
NET_ICMP_MSG_CODE_DEST_PORT,
NET_ICMP_MSG_PTR_NONE,
&err);
NET_CTR_ERR_INC(NetTCP_ErrRxDestCtr);
*perr = NET_ERR_RX_DEST; /* ... & rtn dest err. */
return;
} else {
pbuf_hdr->ConnType = NET_CONN_TYPE_CONN_HALF;
}
} else {
pbuf_hdr->ConnType = NET_CONN_TYPE_CONN_FULL;
}
/* ------------ UPDATE BUF CONN CTRLS ------------- */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (conn_id == NET_CONN_ID_NONE) {
*perr = NET_CONN_ERR_INVALID_CONN;
return;
}
if (conn_id_transport == NET_CONN_ID_NONE) {
*perr = NET_CONN_ERR_INVALID_CONN;
return;
}
#endif
pbuf_hdr->Conn_ID = (CPU_INT16S)conn_id;
pbuf_hdr->Conn_ID_Transport = (CPU_INT16S)conn_id_transport;
pbuf_hdr->Conn_ID_App = (CPU_INT16S)conn_id_app;
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandler()
*
* Description : (1) Handle received TCP packets for its TCP connection :
*
* (a) Demultiplex TCP packet to appropriate TCP connection state handler
* (b) Free/Discard TCP packet
* (c) Update receive statistics See Note #2
*
*
* Argument(s) : pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO
* data queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled & valid
* data queued for later processing.
* NET_TCP_ERR_CONN_RESET_VALID Received reset segment successfully handled;
* i.e. the TCP connection was reset.
* NET_TCP_ERR_CONN_CLOSED TCP connection successfully closed.
*
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
*
* ---- RETURNED BY NetTCP_ConnIsUsed() : -----
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_INVALID_CONN Invalid TCP connection number.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
*
* --- RETURNED BY NetTCP_RxPktDiscard() : ----
* NET_ERR_RX Receive error; packet discarded.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_Rx().
*
* Note(s) : (2) (a) SOME TCP receive statistics updated in NetTCP_RxPktDiscard(); do NOT re-update.
*
* (b) Update TCP receive statistics even if any transitory transmit error(s) occur in
* TCP connection state handler functions.
*
* (3) RFC #1122, Section 4.2.2.13 states that "a host MAY implement a 'half-duplex' TCP
* close sequence ... i.e., closed in only one direction, and a host is permitted to
* continue sending data in the open direction on a half-closed connection".
*
* (a) "A host ... that has called CLOSE cannot continue to read data from the
* connection. If such a host issues a CLOSE call while received data is
* still pending ... its TCP SHOULD send a RST to show that data was lost."
*
* However, since it does NOT seem reasonable to allow a half-closed connection
* "to continue sending data in the open direction" (i.e. from the host that did
* NOT issue a CLOSE call) but prevent the receiving host (i.e. the host that DID
* issue the CLOSE call) from receiving the transmitted data; it is assumed that
* the host that issued the CLOSE call MUST be allowed to receive data transmitted
* from the other host that has NOT yet issued its CLOSE.
*
* (b) However, "if such a host issues a CLOSE call ... [and] new data is received
* after CLOSE is called, its TCP SHOULD send a RST to show that data was lost".
*
* In other words, since a TCP connection in the connection-closing-data-available
* state is closed to further TCP data or controls, a TCP reset is transmitted as
* for the CLOSED state.
*
* (c) "Some systems have not implemented half-closed connections."
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_RxPktConnHandler (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if (((NET_CTR_CFG_STAT_EN == DEF_ENABLED) || \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED)) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_CONN_ID conn_id_tcp;
NET_TCP_CONN *pconn;
NET_ERR err;
conn_id_tcp = (NET_TCP_CONN_ID)pbuf_hdr->Conn_ID_Transport;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* -------------- VALIDATE TCP CONN USED -------------- */
(void)NetTCP_ConnIsUsed(conn_id_tcp, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
#endif
/*$PAGE*/
pconn = &NetTCP_ConnTbl[conn_id_tcp];
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_LISTEN:
NetTCP_RxPktConnHandlerListen(pconn, pbuf, pbuf_hdr, perr);
switch (*perr) {
case NET_TCP_ERR_CONN_DATA_NONE:
NetTCP_RxPktFree(pbuf);
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_ERR_CONN_DATA_VALID'. */
case NET_TCP_ERR_CONN_DATA_VALID:
NET_CTR_STAT_INC(NetTCP_StatRxSegProcessedCtr);
break;
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_SEQ_INVALID:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_RESET_INVALID:
case NET_TCP_ERR_CONN_SEQ_FIN_INVALID:
case NET_TCP_ERR_CONN_LISTEN_Q_MAX:
case NET_TCP_ERR_INVALID_CONN_ID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_ERR_TX:
case NET_CONN_ERR_NOT_USED:
case NET_CONN_ERR_INVALID_CONN:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
NetTCP_RxPktConnHandlerSyncRxd(pconn, pbuf, pbuf_hdr, perr);
switch (*perr) {
case NET_TCP_ERR_CONN_RESET_VALID:
case NET_TCP_ERR_CONN_DATA_NONE:
NetTCP_RxPktFree(pbuf);
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_ERR_CONN_DATA_VALID'. */
case NET_TCP_ERR_CONN_DATA_VALID:
NET_CTR_STAT_INC(NetTCP_StatRxSegProcessedCtr);
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_SEQ_SYNC_INVALID:
case NET_TCP_ERR_CONN_SEQ_INVALID:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_RESET_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_CONN_DATA_DUP:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
case NET_TCP_ERR_NONE_AVAIL:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_SYNC_TXD:
NetTCP_RxPktConnHandlerSyncTxd(pconn, pbuf, pbuf_hdr, perr);
switch (*perr) {
case NET_TCP_ERR_CONN_RESET_VALID:
case NET_TCP_ERR_CONN_DATA_NONE:
NetTCP_RxPktFree(pbuf);
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_ERR_CONN_DATA_VALID'. */
case NET_TCP_ERR_CONN_DATA_VALID:
NET_CTR_STAT_INC(NetTCP_StatRxSegProcessedCtr);
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_SEQ_INVALID:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_RESET_INVALID:
case NET_TCP_ERR_CONN_SEQ_FIN_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_CONN_DATA_DUP:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
case NET_TCP_ERR_NONE_AVAIL:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_CONN_STATE_CONN:
NetTCP_RxPktConnHandlerConn(pconn, pbuf, pbuf_hdr, perr);
switch (*perr) {
case NET_TCP_ERR_CONN_RESET_VALID:
case NET_TCP_ERR_CONN_DATA_NONE:
NetTCP_RxPktFree(pbuf);
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_ERR_CONN_DATA_VALID'. */
case NET_TCP_ERR_CONN_DATA_VALID:
NET_CTR_STAT_INC(NetTCP_StatRxSegProcessedCtr);
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_SEQ_SYNC_INVALID:
case NET_TCP_ERR_CONN_SEQ_INVALID:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_RESET_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_CONN_DATA_DUP:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
case NET_TCP_ERR_NONE_AVAIL:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_FIN_WAIT_1:
NetTCP_RxPktConnHandlerFinWait1(pconn, pbuf, pbuf_hdr, perr);
switch (*perr) {
case NET_TCP_ERR_CONN_RESET_VALID:
case NET_TCP_ERR_CONN_DATA_NONE:
NetTCP_RxPktFree(pbuf);
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_ERR_CONN_DATA_VALID'. */
case NET_TCP_ERR_CONN_DATA_VALID:
NET_CTR_STAT_INC(NetTCP_StatRxSegProcessedCtr);
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_SEQ_SYNC_INVALID:
case NET_TCP_ERR_CONN_SEQ_INVALID:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_RESET_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_CONN_DATA_DUP:
case NET_TCP_ERR_INVALID_CONN_ID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
case NET_TCP_ERR_NONE_AVAIL:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
case NET_CONN_ERR_INVALID_CONN:
case NET_CONN_ERR_NOT_USED:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_CONN_STATE_FIN_WAIT_2:
NetTCP_RxPktConnHandlerFinWait2(pconn, pbuf, pbuf_hdr, perr);
switch (*perr) {
case NET_TCP_ERR_CONN_RESET_VALID:
case NET_TCP_ERR_CONN_DATA_NONE:
NetTCP_RxPktFree(pbuf);
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_ERR_CONN_DATA_VALID'. */
case NET_TCP_ERR_CONN_DATA_VALID:
NET_CTR_STAT_INC(NetTCP_StatRxSegProcessedCtr);
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_SEQ_SYNC_INVALID:
case NET_TCP_ERR_CONN_SEQ_INVALID:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_RESET_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_CONN_DATA_DUP:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_NONE_AVAIL:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_CLOSING:
NetTCP_RxPktConnHandlerClosing(pconn, pbuf, pbuf_hdr, perr);
switch (*perr) {
case NET_TCP_ERR_CONN_RESET_VALID:
case NET_TCP_ERR_CONN_DATA_NONE:
NetTCP_RxPktFree(pbuf);
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_ERR_CONN_DATA_VALID'. */
case NET_TCP_ERR_CONN_DATA_VALID:
NET_CTR_STAT_INC(NetTCP_StatRxSegProcessedCtr);
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_SEQ_SYNC_INVALID:
case NET_TCP_ERR_CONN_SEQ_INVALID:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_RESET_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_CONN_DATA_DUP:
case NET_TCP_ERR_INVALID_CONN_ID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
case NET_TCP_ERR_NONE_AVAIL:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
case NET_CONN_ERR_INVALID_CONN:
case NET_CONN_ERR_NOT_USED:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_CONN_STATE_TIME_WAIT:
NetTCP_RxPktConnHandlerTimeWait(pconn, pbuf, pbuf_hdr, perr);
switch (*perr) {
case NET_TCP_ERR_CONN_RESET_VALID:
case NET_TCP_ERR_CONN_DATA_NONE:
NetTCP_RxPktFree(pbuf);
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_ERR_CONN_DATA_VALID'. */
case NET_TCP_ERR_CONN_DATA_VALID:
NET_CTR_STAT_INC(NetTCP_StatRxSegProcessedCtr);
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_SEQ_SYNC_INVALID:
case NET_TCP_ERR_CONN_SEQ_INVALID:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_RESET_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_CONN_DATA_DUP:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_NONE_AVAIL:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_CLOSE_WAIT:
NetTCP_RxPktConnHandlerCloseWait(pconn, pbuf, pbuf_hdr, perr);
switch (*perr) {
case NET_TCP_ERR_CONN_RESET_VALID:
case NET_TCP_ERR_CONN_DATA_NONE:
NetTCP_RxPktFree(pbuf);
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_ERR_CONN_DATA_VALID'. */
case NET_TCP_ERR_CONN_DATA_VALID:
NET_CTR_STAT_INC(NetTCP_StatRxSegProcessedCtr);
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_SEQ_SYNC_INVALID:
case NET_TCP_ERR_CONN_SEQ_INVALID:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_RESET_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_CONN_DATA_DUP:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
case NET_TCP_ERR_NONE_AVAIL:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_CONN_STATE_LAST_ACK:
NetTCP_RxPktConnHandlerLastAck(pconn, pbuf, pbuf_hdr, perr);
switch (*perr) {
case NET_TCP_ERR_CONN_RESET_VALID:
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_CLOSED:
NetTCP_RxPktFree(pbuf);
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_ERR_CONN_DATA_VALID'. */
case NET_TCP_ERR_CONN_DATA_VALID:
NET_CTR_STAT_INC(NetTCP_StatRxSegProcessedCtr);
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_SEQ_SYNC_INVALID:
case NET_TCP_ERR_CONN_SEQ_INVALID:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_RESET_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_CONN_DATA_DUP:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
case NET_TCP_ERR_NONE_AVAIL:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NetTCP_TxConnReset((NET_TCP_CONN *) 0, /* Tx TCP conn reset (see Note #3b). */
(NET_BUF_HDR *) pbuf_hdr,
(NET_TCP_RESET_CODE) NET_TCP_CONN_TX_RESET,
(NET_TCP_CLOSE_CODE) NET_TCP_CONN_CLOSE_ALL,
(NET_ERR *)&err);
NetTCP_RxPktDiscard(pbuf, perr);
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
case NET_TCP_CONN_STATE_CLOSED:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerListen()
*
* Description : (1) Handle TCP connection in LISTEN state :
*
* (a) Validate received TCP packet for current TCP connection state :
*
* (1) Reset (RST) See Note #2a
* (2) Acknowledgement (ACK) See Note #2b
* (3) Synchronization (SYN) See Note #2c
*
* (b) Check if TCP connection listen queue is available See Note #3
*
* (c) Prepare/configure TCP connection :
*
* (1) Clone new TCP connection from current TCP listen connection, See Note #5a
* if half-connection :
*
* (A) Get connections
* (B) Set connection identification handles
* (C) Set connection addresses
* (D) Add connection into connection list
* (E) Copy connection from half-connection
*
* (2) Re-configure current TCP listen connection, See Note #5b
* if full-connection
*
* (d) Update TCP connection :
* (1) Handle received TCP segment See Note #2c2
* (2) Configure TCP connection remote host maximum segment size See Note #7
*
* (e) Transmit TCP connection synchronization for valid received See Note #2c3
* TCP connection reqeusts
*
* (f) Update TCP connection state See Note #2c
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_ACK_INVALID Received segment's acknowledgement number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_SEQ_FIN_INVALID Received segment's finish/close flag is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_RESET_INVALID Received segment's reset flag is
* NOT valid for current TCP connection.
*
* NET_TCP_ERR_CONN_LISTEN_Q_MAX TCP connection listen queue is NOT available
* queue a new connection.
*
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
*
* NET_CONN_ERR_INVALID_FAMILY Invalid network connection family.
*
* ------ RETURNED BY NetTCP_RxPktConnIsValidReset() : ------
* ------- RETURNED BY NetTCP_RxPktConnIsValidAck() : -------
* ------- RETURNED BY NetTCP_RxPktConnIsValidSeq() : -------
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* - RETURNED BY NetTCP_RxPktConnHandlerListenQ_IsAvail() : -
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_INVALID_CONN_ID Invalid application connection.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
* NET_CONN_ERR_INVALID_CONN Invalid network connection number.
* NET_CONN_ERR_NOT_USED Network connection NOT currently used.
*
* ----------- RETURNED BY NetTCP_TxConnSync() : ------------
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
* NET_TCP_ERR_TX TCP transmit error.
* NET_ERR_TX Transmit error.
*
* ------- RETURNED BY NetTCP_RxPktConnHandlerSeg() : -------
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO
* data queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled & valid
* data queued for later processing (see Note #2c2).
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandler().
*$PAGE*
* Note(s) : (2) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State]' states that :
*
* (a) "An incoming RST should be ignored."
*
* (b) "Any acknowledgment is bad if it arrives on a connection still in the LISTEN state.
* An acceptable reset segment should be formed for any arriving ACK-bearing segment."
*
* (c) "If the SYN bit is set ... the connection state should be changed to SYN-RECEIVED" ...
*
* (1) "Set RCV.NXT to SEG.SEQ+1, IRS is set to SEG.SEQ ..."
* (A) See Note #2c3
*
* (2) "And any other control or text should be queued for processing later."
*
* (A) If any control or text is queued for later processing, the next sequence octet to
* receive (RCV.NXT) MUST include the length of this received segment (SEG.LEN) :
*
* (1) RCV.NXT = SEG.SEQ + SEG.LEN + 1
*
* (3) "ISS should be selected and a SYN segment sent."
*
* (d) "Any other control or text-bearing segment (not containing SYN) must have an ACK and
* thus would be discarded by the ACK processing ... So you are unlikely to get here,
* but if you do, drop the segment, and return."
*
* (e) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states to
* "not process the FIN if the state is CLOSED, LISTEN or SYN-SENT since the SEG.SEQ cannot
* be validated; drop the segment".
*
* (3) (a) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 18.11, Pages 257-258 states
* that :
*
* (1) "Each listening end point has a fixed length queue of connections that have been
* accepted by TCP (i.e., the three-way handshake is complete), but not yet accepted
* by the application."
*
* (3) "When a connection request arrives (i.e., the SYN segment), ... the current number
* of connections already queued for this listening end point [is checked] to see
* whether to accept the connection or not."
*
* (4) "If there is room on this listening end point's queue for this new connection, ...
* the TCP module ACKs the SYN and completes the connection."
*
* (5) "If there is not room on the queue for the new connection" ... :
*
* (A) "TCP just ignores the received SYN."
* (B) "Nothing is sent back (i.e., no RST segment)."
*
* (b) (A) Wright/Stevens, TCP/IP Illustrated, Volume 2, 3rd Printing, Section 15.9, Page 455
* reiterates that :
*
* (2) A "listen ... socket ... limit[s] ... the number of connections that can be
* queued on the socket," ...
*
* (5) "after which the socket layer refuses to queue additional connection requests.
* When this occurs, TCP ignores incoming connection requests."
*
* (B) Wright/Stevens, TCP/IP Illustrated, Volume 2, 3rd Printing, Section 28.2, Page 930
* also states that :
*
* (5) (A) "By silently dropping the segment" ...
* (B) "and not replying with an RST," ...
* (C) "The client's connection request should time out, causing the client to
* retransmit the SYN."
*
* (C) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 18.11, Pages 259-260
* summarizes that :
*
* (5) (A) "TCP ignores the incoming SYN when the queue is full," ...
* (B) "and doesn't respond with an RST," ...
*
* (C) (1) "because ... this condition could change in a short while ... [and] by
* ignoring the SYN, the server forces the client TCP to re-transmit the
* SYN later, hoping that the queue will then have room for the new
* connection".
*
* (2) Whereas page 259-260 counters that "if the server's TCP responded with
* a reset, the client's active open would abort".
*
* See also 'NetTCP_RxPktConnHandlerListenQ_IsAvail() Note #1'.
*$PAGE*
* (4) The 'NET_CONN_CFG_FAMILY' pre-processor 'else'-conditional code will never be compiled/linked
* since 'net_conn.h' ensures that the family type configuration constant (NET_CONN_CFG_FAMILY)
* is configured with an appropriate family type value (see 'net_conn.h CONFIGURATION ERRORS').
* The 'else'-conditional code is included for completeness & as an extra precaution in case
* 'net_conn.h' is incorrectly modified.
*
* (5) (a) (1) If any received TCP connection request to a LISTEN-state connection is a half-connection
* -- i.e. a connection with ONLY the local address specified/configured -- then a new
* connection is cloned from the LISTEN-state connection to handle each unique connection
* request.
*
* (2) The following connection parameters are cloned/copied from the LISTEN-state connection :
*
* (A) Application connection handle identifier
* (1) When the cloned connection is fully connected/established, it is queued to the
* LISTEN-state connection's application connection as a cloned network connection
* until the connection is accepted & a new application connection is created.
*
* See also 'net_sock.c NetSock_Accept() Notes #1d & #1e'.
*
* (B) (1) TCP connection receive parameters
* (2) TCP connection transmit parameters
* (3) TCP connection timeout values
*
* See also 'NetTCP_ConnCopy() Note #1'.
*
* (b) If any received TCP connection request to a LISTEN-state connection is a full-connection --
* i.e. a connection with BOTH the local & remote addresses specified/configured -- then the
* LISTEN-state connection is re-configured to handle the received connection request.
*
* (6) On ANY TCP LISTEN-connection preparation errors, network resources MUST be appropriately freed :
*
* (a) If NO TCP connections available, NO resources need be freed.
* (b) If NO network connections available, ONLY the TCP connection need be closed.
* (c) If network connection preparation fails, the TCP & network connection MUST both
* be closed. However, the TCP connection need NOT close application connection(s).
*
* See also 'NetTCP_ConnCloseHandler() Note #2b1C1'.
*
* (d) If any remaining TCP connection preparation fails, the TCP & network connection MUST
* both be closed. The application connection(s) SHOULD NOT be closed since it is cloned
* from the LISTEN-state connection (see Note #4), but network connections MAY need to be
* de-referenced from the application connection(s).
*
* See also 'NetTCP_ConnCloseHandler() Note #2b';
* & 'net_conn.c NetConn_CloseApp() Note #1'
* & 'net_sock.c NetSock_FreeConnFromSock() Note #2'.
*
* (7) RFC #1122, Section 4.2.2.6 states that ... :
*
* (a) A "TCP SHOULD send an MSS (Maximum Segment Size) option in every SYN segment".
*
* (b) "If an MSS option is not received at connection setup, TCP MUST assume a default
* send MSS of 536."
*
* (8) TCP connection timeout for LISTEN state is implemented by TCP connection retransmission
* function(s) (see 'NetTCP_TxConnReTxQ() Note #3c').
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_RxPktConnHandlerListen (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
NET_IP_ADDR addr_ip;
#endif
CPU_INT08U addr_local[NET_CONN_CFG_ADDR_LEN];
CPU_INT08U addr_remote[NET_CONN_CFG_ADDR_LEN];
CPU_BOOLEAN q_avail;
NET_TCP_SEQ_CODE seq_code;
NET_TCP_ACK_CODE ack_code;
NET_TCP_RESET_CODE reset_code;
NET_TCP_PORT_NBR port_nbr;
NET_CONN_FAMILY conn_family;
NET_CONN_LIST_IX conn_protocol_ix;
NET_CONN_ID conn_id;
NET_CONN_ID conn_id_clone;
NET_CONN_ID conn_id_clone_app;
NET_TCP_CONN_ID conn_id_clone_tcp;
NET_TCP_CONN *pconn_clone;
NET_TCP_CONN *pconn_tx_sync;
NET_ERR err;
NET_ERR err_rtn;
/* ---------- VALIDATE RX'D TCP PKT ----------- */
/* Chk for rx'd fin/close. */
if (pbuf_hdr->TCP_SegClose != DEF_NO) { /* If invalid fin/close rx'd, ... */
*perr = NET_TCP_ERR_CONN_SEQ_FIN_INVALID;
return; /* ... ignore TCP pkt (see Note #2e). */
}
/* Chk for rx'd reset. */
reset_code = NetTCP_RxPktConnIsValidReset(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
if (reset_code != NET_TCP_CONN_RX_RESET_NONE) { /* If reset rx'd, ... */
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return; /* ... ignore TCP pkt (see Note #2a). */
}
/* Chk for rx'd ack. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
if (ack_code != NET_TCP_CONN_RX_ACK_NONE) { /* If ack rx'd, ... */
/* ... tx TCP conn reset (see Note #2b). */
NetTCP_TxConnReset(pconn, pbuf_hdr, NET_TCP_CONN_TX_RESET, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return;
}
/* Chk rx'd seq nbr. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
if (seq_code != NET_TCP_CONN_RX_SEQ_SYNC) { /* If sync NOT rx'd, ... */
*perr = NET_TCP_ERR_CONN_SEQ_INVALID;
return; /* ... ignore TCP pkt (see Note #2d). */
}
/* Else sync avail, update seg lens. */
pbuf_hdr->TCP_SegLenInit += NET_TCP_SEG_LEN_SYNC;
pbuf_hdr->TCP_SegLen += NET_TCP_SEG_LEN_SYNC;
/*$PAGE*/
/* ---------- CHK TCP CONN LISTEN Q ----------- */
q_avail = NetTCP_RxPktConnHandlerListenQ_IsAvail(pconn, perr); /* Chk TCP listen Q avail. */
if (*perr != NET_TCP_ERR_NONE) {
return;
}
if (q_avail != DEF_YES) { /* If TCP listen Q NOT avail (see Note #3a5), */
*perr = NET_TCP_ERR_CONN_LISTEN_Q_MAX;
return; /* ... ignore TCP pkt (see Note #3a5A). */
}
/* ------------- PREPARE TCP CONN ------------- */
if (pbuf_hdr->ConnType != NET_CONN_TYPE_CONN_FULL) { /* If pkt demux'd to half-conn, clone new conn */
/* .. from LISTEN half-conn (see Note #5a). */
/* ---------------- GET CONNS ----------------- */
conn_id_clone_tcp = NetTCP_ConnGet(&err);
if ( err != NET_TCP_ERR_NONE) { /* See Note #6a. */
*perr = NET_TCP_ERR_NONE_AVAIL;
return;
}
pconn_clone = &NetTCP_ConnTbl[conn_id_clone_tcp];
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
conn_family = NET_CONN_FAMILY_IP_V4_SOCK;
conn_protocol_ix = NET_CONN_LIST_IX_IP_V4_SOCK_TCP;
#else /* See Notes #4 & #6d. */
NetTCP_ConnClose(pconn_clone, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_CONN_ERR_INVALID_FAMILY;
return;
#endif
conn_id_clone = NetConn_Get(conn_family, conn_protocol_ix, &err);
if ( err != NET_CONN_ERR_NONE) { /* See Note #6b. */
NetTCP_ConnClose(pconn_clone, pbuf_hdr, DEF_NO, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_NONE_AVAIL;
return;
}
/* --------------- SET CONN IDs --------------- */
pconn_clone->ID_Conn = conn_id_clone;
NetConn_ID_TransportSet((NET_CONN_ID) conn_id_clone,
(NET_CONN_ID) conn_id_clone_tcp,
(NET_ERR *)&err);
if ( err != NET_CONN_ERR_NONE) { /* See Note #6c. */
NetTCP_ConnClose(pconn_clone, pbuf_hdr, DEF_NO, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
conn_id = pconn->ID_Conn;
conn_id_clone_app = NetConn_ID_AppGet((NET_CONN_ID) conn_id, /* Get half-conn's app conn id & ... */
(NET_ERR *)&err);
if ( err != NET_CONN_ERR_NONE) { /* See Note #6c. */
NetTCP_ConnClose(pconn_clone, pbuf_hdr, DEF_NO, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
NetConn_ID_AppCloneSet((NET_CONN_ID) conn_id_clone, /* ... set as cloned conn's ... */
(NET_CONN_ID) conn_id_clone_app, /* ... app conn clone id (see Note #5a2A1). */
(NET_ERR *)&err);
if ( err != NET_CONN_ERR_NONE) { /* See Note #6c. */
NetTCP_ConnClose(pconn_clone, pbuf_hdr, DEF_NO, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
/*$PAGE*/
/* -------------- CFG CONN ADDRS -------------- */
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
/* Cfg local addr as pkt dest addr. */
port_nbr = (NET_TCP_PORT_NBR)NET_UTIL_HOST_TO_NET_16(pbuf_hdr->TCP_UDP_PortDest);
addr_ip = (NET_IP_ADDR )NET_UTIL_HOST_TO_NET_32(pbuf_hdr->IP_AddrDest);
Mem_Copy((void *)&addr_local[NET_CONN_ADDR_IP_IX_PORT],
(void *)&port_nbr,
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_PORT);
Mem_Copy((void *)&addr_local[NET_CONN_ADDR_IP_IX_ADDR],
(void *)&addr_ip,
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_ADDR);
/* Cfg remote addr as pkt src addr. */
port_nbr = (NET_TCP_PORT_NBR)NET_UTIL_HOST_TO_NET_16(pbuf_hdr->TCP_UDP_PortSrc);
addr_ip = (NET_IP_ADDR )NET_UTIL_HOST_TO_NET_32(pbuf_hdr->IP_AddrSrc);
Mem_Copy((void *)&addr_remote[NET_CONN_ADDR_IP_IX_PORT],
(void *)&port_nbr,
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_PORT);
Mem_Copy((void *)&addr_remote[NET_CONN_ADDR_IP_IX_ADDR],
(void *)&addr_ip,
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_ADDR);
#else /* See Notes #4 & #6d. */
NetTCP_ConnClose(pconn_clone, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_CONN_ERR_INVALID_FAMILY;
return;
#endif
NetConn_AddrLocalSet((NET_CONN_ID ) conn_id_clone,
(CPU_INT08U *)&addr_local[0],
(NET_CONN_ADDR_LEN) NET_CONN_CFG_ADDR_LEN,
(CPU_BOOLEAN ) DEF_NO,
(NET_ERR *)&err);
if ( err != NET_CONN_ERR_NONE) { /* See Note #6c. */
NetTCP_ConnClose(pconn_clone, pbuf_hdr, DEF_NO, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
NetConn_AddrRemoteSet((NET_CONN_ID ) conn_id_clone,
(CPU_INT08U *)&addr_remote[0],
(NET_CONN_ADDR_LEN) NET_CONN_CFG_ADDR_LEN,
(CPU_BOOLEAN ) DEF_NO,
(NET_ERR *)&err);
if ( err != NET_CONN_ERR_NONE) { /* See Note #6c. */
NetTCP_ConnClose(pconn_clone, pbuf_hdr, DEF_NO, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
/* Add conn into server conn list. */
NetConn_ListAdd(conn_id_clone, NET_CONN_LIST_TYPE_SERVER, &err);
if ( err != NET_CONN_ERR_NONE) { /* See Note #6c. */
NetTCP_ConnClose(pconn_clone, pbuf_hdr, DEF_NO, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
/* Copy half-conn state to full conn. */
NetTCP_ConnCopy(pconn_clone, pconn);
pconn_tx_sync = pconn_clone;
} else { /* Else conn to listen TCP conn (see Note #5b). */
pconn_tx_sync = pconn;
}
/*$PAGE*/
/* ------------- HANDLE RX'D SEG -------------- */
NetTCP_RxPktConnHandlerSeg(pconn_tx_sync, ack_code, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
default: /* See Note #6d. */
NetTCP_ConnClose(pconn_tx_sync, pbuf_hdr, pconn_tx_sync->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' warning. */
}
/* ------------- UPDATE TCP CONN -------------- */
/* Cfg remote max seg size as advertised ... */
/* ... by remote host (see Note #7). */
pconn_tx_sync->MaxSegSizeRemote = (pbuf_hdr->TCP_MaxSegSize != NET_TCP_MAX_SEG_SIZE_NONE)
? pbuf_hdr->TCP_MaxSegSize
: NET_TCP_MAX_SEG_SIZE_DFLT_TX;
/* ------------- TX TCP CONN SYNC ------------- */
NetTCP_TxConnSync(pconn_tx_sync, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) { /* See Note #6d. */
NetTCP_ConnClose(pconn_tx_sync, pbuf_hdr, pconn_tx_sync->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
return;
}
/* ---------- UPDATE TCP CONN STATE ----------- */
pconn_tx_sync->ConnState = NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE;
*perr = err_rtn;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerSyncRxd()
*
* Description : (1) Handle TCP connection in SYN-RECEIVED state :
*
* (a) Validate received TCP packet for current TCP connection state :
*
* (1) Sequence Number (SEQ) See Note #2a
* (2) Reset (RST) See Note #2b
* (3) Synchronization (SYN) See Note #2c
* (4) Acknowledgement (ACK) See Note #2d
* (5) Finish/Close (FIN) See Note #2e
*
* (b) Update TCP connection :
* (1) Handle received TCP segment See Note #2d2A1
* (2) Update TCP connection state See Notes #2d2A1a & #2e4
* (3) Update TCP connection timer
*
* (c) Acknowledge TCP connection
* (1) Signal TCP/application connection complete
* (2) Handle TCP connection received data See Note #2d2A1
* (3) Transmit TCP connection data See Notes #2d2A2 & #2e3
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_SEQ_SYNC_INVALID Received segment's synchronization is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_ACK_NONE Received segment's acknowledgement is
* NOT available.
* NET_TCP_ERR_CONN_ACK_INVALID Received segment's acknowledgement number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_RESET_VALID Received segment's reset flag is valid
* for current TCP connection; i.e. reset
* the TCP connection.
* NET_TCP_ERR_CONN_RESET_INVALID Received segment's reset flag is NOT valid
* for current TCP connection.
*
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
*
* ----- RETURNED BY NetTCP_RxPktConnIsValidSeq() : -----
* ----- RETURNED BY NetTCP_RxPktConnIsValidAck() : -----
* ---- RETURNED BY NetTCP_RxPktConnIsValidReset() : ----
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* ----- RETURNED BY NetTCP_RxPktConnHandlerSeg() : -----
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO
* data to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled & valid
* data processed (see Note #2d2A1).
* NET_TCP_ERR_CONN_DATA_INVALID Received packet contains invalid segment
* data; NOT queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_DUP Received packet contains duplicate segment
* data; NOT queued to receive queue(s).
*
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
*
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* NET_TCP_ERR_TX TCP transmit error.
* NET_TCP_ERR_TX_Q_SIGNAL_FAULT TCP connection transmit queue signal fault.
* NET_TCP_ERR_RE_TX_SEG_TH TCP connection closed due to excessive retransmission.
*
* ---------- RETURNED BY NetTCP_TxConnTxQ() : ----------
* NET_TCP_ERR_CONN_CLOSE TCP connection closed.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandler().
*$PAGE*
* Note(s) : (2) TCP connections in the SYN-RECEIVED state are handled as follows :
*
* (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence Number'
* states that in the "SYN-RECEIVED, ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2
* STATE, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT STATE" that ...
*
* (1) "Segments are processed in sequence ... processing is done in SEG.SEQ order."
*
* (2) "Initial tests on arrival are used to discard old duplicates."
*
* (3) "If a segment's contents straddle the boundary between old and new, only the
* new parts should be processed."
*
* (4) (A) "If an incoming segment is not acceptable," ...
*
* (B) "an acknowledgment should be sent in reply" ...
*
* (C) "(unless the RST bit is set, if so drop the segment)".
*
* See also Notes #2b2Aa & #2b2C.
*
* See also 'NetTCP_RxPktConnIsValidSeq() Note #1d'.
*
* (b) (1) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit :
* SYN-RECEIVED STATE' states that "if the RST bit is set" and ...
*
* (1) "If this connection was initiated with a passive OPEN (i.e., came from
* the LISTEN state), then return this connection to the LISTEN state."
*
* (2) "If this connection was initiated with an active OPEN (i.e., came from
* the SYN-SENT state) then the connection was refused, signal the user
* 'connection refused' ... enter the CLOSED state."
*
* (B) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing'
* reiterates that "if the receiver ... of a RST ... was in SYN-RECEIVED state
* and had previously been in the LISTEN state, then the receiver returns to
* the LISTEN state, otherwise the receiver aborts the connection and goes to
* the CLOSED state".
*
* (C) However, since TCP connections opened from the LISTEN state are cloned from
* the original LISTEN-state TCP connection, it is NOT necessary to return ANY
* reset TCP connection from the SYN-RECEIVED state back to the LISTEN state.
*
* See also 'NetTCP_RxPktConnIsValidReset() Note #2a4B'.
*
* (2) (A) RFC Draft-IETF-TCPm-TCPSecure #00, Section 2.2 amends the "handling of
* a segment with the RST when in a synchronized state" to "provide some
* protection against ... blind reset attack[s] using the RST bit" :
*
* (a) "If the RST bit is set and the sequence number is outside the expected
* window, silently drop the segment."
*
* (b) "If the RST bit is exactly the next expected sequence number [sic], reset
* the connection"; it is assumed that this should read "if the RST bit is
* set and the sequence number is exactly the next expected sequence number,
* reset the connection."
*
* (c) "If the RST bit is set and the sequence number does not exactly match
* the next expected sequence value, yet is within the acceptable window
* (RCV.NXT <= SEG.SEQ < RCV.NXT+RCV.WND) send an acknowledgment."
*
* (B) ???? Although RFC Draft-IETF-TCPm-TCPSecure #00 explicitly states that this
* amendment applies only to the "handling of a ... RST ... when in a synchronized
* state", it is assumed that this should also apply to the SYN-RECEIVED state.
*
* See also 'NetTCP_RxPktConnIsValidReset() Note #2a5B'.
*
* (C) ???? In addition, RFC Draft-IETF-TCPm-TCPSecure #00 does NOT provide a precedence
* priority for handling TCP segments received with BOTH the RST & SYN bits set.
*
* ???? Therefore, since it does NOT seem reasonable to reset a TCP connection
* due to a TCP segment that also attempted to synchronize the TCP connection,
* it is assumed that the amended handling of the SYN bit should take precedence
* over the amended handling of the RST bit.
*
* See also Note #2c2.
*$PAGE*
* (c) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check SYN Bit'
* states that in the "SYN-RECEIVED [STATE], ESTABLISHED STATE, FIN-WAIT STATE-1,
* FIN-WAIT STATE-2, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that ...
*
* (A) "If the SYN is in the window it is an error, send a reset, any outstanding
* RECEIVEs and SEND[s] should receive 'reset' responses, all segment queues
* should be flushed, the user should also receive an unsolicited general
* 'connection reset' signal[, and] enter the CLOSED state."
*
* (B) But "if the SYN is not in the window this step would not have been reached
* and an ack would have been sent".
*
* (2) (A) HOWEVER, RFC Draft-IETF-TCPm-TCPSecure #00, Section 3.2 amends the "handling
* of a segment with the SYN bit set in the synchronized state ... [by] handling
* ... the SYN bit" as follows :
*
* (a) "If the SYN bit is set and the sequence number is outside the
* expected window, send an ACK back to the peer."
*
* (b) "If the SYN bit is set and the sequence number is an exact
* match to the next expected sequence (RCV.NXT == SEG.SEQ)
* then send an ACK segment ... but ... subtract one from
* value being acknowledged."
*
* (c) "If the SYN bit is set and the sequence number is acceptable,
* i.e.: (RCV.NXT <= SEG.SEQ <= RCV.NXT+RCV.WND) then send an
* ACK segment."
*
* (B) ???? Although RFC Draft-IETF-TCPm-TCPSecure #00 explicitly states that this
* amendment applies only to the "handling of a ... SYN ... in a synchronized
* state", it is assumed that this should also apply to the SYN-RECEIVED state.
*
* (d) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field' states
* that ... :
*
* (1) "If the ACK bit is off drop the segment."
*
* (2) "If the ACK bit is on [and in the] SYN-RECEIVED STATE" ...
*
* (A) (1) "If SND.UNA < SEG.ACK <= SND.NXT then" ...
*
* (a) "enter the ESTABLISHED state" ...
* (b) "and continue processing."
*
* (2) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT
* [State]' states to "send ... [any] data or controls which were queued
* for transmission" when the SYN-SENT state transitions to the ESTABLISHED
* state.
*
* Although this section is the only section to state that any data or
* controls should be sent when transitioning from the SYN-SENT state
* to the ESTABLISHED state, it is assumed that any data or controls
* should also be sent for the transition from the SYN-RECEIVED state
* to the ESTABLISHED state.
*
* (B) "If the segment acknowledgment is not acceptable, form a reset segment ...
* and send it."
*
* (e) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states
* that "if the FIN bit is set" ...
*
* (1) "signal the user 'connection closing' and return any pending RECEIVEs with
* same message," ...
*
* (2) "advance RCV.NXT over the FIN," ...
*
* (3) "send an acknowledgment for the FIN" ...
*
* (4) And the "SYN-RECEIVED STATE enter[s] the CLOSE-WAIT state".
*$PAGE*
* (3) (a) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : USER TIMEOUT' states that
* "for any state if the user timeout expires, flush all queues, signal the user
* 'error : connection aborted due to user timeout' ... [and] enter the CLOSED state".
*
* (b) However, NO RFC specifies or suggests any mechanism to implement/handle user timeouts.
*
* ???? Therefore, it is assumed that ANY TCP connection that receives a valid TCP data
* or control segment should reset its user connection timer.
*
* (c) (1) Once a TCP connection enters the connected state, most of its TCP connection
* timers should be reset.
*
* (2) However, the following timers MAY already have been allocated & initialized,
* & MUST NOT be reset :
*
* (A) Transmit Idle timer 'TxQ_IdleTmr'
* (B) Re-transmit timer 'ReTxQ_Tmr'
*********************************************************************************************************
*/
static void NetTCP_RxPktConnHandlerSyncRxd (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
NET_TCP_SEQ_CODE seq_code;
NET_TCP_ACK_CODE ack_code;
NET_TCP_RESET_CODE reset_code;
NET_TCP_FREE_CODE free_code;
NET_TCP_CONN_STATE state;
NET_TCP_TIMEOUT_SEC timeout_sec;
NET_TMR_TICK timeout_tick;
NET_ERR err;
NET_ERR err_rtn;
/*$PAGE*/
/* -------------- VALIDATE RX'D TCP PKT --------------- */
/* Chk for rx'd fin/close. */
if (pbuf_hdr->TCP_SegClose == DEF_YES) { /* If fin/close avail, update seg lens. */
pbuf_hdr->TCP_SegLenInit += NET_TCP_SEG_LEN_CLOSE;
pbuf_hdr->TCP_SegLen += NET_TCP_SEG_LEN_CLOSE;
}
/* Chk rx'd seq nbr. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (seq_code) {
case NET_TCP_CONN_RX_SEQ_VALID:
break;
case NET_TCP_CONN_RX_SEQ_SYNC: /* If invalid sync rx'd, ... */
case NET_TCP_CONN_RX_SEQ_SYNC_INVALID:
/* ... tx TCP conn ack (see Notes #2c2 & #2b2C). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_SEQ_SYNC_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_SEQ_NONE:
case NET_TCP_CONN_RX_SEQ_INVALID: /* If invalid seq rx'd (see Note #2a4A), ... */
default:
if (pbuf_hdr->TCP_SegReset != DEF_YES) { /* ... & reset NOT rx'd (see Note #2a4C), ... */
/* ... tx TCP conn ack (see Note #2a4B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
}
*perr = NET_TCP_ERR_CONN_SEQ_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd reset. */
reset_code = NetTCP_RxPktConnIsValidReset(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (reset_code) {
case NET_TCP_CONN_RX_RESET_NONE:
break;
case NET_TCP_CONN_RX_RESET_VALID: /* If valid reset rx'd, ... */
/* ... close TCP conn (see Note #2b2Ab). */
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_RESET_VALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_RESET_INVALID: /* If invalid reset rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2b2Ac). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd ack. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
break;
case NET_TCP_CONN_RX_ACK_NONE: /* If NO ack rx'd, ... */
*perr = NET_TCP_ERR_CONN_ACK_NONE; /* ... ignore TCP pkt (see Note #2d1). */
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_ACK_INVALID: /* If invalid ack rx'd, ... */
case NET_TCP_CONN_RX_ACK_DUP:
case NET_TCP_CONN_RX_ACK_PREV:
default:
/* ... tx TCP conn reset (see Note #2d2B). */
NetTCP_TxConnReset(pconn, pbuf_hdr, NET_TCP_CONN_TX_RESET, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ----------------- HANDLE RX'D SEG ------------------ */
NetTCP_RxPktConnHandlerSeg(pconn, ack_code, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_DATA_DUP: /* ???? Allow dup data to update TCP conn? */
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* ----------------- UPDATE TCP CONN ------------------ */
state = pconn->ConnState;
if (pbuf_hdr->TCP_SegClose != DEF_YES) { /* If fin/close NOT rx'd, ... */
pconn->ConnState = NET_TCP_CONN_STATE_CONN; /* ... chng to conn'd state (see Note #2d2A1a). */
} else { /* Else chng to close-wait state (see Note #2e4). */
pconn->ConnState = NET_TCP_CONN_STATE_CLOSE_WAIT;
}
pconn->TxQ_State = NET_TCP_TX_Q_STATE_CONN;
/* ------------------- UPDATE TMRs -------------------- */
free_code = NET_TCP_CONN_FREE_TMR_ALL; /* See Note #3c1. */
DEF_BIT_CLR(free_code, NET_TCP_CONN_FREE_TMR_TX_IDLE); /* See Note #3c2A. */
DEF_BIT_CLR(free_code, NET_TCP_CONN_FREE_TMR_RE_TX); /* See Note #3c2B. */
NetTCP_ConnFreeTmr(pconn, free_code); /* Free TCP conn tmr(s) [see Note #3c]. */
/* Get TCP conn tmr. */
timeout_sec = pconn->TimeoutConn_sec; /* Start conn tmr (see Note #3b). */
timeout_tick = (NET_TMR_TICK)timeout_sec * NET_TMR_TIME_TICK_PER_SEC;
pconn->TimeoutTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
if ( err != NET_TMR_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_NONE_AVAIL;
return;
}
/*$PAGE*/
/* ------------------- ACK TCP CONN ------------------- */
NetTCP_RxPktConnHandlerSignalConn(pconn, state, &err); /* Signal app conn (see Note #1c1). */
if ( err != NET_TCP_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
NetTCP_RxPktConnHandlerRxQ_AppData(pconn, &err); /* Handle TCP conn rx'd data (see Note #2d2A1). */
if ( err != NET_TCP_ERR_NONE) { /* #### On err, close TCP conn? */
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
if (pconn->ConnState == NET_TCP_CONN_STATE_CONN) { /* If conn'd, tx any tx data (see Note #1c3). */
NetTCP_TxConnTxQ(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_NONE, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
} else { /* Else tx TCP conn ack (see Note #2e3). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_IMMED, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
break;
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
}
*perr = err_rtn;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerSyncTxd()
*
* Description : (1) Handle TCP connection in SYN-SENT state :
*
* (a) Validate received TCP packet for current TCP connection state :
*
* (1) Acknowledgement (ACK) See Note #2a
* (2) Reset (RST) See Note #2b
* (3) Synchronization (SYN) See Note #2c
*
* (b) Update TCP connection :
* (1) Configure TCP connection remote host maximum segment size See Note #3
* (2) Handle received TCP segment See Note #2c
* (3) Update TCP connection state See Notes #2c3A1 & #2c3B1
* (4) Update TCP connection timer
*
* (c) Acknowledge TCP connection
* (1) Signal TCP/application connection complete
* (2) Handle TCP connection received data See Note #2c3A3
* (3) Transmit TCP connection acknowledgement & data See Note #2c3A2
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_ACK_INVALID Received segment's acknowledgement number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_SEQ_FIN_INVALID Received segment's finish/close flag is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_RESET_VALID Received segment's reset flag is valid
* for current TCP connection; i.e. reset
* the TCP connection.
* NET_TCP_ERR_CONN_RESET_INVALID Received segment's reset flag is NOT valid
* for current TCP connection.
*
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
*
* ----- RETURNED BY NetTCP_RxPktConnIsValidSeq() : -----
* ----- RETURNED BY NetTCP_RxPktConnIsValidAck() : -----
* ---- RETURNED BY NetTCP_RxPktConnIsValidReset() : ----
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* ----- RETURNED BY NetTCP_RxPktConnHandlerSeg() : -----
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO
* data to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled &
* valid data queued for processing
* (see Notes #2c3A3 & #2c3B3).
* NET_TCP_ERR_CONN_DATA_INVALID Received packet contains invalid segment
* data; NOT queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_DUP Received packet contains duplicate segment
* data; NOT queued to receive queue(s).
*
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
*
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* NET_TCP_ERR_TX TCP transmit error.
* NET_TCP_ERR_TX_Q_SIGNAL_FAULT TCP connection transmit queue signal fault.
* NET_TCP_ERR_RE_TX_SEG_TH TCP connection closed due to excessive retransmission.
*
* ---------- RETURNED BY NetTCP_TxConnTxQ() : ----------
* NET_TCP_ERR_CONN_CLOSE TCP connection closed.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandler().
*$PAGE*
* Note(s) : (2) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State]' states to :
*
* (a) "First check the ACK bit[;] if the ACK bit is set" :
*
* (1) "If SEG.ACK =< ISS, or SEG.ACK > SND.NXT, send a reset (unless the RST bit is
* set) ... and discard the segment."
*
* (2) "If SND.UNA < SEG.ACK =< SND.NXT then the ACK is acceptable."
*
* See also 'NetTCP_RxPktConnIsValidAck() Note #1c1A'.
*
* (b) "Second check the RST bit[;] if the RST bit is set [and] if the ACK was acceptable
* then signal the user 'error: connection reset', drop the segment, [and] enter
* CLOSED state."
*
* See also 'NetTCP_RxPktConnIsValidReset() Notes #2a3 & #2a5C'.
*
* (c) "Fourth check the SYN bit[;] if the SYN bit is on and ... acceptable then" ...
*
* (1) "RCV.NXT is set to SEG.SEQ+1, IRS is set to SEG.SEQ."
* (A) See also Note #2c3B3a
*
* (2) (A) "SND.UNA should be advanced to equal SEG.ACK (if there is an ACK)" ...
*
* (B) "and any segments on the retransmission queue which are thereby acknowledged
* should be removed."
*
* (3) (A) "If SND.UNA > ISS (our SYN has been ACKed)," ...
*
* (1) "change the connection state to ESTABLISHED" ...
*
* (2) (a) "form an ACK segment ... and send it."
*
* (b) "Data or controls which were queued for transmission may be included."
*
* (3) "If there are other controls or text in the segment then continue processing."
*
* (4) RFC #1122, Section 4.2.2.20.(c) adds that "when the connection enters
* ESTABLISHED state, the following variables must be set" :
*
* (a) SND.WND <- SEG.WND
* (b) SND.WL1 <- SEG.SEQ
* (c) SND.WL2 <- SEG.ACK
*
* (B) "Otherwise" ...
*
* (1) "enter SYN-RECEIVED," ...
*
* (2) "form an SYN,ACK segment ... and send it."
*
* (3) "If there are other controls or text in the segment, queue them for later
* processing after the ESTABLISHED state has been reached."
*
* (a) If any control or text is queued for later processing, the next sequence
* octet to receive (RCV.NXT) MUST include the length of this received
* segment (SEG.LEN) :
*
* (1) RCV.NXT = SEG.SEQ + SEG.LEN + 1
*
* (d) "Fifth, if neither of the SYN or RST bits is set then drop the segment."
*
* (e) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states
* to "not process the FIN if the state is CLOSED, LISTEN or SYN-SENT since the SEG.SEQ
* cannot be validated; drop the segment".
*$PAGE*
* (3) RFC #1122, Section 4.2.2.6 states that ... :
*
* (a) A "TCP SHOULD send an MSS (Maximum Segment Size) option in every SYN segment".
*
* (b) "If an MSS option is not received at connection setup, TCP MUST assume a default
* send MSS of 536."
*
* (4) (a) TCP connection timeout for SYN-SENT state is implemented by TCP connection retransmission
* function(s) (see 'NetTCP_TxConnReTxQ() Note #3c').
*
* (b) (1) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : USER TIMEOUT' states that
* "for any state if the user timeout expires, flush all queues, signal the user
* 'error : connection aborted due to user timeout' ... [and] enter the CLOSED state".
*
* (2) However, NO RFC specifies or suggests any mechanism to implement/handle user timeouts.
*
* ???? Therefore, it is assumed that ANY TCP connection that receives a valid TCP data
* or control segment should reset its user connection timer.
*
* (c) (1) Once a TCP connection enters the connected state, most of its TCP connection
* timers should be reset.
*
* (2) However, the following timers MAY already have been allocated & initialized,
* & MUST NOT be reset :
*
* (A) Transmit Idle timer 'TxQ_IdleTmr'
* (B) Re-transmit timer 'ReTxQ_Tmr'
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_RxPktConnHandlerSyncTxd (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
NET_TCP_SEQ_CODE seq_code;
NET_TCP_ACK_CODE ack_code;
NET_TCP_RESET_CODE reset_code;
NET_TCP_FREE_CODE free_code;
NET_TCP_CONN_STATE state;
NET_TCP_TIMEOUT_SEC timeout_sec;
NET_TMR_TICK timeout_tick;
NET_ERR err;
NET_ERR err_rtn;
/* -------------- VALIDATE RX'D TCP PKT --------------- */
/* Chk for rx'd fin/close. */
if (pbuf_hdr->TCP_SegClose != DEF_NO) { /* If invalid fin/close rx'd, ... */
*perr = NET_TCP_ERR_CONN_SEQ_FIN_INVALID;
return; /* ... ignore TCP pkt (see Note #2e). */
}
/* Chk for rx'd ack. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
if (ack_code == NET_TCP_CONN_RX_ACK_INVALID) { /* If invalid ack rx'd, ... */
/* ... tx TCP conn reset (see Note #2a1). */
NetTCP_TxConnReset(pconn, pbuf_hdr, NET_TCP_CONN_TX_RESET, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return;
}
/* Chk for rx'd reset. */
reset_code = NetTCP_RxPktConnIsValidReset(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (reset_code) {
case NET_TCP_CONN_RX_RESET_NONE:
break;
case NET_TCP_CONN_RX_RESET_VALID: /* If valid reset rx'd, close TCP conn (see Note #2b). */
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_RESET_VALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_RESET_INVALID:
default:
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk rx'd seq nbr. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
if (seq_code != NET_TCP_CONN_RX_SEQ_SYNC) { /* If sync NOT rx'd, ... */
*perr = NET_TCP_ERR_CONN_SEQ_INVALID;
return; /* ... ignore TCP pkt (see Note #2d). */
}
/* Else sync avail, update seg lens. */
pbuf_hdr->TCP_SegLenInit += NET_TCP_SEG_LEN_SYNC;
pbuf_hdr->TCP_SegLen += NET_TCP_SEG_LEN_SYNC;
/*$PAGE*/
/* ----------------- UPDATE TCP CONN ------------------ */
/* Cfg remote max seg size ... */
/* ... as advertised by remote host (see Note #3). */
pconn->MaxSegSizeRemote = (pbuf_hdr->TCP_MaxSegSize != NET_TCP_MAX_SEG_SIZE_NONE)
? pbuf_hdr->TCP_MaxSegSize
: NET_TCP_MAX_SEG_SIZE_DFLT_TX;
/* ----------------- HANDLE RX'D SEG ------------------ */
NetTCP_RxPktConnHandlerSeg(pconn, ack_code, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_DATA_DUP: /* ???? Allow dup data to update TCP conn? */
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* ----------------- UPDATE TCP CONN ------------------ */
if (ack_code == NET_TCP_CONN_RX_ACK_VALID) { /* If valid ack rx'd (see Note #2a1), ... */
state = pconn->ConnState;
pconn->ConnState = NET_TCP_CONN_STATE_CONN; /* ... chng to conn'd state (see Note #2c3A1). */
pconn->TxQ_State = NET_TCP_TX_Q_STATE_CONN;
} else { /* Else chng to sync rx'd state (see Note #2c3B1). */
pconn->ConnState = NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE;
}
/* ------------------- UPDATE TMRs -------------------- */
free_code = NET_TCP_CONN_FREE_TMR_ALL; /* See Note #4c1. */
DEF_BIT_CLR(free_code, NET_TCP_CONN_FREE_TMR_TX_IDLE); /* See Note #4c2A. */
DEF_BIT_CLR(free_code, NET_TCP_CONN_FREE_TMR_RE_TX); /* See Note #4c2B. */
NetTCP_ConnFreeTmr(pconn, free_code); /* Free TCP conn tmr(s) [see Note #4c]. */
if (pconn->ConnState == NET_TCP_CONN_STATE_CONN) { /* If conn'd, get TCP conn tmr. */
timeout_sec = pconn->TimeoutConn_sec; /* Start conn tmr (see Note #4b2). */
timeout_tick = (NET_TMR_TICK)timeout_sec * NET_TMR_TIME_TICK_PER_SEC;
pconn->TimeoutTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
if ( err != NET_TMR_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_NONE_AVAIL;
return;
}
}
/*$PAGE*/
/* ------------------- ACK TCP CONN ------------------- */
if (pconn->ConnState == NET_TCP_CONN_STATE_CONN) { /* If conn'd, ... */
NetTCP_RxPktConnHandlerSignalConn(pconn, state, &err); /* ... signal app conn (see Note #1c1); ... */
if ( err != NET_TCP_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
NetTCP_RxPktConnHandlerRxQ_AppData(pconn, &err); /* ... handle TCP conn rx'd data (see Note #2d2A1); ... */
if ( err != NET_TCP_ERR_NONE) { /* #### On err, close TCP conn? */
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
/* ... & tx ack & any tx data (see Note #1c3). */
NetTCP_TxConnTxQ(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_IMMED, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
} else { /* Else tx TCP conn sync/ack (see Note #2c3B2). */
NetTCP_TxConnSync(pconn, pbuf_hdr, &err);
if ( err != NET_TCP_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_CLOSE;
return;
}
}
*perr = err_rtn;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerConn()
*
* Description : (1) Handle TCP connection in ESTABLISHED state :
*
* (a) Validate received TCP packet for current TCP connection state :
*
* (1) Sequence Number (SEQ) See Note #2a
* (2) Reset (RST) See Note #2b
* (3) Synchronization (SYN) See Note #2c
* (4) Acknowledgement (ACK) See Note #2d
* (5) Finish/Close (FIN) See Note #2f
*
* (b) Update TCP connection :
* (1) Handle received TCP segment See Notes #2d & #2e
* (2) Update TCP connection state See Note #2f5
* (3) Update TCP connection timer See Note #3
*
* (c) Transmit TCP connection acknowledgement & data See Notes #2e2A & #2f3
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_SEQ_SYNC_INVALID Received segment's synchronization is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_ACK_NONE Received segment's acknowledgement is
* NOT available.
* NET_TCP_ERR_CONN_ACK_INVALID Received segment's acknowledgement number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_RESET_VALID Received segment's reset flag is valid
* for current TCP connection; i.e. reset
* the TCP connection.
* NET_TCP_ERR_CONN_RESET_INVALID Received segment's reset flag is NOT valid
* for current TCP connection.
*
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
*
* ----- RETURNED BY NetTCP_RxPktConnIsValidSeq() : -----
* ----- RETURNED BY NetTCP_RxPktConnIsValidAck() : -----
* ---- RETURNED BY NetTCP_RxPktConnIsValidReset() : ----
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* ----- RETURNED BY NetTCP_RxPktConnHandlerSeg() : -----
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO
* data to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled & valid
* data queued for processing.
* NET_TCP_ERR_CONN_DATA_INVALID Received packet contains invalid segment
* data; NOT queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_DUP Received packet contains duplicate segment
* data; NOT queued to receive queue(s).
*
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
*
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* NET_TCP_ERR_RX_Q_FULL TCP connection receive queue full.
* NET_TCP_ERR_RX_Q_SIGNAL_FAULT TCP connection receive queue signal fault.
* NET_TCP_ERR_TX_Q_SIGNAL_FAULT TCP connection transmit queue signal fault.
* NET_TCP_ERR_RE_TX_SEG_TH TCP connection closed due to excessive retransmission.
* NET_TCP_ERR_TX TCP transmit error.
*
* ---------- RETURNED BY NetTCP_TxConnTxQ() : ----------
* NET_TCP_ERR_CONN_CLOSE TCP connection closed.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandler().
*$PAGE*
* Note(s) : (2) TCP connections in the ESTABLISHED state are handled as follows :
*
* (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence Number'
* states that in the "SYN-RECEIVED, ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2
* STATE, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT STATE" that ...
*
* (1) "Segments are processed in sequence ... processing is done in SEG.SEQ order."
*
* (2) "Initial tests on arrival are used to discard old duplicates."
*
* (3) "If a segment's contents straddle the boundary between old and new, only the
* new parts should be processed."
*
* (4) (A) "If an incoming segment is not acceptable," ...
*
* (B) "an acknowledgment should be sent in reply" ...
*
* (C) "(unless the RST bit is set, if so drop the segment)".
*
* See also Notes #2b2Aa & #2b2B.
*
* See also 'NetTCP_RxPktConnIsValidSeq() Note #1d'.
*
* (b) (1) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit' states
* that in the "ESTABLISHED, FIN-WAIT-1, FIN-WAIT-2, CLOSE-WAIT" states that "if the
* RST bit is set then, any outstanding RECEIVEs and SEND[s] should receive 'reset'
* responses. All segment queues should be flushed. Users should also receive an
* unsolicited general 'connection reset' signal[, and] enter the CLOSED state".
*
* (B) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing' reiterates
* that "if the receiver ... of a RST ... was in any other state [other than LISTEN
* or SYN-RECEIVED], it aborts the connection and advises the user and goes to the
* CLOSED state".
*
* (2) (A) RFC Draft-IETF-TCPm-TCPSecure #00, Section 2.2 amends the "handling of a segment
* with the RST bit when in a synchronized state" to "provide some protection against
* ... blind reset attack[s] using the RST bit" :
*
* (a) "If the RST bit is set and the sequence number is outside the expected
* window, silently drop the segment."
*
* (b) "If the RST bit is exactly the next expected sequence number [sic], reset
* the connection"; it is assumed that this should read "if the RST bit is
* set and the sequence number is exactly the next expected sequence number,
* reset the connection."
*
* (c) "If the RST bit is set and the sequence number does not exactly match
* the next expected sequence value, yet is within the acceptable window
* (RCV.NXT <= SEG.SEQ < RCV.NXT+RCV.WND) send an acknowledgment."
*
* (B) ???? In addition, RFC Draft-IETF-TCPm-TCPSecure #00 does NOT provide a precedence
* priority for handling TCP segments received with BOTH the RST & SYN bits set.
*
* ???? Therefore, since it does NOT seem reasonable to reset a TCP connection
* due to a TCP segment that also attempted to synchronize the TCP connection,
* it is assumed that the amended handling of the SYN bit should take precedence
* over the amended handling of the RST bit.
*
* See also Note #2c2.
*
* (c) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check SYN Bit'
* states that in the "SYN-RECEIVED [STATE], ESTABLISHED STATE, FIN-WAIT STATE-1,
* FIN-WAIT STATE-2, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that ...
*
* (A) "If the SYN is in the window it is an error, send a reset, any outstanding
* RECEIVEs and SEND[s] should receive 'reset' responses, all segment queues
* should be flushed, the user should also receive an unsolicited general
* 'connection reset' signal[, and] enter the CLOSED state."
*
* (B) But "if the SYN is not in the window this step would not have been reached
* and an ack would have been sent".
*
* (2) HOWEVER, RFC Draft-IETF-TCPm-TCPSecure #00, Section 3.2 amends the "handling
* of a segment with the SYN bit set in the synchronized state ... [by] handling
* ... the SYN bit" as follows :
*
* (a) "If the SYN bit is set and the sequence number is outside the
* expected window, send an ACK back to the peer."
*
* (b) "If the SYN bit is set and the sequence number is an exact
* match to the next expected sequence (RCV.NXT == SEG.SEQ)
* then send an ACK segment ... but ... subtract one from
* value being acknowledged."
*
* (c) "If the SYN bit is set and the sequence number is acceptable,
* i.e.: (RCV.NXT <= SEG.SEQ <= RCV.NXT+RCV.WND) then send an
* ACK segment."
*$PAGE*
* (d) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field'
* states that ... :
*
* (1) "If the ACK bit is off drop the segment."
*
* (2) "If the ACK bit is on [and in the] ESTABLISHED STATE" ...
*
* (A) "If SND.UNA < SEG.ACK <= SND.NXT then" ...
*
* (1) "set SND.UNA <- SEG.ACK."
*
* (2) "Any segments on the retransmission queue which are thereby entirely
* acknowledged are removed."
*
* (3) "the send window should be updated" :
*
* (a) (1) (A) "If ((SND.WL1 < SEG.SEQ) or" ...
*
* (B) (1) "(SND.WL1 = SEG.SEQ and" ...
* (2) "SND.WL2 <= SEG.ACK))," ...
*
* (2) (A) "set SND.WND <- SEG.WND," ...
* (B) "set SND.WL1 <- SEG.SEQ," ...
* (C) "set SND.WL2 <- SEG.ACK."
*
* (b) "Note that SND.WND is an offset from SND.UNA, that SND.WL1 records the
* sequence number of the last segment used to update SND.WND, and that
* SND.WL2 records the acknowledgment number of the last segment used to
* update SND.WND. The check here preveents using old segments to update
* the window."
*
* (B) (1) "If the ACK is a duplicate (SEG.ACK <= SND.UNA), it can be ignored."
*
* (2) RFC #1122, Section 4.2.2.20.(g) amends the transmit window update criteria
* for the segment's acknowledgement to include SND.UNA : "The window should
* updated if SND.UNA <= SEG.ACK <= SND.NXT."
*
* See also 'NetTCP_RxPktConnHandlerTxWinRemote() Note #1b2'.
*
* (C) "If the ACK acks something not yet sent (SEG.ACK > SND.NXT) then send an ACK
* [and] drop the segment."
*
* (e) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment Text'
* states that for the "ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2 STATE ... it
* is possible to deliver segment text to user RECEIVE buffers" :
*
* (1) "If the segment ... carries [a] PUSH flag, then the user is informed [and] the
* buffer is returned."
*
* (2) (A) (1) "When the TCP takes responsibility for delivering the data to the user it
* must also acknowledge the receipt of the data."
*
* (2) "This acknowledgment should be piggybacked on a segment being transmitted
* if possible without incurring undue delay."
*
* (B) "Once the TCP takes responsibility for the data" ...
*
* (1) "it advances RCV.NXT over the data accepted," ...
*
* (2) "adjusts RCV.WND as appropriate to the current buffer availability" ...
*
* (3) (a) "The total of RCV.NXT and RCV.WND should not be reduced."
*
* (b) RFC #793, Section 3.7 'Data Communication : Managing the Window' &
* RFC #1122, Section 4.2.2.16 confirm that "a TCP receiver SHOULD NOT
* shrink the window"; i.e. "advertise a much smaller window without
* having accepted that much data".
*
* (f) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states
* that "if the FIN bit is set" ...
*
* (1) "signal the user 'connection closing' and return any pending RECEIVEs with
* same message," ...
*
* (2) "advance RCV.NXT over the FIN," ...
*
* (3) "send an acknowledgment for the FIN" ...
*
* (4) "FIN implies PUSH for any segment text not yet delivered to the user" ...
*
* (5) And the "ESTABLISHED STATE enter[s] the CLOSE-WAIT state".
*$PAGE*
* (3) (a) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : USER TIMEOUT' states that
* "for any state if the user timeout expires, flush all queues, signal the user
* 'error : connection aborted due to user timeout' ... [and] enter the CLOSED state".
*
* (b) However, NO RFC specifies or suggests any mechanism to implement/handle user timeouts.
*
* ???? Therefore, it is assumed that ANY TCP connection that receives a valid TCP data
* or control segment should reset its user connection timer.
*********************************************************************************************************
*/
static void NetTCP_RxPktConnHandlerConn (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
NET_TCP_SEQ_CODE seq_code;
NET_TCP_ACK_CODE ack_code;
NET_TCP_RESET_CODE reset_code;
NET_TCP_TIMEOUT_SEC timeout_sec;
NET_TMR_TICK timeout_tick;
NET_ERR err;
NET_ERR err_rtn;
/*$PAGE*/
/* -------------- VALIDATE RX'D TCP PKT --------------- */
/* Chk for rx'd fin/close. */
if (pbuf_hdr->TCP_SegClose == DEF_YES) { /* If fin/close avail, update seg lens. */
pbuf_hdr->TCP_SegLenInit += NET_TCP_SEG_LEN_CLOSE;
pbuf_hdr->TCP_SegLen += NET_TCP_SEG_LEN_CLOSE;
}
/* Chk rx'd seq nbr. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (seq_code) {
case NET_TCP_CONN_RX_SEQ_VALID:
break;
case NET_TCP_CONN_RX_SEQ_SYNC: /* If invalid sync rx'd, ... */
case NET_TCP_CONN_RX_SEQ_SYNC_INVALID:
/* ... tx TCP conn ack (see Notes #2c2 & #2b2B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_SEQ_SYNC_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_SEQ_NONE:
case NET_TCP_CONN_RX_SEQ_INVALID: /* If invalid seq rx'd (see Note #2a4A), ... */
default:
if (pbuf_hdr->TCP_SegReset != DEF_YES) { /* ... & reset NOT rx'd (see Note #2a4C), ... */
/* ... tx TCP conn ack (see Note #2a4B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
}
*perr = NET_TCP_ERR_CONN_SEQ_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd reset. */
reset_code = NetTCP_RxPktConnIsValidReset(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (reset_code) {
case NET_TCP_CONN_RX_RESET_NONE:
break;
case NET_TCP_CONN_RX_RESET_VALID: /* If valid reset rx'd, ... */
/* ... close TCP conn (see Note #2b1A). */
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_RESET_VALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_RESET_INVALID: /* If invalid reset rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2b2Ac). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd ack. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
case NET_TCP_CONN_RX_ACK_DUP:
case NET_TCP_CONN_RX_ACK_PREV:
break;
case NET_TCP_CONN_RX_ACK_NONE: /* If NO ack rx'd, ... */
*perr = NET_TCP_ERR_CONN_ACK_NONE; /* ... ignore TCP pkt (see Note #2d1). */
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_ACK_INVALID: /* If invalid ack rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2d2C). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ----------------- HANDLE RX'D SEG ------------------ */
NetTCP_RxPktConnHandlerSeg(pconn, ack_code, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_DATA_DUP: /* ???? Allow dup data to update TCP conn? */
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* ----------------- UPDATE TCP CONN ------------------ */
if (pbuf_hdr->TCP_SegClose == DEF_YES) { /* If fin/close rx'd, ... */
pconn->ConnState = NET_TCP_CONN_STATE_CLOSE_WAIT; /* ... chng to close-wait state (see Note #2f5). */
}
/* -------------------- UPDATE TMR -------------------- */
timeout_sec = pconn->TimeoutConn_sec; /* Reset conn tmr (see Note #3b). */
timeout_tick = (NET_TMR_TICK)timeout_sec * NET_TMR_TIME_TICK_PER_SEC;
if (pconn->TimeoutTmr != (NET_TMR *)0) {
NetTmr_Set((NET_TMR *) pconn->TimeoutTmr,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(NET_ERR *)&err);
} else {
pconn->TimeoutTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
}
if ( err != NET_TMR_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
/*$PAGE*/
/* --------------- TX TCP CONN ACK/DATA --------------- */
ack_code = ((pbuf_hdr->TCP_SegAckTxReqCode == NET_TCP_CONN_TX_ACK_IMMED) ||
(pbuf_hdr->TCP_SegClose == DEF_YES)) /* See Note #2f3. */
? NET_TCP_CONN_TX_ACK_IMMED
: NET_TCP_CONN_TX_ACK;
/* Tx ack & any tx data (see Note #1c). */
NetTCP_TxConnTxQ(pconn, pbuf_hdr, ack_code, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
*perr = err_rtn;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerFinWait1()
*
* Description : (1) Handle TCP connection in FIN-WAIT-1 state :
*
* (a) Validate received TCP packet for current TCP connection state :
*
* (1) Sequence Number (SEQ) See Note #2a
* (2) Reset (RST) See Note #2b
* (3) Synchronization (SYN) See Note #2c
* (4) Acknowledgement (ACK) See Note #2d
* (5) Finish/Close (FIN) See Note #2f
*
* (b) Update TCP connection :
* (1) Handle received TCP segment See Notes #2d & #2e
* (2) Signal TCP/application connection close See Note #2d2B2
* (3) Update TCP connection state : See Notes #2f5A1, #2f5A2b1, & #2f5B
* (A) Configure TCP connection timeout value
* (B) Configure TCP connection timeout function
* (4) Update TCP connection timer(s) See Notes #2f5A1, #2f5A2b2, & #3
*
* (c) Transmit TCP connection acknowledgement & data See Notes #2e2A & #2f3
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_SEQ_SYNC_INVALID Received segment's synchronization is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_ACK_NONE Received segment's acknowledgement is
* NOT available.
* NET_TCP_ERR_CONN_ACK_INVALID Received segment's acknowledgement number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_RESET_VALID Received segment's reset flag is valid
* for current TCP connection; i.e. reset
* the TCP connection.
* NET_TCP_ERR_CONN_RESET_INVALID Received segment's reset flag is NOT valid
* for current TCP connection.
*
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
*
* ----- RETURNED BY NetTCP_RxPktConnIsValidSeq() : -----
* ----- RETURNED BY NetTCP_RxPktConnIsValidAck() : -----
* ---- RETURNED BY NetTCP_RxPktConnIsValidReset() : ----
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* ----- RETURNED BY NetTCP_RxPktConnHandlerSeg() : -----
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO
* data to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled & valid
* data queued for processing.
* NET_TCP_ERR_CONN_DATA_INVALID Received packet contains invalid segment
* data; NOT queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_DUP Received packet contains duplicate segment
* data; NOT queued to receive queue(s).
*
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
*
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* NET_TCP_ERR_RX_Q_FULL TCP connection receive queue full.
* NET_TCP_ERR_RX_Q_SIGNAL_FAULT TCP connection receive queue signal fault.
* NET_TCP_ERR_TX_Q_SIGNAL_FAULT TCP connection transmit queue signal fault.
* NET_TCP_ERR_RE_TX_SEG_TH TCP connection closed due to excessive retransmission.
* NET_TCP_ERR_TX TCP transmit error.
*
* - RETURNED BY NetTCP_RxPktConnHandlerSignalClose() : -
* NET_TCP_ERR_INVALID_CONN_ID Invalid application connection.
* NET_CONN_ERR_INVALID_FAMILY Invalid network connection family.
* NET_CONN_ERR_INVALID_CONN Invalid network connection number.
* NET_CONN_ERR_NOT_USED Network connection NOT currently used.
*
* ---------- RETURNED BY NetTCP_TxConnTxQ() : ----------
* NET_TCP_ERR_CONN_CLOSE TCP connection closed.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
*$PAGE*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandler().
*
* Note(s) : (2) TCP connections in the FIN-WAIT-1 state are handled as follows :
*
* (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence Number'
* states that in the "SYN-RECEIVED, ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2
* STATE, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT STATE" that ...
*
* (1) "Segments are processed in sequence ... processing is done in SEG.SEQ order."
*
* (2) "Initial tests on arrival are used to discard old duplicates."
*
* (3) "If a segment's contents straddle the boundary between old and new, only the
* new parts should be processed."
*
* (4) (A) "If an incoming segment is not acceptable," ...
*
* (B) "an acknowledgment should be sent in reply" ...
*
* (C) "(unless the RST bit is set, if so drop the segment)".
*
* See also Notes #2b2Aa & #2b2B.
*
* See also 'NetTCP_RxPktConnIsValidSeq() Note #1d'.
*
* (b) (1) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit' states
* that in the "ESTABLISHED, FIN-WAIT-1, FIN-WAIT-2, CLOSE-WAIT" states that "if the
* RST bit is set then, any outstanding RECEIVEs and SEND[s] should receive 'reset'
* responses. All segment queues should be flushed. Users should also receive an
* unsolicited general 'connection reset' signal[, and] enter the CLOSED state".
*
* (B) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing' reiterates
* that "if the receiver ... of a RST ... was in any other state [other than LISTEN
* or SYN-RECEIVED], it aborts the connection and advises the user and goes to the
* CLOSED state".
*
* (2) (A) RFC Draft-IETF-TCPm-TCPSecure #00, Section 2.2 amends the "handling of a segment
* with the RST bit when in a synchronized state" to "provide some protection against
* ... blind reset attack[s] using the RST bit" :
*
* (a) "If the RST bit is set and the sequence number is outside the expected
* window, silently drop the segment."
*
* (b) "If the RST bit is exactly the next expected sequence number [sic], reset
* the connection"; it is assumed that this should read "if the RST bit is
* set and the sequence number is exactly the next expected sequence number,
* reset the connection."
*
* (c) "If the RST bit is set and the sequence number does not exactly match
* the next expected sequence value, yet is within the acceptable window
* (RCV.NXT <= SEG.SEQ < RCV.NXT+RCV.WND) send an acknowledgment."
*
* (B) ???? In addition, RFC Draft-IETF-TCPm-TCPSecure #00 does NOT provide a precedence
* priority for handling TCP segments received with BOTH the RST & SYN bits set.
*
* ???? Therefore, since it does NOT seem reasonable to reset a TCP connection
* due to a TCP segment that also attempted to synchronize the TCP connection,
* it is assumed that the amended handling of the SYN bit should take precedence
* over the amended handling of the RST bit.
*
* See also Note #2c2.
*
* (c) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check SYN Bit'
* states that in the "SYN-RECEIVED [STATE], ESTABLISHED STATE, FIN-WAIT STATE-1,
* FIN-WAIT STATE-2, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that ...
*
* (A) "If the SYN is in the window it is an error, send a reset, any outstanding
* RECEIVEs and SEND[s] should receive 'reset' responses, all segment queues
* should be flushed, the user should also receive an unsolicited general
* 'connection reset' signal[, and] enter the CLOSED state."
*
* (B) But "if the SYN is not in the window this step would not have been reached
* and an ack would have been sent".
*
* (2) HOWEVER, RFC Draft-IETF-TCPm-TCPSecure #00, Section 3.2 amends the "handling
* of a segment with the SYN bit set in the synchronized state ... [by] handling
* ... the SYN bit" as follows :
*
* (a) "If the SYN bit is set and the sequence number is outside the
* expected window, send an ACK back to the peer."
*
* (b) "If the SYN bit is set and the sequence number is an exact
* match to the next expected sequence (RCV.NXT == SEG.SEQ)
* then send an ACK segment ... but ... subtract one from
* value being acknowledged."
*
* (c) "If the SYN bit is set and the sequence number is acceptable,
* i.e.: (RCV.NXT <= SEG.SEQ <= RCV.NXT+RCV.WND) then send an
* ACK segment."
*$PAGE*
* (d) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field'
* states that ... :
*
* (1) "If the ACK bit is off drop the segment."
*
* (2) "If the ACK bit is on" ...
*
* (A) And in the "ESTABLISHED STATE" ...
*
* (1) "If SND.UNA < SEG.ACK <= SND.NXT then" ...
*
* (a) "set SND.UNA <- SEG.ACK."
*
* (b) "Any segments on the retransmission queue which are thereby entirely
* acknowledged are removed."
*
* (c) "the send window should be updated" :
*
* (1) (A) (1) "If ((SND.WL1 < SEG.SEQ) or" ...
*
* (2) (a) "(SND.WL1 = SEG.SEQ and" ...
* (b) "SND.WL2 <= SEG.ACK))," ...
*
* (B) (1) "set SND.WND <- SEG.WND," ...
* (2) "set SND.WL1 <- SEG.SEQ," ...
* (3) "set SND.WL2 <- SEG.ACK."
*
* (2) "Note that SND.WND is an offset from SND.UNA, that SND.WL1 records the
* sequence number of the last segment used to update SND.WND, and that
* SND.WL2 records the acknowledgment number of the last segment used to
* update SND.WND. The check here preveents using old segments to update
* the window."
*
* (2) (a) "If the ACK is a duplicate (SEG.ACK <= SND.UNA), it can be ignored."
*
* (b) RFC #1122, Section 4.2.2.20.(g) amends the transmit window update criteria
* for the segment's acknowledgement to include SND.UNA : "The window should
* updated if SND.UNA <= SEG.ACK <= SND.NXT."
*
* See also 'NetTCP_RxPktConnHandlerTxWinRemote() Note #1b2'.
*
* (3) "If the ACK acks something not yet sent (SEG.ACK > SND.NXT) then send an ACK
* [and] drop the segment."
*
* (B) (1) For the "FIN-WAIT-1 STATE" :
*
* (a) "in addition to the processing for the ESTABLISHED state" ...
* (b) "if our FIN is now acknowledged then" ...
* (1) "enter FIN-WAIT-2 [state] and continue processing in that state."
*
* (2) (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* FIN-WAIT-2 STATE' states that "if the retransmission queue is empty, the user's
* CLOSE can be acknowledged".
*
* (b) However, a TCP connection transitions into the FIN-WAIT-2 state if & only if
* the TCP connection's close request was previously acknowledged while in the
* FIN-WAIT-1 state. Thus, the TCP connection's re-transmit queue should
* already be empty prior to entering the FIN-WAIT-2 state.
*
* ???? Therefore, a TCP connection in the FIN-WAIT-1 state should :
*
* (1) Signal the application layer that "the user's close [is] acknowledged"
* whenever its re-transmit queue becomes empty.
*
* (2) Close all unused timers (see also Note #2f5A1b).
*$PAGE*
* (e) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment Text'
* states that for the "ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2 STATE ... it
* is possible to deliver segment text to user RECEIVE buffers" :
*
* (1) "If the segment ... carries [a] PUSH flag, then the user is informed [and] the
* buffer is returned."
*
* (2) (A) (1) "When the TCP takes responsibility for delivering the data to the user it
* must also acknowledge the receipt of the data."
*
* (2) "This acknowledgment should be piggybacked on a segment being transmitted
* if possible without incurring undue delay."
*
* (B) "Once the TCP takes responsibility for the data" ...
*
* (1) "it advances RCV.NXT over the data accepted," ...
*
* (2) "adjusts RCV.WND as appropriate to the current buffer availability" ...
*
* (3) (a) "The total of RCV.NXT and RCV.WND should not be reduced."
*
* (b) RFC #793, Section 3.7 'Data Communication : Managing the Window' &
* RFC #1122, Section 4.2.2.16 confirm that "a TCP receiver SHOULD NOT
* shrink the window"; i.e. "advertise a much smaller window without
* having accepted that much data".
*
* (f) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states
* that "if the FIN bit is set" ...
*
* (1) "signal the user 'connection closing' and return any pending RECEIVEs with
* same message," ...
*
* (2) "advance RCV.NXT over the FIN," ...
*
* (3) "send an acknowledgment for the FIN" ...
*
* (4) "FIN implies PUSH for any segment text not yet delivered to the user" ...
*
* (5) For the "FIN-WAIT-1 STATE" :
*
* (A) "If our FIN has been ACKed (perhaps in this segment), then" ...
*
* (1) "enter TIME-WAIT [state]" ...
* (a) "start the time-wait timer, ...
* (1) A TCP connection should be closed WITHOUT fault following a TCP
* connection TIME-WAIT timeout.
*
* (b) "turn off the other timers;" ...
*
* (2) However, it is possible that some closing received data from the remote
* host is available but has NOT yet been received by the application layer.
*
* (a) Therefore, if the application receive queue is closed, then enter the
* TIME-WAIT state.
*
* (b) (1) But if the application receive queue is NOT closed, then enter the
* connection-closing-data-available state to allow the application
* layer to receive the remaining receive data.
*
* (2) (A) To satisfy the required time-wait timeout of two maximum segment
* lifetimes (see Note #2f5A1a), the time-wait timeout is intially
* used to provide the application layer sufficient time to receive
* the closing received data.
*
* (B) If after the time-wait timeout expires, the application receive
* queue is still not empty, the user connection timeout is used
* to provide the application layer additional time to receive the
* closing received data.
*
* See also Note #3.
*
* (B) "otherwise, enter the CLOSING state."
*$PAGE*
* (3) (a) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : USER TIMEOUT' states that
* "for any state if the user timeout expires, flush all queues, signal the user
* 'error : connection aborted due to user timeout' ... [and] enter the CLOSED state".
*
* (b) However, NO RFC specifies or suggests any mechanism to implement/handle user timeouts.
*
* ???? Therefore, it is assumed that ANY TCP connection that receives a valid TCP data
* or control segment should reset its user connection timer.
*
* (4) Since the mechanisms of TCP connection close are independent of the application layer
* close; any external application layer close error(s) are ignored.
*********************************************************************************************************
*/
static void NetTCP_RxPktConnHandlerFinWait1 (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
NET_TCP_SEQ_CODE seq_code;
NET_TCP_ACK_CODE ack_code;
NET_TCP_RESET_CODE reset_code;
CPU_BOOLEAN data_avail;
NET_TCP_TIMEOUT_SEC timeout_sec;
NET_TMR_TICK timeout_tick;
CPU_FNCT_PTR timeout_fnct;
NET_TCP_FREE_CODE free_code;
NET_ERR err;
NET_ERR err_rtn;
/*$PAGE*/
/* -------------- VALIDATE RX'D TCP PKT --------------- */
/* Chk for rx'd fin/close. */
if (pbuf_hdr->TCP_SegClose == DEF_YES) { /* If fin/close avail, update seg lens. */
pbuf_hdr->TCP_SegLenInit += NET_TCP_SEG_LEN_CLOSE;
pbuf_hdr->TCP_SegLen += NET_TCP_SEG_LEN_CLOSE;
}
/* Chk rx'd seq nbr. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (seq_code) {
case NET_TCP_CONN_RX_SEQ_VALID:
break;
case NET_TCP_CONN_RX_SEQ_SYNC: /* If invalid sync rx'd, ... */
case NET_TCP_CONN_RX_SEQ_SYNC_INVALID:
/* ... tx TCP conn ack (see Notes #2c2 & #2b2B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_SEQ_SYNC_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_SEQ_NONE:
case NET_TCP_CONN_RX_SEQ_INVALID: /* If invalid seq rx'd (see Note #2a4A), ... */
default:
if (pbuf_hdr->TCP_SegReset != DEF_YES) { /* ... & reset NOT rx'd (see Note #2a4C), ... */
/* ... tx TCP conn ack (see Note #2a4B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
}
*perr = NET_TCP_ERR_CONN_SEQ_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd reset. */
reset_code = NetTCP_RxPktConnIsValidReset(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (reset_code) {
case NET_TCP_CONN_RX_RESET_NONE:
break;
case NET_TCP_CONN_RX_RESET_VALID: /* If valid reset rx'd, ... */
/* ... close TCP conn (see Note #2b1A). */
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_RESET_VALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_RESET_INVALID: /* If invalid reset rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2b2Ac). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd ack. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
case NET_TCP_CONN_RX_ACK_DUP:
case NET_TCP_CONN_RX_ACK_PREV:
break;
case NET_TCP_CONN_RX_ACK_NONE: /* If NO ack rx'd, ... */
*perr = NET_TCP_ERR_CONN_ACK_NONE; /* ... ignore TCP pkt (see Note #2d1). */
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_ACK_INVALID: /* If invalid ack rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2d2A3). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ----------------- HANDLE RX'D SEG ------------------ */
NetTCP_RxPktConnHandlerSeg(pconn, ack_code, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_DATA_DUP: /* ???? Allow dup data to update TCP conn? */
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* ----------------- UPDATE TCP CONN ------------------ */
timeout_fnct = (CPU_FNCT_PTR)0;
if (pconn->TxQ_State == NET_TCP_TX_Q_STATE_CONN_CLOSED) { /* If local conn close ack'd (see Note #2f5A); ... */
/* Closing data avail for half-closed conns ONLY. */
data_avail = ((pconn->ConnCloseCode != NET_CONN_CLOSE_HALF ) ||
((pconn->RxQ_State == NET_TCP_RX_Q_STATE_CONN_CLOSED) &&
(pconn->RxQ_App_Head == (NET_BUF *)0))) ? DEF_NO : DEF_YES;
/* ... signal app conn close (see Note #2d2B2b1); ... */
NetTCP_RxPktConnHandlerSignalClose(pconn, data_avail, &err);
switch (err) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_FAIL: /* Ignore any app conn close err(s) [see Note #4]. */
break;
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_INVALID_CONN_ID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_CONN:
case NET_CONN_ERR_NOT_USED:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
*perr = err;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
if (pbuf_hdr->TCP_SegClose == DEF_YES) { /* ... & if fin/close rx'd ... */
if (data_avail != DEF_YES) { /* ... & NO app data avail, ... */
/* ... chng to time-wait state (see Note #2f5A2a); ... */
pconn->ConnState = NET_TCP_CONN_STATE_TIME_WAIT;
pconn->ConnCloseTimeoutFaultFlag = DEF_NO; /* ... clr close timeout fault (see Note #2f5A1a1);... */
timeout_fnct = (CPU_FNCT_PTR)NetTCP_ConnCloseTimeout;
} else { /* ... else chng to conn-closing-data-avail state ... */
/* ... (see Note #2f5A2b1);... */
pconn->ConnState = NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL;
timeout_fnct = (CPU_FNCT_PTR)NetTCP_ConnClosingTimeoutDataAvail;
}
/* ... & start time-wait tmr (see Notes #2f5A1a & ... */
/* ... #2f5A2b2A). */
timeout_sec = pconn->TimeoutMaxSeg_sec * NET_TCP_CONN_TIMEOUT_MAX_SEG_SCALAR;
} else {
pconn->ConnState = NET_TCP_CONN_STATE_FIN_WAIT_2; /* ... else chng to fin-wait-2 state (see Note #2d2B1b1)*/
timeout_sec = pconn->TimeoutConn_sec; /* ... & start conn close tmr (see Note #3b). */
timeout_fnct = (CPU_FNCT_PTR)NetTCP_ConnCloseTimeout;
}
} else {
if (pbuf_hdr->TCP_SegClose == DEF_YES) { /* Else if fin/close rx'd, ... */
pconn->ConnState = NET_TCP_CONN_STATE_CLOSING; /* ... chng to closing state (see Note #2f5B) ... */
timeout_sec = pconn->TimeoutConn_sec; /* ... & start conn close tmr (see Note #3b). */
timeout_fnct = (CPU_FNCT_PTR)NetTCP_ConnCloseTimeout;
}
}
/* ------------------- UPDATE TMRs -------------------- */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_TIME_WAIT: /* If in time-wait (see Note #2f5A1) ... */
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL: /* ... or closing state(s) [see Note #2d2B2b2], ... */
free_code = NET_TCP_CONN_FREE_TMR_ALL; /* ... free all TCP conn tmrs (see Note #2f5A1b). */
DEF_BIT_CLR(free_code, NET_TCP_CONN_FREE_TMR_TIMEOUT);
NetTCP_ConnFreeTmr(pconn, free_code);
break;
}
if (timeout_fnct != (CPU_FNCT_PTR)0) {
timeout_tick = (NET_TMR_TICK)timeout_sec * NET_TMR_TIME_TICK_PER_SEC;
if (pconn->TimeoutTmr != (NET_TMR *)0) {
NetTmr_Set((NET_TMR *) pconn->TimeoutTmr,
(CPU_FNCT_PTR) timeout_fnct,
(NET_TMR_TICK) timeout_tick,
(NET_ERR *)&err);
} else {
pconn->TimeoutTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) timeout_fnct,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
}
if ( err != NET_TMR_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
}
/*$PAGE*/
/* --------------- TX TCP CONN ACK/DATA --------------- */
ack_code = ((pbuf_hdr->TCP_SegAckTxReqCode == NET_TCP_CONN_TX_ACK_IMMED) ||
(pbuf_hdr->TCP_SegClose == DEF_YES)) /* See Note #2f3. */
? NET_TCP_CONN_TX_ACK_IMMED
: NET_TCP_CONN_TX_ACK;
if ((pconn->ConnState == NET_TCP_CONN_STATE_FIN_WAIT_1) || /* If TCP conn tx Q NOT closed, ... */
(pconn->ConnState == NET_TCP_CONN_STATE_CLOSING )) { /* ... tx ack & any tx data (see Note #1c). */
NetTCP_TxConnTxQ(pconn, pbuf_hdr, ack_code, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
} else { /* Else tx TCP conn ack (see Note #2f3). */
NetTCP_TxConnAck(pconn, pbuf_hdr, ack_code, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
break;
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
}
*perr = err_rtn;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerFinWait2()
*
* Description : (1) Handle TCP connection in FIN-WAIT-2 state :
*
* (a) Validate received TCP packet for current TCP connection state :
*
* (1) Sequence Number (SEQ) See Note #2a
* (2) Reset (RST) See Note #2b
* (3) Synchronization (SYN) See Note #2c
* (4) Acknowledgement (ACK) See Note #2d
* (5) Finish/Close (FIN) See Note #2f
*
* (b) Update TCP connection :
* (1) Handle received TCP segment See Notes #2d & #2e
* (2) Update TCP connection state : See Notes #2f5A & #2f5B2a
* (A) Configure TCP connection timeout value
* (B) Configure TCP connection timeout function
* (3) Update TCP connection timer(s) See Notes #2f5A, #2f5B2b, & #3
*
* (c) Transmit TCP connection acknowledgement See Notes #2e2A & #2f3
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_SEQ_SYNC_INVALID Received segment's synchronization is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_ACK_NONE Received segment's acknowledgement is
* NOT available.
* NET_TCP_ERR_CONN_ACK_INVALID Received segment's acknowledgement number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_RESET_VALID Received segment's reset flag is valid
* for current TCP connection; i.e. reset
* the TCP connection.
* NET_TCP_ERR_CONN_RESET_INVALID Received segment's reset flag is NOT valid
* for current TCP connection.
*
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
*
* -- RETURNED BY NetTCP_RxPktConnIsValidSeq() : --
* -- RETURNED BY NetTCP_RxPktConnIsValidAck() : --
* - RETURNED BY NetTCP_RxPktConnIsValidReset() : -
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* -- RETURNED BY NetTCP_RxPktConnHandlerSeg() : --
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO
* data to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled & valid
* data queued for processing.
* NET_TCP_ERR_CONN_DATA_INVALID Received packet contains invalid segment
* data; NOT queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_DUP Received packet contains duplicate segment
* data; NOT queued to receive queue(s).
*
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
*
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* NET_TCP_ERR_RX_Q_FULL TCP connection receive queue full.
* NET_TCP_ERR_RX_Q_SIGNAL_FAULT TCP connection receive queue signal fault.
*
* ------- RETURNED BY NetTCP_TxConnAck() : -------
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandler().
*$PAGE*
* Note(s) : (2) TCP connections in the FIN-WAIT-2 state are handled as follows :
*
* (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence Number'
* states that in the "SYN-RECEIVED, ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2
* STATE, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT STATE" that ...
*
* (1) "Segments are processed in sequence ... processing is done in SEG.SEQ order."
*
* (2) "Initial tests on arrival are used to discard old duplicates."
*
* (3) "If a segment's contents straddle the boundary between old and new, only the
* new parts should be processed."
*
* (4) (A) "If an incoming segment is not acceptable," ...
*
* (B) "an acknowledgment should be sent in reply" ...
*
* (C) "(unless the RST bit is set, if so drop the segment)".
*
* See also Notes #2b2Aa & #2b2B.
*
* See also 'NetTCP_RxPktConnIsValidSeq() Note #1d'.
*
* (b) (1) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit' states
* that in the "ESTABLISHED, FIN-WAIT-1, FIN-WAIT-2, CLOSE-WAIT" states that "if the
* RST bit is set then, any outstanding RECEIVEs and SEND[s] should receive 'reset'
* responses. All segment queues should be flushed. Users should also receive an
* unsolicited general 'connection reset' signal[, and] enter the CLOSED state".
*
* (B) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing' reiterates
* that "if the receiver ... of a RST ... was in any other state [other than LISTEN
* or SYN-RECEIVED], it aborts the connection and advises the user and goes to the
* CLOSED state".
*
* (2) (A) RFC Draft-IETF-TCPm-TCPSecure #00, Section 2.2 amends the "handling of a segment
* with the RST bit when in a synchronized state" to "provide some protection against
* ... blind reset attack[s] using the RST bit" :
*
* (a) "If the RST bit is set and the sequence number is outside the expected
* window, silently drop the segment."
*
* (b) "If the RST bit is exactly the next expected sequence number [sic], reset
* the connection"; it is assumed that this should read "if the RST bit is
* set and the sequence number is exactly the next expected sequence number,
* reset the connection."
*
* (c) "If the RST bit is set and the sequence number does not exactly match
* the next expected sequence value, yet is within the acceptable window
* (RCV.NXT <= SEG.SEQ < RCV.NXT+RCV.WND) send an acknowledgment."
*
* (B) ???? In addition, RFC Draft-IETF-TCPm-TCPSecure #00 does NOT provide a precedence
* priority for handling TCP segments received with BOTH the RST & SYN bits set.
*
* ???? Therefore, since it does NOT seem reasonable to reset a TCP connection
* due to a TCP segment that also attempted to synchronize the TCP connection,
* it is assumed that the amended handling of the SYN bit should take precedence
* over the amended handling of the RST bit.
*
* See also Note #2c2.
*
* (c) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check SYN Bit'
* states that in the "SYN-RECEIVED [STATE], ESTABLISHED STATE, FIN-WAIT STATE-1,
* FIN-WAIT STATE-2, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that ...
*
* (A) "If the SYN is in the window it is an error, send a reset, any outstanding
* RECEIVEs and SEND[s] should receive 'reset' responses, all segment queues
* should be flushed, the user should also receive an unsolicited general
* 'connection reset' signal[, and] enter the CLOSED state."
*
* (B) But "if the SYN is not in the window this step would not have been reached
* and an ack would have been sent".
*
* (2) HOWEVER, RFC Draft-IETF-TCPm-TCPSecure #00, Section 3.2 amends the "handling
* of a segment with the SYN bit set in the synchronized state ... [by] handling
* ... the SYN bit" as follows :
*
* (a) "If the SYN bit is set and the sequence number is outside the
* expected window, send an ACK back to the peer."
*
* (b) "If the SYN bit is set and the sequence number is an exact
* match to the next expected sequence (RCV.NXT == SEG.SEQ)
* then send an ACK segment ... but ... subtract one from
* value being acknowledged."
*
* (c) "If the SYN bit is set and the sequence number is acceptable,
* i.e.: (RCV.NXT <= SEG.SEQ <= RCV.NXT+RCV.WND) then send an
* ACK segment."
*$PAGE*
* (d) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field'
* states that ... :
*
* (1) "If the ACK bit is off drop the segment."
*
* (2) "If the ACK bit is on" ...
*
* (A) And in the "ESTABLISHED STATE" ...
*
* (1) "If SND.UNA < SEG.ACK <= SND.NXT then" ...
*
* (a) "set SND.UNA <- SEG.ACK."
*
* (b) "Any segments on the retransmission queue which are thereby entirely
* acknowledged are removed."
*
* (c) "the send window should be updated" :
*
* (1) (A) (1) "If ((SND.WL1 < SEG.SEQ) or" ...
*
* (2) (a) "(SND.WL1 = SEG.SEQ and" ...
* (b) "SND.WL2 <= SEG.ACK))," ...
*
* (B) (1) "set SND.WND <- SEG.WND," ...
* (2) "set SND.WL1 <- SEG.SEQ," ...
* (3) "set SND.WL2 <- SEG.ACK."
*
* (2) "Note that SND.WND is an offset from SND.UNA, that SND.WL1 records the
* sequence number of the last segment used to update SND.WND, and that
* SND.WL2 records the acknowledgment number of the last segment used to
* update SND.WND. The check here preveents using old segments to update
* the window."
*
* (2) (a) "If the ACK is a duplicate (SEG.ACK <= SND.UNA), it can be ignored."
*
* (b) RFC #1122, Section 4.2.2.20.(g) amends the transmit window update criteria
* for the segment's acknowledgement to include SND.UNA : "The window should
* updated if SND.UNA <= SEG.ACK <= SND.NXT."
*
* See also 'NetTCP_RxPktConnHandlerTxWinRemote() Note #1b2'.
*
* (3) "If the ACK acks something not yet sent (SEG.ACK > SND.NXT) then send an ACK
* [and] drop the segment."
*
* (B) For the "FIN-WAIT-2 STATE" :
*
* (1) "in addition to the processing for the ESTABLISHED state" ...
* (2) "if the retransmission queue is empty," ...
*
* (a) (1) "the user's CLOSE can be acknowledged."
* (2) However, a TCP connection transitions into the FIN-WAIT-2 state if &
* only if the TCP connection's close request was previously acknowledged
* while in the FIN-WAIT-1 state. Thus, the TCP connection's re-transmit
* queue should already be empty prior to entering the FIN-WAIT-2 state.
*
* See also 'NetTCP_RxPktConnHandlerFinWait1() Note #2d2B2'.
*
* (e) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment Text'
* states that for the "ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2 STATE ... it
* is possible to deliver segment text to user RECEIVE buffers" :
*
* (1) "If the segment ... carries [a] PUSH flag, then the user is informed [and] the
* buffer is returned."
*
* (2) (A) "When the TCP takes responsibility for delivering the data to the user it
* must also acknowledge the receipt of the data."
*
* (B) "Once the TCP takes responsibility for the data" ...
*
* (1) "it advances RCV.NXT over the data accepted," ...
*
* (2) "adjusts RCV.WND as appropriate to the current buffer availability" ...
*
* (3) (a) "The total of RCV.NXT and RCV.WND should not be reduced."
*
* (b) RFC #793, Section 3.7 'Data Communication : Managing the Window' &
* RFC #1122, Section 4.2.2.16 confirm that "a TCP receiver SHOULD NOT
* shrink the window"; i.e. "advertise a much smaller window without
* having accepted that much data".
*$PAGE*
* (f) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states
* that "if the FIN bit is set" ...
*
* (1) "signal the user 'connection closing' and return any pending RECEIVEs with
* same message," ...
*
* (2) "advance RCV.NXT over the FIN," ...
*
* (3) "send an acknowledgment for the FIN" ...
*
* (4) "FIN implies PUSH for any segment text not yet delivered to the user" ...
*
* (5) For the "FIN-WAIT-2 STATE" :
*
* (A) "Enter the TIME-WAIT state" ...
* (1) "Start the time-wait timer," ...
* (a) A TCP connection should be closed WITHOUT fault following a TCP
* connection TIME-WAIT timeout.
*
* (2) "turn off the other timers."
*
* (B) However, it is possible that some closing received data from the remote
* host is available but has NOT yet been received by the application layer.
*
* (1) Therefore, if the application receive queue is closed, then enter the
* TIME-WAIT state.
*
* (2) (a) But if the application receive queue is NOT closed, then enter the
* connection-closing-data-available state to allow the application
* layer to receive the remaining receive data.
*
* (b) (1) To satisfy the required time-wait timeout of two maximum segment
* lifetimes (see Note #2f5A1a), the time-wait timeout is intially
* used to provide the application layer sufficient time to receive
* the closing received data.
*
* (2) If after the time-wait timeout expires, the application receive
* queue is still not empty, the user connection timeout is used
* to provide the application layer additional time to receive the
* closing received data.
*
* See also Note #3.
*
* (3) (a) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : USER TIMEOUT' states that
* "for any state if the user timeout expires, flush all queues, signal the user
* 'error : connection aborted due to user timeout' ... [and] enter the CLOSED state".
*
* (b) However, NO RFC specifies or suggests any mechanism to implement/handle user timeouts.
*
* ???? Therefore, it is assumed that ANY TCP connection that receives a valid TCP data
* or control segment should reset its user connection timer.
*********************************************************************************************************
*/
static void NetTCP_RxPktConnHandlerFinWait2 (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
NET_TCP_SEQ_CODE seq_code;
NET_TCP_ACK_CODE ack_code;
NET_TCP_RESET_CODE reset_code;
CPU_BOOLEAN data_avail;
NET_TCP_TIMEOUT_SEC timeout_sec;
NET_TMR_TICK timeout_tick;
CPU_FNCT_PTR timeout_fnct;
NET_TCP_FREE_CODE free_code;
NET_ERR err;
NET_ERR err_rtn;
/*$PAGE*/
/* -------------- VALIDATE RX'D TCP PKT --------------- */
/* Chk for rx'd fin/close. */
if (pbuf_hdr->TCP_SegClose == DEF_YES) { /* If fin/close avail, update seg lens. */
pbuf_hdr->TCP_SegLenInit += NET_TCP_SEG_LEN_CLOSE;
pbuf_hdr->TCP_SegLen += NET_TCP_SEG_LEN_CLOSE;
}
/* Chk rx'd seq nbr. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (seq_code) {
case NET_TCP_CONN_RX_SEQ_VALID:
break;
case NET_TCP_CONN_RX_SEQ_SYNC: /* If invalid sync rx'd, ... */
case NET_TCP_CONN_RX_SEQ_SYNC_INVALID:
/* ... tx TCP conn ack (see Notes #2c2 & #2b2B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_SEQ_SYNC_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_SEQ_NONE:
case NET_TCP_CONN_RX_SEQ_INVALID: /* If invalid seq rx'd (see Note #2a4A), ... */
default:
if (pbuf_hdr->TCP_SegReset != DEF_YES) { /* ... & reset NOT rx'd (see Note #2a4C), ... */
/* ... tx TCP conn ack (see Note #2a4B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
}
*perr = NET_TCP_ERR_CONN_SEQ_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd reset. */
reset_code = NetTCP_RxPktConnIsValidReset(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (reset_code) {
case NET_TCP_CONN_RX_RESET_NONE:
break;
case NET_TCP_CONN_RX_RESET_VALID: /* If valid reset rx'd, ... */
/* ... close TCP conn (see Note #2b1A). */
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_RESET_VALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_RESET_INVALID: /* If invalid reset rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2b2Ac). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd ack. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
case NET_TCP_CONN_RX_ACK_DUP:
case NET_TCP_CONN_RX_ACK_PREV:
break;
case NET_TCP_CONN_RX_ACK_NONE: /* If NO ack rx'd, ... */
*perr = NET_TCP_ERR_CONN_ACK_NONE; /* ... ignore TCP pkt (see Note #2d1). */
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_ACK_INVALID: /* If invalid ack rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2d2A3). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ----------------- HANDLE RX'D SEG ------------------ */
NetTCP_RxPktConnHandlerSeg(pconn, ack_code, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_DATA_DUP: /* ???? Allow dup data to update TCP conn? */
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* ----------------- UPDATE TCP CONN ------------------ */
if (pbuf_hdr->TCP_SegClose == DEF_YES) { /* If fin/close rx'd, ... */
/* Closing data avail for half-closed conns ONLY. */
data_avail = ((pconn->ConnCloseCode != NET_CONN_CLOSE_HALF ) ||
((pconn->RxQ_State == NET_TCP_RX_Q_STATE_CONN_CLOSED) &&
(pconn->RxQ_App_Head == (NET_BUF *)0))) ? DEF_NO : DEF_YES;
if (data_avail != DEF_YES) { /* ... & NO app data avail, ... */
/* ... chng to time-wait state (see Note #2f5B1); ... */
pconn->ConnState = NET_TCP_CONN_STATE_TIME_WAIT;
pconn->ConnCloseTimeoutFaultFlag = DEF_NO; /* ... clr close timeout fault (see Note #2f5A1a); ... */
timeout_fnct = (CPU_FNCT_PTR)NetTCP_ConnCloseTimeout;
} else { /* ... else chng to conn-closing-data-avail state ... */
/* ... (see Note #2f5B2a); ... */
pconn->ConnState = NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL;
timeout_fnct = (CPU_FNCT_PTR)NetTCP_ConnClosingTimeoutDataAvail;
}
/* ... & start time-wait tmr (see Notes #2f5A1 & ... */
/* ... #2f5B2b1). */
timeout_sec = pconn->TimeoutMaxSeg_sec * NET_TCP_CONN_TIMEOUT_MAX_SEG_SCALAR;
} else {
timeout_sec = pconn->TimeoutConn_sec; /* Else start conn close tmr (see Note #3b). */
timeout_fnct = (CPU_FNCT_PTR)NetTCP_ConnCloseTimeout;
}
/*$PAGE*/
/* ------------------- UPDATE TMRs -------------------- */
/* In time-wait or closing state(s) [see Note #2f5A], */
free_code = NET_TCP_CONN_FREE_TMR_ALL; /* ... free all TCP conn tmrs (see Note #2f5A2). */
DEF_BIT_CLR(free_code, NET_TCP_CONN_FREE_TMR_TIMEOUT);
NetTCP_ConnFreeTmr(pconn, free_code);
timeout_tick = (NET_TMR_TICK)timeout_sec * NET_TMR_TIME_TICK_PER_SEC;
if (pconn->TimeoutTmr != (NET_TMR *)0) {
NetTmr_Set((NET_TMR *) pconn->TimeoutTmr,
(CPU_FNCT_PTR) timeout_fnct,
(NET_TMR_TICK) timeout_tick,
(NET_ERR *)&err);
} else {
pconn->TimeoutTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) timeout_fnct,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
}
if ( err != NET_TMR_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
/* ----------------- TC TCP CONN ACK ------------------ */
/* Tx TCP conn ack (see Notes #1c). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_IMMED, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
break;
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
*perr = err_rtn;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerClosing()
*
* Description : (1) Handle TCP connection in CLOSING state :
*
* (a) Validate received TCP packet for current TCP connection state :
*
* (1) Sequence Number (SEQ) See Note #2a
* (2) Reset (RST) See Note #2b
* (3) Synchronization (SYN) See Note #2c
* (4) Acknowledgement (ACK) See Note #2d
* (5) Finish/Close (FIN) See Note #2f
*
* (b) Update TCP connection :
* (1) Handle received TCP segment See Notes #2d & #2e
* (2) Update TCP connection state : See Note #2d2B2a1A
* (A) Configure TCP connection timeout value
* (B) Configure TCP connection timeout function
* (3) Update TCP connection timer(s) See Notes #2d2B2a1A, #2d2B2a1B2b,
* & #3
*
* (c) Transmit TCP connection acknowledgement & data See Notes #2d2B1 & #2f3
*
*$PAGE*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_SEQ_SYNC_INVALID Received segment's synchronization is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_ACK_NONE Received segment's acknowledgement is
* NOT available.
* NET_TCP_ERR_CONN_ACK_INVALID Received segment's acknowledgement number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_RESET_VALID Received segment's reset flag is valid
* for current TCP connection; i.e. reset
* the TCP connection.
* NET_TCP_ERR_CONN_RESET_INVALID Received segment's reset flag is NOT valid
* for current TCP connection.
*
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
*
* ----- RETURNED BY NetTCP_RxPktConnIsValidSeq() : -----
* ----- RETURNED BY NetTCP_RxPktConnIsValidAck() : -----
* ---- RETURNED BY NetTCP_RxPktConnIsValidReset() : ----
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* ----- RETURNED BY NetTCP_RxPktConnHandlerSeg() : -----
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO
* data to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled & valid
* data queued for processing.
* NET_TCP_ERR_CONN_DATA_INVALID Received packet contains invalid segment
* data; NOT queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_DUP Received packet contains duplicate segment
* data; NOT queued to receive queue(s).
*
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
*
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* NET_TCP_ERR_RX_Q_FULL TCP connection receive queue full.
* NET_TCP_ERR_RX_Q_SIGNAL_FAULT TCP connection receive queue signal fault.
* NET_TCP_ERR_TX_Q_SIGNAL_FAULT TCP connection transmit queue signal fault.
* NET_TCP_ERR_RE_TX_SEG_TH TCP connection closed due to excessive retransmission.
* NET_TCP_ERR_TX TCP transmit error.
*
* - RETURNED BY NetTCP_RxPktConnHandlerSignalClose() : -
* NET_TCP_ERR_INVALID_CONN_ID Invalid application connection.
* NET_CONN_ERR_INVALID_FAMILY Invalid network connection family.
* NET_CONN_ERR_INVALID_CONN Invalid network connection number.
* NET_CONN_ERR_NOT_USED Network connection NOT currently used.
*
* ---------- RETURNED BY NetTCP_TxConnTxQ() : ----------
* NET_TCP_ERR_CONN_CLOSE TCP connection closed.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
*$PAGE*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandler().
*
* Note(s) : (2) TCP connections in the CLOSING state are handled as follows :
*
* (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence Number'
* states that in the "SYN-RECEIVED, ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2
* STATE, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT STATE" that ...
*
* (1) "Segments are processed in sequence ... processing is done in SEG.SEQ order."
*
* (2) "Initial tests on arrival are used to discard old duplicates."
*
* (3) "If a segment's contents straddle the boundary between old and new, only the
* new parts should be processed."
*
* (4) (A) "If an incoming segment is not acceptable," ...
*
* (B) "an acknowledgment should be sent in reply" ...
*
* (C) "(unless the RST bit is set, if so drop the segment)".
*
* See also Notes #2b2Aa & #2b2B.
*
* See also 'NetTCP_RxPktConnIsValidSeq() Note #1d'.
*
* (b) (1) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit'
* states that in the "CLOSING, LAST-ACK, TIME-WAIT" states that "if the RST bit
* is set then, enter the CLOSED state".
*
* (B) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing' reiterates
* that "if the receiver ... of a RST ... was in any other state [other than LISTEN
* or SYN-RECEIVED], it aborts the connection and advises the user and goes to the
* CLOSED state".
*
* (2) (A) RFC Draft-IETF-TCPm-TCPSecure #00, Section 2.2 amends the "handling of a segment
* with the RST bit when in a synchronized state" to "provide some protection against
* ... blind reset attack[s] using the RST bit" :
*
* (a) "If the RST bit is set and the sequence number is outside the expected
* window, silently drop the segment."
*
* (b) "If the RST bit is exactly the next expected sequence number [sic], reset
* the connection"; it is assumed that this should read "if the RST bit is
* set and the sequence number is exactly the next expected sequence number,
* reset the connection."
*
* (c) "If the RST bit is set and the sequence number does not exactly match
* the next expected sequence value, yet is within the acceptable window
* (RCV.NXT <= SEG.SEQ < RCV.NXT+RCV.WND) send an acknowledgment."
*
* (B) ???? In addition, RFC Draft-IETF-TCPm-TCPSecure #00 does NOT provide a precedence
* priority for handling TCP segments received with BOTH the RST & SYN bits set.
*
* ???? Therefore, since it does NOT seem reasonable to reset a TCP connection
* due to a TCP segment that also attempted to synchronize the TCP connection,
* it is assumed that the amended handling of the SYN bit should take precedence
* over the amended handling of the RST bit.
*
* See also Note #2c2.
*
* (c) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check SYN Bit'
* states that in the "SYN-RECEIVED [STATE], ESTABLISHED STATE, FIN-WAIT STATE-1,
* FIN-WAIT STATE-2, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that ...
*
* (A) "If the SYN is in the window it is an error, send a reset, any outstanding
* RECEIVEs and SEND[s] should receive 'reset' responses, all segment queues
* should be flushed, the user should also receive an unsolicited general
* 'connection reset' signal[, and] enter the CLOSED state."
*
* (B) But "if the SYN is not in the window this step would not have been reached
* and an ack would have been sent".
*
* (2) HOWEVER, RFC Draft-IETF-TCPm-TCPSecure #00, Section 3.2 amends the "handling
* of a segment with the SYN bit set in the synchronized state ... [by] handling
* ... the SYN bit" as follows :
*
* (a) "If the SYN bit is set and the sequence number is outside the
* expected window, send an ACK back to the peer."
*
* (b) "If the SYN bit is set and the sequence number is an exact
* match to the next expected sequence (RCV.NXT == SEG.SEQ)
* then send an ACK segment ... but ... subtract one from
* value being acknowledged."
*
* (c) "If the SYN bit is set and the sequence number is acceptable,
* i.e.: (RCV.NXT <= SEG.SEQ <= RCV.NXT+RCV.WND) then send an
* ACK segment."
*$PAGE*
* (d) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field'
* states that ... :
*
* (1) "If the ACK bit is off drop the segment."
*
* (2) "If the ACK bit is on" ...
*
* (A) And in the "ESTABLISHED STATE" ...
*
* (1) "If SND.UNA < SEG.ACK <= SND.NXT then" ...
*
* (a) "set SND.UNA <- SEG.ACK."
*
* (b) "Any segments on the retransmission queue which are thereby entirely
* acknowledged are removed."
*
* (c) "the send window should be updated" :
*
* (1) (A) (1) "If ((SND.WL1 < SEG.SEQ) or" ...
*
* (2) (a) "(SND.WL1 = SEG.SEQ and" ...
* (b) "SND.WL2 <= SEG.ACK))," ...
*
* (B) (1) "set SND.WND <- SEG.WND," ...
* (2) "set SND.WL1 <- SEG.SEQ," ...
* (3) "set SND.WL2 <- SEG.ACK."
*
* (2) "Note that SND.WND is an offset from SND.UNA, that SND.WL1 records the
* sequence number of the last segment used to update SND.WND, and that
* SND.WL2 records the acknowledgment number of the last segment used to
* update SND.WND. The check here preveents using old segments to update
* the window."
*
* (2) (a) "If the ACK is a duplicate (SEG.ACK <= SND.UNA), it can be ignored."
*
* (b) RFC #1122, Section 4.2.2.20.(g) amends the transmit window update criteria
* for the segment's acknowledgement to include SND.UNA : "The window should
* updated if SND.UNA <= SEG.ACK <= SND.NXT."
*
* See also 'NetTCP_RxPktConnHandlerTxWinRemote() Note #1b2'.
*
* (3) "If the ACK acks something not yet sent (SEG.ACK > SND.NXT) then send an ACK
* [and] drop the segment."
*$PAGE*
* (B) For the "CLOSING STATE" :
*
* (1) "in addition to the processing for the ESTABLISHED state" ...
*
* (2) (a) "if the ACK acknowledges our FIN then" ...
*
* (1) (A) "enter the TIME-WAIT state," ...
*
* (1) The following sections ... :
*
* (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES :
* Check FIN Bit : FIN-WAIT-1 STATE'
* (b) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES :
* Check FIN Bit : FIN-WAIT-2 STATE'
*
* (2) ... generalize that when entering "the TIME-WAIT state" to ...
*
* (a) "Start the time-wait timer," ...
* (1) A TCP connection should be closed WITHOUT fault following
* a TCP connection TIME-WAIT timeout.
*
* (b) "turn off the other timers."
*
* (3) Although these sections are the only sections to state that these
* TCP connection timers should be updated when transitioning to the
* TIME-WAIT state, it is assumed that these timers should also be
* updated for the transition from the CLOSING state to the TIME-WAIT
* state.
*
* (B) However, it is possible that some closing received data from the remote
* host is available but has NOT yet been received by the application layer.
*
* (1) Therefore, if the application receive queue is closed, then enter the
* TIME-WAIT state.
*
* (2) (a) But if the application receive queue is NOT closed, then enter the
* connection-closing-data-available state to allow the application
* layer to receive the remaining receive data.
*
* (b) (1) To satisfy the required time-wait timeout of two maximum segment
* lifetimes (see Note #2f5A1a), the time-wait timeout is intially
* used to provide the application layer sufficient time to receive
* the closing received data.
*
* (2) If after the time-wait timeout expires, the application receive
* queue is still not empty, the user connection timeout is used
* to provide the application layer additional time to receive the
* closing received data.
*
* See also Note #3.
*
* (2) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check
* ACK Field : FIN-WAIT-2 STATE' states that "if the retransmission
* queue is empty, the user's CLOSE can be acknowledged".
*
* (B) Although this section is the only section to state that the TCP
* connection should acknowledge the user's close, it is assumed that
* a TCP connection should signal the application layer that "the
* user's close [is] acknowledged" whenever its re-transmit queue
* becomes empty.
*
* (b) (1) "otherwise ignore the segment."
*
* (2) However, it is possible that some but NOT all transmitted data has
* been received by the remote host. In other words, the remote host may
* have received some but NOT ALL transmitted data preceding this host's
* connection close request.
*
* ???? Therefore, acknowledgements validated by as within the transmit
* window MUST be received & processed as in connected states.
*
* See also 'NetTCP_RxPktConnIsValidAck() Note #1d'.
*
* See also Note #2e2.
*$PAGE*
* (e) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment Text'
* states that in the "CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that "this should not occur, since a FIN has been received from the remote
* side. Ignore the segment text."
*
* (2) (A) However, it is possible that some but NOT all data has been received from
* the remote host. In other words, the remote host's connection close request
* may have received but ALL receive data preceding the connection close request
* may NOT have been received.
*
* ???? Therefore, receive data validated by sequence number as within the
* receive window MUST be received & processed as in connected states.
*
* (B) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment
* Text' states that "once in the ESTABLISHED state, it is possible to deliver
* segment text to user RECEIVE buffers".
*
* See also Note #2d2B2b.
*
* (f) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states
* that "if the FIN bit is set" ...
*
* (1) "signal the user 'connection closing' and return any pending RECEIVEs with
* same message," ...
*
* (2) "advance RCV.NXT over the FIN," ...
*
* (3) "send an acknowledgment for the FIN" ...
*
* (4) "FIN implies PUSH for any segment text not yet delivered to the user" ...
*
* (5) And the "CLOSING STATE ... remain[s] in the CLOSING state".
*
* (3) (a) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : USER TIMEOUT' states that
* "for any state if the user timeout expires, flush all queues, signal the user
* 'error : connection aborted due to user timeout' ... [and] enter the CLOSED state".
*
* (b) However, NO RFC specifies or suggests any mechanism to implement/handle user timeouts.
*
* ???? Therefore, it is assumed that ANY TCP connection that receives a valid TCP data
* or control segment should reset its user connection timer.
*
* (4) Since the mechanisms of TCP connection close are independent of the application layer
* close; any external application layer close error(s) are ignored.
*********************************************************************************************************
*/
static void NetTCP_RxPktConnHandlerClosing (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
NET_TCP_SEQ_CODE seq_code;
NET_TCP_ACK_CODE ack_code;
NET_TCP_RESET_CODE reset_code;
CPU_BOOLEAN data_avail;
NET_TCP_TIMEOUT_SEC timeout_sec;
NET_TMR_TICK timeout_tick;
CPU_FNCT_PTR timeout_fnct;
NET_TCP_FREE_CODE free_code;
NET_ERR err;
NET_ERR err_rtn;
/*$PAGE*/
/* -------------- VALIDATE RX'D TCP PKT --------------- */
/* Chk for rx'd fin/close. */
if (pbuf_hdr->TCP_SegClose == DEF_YES) { /* If fin/close avail, update seg lens. */
pbuf_hdr->TCP_SegLenInit += NET_TCP_SEG_LEN_CLOSE;
pbuf_hdr->TCP_SegLen += NET_TCP_SEG_LEN_CLOSE;
}
/* Chk rx'd seq nbr. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (seq_code) {
case NET_TCP_CONN_RX_SEQ_VALID:
break;
case NET_TCP_CONN_RX_SEQ_SYNC: /* If invalid sync rx'd, ... */
case NET_TCP_CONN_RX_SEQ_SYNC_INVALID:
/* ... tx TCP conn ack (see Notes #2c2 & #2b2B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_SEQ_SYNC_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_SEQ_NONE:
case NET_TCP_CONN_RX_SEQ_INVALID: /* If invalid seq rx'd (see Note #2a4A), ... */
default:
if (pbuf_hdr->TCP_SegReset != DEF_YES) { /* ... & reset NOT rx'd (see Note #2a4C), ... */
/* ... tx TCP conn ack (see Note #2a4B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
}
*perr = NET_TCP_ERR_CONN_SEQ_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd reset. */
reset_code = NetTCP_RxPktConnIsValidReset(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (reset_code) {
case NET_TCP_CONN_RX_RESET_NONE:
break;
case NET_TCP_CONN_RX_RESET_VALID: /* If valid reset rx'd, ... */
/* ... close TCP conn (see Note #2b1A). */
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_RESET_VALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_RESET_INVALID: /* If invalid reset rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2b2Ac). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd ack. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
case NET_TCP_CONN_RX_ACK_DUP:
case NET_TCP_CONN_RX_ACK_PREV:
break;
case NET_TCP_CONN_RX_ACK_NONE: /* If NO ack rx'd, ... */
*perr = NET_TCP_ERR_CONN_ACK_NONE; /* ... ignore TCP pkt (see Note #2d1). */
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_ACK_INVALID: /* If invalid ack rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2d2A3). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ----------------- HANDLE RX'D SEG ------------------ */
NetTCP_RxPktConnHandlerSeg(pconn, ack_code, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_DATA_DUP: /* ???? Allow dup data to update TCP conn? */
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* ----------------- UPDATE TCP CONN ------------------ */
if (pconn->TxQ_State == NET_TCP_TX_Q_STATE_CONN_CLOSED) { /* If local conn close ack'd (see Note #2d2B2a); .. */
/* Closing data avail for half-closed conns ONLY. */
data_avail = ((pconn->ConnCloseCode != NET_CONN_CLOSE_HALF ) ||
((pconn->RxQ_State == NET_TCP_RX_Q_STATE_CONN_CLOSED) &&
(pconn->RxQ_App_Head == (NET_BUF *)0))) ? DEF_NO : DEF_YES;
/* .. signal app conn close (see Note #2d2B2a2B), .. */
NetTCP_RxPktConnHandlerSignalClose(pconn, data_avail, &err);
switch (err) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_FAIL: /* Ignore any app conn close err(s) [see Note #4]. */
break;
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_INVALID_CONN_ID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_CONN:
case NET_CONN_ERR_NOT_USED:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
*perr = err;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
if (data_avail != DEF_YES) { /* .. & if NO app data avail, .. */
/* .. chng to time-wait state (see Note #2d2B2a1B1); */
pconn->ConnState = NET_TCP_CONN_STATE_TIME_WAIT;
pconn->ConnCloseTimeoutFaultFlag = DEF_NO; /* .. clr close timeout fault (see Note #2d2B2a1A2a1); */
timeout_fnct = (CPU_FNCT_PTR)NetTCP_ConnCloseTimeout;
} else { /* .. else chng to closing-data-avail state .. */
/* .. (see Note #2d2B2a1B2a); */
pconn->ConnState = NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL;
timeout_fnct = (CPU_FNCT_PTR)NetTCP_ConnClosingTimeoutDataAvail;
}
/* .. & start time-wait tmr (see Notes #2d2B2a1A2a & */
/* .. #2d2B2a1B2b1). */
timeout_sec = pconn->TimeoutMaxSeg_sec * NET_TCP_CONN_TIMEOUT_MAX_SEG_SCALAR;
} else {
timeout_sec = pconn->TimeoutConn_sec; /* Else start conn close tmr (see Note #3b). */
timeout_fnct = (CPU_FNCT_PTR)NetTCP_ConnCloseTimeout;
}
/*$PAGE*/
/* ------------------- UPDATE TMRs -------------------- */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_TIME_WAIT: /* If in time-wait (see Note #2d2B2a1A) ... */
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL: /* ... or closing state(s) [see Note #2d2B2a1B], ... */
free_code = NET_TCP_CONN_FREE_TMR_ALL; /* ... free all TCP conn tmrs (see Note #2d2B2a1A2b). */
DEF_BIT_CLR(free_code, NET_TCP_CONN_FREE_TMR_TIMEOUT);
NetTCP_ConnFreeTmr(pconn, free_code);
break;
}
timeout_tick = (NET_TMR_TICK)timeout_sec * NET_TMR_TIME_TICK_PER_SEC;
if (pconn->TimeoutTmr != (NET_TMR *)0) {
NetTmr_Set((NET_TMR *) pconn->TimeoutTmr,
(CPU_FNCT_PTR) timeout_fnct,
(NET_TMR_TICK) timeout_tick,
(NET_ERR *)&err);
} else {
pconn->TimeoutTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) timeout_fnct,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
}
if ( err != NET_TMR_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
/*$PAGE*/
/* --------------- TX TCP CONN ACK/DATA --------------- */
ack_code = ((pbuf_hdr->TCP_SegAckTxReqCode == NET_TCP_CONN_TX_ACK_IMMED) ||
(pbuf_hdr->TCP_SegClose == DEF_YES)) /* See Note #2f3. */
? NET_TCP_CONN_TX_ACK_IMMED
: NET_TCP_CONN_TX_ACK;
if (pconn->ConnState == NET_TCP_CONN_STATE_CLOSING) { /* If conn still closing, ... */
/* ... tx ack & any tx data (see Note #1c). */
NetTCP_TxConnTxQ(pconn, pbuf_hdr, ack_code, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
} else { /* Else tx TCP conn ack (see Note #2f3). */
NetTCP_TxConnAck(pconn, pbuf_hdr, ack_code, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
break;
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
}
*perr = err_rtn;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerTimeWait()
*
* Description : (1) Handle TCP connection in TIME-WAIT state :
*
* (a) Validate received TCP packet for current TCP connection state :
*
* (1) Sequence Number (SEQ) See Note #2a
* (2) Reset (RST) See Note #2b
* (3) Synchronization (SYN) See Note #2c
* (4) Acknowledgement (ACK) See Note #2d
* (5) Finish/Close (FIN) See Note #2f
*
* (b) Update TCP connection :
* (1) Handle received TCP segment See Notes #2d & #2e
* (2) Update TCP connection timer See Notes #2d2C2
*
* (c) Transmit TCP connection acknowledgement See Notes #2d2C1 & #2f3
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_SEQ_SYNC_INVALID Received segment's synchronization is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_ACK_NONE Received segment's acknowledgement is
* NOT available.
* NET_TCP_ERR_CONN_ACK_INVALID Received segment's acknowledgement number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_RESET_VALID Received segment's reset flag is valid
* for current TCP connection; i.e. reset
* the TCP connection.
* NET_TCP_ERR_CONN_RESET_INVALID Received segment's reset flag is NOT valid
* for current TCP connection.
*
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
*
* -- RETURNED BY NetTCP_RxPktConnIsValidSeq() : --
* -- RETURNED BY NetTCP_RxPktConnIsValidAck() : --
* - RETURNED BY NetTCP_RxPktConnIsValidReset() : -
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* -- RETURNED BY NetTCP_RxPktConnHandlerSeg() : --
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO
* data to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled & valid
* data queued for processing.
* NET_TCP_ERR_CONN_DATA_INVALID Received packet contains invalid segment
* data; NOT queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_DUP Received packet contains duplicate segment
* data; NOT queued to receive queue(s).
*
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
*
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* NET_TCP_ERR_RX_Q_FULL TCP connection receive queue full.
* NET_TCP_ERR_RX_Q_SIGNAL_FAULT TCP connection receive queue signal fault.
*
* ------- RETURNED BY NetTCP_TxConnAck() : -------
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandler().
*$PAGE*
* Note(s) : (2) TCP connections in the TIME-WAIT state are handled as follows :
*
* (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence Number'
* states that in the "SYN-RECEIVED, ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2
* STATE, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT STATE" that ...
*
* (1) "Segments are processed in sequence ... processing is done in SEG.SEQ order."
*
* (2) "Initial tests on arrival are used to discard old duplicates."
*
* (3) "If a segment's contents straddle the boundary between old and new, only the
* new parts should be processed."
*
* (4) (A) "If an incoming segment is not acceptable," ...
*
* (B) "an acknowledgment should be sent in reply" ...
*
* (C) "(unless the RST bit is set, if so drop the segment)".
*
* See also Notes #2b2Aa & #2b2B.
*
* See also 'NetTCP_RxPktConnIsValidSeq() Note #1d'.
*
* (b) (1) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit'
* states that in the "CLOSING, LAST-ACK, TIME-WAIT" states that "if the RST bit
* is set then, enter the CLOSED state".
*
* (B) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing' reiterates
* that "if the receiver ... of a RST ... was in any other state [other than LISTEN
* or SYN-RECEIVED], it aborts the connection and advises the user and goes to the
* CLOSED state".
*
* (2) (A) RFC Draft-IETF-TCPm-TCPSecure #00, Section 2.2 amends the "handling of a segment
* with the RST bit when in a synchronized state" to "provide some protection against
* ... blind reset attack[s] using the RST bit" :
*
* (a) "If the RST bit is set and the sequence number is outside the expected
* window, silently drop the segment."
*
* (b) "If the RST bit is exactly the next expected sequence number [sic], reset
* the connection"; it is assumed that this should read "if the RST bit is
* set and the sequence number is exactly the next expected sequence number,
* reset the connection."
*
* (c) "If the RST bit is set and the sequence number does not exactly match
* the next expected sequence value, yet is within the acceptable window
* (RCV.NXT <= SEG.SEQ < RCV.NXT+RCV.WND) send an acknowledgment."
*
* (B) ???? In addition, RFC Draft-IETF-TCPm-TCPSecure #00 does NOT provide a precedence
* priority for handling TCP segments received with BOTH the RST & SYN bits set.
*
* ???? Therefore, since it does NOT seem reasonable to reset a TCP connection
* due to a TCP segment that also attempted to synchronize the TCP connection,
* it is assumed that the amended handling of the SYN bit should take precedence
* over the amended handling of the RST bit.
*
* See also Note #2c2.
*
* (c) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check SYN Bit'
* states that in the "SYN-RECEIVED [STATE], ESTABLISHED STATE, FIN-WAIT STATE-1,
* FIN-WAIT STATE-2, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that ...
*
* (A) "If the SYN is in the window it is an error, send a reset, any outstanding
* RECEIVEs and SEND[s] should receive 'reset' responses, all segment queues
* should be flushed, the user should also receive an unsolicited general
* 'connection reset' signal[, and] enter the CLOSED state."
*
* (B) But "if the SYN is not in the window this step would not have been reached
* and an ack would have been sent".
*
* (2) HOWEVER, RFC Draft-IETF-TCPm-TCPSecure #00, Section 3.2 amends the "handling
* of a segment with the SYN bit set in the synchronized state ... [by] handling
* ... the SYN bit" as follows :
*
* (a) "If the SYN bit is set and the sequence number is outside the
* expected window, send an ACK back to the peer."
*
* (b) "If the SYN bit is set and the sequence number is an exact
* match to the next expected sequence (RCV.NXT == SEG.SEQ)
* then send an ACK segment ... but ... subtract one from
* value being acknowledged."
*
* (c) "If the SYN bit is set and the sequence number is acceptable,
* i.e.: (RCV.NXT <= SEG.SEQ <= RCV.NXT+RCV.WND) then send an
* ACK segment."
*$PAGE*
* (d) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field'
* states that ... :
*
* (1) "If the ACK bit is off drop the segment."
*
* (2) "If the ACK bit is on" ...
*
* (A) "If the ACK is a duplicate (SEG.ACK <= SND.UNA), it can be ignored."
*
* (B) "If the ACK acks something not yet sent ... then send an ACK [and] drop the segment."
*
* (C) For the "TIME-WAIT STATE ... the only thing that can arrive in this state is a
* retransmission of the remote FIN" :
*
* (1) "Acknowledge it" ...
* (2) "restart the 2 MSL timeout."
*
* (e) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment Text'
* states that in the "CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that "this should not occur, since a FIN has been received from the remote
* side. Ignore the segment text."
*
* (2) (A) However, it is possible that some but NOT all data has been received from
* the remote host. In other words, the remote host's connection close request
* may have received but ALL receive data preceding the connection close request
* may NOT have been received.
*
* ???? Therefore, receive data validated by sequence number as within the
* receive window MUST be received & processed as in connected states.
*
* (B) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment
* Text' states that "once in the ESTABLISHED state, it is possible to deliver
* segment text to user RECEIVE buffers".
*
* (f) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states
* that "if the FIN bit is set" ...
*
* (1) "signal the user 'connection closing' and return any pending RECEIVEs with
* same message," ...
*
* (2) "advance RCV.NXT over the FIN," ...
*
* (3) "send an acknowledgment for the FIN" ...
*
* (4) "FIN implies PUSH for any segment text not yet delivered to the user" ...
*
* (5) For the "TIME-WAIT STATE" :
*
* (A) "Remain in the TIME-WAIT state" ...
* (B) "Restart the 2 MSL time-wait timeout."
*
* (3) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : TIME-WAIT TIMEOUT' states
* that "if the time-wait timeout expires on a connection ... enter the CLOSED state".
*********************************************************************************************************
*/
static void NetTCP_RxPktConnHandlerTimeWait (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
NET_TCP_SEQ_CODE seq_code;
NET_TCP_ACK_CODE ack_code;
NET_TCP_RESET_CODE reset_code;
NET_TCP_TIMEOUT_SEC timeout_sec;
NET_TMR_TICK timeout_tick;
NET_ERR err;
NET_ERR err_rtn;
/*$PAGE*/
/* -------------- VALIDATE RX'D TCP PKT --------------- */
(void)&pbuf_hdr->TCP_SegClose; /* Ignore any rx'd fin (see Note #2f5A). */
/* Chk rx'd seq nbr. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (seq_code) {
case NET_TCP_CONN_RX_SEQ_VALID:
break;
case NET_TCP_CONN_RX_SEQ_SYNC: /* If invalid sync rx'd, ... */
case NET_TCP_CONN_RX_SEQ_SYNC_INVALID:
/* ... tx TCP conn ack (see Notes #2c2 & #2b2B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_SEQ_SYNC_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_SEQ_NONE:
case NET_TCP_CONN_RX_SEQ_INVALID: /* If invalid seq rx'd (see Note #2a4A), ... */
default:
if (pbuf_hdr->TCP_SegReset != DEF_YES) { /* ... & reset NOT rx'd (see Note #2a4C), ... */
/* ... tx TCP conn ack (see Note #2a4B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
}
*perr = NET_TCP_ERR_CONN_SEQ_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd reset. */
reset_code = NetTCP_RxPktConnIsValidReset(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (reset_code) {
case NET_TCP_CONN_RX_RESET_NONE:
break;
case NET_TCP_CONN_RX_RESET_VALID: /* If valid reset rx'd, ... */
/* ... close TCP conn (see Note #2b1A). */
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_RESET_VALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_RESET_INVALID: /* If invalid reset rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2b2Ac). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd ack. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
case NET_TCP_CONN_RX_ACK_DUP:
case NET_TCP_CONN_RX_ACK_PREV:
break;
case NET_TCP_CONN_RX_ACK_NONE: /* If NO ack rx'd, ... */
*perr = NET_TCP_ERR_CONN_ACK_NONE; /* ... ignore TCP pkt (see Note #2d1). */
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_ACK_INVALID: /* If invalid ack rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2d2B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ----------------- HANDLE RX'D SEG ------------------ */
NetTCP_RxPktConnHandlerSeg(pconn, ack_code, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_DATA_DUP: /* ???? Allow dup data to update TCP conn? */
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* ----------------- UPDATE TCP CONN ------------------ */
/* -------------------- UPDATE TMR -------------------- */
/* Reset time-wait tmr (see Note #2d2C2). */
timeout_sec = pconn->TimeoutMaxSeg_sec * NET_TCP_CONN_TIMEOUT_MAX_SEG_SCALAR;
timeout_tick = (NET_TMR_TICK)timeout_sec * NET_TMR_TIME_TICK_PER_SEC;
if (pconn->TimeoutTmr != (NET_TMR *)0) {
NetTmr_Set((NET_TMR *) pconn->TimeoutTmr,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(NET_ERR *)&err);
} else {
pconn->TimeoutTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
}
if ( err != NET_TMR_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
/* ----------------- TX TCP CONN ACK ------------------ */
/* Tx TCP conn ack (see Notes #1c). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_IMMED, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
break;
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
*perr = err_rtn;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerCloseWait()
*
* Description : (1) Handle TCP connection in CLOSE-WAIT state :
*
* (a) Validate received TCP packet for current TCP connection state :
*
* (1) Sequence Number (SEQ) See Note #2a
* (2) Reset (RST) See Note #2b
* (3) Synchronization (SYN) See Note #2c
* (4) Acknowledgement (ACK) See Note #2d
* (5) Finish/Close (FIN) See Note #2f
*
* (b) Update TCP connection :
* (1) Handle received TCP segment See Notes #2d & #2e
* (2) Update TCP connection timer See Note #3
*
* (c) Transmit TCP connection acknowledgement & data See Notes #2d2B & #2f3
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_SEQ_SYNC_INVALID Received segment's synchronization is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_ACK_NONE Received segment's acknowledgement is
* NOT available.
* NET_TCP_ERR_CONN_ACK_INVALID Received segment's acknowledgement number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_RESET_VALID Received segment's reset flag is valid
* for current TCP connection; i.e. reset
* the TCP connection.
* NET_TCP_ERR_CONN_RESET_INVALID Received segment's reset flag is NOT valid
* for current TCP connection.
*
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
*
* ----- RETURNED BY NetTCP_RxPktConnIsValidSeq() : -----
* ----- RETURNED BY NetTCP_RxPktConnIsValidAck() : -----
* ---- RETURNED BY NetTCP_RxPktConnIsValidReset() : ----
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* ----- RETURNED BY NetTCP_RxPktConnHandlerSeg() : -----
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO
* data to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled & valid
* data queued for processing.
* NET_TCP_ERR_CONN_DATA_INVALID Received packet contains invalid segment
* data; NOT queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_DUP Received packet contains duplicate segment
* data; NOT queued to receive queue(s).
*
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
*
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* NET_TCP_ERR_RX_Q_FULL TCP connection receive queue full.
* NET_TCP_ERR_RX_Q_SIGNAL_FAULT TCP connection receive queue signal fault.
* NET_TCP_ERR_TX_Q_SIGNAL_FAULT TCP connection transmit queue signal fault.
* NET_TCP_ERR_RE_TX_SEG_TH TCP connection closed due to excessive retransmission.
* NET_TCP_ERR_TX TCP transmit error.
*
* ---------- RETURNED BY NetTCP_TxConnTxQ() : ----------
* NET_TCP_ERR_CONN_CLOSE TCP connection closed.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandler().
*$PAGE*
* Note(s) : (2) TCP connections in the CLOSE-WAIT state are handled as follows :
*
* (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence Number'
* states that in the "SYN-RECEIVED, ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2
* STATE, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT STATE" that ...
*
* (1) "Segments are processed in sequence ... processing is done in SEG.SEQ order."
*
* (2) "Initial tests on arrival are used to discard old duplicates."
*
* (3) "If a segment's contents straddle the boundary between old and new, only the
* new parts should be processed."
*
* (4) (A) "If an incoming segment is not acceptable," ...
*
* (B) "an acknowledgment should be sent in reply" ...
*
* (C) "(unless the RST bit is set, if so drop the segment)".
*
* See also Notes #2b2Aa & #2b2B.
*
* See also 'NetTCP_RxPktConnIsValidSeq() Note #1d'.
*
* (b) (1) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit' states
* that in the "ESTABLISHED, FIN-WAIT-1, FIN-WAIT-2, CLOSE-WAIT" states that "if the
* RST bit is set then, any outstanding RECEIVEs and SEND[s] should receive 'reset'
* responses. All segment queues should be flushed. Users should also receive an
* unsolicited general 'connection reset' signal[, and] enter the CLOSED state".
*
* (B) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing' reiterates
* that "if the receiver ... of a RST ... was in any other state [other than LISTEN
* or SYN-RECEIVED], it aborts the connection and advises the user and goes to the
* CLOSED state".
*
* (2) (A) RFC Draft-IETF-TCPm-TCPSecure #00, Section 2.2 amends the "handling of a segment
* with the RST bit when in a synchronized state" to "provide some protection against
* ... blind reset attack[s] using the RST bit" :
*
* (a) "If the RST bit is set and the sequence number is outside the expected
* window, silently drop the segment."
*
* (b) "If the RST bit is exactly the next expected sequence number [sic], reset
* the connection"; it is assumed that this should read "if the RST bit is
* set and the sequence number is exactly the next expected sequence number,
* reset the connection."
*
* (c) "If the RST bit is set and the sequence number does not exactly match
* the next expected sequence value, yet is within the acceptable window
* (RCV.NXT <= SEG.SEQ < RCV.NXT+RCV.WND) send an acknowledgment."
*
* (B) ???? In addition, RFC Draft-IETF-TCPm-TCPSecure #00 does NOT provide a precedence
* priority for handling TCP segments received with BOTH the RST & SYN bits set.
*
* ???? Therefore, since it does NOT seem reasonable to reset a TCP connection
* due to a TCP segment that also attempted to synchronize the TCP connection,
* it is assumed that the amended handling of the SYN bit should take precedence
* over the amended handling of the RST bit.
*
* See also Note #2c2.
*
* (c) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check SYN Bit'
* states that in the "SYN-RECEIVED [STATE], ESTABLISHED STATE, FIN-WAIT STATE-1,
* FIN-WAIT STATE-2, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that ...
*
* (A) "If the SYN is in the window it is an error, send a reset, any outstanding
* RECEIVEs and SEND[s] should receive 'reset' responses, all segment queues
* should be flushed, the user should also receive an unsolicited general
* 'connection reset' signal[, and] enter the CLOSED state."
*
* (B) But "if the SYN is not in the window this step would not have been reached
* and an ack would have been sent".
*
* (2) HOWEVER, RFC Draft-IETF-TCPm-TCPSecure #00, Section 3.2 amends the "handling
* of a segment with the SYN bit set in the synchronized state ... [by] handling
* ... the SYN bit" as follows :
*
* (a) "If the SYN bit is set and the sequence number is outside the
* expected window, send an ACK back to the peer."
*
* (b) "If the SYN bit is set and the sequence number is an exact
* match to the next expected sequence (RCV.NXT == SEG.SEQ)
* then send an ACK segment ... but ... subtract one from
* value being acknowledged."
*
* (c) "If the SYN bit is set and the sequence number is acceptable,
* i.e.: (RCV.NXT <= SEG.SEQ <= RCV.NXT+RCV.WND) then send an
* ACK segment."
*$PAGE*
* (d) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field'
* states that ... :
*
* (1) "If the ACK bit is off drop the segment."
*
* (2) "If the ACK bit is on" ...
*
* (A) And in the "ESTABLISHED STATE" ...
*
* (1) "If SND.UNA < SEG.ACK <= SND.NXT then" ...
*
* (a) "set SND.UNA <- SEG.ACK."
*
* (b) "Any segments on the retransmission queue which are thereby entirely
* acknowledged are removed."
*
* (c) "the send window should be updated" :
*
* (1) (A) (1) "If ((SND.WL1 < SEG.SEQ) or" ...
*
* (2) (a) "(SND.WL1 = SEG.SEQ and" ...
* (b) "SND.WL2 <= SEG.ACK))," ...
*
* (B) (1) "set SND.WND <- SEG.WND," ...
* (2) "set SND.WL1 <- SEG.SEQ," ...
* (3) "set SND.WL2 <- SEG.ACK."
*
* (2) "Note that SND.WND is an offset from SND.UNA, that SND.WL1 records the
* sequence number of the last segment used to update SND.WND, and that
* SND.WL2 records the acknowledgment number of the last segment used to
* update SND.WND. The check here preveents using old segments to update
* the window."
*
* (2) (a) "If the ACK is a duplicate (SEG.ACK <= SND.UNA), it can be ignored."
*
* (b) RFC #1122, Section 4.2.2.20.(g) amends the transmit window update criteria
* for the segment's acknowledgement to include SND.UNA : "The window should
* updated if SND.UNA <= SEG.ACK <= SND.NXT."
*
* See also 'NetTCP_RxPktConnHandlerTxWinRemote() Note #1b2'.
*
* (3) "If the ACK acks something not yet sent (SEG.ACK > SND.NXT) then send an ACK
* [and] drop the segment."
*
* (B) For the "CLOSE-WAIT STATE ... do the same processing as for the ESTABLISHED state".
*
* (e) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment Text'
* states that in the "CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that "this should not occur, since a FIN has been received from the remote
* side. Ignore the segment text."
*
* (2) (A) However, it is possible that some but NOT all data has been received from the
* remote host. In other words, the remote host's close request may have been
* received but ALL receive data preceding the close request may NOT have been
* received.
*
* ???? Therefore, receive data validated by sequence number as within the receive
* window MUST be received & processed as in connected states.
*
* (B) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment
* Text' states that "once in the ESTABLISHED state, it is possible to deliver
* segment text to user RECEIVE buffers".
*
* See also Note #2d2B.
*$PAGE*
* (f) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states
* that "if the FIN bit is set" ...
*
* (1) "signal the user 'connection closing' and return any pending RECEIVEs with
* same message," ...
*
* (2) "advance RCV.NXT over the FIN," ...
*
* (3) "send an acknowledgment for the FIN" ...
*
* (4) "FIN implies PUSH for any segment text not yet delivered to the user" ...
*
* (5) And the "CLOSE-WAIT STATE ... remain[s] in the CLOSE-WAIT state".
*
* (3) (a) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : USER TIMEOUT' states that
* "for any state if the user timeout expires, flush all queues, signal the user
* 'error : connection aborted due to user timeout' ... [and] enter the CLOSED state".
*
* (b) However, NO RFC specifies or suggests any mechanism to implement/handle user timeouts.
*
* ???? Therefore, it is assumed that ANY TCP connection that receives a valid TCP data
* or control segment should reset its user connection timer.
*********************************************************************************************************
*/
static void NetTCP_RxPktConnHandlerCloseWait (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
NET_TCP_SEQ_CODE seq_code;
NET_TCP_ACK_CODE ack_code;
NET_TCP_RESET_CODE reset_code;
NET_TCP_TIMEOUT_SEC timeout_sec;
NET_TMR_TICK timeout_tick;
NET_ERR err;
NET_ERR err_rtn;
/*$PAGE*/
/* -------------- VALIDATE RX'D TCP PKT --------------- */
/* Chk for rx'd fin/close. */
if (pbuf_hdr->TCP_SegClose == DEF_YES) { /* If fin/close avail, update seg lens. */
pbuf_hdr->TCP_SegLenInit += NET_TCP_SEG_LEN_CLOSE;
pbuf_hdr->TCP_SegLen += NET_TCP_SEG_LEN_CLOSE;
}
/* Chk rx'd seq nbr. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (seq_code) {
case NET_TCP_CONN_RX_SEQ_VALID:
break;
case NET_TCP_CONN_RX_SEQ_SYNC: /* If invalid sync rx'd, ... */
case NET_TCP_CONN_RX_SEQ_SYNC_INVALID:
/* ... tx TCP conn ack (see Notes #2c2 & #2b2B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_SEQ_SYNC_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_SEQ_NONE:
case NET_TCP_CONN_RX_SEQ_INVALID: /* If invalid seq rx'd (see Note #2a4A), ... */
default:
if (pbuf_hdr->TCP_SegReset != DEF_YES) { /* ... & reset NOT rx'd (see Note #2a4C), ... */
/* ... tx TCP conn ack (see Note #2a4B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
}
*perr = NET_TCP_ERR_CONN_SEQ_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd reset. */
reset_code = NetTCP_RxPktConnIsValidReset(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (reset_code) {
case NET_TCP_CONN_RX_RESET_NONE:
break;
case NET_TCP_CONN_RX_RESET_VALID: /* If valid reset rx'd, ... */
/* ... close TCP conn (see Note #2b1A). */
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_RESET_VALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_RESET_INVALID: /* If invalid reset rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2b2Ac). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd ack. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
case NET_TCP_CONN_RX_ACK_DUP:
case NET_TCP_CONN_RX_ACK_PREV:
break;
case NET_TCP_CONN_RX_ACK_NONE: /* If NO ack rx'd, ... */
*perr = NET_TCP_ERR_CONN_ACK_NONE; /* ... ignore TCP pkt (see Note #2d1). */
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_ACK_INVALID: /* If invalid ack rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2d2A3). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ----------------- HANDLE RX'D SEG ------------------ */
NetTCP_RxPktConnHandlerSeg(pconn, ack_code, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_DATA_DUP: /* ???? Allow dup data to update TCP conn? */
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* ----------------- UPDATE TCP CONN ------------------ */
/* -------------------- UPDATE TMR -------------------- */
timeout_sec = pconn->TimeoutConn_sec; /* Reset conn close tmr (see Note #3b). */
timeout_tick = (NET_TMR_TICK)timeout_sec * NET_TMR_TIME_TICK_PER_SEC;
if (pconn->TimeoutTmr != (NET_TMR *)0) {
NetTmr_Set((NET_TMR *) pconn->TimeoutTmr,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(NET_ERR *)&err);
} else {
pconn->TimeoutTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
}
if ( err != NET_TMR_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
/*$PAGE*/
/* --------------- TX TCP CONN ACK/DATA --------------- */
ack_code = ((pbuf_hdr->TCP_SegAckTxReqCode == NET_TCP_CONN_TX_ACK_IMMED) ||
(pbuf_hdr->TCP_SegClose == DEF_YES)) /* See Note #2f3. */
? NET_TCP_CONN_TX_ACK_IMMED
: NET_TCP_CONN_TX_ACK;
/* Tx ack & any tx data (see Note #1c). */
NetTCP_TxConnTxQ(pconn, pbuf_hdr, ack_code, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
*perr = err_rtn;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerLastAck()
*
* Description : (1) Handle TCP connection in LAST-ACK state :
*
* (a) Validate received TCP packet for current TCP connection state :
*
* (1) Sequence Number (SEQ) See Note #2a
* (2) Reset (RST) See Note #2b
* (3) Synchronization (SYN) See Note #2c
* (4) Acknowledgement (ACK) See Note #2d
* (5) Finish/Close (FIN) See Note #2f
*
* (b) Update TCP connection :
* (1) Handle received TCP segment See Notes #2d & #2e
* (2) Update TCP connection state : See Notes #2d2A1a & #2d2A1b2A
* (A) Configure TCP connection timeout value
* (3) Update TCP connection timer See Notes #2d2A1b2B & #3
*
* (c) Transmit TCP connection acknowledgement & data See Notes #2d2B & #2f3
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_SEQ_SYNC_INVALID Received segment's synchronization is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_ACK_NONE Received segment's acknowledgement is
* NOT available.
* NET_TCP_ERR_CONN_ACK_INVALID Received segment's acknowledgement number is
* NOT valid for current TCP connection.
* NET_TCP_ERR_CONN_RESET_VALID Received segment's reset flag is valid
* for current TCP connection; i.e. reset
* the TCP connection.
* NET_TCP_ERR_CONN_RESET_INVALID Received segment's reset flag is NOT valid
* for current TCP connection.
*
* NET_TCP_ERR_CONN_CLOSED TCP connection successfully closed.
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
*
* ----- RETURNED BY NetTCP_RxPktConnIsValidSeq() : -----
* ----- RETURNED BY NetTCP_RxPktConnIsValidAck() : -----
* ---- RETURNED BY NetTCP_RxPktConnIsValidReset() : ----
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* ----- RETURNED BY NetTCP_RxPktConnHandlerSeg() : -----
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO
* data to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled & valid
* data queued for processing.
* NET_TCP_ERR_CONN_DATA_INVALID Received packet contains invalid segment
* data; NOT queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_DUP Received packet contains duplicate segment
* data; NOT queued to receive queue(s).
*
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
*
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* NET_TCP_ERR_RX_Q_FULL TCP connection receive queue full.
* NET_TCP_ERR_RX_Q_SIGNAL_FAULT TCP connection receive queue signal fault.
* NET_TCP_ERR_TX_Q_SIGNAL_FAULT TCP connection transmit queue signal fault.
* NET_TCP_ERR_RE_TX_SEG_TH TCP connection closed due to excessive retransmission.
*
* ---------- RETURNED BY NetTCP_TxConnTxQ() : ----------
* NET_TCP_ERR_CONN_CLOSE TCP connection closed.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandler().
*$PAGE*
* Note(s) : (2) TCP connections in the LAST-ACK state are handled as follows :
*
* (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence Number'
* states that in the "SYN-RECEIVED, ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2
* STATE, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT STATE" that ...
*
* (1) "Segments are processed in sequence ... processing is done in SEG.SEQ order."
*
* (2) "Initial tests on arrival are used to discard old duplicates."
*
* (3) "If a segment's contents straddle the boundary between old and new, only the
* new parts should be processed."
*
* (4) (A) "If an incoming segment is not acceptable," ...
*
* (B) "an acknowledgment should be sent in reply" ...
*
* (C) "(unless the RST bit is set, if so drop the segment)".
*
* See also Notes #2b2Aa & #2b2B.
*
* See also 'NetTCP_RxPktConnIsValidSeq() Note #1d'.
*
* (b) (1) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit' states
* that in the "ESTABLISHED, FIN-WAIT-1, FIN-WAIT-2, CLOSE-WAIT" states that "if the
* RST bit is set then, any outstanding RECEIVEs and SEND[s] should receive 'reset'
* responses. All segment queues should be flushed. Users should also receive an
* unsolicited general 'connection reset' signal[, and] enter the CLOSED state".
*
* (B) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing' reiterates
* that "if the receiver ... of a RST ... was in any other state [other than LISTEN
* or SYN-RECEIVED], it aborts the connection and advises the user and goes to the
* CLOSED state".
*
* (2) (A) RFC Draft-IETF-TCPm-TCPSecure #00, Section 2.2 amends the "handling of a segment
* with the RST bit when in a synchronized state" to "provide some protection against
* ... blind reset attack[s] using the RST bit" :
*
* (a) "If the RST bit is set and the sequence number is outside the expected
* window, silently drop the segment."
*
* (b) "If the RST bit is exactly the next expected sequence number [sic], reset
* the connection"; it is assumed that this should read "if the RST bit is
* set and the sequence number is exactly the next expected sequence number,
* reset the connection."
*
* (c) "If the RST bit is set and the sequence number does not exactly match
* the next expected sequence value, yet is within the acceptable window
* (RCV.NXT <= SEG.SEQ < RCV.NXT+RCV.WND) send an acknowledgment."
*
* (B) ???? In addition, RFC Draft-IETF-TCPm-TCPSecure #00 does NOT provide a precedence
* priority for handling TCP segments received with BOTH the RST & SYN bits set.
*
* ???? Therefore, since it does NOT seem reasonable to reset a TCP connection
* due to a TCP segment that also attempted to synchronize the TCP connection,
* it is assumed that the amended handling of the SYN bit should take precedence
* over the amended handling of the RST bit.
*
* See also Note #2c2.
*
* (c) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check SYN Bit'
* states that in the "SYN-RECEIVED [STATE], ESTABLISHED STATE, FIN-WAIT STATE-1,
* FIN-WAIT STATE-2, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that ...
*
* (A) "If the SYN is in the window it is an error, send a reset, any outstanding
* RECEIVEs and SEND[s] should receive 'reset' responses, all segment queues
* should be flushed, the user should also receive an unsolicited general
* 'connection reset' signal[, and] enter the CLOSED state."
*
* (B) But "if the SYN is not in the window this step would not have been reached
* and an ack would have been sent".
*
* (2) HOWEVER, RFC Draft-IETF-TCPm-TCPSecure #00, Section 3.2 amends the "handling
* of a segment with the SYN bit set in the synchronized state ... [by] handling
* ... the SYN bit" as follows :
*
* (a) "If the SYN bit is set and the sequence number is outside the
* expected window, send an ACK back to the peer."
*
* (b) "If the SYN bit is set and the sequence number is an exact
* match to the next expected sequence (RCV.NXT == SEG.SEQ)
* then send an ACK segment ... but ... subtract one from
* value being acknowledged."
*
* (c) "If the SYN bit is set and the sequence number is acceptable,
* i.e.: (RCV.NXT <= SEG.SEQ <= RCV.NXT+RCV.WND) then send an
* ACK segment."
*$PAGE*
* (d) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field'
* states that ... :
*
* (1) "If the ACK bit is off drop the segment."
*
* (2) "If the ACK bit is on [and in the] LAST-ACK STATE" ...
*
* (A) "The only thing that can arrive in this state is an acknowledgement of our FIN."
*
* (1) "If our FIN is now acknowledged" ...
*
* (a) "enter the CLOSED state."
*
* (b) However, it is possible that some closing received data from the remote
* host is available but has NOT yet been received by the application layer.
*
* (1) Therefore, if the application receive queue is closed, then close the
* TCP connection &/or enter the CLOSED state.
*
* (2) (A) But if the application receive queue is NOT closed, then enter the
* connection-closing-data-available state to allow the application
* layer to receive the remaining receive data.
*
* (B) To provide the application layer sufficient time to receive the
* closing received data, the user connection timeout is used as a
* connection closing timeout.
*
* See also Note #2e2.
*
* (2) (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* FIN-WAIT-2 STATE' states that "if the retransmission queue is empty, the
* user's CLOSE can be acknowledged".
*
* (b) However, TCP connection should signal the application layer that "the user's
* close [is] acknowledged" whenever its re-transmit queue becomes &/or is
* empty :
*
* (1) Transition from LAST-ACK to CLOSED
*
* See also 'NetTCP_RxPktConnHandlerSignalClose() Note #1'.
*
* (B) However, it is possible that some but NOT all transmitted data has been received
* by the remote host. In other words, the remote host may have received some but
* NOT ALL receive data preceding this host's close request.
*
* ???? Therefore, acknowledgements validated as within the transmit window MUST be
* received & processed as in connected states.
*
* See also 'NetTCP_RxPktConnIsValidAck() Note #1d'.
*
* (e) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment Text'
* states that in the "CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE" that "this should not occur, since a FIN has been received from the remote
* side. Ignore the segment text."
*
* (2) (A) However, it is possible that some but NOT all data has been received from
* the remote host. In other words, the remote host's close request may have
* received but ALL receive data preceding the close request may NOT have been
* received.
*
* ???? Therefore, receive data validated by sequence number as within the
* receive window MUST be received & processed as in connected states.
*
* (B) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment
* Text' states that "once in the ESTABLISHED state, it is possible to deliver
* segment text to user RECEIVE buffers".
*
* See also Note #2d2A1b.
*
* (f) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states
* that "if the FIN bit is set" ...
*
* (1) "signal the user 'connection closing' and return any pending RECEIVEs with
* same message," ...
*
* (2) "advance RCV.NXT over the FIN," ...
*
* (3) "send an acknowledgment for the FIN" ...
*
* (4) "FIN implies PUSH for any segment text not yet delivered to the user" ...
*
* (5) And the "LAST-ACK STATE ... remain[s] in the LAST-ACK state".
*$PAGE*
* (3) (a) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : USER TIMEOUT' states that
* "for any state if the user timeout expires, flush all queues, signal the user
* 'error : connection aborted due to user timeout' ... [and] enter the CLOSED state".
*
* (b) (1) However, a TCP connection enters the LAST-ACK state ONLY after the remote host
* has initiated an active close & enters the TIME-WAIT state, waiting for its
* time-wait timer to expire before closing its TCP connection.
*
* (2) ???? Therefore, a TCP connection in the LAST-ACK state should NOT wait for its
* last acknowledgement from the remote host in the TIME-WAIT state longer than
* the remote host's time-wait timeout of two TCP maximum segment lifetimes.
*
* (3) ???? Therefore, it is assumed that ANY TCP connection in the LAST-ACK state
* that receives a valid TCP data or control segment should reset its time-wait
* timer for two TCP maximum segment lifetimes.
*
* (4) Since the mechanisms of TCP connection close are independent of the application layer
* close; any external application layer close error(s) are ignored.
*********************************************************************************************************
*/
static void NetTCP_RxPktConnHandlerLastAck (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
NET_TCP_SEQ_CODE seq_code;
NET_TCP_ACK_CODE ack_code;
NET_TCP_RESET_CODE reset_code;
CPU_BOOLEAN data_avail;
CPU_BOOLEAN close_conn;
NET_TCP_TIMEOUT_SEC timeout_sec;
NET_TMR_TICK timeout_tick;
NET_ERR err;
NET_ERR err_rtn;
/*$PAGE*/
/* -------------- VALIDATE RX'D TCP PKT --------------- */
/* Chk for rx'd fin/close. */
if (pbuf_hdr->TCP_SegClose == DEF_YES) { /* If fin/close avail, update seg lens. */
pbuf_hdr->TCP_SegLenInit += NET_TCP_SEG_LEN_CLOSE;
pbuf_hdr->TCP_SegLen += NET_TCP_SEG_LEN_CLOSE;
}
/* Chk rx'd seq nbr. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (seq_code) {
case NET_TCP_CONN_RX_SEQ_VALID:
break;
case NET_TCP_CONN_RX_SEQ_SYNC: /* If invalid sync rx'd, ... */
case NET_TCP_CONN_RX_SEQ_SYNC_INVALID:
/* ... tx TCP conn ack (see Notes #2c2 & #2b2B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_SEQ_SYNC_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_SEQ_NONE:
case NET_TCP_CONN_RX_SEQ_INVALID: /* If invalid seq rx'd (see Note #2a4A), ... */
default:
if (pbuf_hdr->TCP_SegReset != DEF_YES) { /* ... & reset NOT rx'd (see Note #2a4C), ... */
/* ... tx TCP conn ack (see Note #2a4B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
}
*perr = NET_TCP_ERR_CONN_SEQ_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd reset. */
reset_code = NetTCP_RxPktConnIsValidReset(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (reset_code) {
case NET_TCP_CONN_RX_RESET_NONE:
break;
case NET_TCP_CONN_RX_RESET_VALID: /* If valid reset rx'd, ... */
/* ... close TCP conn (see Note #2b1A). */
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_RESET_VALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_RESET_INVALID: /* If invalid reset rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2b2Ac). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* Chk for rx'd ack. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
case NET_TCP_CONN_RX_ACK_DUP:
case NET_TCP_CONN_RX_ACK_PREV:
break;
case NET_TCP_CONN_RX_ACK_NONE: /* If NO ack rx'd, ... */
*perr = NET_TCP_ERR_CONN_ACK_NONE; /* ... ignore TCP pkt (see Note #2d1). */
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_RX_ACK_INVALID: /* If invalid ack rx'd, ... */
default:
/* ... tx TCP conn ack (see Note #2d2B). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ----------------- HANDLE RX'D SEG ------------------ */
NetTCP_RxPktConnHandlerSeg(pconn, ack_code, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_DATA_DUP: /* ???? Allow dup data to update TCP conn? */
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_RX_Q_FULL:
case NET_TCP_ERR_RX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_TX_Q_SIGNAL_FAULT:
case NET_TCP_ERR_RE_TX_SEG_TH:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* ----------------- UPDATE TCP CONN ------------------ */
close_conn = DEF_NO;
if (pconn->RxQ_State == NET_TCP_RX_Q_STATE_CONN_CLOSED) { /* If remote conn closed (see #2e2A) ... */
/* ... & local conn close ack'd (see #2d2A1) ... */
if (pconn->TxQ_State == NET_TCP_TX_Q_STATE_CONN_CLOSED) {
close_conn = DEF_YES;
}
}
if (close_conn == DEF_YES) {
/* Closing data avail for half-closed conns ONLY. */
data_avail = ((pconn->ConnCloseCode != NET_CONN_CLOSE_HALF ) ||
((pconn->RxQ_State == NET_TCP_RX_Q_STATE_CONN_CLOSED) &&
(pconn->RxQ_App_Head == (NET_BUF *)0))) ? DEF_NO : DEF_YES;
/* ... signal app conn close (see Note #2d2A2b1); ... */
/* Ignore any app conn close err(s) [see Note #4]. */
NetTCP_RxPktConnHandlerSignalClose(pconn, data_avail, &err);
if (data_avail != DEF_YES) { /* ... & if NO app data avail, ... */
/* ... close TCP conn (see #2d2A1b1); ... */
NetTCP_ConnCloseHandler(pconn, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_CLOSED;
return;
}
/* ... else chng to closing-data-avail state ... */
/* ... (see Note #2d2A1b2A), ... */
pconn->ConnState = NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL;
timeout_sec = pconn->TimeoutUser_sec; /* ... & set user tmr (see Notes #2d2A1b2B). */
} else { /* Else start time-wait tmr (see Note #3b3). */
timeout_sec = pconn->TimeoutMaxSeg_sec * NET_TCP_CONN_TIMEOUT_MAX_SEG_SCALAR;
}
/*$PAGE*/
/* -------------------- UPDATE TMR -------------------- */
timeout_tick = (NET_TMR_TICK)timeout_sec * NET_TMR_TIME_TICK_PER_SEC;
if (pconn->TimeoutTmr != (NET_TMR *)0) {
NetTmr_Set((NET_TMR *) pconn->TimeoutTmr,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(NET_ERR *)&err);
} else {
pconn->TimeoutTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
}
if ( err != NET_TMR_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
/* --------------- TX TCP CONN ACK/DATA --------------- */
ack_code = ((pbuf_hdr->TCP_SegAckTxReqCode == NET_TCP_CONN_TX_ACK_IMMED) ||
(pbuf_hdr->TCP_SegClose == DEF_YES)) /* See Note #2f3. */
? NET_TCP_CONN_TX_ACK_IMMED
: NET_TCP_CONN_TX_ACK;
/* Tx ack & any tx data (see Note #1c). */
NetTCP_TxConnTxQ(pconn, pbuf_hdr, ack_code, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
*perr = err_rtn;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerSeg()
*
* Description : (1) Handle TCP connection's received segments :
*
* (a) Update TCP connection transmit remote window See Note #5
* (b) Update TCP connection controls on transition to connected state(s)
* (c) Handle TCP connection re-transmit queue See Notes #2b & #4
* (d) Update TCP connection transmit congestion controls See Note #6
* (e) Handle TCP connection receive queue(s) See Note #3
* (f) Handle TCP connection receive data See Notes #2a & #3
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* ack_code Indicates the received segment's acknowledgement condition :
* --------
* NET_TCP_CONN_RX_ACK_NONE NO received acknowledgement number.
*
* NET_TCP_CONN_RX_ACK_INVALID Received acknowledgement number
* is invalid for the TCP connection.
*
* NET_TCP_CONN_RX_ACK_VALID Received acknowledgement number
* is valid for the TCP connection.
*
* NET_TCP_CONN_RX_ACK_DUP Received acknowledgement number
* is a duplicate for the
* TCP connection.
*
* NET_TCP_CONN_RX_ACK_PREV Received acknowledgement number
* is a previous duplicate for the
* TCP connection.
*
* Argument validated in NetTCP_RxPktConnHandler() functions.
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_ACK_INVALID Valid received segment acknowledgement NOT available.
*
* -- RETURNED BY NetTCP_RxPktConnHandlerTxWinRemote() : -
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* ---- RETURNED BY NetTCP_RxPktConnHandlerReTxQ() : -----
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
* NET_TCP_ERR_TX_Q_SIGNAL_FAULT TCP connection transmit queue signal fault.
*
* - RETURNED BY NetTCP_TxConnWinSizeHandlerCongCtrl() : -
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_RE_TX_SEG_TH TCP connection closed due to excessive retransmission.
* NET_TCP_ERR_TX TCP transmit error.
*
* --- RETURNED BY NetTCP_RxPktConnHandlerRxQ_Sync() : ---
* --- RETURNED BY NetTCP_RxPktConnHandlerRxQ_Conn() : ---
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but NO data
* to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled & valid data
* queued for application.
*
* --- RETURNED BY NetTCP_RxPktConnHandlerRxQ_Conn() : ---
* NET_TCP_ERR_CONN_DATA_INVALID Received packet contains invalid segment data;
* NOT queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_DUP Received packet contains duplicate segment data;
* NOT queued to receive queue(s).
*
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is NOT
* valid for current TCP connection.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* -- RETURNED BY NetTCP_RxPktConnHandlerRxQ_AppData() : -
* NET_TCP_ERR_RX_Q_FULL TCP connection receive queue full.
* NET_TCP_ERR_RX_Q_SIGNAL_FAULT TCP connection receive queue signal fault.
* NET_TCP_ERR_RX_Q_SIGNAL_CLR TCP connection receive queue clear failed.
*
* Return(s) : none.
*
* Caller(s) : Various NetTCP_RxPktConnHandler() functions.
*$PAGE*
* Note(s) : (2) (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence Number'
* states that "segments are processed in sequence ... processing is done in SEG.SEQ
* order" (see also Note #3).
*
* (b) The following sections generalize that for the SYN-SENT & ESTABLISHED states that
* "any segments on the retransmission queue which are ... acknowledged should be
* removed" :
*
* (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check SYN Bit'
* (2) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* ESTABLISHED STATE'
*
* (3) TCP segments with receive data are sequenced into the appropriate TCP connection
* receive queue(s) to be made available & ready to be read by the application layer.
*
* See also 'NetTCP_RxPktConnHandlerRxQ_Conn() Note #3'
* & 'NetTCP_RxPktConnHandlerRxQ_AppData() Note #2'.
*
* (4) A TCP connection's re-transmit queue SHOULD be updated ONLY by valid received
* acknowledgement segments.
*
* See also 'NetTCP_RxPktConnHandlerReTxQ() Note #3'.
*
* (5) RFC #1122, Section 4.2.2.20 generalizes that "when ... SND.UNA < SEG.ACK <= SND.NXT,
* the send window should be updated".
*
* See also 'NetTCP_RxPktConnHandlerTxWinRemote() Note #1'.
*
* (6) RFC #2581, Section 3.1 states that "the slow start and congestion avoidance algorithms
* ... [update] cwnd [TCP transmit congestion control window] for each ACK received that
* acknowledges new data".
*
* (a) A TCP connection's transmit window congestion controls SHOULD be updated :
*
* (1) After any possible updating of the TCP connection re-transmit queue.
* (2) Prior to any possible queuing of data segments onto the TCP connection
* receive queue(s).
*********************************************************************************************************
*/
static void NetTCP_RxPktConnHandlerSeg (NET_TCP_CONN *pconn,
NET_TCP_ACK_CODE ack_code,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_ERR err_rtn;
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_LISTEN:
NetTCP_RxPktConnHandlerRxQ_Sync(pconn, pbuf, pbuf_hdr, &err_rtn);
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (ack_code != NET_TCP_CONN_RX_ACK_VALID) {
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return;
}
#endif
NetTCP_RxPktConnHandlerTxWinRemote(pconn, ack_code, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
NetTCP_RxPktConnHandlerCfgConn(pconn);
NetTCP_RxPktConnHandlerReTxQ(pconn, ack_code, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
NetTCP_TxConnWinSizeHandlerCongCtrl(pconn, pbuf_hdr, ack_code, 0, NET_TCP_CONN_TX_WIN_SEG_RXD, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_RE_TX_SEG_TH:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
NetTCP_RxPktConnHandlerRxQ_Conn(pconn, pbuf, pbuf_hdr, &err_rtn);
break;
case NET_TCP_CONN_STATE_SYNC_TXD:
if (ack_code == NET_TCP_CONN_RX_ACK_VALID) {
NetTCP_RxPktConnHandlerTxWinRemote(pconn, ack_code, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
NetTCP_RxPktConnHandlerCfgConn(pconn);
NetTCP_RxPktConnHandlerReTxQ(pconn, ack_code, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
NetTCP_TxConnWinSizeHandlerCongCtrl(pconn, pbuf_hdr, ack_code, 0, NET_TCP_CONN_TX_WIN_SEG_RXD, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_RE_TX_SEG_TH:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
NetTCP_RxPktConnHandlerRxQ_Conn(pconn, pbuf, pbuf_hdr, &err_rtn);
} else {
NetTCP_RxPktConnHandlerRxQ_Sync(pconn, pbuf, pbuf_hdr, &err_rtn);
}
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
case NET_TCP_CONN_RX_ACK_DUP:
case NET_TCP_CONN_RX_ACK_PREV:
break;
case NET_TCP_CONN_RX_ACK_NONE:
case NET_TCP_CONN_RX_ACK_INVALID:
default:
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
NetTCP_RxPktConnHandlerTxWinRemote(pconn, ack_code, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID: /* If valid ack, update re-tx Q (see Note #3). */
case NET_TCP_CONN_RX_ACK_DUP:
NetTCP_RxPktConnHandlerReTxQ(pconn, ack_code, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
break;
}
NetTCP_TxConnWinSizeHandlerCongCtrl(pconn, pbuf_hdr, ack_code, 0, NET_TCP_CONN_TX_WIN_SEG_RXD, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_RE_TX_SEG_TH:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
NetTCP_RxPktConnHandlerRxQ_Conn(pconn, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_DATA_DUP:
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_LEN_SEG:
default:
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
NetTCP_RxPktConnHandlerRxQ_AppData(pconn, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
case NET_TCP_CONN_RX_ACK_DUP:
break;
case NET_TCP_CONN_RX_ACK_NONE:
case NET_TCP_CONN_RX_ACK_INVALID:
default:
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
NetTCP_RxPktConnHandlerRxQ_Conn(pconn, pbuf, pbuf_hdr, &err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_CONN_DATA_NONE:
case NET_TCP_ERR_CONN_DATA_VALID:
break;
case NET_TCP_ERR_CONN_DATA_DUP:
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_DATA_INVALID:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_LEN_SEG:
default:
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
NetTCP_RxPktConnHandlerRxQ_AppData(pconn, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
break;
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
case NET_TCP_CONN_STATE_CLOSED:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
*perr = err_rtn;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerCfgConn()
*
* Description : (1) Configure TCP connection's controls on transition to connected state(s) :
*
* (a) Configure TCP connection maximum segment size control(s)
* (b) Configure TCP connection window size controls
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerSeg().
*
* Note(s) : (2) During TCP connection initialization, some TCP connection controls were previously
* configured in NetTCP_ConnGet() when the TCP connection was allocated from the TCP
* connection pool. These TCP connection controls do NOT need to be re-configured
* but are shown for completeness.
*********************************************************************************************************
*/
static void NetTCP_RxPktConnHandlerCfgConn (NET_TCP_CONN *pconn)
{
NET_TCP_CFG_CODE cfg_code;
/* Cfg conn (see Note #1). */
cfg_code = NET_TCP_CONN_CFG_NONE |
NET_TCP_CONN_CFG_MAX_SEG_SIZE_CONN |
NET_TCP_CONN_CFG_WIN_SIZE_ALL;
#if 0 /* Cfg'd in NetTCP_ConnGet() [see Note #2]. */
DEF_BIT_SET(cfg_code, NET_TCP_CONN_CFG_TX_RTT_RTO);
#endif
NetTCP_ConnCfg(pconn, cfg_code);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerRxQ_Sync()
*
* Description : (1) (a) Handle TCP connection's transport receive queue ... :
*
* (1) Update TCP connection initial receive sequence numbers See Note #2b
* (2) Queue received TCP segments onto transport receive queue See Note #3
* (3) Update TCP connection receive window
*
* (b) ... for the following connection-request/synchronization states :
*
* (1) LISTEN
* (2) SYN-SENT
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but
* NO data to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled &
* data queued to receive queue(s)
* for later processing (see Note #2c).
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection receive queue
* state.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerSeg().
*
* Note(s) : (2) (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence Number'
* states that "segments are processed in sequence ... processing is done in SEG.SEQ
* order."
*
* (b) The following sections generalize that for the LISTEN & SYN-SENT states that "if the
* SYN bit is on and ... acceptable then ... RCV.NXT is set to SEG.SEQ+1, IRS is set to
* SEG.SEQ" :
*
* (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State] :
* Check for SYN'
* (2) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check SYN Bit'
*
* (c) (1) The following sections generalize that for the LISTEN & SYN-SENT states that "if
* there are other controls or text in the segment, queue them for later processing
* after the ESTABLISHED state has been reached" :
*
* (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State] :
* Check for SYN'
* (B) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check SYN Bit'
*
* (2) If any control or text is queued for later processing, the next sequence octet to
* receive (RCV.NXT) MUST include the length of this received segment (SEG.LEN) :
*
* (A) RCV.NXT = SEG.SEQ + SEG.LEN + 1
* (3) TCP segments with receive data are sequenced into the appropriate TCP connection
* receive queue(s) to be made available & ready to be read by the application layer.
*
* See also 'NetTCP_RxPktConnHandlerRxQ_Conn() Note #3'
* & 'NetTCP_RxPktConnHandlerRxQ_AppData() Note #2'.
*
* (4) Some buffer controls were previously initialized in NetBuf_Get() when the buffer was
* allocated. These buffer controls do NOT need to be re-initialized but are shown for
* completeness.
*
* (5) RFC #793, Section 3.7 'Data Communication : Managing the Window' states that "the window
* sent in each segment indicates the range of sequence numbers the sender of the window
* (the data receiver) is currently prepared to accept. There is an assumption that this
* is related to the currently available data buffer space available for this connection
* ... One strategy would be to ... [update the] information when the window" changes.
*
* See also 'NetTCP_RxAppData() Note #7',
* 'NetTCP_RxPktConnHandlerRxQ_Conn() Note #6',
* & 'NetTCP_RxConnWinSizeHandler() Note #2a'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_RxPktConnHandlerRxQ_Sync (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
NET_TCP_SEG_SIZE seg_len;
NET_TCP_SEG_SIZE seg_len_data;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ------------- VALIDATE RX Q CONN STATE ------------- */
switch (pconn->RxQ_State) {
case NET_TCP_RX_Q_STATE_CONN_CLOSED:
break;
case NET_TCP_RX_Q_STATE_NONE:
case NET_TCP_RX_Q_STATE_CLOSED:
case NET_TCP_RX_Q_STATE_CONN_SYNC:
case NET_TCP_RX_Q_STATE_CONN:
case NET_TCP_RX_Q_STATE_CONN_CLOSING:
default:
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
/* Update TCP conn rx seq nbrs (see Notes #2b & #2c2). */
pconn->RxSeqNbrSync = (NET_TCP_SEQ_NBR) pbuf_hdr->TCP_SeqNbr;
pconn->RxSeqNbrNext = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_SeqNbr + pbuf_hdr->TCP_SegLen);
pconn->RxQ_State = NET_TCP_RX_Q_STATE_CONN_SYNC;
seg_len = (NET_TCP_SEG_SIZE)pbuf_hdr->TCP_SegLen;
if (seg_len > NET_TCP_SEG_LEN_SYNC) { /* If rx'd seg len > sync seg len, ... */
/* ... Q seg to TCP conn rx Q (see Notes #3 & #2c1). */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NetTCP_ConnFreeBufQ(&pconn->RxQ_Transport_Head, &pconn->RxQ_Transport_Tail);
#endif
pconn->RxQ_Transport_Head = (NET_BUF *)pbuf;
pconn->RxQ_Transport_Tail = (NET_BUF *)pbuf;
#if 0 /* Init'd in NetBuf_Get() [see Note #4]. */
pbuf_hdr->PrevPrimListPtr = (void *)0;
pbuf_hdr->NextPrimListPtr = (void *)0;
#endif
/* Dec TCP conn's rx win size (see Note #5). */
seg_len_data = (NET_TCP_SEG_SIZE)pbuf_hdr->TCP_SegLenData;
NetTCP_RxConnWinSizeHandler((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)pbuf_hdr,
(NET_TCP_WIN_SIZE)seg_len_data,
(NET_TCP_WIN_CODE)NET_TCP_CONN_RX_WIN_DEC);
*perr = NET_TCP_ERR_CONN_DATA_VALID;
} else {
*perr = NET_TCP_ERR_CONN_DATA_NONE;
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerRxQ_Conn()
*
* Description : (1) (a) Handle TCP connection's transport receive queue ... :
*
* (1) Update TCP connection receive sequence numbers See Notes #2c & #2e
* (2) Insert received TCP segments in sequence order See Notes #3 & #4
* (3) Update TCP connection receive window
*
* (b) ... for the following connected states :
*
* (1) SYN-RECEIVED See Notes #1bA & #2b2
* (2) SYN-SENT See Notes #1bA & #2b1
* (3) ESTABLISHED See Note #1bB
* (4) FIN-WAIT-1 See Note #1bB
* (5) FIN-WAIT-2 See Note #1bB
* (6) CLOSING See Note #1bC
* (7) TIME-WAIT See Note #1bC
* (8) CLOSE-WAIT See Note #1bC
* (9) LAST-ACK See Note #1bC
*
*
* (A) For synchronization-to-connected state transitions, segments are queued to
* the TCP connection's transport receive queue, but NOT to the TCP connection's
* application receive queue, until the application layer is signaled that the
* transport layer connection is complete.
*
* See also 'NetTCP_RxPktConnHandlerSyncRxd() Note #1c1'
* & 'NetTCP_RxPktConnHandlerSyncTxd() Note #1c1'.
*
* (B) For connected states, segments are queued to the TCP connection's
* transport &/or application receive queue(s) as appropriate (see Note #3).
*
* (C) For closing states; closing segments are queued to the TCP connection's
* transport &/or application receive queue(s) as for connected states.
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* pbuf Pointer to network buffer that received TCP packet.
* ---- Argument checked in NetTCP_Rx().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_CONN_DATA_NONE Received packet successfully handled; but
* NO data to queue to receive queue(s).
* NET_TCP_ERR_CONN_DATA_VALID Received packet successfully handled &
* data queued to receive queue(s)
* for later processing (see Note #3).
* NET_TCP_ERR_CONN_DATA_INVALID Received packet contains invalid segment
* data; NOT queued to receive queue(s).
* NET_TCP_ERR_CONN_DATA_DUP Received packet contains duplicate segment
* data; NOT queued to receive queue(s)
* (see Note #2a2).
*
* NET_TCP_ERR_CONN_SEQ_INVALID Received segment's sequence number is NOT
* valid for current TCP connection.
*
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection receive queue state.
*
* - RETURNED BY NetTCP_RxPktConnIsValidSeq() : -
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerSeg().
*$PAGE*
* Note(s) : (2) (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence Number'
* states that ... :
*
* (1) "Segments are processed in sequence ... processing is done in SEG.SEQ order."
*
* (A) Assumes received segment's sequences previously validated.
*
* (2) "Initial tests on arrival are used to discard old duplicates."
*
* (3) (A) (1) "If a segment's contents straddle the boundary between old and new,
* only the new parts should be processed."
*
* (2) "One could tailor actual segments to ... the idealized segment that
* begins at RCV.NXT and does not exceed the window ... by trimming off
* any portions that lie outside the window (including SYN and FIN),
* and only processing further if the segment then begins at RCV.NXT.
* Segments with higher beginning sequence numbers may be held for later
* processing."
*
* (B) (1) Sequencing received segments with duplicate data that overlaps
* multiple previously-received segments' non-contiguous sequence numbers
* is data intensive/expensive.
*
* (2) Therefore, any received segment with duplicate data that overlaps
* multiple previously-received segments' non-contiguous sequence numbers
* is trimmed of duplicate data starting from the end of the received
* segment's data.
*
* In other words, only the first contiguous, non-duplicate data sequence
* starting from the start of the received segment's data is sequenced
* into the TCP connection's receive queue(s).
*
* (C) RFC #1122, Section 4.2.2.20 states that "a TCP SHOULD be capable of queueing
* out-of-order TCP segments".
*
* (b) The following sections generalize that in the "SYN-SENT [or] ... SYN-RECEIVED
* STATE[s], ... [that] if the ACK bit is on [and] our SYN has been ACKed ...
* then enter the ESTABLISHED state and continue processing" :
*
* (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check SYN Bit'
* (2) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* SYN-RECEIVED STATE'
*
* (c) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check SYN Bit' states that "if the SYN bit is on and ... acceptable then ...
* RCV.NXT is set to SEG.SEQ+1, IRS is set to SEG.SEQ".
*
* (d) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check SYN Bit' states that "if there are other controls or text in the segment,
* queue them for later processing after the ESTABLISHED state has been reached"
* (see also Note #2b).
*
* (2) If any control or text is queued for later processing, the next sequence octet to
* receive (RCV.NXT) MUST include the length of this received segment (SEG.LEN) :
*
* (A) RCV.NXT = SEG.SEQ + SEG.LEN + 1
*
* (e) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states
* that "if the FIN bit is set ... advance RCV.NXT over the FIN".
*
* (2) However, the next octet to receive is NOT updated with the sequence number of the
* last octet to receive. Instead, the generic sequence algorithm maintains & updates
* BOTH the next & last octets to receive for the closing TCP connection.
*$PAGE*
* (3) TCP segments with receive data are sequenced first into the TCP connection's transport
* receive queue to be made available & ready to be read by the application layer from the
* TCP connection's application receive queue (see 'NetTCP_RxPktConnHandlerRxQ_AppData()
* Note #2').
*
* (a) Received TCP segments are inserted into a doubly-linked Transport Receive Queue,
* sorted by their sequence number(s).
*
* (1) 'RxQ_Transport_Head' points to the head of the Transport Receive Queue;
* 'RxQ_Transport_Tail' points to the tail of the Transport Receive Queue.
*
* (2) Segment buffers' 'PrevPrimListPtr' & 'NextPrimListPtr' doubly-link each
* segment to form the Transport Receive Queue.
*
* (3) Fragmented segment buffer's 'PrevBufPtr' & 'NextBufPtr' doubly-link each
* fragmented segment (see also 'net_ip.c NetIP_RxPktFragReasm() Note #2b3').
*
* (b) Typically & most-frequently, TCP segments will be received in sequence-order.
* Therefore, the sequence sort algorithm starts at the tail of the Transport
* Receive Queue.
*
* (c) As segments are inserted into the Transport Receive Queue, segments migrate to
* the head of the Transport Receive Queue. Queued segments with sequence numbers
* that are contiguous from the next expected receive sequence number are ready to
* be read by the application layer, so are immediately moved from the Transport
* Receive Queue to the Application Receive Queue.
*
* See also 'NetTCP_RxPktConnHandlerRxQ_AppData() Note #2'.
*
*
* | |
* |<-- TCP Connection Transport Receive Queue --->|
* | (see Note #3) |
*
* Segments Moved Segments Sequenced
* to Application into Transport
* Receive Queue Receive Queue
* starting at head starting at tail
* (see Note #3c) (see Note #3b)
*
* | NextPrimListPtr |
* | (see Note #3a2) |
* v | v
* |
* Head of ------- ------- v ------- ------- (see Note #3a1)
* Receive ---->| |------>| |------>| |------>| |
* Queue | | | | | | | | Tail of
* | |<------| |<------| |<------| |<---- Receive
* (see Note #3a1) | | | | ^ | | | | Queue
* | | | | | | | | |
* ------- ------- | ------- -------
* | ^ | | ^
* | | PrevPrimListPtr | |
* v | (see Note #3a2) v |
* ------- -------
* | | | |
* | | | |
* | | | |
* | | | |
* | | | |
* ------- -------
* | ^ | ^
* NextBufPtr ---> | | <--- PrevBufPtr | |
* (see Note #3a3) v | (see Note #3a3) v |
* ------- -------
* | | | |
* | | | |
* | | -------
* | |
* | |
* -------
*
*$PAGE*
* (4) RFC #793 does NOT provide nor suggest any logic to determine/handle sequence number
* comparisons for sequence number windows that overflow the sequence number space.
*
* (a) For example, the next sequence octet to receive (RCV.NXT) is typically less than
* or equal to the next received sequence octet (SEG.SEQ) :
*
* (1) RCV.NXT <= SEG.SEQ
*
* SEG.SEQ itself is also typically less than RCV.NXT plus the current receive window
* size (RCV.WND) :
*
* (2) SEG.SEQ < RCV.NXT + RCV.WND
*
* However, if (RCV.NXT + RCV.WND) or SEG.SEQ overflows the sequence number space,
* these values will be MUCH less than SEG.SEQ or RCV.NXT, respectively, until
* SEG.SEQ & RCV.NXT also overflow :
*
* (3) RCV.NXT + RCV.WND << RCV.NXT
* << SEG.SEQ
*
* (4) SEG.SEQ << RCV.NXT
*
* (b) Therefore, in order to determine if a received segment's sequence value precedes any
* previously received segment(s) in the TCP connection's receive queue(s), the following
* unsigned arithmetic comparisons MUST be checked :
*
* (1) RxQCur.SeqNbr - (SEG.SEQ + 1) < RX.WIN
*
* (2) RX.NXT - (SEG.SEQ + 1) < SEG.LEN
*
* Note that these comparisons bound any received segment's sequence within limits set
* by the TCP connection's receive window size & next expected receive octet.
*
* (c) In order to determine if a received segment's sequence value overlaps any previously
* received segment(s) in the TCP connection's receive queue, the following unsigned
* arithmetic comparisons MUST be checked :
*
* (1) ( SEG.SEQ + SEG.LEN ) - (RxQNext.SeqNbr + 1) < SEG.LEN
*
* (2) (RxQCur.SeqNbr + RxQCur.SegLen) - (SEG.SEQ + 1) < RxQCur.SegLen
*
* See also 'NetTCP_RxPktConnIsValidSeq() Note #2'.
*
* (5) (a) RFC #2581, Section 3.2 states that "a TCP receiver SHOULD send an immediate ACK" :
*
* (1) "When an out-of-order segment arrives. The purpose of this ACK is to inform
* the sender that a segment was received out-of-order and which sequence number
* is expected."
*
* (2) "In addition, ... when the incoming segment fills in all or part of a gap in
* the sequence space."
*
* See also 'NetTCP_TxConnAck() Note #4a5'.
*
* (b) Since segments are typically received in sequence order (see Notes #5a1 & #3b) &
* since segments received in sequential order are immediately made available & ready
* to be read by the application layer (see Note #3c), received segments are out-of-
* order AND/OR fill in sequence number gaps whenever :
*
* (1) A TCP connection's Transport Receive Queue is initially non-empty;
* OR
* (2) A TCP connection's Transport Receive Queue's head segment's sequence number
* does NOT equal the TCP connection's next expected receive sequence number.
*
* (c) However, since a TCP connection's next expected receive sequence numbers are NOT
* updated until both of the TCP connection's transport & application receive queues
* have been handled (see 'NetTCP_RxPktConnHandlerRxQ_AppData() Note #1a3'), the
* transmission of any immediate acknowledgement MUST follow the handling of BOTH
* of the TCP connection's receive queues.
*
* See also 'NetTCP_RxPktConnHandlerRxQ_AppData() Notes #1a3 & #4'.
*
* (6) RFC #793, Section 3.7 'Data Communication : Managing the Window' states that "the window
* sent in each segment indicates the range of sequence numbers the sender of the window
* (the data receiver) is currently prepared to accept. There is an assumption that this
* is related to the currently available data buffer space available for this connection
* ... One strategy would be to ... [update the] information when the window" changes.
*
* See also 'NetTCP_RxAppData() Note #7',
* 'NetTCP_RxPktConnHandlerRxQ_Sync() Note #5',
* & 'NetTCP_RxConnWinSizeHandler() Note #2a'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_RxPktConnHandlerRxQ_Conn (NET_TCP_CONN *pconn,
NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NET_TCP_SEQ_CODE seq_code;
#endif
NET_BUF *pbuf_q;
NET_BUF *pbuf_q_head;
NET_BUF *pbuf_q_prev;
NET_BUF *pbuf_q_next;
NET_BUF_HDR *pbuf_q_hdr;
NET_BUF_HDR *pbuf_q_hdr_head;
NET_BUF_HDR *pbuf_q_hdr_next;
NET_TCP_SEQ_NBR seq_nbr;
NET_TCP_SEQ_NBR seq_nbr_next;
NET_TCP_SEQ_NBR seq_nbr_dup;
NET_TCP_SEQ_NBR seq_nbr_delta;
NET_TCP_SEQ_NBR seq_nbr_win;
CPU_BOOLEAN seq_srch_done;
CPU_BOOLEAN seq_unordered_prev;
CPU_BOOLEAN seq_unordered_cur;
CPU_BOOLEAN seq_unordered;
/* ----------- UPDATE TCP CONN RX SEQ NBRS ------------ */
if (pconn->ConnState == NET_TCP_CONN_STATE_SYNC_TXD) {
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
switch (pconn->RxQ_State) {
case NET_TCP_RX_Q_STATE_CONN_CLOSED:
break;
case NET_TCP_RX_Q_STATE_NONE:
case NET_TCP_RX_Q_STATE_CLOSED:
case NET_TCP_RX_Q_STATE_CONN_SYNC:
case NET_TCP_RX_Q_STATE_CONN:
case NET_TCP_RX_Q_STATE_CONN_CLOSING:
default:
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
/* Init SYN-SENT state (see Notes #2c & #2d2). */
pconn->RxSeqNbrSync = (NET_TCP_SEQ_NBR) pbuf_hdr->TCP_SeqNbr;
pconn->RxSeqNbrNext = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_SeqNbr + pbuf_hdr->TCP_SegLen);
pconn->RxQ_State = NET_TCP_RX_Q_STATE_CONN_SYNC;
} else {
switch (pconn->RxQ_State) {
case NET_TCP_RX_Q_STATE_CONN_SYNC:
break;
case NET_TCP_RX_Q_STATE_CONN:
/* Chk TCP conn closing (see Note #2e). */
if (pbuf_hdr->TCP_SegClose == DEF_YES) {
pconn->RxSeqNbrLast = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_SeqNbr + pbuf_hdr->TCP_SegLen);
pconn->RxSeqNbrClose = (NET_TCP_SEQ_NBR)(pconn->RxSeqNbrLast - NET_TCP_SEG_LEN_CLOSE);
pconn->RxQ_State = NET_TCP_RX_Q_STATE_CONN_CLOSING;
}
/* 'break' intentionally omitted; do NOT move from the */
/* .. following case : 'NET_TCP_RX_Q_STATE_CONN_CLOSED'.*/
case NET_TCP_RX_Q_STATE_CONN_CLOSED:
case NET_TCP_RX_Q_STATE_CONN_CLOSING:
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
/* Chk valid rx'd seq nbr. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
if (seq_code != NET_TCP_CONN_RX_SEQ_VALID) {
*perr = NET_TCP_ERR_CONN_SEQ_INVALID;
return;
}
#endif
break;
case NET_TCP_RX_Q_STATE_NONE:
case NET_TCP_RX_Q_STATE_CLOSED:
default:
*perr = NET_TCP_ERR_CONN_DATA_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
}
/*$PAGE*/
if (pbuf_hdr->TCP_SegLenData < 1) { /* If seg data len < 1, AND ... */
/* ... NOT in rx conn closing state OR ... */
if ((pconn->RxQ_State != NET_TCP_RX_Q_STATE_CONN_CLOSING) ||
(pbuf_hdr->TCP_SegClose != DEF_YES)) { /* ... fin/close NOT rx'd; ... */
*perr = NET_TCP_ERR_CONN_DATA_NONE; /* ... rtn data NOT avail. */
return;
} /* Else seq & handle closing-ctrl seg. */
}
/* ------- INSERT SEG INTO SEQ'D TRANSPORT RX Q ------- */
pbuf_q = (NET_BUF *)pconn->RxQ_Transport_Tail; /* Start seq insert alg from rx Q tail (see Note #3b). */
pbuf_q_next = (NET_BUF *)0;
seq_srch_done = DEF_NO;
/* Chk init'l rx Q seq order (see Note #5b1). */
seq_unordered_prev = (pconn->RxQ_Transport_Head != (NET_BUF *)0)
? DEF_YES : DEF_NO;
while (seq_srch_done == DEF_NO) { /* Srch rx Q to insert rx'd seg into seq nbr position. */
if (pbuf_q != (NET_BUF *)0) { /* While NOT @ rx Q head, chk if seg ... */
pbuf_q_hdr = (NET_BUF_HDR *)&pbuf_q->Hdr;
pbuf_q_prev = (NET_BUF *) pbuf_q_hdr->PrevPrimListPtr;
/* ... before or after cur rx Q seg (see Note #2a1). */
seq_nbr_next = (NET_TCP_SEQ_NBR) pbuf_q_hdr->TCP_SeqNbr;
seq_nbr = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_SeqNbr + 1);
seq_nbr_delta = (NET_TCP_SEQ_NBR)(seq_nbr_next - seq_nbr);
seq_nbr_win = (NET_TCP_SEQ_NBR) pconn->RxWinSizeCfgdActual;
if (seq_nbr_delta < seq_nbr_win) { /* If seg's seq nbr < cur rx Q's seq nbr (see Note #4b1)*/
/* ... adv to prev rx Q seg; but chk ... */
/* ... for dup seqs in next rx Q seg. */
seq_nbr_next = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_SeqNbr + pbuf_hdr->TCP_SegLen);
seq_nbr = (NET_TCP_SEQ_NBR)(pbuf_q_hdr->TCP_SeqNbr + 1);
seq_nbr_delta = (NET_TCP_SEQ_NBR)(seq_nbr_next - seq_nbr);
seq_nbr_win = (NET_TCP_SEQ_NBR) pbuf_hdr->TCP_SegLen;
if (seq_nbr_delta < seq_nbr_win) { /* If seg overlaps next rx Q seqs (see Note #4c1), ... */
seq_nbr_dup = seq_nbr_delta + 1; /* ... trim dup seqs from seg (see Note #2a3); ... */
if (pbuf_hdr->TCP_SegLenData > (CPU_INT16U)seq_nbr_dup) {
pbuf_hdr->TCP_SegLenData -= (CPU_INT16U)seq_nbr_dup;
pbuf_hdr->TCP_SegLen -= (CPU_INT16U)seq_nbr_dup;
} else { /* ... else discard ALL dup seqs (see Note #2a2). */
*perr = NET_TCP_ERR_CONN_DATA_DUP;
return;
}
}
/* Adv to prev rx Q seg. */
pbuf_q_next = (NET_BUF *)pbuf_q;
pbuf_q = (NET_BUF *)pbuf_q_prev;
} else { /* Else insert seg between cur/next rx Q segs. */
/* Chk for dup seqs in cur rx Q seg. */
seq_nbr_next = (NET_TCP_SEQ_NBR)(pbuf_q_hdr->TCP_SeqNbr + pbuf_q_hdr->TCP_SegLen);
seq_nbr = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_SeqNbr + 1);
seq_nbr_delta = (NET_TCP_SEQ_NBR)(seq_nbr_next - seq_nbr);
seq_nbr_win = (NET_TCP_SEQ_NBR) pbuf_q_hdr->TCP_SegLen;
if (seq_nbr_delta < seq_nbr_win) { /* If seg overlaps prev'ly rx'd seqs (see Note #4c2), */
seq_nbr_dup = seq_nbr_delta + 1; /* ... trim dup seqs from seg (see Note #2a3); ... */
if (pbuf_hdr->TCP_SegLenData > (CPU_INT16U)seq_nbr_dup) {
pbuf_hdr->TCP_SegLenData -= (CPU_INT16U)seq_nbr_dup;
pbuf_hdr->TCP_SegLen -= (CPU_INT16U)seq_nbr_dup;
pbuf_hdr->TCP_SeqNbr = (CPU_INT32U)seq_nbr_next;
} else { /* ... else discard ALL dup seqs (see Note #2a2). */
*perr = NET_TCP_ERR_CONN_DATA_DUP;
return;
}
}
seq_srch_done = DEF_YES;
}
/*$PAGE*/
} else { /* Else if @ head of rx Q, entire rx Q srch'd; ... */
/* ... chk for dup seqs prior to TCP conn's ... */
/* ... next expected rx octet. */
seq_nbr_next = (NET_TCP_SEQ_NBR) pconn->RxSeqNbrNext;
seq_nbr = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_SeqNbr + 1);
seq_nbr_delta = (NET_TCP_SEQ_NBR)(seq_nbr_next - seq_nbr);
seq_nbr_win = (NET_TCP_SEQ_NBR) pbuf_hdr->TCP_SegLen;
if (seq_nbr_delta < seq_nbr_win) { /* If seg overlaps prev'ly rx'd seqs (see Note #4b2), */
seq_nbr_dup = seq_nbr_delta + 1; /* ... trim dup seqs from seg (see Note #2a3); */
if (pbuf_hdr->TCP_SegLenData > (CPU_INT16U)seq_nbr_dup) {
pbuf_hdr->TCP_SegLenData -= (CPU_INT16U)seq_nbr_dup;
pbuf_hdr->TCP_SegLen -= (CPU_INT16U)seq_nbr_dup;
pbuf_hdr->TCP_SeqNbr = (CPU_INT32U)seq_nbr_next;
} else { /* ... else discard ALL dup seqs (see Note #2a2). */
*perr = NET_TCP_ERR_CONN_DATA_DUP;
return;
}
}
seq_srch_done = DEF_YES;
}
}
/* Insert rx'd seg between cur/next rx Q segs. */
pbuf_hdr->PrevPrimListPtr = (void *)pbuf_q;
if (pbuf_q != (NET_BUF *)0) { /* If avail, insert rx'd seg after cur rx Q seg. */
pbuf_q_hdr->NextPrimListPtr = (void *)pbuf;
} else { /* Else insert rx'd seg @ rx Q head. */
pconn->RxQ_Transport_Head = (NET_BUF *)pbuf;
}
pbuf_hdr->NextPrimListPtr = (void *)pbuf_q_next;
if (pbuf_q_next != (NET_BUF *)0) { /* If avail, insert rx'd seg before next rx Q seg. */
pbuf_q_hdr_next = (NET_BUF_HDR *)&pbuf_q_next->Hdr;
pbuf_q_hdr_next->PrevPrimListPtr = (void *) pbuf;
} else { /* Else insert rx'd seg @ rx Q tail. */
pconn->RxQ_Transport_Tail = (NET_BUF *) pbuf;
}
/* Chk rx'd out-of-order seg(s) [see Note #5a]. */
if (pconn->RxQ_Transport_Head != (NET_BUF *)0) {
pbuf_q_head = (NET_BUF *) pconn->RxQ_Transport_Head;
pbuf_q_hdr_head = (NET_BUF_HDR *)&pbuf_q_head->Hdr;
/* Chk cur rx Q seq order (see Note #5b2). */
seq_unordered_cur = ((NET_TCP_SEQ_NBR)pbuf_q_hdr_head->TCP_SeqNbr
!= (NET_TCP_SEQ_NBR)pconn->RxSeqNbrNext)
? DEF_YES : DEF_NO;
}
seq_unordered = ((seq_unordered_prev == DEF_YES) ||
(seq_unordered_cur == DEF_YES)) ? DEF_YES : DEF_NO;
if (seq_unordered != DEF_NO) { /* If out-of-order seg(s) rx'd (see Note #5a) ... */
if (pconn->RxQ_State != NET_TCP_RX_Q_STATE_CONN_SYNC) { /* ... in non-sync state, ... */
/* ... req immed TCP conn ack tx (see Note #5c). */
pbuf_hdr->TCP_SegAckTxReqCode = NET_TCP_CONN_TX_ACK_IMMED;
}
}
/* ----------- UPDATE TCP CONN RX WIN SIZE ------------ */
/* Dec TCP conn's rx win size (see Note #6). */
NetTCP_RxConnWinSizeHandler((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)pbuf_hdr,
(NET_TCP_WIN_SIZE)pbuf_hdr->TCP_SegLenData,
(NET_TCP_WIN_CODE)NET_TCP_CONN_RX_WIN_DEC);
*perr = NET_TCP_ERR_CONN_DATA_VALID;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerRxQ_AppData()
*
* Description : (1) (a) Handle TCP connection's application receive queue ... :
*
* (1) Remove segments from TCP connection's transport receive queue See Note #3b1B
* (2) Update TCP connection transport receive queue
* (3) Update TCP connection receive sequence numbers
* (4) Move segments onto TCP connection's application receive queue See Note #2
* (5) Update TCP connection receive window See Note #6
*
* (b) ... for the following connected states :
*
* (1) SYN-RECEIVED See Note #1bA
* (2) SYN-SENT See Note #1bA
* (3) ESTABLISHED See Note #1bB
* (4) FIN-WAIT-1 See Note #1bB
* (5) FIN-WAIT-2 See Note #1bB
* (6) CLOSING See Note #1bC
* (7) TIME-WAIT See Note #1bC
* (8) CLOSE-WAIT See Note #1bC
* (9) LAST-ACK See Note #1bC
*
*
* (A) For synchronization-to-connected state transitions, segments are queued to
* the TCP connection's transport receive queue, but NOT to the TCP connection's
* application receive queue, until the application layer is signaled that the
* transport layer connection is complete.
*
* See also 'NetTCP_RxPktConnHandlerSyncRxd() Note #1c1'
* & 'NetTCP_RxPktConnHandlerSyncTxd() Note #1c1'.
*
* (B) For connected states, segments are queued to the TCP connection's application
* receive queue as appropriate (see Notes #2 & #3b).
*
* (C) For closing states; closing segments are queued to the TCP connection's
* transport &/or application receive queue(s) as for connected states.
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection's application receive queue
* successfully handled.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection receive queue state.
*
* ---- RETURNED BY NetOS_TCP_RxQ_Signal() : ----
* NET_TCP_ERR_RX_Q_FULL TCP connection receive queue full.
* NET_TCP_ERR_RX_Q_SIGNAL_FAULT TCP connection receive queue signal fault.
*
* ----- RETURNED BY NetOS_TCP_RxQ_Clr() : ------
* NET_TCP_ERR_RX_Q_SIGNAL_CLR TCP connection receive queue clear failed.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerSeg(),
* NetTCP_RxPktConnHandlerSyncRxd(),
* NetTCP_RxPktConnHandlerSyncTxd().
*$PAGE*
* Note(s) : (2) TCP segments with receive data that are available & ready to be read by the application
* layer are linked in a TCP connection's application receive queue.
*
* (a) Received TCP segments are moved from the doubly-linked Transport Receive Queue,
* sorted by their sequence number(s), onto the Application Receive Queue.
*
* (1) 'RxQ_App_Head' points to the head of the Application Receive Queue;
* 'RxQ_App_Tail' points to the tail of the Application Receive Queue.
*
* (2) Segment buffers' 'PrevPrimListPtr' & 'NextPrimListPtr' doubly-link each
* segment to form the Application Receive Queue.
*
* (3) Fragmented segment buffer's 'PrevBufPtr' & 'NextBufPtr' doubly-link each
* fragmented segment (see also 'net_ip.c NetIP_RxPktFragReasm() Note #2b3').
*
* (b) TCP segments are appended in sequence order from the head of a TCP connection's
* Transport Receive Queue to the tail of the TCP connection's Application Receive
* Queue.
*
* See also 'NetTCP_RxPktConnHandlerRxQ_Conn() Note #3'.
*
* (c) Application data is read from segments starting from the head of the Application
* Receive Queue. Segments that are read by the application layer are removed from
* the Application Receive Queue.
*
*
* | |
* |<- TCP Connection Application Receive Queue -->|
* | (see Note #2) |
*
* Segments Read by Segments Appended to
* Application Layer Application Receive Queue
* starting at head starting at tail
* (see Note #2c) (see Note #2b)
*
* | NextPrimListPtr |
* | (see Note #2a2) |
* v | v
* |
* Head of ------- ------- v ------- ------- (see Note #2a1)
* Receive ---->| |------>| |------>| |------>| |
* Queue | | | | | | | | Tail of
* | |<------| |<------| |<------| |<---- Receive
* (see Note #2a1) | | | | ^ | | | | Queue
* | | | | | | | | |
* ------- ------- | ------- -------
* | ^ | | ^
* | | PrevPrimListPtr | |
* v | (see Note #2a2) v |
* ------- -------
* | | | |
* | | | |
* | | | |
* | | | |
* | | | |
* ------- -------
* | ^ | ^
* NextBufPtr ---> | | <--- PrevBufPtr | |
* (see Note #2a3) v | (see Note #2a3) v |
* ------- -------
* | | | |
* | | | |
* | | -------
* | |
* | |
* -------
*
*$PAGE*
* (3) (a) (1) RFC #793, Section 3.8 'Interfaces : User/TCP Interface : TCP User Commands :
* Receive' states that :
*
* (A) "If enough data arrive [sic] to fill the buffer before a PUSH is seen,
* the PUSH flag will not be set in the response to the RECEIVE. The
* buffer will be filled with as much data as it can hold."
*
* (B) "If the PUSH is seen before the buffer is filled the buffer will be
* returned partially filled and PUSH indicated."
*
* See Notes #3b1B & #3b1B.
*
* (2) RFC #1122, Section 4.2.2.2 states that :
*
* (A) (1) "At the receiver, the PSH bit forces buffered data to be delivered to
* the application (even if less than a full buffer has been received)."
*
* (2) (a) "Conversely, the lack of a PSH bit can be used to avoid unnecessary
* wakeup calls to the application process; this can be an important
* performance optimization for large timesharing hosts."
*
* (b) "When a series of segments is received without the PSH bit, a TCP
* MAY queue the data internally without passing it to the receiving
* application."
*
* (B) (1) "Passing the PSH bit to the receiving application allows an ...
* optimization within the application."
*
* (2) "RFC-793 ... erroneously implies that a received PSH flag must be passed
* to the application layer. Passing a received PSH flag to the application
* layer is now OPTIONAL."
*
* (C) "The PSH bit is not a record marker and is independent of segment boundaries."
*
* (b) (1) (A) (1) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 20.5, Page 284
* states that "Berkeley-derived implementations ignore a received PUSH flag
* because they normally never delay the delivery of received data to the
* application".
*
* (2) Therefore, for TCP connections in any connected state, received TCP segment
* data is made available to the application receive queue as soon as it is
* enqueued to the application receive queue.
*
* (B) Thus, for TCP connections in any connected state, TCP segments are moved from
* a TCP connection's transport receive queue to its application receive queue
* whenever the transport receive queue's enqueued TCP segments are consecutively
* sequenced starting from the TCP connection's next expected receive octet.
*
* (2) Thus, TCP application-receive PUSH feature is obsoleted & NOT implemented.
*
* See also 'NetTCP_TxConnAck() Note #4a4'.
*
* (4) A TCP connection's next expected receive sequence numbers are NOT updated until
* both of the TCP connection's transport & application receive queues have been
* handled. Thus, the transmission of any TCP connection data or acknowledgements
* MUST follow the handling of BOTH of the TCP connection's receive queues.
*
* See also Note #1a3 & 'NetTCP_RxPktConnHandlerRxQ_Conn() Note #5c'.
*
* (5) Stream-type connections receive all data octets in one or more non-distinct
* packets. In other words, the application data is NOT bounded by any specific
* packet(s); rather, it is contiguous & sequenced from one packet to the next.
*
* Therefore, the TCP connection receive queue is signaled ONLY when data is received
* for a connection where data was previously unavailable.
*$PAGE*
* (6) (a) RFC #793, Section 3.7 'Data Communication : Managing the Window' states that
* "the window sent in each segment indicates the range of sequence numbers the
* sender of the window (the data receiver) is currently prepared to accept.
* There is an assumption that this is related to the currently available data
* buffer space available for this connection".
*
* (b) (1) A TCP connection's advertised receive window MUST NEVER be decreased to zero
* if NO receive data is available & ready to be read by the application layer.
*
* In other words, if NO received data starting from the next expected receive
* sequence number(s) is queued, then NO data is available to be read by the
* application layer. Therefore, the receive window size MUST NOT be decreased
* to zero, otherwise the receive window would deadlock since the application
* layer would NOT be able to read & extract any data from the receive window
* & the TCP connection would NOT be able to receive any more data into the
* receive window.
*
* (2) (A) In case the advertised receive window size has decreased to zero, ...
* (B) & NO data is available to be read by the application layer; ...
* (C) then remove & free the last received TCP segment from the tail
* of the TCP connection's transport receive queue, ...
* (D) & increase the advertised receive window size by this freed
* segment's length.
*
* This is permissible because removing the last received TCP segment from
* the TCP connection's transport receive queue does NOT interfere with TCP
* communications since the next expected receive sequence number(s) remains
* unchanged.
*
* (3) (A) A TCP connection's receive window SHOULD NOT become deadlocked during
* correct operation of TCP communication. However, these TCP receive
* zero-sized window cases are included as an extra precaution in the
* case that TCP communication is incorrectly handled &/or corrupted.
*
* (B) A deadlocked TCP connection with a receive window of zero-size with
* absolutely NO buffers queued in the TCP connection's transport receive
* queue SHOULD NEVER occur. However, the TCP receive window size reset
* case is included as an extra precaution in the case that a TCP connection
* receive window is incorrectly handled &/or corrupted.
*
* See also 'NetTCP_RxConnWinSizeHandler() Note #2a1'.
*********************************************************************************************************
*/
static void NetTCP_RxPktConnHandlerRxQ_AppData (NET_TCP_CONN *pconn,
NET_ERR *perr)
{
NET_BUF *pbuf;
NET_BUF *pbuf_head;
NET_BUF *pbuf_tail;
NET_BUF *pbuf_q_head;
NET_BUF *pbuf_q_tail;
NET_BUF_HDR *pbuf_hdr;
NET_BUF_HDR *pbuf_hdr_head;
NET_BUF_HDR *pbuf_hdr_tail;
NET_BUF_HDR *pbuf_hdr_q_head;
NET_BUF_HDR *pbuf_hdr_q_tail;
NET_TCP_SEQ_NBR seq_nbr;
NET_TCP_SEQ_NBR seq_nbr_inc;
CPU_BOOLEAN done;
/*$PAGE*/
/* ---- REMOVE RX'D SEG(S) FROM TRANSPORT RX Q ---- */
switch (pconn->RxQ_State) { /* Cfg starting seq nbr. */
case NET_TCP_RX_Q_STATE_CONN_SYNC:
if (pconn->RxQ_Transport_Head == (NET_BUF *)0) { /* If sync seg NOT q'd with rx'd data, ... */
seq_nbr = pconn->RxSeqNbrNext; /* ... start rx seq move from next rx seq. */
} else { /* Else sync seg possibly q'd with rx'd data. */
pbuf_q_head = (NET_BUF *) pconn->RxQ_Transport_Head;
pbuf_hdr_q_head = (NET_BUF_HDR *)&pbuf_q_head->Hdr;
/* If sync seg q'd, ... */
seq_nbr = (pbuf_hdr_q_head->TCP_SegSync == DEF_YES)
? pconn->RxSeqNbrSync /* ... start rx seq move from sync rx seq; ... */
: pconn->RxSeqNbrNext; /* ... else start rx seq move from next rx seq. */
}
pconn->RxQ_State = NET_TCP_RX_Q_STATE_CONN;
break;
case NET_TCP_RX_Q_STATE_CONN:
case NET_TCP_RX_Q_STATE_CONN_CLOSING:
seq_nbr = pconn->RxSeqNbrNext;
break;
case NET_TCP_RX_Q_STATE_CONN_CLOSED:
*perr = NET_TCP_ERR_NONE;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_RX_Q_STATE_NONE:
case NET_TCP_RX_Q_STATE_CLOSED:
default:
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
pbuf = (NET_BUF *)pconn->RxQ_Transport_Head;
pbuf_head = (NET_BUF *)pbuf;
pbuf_tail = (NET_BUF *)0;
done = DEF_NO;
while (done == DEF_NO) { /* Srch for ALL segs with consecutive seq nbrs ... */
/* ... from next expected rx seq. */
if (pbuf != (NET_BUF *)0) {
pbuf_hdr = (NET_BUF_HDR *)&pbuf->Hdr;
if (pbuf_hdr->TCP_SeqNbr == seq_nbr) { /* If seq consecutive from next expected rx seq, .. */
seq_nbr_inc = (NET_TCP_SEQ_NBR)pbuf_hdr->TCP_SegLen;
seq_nbr += (NET_TCP_SEQ_NBR)seq_nbr_inc; /* .. update next expected rx seq. */
pbuf_tail = (NET_BUF *)pbuf;
pbuf = (NET_BUF *)pbuf_hdr->NextPrimListPtr;
} else {
done = DEF_YES;
}
} else {
done = DEF_YES;
}
}
/* -------- UPDATE TCP CONN TRANSPORT RX Q -------- */
if (pbuf != (NET_BUF *)0) { /* If transport rx Q NOT empty, update .. */
/* .. transport rx Q head. */
pbuf_hdr->PrevPrimListPtr = (void *)0;
pconn->RxQ_Transport_Head = (NET_BUF *)pbuf;
} else { /* Else clr transport rx Q. */
pconn->RxQ_Transport_Head = (NET_BUF *)0;
pconn->RxQ_Transport_Tail = (NET_BUF *)0;
}
pconn->RxSeqNbrNext = seq_nbr; /* Update next expected rx seq. */
if (pconn->RxQ_State == NET_TCP_RX_Q_STATE_CONN_CLOSING) {
if (pconn->RxSeqNbrNext == pconn->RxSeqNbrLast) { /* If last seq rx'd, close TCP conn rx. */
pconn->RxQ_State = NET_TCP_RX_Q_STATE_CONN_CLOSED;
}
}
/*$PAGE*/
/* -------- MOVE RX'D SEG(S) ONTO APP RX Q -------- */
if (pbuf_tail != (NET_BUF *)0) { /* If avail, move rx'd seg(s) from transport rx Q */
/* ... onto app rx Q (see Note #3b1B). */
pbuf_hdr_head = (NET_BUF_HDR *)&pbuf_head->Hdr;
pbuf_hdr_tail = (NET_BUF_HDR *)&pbuf_tail->Hdr;
pbuf_hdr_head->PrevPrimListPtr = (void *) pconn->RxQ_App_Tail;
pbuf_hdr_tail->NextPrimListPtr = (void *) 0;
if (pconn->RxQ_App_Tail != (NET_BUF *)0) { /* If app rx Q NOT empty, ... */
/* ... append seg(s) @ Q tail (see Note #2b). */
pbuf_q_tail = (NET_BUF *) pconn->RxQ_App_Tail;
pbuf_hdr_q_tail = (NET_BUF_HDR *)&pbuf_q_tail->Hdr;
pbuf_hdr_q_tail->NextPrimListPtr = (void *) pbuf_head;
pconn->RxQ_App_Tail = (NET_BUF *) pbuf_tail;
} else { /* Else add seg(s) to empty app rx Q ... */
pconn->RxQ_App_Head = (NET_BUF *) pbuf_head;
pconn->RxQ_App_Tail = (NET_BUF *) pbuf_tail;
NetOS_TCP_RxQ_Signal(pconn->ID, perr); /* ... & signal non-empty app rx Q (see Note #5). */
if (*perr != NET_TCP_ERR_NONE) {
return;
}
}
} else { /* --------------- CHK RX WIN SIZE ---------------- */
if (pconn->RxWinSizeActual < 1) { /* If avail rx win size zero (see Note #6b2A) ... */
if (pconn->RxQ_App_Head == (NET_BUF *)0) { /* ... & NO avail app rx data (see Note #6b2B); ... */
/* ... inc rx win size (see Note #6b). */
pbuf = pconn->RxQ_Transport_Tail;
if (pbuf != (NET_BUF *)0) { /* If transport rx Q NOT empty; ... */
/* ... remove last q'd seg (see Note #6b2C), ... */
pbuf_hdr = (NET_BUF_HDR *)&pbuf->Hdr;
pbuf_q_tail = (NET_BUF *) pbuf_hdr->PrevPrimListPtr;
if (pbuf_q_tail != (NET_BUF *)0) {
pconn->RxQ_Transport_Tail = (NET_BUF *) pbuf_q_tail;
pbuf_hdr_q_tail = (NET_BUF_HDR *)&pbuf_q_tail->Hdr;
pbuf_hdr_q_tail->NextPrimListPtr = (void *) 0;
} else {
pconn->RxQ_Transport_Head = (NET_BUF *) 0;
pconn->RxQ_Transport_Tail = (NET_BUF *) 0;
NetOS_TCP_RxQ_Clr(pconn->ID, perr);
if (*perr != NET_TCP_ERR_NONE) {
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )pconn->ConnCloseAppFlag,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
return;
}
}
/* ... inc win size by seg's len (see Note #6b2D), */
NetTCP_RxConnWinSizeHandler((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(NET_TCP_WIN_SIZE)pbuf_hdr->TCP_SegLenData,
(NET_TCP_WIN_CODE)NET_TCP_CONN_RX_WIN_SET);
NetTCP_RxPktFree(pbuf); /* ... & free seg (see Note #6b2C). */
} else { /* Else reset TCP conn rx win size (see Note #6b3B).*/
NetTCP_RxConnWinSizeHandler((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(NET_TCP_WIN_SIZE)0,
(NET_TCP_WIN_CODE)NET_TCP_CONN_RX_WIN_RESET);
}
}
}
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerTxWinRemote()
*
* Description : Handle TCP connection's transmit remote host window update.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* ack_code Indicates the received segment's acknowledgement condition :
* --------
* NET_TCP_CONN_RX_ACK_VALID Received acknowledgement number is
* valid for the TCP connection.
*
* NET_TCP_CONN_RX_ACK_DUP Received acknowledgement number is a
* duplicate for the TCP
* connection.
*
* NET_TCP_CONN_RX_ACK_PREV Received acknowledgement number is a
* previous duplicate for the TCP
* connection.
*
* Argument validated in NetTCP_RxPktConnHandler() functions.
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection's transmit remote host
* window successfully handled.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerSeg().
*$PAGE*
* Note(s) : (1) (a) (1) The following sections ... :
*
* (A) RFC #1122, Section 4.2.2.20.(c)
* (B) RFC #1122, Section 4.2.2.20.(f)
*
* (2) ... generalize that "when the connection enters ESTABLISHED STATE, the following
* variables should be set" :
*
* (A) SND.WND <- SEG.WND
* (B) SND.WL1 <- SEG.SEQ
* (C) SND.WL2 <- SEG.ACK
*
* (b) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* ESTABLISHED STATE' generalizes ...
*
* (A) ... that for the following connected states ... :
*
* (1) ESTABLISHED
* (2) FIN-WAIT-1
* (3) CLOSING
* (4) CLOSE-WAIT
* (5) LAST-ACK
* (a) See 'NetTCP_RxPktConnHandlerLastAck() Notes #2d2B'.
*
* (B) ... that "if SND.UNA < SEG.ACK <= SND.NXT, the send window should be updated" :
*
* (1) If ...
*
* (a) ((SND.WL1 < SEG.SEQ) or
* (b) ((SND.WL1 == SEG.SEQ) and
* (c) (SND.WL2 <= SEG.ACK)) ...
*
* (2) ... [then] set ...
*
* (a) SND.WND <- SEG.WND
* (b) SND.WL1 <- SEG.SEQ
* (c) SND.WL2 <- SEG.ACK
*
* (2) (A) RFC #1122, Section 4.2.2.20.(g) amends the transmit window update criteria
* for the segment's acknowledgement to include SND.UNA : "The window should
* updated if SND.UNA <= SEG.ACK <= SND.NXT."
*
* This permits received segments that exactly acknowledge the TCP connection's
* last acknowledged transmit sequence octet to update the transmit window in
* case the remote host's receive window size is increasing or decreasing.
*
* (B) However, it does NOT seem reasonable to update a TCP connection's remote
* transmit window for any received duplicate acknowledgement segment ; i.e.
* an acknowledgement with the exact same sequence numbers & receive window
* size advertisement. Otherwise, each received duplicate acknowledgement
* would incorrectly update the TCP connection's remote transmit window size.
*
* Therefore, it seems reasonable & is assumed that the transmit window MUST
* be updated for received acknowledgements that exactly acknowledge the TCP
* connection's last acknowledged transmit sequence octet, if & only if the
* received segment's receive window size advertisement has increased or
* decreased since the last received acknowledgement segment.
*
* See also RFC #1122, Section 4.2.2.16 & 'NetTCP_TxConnAck() Note #4b1B1'.
*
* See also 'NetTCP_TxConnWinSizeHandlerCongCtrl() Note #3'.
*$PAGE*
* (2) RFC #793 does NOT provide nor suggest any logic to determine/handle sequence number
* comparisons for sequence number windows that overflow the sequence number space.
*
* (a) (1) For example, in order to update the transmit window, a received segment's
* acknowledgement value (SEG.ACK) MUST be greater than or equal to the last
* received acknowledgement number that updated the transmit window (SND.WL2)
* [see Note #1b1B1c] :
*
* (A) SEG.ACK >= SND.WL2
*
* However, if SEG.ACK overflows the sequence number space, it will be MUCH
* less than SND.WL2 until SND.WL2 also overflows :
*
* (B) SEG.ACK << SND.WL2
*
* (2) Therefore, in order to validate a received segment's acknowledgement number
* as valid for updating the TCP connection's transmit window, the following
* unsigned arithmetic comparison MUST be true :
*
* (A) (SND.NXT - SEG.ACK) <= (SND.NXT - SND.WL2)
*
* (b) (1) Alternatively, to update the transmit window, a received segment's sequence
* number (SEG.SEQ) MUST be greater than or equal to the last received sequence
* number that updated the transmit window (SND.WL1) [see Notes #1b1B1a & #1b1B1b] :
*
* (A) SEG.SEQ >= SND.WL1
*
* (2) Therefore, in order to validate a received segment's sequence number as valid
* for updating the TCP connection's transmit window, the following unsigned
* arithmetic comparison MUST be true :
*
* (A) (RCV.NXT + RCV.WND) - SEG.SEQ < (RCV.NXT + RCV.WND) - SND.WL1
*
* See also 'NetTCP_RxPktConnIsValidAck() Note #3'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_RxPktConnHandlerTxWinRemote (NET_TCP_CONN *pconn,
NET_TCP_ACK_CODE ack_code,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
CPU_BOOLEAN tx_win_update;
NET_TCP_SEQ_NBR ack_delta_next;
NET_TCP_SEQ_NBR ack_delta_win_update;
NET_TCP_SEQ_NBR seq_win;
NET_TCP_SEQ_NBR seq_win_delta;
NET_TCP_SEQ_NBR seq_win_update_delta;
/* ------ VALIDATE TCP CONN TX REMOTE WIN UPDATE ------ */
tx_win_update = DEF_NO;
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
/* Validate TCP conn tx Q state. */
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND:
default:
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
tx_win_update = DEF_YES; /* Update tx win ctrls (see Note #1a2). */
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
/* Validate TCP conn tx Q state. */
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND:
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
default:
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
/* Chk tx win ctrls update (see Note #1b1B1). */
/* If seq = last win update seq (see Note #1b1B1b), .. */
if (pbuf_hdr->TCP_SeqNbr == pconn->TxWinUpdateSeqNbr) {
ack_delta_next = (NET_TCP_SEQ_NBR)(pconn->TxSeqNbrNext - pbuf_hdr->TCP_AckNbr);
ack_delta_win_update = (NET_TCP_SEQ_NBR)(pconn->TxSeqNbrNext - pconn->TxWinUpdateAckNbr);
if (ack_delta_next <= ack_delta_win_update) { /* .. (next - ack) <= (next - last win update ack), .. */
/* .. & rx'd ack OR win != last rx'd ack or win, .. */
/* .. update tx win (see Notes #1b1B1c, #1b2B, & #2a2A);*/
tx_win_update = ((pbuf_hdr->TCP_AckNbr != pconn->TxWinUpdateAckNbr ) ||
(pbuf_hdr->TCP_WinSize != pconn->TxWinUpdateWinSize)) ? DEF_YES : DEF_NO;
}
} else {
seq_win = (NET_TCP_SEQ_NBR)(pconn->RxSeqNbrNext + pconn->RxWinSizeActual);
seq_win_delta = (NET_TCP_SEQ_NBR)(seq_win - pbuf_hdr->TCP_SeqNbr);
seq_win_update_delta = (NET_TCP_SEQ_NBR)(seq_win - pconn->TxWinUpdateSeqNbr);
if (seq_win_delta < seq_win_update_delta) { /* .. else if [(next + win) - seq] < .. */
/* .. [(next + win) - last win update seq], .. */
tx_win_update = DEF_YES; /* .. update tx win (see Notes #1b1B1a & #2b2A). */
}
}
break;
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
case NET_TCP_CONN_STATE_CLOSED:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* ---------- UPDATE TCP CONN TX REMOTE WIN ----------- */
if (tx_win_update == DEF_YES) { /* Update tx win ctrls (see Notes #1a2 & #1b1B2). */
NetTCP_TxConnWinSizeHandlerCongCtrl(pconn, pbuf_hdr, ack_code, 0, NET_TCP_CONN_TX_WIN_REMOTE_UPDATE, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerReTxQ()
*
* Description : (1) Handle received valid acknowledgement segments :
*
* (a) Update TCP connection re-transmit queue :
*
* (1) Update TCP connection's unacknowledged transmit sequences See Note #2c1
* (2) Remove acknowledged TCP segments from a TCP See Note #2c2
* connection's re-transmit queue
* (3) Update TCP connection's round-trip time calculations
* (see 'NetTCP_TxConnRTT_RTO_Calc() Note #2a1')
* (4) Update TCP connection's re-transmit timeout See Note #8b
* (5) Free TCP packet buffer(s)
* (6) Start TCP connection's transmit idle timer
* (see 'NetTCP_TxConnTxQ_TimeoutIdleSet() Note #2a1')
*
* (b) Update TCP connection's transmit window(s) :
*
* (1) Increment TCP connection's configured transmit window size
* (2) Increment TCP connection's congetion control transmit window size
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandler().
*
* ack_code Indicates the received segment's acknowledgement condition :
* --------
* NET_TCP_CONN_RX_ACK_VALID Received acknowledgement number is
* valid for the TCP connection.
*
* NET_TCP_CONN_RX_ACK_DUP Received acknowledgement number is a
* duplicate for the TCP connection.
*
* Argument validated in NetTCP_RxPktConnHandler() functions.
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection's re-transmit queue
* successfully handled.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* NET_TCP_ERR_CONN_ACK_INVALID Invalid received segment acknowledgement.
* NET_TCP_ERR_CONN_DATA_INVALID TCP connection re-transmit queue contains
* invalid or improperly sequenced data.
*
* -- RETURNED BY NetTCP_TxConnReTxQ_TimeoutSet() : --
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
*
* - RETURNED BY NetTCP_TxConnWinSizeHandlerCfgd() : -
* NET_TCP_ERR_TX_Q_SIGNAL_FAULT TCP connection transmit queue signal fault.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerSeg().
*$PAGE*
* Note(s) : (2) (a) The following sections ... :
*
* (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check SYN Bit'
* (2) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* ESTABLISHED STATE'
*
* (b) ... generalize that for ...
*
* (1) ... the following synchronization-to-connected state transitions ... :
*
* (A) SYN-RECEIVED to ESTABLISHED
* (B) SYN-SENT to ESTABLISHED
*
* (2) ... & for the following connected states ... :
*
* (A) ESTABLISHED
* (B) FIN-WAIT-1
* (C) CLOSING
* (D) CLOSE-WAIT
* (E) LAST-ACK
* (1) See 'NetTCP_RxPktConnHandlerLastAck() Notes #2d2B'.
*
* (c) ... that ...
*
* (1) "If SND.UNA < SEG.ACK <= SND.NXT, SND.UNA should be advanced to equal SEG.ACK" :
*
* (A) SND.UNA <- SEG.ACK
*
* (2) "Any segments on the retransmission queue which are thereby entirely acknowledged
* are removed."
*
* (3) A TCP connection's re-transmit queue SHOULD be updated ONLY by valid, non-duplicate
* received acknowledgement segments.
*
* (4) Since valid received acknowledgement segments update a TCP connection's last
* unacknowledged transmit sequence number ('TxSeqNbrUnackd'), any controls &/or
* calculations based on the TCP connection's last unacknowledged transmit sequence
* number MUST use the saved/previous value of the TCP connection's last unacknowledged
* transmit sequence number ('TxSeqNbrUnackdPrev').
*
* (5) Since segments enqueued to a TCP connection's re-transmit queue have already been
* transmitted to the remote host & reported to the application layer as having been
* transmitted, any TCP connection whose re-transmit queue becomes corrupted MUST be
* closed to prevent the further transmit of corrupted data.
*
* (6) Although network packets are NOT required to ensure that network packet headers or
* data will locate on CPU word-aligned addresses; many processors may be more efficient
* & may even REQUIRE that memory transfers occur on CPU word-aligned addresses [e.g.
* processors or NICs with direct memory access (DMA) capability].
*
* Therefore, to ensure appropriate CPU word alignment; any segment in a TCP connection's
* re-transmit queue whose transmit sequences are partially acknowledged MUST acknowledge
* an exact number of sequences such that the remaining sequences are aligned on a CPU
* word-aligned address.
*
* (a) Since RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check
* Sequence Number' states that in the "SYN-RECEIVED, ESTABLISHED STATE,
* FIN-WAIT-1 STATE, FIN-WAIT-2 STATE, CLOSE-WAIT STATE, CLOSING STATE,
* LAST-ACK STATE, TIME-WAIT STATE" that "if a segment's contents straddle
* the boundary between old and new, only the new parts should be processed";
* any data segments partially acknowledged in a TCP connections' re-transmit
* queue may be re-transmitted in full or in part since the retransmission of
* previously received data is not processed.
*$PAGE*
* (7) (a) RFC #1122, Section 4.2.3.5 states that "excessive retransmission of the same
* segment by TCP indicates some failure of the remote host or the Internet path
* ... When the number of transmissions of the same segment reaches a threshold
* ... close the connection."
*
* (b) However, any segment in a TCP connection's re-transmit queue whose transmit
* sequences are partially acknowledged SHOULD NOT be considered the same segment
* for purposes of excessive retransmission.
*
* Therefore, it seems reasonable that whenever a TCP connection's re-transmit
* queue segment's transmit sequences are partially acknowledged; that segment's
* re-transmit counter should be reset.
*
* See also 'NetTCP_TxConnReTxQ() Note #3'.
*
* (8) (a) (1) (A) RFC #793, Section 3.7 'Data Communication : Retransmission Timeout' states
* that "the Round Trip Time (RTT) ... [is] the elapsed time between" :
*
* (1) "sending a data octet with a particular sequence number and" ...
* (2) "receiving an acknowledgment that covers that sequence number" ...
* (3) "(segments sent do not have to match segments received)".
*
* (B) (1) RFC #2988, Section 3 adds that :
*
* (a) "Traditionally, TCP implementations have taken one RTT measurement at
* a time (typically once per RTT)."
*
* (2) RFC #2988, Section 1 states that "in some situations it may be beneficial
* for a TCP sender to be more conservative than the algorithms detailed in
* this document allow. However, a TCP MUST NOT be more aggressive than the
* ... algorithms allow".
*
* See also 'NetTCP_TxConnRTT_RTO_Calc() Note #2a2'.
*
* (2) RFC #2988, Section 3 states that "TCP MUST use Karn's algorithm ... for taking
* RTT samples. That is, RTT samples MUST NOT be made using segments that were
* retransmitted (and thus for which it is ambiguous whether the reply was for
* the first instance of the packet or a later instance)".
*
* (A) (1) To determine if any segment(s) from a TCP connection's re-transmit queue
* have been re-transmitted (i.e. transmitted more than once), the TCP
* connection's transmit unacknowledged & un-re-transmitted sequence numbers
* are compared :
*
* (a) If NO sequences in the TCP connection's re-transmit queue have been
* re-transmitted, the TCP connection's transmit unacknowledged &
* un-re-transmitted sequence numbers will be equal.
*
* (b) If ANY sequences in the TCP connection's re-transmit queue have been
* re-transmitted, the TCP connection's transmit unacknowledged
* sequence number will be less than the un-re-transmitted sequence
* number.
*
* (2) If a received acknowledgement fully acknowledges ALL re-transmitted
* segment(s) from a TCP connection's re-transmit queue, the TCP connection
* advances its un-re-transmitted sequence number to the received segment's
* acknowledgement sequence number.
*
* (B) Although RTT measurements could be calculated for ALL transmitted segments;
* to simplify implementation of Karn's algorithm :
*
* (1) Only a single RTT measurement is calculated, ... See Note #8a1B1a
* (2) (a) per TCP acknowledgement received ... See Note #8a1A2
* AND
* (b) the segment at the head of a TCP connection's
* re-transmit queue. See Note #8a1A1
*
* See also 'NetTCP_TxConnReTxQ() Note #4'.
*
* (b) RFC #2988, Section 5 states that "the following is the RECOMMENDED algorithm for
* managing the retransmission timer" :
*
* (2) "When all outstanding data has been acknowledged, turn off the retransmission
* timer."
*
* (3) "When an ACK is received that acknowledges new data, restart the retransmission
* timer so that it will expire after RTO seconds (for the current value of RTO)."
*
* See also 'NetTCP_TxConnReTxQ() Note #2b1A'.
*$PAGE*
* (9) RFC #793 does NOT provide nor suggest any logic to determine/handle sequence number
* comparisons for sequence number windows that overflow the sequence number space.
*
* (a) For example, the next sequence octet to transmit (SND.NXT) is typically greater
* than or equal to any received segment's acknowledgement number (SEG.ACK) :
*
* (1) SND.NXT >= SEG.ACK
*
* However, if SND.NXT overflows the sequence number space, it will be MUCH less
* than SEG.ACK until SEG.ACK also overflows :
*
* (2) SND.NXT << SEG.ACK
*
* (b) (1) Therefore, in order to determine if a received segment's acknowledgement value
* fully acknowledges previously transmitted segment(s) in the TCP connection's
* re-transmit queue, the following unsigned arithmetic comparison MUST be checked :
*
* (A) (SND.NXT - SEG.ACK) <= SND.NXT - (ReTxQCur.SeqNbr + ReTxQCur.SegLen)
*
* See also 'NetTCP_RxPktConnIsValidAck() Note #3a2'.
*
* (2) In order to determine if a received segment's acknowledgement partially
* acknowledges a previously received segment in the TCP connection's re-
* transmit queue, the following unsigned arithmetic comparison MUST be checked :
*
* (A) (ReTxQCur.SeqNbr + ReTxQCur.SegLen) - SEG.ACK < ReTxQCur.SegLen
*
* See also 'NetTCP_RxPktConnHandlerRxQ_Conn() Note #4c2'.
*
* (3) In order to determine if a received segment's acknowledgement should
* advance the TCP connection's un-re-transmitted sequence number(s), the
* following unsigned arithmetic comparison MUST be true :
*
* (A) (SEG.ACK - ReTxQ.UnReTxdSeqNbr) <= (SND.NXT - ReTxQ.UnReTxdSeqNbr)
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_RxPktConnHandlerReTxQ (NET_TCP_CONN *pconn,
NET_TCP_ACK_CODE ack_code,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NET_TCP_SEQ_NBR seq_nbr_cur;
NET_TCP_SEQ_NBR seq_nbr_delta;
NET_TCP_SEQ_NBR seq_nbr_next_qd;
#endif
NET_TCP_SEQ_NBR ack_delta_seq;
NET_TCP_SEQ_NBR ack_delta_seq_align;
NET_TCP_SEQ_NBR ack_delta_seq_align_offset;
NET_TCP_SEQ_NBR ack_delta_unretxd;
NET_TCP_SEQ_NBR ack_delta_next;
NET_TCP_SEQ_NBR seq_delta_unretxd;
NET_TCP_SEQ_NBR seq_delta_next;
NET_TCP_SEQ_NBR seq_nbr_next;
NET_TCP_SEQ_NBR seq_nbr;
NET_TCP_SEG_SIZE seg_len;
NET_TCP_SEG_SIZE seg_len_tot;
NET_TCP_SEG_SIZE seg_len_data;
NET_TCP_SEG_SIZE seg_len_data_tot;
NET_TCP_TX_RTT_TS_MS seg_rtt_ts_txd_ms;
NET_TCP_TX_RTT_TS_MS seg_rtt_ts_rxd_ms;
CPU_BOOLEAN segs_re_txd;
CPU_BOOLEAN seqs_ackd;
CPU_BOOLEAN done;
CPU_BOOLEAN tmr_update;
NET_BUF *pbuf_q;
NET_BUF *pbuf_q_head;
NET_BUF *pbuf_q_prev;
NET_BUF *pbuf_q_next;
NET_BUF_HDR *pbuf_q_hdr;
NET_BUF_HDR *pbuf_q_head_hdr;
NET_BUF_HDR *pbuf_q_prev_hdr;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ---------------- VALIDATE TCP CONN ----------------- */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
break;
case NET_TCP_CONN_RX_ACK_NONE:
case NET_TCP_CONN_RX_ACK_INVALID:
case NET_TCP_CONN_RX_ACK_DUP:
case NET_TCP_CONN_RX_ACK_PREV:
default:
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND:
default:
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND:
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
case NET_TCP_CONN_RX_ACK_DUP:
break;
case NET_TCP_CONN_RX_ACK_NONE:
case NET_TCP_CONN_RX_ACK_INVALID:
case NET_TCP_CONN_RX_ACK_PREV:
default:
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
default:
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
case NET_TCP_CONN_STATE_CLOSED:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
/*$PAGE*/
/* ------------- UPDATE UNACK'D TX SEQ(S) ------------- */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
seq_nbr_cur = (NET_TCP_SEQ_NBR)pconn->TxSeqNbrUnAckd;
seq_nbr_delta = (NET_TCP_SEQ_NBR)pconn->TxSeqNbrUnAckdAlignDelta;
#endif
/* Save prev tx unack'd seq nbr (see Note #4). */
pconn->TxSeqNbrUnAckdPrev = (NET_TCP_SEQ_NBR)pconn->TxSeqNbrUnAckd;
/* Ack prev'ly unack'd tx segs (see Note #2c1). */
pconn->TxSeqNbrUnAckd = (NET_TCP_SEQ_NBR)pbuf_hdr->TCP_AckNbr;
if (pconn->TxQ_State == NET_TCP_TX_Q_STATE_CONN_CLOSING) {
if (pconn->TxSeqNbrUnAckd == pconn->TxSeqNbrLast) { /* If last tx'd seq ack'd, close TCP conn tx. */
pconn->TxQ_State = NET_TCP_TX_Q_STATE_CONN_CLOSED;
}
}
/* --------- REMOVE ACK'D SEG(S) FROM RE-TX Q --------- */
if (ack_code != NET_TCP_CONN_RX_ACK_VALID) { /* If ack NOT valid, non-dup ack; ... */
*perr = NET_TCP_ERR_NONE; /* ... do NOT update re-tx Q (see Note #3). */
return;
}
pbuf_q_head = (NET_BUF *)pconn->ReTxQ_Head;
pbuf_q_prev = (NET_BUF *)0;
pbuf_q = (NET_BUF *)pbuf_q_head;
seg_len_tot = 0;
seg_len_data_tot = 0;
/* Chk re-tx'd seg(s) [see Notes #8a2A1 & #4]. */
segs_re_txd = (pconn->TxSeqNbrUnAckdPrev == pconn->TxSeqNbrUnReTxd)
? DEF_NO : DEF_YES;
seqs_ackd = DEF_NO;
done = DEF_NO;
while ((pbuf_q != (NET_BUF *)0) && /* While NOT @ re-tx Q tail, ... */
(done == DEF_NO)) { /* ... srch for ack'd tx segs to remove (see Note #2c2).*/
pbuf_q_hdr = (NET_BUF_HDR *)&pbuf_q->Hdr;
pbuf_q_next = (NET_BUF *) pbuf_q_hdr->NextPrimListPtr;
seq_nbr = (NET_TCP_SEQ_NBR ) pbuf_q_hdr->TCP_SeqNbr;
seg_len = (NET_TCP_SEG_SIZE) pbuf_q_hdr->TCP_SegLen;
seg_len_data = (NET_TCP_SEG_SIZE) seg_len;
if (pbuf_q_hdr->TCP_SegSync == DEF_YES) { /* If sync seg ... */
if (seg_len_data >= NET_TCP_SEG_LEN_SYNC) { /* ... & seg len >= sync seg len, ... */
seg_len_data -= NET_TCP_SEG_LEN_SYNC; /* ... dec data seg len by sync seg len. */
}
}
if (pbuf_q_hdr->TCP_SegClose == DEF_YES) { /* If close seg ... */
if (seg_len_data >= NET_TCP_SEG_LEN_CLOSE) { /* ... & seg len >= close seg len, ... */
seg_len_data -= NET_TCP_SEG_LEN_CLOSE; /* ... dec data seg len by close seg len. */
}
}
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
seq_nbr_next_qd = seq_nbr + pconn->TxSeqNbrUnAckdAlignDelta;
if (seq_nbr_cur != seq_nbr_next_qd) { /* If next q'd seg's seq nbr NOT consecutive, ... */
/* ... close TCP conn (see Note #5). */
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_DATA_INVALID;
return;
}
#endif
/* Chk if rx'd seg acks cur re-tx Q seg. */
ack_delta_next = (NET_TCP_SEQ_NBR)(pconn->TxSeqNbrNext - pbuf_hdr->TCP_AckNbr);
seq_nbr_next = (NET_TCP_SEQ_NBR)(seq_nbr + seg_len);
seq_delta_next = (NET_TCP_SEQ_NBR)(pconn->TxSeqNbrNext - seq_nbr_next);
if (ack_delta_next <= seq_delta_next) { /* If seg fully acks cur re-tx Q seg (see Note #9b1A), */
pbuf_q_prev = pbuf_q;
pbuf_q = pbuf_q_next; /* ... adv to next re-tx Q seg. */
pconn->TxSeqNbrUnAckdAlignDelta = 0;
seg_len_tot += seg_len;
seg_len_data_tot += seg_len_data;
seqs_ackd = DEF_YES;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
seq_nbr_cur += (NET_TCP_SEQ_NBR)(seg_len - seq_nbr_delta);
seq_nbr_delta = (NET_TCP_SEQ_NBR) 0;
#endif
/*$PAGE*/
} else { /* Else chk partial re-tx Q seg ack (see Note #9b2A) : */
ack_delta_seq = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_AckNbr - seq_nbr);
if (ack_delta_seq == 0) { /* If NO seqs ack'd for cur re-tx Q seg, ... */
; /* ... do NOT update seg. */
} else if (ack_delta_seq < seg_len) { /* If SOME seqs ack'd for cur re-tx Q seg, ... */
/* Align partial ack to word boundary (see Note #6). */
ack_delta_seq_align_offset = (NET_TCP_SEQ_NBR )(ack_delta_seq % sizeof(CPU_ALIGN));
ack_delta_seq_align = (NET_TCP_SEQ_NBR )(ack_delta_seq - ack_delta_seq_align_offset);
pconn->TxSeqNbrUnAckdAlignDelta = (NET_TCP_SEQ_NBR ) ack_delta_seq_align_offset;
/* ... update cur seg's seq nbr & seg len ... */
pbuf_q_hdr->TCP_SeqNbr += (CPU_INT32U ) ack_delta_seq_align;
pbuf_q_hdr->TCP_SegLen -= (CPU_INT16U ) ack_delta_seq_align;
pbuf_q_hdr->TCP_SegLenData -= (CPU_INT16U ) ack_delta_seq_align;
seg_len_tot += (NET_TCP_SEG_SIZE) ack_delta_seq_align;
seg_len_data_tot += (NET_TCP_SEG_SIZE) ack_delta_seq_align;
/* ... & update TCP tx buf ctrls. */
pbuf_q_hdr->DataIx += (CPU_INT16U ) ack_delta_seq_align;
pbuf_q_hdr->DataLen -= (NET_BUF_SIZE ) ack_delta_seq_align;
pbuf_q_hdr->TotLen -= (NET_BUF_SIZE ) ack_delta_seq_align;
pbuf_q_hdr->TCP_SegReTxCtr = 0; /* Reset re-tx ctr (see Note #7b). */
seqs_ackd = DEF_YES;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
} else { /* Else fully-ack'd-seg chk failed?; close TCP conn? */
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
*perr = NET_TCP_ERR_CONN_DATA_INVALID;
return;
#endif
}
done = DEF_YES;
}
}
/* --------------- UPDATE TCP CONN RTO ---------------- */
if (seqs_ackd == DEF_YES) { /* If ANY re-tx Q seq(s) ack'd .. */
if (segs_re_txd == DEF_NO) { /* .. & NO re-tx Q seg(s) re-tx'd (see Note #8a2); .. */
/* .. get tx'd seg RTT ts (see Note #8a1A1) .. */
pbuf_q_head_hdr = (NET_BUF_HDR *)&pbuf_q_head->Hdr;
seg_rtt_ts_txd_ms = (NET_TCP_TX_RTT_TS_MS) pbuf_q_head_hdr->TCP_RTT_TS_Txd_ms;
/* .. get rx'd ack RTT ts (see Note #8a1A2) .. */
seg_rtt_ts_rxd_ms = (NET_TCP_TX_RTT_TS_MS) pbuf_hdr->TCP_RTT_TS_Rxd_ms;
/* .. & calc/update RTT/RTO (see Note #1a3). */
NetTCP_TxConnRTT_RTO_Calc(pconn, NET_TCP_CONN_TX_RTT_CALC, seg_rtt_ts_txd_ms, seg_rtt_ts_rxd_ms);
}
ack_delta_unretxd = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_AckNbr - pconn->TxSeqNbrUnReTxd);
seq_delta_unretxd = (NET_TCP_SEQ_NBR)(pconn->TxSeqNbrNext - pconn->TxSeqNbrUnReTxd);
if (ack_delta_unretxd <= seq_delta_unretxd) { /* If (ack - un-re-tx'd) < (next - un-re-tx'd), ... */
/* ... acks ALL re-tx'd seg(s) [see Note #9b3A]; */
pconn->TxSeqNbrUnReTxd = pbuf_hdr->TCP_AckNbr; /* ... adv un-re-tx'd seq(s) to ack (see Note #8a2A2).*/
}
}
/*$PAGE*/
/* ------------- UPDATE TCP CONN RE-TX Q -------------- */
tmr_update = seqs_ackd; /* Update re-tx Q tmr if ANY re-tx Q seqs ack'd ... */
/* ... (see Note #8b3). */
if (pbuf_q != pbuf_q_head) { /* If ANY re-tx Q segs fully ack'd, update re-tx Q. */
if (pbuf_q != (NET_BUF *)0) { /* If re-tx Q still NOT empty, . .. */
pbuf_q_prev_hdr = (NET_BUF_HDR *)&pbuf_q_prev->Hdr;
pbuf_q_prev_hdr->NextPrimListPtr = (void *) 0;
/* ... update re-tx Q head. */
pconn->ReTxQ_Head = (NET_BUF *) pbuf_q;
pbuf_q_hdr->PrevPrimListPtr = (void *) 0;
} else { /* Else clr re-tx Q. */
pconn->ReTxQ_Head = (NET_BUF *)0;
pconn->ReTxQ_Tail = (NET_BUF *)0;
if (pconn->ReTxQ_Tmr != (NET_TMR *)0) { /* Free re-tx Q tmr (see Note #8b2). */
NetTmr_Free(pconn->ReTxQ_Tmr);
}
pconn->ReTxQ_Tmr = (NET_TMR *)0;
tmr_update = DEF_NO;
NetTCP_TxConnTxQ_TimeoutIdleSet(pconn); /* Start tx Q idle tmr (see Note #1a6). */
}
NetTCP_TxPktFree(pbuf_q_head); /* Free ALL fully ack'd seg pkt buf(s). */
}
if (tmr_update == DEF_YES) { /* Update re-tx Q tmr. */
NetTCP_TxConnReTxQ_TimeoutSet(pconn, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
}
/* ----------- UPDATE TCP CONN TX WIN SIZES ----------- */
/* Inc TCP conn's tx win sizes (see Note #1b). */
NetTCP_TxConnWinSizeHandlerCfgd((NET_TCP_CONN *)pconn,
(NET_TCP_WIN_SIZE)seg_len_data_tot,
(NET_TCP_WIN_CODE)NET_TCP_CONN_TX_WIN_INC,
(NET_ERR *)perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
NetTCP_TxConnWinSizeHandlerCongCtrl((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(NET_TCP_ACK_CODE)NET_TCP_CONN_RX_ACK_NONE,
(NET_TCP_WIN_SIZE)seg_len_data_tot,
(NET_TCP_WIN_CODE)NET_TCP_CONN_TX_WIN_INC,
(NET_ERR *)perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerListenQ_IsAvail()
*
* Description : Check if application layer listen queue is available to queue a new connection.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandlerListen().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE Application layer listen queue successfully
* checked; check return value for listen
* queue availablity.
*
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_ID Invalid application connection.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
* NET_CONN_ERR_INVALID_FAMILY Invalid network connection family.
*
* ---- RETURNED BY NetConn_ID_AppGet() : ----
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_CONN_ERR_INVALID_CONN Invalid network connection number.
* NET_CONN_ERR_NOT_USED Network connection NOT currently used.
*
* Return(s) : DEF_YES, if application connection's listen queue is available to queue a new connection.
*
* DEF_NO, otherwise.
*
* Caller(s) : NetTCP_RxPktConnHandlerListen().
*
* Note(s) : (1) (a) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 18.11, Pages 257-258 states
* that :
*
* (1) "Each listening end point has a fixed length queue of connections that have been
* accepted by TCP (i.e., the three-way handshake is complete), but not yet accepted
* by the application."
*
* (2) "The application specifies a limit to this queue, commonly called the backlog" :
*
* (A) "This backlog must be between 0 and 5, inclusive."
* (B) "(Most applications specify the maximum value of 5.)"
*
* (3) "When a connection request arrives (i.e., the SYN segment), ... the current number
* of connections already queued for this listening end point [is checked] to see
* whether to accept the connection or not."
*
* (4) "If there is room on this listening end point's queue for this new connection, ...
* the TCP module ACKs the SYN and completes the connection."
*
* (5) "If there is not room on the queue for the new connection" ... :
*
* (A) "TCP just ignores the received SYN."
* (B) "Nothing is sent back (i.e., no RST segment)."
*
* (b) (A) Wright/Stevens, TCP/IP Illustrated, Volume 2, 3rd Printing, Section 15.9, Page 455
* reiterates that :
*
* (2) A "listen ... socket ... specifies a limit on the number of connections that can
* be queued on the socket," ...
*
* (5) "after which the socket layer refuses to queue additional connection requests.
* When this occurs, TCP ignores incoming connection requests."
*
* (B) Wright/Stevens, TCP/IP Illustrated, Volume 2, 3rd Printing, Section 28.2, Page 930
* also states that :
*
* (5) (A) "By silently dropping the segment" ...
* (B) "and not replying with an RST," ...
* (C) "The client's connection request should time out, causing the client to
* retransmit the SYN."
*
* (C) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 18.11, Pages 259-260
* summarizes that :
*
* (5) (A) "TCP ignores the incoming SYN when the queue is full," ...
* (B) "and doesn't respond with an RST," ...
*
* (C) (1) "because ... this condition could change in a short while ... [and] by
* ignoring the SYN, the server forces the client TCP to re-transmit the
* SYN later, hoping that the queue will then have room for the new
* connection".
*
* (2) Whereas page 259-260 counters that "if the server's TCP responded with
* a reset, the client's active open would abort".
*
* See also 'net_sock.c NetSock_ListenQ_IsAvail() Note #2'.
*
* (2) The 'NET_CONN_CFG_FAMILY' pre-processor 'else'-conditional code will never be compiled/linked
* since 'net_conn.h' ensures that the family type configuration constant (NET_CONN_CFG_FAMILY)
* is configured with an appropriate family type value (see 'net_conn.h CONFIGURATION ERRORS').
* The 'else'-conditional code is included for completeness & as an extra precaution in case
* 'net_conn.h' is incorrectly modified.
*********************************************************************************************************
*/
/*$PAGE*/
static CPU_BOOLEAN NetTCP_RxPktConnHandlerListenQ_IsAvail (NET_TCP_CONN *pconn,
NET_ERR *perr)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_CONN_ID conn_id;
NET_CONN_ID conn_id_app;
CPU_BOOLEAN q_avail;
NET_ERR err;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ------------- VALIDATE TCP CONN STATE -------------- */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return (DEF_NO); /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_LISTEN:
break;
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return (DEF_NO); /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return (DEF_NO); /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
conn_id = pconn->ID_Conn;
conn_id_app = NetConn_ID_AppGet(conn_id, perr); /* Get TCP listen conn's app conn id. */
if (*perr != NET_CONN_ERR_NONE) {
return (DEF_NO);
}
if (conn_id_app == NET_CONN_ID_NONE) {
*perr = NET_TCP_ERR_INVALID_CONN_ID;
return (DEF_NO);
}
/* -------------- CHK APP LISTEN Q AVAIL -------------- */
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
q_avail = NetSock_ListenQ_IsAvail((NET_SOCK_ID) conn_id_app,
(NET_ERR *)&err);
#else /* See Note #2. */
(void)&q_avail; /* Prevent compiler warnings. */
(void)&err;
*perr = NET_CONN_ERR_INVALID_FAMILY;
return (DEF_NO);
#endif
*perr = NET_TCP_ERR_NONE;
return (q_avail);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerSignalConn()
*
* Description : (1) Signal application layer that TCP/transport layer connection's state is now connected :
*
* (a) From passive SYN-RECEIVED state, signal application layer that
* connection request received; connection accept now available.
*
* (b) From active SYN-RECEIVED or SYN-SENT states, signal application layer that
* connection request complete.
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandlerSyncRxd(),
* NetTCP_RxPktConnHandlerSyncTxd().
*
* state Current TCP connection state.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE Application layer successfully signaled.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_FAIL Application layer signal failed.
* NET_TCP_ERR_INVALID_CONN_ID Invalid application connection.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
* NET_CONN_ERR_INVALID_FAMILY Invalid network connection family.
*
* --- RETURNED BY NetConn_ID_AppGet() : ----
* - RETURNED BY NetConn_ID_AppCloneGet() : -
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_CONN_ERR_INVALID_CONN Invalid network connection number.
* NET_CONN_ERR_NOT_USED Network connection NOT currently used.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerSyncRxd(),
* NetTCP_RxPktConnHandlerSyncTxd().
*
* Note(s) : (2) The 'NET_CONN_CFG_FAMILY' pre-processor 'else'-conditional code will never be compiled/linked
* since 'net_conn.h' ensures that the family type configuration constant (NET_CONN_CFG_FAMILY)
* is configured with an appropriate family type value (see 'net_conn.h CONFIGURATION ERRORS').
* The 'else'-conditional code is included for completeness & as an extra precaution in case
* 'net_conn.h' is incorrectly modified.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_RxPktConnHandlerSignalConn (NET_TCP_CONN *pconn,
NET_TCP_CONN_STATE state,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_CONN_ID conn_id;
NET_CONN_ID conn_id_app;
NET_ERR err;
CPU_BOOLEAN err_conn;
conn_id = pconn->ID_Conn;
/* ------------------- SIGNAL CONN -------------------- */
switch (state) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE: /* See Note #1a. */
/* Get app conn id clone. */
conn_id_app = NetConn_ID_AppCloneGet(conn_id, perr);
if (*perr != NET_CONN_ERR_NONE) {
return;
}
if (conn_id_app == NET_CONN_ID_NONE) {
*perr = NET_TCP_ERR_INVALID_CONN_ID;
return;
}
/* Signal app conn accept. */
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
NetSock_ConnSignalAccept((NET_SOCK_ID) conn_id_app,
(NET_CONN_ID) conn_id,
(NET_ERR *)&err);
*perr = (err != NET_SOCK_ERR_NONE) ? NET_TCP_ERR_CONN_FAIL
: NET_TCP_ERR_NONE;
#else /* See Note #2. */
(void)&err; /* Prevent compiler warning. */
*perr = NET_CONN_ERR_INVALID_FAMILY;
return;
#endif
if (*perr != NET_TCP_ERR_NONE) {
return;
}
break;
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE: /* See Note #1b. */
case NET_TCP_CONN_STATE_SYNC_TXD:
/* Get app conn id. */
conn_id_app = NetConn_ID_AppGet(conn_id, perr);
if (*perr != NET_CONN_ERR_NONE) {
return;
}
if (conn_id_app == NET_CONN_ID_NONE) {
*perr = NET_TCP_ERR_INVALID_CONN_ID;
return;
}
/* Signal app conn req. */
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
NetSock_ConnSignalReq((NET_SOCK_ID) conn_id_app,
(NET_ERR *)&err);
*perr = (err != NET_SOCK_ERR_NONE) ? NET_TCP_ERR_CONN_FAIL
: NET_TCP_ERR_NONE;
#else /* See Note #2. */
(void)&err; /* Prevent compiler warning. */
*perr = NET_CONN_ERR_INVALID_FAMILY;
return;
#endif
if (*perr != NET_TCP_ERR_NONE) {
return;
}
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_SYNC_RXD: /* See Notes #1a & #1b. */
/* Get app conn id. */
err_conn = DEF_NO;
conn_id_app = NetConn_ID_AppGet(conn_id, perr);
if (*perr != NET_CONN_ERR_NONE) {
err_conn = DEF_YES;
}
if (conn_id_app == NET_CONN_ID_NONE) {
err_conn = DEF_YES;
}
if (err_conn == DEF_YES) { /* If app conn id get failed, get app conn id clone. */
conn_id_app = NetConn_ID_AppCloneGet(conn_id, perr);
if (*perr != NET_CONN_ERR_NONE) {
return;
}
if (conn_id_app == NET_CONN_ID_NONE) {
*perr = NET_TCP_ERR_INVALID_CONN_ID;
return;
}
}
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
/* Signal app conn req. */
NetSock_ConnSignalReq((NET_SOCK_ID) conn_id_app,
(NET_ERR *)&err);
*perr = (err != NET_SOCK_ERR_NONE) ? NET_TCP_ERR_CONN_FAIL
: NET_TCP_ERR_NONE;
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* Signal app conn accept. */
NetSock_ConnSignalAccept((NET_SOCK_ID) conn_id_app,
(NET_CONN_ID) conn_id,
(NET_ERR *)&err);
*perr = (err != NET_SOCK_ERR_NONE) ? NET_TCP_ERR_CONN_FAIL
: NET_TCP_ERR_NONE;
#else /* See Note #2. */
(void)&err; /* Prevent compiler warning. */
*perr = NET_CONN_ERR_INVALID_FAMILY;
return;
#endif
if (*perr != NET_TCP_ERR_NONE) {
return;
}
break;
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnHandlerSignalClose()
*
* Description : Signal application layer that TCP/transport layer connection's state is now closed.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_ConnReqClose(),
* NetTCP_RxPktConnHandlerFinWait1(),
* NetTCP_RxPktConnHandlerClosing(),
* NetTCP_RxPktConnHandlerLastAck().
*
* data_avail Indicate whether application data is still available on the TCP connection's
* application receive queue :
*
* DEF_YES Application data is available on the
* closing TCP connection's application
* receive queue.
* DEF_NO Application data is NOT available for the
* closing TCP connection's application
* receive queue.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE Application layer successfully signaled.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_FAIL Application layer signal failed.
* NET_TCP_ERR_INVALID_CONN_ID Invalid application connection.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
* NET_CONN_ERR_INVALID_FAMILY Invalid network connection family.
*
* -- RETURNED BY NetConn_ID_AppGet() : ---
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_CONN_ERR_INVALID_CONN Invalid network connection number.
* NET_CONN_ERR_NOT_USED Network connection NOT currently used.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_ConnReqClose(),
* NetTCP_RxPktConnHandlerFinWait1(),
* NetTCP_RxPktConnHandlerClosing(),
* NetTCP_RxPktConnHandlerLastAck().
*
* Note(s) : (1) (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* FIN-WAIT-2 STATE' states that "if the retransmission queue is empty, the user's
* CLOSE can be acknowledged".
*
* (b) However, TCP connection should signal the application layer that "the user's close
* [is] acknowledged" whenever its re-transmit queue becomes &/or is empty :
*
* (1) Transition from LISTEN to CLOSED
* (2) Transition from SYN-SENT to CLOSED
*
* (3) Transition from FIN-WAIT-1 to ... See also 'NetTCP_RxPktConnHandlerFinWait1()
* Note #2d2B2'
* (A) FIN-WAIT-2
* (B) TIME-WAIT
*
* (4) Transition from CLOSING to TIME-WAIT See also 'NetTCP_RxPktConnHandlerClosing()
* Note #2d2B2a2'
*
* (5) Transition from LAST-ACK to CLOSED
*
* (2) Once an application connection has been signaled of its close, the application connection is
* responsible for closing its remaining connection(s).
*
* See also 'NetTCP_ConnCloseHandler() Note #2b1B'.
*
* (3) The 'NET_CONN_CFG_FAMILY' pre-processor 'else'-conditional code will never be compiled/linked
* since 'net_conn.h' ensures that the family type configuration constant (NET_CONN_CFG_FAMILY)
* is configured with an appropriate family type value (see 'net_conn.h CONFIGURATION ERRORS').
* The 'else'-conditional code is included for completeness & as an extra precaution in case
* 'net_conn.h' is incorrectly modified.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_RxPktConnHandlerSignalClose (NET_TCP_CONN *pconn,
CPU_BOOLEAN data_avail,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_CONN_ID conn_id;
NET_CONN_ID conn_id_app;
NET_ERR err;
/* Get conn id's. */
conn_id = pconn->ID_Conn;
conn_id_app = NetConn_ID_AppGet(conn_id, perr);
if (*perr != NET_CONN_ERR_NONE) {
return;
}
if (conn_id_app == NET_CONN_ID_NONE) {
*perr = NET_TCP_ERR_INVALID_CONN_ID;
return;
}
/* ------------- VALIDATE TCP CONN STATE -------------- */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_LISTEN: /* See Note #1b1. */
case NET_TCP_CONN_STATE_SYNC_TXD: /* See Note #1b2. */
case NET_TCP_CONN_STATE_FIN_WAIT_1: /* See Note #1b3. */
case NET_TCP_CONN_STATE_CLOSING: /* See Note #1b4. */
case NET_TCP_CONN_STATE_LAST_ACK: /* See Note #1b5. */
break;
case NET_TCP_CONN_STATE_NONE:
case NET_TCP_CONN_STATE_CLOSED:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ------------------- SIGNAL CLOSE ------------------- */
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
/* Signal app conn close. */
NetSock_ConnSignalClose((NET_SOCK_ID) conn_id_app,
(CPU_BOOLEAN) data_avail,
(NET_ERR *)&err);
*perr = (err != NET_SOCK_ERR_NONE) ? NET_TCP_ERR_CONN_FAIL
: NET_TCP_ERR_NONE;
#else /* See Note #3. */
(void)&data_avail; /* Prevent compiler warnings. */
(void)&err;
*perr = NET_CONN_ERR_INVALID_FAMILY;
return;
#endif
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* Clr app close flag; ... */
pconn->ConnCloseAppFlag = DEF_NO; /* ... app closes rem'ing conn(s) [see Note #2]. */
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnIsValidSeq()
*
* Description : Validate a received segment's sequence number with current TCP connection.
*
* Argument(s) : pconn Pointer to a TCP connection.
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE Sequence number successfully validated;
* check return value.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* Return(s) : NET_TCP_CONN_RX_SEQ_INVALID, if received sequence number invalid for the TCP connection.
*
* NET_TCP_CONN_RX_SEQ_VALID, if received sequence number valid for the TCP connection.
*
* NET_TCP_CONN_RX_SEQ_SYNC_INVALID, if received sequence number is an invalid synchronization
* for the TCP connection.
*
* NET_TCP_CONN_RX_SEQ_SYNC, if received sequence number is a valid synchronization
* for the TCP connection.
*
* Caller(s) : various.
*
* Note(s) : (1) Validate received TCP connection sequence numbers :
*
* (A) Some TCP receive sequence number validation logic implemented in previous
* functions; include duplicate validation logic in NetTCP_RxPktConnIsValidSeq()
* only if debug/validation code is enabled (i.e. NET_ERR_CFG_ARG_CHK_DBG_EN is
* DEF_ENABLED in 'net_cfg.h').
*
* (a) RFC #793, Section 3.4 'Establishing a Connection : Reset Generation : 1' states
* that "if [a] connection [is] ... CLOSED then a reset is sent in response to any
* incoming segment". Thus, ALL received segments are invalid.
*
* (b) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State]' :
*
* (1) "If the SYN bit is set ... the connection state should be changed to SYN-
* RECEIVED ... and any other control or text should be queued for processing
* later ... Note that any other incoming control or data ... will be processed
* in the SYN-RECEIVED state."
*
* Therefore, the ONLY TCP segment data that may be queued in the LISTEN state
* MUST be received in a TCP connection request segment.
*
* (2) Otherwise "any other control or text-bearing segment (not containing SYN)
* must have an ACK and thus would be discarded by the ACK processing ...
* [so] drop the segment".
*
* (c) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check SYN Bit' :
*
* (1) "If ... our SYN has been ACKed ... change the connection state to
* ESTABLISHED ... [and] if there are other controls or text in the
* segment then continue processing" as for the ESTABLISHED state
* (see Note #1d).
*
* (2) "Otherwise enter SYN-RECEIVED ... [and] if there are other controls or
* text in the segment, queue them for processing after the ESTABLISHED
* state has been reached."
*
* (3) Otherwise "if neither the SYN or RST bits is set then drop the segment".
*
* Therefore, the ONLY TCP segment data that may be queued in the SYN-SENT
* state MUST be received in a TCP connection request segment.
*$PAGE*
* (d) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence
* Number' states that for the "SYN-RECEIVED STATE, ESTABLISHED STATE, FIN-
* WAIT-1 STATE, FIN-WAIT-2 STATE, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK
* STATE, TIME-WAIT STATE ... there are four cases for the acceptability test
* for an incoming segment :
*
* Local
* Segment Receive
* Length Window Test
* ------- ------- -------------------------------------------------------
*
* (1) 0 0 SEG.SEQ = RCV.NXT
*
* (2) 0 >0 RCV.NXT =< SEG.SEQ < RCV.NXT + RCV.WND
*
* (3) >0 0 not acceptable
*
* (4) >0 >0 RCV.NXT =< SEG.SEQ < RCV.NXT + RCV.WND
* or RCV.NXT =< SEG.SEQ + SEG.LEN - 1 < RCV.NXT + RCV.WND
*
*
* If the RCV.WND is zero, no segments will be acceptable, but special allowance
* should be made to accept valid ACKs ... and RSTs.
*
* If an incoming segment is not acceptable, an acknowledgment should be sent in
* reply".
*
* See also Note #2.
*
* (e) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check SYN Bit'
* states that in the "SYN-RECEIVED [STATE], ESTABLISHED STATE, FIN-WAIT STATE-1,
* FIN-WAIT STATE-2, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-WAIT
* STATE ... if the SYN is in the window it is an error, send a reset, any
* outstanding RECEIVEs and SEND[s] should receive 'reset' responses, all segment
* queues should be flushed, the user should also receive an unsolicited general
* 'connection reset' signal[, and] enter the CLOSED state".
*
* (2) RFC #793 does NOT provide nor suggest any logic to determine/handle sequence number
* comparisons for sequence number windows that overflow the sequence number space.
*
* (a) For example, the next sequence octet to receive (RCV.NXT) is typically less than
* or equal to the next received sequence octet (SEG.SEQ) :
*
* (1) RCV.NXT <= SEG.SEQ
*
* SEG.SEQ itself is also typically less than RCV.NXT plus the current receive window
* size (RCV.WND) :
*
* (2) SEG.SEQ < (RCV.NXT + RCV.WND)
*
* However, if (RCV.NXT + RCV.WND) or SEG.SEQ overflows the sequence number space,
* these values will be MUCH less than SEG.SEQ or RCV.NXT, respectively, until
* SEG.SEQ & RCV.NXT also overflow :
*
* (3) RCV.NXT + RCV.WND << RCV.NXT
* << SEG.SEQ
*
* (4) SEG.SEQ << RCV.NXT
*
* (b) Therefore, in order to validate a received segment's sequence value as within the
* TCP connection's current receive window, one of the following unsigned arithmetic
* comparisons MUST be true :
*
* (1) (A) (RCV.NXT + RCV.WND) - SEG.SEQ <= (RCV.NXT + RCV.WND) - RCV.NXT
*
* (B) (RCV.NXT + RCV.WND) - SEG.SEQ <= RCV.WND
*
* (C) (RCV.NXT + RCV.WND) - SEG.SEQ - 1 < RCV.WND
*
* (D) (RCV.NXT + RCV.WND) - (SEG.SEQ + 1) < RCV.WND
*
* (a) Comparison #2b1C's left-hand side decremented by one to modify the
* conditional test from less-than-or-equal-to to just less-than in
* order to satisfy the exact boundary conditions shown in the incoming
* segment acceptability test comparisons (see Notes #1d2 & #1d4).
*
* (2) Substituting (SEG.SEQ + SEG.LEN - 1) into SEG.SEQ :
*
* (A) (RCV.NXT + RCV.WND) - (SEG.SEQ + SEG.LEN - 1 + 1) < RCV.WND
*
* (B) (RCV.NXT + RCV.WND) - (SEG.SEQ + SEG.LEN) < RCV.WND
*
* (c) In order to determine if a received segment's sequence value is within but NOT
* following a closing TCP connection's last valid receive sequence numbers, the
* following unsigned arithmetic comparison MUST be checked :
*
* (1) RX.LAST - (SEG.SEQ + SEG.LEN) <= (RX.LAST - RX.NXT)
*********************************************************************************************************
*/
/*$PAGE*/
static NET_TCP_SEQ_CODE NetTCP_RxPktConnIsValidSeq (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NET_TCP_ACK_CODE ack_code;
#endif
NET_TCP_SEQ_CODE seq_code;
NET_TCP_SEQ_NBR seq_nbr;
NET_TCP_SEQ_NBR seq_win;
NET_TCP_SEQ_NBR seq_win_next;
NET_TCP_SEQ_NBR seq_win_delta;
*perr = NET_TCP_ERR_NONE;
seq_code = NET_TCP_CONN_RX_SEQ_INVALID;
if (pconn != (NET_TCP_CONN *)0) {
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return (NET_TCP_CONN_RX_SEQ_INVALID); /* Prevent 'break NOT reachable' warning. */
case NET_TCP_CONN_STATE_CLOSED: /* See Note #1a. */
break;
case NET_TCP_CONN_STATE_LISTEN: /* See Note #1b. */
if (pbuf_hdr->TCP_SegSync == DEF_YES) { /* If sync rx'd, .. */
seq_code = NET_TCP_CONN_RX_SEQ_SYNC; /* .. sync's seq nbr valid (see Note #1b1). */
}
break;
case NET_TCP_CONN_STATE_SYNC_TXD: /* See Note #1c. */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* See Note #1A. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return (NET_TCP_CONN_RX_SEQ_INVALID);
}
if (ack_code != NET_TCP_CONN_RX_ACK_VALID) {
return (NET_TCP_CONN_RX_SEQ_INVALID);
}
#endif
if (pbuf_hdr->TCP_SegSync == DEF_YES) { /* If valid sync rx'd, .. */
seq_code = NET_TCP_CONN_RX_SEQ_SYNC; /* .. sync's seq nbr valid. */
}
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_SYNC_RXD: /* See Notes #1d & #1e. */
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
if (pbuf_hdr->TCP_SegSync != DEF_NO) { /* If sync rx'd, ... */
return (NET_TCP_CONN_RX_SEQ_SYNC_INVALID); /* ... rtn invalid sync (see Note #1e). */
}
if (pconn->RxWinSizeActual > 0) { /* If rx win size > 0, ... */
/* ... chk for seg seq within rx win. */
switch (pconn->RxQ_State) {
case NET_TCP_RX_Q_STATE_CONN_SYNC:
case NET_TCP_RX_Q_STATE_CONN:
seq_win_next = (NET_TCP_SEQ_NBR)(pconn->RxSeqNbrNext + pconn->RxWinSizeActual);
seq_nbr = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_SeqNbr + 1);
seq_win_delta = (NET_TCP_SEQ_NBR)(seq_win_next - seq_nbr);
/* If [(next + win) - seq ] < win size, */
if (seq_win_delta < pconn->RxWinSizeActual) {
seq_code = NET_TCP_CONN_RX_SEQ_VALID; /* .. seq nbr within rx win (see Note #1d2). */
} else if (pbuf_hdr->TCP_SegLen > 0) {
seq_nbr = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_SeqNbr + pbuf_hdr->TCP_SegLen);
seq_win_delta = (NET_TCP_SEQ_NBR)(seq_win_next - seq_nbr);
/* If [(next + win) - (seq + len)] < win size, */
if (seq_win_delta < pconn->RxWinSizeActual) {
/* .. seq nbr within rx win (see Note #1d4). */
seq_code = NET_TCP_CONN_RX_SEQ_VALID;
}
}
break;
case NET_TCP_RX_Q_STATE_CONN_CLOSED:
case NET_TCP_RX_Q_STATE_CONN_CLOSING:
seq_win_next = (NET_TCP_SEQ_NBR) pconn->RxSeqNbrLast;
seq_nbr = (NET_TCP_SEQ_NBR)(pbuf_hdr->TCP_SeqNbr + pbuf_hdr->TCP_SegLen);
seq_win_delta = (NET_TCP_SEQ_NBR)(seq_win_next - seq_nbr);
seq_win = (NET_TCP_SEQ_NBR)(pconn->RxSeqNbrLast - pconn->RxSeqNbrNext);
if (seq_win_delta <= seq_win) { /* If [last - (seq + len)] <= [last - next], .. */
seq_code = NET_TCP_CONN_RX_SEQ_VALID; /* .. seq nbr within close win (see Note #2c1). */
}
break;
case NET_TCP_RX_Q_STATE_NONE:
case NET_TCP_RX_Q_STATE_CLOSED:
default:
return (NET_TCP_CONN_RX_SEQ_INVALID);
}
} else { /* Else chk for valid, zero-len seg. */
if (pbuf_hdr->TCP_SegLen > 0) { /* If seg len > 0, ... */
*perr = NET_TCP_ERR_INVALID_LEN_SEG; /* ... rtn invalid seg len (see Note #1d3). */
return (NET_TCP_CONN_RX_SEQ_INVALID);
}
if (pbuf_hdr->TCP_SeqNbr == pconn->RxSeqNbrNext) { /* If seq nbr equals next rx seq expected, .. */
seq_code = NET_TCP_CONN_RX_SEQ_VALID; /* .. seq nbr valid (see Note #1d1). */
}
}
break;
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return (NET_TCP_CONN_RX_SEQ_INVALID); /* Prevent 'break NOT reachable' warning. */
}
}
return (seq_code);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnIsValidAck()
*
* Description : Validate a received segment's acknowledgement number with current TCP connection.
*
* Argument(s) : pconn Pointer to a TCP connection.
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE Acknowledgement number successfully
* validated; check return value.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
*
* Return(s) : NET_TCP_CONN_RX_ACK_INVALID, if received acknowledgement number invalid for the TCP connection.
*
* NET_TCP_CONN_RX_ACK_VALID, if received acknowledgement number valid for the TCP connection.
*
* NET_TCP_CONN_RX_ACK_NONE, if NO received acknowledgement number.
*
* NET_TCP_CONN_RX_ACK_DUP, if received acknowledgement number is a duplicate for the
* TCP connection.
*
* NET_TCP_CONN_RX_ACK_PREV, if received acknowledgement number is a previous duplicate for the
* TCP connection.
*
* Caller(s) : various.
*
* Note(s) : (1) Validate received TCP connection acknowledgements :
*
* (a) RFC #793, Section 3.4 'Establishing a Connection : Reset Generation : 1' states
* that "if [a] connection [is] ... CLOSED then a reset is sent in response to any
* incoming segment". Thus, ALL received segments, including acknowledgement
* segments, are invalid.
*
* (b) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State] :
* Check for ACK' states that "any acknowledgment is bad if it arrives on a
* connection still in the LISTEN state".
*
* (c) (1) The following sections generalize that "if SND.UNA < SEG.ACK =< SND.NXT then
* the ACK is acceptable", whereas "if SEG.ACK =< SND.UNA, or SEG.ACK > SND.NXT"
* then the acknowledgement is unacceptable :
*
* (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT
* [State] : Check ACK Bit'
* (B) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK
* Field : SYN-RECEIVED STATE'
* (C) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK
* Field : ESTABLISHED STATE'
*
* Including states with similar "processing as for the ESTABLISHED STATE" (see
* RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field') :
*
* (D) FIN-WAIT-1 STATE
* (E) FIN-WAIT-2 STATE
* (F) CLOSING STATE
* (G) CLOSE-WAIT STATE
*
* See also Note #3a.
*
* (2) However, RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT
* [State] : Check SYN Bit' also states to "check the SYN bit ... if the ACK is
* ok, or there is no ACK".
*
* Therefore, the lack of an acknowledgement in the SYN-SENT state is acceptable.
*
* (3) However, RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check
* ACK Field : ESTABLISHED STATE' also states that in the "ESTABLISHED STATE"
* or any state with similar "processing as for the ESTABLISHED STATE ... if
* the ACK is a duplicate (SEG.ACK =< SND.UNA), it can be ignored".
*
* See also Note #3b.
*
* (d) (1) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* TIME-WAIT STATE' states that "the only thing that can arrive in this state is
* a retransmission of the remote FIN".
*
* (B) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* LAST-ACK STATE' states that "the only thing that can arrive in this state is
* an acknowledgement of our FIN".
*
* (2) However, it is possible that some but NOT all transmitted data has been received
* by the remote host. In other words, the remote host may have received some but
* NOT ALL transmitted data preceding this host's connection close request.
*
* ???? Therefore, acknowledgements validated by as within the transmit window MUST
* be received & processed as in connected states.
*$PAGE*
* (2) ???? RFC #793 contains multiple errors/inconsistencies regarding the boundary conditions
* of TCP sequence/acknowledgement inequalities -- i.e. some of the expressions incorrectly
* include or exclude the equality condition.
*
* RFC #1122, Section 4.2.2.20 corrects some but NOT all of these errors/inconsistencies.
*
* (3) RFC #793 does NOT provide nor suggest any logic to determine/handle sequence number
* comparisons for sequence number windows that overflow the sequence number space.
*
* (a) (1) For example, the next sequence octet to transmit (SND.NXT) is typically greater
* than or equal to the last unacknowledged transmit sequence octet (SND.UNA) :
*
* (A) SND.NXT >= SND.UNA
*
* However, when SND.NXT overflows the sequence number space, it will be MUCH less
* than SND.UNA until SND.UNA also overflows :
*
* (B) SND.NXT << SND.UNA
*
* (2) Therefore, in order to validate a received segment's acknowledgement value
* (SEG.ACK) as within the TCP connection's current transmit acknowledgement
* window, the following unsigned arithmetic comparison MUST be true :
*
* (A) (SND.NXT - SEG.ACK) < (SND.NXT - SND.UNA)
*
* (b) (1) Typically, duplicate acknowledgements are less than or equal to the last
* unacknowledged transmit sequence octet (SND.UNA) :
*
* (A) SEG.ACK <= SND.UNA
*
* However, when SND.UNA overflows the sequence number space, it will be MUCH less
* than duplicate acknowledgements until these duplicates also overflow :
*
* (B) SEG.ACK >> SND.UNA
*
* (2) Therefore, in order to validate SEG.ACK as a recent duplicate acknowledgement
* for the TCP connection's current transmit acknowledgement window, the following
* unsigned arithmetic comparison MUST be true :
*
* (A) (SND.UNA - SEG.ACK) <= (WIN_SIZE_SCALE * TxWinSizeRemote)
*
* where
*
* WIN_SIZE_SCALE is some window-size scalar multiplier
* TxWinSizeRemote is the remote host's last-advertised
* receive window size, which is this
* host's transmit remote window size
*********************************************************************************************************
*/
static NET_TCP_ACK_CODE NetTCP_RxPktConnIsValidAck (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_ACK_CODE ack_code;
NET_TCP_SEQ_NBR ack_delta_next;
NET_TCP_SEQ_NBR ack_delta_unackd;
NET_TCP_SEQ_NBR ack_win;
NET_TCP_SEQ_NBR ack_dup_win;
/*$PAGE*/
*perr = NET_TCP_ERR_NONE;
ack_code = NET_TCP_CONN_RX_ACK_INVALID;
if (pconn != (NET_TCP_CONN *)0) {
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return (NET_TCP_CONN_RX_ACK_INVALID); /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED: /* See Note #1a. */
case NET_TCP_CONN_STATE_LISTEN: /* See Note #1b. */
if (pbuf_hdr->TCP_SegAck != DEF_NO) { /* If ack rx'd, ... */
return (NET_TCP_CONN_RX_ACK_INVALID); /* ... rtn invalid ack. */
}
ack_code = NET_TCP_CONN_RX_ACK_NONE;
break;
case NET_TCP_CONN_STATE_SYNC_TXD:
if (pbuf_hdr->TCP_SegAck == DEF_NO) { /* If NO ack rx'd, ... */
return (NET_TCP_CONN_RX_ACK_NONE); /* ... rtn valid ack (see Note #1c2). */
}
/* 'break' intentionally omitted; do NOT move .. */
/* .. from the following case (see Note #1c1A) : .. */
/* .. 'NET_TCP_CONN_STATE_SYNC_RXD'. */
case NET_TCP_CONN_STATE_SYNC_RXD: /* See Note #1c1B. */
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
if (pbuf_hdr->TCP_SegAck != DEF_YES) { /* If NO ack rx'd, ... */
return (NET_TCP_CONN_RX_ACK_NONE); /* ... rtn NO ack. */
}
ack_delta_next = (NET_TCP_SEQ_NBR)(pconn->TxSeqNbrNext - pbuf_hdr->TCP_AckNbr);
ack_win = (NET_TCP_SEQ_NBR)(pconn->TxSeqNbrNext - pconn->TxSeqNbrUnAckd);
if (ack_delta_next < ack_win) { /* If (next - ack) < ack win, ... */
ack_code = NET_TCP_CONN_RX_ACK_VALID; /* ... ack is within ack win (see Note #3a2A). */
}
break;
case NET_TCP_CONN_STATE_CONN: /* See Note #1c1C. */
case NET_TCP_CONN_STATE_FIN_WAIT_1: /* See Note #1c1D. */
case NET_TCP_CONN_STATE_FIN_WAIT_2: /* See Note #1c1E. */
case NET_TCP_CONN_STATE_CLOSING: /* See Note #1c1F. */
case NET_TCP_CONN_STATE_CLOSE_WAIT: /* See Note #1c1G. */
case NET_TCP_CONN_STATE_TIME_WAIT: /* See Note #1d2. */
case NET_TCP_CONN_STATE_LAST_ACK: /* See Note #1d2. */
if (pbuf_hdr->TCP_SegAck != DEF_YES) { /* If NO ack rx'd, ... */
return (NET_TCP_CONN_RX_ACK_NONE); /* ... rtn NO ack. */
}
ack_delta_next = (NET_TCP_SEQ_NBR)(pconn->TxSeqNbrNext - pbuf_hdr->TCP_AckNbr);
ack_win = (NET_TCP_SEQ_NBR)(pconn->TxSeqNbrNext - pconn->TxSeqNbrUnAckd);
if (ack_delta_next < ack_win) { /* If (next - ack) < ack win, ... */
ack_code = NET_TCP_CONN_RX_ACK_VALID; /* ... ack is within ack win (see Note #3a2A). */
} else {
ack_delta_unackd = (NET_TCP_SEQ_NBR)(pconn->TxSeqNbrUnAckd - pbuf_hdr->TCP_AckNbr);
if (ack_delta_unackd == 0) { /* If (unackd - ack) = 0, ... */
ack_code = NET_TCP_CONN_RX_ACK_DUP; /* ... ack is dup ack. */
/* ... (see Note #1c3). */
} else {
ack_dup_win = (NET_TCP_SEQ_NBR)(NET_TCP_ACK_NBR_DUP_WIN_SIZE_SCALE * pconn->TxWinSizeRemote);
if (ack_delta_unackd <= ack_dup_win) { /* If (unackd - ack) <= dup ack win, ... */
ack_code = NET_TCP_CONN_RX_ACK_PREV; /* ... ack is recent dup ack ... */
/* ... (see Notes #1c3 & #3b2A). */
}
}
}
break;
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return (NET_TCP_CONN_RX_ACK_INVALID); /* Prevent 'break NOT reachable' compiler warning. */
}
}
return (ack_code);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktConnIsValidReset()
*
* Description : Validate a received segment's reset flag, if any, with current TCP connection.
*
* Argument(s) : pconn Pointer to a TCP connection.
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE Received segment's reset flag successfully
* validated; check return value.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
*
* - RETURNED BY NetTCP_RxPktConnIsValidSeq() : -
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* Return(s) : NET_TCP_CONN_RX_RESET_INVALID, if received reset flag invalid for the TCP connection.
*
* NET_TCP_CONN_RX_RESET_VALID, if received reset flag valid for the TCP connection;
* i.e. reset the TCP connection.
*
* NET_TCP_CONN_RX_RESET_NONE, if NO received reset flag.
*
* Caller(s) : various.
*
* Note(s) : (1) See the following RFC's for TCP reset validation summary :
*
* (a) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing'
* (b) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES'
* (c) RFC Draft-IETF-TCPm-TCPSecure #00, Section 2
*
* (2) Validate received TCP connection resets :
*
* (A) Some TCP receive reset validation logic implemented in previous functions; include
* duplicate validation logic in NetTCP_RxPktConnIsValidReset() only if debug/validation
* code is enabled (i.e. NET_ERR_CFG_ARG_CHK_DBG_EN is DEF_ENABLED in 'net_cfg.h').
*
* (a) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : CLOSED [State]' states
* that "if the state is CLOSED ... an incoming segment containing a RST is discarded".
*
* (2) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State]'
* states that if "the state is LISTEN ... an incoming RST should be ignored".
*
* (B) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing' reiterates
* that "if the receiver ... of a RST ... was in the LISTEN state, it ignores it".
*
* (3) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check RST Bit' states that "if the RST bit is set [and] if the ACK was
* acceptable then ... enter CLOSED state".
*
* (B) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing' reiterates
* that "in the SYN-SENT state (a RST received in response to an initial SYN), the
* RST is acceptable if the ACK field acknowledges the SYN".
*
* (1) However, since receiving a TCP connection request/synchronization segment
* with no acknowledgement number in the SYN-SENT state is permitted, then
* a received TCP reset segment with no acknowledgement number MUST also be
* acceptable.
*
* See also Note #2a5C.
*$PAGE*
* (4) (A) (1) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing'
* summarizes that "in all states except SYN-SENT, all reset (RST) segments
* are validated by checking their SEQ-fields. A reset is valid if its
* sequence number is in the window".
*
* (2) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit'
* reiterates that the received segment's reset is valid if and only if its
* sequence number is valid since it follows RFC #793, Section 3.9 'Event
* Processing : SEGMENT ARRIVES : Check Sequence Number'.
*
* (3) RFC #793, Section 3.3 states "that when the receive window is zero no
* segments should be acceptable except ACK segments ... However, even when
* the receive window is zero, a TCP must process the RST ... fields of all
* incoming segments".
*
* However, this contradicts the following sections which state that a
* "received segment's reset is valid if and only if its sequence number if
* valid" & that "if an incoming segment is not acceptable ... [and] the RST
* bit is set, ... drop the segment" :
*
* (a) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing'
* (b) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check
* Sequence Number'
*
* See also Note #2a5B.
*
* (B) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit'
* states that in the "SYN-RECEIVED STATE" that "if the RST bit is set [and]
* this connection was initiated with a passive OPEN (i.e., came from the
* LISTEN state), then return this connection to the LISTEN state ... If this
* connection was initiated with an active OPEN (i.e., came from SYN-SENT state)
* then the connection was refused, ... enter the CLOSED state".
*
* (2) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing'
* reiterates that "if the receiver ... of a RST ... was in SYN-RECEIVED state
* and had previously been in the LISTEN state, then the receiver returns to
* the LISTEN state, otherwise the receiver aborts the connection and goes to
* the CLOSED state".
*
* (3) However, since TCP connections opened from the LISTEN state are cloned from
* the original LISTEN-state TCP connection, it is NOT necessary to return ANY
* reset TCP connection from the SYN-RECEIVED state back to the LISTEN state.
*
* See also Note #2a5A.
*
* (C) (1) RFC #793, Section 3.4 'Establishing a Connection : Reset Processing' states
* that "if the receiver ... of a RST ... was in any other state [other than
* LISTEN or SYN-RECEIVED], it aborts the connection and advises the user and
* goes to the CLOSED state".
*
* (2) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit'
* states that in the "ESTABLISHED, FIN-WAIT-1, FIN-WAIT-2, CLOSE-WAIT" states
* that "if the RST bit is set then, any outstanding RECEIVEs and SEND[s] should
* receive 'reset' responses. All segment queues should be flushed. Users
* should also receive an unsolicited general 'connection reset' signal[, and]
* enter the CLOSED state".
*
* (3) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit'
* states that in the "CLOSING STATE, LAST-ACK STATE, TIME-WAIT" states that
* "if the RST bit is set then, enter the CLOSED state".
*
* See also Note #2a5A.
*$PAGE*
* (5) (A) RFC Draft-IETF-TCPm-TCPSecure #00, Section 2.2 amends the "handling of a segment
* with the RST bit when in a synchronized state" to "provide some protection against
* ... blind reset attack[s] using the RST bit" :
*
* (a) "If the RST bit is set and the sequence number is outside the expected window,
* silently drop the segment."
*
* (b) "If the RST bit is exactly the next expected sequence number [sic], reset the
* connection"; it is assumed that this should read "if the RST bit is set and
* the sequence number is exactly the next expected sequence number, reset the
* connection."
*
* (c) "If the RST bit is set and the sequence number does not exactly match
* the next expected sequence value, yet is within the acceptable window
* (RCV.NXT <= SEG.SEQ < RCV.NXT+RCV.WND) send an acknowledgment."
*
* (B) ???? Although RFC Draft-IETF-TCPm-TCPSecure #00 explicitly states that this
* amendment applies only to the "handling of a ... RST ... when in a synchronized
* state", it is assumed that this should also apply to the SYN-RECEIVED state.
*
* (C) (1) ???? In addition, it is assumed that a similar validation should also
* apply to the SYN-SENT state. Since the SYN-SENT state validates a
* received TCP reset segment based only on the segment's acknowledgement,
* a similar validation could require that the acknowledgement "exactly
* match the next expected sequence value" -- i.e. the initial connection
* synchronization sequence number plus one.
*
* (2) However, a specific check for the exact acknowledgement is NOT necessary
* since NO data is transmitted from the SYN-SENT state. Therefore, the ONLY
* value to be acknowledged is the initial connection synchronization sequence
* number.
*
* (D) ???? In addition, RFC Draft-IETF-TCPm-TCPSecure #00 does NOT provide a precedence
* priority for handling TCP segments received with BOTH the RST & SYN bits set.
*
* ???? Therefore, since it does NOT seem reasonable to reset a TCP connection
* due to a TCP segment that also attempted to synchronize the TCP connection,
* it is assumed that the amended handling of the SYN bit should take precedence
* over the amended handling of the RST bit.
*
* (b) RFC #1122, Section 4.2.2.12 states that "a TCP SHOULD allow a received RST segment
* to include data".
*********************************************************************************************************
*/
static NET_TCP_RESET_CODE NetTCP_RxPktConnIsValidReset (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NET_TCP_ACK_CODE ack_code;
NET_TCP_SEQ_CODE seq_code;
#endif
NET_TCP_RESET_CODE reset_code;
/*$PAGE*/
*perr = NET_TCP_ERR_NONE;
if (pbuf_hdr->TCP_SegReset != DEF_YES) { /* If NO reset rx'd, ... */
return (NET_TCP_CONN_RX_RESET_NONE); /* ... rtn NONE. */
}
reset_code = NET_TCP_CONN_RX_RESET_INVALID;
if (pconn != (NET_TCP_CONN *)0) {
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return (NET_TCP_CONN_RX_RESET_INVALID); /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED: /* See Note #2a1. */
case NET_TCP_CONN_STATE_LISTEN: /* See Note #2a2. */
break;
case NET_TCP_CONN_STATE_SYNC_TXD: /* See Note #2a3. */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* See Note #2A. */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return (NET_TCP_CONN_RX_RESET_INVALID);
}
if (ack_code == NET_TCP_CONN_RX_ACK_INVALID) {
return (NET_TCP_CONN_RX_RESET_INVALID);
}
#endif
reset_code = NET_TCP_CONN_RX_RESET_VALID;
break;
case NET_TCP_CONN_STATE_SYNC_RXD: /* See Notes #2a4B & #2a5B. */
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_CONN: /* See Notes #2a4C & #2a5A. */
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* See Note #2A. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return (NET_TCP_CONN_RX_RESET_INVALID);
}
if (seq_code != NET_TCP_CONN_RX_SEQ_VALID) {
return (NET_TCP_CONN_RX_RESET_INVALID);
}
#endif
if (pbuf_hdr->TCP_SeqNbr == pconn->RxSeqNbrNext) { /* If seq nbr equals next rx seq expected ... */
reset_code = NET_TCP_CONN_RX_RESET_VALID; /* ... (see Note #2a5Ab), rtn valid reset. */
}
break;
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return (NET_TCP_CONN_RX_RESET_INVALID); /* Prevent 'break NOT reachable' warning. */
}
}
return (reset_code);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxPktFree()
*
* Description : Free network buffer(s).
*
* Argument(s) : pbuf_q Pointer to network buffer queue.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxAppData(),
* NetTCP_RxPktConnHandler(),
* NetTCP_RxPktConnHandlerRxQ_AppData().
*
* Note(s) : none.
*********************************************************************************************************
*/
static void NetTCP_RxPktFree (NET_BUF *pbuf_q)
{
NetBuf_FreeBufQ_PrimList((NET_BUF *)pbuf_q,
(NET_CTR *)0);
}
/*
*********************************************************************************************************
* NetTCP_RxPktDiscard()
*
* Description : On any TCP Receive errors, discard TCP packet(s) & buffer(s).
*
* Argument(s) : pbuf Pointer to network buffer.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_ERR_RX Receive error; packet discarded.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_Rx(),
* NetTCP_RxPktConnHandler().
*
* Note(s) : none.
*********************************************************************************************************
*/
static void NetTCP_RxPktDiscard (NET_BUF *pbuf,
NET_ERR *perr)
{
NET_CTR *pctr;
#if (NET_CTR_CFG_ERR_EN == DEF_ENABLED)
pctr = (NET_CTR *)&NetTCP_ErrRxPktDiscardedCtr;
#else
pctr = (NET_CTR *) 0;
#endif
NetBuf_FreeBufQ_PrimList((NET_BUF *)pbuf,
(NET_CTR *)pctr);
*perr = NET_ERR_RX;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxConnWinSizeCfg()
*
* Description : (1) Configure TCP connection's receive window controls :
*
* (a) Configure TCP connection's receive window update threshold
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_ConnCfg().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_ConnCfg(),
* NetTCP_ConnCfgRxWinSize().
*
* Note(s) : (2) A TCP connection's receive window controls should NOT be updated until after the
* following TCP connection control(s) have been configured :
*
* (a) TCP connection's configured receive window size ('RxWinSizeCfgd')
* [see 'NetTCP_RxConnWinSizeCfgUpdateTh() Note #2a']
*
* (b) TCP connection's connection maximum segment size ('MaxSegSizeConn')
* [see 'NetTCP_RxConnWinSizeCfgUpdateTh() Note #2b']
*********************************************************************************************************
*/
static void NetTCP_RxConnWinSizeCfg (NET_TCP_CONN *pconn)
{
NetTCP_RxConnWinSizeCfgUpdateTh(pconn);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxConnWinSizeCfgUpdateTh()
*
* Description : Configure TCP connection's receive window update threshold.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxConnWinSizeCfg().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxConnWinSizeCfg().
*
* Note(s) : (1) RFC #1122, Section 4.2.3.3 states that "the suggested SWS avoidance algorithm for
* the receiver is ... to avoid advancing the right window edge RCV.NXT+RCV.WND ...
* until the reduction satisfies" :
*
* (a) RCV.BUFF - RCV.USER - RCV.WND >= min(Fr * RCV.BUFF, Eff.snd.MSS)
*
* where
* (1) RCV.BUFF Total receive buffer space
* (2) RCV.USER Data received but not yet consumed
* (3) RCV.WND Space advertised to sender
* (4) Fr Fraction whose recommended value is 1/2
* (5) Eff.snd.MSS Effective send MSS for the connection
*
* (2) A TCP connection's receive window update threshold should NOT be updated until
* after the following TCP connection control(s) have been configured :
*
* (a) TCP connection's configured receive window size ('RxWinSizeCfgd')
* [see 'NetTCP_ConnClr() Note #4']
*
* (b) TCP connection's connection maximum segment size ('MaxSegSizeConn')
* [see 'NetTCP_ConnCfgMaxSegSize() Note #1']
*********************************************************************************************************
*/
static void NetTCP_RxConnWinSizeCfgUpdateTh (NET_TCP_CONN *pconn)
{
NET_TCP_WIN_SIZE rx_win_size_th;
/* Cfg silly win min th (see Note #1a). */
rx_win_size_th = (NET_TCP_WIN_SIZE)(((CPU_INT32U)pconn->RxWinSizeCfgd * NET_TCP_RX_SILLY_WIN_NUMER)
/ NET_TCP_RX_SILLY_WIN_DENOM);
pconn->RxWinSizeUpdateTh = DEF_MIN(pconn->MaxSegSizeConn,
rx_win_size_th);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_RxConnWinSizeHandler()
*
* Description : (1) Handle TCP connection's receive window :
*
* (a) Handle TCP connection receive window See Notes #2 & #3
* (b) Transmit TCP connection acknowledgement See Note #4
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxAppData(),
* NetTCP_RxPktConnHandlerRxQ_Sync(),
* NetTCP_RxPktConnHandlerRxQ_Conn(),
* NetTCP_RxPktConnHandlerRxQ_AppData().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
*
* win_update_size Size to update TCP connection's receive window (in octets).
*
* win_update_code Indicate how to update TCP connection receive window :
*
* NET_TCP_CONN_RX_WIN_RESET Reset TCP connection's available
* receive window size.
* NET_TCP_CONN_RX_WIN_SET Set TCP connection's available
* receive window size.
* NET_TCP_CONN_RX_WIN_INC Increment TCP connection's available
* receive window size.
* NET_TCP_CONN_RX_WIN_DEC Decrement TCP connection's available
* receive window size.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxAppData(),
* NetTCP_RxPktConnHandlerRxQ_Sync(),
* NetTCP_RxPktConnHandlerRxQ_Conn(),
* NetTCP_RxPktConnHandlerRxQ_AppData().
*
* Note(s) : (2) RFC #793, Section 3.7 'Data Communication : Managing the Window' states that ... :
*
* (a) "The window sent in each segment indicates the range of sequence numbers the
* sender of the window (the data receiver) is currently prepared to accept.
* There is an assumption that this is related to the currently available data
* buffer space available for this connection."
*
* (1) A TCP connection's advertised receive window MUST NEVER be decreased to zero
* if NO receive data is available & ready to be read by the application layer.
*
* In other words, if NO received data starting from the next expected receive
* sequence number(s) is queued, then NO data is available to be read by the
* application layer. Therefore, the receive window size MUST NOT be decreased
* to zero, otherwise the receive window would deadlock since the application
* layer would NOT be able to read & extract any data from the receive window
* & the TCP connection would NOT be able to receive any more data into the
* receive window.
*
* See also 'NetTCP_RxPktConnHandlerRxQ_AppData() Note #6b'.
*
* (b) "The mechanisms provided allow a TCP to advertise a large window and to
* subsequently advertise a much smaller window without having accepted that
* much data. This ... 'shrinking the window' is strongly discouraged. The
* robustness principle dictates that TCPs will not shrink the window ... but
* will be prepared for such behavior on the part of other TCPs."
*
* (c) "Note that ... acknowledgments should not be delayed or unnecessary
* retransmissions will result. One strategy would be to send an acknowledgment
* when a small segment arrives (with out [sic] updating the window information),
* and then to send another acknowledgment with new window information when the
* window is larger."
*
* (1) However, the following sections retract this delayed acknowledgement
* prohibition & state that "a TCP SHOULD implement a delayed ACK" :
*
* (A) RFC # 813, Section 5
* (B) RFC #1122, Section 4.2.3.2
* (C) RFC #2581, Section 4.2
*
* See also Note #4 & 'NetTCP_TxConnAck() Note #6'.
*$PAGE*
* (3) (a) RFC #813, Section 2 states that "a bad implementation of the window algorithm
* can lead to extremely poor performance ... This particular phenomenon ... has
* been given the name of Silly Window Syndrome, or SWS".
*
* Section 3 elaborates that "SWS is a degeneration in the throughput which develops
* ... whenever the acknowledgement of a small segment ... cause[s] another segment
* of the same small size to be sent, until ... the network ... becomes clogged with
* many small segments, and an equal number of acknowledgements".
*
* (b) (1) RFC #813, Section 4 states that "the receiver of data can take a very simple
* step to eliminate SWS. When it disposes of a small amount of data, it can
* artificially reduce the offered window in subsequent acknowledgements, so
* that the useable window computed by the sender does not permit the sending
* of any further data.
*
* At some later time, when the receiver has processed a substantially larger
* amount of incoming data, the artificial limitation on the offered window
* can be removed all at once, so that the sender computes a sudden large jump
* rather than a sequence of small jumps in the useable window.
*
* For a simple implementation, ... artificially reduce the offered window until
* the reduction constitutes one half of the available space ... [or] at least
* permit one reasonably large segment".
*
* (2) RFC #1122, Section 4.2.3.3 reiterates that "a TCP MUST include a SWS avoidance
* algorithm in the receiver ... This algorithm combines with the delayed ACK
* algorithm ... to determine when an ACK segment containing the current window
* will really be sent to the receiver [sic]".
*
* "The solution to receiver SWS is to avoid advancing the right window edge
* RCV.NXT+RCV.WND in small increments, even if data is received from the
* network in small segments ... The suggested SWS avoidance algorithm for
* the receiver is to keep RCV.NXT+RCV.WND fixed until the reduction satisfies :
*
* (A) RCV.BUFF - RCV.USER - RCV.WND >= min(Fr * RCV.BUFF, Eff.snd.MSS)
*
* where
* (1) RCV.BUFF Total receive buffer space
* (2) RCV.USER Data received but not yet consumed
* (3) RCV.WND Space advertised to sender
* (4) Fr Fraction whose recommended value is 1/2
* (5) Eff.snd.MSS Effective send MSS for the connection
*
*
* Note that the general effect of this algorithm is to advance RCV.WND in
* increments of the Eff.snd.MSS."
*
* (4) (a) RFC #813, Section 5 states that "the receiver of data will refrain from
* sending an acknowledgement under certain circumstances ... Postpone
* sending an acknowledgement if ... the following conditions hold" :
*
* (1) "There is no revised window information to be sent back."
*
* (A) However, if any local receive window size is available to update to
* the remote host, an acknowledgement should be immediately transmitted.
*
* (1) HOWEVER, since local receive window size updates will continually
* occur for "a host that is receiving a stream of TCP data segments"
* (RFC #1122, Section 4.2.3.2); it is NOT possible to both update the
* local receive window & implement a delayed acknowledgement.
*
* (a) #### Therefore, in order to implement a delayed acknowledgement,
* the only local receive window size updates that SHOULD transmit
* an immediate acknowledgement :
*
* (1) Local receive window size sets/resets
* (2) Local receive window size increases
* (3) Local receive window size decreases to zero-sized
*
* (b) #### The following local receive window size updates SHOULD NOT
* transmit an immediate acknowledgement :
*
* (1) Local receive window size decreases
*
* (b) RFC #1122, Section 4.2.3.2 states that "a delayed ACK gives the application an
* opportunity to update the window and perhaps to send an immediate response".
*
* See also 'NetTCP_TxConnAck() Notes #4b1, #6, & #7'.
*$PAGE*
* (5) Since the configured receive window size may be asynchronously modified by the
* application layer, changes in the calculated &/or advertised receive window size
* MUST be appropriately validated to any possible new value for the configured
* receive window size :
*
* (a) During receive window size increases, if the currently calculated receive
* window size is already greater than the currently configured receive window
* size; then the calculated window size is NOT increased, but is allowed to
* remain greater than the configured window size until the calculated window
* size decreases below the configured window size.
*
* (b) During receive window size decreases, if the currently calculated receive
* window size is already greater than the currently configured receive window
* size; then the calculated window size is further decreased, but is allowed to
* remain greater than the configured window size until the calculated window
* size decreases below the configured window size.
*
* (c) During receive window size decreases, if the currently configured receive
* window size is less than the actual configured receive window size; then
* the actual configured receive window size is also decremented by the window
* size decrease.
*********************************************************************************************************
*/
static void NetTCP_RxConnWinSizeHandler (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_WIN_SIZE win_update_size,
NET_TCP_WIN_CODE win_update_code)
{
CPU_BOOLEAN tx_ack;
NET_TCP_ACK_CODE tx_ack_code;
NET_TCP_WIN_SIZE win_size_avail;
NET_TCP_WIN_SIZE win_size_delta;
NET_ERR err;
/* ---------- HANDLE TCP CONN RX WIN ---------- */
tx_ack = DEF_NO;
switch (win_update_code) {
case NET_TCP_CONN_RX_WIN_RESET:
default:
/* If < cfg'd win size (see Note #5a), ... */
if (pconn->RxWinSizeCalcd < pconn->RxWinSizeCfgd) {
/* ... reset calc'd win size to cfg'd win size. */
pconn->RxWinSizeCalcd = pconn->RxWinSizeCfgd;
pconn->RxWinSizeCfgdActual = pconn->RxWinSizeCfgd;
pconn->RxWinSizeCfgdActualUpdateRem = 0;
}
if (pconn->RxWinSizeActual < pconn->RxWinSizeCalcd) { /* Do NOT shrink rx win (see Note #2b). */
pconn->RxWinSizeActual = pconn->RxWinSizeCalcd;
tx_ack = DEF_YES;
tx_ack_code = NET_TCP_CONN_TX_ACK_IMMED; /* See Note #4a1A1a1. */
}
break;
case NET_TCP_CONN_RX_WIN_SET:
if (pconn->RxWinSizeActual < win_update_size) { /* If actual rx win size < win update, ... */
pconn->RxWinSizeActual = win_update_size; /* ... set rx win size. */
pconn->RxWinSizeCalcd = win_update_size;
tx_ack = DEF_YES;
tx_ack_code = NET_TCP_CONN_TX_ACK_IMMED; /* See Note #4a1A1a1. */
break;
} /* Else inc; do NOT shrink win (see Note #2b). */
/* 'break' intentionally omitted; do NOT .. */
/* .. move from the following case : .. */
/* .. 'NET_TCP_CONN_RX_WIN_INC'. */
/*$PAGE*/
case NET_TCP_CONN_RX_WIN_INC:
if (win_update_size == 0) { /* If NO win update, MUST NOT update win. */
break;
}
if (pconn->RxWinSizeCalcd <= pconn->RxWinSizeCfgdActual) { /* If <= cfg'd win size (see Note #5a), ... */
/* ... inc rx win size. */
win_size_avail = pconn->RxWinSizeCfgdActual - pconn->RxWinSizeCalcd;
if (win_size_avail > win_update_size) { /* If avail rx win size > win update, ... */
pconn->RxWinSizeCalcd += win_update_size; /* ... inc rx win size by win update. */
} else { /* Else limit to cfg'd rx win size. */
pconn->RxWinSizeCalcd = pconn->RxWinSizeCfgdActual;
}
if (pconn->RxWinSizeCalcd > pconn->RxWinSizeActual) {
win_size_delta = pconn->RxWinSizeCalcd - pconn->RxWinSizeActual;
if (win_size_delta >= pconn->RxWinSizeUpdateTh) { /* If calc'd - actual rx win size >= th, ... */
pconn->RxWinSizeActual = pconn->RxWinSizeCalcd;/* ... update rx win size (see Note #3b2). */
tx_ack = DEF_YES;
tx_ack_code = NET_TCP_CONN_TX_ACK_IMMED; /* See Note #4a1A1a2. */
}
} else { /* Prevent rx win shrink (see Note #2b). */
pconn->RxWinSizeCalcd = pconn->RxWinSizeActual;
}
}
break;
case NET_TCP_CONN_RX_WIN_DEC:
if (win_update_size == 0) { /* If NO win update, MUST NOT update win. */
break;
}
if (pconn->RxWinSizeCfgdActualUpdateRem > 0) { /* If cfg'd win update > 0 (see Note #5c), .. */
/* .. cfg actual cfg'd win update to : .. */
if (pconn->RxWinSizeCfgdActualUpdateRem > win_update_size) {
win_size_avail = win_update_size; /* .. win update size .. */
} else { /* .. or limit to cfg'd win update rem'ing; .. */
win_size_avail = pconn->RxWinSizeCfgdActualUpdateRem;
}
pconn->RxWinSizeCfgdActualUpdateRem -= win_size_avail; /* .. dec cfg'd win update rem'ing; & .. */
if (pconn->RxWinSizeCfgdActual > win_size_avail) {
pconn->RxWinSizeCfgdActual -= win_size_avail; /* .. dec actual cfg'd win size. */
} else {
pconn->RxWinSizeCfgdActual = 0;
}
}
if (pconn->RxWinSizeCalcd > win_update_size) { /* If calc'd rx win size > win update, ... */
pconn->RxWinSizeCalcd -= win_update_size; /* ... dec rx win size by win update. */
} else {
pconn->RxWinSizeCalcd = 0; /* Else limit to min rx win size. */
}
if (pconn->RxWinSizeActual > 0) {
if (pconn->RxWinSizeActual > win_update_size) { /* If actual rx win size > win update, ... */
pconn->RxWinSizeActual -= win_update_size; /* ... dec rx win size by win update. */
tx_ack_code = NET_TCP_CONN_TX_ACK; /* See Note #4a1A1b1. */
} else {
pconn->RxWinSizeActual = 0; /* Else limit to min rx win size. */
tx_ack_code = NET_TCP_CONN_TX_ACK_IMMED; /* See Note #4a1A1a3. */
}
tx_ack = DEF_YES;
}
break;
}
/* --------------- TX TCP CONN ACK ------------ */
if (tx_ack == DEF_YES) { /* If rx win updated, tx ack (see Note #4a1A). */
if (pbuf_hdr != (NET_BUF_HDR *)0) { /* If rx'd pkt avail, req tx ack; but ack ... */
pbuf_hdr->TCP_SegAckTxReqCode = tx_ack_code; /* ... NOT tx'd until after rx'd pkt handling. */
} else {
NetTCP_TxConnAck(pconn, pbuf_hdr, tx_ack_code, NET_TCP_CONN_CLOSE_ALL, &err);
}
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeCfg()
*
* Description : (1) Configure TCP connection's transmit window controls :
*
* (a) Configure TCP connection's transmit window congestion controls
* (b) Configure TCP connection's transmit window minimum threshold
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_ConnCfg().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_ConnCfg().
*
* Note(s) : (2) A TCP connection's transmit window controls should NOT be updated until after the
* following TCP connection control(s) have been configured :
*
* (a) TCP connection's maximum transmit remote window size ('TxWinSizeRemoteMax')
* [see 'NetTCP_TxConnWinSizeCfgCongCtrl() Note #5a'
* & 'NetTCP_TxConnWinSizeCfgMinTh() Note #2a']
*
* (b) TCP connection's remaining transmit remote window size ('TxWinSizeRemoteRem')
* [see 'NetTCP_TxConnWinSizeCfgCongCtrl() Note #5b']
*
* (c) TCP connection's connection maximum segment size ('MaxSegSizeConn')
* [see 'NetTCP_TxConnWinSizeCfgCongCtrl() Note #5c']
*********************************************************************************************************
*/
static void NetTCP_TxConnWinSizeCfg (NET_TCP_CONN *pconn)
{
NetTCP_TxConnWinSizeCfgCongCtrl(pconn);
NetTCP_TxConnWinSizeCfgMinTh(pconn);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeCfgCongCtrl()
*
* Description : (1) Configure TCP connection's transmit window congestion controls :
*
* (a) Configure TCP connection's transmit window slow start threshold See Note #2
* (b) Configure TCP connection's transmit window congestion controls See Note #3
* (c) Reset TCP connection's transmit window duplicate acknowledgement
* controls
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnWinSizeCfg(),
* NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnWinSizeCfg(),
* NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Note(s) : (2) RFC #2581, Section 3.1 states that "the initial value of ssthresh [slow start
* threshold] MAY be arbitrarily high (for example, some implementations use the
* size of the advertised window)".
*
* (a) This amends RFC #2001, Section 2.1 which previously stated that "initialization
* for a given connection sets ... ssthresh to 65535 bytes".
*
* (b) To always ensure a sufficiently high initial value, the slow start threshold
* initializes to the TCP connection's maximum remote window size.
*
* (3) "The initial value of cwnd [congestion window], MUST be less than or equal to 2*SMSS
* bytes and MUST NOT be more than 2 segments."
*
* (a) This amends RFC #2001, Section 2.1 which previously stated that "initialization
* for a given connection sets cwnd to one segment".
*
* (4) (a) RFC #2001, Section 2.2 states that "the TCP output routine never sends more than
* the minimum of cwnd and the receiver's advertised window".
*
* (b) RFC #2581, Section 3.1 reiterates that "the minimum of cwnd and rwnd [receiver's
* advertised window] governs data transmission".
*
* See also 'NetTCP_TxConnWinSizeUpdateAvail() Note #1'.
*
* (5) A TCP connection's transmit window congestion controls should NOT be updated until
* after the following TCP connection control(s) have been configured :
*
* (a) TCP connection's maximum transmit remote window size ('TxWinSizeRemoteMax')
* [see 'NetTCP_RxPktConnHandlerTxWinRemote() Note #1a2A'
* & 'NetTCP_TxConnWinSizeHandlerCongCtrl() Notes #3a2A & #3b']
*
* (b) TCP connection's remaining transmit remote window size ('TxWinSizeRemoteRem')
* [see 'NetTCP_RxPktConnHandlerTxWinRemote() Note #1a2A'
* & 'NetTCP_TxConnWinSizeHandlerCongCtrl() Notes #3a2A']
*
* (c) TCP connection's connection maximum segment size ('MaxSegSizeConn')
* [see 'NetTCP_ConnCfgMaxSegSize() Note #1']
*********************************************************************************************************
*/
static void NetTCP_TxConnWinSizeCfgCongCtrl (NET_TCP_CONN *pconn)
{
/* Cfg tx slow start th (see Note #2b). */
pconn->TxWinSizeSlowStartThInit = (NET_TCP_WIN_SIZE)pconn->TxWinSizeRemoteMax;
pconn->TxWinSizeSlowStartTh = (NET_TCP_WIN_SIZE)pconn->TxWinSizeSlowStartThInit;
/* Cfg tx cong ctrls (see Note #3a). */
pconn->TxWinSizeCongInit = (NET_TCP_WIN_SIZE)pconn->MaxSegSizeConn * NET_TCP_CONG_WIN_MSS_SCALAR_INIT;
pconn->TxWinSizeCongCalcdActual = (NET_TCP_WIN_SIZE)pconn->TxWinSizeCongInit;
pconn->TxWinSizeCongCalcdCur = (NET_TCP_WIN_SIZE)0;
pconn->TxWinSizeCongRem = (NET_TCP_WIN_SIZE)pconn->TxWinSizeCongCalcdActual;
/* Cfg tx win avail (see Note #4). */
NetTCP_TxConnWinSizeUpdateAvail(pconn);
NetTCP_TxConnWinSizeDupAckCtrlReset(pconn); /* Reset dup ack ctrls. */
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeCfgMinTh()
*
* Description : Configure TCP connection's transmit silly window minimum threshold.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnWinSizeCfg(),
* NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnWinSizeCfg(),
* NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Note(s) : (1) RFC #1122, Section 4.2.3.4 states that "the sender's SWS avoidance algorithm is ...
* [to] send data ... if at least a fraction Fs of the maximum window can be sent ...
* Fs is a fraction whose recommended value is 1/2".
*
* (2) A TCP connection's transmit window minimum threshold should NOT be updated until
* after the following TCP connection control(s) have been configured :
*
* (a) TCP connection's maximum transmit remote window size ('TxWinSizeRemoteMax')
* [see 'NetTCP_RxPktConnHandlerTxWinRemote() Note #1a2A'
* & 'NetTCP_TxConnWinSizeHandlerCongCtrl() Notes #3a2A & #3b']
*********************************************************************************************************
*/
static void NetTCP_TxConnWinSizeCfgMinTh (NET_TCP_CONN *pconn)
{
/* Cfg silly win min th (see Note #1). */
pconn->TxWinSizeMinTh = (NET_TCP_WIN_SIZE)(((CPU_INT32U)pconn->TxWinSizeRemoteMax * NET_TCP_TX_SILLY_WIN_NUMER)
/ NET_TCP_TX_SILLY_WIN_DENOM);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeHandlerCfgd()
*
* Description : (1) Handle TCP connection's configured transmit window :
*
* (a) Update TCP connection configured transmit window
* (b) Update TCP connection total transmit data queued
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnAppData(),
* NetTCP_RxPktConnHandlerReTxQ().
*
* win_update_size Size to update TCP connection's transmit window (in octets).
*
* win_update_code Indicate how to update TCP connection transmit window :
*
* NET_TCP_CONN_TX_WIN_RESET Reset TCP connection's available
* transmit window size.
* NET_TCP_CONN_TX_WIN_SET Set TCP connection's available
* transmit window size.
* NET_TCP_CONN_TX_WIN_INC Increment TCP connection's available
* transmit window size.
* NET_TCP_CONN_TX_WIN_DEC Decrement TCP connection's available
* transmit window size.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection's configured transmit window
* successfully updated.
*
* --- RETURNED BY NetOS_TCP_TxQ_Signal() : ---
* NET_TCP_ERR_TX_Q_SIGNAL_FAULT TCP connection transmit queue signal fault.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnAppData(),
* NetTCP_RxPktConnHandlerReTxQ().
*
* Note(s) : (2) (a) RFC #793, Section 3.7 'Data Communication : Managing the Window' states
* that "the window sent in each segment indicates the range of sequence
* numbers the sender of the window (the data receiver) is currently
* prepared to accept. There is an assumption that this is related to the
* currently available data buffer space available for this connection".
*
* (b) Thus, a TCP connection's configured transmit window is constrained by
* the available network resources; of which, network buffers are the
* primary transmit window network resource.
*
* However, since network buffers are discrete resources with non-discrete
* packet size; it is NOT necessary to enforce exact/strict compliance with
* a TCP connection's configured transmit window.
*
* In other words, network buffers allocated for TCP connection transmit
* SHOULD be fully used even if the TCP connection's configured transmit
* window is zero.
*
* (3) Since the configured transmit window size may be asynchronously modified by
* the application layer, changes in the remaining transmit window size MUST be
* appropriately validated to any possible new value for the configured transmit
* window size :
*
* (a) During transmit window size increases, if the remaining transmit window
* size is already greater than the currently configured transmit window
* size; then the remaining window size is NOT increased, but is allowed to
* remain greater than the configured window size until the remaining window
* size decreases below the configured window size.
*
* (b) During transmit window size decreases, if the remaining transmit window
* size is already greater than the currently configured transmit window
* size; then the remaining window size is further decreased, but is allowed
* to remain greater than the configured window size until the remaining
* window size decreases below the configured window size.
*
* (c) Window size update is NOT validated for transmit window size resets.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnWinSizeHandlerCfgd (NET_TCP_CONN *pconn,
NET_TCP_WIN_SIZE win_update_size,
NET_TCP_WIN_CODE win_update_code,
NET_ERR *perr)
{
CPU_BOOLEAN q_prevly_full;
NET_TCP_WIN_SIZE win_size_avail;
NET_TCP_CONN_ID conn_id_tcp;
switch (win_update_code) {
case NET_TCP_CONN_TX_WIN_RESET: /* Reset cfg'd tx win size (see Note #1c). */
default:
pconn->TxWinSizeCfgdRem = pconn->TxWinSizeCfgd;
break;
case NET_TCP_CONN_TX_WIN_SET:
if (pconn->TxWinSizeCfgdRem < win_update_size) { /* If rem cfg'd win size < win update, ... */
pconn->TxWinSizeCfgdRem = win_update_size; /* .. set cfg'd win size. */
break;
} /* Else inc; do NOT shrink win. */
/* 'break' intentionally omitted; do NOT .. */
/* .. move from the following case : .. */
/* .. 'NET_TCP_CONN_TX_WIN_INC'. */
case NET_TCP_CONN_TX_WIN_INC:
if (win_update_size == 0) { /* If NO win update, do NOT update win. */
break;
}
q_prevly_full = (pconn->TxWinSizeCfgdRem < 1) ? DEF_YES : DEF_NO;
if (pconn->TxWinSizeCfgdRem < pconn->TxWinSizeCfgd) { /* If < cfg'd win size (see Note #3a), ... */
/* ... inc tx win size. */
win_size_avail = pconn->TxWinSizeCfgd - pconn->TxWinSizeCfgdRem;
if (win_size_avail > win_update_size) { /* If avail tx win size > win update, ... */
pconn->TxWinSizeCfgdRem += win_update_size; /* ... inc tx win size by win update. */
} else {
pconn->TxWinSizeCfgdRem = pconn->TxWinSizeCfgd; /* Else limit to cfg'd tx win size. */
}
}
if (q_prevly_full == DEF_YES) { /* If tx Q prev'ly full, ... */
conn_id_tcp = pconn->ID;
NetOS_TCP_TxQ_Signal(conn_id_tcp, perr); /* ... signal tx Q. */
if (*perr != NET_TCP_ERR_NONE) { /* #### On err, handle tx Q?; close TCP conn? */
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
return;
}
}
break;
case NET_TCP_CONN_TX_WIN_DEC:
if (win_update_size == 0) { /* If NO win update, do NOT update win. */
break;
}
if (pconn->TxWinSizeCfgdRem > win_update_size) { /* If rem tx win size > win update, .. */
pconn->TxWinSizeCfgdRem -= win_update_size; /* .. dec tx win size by win update. */
} else {
pconn->TxWinSizeCfgdRem = 0; /* Else limit to min tx win size. */
}
break;
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeHandlerCongCtrl()
*
* Description : (1) Handle TCP connection's transmit window congestion controls :
*
* (a) Perform slow start / congestion avoidance algorithms See Note #2c2A
* (b) Perform fast re-transmit / fast recovery algorithms See Note #2c2B
* (c) Handle remote host's receive window updates See Note #3
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandlerSeg(),
* NetTCP_RxPktConnHandlerReTxQ(),
* NetTCP_TxConnTxQ(),
* NetTCP_TxConnTxQ_TimeoutIdleSet(),
* NetTCP_TxConnTxQ_TimeoutIdle(),
* NetTCP_TxConnReTxQ().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* ack_code Indicates the received segment's acknowledgement condition :
*
* NET_TCP_CONN_RX_ACK_NONE NO received acknowledgement number.
*
* NET_TCP_CONN_RX_ACK_INVALID Received acknowledgement number
* is invalid for the TCP connection.
*
* NET_TCP_CONN_RX_ACK_VALID Received acknowledgement number
* is valid for the TCP connection.
*
* NET_TCP_CONN_RX_ACK_DUP Received acknowledgement number
* is a duplicate for the
* TCP connection.
*
* NET_TCP_CONN_RX_ACK_PREV Received acknowledgement number
* is a previous duplicate for the
* TCP connection.
*
* win_update_size Size to update TCP connection's transmit window (in octets).
*
* win_update_code Indicate how to update TCP connection transmit window :
*
* NET_TCP_CONN_TX_WIN_RESET Reset TCP connection's congestion
* control transmit window size.
* NET_TCP_CONN_TX_WIN_SEG_RXD Update TCP connection's congestion
* control transmit window size
* based on received segment.
* NET_TCP_CONN_TX_WIN_TIMEOUT Update TCP connection's congestion
* control transmit window size
* based on transmission timeout.
* NET_TCP_CONN_TX_WIN_INC Increment TCP connection's congestion
* control transmit window sizes.
* NET_TCP_CONN_TX_WIN_DEC Decrement TCP connection's
* transmit window sizes.
* NET_TCP_CONN_TX_WIN_REMOTE_UPDATE Update TCP connection's remote
* receive window size.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection's transmit window congestion controls
* successfully updated.
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
*
* --------- RETURNED BY NetTCP_TxConnReTxQ() : ---------
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
* NET_TCP_ERR_RE_TX_SEG_TH TCP connection closed due to excessive retransmission.
* NET_TCP_ERR_TX TCP transmit error.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerSeg(),
* NetTCP_RxPktConnHandlerReTxQ(),
* NetTCP_RxPktConnHandlerTxWinRemote(),
* NetTCP_TxConnTxQ(),
* NetTCP_TxConnTxQ_TimeoutIdleSet(),
* NetTCP_TxConnTxQ_TimeoutIdle(),
* NetTCP_TxConnReTxQ().
*$PAGE*
* Note(s) : (2) (a) (1) The following sections define, specify, &/or require "TCP's four intertwined congestion
* control algorithms: slow start, congestion avoidance, fast retransmit, and fast recovery" :
*
* (A) RFC #2001 See Note #2c1
* (B) RFC #2581 See Notes #2c2, #2a2, & #2e
* (C) RFC #1122
* (1) Section 4.2.2.15
* (2) Section 4.2.2.21
* (3) Section 4.2.3.9 See 'net_tcp.c Note #1e'
* (a) 'Source Quench' See Note #2e2
* (b) 'Destination Unreachable -- Codes 2-4'
*
*
* (2) Although RFC #2581, Section 1 states that "this document is an update of [RFC #2001]";
* both references are included as complementary specifications of the congestion control
* algorithms.
*
* However, since RFC #2581 is the update to RFC #2001, its specifications supercede
* those of RFC #2001; & ALL differences are implemented by RFC #2581 specifications.
*
* (b) (1) (A) RFC #2581, Section 3.1 states that "the slow start and congestion avoidance
* algorithms MUST be used by a TCP sender to control the amount of outstanding
* data being injected into the network".
*
* (B) RFC #1122, Section 4.2.2.15 reiterates that "a TCP MUST implement ... 'slow
* start' with 'congestion avoidance'".
*
* (2) (A) RFC #2001, Section 1 states that "the sender's ... congestion window ... is
* flow control imposed by the sender, while the advertised window is flow control
* imposed by the receiver. The former is based on the sender's assessment of
* perceived network congestion; the latter is related to the amount of available
* buffer space at the receiver for this connection".
*
* (B) RFC #2581, Section 3.1 reiterates that "the congestion window ... is a sender-
* side limit on the amount of data the sender can transmit into the network
* before receiving an acknowledgment (ACK), while the receiver's advertised
* window ... is a receiver-side limit on the amount of outstanding data."
*
* (3) (A) (1) RFC #2001, Section 1 states that "the sender can transmit up to the minimum
* of the congestion window and the advertised window."
*
* (2) RFC #2001, Section 2.2 reiterates that "the TCP output routine never sends
* more than the minimum of cwnd and the receiver's advertised window".
*
* (3) RFC #2581, Section 3.1 also reiterates that "the minimum of cwnd and rwnd
* [receiver's advertised window] governs data transmission".
*
* (B) RFC #2581, Section 3 also states that "a TCP MUST NOT be more aggressive than
* the [congestion control] algorithms allow (that is, MUST NOT send data when
* the value of cwnd computed by the [congestion control] algorithms would not
* allow the data to be sent)".
*
* (C) TCP transmit resulting from TCP congestion controls update handled by appropriate
* TCP connection state receive handler function(s).
*
* See 'NetTCP_RxPktConnHandlerSyncRxd() Note #1c3',
* 'NetTCP_RxPktConnHandlerSyncTxd() Note #1c3',
* 'NetTCP_RxPktConnHandlerConn() Note #1c',
* 'NetTCP_RxPktConnHandlerFinWait1() Note #1c',
* 'NetTCP_RxPktConnHandlerClosing() Note #1c',
* 'NetTCP_RxPktConnHandlerCloseWait() Note #1c',
* & 'NetTCP_RxPktConnHandlerLastAck() Note #1c'.
*
* (4) (A) RFC #2001, Sections 3 & 4 state that "since ... a duplicate ACK is caused by
* a lost segment or just a reordering of segments, ... [fast retransmit] waits
* for a small number of duplicate ACKs to be received ... [as] a strong indication
* that a segment has been lost ... [and] then performs a retransmission of what
* appears to be the missing segment, without waiting for a retransmission timer
* to expire.
*
* After fast retransmit sends ... the missing segment, congestion avoidance,
* but not slow start is performed. This is the fast recovery algorithm".
*
* (B) RFC #2581, Section 3.2 reiterates that "the TCP sender SHOULD use the 'fast
* retransmit' algorithm to detect and repair loss, based on ... the arrival of
* 3 duplicate ACKs (4 identical ACKs without the arrival of any other intervening
* packets) as an indication that a segment has been lost. After receiving 3
* duplicate ACKs, TCP performs a retransmission of what appears to be the missing
* segment, without waiting for the retransmission timer to expire.
*
* After the fast retransmit algorithm sends ... the missing segment, the 'fast
* recovery' algorithm ... can continue to transmit new segments ... (using a
* reduced cwnd) ... until a non-duplicate ACK arrives".
*$PAGE*
* (c) (1) (A) RFC #2001, Section 2 states that the "congestion avoidance and slow start ...
* combined algorithm operates as follows" :
*
* (1) "Initialization for a given connection sets" :
*
* (a) "cwnd to one segment" ...
* (b) "and ssthresh to 65535 bytes."
*
* (3) (a) (1) "When congestion occurs (indicated by" :
*
* (A) "a timeout" ...
* (B) "or the reception of duplicate ACKs)," ...
*
* (2) "one-half of the current window size" :
*
* (A) "the minimum of" :
* (1) "cwnd" ...
* (2) "and the receiver's advertised window" ...
* (B) "but at least two segments" ...
*
* (3) "is saved in ssthresh [slow start threshold]."
*
* (b) (1) "Additionally, if the congestion is indicated by a timeout," ...
* (2) "cwnd is set to one segment (i.e., slow start)."
*
* (4) "When new data is acknowledged by the other end, increase cwnd, but the way
* it increases depends on whether TCP is performing slow start or congestion
* avoidance" :
*
* (a) (1) (A) (1) (a) "If cwnd is less than or equal to ssthresh," ...
* (b) "TCP is in slow start."
*
* (2) "Slow start continues until TCP is halfway to where it was
* when congestion occurred (since it recorded half of the
* window size that caused the problem)."
*
* (B) (1) "Slow start has cwnd begin at one segment," ...
*
* (2) (a) "and be incremented by one segment" ...
* (b) "every time an ACK is received."
*
* (3) "The increase in cwnd ... [for] slow start increments cwnd
* by the number of ACKs received in a round-trip time ...
* [which] opens the window exponentially: send one segment,
* then two, then four, and so on."
*
* (2) RFC #2001, Section 1 states that :
*
* (A) "Early implementations performed slow start only if the other
* end was on a different network."
*
* (B) "Current implementations always perform slow start."
*
* (b) (1) (A) "If cwnd is [not] less than or equal to ssthresh," ...
* (B) "TCP is performing congestion avoidance."
*
* (2) (A) (1) "cwnd [is] incremented by segsize*segsize/cwnd" ...
* (a) "where segsize is the segment size" ...
* (b) "and cwnd is maintained in bytes";
* (2) "each time an ACK is received."
*
* (B) "This is a linear growth of cwnd ... The increase in cwnd should
* be at most one segment each round-trip time (regardless how many
* ACKs are received in that RTT)."
*
* (B) RFC #2001, Section 4 states that "the fast retransmit and fast recovery
* algorithms are usually implemented together as follows" :
*
* (1) "When the third duplicate ACK in a row is received" :
*
* (a) "Set ssthresh to" :
* (1) "one-half the current congestion window, cwnd" ...
* (2) "but no less than two segments."
*
* (b) "Retransmit the missing segment."
*
* (c) "Set cwnd to ssthresh plus 3 times the segment size."
*
* (2) "Each time another duplicate ACK arrives" :
*
* (a) "Increment cwnd by the segment size."
* (b) "Transmit a packet, if allowed by the new value of cwnd."
*
* (3) "When the next ACK arrives that acknowledges new data" :
*
* (a) "Set cwnd to ssthresh" (see Note #2c1B1a).
*$PAGE*
* (2) (A) RFC #2581, Section 3.1 defines the "slow start and congestion avoidance algorithms"
* as follows :
*
* (1) (a) "The initial value of cwnd, MUST be" :
*
* (1) "less than or equal to 2*SMSS bytes" ...
* (2) "and MUST NOT be more than 2 segments."
*
* (b) "The initial value of ssthresh MAY be arbitrarily high" :
* (1) "some implementations use the size of the advertised window."
*
* (2) (a) "The slow start algorithm is used when cwnd < ssthresh," ...
* (b) "while the congestion avoidance algorithm is used when cwnd > ssthresh."
* (c) "When cwnd and ssthresh are equal the sender may use either slow start or
* congestion avoidance."
*
* (3) (a) "During slow start" :
*
* (1) "a TCP increments cwnd by at most SMSS bytes" ...
* (2) "for each ACK received that acknowledges new data."
*
* (b) "Slow start ends when" :
*
* (1) "cwnd exceeds ... or ... reaches ... ssthresh" ...
* (2) "or when congestion is observed."
*
* (4) (a) "During congestion avoidance" :
*
* (1) "cwnd is incremented by 1 full-sized segment per round-trip time (RTT)."
*
* (2) (A) "One formula commonly used to update cwnd during congestion avoidance
* is given" by :
*
* (2) cwnd += (SMSS * SMSS) / cwnd
*
* (B) "Another acceptable way to increase cwnd during congestion avoidance
* is to count the number of bytes that have been acknowledged by ACKs
* for new data" :
*
* (1) "When the number of bytes acknowledged reaches cwnd," ...
* (2) "then cwnd can be incremented by up to SMSS bytes."
*
* (3) "This adjustment is executed on every incoming non-duplicate ACK."
*
* (b) "Congestion avoidance continues until congestion is detected."
*
* (5) "When a TCP sender detects segment loss using the retransmission timer" :
*
* (a) "the value of ssthresh MUST be set to no more than" :
*
* (3) ssthresh = max (FlightSize / 2, 2 * SMSS)
*
* (A) "FlightSize is the amount of outstanding data ... that has been
* sent but not yet acknowledged."
*
* (b) "cwnd MUST be set to no more than ... 1 full-sized segment."
*
* (c) "Therefore, after retransmitting the dropped segment the TCP sender uses
* the slow start algorithm to increase the window."
*$PAGE*
* (B) RFC #2581, Section 3.2 states that "the fast retransmit and fast recovery algorithms
* are usually implemented together as follows" :
*
* (1) "When the third duplicate ACK is received" (see Note #2d1) :
*
* (a) "set ssthresh to no more than the value given [by the] equation"
* (see Note #2c2A5a3), ...
*
* (b) "Retransmit the lost segment"
* (see Note #2d2), ...
*
* (c) "set cwnd to ssthresh plus 3*SMSS."
* (1) "This artificially 'inflates' the congestion window by the number of
* segments (three) that have left the network and which the receiver
* has buffered."
*
* (2) "For each additional duplicate ACK received" :
*
* (a) "increment cwnd by SMSS."
* (1) "This artificially inflates the congestion window in order to reflect
* the additional segment that has left the network."
*
* (b) (1) "Transmit a segment, if allowed by" :
*
* (A) "the new value of cwnd" ...
* (B) "and the receiver's advertised window."
*
* (2) TCP transmit resulting from TCP congestion controls update handled by
* appropriate TCP connection state receive handler function(s).
*
* See also Note #2b3C.
*
* (3) (a) "When the next ACK arrives that acknowledges new data," ...
* (b) "set cwnd to ssthresh" (see Note #2c2B1a).
*
* (d) (1) (A) RFC #1122, Section 4.2.2.21 states that "'fast retransmit' ... counts the number of
* ... 'redundant' ACK's ... received with" :
*
* (1) "the same value of SEG.ACK and" ...
* (2) "the same right window edge".
*
* (B) Although it is not directly stated, it is inferred that duplicate acknowledgements
* SHOULD be :
*
* (1) Acknowledgement-only segments
* (a) i.e. with NO transmit data See Note #2d1C1
* (1) i.e. with NO TCP segment length
* (2) With NO sequence number update
* (3) With NO receive window size update See Note #2d1C2
*
* (C) Also although RFC #2581, Section 3.2 states that "the TCP sender SHOULD use the
* 'fast retransmit' algorithm ... based on ... the arrival of ... 4 identical ACKs
* without the arrival of any other intervening packets"; it seems reasonable that
* the TCP fast retransmit algorithm MUST NOT consider the arrival of non-duplicate
* acknowledgement segments as "intervening packets".
*
* In other words, TCP fast retransmit MUST ignore the following TCP packets as
* duplicate acknowledgement packets :
*
* (1) TCP data segments
* (2) Remote host receive window updates
*
* (2) RFC #1122, Section 4.2.2.21 reiterates that "with this ... 'fast retransmit' ...
* algorithm, the sender uses the redundant ACK's to deduce that a segment has been
* lost before the retransmission timer has expired. If more than a threshold number
* of such ACK's is received, then the segment containing the octets starting at
* SEG.ACK is assumed to have been lost and is retransmitted, without awaiting a
* timeout".
*
* (e) (1) RFC #2581, Section 4.1 states that "after TCP has been idle for a relatively long period
* of time ... use slow start to restart transmission" :
*
* (A) (1) "If the TCP has not sent data in an interval exceeding the retransmission timeout"
* (2) "cwnd is reduced to ... no more than ... the value of the restart window"
* (see Note #2c2A1).
*
* See also 'NetTCP_TxConnTxQ_TimeoutIdle() Note #2a'.
*
* (B) Although NO RFC specifies that a TCP connection's slow start threshold should be
* reset following a TCP transmit idle timeout; it seems reasonable to reset the slow
* start threshold whenever the TCP transmit congestion window is reset.
*
* See also 'NetTCP_TxConnWinSizeCfgCongCtrl() Notes #2 & #3'.
*
* (2) RFC #1122, Section 4.2.3.9 'Source Quench' states that "TCP MUST react to a Source Quench
* by slowing transmission on the connection. The RECOMMENDED procedure is ... to trigger a
* 'slow start', as if a retransmission timeout had occurred".
*$PAGE*
* (3) (a) (1) The following sections ... :
*
* (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* ESTABLISHED STATE'
* (B) RFC #1122, Section 4.2.2.20.(c)
* (C) RFC #1122, Section 4.2.2.20.(f)
*
* (2) ... generalize that "the following variables should be set ... [when] the send
* window should be updated" :
*
* (A) SND.WND <- SEG.WND
*
* (1) A TCP connection's remote host receive window advertisements are relative
* to the received window advertisement acknowledgement sequence number, &
* are asynchronous to the TCP connection's recent transmitted sequences.
*
* Therefore, the actual transmit remote window size MUST be compensated by
* the difference in the remote host receive window advertisement & the TCP
* connection's number of recently transmitted sequences :
*
* (a) TxWinSizeRemoteActual = SEG.WIN - (SND.NXT - SEG.ACK)
*
* where
*
* TxWinSizeRemoteActual TCP connection's actual transmit
* remote window size
*
* (B) SND.WL1 <- SEG.SEQ
* (C) SND.WL2 <- SEG.ACK
*
* (b) RFC #1122, Section 4.2.3.4 'IMPLEMENTATION' states that "because the sender does not
* know (directly) the receiver's total buffer space RCV.BUFF ... An approach [that] has
* been found to work well is for the sender to calculate Max(SND.WND), the maximum send
* window it has seen so far on the connection, and to use this value as an estimate of
* RCV.BUFF".
*
* (c) RFC #1122, Section 4.2.2.17 states that although "a TCP MAY keep its offered receive
* window closed indefinitely ... the sending TCP MUST allow the connection to stay open
* ... as long as the receiving TCP continues to send acknowledgments in response to ...
* probe segments".
*
* See also 'NetTCP_TxConnWinSizeZeroWinHandler() Note #1'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnWinSizeHandlerCongCtrl (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_ACK_CODE ack_code,
NET_TCP_WIN_SIZE win_update_size,
NET_TCP_WIN_CODE win_update_code,
NET_ERR *perr)
{
CPU_BOOLEAN ack_dup;
NET_TCP_WIN_SIZE tx_win_size_remote_actual;
NET_TCP_WIN_SIZE tx_win_size_remote_actual_min;
switch (win_update_code) {
case NET_TCP_CONN_TX_WIN_RESET:
default:
NetTCP_TxConnWinSizeCfgCongCtrl(pconn); /* Reset tx cong ctrls (see Note #2e). */
break;
case NET_TCP_CONN_TX_WIN_SEG_RXD:
switch (ack_code) {
case NET_TCP_CONN_RX_ACK_VALID:
/* -------------- FAST RECOVERY --------------- */
/* If valid ack rx'd after fast re-tx th, .. */
if (pconn->TxWinRxdAckDupCtr >= NET_TCP_FAST_RE_TX_ACK_DUP_TH) {
/* .. perform fast recovery (see Note #2c2B3) : */
/* .. set cong win to slow start th .. */
/* .. (see Note #2c2B3b). */
NetTCP_TxConnWinSizeCongSet(pconn, NET_TCP_CONN_TX_WIN_CONG_SET_SLOW_START);
NetTCP_TxConnWinSizeUpdateAvail(pconn); /* Update avail tx win (see Note #2b3). */
} else { /* -------- SLOW START / CONG AVOIDANCE ------- */
/* If cong win < slow start th .. */
/* .. (see Notes #2c2A2a), .. */
if (pconn->TxWinSizeCongCalcdActual < pconn->TxWinSizeSlowStartTh) {
/* .. perform slow start (see Note #2c2A3) : */
/* .. inc cong win by MSS (see Note #2c2A3a1). */
NetTCP_TxConnWinSizeCongInc(pconn, pbuf_hdr, 0, NET_TCP_CONN_TX_WIN_CONG_INC_SLOW_START);
} else { /* If cong win >= slow start th .. */
/* .. (see Note #2c2A2b & #2c2A2c), .. */
/* .. perform cong avoid (see Note #2c2A4) : */
/* .. inc cong win (see Note #2c2A4a2B). */
NetTCP_TxConnWinSizeCongInc(pconn, pbuf_hdr, 0, NET_TCP_CONN_TX_WIN_CONG_INC_CONG_AVOID);
}
NetTCP_TxConnWinSizeUpdateAvail(pconn); /* Update avail tx win (see Note #2b3A). */
}
#if 0 /* Tx avail seg(s) [see Note #2b3C]. */
NetTCP_TxConnTxQ(pconn, pbuf_hdr, ack_code, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
return; /* Prevent 'break NOT reachable' warning. */
}
#endif
/* Reset dup ack ctrls. */
NetTCP_TxConnWinSizeDupAckCtrlUpdate(pconn, pbuf_hdr, DEF_YES);
break;
/*$PAGE*/
case NET_TCP_CONN_RX_ACK_DUP: /* -------- FAST RE-TX / FAST RECOVERY -------- */
/* Chk dup ack (see Notes #2b4 & #2d1). */
ack_dup = ((pbuf_hdr->TCP_SeqNbr == pconn->TxWinRxdLastSeqNbr ) &&
(pbuf_hdr->TCP_AckNbr == pconn->TxWinRxdLastAckNbr ) &&
(pbuf_hdr->TCP_WinSize == pconn->TxWinRxdLastWinSize) &&
(pbuf_hdr->TCP_SegLen == 0 )) ? DEF_YES : DEF_NO;
if (ack_dup == DEF_YES) { /* If dup ack, .. */
pconn->TxWinRxdAckDupCtr++; /* .. inc dup ack ctr. */
/* If equal to fast re-tx th, .. */
if (pconn->TxWinRxdAckDupCtr == NET_TCP_FAST_RE_TX_ACK_DUP_TH) {
/* .. perform fast re-tx (see Note #2c2B1) : .. */
/* .. calc slow start th (see Note #2c2B1a); .. */
NetTCP_TxConnWinSizeCalcSlowStartTh(pconn);
/* .. re-tx unack'd seg (see Note #2c2B1b); .. */
NetTCP_TxConnReTxQ(pconn, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_ERR_TX: /* Ignore transitory re-tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_TX:
case NET_TCP_ERR_RE_TX_SEG_TH:
default:
return; /* Prevent 'break NOT reachable' warning. */
}
/* .. set cong win to fast recovery th .. */
/* .. (see Note #2c2B1c). */
NetTCP_TxConnWinSizeCongSet(pconn, NET_TCP_CONN_TX_WIN_CONG_SET_FAST_RECOVERY);
NetTCP_TxConnWinSizeUpdateAvail(pconn); /* Update avail tx win (see Note #2b3). */
/* Else if > fast re-tx th, .. */
} else if (pconn->TxWinRxdAckDupCtr > NET_TCP_FAST_RE_TX_ACK_DUP_TH) {
/* .. perform fast recovery (see Note #2c2B2) : */
/* .. inc cong win by MSS (see Note #2c2B2a); */
NetTCP_TxConnWinSizeCongInc(pconn, pbuf_hdr, 0, NET_TCP_CONN_TX_WIN_CONG_INC_SLOW_START);
NetTCP_TxConnWinSizeUpdateAvail(pconn); /* .. update avail tx win (see Note #2b3) .. */
#if 0 /* .. & tx avail seg(s) [see Note #2c2B2b]. */
NetTCP_TxConnTxQ(pconn, pbuf_hdr, ack_code, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
return; /* Prevent 'break NOT reachable' warning. */
}
#endif
}
} else { /* Else update dup ack ctrls (see Note #2d1C). */
NetTCP_TxConnWinSizeDupAckCtrlUpdate(pconn, pbuf_hdr, DEF_NO);
}
break;
/*$PAGE*/
case NET_TCP_CONN_RX_ACK_PREV: /* Ignore prev dup acks. */
*perr = NET_TCP_ERR_NONE;
return; /* Prevent 'break NOT reachable' warning. */
case NET_TCP_CONN_RX_ACK_NONE:
case NET_TCP_CONN_RX_ACK_INVALID:
default:
*perr = NET_TCP_ERR_CONN_FAIL;
return; /* Prevent 'break NOT reachable' warning. */
}
break;
case NET_TCP_CONN_TX_WIN_TIMEOUT: /* --------------- SLOW START ----------------- */
/* On timeout (see Note #2c2A5), .. */
/* .. perform slow start (see Note #2c2A5c) : */
NetTCP_TxConnWinSizeCalcSlowStartTh(pconn); /* .. calc slow start th (see Note #2c2A5a); .. */
/* .. set cong win to timeout th .. */
/* .. (see Note #2c2A5b). */
NetTCP_TxConnWinSizeCongSet(pconn, NET_TCP_CONN_TX_WIN_CONG_SET_TIMEOUT);
NetTCP_TxConnWinSizeUpdateAvail(pconn); /* Update avail tx win (see Note #2b3). */
break;
case NET_TCP_CONN_TX_WIN_INC:
if (win_update_size == 0) { /* If NO win update, do NOT update win. */
break;
}
/* Inc rem cong win size. */
NetTCP_TxConnWinSizeCongInc(pconn, pbuf_hdr, win_update_size, NET_TCP_CONN_TX_WIN_CONG_INC_REM);
NetTCP_TxConnWinSizeUpdateAvail(pconn); /* Update avail tx win (see Note #2b3). */
break;
case NET_TCP_CONN_TX_WIN_DEC:
if (win_update_size == 0) { /* If NO win update, do NOT update win. */
break;
}
if (pconn->TxWinSizeCongRem > win_update_size) { /* If rem cong win size > win update, .. */
pconn->TxWinSizeCongRem -= win_update_size; /* .. dec cong win size by win update. */
} else {
pconn->TxWinSizeCongRem = 0; /* Else limit to min cong win size. */
}
if (pconn->TxWinSizeRemoteRem > win_update_size) { /* If rem remote win size > win update, .. */
pconn->TxWinSizeRemoteRem -= win_update_size; /* .. dec remote win size by win update. */
} else {
pconn->TxWinSizeRemoteRem = 0; /* Else limit to min remote win size. */
}
NetTCP_TxConnWinSizeUpdateAvail(pconn); /* Update avail tx win (see Note #2b3). */
break;
case NET_TCP_CONN_TX_WIN_REMOTE_UPDATE:
/* Calc actual tx remote win (see Note #3a2A1a).*/
tx_win_size_remote_actual = (NET_TCP_WIN_SIZE)(pbuf_hdr->TCP_WinSize - (pconn->TxSeqNbrNext - pbuf_hdr->TCP_AckNbr));
tx_win_size_remote_actual_min = (NET_TCP_WIN_SIZE) DEF_MIN(pbuf_hdr->TCP_WinSize, tx_win_size_remote_actual);
/* Update tx remote win (see Note #3a2). */
pconn->TxWinSizeRemote = (NET_TCP_WIN_SIZE) pbuf_hdr->TCP_WinSize;
pconn->TxWinSizeRemoteActual = (NET_TCP_WIN_SIZE) tx_win_size_remote_actual_min;
pconn->TxWinSizeRemoteRem = (NET_TCP_WIN_SIZE) pconn->TxWinSizeRemoteActual;
pconn->TxWinUpdateSeqNbr = (NET_TCP_SEQ_NBR ) pbuf_hdr->TCP_SeqNbr;
pconn->TxWinUpdateAckNbr = (NET_TCP_SEQ_NBR ) pbuf_hdr->TCP_AckNbr;
pconn->TxWinUpdateWinSize = (NET_TCP_WIN_SIZE) pbuf_hdr->TCP_WinSize;
if (pconn->TxWinSizeRemoteMax < pconn->TxWinSizeRemote) { /* If max < updated remote win size, ... */
pconn->TxWinSizeRemoteMax = pconn->TxWinSizeRemote; /* ... set as new max (see Note #3b). */
NetTCP_TxConnWinSizeCfgMinTh(pconn); /* Cfg new tx silly win min th. */
}
/* Handle zero win size (see Note #3c). */
NetTCP_TxConnWinSizeZeroWinHandler(pconn, NET_TCP_CONN_TX_WIN_REMOTE_UPDATE, NET_TCP_CONN_CLOSE_ALL);
NetTCP_TxConnWinSizeUpdateAvail(pconn); /* Update avail tx win (see Note #2b3). */
break;
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeCalcSlowStartTh()
*
* Description : Calculate TCP connection's transmit slow start threshold.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Note(s) : (1) RFC #2581, Section 3.1 states that ... :
*
* (a) "the value of ssthresh MUST be set to no more than" :
*
* (3) ssthresh = max (FlightSize / 2, 2 * SMSS)
*
* (A) "FlightSize is the amount of outstanding data ... that has been sent but
* not yet acknowledged."
*
* See also 'NetTCP_TxConnWinSizeHandlerCongCtrl() Note #2c2A5a'.
*********************************************************************************************************
*/
static void NetTCP_TxConnWinSizeCalcSlowStartTh (NET_TCP_CONN *pconn)
{
NET_TCP_SEQ_NBR tx_data_unackd;
NET_TCP_SEQ_NBR tx_data_unackd_th;
NET_TCP_SEG_SIZE max_seg_size_th;
/* Calc slow start th (see Note #1a3). */
tx_data_unackd = (NET_TCP_SEQ_NBR ) (pconn->TxSeqNbrNext - pconn->TxSeqNbrUnAckd);
tx_data_unackd_th = (NET_TCP_SEQ_NBR )((tx_data_unackd * NET_TCP_SST_UNACKD_DATA_NUMER)
/ NET_TCP_SST_UNACKD_DATA_DENOM);
max_seg_size_th = (NET_TCP_SEG_SIZE)pconn->MaxSegSizeConn * NET_TCP_SST_MSS_SCALAR;
pconn->TxWinSizeSlowStartTh = (NET_TCP_WIN_SIZE)DEF_MAX(tx_data_unackd_th,
max_seg_size_th);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeCongSet()
*
* Description : Set TCP connection's transmit congestion window.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* win_inc_code Indicate how to set TCP connection transmit congestion window :
*
* NET_TCP_CONN_TX_WIN_CONG_SET_SLOW_START Set TCP connection's congestion
* control transmit window size
* based on slow start.
*
* NET_TCP_CONN_TX_WIN_CONG_SET_FAST_RECOVERY Set TCP connection's congestion
* control transmit window size
* based on fast recovery
* (see Note #1a).
*
* NET_TCP_CONN_TX_WIN_CONG_SET_TIMEOUT Set TCP connection's congestion
* control transmit window size
* based on transmission timeout
* (see Note #1b).
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Note(s) : (1) (a) RFC #2581, Section 3.2 states that "when the third duplicate ACK is received ...
* [for] fast recovery ... set cwnd to ssthresh plus 3*SMSS".
*
* See also 'NetTCP_TxConnWinSizeHandlerCongCtrl() Note #2c2B1c'.
*
* (b) RFC #2581, Section 3.1 states that "when a TCP sender detects segment loss using the
* retransmission timer ... cwnd MUST be set to no more than ... 1 full-sized segment".
*
* See also 'NetTCP_TxConnWinSizeHandlerCongCtrl() Note #2c2A5b'.
*********************************************************************************************************
*/
static void NetTCP_TxConnWinSizeCongSet (NET_TCP_CONN *pconn,
NET_TCP_WIN_CODE win_inc_code)
{
NET_TCP_WIN_SIZE win_size_set;
switch (win_inc_code) {
case NET_TCP_CONN_TX_WIN_CONG_SET_SLOW_START:
win_size_set = (NET_TCP_WIN_SIZE)pconn->TxWinSizeSlowStartTh;
break;
case NET_TCP_CONN_TX_WIN_CONG_SET_FAST_RECOVERY: /* See Note #1a. */
win_size_set = (NET_TCP_WIN_SIZE)pconn->TxWinSizeSlowStartTh;
win_size_set += (NET_TCP_WIN_SIZE)pconn->MaxSegSizeConn * NET_TCP_FAST_RECOVERY_MSS_SCALAR;
break;
case NET_TCP_CONN_TX_WIN_CONG_SET_TIMEOUT: /* See Note #1b. */
default:
win_size_set = (NET_TCP_WIN_SIZE)pconn->MaxSegSizeConn * NET_TCP_CONG_WIN_MSS_SCALAR_TIMEOUT;
break;
}
pconn->TxWinSizeCongCalcdActual = win_size_set;
pconn->TxWinSizeCongCalcdCur = 0;
pconn->TxWinSizeCongRem = pconn->TxWinSizeCongCalcdActual;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeCongInc()
*
* Description : Increment TCP connection's transmit congestion window.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* win_update_size Size to increment TCP connection's transmit congestion window (in octets).
*
* win_inc_code Indicate how to increment TCP connection transmit congestion window :
*
* NET_TCP_CONN_TX_WIN_CONG_INC_SLOW_START Increment TCP connection's congestion
* control transmit window size
* based on slow start
* (see Note #1a).
*
* NET_TCP_CONN_TX_WIN_CONG_INC_CONG_AVOID Increment TCP connection's congestion
* control transmit window size
* based on congestion avoidance
* (see Note #1b).
*
* NET_TCP_CONN_TX_WIN_CONG_INC_REM Increment TCP connection's congestion
* control transmit window size
* remaining.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Note(s) : (1) RFC #2581, Section 3.1 states that ... :
*
* (a) "During slow start, a TCP increments cwnd by at most SMSS bytes for each ACK received
* that acknowledges new data."
*
* See also 'NetTCP_TxConnWinSizeHandlerCongCtrl() Note #2c2A3a'.
*
* (b) "During congestion avoidance, cwnd is incremented by 1 full-sized segment per round-
* trip time (RTT) ... [An] acceptable way to increase cwnd during congestion avoidance
* is to" :
*
* (1) "Count the number of bytes that have been acknowledged by ACKs for new data."
*
* (A) The following equation calculates the number of octets that acknowledge
* new data for a TCP connection :
*
* Number of Octets Acknowledged = (SEG.ACK - SND.UNA)
*
* (B) However, since TCP connection transmit congestion controls are
* updated following any TCP connection re-transmit queue handling
* (see 'NetTCP_RxPktConnHandlerSeg() Notes #1c & #1d'); the saved
* previous value of the TCP connection's last unacknowledged
* transmit sequence number ('TxSeqNbrUnackdPrev') MUST be used
* (see 'NetTCP_RxPktConnHandlerReTxQ() Note #4').
*
* (2) "When the number of bytes acknowledged reaches cwnd," ...
* (3) "then cwnd can be incremented by up to SMSS bytes."
*
* See also 'NetTCP_TxConnWinSizeHandlerCongCtrl() Note #2c2A4'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnWinSizeCongInc (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_WIN_SIZE win_update_size,
NET_TCP_WIN_CODE win_inc_code)
{
CPU_BOOLEAN win_size_rem_update;
NET_TCP_WIN_SIZE win_size_inc;
NET_TCP_WIN_SIZE win_size_inc_mss;
NET_TCP_WIN_SIZE win_size_inc_rem;
NET_TCP_WIN_SIZE win_size_avail;
win_size_rem_update = DEF_NO;
win_size_inc_mss = (NET_TCP_WIN_SIZE)pconn->MaxSegSizeConn * NET_TCP_CONG_WIN_MSS_SCALAR_INC;
switch (win_inc_code) {
case NET_TCP_CONN_TX_WIN_CONG_INC_SLOW_START: /* See Note #1a. */
default:
win_size_avail = NET_TCP_WIN_SIZE_MAX - pconn->TxWinSizeCongCalcdActual;
if (win_size_inc_mss < win_size_avail) { /* If inc < max avail, .. */
pconn->TxWinSizeCongCalcdActual += win_size_inc_mss; /* .. inc cong win by MSS (see Note #1a). */
} else {
pconn->TxWinSizeCongCalcdActual = NET_TCP_WIN_SIZE_MAX; /* Else set cong win to max. */
}
pconn->TxWinSizeCongCalcdCur = 0;
win_size_rem_update = DEF_YES;
win_size_inc_rem = win_size_inc_mss;
break;
case NET_TCP_CONN_TX_WIN_CONG_INC_CONG_AVOID: /* See Note #1b. */
/* Calc nbr ack'd octets (see Note #1b1). */
win_size_inc = (NET_TCP_WIN_SIZE)((NET_TCP_SEQ_NBR)pbuf_hdr->TCP_AckNbr - pconn->TxSeqNbrUnAckdPrev);
win_size_avail = NET_TCP_WIN_SIZE_MAX - pconn->TxWinSizeCongCalcdActual;
if (win_size_inc < win_size_avail) { /* If inc < max avail, .. */
pconn->TxWinSizeCongCalcdCur += win_size_inc; /* .. inc nbr ack'd octets (see Note #1b1). */
/* If >= cong win (see Note #1b2), */
/* .. inc cong win by MSS (see Note #1b3). */
if (pconn->TxWinSizeCongCalcdCur >= pconn->TxWinSizeCongCalcdActual) {
pconn->TxWinSizeCongCalcdCur -= pconn->TxWinSizeCongCalcdActual;
win_size_avail = NET_TCP_WIN_SIZE_MAX - pconn->TxWinSizeCongCalcdActual;
if (win_size_inc_mss < win_size_avail) {
pconn->TxWinSizeCongCalcdActual += win_size_inc_mss;
} else {
pconn->TxWinSizeCongCalcdActual = NET_TCP_WIN_SIZE_MAX;
}
/* Cfg rem cong win inc by MSS. */
win_size_rem_update = DEF_YES;
win_size_inc_rem = win_size_inc_mss;
}
} else { /* Else set cong win to max. */
pconn->TxWinSizeCongCalcdActual = NET_TCP_WIN_SIZE_MAX;
win_size_avail = NET_TCP_WIN_SIZE_MAX - pconn->TxWinSizeCongCalcdCur;
if (win_size_inc < win_size_avail) { /* If inc < max avail, .. */
pconn->TxWinSizeCongCalcdCur += win_size_inc; /* .. inc nbr ack'd octets (see Note #1b1). */
} else { /* Else set nbr ack'd octets to inc ovf ... */
pconn->TxWinSizeCongCalcdCur = win_size_inc - win_size_avail;
/* ... & cfg rem cong win inc by MSS. */
win_size_rem_update = DEF_YES;
win_size_inc_rem = win_size_inc_mss;
}
}
break;
case NET_TCP_CONN_TX_WIN_CONG_INC_REM: /* Cfg rem cong win inc by win update size. */
win_size_rem_update = DEF_YES;
win_size_inc_rem = win_update_size;
break;
}
if (win_size_rem_update == DEF_YES) { /* If rem tx cong win update req'd ... */
if (pconn->TxWinSizeCongRem < pconn->TxWinSizeCongCalcdActual) { /* ... & < actual tx cong win size, ... */
/* ... inc rem tx cong win size. */
win_size_avail = pconn->TxWinSizeCongCalcdActual - pconn->TxWinSizeCongRem;
if (win_size_inc_rem < win_size_avail) { /* If avail win size > rem inc, ... */
pconn->TxWinSizeCongRem += win_size_inc_rem; /* ... inc rem tx cong win size by rem inc. */
} else { /* Else limit to actual tx cong win size. */
pconn->TxWinSizeCongRem = pconn->TxWinSizeCongCalcdActual;
}
}
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeUpdateAvail()
*
* Description : Update TCP connection's available transmit window.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnWinSizeCfgCongCtrl(),
* NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Note(s) : (1) (a) RFC #2001, Section 1 states that "the sender can transmit up to the minimum
* of the congestion window and the advertised window."
*
* (b) RFC #2001, Section 2.2 reiterates that "the TCP output routine never sends
* more than the minimum of cwnd and the receiver's advertised window".
*
* (c) RFC #2581, Section 3.1 also reiterates that "the minimum of cwnd and rwnd
* [receiver's advertised window] governs data transmission".
*
* See also 'NetTCP_TxConnWinSizeHandlerCongCtrl() Note #2b3'.
*********************************************************************************************************
*/
static void NetTCP_TxConnWinSizeUpdateAvail (NET_TCP_CONN *pconn)
{
/* Calc avail tx win (see Note #1). */
pconn->TxWinSizeAvail = DEF_MIN(pconn->TxWinSizeCongRem,
pconn->TxWinSizeRemoteRem);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeDupAckCtrlReset()
*
* Description : Reset TCP connection's transmit window duplicate acknowledgement controls.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnWinSizeCfgCongCtrl().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnWinSizeCfgCongCtrl().
*
* Note(s) : none.
*********************************************************************************************************
*/
static void NetTCP_TxConnWinSizeDupAckCtrlReset (NET_TCP_CONN *pconn)
{
pconn->TxWinRxdLastSeqNbr = pconn->RxSeqNbrNext;
pconn->TxWinRxdLastAckNbr = pconn->TxSeqNbrNext;
pconn->TxWinRxdLastWinSize = pconn->TxWinSizeRemote;
pconn->TxWinRxdAckDupCtr = 0;
}
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeDupAckCtrlUpdate()
*
* Description : Update TCP connection's transmit window duplicate acknowledgement controls.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* reset_ctr Indicate whether to reset the duplicate acknowledgement counter :
*
* DEF_YES Reset duplicate acknowledgement counter.
* DEF_NO Do NOT reset duplicate acknowledgement counter.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Note(s) : none.
*********************************************************************************************************
*/
static void NetTCP_TxConnWinSizeDupAckCtrlUpdate (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
CPU_BOOLEAN reset_ctr)
{
pconn->TxWinRxdLastSeqNbr = (NET_TCP_SEQ_NBR )pbuf_hdr->TCP_SeqNbr;
pconn->TxWinRxdLastAckNbr = (NET_TCP_SEQ_NBR )pbuf_hdr->TCP_AckNbr;
pconn->TxWinRxdLastWinSize = (NET_TCP_WIN_SIZE)pbuf_hdr->TCP_WinSize;
if (reset_ctr == DEF_YES) {
pconn->TxWinRxdAckDupCtr = 0;
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeZeroWinHandler()
*
* Description : Handle TCP connection's transmit queue zero window.
*
* Argument(s) : pconn Pointer to TCP connection.
* ----- Argument validated in NetTCP_TxConnWinSizeHandlerCongCtrl(),
* NetTCP_TxConnWinSizeZeroWinTimeout().
*
* win_update_code Indicate how to update TCP connection transmit window :
*
* NET_TCP_CONN_TX_WIN_REMOTE_UPDATE Handle TCP connection's remote
* receive window size update.
* NET_TCP_CONN_TX_WIN_TIMEOUT Handle TCP connection's remote
* receive zero window size timeout.
*
* close_code Select which close action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_CLOSE_NONE Perform NO close actions.
* NET_TCP_CONN_CLOSE_ALL Perform ALL close actions.
*
* NET_TCP_CONN_CLOSE_CONN_TX_RESET Perform close connection transmit reset.
* NET_TCP_CONN_CLOSE_CONN_ALL Perform ALL connection close actions.
*
* NET_TCP_CONN_CLOSE_TMR_TX_IDLE Close transmit idle timer.
* NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN Close transmit silly window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN Close transmit zero window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY Close transmit acknowledgement delay timer.
* NET_TCP_CONN_CLOSE_TMR_RE_TX Close re-transmit timer.
* NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE Close connection keep-alive timer.
* NET_TCP_CONN_CLOSE_TMR_TIMEOUT Close connection timer.
* NET_TCP_CONN_CLOSE_TMR_ALL Close ALL timers.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES'.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnWinSizeZeroWinTimeout(),
* NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* Note(s) : (1) RFC #1122, Section 4.2.2.17 states that although "a TCP MAY keep its offered receive
* window closed indefinitely ... the sending TCP MUST allow the connection to stay open
* ... as long as the receiving TCP continues to send acknowledgments in response to ...
* probe segments".
*
* (a) "Probing of zero (offered) windows MUST be supported."
*
* (1) "If zero window probing is not supported, a connection may hang forever when an
* ACK segment that re-opens the window is lost."
*
* See also Note #1c2.
*
* (b) (1) "The transmitting host SHOULD send the first zero-window probe" ...
*
* (A) Although NO RFC specifies whether a TCP zero window probe should or should NOT
* include data; Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 22.1,
* Page 325 states that "the window probes contain 1 byte of data".
*
* (2) (A) "when a zero window has existed for the retransmission timeout period," ...
*
* (B) "and SHOULD increase exponentially the interval between successive probes."
*
* (1) "Exponential backoff is recommended ... similar to ... the retransmission
* algorithm, and it may be possible to combine the two procedures in the
* implementation."
*
* See also 'NetTCP_TxConnRTO_CalcBackOff() Notes #1 & #2'.
*
* (c) (1) "It is extremely important to remember that ACK (acknowledgment) segments that
* contain no data are not reliably transmitted by TCP."
*
* (2) "This procedure minimizes delay if the zero-window condition is due to a lost
* ACK segment containing a window-opening update."
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnWinSizeZeroWinHandler (NET_TCP_CONN *pconn,
NET_TCP_WIN_CODE win_update_code,
NET_TCP_CLOSE_CODE close_code)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
CPU_BOOLEAN tmr_update;
NET_TCP_TIMEOUT_MS timeout_ms;
NET_TMR_TICK timeout_tick;
NET_ERR err;
/* ----------- VALIDATE TCP CONN STATE ------------ */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
break;
case NET_TCP_CONN_STATE_NONE:
default:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* --------- HANDLE TCP CONN TX ZERO WIN ---------- */
tmr_update = DEF_NO;
switch (win_update_code) {
case NET_TCP_CONN_TX_WIN_REMOTE_UPDATE:
default:
if (pconn->TxWinSizeRemote > 0) { /* If remote win size > 0, ... */
if (pconn->TxQ_ZeroWinTmr != (NET_TMR *)0) { /* ... free zero win tmr. */
NetTmr_Free(pconn->TxQ_ZeroWinTmr);
pconn->TxQ_ZeroWinTmr = (NET_TMR *)0;
}
} else { /* Else if remote win size zero ... */
if (pconn->TxQ_ZeroWinTmr != (NET_TMR *)0) { /* ... & NO zero win tmr; ... */
/* ... set first tx zero win probe timeout ... */
timeout_ms = pconn->TxRTT_RTO_ms; /* ... = RTO (see Note #1b2A). */
timeout_tick = pconn->TxRTT_RTO_tick;
tmr_update = DEF_YES;
}
}
break;
case NET_TCP_CONN_TX_WIN_TIMEOUT: /* On timeout : ... */
/* ... tx TCP zero win probe (see Note #1b1); ... */
NetTCP_TxConnProbe((NET_TCP_CONN *) pconn,
(CPU_BOOLEAN ) DEF_YES, /* Tx probe with data (see Note #1b1A). */
(NET_TCP_CLOSE_CODE) close_code,
(NET_ERR *)&err); /* Ignore transitory tx err(s). */
/* ... update tx probe timeout (see Note #1b2B). */
timeout_ms = (NET_TCP_TIMEOUT_MS )NetTCP_TxConnRTO_CalcBackOff(pconn, pconn->TxWinZeroWinTimeout_ms);
timeout_tick = ((NET_TMR_TICK )timeout_ms * NET_TMR_TIME_TICK_PER_SEC) / DEF_TIME_NBR_mS_PER_SEC;
tmr_update = DEF_YES;
break;
}
if (tmr_update == DEF_YES) { /* If tx probe tmr update req'd, ... */
/* ... get tx zero win probe tmr. */
pconn->TxQ_ZeroWinTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_TxConnWinSizeZeroWinTimeout,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
if (err == NET_TMR_ERR_NONE) { /* If NO err(s), cfg tx zero win probe timeout. */
pconn->TxWinZeroWinTimeout_ms = timeout_ms;
} /* Else ignore transitory rsrc err(s) ... */
/* ... [see Note #1a1]. */
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnWinSizeZeroWinTimeout()
*
* Description : (1) (a) Handle TCP connection's transmit queue zero window persist timeout ... :
*
* (1) Clear TCP connection's transmit zero window persist timer See Note #4aA1
* (2) Handle TCP connection transmit zero window See Note #2
*
* (b) ... for the following states :
*
* (1) ESTABLISHED
* (2) FIN-WAIT-1
* (3) CLOSING
* (4) CLOSE-WAIT
* (5) LAST-ACK
*
*
* Argument(s) : pconn_timeout Pointer to TCP connection (see Note #3b).
*
* Return(s) : none.
*
* Caller(s) : Referenced in NetTCP_TxConnWinSizeZeroWinHandler().
*
* Note(s) : (2) RFC #1122, Section 4.2.2.17 states that the "probing of zero (offered) windows
* ... SHOULD send the first zero-window probe when a zero window has existed for
* the retransmission timeout period and SHOULD increase exponentially the interval
* between successive probes".
*
* See also 'NetTCP_TxConnWinSizeZeroWinHandler() Note #1'.
*
* (3) Ideally, network timer expiration functions could be defined as '[(void) (OBJECT *)]'
* type functions -- even though network timer API functions cast expiration functions
* to generic 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]').
*
* (a) (1) Unfortunately, ISO-IEC 9899-1999 ANSI-C, Section 6.3.2.3.7 states that "a
* pointer to an object ... may be converted to a pointer to a different object
* ... [but] if the resulting pointer is not correctly aligned ... the behavior
* is undefined".
*
* And since compilers may NOT correctly convert 'void' pointers to non-'void'
* pointer arguments, network timer expiration functions MUST avoid incorrect
* pointer conversion behavior between 'void' pointer parameters & non-'void'
* pointer arguments & therefore CANNOT be defined as '[(void) (OBJECT *)]'.
*
* (2) However, Section 6.3.2.3.1 states that "a pointer to void may be converted
* to or from a pointer to any ... object ... A pointer to any ... object ...
* may be converted to a pointer to void and back again; the result shall
* compare equal to the original pointer".
*
* (b) Therefore, to correctly convert 'void' pointer objects back to appropriate
* network object pointer objects, network timer expiration functions MUST :
*
* (1) Be defined as 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]'); & ...
* (2) Explicitly cast 'void' pointer arguments to specific object pointers; ...
* (A) ... in this case, a 'NET_TCP_CONN' pointer.
*
* See also 'net_tmr.c NetTmr_Get() Note #3'.
*
* (4) This function is a network timer expiration function :
*
* (a) (1) For the following connection timer(s) ... :
*
* (A) TCP connection transmit zero window persist timer ('TxQ_ZeroWinTmr')
*
* (2) (A) Clear the timer pointer; ...
* (1) Cleared prior to next handler function(s) as an extra precaution to
* avoiding re-freeing the timer (see Note #4a2B).
*
* (B) but do NOT re-free the timer.
*
* (b) Do NOT set the following close timer flag(s) :
*
* (1) NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN
*
* (5) Certain network connections MUST periodically suspend network transmit(s) to handle
* network receive packet(s). To protect TCP connections from transmit corruption while
* suspended, ALL TCP data transmits & TCP transmit queue handling MUST be blocked for
* suspended connections until the connection is no longer suspended.
*
* However, handling the TCP connection's transmit zero window timeout is permitted since
* NO TCP data is transmitted & the TCP connection's transmit queue is NOT handled (see
* Note #1a).
*
* See also 'NetTCP_TxConnTxQ() Note #10b2A2',
* 'NetTCP_TxConnTxQ_TimeoutIdle() Note #5',
* 'NetTCP_TxConnTxQ_TimeoutSillyWin() Note #5',
* & 'NetTCP_TxConnReTxQ_Timeout() Note #5'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnWinSizeZeroWinTimeout (void *pconn_timeout)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
NET_TCP_CLOSE_CODE close_code;
pconn = (NET_TCP_CONN *)pconn_timeout; /* See Note #3b2A. */
close_code = NET_TCP_CONN_CLOSE_ALL;
DEF_BIT_CLR(close_code, NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN); /* See Note #4b1. */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* -------------- VALIDATE TCP CONN --------------- */
if (pconn == (NET_TCP_CONN *)0) {
NET_CTR_ERR_INC(NetTCP_ErrNullPtrCtr);
return;
}
if (pconn->Type != NET_TCP_TYPE_CONN) {
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidTypeCtr);
return;
}
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CONN: /* See Note #1. */
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND: /* See Note #5. */
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)close_code);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
/* ----- HANDLE TCP CONN TX ZERO WIN TIMEOUT ------ */
pconn->TxQ_ZeroWinTmr = (NET_TMR *)0; /* Clr tx Q zero win tmr (see Note #4a2A1). */
/* Handle tx zero win (see Note #2). */
NetTCP_TxConnWinSizeZeroWinHandler(pconn, NET_TCP_CONN_TX_WIN_TIMEOUT, close_code);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnSync()
*
* Description : (1) Prepare & transmit TCP connection synchronization :
*
* (a) Validate TCP connection state
* (b) Prepare TCP connection synchronization :
* (1) Get timer
* (2) Get buffer
* (3) Prepare TCP segment :
* (A) TCP segment addresses
* (B) TCP segment sequence numbers
* (C) TCP segment transmit flags :
*- (1) SYN
* (2) ACK
* (D) TCP segment window size
* (E) TCP segment options
* (F) IP datagram parameters
* (G) TCP segment packet buffer controls
* (c) Update TCP connection :
* (1) Queue TCP connection synchronization packet
* (2) Update TCP connection sequence numbers
* (d) Transmit TCP connection synchronization
*
*
* (2) (a) RFC #793, Section 3.3 'Sequence Numbers : Initial Sequence Number Selection' states
* that "for a [TCP] connection to be established or initialized, ... two TCP's must
* synchronize ... each other's initial sequence numbers" by transmitting initial
* connection request segments (i.e., segments with the SYN control bit set).
*
* RFC #793, Section 3.4 states that "this procedure normally is initiated by one TCP
* and responded to by another TCP ... [but] works if two TCP simultaneously initiate
* the procedure".
*
* (b) RFC #793, Section 3.9 'Event Processing : OPEN Call : CLOSED STATE' states that after
* "a SYN segment ... is sent ... [to] set SND.UNA to ISS [initial send sequence number],
* SND.NXT to ISS+1".
*
* The following sections confirm these sequence number configurations summary :
*
* (1) RFC #793, Section 3.9 'Event Processing : OPEN Call : LISTEN STATE'
* (2) RFC #793, Section 3.9 'Event Processing : SEND Call : LISTEN STATE'
* (3) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State] :
* Check for SYN'
*
* (3) A TCP connection's transmit sequences are initialized when the initial TCP synchronization
* segment is queued for transmission :
*
* (a) 'TxSeqNbrSync' points to the initial, synchronization (SYN) transmit sequence number.
*
* (b) (1) 'TxSeqNbrNextQ' points to the next transmit sequence number to enqueue data octets.
* (2) 'TxSeqNbrNext' points to the next transmit sequence number to transmit.
*
*
* ----- ------------------------ Initial Synchronization
* ^ | Initial SEQ # (SYN) | <--- Transmit Sequence Number
* | ------------------------ (see Note #3a)
* | | Data Octet # 1 | ---
* | | Data Octet # 2 | ^
* | | Data Octet # 3 | |
* | . | | Next / Queued
* TCP Connection | . | | Transmit Sequence Number(s)
* Transmit Sequences | . | | (see Note #3b)
* (see Note #3) | Data Octet # (N - 2) | |
* | Data Octet # (N - 1) | v
* | | Data Octet # N | ---
* | ------------------------
* | | Close SEQ # (FIN) |
* | ------------------------
* v | Last SEQ # |
* ----- ------------------------
*
*
* See also 'NetTCP_TxConnClose() Note #2'.
*
*
*$PAGE*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnReq(),
* NetTCP_RxPktConnHandlerListen().
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection synchronization successfully
* transmitted.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
*
* - RETURNED BY NetTCP_TxConnReTxQ_TimeoutSet() : -
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
*
* - RETURNED BY NetTCP_TxConnPrepareSegAddrs() : --
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
*
* ------ RETURNED BY NetTCP_TxPktHandler() : ------
* NET_TCP_ERR_TX TCP transmit error.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnReq(),
* NetTCP_RxPktConnHandlerListen(),
* NetTCP_RxPktConnHandlerSyncTxd().
*
* Note(s) : (4) RFC #1122, Section 4.2.2.6 states that a "TCP SHOULD send an MSS (Maximum Segment Size)
* option in every SYN segment".
*
* (5) Network resources MUST be appropriately allocated/deallocated :
*
* (a) Increment network buffer's reference counter to include the queued TCP connection
* synchronization as a new reference to the network buffer.
*
* (b) On ANY errors, network resources MUST be appropriately freed :
*
* (1) For any network resources NOT yet linked to the TCP connection, each
* network resource MUST be freed by appropriate function(s).
* (2) For all network resources that have been linked to the TCP connection, ALL
* network resources are freed by NetTCP_ConnClose().
*
* (6) If transmitting a TCP synchronization packet from the SYN-SENT state :
*
* (a) Connection timeout is reset to initial synchronization timeout value
* (b) Previous synchronization sequence number MUST be re-used
* (c) Previous synchronization packet in TCP connection's re-transmit queue is freed
*
* See also 'NetTCP_RxPktConnHandlerSyncTxd() Note #2c3B2'.
*
* (7) #### IP options currently NOT implemented.
*********************************************************************************************************
*/
static void NetTCP_TxConnSync (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_ERR *perr)
{
#if (CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL)
CPU_SR cpu_sr;
#endif
NET_BUF_SIZE data_len;
NET_BUF_SIZE data_ix;
NET_BUF *pseg_sync;
NET_BUF_HDR *pseg_sync_hdr;
NET_IP_TOS TOS;
NET_IP_TTL TTL;
NET_IP_ADDR src_addr;
NET_IP_ADDR dest_addr;
NET_TCP_PORT_NBR src_port;
NET_TCP_PORT_NBR dest_port;
NET_TCP_SEQ_NBR seq_nbr;
NET_TCP_SEQ_NBR ack_nbr;
NET_TCP_WIN_SIZE win_size;
NET_TCP_OPT_CFG_MAX_SEG_SIZE *popt_cfg_max_seg_size;
NET_TCP_OPT_CFG_MAX_SEG_SIZE opt_cfg_max_seg_size;
CPU_INT16U flags_tcp;
CPU_INT16U flags_ip;
NET_ERR err;
/*$PAGE*/
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ----------- VALIDATE TCP CONN STATE ------------ */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_TXD:
break;
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, NET_TCP_CONN_CLOSE_CONN_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
/* ----------- PREPARE TCP CONN SYNC SEG ---------- */
/* ------------------- GET TMR -------------------- */
NetTCP_TxConnReTxQ_TimeoutSet(pconn, DEF_NO, NET_TCP_CONN_CLOSE_ALL, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* ------------------- GET BUF -------------------- */
data_len = NET_TCP_DATA_LEN_TX_SYNC;
data_ix = NET_BUF_DATA_TX_IX;
pseg_sync = NetBuf_Get((NET_BUF_SIZE) data_len,
(NET_BUF_SIZE) data_ix,
(CPU_INT16U ) NET_BUF_FLAG_NONE,
(NET_ERR *)&err);
if ( err != NET_BUF_ERR_NONE) { /* See Note #5b1. */
*perr = NET_TCP_ERR_NONE_AVAIL;
return;
}
/*$PAGE*/
/* --------------- PREPARE TCP HDR ---------------- */
/* Prepare seg addrs. */
if (pbuf_hdr != (NET_BUF_HDR *)0) { /* If TCP pkt rx'd, cfg TCP tx ... */
/* ... src addr from rx'd TCP pkt dest addr ... */
src_port = (NET_TCP_PORT_NBR)pbuf_hdr->TCP_UDP_PortDest;
src_addr = (NET_IP_ADDR )pbuf_hdr->IP_AddrDest;
/* .. & dest addr from rx'd TCP pkt src addr. */
dest_port = (NET_TCP_PORT_NBR)pbuf_hdr->TCP_UDP_PortSrc;
dest_addr = (NET_IP_ADDR )pbuf_hdr->IP_AddrSrc;
} else { /* Else cfg TCP tx pkt addrs from TCP conn addrs. */
NetTCP_TxConnPrepareSegAddrs((NET_TCP_CONN *) pconn,
(CPU_INT08U *)&src_port,
(CPU_INT08U *)&src_addr,
(CPU_INT16U ) sizeof(src_port),
(CPU_INT16U ) sizeof(src_addr),
(CPU_INT08U *)&dest_port,
(CPU_INT08U *)&dest_addr,
(CPU_INT16U ) sizeof(dest_port),
(CPU_INT16U ) sizeof(dest_addr),
(NET_ERR *) perr);
if (*perr != NET_TCP_ERR_NONE) { /* See Note #5b1. */
NetBuf_Free(pseg_sync);
return;
}
}
/* Prepare TCP sync seq nbrs. */
if (pconn->ConnState != NET_TCP_CONN_STATE_SYNC_TXD) { /* For non-sync-tx'd states (see Note #6b), ... */
NET_TCP_TX_GET_SEQ_NBR(seq_nbr); /* ... get sync seq nbr. */
} else {
seq_nbr = pconn->TxSeqNbrSync;
}
ack_nbr = (pconn->ConnState != NET_TCP_CONN_STATE_CLOSED) ? pconn->RxSeqNbrNext
: NET_TCP_ACK_NBR_NONE;
/* Prepare TCP tx flags (see Note #1b3C). */
flags_tcp = NET_TCP_FLAG_NONE |
NET_TCP_FLAG_TX_SYNC;
if (pconn->ConnState != NET_TCP_CONN_STATE_CLOSED) { /* For non-CLOSED state, ... */
DEF_BIT_SET(flags_tcp, NET_TCP_FLAG_TX_ACK); /* ... tx ACK. */
}
/* Prepare TCP rx win size. */
win_size = pconn->RxWinSizeActual;
/* Prepare TCP max seg size opt (see Note #4). */
popt_cfg_max_seg_size = &opt_cfg_max_seg_size;
popt_cfg_max_seg_size->Type = NET_TCP_OPT_CFG_TYPE_MAX_SEG_SIZE;
popt_cfg_max_seg_size->MaxSegSize = pconn->MaxSegSizeLocal;
popt_cfg_max_seg_size->NextOptPtr = (void *)0;
/* Prepare IP params. */
TOS = pconn->TxIP_TOS;
TTL = pconn->TxIP_TTL;
flags_ip = pconn->TxIP_Flags;
/*$PAGE*/
/* Init buf ctrls. */
pseg_sync_hdr = &pseg_sync->Hdr;
pseg_sync_hdr->DataIx = (CPU_INT16U )data_ix;
pseg_sync_hdr->DataLen = (NET_BUF_SIZE)data_len;
pseg_sync_hdr->TotLen = (NET_BUF_SIZE)pseg_sync_hdr->DataLen;
pseg_sync_hdr->ProtocolHdrType = NET_PROTOCOL_TYPE_TCP;
pseg_sync_hdr->TCP_UDP_PortSrc = (NET_PORT_NBR)src_port;
pseg_sync_hdr->IP_AddrSrc = (CPU_INT32U )src_addr;
pseg_sync_hdr->TCP_UDP_PortDest = (NET_PORT_NBR)dest_port;
pseg_sync_hdr->IP_AddrDest = (CPU_INT32U )dest_addr;
pseg_sync_hdr->TCP_SegLenInit = (CPU_INT16U )NET_TCP_SEG_LEN_SYNC;
pseg_sync_hdr->TCP_SegLen = (CPU_INT16U )pseg_sync_hdr->TCP_SegLenInit;
pseg_sync_hdr->TCP_SegLenLast = (CPU_INT16U )pseg_sync_hdr->TCP_SegLenInit;
pseg_sync_hdr->TCP_SegLenData = (CPU_INT16U )0;
pseg_sync_hdr->TCP_SegSync = (CPU_BOOLEAN )DEF_YES;
pseg_sync_hdr->TCP_SegClose = (CPU_BOOLEAN )DEF_NO;
pseg_sync_hdr->TCP_SegAck = (CPU_BOOLEAN )DEF_BIT_IS_SET(flags_tcp, NET_TCP_FLAG_TX_ACK);
pseg_sync_hdr->TCP_SegReset = (CPU_BOOLEAN )DEF_NO;
pseg_sync_hdr->TCP_SeqNbrInit = (CPU_INT32U )seq_nbr;
pseg_sync_hdr->TCP_SeqNbrLast = (CPU_INT32U )pseg_sync_hdr->TCP_SeqNbrInit;
pseg_sync_hdr->TCP_SeqNbr = (CPU_INT32U )pseg_sync_hdr->TCP_SeqNbrInit;
pseg_sync_hdr->TCP_AckNbr = (CPU_INT32U )ack_nbr;
pseg_sync_hdr->TCP_AckNbrLast = (CPU_INT32U )pseg_sync_hdr->TCP_AckNbr;
pseg_sync_hdr->TCP_WinSizeLast = (CPU_INT16U )win_size;
pseg_sync_hdr->TCP_Flags = (CPU_INT16U )flags_tcp;
pseg_sync_hdr->TCP_SegReTxCtr = (CPU_INT16U )0;
pseg_sync_hdr->RefCtr++; /* TCP maintains ref until seg ack'd (see Note #5a).*/
/* --------------- UPDATE TCP CONN ---------------- */
/* Q conn sync seg to TCP re-tx Q. */
NetTCP_ConnFreeBufQ(&pconn->ReTxQ_Head, &pconn->ReTxQ_Tail); /* Free re-tx Q (see Note #6c). */
pconn->ReTxQ_Head = pseg_sync;
pconn->ReTxQ_Tail = pseg_sync;
/* Update TCP conn seq nbrs (see Notes #2 & #3). */
pconn->TxSeqNbrSync = (NET_TCP_SEQ_NBR) seq_nbr;
pconn->TxSeqNbrNext = (NET_TCP_SEQ_NBR)(seq_nbr + pseg_sync_hdr->TCP_SegLen);
pconn->TxSeqNbrNextQ = (NET_TCP_SEQ_NBR) pconn->TxSeqNbrNext;
pconn->TxSeqNbrUnAckdPrev = (NET_TCP_SEQ_NBR) pconn->TxSeqNbrUnAckd;
pconn->TxSeqNbrUnAckd = (NET_TCP_SEQ_NBR) pconn->TxSeqNbrSync;
pconn->TxSeqNbrUnReTxd = (NET_TCP_SEQ_NBR) pconn->TxSeqNbrUnAckd;
/* ------------- TX TCP CONN SYNC SEG ------------- */
NetTCP_TxPktHandler((NET_BUF *)pseg_sync,
(NET_IP_ADDR )src_addr,
(NET_TCP_PORT_NBR)src_port,
(NET_IP_ADDR )dest_addr,
(NET_TCP_PORT_NBR)dest_port,
(NET_TCP_SEQ_NBR )seq_nbr,
(NET_TCP_SEQ_NBR )ack_nbr,
(NET_TCP_WIN_SIZE)win_size,
(NET_IP_TOS )TOS,
(NET_IP_TTL )TTL,
(CPU_INT16U )flags_tcp,
(CPU_INT16U )flags_ip,
(void *)popt_cfg_max_seg_size,
(void *)0, /* See Note #7. */
(NET_ERR *)perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_ERR_INIT_INCOMPLETE:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
NET_CTR_STAT_INC(NetTCP_StatTxSegConnSyncCtr);
break;
case NET_TCP_ERR_TX:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, NET_TCP_CONN_CLOSE_CONN_ALL);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnClose()
*
* Description : (1) Prepare & transmit TCP connection close :
*
* (a) Validate TCP connection state
* (b) Prepare TCP connection close segment :
* (1) Get buffer
* (2) Prepare TCP segment :
* (A) TCP segment addresses
* (B) TCP segment sequence numbers
* (C) TCP segment transmit flags :
* (1) ACK
* (2) FIN
* (D) TCP segment window size
* (E) IP datagram parameters
* (F) TCP segment packet buffer controls
* (c) Update TCP connection :
* (1) Queue TCP connection close packet
* (2) Update TCP connection sequence number(s)
* (d) Transmit TCP connection close segment
*
*
* (2) A TCP connection's transmit sequences are closed when the closing TCP segment is queued
* for transmission :
*
* (a) 'TxSeqNbrClose' points to the closing (FIN) transmit sequence number.
*
* (b) 'TxSeqNbrLast' points to the last sequence number used to close the TCP connection
* transmit sequences when acknowledged.
*
*
* ----- ------------------------
* ^ | Initial SEQ # (SYN) |
* | ------------------------
* | | Data Octet # 1 |
* | | Data Octet # 2 |
* | | Data Octet # 3 |
* | . |
* TCP Connection | . |
* Transmit Sequences | . |
* (see Note #2) | Data Octet # (N - 2) |
* | Data Octet # (N - 1) |
* | | Data Octet # N | Closing Transmit
* | ------------------------ Sequence Number
* | | Close SEQ # (FIN) | <--- (see Note #2a)
* | ------------------------
* v | Last SEQ # | <--- Last Transmit
* ----- ------------------------ Sequence Number
* (see Note #2b)
*
*
* See also 'NetTCP_TxConnSync() Note #3'.
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_ConnReqClose().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection close successfully
* transmitted.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
*
* ------- RETURNED BY NetTCP_TxConnTxQ() : -------
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
* NET_TCP_ERR_CONN_ACK_INVALID TCP connection acknowledgement NOT valid for
* current TCP connection state.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
* NET_TCP_ERR_TX TCP transmit error.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_ConnReqClose().
*$PAGE*
* Note(s) : (3) Network resources MUST be appropriately allocated/deallocated :
*
* (a) Network buffer's reference counter MUST include the queued TCP connection close as a
* new reference to the network buffer. However, this additional reference is handled
* by the TCP connection transmit queue (see 'NetTCP_TxConnTxQ() Note #9').
*
* (b) On ANY errors, network resources MUST be appropriately freed :
*
* (1) For any network resources NOT yet linked to the TCP connection, each network
* resource MUST be freed by appropriate function(s).
* (2) For all network resources that have been linked to the TCP connection, ALL network
* resources are freed by NetTCP_ConnClose().
*
* (4) Network buffer's reference counter must be incremented to include the TCP connection close
* segment to be enqueued to the TCP connection's re-transmit queue as a new reference to the
* network buffer.
*
* However, NetTCP_TxConnTxQ() handles the reference counter increment when it enqueues the
* TCP connection close segment queued to the TCP connection's re-transmit queue.
*
* See 'NetTCP_TxConnTxQ() Note #9'.
*********************************************************************************************************
*/
static void NetTCP_TxConnClose (NET_TCP_CONN *pconn,
NET_ERR *perr)
{
#if ((((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED)) || \
(NET_CTR_CFG_STAT_EN == DEF_ENABLED)) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_SEG_SIZE seg_len;
NET_BUF_SIZE data_len;
NET_BUF_SIZE data_ix;
NET_BUF *pseg_close;
NET_BUF_HDR *pseg_close_hdr;
NET_IP_ADDR src_addr;
NET_IP_ADDR dest_addr;
NET_TCP_PORT_NBR src_port;
NET_TCP_PORT_NBR dest_port;
NET_TCP_SEQ_NBR seq_nbr;
CPU_INT16U flags_tcp;
NET_ERR err;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ----------- VALIDATE TCP CONN STATE ------------ */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
/*$PAGE*/
/* ---------- PREPARE TCP CONN CLOSE SEG ---------- */
seg_len = NET_TCP_SEG_LEN_CLOSE;
data_len = NET_TCP_DATA_LEN_TX_CLOSE;
if (pconn->TxQ_Tail != (NET_BUF *)0) { /* If tx Q NOT empty ... */
pseg_close = pconn->TxQ_Tail; /* ... update tx Q tail seg as close seg. */
pseg_close_hdr = &pseg_close->Hdr;
pseg_close_hdr->DataLen += (NET_BUF_SIZE)data_len;
pseg_close_hdr->TotLen += (NET_BUF_SIZE)data_len;
pseg_close_hdr->TCP_SegLenInit += (CPU_INT16U )seg_len;
pseg_close_hdr->TCP_SegLen += (CPU_INT16U )seg_len;
pseg_close_hdr->TCP_SegLenData += (CPU_INT16U )data_len;
DEF_BIT_SET(pseg_close_hdr->TCP_Flags, NET_TCP_FLAG_TX_CLOSE);
} else { /* Else get/cfg close seg buf. */
/* Get buf. */
data_ix = NET_BUF_DATA_TX_IX;
pseg_close = NetBuf_Get((NET_BUF_SIZE) data_len,
(NET_BUF_SIZE) data_ix,
(CPU_INT16U ) NET_BUF_FLAG_NONE,
(NET_ERR *)&err);
if ( err != NET_BUF_ERR_NONE) {
*perr = NET_TCP_ERR_NONE_AVAIL;
return;
}
/* --------------- PREPARE TCP HDR ---------------- */
/* Prepare seg addrs. */
NetTCP_TxConnPrepareSegAddrs((NET_TCP_CONN *) pconn,
(CPU_INT08U *)&src_port,
(CPU_INT08U *)&src_addr,
(CPU_INT16U ) sizeof(src_port),
(CPU_INT16U ) sizeof(src_addr),
(CPU_INT08U *)&dest_port,
(CPU_INT08U *)&dest_addr,
(CPU_INT16U ) sizeof(dest_port),
(CPU_INT16U ) sizeof(dest_addr),
(NET_ERR *)&err);
if ( err != NET_TCP_ERR_NONE) { /* See Note #3b1. */
*perr = NET_TCP_ERR_CONN_FAULT;
NetBuf_Free(pseg_close);
return;
}
/* Prepare TCP seq nbr(s). */
seq_nbr = pconn->TxSeqNbrNextQ;
/* Prepare TCP tx flags (see Note #1b2C). */
flags_tcp = NET_TCP_FLAG_NONE |
NET_TCP_FLAG_TX_ACK |
NET_TCP_FLAG_TX_CLOSE;
/* Init buf ctrls. */
pseg_close_hdr = &pseg_close->Hdr;
pseg_close_hdr->DataIx = (CPU_INT16U )data_ix;
pseg_close_hdr->DataLen = (NET_BUF_SIZE)data_len;
pseg_close_hdr->TotLen = (NET_BUF_SIZE)pseg_close_hdr->DataLen;
pseg_close_hdr->ProtocolHdrType = NET_PROTOCOL_TYPE_TCP;
pseg_close_hdr->TCP_UDP_PortSrc = (NET_PORT_NBR)src_port;
pseg_close_hdr->IP_AddrSrc = (CPU_INT32U )src_addr;
pseg_close_hdr->TCP_UDP_PortDest = (NET_PORT_NBR)dest_port;
pseg_close_hdr->IP_AddrDest = (CPU_INT32U )dest_addr;
pseg_close_hdr->TCP_SegLenInit = (CPU_INT16U )seg_len;
pseg_close_hdr->TCP_SegLen = (CPU_INT16U )pseg_close_hdr->TCP_SegLenInit;
pseg_close_hdr->TCP_SegLenData = (CPU_INT16U )data_len;
pseg_close_hdr->TCP_SegSync = (CPU_BOOLEAN )DEF_NO;
pseg_close_hdr->TCP_SegClose = (CPU_BOOLEAN )DEF_YES;
pseg_close_hdr->TCP_SegAck = (CPU_BOOLEAN )DEF_YES;
pseg_close_hdr->TCP_SegReset = (CPU_BOOLEAN )DEF_NO;
pseg_close_hdr->TCP_SeqNbrInit = (CPU_INT32U )seq_nbr;
pseg_close_hdr->TCP_SeqNbr = (CPU_INT32U )pseg_close_hdr->TCP_SeqNbrInit;
pseg_close_hdr->TCP_Flags = (CPU_INT16U )flags_tcp;
}
/*$PAGE*/
/* --------------- UPDATE TCP CONN ---------------- */
/* Q conn close seg to TCP tx Q : ... */
if (pconn->TxQ_Tail == (NET_BUF *)0) { /* ... if tx Q empty, add close seg to empty tx Q. */
pconn->TxQ_Head = (NET_BUF *)pseg_close;
pconn->TxQ_Tail = (NET_BUF *)pseg_close;
}
/* Update TCP conn seq nbrs (see Note #2). */
pconn->TxSeqNbrNextQ += (NET_TCP_SEQ_NBR) seg_len; /* Update next tx Q seq nbr by close seg len. */
pconn->TxSeqNbrLast = (NET_TCP_SEQ_NBR) pconn->TxSeqNbrNextQ;
pconn->TxSeqNbrClose = (NET_TCP_SEQ_NBR)(pconn->TxSeqNbrLast - seg_len);
/* ------------ TX TCP CONN CLOSE SEG ------------- */
NetTCP_TxConnTxQ((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(NET_TCP_ACK_CODE )NET_TCP_CONN_TX_ACK_NONE,
(CPU_BOOLEAN )DEF_NO,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL,
(NET_ERR *)perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_TCP_ERR_CONN_ACK_NONE:
case NET_TCP_ERR_CONN_ACK_INVALID:
case NET_TCP_ERR_CONN_ACK_DLYD:
case NET_TCP_ERR_CONN_ACK_PREVLY_TXD:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_CONN_NOT_USED:
case NET_TCP_ERR_CONN_CLOSE:
case NET_TCP_ERR_CONN_FAULT:
case NET_TCP_ERR_CONN_FAIL:
case NET_TCP_ERR_INVALID_CONN_STATE:
case NET_TCP_ERR_INVALID_CONN_OP:
case NET_TCP_ERR_INVALID_LEN_SEG:
case NET_TCP_ERR_NONE_AVAIL:
case NET_TCP_ERR_TX:
case NET_CONN_ERR_INVALID_FAMILY:
case NET_CONN_ERR_INVALID_ADDR:
case NET_CONN_ERR_INVALID_ADDR_LEN:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
NET_CTR_STAT_INC(NetTCP_StatTxSegConnCloseCtr);
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnAck()
*
* Description : (1) Prepare & transmit a TCP connection acknowledgement :
*
* (a) Validate TCP connection for TCP acknowledgement See Notes #2, #4, #5, & #6
* (b) Prepare TCP acknowledgement segment :
* (1) Get buffer
* (2) Prepare TCP segment :
* (A) TCP segment addresses
* (B) TCP segment sequence numbers See Notes #4a1D1a1, #4a2A1
* & #4a1D3b1B,
* (C) TCP segment transmit flags :
* (1) ACK
* (D) TCP segment window size
* (E) IP datagram parameters
* (F) TCP segment packet buffer controls
* (c) Transmit TCP connection acknowledgement
*
*
* (2) NetTCP_TxConnAck() transmits TCP connection acknowledgements in response to certain
* received TCP packets or TCP connection events (see Note #4). TCP acknowledgements
* transmitted with other TCP controls &/or data SHOULD NOT be transmitted with
* NetTCP_TxConnAck().
*
* See also 'NetTCP_TxConnTxQ() Note #2'.
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in various.
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
* -------- Argument validated in NetTCP_Rx().
*
* tx_ack_code Indicate whether & how to transmit a TCP acknowledgement segment :
*
* NET_TCP_CONN_TX_ACK_NONE Do NOT transmit a TCP acknowledgement segment.
* NET_TCP_CONN_TX_ACK Transmit a TCP acknowledgement segment.
* NET_TCP_CONN_TX_ACK_IMMED Transmit a TCP acknowledgement segment
* immediately (see Note #4a5).
* NET_TCP_CONN_TX_ACK_FAULT Transmit a TCP acknowledgement segment
* immediately in response to an invalid
* received TCP packet (see Note #4a1).
* NET_TCP_CONN_TX_ACK_TIMEOUT Transmit a TCP acknowledgement segment
* immediately in response to a delayed
* acknowledgement timeout (see Note #6).
*
* close_code Select which close action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_CLOSE_NONE Perform NO close actions.
* NET_TCP_CONN_CLOSE_ALL Perform ALL close actions.
*
* NET_TCP_CONN_CLOSE_CONN_TX_RESET Perform close connection transmit reset.
* NET_TCP_CONN_CLOSE_CONN_ALL Perform ALL connection close actions.
*
* NET_TCP_CONN_CLOSE_TMR_TX_IDLE Close transmit idle timer.
* NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN Close transmit silly window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN Close transmit zero window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY Close transmit acknowledgement delay timer.
* NET_TCP_CONN_CLOSE_TMR_RE_TX Close re-transmit timer.
* NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE Close connection keep-alive timer.
* NET_TCP_CONN_CLOSE_TMR_TIMEOUT Close connection timer.
* NET_TCP_CONN_CLOSE_TMR_ALL Close ALL timers.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES'.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection acknowledgement successfully
* transmitted.
* NET_TCP_ERR_CONN_ACK_NONE TCP connection acknowledgement NOT requested.
* NET_TCP_ERR_CONN_ACK_DLYD TCP connection acknowledgement transmit delayed
* (see Note #6).
* NET_TCP_ERR_CONN_ACK_PREVLY_TXD TCP connection acknowledgement previously
* transmitted for segment (see Note #7).
* NET_TCP_ERR_CONN_ACK_INVALID TCP connection acknowledgement NOT valid for
* current TCP connection state.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
*
* -- RETURNED BY NetTCP_RxPktConnIsValidSeq() : --
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* Return(s) : none.
*
* Caller(s) : various.
*$PAGE*
* Note(s) : (3) See the following RFC's for TCP acknowledgement generation summary :
*
* (a) RFC # 793, Section 3.9 'Event Processing : SEGMENT ARRIVES'
* (b) RFC # 813, Section 5
* (c) RFC #1122, Section 4.2.3.2
* (d) RFC #2581, Sections 3.2 & 4.2
* (e) RFC Draft-IETF-TCPm-TCPSecure #00, Sections 2 & 3
*
* (4) (a) TCP connection acknowledgements are transmitted when certain segments are received :
*
* (A) Some TCP transmit acknowledgement validation logic implemented in previous
* functions; include duplicate validation logic in NetTCP_TxConnAck() only
* if debug/validation code is enabled (i.e. NET_ERR_CFG_ARG_CHK_DBG_EN is
* DEF_ENABLED in 'net_cfg.h').
*
* (1) (A) RFC #793, Section 3.4 'Establishing a Connection : Reset Generation : 1' states that
* "if [a] connection does not exist (CLOSED) then a reset is sent in response to any
* incoming segment except another reset".
*
* Thus, ONLY resets are transmitted from the CLOSED state; never acknowledgements.
*
* (B) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State]' allows
* for the transmission of TCP connection reset & connection synchronization segments
* ONLY; never acknowledgement-only segments (see also Note #2).
*
* (C) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check SYN Bit' states that "if ... our SYN has been ACKed ... change the
* connection state to ESTABLISHED, form an ACK segment ... and send it".
*
* Thus, acknowledgements MUST be immediately transmitted in reply to all valid
* synchronization segments received.
*
* (D) (1) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence
* Number' states that for the "SYN-RECEIVED STATE, ESTABLISHED STATE, FIN-WAIT-1
* STATE, FIN-WAIT-2 STATE, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK STATE, TIME-
* WAIT STATE ... if an incoming segment is not acceptable," ...
*
* (a) "an acknowledgment should be sent in reply" :
*
* (1) <SEQ=SND.NXT> <ACK=RCV.NXT> <CTL=ACK>
*
* (b) (1) "(unless the RST bit is set)".
*
* (2) However, RFC Draft-IETF-TCPm-TCPSecure #00, Section 2.2 requires
* transmitting a TCP acknowledgement upon receipt of certain TCP
* segments regardless of whether "the RST bit" is set (see Notes
* #4a1D2b1c & #4a1D2b3).
*
* See also Notes #4a1D2b & #4a1D3b.
*$PAGE*
* (2) (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check RST Bit'
* states that "if the RST bit is set ... enter the CLOSED state".
*
* Note this check is placed following the sequence check to prevent a segment
* from an old connection ... from causing an abort of the current connection".
*
* (b) (1) HOWEVER, RFC Draft-IETF-TCPm-TCPSecure #00, Section 2.2 amends the "handling
* of a segment with the RST bit when in a synchronized state" to "provide some
* protection against ... blind reset attack[s] using the RST bit" :
*
* (a) "If the RST bit is set and the sequence number is outside the
* expected window, silently drop the segment."
*
* (b) "If the RST bit is exactly the next expected sequence number [sic],
* reset the connection"; it is assumed that this should read "if the
* RST bit is set and the sequence number is exactly the next expected
* sequence number, reset the connection."
*
* (c) "If the RST bit is set and the sequence number does not exactly
* match the next expected sequence value, yet is within the
* acceptable window (RCV.NXT <= SEG.SEQ < RCV.NXT+RCV.WND) send
* an acknowledgment."
*
* (2) ???? Although RFC Draft-IETF-TCPm-TCPSecure #00 explicitly states that this
* amendment applies only to the "handling of a ... RST when in a synchronized
* state", it is assumed that this should also apply to the SYN-RECEIVED state.
*
* (3) ???? In addition, RFC Draft-IETF-TCPm-TCPSecure #00 does NOT provide a
* precedence priority for handling TCP segments received with BOTH the RST
* & SYN bits set.
*
* ???? Therefore, since it does NOT seem reasonable to reset a TCP connection
* due to a TCP segment that also attempted to synchronize the TCP connection,
* it is assumed that the amended handling of the SYN bit should take precedence
* over the amended handling of the RST bit.
*
* See Note #4a1D3b.
*
* (3) (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check SYN
* Bit' states that for "SYN-RECEIVED [STATE], ESTABLISHED STATE, FIN-WAIT
* STATE-1, FIN-WAIT STATE-2, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK
* STATE, TIME-WAIT STATE ... [to next] check the SYN bit ... [and] if
* the SYN is in the window it is an error, send a reset ... [and] enter
* the CLOSED state ...
*
* [But] if the SYN is not in the window this step would not have been
* reached and an ack would have been sent".
*
* (b) (1) HOWEVER, RFC Draft-IETF-TCPm-TCPSecure #00, Section 3.2 amends the
* "handling of a segment with the SYN bit set in the synchronized state
* ... [by] handling ... the SYN bit" as follows :
*
* (a) "If the SYN bit is set and the sequence number is outside the
* expected window, send an ACK back to the peer."
*
* (b) "If the SYN bit is set and the sequence number is an exact match to
* the next expected sequence (RCV.NXT == SEG.SEQ) then send an ACK
* segment ... but ... subtract one from value being acknowledged."
*
* (c) "If the SYN bit is set and the sequence number is acceptable, i.e.:
* (RCV.NXT <= SEG.SEQ < RCV.NXT+RCV.WND) then send an ACK segment."
*
* (2) ???? Although RFC Draft-IETF-TCPm-TCPSecure #00 explicitly states that
* this amendment applies only to the "handling of a ... SYN ... in a
* synchronized state", it is assumed that this should also apply to the
* SYN-RECEIVED state.
*
* (4) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field'
* states that if in the "ESTABLISHED STATE" or any state with similar "processing
* as for the ESTABLISHED STATE", that "if the ACK acks something not yet sent
* (SEG.ACK > SND.NXT) then send an ACK".
*$PAGE*
* (2) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Process Segment Text',
* states that in the "ESTABLISHED STATE, FIN-WAIT-1 STATE, FIN-WAIT-2 STATE ... when
* ... TCP takes responsibility for ... data ... it must also acknowledge ... the data" :
*
* (A) "Send an acknowledgment of the form" :
*
* (1) <SEQ=SND.NXT> <ACK=RCV.NXT> <CTL=ACK>
*
* (B) "This acknowledgment should be piggybacked on a segment being transmitted if
* possible without incurring undue delay."
*
* See also Note #6.
*
* (3) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check FIN Bit' states
* that "if the FIN bit is set, ... send an acknowledgment for the FIN".
*
* (4) RFC #813, Section 5 states that "the receiver of data will refrain from sending an
* acknowledgement under certain circumstances ... The most obvious event on which to
* depend is the arrival of another segment. So, if a segment arrives, postpone sending
* an acknowledgement if ... the following conditions hold" :
*
* (A) "The push bit is not set in the segment, since it is a reasonable assumption
* that there is more data coming in a subsequent segment."
*
* (1) However, if the PUSH bit is set in any received segment, an acknowledgement
* should be immediately transmitted.
*
* See also Notes #4b1, #5b2, & #6.
*
* (5) (A) RFC #2581, Section 3.2 states that "a TCP receiver SHOULD send an immediate ACK" :
*
* (1) "When an out-of-order segment arrives. The purpose of this ACK is to
* inform the sender that a segment was received out-of-order and which
* sequence number is expected."
*
* (2) "In addition, ... when the incoming segment fills in all or part of a
* gap in the sequence space. This will generate more timely information
* for a sender recovering from a ... retransmission timeout ... [or] a
* fast retransmit."
*
* (B) RFC #1122, Section 4.2.2.21 reiterates that "a TCP MAY send an ACK segment
* acknowledging RCV.NXT when a valid segment arrives that is in the window
* but not at the left window edge ... One reason for ACKing out-of-order
* segments [is] to support ... 'fast retransmit'".
*
* (b) TCP connection acknowledgements are transmitted for certain TCP connection events :
*
* (1) RFC #813, Section 5 states that "the receiver of data will refrain from sending an
* acknowledgement under certain circumstances ... Postpone sending an acknowledgement
* if ... the following conditions hold" :
*
* (B) "There is no revised window information to be sent back."
*
* (1) However, if any local receive window size is available to update to the
* remote host, an acknowledgement should be immediately transmitted.
*
* See also Note #4a4 & 'NetTCP_RxConnWinSizeHandler() Note #4'.
*$PAGE*
* (5) (a) Although NO RFC specifies whether an acknowledgement should or should NOT
* be transmitted in response to a received acknowledgement-only segment, it
* seems reasonable & is assumed that NO TCP connection acknowledgement should
* be transmitted in response to any acknowledgement-only segment(s) received.
*
* (1) A received TCP segment is considered an acknowledgement-only segment if
* the segment was received with zero segment length, i.e. NO received TCP
* sequences :
*
* (A) NO synchronization or close controls)
* (B) NO TCP data
*
* (b) (1) However, since acknowledgements are transmitted in response to various
* invalid segments received, some acknowledgements MUST be transmitted
* even for certain invalid acknowledgement-only segments.
*
* See also Note #4a1.
*
* (2) Also, acknowledgements SHOULD be transmitted for received segments with
* the PUSH bit set, even for segments with NO received TCP data.
*
* See also Note #4a4.
*
* (3) (A) Also, RFC #1122, Section 4.2.2.17 states that the "probing of zero
* (offered) windows MUST be supported. A TCP MAY keep its offered
* receive window closed indefinitely. As long as the receiving TCP
* continues to send acknowledgements in response to the probe segments".
*
* (B) In order to always acknowledge a remote host's probing of the local
* TCP connection's receive window size :
*
* (1) Since probe segments :
*
* (a) may or may NOT contain data, ...
* (b) sequence values may or may NOT be within the TCP connection's
* current receive window; ...
*
* See also Note #4a1D1a1 & 'NetTCP_RxPktConnIsValidSeq() Note #1d3'.
*
* (2) ... acknowledgements SHOULD be transmitted in reply to ALL valid
* & SOME invalid received segments from the remote host whenever
* the TCP connection's local receive window is zero-sized.
*
* (6) (a) The following sections state that "a TCP SHOULD implement a delayed ACK" :
*
* (A) RFC # 813, Section 5
* (B) RFC #1122, Section 4.2.3.2
* (C) RFC #2581, Section 4.2
*
* (1) (A) (1) RFC #1122, Section 4.2.3.2 states that "in a stream of full-sized segments
* there SHOULD be an ACK for at least every second segment".
*
* (2) RFC #2581, Section 4.2 reiterates that "an ACK SHOULD be generated for at
* least every second full-sized segment".
*
* (B) However, RFC #2581, Section 4.2 states that "an implementation is deemed to
* comply with this requirement ... by acknowledging at least every second segment,
* regardless of size".
*
* (2) (A) (1) RFC #813, Section 5 states that "the receiver of data will refrain from
* sending an acknowledgement under certain circumstances, in which case it
* must set a timer which will cause the acknowledgement to be sent later".
*
* (2) RFC #1122, Section 4.2.3.2 states that "an ACK should not be excessively
* delayed; in particular, the delay MUST be less than 0.5 seconds".
*
* (3) RFC #2581, Section 4.2 reiterates that "an ACK ... MUST be generated
* within 500 ms of the arrival of the first unacknowledged packet".
*
* (B) If the acknowledgement delay timeout is configured with a non-zero value,
* at least one timer tick MUST be set to ensure that the non-zero timeout
* is implemented.
*
* (b) However, if NO network timer is available to delay the acknowledgement, the TCP
* connection acknowledgement SHOULD be immediately transmitted.
*$PAGE*
* (7) (a) (1) RFC #1122, Section 4.2.2.14 states that "a careless implementation can send
* two or more acknowledgment segments per data segment received".
*
* (2) RFC #1122, Section 4.2.2.20 states that "in general, the processing of
* received segments MUST be implemented to aggregate ACK segments whenever
* possible. For example, if the TCP is processing a series of queued
* segments, it MUST process them all before sending any ACK segments".
*
* (3) Thus, no more than one acknowledgement SHOULD be transmitted in response
* to any received segment.
*
* (b) "When the application program subsequently consumes the data and increases
* the available receive buffer space again, the receiver may send a second
* acknowledgement segment to update the window at the sender."
*
* However, the application layer receives data from a TCP connection's application
* receive queue asynchronously & irrespective of distinct or specific TCP packets
* (see 'NetTCP_RxAppData() Note #5a'). Thus, any acknowledgement transmissions
* triggered during asynchronous application receives CANNOT be associated with, &
* thereby limited by, any specific received segments.
*
* (8) (a) (1) RFC #793, Sections 3.7 & 2.6 state that "TCP uses retransmission ... to ensure
* delivery of every segment".
*
* (2) However, RFC #1122, Section 4.2.2.17 'DISCUSSION' states that "it is extremely
* important to remember that ACK (acknowledgment) segments that contain no data
* are not reliably transmitted by TCP".
*
* Therefore, it is assumed that TCP acknowledgement-ONLY segments should NOT be
* queued for retransmission but SHOULD be silently discarded.
*
* (b) (1) The network buffer's reference counter is NOT incremented since the TCP layer
* does NOT maintain a reference to any transmitted TCP acknowledgement segments.
*
* (2) Therefore, the network buffer MUST be freed by lower layer(s).
*
* See also 'NetTCP_TxConnReset() Note #6',
* & 'NetTCP_TxConnProbe() Note #3'.
*
* (9) On ANY errors, network resources MUST be appropriately freed :
*
* (a) For any network resources NOT linked to the TCP connection, each network resource
* MUST be freed by appropriate function(s).
*
* (10) #### IP options currently NOT implemented.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnAck (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_ACK_CODE tx_ack_code,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr)
{
#if (((NET_CTR_CFG_STAT_EN == DEF_ENABLED) || \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED)) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NET_TCP_SEQ_CODE seq_code;
NET_TCP_RESET_CODE reset_code;
#endif
CPU_BOOLEAN tx_ack;
CPU_BOOLEAN tmr_free;
CPU_BOOLEAN push_avail;
NET_TMR_TICK timeout_tick;
NET_BUF_SIZE data_len;
NET_BUF_SIZE data_ix;
NET_BUF *pseg_ack;
NET_BUF_HDR *pseg_ack_hdr;
NET_IP_TOS TOS;
NET_IP_TTL TTL;
NET_IP_ADDR src_addr;
NET_IP_ADDR dest_addr;
NET_TCP_PORT_NBR src_port;
NET_TCP_PORT_NBR dest_port;
NET_TCP_SEQ_NBR seq_nbr;
NET_TCP_SEQ_NBR ack_nbr;
NET_TCP_SEQ_NBR ack_nbr_delta;
NET_TCP_WIN_SIZE win_size;
CPU_INT16U flags_tcp;
CPU_INT16U flags_ip;
NET_ERR err;
/* ----------- VALIDATE TCP CONN TX ACK ----------- */
tx_ack = DEF_NO;
tmr_free = DEF_YES;
ack_nbr_delta = 0;
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED: /* See Note #4a1A. */
case NET_TCP_CONN_STATE_LISTEN: /* See Note #4a1B. */
break;
case NET_TCP_CONN_STATE_SYNC_TXD: /* See Note #4a1C. */
if (pbuf_hdr != (NET_BUF_HDR *)0) {
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* See Note #4aA. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
if (seq_code == NET_TCP_CONN_RX_SEQ_SYNC) { /* If valid sync rx'd, ... */
tx_ack = DEF_YES; /* ... tx TCP conn ack. */
}
#else
tx_ack = DEF_YES;
#endif
if (pbuf_hdr->TCP_SegAckTxd != DEF_NO) { /* If prev'ly tx'd TCP conn ack for rx'd seg, .. */
*perr = NET_TCP_ERR_CONN_ACK_PREVLY_TXD; /* .. do NOT re-tx TCP conn ack (see Note #7a3). */
return;
}
} else {
tx_ack = DEF_YES;
}
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
if (pbuf_hdr != (NET_BUF_HDR *)0) {
if (pbuf_hdr->TCP_SegAckTxd != DEF_NO) { /* If prev'ly tx'd TCP conn ack for rx'd seg, .. */
*perr = NET_TCP_ERR_CONN_ACK_PREVLY_TXD; /* .. do NOT re-tx TCP conn ack (see Note #7a3). */
return;
}
}
switch (tx_ack_code) {
case NET_TCP_CONN_TX_ACK_NONE:
*perr = NET_TCP_ERR_CONN_ACK_NONE;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_TX_ACK:
case NET_TCP_CONN_TX_ACK_IMMED:
if (pbuf_hdr != (NET_BUF_HDR *)0) {
push_avail = DEF_BIT_IS_SET(pbuf_hdr->TCP_HdrLen_Flags, NET_TCP_HDR_FLAG_PUSH);
if (push_avail == DEF_YES) { /* If rx'd seg push'd & en'd, .. */
if (pconn->TxAckImmedRxdPushEn != DEF_DISABLED) {
tx_ack = DEF_YES; /* .. tx TCP conn ack (see Note #4a4A1). */
break;
}
}
if (pbuf_hdr->TCP_SegLen == 0) { /* If ack-ONLY seg (see Note #5a1); .. */
if (pconn->RxWinSizeActual > 0) { /* .. & local rx win > 0, .. */
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return; /* .. do NOT tx ack (see Note #5a); .. */
} else { /* .. & local rx win = 0 (see Note #5b3B2), .. */
tx_ack = DEF_YES; /* .. tx TCP conn ack. */
break;
}
}
}
if (tx_ack_code == NET_TCP_CONN_TX_ACK_IMMED) { /* If immed ack req'd, ... */
tx_ack = DEF_YES; /* ... tx TCP conn ack. */
break;
}
if (pconn->TxAckDlyTimeout_ms == 0) { /* If ack dly timeout zero, ... */
tx_ack = DEF_YES; /* ... tx TCP conn ack. */
break;
}
pconn->TxAckDlyCnt++; /* If ack dly cnt >= th, ... */
if (pconn->TxAckDlyCnt >= NET_TCP_ACK_DLY_CNT_TH) {
tx_ack = DEF_YES; /* ... tx TCP conn ack (see Note #6a1B). */
break;
}
if (pconn->TxAckDlyTmr != (NET_TMR *)0) { /* If ack dly tmr prev'ly started, ... */
*perr = NET_TCP_ERR_CONN_ACK_DLYD; /* ... continue ack dly (see Note #6a2A1). */
return;
}
timeout_tick = ((NET_TMR_TICK)pconn->TxAckDlyTimeout_ms * NET_TMR_TIME_TICK_PER_SEC) / DEF_TIME_NBR_mS_PER_SEC;
if (timeout_tick < 1) { /* If < 1 tick, ... */
timeout_tick = 1; /* ... set at least 1 tick (see Note #6a2B). */
}
pconn->TxAckDlyTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_TxConnAckDlyTimeout,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
if ( err == NET_TMR_ERR_NONE) { /* If ack dly tmr avail, ... */
*perr = NET_TCP_ERR_CONN_ACK_DLYD; /* ... start ack dly (see Note #6a2A1). */
return;
} else { /* Else tx TCP conn ack (see Note #6b). */
tx_ack = DEF_YES;
}
break;
/*$PAGE*/
case NET_TCP_CONN_TX_ACK_FAULT: /* See Note #4a1D. */
if (pbuf_hdr != (NET_BUF_HDR *)0) {
if (pbuf_hdr->TCP_SegSync == DEF_YES) { /* If sync rx'd (see Note #4a1D3b1), ... */
tx_ack = DEF_YES; /* ... tx TCP conn ack; ignore possible reset. */
/* If rx'd sync equal to next rx seq nbr, ... */
if (pbuf_hdr->TCP_SeqNbr == pconn->RxSeqNbrNext) {
ack_nbr_delta = 1; /* ... sub 1 from ack (see Note #4a1D3b1B). */
}
} else {
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* See Note #4aA. */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
reset_code = NetTCP_RxPktConnIsValidReset(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
switch (seq_code) {
case NET_TCP_CONN_RX_SEQ_VALID: /* If valid seq rx'd .. */
/* .. but invalid reset rx'd, .. */
if (reset_code == NET_TCP_CONN_RX_RESET_INVALID) {
tx_ack = DEF_YES; /* .. tx TCP conn ack (see Note #4a1D2b1c). */
}
break;
case NET_TCP_CONN_RX_SEQ_SYNC: /* If invalid sync rx'd, .. */
case NET_TCP_CONN_RX_SEQ_SYNC_INVALID:
tx_ack = DEF_YES; /* .. tx TCP conn ack (see Note #4a1D3b1). */
break;
case NET_TCP_CONN_RX_SEQ_NONE:
case NET_TCP_CONN_RX_SEQ_INVALID: /* If invalid seq rx'd (see Note #4a1D1) .. */
default:
/* .. & reset NOT rx'd (see Note #4a1D1b1), .. */
if (reset_code == NET_TCP_CONN_RX_RESET_NONE) {
tx_ack = DEF_YES; /* .. tx TCP conn ack (see Note #4a1D1a). */
}
break;
}
#else
tx_ack = DEF_YES;
#endif
}
} else {
tx_ack = DEF_YES;
}
break;
case NET_TCP_CONN_TX_ACK_TIMEOUT:
tx_ack = DEF_YES;
tmr_free = DEF_NO;
break;
default:
break;
}
break;
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, close_code);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
if (tx_ack != DEF_YES) { /* If NOT valid, abort tx TCP conn ack. */
*perr = NET_TCP_ERR_CONN_ACK_INVALID;
return;
}
NetTCP_TxConnAckDlyReset(pconn, tmr_free); /* Reset ack dly ctrls. */
if (pbuf_hdr != (NET_BUF_HDR *)0) {
pbuf_hdr->TCP_SegAckTxd = DEF_YES; /* Set ack tx'd for rx'd seg (see Note #7a). */
}
/*$PAGE*/
/* ----------- PREPARE TCP CONN ACK SEG ----------- */
/* If valid, prepare & tx TCP conn ack. */
/* Get buf. */
data_len = NET_TCP_DATA_LEN_TX_ACK;
data_ix = NET_BUF_DATA_TX_IX;
pseg_ack = NetBuf_Get((NET_BUF_SIZE) data_len,
(NET_BUF_SIZE) data_ix,
(CPU_INT16U ) NET_BUF_FLAG_NONE,
(NET_ERR *)&err);
if ( err != NET_BUF_ERR_NONE) {
*perr = NET_TCP_ERR_NONE_AVAIL;
return;
}
/* --------------- PREPARE TCP HDR ---------------- */
/* Prepare seg addrs. */
if (pbuf_hdr != (NET_BUF_HDR *)0) { /* If TCP pkt rx'd, cfg TCP tx ... */
/* ... src addr from rx'd TCP pkt dest addr ... */
src_port = (NET_TCP_PORT_NBR)pbuf_hdr->TCP_UDP_PortDest;
src_addr = (NET_IP_ADDR )pbuf_hdr->IP_AddrDest;
/* .. & dest addr from rx'd TCP pkt src addr. */
dest_port = (NET_TCP_PORT_NBR)pbuf_hdr->TCP_UDP_PortSrc;
dest_addr = (NET_IP_ADDR )pbuf_hdr->IP_AddrSrc;
} else { /* Else cfg TCP tx pkt addrs from TCP conn addrs. */
NetTCP_TxConnPrepareSegAddrs((NET_TCP_CONN *) pconn,
(CPU_INT08U *)&src_port,
(CPU_INT08U *)&src_addr,
(CPU_INT16U ) sizeof(src_port),
(CPU_INT16U ) sizeof(src_addr),
(CPU_INT08U *)&dest_port,
(CPU_INT08U *)&dest_addr,
(CPU_INT16U ) sizeof(dest_port),
(CPU_INT16U ) sizeof(dest_addr),
(NET_ERR *)&err);
if ( err != NET_TCP_ERR_NONE) { /* See Note #9a. */
*perr = NET_TCP_ERR_CONN_FAULT;
NetBuf_Free(pseg_ack);
return;
}
}
/* Prepare TCP seq nbrs (see Note #1b2B). */
seq_nbr = pconn->TxSeqNbrNext;
ack_nbr = pconn->RxSeqNbrNext - ack_nbr_delta;
/* Prepare TCP tx flags (see Note #1b2C). */
flags_tcp = NET_TCP_FLAG_NONE |
NET_TCP_FLAG_TX_ACK;
/* Prepare TCP win size. */
win_size = pconn->RxWinSizeActual;
/* Prepare IP params. */
TOS = pconn->TxIP_TOS;
TTL = pconn->TxIP_TTL;
flags_ip = pconn->TxIP_Flags;
/* Init buf ctrls. */
pseg_ack_hdr = &pseg_ack->Hdr;
pseg_ack_hdr->DataIx = (CPU_INT16U )data_ix;
pseg_ack_hdr->DataLen = (NET_BUF_SIZE)data_len;
pseg_ack_hdr->TotLen = (NET_BUF_SIZE)pseg_ack_hdr->DataLen;
pseg_ack_hdr->ProtocolHdrType = NET_PROTOCOL_TYPE_TCP;
pseg_ack_hdr->TCP_SegSync = (CPU_BOOLEAN )DEF_NO;
pseg_ack_hdr->TCP_SegClose = (CPU_BOOLEAN )DEF_NO;
pseg_ack_hdr->TCP_SegAck = (CPU_BOOLEAN )DEF_YES;
pseg_ack_hdr->TCP_SegReset = (CPU_BOOLEAN )DEF_NO;
pseg_ack_hdr->TCP_Flags = flags_tcp;
/*$PAGE*/
/* ------------- TX TCP CONN ACK SEG -------------- */
NetTCP_TxPktHandler((NET_BUF *) pseg_ack,
(NET_IP_ADDR ) src_addr,
(NET_TCP_PORT_NBR) src_port,
(NET_IP_ADDR ) dest_addr,
(NET_TCP_PORT_NBR) dest_port,
(NET_TCP_SEQ_NBR ) seq_nbr,
(NET_TCP_SEQ_NBR ) ack_nbr,
(NET_TCP_WIN_SIZE) win_size,
(NET_IP_TOS ) TOS,
(NET_IP_TTL ) TTL,
(CPU_INT16U ) flags_tcp,
(CPU_INT16U ) flags_ip,
(void *) 0,
(void *) 0, /* See Note #10. */
(NET_ERR *)&err); /* Ignore transitory tx err(s). */
#if 0 /* Tx buf freed by lower layer(s) [see Note #8b2]. */
NetTCP_TxPktFree(pseg_ack);
#endif
NET_CTR_STAT_INC(NetTCP_StatTxSegConnAckCtr);
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnAckDlyReset()
*
* Description : Reset a TCP connection's delayed acknowledgement controls.
*
* Argument(s) : pconn Pointer to TCP connection to reset delayed acknowledgement controls.
* ----- Argument validated in NetTCP_TxConnAck(),
* NetTCP_TxConnTxQ(),
* NetTCP_TxConnReTxQ_Timeout().
*
* tmr_free Indicate whether to free network timer :
*
* DEF_YES Free network timer for delayed acknowledgement.
* DEF_NO Do NOT free network timer for delayed acknowledgement
* [Freed by NetTmr_TaskHandler()
* via NetTCP_TxConnAckDlyTimeout()].
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnAck(),
* NetTCP_TxConnTxQ(),
* NetTCP_TxConnReTxQ().
*
* Note(s) : (1) A TCP connection's delayed acknowledgement controls SHOULD be reset whenever :
*
* (a) TCP data segment(s) are transmitted
* (b) TCP data segment(s) are re-transmitted
*
* ... since any transmitted or re-transmitted data segment(s) always transmit an
* accompanying acknowledgement.
*********************************************************************************************************
*/
static void NetTCP_TxConnAckDlyReset (NET_TCP_CONN *pconn,
CPU_BOOLEAN tmr_free)
{
pconn->TxAckDlyCnt = 0; /* Reset ack dly cnts ... */
if (pconn->TxAckDlyTmr != (NET_TMR *)0) { /* ... & free/clr ack dly tmr. */
if (tmr_free == DEF_YES) {
NetTmr_Free(pconn->TxAckDlyTmr);
}
pconn->TxAckDlyTmr = (NET_TMR *)0;
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnAckDlyTimeout()
*
* Description : (1) Handle TCP connection's delayed acknowledgement transmit for the following connected
* states :
*
* (a) SYN-RECEIVED
* (b) ESTABLISHED
* (c) FIN-WAIT-1
* (d) FIN-WAIT-2
* (e) CLOSING
* (f) TIME-WAIT
* (g) CLOSE-WAIT
* (h) LAST-ACK
*
*
* Argument(s) : pconn_timeout Pointer to TCP connection to transmit delayed acknowledgement (see Note #2b).
*
* Return(s) : none.
*
* Caller(s) : Referenced in NetTCP_TxConnAck().
*
* Note(s) : (2) Ideally, network timer expiration functions could be defined as '[(void) (OBJECT *)]'
* type functions -- even though network timer API functions cast expiration functions
* to generic 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]').
*
* (a) (1) Unfortunately, ISO-IEC 9899-1999 ANSI-C, Section 6.3.2.3.7 states that "a
* pointer to an object ... may be converted to a pointer to a different object
* ... [but] if the resulting pointer is not correctly aligned ... the behavior
* is undefined".
*
* And since compilers may NOT correctly convert 'void' pointers to non-'void'
* pointer arguments, network timer expiration functions MUST avoid incorrect
* pointer conversion behavior between 'void' pointer parameters & non-'void'
* pointer arguments & therefore CANNOT be defined as '[(void) (OBJECT *)]'.
*
* (2) However, Section 6.3.2.3.1 states that "a pointer to void may be converted
* to or from a pointer to any ... object ... A pointer to any ... object ...
* may be converted to a pointer to void and back again; the result shall
* compare equal to the original pointer".
*
* (b) Therefore, to correctly convert 'void' pointer objects back to appropriate
* network object pointer objects, network timer expiration functions MUST :
*
* (1) Be defined as 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]'); & ...
* (2) Explicitly cast 'void' pointer arguments to specific object pointers; ...
* (A) ... in this case, a 'NET_TCP_CONN' pointer.
*
* See also 'net_tmr.c NetTmr_Get() Note #3'.
*
* (3) This function is a network timer expiration function :
*
* (a) (1) For the following connection timer(s) :
*
* (A) TCP connection transmit acknowledgement delay timer ('TxAckDlyTmr')
*
* (2) (A) Clear the timer pointer; ...
* (1) Cleared prior to next handler function(s) as an extra precaution to
* avoiding re-freeing the timer (see Note #3a2B).
*
* (B) but do NOT re-free the timer.
*
* (b) Do NOT set the following close timer flag(s) :
*
* (1) NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnAckDlyTimeout (void *pconn_timeout)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
NET_TCP_CLOSE_CODE close_code;
NET_ERR err;
pconn = (NET_TCP_CONN *)pconn_timeout; /* See Note #2b2A. */
close_code = NET_TCP_CONN_CLOSE_ALL;
DEF_BIT_CLR(close_code, NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY); /* See Note #3b1. */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
/* -------------- VALIDATE PTR ---------------- */
if (pconn == (NET_TCP_CONN *)0) {
NET_CTR_ERR_INC(NetTCP_ErrNullPtrCtr);
return;
}
/* -------------- VALIDATE TYPE --------------- */
if (pconn->Type != NET_TCP_TYPE_CONN) {
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidTypeCtr);
return;
}
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
return; /* Prevent 'break NOT reachable' warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
return; /* Prevent 'break NOT reachable' warning. */
case NET_TCP_CONN_STATE_SYNC_RXD: /* See Note #1. */
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)close_code);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
return; /* Prevent 'break NOT reachable' warning. */
}
#endif
/* ------ HANDLE TCP CONN TX ACK TIMEOUT ------ */
pconn->TxAckDlyTmr = (NET_TMR *)0; /* Clr tx ack dly tmr (see Note #3a2A1). */
NetTCP_TxConnAck((NET_TCP_CONN *) pconn,
(NET_BUF_HDR *) 0,
(NET_TCP_ACK_CODE ) NET_TCP_CONN_TX_ACK_TIMEOUT,
(NET_TCP_CLOSE_CODE) close_code,
(NET_ERR *)&err); /* Ignore transitory tx err(s). */
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnReset()
*
* Description : (1) Prepare & transmit a TCP connection reset :
*
* (a) Validate received TCP packet for TCP reset See Note #4
* (b) Validate TCP connection state for TCP reset See Note #3
* (c) Prepare TCP reset segment :
* (1) Get buffer
* (2) Prepare TCP segment :
* (A) TCP segment addresses
* (B) TCP segment sequence numbers See Note #5
* (C) TCP segment transmit flags :
* (1) RESET
* (2) ACK See Note #5a2A
* (D) TCP segment window size
* (E) TCP segment packet buffer controls
* (d) Transmit TCP connection reset
*
*
* Argument(s) : pconn Pointer to a TCP connection.
*
* pbuf_hdr Pointer to network buffer header that received TCP packet, if available.
*
* tx_reset_code Indicate whether & how to transmit a TCP reset segment :
*
* NET_TCP_CONN_TX_RESET Transmit a TCP reset segment, if permitted
* (see Notes #3 & #4).
* NET_TCP_CONN_TX_RESET_FAULT Transmit a TCP reset segment immediately for
* a closing TCP connection fault.
*
* close_code Select which close action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_CLOSE_NONE Perform NO close actions.
* NET_TCP_CONN_CLOSE_ALL Perform ALL close actions.
*
* NET_TCP_CONN_CLOSE_CONN_TX_RESET Perform close connection transmit reset.
* NET_TCP_CONN_CLOSE_CONN_ALL Perform ALL connection close actions.
*
* NET_TCP_CONN_CLOSE_TMR_TX_IDLE Close transmit idle timer.
* NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN Close transmit silly window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN Close transmit zero window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY Close transmit acknowledgement delay timer.
* NET_TCP_CONN_CLOSE_TMR_RE_TX Close re-transmit timer.
* NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE Close connection keep-alive timer.
* NET_TCP_CONN_CLOSE_TMR_TIMEOUT Close connection timer.
* NET_TCP_CONN_CLOSE_TMR_ALL Close ALL timers.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES'.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection reset successfully transmitted.
* NET_TCP_ERR_CONN_RESET_INVALID TCP connection reset NOT valid for current TCP
* connection state.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
*
* - RETURNED BY NetTCP_RxPktConnIsValidSeq() : -
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
*
* Return(s) : none.
*
* Caller(s) : various.
*$PAGE*
* Note(s) : (2) See the following RFC's for TCP reset generation summary :
*
* (a) RFC #793, Section 3.4 'Establishing a Connection : Reset Generation'
* (b) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES'
* (c) RFC Draft-IETF-TCPm-TCPSecure #00, Section 3
*
* (3) TCP connection resets are transmitted :
*
* (a) When certain invalid segments are received :
*
* (A) Some TCP transmit reset validation logic implemented in previous functions;
* include duplicate validation logic in NetTCP_TxConnReset() only if debug/
* validation code is enabled (i.e. NET_ERR_CFG_ARG_CHK_DBG_EN is DEF_ENABLED
* in 'net_cfg.h').
*
* (1) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : CLOSED [State]'
* states that if the current TCP connection "state is CLOSED", then ...
*
* (1) "An incoming segment containing a RST is discarded".
* (2) "An incoming segment NOT containing a RST causes a RST to be sent".
*
* (B) RFC #793, Section 3.4 'Establishing a Connection : Reset Generation : 1'
* reiterates that "if [a] connection does not exist (CLOSED) then a reset is
* sent in response to any incoming segment except another reset".
*
* (2) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State] :
* Check for ACK' states that "any acknowledgment is bad if it arrives on a
* connection still in the LISTEN state. An acceptable reset segment should
* be formed for any arriving ACK-bearing segment".
*
* (B) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State] :
* Check for SYN' also states that "if the security/compartment on the incoming
* segment does not exactly match the security/compartment in the TCB ... [or]
* if the SEG.PRC is ... not allowed [then] send a reset".
*
* However, these checks for invalid connection permissions are NOT necessary
* since TCP security & precedence NOT supported (see 'net_tcp.c Note #1a').
*
* (3) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check ACK Bit' states that "if the state is SYN-SENT" & "the ACK bit is set" &
* the incoming segment's "SEG.ACK =< ISS, or SEG.ACK > SND.NXT, send a reset".
*$PAGE*
* (4) (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check Sequence
* Number' states that for the "SYN-RECEIVED STATE, ESTABLISHED STATE, FIN-
* WAIT-1 STATE, FIN-WAIT-2 STATE, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK
* STATE, TIME-WAIT STATE", to "first check [the] sequence number ... [and if
* it] is not acceptable, an acknowledgment should be sent in reply ... unless
* the RST bit is set".
*
* (B) (1) (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check SYN
* Bit' states that for "SYN-RECEIVED [STATE], ESTABLISHED STATE, FIN-WAIT
* STATE-1, FIN-WAIT STATE-2, CLOSE-WAIT STATE, CLOSING STATE, LAST-ACK
* STATE, TIME-WAIT STATE ... [to next] check the SYN bit ... [and] if
* the SYN is in the window it is an error, send a reset, any outstanding
* RECEIVEs and SEND[s] should receive 'reset' responses, all segment
* queues should be flushed, the user should also receive an unsolicited
* general 'connection reset' signal[, and] enter the CLOSED state".
*
* (b) But "if the SYN is not in the window this step would not have been
* reached and an ack would have been sent" (see Note #3a4A).
*
* (2) (a) HOWEVER, RFC Draft-IETF-TCPm-TCPSecure #00, Section 3.2 amends the
* "handling of a segment with the SYN bit set in the synchronized state
* ... [by] handling ... the SYN bit" as follows :
*
* (a) "If the SYN bit is set and the sequence number is outside the
* expected window, send an ACK back to the peer."
*
* (b) "If the SYN bit is set and the sequence number is an exact
* match to the next expected sequence (RCV.NXT == SEG.SEQ)
* then send an ACK segment ... but ... subtract one from
* value being acknowledged."
*
* (c) "If the SYN bit is set and the sequence number is acceptable,
* i.e.: (RCV.NXT <= SEG.SEQ <= RCV.NXT+RCV.WND) then send an
* ACK segment."
*
* (b) ???? Although RFC Draft-IETF-TCPm-TCPSecure #00 explicitly states that
* this amendment applies only to the "handling of a ... SYN ... in a
* synchronized state", it is assumed that this should also apply to the
* SYN-RECEIVED state.
*
* (C) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field'
* states to next "check the ACK Field" :
*
* (1) If in the "SYN-RECEIVED STATE ... [and] if the segment acknowledgment
* is not acceptable, form a reset segment".
*
* (2) If in the "ESTABLISHED STATE" or any state with similar "processing as
* for the ESTABLISHED STATE", that "if the ACK acks something not yet sent
* (SEG.ACK > SND.NXT) then send an ACK" but "if the ACK is a duplicate
* (SEG.ACK =< SND.UNA), it can be ignored".
*
* (D) RFC #793, Section 3.4 'Establishing a Connection : Reset Generation : 3'
* reiterates that for any TCP "connection ... in a synchronized state
* (ESTABLISHED, FIN-WAIT-1, FIN-WAIT-2, CLOSE-WAIT, CLOSING, LAST-ACK,
* TIME-WAIT), any unacceptable segment (out of window sequence number
* or unacceptible [sic] acknowledgment number) must elicit only an empty
* acknowledgment segment containing the current send-sequence number and
* an acknowledgment indicating the next sequence number expected to be
* received".
*
* (b) (1) When TCP connection fault-closes from the following synchronization/connected/
* closing states :
*
* (A) SYN-RECEIVED
* (B) SYN-SENT
* (C) ESTABLISHED
* (D) FIN-WAIT-1
* (E) FIN-WAIT-2
* (F) CLOSING
* (G) TIME_WAIT
* (H) CLOSE-WAIT
* (I) LAST-ACK
*
* (2) Although NO RFC directly states to transmit a TCP reset segment when a TCP
* connection fault-closes, it is inferred & seems reasonable that a TCP reset
* segment SHOULD be transmitted whenever a TCP connection closes abnormally.
*$PAGE*
* (4) The following sections reiterate the generalization that "a reset is sent in response
* to any [unacceptable segment] ... EXCEPT* another reset"; also "send a reset (UNLESS*
* the RST bit is set, if so drop the segment)" : [*emphasis added]
*
* (a) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State] :
* Check for RST'
* (b) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State] :
* Check ACK Bit'
* (c) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* SYN-RECEIVED STATE' (see Note #4A)
*
* (A) This confirms that the received segment does NOT contain a TCP reset control
* since it follows RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES :
* Check RST Bit'.
*
* (5) (a) (1) The following sections ... :
*
* (A) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : CLOSED [State]'
* (B) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : LISTEN [State]'
* (1) Amended by RFC #1122, Section 4.2.2.20.(b)
* (C) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : SYN-SENT [State]'
* (D) RFC #793, Section 3.9 'Event Processing : SEGMENT ARRIVES : Check ACK Field :
* SYN-RECEIVED STATE'
*
* (2) ... generalize that "the acknowledgment and sequence field values [for the reset
* segment to transmit] are selected to make the reset sequence acceptable to the
* TCP that sent the offending segment" (see Note #3a) :
*
* (A) "If the ACK bit is off, sequence number zero is used,
*
* <SEQ=0> <ACK=SEG.SEQ + SEG.LEN> <CTL=RST, ACK>"
*
* (B) "If the ACK bit is on,
*
* <SEQ=SEG.ACK> <CTL=RST>"
*
* (b) However, NO RFC specifies the sequence & acknowledgement numbers to use when
* trasmitting a reset segment for a TCP connection that closes due to any fault
* condition(s) [see Note #3b].
*
* (1) #### Therefore, TCP transmit reset segments for fault-closing TCP connections
* should be prepared as follows :
*
* (A) With the following TCP sequence numbers :
*
* (1) TCP_SeqNbr = TxSeqNbrUnAckd
*
* (2) TCP_AckNbr = RxSeqNbrNext
*
* where
*
* TCP_SeqNbr TCP transmit reset segment sequence number
* TCP_AckNbr TCP transmit reset segment acknowledgement number
* TxSeqNbrUnAckd TCP connection's currently unacknowledged transmit
* sequence number
* RxSeqNbrNext TCP connection's currently expected next receive
* sequence number
*
* (B) With the following TCP segment header flags set :
*
* (1) RESET
*
* (2) This TCP transmit reset segment format complies with TCP connection received
* reset segment handling as specified in RFC #793, Section 3.9 'Event Processing :
* SEGMENT ARRIVES'.
*
* See also 'NetTCP_RxPktConnIsValidReset() Notes #2a2, 2a3, 2a4A1, & 2a4B1'.
*$PAGE*
* (6) (a) RFC #793, Sections 3.7 & 2.6 state that "TCP uses retransmission ... to ensure
* delivery of every segment".
*
* However, NO RFC specifies whether TCP connection reset segments should be queued
* for retransmission. Therefore, it is assumed that ALL TCP connection reset
* segments SHOULD NOT be queued for retransmission but SHOULD be silently discarded.
*
* (b) (1) The network buffer's reference counter is NOT incremented since the TCP layer
* does NOT maintain a reference to any transmitted TCP connection reset segments.
*
* (2) Therefore, the network buffer MUST be freed by lower layer(s).
*
* See also 'NetTCP_TxConnAck() Note #8',
* & 'NetTCP_TxConnProbe() Note #3'.
*
* (7) On ANY errors :
*
* (a) Network resources MUST be appropriately freed :
*
* (1) For any network resources NOT linked to the TCP connection, each network resource
* MUST be freed by appropriate function(s).
*
* (b) TCP connection MUST NOT be re-closed.
*
* See also 'NetTCP_ConnClose() Note #5'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnReset (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_RESET_CODE tx_reset_code,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr)
{
#if (((NET_CTR_CFG_ERR_EN == DEF_ENABLED) || \
(NET_CTR_CFG_STAT_EN == DEF_ENABLED)) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NET_TCP_ACK_CODE ack_code;
NET_TCP_SEQ_CODE seq_code;
#endif
CPU_BOOLEAN tx_reset;
NET_BUF_SIZE data_len;
NET_BUF_SIZE data_ix;
NET_BUF *pseg_reset;
NET_BUF_HDR *pseg_reset_hdr;
NET_IP_ADDR src_addr;
NET_IP_ADDR dest_addr;
NET_TCP_PORT_NBR src_port;
NET_TCP_PORT_NBR dest_port;
NET_TCP_SEQ_NBR seq_nbr;
NET_TCP_SEQ_NBR ack_nbr;
NET_TCP_WIN_SIZE win_size;
CPU_INT16U flags_tcp;
NET_ERR err;
/* ------------ VALIDATE RX'D TCP PKT ------------- */
if (pbuf_hdr != (NET_BUF_HDR *)0) {
if (pbuf_hdr->TCP_SegReset != DEF_NO) { /* If TCP reset pkt rx'd, ... */
*perr = NET_TCP_ERR_CONN_RESET_INVALID; /* ... do NOT tx TCP conn reset (see Note #4). */
return;
}
}
/* ----------- VALIDATE TCP CONN STATE ------------ */
tx_reset = DEF_NO;
if (pconn != (NET_TCP_CONN *)0) {
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED: /* See Note #3a1. */
tx_reset = DEF_YES;
break;
case NET_TCP_CONN_STATE_LISTEN: /* See Note #3a2. */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* See Note #3aA. */
if (pbuf_hdr != (NET_BUF_HDR *)0) { /* If seg rx'd ... */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
if (ack_code != NET_TCP_CONN_RX_ACK_NONE) { /* ... with ANY (invalid) ack, ... */
tx_reset = DEF_YES; /* ... tx TCP conn reset (see Note #3a2A). */
}
}
#else
tx_reset = DEF_YES;
#endif
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_SYNC_TXD: /* See Note #3a3. */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* See Note #3aA. */
switch (tx_reset_code) {
case NET_TCP_CONN_TX_RESET:
default:
if (pbuf_hdr != (NET_BUF_HDR *)0) { /* If seg rx'd ... */
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* ... with invalid ack, ... */
if (ack_code == NET_TCP_CONN_RX_ACK_INVALID) {
tx_reset = DEF_YES; /* ... tx TCP conn reset (see Note #3a3). */
}
} else { /* Else no seg rx'd, ... */
tx_reset = DEF_YES; /* ... tx TCP conn reset (see Note #3b1B). */
}
break;
case NET_TCP_CONN_TX_RESET_FAULT:
tx_reset = DEF_YES;
break;
}
#else
(void)&tx_reset_code; /* Prevent compiler warning. */
tx_reset = DEF_YES;
#endif
break;
case NET_TCP_CONN_STATE_SYNC_RXD: /* See Note #3a4. */
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* See Note #3aA. */
switch (tx_reset_code) {
case NET_TCP_CONN_TX_RESET:
default:
if (pbuf_hdr != (NET_BUF_HDR *)0) { /* If seg rx'd ... */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* ... with invalid seq/sync, ... */
if (seq_code != NET_TCP_CONN_RX_SEQ_VALID) {
/* ... tx TCP conn ack (see Notes #3a4A & #3a4B2); */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return;
}
ack_code = NetTCP_RxPktConnIsValidAck(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* ... without valid ack, ... */
if (ack_code != NET_TCP_CONN_RX_ACK_VALID) {
tx_reset = DEF_YES; /* ... tx TCP conn reset (see Note #3a4C1). */
}
} else { /* Else no seg rx'd, ... */
tx_reset = DEF_YES; /* ... tx TCP conn reset (see Note #3b1A). */
}
break;
case NET_TCP_CONN_TX_RESET_FAULT:
tx_reset = DEF_YES;
break;
}
#else
(void)&tx_reset_code; /* Prevent compiler warning. */
tx_reset = DEF_YES;
#endif
break;
/*$PAGE*/
case NET_TCP_CONN_STATE_CONN: /* See Note #3a4. */
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* See Note #3aA. */
switch (tx_reset_code) {
case NET_TCP_CONN_TX_RESET:
default:
if (pbuf_hdr != (NET_BUF_HDR *)0) { /* If seg rx'd ... */
seq_code = NetTCP_RxPktConnIsValidSeq(pconn, pbuf_hdr, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* ... with invalid seq/sync, ... */
if (seq_code != NET_TCP_CONN_RX_SEQ_VALID) {
/* ... tx TCP conn ack (see Notes #3a4A & #3a4B2). */
NetTCP_TxConnAck(pconn, pbuf_hdr, NET_TCP_CONN_TX_ACK_FAULT, NET_TCP_CONN_CLOSE_ALL, &err);
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return;
}
} else { /* Else no seg rx'd, ... */
tx_reset = DEF_YES; /* ... tx TCP conn reset (see Notes #3b1C - #3b1I).*/
}
break;
case NET_TCP_CONN_TX_RESET_FAULT:
tx_reset = DEF_YES;
break;
}
#else
(void)&tx_reset_code; /* Prevent compiler warning. */
tx_reset = DEF_YES;
#endif
break;
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
tx_reset = DEF_YES;
break;
case NET_TCP_CONN_STATE_NONE:
default:
if (close_code != NET_TCP_CONN_CLOSE_NONE) { /* If tx reset NOT req'd by TCP conn close fnct(s), */
/* ... close TCP conn (see Note #7b). */
DEF_BIT_CLR(close_code, NET_TCP_CONN_CLOSE_CONN_TX_RESET);
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)close_code);
}
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
} else { /* If NO demux'd TCP conn avail, handle as CLOSED. */
if (pbuf_hdr != (NET_BUF_HDR *)0) { /* If rx'd pkt avail, ... */
tx_reset = DEF_YES; /* ... tx reset. */
}
}
if (tx_reset != DEF_YES) { /* If NOT valid, abort tx TCP conn reset. */
*perr = NET_TCP_ERR_CONN_RESET_INVALID;
return;
}
/*$PAGE*/
/* ---------- PREPARE TCP CONN RESET SEG ---------- */
/* If valid, prepare & tx TCP conn reset. */
/* Get buf. */
data_len = NET_TCP_DATA_LEN_TX_RESET;
data_ix = NET_BUF_DATA_TX_IX;
pseg_reset = NetBuf_Get((NET_BUF_SIZE) data_len,
(NET_BUF_SIZE) data_ix,
(CPU_INT16U ) NET_BUF_FLAG_NONE,
(NET_ERR *)&err);
if ( err != NET_BUF_ERR_NONE) {
*perr = NET_TCP_ERR_NONE_AVAIL;
return;
}
/* --------------- PREPARE TCP HDR ---------------- */
/* Prepare seg addrs. */
if (pbuf_hdr != (NET_BUF_HDR *)0) { /* If TCP pkt rx'd, cfg TCP tx ... */
/* ... src addr from rx'd TCP pkt dest addr ... */
src_port = (NET_TCP_PORT_NBR)pbuf_hdr->TCP_UDP_PortDest;
src_addr = (NET_IP_ADDR )pbuf_hdr->IP_AddrDest;
/* .. & dest addr from rx'd TCP pkt src addr. */
dest_port = (NET_TCP_PORT_NBR)pbuf_hdr->TCP_UDP_PortSrc;
dest_addr = (NET_IP_ADDR )pbuf_hdr->IP_AddrSrc;
} else { /* Else cfg TCP tx pkt addrs from TCP conn addrs. */
NetTCP_TxConnPrepareSegAddrs((NET_TCP_CONN *) pconn,
(CPU_INT08U *)&src_port,
(CPU_INT08U *)&src_addr,
(CPU_INT16U ) sizeof(src_port),
(CPU_INT16U ) sizeof(src_addr),
(CPU_INT08U *)&dest_port,
(CPU_INT08U *)&dest_addr,
(CPU_INT16U ) sizeof(dest_port),
(CPU_INT16U ) sizeof(dest_addr),
(NET_ERR *)&err);
if ( err != NET_TCP_ERR_NONE) { /* See Note #7a. */
*perr = NET_TCP_ERR_CONN_FAULT;
NetBuf_Free(pseg_reset);
return;
}
}
/* Prepare TCP tx flags (see Note #1c2C). */
flags_tcp = NET_TCP_FLAG_NONE |
NET_TCP_FLAG_TX_RESET;
/* Prepare TCP seq nbrs (see Note #5). */
if (pbuf_hdr != (NET_BUF_HDR *)0) {
if (pbuf_hdr->TCP_SegAck != DEF_NO) { /* If TCP ack rx'd, ... (see Note #5a2B) */
seq_nbr = pbuf_hdr->TCP_AckNbr; /* .. tx seq = ack ... */
ack_nbr = NET_TCP_ACK_NBR_NONE; /* .. & ack = none. */
} else { /* Otherwise, ... (see Note #5a2A) */
seq_nbr = NET_TCP_SEQ_NBR_NONE; /* .. tx seq = 0 (none) ... */
ack_nbr = pbuf_hdr->TCP_SeqNbr /* .. & ack = seg seq ... */
+ pbuf_hdr->TCP_SegLen; /* .. + seg len. */
DEF_BIT_SET(flags_tcp, NET_TCP_FLAG_TX_ACK);
}
} else { /* Else no seg rx'd, ... (see Note #5b1A) */
seq_nbr = pconn->TxSeqNbrUnAckd; /* .. tx seq = tx unack'd ... */
ack_nbr = pconn->RxSeqNbrNext; /* .. & ack = rx next. */
}
/* Prepare TCP win size. */
win_size = NET_TCP_WIN_SIZE_NONE;
/* Init buf ctrls. */
pseg_reset_hdr = &pseg_reset->Hdr;
pseg_reset_hdr->DataIx = (CPU_INT16U )data_ix;
pseg_reset_hdr->DataLen = (NET_BUF_SIZE)data_len;
pseg_reset_hdr->TotLen = (NET_BUF_SIZE)pseg_reset_hdr->DataLen;
pseg_reset_hdr->ProtocolHdrType = NET_PROTOCOL_TYPE_TCP;
pseg_reset_hdr->TCP_SegSync = (CPU_BOOLEAN )DEF_NO;
pseg_reset_hdr->TCP_SegClose = (CPU_BOOLEAN )DEF_NO;
pseg_reset_hdr->TCP_SegAck = (CPU_BOOLEAN )DEF_BIT_IS_SET(flags_tcp, NET_TCP_FLAG_TX_ACK);
pseg_reset_hdr->TCP_SegReset = (CPU_BOOLEAN )DEF_YES;
pseg_reset_hdr->TCP_Flags = flags_tcp;
/*$PAGE*/
/* ------------ TX TCP CONN RESET SEG ------------- */
NetTCP_TxPktHandler((NET_BUF *) pseg_reset,
(NET_IP_ADDR ) src_addr,
(NET_TCP_PORT_NBR) src_port,
(NET_IP_ADDR ) dest_addr,
(NET_TCP_PORT_NBR) dest_port,
(NET_TCP_SEQ_NBR ) seq_nbr,
(NET_TCP_SEQ_NBR ) ack_nbr,
(NET_TCP_WIN_SIZE) win_size,
(NET_IP_TOS ) NET_IP_TOS_DFLT,
(NET_IP_TTL ) NET_IP_TTL_DFLT,
(CPU_INT16U ) flags_tcp,
(CPU_INT16U ) NET_IP_FLAG_NONE,
(void *) 0,
(void *) 0,
(NET_ERR *)&err); /* Ignore transitory tx err(s). */
#if 0 /* Tx buf freed by lower layer(s) [see Note #6b2]. */
NetTCP_TxPktFree(pseg_reset);
#endif
NET_CTR_STAT_INC(NetTCP_StatTxSegConnResetCtr);
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnProbe()
*
* Description : (1) Prepare & transmit a TCP connection probe :
*
* (a) Validate TCP connection state for TCP probe
* (b) Prepare TCP probe segment : See Note #2
* (1) Get buffer
* (2) Prepare TCP segment :
* (A) TCP segment addresses
* (B) TCP segment sequence numbers See Note #2b1
* (C) TCP segment transmit flags :
* (1) ACK
* (D) TCP segment window size
* (E) IP datagram parameters
* (F) TCP segment packet buffer controls
* (c) Transmit TCP connection probe
*
*
* Argument(s) : pconn Pointer to a TCP connection.
*
* tx_probe_data_octet Indicate whether to transmit a single data probe octet (see Note #2b2) :
*
* DEF_YES Transmit data probe octet.
* DEF_NO Do NOT transmit data probe octet.
*
* close_code Select which close action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_CLOSE_NONE Perform NO close actions.
* NET_TCP_CONN_CLOSE_ALL Perform ALL close actions.
*
* NET_TCP_CONN_CLOSE_CONN_TX_RESET Perform close connection transmit reset.
* NET_TCP_CONN_CLOSE_CONN_ALL Perform ALL connection close actions.
*
* NET_TCP_CONN_CLOSE_TMR_TX_IDLE Close transmit idle timer.
* NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN Close transmit silly window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN Close transmit zero window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY Close transmit acknowledgement delay timer.
* NET_TCP_CONN_CLOSE_TMR_RE_TX Close re-transmit timer.
* NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE Close connection keep-alive timer.
* NET_TCP_CONN_CLOSE_TMR_TIMEOUT Close connection timer.
* NET_TCP_CONN_CLOSE_TMR_ALL Close ALL timers.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES'.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection probe successfully transmitted.
* NET_TCP_ERR_CONN_PROBE_INVALID TCP connection probe NOT valid for current
* TCP connection state.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_CONN_FAIL TCP connection operation(s) failed.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnWinSizeZeroWinHandler(),
* NetTCP_TxConnKeepAlive().
*$PAGE*
* Note(s) : (2) TCP connection probes are transmitted for certain TCP conditions :
*
* (A) Some TCP transmit probe validation logic implemented in previous functions;
* include duplicate validation logic in NetTCP_TxConnProbe() only if debug/
* validation code is enabled (i.e. NET_ERR_CFG_ARG_CHK_DBG_EN is DEF_ENABLED
* in 'net_cfg.h').
*
* (a) RFC #1122, Section 4.2.3.6 specifies a "mechanism [that] periodically probes the
* other end of a connection" for the following TCP connection conditions :
*
* (1) Probing Zero Windows RFC #1122, Section 4.2.2.17
* (see 'NetTCP_TxConnWinSizeZeroWinHandler() Note #1b')
*
* (2) TCP Keep-Alives RFC #1122, Section 4.2.3.6
* (see 'NetTCP_TxConnKeepAlive() Note #2c')
*
* (b) "Send a probe segment ... to elicit a response from the peer TCP" :
*
* (1) "Such a segment generally contains SEG.SEQ = SND.NXT-1" ...
*
* (A) "Note that on a quiet [or deadlocked] connection SND.NXT = RCV.NXT, so that
* this SEG.SEQ will be outside the window. Therefore, the probe causes the
* receiver to return an acknowledgment segment."
*
* (B) "It is extremely important to remember that ACK segments that contain no data
* are not reliably transmitted by TCP."
*
* (2) "and may or may not contain one garbage octet of data."
*
* (A) "An implementation SHOULD send a [probe] segment with no data."
*
* (B) (1) "Unfortunately, some misbehaved TCP implementations fail to respond to
* a segment with SEG.SEQ = SND.NXT-1 unless the segment contains data."
*
* (2) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 23.3,
* Page 335 reiterates that "some older implementations based on 4.2BSD
* do not respond to these ... probes unless the segment contains data".
*
* (C) Therefore, RFC #1122, Section 4.2.3.6 states that a TCP "implementation ...
* MAY be configurable to send a [probe] segment containing one garbage octet,
* for compatibility with erroneous TCP implementations".
*
* (3) (a) (1) RFC #793, Sections 3.7 & 2.6 state that "TCP uses retransmission ... to ensure
* delivery of every segment".
*
* (2) However, RFC #1122, Section 4.2.2.17 'DISCUSSION' states that "it is extremely
* important to remember that ACK (acknowledgment) segments that contain no data
* are not reliably transmitted by TCP".
*
* Therefore, it is assumed that TCP acknowledgement/probe segments should NOT be
* queued for retransmission but SHOULD be silently discarded.
*
* (b) (1) The network buffer's reference counter is NOT incremented since the TCP layer
* does NOT maintain a reference to any transmitted TCP probe segments.
*
* (2) Therefore, the network buffer MUST be freed by lower layer(s).
*
* See also 'NetTCP_TxConnAck() Note #8',
* & 'NetTCP_TxConnReset() Note #6'.
*
* (4) On ANY errors, network resources MUST be appropriately freed :
*
* (a) For any network resources NOT linked to the TCP connection, each network resource
* MUST be freed by appropriate function(s).
*
* (5) #### IP options currently NOT implemented.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnProbe (NET_TCP_CONN *pconn,
CPU_BOOLEAN tx_probe_data_octet,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr)
{
#if ((((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED)) || \
(NET_CTR_CFG_STAT_EN == DEF_ENABLED)) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
CPU_BOOLEAN tx_probe;
#endif
NET_BUF_SIZE data_len;
NET_BUF_SIZE data_ix;
NET_BUF *pseg_probe;
NET_BUF_HDR *pseg_probe_hdr;
NET_IP_TOS TOS;
NET_IP_TTL TTL;
NET_IP_ADDR src_addr;
NET_IP_ADDR dest_addr;
NET_TCP_PORT_NBR src_port;
NET_TCP_PORT_NBR dest_port;
NET_TCP_SEQ_NBR seq_nbr;
NET_TCP_SEQ_NBR ack_nbr;
NET_TCP_WIN_SIZE win_size;
CPU_INT16U flags_tcp;
CPU_INT16U flags_ip;
CPU_INT08U probe_data[NET_TCP_DATA_LEN_TX_PROBE_DATA];
NET_ERR err;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* See Note #2A. */
/* ----------- VALIDATE TCP CONN STATE ------------ */
tx_probe = DEF_NO;
if (pconn != (NET_TCP_CONN *)0) {
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
tx_probe = DEF_YES;
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)close_code);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
}
if (tx_probe != DEF_YES) { /* If NOT valid, abort tx TCP conn probe. */
*perr = NET_TCP_ERR_CONN_PROBE_INVALID;
return;
}
#else /* Prevent compiler warning. */
(void)&close_code;
#endif
/*$PAGE*/
/* ---------- PREPARE TCP CONN PROBE SEG ---------- */
/* If valid, prepare & tx TCP conn probe. */
/* Get buf. */
data_len = (tx_probe_data_octet == DEF_YES) /* Cfg data len for probe data (see Note #2b2C). */
? NET_TCP_DATA_LEN_TX_PROBE_DATA
: NET_TCP_DATA_LEN_TX_PROBE_NO_DATA;
data_ix = NET_BUF_DATA_TX_IX;
pseg_probe = NetBuf_Get((NET_BUF_SIZE) data_len,
(NET_BUF_SIZE) data_ix,
(CPU_INT16U ) NET_BUF_FLAG_NONE,
(NET_ERR *)&err);
if ( err != NET_BUF_ERR_NONE) {
*perr = NET_TCP_ERR_NONE_AVAIL;
return;
}
if (tx_probe_data_octet == DEF_YES) { /* If tx probe data req'd, ... */
probe_data[0] = NET_TCP_TX_PROBE_DATA; /* ... prepare data (see Note #2b2) ... */
NetBuf_DataWr((NET_BUF *) pseg_probe, /* ... & wr data into TCP tx buf. */
(NET_BUF_SIZE) data_ix,
(NET_BUF_SIZE) data_len,
(CPU_INT08U *)&probe_data[0],
(NET_ERR *)&err);
if ( err != NET_BUF_ERR_NONE) { /* See Note #4a. */
NetBuf_Free(pseg_probe);
*perr = NET_TCP_ERR_CONN_FAIL;
return;
}
}
/* --------------- PREPARE TCP HDR ---------------- */
/* Prepare seg addrs. */
NetTCP_TxConnPrepareSegAddrs((NET_TCP_CONN *) pconn,
(CPU_INT08U *)&src_port,
(CPU_INT08U *)&src_addr,
(CPU_INT16U ) sizeof(src_port),
(CPU_INT16U ) sizeof(src_addr),
(CPU_INT08U *)&dest_port,
(CPU_INT08U *)&dest_addr,
(CPU_INT16U ) sizeof(dest_port),
(CPU_INT16U ) sizeof(dest_addr),
(NET_ERR *)&err);
if ( err != NET_TCP_ERR_NONE) { /* See Note #4a. */
*perr = NET_TCP_ERR_CONN_FAULT;
NetBuf_Free(pseg_probe);
return;
}
/* Prepare TCP seq nbrs (see Note #1b2B). */
seq_nbr = pconn->TxSeqNbrNext - 1; /* Sub 1 from probe seq (see Note #2b1). */
ack_nbr = pconn->RxSeqNbrNext;
/* Prepare TCP tx flags (see Note #1b2C). */
flags_tcp = NET_TCP_FLAG_NONE |
NET_TCP_FLAG_TX_ACK;
/* Prepare TCP win size. */
win_size = pconn->RxWinSizeActual;
/* Prepare IP params. */
TOS = pconn->TxIP_TOS;
TTL = pconn->TxIP_TTL;
flags_ip = pconn->TxIP_Flags;
/* Init buf ctrls. */
pseg_probe_hdr = &pseg_probe->Hdr;
pseg_probe_hdr->DataIx = (CPU_INT16U )data_ix;
pseg_probe_hdr->DataLen = (NET_BUF_SIZE)data_len;
pseg_probe_hdr->TotLen = (NET_BUF_SIZE)pseg_probe_hdr->DataLen;
pseg_probe_hdr->ProtocolHdrType = NET_PROTOCOL_TYPE_TCP;
pseg_probe_hdr->TCP_SegSync = (CPU_BOOLEAN )DEF_NO;
pseg_probe_hdr->TCP_SegClose = (CPU_BOOLEAN )DEF_NO;
pseg_probe_hdr->TCP_SegAck = (CPU_BOOLEAN )DEF_YES;
pseg_probe_hdr->TCP_SegReset = (CPU_BOOLEAN )DEF_NO;
pseg_probe_hdr->TCP_Flags = flags_tcp;
/*$PAGE*/
/* ------------ TX TCP CONN PROBE SEG ------------- */
NetTCP_TxPktHandler((NET_BUF *) pseg_probe,
(NET_IP_ADDR ) src_addr,
(NET_TCP_PORT_NBR) src_port,
(NET_IP_ADDR ) dest_addr,
(NET_TCP_PORT_NBR) dest_port,
(NET_TCP_SEQ_NBR ) seq_nbr,
(NET_TCP_SEQ_NBR ) ack_nbr,
(NET_TCP_WIN_SIZE) win_size,
(NET_IP_TOS ) TOS,
(NET_IP_TTL ) TTL,
(CPU_INT16U ) flags_tcp,
(CPU_INT16U ) flags_ip,
(void *) 0,
(void *) 0, /* See Note #5. */
(NET_ERR *)&err); /* Ignore transitory tx err(s). */
#if 0 /* Tx buf freed by lower layer(s) [see Note #3b2]. */
NetTCP_TxPktFree(pseg_probe);
#endif
NET_CTR_STAT_INC(NetTCP_StatTxSegConnProbeCtr);
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnKeepAlive()
*
* Description : (1) #### Prepare & transmit a TCP connection keep-alive :
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in ####
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection keep-alive successfully
* transmitted.
*
* Return(s) : none.
*
* Caller(s) : ####
*
* Note(s) : (2) RFC #1122, Section 4.2.3.6 states that "implementors MAY include 'keep-alives' in
* their TCP implementations, although this practice is not universally accepted ...
* A 'keep-alive' mechanism periodically probes the other end of a connection when
* the connection is otherwise idle, even when there is no data to be sent".
*
* (a) "If keep-alives are included," ...
*
* (1) "the application MUST be able to turn them on or off for each TCP connection,"
* (2) "and they MUST default to off."
*
* (b) "Keep-alive packets MUST only be sent when no data or acknowledgement packets have
* been received for the connection within an interval" :
*
* (1) "This interval MUST be configurable" ...
* (2) "and MUST default to no less than two hours."
*
* (c) "To confirm that an idle connection is still active ... send a probe segment ...
* to elicit a response from the peer TCP" :
*
* (1) "Such a segment generally contains SEG.SEQ = SND.NXT-1" ...
*
* (A) "Note that on a quiet connection SND.NXT = RCV.NXT, so that this SEG.SEQ will
* be outside the window. Therefore, the probe causes the receiver to return an
* acknowledgment segment, confirming that the connection is still live. If the
* peer has dropped the connection ... it will respond with a RST instead of an
* acknowledgment segment."
*
* (2) "and may or may not contain one garbage octet of data."
*
* (A) "An implementation SHOULD send a keep-alive segment with no data".
*
* (1) (a) "Unfortunately, some misbehaved TCP implementations fail to respond to
* a segment with SEG.SEQ = SND.NXT-1 unless the segment contains data."
*
* (b) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 23.3,
* Page 335 reiterates that "some older implementations based on 4.2BSD do
* not respond to these keepalive probes unless the segment contains data".
*
* (2) (a) Therefore, RFC #1122, Section 4.2.3.6 states that a TCP "implementation ...
* MAY be configurable to send a keep-alive segment containing one garbage
* octet, for compatibility with erroneous TCP implementations".
*
* (b) (1) "Alternatively, an implementation could determine whether a peer
* responded correctly to keep-alive packets with no garbage data octet."
*
* (2) (A) Or as Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section
* 23.3, Page 335 states, some "systems send the 4.3BSD-style segment
* (no data) for the first half of the probe period, and if no response
* is received, switch to the 4.2BSD-style segment for the last half".
*
* (B) Therefore, it seems reasonable to implement the combined BSD 4.3/4.2
* solution since it does NOT require any non-standard configuration
* for the garbage data octet & SHOULD be backwards-compatible with all
* other systems.
*
* (3) "It is extremely important to remember that ACK segments that contain no data
* are not reliably transmitted by TCP. Consequently, if a keep-alive mechanism
* is implemented it MUST NOT interpret failure to respond to any specific probe
* as a dead connection."
*********************************************************************************************************
*/
#if 0 /* #### NOT yet implemented. */
static void NetTCP_TxConnKeepAlive (NET_TCP_CONN *pconn,
NET_ERR *perr)
{
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnTxQ()
*
* Description : (1) Transmit TCP data segment(s) from TCP connection transmit queue :
*
* (a) Configure TCP connection transmit :
*
* (1) Configure TCP connection transmit acknowledgement request : See Note #1d1
*
* (A) Do NOT transmit TCP data/acknowledgement if ...
* (1) NO TCP transmit data available or allowed to transmit
* AND
* (2) NO transmit acknowledgement requested
*
* (B) Transmit TCP acknowledgement if ...
* (1) NO TCP transmit data available or allowed to transmit
* BUT
* (2) Transmit acknowledgement requested
*
* (2) Configure TCP connection transmit free timer request See Note #1d4
*
* (b) Transmit TCP connection transmit queue data :
*
* (1) Control TCP connection transmit versus transmit congestion controls :
*
* (a) See also 'NetTCP_TxConnWinSizeHandlerCongCtrl() Note #2'
* & 'NetTCP_TxConnWinSizeUpdateAvail() Note #1'
*
* (A) Available Transmit Window See Note #1b1a
* (B) Transmit Queue Segment See Notes #5 & #8
* (C) Nagle Algorithm See Notes #6, #7b2B, & #8
* (D) Silly Window Syndrome See Notes #7 & #8
*
* (2) Update TCP connection transmit queue :
* (A) Remove TCP transmit segment(s) from
* TCP connection transmit queue See Note #3
* (B) Append TCP transmit segment(s) to
* TCP connection re-transmit queue See Note #4
* (C) Update TCP connection re-transmit queue timer
*
* (3) Update TCP connection :
* (A) Update TCP connection sequence number(s)
* (B) Update TCP connection transmit congestion window
*
* (4) Prepare TCP data/acknowledgement segment(s) :
* (A) TCP segment addresses
* (B) TCP segment sequence numbers
* (C) TCP segment transmit flags :
* (1) ACK
* (D) TCP segment window size
* (E) IP datagram parameters
* (F) TCP segment packet buffer controls
*
* (5) Transmit TCP data/acknowledgement segment(s)
*
* (c) Suspend TCP transmit : See Note #10
*
* (1) Handle any network receive packet(s) See Note #10b2A
*
* (d) Complete TCP connection transmit :
*
* (1) Transmit TCP connection acknowledgement See Note #1a1
* (2) Clear TCP connection transmit idle timer
* (see 'NetTCP_TxConnTxQ_TimeoutIdleClr() Note #2b2')
* (3) Reset TCP connection delayed acknowledgement controls
* (4) Free TCP connection transmit queue persist timer See Note #1a2
*
*
* (2) NetTCP_TxConnTxQ() transmits TCP connection data & acknowledgements. TCP acknowledgements
* transmitted independently of TCP controls &/or data MAY be transmitted with NetTCP_TxConnAck().
*
* See also 'NetTCP_TxConnAck() Note #2'.
*
*$PAGE*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in various.
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
*
* tx_ack_code Indicate whether & how to transmit a TCP acknowledgement segment :
*
* NET_TCP_CONN_TX_ACK_NONE Do NOT transmit a TCP acknowledgement
* segment if TCP transmit data
* NOT available.
* NET_TCP_CONN_TX_ACK Transmit a TCP acknowledgement segment
* even if TCP transmit data NOT available.
* NET_TCP_CONN_TX_ACK_IMMED Transmit a TCP acknowledgement segment
* immediately even if TCP transmit data
* NOT available.
*
* tx_q_timeout Indicate whether the TCP connection transmit queue timed out :
*
* DEF_NO TCP connection transmit queue did
* NOT time out.
* DEF_YES TCP connection transmit queue
* timed out.
*
* close_code Select which close action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_CLOSE_NONE Perform NO close actions.
* NET_TCP_CONN_CLOSE_ALL Perform ALL close actions.
*
* NET_TCP_CONN_CLOSE_CONN_TX_RESET Perform close connection transmit reset.
* NET_TCP_CONN_CLOSE_CONN_ALL Perform ALL connection close actions.
*
* NET_TCP_CONN_CLOSE_TMR_TX_IDLE Close transmit idle timer.
* NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN Close transmit silly window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN Close transmit zero window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY Close transmit acknowledgement delay timer.
* NET_TCP_CONN_CLOSE_TMR_RE_TX Close re-transmit timer.
* NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE Close connection keep-alive timer.
* NET_TCP_CONN_CLOSE_TMR_TIMEOUT Close connection timer.
* NET_TCP_CONN_CLOSE_TMR_ALL Close ALL timers.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES'.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection transmit queue successfully
* handled.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_CLOSE TCP connection closed.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* ------- RETURNED BY NetTCP_TxConnAck() : -------
* NET_TCP_ERR_CONN_ACK_NONE TCP connection acknowledgement NOT requested.
* NET_TCP_ERR_CONN_ACK_DLYD TCP connection acknowledgement transmit delayed.
* NET_TCP_ERR_CONN_ACK_PREVLY_TXD TCP connection acknowledgement previously
* transmitted for segment.
* NET_TCP_ERR_CONN_ACK_INVALID TCP connection acknowledgement NOT valid for
* current TCP connection state.
* NET_TCP_ERR_NONE_AVAIL Resources NOT available.
* NET_TCP_ERR_INVALID_LEN_SEG Invalid TCP sequence-segment length.
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
*
* ----- RETURNED BY NetTCP_TxPktHandler() : ------
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_TCP_ERR_TX TCP transmit error (see Note #12a).
* NET_ERR_TX Transmit error.
*
* Return(s) : none.
*
* Caller(s) : various.
*$PAGE*
* Note(s) : (3) See 'NetTCP_TxConnAppData() Note #4' for TCP connection Transmit Queue diagram.
*
* (4) TCP segments that have been transmitted but NOT yet acknowledged are sequenced into
* the TCP connection's re-transmit queue to await acknowledgement or retransmission.
*
* (a) Transmitted TCP segments are inserted into a doubly-linked Re-Transmit Queue,
* ordered consecutively by sequence number(s) [see also Note #4b].
*
* (1) 'ReTxQ_Head' points to the head of the Re-Transmit Queue;
* 'ReTxQ_Tail' points to the tail of the Re-Transmit Queue.
*
* (2) Segment buffers' 'PrevPrimListPtr' & 'NextPrimListPtr' doubly-link each
* segment to form the Re-Transmit Queue.
*
* (b) Transmit segments are transmitted & await acknowledgement in sequence-order.
* Therefore, newly-transmitted segments are sequenced after previously transmitted
* segments starting at the tail of the Re-Transmit Queue.
*
* (c) Segments at the head of the Re-Transmit Queue are awaiting acknowledgement &
* removal from the Re-Transmit Queue; & are ready to be re-transmitted until
* acknowledged & removed from the queue.
*
*
* | |
* |<----- TCP Connection Re-Transmit Queue ------>|
* | (see Note #4) |
*
* Segments Awaiting
* Acknowledgement or Segments Sequenced
* Re-Transmit into Re-Transmit Queue
* start at head starting at tail
* (see Note #4c) (see Note #4b)
*
* | NextPrimListPtr |
* | (see Note #4a2) |
* v | v
* |
* Head of ------- ------- v ------- ------- (see Note #4a1)
* Re-Transmit ---->| |------>| |------>| |------>| |
* Queue | | | | | | | | Tail of
* | |<------| |<------| |<------| |<---- Re-Transmit
* (see Note #4a1) | | | | ^ | | | | Queue
* | | | | | | | | |
* ------- ------- | ------- -------
* |
* PrevPrimListPtr
* (see Note #4a2)
*
*$PAGE*
* (5) In order to simply TCP transmit buffer management, TCP transmit does NOT transmit
* partial network-buffer segments (i.e. portions of TCP segments in the same network
* buffer). This avoids the complexity of queuing & handling partially transmitted
* segments on both the TCP transmit & re-transmit queues.
*
* (a) However, in order to avoid transmit window deadlock with a remote host's receive
* window, the TCP connection's connection maximum segment size MUST be configured
* to ensure that full, maximum-segment-sized segments will transmit even for receive
* windows less than the default maximum segment size.
*
* See also 'NetTCP_ConnCfgMaxSegSize() Note #2'.
*
* (6) (a) (1) RFC #896, Section 'The small-packet problem' states that "there is a special
* problem associated with small packets ... the congestion ... can result in
* lost datagrams and retransmissions, as well as excessive propagation time ...
* In practice, throughput may drop so low that TCP connections are aborted".
*
* (2) RFC #896, Section 'The solution to the small-packet problem' states that "the
* solution to the small-packet problem ... is" :
*
* (A) "to inhibit the sending of new TCP segments when new outgoing data arrives
* from the user" ...
*
* (B) "if any previously transmitted data on the connection remains unacknowledged."
*
* (C) "This inhibition is to be unconditional;" :
* (1) "no timers," ...
* (2) "tests for size of data received, ...
* (3) "or other conditions are required."
*
* (b) (1) RFC #1122, Section 4.2.3.4 states that "the Nagle algorithm is ... as follows" :
*
* (A) "If there is unacknowledged data (i.e., SND.NXT > SND.UNA)," ...
* (B) "then the sending TCP buffers all user data" ...
* (1) "(regardless of the PSH bit)," ...
* (2) "until" :
* (a) "the outstanding data has been acknowledged" ...
* (b) "or until the TCP can send a full-sized segment."
*
* (2) (A) "A TCP SHOULD implement the Nalge Algorithm ... to coalesce short segments."
*
* (B) (1) "However, there MUST be a way for an application to disable the Nagle
* algorithm on an individual connection."
*
* (2) Thus, it is assumed from these two requirements that the Nagle algorithm
* should be enabled by default.
*
* See also Note #7b2Ba2A.
*$PAGE*
* (7) (a) RFC #813, Section 2 states that "a bad implementation of the window algorithm can
* lead to extremely poor performance ... This particular phenomenon ... has been
* given the name of Silly Window Syndrome, or SWS".
*
* Section 3 elaborates that "SWS is a degeneration in the throughput which develops
* ... whenever the acknowledgement of a small segment ... cause[s] another segment
* of the same small size to be sent, until ... the network ... becomes clogged with
* many small segments, and an equal number of acknowledgements".
*
* (b) (1) RFC #813, Section 4 states that "there is an algorithm that the sender can use
* ... [which] compares the useable window to the offered window, and refrains from
* anything if the ratio of useable to offered is less than a certain fraction ...
* Until the useable window reaches a certain amount, the sender should simply refuse
* to send anything".
*
* (2) (A) RFC #1122, Section 4.2.3.4 reiterates that "a TCP MUST include a SWS avoidance
* algorithm in the sender". However, "the SWS avoidance algorithm ... specified"
* in RFC #1122 "is to be used instead of the sender-side algorithm contained in
* [RFC #813]".
*
* (B) (a) RFC #1122, Section 4.2.3.4 states that "the sender's SWS avoidance algorithm
* is ... [to] send data" :
*
* (1) "If a maximum-sized segment can be sent, i.e, [sic] if" :
*
* (A) "min(D,U) >= Eff.snd.MSS"
* (1) (a) This threshold subtly assumes that the amount of data queued
* on the TCP connection's transmit queue is queued in maximum-
* sized segments.
* (b) Although this assumption is typically satisfied since all
* new TCP transmit data is usually aggregated & appended onto
* the TCP connection's transmit queue in maximum-sized segments
* (see 'NetTCP_TxConnAppData() Note #7b1'); to ensure that the
* maximum-sized-segment threshold is satisfied the transmit
* segment's length is also checked.
*
* (2) "Or if the data is pushed and all queued data can be sent now, i.e., if" :
*
* (A) "[SND.NXT = SND.UNA and] ...
* (1) "(the bracketed condition is imposed by the Nagle algorithm)"
* (2) (a) This condition is required ONLY if the Nagle algorithm
* is enabled (see Note #6b2B).
* (b) However, if the Nagle algorithm is disabled, the silly
* window syndrome threshold conditions MUST be checked
* (see Note #7b2Ba3).
*
* (B) "PUSHED and" ...
* (1) See also 'NetTCP_TxConnAppData() Note #7b3B1b'.
*
* (C) "D <= U"
* (1) (a) This threshold subtly assumes that the amount of data queued
* on the TCP connection's transmit queue is queued in maximum-
* sized segments.
* (b) To ensure that the next actual transmit segment is compared
* to the available transmit window, the following threshold is
* actually checked :
*
* (1) min(D, SEG.LEN) <= U
*
* See also Note #7b2Ba1A1.
*
* (3) "Or if at least a fraction Fs of the maximum window can be sent, i.e., if" :
*
* (A) "[SND.NXT = SND.UNA and]" ...
* (1) This condition is required ONLY if the Nagle algorithm is enabled
* (see Note #6b2B).
*
* (B) "min(D,U) >= Fs * Max(SND.WND)"
*$PAGE*
* (4) "or if" :
*
* (A) "data is PUSHed and" ...
* (1) Although it is not directly stated, it is inferred that if
* the segment(s)' data is NOT pushed, the segment transmit
* SHOULD be postponed until the previous transmit silly window
* syndrome avoidance conditions have NOT been satisfied (see
* Notes #7b2Ba1, #7b2Ba2, & #7b2Ba3).
*
* (2) See also 'NetTCP_TxConnAppData() Note #7b3B1b'.
*
* (B) "the override timeout occurs."
* (1) Although it is not directly stated, it is inferred that the
* transmit silly window override timer should be set when :
*
* (a) The previous transmit silly window syndrome avoidance
* conditions have NOT been satisfied (see Notes #7b2Ba1,
* #7b2Ba2, & #7b2Ba3) ...
* (b) BUT ...
* (1) the TCP segment data is pushed ...
* (2) & no current timeout exists.
*
* (2) However, if NO network timer is available to delay the TCP
* data segment(s), the TCP data segment(s) SHOULD be immediately
* transmitted.
*
* See also Note #7b2Bb.
*
*
* where
* (A) D Amount of data queued in the sending TCP but not
* yet sent
*
* (B) U 'Useable window' ... i.e., the offered window less
* the amount of data sent but not acknowledged :
*
* (1) U = SND.UNA + SND.WND - SND.NXT
*
* (2) The 'useable window' is also constrained by the
* available window & other TCP congestion controls
* (see 'NetTCP_TxConnWinSizeUpdateAvail() Note #1').
*
* (C) Eff.snd.MSS Effective send MSS for the connection
* (D) SND.NXT Next sequence number to transmit
* (E) SND.UNA Oldest unacknowledged sequence number
* (F) Max(SND.WND) Maximum send window ... seen ... on the connection
* (G) Fs Fraction whose recommended value is 1/2
*
*
* (b) (1) Although RFC #813, Section 4 stated "that it is not necessary to set
* a timer to protect against protocol lockup when postponing the send
* operation"; RFC #1122, Section 4.2.3.4 amends that "to avoid a ...
* deadlock, it is necessary to have a timeout to force transmission of
* data, overriding the SWS avoidance algorithm".
*
* (2) "The override timeout should be in the range 0.1 - 1.0 seconds."
*
* (3) "In practice, this timeout should seldom occur."
*$PAGE*
* (8) (a) Although it is not directly stated, it is inferred that the limitations of
* the Nagle & transmit silly window syndrome avoidance algorithms apply only
* to discrete, individually-queued data segments & NOT to any stream of data
* segments.
*
* Therefore, a data segment -- especially the last queued data segment in the
* TCP connection's transmit queue -- should NOT be constrained by the Nagle &
* transmit silly window syndrome avoidance algorithms if this last queued data
* segment is immediately transmitted after the transmission of the preceding
* queued data segments.
*
* See also 'NetTCP_TxConnAppData() Notes #7b1 & #7b3B2'.
*
* (b) Also, although NO RFC specifies the Nagle algorithm's or the transmit silly
* window syndrome avoidance algorithm's compliance, effect, or limitation on
* TCP connection closes; it does NOT seem reasonable for the Nagle algorithm
* or the transmit silly window syndrome avoidance algorithm to inhibit or
* delay the transmission of a TCP connection close segment.
*
* (9) Increment network buffer's reference counter to include the TCP segment now enqueued
* to the TCP connection's re-transmit queue as a new reference to the network buffer.
*
* (10) To balance network receive versus transmit packet loads for certain network connection
* types (e.g. stream-type connections), network receive & transmit packets SHOULD be
* handled in an APPROXIMATELY balanced ratio.
*
* (a) Network task priorities & lock mechanisms partially maintain a balanced ratio
* between network receive versus transmit packet handling.
*
* However, the handling of network receive & transmit packets :
*
* (1) SHOULD be interleaved so that for every few packet(s) received & handled,
* several packet(s) should be transmitted; & vice versa.
*
* (2) SHOULD NOT exclusively handle receive nor transmit packets, even for a
* short period of time.
*
* (b) To implement network receive versus transmit load balancing :
*
* (2) Certain network connections MUST periodically suspend network transmit(s)
* to handle network receive packet(s) :
*
* (A) Suspend network transmit(s) if network receive packets are available.
*
* (1) To approximate a balanced ratio of network receive versus transmit
* packets handled; the number of consecutive times that a network
* transmit suspends itself to check for & handle any network receive
* packet(s) SHOULD APPROXIMATELY correspond to the number of queued
* network receive packet(s) availabile.
*
* See also 'net.c Net_RxPktIsAvail() Note #2'.
*
* (2) To protect TCP connections from transmit corruption while suspended,
* ALL TCP data transmits & TCP transmit queue handling MUST be blocked
* for suspended connections until the connection is no longer suspended.
*
* (B) Signal or timeout network transmit suspend(s) to restart transmit(s).
*
* See also 'net.h NETWORK RECEIVE PACKET MACRO'S Note #1'.
*
* (11) On ANY errors, network resources MUST be appropriately freed :
*
* (a) For all network resources that have been linked to the TCP connection, ALL
* network resources are freed by NetTCP_ConnClose().
*
* (12) (a) Since segments enqueued to a TCP connection's transmit queue have already been
* reported as transmitted to the application & since no mechanism exists for a TCP
* connection to re-request previously transmitted data, any TCP connection whose
* transmit queue(s) becomes corrupted MUST be closed to force the application layer
* to abort &/or recover from the corrupted data.
*
* (b) For any internal errors where the TCP connection's transmit queue is NOT corrupted,
* the TCP connection is NOT closed.
*
* See also 'NetTCP_TxConnAppData() Note #10'
* & 'NetTCP_TxConnReTxQ() Note #11'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnTxQ (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_ACK_CODE tx_ack_code,
CPU_BOOLEAN tx_q_timeout,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr)
{
#if (((NET_CTR_CFG_STAT_EN == DEF_ENABLED) || \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED)) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_BUF *pseg;
NET_BUF *pseg_next;
NET_BUF *pbuf_q_tail;
NET_BUF_HDR *pseg_hdr;
NET_BUF_HDR *pseg_next_hdr;
NET_BUF_HDR *pbuf_q_tail_hdr;
NET_TMR_TICK timeout_tick;
NET_IP_TOS TOS;
NET_IP_TTL TTL;
NET_IP_ADDR src_addr;
NET_IP_ADDR dest_addr;
NET_TCP_PORT_NBR src_port;
NET_TCP_PORT_NBR dest_port;
NET_TCP_SEQ_NBR seq_nbr;
NET_TCP_SEQ_NBR ack_nbr;
NET_TCP_WIN_SIZE win_size;
NET_TCP_WIN_SIZE tx_data_qd;
NET_TCP_WIN_SIZE tx_data_min;
NET_TCP_WIN_SIZE tx_th_q_min;
NET_TCP_TX_Q_STATE state;
CPU_INT16U flags_tcp;
CPU_INT16U flags_ip;
CPU_BOOLEAN tx_ack;
CPU_BOOLEAN tx_seg;
CPU_BOOLEAN tx_seg_push;
CPU_BOOLEAN tx_seg_close;
CPU_BOOLEAN tx_segs_txd;
CPU_BOOLEAN tx_segs;
CPU_BOOLEAN tx_done;
CPU_BOOLEAN tx_th_seg;
CPU_BOOLEAN tx_th_mss;
CPU_BOOLEAN tx_th_nagle;
CPU_BOOLEAN tx_th_silly_win;
CPU_BOOLEAN tx_tmr_free;
CPU_BOOLEAN net_rx_avail;
NET_CTR net_rx_nbr;
NET_ERR err;
NET_ERR err_rtn;
/* ------------------ CFG TCP TX ------------------ */
switch (tx_ack_code) { /* Cfg tx ack req. */
case NET_TCP_CONN_TX_ACK_NONE:
default:
tx_ack = DEF_NO;
break;
case NET_TCP_CONN_TX_ACK:
case NET_TCP_CONN_TX_ACK_IMMED:
tx_ack = DEF_YES;
break;
}
/* Cfg tx tmr free req. */
tx_tmr_free = (pconn->TxQ_Head == (NET_BUF *)0) ? DEF_YES : DEF_NO;
/*$PAGE*/
switch (pconn->ConnState) { /* Cfg tx Q seg(s). */
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
tx_segs = DEF_YES;
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND:
default:
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
tx_segs = DEF_YES;
break;
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND: /* See Note #10b2A2. */
tx_segs = DEF_NO;
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
default:
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_NONE:
case NET_TCP_CONN_STATE_CLOSED:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, DEF_YES, close_code);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
err_rtn = NET_TCP_ERR_NONE;
/*$PAGE*/
/* ---------- TX DATA FROM TCP CONN TX Q ---------- */
pseg_next = pconn->TxQ_Head;
tx_done = (tx_segs == DEF_YES) ? DEF_NO : DEF_YES;
tx_segs_txd = DEF_NO;
while (tx_done == DEF_NO) { /* Tx ALL TCP conn tx Q seg(s) ... */
/* ... allowed by cong ctrls (see Note #1b1). */
tx_seg = DEF_NO;
pseg = pseg_next;
if (pseg != (NET_BUF *)0) {
pseg_hdr = (NET_BUF_HDR *)&pseg->Hdr;
pseg_next = (NET_BUF *) pseg_hdr->NextPrimListPtr;
/* ----------------- CTRL TCP TX ------------------ */
/* Validate tx win cong th's : ... */
if (pconn->TxWinSizeAvail >= pseg_hdr->TCP_SegLenData) {/* ... chk avail tx win >= seg len (see Note #5); */
tx_seg = DEF_YES;
/* ... chk prev'ly tx'd seg(s) [see Note #8a]; ... */
/* ... or TCP conn close seg [see Note #8b]; ... */
tx_seg_close = DEF_BIT_IS_SET(pseg_hdr->TCP_Flags, NET_TCP_FLAG_TX_CLOSE);
tx_th_seg = ((tx_segs_txd == DEF_YES) ||
(tx_seg_close == DEF_YES)) ? DEF_OK : DEF_FAIL;
if (tx_th_seg != DEF_OK) {
/* ... chk MSS th (see Note #7b2Ba1); ... */
tx_data_qd = (NET_TCP_WIN_SIZE)(pconn->TxSeqNbrNextQ - pconn->TxSeqNbrNext);
tx_data_min = (NET_TCP_WIN_SIZE) DEF_MIN(tx_data_qd, pseg_hdr->TCP_SegLenData);
tx_th_q_min = (NET_TCP_WIN_SIZE) DEF_MIN(tx_data_min, pconn->TxWinSizeAvail);
tx_th_mss = (tx_th_q_min >= pconn->MaxSegSizeConn) ? DEF_OK : DEF_FAIL;
if (tx_th_mss != DEF_OK) {
/* ... chk Nagle th (see Note #7b2Ba2); ... */
tx_seg_push = DEF_BIT_IS_SET(pseg_hdr->TCP_Flags, NET_TCP_FLAG_TX_PUSH);
tx_th_nagle = ((pconn->TxWinSizeNagleEn != DEF_DISABLED ) &&
(pconn->TxSeqNbrNext == pconn->TxSeqNbrUnAckd) &&
(tx_seg_push == DEF_YES ) &&
(tx_data_min <= pconn->TxWinSizeAvail)) ? DEF_OK : DEF_FAIL;
if (tx_th_nagle != DEF_OK) {
/* ... chk silly win th (see Note #7b2Ba3); ... */
tx_th_silly_win = (((pconn->TxWinSizeNagleEn == DEF_DISABLED ) ||
(pconn->TxSeqNbrNext == pconn->TxSeqNbrUnAckd)) &&
(tx_th_q_min >= pconn->TxWinSizeMinTh)) ? DEF_OK : DEF_FAIL;
if (tx_th_silly_win != DEF_OK) {
/* ... chk push timeout (see Note #7b2Ba4). */
if (tx_seg_push == DEF_YES) { /* If data seg pushed (see Note #7b2Ba4A), ... */
if (tx_q_timeout == DEF_NO) { /* ... & no cur timeout (see Note #7b2Ba4B1b2), ... */
/* ... & tx Q tmr NOT yet cfg'd, ... */
if (pconn->TxQ_SillyWinTmr == (NET_TMR *)0) {
timeout_tick = ((NET_TMR_TICK)pconn->TxWinSillyWinTimeout_ms * NET_TMR_TIME_TICK_PER_SEC)
/ DEF_TIME_NBR_mS_PER_SEC;
pconn->TxQ_SillyWinTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_TxConnTxQ_TimeoutSillyWin,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
/* ... & tx Q tmr avail, ... */
if (err == NET_TMR_ERR_NONE) {
tx_seg = DEF_NO; /* ... dly tx seg (see Note #7b2Ba4B1); ... */
} /* ... else tx seg (see Note #7b2Ba4B2). */
} else { /* Else tx Q tmr already cfg'd, ... */
tx_seg = DEF_NO; /* ... dly tx seg (see Note #7b2Ba4B1). */
}
}
} else { /* If data seg NOT pushed, ... */
tx_seg = DEF_NO; /* ... dly tx seg (see Note #7b2Ba4A1). */
}
}
}
}
}
}
}
/*$PAGE*/
/* ----------------- TX TCP SEGS ------------------ */
if (tx_seg == DEF_YES) { /* If avail & rdy, tx Q seg(s). */
/* ------------ UPDATE TCP CONN TX Q's ------------ */
/* Move seg from tx Q to re-tx Q : */
if (pseg_next != (NET_BUF *)0) { /* If tx Q next seg(s) avail, ... */
/* ... update TCP conn tx Q. */
pseg_next_hdr = (NET_BUF_HDR *)&pseg_next->Hdr;
pseg_next_hdr->PrevPrimListPtr = (void *) 0;
pconn->TxQ_Head = (NET_BUF *) pseg_next;
} else { /* Else clr tx Q. */
pconn->TxQ_Head = (NET_BUF *)0;
pconn->TxQ_Tail = (NET_BUF *)0;
tx_tmr_free = DEF_YES;
}
pseg_hdr->PrevPrimListPtr = (void *)pconn->ReTxQ_Tail;
pseg_hdr->NextPrimListPtr = (void *)0;
if (pconn->ReTxQ_Tail != (NET_BUF *)0) { /* If re-tx Q NOT empty, ... */
/* ... append seg(s) @ Q tail (see Note #4b). */
pbuf_q_tail = (NET_BUF *) pconn->ReTxQ_Tail;
pbuf_q_tail_hdr = (NET_BUF_HDR *)&pbuf_q_tail->Hdr;
pbuf_q_tail_hdr->NextPrimListPtr = (void *) pseg;
pconn->ReTxQ_Tail = (NET_BUF *) pseg;
} else { /* Else add seg to empty re-tx Q. */
pconn->ReTxQ_Head = (NET_BUF *) pseg;
pconn->ReTxQ_Tail = (NET_BUF *) pseg;
}
if (pconn->ReTxQ_Tmr == (NET_TMR *)0) { /* If unavail, get & update re-tx Q tmr. */
NetTCP_TxConnReTxQ_TimeoutSet(pconn, DEF_NO, close_code, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
}
/* --------------- UPDATE TCP CONN ---------------- */
/* Update TCP conn tx seq nbr(s). */
pconn->TxSeqNbrNext += (NET_TCP_SEQ_NBR)pseg_hdr->TCP_SegLen;
/* Update TCP conn tx win ctrls (see Note #3a2). */
NetTCP_TxConnWinSizeHandlerCongCtrl((NET_TCP_CONN *) pconn,
(NET_BUF_HDR *) 0,
(NET_TCP_ACK_CODE) NET_TCP_CONN_RX_ACK_NONE,
(NET_TCP_WIN_SIZE) pseg_hdr->TCP_SegLenData,
(NET_TCP_WIN_CODE) NET_TCP_CONN_TX_WIN_DEC,
(NET_ERR *)&err);
if ( err != NET_TCP_ERR_NONE) {
*perr = NET_TCP_ERR_CONN_FAULT;
return;
}
/*$PAGE*/
/* --------- PREPARE TCP TX DATA/ACK SEG ---------- */
/* Prepare TCP seg addrs. */
src_port = (NET_TCP_PORT_NBR)pseg_hdr->TCP_UDP_PortSrc;
src_addr = (NET_IP_ADDR )pseg_hdr->IP_AddrSrc;
dest_port = (NET_TCP_PORT_NBR)pseg_hdr->TCP_UDP_PortDest;
dest_addr = (NET_IP_ADDR )pseg_hdr->IP_AddrDest;
/* Prepare TCP seq nbrs. */
seq_nbr = (NET_TCP_SEQ_NBR )pseg_hdr->TCP_SeqNbr;
ack_nbr = (NET_TCP_SEQ_NBR )pconn->RxSeqNbrNext;
/* Prepare TCP tx flags. */
flags_tcp = pseg_hdr->TCP_Flags;
/* Prepare TCP win size. */
win_size = pconn->RxWinSizeActual;
/* Prepare IP params. */
TOS = pconn->TxIP_TOS;
TTL = pconn->TxIP_TTL;
flags_ip = pconn->TxIP_Flags;
/* Update TCP tx buf ctrls. */
pseg_hdr->TCP_SeqNbrLast = (CPU_INT32U)seq_nbr;
pseg_hdr->TCP_AckNbrLast = (CPU_INT32U)ack_nbr;
pseg_hdr->TCP_SegLenLast = (CPU_INT16U)pseg_hdr->TCP_SegLen;
pseg_hdr->TCP_WinSizeLast = (CPU_INT16U)win_size;
pseg_hdr->TCP_SegReTxCtr = (CPU_INT16U)0;
pseg_hdr->RefCtr++; /* TCP maintains ref until seg ack'd (see Note #9). */
/* ------------- TX TCP DATA/ACK SEG -------------- */
NetTCP_TxPktHandler((NET_BUF *) pseg,
(NET_IP_ADDR ) src_addr,
(NET_TCP_PORT_NBR) src_port,
(NET_IP_ADDR ) dest_addr,
(NET_TCP_PORT_NBR) dest_port,
(NET_TCP_SEQ_NBR ) seq_nbr,
(NET_TCP_SEQ_NBR ) ack_nbr,
(NET_TCP_WIN_SIZE) win_size,
(NET_IP_TOS ) TOS,
(NET_IP_TTL ) TTL,
(CPU_INT16U ) flags_tcp,
(CPU_INT16U ) flags_ip,
(void *) 0,
(void *) 0,
(NET_ERR *)&err_rtn);
switch (err_rtn) {
case NET_TCP_ERR_NONE: /* If NO tx err(s); ... */
tx_segs_txd = DEF_YES; /* ... indicate seg(s) tx'd, ... */
NET_CTR_STAT_INC(NetTCP_StatTxSegConnTxQ_Ctr); /* ... & inc tx seg stat ctr. */
break;
case NET_ERR_INIT_INCOMPLETE: /* Else indicate tx done. */
case NET_ERR_TX:
tx_done = DEF_YES;
break;
case NET_TCP_ERR_TX: /* See Note #12a. */
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, close_code);
*perr = err_rtn;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
} else { /* Else if seg NOT tx'd, ... */
tx_done = DEF_YES; /* ... indicate tx done. */
}
/*$PAGE*/
/* ---------------- SUSPEND TCP TX ---------------- */
if (tx_done == DEF_NO) { /* If tx NOT done .. */
net_rx_nbr = 0;
net_rx_avail = Net_RxPktIsAvail(net_rx_nbr);
if (net_rx_avail == DEF_YES) { /* .. & net rx avail; .. */
state = pconn->TxQ_State; /* .. save TCP conn tx Q state, .. */
pconn->TxQ_State = NET_TCP_TX_Q_STATE_CONN_SUSPEND; /* .. set TCP conn tx Q state to SUSPEND; .. */
NetOS_Unlock();
do {
Net_TxSuspend(); /* .. suspend tx to handle net rx (see Note #10b2A) */
net_rx_nbr++;
net_rx_avail = Net_RxPktIsAvail(net_rx_nbr);
} while (net_rx_avail == DEF_YES); /* .. while net rx avail (see Note #10b2A1). */
NetOS_Lock(&err);
if ( err != NET_OS_ERR_NONE) {
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, close_code);
*perr = NET_TCP_ERR_CONN_CLOSE;
return;
}
switch (pconn->TxQ_State) { /* Validate TCP conn tx Q state. */
case NET_TCP_TX_Q_STATE_CONN_SUSPEND: /* If still SUSPEND state, .. */
pconn->TxQ_State = state; /* .. restore TCP conn tx Q state. */
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED: /* If CLOSED state, close TCP conn. */
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
default:
NetTCP_ConnClose(pconn, pbuf_hdr, pconn->ConnCloseAppFlag, close_code);
*perr = NET_TCP_ERR_CONN_CLOSE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
}
}
}
/* --------------- COMPLETE TCP TX ---------------- */
if (tx_segs_txd != DEF_YES) { /* If NO tx Q seg(s) tx'd, ... */
if (tx_ack == DEF_YES) { /* ... but tx ack req'd; ... */
/* ... tx TCP conn ack (see Note #1c1). */
NetTCP_TxConnAck(pconn, pbuf_hdr, tx_ack_code, close_code, &err_rtn);
}
} else { /* Else if ANY tx Q seg(s) tx'd; .. */
NetTCP_TxConnTxQ_TimeoutIdleClr(pconn); /* .. clr tx Q idle tmr (see Note #1c2), .. */
NetTCP_TxConnAckDlyReset(pconn, DEF_YES); /* .. reset ack dly ctrls, .. */
tx_tmr_free = DEF_YES; /* .. free tx Q tmr. */
}
if (tx_tmr_free == DEF_YES) { /* If free tx Q tmr req'd, .. */
if (pconn->TxQ_SillyWinTmr != (NET_TMR *)0) { /* .. & tx Q tmr avail, .. */
if (tx_q_timeout == DEF_NO) { /* .. & NOT timed out, .. */
/* .. free tx Q tmr. */
NetTmr_Free(pconn->TxQ_SillyWinTmr);
}
pconn->TxQ_SillyWinTmr = (NET_TMR *)0;
}
}
*perr = err_rtn; /* Rtn err from tx handler(s). */
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnTxQ_TimeoutIdle()
*
* Description : (1) (a) Handle TCP connection's transmit queue idle timeout ... :
*
* (1) Clear TCP connection's transmit idle timer See Note #4aA1
* (2) Reset TCP connection's transmit congestion window controls See Note #2a
* (3) Reset TCP connection's transmit round-trip time controls See Note #2b
*
* (b) ... for the following states :
*
* (1) ESTABLISHED
* (2) FIN-WAIT-1
* (3) CLOSING
* (4) CLOSE-WAIT
* (5) LAST-ACK
*
*
* Argument(s) : pconn_timeout Pointer to TCP connection (see Note #3b).
*
* Return(s) : none.
*
* Caller(s) : Referenced in NetTCP_TxConnTxQ_TimeoutIdleSet().
*
* Note(s) : (2) (a) RFC #2581, Section 4.1 states that "after TCP has been idle for a relatively long period
* of time ... use slow start to restart transmission" :
*
* (1) (A) "When TCP has not received a segment for more than one retransmission timeout," ...
* (B) "cwnd is reduced to the value of the restart window."
*
* (2) However, RFC #2581, Section 4.1 re-states that "using the last time a segment was
* received to determine whether or not to decrease cwnd fails to deflate cwnd in the
* common case of persistent ... connections ... The reception of [segments] makes the
* test for an idle connection fail, and allows the TCP to begin transmission with a
* possibly inappropriately large cwnd."
*
* (A) "Therefore, ... if the TCP has not sent data ... in an interval exceeding the
* retransmission timeout" ...
*
* (B) "a TCP SHOULD set cwnd to no more than RW before beginning transmission."
*
* See also 'NetTCP_TxConnWinSizeHandlerCongCtrl() Note #2e1'.
*
* (b) Similarly, although NO RFC specifies that a TCP connection's RTT average & deviation
* should be reset following a TCP transmit idle timeout; it seems reasonable to reset a
* TCP connection's RTT average & deviation controls whenever a TCP connection's transmit
* is idle for a period exceeding the re-transmit timeout.
*
* See also 'NetTCP_TxConnRTT_RTO_Calc() Note #2a4B'.
*$PAGE*
* (3) Ideally, network timer expiration functions could be defined as '[(void) (OBJECT *)]'
* type functions -- even though network timer API functions cast expiration functions
* to generic 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]').
*
* (a) (1) Unfortunately, ISO-IEC 9899-1999 ANSI-C, Section 6.3.2.3.7 states that "a
* pointer to an object ... may be converted to a pointer to a different object
* ... [but] if the resulting pointer is not correctly aligned ... the behavior
* is undefined".
*
* And since compilers may NOT correctly convert 'void' pointers to non-'void'
* pointer arguments, network timer expiration functions MUST avoid incorrect
* pointer conversion behavior between 'void' pointer parameters & non-'void'
* pointer arguments & therefore CANNOT be defined as '[(void) (OBJECT *)]'.
*
* (2) However, Section 6.3.2.3.1 states that "a pointer to void may be converted
* to or from a pointer to any ... object ... A pointer to any ... object ...
* may be converted to a pointer to void and back again; the result shall
* compare equal to the original pointer".
*
* (b) Therefore, to correctly convert 'void' pointer objects back to appropriate
* network object pointer objects, network timer expiration functions MUST :
*
* (1) Be defined as 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]'); & ...
* (2) Explicitly cast 'void' pointer arguments to specific object pointers; ...
* (A) ... in this case, a 'NET_TCP_CONN' pointer.
*
* See also 'net_tmr.c NetTmr_Get() Note #3'.
*
* (4) This function is a network timer expiration function :
*
* (a) (1) For the following connection timer(s) ... :
*
* (A) TCP connection transmit queue idle timer ('TxQ_IdleTmr')
*
* (2) (A) Clear the timer pointer; ...
* (1) Cleared prior to next handler function(s) as an extra precaution to avoiding
* re-freeing the timer (see Note #4a2B).
*
* (B) but do NOT re-free the timer.
*
* (b) Do NOT set the following close timer flag(s) :
*
* (1) NET_TCP_CONN_CLOSE_TMR_TX_IDLE
*
* (5) Certain network connections MUST periodically suspend network transmit(s) to handle
* network receive packet(s). To protect TCP connections from transmit corruption while
* suspended, ALL TCP data transmits & TCP transmit queue handling MUST be blocked for
* suspended connections until the connection is no longer suspended.
*
* However, handling the TCP connection's transmit queue idle timeout is permitted since
* NO TCP data is transmitted & the TCP connection's transmit queue is NOT handled (see
* Note #1a).
*
* See also 'NetTCP_TxConnTxQ() Note #10b2A2',
* 'NetTCP_TxConnTxQ_TimeoutSillyWin() Note #5',
* 'NetTCP_TxConnReTxQ_Timeout() Note #5',
* & 'NetTCP_TxConnWinSizeZeroWinTimeout() Note #5'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnTxQ_TimeoutIdle (void *pconn_timeout)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NET_TCP_CLOSE_CODE close_code;
#endif
NET_TCP_CONN *pconn;
NET_ERR err;
pconn = (NET_TCP_CONN *)pconn_timeout; /* See Note #3b2A. */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
close_code = NET_TCP_CONN_CLOSE_ALL;
DEF_BIT_CLR(close_code, NET_TCP_CONN_CLOSE_TMR_TX_IDLE); /* See Note #4b1. */
/* ------------ VALIDATE TCP CONN ------------- */
if (pconn == (NET_TCP_CONN *)0) {
NET_CTR_ERR_INC(NetTCP_ErrNullPtrCtr);
return;
}
if (pconn->Type != NET_TCP_TYPE_CONN) {
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidTypeCtr);
return;
}
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
return; /* Prevent 'break NOT reachable' warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
return; /* Prevent 'break NOT reachable' warning. */
case NET_TCP_CONN_STATE_CONN: /* See Note #1. */
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND: /* See Note #5. */
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
default:
return; /* Prevent 'break NOT reachable' warning. */
}
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)close_code);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
return; /* Prevent 'break NOT reachable' warning. */
}
#endif
/*$PAGE*/
/* ---- HANDLE TCP CONN TX Q IDLE TIMEOUT ----- */
pconn->TxQ_IdleTmr = (NET_TMR *)0; /* Clr tx Q idle tmr (see Note #4a2A1). */
/* Reset tx win ctrls (see Note #2a2B). */
NetTCP_TxConnWinSizeHandlerCongCtrl((NET_TCP_CONN *) pconn,
(NET_BUF_HDR *) 0,
(NET_TCP_ACK_CODE) NET_TCP_CONN_RX_ACK_NONE,
(NET_TCP_WIN_SIZE) 0,
(NET_TCP_WIN_CODE) NET_TCP_CONN_TX_WIN_RESET,
(NET_ERR *)&err);
/* Reset RTT ctrls (see Note #2b). */
NetTCP_TxConnRTT_RTO_Calc(pconn, NET_TCP_CONN_TX_RTT_RESET, NET_TCP_TX_RTT_NONE, NET_TCP_TX_RTT_NONE);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnTxQ_TimeoutIdleSet()
*
* Description : (1) Start TCP connection's transmit queue idle timeout for the following states :
*
* (a) SYN-RECEIVED
* (b) SYN-SENT
* (c) ESTABLISHED
* (d) FIN-WAIT-1
* (e) CLOSING
* (f) CLOSE-WAIT
* (g) LAST-ACK
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandlerReTxQ().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerReTxQ().
*
* Note(s) : (2) (a) RFC #2581, Section 4.1 states that "after TCP has been idle for a relatively long period
* of time ... use slow start to restart transmission" :
*
* (1) "If the TCP has not sent data in an interval exceeding the retransmission timeout" ...
* (2) "cwnd is reduced to ... no more than ... the value of the restart window."
*
* See also 'NetTCP_TxConnTxQ_TimeoutIdle() Note #2a'.
*
* (b) However, if NO network timer is available to time the transmit queue idle interval, the
* TCP connection SHOULD be immediately slow started.
*********************************************************************************************************
*/
static void NetTCP_TxConnTxQ_TimeoutIdleSet (NET_TCP_CONN *pconn)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TMR_TICK timeout_tick;
NET_ERR err;
/*$PAGE*/
/* ------------ VALIDATE TCP CONN ------------- */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
return; /* Prevent 'break NOT reachable' warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
return; /* Prevent 'break NOT reachable' warning. */
case NET_TCP_CONN_STATE_SYNC_RXD: /* See Note #1a. */
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD: /* See Note #1b. */
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND:
default:
return; /* Prevent 'break NOT reachable' warning. */
}
break;
case NET_TCP_CONN_STATE_CONN: /* See Note #1c. */
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND:
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
default:
return; /* Prevent 'break NOT reachable' warning. */
}
break;
case NET_TCP_CONN_STATE_NONE:
default:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
return; /* Prevent 'break NOT reachable' warning. */
}
/* ------ START TCP CONN TX Q IDLE TMR ------- */
timeout_tick = pconn->TxRTT_RTO_tick; /* Tx Q idle timeout = RTO (see Note #2a1). */
if (pconn->TxQ_IdleTmr == (NET_TMR *)0) { /* If tx Q idle tmr NOT avail, ... */
pconn->TxQ_IdleTmr = NetTmr_Get((void *) pconn, /* ... get tx Q idle tmr. */
(CPU_FNCT_PTR) NetTCP_TxConnTxQ_TimeoutIdle,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
} else { /* Else set tx Q idle tmr. */
NetTmr_Set((NET_TMR *) pconn->TxQ_IdleTmr,
(CPU_FNCT_PTR) NetTCP_TxConnTxQ_TimeoutIdle,
(NET_TMR_TICK) timeout_tick,
(NET_ERR *)&err);
}
if (err != NET_TMR_ERR_NONE) { /* If any err(s), ... */
/* ... reset tx win ctrls (see Note #2b). */
NetTCP_TxConnWinSizeHandlerCongCtrl((NET_TCP_CONN *) pconn,
(NET_BUF_HDR *) 0,
(NET_TCP_ACK_CODE) NET_TCP_CONN_RX_ACK_NONE,
(NET_TCP_WIN_SIZE) 0,
(NET_TCP_WIN_CODE) NET_TCP_CONN_TX_WIN_RESET,
(NET_ERR *)&err);
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnTxQ_TimeoutIdleClr()
*
* Description : (1) Clear TCP connection's transmit queue idle timer for the following states :
*
* (a) ESTABLISHED
* (b) FIN-WAIT-1
* (c) CLOSING
* (d) CLOSE-WAIT
* (e) LAST-ACK
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnTxQ().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnTxQ().
*
* Note(s) : (2) (a) RFC #2581, Section 4.1 states that "after TCP has been idle for a relatively long period
* of time ... use slow start to restart transmission" :
*
* (1) "If the TCP has not sent data in an interval exceeding the retransmission timeout" ...
* (2) "cwnd is reduced to ... no more than ... the value of the restart window."
*
* See also 'NetTCP_TxConnTxQ_TimeoutIdle() Note #2a'.
*
* (b) (1) However, if the TCP connection's re-transmit queue is NOT empty, then TCP data has
* has been transmitted & is awaiting acknowledgement.
*
* (2) Therefore, NO transmit queue idle timeout is currently needed.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnTxQ_TimeoutIdleClr (NET_TCP_CONN *pconn)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
CPU_BOOLEAN tmr_free;
/* ------------ VALIDATE TCP CONN ------------- */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
return; /* Prevent 'break NOT reachable' warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
return; /* Prevent 'break NOT reachable' warning. */
case NET_TCP_CONN_STATE_CONN: /* See Note #1. */
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND:
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
default:
return; /* Prevent 'break NOT reachable' warning. */
}
break;
case NET_TCP_CONN_STATE_NONE:
default:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
return; /* Prevent 'break NOT reachable' warning. */
}
/* ------- CLR TCP CONN TX Q IDLE TMR -------- */
tmr_free = (pconn->ReTxQ_Head != (NET_BUF *)0) ? DEF_YES : DEF_NO;
if (tmr_free == DEF_YES) { /* If re-tx Q NOT empty (see Note #2b1), ... */
if (pconn->TxQ_IdleTmr != (NET_TMR *)0) {
NetTmr_Free(pconn->TxQ_IdleTmr); /* ... free tx Q idle tmr (see Note #2b2). */
pconn->TxQ_IdleTmr = (NET_TMR *)0;
}
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnTxQ_TimeoutSillyWin()
*
* Description : (1) (a) Handle TCP connection's transmit queue silly window timeout ... :
*
* (1) Clear TCP connection's transmit silly window persist timer See Note #4aA1
* (2) Transmit TCP connection's transmit data See Note #2
*
* (b) ... for the following states :
*
* (1) ESTABLISHED
* (2) FIN-WAIT-1
* (3) CLOSING
* (4) CLOSE-WAIT
* (5) LAST-ACK
*
*
* Argument(s) : pconn_timeout Pointer to TCP connection (see Note #3b).
*
* Return(s) : none.
*
* Caller(s) : Referenced in NetTCP_TxConnTxQ().
*
* Note(s) : (2) RFC #1122, Section 4.2.3.4 states that on "timeout ... force transmission of data,
* overriding the SWS avoidance algorithm".
*
* See also 'NetTCP_TxConnTxQ() Note #7b2Bb'.
*
* (3) Ideally, network timer expiration functions could be defined as '[(void) (OBJECT *)]'
* type functions -- even though network timer API functions cast expiration functions
* to generic 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]').
*
* (a) (1) Unfortunately, ISO-IEC 9899-1999 ANSI-C, Section 6.3.2.3.7 states that "a
* pointer to an object ... may be converted to a pointer to a different object
* ... [but] if the resulting pointer is not correctly aligned ... the behavior
* is undefined".
*
* And since compilers may NOT correctly convert 'void' pointers to non-'void'
* pointer arguments, network timer expiration functions MUST avoid incorrect
* pointer conversion behavior between 'void' pointer parameters & non-'void'
* pointer arguments & therefore CANNOT be defined as '[(void) (OBJECT *)]'.
*
* (2) However, Section 6.3.2.3.1 states that "a pointer to void may be converted
* to or from a pointer to any ... object ... A pointer to any ... object ...
* may be converted to a pointer to void and back again; the result shall
* compare equal to the original pointer".
*
* (b) Therefore, to correctly convert 'void' pointer objects back to appropriate
* network object pointer objects, network timer expiration functions MUST :
*
* (1) Be defined as 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]'); & ...
* (2) Explicitly cast 'void' pointer arguments to specific object pointers; ...
* (A) ... in this case, a 'NET_TCP_CONN' pointer.
*
* See also 'net_tmr.c NetTmr_Get() Note #3'.
*
* (4) This function is a network timer expiration function :
*
* (a) (1) For the following connection timer(s) ... :
*
* (A) TCP connection transmit silly window persist timer ('TxQ_SillyWinTmr')
*
* (2) (A) Clear the timer pointer; ...
* (1) Cleared prior to next handler function(s) as an extra precaution to
* avoiding re-freeing the timer (see Note #4a2B).
*
* (B) but do NOT re-free the timer.
*
* (b) Do NOT set the following close timer flag(s) :
*
* (1) NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN
*
* (5) Certain network connections MUST periodically suspend network transmit(s) to handle
* network receive packet(s). To protect TCP connections from transmit corruption while
* suspended, ALL TCP data transmits & TCP transmit queue handling MUST be blocked for
* suspended connections until the connection is no longer suspended.
*
* (a) The transmit queue silly window timeout is re-configured with one timer tick to
* ensure that a non-zero delay is implemented.
*
* (b) If NO timer is available, a TCP connection will NOT be able to re-schedule the
* transmission of its TCP transmit queue data. Thus, the TCP transmit queue data
* will be delayed until triggered by any received acknowledgement packets or by
* additional data transmits from the applications layer.
*
* See also 'NetTCP_TxConnTxQ() Note #10b2A2',
* 'NetTCP_TxConnTxQ_TimeoutIdle() Note #5',
* 'NetTCP_TxConnReTxQ_Timeout() Note #5',
* & 'NetTCP_TxConnWinSizeZeroWinTimeout() Note #5'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnTxQ_TimeoutSillyWin (void *pconn_timeout)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
NET_TCP_CLOSE_CODE close_code;
NET_TMR_TICK timeout_tick;
NET_ERR err;
pconn = (NET_TCP_CONN *)pconn_timeout; /* See Note #3b2A. */
close_code = NET_TCP_CONN_CLOSE_ALL;
DEF_BIT_CLR(close_code, NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN); /* See Note #4b1. */
/* -------------- VALIDATE TCP CONN --------------- */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (pconn == (NET_TCP_CONN *)0) {
NET_CTR_ERR_INC(NetTCP_ErrNullPtrCtr);
return;
}
if (pconn->Type != NET_TCP_TYPE_CONN) {
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidTypeCtr);
return;
}
#endif
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CONN: /* See Note #1. */
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
break;
case NET_TCP_TX_Q_STATE_CONN_SUSPEND: /* See Note #5. */
timeout_tick = (NET_TMR_TICK)1; /* See Note #5a. */
pconn->TxQ_SillyWinTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_TxConnTxQ_TimeoutSillyWin,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
(void)err; /* Ignore transitory rsrc err(s) [see Note #5b]. */
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)close_code);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/*$PAGE*/
/* ---- HANDLE TCP CONN TX Q SILL WIN TIMEOUT ----- */
pconn->TxQ_SillyWinTmr = (NET_TMR *)0; /* Clr tx Q silly win tmr (see Note #4a2A1). */
NetTCP_TxConnTxQ((NET_TCP_CONN *) pconn, /* Tx Q data (see Note #2). */
(NET_BUF_HDR *) 0,
(NET_TCP_ACK_CODE ) NET_TCP_CONN_TX_ACK_NONE,
(CPU_BOOLEAN ) DEF_YES,
(NET_TCP_CLOSE_CODE) close_code,
(NET_ERR *)&err); /* Ignore ALL tx err(s), transitory or fatal. */
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnReTxQ()
*
* Description : (1) Re-transmit TCP data segment(s) from TCP connection re-transmit queue :
*
* (a) Update TCP connection :
* (1) Update TCP connection's re-transmit queue timeout :
* (A) Update TCP connection's re-transmit queue timer See Note #2b
* (B) Reset TCP connection's transmit round-trip time See Note #2b2A2
* controls
* (2) Update TCP connection's transmit congestion controls :
* (A) Update TCP connection's transmit congestion window See Note #5
* (B) Reset TCP connection's delayed acknowledgement controls See Note #6
*
* (b) Prepare TCP segment re-transmit :
* (1) Prepare unchanged TCP segment for re-transmit See Note #7
*
* (2) Prepare updated TCP segment for re-transmit :
* (A) TCP segment sequence numbers
* (B) TCP segment window size
* (C) TCP segment addresses
* (D) TCP segment transmit flags
* (E) IP datagram parameters
* (F) Update TCP segment's last transmit values :
* (1) Sequence Number
* (2) Acknowledgement Number
* (3) Segment Length
* (4) Window Size
* (G) Unlink TCP segment packet buffer from any other network layer(s)
* (H) Update TCP segment packet buffer controls
*
* (c) Re-transmit TCP segment See Note #2a
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnReTxQ_Timeout(),
* NetTCP_TxConnWinSizeHandlerCongCtrl().
*
* re_tx_q_timeout Indicate whether the TCP connection re-transmit queue timed out :
*
* DEF_NO TCP connection re-transmit queue did
* NOT time out.
* DEF_YES TCP connection re-transmit queue
* timed out.
*
* close_code Select which close action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_CLOSE_NONE Perform NO close actions.
* NET_TCP_CONN_CLOSE_ALL Perform ALL close actions.
*
* NET_TCP_CONN_CLOSE_CONN_TX_RESET Perform close connection transmit reset.
* NET_TCP_CONN_CLOSE_CONN_ALL Perform ALL connection close actions.
*
* NET_TCP_CONN_CLOSE_TMR_TX_IDLE Close transmit idle timer.
* NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN Close transmit silly window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN Close transmit zero window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY Close transmit acknowledgement delay timer.
* NET_TCP_CONN_CLOSE_TMR_RE_TX Close re-transmit timer.
* NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE Close connection keep-alive timer.
* NET_TCP_CONN_CLOSE_TMR_TIMEOUT Close connection timer.
* NET_TCP_CONN_CLOSE_TMR_ALL Close ALL timers.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES'.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection re-transmit queue successfully handled.
* NET_TCP_ERR_RE_TX_SEG_TH TCP connection closed due to excessive retransmission.
*
* --- RETURNED BY NetTCP_TxConnReTxQ_TimeoutSet() : ----
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* -------- RETURNED BY NetTCP_TxPktHandler() : ---------
* ------------- RETURNED BY NetIP_ReTx() : -------------
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_ERR_TX Transmit error.
*
* -------- RETURNED BY NetTCP_TxPktHandler() : ---------
* NET_TCP_ERR_TX TCP transmit error (see Note #11a).
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnReTxQ_Timeout(),
* NetTCP_TxConnWinSizeHandlerCongCtrl().
*$PAGE*
* Note(s) : (2) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : RETRANSMISSION TIMEOUT'
* states that "for any state if the retransmission timeout expires on a segment in
* the retransmission queue" :
*
* (A) RFC #1122, Section 4.2.3.1 reiterates that "retransmission of SYN segments
* SHOULD use the same algorithm as data segments".
*
* (a) "Send the segment at the front of the retransmission queue."
*
* (A) RFC #2988, Section 5.4 reiterates that "when the retransmission timer
* expires ... retransmit the earliest segment that has not been acknowledged
* by the TCP receiver".
*
* (1) RFC #1122, Section 4.2.2.16 states that "a TCP receiver SHOULD NOT shrink the
* window ... However, a sending TCP MUST be robust against window shrinking ...
* If this happens, the sender SHOULD NOT send new data, but SHOULD retransmit
* normally the old unacknowledged data between SND.UNA and SND.UNA+SND.WND. The
* sender MAY also retransmit old data beyond SND.UNA+SND.WND, but SHOULD NOT time
* out the connection if data beyond the right window edge is not acknowledged".
*
* Therefore, ALL data segments previously transmitted & awaiting acknowledgement
* in a TCP connections' re-transmit queue may be re-transmitted regardless of the
* TCP connection's current transmit congestion control window size or the remote
* host's receive window size.
*
* (2) (A) RFC #2581, Section 3.2 states that "the fast retransmit algorithm uses the
* arrival of 3 duplicate ACKs ... as an indication that a segment has been
* lost ... [and] performs a retransmission of what appears to be the missing
* segment".
*
* (B) RFC #1122, Section 4.2.2.21 reiterates that "'fast retransmit' ... uses the
* redundant ACK's to deduce that a segment has been lost ... If more than a
* threshold number of such ACK's is received, then the segment containing the
* octets starting at SEG.ACK is assumed to have been lost and is retransmitted".
*
* (b) "Reinitialize the retransmission timer."
*
* (1) RFC #2988, Section 5 states that "an implementation MUST manage the retransmission
* timer(s) in such a way that a segment is never retransmitted too early, i.e. less
* than one RTO after the previous transmission of that segment".
*
* (A) "The following is the RECOMMENDED algorithm for managing the retransmission
* timer" :
*
* (1) "Every time a packet containing data is sent (including a retransmission),
* if the timer is not running, start it running so that it will expire after
* RTO seconds (for the current value of RTO)."
*
* Therefore, the TCP connection re-transmit queue timer is reset whenever a
* segment is re-transmitted.
*
* (2) "When all outstanding data has been acknowledged, turn off the retransmission
* timer."
*
* (3) "When an ACK is received that acknowledges new data, restart the retransmission
* timer so that it will expire after RTO seconds (for the current value of RTO)."
*
* (B) "When the retransmission timer expires, do the following" :
*
* (5) "The host MUST set RTO <- RTO * 2 ('back off the timer')."
*
* See also Note #2b2A1.
*
* (6) "Start the retransmission timer, such that it expires after RTO seconds
* (for the value of RTO after the doubling operation)."
*$PAGE*
* (2) (A) (1) RFC #1122, Section 4.2.3.1 reiterates that an "implementation MUST also
* include 'exponential backoff' for successive RTO values for the same
* segment".
*
* (a) RFC #2988, Section 5.5 states that "when the retransmission timer
* expires ... the host MUST set RTO <- RTO * 2 ('back off the timer')".
*
* Thus, the TCP retransmission timer exponential back-off scalar
* value is 2.
*
* (b) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 21.2,
* Page 299 reiterates that "this doubling is called an 'exponential
* backoff'".
*
* See also 'NetTCP_TxConnRTT_RTO_Calc() Note #2b2'.
*
* (2) RFC #2988, Section 5 adds "that a TCP implementation MAY clear SRTT [TCP
* smoothed round-trip time] and RTTVAR [TCP round-trip time variance] after
* backing off the timer multiple times as it is likely that the current SRTT
* and RTTVAR are bogus in this situation. Once SRTT and RTTVAR are cleared
* they should be initialized with the next RTT sample taken".
*
* See also 'NetTCP_TxConnRTT_RTO_Calc() Note #2a4A'.
*
* (B) (1) (a) RFC #2581, Section 3.2 states that "after receiving 3 duplicate ACKs
* ... the fast retransmit algorithm ... performs a retransmission of
* what appears to be the missing segment, without waiting for the
* retransmission timer to expire".
*
* (b) RFC #1122, Section 4.2.2.21 reiterates that with "'fast retransmit' ...
* the [lost] segment ... is retransmitted, without awaiting a timeout".
*
* (2) If a segment is re-transmitted due to the TCP fast re-transmit algorithm
* & NOT due to the TCP connection's re-transmit queue timer expiring, the
* TCP connection's re-transmit queue timer is :
*
* (a) NOT backed-off because the re-transmit queue See Note #2b1B
* timer did NOT expire
* (b) Restarted with its current RTO value See Note #2b1A1
*
* (3) RFC #1122, Section 4.2.3.5 states that "excessive retransmission of the same segment
* by TCP indicates some failure of the remote host or the Internet path ... The following
* procedure MUST be used to handle excessive retransmissions of data segments" :
*
* (c) "When the number of transmissions of the same segment reaches a threshold ...
* close the connection."
*
* See also 'NetTCP_RxPktConnHandlerReTxQ() Note #7'.
*
* (4) RFC #2988, Section 3 states that "TCP MUST use Karn's algorithm ... for taking RTT samples.
* That is, RTT samples MUST NOT be made using segments that were retransmitted (and thus for
* which it is ambiguous whether the reply was for the first instance of the packet or a later
* instance)".
*
* (a) To ensure implementation of Karn's algorithm, while ANY re-transmitted segment(s)
* remain unacknowledged in a TCP connection's re-transmit queue :
*
* (1) (A) NO RTT calculations are performed; ... See Note #4
*
* (B) The TCP connection's re-transmit timeout :
* (1) MAY be backed-off ... See Note #2b1B5
* OR
* (2) MAY be latched at a previously backed-off value; See Note #2b1B6
* BUT
* (3) MUST NOT be updated by RTT calculations. See Note #4a1A
*
* (2) Each time a TCP connection re-transmits a segment, the TCP connection advances
* its un-re-transmitted sequence number to the TCP connection's next sequence
* number to transmit. This ensures that NO RTT or RTO calculations are performed
* until ALL re-transmitted data is acknowledged & remove from the TCP connection's
* re-transmit queue.
*
* (5) RFC #2581, Section 3.1 states that "when a TCP sender detects segment loss using the
* retransmission timer, the value of ssthresh [TCP transmit congestion control slow start
* threshold] ... [and] cwnd [TCP transmit congestion control window] MUST be set".
*
* See also 'NetTCP_TxConnWinSizeHandlerCongCtrl() Notes #2c2A5a & #2c2A5b'.
*
* (6) A TCP connection's delayed acknowledgement controls :
*
* (a) SHOULD be reset whenever a TCP connection re-transmits data segment(s) since
* any re-transmit always transmits an accompanying acknowledgement;
* (b) MAY be reset whenever a TCP connection re-transmits a connection request
* segment since NO delayed acknowledgement controls should be active.
*
* See also 'NetTCP_TxConnAckDlyReset() Note #1'.
*$PAGE*
* (7) RFC #1122, Section 4.2.2.15 states that "if a retransmitted packet is identical to the
* original packet (which implies not only that the data boundaries have not changed, but
* also that the window and acknowledgment fields of the header have not changed), then
* the same IP Identification field MAY be used".
*
* In other words, if the following TCP segment header values are unchanged since the
* last transmission of the TCP segment, then the TCP segment may be transmitted without
* re-calculation of the TCP header :
*
* (a) Sequence Number
* (b) Acknowledgement Number
* (c) Segment Length
* (d) Window Size
*
* (8) (a) Some network interfaces require a minimum packet size & may also require that
* packets smaller than the minimum packet size be appended with trailing pad
* octets. Therefore, all network transmit packets MUST be prepared to satisfy
* a possible network interface minimum packet size requirement.
*
* (b) To ensure that TCP re-transmit segments will be properly prepared to satisfy
* a network interface minimum packet size requirement, the following equations
* are used to validate a TCP re-transmit segment size :
*
* (A) (1) TCP Re-transmit Segment Size = Segment's Re-transmit Protocol Header Sizes +
* Segment's Remaining Segment Data Size
*
* (2) = Segment's Previous Protocol Header Sizes +
* Segment's Remaining Segment Data Size
*
* (3) = (Segment's Previous Total Packet Size -
* Segment's Previous Data Size) +
* Segment's Remaining Segment Data Size
*
* (B) (1) TCP Re-transmit Minimum Segment Size = Network Interface Minimum Packet Size
*
* (2) [(Segment's Total Packet Size -
* Segment's Data Size) +
* Segment's Minimum Segment Data Size ] = Network Interface Minimum Packet Size
*
* (3) Segment's Minimum Segment Data Size = Network Interface Minimum Packet Size -
* (Segment's Total Packet Size -
* Segment's Data Size)
*
* (1) Equation #8bA2 subtly assumes that the TCP re-transmit segment's network
* protocol header sizes equal the segment's previously transmitted network
* protocol header sizes. In other words, it is assumed that a TCP transmit
* segment's network protocol header sizes will remain constant for the
* segment's initial transmission & any subsequent retransmissions.
*
* This assumption is true if & only if the TCP segment is re-transmitted
* with no changes in any of the segment's network protocol header sizes,
* which typically vary only for changes in the network protocol header
* types or in the number of network protocol header options.
*
* #### However, since TCP segments that have already been transmitted can
* NOT modify their segment data (see 'NetTCP_TxConnAppData() Note #10a'),
* it seems reasonable that TCP segments that have already been transmitted
* will NOT likely modify their network protocol header types & SHOULD NOT
* modify their network protocol header options.
*
* #### Therefore, it seems reasonable that TCP segments that have already
* been transmitted will NOT likely vary their network protocol header sizes.
* Thus, TCP segments may validate their re-transmit segment size versus any
* possible network interface minimum packet size requirement based on their
* previously transmitted network protocol header & packet sizes.
*
* (2) (A) Equation #8bB calculates a TCP re-transmit segment's minimum data size
* as required by a possible network interface minimum packet size. If
* the TCP re-transmit segment's data size is smaller than the network
* interface minimum packet size, the network buffer MUST be checked for
* sufficient & available trailing octets, as required by the network
* interface layer to append pad octets.
*
* (B) (1) (a) (1) If the TCP re-transmit segment's minimum data size is smaller
* than the required network interface minimum packet size ...
* AND
* (2) there is insufficient network buffer octets available for
* the network interface layer to append pad octets, ...
*
* (b) then the TCP segment's remaining data octets MUST be moved to
* the network buffer's transmit index to provide sufficient
* network buffer data octets for the network interface layer to
* append pad octets.
*
* (2) A network interface that appends cleared trailing pad octets MAY be
* optimized to skip clearing the trailing pad octets if the network
* buffer's memory clear flag is set. Since a partially-acknowledged
* TCP segment's network buffer contains previously acknowledged data
* octets, the network buffer's memory clear flag MUST be cleared to
* ensure that the network interface layer clears the trailing pad
* octets.
*$PAGE*
* (9) If a packet buffer's unlink function is available, it is assumed that the function ...
*
* (a) Correctly unlinks the packet buffer from any other network protocol layers
* AND
* (b) Correctly updates the network buffer's reference counter to decrement the
* number of network protocol layers that no longer maintain a reference to
* the packet buffer.
* AND
* (c) Clears both the unlink function & object pointers.
*
* (10) Increment network buffer's reference counter to include the TCP segment STILL enqueued
* to the TCP connection's re-transmit queue as a reference to the network buffer.
*
* (11) (a) Since segments enqueued to a TCP connection's transmit queue have already been
* reported as transmitted to the application & since no mechanism exists for a TCP
* connection to re-request previously transmitted data, any TCP connection whose
* transmit queue(s) becomes corrupted MUST be closed to force the application layer
* to abort &/or recover from the corrupted data.
*
* (b) For any internal errors where the TCP connection's transmit queue is NOT corrupted,
* the TCP connection is NOT closed.
*
* See also 'NetTCP_TxConnAppData() Note #10'
* & 'NetTCP_TxConnTxQ() Note #12'.
*********************************************************************************************************
*/
static void NetTCP_TxConnReTxQ (NET_TCP_CONN *pconn,
CPU_BOOLEAN re_tx_q_timeout,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_STAT_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_BUF *pseg;
NET_BUF_HDR *pseg_hdr;
NET_IP_TOS TOS;
NET_IP_TTL TTL;
NET_IP_ADDR src_addr;
NET_IP_ADDR dest_addr;
NET_TCP_PORT_NBR src_port;
NET_TCP_PORT_NBR dest_port;
NET_TCP_SEQ_NBR seq_nbr;
NET_TCP_SEQ_NBR ack_nbr;
NET_TCP_SEG_SIZE seg_len;
NET_TCP_WIN_SIZE win_size;
NET_BUF_SIZE seg_len_tot;
NET_BUF_SIZE seg_len_hdr;
NET_BUF_SIZE seg_len_data_min;
NET_BUF_SIZE buf_size_max;
NET_BUF_SIZE data_ix_cur;
NET_BUF_SIZE data_ix_re_tx;
NET_BUF_SIZE data_len_cur;
CPU_INT16U flags_tcp;
CPU_INT16U flags_ip;
CPU_INT08U *pdata_re_tx;
CPU_FNCT_PTR unlink_fnct;
CPU_BOOLEAN seg_chngd;
CPU_BOOLEAN seg_updated;
CPU_BOOLEAN seg_data_moved;
NET_ERR err;
/*$PAGE*/
/* ----------------- VALIDATE RE-TX Q ----------------- */
if (pconn->ReTxQ_Head == (NET_BUF *)0) {
*perr = NET_TCP_ERR_NONE;
return;
}
pseg = pconn->ReTxQ_Head; /* Re-tx seg @ head of re-tx Q (see Note #2a). */
pseg_hdr = &pseg->Hdr;
pseg_hdr->TCP_SegReTxCtr++;
if (pseg_hdr->TCP_SegReTxCtr >= pconn->TxSegReTxTh) { /* If nbr re-tx's >= th, close TCP conn (see Note #3). */
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )pconn->ConnCloseAppFlag,
(NET_TCP_CLOSE_CODE)close_code);
*perr = NET_TCP_ERR_RE_TX_SEG_TH;
return;
}
/* ----------------- UPDATE TCP CONN ------------------ */
if (re_tx_q_timeout != DEF_NO) { /* If re-tx Q timeout, ... */
/* ... back-off re-tx Q timeout (see Note #2b1B5) ... */
NetTCP_TxConnRTT_RTO_Calc(pconn, NET_TCP_CONN_TX_RTT_BACKOFF, NET_TCP_TX_RTT_NONE, NET_TCP_TX_RTT_NONE);
#if 0 /* Implemented with backoff (see Note #2b2A2). */
/* ... & reset RTT ctrls (see Note #2b2A2). */
NetTCP_TxConnRTT_RTO_Calc(pconn, NET_TCP_CONN_TX_RTT_RESET, NET_TCP_TX_RTT_NONE, NET_TCP_TX_RTT_NONE);
#endif
}
/* Update re-tx Q tmr (see Note #2b1A1). */
NetTCP_TxConnReTxQ_TimeoutSet(pconn, re_tx_q_timeout, close_code, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* Adv un-re-tx'd seq(s) to ... */
pconn->TxSeqNbrUnReTxd = pconn->TxSeqNbrNext; /* ... not-yet-tx'd seq(s) [see Note #4a2]. */
if (re_tx_q_timeout != DEF_NO) { /* If re-tx Q timeout, ... */
/* ... update tx cong win (see Note #5). */
NetTCP_TxConnWinSizeHandlerCongCtrl((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(NET_TCP_ACK_CODE)NET_TCP_CONN_RX_ACK_NONE,
(NET_TCP_WIN_SIZE)0,
(NET_TCP_WIN_CODE)NET_TCP_CONN_TX_WIN_TIMEOUT,
(NET_ERR *)perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
}
NetTCP_TxConnAckDlyReset(pconn, DEF_YES); /* Reset ack dly ctrls (see Note #6). */
/*$PAGE*/
/* -------------- PREPARE TCP RE-TX SEG --------------- */
/* Prepare TCP seq nbrs. */
seq_nbr = (NET_TCP_SEQ_NBR )pseg_hdr->TCP_SeqNbr;
ack_nbr = (NET_TCP_SEQ_NBR )pconn->RxSeqNbrNext;
seg_len = (NET_TCP_SEG_SIZE)pseg_hdr->TCP_SegLen;
/* Prepare TCP win size. */
win_size = (NET_TCP_WIN_SIZE)pconn->RxWinSizeActual;
/* Chk for re-tx seg update (see Note #7). */
seg_updated = ((pseg_hdr->TCP_SeqNbrLast != seq_nbr ) ||
(pseg_hdr->TCP_AckNbrLast != ack_nbr ) ||
(pseg_hdr->TCP_SegLenLast != seg_len ) ||
(pseg_hdr->TCP_WinSizeLast != win_size)) ? DEF_YES : DEF_NO;
seg_data_moved = DEF_NO;
seg_len_tot = (NET_BUF_SIZE)(pseg_hdr->TotLen - /* Seg cur tot len = prev'ly tx'd/ack'd pkt tot len - */
pseg_hdr->DataLen + /* ... prev'ly tx'd/ack'd pkt data len + */
pseg_hdr->TCP_SegLenData); /* ... rem'ing seg data len */
/* ... (see Note #8bA). */
if (seg_len_tot < NET_IF_PKT_SIZE_MIN) { /* If TCP re-tx seg tot len ... */
/* ... < min IF pkt size (see Note #8b2B1a2), ... */
/* ... calc min IF seg data len (see Note #8bB); ... */
seg_len_hdr = pseg_hdr->TotLen - pseg_hdr->DataLen;
seg_len_data_min = NET_IF_FRAME_MIN_SIZE - seg_len_hdr;
buf_size_max = NetBuf_GetMaxSize((NET_BUF *)pseg,
(NET_BUF_SIZE)pseg_hdr->DataIx);
if (seg_len_data_min > buf_size_max) { /* ... & if min IF seg data len ... */
/* ... > max buf size (see Note #8b2B1a2), ... */
data_ix_cur = (NET_BUF_SIZE) pseg_hdr->DataIx;
data_ix_re_tx = (NET_BUF_SIZE) NET_BUF_DATA_TX_IX;
data_len_cur = (NET_BUF_SIZE) pseg_hdr->TCP_SegLenData;
pdata_re_tx = (CPU_INT08U *)&pseg->Data[data_ix_re_tx];
NetBuf_DataRd((NET_BUF *) pseg, /* ... rd rem'ing TCP seg data ... */
(NET_BUF_SIZE) data_ix_cur,
(NET_BUF_SIZE) data_len_cur,
(CPU_INT08U *) pdata_re_tx, /* ... & move to base re-tx ix (see Note #8b2B1b). */
(NET_ERR *)&err);
if (err != NET_BUF_ERR_NONE) { /* See Note #11a. */
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)close_code);
*perr = NET_TCP_ERR_CONN_FAULT;
return;
}
DEF_BIT_CLR(pseg_hdr->Flags, NET_BUF_FLAG_CLR_MEM); /* MUST clr buf mem clr flag (see Note #8b2B2). */
seg_data_moved = DEF_YES;
}
}
seg_chngd = ((seg_updated != DEF_NO) ||
(seg_data_moved != DEF_NO)) ? DEF_YES : DEF_NO;
/*$PAGE*/
if (seg_chngd != DEF_NO) { /* If chng'd, prepare seg for re-tx (see Note #1b2). */
/* Prepare TCP seg addrs. */
src_port = (NET_TCP_PORT_NBR)pseg_hdr->TCP_UDP_PortSrc;
src_addr = (NET_IP_ADDR )pseg_hdr->IP_AddrSrc;
dest_port = (NET_TCP_PORT_NBR)pseg_hdr->TCP_UDP_PortDest;
dest_addr = (NET_IP_ADDR )pseg_hdr->IP_AddrDest;
/* Prepare TCP tx flags. */
flags_tcp = pseg_hdr->TCP_Flags;
/* Prepare IP params. */
TOS = pconn->TxIP_TOS;
TTL = pconn->TxIP_TTL;
flags_ip = pconn->TxIP_Flags;
/* Update re-tx seg's last tx ctrls (see Note #1b2F). */
pseg_hdr->TCP_SeqNbrLast = (CPU_INT32U)seq_nbr;
pseg_hdr->TCP_AckNbrLast = (CPU_INT32U)ack_nbr;
pseg_hdr->TCP_SegLenLast = (CPU_INT16U)seg_len;
pseg_hdr->TCP_WinSizeLast = (CPU_INT16U)win_size;
/* Reset protocol & tot len for re-tx. */
pseg_hdr->ProtocolHdrType = NET_PROTOCOL_TYPE_TCP;
pseg_hdr->TotLen = pseg_hdr->DataLen;
}
unlink_fnct = pseg_hdr->UnlinkFnctPtr;
if (unlink_fnct != (CPU_FNCT_PTR)0) { /* If unlink fnct avail, .. */
unlink_fnct((void *)pseg); /* .. unlink seg from other layer(s) [see Note #9]. */
}
if (pseg_hdr->RefCtr <= 1) {
pseg_hdr->RefCtr++; /* TCP STILL maintains ref to seg (see Note #10). */
}
/* ---------------- RE-TX TCP CONN SEG ---------------- */
if (seg_updated == DEF_NO) { /* If seg NOT updated, */
NetIP_ReTx((NET_BUF *)pseg, /* ... re-tx unchng'd seg (see Note #7). */
(NET_ERR *)perr);
if (*perr != NET_IP_ERR_NONE) {
return;
}
} else { /* Else re-tx updated seg. */
NetTCP_TxPktHandler((NET_BUF *)pseg,
(NET_IP_ADDR )src_addr,
(NET_TCP_PORT_NBR)src_port,
(NET_IP_ADDR )dest_addr,
(NET_TCP_PORT_NBR)dest_port,
(NET_TCP_SEQ_NBR )seq_nbr,
(NET_TCP_SEQ_NBR )ack_nbr,
(NET_TCP_WIN_SIZE)win_size,
(NET_IP_TOS )TOS,
(NET_IP_TTL )TTL,
(CPU_INT16U )flags_tcp,
(CPU_INT16U )flags_ip,
(void *)0,
(void *)0,
(NET_ERR *)perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
case NET_ERR_INIT_INCOMPLETE:
case NET_ERR_TX: /* Ignore transitory tx err(s). */
break;
case NET_TCP_ERR_TX: /* See Note #11a. */
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )pconn->ConnCloseAppFlag,
(NET_TCP_CLOSE_CODE)close_code);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
}
NET_CTR_STAT_INC(NetTCP_StatTxSegConnReTxQ_Ctr);
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnReTxQ_Timeout()
*
* Description : (1) (a) Handle TCP connection re-transmit queue timeout ... :
*
* (1) Clear TCP connection's re-transmit timer See Note #4aA1
* (2) Handle TCP connection re-transmit See Note #2
*
* (b) ... for the following synchronization/connected states :
*
* (1) SYN-RECEIVED
* (2) SYN-SENT
* (3) ESTABLISHED
* (4) FIN-WAIT-1
* (5) CLOSING
* (6) CLOSE-WAIT
* (7) LAST-ACK
*
*
* Argument(s) : pconn_timeout Pointer to TCP connection to perform re-transmit (see Note #3b).
*
* Return(s) : none.
*
* Caller(s) : Referenced in NetTCP_TxConnReTxQ_TimeoutSet().
*
* Note(s) : (2) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : RETRANSMISSION TIMEOUT'
* states that "if the retransmission timeout expires ... send the segment at the
* front of the retransmission queue ... [and] reinitialize the retransmission timer".
*
* See also 'NetTCP_TxConnReTxQ() Note #2'.
*
* (3) Ideally, network timer expiration functions could be defined as '[(void) (OBJECT *)]'
* type functions -- even though network timer API functions cast expiration functions
* to generic 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]').
*
* (a) (1) Unfortunately, ISO-IEC 9899-1999 ANSI-C, Section 6.3.2.3.7 states that "a
* pointer to an object ... may be converted to a pointer to a different object
* ... [but] if the resulting pointer is not correctly aligned ... the behavior
* is undefined".
*
* And since compilers may NOT correctly convert 'void' pointers to non-'void'
* pointer arguments, network timer expiration functions MUST avoid incorrect
* pointer conversion behavior between 'void' pointer parameters & non-'void'
* pointer arguments & therefore CANNOT be defined as '[(void) (OBJECT *)]'.
*
* (2) However, Section 6.3.2.3.1 states that "a pointer to void may be converted
* to or from a pointer to any ... object ... A pointer to any ... object ...
* may be converted to a pointer to void and back again; the result shall
* compare equal to the original pointer".
*
* (b) Therefore, to correctly convert 'void' pointer objects back to appropriate
* network object pointer objects, network timer expiration functions MUST :
*
* (1) Be defined as 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]'); & ...
* (2) Explicitly cast 'void' pointer arguments to specific object pointers; ...
* (A) ... in this case, a 'NET_TCP_CONN' pointer.
*
* See also 'net_tmr.c NetTmr_Get() Note #3'.
*
* (4) This function is a network timer expiration function :
*
* (a) (1) For the following connection timer(s) ... :
*
* (A) TCP connection re-transmit queue timer ('ReTxQ_Tmr')
*
* (2) (A) Clear the timer pointer; ...
* (1) Cleared prior to next handler function(s) as an extra precaution to
* avoiding re-freeing the timer (see Note #4a2B).
*
* (B) but do NOT re-free the timer.
*
* (b) Do NOT set the following close timer flag(s) :
*
* (1) NET_TCP_CONN_CLOSE_TMR_RE_TX
*
* (5) Certain network connections MUST periodically suspend network transmit(s) to handle
* network receive packet(s). To protect TCP connections from transmit corruption while
* suspended, ALL TCP data transmits & TCP transmit queue handling MUST be blocked for
* suspended connections until the connection is no longer suspended.
*
* However, handling the TCP connection's re-transmit timeout is permitted since NO TCP
* data is transmitted & the TCP connection's transmit queue is NOT handled (see Note #1a).
*
* See also 'NetTCP_TxConnTxQ() Note #10b2A2',
* 'NetTCP_TxConnTxQ_TimeoutIdle() Note #5',
* 'NetTCP_TxConnTxQ_TimeoutSillyWin() Note #5',
* & 'NetTCP_TxConnWinSizeZeroWinTimeout() Note #5'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnReTxQ_Timeout (void *pconn_timeout)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
NET_TCP_CLOSE_CODE close_code;
NET_ERR err;
pconn = (NET_TCP_CONN *)pconn_timeout; /* See Note #3b2A. */
close_code = NET_TCP_CONN_CLOSE_ALL;
DEF_BIT_CLR(close_code, NET_TCP_CONN_CLOSE_TMR_RE_TX); /* See Note #4b1. */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ---------------- VALIDATE TCP CONN ----------------- */
if (pconn == (NET_TCP_CONN *)0) {
NET_CTR_ERR_INC(NetTCP_ErrNullPtrCtr);
return;
}
if (pconn->Type != NET_TCP_TYPE_CONN) {
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidTypeCtr);
return;
}
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED:
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_SYNC_RXD: /* See Note #1. */
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
switch (pconn->TxQ_State) {
case NET_TCP_TX_Q_STATE_CONN:
case NET_TCP_TX_Q_STATE_CONN_CLOSING:
case NET_TCP_TX_Q_STATE_CONN_SUSPEND: /* See Note #5. */
break;
case NET_TCP_TX_Q_STATE_NONE:
case NET_TCP_TX_Q_STATE_CLOSED:
case NET_TCP_TX_Q_STATE_CONN_CLOSED:
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)close_code);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
/* --------- HANDLE TCP CONN RE-TX Q TIMEOUT ---------- */
pconn->ReTxQ_Tmr = (NET_TMR *)0; /* Clr re-tx Q tmr (see Note #4a2A1). */
NetTCP_TxConnReTxQ(pconn, DEF_YES, close_code, &err); /* Handle re-tx Q (see Note #2). */
(void)err; /* Ignore ALL re-tx err(s), transitory or fatal. */
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnReTxQ_TimeoutSet()
*
* Description : (1) (a) Set TCP connection's re-transmit queue timer for the following synchronization/
* connected states :
*
* (1) CLOSED
* (2) LISTEN
* (3) SYN-RECEIVED
* (4) SYN-SENT
* (5) ESTABLISHED
* (6) FIN-WAIT-1
* (7) CLOSING
* (8) CLOSE-WAIT
* (9) LAST-ACK
*
* (A) (1) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : RETRANSMISSION
* TIMEOUT' reiterates that "for any state if the retransmission timeout expires
* on a segment in the retransmission queue ... reinitialize the retransmission
* timer".
*
* (b) However, since a TCP connection's transmit & re-transmit queue SHOULD be closed for
* the following states, it does NOT seem reasonable to set or reset a TCP connection's
* re-transmit queue timer for these states :
*
* (1) FIN-WAIT-2
* (2) TIME-WAIT
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnSync(),
* NetTCP_TxConnTxQ(),
* NetTCP_TxConnReTxQ(),
* NetTCP_RxPktConnHandlerReTxQ().
*
* re_tx_q_timeout Indicate whether the TCP connection re-transmit queue timed out :
*
* DEF_NO TCP connection re-transmit queue did
* NOT time out.
* DEF_YES TCP connection re-transmit queue
* timed out.
*
* close_code Select which close action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_CLOSE_NONE Perform NO close actions.
* NET_TCP_CONN_CLOSE_ALL Perform ALL close actions.
*
* NET_TCP_CONN_CLOSE_CONN_TX_RESET Perform close connection transmit reset.
* NET_TCP_CONN_CLOSE_CONN_ALL Perform ALL connection close actions.
*
* NET_TCP_CONN_CLOSE_TMR_TX_IDLE Close transmit idle timer.
* NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN Close transmit silly window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN Close transmit zero window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY Close transmit acknowledgement delay timer.
* NET_TCP_CONN_CLOSE_TMR_RE_TX Close re-transmit timer.
* NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE Close connection keep-alive timer.
* NET_TCP_CONN_CLOSE_TMR_TIMEOUT Close connection timer.
* NET_TCP_CONN_CLOSE_TMR_ALL Close ALL timers.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES'.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection re-transmit queue timer
* successfully set.
* NET_TCP_ERR_CONN_NOT_USED TCP connection NOT currently used.
* NET_TCP_ERR_CONN_FAULT TCP connection fault; connection(s) aborted.
* NET_TCP_ERR_INVALID_CONN_STATE Invalid TCP connection state.
* NET_TCP_ERR_INVALID_CONN_OP Invalid TCP connection operation.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnSync(),
* NetTCP_TxConnTxQ(),
* NetTCP_TxConnReTxQ(),
* NetTCP_RxPktConnHandlerReTxQ().
*
* Note(s) : none.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnReTxQ_TimeoutSet (NET_TCP_CONN *pconn,
CPU_BOOLEAN re_tx_q_timeout,
NET_TCP_CLOSE_CODE close_code,
NET_ERR *perr)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TMR_TICK timeout_tick;
NET_ERR err;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ------------- VALIDATE TCP CONN STATE -------------- */
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_FREE:
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
*perr = NET_TCP_ERR_CONN_NOT_USED;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_FIN_WAIT_2: /* See Note #1b. */
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidOpCtr);
*perr = NET_TCP_ERR_INVALID_CONN_OP;
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_STATE_CLOSED: /* See Note #1a. */
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
break;
case NET_TCP_CONN_STATE_NONE:
default:
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)close_code);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidStateCtr);
*perr = NET_TCP_ERR_INVALID_CONN_STATE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
/* ------------ SET TCP CONN RE-TX Q TMR ------------- */
timeout_tick = pconn->TxRTT_RTO_tick;
if ((pconn->ReTxQ_Tmr != (NET_TMR *)0) && /* If re-tx Q tmr avail .. */
(re_tx_q_timeout == DEF_NO)) { /* .. but NOT timed out, .. */
NetTmr_Set((NET_TMR *) pconn->ReTxQ_Tmr, /* .. reset re-tx Q tmr. */
(CPU_FNCT_PTR) NetTCP_TxConnReTxQ_Timeout,
(NET_TMR_TICK) timeout_tick,
(NET_ERR *)&err);
} else { /* Else get re-tx Q tmr. */
pconn->ReTxQ_Tmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_TxConnReTxQ_Timeout,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
}
if ( err != NET_TMR_ERR_NONE) { /* #### On err, handle re-tx Q?; close TCP conn? */
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )pconn->ConnCloseAppFlag,
(NET_TCP_CLOSE_CODE)close_code);
*perr = NET_TCP_ERR_CONN_FAULT;
return;
}
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnPrepareSegAddrs()
*
* Description : Prepare TCP transmit segment addresses from TCP connection addresses.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnAppData();
* checked in NetTCP_TxConnSync(),
* NetTCP_TxConnClose(),
* NetTCP_TxConnAck(),
* NetTCP_TxConnReset(),
* NetTCP_TxConnProbe().
*
* psrc_port Pointer to variable buffer that will receive the return source port number
* --------- (see Note #1), if NO errors.
*
* Argument validated in NetTCP_TxConnAppData(),
* NetTCP_TxConnSync(),
* NetTCP_TxConnClose(),
* NetTCP_TxConnAck(),
* NetTCP_TxConnReset(),
* NetTCP_TxConnProbe().
*
* psrc_addr Pointer to variable buffer that will receive the return source address
* --------- (see Note #1), if NO errors.
*
* Argument validated in NetTCP_TxConnAppData(),
* NetTCP_TxConnSync(),
* NetTCP_TxConnClose(),
* NetTCP_TxConnAck(),
* NetTCP_TxConnReset(),
* NetTCP_TxConnProbe().
*
* src_port_len Size of the variable buffer that will receive the return source port number.
*
* src_addr_len Size of the variable buffer that will receive the return source address.
*
* pdest_port Pointer to variable buffer that will receive the return destination port number
* ---------- (see Note #1), if NO errors.
*
* Argument validated in NetTCP_TxConnAppData(),
* NetTCP_TxConnSync(),
* NetTCP_TxConnClose(),
* NetTCP_TxConnAck(),
* NetTCP_TxConnReset(),
* NetTCP_TxConnProbe().
*
* pdest_addr Pointer to variable buffer that will receive the return destination address
* ---------- (see Note #1), if NO errors.
*
* Argument validated in NetTCP_TxConnAppData(),
* NetTCP_TxConnSync(),
* NetTCP_TxConnClose(),
* NetTCP_TxConnAck(),
* NetTCP_TxConnReset(),
* NetTCP_TxConnProbe().
*
* dest_port_len Size of the variable buffer that will receive the return destination port number.
*
* dest_addr_len Size of the variable buffer that will receive the return destination address.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP connection addresses successfully
* prepared.
*
* NET_CONN_ERR_INVALID_FAMILY Invalid connection family.
* NET_CONN_ERR_INVALID_ADDR Invalid TCP connection address.
* NET_CONN_ERR_INVALID_ADDR_LEN Invalid TCP connection address length.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnAppData(),
* NetTCP_TxConnSync(),
* NetTCP_TxConnClose(),
* NetTCP_TxConnAck(),
* NetTCP_TxConnReset(),
* NetTCP_TxConnProbe().
*
* Note(s) : (1) Variable buffers to receive the returned port & address values may start on any CPU address,
* word-aligned or not.
*
* See also 'net_util.h NETWORK DATA VALUE MACRO'S Note #2b'.
*
* (2) The 'NET_CONN_CFG_FAMILY' pre-processor 'else'-conditional code will never be compiled/linked
* since 'net_conn.h' ensures that the family type configuration constant (NET_CONN_CFG_FAMILY)
* is configured with an appropriate family type value (see 'net_conn.h CONFIGURATION ERRORS').
* The 'else'-conditional code is included for completeness & as an extra precaution in case
* 'net_conn.h' is incorrectly modified.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxConnPrepareSegAddrs (NET_TCP_CONN *pconn,
CPU_INT08U *psrc_port,
CPU_INT08U *psrc_addr,
CPU_INT16U src_port_len,
CPU_INT16U src_addr_len,
CPU_INT08U *pdest_port,
CPU_INT08U *pdest_addr,
CPU_INT16U dest_port_len,
CPU_INT16U dest_addr_len,
NET_ERR *perr)
{
NET_CONN_ID conn_id;
NET_CONN_ADDR_LEN addr_len;
CPU_INT08U addr[NET_CONN_CFG_ADDR_LEN];
CPU_INT08U port[NET_CONN_CFG_ADDR_LEN];
CPU_INT08U addr_local[NET_CONN_CFG_ADDR_LEN];
CPU_INT08U addr_remote[NET_CONN_CFG_ADDR_LEN];
NET_ERR err;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
/* ---------------- VALIDATE ADDR LENS ---------------- */
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
if (src_port_len != NET_CONN_ADDR_IP_LEN_PORT) {
*perr = NET_CONN_ERR_INVALID_ADDR_LEN;
return;
}
if (src_addr_len != NET_CONN_ADDR_IP_LEN_ADDR) {
*perr = NET_CONN_ERR_INVALID_ADDR_LEN;
return;
}
if (dest_port_len != NET_CONN_ADDR_IP_LEN_PORT) {
*perr = NET_CONN_ERR_INVALID_ADDR_LEN;
return;
}
if (dest_addr_len != NET_CONN_ADDR_IP_LEN_ADDR) {
*perr = NET_CONN_ERR_INVALID_ADDR_LEN;
return;
}
#else /* See Note #2. */
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
*perr = NET_CONN_ERR_INVALID_FAMILY;
return;
#endif
#else /* Prevent compiler warnings. */
(void)&src_port_len;
(void)&src_addr_len;
(void)&dest_port_len;
(void)&dest_addr_len;
#endif
/*$PAGE*/
/* ------------------ PREPARE ADDRS ------------------- */
conn_id = pconn->ID_Conn;
addr_len = sizeof(addr_local);
NetConn_AddrLocalGet((NET_CONN_ID ) conn_id, /* Get local/src addr. */
(CPU_INT08U *)&addr_local[0],
(NET_CONN_ADDR_LEN *)&addr_len,
(NET_ERR *)&err);
if (err != NET_CONN_ERR_NONE) {
*perr = NET_CONN_ERR_INVALID_ADDR;
return;
}
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (addr_len != NET_CONN_CFG_ADDR_LEN) {
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
*perr = NET_CONN_ERR_INVALID_ADDR_LEN;
return;
}
#endif
addr_len = sizeof(addr_remote);
NetConn_AddrRemoteGet((NET_CONN_ID ) conn_id, /* Get remote/dest addr. */
(CPU_INT08U *)&addr_remote[0],
(NET_CONN_ADDR_LEN *)&addr_len,
(NET_ERR *)&err);
if (err != NET_CONN_ERR_NONE) {
*perr = NET_CONN_ERR_INVALID_ADDR;
return;
}
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (addr_len != NET_CONN_CFG_ADDR_LEN) {
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
*perr = NET_CONN_ERR_INVALID_ADDR_LEN;
return;
}
#endif
/* Prepare src/dest addrs (see Note #1). */
#if (NET_CONN_CFG_FAMILY == NET_CONN_FAMILY_IP_V4_SOCK)
Mem_Copy((void *)&port[0],
(void *)&addr_local[NET_CONN_ADDR_IP_IX_PORT],
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_PORT);
Mem_Copy((void *)&addr[0],
(void *)&addr_local[NET_CONN_ADDR_IP_IX_ADDR],
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_ADDR);
NET_UTIL_VAL_COPY_GET_NET_16(psrc_port, &port[0]);
NET_UTIL_VAL_COPY_GET_NET_32(psrc_addr, &addr[0]);
Mem_Copy((void *)&port[0],
(void *)&addr_remote[NET_CONN_ADDR_IP_IX_PORT],
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_PORT);
Mem_Copy((void *)&addr[0],
(void *)&addr_remote[NET_CONN_ADDR_IP_IX_ADDR],
(CPU_SIZE_T) NET_CONN_ADDR_IP_LEN_ADDR);
NET_UTIL_VAL_COPY_GET_NET_16(pdest_port, &port[0]);
NET_UTIL_VAL_COPY_GET_NET_32(pdest_addr, &addr[0]);
#else /* See Note #2. */
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )DEF_YES,
(NET_TCP_CLOSE_CODE)NET_TCP_CONN_CLOSE_ALL);
*perr = NET_CONN_ERR_INVALID_FAMILY;
return;
#endif
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnRTT_Init()
*
* Description : Initialize TCP connection's transmit round-trip time (RTT) controls.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnRTT_Reset(),
* NetTCP_TxConnRTT_RTO_Init().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnRTT_Reset(),
* NetTCP_TxConnRTT_RTO_Init().
*
* Note(s) : (1) (A) RFC #1122, Section 4.2.3.1 states that "the following values SHOULD be
* used to initialize the estimation parameters for a new connection" :
*
* (a) RTT = 0 seconds
*
* where
* RTT Round-Trip Time
*
* (1) Furthermore, RFC #1122, Section 4.2.3.1.(b) states that "the
* smoothed variance is to be initialized to the value that will
* result in" these values.
*
* (B) However, since RFC #2988, Section 2.2 amends the RFC #1122, Section
* 4.2.3.1 RTT initialization; the smoothed RTT average & deviation do
* NOT truly require explicit initialization. Nonetheless, these RTT
* values are initialized to conform with RFC #1122, Section 4.2.3.1.
*********************************************************************************************************
*/
static void NetTCP_TxConnRTT_Init (NET_TCP_CONN *pconn)
{
/* Init RTT (see Note #1). */
pconn->TxRTT_Avg_ms_scaled = NET_TCP_TX_RTT_AVG_INIT_MS_SCALED; /* Init RTT avg (see Note #1Aa). */
pconn->TxRTT_Dev_ms_scaled = NET_TCP_TX_RTT_DEV_INIT_MS_SCALED; /* Init RTT dev (see Note #1A1). */
NetTCP_TxConnRTT_CalcUpdate(pconn);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnRTT_Reset()
*
* Description : Reset TCP connection's transmit round-trip time (RTT) controls.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnRTT_RTO_Calc().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnRTT_RTO_Calc().
*
* Note(s) : (1) (a) RFC #2988, Section 5 states "that a TCP implementation MAY clear SRTT and
* RTTVAR after backing off the timer multiple times as it is likely that the
* current SRTT and RTTVAR are bogus in this situation. Once SRTT and RTTVAR
* are cleared they should be initialized with the next RTT sample taken".
*
* (b) RFC #2581, Section 4.1 states that "after TCP has been idle for ... an
* interval exceeding the retransmission timeout ... use slow start to
* restart transmission".
*
* Similarly, although NO RFC specifies that a TCP connection's RTT average &
* deviation should be reset following a TCP transmit idle timeout; it seems
* reasonable to reset a TCP connection's RTT average & deviation controls
* whenever a TCP connection's transmit is idle for a period exceeding the
* re-transmit timeout.
*
* See also 'NetTCP_TxConnRTT_RTO_Calc() Note #2a4'.
*********************************************************************************************************
*/
static void NetTCP_TxConnRTT_Reset (NET_TCP_CONN *pconn)
{
NetTCP_TxConnRTT_Init(pconn);
pconn->TxRTT_RTO_State = NET_TCP_TX_RTT_RTO_STATE_RESET;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnRTT_CalcUpdate()
*
* Description : Update TCP connection's transmit round-trip time (RTT) control calculations.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnRTT_Init(),
* NetTCP_TxConnRTT_RTO_Calc().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnRTT_Init(),
* NetTCP_TxConnRTT_RTO_Calc().
*
* Note(s) : (1) A TCP connection's transmit round-trip time controls should NOT be updated until
* after the following TCP connection control(s) have been configured :
*
* (a) TCP connection's transmit round-trip time average (in scaled milliseconds)
* ['TxRTT_Avg_ms_scaled']
*
* (b) TCP connection's transmit round-trip time deviation (in scaled milliseconds)
* ['TxRTT_Dev_ms_scaled']
*********************************************************************************************************
*/
static void NetTCP_TxConnRTT_CalcUpdate (NET_TCP_CONN *pconn)
{
pconn->TxRTT_Avg_ms = (NET_TCP_TIMEOUT_MS)(pconn->TxRTT_Avg_ms_scaled / NET_TCP_TX_RTT_SCALE);
pconn->TxRTT_Dev_ms = (NET_TCP_TIMEOUT_MS)(pconn->TxRTT_Dev_ms_scaled / NET_TCP_TX_RTT_SCALE);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnRTO_Init()
*
* Description : (1) Initialize TCP connection's re-transmit timeout (RTO) controls :
*
* (a) Initialize RTO See Note #2
* (b) Configure RTO maximum timeout See Note #3
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnRTT_RTO_Init().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnRTT_RTO_Init().
*
* Note(s) : (2) RFC #1122, Section 4.2.3.1 states that "the following values SHOULD be
* used to initialize the estimation parameters for a new connection" :
*
* (b) RTO = 3 seconds
*
* where
* RTO Retransmission Timeout
*
* (A) RFC #2988, Section 2.1 reiterates that "until a round-trip time (RTT)
* measurement has been made ... the sender SHOULD set RTO <- 3 seconds".
*
* (3) A TCP connection's re-transmit timeout controls should NOT be updated until
* after the following TCP connection control(s) have been configured :
*
* (a) TCP connection's maximum re-transmit timeout (in seconds) ['TxRTT_RTO_Max_sec']
* [see 'NetTCP_TxConnRTO_CfgMaxTimeout() Note #2a']
*********************************************************************************************************
*/
static void NetTCP_TxConnRTO_Init (NET_TCP_CONN *pconn)
{
pconn->TxRTT_RTO_ms_scaled = NET_TCP_TX_RTT_RTO_INIT_MS_SCALED; /* Init RTO (see Note #2). */
NetTCP_TxConnRTO_CalcUpdate(pconn);
NetTCP_TxConnRTO_CfgMaxTimeout(pconn); /* Cfg RTO max timeout (see Note #3). */
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnRTO_CfgMaxTimeout()
*
* Description : Configure TCP connection's maximum re-transmit timeout (RTO).
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnRTO_Init(),
* NetTCP_ConnCfgReTxMaxTimeout().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnRTO_Init(),
* NetTCP_ConnCfgReTxMaxTimeout().
*
* Note(s) : (1) (a) RFC #2988, Section 2.4 states that "a maximum value MAY be placed on RTO provided
* it is at least 60 seconds".
*
* (b) RFC #1122, Section 4.2.3.1 states that "the recommended ... RTO ... upper bound
* should be 2*MSL".
*
* (c) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 21.2, Page 299 states
* that "the timeout value ... [has] an upper limit of 64 seconds".
*
* (2) A TCP connection's maximum re-transmit timeouts (in scaled milliseconds or milliseconds)
* should NOT be updated until after the following TCP connection control(s) have been
* configured :
*
* (a) TCP connection's maximum re-transmit timeout (in seconds) ['TxRTT_RTO_Max_sec']
* [see 'NetTCP_ConnClr() Note #11'
* & 'NetTCP_ConnCfgReTxMaxTimeout() Note #1']
*********************************************************************************************************
*/
static void NetTCP_TxConnRTO_CfgMaxTimeout (NET_TCP_CONN *pconn)
{
pconn->TxRTT_RTO_Max_ms_scaled = (NET_TCP_TX_RTT_MS_SCALED)pconn->TxRTT_RTO_Max_sec * NET_TCP_TX_RTT_MS_SCALE;
pconn->TxRTT_RTO_Max_ms = (NET_TCP_TIMEOUT_MS )pconn->TxRTT_RTO_Max_sec * DEF_TIME_NBR_mS_PER_SEC;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnRTO_CalcUpdate()
*
* Description : Update TCP connection's re-transmit timeout (RTO) control calculations.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnRTO_Init(),
* NetTCP_TxConnRTT_RTO_Calc().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnRTO_Init(),
* NetTCP_TxConnRTT_RTO_Calc().
*
* Note(s) : (1) A TCP connection's re-transmit timeout controls should NOT be updated until
* after the following TCP connection control(s) have been configured :
*
* (a) TCP connection's re-transmit timeout (in scaled milliseconds)
* ['TxRTT_RTO_ms_scaled']
*********************************************************************************************************
*/
static void NetTCP_TxConnRTO_CalcUpdate (NET_TCP_CONN *pconn)
{
pconn->TxRTT_RTO_ms = (NET_TCP_TIMEOUT_MS )(pconn->TxRTT_RTO_ms_scaled / NET_TCP_TX_RTT_SCALE);
pconn->TxRTT_RTO_sec = (NET_TCP_TIMEOUT_SEC)(pconn->TxRTT_RTO_ms_scaled / NET_TCP_TX_RTT_MS_SCALE);
pconn->TxRTT_RTO_tick = ((NET_TMR_TICK ) pconn->TxRTT_RTO_ms * NET_TMR_TIME_TICK_PER_SEC) / DEF_TIME_NBR_mS_PER_SEC;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnRTO_CalcBackOff()
*
* Description : Calculate next backed-off re-transmit timeout (RTO) value.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_TxConnRTT_RTO_Calc(),
* NetTCP_TxConnWinSizeZeroWinHandler().
*
* rto_ms Current re-transmit timeout value (in milliseconds).
*
* Return(s) : Backed-off re-transmit timeout value (in milliseconds).
*
* Caller(s) : NetTCP_TxConnRTT_RTO_Calc(),
* NetTCP_TxConnWinSizeZeroWinHandler().
*
* Note(s) : (1) (a) RFC #1122, Section 4.2.3.1 states that an "implementation MUST also include
* 'exponential backoff' for successive RTO values for the same segment".
*
* (1) RFC #2988, Section 5.5 states that "when the retransmission timer expires
* ... the host MUST set RTO <- RTO * 2 ('back off the timer')".
*
* Thus, the TCP retransmission timer exponential back-off scalar value is 2.
*
* (2) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 21.2, Page 299
* reiterates that "this doubling is called an 'exponential backoff'".
*
* (b) (1) RFC #2988, Section 2.4 adds that "a maximum value MAY be placed on RTO
* provided it is at least 60 seconds".
*
* (2) RFC #1122, Section 4.2.3.1 states that "the recommended ... RTO ... upper
* bound should be 2*MSL".
*
* (3) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 21.2, Page 299
* states that "the timeout value is doubled for each retransmission, with an
* upper limit of 64 seconds".
*
* See also 'NetTCP_TxConnRTO_CfgMaxTimeout() Note #1'.
*
* (2) RFC #1122, Section 4.2.2.17 states that "zero-window probe[s] ... SHOULD increase
* exponentially the interval between successive probes ... Exponential backoff is
* recommended ... similar to ... the retransmission algorithm, and it may be possible
* to combine the two procedures in the implementation".
*********************************************************************************************************
*/
static NET_TCP_TIMEOUT_MS NetTCP_TxConnRTO_CalcBackOff (NET_TCP_CONN *pconn,
NET_TCP_TIMEOUT_MS rto_ms)
{
NET_TCP_TIMEOUT_MS rto_ms_backoff_calcd;
NET_TCP_TIMEOUT_MS rto_ms_backoff;
/* Calc backed-off RTO timeout value (see Note #1a). */
rto_ms_backoff_calcd = (rto_ms < pconn->TxRTT_RTO_Max_ms)
? (rto_ms * NET_TCP_TX_RTO_TIMEOUT_BACKOFF_SCALAR)
: pconn->TxRTT_RTO_Max_ms;
/* Limit backed-off RTO timeout value (see Note #1b). */
rto_ms_backoff = DEF_MIN(rto_ms_backoff_calcd, pconn->TxRTT_RTO_Max_ms);
return (rto_ms_backoff);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnRTT_RTO_Init()
*
* Description : Initialize TCP connection's transmit round-trip time (RTT) & re-transmit timeout (RTO) values.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_ConnCfg().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_ConnCfg().
*
* Note(s) : (1) A TCP connection's re-transmit timeout controls should NOT be updated until
* after the following TCP connection control(s) have been configured :
*
* (a) TCP connection's maximum re-transmit timeout (in seconds) ['TxRTT_RTO_Max_sec']
* [see 'NetTCP_TxConnRTO_Init() Note #3']
*********************************************************************************************************
*/
static void NetTCP_TxConnRTT_RTO_Init (NET_TCP_CONN *pconn)
{
NetTCP_TxConnRTT_Init(pconn);
NetTCP_TxConnRTO_Init(pconn);
pconn->TxRTT_RTO_State = NET_TCP_TX_RTT_RTO_STATE_INIT;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxConnRTT_RTO_Calc()
*
* Description : (1) Calculate TCP connection's transmit round-trip time (RTT) & re-transmit timeout (RTO) values :
*
* (a) Perform requested RTT/RTO calculation operation(s)
* (b) Prepare & perform RTT calculations
* (c) Prepare & perform RTO calculations
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandlerReTxQ(),
* NetTCP_TxConnReTxQ(),
* NetTCP_TxConnTxQ_TimeoutIdle().
*
* calc_code Indicate which TCP connection's transmit round-trip time calculations to perform
* (see Note #1a) :
*
* NET_TCP_CONN_TX_RTT_INIT Initialize TCP connection's transmit
* round-trip time controls
* (see 'NetTCP_TxConnRTT_Init() Note #1'
* & 'NetTCP_TxConnRTO_Init() Note #2').
* NET_TCP_CONN_TX_RTT_RESET Reset TCP connection's transmit
* round-trip time controls.
*
* NET_TCP_CONN_TX_RTT_CALC Calculate & update TCP connection's transmit
* round-trip time controls.
*
* NET_TCP_CONN_TX_RTT_BACKOFF Back-off & update TCP connection's transmit
* round-trip time controls for a TCP re-
* transmit timeout.
*
* rtt_ts_txd_ms Round-trip timestamp when transmitted (in milliseconds).
*
* rtt_ts_rxd_ms Round-trip timestamp when received (in milliseconds).
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerReTxQ(),
* NetTCP_TxConnReTxQ(),
* NetTCP_TxConnTxQ_TimeoutIdle().
*$PAGE*
* Note(s) : (2) (a) (1) RFC #2988, Section 2 states that "the rules governing the computation of SRTT
* (smoothed round-trip time), RTTVAR RTTVAR (round-trip time variation), and RTO
* are as follows" :
*
* (A) RFC #2988, Section 2.2 states that for "the first RTT measurement R ...
* the host MUST set" :
*
* (1) SRTT <- R
* (2) RTTVAR <- R/2
* (3) RTO <- SRTT + max(G, K * RTTVAR)
*
* where
* SRTT RTT Smoothed Average
* RTTVAR RTT Variance/Deviation
* RTO Retransmission Timeout
* R RTT First Measurement
* (4) R = R * 1 RTT First Average Gain
* (5) R/2 = R * 1/2 RTT First Deviation Gain
* G RTT Clock Granularity (resolution)
* (6) K = 4 RTT-RTO Gain
*
*
* (B) RFC #2988, Section 2.3 states that for "subsequent RTT measurement R' ...
* a host MUST set" :
*
* (1) RTTVAR <- (1 - beta ) * RTTVAR + beta * |SRTT - R'|
* (2) SRTT <- (1 - alpha) * SRTT + alpha * R'
* (3) RTO <- SRTT + max(G, K * RTTVAR)
*
* where
* SRTT RTT Smoothed Average
* RTTVAR RTT Variance/Deviation
* RTO Retransmission Timeout
* R' RTT Subsequent Measurement(s)
* (4) alpha = 1/8 RTT-Average Gain
* (5) beta = 1/4 RTT-Deviation Gain
* G RTT Clock Granularity (resolution)
* (6) K = 4 RTT-RTO Gain
*
*
* (a) RFC #2988, Section 2.3 states tht "updating RTTVAR and SRTT MUST be
* computed in ... order ... [since] the value of SRTT used in the update
* to RTTVAR is its value before updating SRTT itself".
*
* (b) To reduce the total number of operations for both RTT calculations,
* the equations SHOULD be factored & rearranged as follows :
*
* (1) (A) RTTVAR <- (1 - beta) * RTTVAR + beta * |SRTT - R'|
*
* (B) RTTVAR <- RTTVAR - beta * RTTVAR + beta * |SRTT - R'|
*
* (C) RTTVAR <- RTTVAR + beta * (|SRTT - R'| - RTTVAR)
*
* (D) RTTVAR <- RTTVAR + beta * (|R' - SRTT| - RTTVAR)
*
*
* (2) (A) SRTT <- (1 - alpha) * SRTT + alpha * R'
*
* (B) SRTT <- SRTT - alpha * SRTT + alpha * R'
*
* (C) SRTT <- SRTT + alpha * (R' - SRTT)
*
*
* (2) (A) RFC #793, Section 3.7 'Data Communication : Retransmission Timeout' states
* that "the Round Trip Time (RTT) ... [is] the elapsed time between" :
*
* (1) "sending a data octet with a particular sequence number and" ...
* (2) "receiving an acknowledgment that covers that sequence number" ...
* (3) "(segments sent do not have to match segments received)".
*
* (B) (1) RFC #2988, Section 3 adds that :
*
* (a) "Traditionally, TCP implementations have taken one RTT measurement at
* a time (typically once per RTT)."
* (b) "A TCP implementation MUST take at least one RTT measurement per RTT
* (unless that is not possible per Karn's algorithm) [see Note #2a5]".
* (c) "For fairly modest congestion window sizes research suggests that
* timing each segment does not lead to a better RTT estimator."
* (d) "Additionally, when multiple samples are taken per RTT the alpha and
* beta ... may keep an inadequate RTT history."
*
* (2) RFC #2988, Section 1 states that "in some situations it may be beneficial
* for a TCP sender to be more conservative than the algorithms detailed in
* this document allow. However, a TCP MUST NOT be more aggressive than the
* ... algorithms allow".
*
* Thus, the following TCP algorithm(s) are permitted; even if the algorithms
* delay or decrease the number of received acknowledgements, which thereby
* increases the measured time values for RTT samples :
*
* (a) Karn's Algorithm See Note #2a5
* (b) TCP Delayed Acknowledgements See 'NetTCP_TxConnAck() Note #6'
*$PAGE*
* (3) Jacobson/Karels, "Congestion Avoidance and Control", Appendix A.2 states that RTT
* calculations "should be done in integer arithmetic". RFC #2988, Section 2.3 adds
* that RTT calculations "SHOULD be computed using ... 1/8 and ... 1/4" gains (see
* Notes #2a1B4 & #2a1B5).
*
* (4) (A) RFC #2988, Section 5 states "that a TCP implementation MAY clear SRTT and
* RTTVAR after backing off the timer multiple times as it is likely that the
* current SRTT and RTTVAR are bogus in this situation. Once SRTT and RTTVAR
* are cleared they should be initialized with the next RTT sample taken per
* [Note #2a1A] rather than using [Note #2a1B]".
*
* (B) RFC #2581, Section 4.1 states that "after TCP has been idle for ... an
* interval exceeding the retransmission timeout ... use slow start to
* restart transmission".
*
* Similarly, although NO RFC specifies that a TCP connection's RTT average &
* deviation should be reset following a TCP transmit idle timeout; it seems
* reasonable to reset a TCP connection's RTT average & deviation controls
* whenever a TCP connection's transmit is idle for a period exceeding the
* re-transmit timeout.
*
* See also 'NetTCP_TxConnTxQ_TimeoutIdle() Note #2a'.
*
* (5) RFC #2988, Section 3 states that "TCP MUST use Karn's algorithm ... for
* taking RTT samples. That is, RTT samples MUST NOT be made using segments
* that were retransmitted (and thus for which it is ambiguous whether the reply
* was for the first instance of the packet or a later instance)".
*
* (b) (1) (A) (1) RFC #2988, Section 2.4 states that "whenever RTO is computed, if it
* is less than 1 second then the RTO SHOULD be rounded up to 1 second".
*
* (a) This amends RFC #1122, Section 4.2.3.1 which previously stated
* that "the recommended ... RTO ... lower bound ... SHOULD be
* measured in fractions of a second".
*
* (2) RFC #2988, Section 4 states that "there is no requirement for the
* clock granularity G used for computing RTT measurements ... However,
* if the K*RTTVAR term in the RTO calculation equals zero, the variance
* term MUST be rounded to G seconds".
*
* See also Notes #2a1A3 & #2a1B3.
*
* (B) (1) RFC #2988, Section 2.4 adds that "a maximum value MAY be placed on
* RTO provided it is at least 60 seconds".
*
* (2) RFC #1122, Section 4.2.3.1 states that "the recommended ... RTO ...
* upper bound should be 2*MSL".
*
* (3) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 21.2,
* Page 299 states that "the timeout value ... [has] an upper limit of
* 64 seconds".
*
* See also 'net_tcp.c NetTCP_TxConnRTO_CfgMaxTimeout() Note #1'.
*
* (2) RFC #1122, Section 4.2.3.1 reiterates that an "implementation MUST also
* include 'exponential backoff' for successive RTO values for the same
* segment".
*
* (a) RFC #2988, Section 5.5 states that "when the retransmission timer
* expires ... the host MUST set RTO <- RTO * 2 ('back off the timer')".
*
* Thus, the TCP retransmission timer exponential back-off scalar
* value is 2.
*
* (b) Stevens, TCP/IP Illustrated, Volume 1, 8th Printing, Section 21.2,
* Page 299 reiterates that "this doubling is called an 'exponential
* backoff'".
*
* See also 'NetTCP_TxConnRTO_CalcBackOff() Note #1'.
*********************************************************************************************************
*/
static void NetTCP_TxConnRTT_RTO_Calc (NET_TCP_CONN *pconn,
NET_TCP_CALC_CODE calc_code,
NET_TCP_TX_RTT_TS_MS rtt_ts_txd_ms,
NET_TCP_TX_RTT_TS_MS rtt_ts_rxd_ms)
{
NET_TCP_TIMEOUT_MS timeout_ms;
NET_TMR_TICK timeout_tick;
NET_TCP_TX_RTT_MS rtt_cur_ms;
NET_TCP_TX_RTT_MS_SCALED rtt_cur_ms_scaled;
NET_TCP_TX_RTT_MS_SCALED rtt_err_ms_scaled;
NET_TCP_TX_RTT_MS_SCALED rtt_err_ms_scaled_abs;
NET_TCP_TX_RTT_MS_SCALED rtt_avg_ms_scaled;
NET_TCP_TX_RTT_MS_SCALED rtt_dev_ms_scaled;
NET_TCP_TX_RTT_MS_SCALED rtt_dev_ms_scaled_gain;
NET_TCP_TX_RTT_MS_SCALED rtt_dev_ms_scaled_min;
NET_TCP_TX_RTT_MS_SCALED rto_ms_scaled;
/*$PAGE*/
/* -------------- PERFORM CALC CODE --------------- */
switch (calc_code) {
case NET_TCP_CONN_TX_RTT_CALC:
break;
case NET_TCP_CONN_TX_RTT_BACKOFF: /* Back-off RTO (see Note #2b2). */
timeout_ms = (NET_TCP_TIMEOUT_MS ) NetTCP_TxConnRTO_CalcBackOff(pconn, pconn->TxRTT_RTO_ms);
timeout_tick = ((NET_TMR_TICK ) timeout_ms * NET_TMR_TIME_TICK_PER_SEC) / DEF_TIME_NBR_mS_PER_SEC;
pconn->TxRTT_RTO_ms = (NET_TCP_TIMEOUT_MS ) timeout_ms;
pconn->TxRTT_RTO_sec = (NET_TCP_TIMEOUT_SEC)(timeout_ms / DEF_TIME_NBR_mS_PER_SEC);
pconn->TxRTT_RTO_tick = (NET_TMR_TICK ) timeout_tick;
/* 'break' intentionally omitted; do NOT move from */
/* ... following case : 'NET_TCP_CONN_TX_RTT_RESET'.*/
case NET_TCP_CONN_TX_RTT_RESET: /* See Note #2a4. */
NetTCP_TxConnRTT_Reset(pconn);
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_TCP_CONN_TX_RTT_INIT:
default:
NetTCP_TxConnRTT_RTO_Init(pconn);
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* -------------- PREPARE RTT CALCS --------------- */
switch (pconn->TxRTT_RTO_State) {
case NET_TCP_TX_RTT_RTO_STATE_INIT:
case NET_TCP_TX_RTT_RTO_STATE_RESET:
case NET_TCP_TX_RTT_RTO_STATE_CALC:
rtt_cur_ms = (NET_TCP_TX_RTT_MS )(rtt_ts_rxd_ms - rtt_ts_txd_ms);
rtt_cur_ms_scaled = (NET_TCP_TX_RTT_MS_SCALED)(rtt_cur_ms * NET_TCP_TX_RTT_SCALE);
break;
case NET_TCP_TX_RTT_RTO_STATE_NONE:
case NET_TCP_TX_RTT_RTO_STATE_RE_TX: /* See Note #2a5. */
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* -------------- PERFORM RTT CALCS --------------- */
switch (pconn->TxRTT_RTO_State) {
case NET_TCP_TX_RTT_RTO_STATE_INIT: /* Init RTT calcs (see Notes #2a1A1 & #2a1A2). */
case NET_TCP_TX_RTT_RTO_STATE_RESET:
rtt_avg_ms_scaled = (rtt_cur_ms_scaled * NET_TCP_TX_RTT_GAIN_AVG_INIT_NUMER)
/ NET_TCP_TX_RTT_GAIN_AVG_INIT_DENOM;
rtt_dev_ms_scaled = (rtt_cur_ms_scaled * NET_TCP_TX_RTT_GAIN_DEV_INIT_NUMER)
/ NET_TCP_TX_RTT_GAIN_DEV_INIT_DENOM;
pconn->TxRTT_RTO_State = NET_TCP_TX_RTT_RTO_STATE_CALC;
break;
case NET_TCP_TX_RTT_RTO_STATE_CALC: /* Update RTT calcs (see Notes #2a1Bb1D & #2a1Bb2C).*/
rtt_err_ms_scaled = rtt_cur_ms_scaled - pconn->TxRTT_Avg_ms_scaled;
rtt_err_ms_scaled_abs = DEF_ABS(rtt_err_ms_scaled);
rtt_dev_ms_scaled = pconn->TxRTT_Dev_ms_scaled + (((rtt_err_ms_scaled_abs - pconn->TxRTT_Dev_ms_scaled) * NET_TCP_TX_RTT_GAIN_DEV_NUMER)
/ NET_TCP_TX_RTT_GAIN_DEV_DENOM);
rtt_avg_ms_scaled = pconn->TxRTT_Avg_ms_scaled + ((rtt_err_ms_scaled * NET_TCP_TX_RTT_GAIN_AVG_NUMER)
/ NET_TCP_TX_RTT_GAIN_AVG_DENOM);
break;
case NET_TCP_TX_RTT_RTO_STATE_NONE:
case NET_TCP_TX_RTT_RTO_STATE_RE_TX: /* See Note #2a5. */
default:
return; /* Prevent 'break NOT reachable' compiler warning. */
}
/* ------------------ UPDATE RTT ------------------ */
pconn->TxRTT_Avg_ms_scaled = rtt_avg_ms_scaled;
pconn->TxRTT_Dev_ms_scaled = rtt_dev_ms_scaled;
NetTCP_TxConnRTT_CalcUpdate(pconn);
/*$PAGE*/
/* ------------------- CALC RTO ------------------- */
/* Calc RTO (see Note #2a1B3). */
rtt_dev_ms_scaled_gain = (pconn->TxRTT_Dev_ms_scaled * NET_TCP_TX_RTT_GAIN_RTO_NUMER)
/ NET_TCP_TX_RTT_GAIN_RTO_DENOM;
/* Limit RTT dev (see Note #2b1A2). */
rtt_dev_ms_scaled_min = DEF_MAX(NET_TCP_TX_RTT_TS_CLK_MS_SCALED,
rtt_dev_ms_scaled_gain);
rto_ms_scaled = pconn->TxRTT_Avg_ms_scaled + rtt_dev_ms_scaled_min;
/* Limit RTO (see Note #2b1). */
if (rto_ms_scaled < NET_TCP_TX_RTO_MIN_TIMEOUT_MS_SCALED) {
rto_ms_scaled = NET_TCP_TX_RTO_MIN_TIMEOUT_MS_SCALED;
}
if (rto_ms_scaled > pconn->TxRTT_RTO_Max_ms_scaled) {
rto_ms_scaled = pconn->TxRTT_RTO_Max_ms_scaled;
}
/* ------------------ UPDATE RTO ------------------ */
pconn->TxRTT_RTO_ms_scaled = rto_ms_scaled;
NetTCP_TxConnRTO_CalcUpdate(pconn);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxPktHandler()
*
* Description : (1) Prepare & transmit TCP packets :
*
* (a) Validate transmit packet
* (b) Transmit TCP packet
* (c) Free transmit packet buffer(s)
* (d) Update transmit statistics
*
*
* Argument(s) : pbuf Pointer to network buffer to transmit TCP packet.
*
* src_addr Source IP address.
*
* src_port Source TCP port.
*
* dest_addr Destination IP address.
*
* dest_port Destination TCP port.
*
* seq_nbr TCP segment sequence number.
*
* ack_nbr TCP segment acknowledgement sequence number.
*
* win_size TCP receive window advertisement size.
*
* TOS Specific TOS to transmit TCP/IP packet
* (see 'net_ip.h IP HEADER TYPE OF SERVICE (TOS) DEFINES').
*
* TTL Specific TTL to transmit TCP/IP packet (see RFC #1122, Section 3.2.1.7) :
*
* NET_IP_HDR_TTL_MIN 1 minimum TTL transmit value
* NET_IP_HDR_TTL_MAX 255 maximum TTL transmit value
* NET_IP_HDR_TTL_DFLT default TTL transmit value
* NET_IP_HDR_TTL_NONE 0 replace with default TTL
*
* flags_tcp Flags to select TCP transmit options; bit-field flags logically OR'd :
*
* NET_TCP_FLAG_NONE No TCP transmit flags selected.
* NET_TCP_FLAG_TX_FIN Set TCP 'FIN' flag.
* NET_TCP_FLAG_TX_SYNC Set TCP 'SYN' flag.
* NET_TCP_FLAG_TX_RESET Set TCP 'RESET' flag.
* NET_TCP_FLAG_TX_PUSH Set TCP 'PUSH' flag.
* NET_TCP_FLAG_TX_ACK Set TCP 'ACK' flag.
* NET_TCP_FLAG_TX_URGENT Set TCP 'URGENT' flag.
*
* flags_ip Flags to select IP transmit options; bit-field flags logically OR'd :
*
* NET_IP_FLAG_NONE No IP transmit flags selected.
* NET_IP_FLAG_TX_DONT_FRAG Set IP 'Don't Frag' flag.
*
* popts_tcp Pointer to one or more TCP options configuration data structures :
*
* NULL NO TCP transmit options configuration.
* NET_TCP_OPT_CFG_MAX_SEG_SIZE TCP Maximum Segment Size options configuration.
*
* popts_ip Pointer to one or more IP options configuration data structures :
*
* NULL NO IP transmit options configuration.
* NET_IP_OPT_CFG_ROUTE_TS Route &/or Internet Timestamp options configuration.
* NET_IP_OPT_CFG_SECURITY Security options configuration
* (see 'net_ip.c Note #1f').
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP segments(s) successfully prepared & transmitted
* to IP layer.
* NET_TCP_ERR_TX TCP transmit error; TCP segment buffer(s) discarded.
*
* ----------- RETURNED BY NetTCP_TxPkt() : -----------
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_ERR_TX Transmit error.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnSync(),
* NetTCP_TxConnAck(),
* NetTCP_TxConnReset(),
* NetTCP_TxConnProbe(),
* NetTCP_TxConnTxQ(),
* NetTCP_TxConnReTxQ_Timeout().
*
* Note(s) : (2) Network buffer already freed by lower layer; only increment error counter.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxPktHandler (NET_BUF *pbuf,
NET_IP_ADDR src_addr,
NET_TCP_PORT_NBR src_port,
NET_IP_ADDR dest_addr,
NET_TCP_PORT_NBR dest_port,
NET_TCP_SEQ_NBR seq_nbr,
NET_TCP_SEQ_NBR ack_nbr,
NET_TCP_WIN_SIZE win_size,
NET_IP_TOS TOS,
NET_IP_TTL TTL,
CPU_INT16U flags_tcp,
CPU_INT16U flags_ip,
void *popts_tcp,
void *popts_ip,
NET_ERR *perr)
{
#if (((NET_CTR_CFG_STAT_EN == DEF_ENABLED) || \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED)) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_BUF_HDR *pbuf_hdr;
NET_ERR err;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ------------------- VALIDATE PTR ------------------- */
if (pbuf == (NET_BUF *)0) {
NetTCP_TxPktDiscard(pbuf, perr);
NET_CTR_ERR_INC(NetTCP_ErrNullPtrCtr);
return;
}
#endif
/* --------------- VALIDATE TX TCP PKT ---------------- */
pbuf_hdr = &pbuf->Hdr;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
NetTCP_TxPktValidate(pbuf,
pbuf_hdr,
src_port,
dest_port,
seq_nbr,
ack_nbr,
win_size,
flags_tcp,
popts_tcp,
perr);
switch (*perr) {
case NET_TCP_ERR_NONE:
break;
case NET_ERR_INVALID_PROTOCOL:
case NET_BUF_ERR_INVALID_IX:
case NET_TCP_ERR_INVALID_LEN_DATA:
case NET_TCP_ERR_INVALID_PORT_NBR:
case NET_TCP_ERR_INVALID_FLAG:
case NET_TCP_ERR_INVALID_OPT_TYPE:
case NET_TCP_ERR_INVALID_OPT_CFG:
default:
NetTCP_TxPktDiscard(pbuf, &err);
*perr = NET_TCP_ERR_TX;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
#endif
/*$PAGE*/
/* -------------------- TX TCP PKT -------------------- */
NetTCP_TxPkt(pbuf,
pbuf_hdr,
src_addr,
src_port,
dest_addr,
dest_port,
seq_nbr,
ack_nbr,
win_size,
TOS,
TTL,
flags_tcp,
flags_ip,
popts_tcp,
popts_ip,
perr);
/* ---------- FREE TX PKT / UPDATE TX STATS ----------- */
switch (*perr) {
case NET_IP_ERR_NONE:
NET_CTR_STAT_INC(NetTCP_StatTxSegCtr);
*perr = NET_TCP_ERR_NONE;
break;
case NET_ERR_TX:
NET_CTR_ERR_INC(NetTCP_ErrTxPktDiscardedCtr); /* See Note #2. */
return; /* Prevent 'break NOT reachable' compiler warning. */
case NET_ERR_INIT_INCOMPLETE:
case NET_TCP_ERR_INVALID_LEN_HDR:
case NET_TCP_ERR_INVALID_OPT_TYPE:
case NET_TCP_ERR_INVALID_OPT_LEN:
case NET_BUF_ERR_INVALID_IX:
case NET_BUF_ERR_INVALID_LEN:
case NET_UTIL_ERR_NULL_PTR:
case NET_UTIL_ERR_NULL_SIZE:
case NET_UTIL_ERR_INVALID_PROTOCOL:
default:
NetTCP_TxPktDiscard(pbuf, &err);
*perr = NET_TCP_ERR_TX;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxPktValidate()
*
* Description : (1) Validate TCP transmit packet parameters & options :
*
* (a) Packets with the following invalid parameters will be "silently discarded" :
*
* (1) Protocols other than supported protocols :
* (A) BSD Sockets
* (B) TCP See Note #2
*
* (2) Data Length
* (3) Source Port
* (4) Destination Port
* (5) Flags
*
* (b) The following parameters are inherently assumed to be valid :
*
* (1) Sequence Number
* (2) Acknowledgement Number
* (3) Receive Window Size
*
*
* Argument(s) : pbuf Pointer to network buffer to transmit TCP packet.
* ---- Argument checked in NetTCP_TxPktHandler().
*
* pbuf_hdr Pointer to network buffer header.
* -------- Argument validated in NetTCP_TxPktHandler().
*
* src_port Source TCP port.
*
* dest_port Destination TCP port.
*
* seq_nbr TCP segment sequence number.
*
* ack_nbr TCP segment acknowledgement sequence number.
*
* win_size TCP receive window advertisement size.
*
* flags_tcp Flags to select TCP transmit options; bit-field flags logically OR'd :
*
* NET_TCP_FLAG_NONE No TCP transmit flags selected.
* NET_TCP_FLAG_TX_FIN Set TCP 'FIN' flag.
* NET_TCP_FLAG_TX_SYNC Set TCP 'SYN' flag.
* NET_TCP_FLAG_TX_RESET Set TCP 'RESET' flag.
* NET_TCP_FLAG_TX_PUSH Set TCP 'PUSH' flag.
* NET_TCP_FLAG_TX_ACK Set TCP 'ACK' flag.
* NET_TCP_FLAG_TX_URGENT Set TCP 'URGENT' flag.
*
* popts_tcp Pointer to one or more TCP options configuration data structures :
*
* NULL NO TCP transmit options configuration.
* NET_TCP_OPT_CFG_MAX_SEG_SIZE TCP Maximum Segment Size options configuration.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE Transmit packet validated.
* NET_ERR_INVALID_PROTOCOL Invalid/unknown protocol type.
* NET_BUF_ERR_INVALID_IX Invalid or insufficient buffer index.
* NET_TCP_ERR_INVALID_LEN_DATA Invalid protocol/data length.
* NET_TCP_ERR_INVALID_PORT_NBR Invalid TCP port number.
* NET_TCP_ERR_INVALID_FLAG Invalid TCP flag(s).
*
* - RETURNED BY NetTCP_TxPktValidateOpt() : -
* NET_TCP_ERR_INVALID_OPT_TYPE Invalid TCP option type.
* NET_TCP_ERR_INVALID_OPT_CFG Invalid TCP option configuration.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxPktHandler().
*
* Note(s) : none.
*********************************************************************************************************
*/
/*$PAGE*/
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
static void NetTCP_TxPktValidate (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_TCP_PORT_NBR src_port,
NET_TCP_PORT_NBR dest_port,
NET_TCP_SEQ_NBR seq_nbr,
NET_TCP_SEQ_NBR ack_nbr,
NET_TCP_WIN_SIZE win_size,
CPU_INT16U flags_tcp,
void *popts_tcp,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
CPU_INT16U ix;
CPU_INT16U len;
CPU_INT16U flag_mask;
CPU_BOOLEAN flags_tcp_fin_syn;
/* ----------------- VALIDATE PROTOCOL ---------------- */
switch (pbuf_hdr->ProtocolHdrType) {
case NET_PROTOCOL_TYPE_APP:
case NET_PROTOCOL_TYPE_SOCK:
case NET_PROTOCOL_TYPE_TCP:
ix = (CPU_INT16U)pbuf_hdr->DataIx;
len = (CPU_INT16U)pbuf_hdr->DataLen;
break;
case NET_PROTOCOL_TYPE_NONE:
default:
NET_CTR_ERR_INC(NetTCP_ErrTxInvalidProtocolCtr);
*perr = NET_ERR_INVALID_PROTOCOL;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
if (ix == NET_BUF_IX_NONE) {
NET_CTR_ERR_INC(NetTCP_ErrTxInvalidBufIxCtr);
*perr = NET_BUF_ERR_INVALID_IX;
return;
}
if (ix < NET_TCP_HDR_SIZE_MAX) {
NET_CTR_ERR_INC(NetTCP_ErrTxInvalidBufIxCtr);
*perr = NET_BUF_ERR_INVALID_IX;
return;
}
/* -------------- VALIDATE TOT DATA LEN --------------- */
if (len != pbuf_hdr->TotLen) {
NET_CTR_ERR_INC(NetTCP_ErrTxHdrDataLenCtr);
*perr = NET_TCP_ERR_INVALID_LEN_DATA;
return;
}
/* ---------------- VALIDATE TCP PORTS ---------------- */
if (src_port == NET_TCP_PORT_NBR_RESERVED) {
NET_CTR_ERR_INC(NetTCP_ErrTxHdrPortSrcCtr);
*perr = NET_TCP_ERR_INVALID_PORT_NBR;
return;
}
if (dest_port == NET_TCP_PORT_NBR_RESERVED) {
NET_CTR_ERR_INC(NetTCP_ErrTxHdrPortDestCtr);
*perr = NET_TCP_ERR_INVALID_PORT_NBR;
return;
}
/*$PAGE*/
/* ---------------- VALIDATE TCP FLAGS ---------------- */
flag_mask = NET_TCP_FLAG_NONE |
NET_TCP_FLAG_TX_CLOSE |
NET_TCP_FLAG_TX_SYNC |
NET_TCP_FLAG_TX_RESET |
NET_TCP_FLAG_TX_PUSH |
NET_TCP_FLAG_TX_ACK |
NET_TCP_FLAG_TX_URGENT;
if ((flags_tcp & ~flag_mask) != NET_TCP_FLAG_NONE) { /* If any invalid flags req'd, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrTxHdrFlagsCtr);
*perr = NET_TCP_ERR_INVALID_FLAG;
return;
}
#if 1 /* ???? Allow invalid 'SYN'/'FIN' flag combo? */
flag_mask = NET_TCP_FLAG_TX_SYNC |
NET_TCP_FLAG_TX_FIN;
flags_tcp_fin_syn = DEF_BIT_IS_SET(flags_tcp, flag_mask);
if (flags_tcp_fin_syn != DEF_NO) { /* If invalid 'SYN'/'FIN' flag combo req'd, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrTxHdrFlagsCtr);
*perr = NET_TCP_ERR_INVALID_FLAG;
return;
}
#endif
/* ---------------- VALIDATE TCP OPTS ----------------- */
if (popts_tcp != (void *)0) {
NetTCP_TxPktValidateOpt(popts_tcp, flags_tcp, perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
}
/* ------------- IGNORE VALID TCP FIELDS -------------- */
(void)&seq_nbr; /* Prevent compiler warnings. */
(void)&ack_nbr;
(void)&win_size;
*perr = NET_TCP_ERR_NONE;
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxPktValidateOpt()
*
* Description : Validate TCP transmit option configurations.
*
* (1) TCP transmit options MUST be configured by appropriate transmit options configuration
* data structure(s) passed via 'popts_tcp'; see 'net_tcp.h TCP HEADER OPTION CONFIGURATION
* DATA TYPES' for TCP options configuration.
*
* (2) TCP header allows for a maximum option size of 40 octets (see 'net_tcp.h TCP HEADER
* OPTIONS DEFINES Note #3').
*
*
* Argument(s) : popts_tcp Pointer to one or more TCP options configuration data structures (see Note #1) :
*
* NULL NO TCP transmit options configuration.
* NET_TCP_OPT_CFG_MAX_SEG_SIZE TCP Maximum Segment Size options configuration.
*
* flags_tcp Flags to select TCP transmit options; bit-field flags logically OR'd :
*
* NET_TCP_FLAG_NONE No TCP transmit flags selected.
* NET_TCP_FLAG_TX_FIN Set TCP 'FIN' flag.
* NET_TCP_FLAG_TX_SYNC Set TCP 'SYN' flag.
* NET_TCP_FLAG_TX_RESET Set TCP 'RESET' flag.
* NET_TCP_FLAG_TX_PUSH Set TCP 'PUSH' flag.
* NET_TCP_FLAG_TX_ACK Set TCP 'ACK' flag.
* NET_TCP_FLAG_TX_URGENT Set TCP 'URGENT' flag.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP transmit option configurations validated.
* NET_TCP_ERR_INVALID_OPT_TYPE Invalid TCP option type.
* NET_TCP_ERR_INVALID_OPT_CFG Invalid TCP option configuration.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxPktValidate().
*
* Note(s) : (3) (a) See 'net_tcp.h TCP HEADER OPTIONS DEFINES' for supported TCP options' summary.
*
* (b) See 'net_tcp.c Note #1c' for unsupported TCP options.
*
* (4) The following TCP transmit options MUST be configured exclusively--i.e. only a single
* of each of the following TCP options may be configured for any one TCP segment :
*
* (a) NET_TCP_OPT_CFG_TYPE_MAX_SEG_SIZE
*********************************************************************************************************
*/
/*$PAGE*/
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
static void NetTCP_TxPktValidateOpt (void *popts_tcp,
CPU_INT16U flags_tcp,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
CPU_INT08U opt_len_size;
CPU_INT08U opt_len;
CPU_INT08U opt_nbr_max_seg_size;
NET_TYPE *popt_cfg_type;
void *popt_cfg;
void *popt_next;
opt_len_size = 0;
opt_nbr_max_seg_size = 0;
popt_cfg = popts_tcp;
while (popt_cfg != (void *)0) {
popt_cfg_type = (NET_TYPE *)popt_cfg;
switch (*popt_cfg_type) {
case NET_TCP_OPT_CFG_TYPE_MAX_SEG_SIZE: /* ----------------- MAX SEG SIZE OPT ----------------- */
if (opt_nbr_max_seg_size > 0) { /* If > 1 max seg size opt, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrTxHdrOptCfgCtr);
*perr = NET_TCP_ERR_INVALID_OPT_CFG;
return;
}
opt_nbr_max_seg_size++;
NetTCP_TxPktValidateOptMaxSegSize(popt_cfg, &opt_len, &popt_next, flags_tcp, perr);
break;
#if 0 /* --------------- UNSUPPORTED TCP OPTS --------------- */
/* See Note #3b. */
case NET_TCP_OPT_CFG_TYPE_WIN_SCALE:
case NET_TCP_OPT_CFG_TYPE_SACK_PERMIT:
case NET_TCP_OPT_CFG_TYPE_SACK:
case NET_TCP_OPT_CFG_TYPE_ECHO_REQ:
case NET_TCP_OPT_CFG_TYPE_ECHO_REPLY:
case NET_TCP_OPT_CFG_TYPE_TS:
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_OPT_CFG_TYPE_NONE'. */
#endif
case NET_TCP_OPT_CFG_TYPE_NONE: /* ----------------- INVALID TCP OPTS ----------------- */
default:
NET_CTR_ERR_INC(NetTCP_ErrTxOptTypeCtr);
*perr = NET_TCP_ERR_INVALID_OPT_TYPE;
return; /* Prevent 'break NOT reachable' compiler warning. */
}
if (*perr != NET_TCP_ERR_NONE) {
return;
}
opt_len_size += opt_len;
if (opt_len_size > NET_TCP_HDR_OPT_SIZE_MAX) { /* If tot opt len exceeds max opt len, rtn err. */
NET_CTR_ERR_INC(NetTCP_ErrTxHdrOptLenCtr);
*perr = NET_TCP_ERR_INVALID_OPT_LEN;
return;
}
popt_cfg = popt_next; /* Validate next cfg opt. */
}
*perr = NET_TCP_ERR_NONE;
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxPktValidateOptMaxSegSize()
*
* Description : Validate TCP Maximum Segment Size option configuration.
*
* (1) See 'net_tcp.h TCP MAXIMUM SEGMENT SIZE OPTION CONFIGURATION DATA TYPE' for valid
* TCP Maximum Segment Size option configuration.
*
* (2) Return option values.
*
*
* Argument(s) : popt_tcp Pointer to TCP Maximum Segment Size option configuration data structure.
* -------- Argument checked in NetTCP_TxPktValidateOpt().
*
* popt_len Pointer to variable that will receive the TCP Maximum Segment Size option length
* -------- (in octets).
*
* Argument validated in NetTCP_TxPktValidateOpt().
*
* popt_next Pointer to variable that will receive the pointer to the next TCP transmit option.
* --------- Argument validated in NetTCP_TxPktValidateOpt().
*
* flags_tcp Flags to select TCP transmit options; bit-field flags logically OR'd :
*
* NET_TCP_FLAG_NONE No TCP transmit flags selected.
* NET_TCP_FLAG_TX_FIN Set TCP 'FIN' flag.
* NET_TCP_FLAG_TX_SYNC Set TCP 'SYN' flag.
* NET_TCP_FLAG_TX_RESET Set TCP 'RESET' flag.
* NET_TCP_FLAG_TX_PUSH Set TCP 'PUSH' flag.
* NET_TCP_FLAG_TX_ACK Set TCP 'ACK' flag.
* NET_TCP_FLAG_TX_URGENT Set TCP 'URGENT' flag.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP Maximum Segment Size option
* configuration validated.
* NET_TCP_ERR_INVALID_OPT_TYPE Invalid TCP option type.
* NET_TCP_ERR_INVALID_OPT_CFG Invalid TCP option configuration.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxPktValidateOpt().
*
* Note(s) : (3) RFC #793, Section 3.1 'Header Format : Options : Maximum Segment Size' states that a
* TCP Maximum Segment Size option "must only be sent in the initial connection request
* (i.e., in segments with the SYN control bit set)".
*********************************************************************************************************
*/
/*$PAGE*/
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
static void NetTCP_TxPktValidateOptMaxSegSize (void *popt_tcp,
CPU_INT08U *popt_len,
void **popt_next,
CPU_INT16U flags_tcp,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_OPT_CFG_MAX_SEG_SIZE *popt_cfg_max_seg_size;
CPU_BOOLEAN flags_tcp_syn;
popt_cfg_max_seg_size = (NET_TCP_OPT_CFG_MAX_SEG_SIZE *)popt_tcp;
/* ------------------ VALIDATE TYPE ------------------- */
if (popt_cfg_max_seg_size->Type != NET_TCP_OPT_CFG_TYPE_MAX_SEG_SIZE) {
NET_CTR_ERR_INC(NetTCP_ErrTxOptTypeCtr);
*perr = NET_TCP_ERR_INVALID_OPT_TYPE;
return;
}
/* -------------- VALIDATE MAX SEG SIZE --------------- */
/* If max seg size > max, rtn err. */
if (popt_cfg_max_seg_size->MaxSegSize > NET_TCP_MAX_SEG_SIZE_MAX) {
NET_CTR_ERR_INC(NetTCP_ErrTxHdrOptCfgCtr);
*perr = NET_TCP_ERR_INVALID_OPT_CFG;
return;
}
/* -------------- VALIDATE OPT CFG/CTRL --------------- */
flags_tcp_syn = DEF_BIT_IS_SET(flags_tcp, NET_TCP_HDR_FLAG_SYNC);
if (flags_tcp_syn != DEF_YES) { /* If 'SYN' bit NOT set, rtn err (see Note #3). */
NET_CTR_ERR_INC(NetTCP_ErrTxHdrOptCfgCtr);
*perr = NET_TCP_ERR_INVALID_OPT_CFG;
return;
}
/* ------------------- RTN OPT VALS ------------------- */
*popt_len = NET_TCP_HDR_OPT_LEN_MAX_SEG_SIZE;
*popt_next = popt_cfg_max_seg_size->NextOptPtr;
*perr = NET_TCP_ERR_NONE;
}
#endif
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxPkt()
*
* Description : (1) Prepare TCP header & transmit TCP packet to IP layer :
*
* (a) Prepare TCP options (if any)
* (b) Calculate TCP header buffer controls
* (c) Prepare TCP header
* (d) Transmit TCP packet
*
*
* Argument(s) : pbuf Pointer to network buffer to transmit TCP packet.
* ---- Argument checked in NetTCP_TxPktHandler().
*
* pbuf_hdr Pointer to network buffer header.
* -------- Argument validated in NetTCP_TxPktHandler().
*
* src_addr Source IP address.
*
* src_port Source TCP port.
* -------- Argument checked in NetTCP_TxPktValidate().
*
* dest_addr Destination IP address.
*
* dest_port Destination TCP port.
* --------- Argument checked in NetTCP_TxPktValidate().
*
* seq_nbr TCP segment sequence number.
* ------- Argument validated in NetTCP_TxPktValidate().
*
* ack_nbr TCP segment acknowledgement sequence number.
* ------- Argument validated in NetTCP_TxPktValidate().
*
* win_size TCP receive window advertisement size.
* -------- Argument validated in NetTCP_TxPktValidate().
*
* TOS Specific TOS to transmit TCP/IP packet
* (see 'net_ip.h IP HEADER TYPE OF SERVICE (TOS) DEFINES').
*
* TTL Specific TTL to transmit TCP/IP packet (see RFC #1122, Section 3.2.1.7) :
*
* NET_IP_HDR_TTL_MIN 1 minimum TTL transmit value
* NET_IP_HDR_TTL_MAX 255 maximum TTL transmit value
* NET_IP_HDR_TTL_DFLT default TTL transmit value
* NET_IP_HDR_TTL_NONE 0 replace with default TTL
*
* flags_tcp Flags to select TCP transmit options; bit-field flags logically OR'd :
* ---------
* NET_TCP_FLAG_NONE No TCP transmit flags selected.
* NET_TCP_FLAG_TX_FIN Set TCP 'FIN' flag.
* NET_TCP_FLAG_TX_SYNC Set TCP 'SYN' flag.
* NET_TCP_FLAG_TX_RESET Set TCP 'RESET' flag.
* NET_TCP_FLAG_TX_PUSH Set TCP 'PUSH' flag.
* NET_TCP_FLAG_TX_ACK Set TCP 'ACK' flag.
* NET_TCP_FLAG_TX_URGENT Set TCP 'URGENT' flag.
*
* Argument checked in NetTCP_TxPktValidate().
*
* flags_ip Flags to select IP transmit options; bit-field flags logically OR'd :
*
* NET_IP_FLAG_NONE No IP transmit flags selected.
* NET_IP_FLAG_TX_DONT_FRAG Set IP 'Don't Frag' flag.
*
* popts_tcp Pointer to one or more TCP options configuration data structures :
* ---------
* NULL NO TCP transmit options configuration.
* NET_TCP_OPT_CFG_MAX_SEG_SIZE TCP Maximum Segment Size options configuration.
*
* Argument checked in NetTCP_TxPktValidate().
*$PAGE*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_INVALID_LEN_HDR Invalid TCP header length.
*
* - RETURNED BY NetTCP_TxPktPrepareOpt() : -
* NET_TCP_ERR_INVALID_OPT_TYPE Invalid TCP option type.
* NET_TCP_ERR_INVALID_OPT_LEN Invalid TCP option length.
*
* - RETURNED BY NetTCP_TxPktPrepareHdr() : -
* NET_BUF_ERR_INVALID_IX Invalid/insufficient buffer index.
* NET_BUF_ERR_INVALID_LEN Invalid buffer length.
* NET_UTIL_ERR_NULL_PTR Check-sum passed a NULL pointer.
* NET_UTIL_ERR_NULL_SIZE Check-sum passed a zero size.
* NET_UTIL_ERR_INVALID_PROTOCOL Invalid data packet protocol.
*
* -------- RETURNED BY NetIP_Tx() : --------
* NET_IP_ERR_NONE TCP/IP packet successfully transmitted.
* NET_ERR_INIT_INCOMPLETE Network initialization NOT complete.
* NET_ERR_TX Transmit error.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxPktHandler().
*
* Note(s) : none.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxPkt (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
NET_IP_ADDR src_addr,
NET_TCP_PORT_NBR src_port,
NET_IP_ADDR dest_addr,
NET_TCP_PORT_NBR dest_port,
NET_TCP_SEQ_NBR seq_nbr,
NET_TCP_SEQ_NBR ack_nbr,
NET_TCP_WIN_SIZE win_size,
NET_IP_TOS TOS,
NET_IP_TTL TTL,
CPU_INT16U flags_tcp,
CPU_INT16U flags_ip,
void *popts_tcp,
void *popts_ip,
NET_ERR *perr)
{
CPU_INT08U tcp_opt_len_size;
CPU_INT16U tcp_hdr_len_size;
NET_TCP_OPT_SIZE tcp_hdr_opts[NET_TCP_HDR_OPT_NBR_MAX];
/* ----------------- PREPARE TCP OPTS ----------------- */
if (popts_tcp != (void *)0) {
tcp_opt_len_size = NetTCP_TxPktPrepareOpt((void *) popts_tcp,
(CPU_INT08U *)&tcp_hdr_opts[0],
(NET_ERR *) perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
} else {
tcp_opt_len_size = 0;
}
/* ---------------- CALC TCP HDR CTRLS ---------------- */
/* Calc tot TCP hdr len (in octets). */
tcp_hdr_len_size = (CPU_INT16U)(NET_TCP_HDR_SIZE_MIN + tcp_opt_len_size);
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (tcp_hdr_len_size > NET_TCP_HDR_SIZE_MAX) {
*perr = NET_TCP_ERR_INVALID_LEN_HDR;
return;
}
#endif
/* ----------------- PREPARE TCP HDR ------------------ */
NetTCP_TxPktPrepareHdr(pbuf,
pbuf_hdr,
tcp_hdr_len_size,
tcp_opt_len_size,
src_addr,
src_port,
dest_addr,
dest_port,
seq_nbr,
ack_nbr,
win_size,
flags_tcp,
&tcp_hdr_opts[0],
perr);
if (*perr != NET_TCP_ERR_NONE) {
return;
}
/* -------------------- TX TCP PKT -------------------- */
NetIP_Tx(pbuf,
src_addr,
dest_addr,
TOS,
TTL,
flags_ip,
popts_ip,
perr);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxPktPrepareOpt()
*
* Description : (1) Prepare TCP header with TCP transmit options :
*
* (a) Prepare ALL TCP options from configuration
* data structure(s)
* (b) Pad remaining TCP header octets See RFC #793, Section 3.1
* 'Header Format : Padding'
*
* (2) TCP transmit options MUST be configured by appropriate options configuration data
* structure(s) passed via 'popts_tcp'; see 'net_tcp.h TCP HEADER OPTION CONFIGURATION
* DATA TYPES' for TCP options configuration.
*
*
* Argument(s) : popts_tcp Pointer to one or more TCP options configuration data structures :
* ---------
* NULL NO TCP transmit options configuration.
* NET_TCP_OPT_CFG_MAX_SEG_SIZE TCP Maximum Segment Size options configuration.
*
* Argument checked in NetTCP_TxPkt().
*
* popt_hdr Pointer to TCP transmit option buffer to prepare TCP options.
* -------- Argument validated in NetTCP_TxPkt().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP header options successfully prepared.
* NET_TCP_ERR_INVALID_OPT_TYPE Invalid TCP option type.
* NET_TCP_ERR_INVALID_OPT_LEN Invalid TCP option length.
*
* Return(s) : Total TCP option length (in octets), if NO errors.
*
* 0, otherwise.
*
* Caller(s) : NetTCP_TxPkt().
*
* Note(s) : (3) Transmit arguments & options validated in NetTCP_TxPktValidate()/NetTCP_TxPktValidateOpt() :
* (a) Assumes ALL transmit arguments & options are valid.
* (b) Assumes total transmit options' lengths are valid.
*
* (4) TCP header allows for a maximum option size of 40 octets (see 'net_tcp.h TCP HEADER
* OPTIONS DEFINES Note #3').
*
* (5) (a) RFC # 793, Section 3.1 'Options' states that each option is "a multiple of 8 bits
* in length" and "may begin on any octet boundary".
*
* (b) Since TCP options are NOT required or guaranteed to align multi-octet words on
* appropriate word boundaries, ALL TCP options are prepared a single octet at a time.
*
* (6) Default case already invalidated in NetTCP_TxPktValidateOpt(). However, the default
* case is included as an extra precaution in case any of the TCP transmit options types
* are incorrectly modified.
*********************************************************************************************************
*/
/*$PAGE*/
static CPU_INT08U NetTCP_TxPktPrepareOpt (void *popts_tcp,
CPU_INT08U *popt_hdr,
NET_ERR *perr)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
CPU_INT08U tcp_opt_len_tot;
CPU_INT08U tcp_opt_len;
CPU_INT08U *popt_cfg_hdr;
NET_TYPE *popt_cfg_type;
void *popt_next;
void *popt_cfg;
tcp_opt_len_tot = 0;
popt_cfg = popts_tcp;
popt_cfg_hdr = popt_hdr;
/* ----------------- PREPARE TCP OPTS ----------------- */
while (popt_cfg != (void *)0) { /* Prepare ALL cfg'd TCP opts (see Note #1a). */
popt_cfg_type = (NET_TYPE *)popt_cfg;
switch (*popt_cfg_type) {
case NET_TCP_OPT_CFG_TYPE_MAX_SEG_SIZE:
NetTCP_TxPktPrepareOptMaxSegSize(popt_cfg, popt_cfg_hdr, &tcp_opt_len, &popt_next, perr);
break;
#if 0 /* --------------- UNSUPPORTED TCP OPTS --------------- */
case NET_TCP_OPT_CFG_TYPE_WIN_SCALE:
case NET_TCP_OPT_CFG_TYPE_SACK_PERMIT:
case NET_TCP_OPT_CFG_TYPE_SACK:
case NET_TCP_OPT_CFG_TYPE_ECHO_REQ:
case NET_TCP_OPT_CFG_TYPE_ECHO_REPLY:
case NET_TCP_OPT_CFG_TYPE_TS:
/* 'break' intentionally omitted; do NOT move from the */
/* ... following case : 'NET_TCP_OPT_CFG_TYPE_NONE'. */
#endif
case NET_TCP_OPT_CFG_TYPE_NONE: /* ----------------- INVALID TCP OPTS ----------------- */
default: /* See Note #6. */
NET_CTR_ERR_INC(NetTCP_ErrTxOptTypeCtr);
*perr = NET_TCP_ERR_INVALID_OPT_TYPE;
return (0); /* Prevent 'break NOT reachable' compiler warning. */
}
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (*perr != NET_TCP_ERR_NONE) { /* See Note #3a. */
return (0);
}
if (tcp_opt_len_tot > NET_TCP_HDR_OPT_SIZE_MAX) { /* See Note #3b. */
NET_CTR_ERR_INC(NetTCP_ErrTxHdrOptLenCtr);
*perr = NET_TCP_ERR_INVALID_OPT_LEN;
return (0);
}
#endif
tcp_opt_len_tot += tcp_opt_len;
popt_cfg_hdr += tcp_opt_len;
popt_cfg = popt_next; /* Prepare next cfg opt. */
}
/* ------------------- PAD TCP HDR -------------------- */
if (tcp_opt_len_tot > 0) {
/* Pad rem'ing TCP hdr octets (see Note #1b). */
while ((tcp_opt_len_tot % NET_TCP_HDR_OPT_SIZE_WORD) &&
(tcp_opt_len_tot <= NET_TCP_HDR_OPT_SIZE_MAX )) {
*popt_cfg_hdr = NET_TCP_HDR_OPT_PAD;
popt_cfg_hdr++;
tcp_opt_len_tot++;
}
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (tcp_opt_len_tot > NET_TCP_HDR_OPT_SIZE_MAX) { /* See Note #3b. */
NET_CTR_ERR_INC(NetTCP_ErrTxHdrOptLenCtr);
*perr = NET_TCP_ERR_INVALID_OPT_LEN;
return (0);
}
#endif
}
*perr = NET_TCP_ERR_NONE;
return (tcp_opt_len_tot);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxPktPrepareOptMaxSegSize()
*
* Description : (1) Prepare TCP header with TCP Maximum Segment Size option :
*
* (a) Prepare TCP Maximum Segment Size option
* (b) Return option values
*
*
* Argument(s) : popts_tcp Pointer to TCP Maximum Segment Size option configuration data structure.
* --------- Argument checked in NetTCP_TxPkt().
*
* popt_hdr Pointer to TCP transmit option buffer to prepare TCP Maximum Segment Size option.
* -------- Argument validated in NetTCP_TxPkt().
*
* popt_len Pointer to variable that will receive the returned TCP option length (in octets).
* -------- Argument validated in NetTCP_TxPktPrepareOpt().
*
* popt_next Pointer to variable that will receive the pointer to the next TCP transmit option.
* -------- Argument validated in NetTCP_TxPktPrepareOpt().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP Maximum Segment Size option successfully
* prepared.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxPktPrepareOpt().
*
* Note(s) : (2) See 'net_tcp.h TCP HEADER OPTIONS DEFINES Note #2b1' for TCP Maximum Segment Size
* option summary.
*
* (3) Transmit arguments & options validated in NetTCP_TxPktValidate()/NetTCP_TxPktValidateOpt() :
* (a) Assumes ALL transmit arguments & options are valid.
* (b) Assumes total transmit options' lengths are valid.
*
* (4) (a) RFC # 793, Section 3.1 'Options' states that each option is "a multiple of 8 bits
* in length" and "may begin on any octet boundary".
*
* (b) Since TCP options are NOT required or guaranteed to align multi-octet words on
* appropriate word boundaries, ALL TCP options are prepared a single octet at a time.
*
* (5) #### 'perr' may NOT be necessary (remove if unnecessary).
*********************************************************************************************************
*/
static void NetTCP_TxPktPrepareOptMaxSegSize (void *popts_tcp,
CPU_INT08U *popt_hdr,
CPU_INT08U *popt_len,
void **popt_next,
NET_ERR *perr)
{
NET_TCP_OPT_CFG_MAX_SEG_SIZE *popt_cfg_max_seg_size;
CPU_INT08U *popt_cfg_hdr;
CPU_INT08U opt_len;
CPU_INT08U max_seg_size_hi;
CPU_INT08U max_seg_size_lo;
/* ------------- PREPARE MAX SEG SIZE OPT ------------- */
popt_cfg_max_seg_size = (NET_TCP_OPT_CFG_MAX_SEG_SIZE *)popts_tcp;
popt_cfg_hdr = popt_hdr;
opt_len = NET_TCP_HDR_OPT_LEN_MAX_SEG_SIZE;
max_seg_size_hi = (CPU_INT08U)(popt_cfg_max_seg_size->MaxSegSize >> DEF_OCTET_NBR_BITS);
max_seg_size_lo = (CPU_INT08U) popt_cfg_max_seg_size->MaxSegSize;
*popt_cfg_hdr = NET_TCP_HDR_OPT_MAX_SEG_SIZE; /* Prepare opt type. */
popt_cfg_hdr++;
*popt_cfg_hdr = opt_len; /* Prepare opt len. */
popt_cfg_hdr++;
*popt_cfg_hdr = max_seg_size_hi; /* Prepare max seg size val. */
popt_cfg_hdr++;
*popt_cfg_hdr = max_seg_size_lo;
/* ------------------- RTN OPT VALS ------------------- */
*popt_len = opt_len;
*popt_next = popt_cfg_max_seg_size->NextOptPtr;
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxPktPrepareHdr()
*
* Description : (1) Prepare TCP header :
*
* (a) Update network buffer's protocol index & length controls.
*
* (b) Prepare the transmit packet's following TCP header fields :
*
* (1) Source Port
* (2) Destination Port
* (3) Sequence Number
* (4) Acknowledgement Number
* (5) Header Length/Flags
* (6) Window Advertisement
* (7) Check-Sum See Note #3
* (8) Urgent Pointer See Note #2
* (9) Options
*
* (c) Convert the following TCP header fields from host-order to network-order :
*
* (1) Source Port
* (2) Destination Port
* (3) Sequence Number
* (4) Acknowledgement Number
* (5) Header Length/Flags
* (6) Window Advertisement
* (7) Check-Sum See Note #3e
* (8) Urgent Pointer See Note #2
*
* (d) Get TCP packet RTT timestamp transmitted. See 'NetTCP_TxConnRTT_RTO_Calc()
* Note #2a2A1'
*
*$PAGE*
* Argument(s) : pbuf Pointer to network buffer to transmit TCP packet.
* ---- Argument checked in NetTCP_TxPktHandler().
*
* pbuf_hdr Pointer to network buffer header.
* -------- Argument validated in NetTCP_TxPktHandler().
*
* tcp_hdr_len_tot Total TCP header length.
* --------------- Argument checked in NetTCP_TxPkt().
*
* tcp_opt_len_tot Total TCP header options' length.
* --------------- Argument checked in NetTCP_TxPktPrepareOpt().
*
* src_addr Source IP address.
*
* src_port Source TCP port.
* -------- Argument checked in NetTCP_TxPktValidate().
*
* dest_addr Destination IP address.
*
* dest_port Destination TCP port.
* --------- Argument checked in NetTCP_TxPktValidate().
*
* seq_nbr TCP segment sequence number.
* ------- Argument validated in NetTCP_TxPktValidate().
*
* ack_nbr TCP segment acknowledgement sequence number.
* ------- Argument validated in NetTCP_TxPktValidate().
*
* win_size TCP receive window advertisement size.
* -------- Argument validated in NetTCP_TxPktValidate().
*
* flags_tcp Flags to select TCP transmit options; bit-field flags logically OR'd :
* ---------
* NET_TCP_FLAG_NONE No TCP transmit flags selected.
* NET_TCP_FLAG_TX_FIN Set TCP 'FIN' flag.
* NET_TCP_FLAG_TX_SYNC Set TCP 'SYN' flag.
* NET_TCP_FLAG_TX_RESET Set TCP 'RESET' flag.
* NET_TCP_FLAG_TX_PUSH Set TCP 'PUSH' flag.
* NET_TCP_FLAG_TX_ACK Set TCP 'ACK' flag.
* NET_TCP_FLAG_TX_URGENT Set TCP 'URGENT' flag.
*
* Argument checked in NetTCP_TxPktValidate().
*
* ptcp_hdr_opts Pointer to TCP options buffer.
* ------------- Argument checked in NetTCP_TxPktPrepareOpt().
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_TCP_ERR_NONE TCP header successfully prepared.
*
* ----------- RETURNED BY NetBuf_DataWr() : ------------
* NET_BUF_ERR_INVALID_IX Invalid buffer index for transmit options.
* NET_BUF_ERR_INVALID_LEN Invalid buffer length for transmit options.
*
* - RETURNED BY NetUtil_16BitOnesCplChkSumDataCalc() : -
* NET_UTIL_ERR_NULL_PTR Check-sum passed a NULL pointer.
* NET_UTIL_ERR_NULL_SIZE Check-sum passed a zero size.
* NET_UTIL_ERR_INVALID_PROTOCOL Invalid data packet protocol.
* NET_BUF_ERR_INVALID_IX Invalid buffer index.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxPkt().
*$PAGE*
* Note(s) : (2) Urgent pointer & data NOT supported (see 'net_tcp.c Note #1b').
*
* (3) (a) TCP header Check-Sum MUST be calculated AFTER the entire TCP header has been prepared.
* In addition, ALL multi-octet words are converted from host-order to network-order
* since "the sum of 16-bit integers can be computed in either byte order" [RFC #1071,
* Section 2.(B)].
*
* (b) TCP header Check-Sum field MUST be cleared to '0' BEFORE the TCP header Check-Sum is
* calculated (see RFC #793, Section 3.1 'Header Format : Checksum').
*
* (c) (1) In addition to the TCP segment header & data, the TCP Check-Sum calculation
* includes "a 96-bit pseudo header conceptually prefixed to the TCP header ...
* [which] contains the Source Address, the Destination Address, the Protocol,
* and TCP length" (see RFC #793, Section 3.1 'Header Format : Checksum').
*
* (2) Since network check-sum functions REQUIRE that 16-bit one's-complement check-
* sum calculations be performed on headers & data arranged in network-order (see
* 'net_util.c NetUtil_16BitOnesCplChkSumDataCalc() Note #3'), TCP pseudo-header
* values MUST be set or converted to network-order.
*
* (d) RFC #793, Section 3.1 'Header Format : Checksum' specifies that "if a segment contains
* an odd number of header and text octets ... the last octet is padded ... with zeros to
* form a 16-bit word for checksum purposes".
*
* See also 'net_util.c NetUtil_16BitSumDataCalc() Note #8'.
*
* (e) The TCP header Check-Sum field is returned in network-order & MUST NOT be re-
* converted back to host-order (see 'net_util.c NetUtil_16BitOnesCplChkSumDataCalc()
* Note #4').
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_TxPktPrepareHdr (NET_BUF *pbuf,
NET_BUF_HDR *pbuf_hdr,
CPU_INT16U tcp_hdr_len_tot,
CPU_INT08U tcp_opt_len_tot,
NET_IP_ADDR src_addr,
NET_TCP_PORT_NBR src_port,
NET_IP_ADDR dest_addr,
NET_TCP_PORT_NBR dest_port,
NET_TCP_SEQ_NBR seq_nbr,
NET_TCP_SEQ_NBR ack_nbr,
NET_TCP_WIN_SIZE win_size,
CPU_INT16U flags_tcp,
CPU_INT32U *ptcp_hdr_opts,
NET_ERR *perr)
{
NET_TCP_HDR *ptcp_hdr;
NET_TCP_PSEUDO_HDR tcp_pseudo_hdr;
CPU_INT16U tcp_hdr_len;
CPU_INT16U tcp_flags;
CPU_INT16U tcp_hdr_len_flags;
CPU_INT16U tcp_opt_ix;
NET_CHK_SUM tcp_chk_sum;
/* ----------------- UPDATE BUF CTRLS ----------------- */
pbuf_hdr->TCP_UDP_HdrLen = tcp_hdr_len_tot;
pbuf_hdr->TCP_UDP_HdrDataIx = pbuf_hdr->DataIx - pbuf_hdr->TCP_UDP_HdrLen;
pbuf_hdr->TotLen += (NET_BUF_SIZE)pbuf_hdr->TCP_UDP_HdrLen;
pbuf_hdr->TCP_UDP_TotLen = (CPU_INT16U )pbuf_hdr->TotLen;
pbuf_hdr->TCP_UDP_DataLen = (CPU_INT16U )pbuf_hdr->DataLen;
pbuf_hdr->ProtocolHdrType = NET_PROTOCOL_TYPE_TCP;
/* ----------------- PREPARE TCP HDR ------------------ */
ptcp_hdr = (NET_TCP_HDR *)&pbuf->Data[pbuf_hdr->TCP_UDP_HdrDataIx];
/* ---------------- PREPARE TCP PORTS ----------------- */
NET_UTIL_VAL_COPY_SET_NET_16(&ptcp_hdr->PortSrc, &src_port);
NET_UTIL_VAL_COPY_SET_NET_16(&ptcp_hdr->PortDest, &dest_port);
/* --------------- PREPARE TCP SEQ NBRS --------------- */
NET_UTIL_VAL_COPY_SET_NET_32(&ptcp_hdr->SeqNbr, &seq_nbr);
NET_UTIL_VAL_COPY_SET_NET_32(&ptcp_hdr->AckNbr, &ack_nbr);
/* ------------ PREPARE TCP HDR LEN/FLAGS ------------- */
tcp_hdr_len = pbuf_hdr->TCP_UDP_HdrLen / NET_TCP_HDR_LEN_WORD_SIZE;
tcp_hdr_len <<= NET_TCP_HDR_LEN_SHIFT;
tcp_flags = NET_TCP_HDR_FLAG_NONE;
tcp_flags |= flags_tcp;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
tcp_hdr_len &= NET_TCP_HDR_LEN_MASK;
tcp_flags &= NET_TCP_HDR_FLAG_MASK;
#endif
tcp_hdr_len_flags = tcp_hdr_len | tcp_flags;
NET_UTIL_VAL_COPY_SET_NET_16(&ptcp_hdr->HdrLen_Flags, &tcp_hdr_len_flags);
/* ----------------- PREPARE TCP WIN ------------------ */
NET_UTIL_VAL_COPY_SET_NET_16(&ptcp_hdr->WinSize, &win_size);
/* -------------- PREPARE TCP URGENT PTR -------------- */
/* See Note #2. */
NET_UTIL_VAL_SET_NET_16(&ptcp_hdr->UrgentPtr, NET_TCP_HDR_URG_PTR_NONE);
/*$PAGE*/
/* ----------------- PREPARE TCP OPTS ----------------- */
if (tcp_opt_len_tot > 0) {
tcp_opt_ix = pbuf_hdr->TCP_UDP_HdrDataIx + NET_TCP_HDR_OPT_IX;
NetBuf_DataWr((NET_BUF *)pbuf,
(NET_BUF_SIZE)tcp_opt_ix,
(NET_BUF_SIZE)tcp_opt_len_tot,
(CPU_INT08U *)ptcp_hdr_opts,
(NET_ERR *)perr);
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
if (*perr != NET_BUF_ERR_NONE) {
return;
}
#endif
}
/* --------------- PREPARE TCP CHK SUM ---------------- */
NET_UTIL_VAL_SET_NET_16(&ptcp_hdr->ChkSum, 0x0000); /* Clr TCP chk sum (see Note #3b). */
/* Cfg TCP chk sum pseudo-hdr (see Note #3c). */
tcp_pseudo_hdr.AddrSrc = (NET_IP_ADDR)NET_UTIL_HOST_TO_NET_32(src_addr);
tcp_pseudo_hdr.AddrDest = (NET_IP_ADDR)NET_UTIL_HOST_TO_NET_32(dest_addr);
tcp_pseudo_hdr.Zero = (CPU_INT08U )0x00;
tcp_pseudo_hdr.Protocol = (CPU_INT08U )NET_IP_HDR_PROTOCOL_TCP;
tcp_pseudo_hdr.TotLen = (CPU_INT16U )NET_UTIL_HOST_TO_NET_16(pbuf_hdr->TCP_UDP_TotLen);
/* Calc TCP chk sum. */
tcp_chk_sum = NetUtil_16BitOnesCplChkSumDataCalc((void *) pbuf,
(void *)&tcp_pseudo_hdr,
(CPU_INT16U) NET_TCP_PSEUDO_HDR_SIZE,
(NET_ERR *) perr);
if (*perr != NET_UTIL_ERR_NONE) {
return;
}
NET_UTIL_VAL_COPY_16(&ptcp_hdr->ChkSum, &tcp_chk_sum); /* Copy TCP chk sum in net order (see Note #3e). */
/* ---------------- GET TCP RTT TX TS ----------------- */
pbuf_hdr->TCP_RTT_TS_Txd_ms = (CPU_INT32U)NetTCP_TxConnRTT_GetTS_ms();
*perr = NET_TCP_ERR_NONE;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_TxPktFree()
*
* Description : Free network buffer(s).
*
* Argument(s) : pbuf_q Pointer to network buffer queue.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerReTxQ(),
* NetTCP_TxConnAck(),
* NetTCP_TxConnReset().
*
* Note(s) : (1) (a) Although TCP Transmit initially requests the network buffer for transmit, the
* TCP layer maintains a reference to the buffer for possible retransmission.
*
* (b) Therefore, even though the network interface layer frees ALL unreferenced
* buffers after successful transmission [see 'net_if_pkt.c NetIF_Pkt_TxPktFree()'
* or 'net_if_char.c NetIF_Char_TxPktFree()'], the TCP layer MUST free transmit
* buffers which are still referenced.
*********************************************************************************************************
*/
static void NetTCP_TxPktFree (NET_BUF *pbuf_q)
{
NetBuf_FreeBufQ_PrimList((NET_BUF *)pbuf_q,
(NET_CTR *)0);
}
/*
*********************************************************************************************************
* NetTCP_TxPktDiscard()
*
* Description : On any Transmit packet errors, discard TCP packet(s) & buffer(s).
*
* Argument(s) : pbuf Pointer to network buffer.
*
* perr Pointer to variable that will receive the return error code from this function :
*
* NET_ERR_TX Transmit error.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_TxConnAppData(),
* NetTCP_TxPktHandler().
*
* Note(s) : (1) Since some TCP Transmit packets are passed the network buffer from other TCP functions,
* they may NOT be the buffers' only references & MUST therefore check buffers' reference
* counter before freeing buffers.
*********************************************************************************************************
*/
static void NetTCP_TxPktDiscard (NET_BUF *pbuf,
NET_ERR *perr)
{
NET_CTR *pctr;
#if (NET_CTR_CFG_ERR_EN == DEF_ENABLED)
pctr = (NET_CTR *)&NetTCP_ErrTxPktDiscardedCtr;
#else
pctr = (NET_CTR *) 0;
#endif
NetBuf_FreeBufQ_PrimList((NET_BUF *)pbuf,
(NET_CTR *)pctr);
*perr = NET_ERR_TX;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnCfg()
*
* Description : (1) Configure TCP connection's controls :
*
* (a) Configure TCP connection's connection maximum segment size See Note #2
* (b) Configure TCP connection's receive window controls See Note #3
* (c) Configure TCP connection's transmit window controls See Note #4
* (d) Initialize TCP connection's transmit round-trip time &
* re-transmit timeout controls
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_RxPktConnHandlerListen(),
* NetTCP_RxPktConnHandlerSyncTxd(),
* NetTCP_ConnClr().
*
* cfg_code Select which close action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_CFG_NONE Perform NO configuration actions.
* NET_TCP_CONN_CFG_ALL Perform ALL configuration actions.
*
* NET_TCP_CONN_CFG_MAX_SEG_SIZE_LOCAL Configure local maximum segment size.
* NET_TCP_CONN_CFG_MAX_SEG_SIZE_REMOTE Configure remote maximum segment size.
* NET_TCP_CONN_CFG_MAX_SEG_SIZE_CONN Configure connection maximum segment size.
* NET_TCP_CONN_CFG_MAX_SEG_SIZE_ALL Configure ALL maximum segment sizes.
*
* NET_TCP_CONN_CFG_WIN_SIZE_RX Configure receive window size(s).
* NET_TCP_CONN_CFG_WIN_SIZE_TX Configure transmit window size(s).
* NET_TCP_CONN_CFG_WIN_SIZE_CONN Configure connection window size(s).
* NET_TCP_CONN_CFG_WIN_SIZE_ALL Configure ALL window sizes.
*
* NET_TCP_CONN_CFG_TX_RTT_RTO Configure transmit round-trip time (RTT)
* & re-transmit timeout (RTO) control(s).
*
* See also 'TCP CONNECTION CONFIGURATION CODE DEFINES'.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerListen(),
* NetTCP_RxPktConnHandlerSyncTxd(),
* NetTCP_ConnClr().
*
* Note(s) : (2) A TCP connection's connection maximum segment size should NOT be updated until
* after certain other TCP connection control(s) have been configured.
*
* See also 'NetTCP_ConnCfgMaxSegSize() Note #3'.
*
* (3) A TCP connection's receive window controls should NOT be updated until after
* certain other TCP connection control(s) have been configured.
*
* See also 'NetTCP_RxConnWinSizeCfg() Note #2'.
*
* (4) A TCP connection's transmit window controls should NOT be updated until after
* certain other TCP connection control(s) have been configured.
*
* See also 'NetTCP_TxConnWinSizeCfg() Note #2'.
*
* (5) A TCP connection's transmit round-trip time & re-transmit timeout controls
* should NOT be updated until after certain other TCP connection control(s)
* have been configured.
*
* See also 'NetTCP_TxConnRTT_RTO_Init() Note #1'.
*********************************************************************************************************
*/
static void NetTCP_ConnCfg (NET_TCP_CONN *pconn,
NET_TCP_CFG_CODE cfg_code)
{
CPU_BOOLEAN cfg_conn_max_seg_size;
CPU_BOOLEAN cfg_conn_win_size;
CPU_BOOLEAN cfg_conn_tx_rtt_rto;
cfg_conn_max_seg_size = DEF_BIT_IS_SET(cfg_code, NET_TCP_CONN_CFG_MAX_SEG_SIZE_CONN);
if (cfg_conn_max_seg_size == DEF_YES) {
NetTCP_ConnCfgMaxSegSize(pconn); /* Cfg conn max seg size (see Note #2). */
}
cfg_conn_win_size = DEF_BIT_IS_SET(cfg_code, NET_TCP_CONN_CFG_WIN_SIZE_ALL);
if (cfg_conn_win_size == DEF_YES) {
NetTCP_RxConnWinSizeCfg(pconn); /* Cfg rx win ctrls (see Note #3). */
NetTCP_TxConnWinSizeCfg(pconn); /* Cfg tx win ctrls (see Note #4). */
}
cfg_conn_tx_rtt_rto = DEF_BIT_IS_SET(cfg_code, NET_TCP_CONN_CFG_TX_RTT_RTO);
if (cfg_conn_tx_rtt_rto == DEF_YES) {
NetTCP_TxConnRTT_RTO_Init(pconn); /* Init tx RTT / RTO ctrls (see Note #5). */
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnCfgMaxSegSize()
*
* Description : Configure TCP connection's maximum segment size.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_ConnCfg().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_ConnCfg().
*
* Note(s) : (1) RFC #1122, Section 4.2.2.6 states that "the maximum size of a segment that TCP really
* sends, the 'effective send MSS', MUST be the smaller of the send MSS ... and ... less
* than or equal to ... the maximum size ... that can be received".
*
* (2) In order to avoid transmit window deadlock with a remote host's receive window, the
* TCP connection's connection maximum segment size MUST be configured to ensure that
* full, maximum-segment-sized segments will transmit even for receive windows less than
* the default maximum segment size.
*
* (a) RFC #1122, Section 4.2.3.4.(3) states to "send data ... if at least a fraction Fs
* of the maximum window can be sent ... Fs is a fraction whose recommended value is
* 1/2".
*
* Thus, it seems reasonable to calculate & limit the remote host's maximum window
* size by a similar fraction.
*
* (3) A TCP connection's connection maximum segment size should NOT be updated until after
* the following TCP connection control(s) have been configured :
*
* (a) TCP connection's local maximum segment size ('MaxSegSizeLocal')
* [see 'NetTCP_ConnClr() Note #3a']
*
* (b) TCP connection's remote maximum segment size ('MaxSegSizeRemote')
* [see 'NetTCP_RxPktConnHandlerListen() Note #7'
* & 'NetTCP_RxPktConnHandlerSyncTxd() Note #3']
*
* (c) TCP connection's maximum transmit remote window size ('TxWinSizeRemoteMax')
* [see 'NetTCP_RxPktConnHandlerTxWinRemote() Note #1a2A'
* & 'NetTCP_TxConnWinSizeHandlerCongCtrl() Notes #3a2A & #3b']
*********************************************************************************************************
*/
static void NetTCP_ConnCfgMaxSegSize (NET_TCP_CONN *pconn)
{
NET_TCP_WIN_SIZE remote_win_size_th;
NET_TCP_SEG_SIZE remote_max_seg_size;
/* Calc remote max seg size (see Note #2). */
remote_win_size_th = (NET_TCP_WIN_SIZE)(((CPU_INT32U)pconn->TxWinSizeRemoteMax * NET_TCP_TX_SILLY_WIN_NUMER)
/ NET_TCP_TX_SILLY_WIN_DENOM);
remote_max_seg_size = (NET_TCP_SEG_SIZE)DEF_MIN(pconn->MaxSegSizeRemote,
remote_win_size_th);
/* Cfg conn max seg size (see Note #1). */
pconn->MaxSegSizeConn = (NET_TCP_SEG_SIZE)DEF_MIN(pconn->MaxSegSizeLocal,
remote_max_seg_size);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnClose()
*
* Description : (1) Close a TCP connection due to TCP connection fault(s) :
*
* (a) Update TCP connection close statistic(s)
* (b) Transmit TCP connection reset to remote host See Note #4
* (c) Close TCP connection
*
*
* (2) TCP connection closed internally by TCP layer when certain TCP connection parameters
* are corrupted or when certain valid TCP connection operations fail.
*
* (3) Since the mechanisms of TCP connection close are independent of the application layer
* close; TCP connection MAY need to close application layer connection(s).
*
* See also 'NetTCP_ConnCloseHandler() Note #2b'.
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in various.
*
* pbuf_hdr Pointer to network buffer header that received TCP packet.
*
* close_conn_app Indicate whether to close application connection (see Note #3):
*
* DEF_YES Close application connection.
* DEF_NO Do NOT close application connection.
*
* close_code Select which close action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_CLOSE_NONE Perform NO close actions.
* NET_TCP_CONN_CLOSE_ALL Perform ALL close actions.
*
* NET_TCP_CONN_CLOSE_CONN_TX_RESET Perform close connection transmit reset.
* NET_TCP_CONN_CLOSE_CONN_ALL Perform ALL connection close actions.
*
* NET_TCP_CONN_CLOSE_TMR_TX_IDLE Close transmit idle timer.
* NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN Close transmit silly window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN Close transmit zero window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY Close transmit acknowledgement delay timer.
* NET_TCP_CONN_CLOSE_TMR_RE_TX Close re-transmit timer.
* NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE Close connection keep-alive timer.
* NET_TCP_CONN_CLOSE_TMR_TIMEOUT Close connection timer.
* NET_TCP_CONN_CLOSE_TMR_ALL Close ALL timers.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES'.
*
* Return(s) : none.
*
* Caller(s) : various.
*
* Note(s) : (4) Although NO RFC directly states to transmit a TCP reset segment when a TCP connection
* fault-closes, it is inferred & seems reasonable that a TCP reset segment SHOULD be
* transmitted whenever a TCP connection closes abnormally from any of the following
* synchronization/connected/closing states :
*
* (a) SYN-RECEIVED
* (b) SYN-SENT
* (c) ESTABLISHED
* (d) FIN-WAIT-1
* (e) FIN-WAIT-2
* (f) CLOSING
* (g) TIME_WAIT
* (h) CLOSE-WAIT
* (i) LAST-ACK
*
* See also 'NetTCP_TxConnReset() Note #3b'.
*
* (5) On any TCP connection handler function fault(s), TCP connection MUST NEVER be re-closed.
*
* See also 'NetTCP_ConnCloseHandler() Note #4'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_ConnClose (NET_TCP_CONN *pconn,
NET_BUF_HDR *pbuf_hdr,
CPU_BOOLEAN close_conn_app,
NET_TCP_CLOSE_CODE close_code)
{
#if ((NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
CPU_BOOLEAN tx_reset;
NET_ERR err;
/* ---------- UPDATE CLOSE STATS ---------- */
NET_CTR_ERR_INC(NetTCP_ErrConnCloseCtr);
/* ---------- TX TCP CONN RESET ----------- */
tx_reset = DEF_BIT_IS_SET(close_code, NET_TCP_CONN_CLOSE_CONN_TX_RESET);
if (tx_reset == DEF_YES) { /* Tx TCP conn reset (see Note #4). */
NetTCP_TxConnReset((NET_TCP_CONN *) pconn,
(NET_BUF_HDR *) pbuf_hdr,
(NET_TCP_RESET_CODE) NET_TCP_CONN_TX_RESET_FAULT,
(NET_TCP_CLOSE_CODE) NET_TCP_CONN_CLOSE_NONE, /* MUST NOT re-close TCP conn (see Note #5).*/
(NET_ERR *)&err);
}
/* ------------ CLOSE TCP CONN ------------ */
NetTCP_ConnCloseHandler(pconn, close_conn_app, close_code);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnCloseHandler()
*
* Description : (1) Close a TCP connection :
*
* (a) Close network connection(s) See Note #2
* (b) Free TCP connection
*
*
* (2) (a) TCP connection's network connection(s) MUST be closed BEFORE the TCP connection
* is closed/freed.
*
* (b) TCP connection's application connection(s) :
*
* (1) MAY be CLOSED &/or reset :
*
* (A) For the following TCP connection condition(s), the TCP connection MUST
* close the application connection(s) :
*
* (1) (a) Invalid TCP connection parameters :
* (1) Invalid TCP connection state(s)
* (2) Invalid/corrupted TCP data queue(s) :
* (A) Invalid sequence numbers
* (B) Invalid segment lengths
*
* (b) Fatal TCP transmit fault(s)
* (c) TCP connection closing fault(s)
*
* (2) Invalid network connection configuration
*
* (B) For the following TCP connection condition(s), the TCP connection SHOULD
* close the application connection(s) based on its application close flag
* ('ConnCloseAppFlag') :
*
* (1) Valid TCP connection closing states/timeouts
*
* (C) For the following TCP connection condition(s), the TCP connection MAY --
* but is NOT required to -- close the application connection(s) :
*
* (1) Initial TCP connection configuration/preparation
*
* (2) But possibly NOT freed, since some application connections have NO mechanism
* or API to close an application's reference to the connection.
*
* See also specific application connection close function(s) for additional notes.
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_ConnClose(),
* NetTCP_ConnCloseTimeout(),
* various.
*
* close_conn_app Indicate whether to close application connection (see Note #2b):
*
* DEF_YES Close application connection.
* DEF_NO Do NOT close application connection.
*
* close_code Select which close action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_CLOSE_NONE Perform NO close actions.
* NET_TCP_CONN_CLOSE_ALL Perform ALL close actions.
*
* NET_TCP_CONN_CLOSE_CONN_TX_RESET Perform close connection transmit reset.
* NET_TCP_CONN_CLOSE_CONN_ALL Perform ALL connection close actions.
*
* NET_TCP_CONN_CLOSE_TMR_TX_IDLE Close transmit idle timer.
* NET_TCP_CONN_CLOSE_TMR_TX_SILLY_WIN Close transmit silly window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ZERO_WIN Close transmit zero window persist timer.
* NET_TCP_CONN_CLOSE_TMR_TX_ACK_DLY Close transmit acknowledgement delay timer.
* NET_TCP_CONN_CLOSE_TMR_RE_TX Close re-transmit timer.
* NET_TCP_CONN_CLOSE_TMR_KEEP_ALIVE Close connection keep-alive timer.
* NET_TCP_CONN_CLOSE_TMR_TIMEOUT Close connection timer.
* NET_TCP_CONN_CLOSE_TMR_ALL Close ALL timers.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES'.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_ConnClose(),
* NetTCP_ConnCloseTimeout(),
* various.
*
* Note(s) : (3) TCP connection free codes are identical to TCP connection close codes.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES Note #2'.
*
* (4) On any TCP connection close, TCP connection MUST NEVER be re-closed.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_ConnCloseHandler (NET_TCP_CONN *pconn,
CPU_BOOLEAN close_conn_app,
NET_TCP_CLOSE_CODE close_code)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
CPU_BOOLEAN used;
#endif
NET_TCP_FREE_CODE free_code;
/* ------------ VALIDATE TCP CONN CLOSE ----------- */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
used = DEF_BIT_IS_SET(pconn->Flags, NET_TCP_FLAG_USED);
if (used != DEF_YES) {
NET_CTR_ERR_INC(NetTCP_ErrNotUsedCtr);
return;
}
#endif
switch (pconn->ConnState) {
case NET_TCP_CONN_STATE_LISTEN:
case NET_TCP_CONN_STATE_SYNC_RXD:
case NET_TCP_CONN_STATE_SYNC_RXD_PASSIVE:
case NET_TCP_CONN_STATE_SYNC_RXD_ACTIVE:
case NET_TCP_CONN_STATE_SYNC_TXD:
case NET_TCP_CONN_STATE_CONN:
case NET_TCP_CONN_STATE_FIN_WAIT_1:
case NET_TCP_CONN_STATE_FIN_WAIT_2:
case NET_TCP_CONN_STATE_CLOSING:
case NET_TCP_CONN_STATE_TIME_WAIT:
case NET_TCP_CONN_STATE_CLOSE_WAIT:
case NET_TCP_CONN_STATE_LAST_ACK:
case NET_TCP_CONN_STATE_CLOSING_DATA_AVAIL:
break;
case NET_TCP_CONN_STATE_NONE:
case NET_TCP_CONN_STATE_FREE: /* MUST NOT re-close TCP conn if already .. */
case NET_TCP_CONN_STATE_CLOSED: /* .. free/closed (see Note #4). */
default:
return; /* Prevent 'break NOT reachable' warning. */
}
/* ---------------- CLOSE CONN(S) ----------------- */
NetConn_CloseFromTransport(pconn->ID_Conn, close_conn_app);
pconn->ID_Conn = NET_CONN_ID_NONE; /* Clr TCP conn's net conn id. */
/* ---------------- FREE TCP CONN ----------------- */
free_code = (NET_TCP_FREE_CODE)close_code; /* See Note #3. */
NetTCP_ConnFreeHandler(pconn, free_code);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnCloseTimeout()
*
* Description : Close a TCP connection on timeout.
*
* Argument(s) : pconn_timeout Pointer to a TCP connection (see Note #1b).
*
* Return(s) : none.
*
* Caller(s) : Referenced in NetTCP_ConnReqClose(),
* various NetTCP_RxPktConnHandler() functions.
*
* Note(s) : (1) Ideally, network timer expiration functions could be defined as '[(void) (OBJECT *)]'
* type functions -- even though network timer API functions cast expiration functions
* to generic 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]').
*
* (a) (1) Unfortunately, ISO-IEC 9899-1999 ANSI-C, Section 6.3.2.3.7 states that "a
* pointer to an object ... may be converted to a pointer to a different object
* ... [but] if the resulting pointer is not correctly aligned ... the behavior
* is undefined".
*
* And since compilers may NOT correctly convert 'void' pointers to non-'void'
* pointer arguments, network timer expiration functions MUST avoid incorrect
* pointer conversion behavior between 'void' pointer parameters & non-'void'
* pointer arguments & therefore CANNOT be defined as '[(void) (OBJECT *)]'.
*
* (2) However, Section 6.3.2.3.1 states that "a pointer to void may be converted
* to or from a pointer to any ... object ... A pointer to any ... object ...
* may be converted to a pointer to void and back again; the result shall
* compare equal to the original pointer".
*
* (b) Therefore, to correctly convert 'void' pointer objects back to appropriate
* network object pointer objects, network timer expiration functions MUST :
*
* (1) Be defined as 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]'); & ...
* (2) Explicitly cast 'void' pointer arguments to specific object pointers; ...
* (A) ... in this case, a 'NET_TCP_CONN' pointer.
*
* See also 'net_tmr.c NetTmr_Get() Note #3'.
*
* (2) This function is a network timer expiration function :
*
* (a) (1) For the following connection timer(s) ... :
*
* (A) TCP connection timeout timer ('TimeoutTmr')
*
* (2) (A) Clear the timer pointer; ...
* (1) Cleared in NetTCP_ConnFreeTmr() via NetTCP_ConnClose(),
* NetTCP_ConnCloseHandler().
*
* (B) but do NOT re-free the timer.
*
* (b) Do NOT set the following close timer flag(s) :
*
* (1) NET_TCP_CONN_CLOSE_TMR_TIMEOUT
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_ConnCloseTimeout (void *pconn_timeout)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
NET_TCP_CLOSE_CODE close_code;
pconn = (NET_TCP_CONN *)pconn_timeout; /* See Note #1b2A. */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
/* ---------------- VALIDATE PTR ------------------ */
if (pconn == (NET_TCP_CONN *)0) {
NET_CTR_ERR_INC(NetTCP_ErrNullPtrCtr);
return;
}
/* ---------------- VALIDATE TYPE ----------------- */
if (pconn->Type != NET_TCP_TYPE_CONN) {
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidTypeCtr);
return;
}
#endif
/* ---------------- CLOSE TCP CONN ---------------- */
close_code = NET_TCP_CONN_CLOSE_ALL;
DEF_BIT_CLR(close_code, NET_TCP_CONN_CLOSE_TMR_TIMEOUT); /* See Note #2b1. */
if (pconn->ConnCloseTimeoutFaultFlag != DEF_NO) { /* If TCP conn timeout fault, ... */
/* ... fault-close TCP conn. */
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )pconn->ConnCloseAppFlag,
(NET_TCP_CLOSE_CODE)close_code);
} else { /* Else close TCP conn. */
NetTCP_ConnCloseHandler((NET_TCP_CONN *)pconn,
(CPU_BOOLEAN )pconn->ConnCloseAppFlag,
(NET_TCP_CLOSE_CODE)close_code);
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnClosingTimeoutDataAvail()
*
* Description : (1) Handle closing TCP connection with available application data :
*
* (a) If TCP connection's application receive queue is now empty,
* close the TCP connection
* (b) If TCP connection's application receive queue is still NOT empty
* after the time-wait timeout, set the user connection timeout
*
* See also 'NetTCP_RxPktConnHandlerFinWait1() Note #2f5A2b',
* 'NetTCP_RxPktConnHandlerFinWait2() Note #2f5B2',
* & 'NetTCP_RxPktConnHandlerClosing() Note #2d2B2a1B2'.
*
*
* Argument(s) : pconn_timeout Pointer to a TCP connection (see Note #2b).
*
* Return(s) : none.
*
* Caller(s) : Referenced in NetTCP_RxPktConnHandlerFinWait1(),
* NetTCP_RxPktConnHandlerFinWait2(),
* NetTCP_RxPktConnHandlerClosing().
*
* Note(s) : (2) Ideally, network timer expiration functions could be defined as '[(void) (OBJECT *)]'
* type functions -- even though network timer API functions cast expiration functions
* to generic 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]').
*
* (a) (1) Unfortunately, ISO-IEC 9899-1999 ANSI-C, Section 6.3.2.3.7 states that "a
* pointer to an object ... may be converted to a pointer to a different object
* ... [but] if the resulting pointer is not correctly aligned ... the behavior
* is undefined".
*
* And since compilers may NOT correctly convert 'void' pointers to non-'void'
* pointer arguments, network timer expiration functions MUST avoid incorrect
* pointer conversion behavior between 'void' pointer parameters & non-'void'
* pointer arguments & therefore CANNOT be defined as '[(void) (OBJECT *)]'.
*
* (2) However, Section 6.3.2.3.1 states that "a pointer to void may be converted
* to or from a pointer to any ... object ... A pointer to any ... object ...
* may be converted to a pointer to void and back again; the result shall
* compare equal to the original pointer".
*
* (b) Therefore, to correctly convert 'void' pointer objects back to appropriate
* network object pointer objects, network timer expiration functions MUST :
*
* (1) Be defined as 'CPU_FNCT_PTR' type (i.e. '[(void) (void *)]'); & ...
* (2) Explicitly cast 'void' pointer arguments to specific object pointers; ...
* (A) ... in this case, a 'NET_TCP_CONN' pointer.
*
* See also 'net_tmr.c NetTmr_Get() Note #3'.
*
* (3) This function is a network timer expiration function :
*
* (a) (1) For the following connection timer(s) ... :
*
* (A) TCP connection timeout timer ('TimeoutTmr')
*
* (2) (A) Clear the timer pointer; ...
* (1) Cleared in NetTCP_ConnFreeTmr() via NetTCP_ConnCloseHandler(),
* NetTCP_ConnClose(); or
* (2) Reset by NetTmr_Get().
*
* (B) but do NOT re-free the timer.
*
* (b) Do NOT set the following close timer flag(s) :
*
* (1) NET_TCP_CONN_CLOSE_TMR_TIMEOUT
*
* (4) RFC #793, Section 3.9 'Event Processing : USER TIMEOUT : USER TIMEOUT' states that
* "for any state if the user timeout expires, flush all queues, signal the user
* 'error : connection aborted due to user timeout' ... [and] enter the CLOSED state".
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_ConnClosingTimeoutDataAvail (void *pconn_timeout)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
NET_TCP_CONN *pconn;
NET_TCP_CLOSE_CODE close_code;
CPU_BOOLEAN data_avail;
NET_TCP_TIMEOUT_SEC timeout_sec;
NET_TMR_TICK timeout_tick;
NET_ERR err;
pconn = (NET_TCP_CONN *)pconn_timeout; /* See Note #2b2A. */
close_code = NET_TCP_CONN_CLOSE_ALL;
DEF_BIT_CLR(close_code, NET_TCP_CONN_CLOSE_TMR_TIMEOUT); /* See Note #3b1. */
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED)
/* ---------------- VALIDATE PTR ------------------ */
if (pconn == (NET_TCP_CONN *)0) {
NET_CTR_ERR_INC(NetTCP_ErrNullPtrCtr);
return;
}
/* ---------------- VALIDATE TYPE ----------------- */
if (pconn->Type != NET_TCP_TYPE_CONN) {
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidTypeCtr);
return;
}
#endif
/* Closing data avail for half-closed conns ONLY. */
data_avail = ((pconn->ConnCloseCode != NET_CONN_CLOSE_HALF ) ||
((pconn->RxQ_State == NET_TCP_RX_Q_STATE_CONN_CLOSED) &&
(pconn->RxQ_App_Head == (NET_BUF *)0))) ? DEF_NO : DEF_YES;
if (data_avail != DEF_YES) { /* If NO app data avail, ... */
/* ... close TCP conn (see Note #1a). */
NetTCP_ConnCloseHandler((NET_TCP_CONN *)pconn,
(CPU_BOOLEAN )pconn->ConnCloseAppFlag,
(NET_TCP_CLOSE_CODE)close_code);
} else { /* Else reset user tmr (see Notes #1b & #4). */
timeout_sec = pconn->TimeoutUser_sec;
timeout_tick = (NET_TMR_TICK)timeout_sec * NET_TMR_TIME_TICK_PER_SEC;
pconn->TimeoutTmr = NetTmr_Get((void *) pconn,
(CPU_FNCT_PTR) NetTCP_ConnCloseTimeout,
(NET_TMR_TICK) timeout_tick,
(CPU_INT16U ) NET_TMR_FLAG_NONE,
(NET_ERR *)&err);
if (err != NET_TMR_ERR_NONE) {
NetTCP_ConnClose((NET_TCP_CONN *)pconn,
(NET_BUF_HDR *)0,
(CPU_BOOLEAN )pconn->ConnCloseAppFlag,
(NET_TCP_CLOSE_CODE)close_code);
return;
}
pconn->ConnCloseAppFlag = DEF_YES;
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnFreeHandler()
*
* Description : (1) Free a TCP connection :
*
* (a) Free TCP connection timers
* (b) Free TCP connection packet buffer queues
* (c) Clear TCP connection controls
* (d) Free TCP connection back to TCP connection pool
* (e) Update TCP connection pool statistics
*
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_ConnFree(),
* NetTCP_ConnClose().
*
* free_code Select which free action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_FREE_TMR_NONE Free NO timers.
* NET_TCP_CONN_FREE_TMR_ALL Free ALL timers.
*
* NET_TCP_CONN_FREE_TMR_TX_IDLE Free transmit idle timer.
* NET_TCP_CONN_FREE_TMR_TX_SILLY_WIN Free transmit silly window persist timer.
* NET_TCP_CONN_FREE_TMR_TX_ZERO_WIN Free transmit zero window persist timer.
* NET_TCP_CONN_FREE_TMR_TX_ACK_DLY Free transmit acknowledgement delay timer.
* NET_TCP_CONN_FREE_TMR_RE_TX Free re-transmit timer.
* NET_TCP_CONN_FREE_TMR_KEEP_ALIVE Free connection keep-alive timer.
* NET_TCP_CONN_FREE_TMR_TIMEOUT Free connection timer.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES'.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_ConnFree(),
* NetTCP_ConnClose().
*
* Note(s) : (2) ALL network resources linked to the TCP connection MUST be freed PRIOR to TCP connection
* free or discard so that no network resources are lost.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_ConnFreeHandler (NET_TCP_CONN *pconn,
NET_TCP_FREE_CODE free_code)
{
#if ((NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) && \
(NET_CTR_CFG_ERR_EN == DEF_ENABLED) && \
(CPU_CFG_CRITICAL_METHOD == CPU_CRITICAL_METHOD_STATUS_LOCAL))
CPU_SR cpu_sr;
#endif
CPU_BOOLEAN discard;
NET_ERR err;
#if (NET_ERR_CFG_ARG_CHK_DBG_EN == DEF_ENABLED) /* ---------------- VALIDATE TYPE ----------------- */
if (pconn->Type != NET_TCP_TYPE_CONN) {
NetTCP_ConnDiscard(pconn);
NET_CTR_ERR_INC(NetTCP_ErrConnInvalidTypeCtr);
return;
}
#endif
/* -------------- FREE TCP CONN TMRs -------------- */
NetTCP_ConnFreeTmr(pconn, free_code);
/* -------------- FREE TCP CONN Q's --------------- */
NetTCP_ConnFreeBufQ(&pconn->RxQ_Transport_Head, &pconn->RxQ_Transport_Tail);
NetTCP_ConnFreeBufQ(&pconn->RxQ_App_Head , &pconn->RxQ_App_Tail );
NetTCP_ConnFreeBufQ(&pconn->TxQ_Head , &pconn->TxQ_Tail );
NetTCP_ConnFreeBufQ(&pconn->ReTxQ_Head , &pconn->ReTxQ_Tail );
discard = DEF_NO;
NetOS_TCP_RxQ_Clr(pconn->ID, &err); /* Clr TCP conn rx Q. */
if (err != NET_TCP_ERR_NONE) { /* If TCP conn rx Q NOT clr'd, ... */
discard = DEF_YES; /* ... discard TCP conn (see Note #2b). */
}
NetOS_TCP_RxQ_Abort(pconn->ID, &err); /* Abort wait on TCP conn rx Q. */
NetOS_TCP_TxQ_Clr(pconn->ID, &err); /* Clr TCP conn tx Q. */
if (err != NET_TCP_ERR_NONE) { /* If TCP conn tx Q NOT clr'd, ... */
discard = DEF_YES; /* ... discard TCP conn (see Note #2b). */
}
NetOS_TCP_TxQ_Abort(pconn->ID, &err); /* Abort wait on TCP conn tx Q. */
/* ---------- DISCARD TCP CONN ON ERR(S) ---------- */
if (discard != DEF_NO) { /* On TCP conn free err(s), ... */
NetTCP_ConnDiscard(pconn); /* ... discard TCP conn (see Note #2a). */
return;
}
/* ----------------- CLR TCP CONN ----------------- */
pconn->ConnState = NET_TCP_CONN_STATE_FREE; /* Set TCP conn as freed/NOT used. */
DEF_BIT_CLR(pconn->Flags, NET_TCP_FLAG_USED);
#if (NET_DBG_CFG_MEM_CLR_EN == DEF_ENABLED)
NetTCP_ConnClr(pconn);
#endif
/* ---------------- FREE TCP CONN ----------------- */
pconn->NextPtr = (void *)NetTCP_ConnPoolPtr;
NetTCP_ConnPoolPtr = (NET_TCP_CONN *)pconn;
/* ---------- UPDATE TCP CONN POOL STATS ---------- */
NetStat_PoolEntryUsedDec(&NetTCP_ConnPoolStat, &err);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnFreeTmr()
*
* Description : Clear TCP connection's timers.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_ConnFreeHandler(),
* various NetTCP_ConnHandler() functions.
*
* free_code Select which free action(s) to perform; bit-field flags logically OR'd :
*
* NET_TCP_CONN_FREE_TMR_NONE Free NO timers.
* NET_TCP_CONN_FREE_TMR_ALL Free ALL timers.
*
* NET_TCP_CONN_FREE_TMR_TX_IDLE Free transmit idle timer.
* NET_TCP_CONN_FREE_TMR_TX_SILLY_WIN Free transmit silly window persist timer.
* NET_TCP_CONN_FREE_TMR_TX_ZERO_WIN Free transmit zero window persist timer.
* NET_TCP_CONN_FREE_TMR_TX_ACK_DLY Free transmit acknowledgement delay timer.
* NET_TCP_CONN_FREE_TMR_RE_TX Free re-transmit timer.
* NET_TCP_CONN_FREE_TMR_KEEP_ALIVE Free connection keep-alive timer.
* NET_TCP_CONN_FREE_TMR_TIMEOUT Free connection timer.
*
* See also 'TCP CONNECTION CLOSE/FREE CODE DEFINES'.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_ConnFreeHandler(),
* various NetTCP_ConnHandler() functions.
*
* Note(s) : none.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_ConnFreeTmr (NET_TCP_CONN *pconn,
NET_TCP_FREE_CODE free_code)
{
CPU_BOOLEAN free_tmr;
free_tmr = DEF_BIT_IS_SET(free_code, NET_TCP_CONN_FREE_TMR_TX_IDLE);
if (free_tmr == DEF_YES) {
if (pconn->TxQ_IdleTmr != (NET_TMR *)0) {
NetTmr_Free(pconn->TxQ_IdleTmr);
pconn->TxQ_IdleTmr = (NET_TMR *)0;
}
}
free_tmr = DEF_BIT_IS_SET(free_code, NET_TCP_CONN_FREE_TMR_TX_SILLY_WIN);
if (free_tmr == DEF_YES) {
if (pconn->TxQ_SillyWinTmr != (NET_TMR *)0) {
NetTmr_Free(pconn->TxQ_SillyWinTmr);
pconn->TxQ_SillyWinTmr = (NET_TMR *)0;
}
}
free_tmr = DEF_BIT_IS_SET(free_code, NET_TCP_CONN_FREE_TMR_TX_ZERO_WIN);
if (free_tmr == DEF_YES) {
if (pconn->TxQ_ZeroWinTmr != (NET_TMR *)0) {
NetTmr_Free(pconn->TxQ_ZeroWinTmr);
pconn->TxQ_ZeroWinTmr = (NET_TMR *)0;
}
}
free_tmr = DEF_BIT_IS_SET(free_code, NET_TCP_CONN_FREE_TMR_TX_ACK_DLY);
if (free_tmr == DEF_YES) {
if (pconn->TxAckDlyTmr != (NET_TMR *)0) {
NetTmr_Free(pconn->TxAckDlyTmr);
pconn->TxAckDlyTmr = (NET_TMR *)0;
}
}
free_tmr = DEF_BIT_IS_SET(free_code, NET_TCP_CONN_FREE_TMR_RE_TX);
if (free_tmr == DEF_YES) {
if (pconn->ReTxQ_Tmr != (NET_TMR *)0) {
NetTmr_Free(pconn->ReTxQ_Tmr);
pconn->ReTxQ_Tmr = (NET_TMR *)0;
}
}
free_tmr = DEF_BIT_IS_SET(free_code, NET_TCP_CONN_FREE_TMR_KEEP_ALIVE);
if (free_tmr == DEF_YES) {
if (pconn->KeepAliveTmr != (NET_TMR *)0) {
NetTmr_Free(pconn->KeepAliveTmr);
pconn->KeepAliveTmr = (NET_TMR *)0;
}
}
free_tmr = DEF_BIT_IS_SET(free_code, NET_TCP_CONN_FREE_TMR_TIMEOUT);
if (free_tmr == DEF_YES) {
if (pconn->TimeoutTmr != (NET_TMR *)0) {
NetTmr_Free(pconn->TimeoutTmr);
pconn->TimeoutTmr = (NET_TMR *)0;
}
}
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnFreeBufQ()
*
* Description : Free a TCP connection's buffer queue.
*
* Argument(s) : pbuf_q_head Pointer to a TCP connection buffer queue's head pointer.
*
* pbuf_q_tail Pointer to a TCP connection buffer queue's tail pointer.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerRxQ_Sync(),
* NetTCP_TxConnSync(),
* NetTCP_ConnFreeHandler().
*
* Note(s) : none.
*********************************************************************************************************
*/
static void NetTCP_ConnFreeBufQ (NET_BUF **pbuf_q_head,
NET_BUF **pbuf_q_tail)
{
NET_BUF *pbuf_q;
/* Free buf Q. */
pbuf_q = *pbuf_q_head;
NetBuf_FreeBufQ_PrimList((NET_BUF *)pbuf_q,
(NET_CTR *)0);
/* Clr buf Q ptrs to NULL. */
*pbuf_q_head = (NET_BUF *)0;
*pbuf_q_tail = (NET_BUF *)0;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnClr()
*
* Description : Clear TCP connection controls.
*
* Argument(s) : pconn Pointer to a TCP connection.
* ----- Argument validated in NetTCP_Init(),
* NetTCP_ConnGet(),
* NetTCP_ConnFreeHandler().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_Init(),
* NetTCP_ConnGet(),
* NetTCP_ConnFreeHandler().
*
* Note(s) : (1) Configured in NetTCP_ConnCfg() :
*
* (a) Configured in NetTCP_ConnCfgMaxSegSize().
*
* (b) Configured in NetTCP_RxConnWinSizeCfg() :
* (1) Configured in NetTCP_RxConnWinSizeCfgUpdateTh().
*
* (c) Configured in NetTCP_TxConnWinSizeCfg() :
* (1) Configured in NetTCP_TxConnWinSizeCfgCongCtrl().
* (2) Configured in NetTCP_TxConnWinSizeCfgMinTh().
*
* (d) Initialized in NetTCP_TxConnRTT_RTO_Init().
* (1) Configured in NetTCP_TxConnRTO_CfgMaxTimeout().
*
* (2) See 'NetTCP_RxPktConnHandler() Note #3c'.
*
* (3) (a) See 'net_tcp.h TCP SEGMENT SIZE DEFINES Note #1b1'.
* (b) See 'net_tcp.h TCP SEGMENT SIZE DEFINES Note #1b2'.
*
* (4) See 'net_cfg.h TRANSMISSION CONTROL PROTOCOL LAYER CONFIGURATION Note #2'.
*
* (5) See 'NetTCP_TxConnTxQ() Note #6b2B2'.
*
* (6) See 'net_tcp.h TCP CONGESTION CONTROL DEFINES Note #5b4'.
*
* (7) See 'NetTCP_TxConnWinSizeZeroWinHandler() Note #1b2'.
*
* (8) See 'net_tcp.h TCP CONGESTION CONTROL DEFINES Note #7'.
*
* (9) See 'net_tcp.h TCP CONGESTION CONTROL DEFINES Note #6b'.
*
* (10) See 'NetTCP_TxConnAck() Note #4a4A1'.
*
* (11) See 'NetTCP_ConnCfgReTxMaxTimeout() Note #1'.
*
* (12) See ####
*
* (13) See 'NetTCP_RxPktConnHandlerConn() Note #3a'.
*
* (14) See 'net_tcp.h TCP CONNECTION TIMEOUT DEFINES Note #1b'.
*********************************************************************************************************
*/
/*$PAGE*/
static void NetTCP_ConnClr (NET_TCP_CONN *pconn)
{
NET_TCP_CONN_ID conn_id_tcp;
NET_ERR err;
pconn->NextPtr = (void *)0;
pconn->ID_Conn = NET_CONN_ID_NONE;
pconn->ConnState = NET_TCP_CONN_STATE_FREE;
pconn->ConnCloseCode = NET_CONN_CLOSE_FULL; /* See Note #2. */
pconn->ConnCloseAppFlag = DEF_YES;
pconn->ConnCloseTimeoutFaultFlag = DEF_YES;
pconn->MaxSegSizeLocal = NET_TCP_MAX_SEG_SIZE_DFLT_RX; /* See Note #3a. */
pconn->MaxSegSizeRemote = NET_TCP_MAX_SEG_SIZE_DFLT_TX; /* See Note #3b. */
#if 0 /* See Note #1a. */
pconn->MaxSegSizeConn = NET_TCP_MAX_SEG_SIZE_NONE;
#endif
pconn->RxSeqNbrSync = NET_TCP_SEQ_NBR_NONE;
pconn->RxSeqNbrNext = NET_TCP_SEQ_NBR_NONE;
pconn->RxSeqNbrLast = NET_TCP_SEQ_NBR_NONE;
pconn->RxSeqNbrClose = NET_TCP_SEQ_NBR_NONE;
pconn->RxWinSizeCfgd = NET_TCP_CFG_RX_WIN_SIZE_OCTET; /* See Note #4. */
pconn->RxWinSizeCfgdActualUpdateRem = NET_TCP_WIN_SIZE_NONE;
pconn->RxWinSizeCfgdActual = pconn->RxWinSizeCfgd;
pconn->RxWinSizeCalcd = pconn->RxWinSizeCfgd;
pconn->RxWinSizeActual = pconn->RxWinSizeCfgd;
#if 0 /* See Note #1b1. */
pconn->RxWinSizeUpdateTh = NET_TCP_WIN_SIZE_NONE;
#endif
pconn->RxQ_State = NET_TCP_RX_Q_STATE_CONN_CLOSED;
pconn->RxQ_Transport_Head = (NET_BUF *)0;
pconn->RxQ_Transport_Tail = (NET_BUF *)0;
pconn->RxQ_App_Head = (NET_BUF *)0;
pconn->RxQ_App_Tail = (NET_BUF *)0;
pconn->TxSeqNbrSync = NET_TCP_SEQ_NBR_NONE;
pconn->TxSeqNbrNext = NET_TCP_SEQ_NBR_NONE;
pconn->TxSeqNbrNextQ = NET_TCP_SEQ_NBR_NONE;
pconn->TxSeqNbrUnReTxd = NET_TCP_SEQ_NBR_NONE;
pconn->TxSeqNbrUnAckd = NET_TCP_SEQ_NBR_NONE;
pconn->TxSeqNbrUnAckdPrev = NET_TCP_SEQ_NBR_NONE;
pconn->TxSeqNbrUnAckdAlignDelta = 0;
pconn->TxSeqNbrLast = NET_TCP_SEQ_NBR_NONE;
pconn->TxSeqNbrClose = NET_TCP_SEQ_NBR_NONE;
pconn->TxWinUpdateSeqNbr = NET_TCP_SEQ_NBR_NONE;
pconn->TxWinUpdateAckNbr = NET_TCP_ACK_NBR_NONE;
pconn->TxWinUpdateWinSize = NET_TCP_WIN_SIZE_NONE;
pconn->TxWinSizeCfgd = NET_TCP_CFG_TX_WIN_SIZE_OCTET; /* See Note #4. */
pconn->TxWinSizeCfgdRem = pconn->TxWinSizeCfgd;
pconn->TxWinSizeRemote = NET_TCP_WIN_SIZE_NONE;
pconn->TxWinSizeRemoteMax = pconn->TxWinSizeRemote;
pconn->TxWinSizeRemoteActual = pconn->TxWinSizeRemote;
pconn->TxWinSizeRemoteRem = pconn->TxWinSizeRemote;
pconn->TxWinSizeNagleEn = DEF_ENABLED; /* See Note #5. */
pconn->TxWinSillyWinTimeout_ms = NET_TCP_TX_SILLY_WIN_TIMEOUT_DFLT_MS; /* See Note #6. */
pconn->TxWinZeroWinTimeout_ms = 0; /* See Note #7. */
#if 0 /* See Note #1c. */
pconn->TxWinRxdAckDupCtr = 0;
pconn->TxWinRxdLastSeqNbr = NET_TCP_SEQ_NBR_NONE;
pconn->TxWinRxdLastAckNbr = NET_TCP_ACK_NBR_NONE;
pconn->TxWinRxdLastWinSize = NET_TCP_WIN_SIZE_NONE;
pconn->TxWinSizeSlowStartTh = NET_TCP_WIN_SIZE_NONE;
pconn->TxWinSizeSlowStartThInit = NET_TCP_WIN_SIZE_NONE;
pconn->TxWinSizeCongInit = NET_TCP_WIN_SIZE_NONE;
pconn->TxWinSizeCongCalcdActual = NET_TCP_WIN_SIZE_NONE;
pconn->TxWinSizeCongCalcdCur = NET_TCP_WIN_SIZE_NONE;
pconn->TxWinSizeCongRem = NET_TCP_WIN_SIZE_NONE;
pconn->TxWinSizeAvail = NET_TCP_WIN_SIZE_NONE;
pconn->TxWinSizeMinTh = NET_TCP_WIN_SIZE_NONE;
#endif
/*$PAGE*/
pconn->TxSegReTxTh = NET_TCP_RE_TX_TH_DFLT; /* See Note #8. */
pconn->TxAckDlyTimeout_ms = NET_TCP_CFG_TIMEOUT_CONN_ACK_DLY_MS; /* See Note #9. */
pconn->TxAckDlyTmr = (NET_TMR *)0;
pconn->TxAckDlyCnt = 0;
pconn->TxAckImmedRxdPushEn = DEF_ENABLED; /* See Note #10. */
pconn->TxRTT_RTO_Max_sec = NET_TCP_TX_RTO_MAX_TIMEOUT_DFLT_SEC; /* See Note #11. */
#if 0 /* See Note #1d. */
pconn->TxRTT_Avg_ms_scaled = NET_TCP_TX_RTT_NONE;
pconn->TxRTT_Dev_ms_scaled = NET_TCP_TX_RTT_NONE;
pconn->TxRTT_RTO_ms_scaled = NET_TCP_TX_RTO_NONE;
pconn->TxRTT_RTO_Max_ms_scaled = NET_TCP_TX_RTO_NONE; /* See Note #1d1. */
pconn->TxRTT_Avg_ms = NET_TCP_TX_RTT_NONE;
pconn->TxRTT_Dev_ms = NET_TCP_TX_RTT_NONE;
pconn->TxRTT_RTO_ms = NET_TCP_TX_RTO_NONE;
pconn->TxRTT_RTO_Max_ms = NET_TCP_TX_RTO_NONE; /* See Note #1d1. */
pconn->TxRTT_RTO_sec = NET_TCP_TX_RTO_NONE;
pconn->TxRTT_RTO_tick = NET_TMR_TIME_0S;
pconn->TxRTT_RTO_State = NET_TCP_TX_RTT_RTO_STATE_NONE;
#endif
pconn->TxIP_TOS = NET_IP_TOS_DFLT;
pconn->TxIP_TTL = NET_IP_TTL_DFLT;
pconn->TxIP_Flags = NET_IP_FLAG_NONE;
pconn->TxQ_State = NET_TCP_TX_Q_STATE_CONN_CLOSED;
pconn->TxQ_Head = (NET_BUF *)0;
pconn->TxQ_Tail = (NET_BUF *)0;
pconn->TxQ_IdleTmr = (NET_TMR *)0;
pconn->TxQ_SillyWinTmr = (NET_TMR *)0;
pconn->TxQ_ZeroWinTmr = (NET_TMR *)0;
pconn->ReTxQ_Head = (NET_BUF *)0;
pconn->ReTxQ_Tail = (NET_BUF *)0;
pconn->ReTxQ_Tmr = (NET_TMR *)0;
pconn->KeepAliveTmr = (NET_TMR *)0;
pconn->TimeoutTmr = (NET_TMR *)0;
pconn->TimeoutConn_sec = NET_TCP_CONN_TIMEOUT_CONN_DFLT_SEC; /* See Note #12. */
pconn->TimeoutUser_sec = NET_TCP_CONN_TIMEOUT_USER_DFLT_SEC; /* See Note #13. */
pconn->TimeoutMaxSeg_sec = NET_TCP_CFG_TIMEOUT_CONN_MAX_SEG_SEC; /* See Note #14. */
pconn->Flags = NET_TCP_FLAG_NONE;
NetTCP_ConnCfg(pconn, NET_TCP_CONN_CFG_ALL); /* See Note #1. */
/* -- CFG DFLT TIMEOUT VALS --- */
conn_id_tcp = pconn->ID;
NetOS_TCP_RxQ_TimeoutDflt(conn_id_tcp, &err);
NetOS_TCP_TxQ_TimeoutDflt(conn_id_tcp, &err);
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnCopy()
*
* Description : (1) Copy/clone a TCP connection :
*
* (a) TCP connection state
*
* (b) Receive parameters :
* (1) Receive window size
*
* (c) Transmit parameters :
* (1) Transmit window size
*
* (2) Re-transmit parameters :
* (A) Threshold
* (B) Maximum timeout
*
* (3) IP transmit parameters :
* (A) TOS
* (B) TTL
* (C) IP flags
*
* (d) TCP connection timeout values
*
*
* Argument(s) : pconn_dest Pointer to TCP connection to receive TCP connection copy.
* ---------- Argument validated in NetTCP_RxPktConnHandlerListen().
*
* pconn_src Pointer to TCP connection to copy.
* --------- Argument validated in NetTCP_RxPktConnHandlerListen().
*
* Return(s) : none.
*
* Caller(s) : NetTCP_RxPktConnHandlerListen().
*
* Note(s) : none.
*********************************************************************************************************
*/
static void NetTCP_ConnCopy (NET_TCP_CONN *pconn_dest,
NET_TCP_CONN *pconn_src)
{
pconn_dest->ConnState = pconn_src->ConnState;
pconn_dest->RxWinSizeCfgd = pconn_src->RxWinSizeCfgd;
pconn_dest->TxWinSizeCfgd = pconn_src->TxWinSizeCfgd;
pconn_dest->TxWinSizeNagleEn = pconn_src->TxWinSizeNagleEn;
pconn_dest->TxSegReTxTh = pconn_src->TxSegReTxTh;
pconn_dest->TxAckDlyTimeout_ms = pconn_src->TxAckDlyTimeout_ms;
pconn_dest->TxAckImmedRxdPushEn = pconn_src->TxAckImmedRxdPushEn;
pconn_dest->TxRTT_RTO_Max_sec = pconn_src->TxRTT_RTO_Max_sec;
pconn_dest->TxIP_TOS = pconn_src->TxIP_TOS;
pconn_dest->TxIP_TTL = pconn_src->TxIP_TTL;
pconn_dest->TxIP_Flags = pconn_src->TxIP_Flags;
pconn_dest->TimeoutConn_sec = pconn_src->TimeoutConn_sec;
pconn_dest->TimeoutUser_sec = pconn_src->TimeoutUser_sec;
pconn_dest->TimeoutMaxSeg_sec = pconn_src->TimeoutMaxSeg_sec;
}
/*$PAGE*/
/*
*********************************************************************************************************
* NetTCP_ConnDiscard()
*
* Description : (1) Discard an invalid/corrupted TCP connection :
*
* (a) Discard TCP connection from available TCP connection pool See Note #2
* (b) Update TCP connection pool statistics
*
* (2) Assumes TCP connection is invalid/corrupt & MUST be removed. TCP connection removed
* simply by NOT returning the TCP connection back to the TCP connection pool.
*
*
* Argument(s) : pconn Pointer to an invalid/corrupted TCP connection.
*
* Return(s) : none.
*
* Caller(s) : NetTCP_ConnGet(),
* NetTCP_ConnFree().
*
* Note(s) : none.
*********************************************************************************************************
*/
static void NetTCP_ConnDiscard (NET_TCP_CONN *pconn)
{
NET_ERR stat_err;
/* ----------------- DISCARD TCP CONN ----------------- */
(void)&pconn; /* Prevent compiler warning (see Note #2). */
/* --------------- UPDATE DISCARD STATS --------------- */
NetStat_PoolEntryLostInc(&NetTCP_ConnPoolStat, &stat_err);
}
/*$PAGE*/
/*
*********************************************************************************************************
* MODULE END
*
* Note(s) : (1) See 'MODULE Note #1' & 'net_tcp.h MODULE Note #1'.
*********************************************************************************************************
*/
#endif /* End of TCP module include (see Note #1). */
Reference in New Issue View Git Blame Copy Permalink