inet::tcp Namespace Reference

Classes
class	DumbTCP
	A very-very basic TCPAlgorithm implementation, with hardcoded retransmission timeout and no other sophistication. More...
class	DumbTCPStateVariables
	State variables for DumbTCP. More...
struct	icmp_echo_hdr
	This is the standard ICMP header only that the u32_t data is splitted to two u16_t like ICMP echo needs it. More...
struct	in_addr
struct	ip_addr
struct	ip_addr2
struct	ip_hdr
struct	ip_pcb
class	LwipTcpStackIf
	Interface class between TCP_lwIP and LwipTcpLayer. More...
struct	memp
struct	netbuf
struct	netif
	Generic data structure used for all lwIP network interfaces. More...
struct	nsc_iphdr
struct	nsc_ipv6hdr
struct	pbuf
class	Sack
class	Sack_Base
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:122 by nedtool. More...
class	SackItem
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:116 by nedtool. More...
struct	sys_timeo
struct	sys_timeouts
class	TCP
	Implements the TCP protocol. More...
class	TCP_lwIP
	Encapsulates a Network Simulation Cradle (NSC) instance. More...
class	TCP_NSC
	Encapsulates a Network Simulation Cradle (NSC) instance. More...
class	TCP_NSC_ByteStreamReceiveQueue
	Receive queue that manages actual bytes. More...
class	TCP_NSC_ByteStreamSendQueue
	Send queue that manages actual bytes. More...
class	TCP_NSC_Connection
	Encapsulates a Network Simulation Cradle (NSC) instance. More...
class	TCP_NSC_ReceiveQueue
class	TCP_NSC_SendQueue
	Abstract base class for TCP_NSC send queues. More...
class	TCP_NSC_VirtualDataReceiveQueue
	Send/Receive queue that manages "virtual bytes", that is, byte counts only. More...
class	TCP_NSC_VirtualDataSendQueue
	Send queue that manages "virtual bytes", that is, byte counts only. More...
class	TCPAlgorithm
	Abstract base class for TCP algorithms which encapsulate all behaviour during data transfer state: flavour of congestion control, fast retransmit/recovery, selective acknowledgement etc. More...
class	TCPBaseAlg
	Includes basic TCP algorithms: adaptive retransmission, PERSIST timer, keep-alive, delayed acks – EXCLUDING congestion control. More...
class	TCPBaseAlgStateVariables
	State variables for TCPBaseAlg. More...
class	TCPByteStreamRcvQueue
	TCP send queue that stores actual bytes. More...
class	TCPByteStreamSendQueue
	Send queue that manages messages. More...
class	TCPConnection
	Manages a TCP connection. More...
struct	tcpip_msg
class	TcpLwipByteStreamReceiveQueue
	Receive queue that manages "data stream", that is, actual bytes. More...
class	TcpLwipByteStreamSendQueue
	Send queue that manages "data stream", that is, actual bytes. More...
class	TcpLwipConnection
class	TcpLwipMsgBasedReceiveQueue
	Receive queue that manages "objects". More...
class	TcpLwipMsgBasedSendQueue
	Send queue that manages "objects". More...
class	TcpLwipReceiveQueue
class	TcpLwipSendQueue
	Abstract base class for TCP_LWIP send queues. More...
class	TcpLwipVirtualDataReceiveQueue
	Receive queue that manages "virtual bytes", that is, byte counts only. More...
class	TcpLwipVirtualDataSendQueue
	Send queue that manages "virtual bytes", that is, byte counts only. More...
class	TCPMsgBasedRcvQueue
class	TCPMsgBasedSendQueue
	Send queue that manages messages. More...
class	TCPNewReno
	Implements TCP NewReno. More...
class	TCPNoCongestionControl
	TCP with no congestion control (i.e. More...
class	TCPOption
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:129 by nedtool. More...
class	TCPOptionEnd
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:135 by nedtool. More...
class	TCPOptionMaxSegmentSize
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:147 by nedtool. More...
class	TCPOptionNop
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:141 by nedtool. More...
class	TCPOptionSack
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:167 by nedtool. More...
class	TCPOptionSackPermitted
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:161 by nedtool. More...
class	TCPOptionTimestamp
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:174 by nedtool. More...
class	TCPOptionUnknown
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:182 by nedtool. More...
class	TCPOptionWindowScale
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:154 by nedtool. More...
struct	TCPPayloadMessage
	Struct generated from inet/transportlayer/tcp_common/TCPSegment.msg:63 by nedtool. More...
class	TCPReceiveQueue
	Abstract base class for TCP receive queues. More...
class	TCPReno
	Implements TCP Reno. More...
class	TCPSACKRexmitQueue
	Retransmission data for SACK. More...
class	TCPSegment
	Represents a TCP segment. More...
class	TCPSegment_Base
	Class generated from inet/transportlayer/tcp_common/TCPSegment.msg:202 by nedtool. More...
class	TCPSegmentTransmitInfoList
class	TCPSendQueue
	Abstract base class for TCP send queues. More...
class	TCPSpoof
	Sends fabricated TCP packets. More...
class	TCPStateVariables
	Contains state variables ("TCB") for TCP. More...
class	TCPTahoe
	Implements Tahoe. More...
class	TCPTahoeRenoFamily
	Provides utility functions to implement TCPTahoe, TCPReno and TCPNewReno. More...
class	TCPTahoeRenoFamilyStateVariables
	State variables for TCPTahoeRenoFamily. More...
class	TCPVegas
class	TCPVegasStateVariables
	State variables for TCPVegas. More...
class	TCPVirtualDataRcvQueue
	Receive queue that manages "virtual bytes", that is, byte counts only. More...
class	TCPVirtualDataSendQueue
	Send queue that manages "virtual bytes", that is, byte counts only. More...
class	TCPWestwood
class	TCPWestwoodStateVariables
	State variables for TCPWestwood. More...

Typedefs
typedef TCPTahoeRenoFamilyStateVariables	TCPNewRenoStateVariables
	State variables for TCPNewReno. More...
typedef TCPBaseAlgStateVariables	TCPNoCongestionControlStateVariables
	State variables for TCPNoCongestionControl. More...
typedef TCPTahoeRenoFamilyStateVariables	TCPRenoStateVariables
	State variables for TCPReno. More...
typedef TCPTahoeRenoFamilyStateVariables	TCPTahoeStateVariables
	State variables for TCPTahoe. More...
typedef std::list< Sack >	SackList
typedef TCPOption *	TCPOptionPtr
typedef cPacket *	cPacketPtr
typedef intptr_t	mem_ptr_t
typedef uint8_t	u8_t
typedef uint16_t	u16_t
typedef uint32_t	u32_t
typedef int8_t	s8_t
typedef int16_t	s16_t
typedef int32_t	s32_t
typedef void *	sys_sem_t
typedef void *	sys_mbox_t
typedef void *	sys_thread_t
typedef s8_t	err_t
	Define LWIP_ERR_T in cc.h if you want to use a different type for your platform (must be signed). More...
typedef void(*	sys_timeout_handler) (void *arg)

Enumerations
enum	TcpState {   TCP_S_INIT = 0, TCP_S_CLOSED = FSM_Steady(1), TCP_S_LISTEN = FSM_Steady(2), TCP_S_SYN_SENT = FSM_Steady(3),   TCP_S_SYN_RCVD = FSM_Steady(4), TCP_S_ESTABLISHED = FSM_Steady(5), TCP_S_CLOSE_WAIT = FSM_Steady(6), TCP_S_LAST_ACK = FSM_Steady(7),   TCP_S_FIN_WAIT_1 = FSM_Steady(8), TCP_S_FIN_WAIT_2 = FSM_Steady(9), TCP_S_CLOSING = FSM_Steady(10), TCP_S_TIME_WAIT = FSM_Steady(11) }
enum	TCPEventCode {   TCP_E_IGNORE, TCP_E_OPEN_ACTIVE, TCP_E_OPEN_PASSIVE, TCP_E_SEND,   TCP_E_CLOSE, TCP_E_ABORT, TCP_E_STATUS, TCP_E_QUEUE_BYTES_LIMIT,   TCP_E_READ, TCP_E_RCV_DATA, TCP_E_RCV_ACK, TCP_E_RCV_SYN,   TCP_E_RCV_SYN_ACK, TCP_E_RCV_FIN, TCP_E_RCV_FIN_ACK, TCP_E_RCV_RST,   TCP_E_RCV_UNEXP_SYN, TCP_E_TIMEOUT_2MSL, TCP_E_TIMEOUT_CONN_ESTAB, TCP_E_TIMEOUT_FIN_WAIT_2 }
enum	TCPOptionNumbers {   TCPOPTION_END_OF_OPTION_LIST = 0, TCPOPTION_NO_OPERATION = 1, TCPOPTION_MAXIMUM_SEGMENT_SIZE = 2, TCPOPTION_WINDOW_SCALE = 3,   TCPOPTION_SACK_PERMITTED = 4, TCPOPTION_SACK = 5, TCPOPTION_TIMESTAMP = 8 }
	Enum generated from inet/transportlayer/tcp_common/TCPSegment.msg:76 by nedtool. More...
enum	icmp_dur_type {   ICMP_DUR_NET = 0, ICMP_DUR_HOST = 1, ICMP_DUR_PROTO = 2, ICMP_DUR_PORT = 3,   ICMP_DUR_FRAG = 4, ICMP_DUR_SR = 5 }
enum	icmp_te_type { ICMP_TE_TTL = 0, ICMP_TE_FRAG = 1 }
enum	memp_t { MEMP_MAX }
enum	pbuf_layer { PBUF_TRANSPORT, PBUF_IP, PBUF_LINK, PBUF_RAW }
enum	pbuf_type { PBUF_RAM, PBUF_ROM, PBUF_REF, PBUF_POOL }
enum	snmp_ifType {   snmp_ifType_other =1, snmp_ifType_regular1822, snmp_ifType_hdh1822, snmp_ifType_ddn_x25,   snmp_ifType_rfc877_x25, snmp_ifType_ethernet_csmacd, snmp_ifType_iso88023_csmacd, snmp_ifType_iso88024_tokenBus,   snmp_ifType_iso88025_tokenRing, snmp_ifType_iso88026_man, snmp_ifType_starLan, snmp_ifType_proteon_10Mbit,   snmp_ifType_proteon_80Mbit, snmp_ifType_hyperchannel, snmp_ifType_fddi, snmp_ifType_lapb,   snmp_ifType_sdlc, snmp_ifType_ds1, snmp_ifType_e1, snmp_ifType_basicISDN,   snmp_ifType_primaryISDN, snmp_ifType_propPointToPointSerial, snmp_ifType_ppp, snmp_ifType_softwareLoopback,   snmp_ifType_eon, snmp_ifType_ethernet_3Mbit, snmp_ifType_nsip, snmp_ifType_slip,   snmp_ifType_ultra, snmp_ifType_ds3, snmp_ifType_sip, snmp_ifType_frame_relay }
enum	tcpip_msg_type { TCPIP_MSG_INPKT, TCPIP_MSG_CALLBACK, TCPIP_MSG_TIMEOUT, TCPIP_MSG_UNTIMEOUT }

Functions
	Register_Class (DumbTCP)
	Register_Class (TCPNewReno)
	Register_Class (TCPNoCongestionControl)
	Register_Class (TCPReno)
	Register_Class (TCPTahoe)
	Register_Class (TCPVegas)
	Register_Class (TCPWestwood)
	Register_Class (TCPByteStreamRcvQueue)
	Register_Class (TCPByteStreamSendQueue)
	Register_Class (TCPMsgBasedRcvQueue)
	Register_Class (TCPMsgBasedSendQueue)
	Register_Class (TCPVirtualDataRcvQueue)
	Register_Class (TCPVirtualDataSendQueue)
	Define_Module (TCP)
	Register_Class (Sack)
	Register_Class (TCPSegment)
std::ostream &	operator<< (std::ostream &os, cPacketPtr msg)
void	doPacking (cCommBuffer *b, cPacketPtr &msg)
void	doUnpacking (cCommBuffer *b, cPacketPtr &msg)
void INET_API	__doPacking (omnetpp::cCommBuffer *b, const TCPPayloadMessage &a)
void INET_API	__doUnpacking (omnetpp::cCommBuffer *b, TCPPayloadMessage &a)
void	doParsimPacking (omnetpp::cCommBuffer *b, const TCPPayloadMessage &obj)
void	doParsimUnpacking (omnetpp::cCommBuffer *b, TCPPayloadMessage &obj)
void	doParsimPacking (omnetpp::cCommBuffer *b, const SackItem &obj)
void	doParsimUnpacking (omnetpp::cCommBuffer *b, SackItem &obj)
void	doParsimPacking (omnetpp::cCommBuffer *b, const TCPOption &obj)
void	doParsimUnpacking (omnetpp::cCommBuffer *b, TCPOption &obj)
void	doParsimPacking (omnetpp::cCommBuffer *b, const TCPOptionEnd &obj)
void	doParsimUnpacking (omnetpp::cCommBuffer *b, TCPOptionEnd &obj)
void	doParsimPacking (omnetpp::cCommBuffer *b, const TCPOptionNop &obj)
void	doParsimUnpacking (omnetpp::cCommBuffer *b, TCPOptionNop &obj)
void	doParsimPacking (omnetpp::cCommBuffer *b, const TCPOptionMaxSegmentSize &obj)
void	doParsimUnpacking (omnetpp::cCommBuffer *b, TCPOptionMaxSegmentSize &obj)
void	doParsimPacking (omnetpp::cCommBuffer *b, const TCPOptionWindowScale &obj)
void	doParsimUnpacking (omnetpp::cCommBuffer *b, TCPOptionWindowScale &obj)
void	doParsimPacking (omnetpp::cCommBuffer *b, const TCPOptionSackPermitted &obj)
void	doParsimUnpacking (omnetpp::cCommBuffer *b, TCPOptionSackPermitted &obj)
void	doParsimPacking (omnetpp::cCommBuffer *b, const TCPOptionSack &obj)
void	doParsimUnpacking (omnetpp::cCommBuffer *b, TCPOptionSack &obj)
void	doParsimPacking (omnetpp::cCommBuffer *b, const TCPOptionTimestamp &obj)
void	doParsimUnpacking (omnetpp::cCommBuffer *b, TCPOptionTimestamp &obj)
void	doParsimPacking (omnetpp::cCommBuffer *b, const TCPOptionUnknown &obj)
void	doParsimUnpacking (omnetpp::cCommBuffer *b, TCPOptionUnknown &obj)
	Define_Module (TCPSpoof)
void	memp_init (void)
	Initialize this module. More...
void *	memp_malloc (memp_t type)
	Get an element from a specific pool. More...
void	memp_free (memp_t type, void *mem)
	Put an element back into its pool. More...
struct pbuf *	pbuf_alloc (pbuf_layer layer, u16_t length, pbuf_type type)
	Allocates a pbuf of the given type (possibly a chain for PBUF_POOL type). More...
void	pbuf_realloc (struct pbuf *p, u16_t new_len)
	Shrink a pbuf chain to a desired length. More...
u8_t	pbuf_header (struct pbuf *p, s16_t header_size_increment)
	Adjusts the payload pointer to hide or reveal headers in the payload. More...
u8_t	pbuf_free (struct pbuf *p)
	Dereference a pbuf chain or queue and deallocate any no-longer-used pbufs at the head of this chain or queue. More...
u8_t	pbuf_clen (struct pbuf *p)
	Count number of pbufs in a chain. More...
void	pbuf_ref (struct pbuf *p)
	Increment the reference count of the pbuf. More...
void	pbuf_cat (struct pbuf *h, struct pbuf *t)
	Concatenate two pbufs (each may be a pbuf chain) and take over the caller's reference of the tail pbuf. More...
void	pbuf_chain (struct pbuf *h, struct pbuf *t)
	Chain two pbufs (or pbuf chains) together. More...
struct pbuf *	pbuf_dechain (struct pbuf *p)
	Dechains the first pbuf from its succeeding pbufs in the chain. More...
err_t	pbuf_copy (struct pbuf *p_to, struct pbuf *p_from)
	Create PBUF_RAM copies of pbufs. More...
u16_t	pbuf_copy_partial (struct pbuf *buf, void *dataptr, u16_t len, u16_t offset)
	Copy (part of) the contents of a packet buffer to an application supplied buffer. More...
err_t	pbuf_take (struct pbuf *buf, const void *dataptr, u16_t len)
	Copy application supplied data into a pbuf. More...
struct pbuf *	pbuf_coalesce (struct pbuf *p, pbuf_layer layer)
	Creates a single pbuf out of a queue of pbufs. More...
u32_t	inet_addr (const char *cp)
int	inet_aton (const char *cp, struct in_addr *addr)
char *	inet_ntoa (struct in_addr addr)
u16_t	inet_chksum (void *dataptr, u16_t len)
u16_t	inet_chksum_pbuf (struct pbuf *p)
u16_t	inet_chksum_pseudo (struct pbuf *p, struct ip_addr *src, struct ip_addr *dest, u8_t proto, u16_t proto_len)
u8_t	ip_addr_isbroadcast (struct ip_addr *, struct netif *)
struct netif *	ip_route (struct ip_addr *dest)
err_t	ip_input (struct pbuf *p, struct netif *inp)
err_t	ip_output (struct pbuf *p, struct ip_addr *src, struct ip_addr *dest, u8_t ttl, u8_t tos, u8_t proto)
err_t	ip_output_if (struct pbuf *p, struct ip_addr *src, struct ip_addr *dest, u8_t ttl, u8_t tos, u8_t proto, struct netif *netif)
struct netbuf *	netbuf_new (void)
void	netbuf_delete (struct netbuf *buf)
void *	netbuf_alloc (struct netbuf *buf, u16_t size)
void	netbuf_free (struct netbuf *buf)
err_t	netbuf_ref (struct netbuf *buf, const void *dataptr, u16_t size)
void	netbuf_chain (struct netbuf *head, struct netbuf *tail)
u16_t	netbuf_len (struct netbuf *buf)
err_t	netbuf_data (struct netbuf *buf, void **dataptr, u16_t *len)
s8_t	netbuf_next (struct netbuf *buf)
void	netbuf_first (struct netbuf *buf)
struct netif *	netif_add (struct netif *netif, struct ip_addr *ipaddr, struct ip_addr *netmask, struct ip_addr *gw, void *state, err_t(*init)(struct netif *netif), err_t(*input)(struct pbuf *p, struct netif *netif))
void	netif_set_addr (struct netif *netif, struct ip_addr *ipaddr, struct ip_addr *netmask, struct ip_addr *gw)
void	netif_remove (struct netif *netif)
struct netif *	netif_find (char *name)
void	netif_set_default (struct netif *netif)
void	netif_set_ipaddr (struct netif *netif, struct ip_addr *ipaddr)
void	netif_set_netmask (struct netif *netif, struct ip_addr *netmask)
void	netif_set_gw (struct netif *netif, struct ip_addr *gw)
void	netif_set_up (struct netif *netif)
void	netif_set_down (struct netif *netif)
u8_t	netif_is_up (struct netif *netif)
void	pbuf_ref_chain (struct pbuf *p)
void	sys_init (void)
void	sys_timeout (u32_t msecs, sys_timeout_handler h, void *arg)
void	sys_untimeout (sys_timeout_handler h, void *arg)
struct sys_timeouts *	sys_arch_timeouts (void)
sys_sem_t	sys_sem_new (u8_t count)
void	sys_sem_signal (sys_sem_t sem)
u32_t	sys_arch_sem_wait (sys_sem_t sem, u32_t timeout)
void	sys_sem_free (sys_sem_t sem)
void	sys_sem_wait (sys_sem_t sem)
int	sys_sem_wait_timeout (sys_sem_t sem, u32_t timeout)
void	sys_msleep (u32_t ms)
u32_t	sys_jiffies (void)
sys_mbox_t	sys_mbox_new (int size)
void	sys_mbox_post (sys_mbox_t mbox, void *msg)
err_t	sys_mbox_trypost (sys_mbox_t mbox, void *msg)
u32_t	sys_arch_mbox_fetch (sys_mbox_t mbox, void **msg, u32_t timeout)
u32_t	sys_arch_mbox_tryfetch (sys_mbox_t mbox, void **msg)
void	sys_mbox_free (sys_mbox_t mbox)
void	sys_mbox_fetch (sys_mbox_t mbox, void **msg)
sys_thread_t	sys_thread_new (char *name, void(*thread)(void *arg), void *arg, int stacksize, int prio)
u32_t	sys_now (void)
	Returns the current time in milliseconds. More...
void	tcpip_init (void(*tcpip_init_done)(void *), void *arg)
err_t	tcpip_input (struct pbuf *p, struct netif *inp)
err_t	tcpip_callback_with_block (void(*f)(void *ctx), void *ctx, u8_t block)
err_t	pbuf_free_callback (struct pbuf *p)
err_t	mem_free_callback (void *m)
err_t	tcpip_timeout (u32_t msecs, sys_timeout_handler h, void *arg)
err_t	tcpip_untimeout (sys_timeout_handler h, void *arg)
err_t	loopif_init (struct netif *netif)
err_t	slipif_init (struct netif *netif)
void	slipif_poll (struct netif *netif)
	Register_Class (TcpLwipByteStreamSendQueue)
	Register_Class (TcpLwipByteStreamReceiveQueue)
	Register_Class (TcpLwipMsgBasedSendQueue)
	Register_Class (TcpLwipMsgBasedReceiveQueue)
	Register_Class (TcpLwipVirtualDataSendQueue)
	Register_Class (TcpLwipVirtualDataReceiveQueue)
	Define_Module (TCP_lwIP)
simtime_t	roundTime (const simtime_t &timeP, int secSlicesP)
	Register_Class (TCP_NSC_ByteStreamSendQueue)
	Register_Class (TCP_NSC_ByteStreamReceiveQueue)
	Register_Class (TCP_NSC_VirtualDataSendQueue)
	Register_Class (TCP_NSC_VirtualDataReceiveQueue)
	Define_Module (TCP_NSC)
struct inet::tcp::nsc_iphdr	__attribute__ ((packed))
Comparing sequence numbers
bool	seqLess (uint32 a, uint32 b)
bool	seqLE (uint32 a, uint32 b)
bool	seqGreater (uint32 a, uint32 b)
bool	seqGE (uint32 a, uint32 b)
uint32	seqMin (uint32 a, uint32 b)
uint32	seqMax (uint32 a, uint32 b)

Variables
const unsigned int	TCP_MAX_HEADER_OCTETS = 60
const unsigned int	MAX_SACK_ENTRIES = 4
PACK_STRUCT_BEGIN struct inet::tcp::ip_addr	PACK_STRUCT_STRUCT
const struct ip_addr	ip_addr_any
const struct ip_addr	ip_addr_broadcast
struct netif *	current_netif
	The interface that provided the packet for the current callback invocation. More...
const struct ip_hdr *	current_header
	Header of the input packet currently being processed. More...
struct netif *	netif_list
	The list of network interfaces. More...
struct netif *	netif_default
	The default network interface. More...
inet::tcp::TCP_NSC	__attribute__

Typedef Documentation

typedef cPacket* inet::tcp::cPacketPtr

typedef s8_t inet::tcp::err_t

Define LWIP_ERR_T in cc.h if you want to use a different type for your platform (must be signed).

typedef intptr_t inet::tcp::mem_ptr_t

typedef int16_t inet::tcp::s16_t

typedef int32_t inet::tcp::s32_t

typedef int8_t inet::tcp::s8_t

typedef std::list<Sack> inet::tcp::SackList

typedef void* inet::tcp::sys_mbox_t

typedef void* inet::tcp::sys_sem_t

typedef void* inet::tcp::sys_thread_t

typedef void(* inet::tcp::sys_timeout_handler) (void *arg)

typedef TCPTahoeRenoFamilyStateVariables inet::tcp::TCPNewRenoStateVariables

State variables for TCPNewReno.

typedef TCPBaseAlgStateVariables inet::tcp::TCPNoCongestionControlStateVariables

State variables for TCPNoCongestionControl.

typedef TCPOption* inet::tcp::TCPOptionPtr

typedef TCPTahoeRenoFamilyStateVariables inet::tcp::TCPRenoStateVariables

State variables for TCPReno.

typedef TCPTahoeRenoFamilyStateVariables inet::tcp::TCPTahoeStateVariables

State variables for TCPTahoe.

typedef uint16_t inet::tcp::u16_t

typedef uint32_t inet::tcp::u32_t

typedef uint8_t inet::tcp::u8_t

Enumeration Type Documentation

enum inet::tcp::icmp_dur_type

Enumerator
ICMP_DUR_NET
ICMP_DUR_HOST
ICMP_DUR_PROTO
ICMP_DUR_PORT
ICMP_DUR_FRAG
ICMP_DUR_SR

                   {
  ICMP_DUR_NET = 0,    /* net unreachable */
  ICMP_DUR_HOST = 1,   /* host unreachable */
  ICMP_DUR_PROTO = 2,  /* protocol unreachable */
  ICMP_DUR_PORT = 3,   /* port unreachable */
  ICMP_DUR_FRAG = 4,   /* fragmentation needed and DF set */
  ICMP_DUR_SR = 5      /* source route failed */
};

enum inet::tcp::icmp_te_type

Enumerator
ICMP_TE_TTL
ICMP_TE_FRAG

                  {
  ICMP_TE_TTL = 0,     /* time to live exceeded in transit */
  ICMP_TE_FRAG = 1     /* fragment reassembly time exceeded */
};

enum inet::tcp::memp_t

Enumerator
MEMP_MAX

             {
#define LWIP_MEMPOOL(name,num,size,desc)  MEMP_##name,
#include "lwip/memp_std.h"
  MEMP_MAX
} memp_t;

enum inet::tcp::pbuf_layer

Enumerator
PBUF_TRANSPORT
PBUF_IP
PBUF_LINK
PBUF_RAW

             {
  PBUF_TRANSPORT,
  PBUF_IP,
  PBUF_LINK,
  PBUF_RAW
} pbuf_layer;

enum inet::tcp::pbuf_type

Enumerator
PBUF_RAM
PBUF_ROM
PBUF_REF
PBUF_POOL

             {
  PBUF_RAM, /* pbuf data is stored in RAM */
  PBUF_ROM, /* pbuf data is stored in ROM */
  PBUF_REF, /* pbuf comes from the pbuf pool */
  PBUF_POOL /* pbuf payload refers to RAM */
} pbuf_type;

enum inet::tcp::snmp_ifType

See also

RFC1213, "MIB-II, 6. Definitions"

Enumerator
snmp_ifType_other
snmp_ifType_regular1822
snmp_ifType_hdh1822
snmp_ifType_ddn_x25
snmp_ifType_rfc877_x25
snmp_ifType_ethernet_csmacd
snmp_ifType_iso88023_csmacd
snmp_ifType_iso88024_tokenBus
snmp_ifType_iso88025_tokenRing
snmp_ifType_iso88026_man
snmp_ifType_starLan
snmp_ifType_proteon_10Mbit
snmp_ifType_proteon_80Mbit
snmp_ifType_hyperchannel
snmp_ifType_fddi
snmp_ifType_lapb
snmp_ifType_sdlc
snmp_ifType_ds1
snmp_ifType_e1
snmp_ifType_basicISDN
snmp_ifType_primaryISDN
snmp_ifType_propPointToPointSerial
snmp_ifType_ppp
snmp_ifType_softwareLoopback
snmp_ifType_eon
snmp_ifType_ethernet_3Mbit
snmp_ifType_nsip
snmp_ifType_slip
snmp_ifType_ultra
snmp_ifType_ds3
snmp_ifType_sip
snmp_ifType_frame_relay

                 {
  snmp_ifType_other=1,                /* none of the following */
  snmp_ifType_regular1822,
  snmp_ifType_hdh1822,
  snmp_ifType_ddn_x25,
  snmp_ifType_rfc877_x25,
  snmp_ifType_ethernet_csmacd,
  snmp_ifType_iso88023_csmacd,
  snmp_ifType_iso88024_tokenBus,
  snmp_ifType_iso88025_tokenRing,
  snmp_ifType_iso88026_man,
  snmp_ifType_starLan,
  snmp_ifType_proteon_10Mbit,
  snmp_ifType_proteon_80Mbit,
  snmp_ifType_hyperchannel,
  snmp_ifType_fddi,
  snmp_ifType_lapb,
  snmp_ifType_sdlc,
  snmp_ifType_ds1,                    /* T-1 */
  snmp_ifType_e1,                     /* european equiv. of T-1 */
  snmp_ifType_basicISDN,
  snmp_ifType_primaryISDN,            /* proprietary serial */
  snmp_ifType_propPointToPointSerial,
  snmp_ifType_ppp,
  snmp_ifType_softwareLoopback,
  snmp_ifType_eon,                    /* CLNP over IP [11] */
  snmp_ifType_ethernet_3Mbit,
  snmp_ifType_nsip,                   /* XNS over IP */
  snmp_ifType_slip,                   /* generic SLIP */
  snmp_ifType_ultra,                  /* ULTRA technologies */
  snmp_ifType_ds3,                    /* T-3 */
  snmp_ifType_sip,                    /* SMDS */
  snmp_ifType_frame_relay
};

enum inet::tcp::TCPEventCode

Enumerator
TCP_E_IGNORE
TCP_E_OPEN_ACTIVE
TCP_E_OPEN_PASSIVE
TCP_E_SEND
TCP_E_CLOSE
TCP_E_ABORT
TCP_E_STATUS
TCP_E_QUEUE_BYTES_LIMIT
TCP_E_READ
TCP_E_RCV_DATA
TCP_E_RCV_ACK
TCP_E_RCV_SYN
TCP_E_RCV_SYN_ACK
TCP_E_RCV_FIN
TCP_E_RCV_FIN_ACK
TCP_E_RCV_RST
TCP_E_RCV_UNEXP_SYN
TCP_E_TIMEOUT_2MSL
TCP_E_TIMEOUT_CONN_ESTAB
TCP_E_TIMEOUT_FIN_WAIT_2

                  {
    TCP_E_IGNORE,

    // app commands
    // (Note: no RECEIVE command, data are automatically passed up)
    TCP_E_OPEN_ACTIVE,
    TCP_E_OPEN_PASSIVE,
    TCP_E_SEND,
    TCP_E_CLOSE,
    TCP_E_ABORT,
    TCP_E_STATUS,
    TCP_E_QUEUE_BYTES_LIMIT,
    TCP_E_READ,

    // TPDU types
    TCP_E_RCV_DATA,
    TCP_E_RCV_ACK,
    TCP_E_RCV_SYN,
    TCP_E_RCV_SYN_ACK,
    TCP_E_RCV_FIN,
    TCP_E_RCV_FIN_ACK,
    TCP_E_RCV_RST,    // covers RST+ACK too

    TCP_E_RCV_UNEXP_SYN,    // unexpected SYN

    // timers
    TCP_E_TIMEOUT_2MSL,    // RFC 793, a.k.a. TIME-WAIT timer
    TCP_E_TIMEOUT_CONN_ESTAB,
    TCP_E_TIMEOUT_FIN_WAIT_2,

    // All other timers (REXMT, PERSIST, DELAYED-ACK, KEEP-ALIVE, etc.),
    // are handled in TCPAlgorithm.
};

enum inet::tcp::tcpip_msg_type

Enumerator
TCPIP_MSG_INPKT
TCPIP_MSG_CALLBACK
TCPIP_MSG_TIMEOUT
TCPIP_MSG_UNTIMEOUT

                    {
#if LWIP_NETCONN
  TCPIP_MSG_API,
#endif /* LWIP_NETCONN */
  TCPIP_MSG_INPKT,
#if LWIP_NETIF_API
  TCPIP_MSG_NETIFAPI,
#endif /* LWIP_NETIF_API */
  TCPIP_MSG_CALLBACK,
  TCPIP_MSG_TIMEOUT,
  TCPIP_MSG_UNTIMEOUT
};

enum inet::tcp::TCPOptionNumbers

Enum generated from inet/transportlayer/tcp_common/TCPSegment.msg:76 by nedtool.

//
// TCP Option Numbers
// Reference: http://www.iana.org/assignments/tcp-parameters/
// Date: 2011-07-02
//
// Note: Options not yet implemented should stay commented out
//
enum TCPOptionNumbers
{
TCPOPTION_END_OF_OPTION_LIST = 0;                   // RFC 793, LENGTH: 1 Byte
TCPOPTION_NO_OPERATION = 1;                         // RFC 793, LENGTH: 1 Byte
TCPOPTION_MAXIMUM_SEGMENT_SIZE = 2;                 // RFC 793, LENGTH: 4 Bytes
TCPOPTION_WINDOW_SCALE = 3;                         // RFC 1323, LENGTH: 3 Bytes
TCPOPTION_SACK_PERMITTED = 4;                       // RFC 2018, LENGTH: 2 Bytes
TCPOPTION_SACK = 5;                                 // RFC 2018, LENGTH: N (max. N = 4) 8 * n + 2 Bytes  => 32 + 2 + 2 * NOP = 36 Bytes; If TIMESTAMP option is used with SACK: max. n = 3 => 12 Bytes (for Timestamp) + 28 Bytes (for SACK) = 40 Bytes
//    TCPOPTION_ECHO = 6;                               // (obsoleted by option 8) RFC 1072 & RFC 6247, LENGTH: 6 Bytes
//    TCPOPTION_ECHO_REPLY = 7;                         // (obsoleted by option 8) RFC 1072 & RFC 6247, LENGTH: 6 Bytes
TCPOPTION_TIMESTAMP = 8;                            // RFC 1323, LENGTH: 10 Bytes

}

Enumerator
TCPOPTION_END_OF_OPTION_LIST
TCPOPTION_NO_OPERATION
TCPOPTION_MAXIMUM_SEGMENT_SIZE
TCPOPTION_WINDOW_SCALE
TCPOPTION_SACK_PERMITTED
TCPOPTION_SACK
TCPOPTION_TIMESTAMP

                      {
    TCPOPTION_END_OF_OPTION_LIST = 0,
    TCPOPTION_NO_OPERATION = 1,
    TCPOPTION_MAXIMUM_SEGMENT_SIZE = 2,
    TCPOPTION_WINDOW_SCALE = 3,
    TCPOPTION_SACK_PERMITTED = 4,
    TCPOPTION_SACK = 5,
    TCPOPTION_TIMESTAMP = 8
};

enum inet::tcp::TcpState

Enumerator
TCP_S_INIT
TCP_S_CLOSED
TCP_S_LISTEN
TCP_S_SYN_SENT
TCP_S_SYN_RCVD
TCP_S_ESTABLISHED
TCP_S_CLOSE_WAIT
TCP_S_LAST_ACK
TCP_S_FIN_WAIT_1
TCP_S_FIN_WAIT_2
TCP_S_CLOSING
TCP_S_TIME_WAIT

              {
    TCP_S_INIT = 0,
    TCP_S_CLOSED = FSM_Steady(1),
    TCP_S_LISTEN = FSM_Steady(2),
    TCP_S_SYN_SENT = FSM_Steady(3),
    TCP_S_SYN_RCVD = FSM_Steady(4),
    TCP_S_ESTABLISHED = FSM_Steady(5),
    TCP_S_CLOSE_WAIT = FSM_Steady(6),
    TCP_S_LAST_ACK = FSM_Steady(7),
    TCP_S_FIN_WAIT_1 = FSM_Steady(8),
    TCP_S_FIN_WAIT_2 = FSM_Steady(9),
    TCP_S_CLOSING = FSM_Steady(10),
    TCP_S_TIME_WAIT = FSM_Steady(11)
};

Function Documentation

struct inet::tcp::nsc_iphdr inet::tcp::__attribute__

(

(packed)

)

void INET_API inet::tcp::__doPacking	(	omnetpp::cCommBuffer *	b,
		const TCPPayloadMessage &	a
	)

Referenced by doParsimPacking().

void INET_API inet::tcp::__doUnpacking	(	omnetpp::cCommBuffer *	b,
		TCPPayloadMessage &	a
	)

Referenced by doParsimUnpacking().

inet::tcp::Define_Module

(

TCPSpoof

)

inet::tcp::Define_Module

(

TCP

)

inet::tcp::Define_Module

(

TCP_lwIP

)

inet::tcp::Define_Module

(

TCP_NSC

)

void inet::tcp::doPacking ( cCommBuffer *  b, cPacketPtr &  msg  )

inline

{msg->parsimPack(b);}

void inet::tcp::doParsimPacking ( omnetpp::cCommBuffer *  b, const TCPPayloadMessage &  obj  )

inline

{ __doPacking(b, obj); }

void inet::tcp::doParsimPacking ( omnetpp::cCommBuffer *  b, const SackItem &  obj  )

inline

{obj.parsimPack(b);}

void inet::tcp::doParsimPacking ( omnetpp::cCommBuffer *  b, const TCPOption &  obj  )

inline

{obj.parsimPack(b);}

void inet::tcp::doParsimPacking ( omnetpp::cCommBuffer *  b, const TCPOptionEnd &  obj  )

inline

{obj.parsimPack(b);}

void inet::tcp::doParsimPacking ( omnetpp::cCommBuffer *  b, const TCPOptionNop &  obj  )

inline

{obj.parsimPack(b);}

void inet::tcp::doParsimPacking ( omnetpp::cCommBuffer *  b, const TCPOptionMaxSegmentSize &  obj  )

inline

{obj.parsimPack(b);}

void inet::tcp::doParsimPacking ( omnetpp::cCommBuffer *  b, const TCPOptionWindowScale &  obj  )

inline

{obj.parsimPack(b);}

void inet::tcp::doParsimPacking ( omnetpp::cCommBuffer *  b, const TCPOptionSackPermitted &  obj  )

inline

{obj.parsimPack(b);}

void inet::tcp::doParsimPacking ( omnetpp::cCommBuffer *  b, const TCPOptionSack &  obj  )

inline

{obj.parsimPack(b);}

void inet::tcp::doParsimPacking ( omnetpp::cCommBuffer *  b, const TCPOptionTimestamp &  obj  )

inline

{obj.parsimPack(b);}

void inet::tcp::doParsimPacking ( omnetpp::cCommBuffer *  b, const TCPOptionUnknown &  obj  )

inline

{obj.parsimPack(b);}

void inet::tcp::doParsimUnpacking ( omnetpp::cCommBuffer *  b, TCPPayloadMessage &  obj  )

inline

{ __doUnpacking(b, obj); }

void inet::tcp::doParsimUnpacking ( omnetpp::cCommBuffer *  b, SackItem &  obj  )

inline

{obj.parsimUnpack(b);}

void inet::tcp::doParsimUnpacking ( omnetpp::cCommBuffer *  b, TCPOption &  obj  )

inline

{obj.parsimUnpack(b);}

void inet::tcp::doParsimUnpacking ( omnetpp::cCommBuffer *  b, TCPOptionEnd &  obj  )

inline

{obj.parsimUnpack(b);}

void inet::tcp::doParsimUnpacking ( omnetpp::cCommBuffer *  b, TCPOptionNop &  obj  )

inline

{obj.parsimUnpack(b);}

void inet::tcp::doParsimUnpacking ( omnetpp::cCommBuffer *  b, TCPOptionMaxSegmentSize &  obj  )

inline

{obj.parsimUnpack(b);}

void inet::tcp::doParsimUnpacking ( omnetpp::cCommBuffer *  b, TCPOptionWindowScale &  obj  )

inline

{obj.parsimUnpack(b);}

void inet::tcp::doParsimUnpacking ( omnetpp::cCommBuffer *  b, TCPOptionSackPermitted &  obj  )

inline

{obj.parsimUnpack(b);}

void inet::tcp::doParsimUnpacking ( omnetpp::cCommBuffer *  b, TCPOptionSack &  obj  )

inline

{obj.parsimUnpack(b);}

void inet::tcp::doParsimUnpacking ( omnetpp::cCommBuffer *  b, TCPOptionTimestamp &  obj  )

inline

{obj.parsimUnpack(b);}

void inet::tcp::doParsimUnpacking ( omnetpp::cCommBuffer *  b, TCPOptionUnknown &  obj  )

inline

{obj.parsimUnpack(b);}

void inet::tcp::doUnpacking ( cCommBuffer *  b, cPacketPtr &  msg  )

inline

{msg->parsimUnpack(b);}

u32_t inet::tcp::inet_addr

(

const char *

cp

)

int inet::tcp::inet_aton	(	const char *	cp,
		struct in_addr *	addr
	)

u16_t inet::tcp::inet_chksum	(	void *	dataptr,
		u16_t	len
	)

u16_t inet::tcp::inet_chksum_pbuf

(

struct pbuf *

p

)

u16_t inet::tcp::inet_chksum_pseudo	(	struct pbuf *	p,
		struct ip_addr *	src,
		struct ip_addr *	dest,
		u8_t	proto,
		u16_t	proto_len
	)

char* inet::tcp::inet_ntoa

(

struct in_addr

addr

)

u8_t inet::tcp::LwipTcpLayer::ip_addr_isbroadcast	(	struct ip_addr *	addr,
		struct netif *	interf
	)

{
    // TODO implementing this if need
    return 0;
}

err_t inet::tcp::ip_input	(	struct pbuf *	p,
		struct netif *	inp
	)

err_t inet::tcp::ip_output	(	struct pbuf *	p,
		struct ip_addr *	src,
		struct ip_addr *	dest,
		u8_t	ttl,
		u8_t	tos,
		u8_t	proto
	)

Referenced by inet::tcp::TCP_lwIP::numInitStages().

err_t inet::tcp::ip_output_if	(	struct pbuf *	p,
		struct ip_addr *	src,
		struct ip_addr *	dest,
		u8_t	ttl,
		u8_t	tos,
		u8_t	proto,
		struct netif *	netif
	)

struct netif* inet::tcp::ip_route

(

struct ip_addr *

dest

)

Referenced by inet::tcp::TCP_lwIP::numInitStages().

err_t inet::tcp::loopif_init

(

struct netif *

netif

)

err_t inet::tcp::mem_free_callback

(

void *

m

)

void inet::tcp::LwipTcpLayer::memp_free	(	memp_t	type,
		void *	mem
	)

Put an element back into its pool.

Parameters

type	the pool where to put mem
mem	the memp element to free

Referenced by ip_addr_isbroadcast(), and pbuf_free().

{
  struct memp *memp;
  SYS_ARCH_DECL_PROTECT(old_level);

  if (mem == nullptr) {
    return;
  }
  LWIP_ASSERT("memp_free: mem properly aligned",
                ((mem_ptr_t)mem % MEM_ALIGNMENT) == 0);

  memp = (struct memp *)((u8_t*)mem - MEMP_SIZE);

  SYS_ARCH_PROTECT(old_level);
#if MEMP_OVERFLOW_CHECK
#if MEMP_OVERFLOW_CHECK >= 2
  memp_overflow_check_all();
#else
  memp_overflow_check_element(memp, memp_sizes[type]);
#endif /* MEMP_OVERFLOW_CHECK >= 2 */
#endif /* MEMP_OVERFLOW_CHECK */

  MEMP_STATS_DEC(used, type);

  memp->next = memp_tab[type];
  memp_tab[type] = memp;

#if MEMP_SANITY_CHECK
  LWIP_ASSERT("memp sanity", memp_sanity());
#endif /* MEMP_SANITY_CHECK */

  SYS_ARCH_UNPROTECT(old_level);
}

void inet::tcp::memp_init

(

void

)

Initialize this module.

Carves out memp_memory into linked lists for each pool-type.

{
  struct memp *memp;
  u16_t i, j;

  for (i = 0; i < MEMP_MAX; ++i) {
    MEMP_STATS_AVAIL(used, i, 0);
    MEMP_STATS_AVAIL(max, i, 0);
    MEMP_STATS_AVAIL(err, i, 0);
    MEMP_STATS_AVAIL(avail, i, memp_num[i]);
  }

  memp = LWIP_MEM_ALIGN(memp_memory);
  /* for every pool: */
  for (i = 0; i < MEMP_MAX; ++i) {
    memp_tab[i] = nullptr;
    /* create a linked list of memp elements */
    for (j = 0; j < memp_num[i]; ++j) {
      memp->next = memp_tab[i];
      memp_tab[i] = memp;
      memp = (struct memp *)((u8_t *)memp + MEMP_SIZE + memp_sizes[i]
#if MEMP_OVERFLOW_CHECK
        + MEMP_SANITY_REGION_AFTER_ALIGNED
#endif
      );
    }
  }
#if MEMP_OVERFLOW_CHECK
  memp_overflow_init();
  /* check everything a first time to see if it worked */
  memp_overflow_check_all();
#endif /* MEMP_OVERFLOW_CHECK */
}

void * inet::tcp::memp_malloc

(

memp_t

type

)

Get an element from a specific pool.

Parameters

type	the pool to get an element from

the debug version has two more parameters:

Parameters

file	file name calling this function
line	number of line where this function is called

Returns

a pointer to the allocated memory or a nullptr pointer on error

Referenced by pbuf_alloc().

{
  struct memp *memp;
  SYS_ARCH_DECL_PROTECT(old_level);

  LWIP_ERROR("memp_malloc: type < MEMP_MAX", (type < MEMP_MAX), return nullptr;);

  SYS_ARCH_PROTECT(old_level);
#if MEMP_OVERFLOW_CHECK >= 2
  memp_overflow_check_all();
#endif /* MEMP_OVERFLOW_CHECK >= 2 */

  memp = memp_tab[type];

  if (memp != nullptr) {
    memp_tab[type] = memp->next;
#if MEMP_OVERFLOW_CHECK
    memp->next = nullptr;
    memp->file = file;
    memp->line = line;
#endif /* MEMP_OVERFLOW_CHECK */
    MEMP_STATS_INC_USED(used, type);
    LWIP_ASSERT("memp_malloc: memp properly aligned",
                ((mem_ptr_t)memp % MEM_ALIGNMENT) == 0);
    memp = (struct memp*)((u8_t*)memp + MEMP_SIZE);
  } else {
    LWIP_DEBUGF(MEMP_DEBUG | LWIP_DBG_LEVEL_SERIOUS, ("memp_malloc: out of memory in pool %s\n", memp_desc[type]));
    MEMP_STATS_INC(err, type);
  }

  SYS_ARCH_UNPROTECT(old_level);

  return memp;
}

void* inet::tcp::netbuf_alloc	(	struct netbuf *	buf,
		u16_t	size
	)

void inet::tcp::netbuf_chain	(	struct netbuf *	head,
		struct netbuf *	tail
	)

err_t inet::tcp::netbuf_data	(	struct netbuf *	buf,
		void **	dataptr,
		u16_t *	len
	)

void inet::tcp::netbuf_delete

(

struct netbuf *

buf

)

void inet::tcp::netbuf_first

(

struct netbuf *

buf

)

void inet::tcp::netbuf_free

(

struct netbuf *

buf

)

u16_t inet::tcp::netbuf_len

(

struct netbuf *

buf

)

struct netbuf* inet::tcp::netbuf_new

(

void

)

s8_t inet::tcp::netbuf_next

(

struct netbuf *

buf

)

err_t inet::tcp::netbuf_ref	(	struct netbuf *	buf,
		const void *	dataptr,
		u16_t	size
	)

struct netif* inet::tcp::netif_add	(	struct netif *	netif,
		struct ip_addr *	ipaddr,
		struct ip_addr *	netmask,
		struct ip_addr *	gw,
		void *	state,
		err_t(*)(struct netif *netif)	init,
		err_t(*)(struct pbuf *p, struct netif *netif)	input
	)

struct netif* inet::tcp::netif_find

(

char *

name

)

u8_t inet::tcp::netif_is_up

(

struct netif *

netif

)

void inet::tcp::netif_remove

(

struct netif *

netif

)

void inet::tcp::netif_set_addr	(	struct netif *	netif,
		struct ip_addr *	ipaddr,
		struct ip_addr *	netmask,
		struct ip_addr *	gw
	)

void inet::tcp::netif_set_default

(

struct netif *

netif

)

void inet::tcp::netif_set_down

(

struct netif *

netif

)

void inet::tcp::netif_set_gw	(	struct netif *	netif,
		struct ip_addr *	gw
	)

void inet::tcp::netif_set_ipaddr	(	struct netif *	netif,
		struct ip_addr *	ipaddr
	)

void inet::tcp::netif_set_netmask	(	struct netif *	netif,
		struct ip_addr *	netmask
	)

void inet::tcp::netif_set_up

(

struct netif *

netif

)

std::ostream& inet::tcp::operator<< ( std::ostream &  os, cPacketPtr  msg  )

inline

    {
        return os << "(" << msg->getClassName() << ") " << msg->getName() << ": " << msg->str();
    }

struct pbuf * inet::tcp::pbuf_alloc	(	pbuf_layer	layer,
		u16_t	length,
		pbuf_type	type
	)

Allocates a pbuf of the given type (possibly a chain for PBUF_POOL type).

The actual memory allocated for the pbuf is determined by the layer at which the pbuf is allocated and the requested size (from the size parameter).

Parameters

layer	flag to define header size
length	size of the pbuf's payload
type	this parameter decides how and where the pbuf should be allocated as follows:

• PBUF_RAM: buffer memory for pbuf is allocated as one large chunk. This includes protocol headers as well.
• PBUF_ROM: no buffer memory is allocated for the pbuf, even for protocol headers. Additional headers must be prepended by allocating another pbuf and chain in to the front of the ROM pbuf. It is assumed that the memory used is really similar to ROM in that it is immutable and will not be changed. Memory which is dynamic should generally not be attached to PBUF_ROM pbufs. Use PBUF_REF instead.
• PBUF_REF: no buffer memory is allocated for the pbuf, even for protocol headers. It is assumed that the pbuf is only being used in a single thread. If the pbuf gets queued, then pbuf_take should be called to copy the buffer.
• PBUF_POOL: the pbuf is allocated as a pbuf chain, with pbufs from the pbuf pool that is allocated during pbuf_init().

Returns

the allocated pbuf. If multiple pbufs where allocated, this is the first pbuf of a pbuf chain.

Referenced by pbuf_coalesce().

{
  struct pbuf *p, *q, *r;
  u16_t offset;
  s32_t rem_len; /* remaining length */
  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc(length=%" U16_F ")\n", length));

  /* determine header offset */
  offset = 0;
  switch (layer) {
  case PBUF_TRANSPORT:
    /* add room for transport (often TCP) layer header */
    offset += PBUF_TRANSPORT_HLEN;
    /* FALLTHROUGH */
  case PBUF_IP:
    /* add room for IP layer header */
    offset += PBUF_IP_HLEN;
    /* FALLTHROUGH */
  case PBUF_LINK:
    /* add room for link layer header */
    offset += PBUF_LINK_HLEN;
    break;
  case PBUF_RAW:
    break;
  default:
    LWIP_ASSERT("pbuf_alloc: bad pbuf layer", 0);
    return nullptr;
  }

  switch (type) {
  case PBUF_POOL:
    /* allocate head of pbuf chain into p */
    p = (struct pbuf *)memp_malloc(MEMP_PBUF_POOL);
    LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc: allocated pbuf %p\n", (void *)p));
    if (p == nullptr) {
      PBUF_POOL_IS_EMPTY();
      return nullptr;
    }
    p->type = type;
    p->next = nullptr;

    /* make the payload pointer point 'offset' bytes into pbuf data memory */
    p->payload = LWIP_MEM_ALIGN((void *)((u8_t *)p + (SIZEOF_STRUCT_PBUF + offset)));
    LWIP_ASSERT("pbuf_alloc: pbuf p->payload properly aligned",
            ((mem_ptr_t)p->payload % MEM_ALIGNMENT) == 0);
    /* the total length of the pbuf chain is the requested size */
    p->tot_len = length;
    /* set the length of the first pbuf in the chain */
    p->len = LWIP_MIN(length, PBUF_POOL_BUFSIZE_ALIGNED - LWIP_MEM_ALIGN_SIZE(offset));
    LWIP_ASSERT("check p->payload + p->len does not overflow pbuf",
                ((u8_t*)p->payload + p->len <=
                 (u8_t*)p + SIZEOF_STRUCT_PBUF + PBUF_POOL_BUFSIZE_ALIGNED));
    LWIP_ASSERT("PBUF_POOL_BUFSIZE must be bigger than MEM_ALIGNMENT",
      (PBUF_POOL_BUFSIZE_ALIGNED - LWIP_MEM_ALIGN_SIZE(offset)) > 0 );
    /* set reference count (needed here in case we fail) */
    p->ref = 1;

    /* now allocate the tail of the pbuf chain */

    /* remember first pbuf for linkage in next iteration */
    r = p;
    /* remaining length to be allocated */
    rem_len = length - p->len;
    /* any remaining pbufs to be allocated? */
    while (rem_len > 0) {
      q = (struct pbuf *)memp_malloc(MEMP_PBUF_POOL);
      if (q == nullptr) {
        PBUF_POOL_IS_EMPTY();
        /* free chain so far allocated */
        pbuf_free(p);
        /* bail out unsuccesfully */
        return nullptr;
      }
      q->type = type;
      q->flags = 0;
      q->next = nullptr;
      /* make previous pbuf point to this pbuf */
      r->next = q;
      /* set total length of this pbuf and next in chain */
      LWIP_ASSERT("rem_len < max_u16_t", rem_len < 0xffff);
      q->tot_len = (u16_t)rem_len;
      /* this pbuf length is pool size, unless smaller sized tail */
      q->len = LWIP_MIN((u16_t)rem_len, PBUF_POOL_BUFSIZE_ALIGNED);
      q->payload = (void *)((u8_t *)q + SIZEOF_STRUCT_PBUF);
      LWIP_ASSERT("pbuf_alloc: pbuf q->payload properly aligned",
              ((mem_ptr_t)q->payload % MEM_ALIGNMENT) == 0);
      LWIP_ASSERT("check p->payload + p->len does not overflow pbuf",
                  ((u8_t*)p->payload + p->len <=
                   (u8_t*)p + SIZEOF_STRUCT_PBUF + PBUF_POOL_BUFSIZE_ALIGNED));
      q->ref = 1;
      /* calculate remaining length to be allocated */
      rem_len -= q->len;
      /* remember this pbuf for linkage in next iteration */
      r = q;
    }
    /* end of chain */
    /*r->next = nullptr;*/

    break;
  case PBUF_RAM:
    /* If pbuf is to be allocated in RAM, allocate memory for it. */
    p = (struct pbuf*)mem_malloc(LWIP_MEM_ALIGN_SIZE(SIZEOF_STRUCT_PBUF + offset) + LWIP_MEM_ALIGN_SIZE(length));
    if (p == nullptr) {
      return nullptr;
    }
    /* Set up internal structure of the pbuf. */
    p->payload = LWIP_MEM_ALIGN((void *)((u8_t *)p + SIZEOF_STRUCT_PBUF + offset));
    p->len = p->tot_len = length;
    p->next = nullptr;
    p->type = type;

    LWIP_ASSERT("pbuf_alloc: pbuf->payload properly aligned",
           ((mem_ptr_t)p->payload % MEM_ALIGNMENT) == 0);
    break;
  /* pbuf references existing (non-volatile static constant) ROM payload? */
  case PBUF_ROM:
  /* pbuf references existing (externally allocated) RAM payload? */
  case PBUF_REF:
    /* only allocate memory for the pbuf structure */
    p = (struct pbuf *)memp_malloc(MEMP_PBUF);
    if (p == nullptr) {
      LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
                  ("pbuf_alloc: Could not allocate MEMP_PBUF for PBUF_%s.\n",
                  (type == PBUF_ROM) ? "ROM" : "REF"));
      return nullptr;
    }
    /* caller must set this field properly, afterwards */
    p->payload = nullptr;
    p->len = p->tot_len = length;
    p->next = nullptr;
    p->type = type;
    break;
  default:
    LWIP_ASSERT("pbuf_alloc: erroneous type", 0);
    return nullptr;
  }
  /* set reference count */
  p->ref = 1;
  /* set flags */
  p->flags = 0;
  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_alloc(length=%" U16_F ") == %p\n", length, (void *)p));
  return p;
}

void inet::tcp::pbuf_cat	(	struct pbuf *	h,
		struct pbuf *	t
	)

Concatenate two pbufs (each may be a pbuf chain) and take over the caller's reference of the tail pbuf.

Note

The caller MAY NOT reference the tail pbuf afterwards. Use pbuf_chain() for that purpose.

See also

pbuf_chain()

Referenced by pbuf_chain().

{
  struct pbuf *p;

  LWIP_ERROR("(h != nullptr) && (t != nullptr) (programmer violates API)",
             ((h != nullptr) && (t != nullptr)), return;);

  /* proceed to last pbuf of chain */
  for (p = h; p->next != nullptr; p = p->next) {
    /* add total length of second chain to all totals of first chain */
    p->tot_len += t->tot_len;
  }
  /* { p is last pbuf of first h chain, p->next == nullptr } */
  LWIP_ASSERT("p->tot_len == p->len (of last pbuf in chain)", p->tot_len == p->len);
  LWIP_ASSERT("p->next == nullptr", p->next == nullptr);
  /* add total length of second chain to last pbuf total of first chain */
  p->tot_len += t->tot_len;
  /* chain last pbuf of head (p) with first of tail (t) */
  p->next = t;
  /* p->next now references t, but the caller will drop its reference to t,
   * so netto there is no change to the reference count of t.
   */
}

void inet::tcp::pbuf_chain	(	struct pbuf *	h,
		struct pbuf *	t
	)

Chain two pbufs (or pbuf chains) together.

The caller MUST call pbuf_free(t) once it has stopped using it. Use pbuf_cat() instead if you no longer use t.

Parameters

h	head pbuf (chain)
t	tail pbuf (chain)

Note

The pbufs MUST belong to the same packet.

MAY NOT be called on a packet queue.

The ->tot_len fields of all pbufs of the head chain are adjusted. The ->next field of the last pbuf of the head chain is adjusted. The ->ref field of the first pbuf of the tail chain is adjusted.

{
  pbuf_cat(h, t);
  /* t is now referenced by h */
  pbuf_ref(t);
  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_chain: %p references %p\n", (void *)h, (void *)t));
}

u8_t inet::tcp::pbuf_clen

(

struct pbuf *

p

)

Count number of pbufs in a chain.

Parameters

p	first pbuf of chain

Returns

the number of pbufs in a chain

{
  u8_t len;

  len = 0;
  while (p != nullptr) {
    ++len;
    p = p->next;
  }
  return len;
}

struct pbuf * inet::tcp::pbuf_coalesce	(	struct pbuf *	p,
		pbuf_layer	layer
	)

Creates a single pbuf out of a queue of pbufs.

Remarks

: The source pbuf 'p' is not freed by this function because that can be illegal in some places!

Parameters

p	the source pbuf
layer	pbuf_layer of the new pbuf

Returns

a new, single pbuf (p->next is nullptr) or the old pbuf if allocation fails

{
  struct pbuf *q;
  err_t err;
  if (p->next == nullptr) {
    return p;
  }
  q = pbuf_alloc(layer, p->tot_len, PBUF_RAM);
  if (q == nullptr) {
    /* @todo: what do we do now? */
    return p;
  }
  err = pbuf_copy(q, p);
  LWIP_ASSERT("pbuf_copy failed", err == ERR_OK);
  pbuf_free(p);
  return q;
}

err_t inet::tcp::pbuf_copy	(	struct pbuf *	p_to,
		struct pbuf *	p_from
	)

Create PBUF_RAM copies of pbufs.

Used to queue packets on behalf of the lwIP stack, such as ARP based queueing.

Note

You MUST explicitly use p = pbuf_take(p);

Only one packet is copied, no packet queue!

Parameters

p_to	pbuf destination of the copy
p_from	pbuf source of the copy

Returns

ERR_OK if pbuf was copied ERR_ARG if one of the pbufs is nullptr or p_to is not big enough to hold p_from

Referenced by pbuf_coalesce().

{
  u16_t offset_to=0, offset_from=0, len;

  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_copy(%p, %p)\n",
    (void*)p_to, (void*)p_from));

  /* is the target big enough to hold the source? */
  LWIP_ERROR("pbuf_copy: target not big enough to hold source", ((p_to != nullptr) &&
             (p_from != nullptr) && (p_to->tot_len >= p_from->tot_len)), return ERR_ARG;);

  /* iterate through pbuf chain */
  do
  {
    LWIP_ASSERT("p_to != nullptr", p_to != nullptr);
    /* copy one part of the original chain */
    if ((p_to->len - offset_to) >= (p_from->len - offset_from)) {
      /* complete current p_from fits into current p_to */
      len = p_from->len - offset_from;
    } else {
      /* current p_from does not fit into current p_to */
      len = p_to->len - offset_to;
    }
    MEMCPY((u8_t*)p_to->payload + offset_to, (u8_t*)p_from->payload + offset_from, len);
    offset_to += len;
    offset_from += len;
    LWIP_ASSERT("offset_to <= p_to->len", offset_to <= p_to->len);
    if (offset_to == p_to->len) {
      /* on to next p_to (if any) */
      offset_to = 0;
      p_to = p_to->next;
    }
    LWIP_ASSERT("offset_from <= p_from->len", offset_from <= p_from->len);
    if (offset_from >= p_from->len) {
      /* on to next p_from (if any) */
      offset_from = 0;
      p_from = p_from->next;
    }

    if((p_from != nullptr) && (p_from->len == p_from->tot_len)) {
      /* don't copy more than one packet! */
      LWIP_ERROR("pbuf_copy() does not allow packet queues!\n",
                 (p_from->next == nullptr), return ERR_VAL;);
    }
    if((p_to != nullptr) && (p_to->len == p_to->tot_len)) {
      /* don't copy more than one packet! */
      LWIP_ERROR("pbuf_copy() does not allow packet queues!\n",
                  (p_to->next == nullptr), return ERR_VAL;);
    }
  } while (p_from);
  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_copy: end of chain reached.\n"));
  return ERR_OK;
}

u16_t inet::tcp::pbuf_copy_partial	(	struct pbuf *	buf,
		void *	dataptr,
		u16_t	len,
		u16_t	offset
	)

Copy (part of) the contents of a packet buffer to an application supplied buffer.

Parameters

buf	the pbuf from which to copy data
dataptr	the application supplied buffer
len	length of data to copy (dataptr must be big enough). No more than buf->tot_len will be copied, irrespective of len
offset	offset into the packet buffer from where to begin copying len bytes

Returns

the number of bytes copied, or 0 on failure

{
  struct pbuf *p;
  u16_t left;
  u16_t buf_copy_len;
  u16_t copied_total = 0;

  LWIP_ERROR("pbuf_copy_partial: invalid buf", (buf != nullptr), return 0;);
  LWIP_ERROR("pbuf_copy_partial: invalid dataptr", (dataptr != nullptr), return 0;);

  left = 0;

  if((buf == nullptr) || (dataptr == nullptr)) {
    return 0;
  }

  /* Note some systems use byte copy if dataptr or one of the pbuf payload pointers are unaligned. */
  for(p = buf; len != 0 && p != nullptr; p = p->next) {
    if ((offset != 0) && (offset >= p->len)) {
      /* don't copy from this buffer -> on to the next */
      offset -= p->len;
    } else {
      /* copy from this buffer. maybe only partially. */
      buf_copy_len = p->len - offset;
      if (buf_copy_len > len)
          buf_copy_len = len;
      /* copy the necessary parts of the buffer */
      MEMCPY(&((char*)dataptr)[left], &((char*)p->payload)[offset], buf_copy_len);
      copied_total += buf_copy_len;
      left += buf_copy_len;
      len -= buf_copy_len;
      offset = 0;
    }
  }
  return copied_total;
}

struct pbuf * inet::tcp::pbuf_dechain

(

struct pbuf *

p

)

Dechains the first pbuf from its succeeding pbufs in the chain.

Makes p->tot_len field equal to p->len.

Parameters

p	pbuf to dechain

Returns

remainder of the pbuf chain, or nullptr if it was de-allocated.

Note

May not be called on a packet queue.

{
  struct pbuf *q;
  u8_t tail_gone = 1;
  /* tail */
  q = p->next;
  /* pbuf has successor in chain? */
  if (q != nullptr) {
    /* assert tot_len invariant: (p->tot_len == p->len + (p->next? p->next->tot_len: 0) */
    LWIP_ASSERT("p->tot_len == p->len + q->tot_len", q->tot_len == p->tot_len - p->len);
    /* enforce invariant if assertion is disabled */
    q->tot_len = p->tot_len - p->len;
    /* decouple pbuf from remainder */
    p->next = nullptr;
    /* total length of pbuf p is its own length only */
    p->tot_len = p->len;
    /* q is no longer referenced by p, free it */
    LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_dechain: unreferencing %p\n", (void *)q));
    tail_gone = pbuf_free(q);
    if (tail_gone > 0) {
      LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE,
                  ("pbuf_dechain: deallocated %p (as it is no longer referenced)\n", (void *)q));
    }
    /* return remaining tail or nullptr if deallocated */
  }
  /* assert tot_len invariant: (p->tot_len == p->len + (p->next? p->next->tot_len: 0) */
  LWIP_ASSERT("p->tot_len == p->len", p->tot_len == p->len);
  return ((tail_gone > 0) ? nullptr : q);
}

u8_t inet::tcp::pbuf_free

(

struct pbuf *

p

)

Dereference a pbuf chain or queue and deallocate any no-longer-used pbufs at the head of this chain or queue.

Decrements the pbuf reference count. If it reaches zero, the pbuf is deallocated.

For a pbuf chain, this is repeated for each pbuf in the chain, up to the first pbuf which has a non-zero reference count after decrementing. So, when all reference counts are one, the whole chain is free'd.

Parameters

p	The pbuf (chain) to be dereferenced.

Returns

the number of pbufs that were de-allocated from the head of the chain.

Note

MUST NOT be called on a packet queue (Not verified to work yet).

the reference counter of a pbuf equals the number of pointers that refer to the pbuf (or into the pbuf).

Referenced by pbuf_alloc(), pbuf_coalesce(), pbuf_dechain(), pbuf_realloc(), and inet::tcp::TCP_lwIP::tcp_event_recv().

{
  u16_t type;
  struct pbuf *q;
  u8_t count;

  if (p == nullptr) {
    LWIP_ASSERT("p != nullptr", p != nullptr);
    /* if assertions are disabled, proceed with debug output */
    LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
      ("pbuf_free(p == nullptr) was called.\n"));
    return 0;
  }
  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free(%p)\n", (void *)p));

  PERF_START;

  LWIP_ASSERT("pbuf_free: sane type",
    p->type == PBUF_RAM || p->type == PBUF_ROM ||
    p->type == PBUF_REF || p->type == PBUF_POOL);

  count = 0;
  /* de-allocate all consecutive pbufs from the head of the chain that
   * obtain a zero reference count after decrementing*/
  while (p != nullptr) {
    u16_t ref;
    SYS_ARCH_DECL_PROTECT(old_level);
    /* Since decrementing ref cannot be guaranteed to be a single machine operation
     * we must protect it. We put the new ref into a local variable to prevent
     * further protection. */
    SYS_ARCH_PROTECT(old_level);
    /* all pbufs in a chain are referenced at least once */
    LWIP_ASSERT("pbuf_free: p->ref > 0", p->ref > 0);
    /* decrease reference count (number of pointers to pbuf) */
    ref = --(p->ref);
    SYS_ARCH_UNPROTECT(old_level);
    /* this pbuf is no longer referenced to? */
    if (ref == 0) {
      /* remember next pbuf in chain for next iteration */
      q = p->next;
      LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free: deallocating %p\n", (void *)p));
      type = p->type;
      /* is this a pbuf from the pool? */
      if (type == PBUF_POOL) {
        memp_free(MEMP_PBUF_POOL, p);
      /* is this a ROM or RAM referencing pbuf? */
      } else if (type == PBUF_ROM || type == PBUF_REF) {
        memp_free(MEMP_PBUF, p);
      /* type == PBUF_RAM */
      } else {
        mem_free(p);
      }
      count++;
      /* proceed to next pbuf */
      p = q;
    /* p->ref > 0, this pbuf is still referenced to */
    /* (and so the remaining pbufs in chain as well) */
    } else {
      LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_free: %p has ref %" U16_F ", ending here.\n", (void *)p, ref));
      /* stop walking through the chain */
      p = nullptr;
    }
  }
  PERF_STOP("pbuf_free");
  /* return number of de-allocated pbufs */
  return count;
}

err_t inet::tcp::pbuf_free_callback

(

struct pbuf *

p

)

u8_t inet::tcp::pbuf_header	(	struct pbuf *	p,
		s16_t	header_size_increment
	)

Adjusts the payload pointer to hide or reveal headers in the payload.

Adjusts the ->payload pointer so that space for a header (dis)appears in the pbuf payload.

The ->payload, ->tot_len and ->len fields are adjusted.

Parameters

p	pbuf to change the header size.
header_size_increment	Number of bytes to increment header size which increases the size of the pbuf. New space is on the front. (Using a negative value decreases the header size.) If hdr_size_inc is 0, this function does nothing and returns succesful.

PBUF_ROM and PBUF_REF type buffers cannot have their sizes increased, so the call will fail. A check is made that the increase in header size does not move the payload pointer in front of the start of the buffer.

Returns

non-zero on failure, zero on success.

{
  u16_t type;
  void *payload;
  u16_t increment_magnitude;

  LWIP_ASSERT("p != nullptr", p != nullptr);
  if ((header_size_increment == 0) || (p == nullptr))
    return 0;

  if (header_size_increment < 0){
    increment_magnitude = -header_size_increment;
    /* Check that we aren't going to move off the end of the pbuf */
    LWIP_ERROR("increment_magnitude <= p->len", (increment_magnitude <= p->len), return 1;);
  } else {
    increment_magnitude = header_size_increment;
#if 0
    /* Can't assert these as some callers speculatively call
         pbuf_header() to see if it's OK.  Will return 1 below instead. */
    /* Check that we've got the correct type of pbuf to work with */
    LWIP_ASSERT("p->type == PBUF_RAM || p->type == PBUF_POOL",
                p->type == PBUF_RAM || p->type == PBUF_POOL);
    /* Check that we aren't going to move off the beginning of the pbuf */
    LWIP_ASSERT("p->payload - increment_magnitude >= p + SIZEOF_STRUCT_PBUF",
                (u8_t *)p->payload - increment_magnitude >= (u8_t *)p + SIZEOF_STRUCT_PBUF);
#endif
  }

  type = p->type;
  /* remember current payload pointer */
  payload = p->payload;

  /* pbuf types containing payloads? */
  if (type == PBUF_RAM || type == PBUF_POOL) {
    /* set new payload pointer */
    p->payload = (u8_t *)p->payload - header_size_increment;
    /* boundary check fails? */
    if ((u8_t *)p->payload < (u8_t *)p + SIZEOF_STRUCT_PBUF) {
      LWIP_DEBUGF( PBUF_DEBUG | LWIP_DBG_LEVEL_SERIOUS,
        ("pbuf_header: failed as %p < %p (not enough space for new header size)\n",
        (void *)p->payload, (void *)(p + 1)));
      /* restore old payload pointer */
      p->payload = payload;
      /* bail out unsuccesfully */
      return 1;
    }
  /* pbuf types refering to external payloads? */
  } else if (type == PBUF_REF || type == PBUF_ROM) {
    /* hide a header in the payload? */
    if ((header_size_increment < 0) && (increment_magnitude <= p->len)) {
      /* increase payload pointer */
      p->payload = (u8_t *)p->payload - header_size_increment;
    } else {
      /* cannot expand payload to front (yet!)
       * bail out unsuccesfully */
      return 1;
    }
  }
  else {
    /* Unknown type */
    LWIP_ASSERT("bad pbuf type", 0);
    return 1;
  }
  /* modify pbuf length fields */
  p->len += header_size_increment;
  p->tot_len += header_size_increment;

  LWIP_DEBUGF(PBUF_DEBUG | LWIP_DBG_TRACE, ("pbuf_header: old %p new %p (%" S16_F ")\n",
    (void *)payload, (void *)p->payload, header_size_increment));

  return 0;
}

void inet::tcp::pbuf_realloc	(	struct pbuf *	p,
		u16_t	new_len
	)

Shrink a pbuf chain to a desired length.

Parameters

p	pbuf to shrink.
new_len	desired new length of pbuf chain

Depending on the desired length, the first few pbufs in a chain might be skipped and left unchanged. The new last pbuf in the chain will be resized, and any remaining pbufs will be freed.

Note

If the pbuf is ROM/REF, only the ->tot_len and ->len fields are adjusted.

May not be called on a packet queue.

Despite its name, pbuf_realloc cannot grow the size of a pbuf (chain).

{
  struct pbuf *q;
  u16_t rem_len; /* remaining length */
  s32_t grow;

  LWIP_ASSERT("pbuf_realloc: p != nullptr", p != nullptr);
  LWIP_ASSERT("pbuf_realloc: sane p->type", p->type == PBUF_POOL ||
              p->type == PBUF_ROM ||
              p->type == PBUF_RAM ||
              p->type == PBUF_REF);

  /* desired length larger than current length? */
  if (new_len >= p->tot_len) {
    /* enlarging not yet supported */
    return;
  }

  /* the pbuf chain grows by (new_len - p->tot_len) bytes
   * (which may be negative in case of shrinking) */
  grow = new_len - p->tot_len;

  /* first, step over any pbufs that should remain in the chain */
  rem_len = new_len;
  q = p;
  /* should this pbuf be kept? */
  while (rem_len > q->len) {
    /* decrease remaining length by pbuf length */
    rem_len -= q->len;
    /* decrease total length indicator */
    LWIP_ASSERT("grow < max_u16_t", grow < 0xffff);
    q->tot_len += (u16_t)grow;
    /* proceed to next pbuf in chain */
    q = q->next;
    LWIP_ASSERT("pbuf_realloc: q != nullptr", q != nullptr);
  }
  /* we have now reached the new last pbuf (in q) */
  /* rem_len == desired length for pbuf q */

  /* shrink allocated memory for PBUF_RAM */
  /* (other types merely adjust their length fields */
  if ((q->type == PBUF_RAM) && (rem_len != q->len)) {
    /* reallocate and adjust the length of the pbuf that will be split */
    q = (struct pbuf *)mem_realloc(q, (u8_t *)q->payload - (u8_t *)q + rem_len);
    LWIP_ASSERT("mem_realloc give q == nullptr", q != nullptr);
  }
  /* adjust length fields for new last pbuf */
  q->len = rem_len;
  q->tot_len = q->len;

  /* any remaining pbufs in chain? */
  if (q->next != nullptr) {
    /* free remaining pbufs in chain */
    pbuf_free(q->next);
  }
  /* q is last packet in chain */
  q->next = nullptr;

}

void inet::tcp::pbuf_ref

(

struct pbuf *

p

)

Increment the reference count of the pbuf.

Parameters

p	pbuf to increase reference counter of

Referenced by pbuf_chain().

{
  SYS_ARCH_DECL_PROTECT(old_level);
  /* pbuf given? */
  if (p != nullptr) {
    SYS_ARCH_PROTECT(old_level);
    ++(p->ref);
    SYS_ARCH_UNPROTECT(old_level);
  }
}

void inet::tcp::pbuf_ref_chain

(

struct pbuf *

p

)

err_t inet::tcp::pbuf_take	(	struct pbuf *	buf,
		const void *	dataptr,
		u16_t	len
	)

Copy application supplied data into a pbuf.

This function can only be used to copy the equivalent of buf->tot_len data.

Parameters

buf	pbuf to fill with data
dataptr	application supplied data buffer
len	length of the application supplied data buffer

Returns

ERR_OK if successful, ERR_MEM if the pbuf is not big enough

{
  struct pbuf *p;
  u16_t buf_copy_len;
  u16_t total_copy_len = len;
  u16_t copied_total = 0;

  LWIP_ERROR("pbuf_take: invalid buf", (buf != nullptr), return 0;);
  LWIP_ERROR("pbuf_take: invalid dataptr", (dataptr != nullptr), return 0;);

  if ((buf == nullptr) || (dataptr == nullptr) || (buf->tot_len < len)) {
    return ERR_ARG;
  }

  /* Note some systems use byte copy if dataptr or one of the pbuf payload pointers are unaligned. */
  for(p = buf; total_copy_len != 0; p = p->next) {
    LWIP_ASSERT("pbuf_take: invalid pbuf", p != nullptr);
    buf_copy_len = total_copy_len;
    if (buf_copy_len > p->len) {
      /* this pbuf cannot hold all remaining data */
      buf_copy_len = p->len;
    }
    /* copy the necessary parts of the buffer */
    MEMCPY(p->payload, &((char*)dataptr)[copied_total], buf_copy_len);
    total_copy_len -= buf_copy_len;
    copied_total += buf_copy_len;
  }
  LWIP_ASSERT("did not copy all data", total_copy_len == 0 && copied_total == len);
  return ERR_OK;
}

inet::tcp::Register_Class

(

Sack

)

inet::tcp::Register_Class

(

TCPVirtualDataSendQueue

)

inet::tcp::Register_Class

(

TCPVirtualDataRcvQueue

)

inet::tcp::Register_Class

(

TCPNoCongestionControl

)

inet::tcp::Register_Class

(

DumbTCP

)

Referenced by inet::tcp::Sack::str().

inet::tcp::Register_Class

(

TCPNewReno

)

inet::tcp::Register_Class

(

TCPTahoe

)

inet::tcp::Register_Class

(

TCPMsgBasedSendQueue

)

inet::tcp::Register_Class

(

TCPReno

)

inet::tcp::Register_Class

(

TCPByteStreamSendQueue

)

inet::tcp::Register_Class

(

TCPMsgBasedRcvQueue

)

inet::tcp::Register_Class

(

TCPVegas

)

inet::tcp::Register_Class

(

TCPWestwood

)

inet::tcp::Register_Class

(

TcpLwipVirtualDataSendQueue

)

inet::tcp::Register_Class

(

TCP_NSC_VirtualDataSendQueue

)

inet::tcp::Register_Class

(

TcpLwipMsgBasedSendQueue

)

inet::tcp::Register_Class

(

TCP_NSC_VirtualDataReceiveQueue

)

inet::tcp::Register_Class

(

TCP_NSC_ByteStreamSendQueue

)

inet::tcp::Register_Class

(

TcpLwipVirtualDataReceiveQueue

)

inet::tcp::Register_Class

(

TCPByteStreamRcvQueue

)

inet::tcp::Register_Class

(

TcpLwipByteStreamSendQueue

)

inet::tcp::Register_Class

(

TcpLwipMsgBasedReceiveQueue

)

inet::tcp::Register_Class

(

TcpLwipByteStreamReceiveQueue

)

inet::tcp::Register_Class

(

TCP_NSC_ByteStreamReceiveQueue

)

inet::tcp::Register_Class

(

TCPSegment

)

simtime_t inet::tcp::roundTime	(	const simtime_t &	timeP,
		int	secSlicesP
	)

Referenced by inet::tcp::TCP_lwIP::handleMessage().

{
    int64_t scale = timeP.getScale() / secSlicesP;
    simtime_t ret = timeP;
    ret /= scale;
    ret *= scale;
    return ret;
}

bool inet::tcp::seqGE ( uint32  a, uint32  b  )

inline

Referenced by inet::tcp::TCPConnection::addSacks(), inet::tcp::TCPVirtualDataRcvQueue::extractTo(), inet::tcp::TCPVirtualDataRcvQueue::insertBytesFromSegment(), inet::tcp::TCPConnection::isLost(), inet::tcp::TcpLwipMsgBasedReceiveQueue::notifyAboutIncomingSegmentProcessing(), inet::tcp::TCPConnection::processAckInEstabEtc(), inet::tcp::TCPReno::receivedDataAck(), inet::tcp::TCPNewReno::receivedDataAck(), inet::tcp::TCPReno::receivedDuplicateAck(), inet::tcp::TCPConnection::sendSegment(), inet::tcp::TCPSACKRexmitQueue::setSackedBit(), and inet::tcp::TCPConnection::updateRcvWnd().

{ return (a - b) < (1UL << 31); }

bool inet::tcp::seqGreater ( uint32  a, uint32  b  )

inline

Referenced by inet::tcp::TCPConnection::processAckInEstabEtc(), inet::tcp::TCPConnection::processSACKOption(), inet::tcp::TCPConnection::processSegment1stThru8th(), inet::tcp::TCPConnection::processSegmentInSynSent(), inet::tcp::TCPVegas::receivedDataAck(), inet::tcp::TCPConnection::retransmitOneSegment(), inet::tcp::TCPConnection::sendData(), inet::tcp::TCPConnection::sendOneNewSegment(), inet::tcp::TCPConnection::sendSegmentDuringLossRecoveryPhase(), inet::tcp::TCPByteStreamRcvQueue::Region::split(), inet::tcp::TCPVirtualDataRcvQueue::Region::split(), and inet::tcp::TCPSegment::truncateSegment().

{ return a != b && (a - b) < (1UL << 31); }

bool inet::tcp::seqLE ( uint32  a, uint32  b  )

inline

Referenced by inet::tcp::TCPConnection::addSacks(), inet::tcp::TCPSACKRexmitQueue::checkRexmitQueueForSackedOrRexmittedSegments(), inet::tcp::TCPSACKRexmitQueue::checkSackBlock(), inet::tcp::TCPSegmentTransmitInfoList::clearTo(), inet::tcp::Sack::contains(), inet::tcp::TCPByteStreamSendQueue::createSegmentWithBytes(), inet::tcp::TCPVirtualDataSendQueue::createSegmentWithBytes(), inet::tcp::TCPMsgBasedSendQueue::createSegmentWithBytes(), inet::tcp::TcpLwipMsgBasedSendQueue::createSegmentWithBytes(), inet::tcp::TcpLwipMsgBasedSendQueue::discardAckedBytes(), inet::tcp::TCPByteStreamSendQueue::discardUpTo(), inet::tcp::TCPVirtualDataSendQueue::discardUpTo(), inet::tcp::TCPMsgBasedSendQueue::discardUpTo(), inet::tcp::TCPSACKRexmitQueue::discardUpTo(), inet::tcp::TCPSACKRexmitQueue::enqueueSentData(), inet::tcp::TcpLwipMsgBasedReceiveQueue::extractBytesUpTo(), inet::tcp::TCPVirtualDataRcvQueue::extractTo(), inet::tcp::TCPSegmentTransmitInfoList::get(), inet::tcp::TCPSACKRexmitQueue::getAmountOfSackedBytes(), inet::tcp::TCPVirtualDataRcvQueue::getLE(), inet::tcp::TCPVirtualDataRcvQueue::Region::getLengthTo(), inet::tcp::TCPSACKRexmitQueue::getNumOfDiscontiguousSacks(), inet::tcp::TCPVirtualDataRcvQueue::getRE(), inet::tcp::TCPSACKRexmitQueue::getSackedBit(), inet::tcp::TCPConnection::hasEnoughSpaceForSegmentInReceiveQueue(), inet::tcp::TCPMsgBasedRcvQueue::insertBytesFromSegment(), inet::tcp::TCPConnection::isSegmentAcceptable(), inet::tcp::TcpLwipMsgBasedReceiveQueue::notifyAboutIncomingSegmentProcessing(), inet::tcp::TCPConnection::processAckInEstabEtc(), inet::tcp::TCPConnection::processSACKOption(), inet::tcp::TCPConnection::processSegment1stThru8th(), inet::tcp::TCPConnection::processSegmentInSynSent(), inet::tcp::TCPConnection::processTSOption(), inet::tcp::TCPConnection::sendSegmentDuringLossRecoveryPhase(), inet::tcp::TCPSegmentTransmitInfoList::set(), inet::tcp::TCPSACKRexmitQueue::setSackedBit(), and inet::tcp::TCPConnection::updateWndInfo().

{ return (b - a) < (1UL << 31); }

bool inet::tcp::seqLess ( uint32  a, uint32  b  )

inline

Referenced by inet::tcp::TCPConnection::addSacks(), inet::tcp::TCPSACKRexmitQueue::checkQueue(), inet::tcp::TCPSACKRexmitQueue::checkRexmitQueueForSackedOrRexmittedSegments(), inet::tcp::TCPSACKRexmitQueue::checkSackBlock(), inet::tcp::TCPSegmentTransmitInfoList::clearTo(), inet::tcp::TCPVirtualDataRcvQueue::Region::compare(), inet::tcp::TCPSACKRexmitQueue::discardUpTo(), inet::tcp::TCPVirtualDataSendQueue::enqueueAppData(), inet::tcp::TCPMsgBasedSendQueue::enqueueAppData(), inet::tcp::TCPSACKRexmitQueue::enqueueSentData(), inet::tcp::TCPMsgBasedRcvQueue::extractBytesUpTo(), inet::tcp::TCPSegmentTransmitInfoList::get(), inet::tcp::TCPSACKRexmitQueue::getAmountOfSackedBytes(), inet::tcp::TCPSendQueue::getBytesAvailable(), inet::tcp::TCPVirtualDataRcvQueue::getLE(), inet::tcp::TCPVirtualDataRcvQueue::Region::getLengthTo(), inet::tcp::TCPVirtualDataRcvQueue::getRE(), inet::tcp::TCPSACKRexmitQueue::getSackedBit(), inet::tcp::TCPMsgBasedRcvQueue::insertBytesFromSegment(), inet::tcp::TCPConnection::isSegmentAcceptable(), inet::tcp::TCPByteStreamRcvQueue::Region::merge(), inet::tcp::TCPVirtualDataRcvQueue::Region::merge(), inet::tcp::TCPConnection::nextSeg(), inet::tcp::TcpLwipMsgBasedReceiveQueue::notifyAboutIncomingSegmentProcessing(), inet::tcp::TCPConnection::processAckInEstabEtc(), inet::tcp::TCPConnection::processSegment1stThru8th(), inet::tcp::TCPConnection::processTSOption(), inet::tcp::TCPBaseAlg::receivedDataAck(), inet::tcp::TCPConnection::sendSegmentDuringLossRecoveryPhase(), inet::tcp::TCPSegmentTransmitInfoList::set(), inet::tcp::TCPConnection::setPipe(), inet::tcp::TCPSACKRexmitQueue::setSackedBit(), inet::tcp::TCPByteStreamRcvQueue::Region::split(), inet::tcp::TCPVirtualDataRcvQueue::Region::split(), inet::tcp::TCPSegment::truncateSegment(), and inet::tcp::TCPConnection::updateWndInfo().

{ return a != b && (b - a) < (1UL << 31); }

uint32 inet::tcp::seqMax ( uint32  a, uint32  b  )

inline

Referenced by inet::tcp::TCPVirtualDataRcvQueue::insertBytesFromSegment(), and inet::tcp::TCPByteStreamRcvQueue::Region::merge().

{ return ((a - b) < (1UL << 31)) ? a : b; }

uint32 inet::tcp::seqMin ( uint32  a, uint32  b  )

inline

Referenced by inet::tcp::TCPVirtualDataRcvQueue::getFirstSeqNo(), inet::tcp::TCPVirtualDataRcvQueue::insertBytesFromSegment(), and inet::tcp::TCPByteStreamRcvQueue::Region::merge().

{ return ((b - a) < (1UL << 31)) ? a : b; }

err_t inet::tcp::slipif_init

(

struct netif *

netif

)

void inet::tcp::slipif_poll

(

struct netif *

netif

)

u32_t inet::tcp::sys_arch_mbox_fetch	(	sys_mbox_t	mbox,
		void **	msg,
		u32_t	timeout
	)

u32_t inet::tcp::sys_arch_mbox_tryfetch	(	sys_mbox_t	mbox,
		void **	msg
	)

u32_t inet::tcp::sys_arch_sem_wait	(	sys_sem_t	sem,
		u32_t	timeout
	)

struct sys_timeouts* inet::tcp::sys_arch_timeouts

(

void

)

void inet::tcp::sys_init

(

void

)

u32_t inet::tcp::sys_jiffies

(

void

)

void inet::tcp::sys_mbox_fetch	(	sys_mbox_t	mbox,
		void **	msg
	)

void inet::tcp::sys_mbox_free

(

sys_mbox_t

mbox

)

sys_mbox_t inet::tcp::sys_mbox_new

(

int

size

)

void inet::tcp::sys_mbox_post	(	sys_mbox_t	mbox,
		void *	msg
	)

err_t inet::tcp::sys_mbox_trypost	(	sys_mbox_t	mbox,
		void *	msg
	)

void inet::tcp::sys_msleep

(

u32_t

ms

)

u32_t inet::tcp::sys_now

(

void

)

Returns the current time in milliseconds.

void inet::tcp::sys_sem_free

(

sys_sem_t

sem

)

sys_sem_t inet::tcp::sys_sem_new

(

u8_t

count

)

void inet::tcp::sys_sem_signal

(

sys_sem_t

sem

)

void inet::tcp::sys_sem_wait

(

sys_sem_t

sem

)

int inet::tcp::sys_sem_wait_timeout	(	sys_sem_t	sem,
		u32_t	timeout
	)

sys_thread_t inet::tcp::sys_thread_new	(	char *	name,
		void(*)(void *arg)	thread,
		void *	arg,
		int	stacksize,
		int	prio
	)

void inet::tcp::sys_timeout	(	u32_t	msecs,
		sys_timeout_handler	h,
		void *	arg
	)

void inet::tcp::sys_untimeout	(	sys_timeout_handler	h,
		void *	arg
	)

err_t inet::tcp::tcpip_callback_with_block	(	void(*)(void *ctx)	f,
		void *	ctx,
		u8_t	block
	)

void inet::tcp::tcpip_init	(	void(*)(void *)	tcpip_init_done,
		void *	arg
	)

err_t inet::tcp::tcpip_input	(	struct pbuf *	p,
		struct netif *	inp
	)

err_t inet::tcp::tcpip_timeout	(	u32_t	msecs,
		sys_timeout_handler	h,
		void *	arg
	)

err_t inet::tcp::tcpip_untimeout	(	sys_timeout_handler	h,
		void *	arg
	)

Variable Documentation

class INET_API inet::tcp::TCP_NSC_Connection inet::tcp::__attribute__

const struct ip_hdr* inet::tcp::current_header

Header of the input packet currently being processed.

struct netif* inet::tcp::current_netif

The interface that provided the packet for the current callback invocation.

const struct ip_addr inet::tcp::ip_addr_any

const struct ip_addr inet::tcp::ip_addr_broadcast

const unsigned int inet::tcp::MAX_SACK_ENTRIES = 4

struct netif* inet::tcp::netif_default

The default network interface.

struct netif* inet::tcp::netif_list

The list of network interfaces.

PACK_STRUCT_BEGIN struct inet::tcp::ip_hdr inet::tcp::PACK_STRUCT_STRUCT

const unsigned int inet::tcp::TCP_MAX_HEADER_OCTETS = 60

Referenced by inet::tcp::TCPConnection::sendToIP().