inet::sctp::SCTPAssociation Class Reference

#include <SCTPAssociation.h>

Inheritance diagram for inet::sctp::SCTPAssociation:

Classes
struct	calcBytesToSend
struct	congestionControlFunctions
struct	counter
struct	streamSchedulingFunctions

Public Member Functions
	SCTPAssociation (SCTP *mod, int32 appGateIndex, int32 assocId, IRoutingTable *rt, IInterfaceTable *ift)
	Constructor. More...
	~SCTPAssociation ()
	Destructor. More...
void	sendOnPath (SCTPPathVariables *pathId, const bool firstPass=true)
	Utility: Send data from sendQueue. More...
void	sendOnAllPaths (SCTPPathVariables *firstPath)

Static Public Member Functions
static const char *	indicationName (const int32 code)
	Utility: returns name of SCTP_I_xxx constants. More...
static int	getAddressLevel (const L3Address &addr)
	Utility: return IPv4 or IPv6 address level. More...

Public Attributes
int32	appGateIndex
int32	assocId
int32	fd
bool	listening
L3Address	remoteAddr
L3Address	localAddr
uint16	localPort
uint16	remotePort
uint32	localVTag
uint32	peerVTag
cMessage *	T1_InitTimer
cMessage *	T2_ShutdownTimer
cMessage *	T5_ShutdownGuardTimer
cMessage *	SackTimer
cMessage *	StartTesting
cMessage *	StartAddIP
cOutVector *	advMsgRwnd
cOutVector *	EndToEndDelay
bool	fairTimer
std::map< uint16, cOutVector * >	streamThroughputVectors
cOutVector *	assocThroughputVector
cMessage *	FairStartTimer
cMessage *	FairStopTimer
uint8_t	dacPacketsRcvd

Protected Types
typedef struct inet::sctp::SCTPAssociation::streamSchedulingFunctions	SSFunctions

Protected Member Functions
void	startTimer (cMessage *timer, const simtime_t &timeout)
SCTPAssociation *	cloneAssociation ()
	Utility: clone a listening association. More...
void	initAssociation (SCTPOpenCommand *openCmd)
	Utility: creates send/receive queues and sctpAlgorithm. More...
bool	tsnIsDuplicate (const uint32 tsn) const
	Methods dealing with the handling of TSNs. More...
bool	makeRoomForTsn (const uint32 tsn, const uint32 length, const bool uBit)
void	sendInit ()
	Methods for creating and sending chunks. More...
void	sendInitAck (SCTPInitChunk *initchunk)
void	sendCookieEcho (SCTPInitAckChunk *initackchunk)
void	sendCookieAck (const L3Address &dest)
void	sendAbort (uint16 tBit=0)
void	sendHeartbeat (const SCTPPathVariables *path)
void	sendHeartbeatAck (const SCTPHeartbeatChunk *heartbeatChunk, const L3Address &src, const L3Address &dest)
void	sendSack ()
void	sendShutdown ()
void	sendShutdownAck (const L3Address &dest)
void	sendShutdownComplete ()
SCTPSackChunk *	createSack ()
void	retransmitInit ()
	Retransmitting chunks. More...
void	retransmitCookieEcho ()
void	retransmitReset ()
void	retransmitShutdown ()
void	retransmitShutdownAck ()
void	sendToIP (SCTPMessage *sctpmsg, const L3Address &dest)
	Utility: adds control info to message and sends it to IP. More...
void	sendToIP (SCTPMessage *sctpmsg)
void	scheduleSack ()
void	signalConnectionTimeout ()
	Utility: signal to user that connection timed out. More...
void	scheduleTimeout (cMessage *msg, const simtime_t &timeout)
	Utility: start a timer. More...
cMessage *	cancelEvent (cMessage *msg)
	Utility: cancel a timer. More...
void	sendToApp (cMessage *msg)
	Utility: sends packet to application. More...
void	sendIndicationToApp (const int32 code, const int32 value=0)
	Utility: sends status indication (SCTP_I_xxx) to application. More...
void	sendEstabIndicationToApp ()
	Utility: sends SCTP_I_ESTABLISHED indication with SCTPConnectInfo to application. More...
void	pushUlp ()
void	sendDataArrivedNotification (uint16 sid)
void	putInDeliveryQ (uint16 sid)
void	printAssocBrief ()
	Utility: prints local/remote addr/port and app gate index/assocId. More...
void	addPath (const L3Address &addr)
SCTPPathVariables *	getNextPath (const SCTPPathVariables *oldPath) const
const L3Address &	getNextAddress (const SCTPPathVariables *oldPath) const
SCTPPathVariables *	getNextDestination (SCTPDataVariables *chunk) const
void	bytesAllowedToSend (SCTPPathVariables *path, const bool firstPass)
void	pathStatusIndication (const SCTPPathVariables *path, const bool status)
bool	allPathsInactive () const
void	sendStreamResetRequest (SCTPResetInfo *info)
void	sendStreamResetResponse (uint32 srrsn, int result)
void	sendStreamResetResponse (SCTPSSNTSNResetRequestParameter *requestParam, int result, bool options)
void	sendOutgoingResetRequest (SCTPIncomingSSNResetRequestParameter *requestParam)
void	sendAddOutgoingStreamsRequest (uint16 numStreams)
void	sendBundledOutgoingResetAndResponse (SCTPIncomingSSNResetRequestParameter *requestParam)
void	sendAddInAndOutStreamsRequest (SCTPResetInfo *info)
void	sendDoubleStreamResetResponse (uint32 insrrsn, uint16 inresult, uint32 outsrrsn, uint16 outresult)
void	checkStreamsToReset ()
void	sendPacketDrop (const bool flag)
void	sendHMacError (const uint16 id)
void	sendInvalidStreamError (uint16 sid)
void	resetGapLists ()
SCTPForwardTsnChunk *	createForwardTsnChunk (const L3Address &pid)
bool	msgMustBeAbandoned (SCTPDataMsg *msg, int32 stream, bool ordered)
bool	chunkMustBeAbandoned (SCTPDataVariables *chunk, SCTPPathVariables *sackPath)
void	advancePeerTsn ()
void	cucProcessGapReports (const SCTPDataVariables *chunk, SCTPPathVariables *path, const bool isAcked)
SCTPDataChunk *	transformDataChunk (SCTPDataVariables *chunk)
	Manipulating chunks. More...
SCTPDataVariables *	makeVarFromMsg (SCTPDataChunk *datachunk)
int32	streamScheduler (SCTPPathVariables *path, bool peek)
	Dealing with streams. More...
void	initStreams (uint32 inStreams, uint32 outStreams)
void	addInStreams (uint32 inStreams)
void	addOutStreams (uint32 outStreams)
int32	numUsableStreams ()
int32	streamSchedulerRoundRobinPacket (SCTPPathVariables *path, bool peek)
int32	streamSchedulerRandom (SCTPPathVariables *path, bool peek)
int32	streamSchedulerRandomPacket (SCTPPathVariables *path, bool peek)
int32	streamSchedulerFairBandwidth (SCTPPathVariables *path, bool peek)
int32	streamSchedulerFairBandwidthPacket (SCTPPathVariables *path, bool peek)
int32	streamSchedulerPriority (SCTPPathVariables *path, bool peek)
int32	streamSchedulerFCFS (SCTPPathVariables *path, bool peek)
int32	pathStreamSchedulerManual (SCTPPathVariables *path, bool peek)
int32	pathStreamSchedulerMapToPath (SCTPPathVariables *path, bool peek)
void	process_QUEUE_MSGS_LIMIT (const SCTPCommand *sctpCommand)
	Queue Management. More...
void	process_QUEUE_BYTES_LIMIT (const SCTPCommand *sctpCommand)
int32	getOutstandingBytes () const
void	dequeueAckedChunks (const uint32 tsna, SCTPPathVariables *path, simtime_t &rttEstimation)
SCTPDataMsg *	peekOutboundDataMsg ()
SCTPDataVariables *	peekAbandonedChunk (const SCTPPathVariables *path)
SCTPDataVariables *	getOutboundDataChunk (const SCTPPathVariables *path, const int32 availableSpace, const int32 availableCwnd)
void	fragmentOutboundDataMsgs ()
SCTPDataMsg *	dequeueOutboundDataMsg (SCTPPathVariables *path, const int32 availableSpace, const int32 availableCwnd)
bool	nextChunkFitsIntoPacket (SCTPPathVariables *path, int32 bytes)
void	putInTransmissionQ (uint32 tsn, SCTPDataVariables *chunk)
uint32	getAllTransQ ()
void	pmStartPathManagement ()
	Flow control. More...
void	pmDataIsSentOn (SCTPPathVariables *path)
void	pmClearPathCounter (SCTPPathVariables *path)
void	pmRttMeasurement (SCTPPathVariables *path, const simtime_t &rttEstimation)
void	disposeOf (SCTPMessage *sctpmsg)
void	resetSsns ()
	Methods for Stream Reset. More...
void	resetExpectedSsns ()
bool	sendStreamPresent (uint16 sid)
bool	receiveStreamPresent (uint16 sid)
void	resetSsn (uint16 id)
void	resetExpectedSsn (uint16 id)
uint32	getExpectedSsnOfStream (uint16 id)
uint32	getSsnOfStream (uint16 id)
SCTPParameter *	makeOutgoingStreamResetParameter (uint32 srsn, SCTPResetInfo *info)
SCTPParameter *	makeIncomingStreamResetParameter (uint32 srsn, SCTPResetInfo *info)
SCTPParameter *	makeSSNTSNResetParameter (uint32 srsn)
SCTPParameter *	makeAddStreamsRequestParameter (uint32 srsn, SCTPResetInfo *info)
void	sendOutgoingRequestAndResponse (uint32 inRequestSn, uint32 outRequestSn)
void	sendOutgoingRequestAndResponse (SCTPIncomingSSNResetRequestParameter *inRequestParam, SCTPOutgoingSSNResetRequestParameter *outRequestParam)
SCTPEventCode	processInAndOutResetRequestArrived (SCTPIncomingSSNResetRequestParameter *inRequestParam, SCTPOutgoingSSNResetRequestParameter *outRequestParam)
SCTPEventCode	processOutAndResponseArrived (SCTPOutgoingSSNResetRequestParameter *outRequestParam, SCTPStreamResetResponseParameter *responseParam)
SCTPEventCode	processStreamResetArrived (SCTPStreamResetChunk *strResChunk)
void	processOutgoingResetRequestArrived (SCTPOutgoingSSNResetRequestParameter *requestParam)
void	processIncomingResetRequestArrived (SCTPIncomingSSNResetRequestParameter *requestParam)
void	processSSNTSNResetRequestArrived (SCTPSSNTSNResetRequestParameter *requestParam)
void	processResetResponseArrived (SCTPStreamResetResponseParameter *responseParam)
void	processAddInAndOutResetRequestArrived (SCTPAddStreamsRequestParameter *addInRequestParam, SCTPAddStreamsRequestParameter *addOutRequestParam)
uint32	getBytesInFlightOfStream (uint16 sid)
bool	getFragInProgressOfStream (uint16 sid)
void	setFragInProgressOfStream (uint16 sid, bool frag)
bool	orderedQueueEmptyOfStream (uint16 sid)
bool	unorderedQueueEmptyOfStream (uint16 sid)
void	sendAsconf (const char *type, const bool remote=false)
	Methods for Add-IP and AUTH. More...
void	sendAsconfAck (const uint32 serialNumber)
SCTPEventCode	processAsconfArrived (SCTPAsconfChunk *asconfChunk)
SCTPEventCode	processAsconfAckArrived (SCTPAsconfAckChunk *asconfAckChunk)
void	retransmitAsconf ()
bool	typeInChunkList (const uint16 type)
bool	typeInOwnChunkList (const uint16 type)
SCTPAsconfAckChunk *	createAsconfAckChunk (const uint32 serialNumber)
SCTPAuthenticationChunk *	createAuthChunk ()
SCTPSuccessIndication *	createSuccessIndication (uint32 correlationId)
void	calculateAssocSharedKey ()
bool	compareRandom ()
void	calculateRcvBuffer ()
void	listOrderedQ ()
void	tsnWasReneged (SCTPDataVariables *chunk, const SCTPPathVariables *sackPath, const int type)
void	printOutstandingTsns ()
void	initCCParameters (SCTPPathVariables *path)
	SCTPCCFunctions. More...
void	updateFastRecoveryStatus (const uint32 lastTsnAck)
void	cwndUpdateBeforeSack ()
void	cwndUpdateAfterSack ()
void	cwndUpdateAfterCwndTimeout (SCTPPathVariables *path)
void	cwndUpdateAfterRtxTimeout (SCTPPathVariables *path)
void	cwndUpdateMaxBurst (SCTPPathVariables *path)
void	cwndUpdateBytesAcked (SCTPPathVariables *path, const uint32 ackedBytes, const bool ctsnaAdvanced)
int32	rpPathBlockingControl (SCTPPathVariables *path, const double reduction)
FSM transitions: analysing events and executing state transitions
SCTPEventCode	preanalyseAppCommandEvent (int32 commandCode)
	Maps app command codes (msg kind of app command msgs) to SCTP_E_xxx event codes. More...
bool	performStateTransition (const SCTPEventCode &event)
	Implemements the pure SCTP state machine. More...
void	stateEntered (int32 state)
Processing app commands. Invoked from processAppCommand().
void	process_ASSOCIATE (SCTPEventCode &event, SCTPCommand *sctpCommand, cMessage *msg)
void	process_OPEN_PASSIVE (SCTPEventCode &event, SCTPCommand *sctpCommand, cMessage *msg)
void	process_SEND (SCTPEventCode &event, SCTPCommand *sctpCommand, cMessage *msg)
void	process_CLOSE (SCTPEventCode &event)
void	process_ABORT (SCTPEventCode &event)
void	process_STATUS (SCTPEventCode &event, SCTPCommand *sctpCommand, cMessage *msg)
void	process_RECEIVE_REQUEST (SCTPEventCode &event, SCTPCommand *sctpCommand)
void	process_PRIMARY (SCTPEventCode &event, SCTPCommand *sctpCommand)
void	process_STREAM_RESET (SCTPCommand *sctpCommand)
Processing SCTP message arrivals. Invoked from processSCTPMessage().
bool	process_RCV_Message (SCTPMessage *sctpseg, const L3Address &src, const L3Address &dest)
bool	processInitArrived (SCTPInitChunk *initChunk, int32 sport, int32 dport)
	Process incoming SCTP packets. More...
bool	processInitAckArrived (SCTPInitAckChunk *initAckChunk)
bool	processCookieEchoArrived (SCTPCookieEchoChunk *cookieEcho, L3Address addr)
bool	processCookieAckArrived ()
SCTPEventCode	processDataArrived (SCTPDataChunk *dataChunk)
SCTPEventCode	processSackArrived (SCTPSackChunk *sackChunk)
SCTPEventCode	processHeartbeatAckArrived (SCTPHeartbeatAckChunk *heartbeatack, SCTPPathVariables *path)
SCTPEventCode	processForwardTsnArrived (SCTPForwardTsnChunk *forChunk)
bool	processPacketDropArrived (SCTPPacketDropChunk *pktdrop)
void	processErrorArrived (SCTPErrorChunk *error)
Processing timeouts. Invoked from processTimer().
void	process_TIMEOUT_RTX (SCTPPathVariables *path)
void	process_TIMEOUT_BLOCKING (SCTPPathVariables *path)
void	process_TIMEOUT_HEARTBEAT (SCTPPathVariables *path)
void	process_TIMEOUT_HEARTBEAT_INTERVAL (SCTPPathVariables *path, bool force)
void	process_TIMEOUT_INIT_REXMIT (SCTPEventCode &event)
void	process_TIMEOUT_PROBING ()
void	process_TIMEOUT_SHUTDOWN (SCTPEventCode &event)
int32	updateCounters (SCTPPathVariables *path)
void	process_TIMEOUT_RESET (SCTPPathVariables *path)
void	process_TIMEOUT_ASCONF (SCTPPathVariables *path)

Static Protected Member Functions
static void	printSegmentBrief (SCTPMessage *sctpmsg)
	Utility: prints important header fields. More...
static const char *	eventName (const int32 event)
	Utility: returns name of SCTP_E_xxx constants. More...

Protected Attributes
IRoutingTable *	rt
IInterfaceTable *	ift
AddressVector	localAddressList
AddressVector	remoteAddressList
uint32	numberOfRemoteAddresses
uint32	inboundStreams
uint32	outboundStreams
uint32	initInboundStreams
int32	status
uint32	initTsn
uint32	initPeerTsn
uint32	sackFrequency
double	sackPeriod
CCFunctions	ccFunctions
uint16	ccModule
cOutVector *	advRwnd
cOutVector *	cumTsnAck
cOutVector *	sendQueue
cOutVector *	numGapBlocks
SCTPStateVariables *	state
BytesToBeSent	bytes
SCTP *	sctpMain
cFSM *	fsm
SCTPPathMap	sctpPathMap
QueueCounter	qCounter
SCTPQueue *	transmissionQ
SCTPQueue *	retransmissionQ
SCTPSendStreamMap	sendStreams
SCTPReceiveStreamMap	receiveStreams
SCTPAlgorithm *	sctpAlgorithm
cOutVector *	statisticsOutstandingBytes
cOutVector *	statisticsQueuedReceivedBytes
cOutVector *	statisticsQueuedSentBytes
cOutVector *	statisticsTotalSSthresh
cOutVector *	statisticsTotalCwnd
cOutVector *	statisticsTotalBandwidth
cOutVector *	statisticsRevokableGapBlocksInLastSACK
cOutVector *	statisticsNonRevokableGapBlocksInLastSACK
cOutVector *	statisticsArwndInLastSACK
cOutVector *	statisticsPeerRwnd
cOutVector *	statisticsNumTotalGapBlocksStored
cOutVector *	statisticsNumRevokableGapBlocksStored
cOutVector *	statisticsNumNonRevokableGapBlocksStored
cOutVector *	statisticsNumDuplicatesStored
cOutVector *	statisticsNumRevokableGapBlocksSent
cOutVector *	statisticsNumNonRevokableGapBlocksSent
cOutVector *	statisticsNumDuplicatesSent
cOutVector *	statisticsSACKLengthSent
SSFunctions	ssFunctions
uint16	ssModule

Private Types
typedef std::map< L3Address, SCTPPathVariables * >	SCTPPathMap
typedef std::map< L3Address, uint32 >	CounterMap
typedef struct inet::sctp::SCTPAssociation::counter	QueueCounter
typedef struct inet::sctp::SCTPAssociation::calcBytesToSend	BytesToBeSent
typedef struct inet::sctp::SCTPAssociation::congestionControlFunctions	CCFunctions
typedef std::map< uint32, SCTPSendStream * >	SCTPSendStreamMap
typedef std::map< uint32, SCTPReceiveStream * >	SCTPReceiveStreamMap
typedef std::map< uint32, SCTPPathVariables * >	SCTPPathCollection

Private Member Functions
SCTPDataVariables *	makeDataVarFromDataMsg (SCTPDataMsg *datMsg, SCTPPathVariables *path)
SCTPPathVariables *	choosePathForRetransmission ()
void	timeForSack (bool &sackOnly, bool &sackWithData)
void	recordCwndUpdate (SCTPPathVariables *path)
void	sendSACKviaSelectedPath (SCTPMessage *sctpMsg)
void	checkOutstandingBytes ()
void	updateHighSpeedCCThresholdIdx (SCTPPathVariables *path)
uint32	getInitialCwnd (const SCTPPathVariables *path) const
void	generateSendQueueAbatedIndication (const uint64 bytes)
void	renegablyAckChunk (SCTPDataVariables *chunk, SCTPPathVariables *sackPath)
void	nonRenegablyAckChunk (SCTPDataVariables *chunk, SCTPPathVariables *sackPath, simtime_t &rttEstimation, SCTP::AssocStat *assocStat)
void	handleChunkReportedAsAcked (uint32 &highestNewAck, simtime_t &rttEstimation, SCTPDataVariables *myChunk, SCTPPathVariables *sackPath, const bool sackIsNonRevokable)
void	handleChunkReportedAsMissing (const SCTPSackChunk *sackChunk, const uint32 highestNewAck, SCTPDataVariables *myChunk, SCTPPathVariables *sackPath)
void	moveChunkToOtherPath (SCTPDataVariables *chunk, SCTPPathVariables *newPath)
void	decreaseOutstandingBytes (SCTPDataVariables *chunk)
void	increaseOutstandingBytes (SCTPDataVariables *chunk, SCTPPathVariables *path)
int32	calculateBytesToSendOnPath (const SCTPPathVariables *pathVar)
void	storePacket (SCTPPathVariables *pathVar, SCTPMessage *sctpMsg, const uint16 chunksAdded, const uint16 dataChunksAdded, const bool authAdded)
void	loadPacket (SCTPPathVariables *pathVar, SCTPMessage **sctpMsg, uint16 *chunksAdded, uint16 *dataChunksAdded, bool *authAdded)
void	ackChunk (SCTPDataVariables *chunk, SCTPPathVariables *sackPath)
void	unackChunk (SCTPDataVariables *chunk)
bool	chunkHasBeenAcked (const SCTPDataVariables *chunk) const
bool	chunkHasBeenAcked (const uint32 tsn) const
void	checkPseudoCumAck (const SCTPPathVariables *path)
std::vector< SCTPPathVariables * >	getSortedPathMap ()
void	chunkReschedulingControl (SCTPPathVariables *path)
void	recalculateOLIABasis ()
uint32	updateOLIA (uint32 w, const uint32 s, const uint32 totalW, double a, const uint32 mtu, const uint32 ackedBytes, SCTPPathVariables *path)
	w: cwnd of the path s: ssthresh of the path totalW: Sum of all cwnds of the association a: factor alpha of olia calculation - see https://tools.ietf.org/html/draft-khalili-mptcp-congestion-control-05 mtu: mtu of the path ackedBytes: ackednowlged bytes path: path variable (for further investigation, debug, etc) More...
bool	addAuthChunkIfNecessary (SCTPMessage *sctpMsg, const uint16 chunkType, const bool authAdded)

Static Private Member Functions
static bool	pathMapLargestSSThreshold (const SCTPPathVariables *left, const SCTPPathVariables *right)
static bool	pathMapLargestSpace (const SCTPPathVariables *left, const SCTPPathVariables *right)
static bool	pathMapLargestSpaceAndSSThreshold (const SCTPPathVariables *left, const SCTPPathVariables *right)
static bool	pathMapSmallestLastTransmission (const SCTPPathVariables *left, const SCTPPathVariables *right)
static bool	pathMapRandomized (const SCTPPathVariables *left, const SCTPPathVariables *right)

Private Attributes
SCTPPathCollection	assocBestPaths
SCTPPathCollection	assocMaxWndPaths
SCTPPathCollection	assocCollectedPaths

Friends
class	SCTP
class	SCTPPathVariables
int32	getFsmState () const
SCTPStateVariables *	getState () const
SCTPQueue *	getTransmissionQueue () const
SCTPQueue *	getRetransmissionQueue () const
SCTPAlgorithm *	getSctpAlgorithm () const
SCTP *	getSctpMain () const
cFSM *	getFsm () const
cMessage *	getInitTimer () const
cMessage *	getShutdownTimer () const
cMessage *	getSackTimer () const
bool	processTimer (cMessage *msg)
bool	processSCTPMessage (SCTPMessage *sctpmsg, const L3Address &srcAddr, const L3Address &destAddr)
	Process incoming SCTP segment. More...
bool	processAppCommand (cMessage *msg)
	Process commands from the application. More...
void	removePath ()
void	removePath (const L3Address &addr)
void	deleteStreams ()
void	stopTimer (cMessage *timer)
void	stopTimers ()
SCTPPathVariables *	getPath (const L3Address &pathId) const
void	printSctpPathMap () const
static const char *	stateName (const int32 state)
	Utility: returns name of SCTP_S_xxx constants. More...
static uint16	chunkToInt (const char *type)
static int32	tsnGe (const uint32 tsn1, const uint32 tsn2)
static int32	tsnGt (const uint32 tsn1, const uint32 tsn2)
static int32	tsnLe (const uint32 tsn1, const uint32 tsn2)
static int32	tsnLt (const uint32 tsn1, const uint32 tsn2)
static int32	tsnBetween (const uint32 tsn1, const uint32 midtsn, const uint32 tsn2)
static int16	ssnGt (const uint16 ssn1, const uint16 ssn2)
static int32	midGt (const uint32 mid1, const uint32 mid2)

Member Typedef Documentation

typedef struct inet::sctp::SCTPAssociation::calcBytesToSend inet::sctp::SCTPAssociation::BytesToBeSent

private

typedef struct inet::sctp::SCTPAssociation::congestionControlFunctions inet::sctp::SCTPAssociation::CCFunctions

private

typedef std::map<L3Address, uint32> inet::sctp::SCTPAssociation::CounterMap

private

typedef struct inet::sctp::SCTPAssociation::counter inet::sctp::SCTPAssociation::QueueCounter

private

typedef std::map<uint32,SCTPPathVariables*> inet::sctp::SCTPAssociation::SCTPPathCollection

private

typedef std::map<L3Address, SCTPPathVariables *> inet::sctp::SCTPAssociation::SCTPPathMap

private

typedef std::map<uint32, SCTPReceiveStream *> inet::sctp::SCTPAssociation::SCTPReceiveStreamMap

private

typedef std::map<uint32, SCTPSendStream *> inet::sctp::SCTPAssociation::SCTPSendStreamMap

private

typedef struct inet::sctp::SCTPAssociation::streamSchedulingFunctions inet::sctp::SCTPAssociation::SSFunctions

protected

Constructor & Destructor Documentation

inet::sctp::SCTPAssociation::SCTPAssociation	(	SCTP *	mod,
		int32	appGateIndex,
		int32	assocId,
		IRoutingTable *	rt,
		IInterfaceTable *	ift
	)

Constructor.

Referenced by cloneAssociation().

{
    // ====== Initialize variables ===========================================
    rt = _rt;
    ift = _ift;
    sctpMain = _module;
    appGateIndex = _appGateIndex;
    assocId = _assocId;
    fd = -1;
    listening = false;
    localPort = 0;
    remotePort = 0;
    localVTag = 0;
    peerVTag = 0;
    numberOfRemoteAddresses = 0;
    inboundStreams = SCTP_DEFAULT_INBOUND_STREAMS;
    outboundStreams = SCTP_DEFAULT_OUTBOUND_STREAMS;
    initInboundStreams = 0;
    // queues and algorithm will be created on active or passive open
    transmissionQ = nullptr;
    retransmissionQ = nullptr;
    sctpAlgorithm = nullptr;
    state = nullptr;
    sackPeriod = SACK_DELAY;

    cumTsnAck = nullptr;
    sendQueue = nullptr;
    numGapBlocks = nullptr;

    qCounter.roomSumSendStreams = 0;
    qCounter.bookedSumSendStreams = 0;
    qCounter.roomSumRcvStreams = 0;
    bytes.chunk = false;
    bytes.packet = false;
    bytes.bytesToSend = 0;

    fairTimer = false;
    status = SCTP_S_CLOSED;
    initTsn = 0;
    initPeerTsn = 0;
    sackFrequency = 2;
    ccFunctions.ccInitParams = nullptr;
    ccFunctions.ccUpdateBeforeSack = nullptr;
    ccFunctions.ccUpdateAfterSack = nullptr;
    ccFunctions.ccUpdateAfterCwndTimeout = nullptr;
    ccFunctions.ccUpdateAfterRtxTimeout = nullptr;
    ccFunctions.ccUpdateMaxBurst = nullptr;
    ccFunctions.ccUpdateBytesAcked = nullptr;
    ccModule = 0;
    ssFunctions.ssInitStreams = nullptr;
    ssFunctions.ssAddInStreams = nullptr;
    ssFunctions.ssAddOutStreams = nullptr;
    ssFunctions.ssGetNextSid = nullptr;
    ssFunctions.ssUsableStreams = nullptr;

    EV_INFO << "SCTPAssociationBase::SCTPAssociation(): new assocId="
            << assocId << endl;

    // ====== FSM ============================================================
    char fsmName[64];
    snprintf(fsmName, sizeof(fsmName), "fsm-%d", assocId);
    fsm = new cFSM();
    fsm->setName(fsmName);
    fsm->setState(SCTP_S_CLOSED);

    // ====== Path Info ======================================================
    SCTPPathInfo *pinfo = new SCTPPathInfo("pathInfo");
    pinfo->setRemoteAddress(L3Address());

    // ====== Timers =========================================================
    char timerName[128];
    snprintf(timerName, sizeof(timerName), "T1_INIT of Association %d", assocId);
    T1_InitTimer = new cMessage(timerName);
    snprintf(timerName, sizeof(timerName), "T2_SHUTDOWN of Association %d", assocId);
    T2_ShutdownTimer = new cMessage(timerName);
    snprintf(timerName, sizeof(timerName), "T5_SHUTDOWN_GUARD of Association %d", assocId);
    T5_ShutdownGuardTimer = new cMessage(timerName);
    snprintf(timerName, sizeof(timerName), "SACK_TIMER of Association %d", assocId);
    SackTimer = new cMessage(timerName);

    StartTesting = nullptr;
    if (sctpMain->testTimeout > 0) {
        StartTesting = new cMessage("StartTesting");
        StartTesting->setContextPointer(this);
        StartTesting->setControlInfo(pinfo->dup());
        scheduleTimeout(StartTesting, sctpMain->testTimeout);
    }

    T1_InitTimer->setContextPointer(this);
    T2_ShutdownTimer->setContextPointer(this);
    SackTimer->setContextPointer(this);
    T5_ShutdownGuardTimer->setContextPointer(this);

    T1_InitTimer->setControlInfo(pinfo);
    T2_ShutdownTimer->setControlInfo(pinfo->dup());
    SackTimer->setControlInfo(pinfo->dup());
    T5_ShutdownGuardTimer->setControlInfo(pinfo->dup());

    // ====== Output vectors =================================================
    char vectorName[128];
    snprintf(vectorName, sizeof(vectorName), "Advertised Receiver Window %d", assocId);
    advRwnd = new cOutVector(vectorName);

    snprintf(vectorName, sizeof(vectorName), "Slow Start Threshold %d:Total", assocId);
    statisticsTotalSSthresh = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Congestion Window %d:Total", assocId);
    statisticsTotalCwnd = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Bandwidth %d:Total", assocId);
    statisticsTotalBandwidth = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Queued Received Bytes %d:Total", assocId);
    statisticsQueuedReceivedBytes = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Queued Sent Bytes %d:Total", assocId);
    statisticsQueuedSentBytes = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Outstanding Bytes %d:Total", assocId);
    statisticsOutstandingBytes = new cOutVector(vectorName);

    snprintf(vectorName, sizeof(vectorName), "Number of Revokable Gap Blocks in SACK %d", assocId);
    statisticsRevokableGapBlocksInLastSACK = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Number of Non-Revokable Gap Blocks in SACK %d", assocId);
    statisticsNonRevokableGapBlocksInLastSACK = new cOutVector(vectorName);

    snprintf(vectorName, sizeof(vectorName), "Number of Total Gap Blocks Stored %d", assocId);
    statisticsNumTotalGapBlocksStored = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Number of Revokable Gap Blocks Stored %d", assocId);
    statisticsNumRevokableGapBlocksStored = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Number of Non-Revokable Gap Blocks Stored %d", assocId);
    statisticsNumNonRevokableGapBlocksStored = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Number of Duplicate TSNs Stored %d", assocId);
    statisticsNumDuplicatesStored = new cOutVector(vectorName);

    snprintf(vectorName, sizeof(vectorName), "Number of Revokable Gap Blocks Sent %d", assocId);
    statisticsNumRevokableGapBlocksSent = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Number of Non-Revokable Gap Blocks Sent %d", assocId);
    statisticsNumNonRevokableGapBlocksSent = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Number of Duplicate TSNs Sent %d", assocId);
    statisticsNumDuplicatesSent = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Length of SACK Sent %d", assocId);
    statisticsSACKLengthSent = new cOutVector(vectorName);

    snprintf(vectorName, sizeof(vectorName), "Arwnd in Last SACK %d", assocId);
    statisticsArwndInLastSACK = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "Peer Rwnd %d", assocId);
    statisticsPeerRwnd = new cOutVector(vectorName);

    // ====== Extensions =====================================================
    StartAddIP = new cMessage("addIP");
    StartAddIP->setContextPointer(this);
    StartAddIP->setControlInfo(pinfo->dup());
    FairStartTimer = new cMessage("fairStart");
    FairStartTimer->setContextPointer(this);
    FairStartTimer->setControlInfo(pinfo->dup());
    FairStopTimer = new cMessage("fairStop");
    FairStopTimer->setContextPointer(this);
    FairStopTimer->setControlInfo(pinfo->dup());
    snprintf(vectorName, sizeof(vectorName), "Advertised Message Receiver Window of Association %d", assocId);
    advMsgRwnd = new cOutVector(vectorName);
    snprintf(vectorName, sizeof(vectorName), "End to End Delay of Association %d", assocId);
    EndToEndDelay = new cOutVector(vectorName);

    // ====== Assoc throughput ===============================================
    snprintf(vectorName, sizeof(vectorName), "Throughput of Association %d", assocId);
    assocThroughputVector = new cOutVector(vectorName);
    assocThroughputVector->record(0.0);

    // ====== CMT Delayed Ack ================================================
    dacPacketsRcvd = 0;

    // ====== Stream scheduling ==============================================
    ssModule = sctpMain->par("ssModule");

    switch (ssModule) {
        case ROUND_ROBIN:
            ssFunctions.ssInitStreams = &SCTPAssociation::initStreams;
            ssFunctions.ssAddInStreams = &SCTPAssociation::addInStreams;
            ssFunctions.ssAddOutStreams = &SCTPAssociation::addOutStreams;
            ssFunctions.ssGetNextSid = &SCTPAssociation::streamScheduler;
            ssFunctions.ssUsableStreams = &SCTPAssociation::numUsableStreams;
            EV_DETAIL << "Setting Stream Scheduler: ROUND_ROBIN" << endl;
            break;

        case ROUND_ROBIN_PACKET:
            ssFunctions.ssInitStreams = &SCTPAssociation::initStreams;
            ssFunctions.ssAddInStreams = &SCTPAssociation::addInStreams;
            ssFunctions.ssAddOutStreams = &SCTPAssociation::addOutStreams;
            ssFunctions.ssGetNextSid = &SCTPAssociation::streamSchedulerRoundRobinPacket;
            ssFunctions.ssUsableStreams = &SCTPAssociation::numUsableStreams;
            EV_DETAIL << "Setting Stream Scheduler: ROUND_ROBIN_PACKET" << endl;
            break;

        case RANDOM_SCHEDULE:
            ssFunctions.ssInitStreams = &SCTPAssociation::initStreams;
            ssFunctions.ssAddInStreams = &SCTPAssociation::addInStreams;
            ssFunctions.ssAddOutStreams = &SCTPAssociation::addOutStreams;
            ssFunctions.ssGetNextSid = &SCTPAssociation::streamSchedulerRandom;
            ssFunctions.ssUsableStreams = &SCTPAssociation::numUsableStreams;
            EV_DETAIL << "Setting Stream Scheduler: RANDOM_SCHEDULE" << endl;
            break;

        case RANDOM_SCHEDULE_PACKET:
            ssFunctions.ssInitStreams = &SCTPAssociation::initStreams;
            ssFunctions.ssAddInStreams = &SCTPAssociation::addInStreams;
            ssFunctions.ssAddOutStreams = &SCTPAssociation::addOutStreams;
            ssFunctions.ssGetNextSid = &SCTPAssociation::streamSchedulerRandomPacket;
            ssFunctions.ssUsableStreams = &SCTPAssociation::numUsableStreams;
            EV_DETAIL << "Setting Stream Scheduler: RANDOM_SCHEDULE_PACKET" << endl;
            break;

        case FAIR_BANDWITH:
            ssFunctions.ssInitStreams = &SCTPAssociation::initStreams;
            ssFunctions.ssAddInStreams = &SCTPAssociation::addInStreams;
            ssFunctions.ssAddOutStreams = &SCTPAssociation::addOutStreams;
            ssFunctions.ssGetNextSid = &SCTPAssociation::streamSchedulerFairBandwidth;
            ssFunctions.ssUsableStreams = &SCTPAssociation::numUsableStreams;
            EV_DETAIL << "Setting Stream Scheduler: FAIR_BANDWITH" << endl;
            break;

        case FAIR_BANDWITH_PACKET:
            ssFunctions.ssInitStreams = &SCTPAssociation::initStreams;
            ssFunctions.ssAddInStreams = &SCTPAssociation::addInStreams;
            ssFunctions.ssAddOutStreams = &SCTPAssociation::addOutStreams;
            ssFunctions.ssGetNextSid = &SCTPAssociation::streamSchedulerFairBandwidthPacket;
            ssFunctions.ssUsableStreams = &SCTPAssociation::numUsableStreams;
            EV_DETAIL << "Setting Stream Scheduler: FAIR_BANDWITH_PACKET" << endl;
            break;

        case PRIORITY:
            ssFunctions.ssInitStreams = &SCTPAssociation::initStreams;
            ssFunctions.ssAddInStreams = &SCTPAssociation::addInStreams;
            ssFunctions.ssAddOutStreams = &SCTPAssociation::addOutStreams;
            ssFunctions.ssGetNextSid = &SCTPAssociation::streamSchedulerPriority;
            ssFunctions.ssUsableStreams = &SCTPAssociation::numUsableStreams;
            EV_DETAIL << "Setting Stream Scheduler: PRIORITY" << endl;
            break;

        case FCFS:
            ssFunctions.ssInitStreams = &SCTPAssociation::initStreams;
            ssFunctions.ssGetNextSid = &SCTPAssociation::streamSchedulerFCFS;
            ssFunctions.ssUsableStreams = &SCTPAssociation::numUsableStreams;
            EV_DETAIL << "Setting Stream Scheduler: FCFS" << endl;
            break;

        case PATH_MANUAL:
            ssFunctions.ssInitStreams = &SCTPAssociation::initStreams;
            ssFunctions.ssAddInStreams = &SCTPAssociation::addInStreams;
            ssFunctions.ssAddOutStreams = &SCTPAssociation::addOutStreams;
            ssFunctions.ssGetNextSid = &SCTPAssociation::pathStreamSchedulerManual;
            ssFunctions.ssUsableStreams = &SCTPAssociation::numUsableStreams;
            EV_DETAIL << "Setting Stream Scheduler: PATH_MANUAL" << endl;
            break;

        case PATH_MAP_TO_PATH:
            ssFunctions.ssInitStreams = &SCTPAssociation::initStreams;
            ssFunctions.ssAddInStreams = &SCTPAssociation::addInStreams;
            ssFunctions.ssAddOutStreams = &SCTPAssociation::addOutStreams;
            ssFunctions.ssGetNextSid = &SCTPAssociation::pathStreamSchedulerMapToPath;
            ssFunctions.ssUsableStreams = &SCTPAssociation::numUsableStreams;
            EV_DETAIL << "Setting Stream Scheduler: PATH_MAP_TO_PATH" << endl;
            break;
    }
}

inet::sctp::SCTPAssociation::~SCTPAssociation

(

)

Destructor.

{
    EV_TRACE << "Destructor SCTPAssociation " << assocId << endl;

    delete T1_InitTimer;
    delete T2_ShutdownTimer;
    delete T5_ShutdownGuardTimer;
    delete SackTimer;

    delete advRwnd;
    delete cumTsnAck;
    delete numGapBlocks;
    delete sendQueue;

    delete statisticsOutstandingBytes;
    delete statisticsQueuedReceivedBytes;
    delete statisticsQueuedSentBytes;
    delete statisticsTotalSSthresh;
    delete statisticsTotalCwnd;
    delete statisticsTotalBandwidth;

    delete statisticsRevokableGapBlocksInLastSACK;
    delete statisticsNonRevokableGapBlocksInLastSACK;
    delete statisticsNumTotalGapBlocksStored;
    delete statisticsNumRevokableGapBlocksStored;
    delete statisticsNumNonRevokableGapBlocksStored;
    delete statisticsNumDuplicatesStored;
    delete statisticsNumRevokableGapBlocksSent;
    delete statisticsNumNonRevokableGapBlocksSent;
    delete statisticsNumDuplicatesSent;
    delete statisticsSACKLengthSent;

    delete statisticsArwndInLastSACK;
    delete statisticsPeerRwnd;

    delete StartAddIP;
    delete advMsgRwnd;
    delete EndToEndDelay;

    int i = 0;
    while (streamThroughputVectors[i] != nullptr) {
        delete streamThroughputVectors[i++];
    }
    if (assocThroughputVector != nullptr)
        delete assocThroughputVector;
    if (FairStartTimer)
        delete cancelEvent(FairStartTimer);
    if (FairStopTimer)
        delete cancelEvent(FairStopTimer);

    if (state->asconfOutstanding && state->asconfChunk)
        delete state->asconfChunk;

    delete fsm;
    delete state;
    delete sctpAlgorithm;
}

Member Function Documentation

void inet::sctp::SCTPAssociation::ackChunk ( SCTPDataVariables *  chunk, SCTPPathVariables *  sackPath  )

inlineprivate

Referenced by nonRenegablyAckChunk(), and renegablyAckChunk().

    {
        chunk->hasBeenAcked = true;
        chunk->ackedOnPath = sackPath;
    }

bool inet::sctp::SCTPAssociation::addAuthChunkIfNecessary ( SCTPMessage *  sctpMsg, const uint16  chunkType, const bool  authAdded  )

inlineprivate

Referenced by sendOnPath().

    {
        if ((state->auth) && (state->peerAuth) && (typeInChunkList(chunkType)) && (authAdded == false)) {
            SCTPAuthenticationChunk *authChunk = createAuthChunk();
            sctpMsg->addChunk(authChunk);
            auto it = sctpMain->assocStatMap.find(assocId);
            it->second.numAuthChunksSent++;
            return true;
        }
        return false;
    }

void inet::sctp::SCTPAssociation::addInStreams ( uint32  inStreams )

protected

Referenced by SCTPAssociation(), and sendAddInAndOutStreamsRequest().

{
    uint32 i, j;
    char vectorName[128];
    EV_INFO << "Add " << inStreams << " inbound streams" << endl;
    for (i = receiveStreams.size(), j = 0; j < inStreams; i++, j++) {
        SCTPReceiveStream *rcvStream = new SCTPReceiveStream(this);
        this->receiveStreams[i] = rcvStream;
        rcvStream->setStreamId(i);
        this->state->numMsgsReq[i] = 0;
        snprintf(vectorName, sizeof(vectorName), "Stream %d Throughput", i);
        streamThroughputVectors[i] = new cOutVector(vectorName);
    }
}

void inet::sctp::SCTPAssociation::addOutStreams ( uint32  outStreams )

protected

Referenced by SCTPAssociation(), and sendAddInAndOutStreamsRequest().

{
    uint32 i, j;
    EV_INFO << "Add " << outStreams << " outbound streams" << endl;
    for (i = sendStreams.size(), j = 0; j < outStreams; i++, j++) {
        SCTPSendStream *sendStream = new SCTPSendStream(this, i);
        sendStream->setStreamId(i);
        this->sendStreams[i] = sendStream;
    }
}

void inet::sctp::SCTPAssociation::addPath ( const L3Address &  addr )

protected

Referenced by processAsconfArrived(), and processInitAckArrived().

{
    EV_INFO << "Add Path remote address: " << addr << "\n";

    auto i = sctpPathMap.find(addr);
    if (i == sctpPathMap.end()) {
        EV_DEBUG << " get new path for " << addr << " at line " << __LINE__ << "\n";
        SCTPPathVariables *path = new SCTPPathVariables(addr, this, rt);
        sctpPathMap[addr] = path;
        qCounter.roomTransQ[addr] = 0;
        qCounter.bookedTransQ[addr] = 0;
        qCounter.roomRetransQ[addr] = 0;
    }
    EV_INFO << "path added\n";
}

void inet::sctp::SCTPAssociation::advancePeerTsn ( )

protected

Referenced by createForwardTsnChunk(), and processSackArrived().

{
    // Rewrote code for efficiency, it consomed >40% of total CPU time before!
    // Find the highest TSN to advance to, not just the first one.
    auto iterator = retransmissionQ->payloadQueue.find(state->advancedPeerAckPoint + 1);
    while (iterator != retransmissionQ->payloadQueue.end()) {
        if (iterator->second->hasBeenAbandoned) {
            state->advancedPeerAckPoint = iterator->second->tsn;
            state->ackPointAdvanced = true;
            iterator++;
        }
        else {
            if (iterator->second->hasBeenAcked == true)
                iterator++;
            else
                break;
        }
    }

    EV_INFO << "advancedPeerTsnAck now=" << state->advancedPeerAckPoint << endl;
}

bool inet::sctp::SCTPAssociation::allPathsInactive ( ) const

protected

Referenced by process_TIMEOUT_HEARTBEAT(), process_TIMEOUT_RTX(), and updateCounters().

{
    for (const auto & elem : sctpPathMap) {
        if (elem.second->activePath) {
            return false;
        }
    }
    return true;
}

void inet::sctp::SCTPAssociation::bytesAllowedToSend ( SCTPPathVariables *  path, const bool  firstPass  )

protected

Referenced by sendOnPath().

{
    assert(path != nullptr);

    bytes.chunk = false;
    bytes.packet = false;
    bytes.bytesToSend = 0;

    EV_INFO << "bytesAllowedToSend(" << path->remoteAddress << "):"
            << " osb=" << path->outstandingBytes << " cwnd=" << path->cwnd << endl;

    // ====== First transmission =============================================
    if (!state->firstDataSent) {
        bytes.chunk = true;
    }
    // ====== Transmission allowed by peer's receiver window? ================
    else if ((state->peerWindowFull || (state->peerAllowsChunks && state->peerMsgRwnd <= 0)) && (path->outstandingBytes == 0)) {
        // Zero Window Probing
        EV_DETAIL << "bytesAllowedToSend(" << path->remoteAddress << "): zeroWindowProbing" << endl;
        state->zeroWindowProbing = true;
        bytes.chunk = true;
    }
    // ====== Retransmissions ================================================
    else {
        CounterMap::const_iterator it = qCounter.roomTransQ.find(path->remoteAddress);
        EV_DETAIL << "bytesAllowedToSend(" << path->remoteAddress << "): bytes in transQ=" << it->second << endl;
        if (it->second > 0) {
            const int32 allowance = path->cwnd - path->outstandingBytes;
            EV_DETAIL << "bytesAllowedToSend(" << path->remoteAddress << "): cwnd-osb=" << allowance << endl;
            if (state->peerRwnd < path->pmtu) {
                bytes.bytesToSend = 0;
                bytes.chunk = true;
                EV_DETAIL << "bytesAllowedToSend(" << path->remoteAddress << "): one chunk" << endl;
                // RFC4960: When a Fast Retransmit is being performed, the sender SHOULD ignore the value
                // of cwnd and SHOULD NOT delay retransmission for this single packet.
                return;
            }
            else if (allowance > 0) {
                CounterMap::const_iterator bit = qCounter.bookedTransQ.find(path->remoteAddress);
                if (bit->second > (uint32)allowance) {
                    bytes.bytesToSend = allowance;
                    EV_DETAIL << "bytesAllowedToSend(" << path->remoteAddress << "): cwnd does not allow all RTX" << endl;
                    return;    // More bytes available than allowed -> just return what is allowed.
                }
                else {
                    bytes.bytesToSend = bit->second;
                    EV_DETAIL << "bytesAllowedToSend(" << path->remoteAddress << "): cwnd allows more than those "
                              << bytes.bytesToSend << " bytes for retransmission" << endl;
                }
            }
            else {    // You may retransmit one packet
                bytes.packet = true;
                EV_DETAIL << "bytesAllowedToSend(" << path->remoteAddress << "): allowance<=0: retransmit one packet" << endl;
            }
        }

        // ====== New transmissions ===========================================
        if (!bytes.chunk && !bytes.packet) {
            (this->*ccFunctions.ccUpdateMaxBurst)(path);

            // ====== Get cwnd value to use, according to maxBurstVariant ======
            uint32 myCwnd = path->cwnd;
            if ((state->maxBurstVariant == SCTPStateVariables::MBV_UseItOrLoseItTempCwnd) ||
                (state->maxBurstVariant == SCTPStateVariables::MBV_CongestionWindowLimitingTempCwnd))
            {
                myCwnd = path->tempCwnd;
            }
            // ====== Obtain byte allowance ====================================
            if ((((state->peerAllowsChunks) &&
                  (path->outstandingBytes < myCwnd) &&
                  (!state->peerWindowFull) &&
                  (state->peerMsgRwnd > 0))
                 ||
                 ((!state->peerAllowsChunks) &&
                  (path->outstandingBytes < myCwnd) &&
                  (!state->peerWindowFull)))
                &&
                ((path->blockingTimeout < 0.0) ||    /* Chunk Rescheduling: no new transmission when blocking is active! */
                 (simTime() >= path->blockingTimeout)))
            {
                EV_DETAIL << "bytesAllowedToSend(" << path->remoteAddress << "):"
                          << " bookedSumSendStreams=" << qCounter.bookedSumSendStreams
                          << " bytes.bytesToSend=" << bytes.bytesToSend << endl;
                const int32 allowance = myCwnd - path->outstandingBytes - bytes.bytesToSend;
                if (allowance > 0) {
                    if (qCounter.bookedSumSendStreams > (uint32)allowance) {
                        bytes.bytesToSend = myCwnd - path->outstandingBytes;
                        EV_DETAIL << "bytesAllowedToSend(" << path->remoteAddress << "): bytesToSend are limited by cwnd: "
                                  << bytes.bytesToSend << endl;
                    }
                    else {
                        bytes.bytesToSend += qCounter.bookedSumSendStreams;
                        EV_DETAIL << "bytesAllowedToSend(" << path->remoteAddress << "): send all stored bytes: "
                                  << bytes.bytesToSend << endl;
                    }
                }
                // Do not send more than the peer's arwnd allows
                bytes.bytesToSend = min(bytes.bytesToSend, state->peerRwnd);
            }
        }
    }

    EV_INFO << "bytesAllowedToSend(" << path->remoteAddress << "):"
            << " osb=" << path->outstandingBytes
            << " cwnd=" << path->cwnd
            << " tempCwnd=" << path->tempCwnd
            << " bytes.packet=" << (bytes.packet ? "YES!" : "no")
            << " bytes.chunk=" << (bytes.chunk ? "YES!" : "no")
            << " bytes.bytesToSend=" << bytes.bytesToSend << endl;
}

void inet::sctp::SCTPAssociation::calculateAssocSharedKey ( )

protected

{
    const bool peerFirst = compareRandom();
    if (peerFirst == true) {
        for (uint32 i = 0; i < state->sizeKeyVector; i++)
            state->sharedKey[i] = state->keyVector[i];
        for (uint32 i = 0; i < state->sizePeerKeyVector; i++)
            state->sharedKey[i + state->sizeKeyVector] = state->peerKeyVector[i];
    }
    else {
        for (uint32 i = 0; i < state->sizePeerKeyVector; i++)
            state->sharedKey[i] = state->peerKeyVector[i];
        for (uint32 i = 0; i < state->sizeKeyVector; i++)
            state->sharedKey[i + state->sizePeerKeyVector] = state->keyVector[i];
    }
}

int32 inet::sctp::SCTPAssociation::calculateBytesToSendOnPath ( const SCTPPathVariables *  pathVar )

private

void inet::sctp::SCTPAssociation::calculateRcvBuffer ( )

protected

Referenced by createSack(), makeRoomForTsn(), makeVarFromMsg(), processDataArrived(), and processForwardTsnArrived().

{
    uint32 sumDelivery = 0;
    uint32 sumOrdered = 0;
    uint32 sumUnOrdered = 0;
    for (SCTPReceiveStreamMap::const_iterator iterator = receiveStreams.begin();
         iterator != receiveStreams.end(); iterator++)
    {
        const SCTPReceiveStream *stream = iterator->second;
        sumDelivery += stream->getDeliveryQ()->getQueueSize();
        sumOrdered += stream->getOrderedQ()->getQueueSize();
        sumUnOrdered += stream->getUnorderedQ()->getQueueSize();
    }
    EV_DEBUG << "DeliveryQ= " << sumDelivery
             << ", OrderedQ=" << sumOrdered
             << ", UnorderedQ=" << sumUnOrdered
             << ", bufferedMessages=" << state->bufferedMessages
             << endl;
}

cMessage* inet::sctp::SCTPAssociation::cancelEvent ( cMessage *  msg )

inlineprotected

Utility: cancel a timer.

Referenced by stopTimer().

    {
        return sctpMain->cancelEvent(msg);
    }

void inet::sctp::SCTPAssociation::checkOutstandingBytes ( )

private

void inet::sctp::SCTPAssociation::checkPseudoCumAck ( const SCTPPathVariables *  path )

private

{
    uint32 earliestOutstandingTSN = path->pseudoCumAck;
    uint32 rtxEarliestOutstandingTSN = path->rtxPseudoCumAck;

    retransmissionQ->findEarliestOutstandingTSNsForPath(
            path->remoteAddress,
            earliestOutstandingTSN, rtxEarliestOutstandingTSN);

    if (tsnGt(path->pseudoCumAck, earliestOutstandingTSN) ||
        tsnGt(path->rtxPseudoCumAck, rtxEarliestOutstandingTSN)) {
        std::cerr << "WRONG PSEUDO CUM-ACK!" << endl
                  << "pseudoCumAck=" << path->pseudoCumAck << ", earliestOutstandingTSN=" << earliestOutstandingTSN << endl
                  << "rtxPseudoCumAck=" << path->rtxPseudoCumAck << ", rtxEarliestOutstandingTSN=" << rtxEarliestOutstandingTSN << endl;
    }
}

void inet::sctp::SCTPAssociation::checkStreamsToReset ( )

protected

Referenced by process_RCV_Message().

{
    if (!state->resetPending && qCounter.roomSumSendStreams == 0 && !state->fragInProgress && (state->resetRequested || state->incomingRequest != nullptr) && (state->outstandingBytes == 0 || state->streamsPending.size() > 0)) {
        if (state->localRequestType == RESET_OUTGOING || state->peerRequestType == RESET_INCOMING) {
            state->streamsToReset.clear();
            std::list<uint16>::iterator it;
            for (it = state->streamsPending.begin(); it != state->streamsPending.end(); it++) {
                if (getBytesInFlightOfStream(*it) == 0) {
                    state->streamsToReset.push_back(*it);
                    state->streamsPending.erase(it);
                }
            }
        }
        if (!state->resetPending && state->resetRequested &&
            (state->localRequestType == SSN_TSN ||
             state->localRequestType == ADD_OUTGOING ||
             state->localRequestType == ADD_INCOMING)) {
            sendStreamResetRequest(state->resetInfo);
            state->resetPending = true;
        }
        if (state->resetDeferred && (state->streamsToReset.size() > 0 || state->peerRequestType == SSN_TSN)) {
            switch (state->peerRequestType) {
                case SSN_TSN: {
                    SCTPSSNTSNResetRequestParameter *ssnParam = check_and_cast<SCTPSSNTSNResetRequestParameter *>(state->incomingRequest);
                    processSSNTSNResetRequestArrived(ssnParam);
                    if (state->sendResponse == PERFORMED_WITH_OPTION) {
                        resetExpectedSsns();
                        state->sendResponse = 0;
                        sendStreamResetResponse((SCTPSSNTSNResetRequestParameter *)state->incomingRequest, PERFORMED, true);
                    }
                    delete ssnParam;
                    break;
                }
                case RESET_INCOMING: {
                    SCTPIncomingSSNResetRequestParameter *inParam = check_and_cast<SCTPIncomingSSNResetRequestParameter *>(state->incomingRequest->dup());
                    state->incomingRequest->setName("StateSackIncoming");
                    inParam->setName("checkInParam");
                    processIncomingResetRequestArrived(inParam);
                    if (state->incomingRequestSet && state->incomingRequest != nullptr) {
                        delete state->incomingRequest;
                        state->incomingRequest = nullptr;
                        state->incomingRequestSet = false;
                    }
                    delete inParam;
                    break;
                }
            }
            state->resetDeferred = false;
        } else if ((state->localRequestType == RESET_OUTGOING || state->peerRequestType == RESET_INCOMING) &&
                   (state->streamsToReset.size() > 0)) {
            if (state->peerRequestType == RESET_INCOMING)
                state->localRequestType = RESET_OUTGOING;
            sendStreamResetRequest(state->resetInfo);
            state->resetPending = true;
        }
    }
}

SCTPPathVariables * inet::sctp::SCTPAssociation::choosePathForRetransmission ( )

private

Referenced by sendOnPath().

{
    uint32 max = 0;
    SCTPPathVariables *temp = nullptr;

    for (auto & elem : sctpPathMap) {
        SCTPPathVariables *path = elem.second;
        CounterMap::const_iterator tq = qCounter.roomTransQ.find(path->remoteAddress);
        if ((tq != qCounter.roomTransQ.end()) && (tq->second > max)) {
            max = tq->second;
            temp = path;
        }
    }
    return temp;
}

bool inet::sctp::SCTPAssociation::chunkHasBeenAcked ( const SCTPDataVariables *  chunk ) const

inlineprivate

Referenced by cucProcessGapReports(), dequeueAckedChunks(), getOutboundDataChunk(), handleChunkReportedAsMissing(), nonRenegablyAckChunk(), process_TIMEOUT_RTX(), processPacketDropArrived(), processSackArrived(), and sendOnPath().

    {
        return chunk->hasBeenAcked;
    }

bool inet::sctp::SCTPAssociation::chunkHasBeenAcked ( const uint32  tsn ) const

inlineprivate

    {
        const SCTPDataVariables *chunk = retransmissionQ->getChunk(tsn);
        if (chunk) {
            return chunkHasBeenAcked(chunk);
        }
        return false;
    }

bool inet::sctp::SCTPAssociation::chunkMustBeAbandoned ( SCTPDataVariables *  chunk, SCTPPathVariables *  sackPath  )

protected

Referenced by handleChunkReportedAsMissing(), and process_TIMEOUT_RTX().

{
    switch (chunk->prMethod) {
        case PR_TTL:
            if (chunk->expiryTime > 0 && chunk->expiryTime <= simTime()) {
                if (!chunk->hasBeenAbandoned) {
                    EV_INFO << "TSN " << chunk->tsn << " will be abandoned"
                            << " (expiryTime=" << chunk->expiryTime
                            << " sendTime=" << chunk->sendTime << ")" << endl;
                    chunk->hasBeenAbandoned = true;
                    chunk->sendForwardIfAbandoned = true;
                    sendIndicationToApp(SCTP_I_ABANDONED);
                }
            }
            break;

        case PR_RTX:
            if (chunk->numberOfRetransmissions >= chunk->allowedNoRetransmissions) {
                if (!chunk->hasBeenAbandoned) {
                    EV_INFO << "chunkMustBeAbandoned: TSN " << chunk->tsn << " will be abandoned"
                            << " (maxRetransmissions=" << chunk->allowedNoRetransmissions << ")" << endl;
                    chunk->hasBeenAbandoned = true;
                    chunk->sendForwardIfAbandoned = true;
                    decreaseOutstandingBytes(chunk);
                    chunk->countsAsOutstanding = false;
                    sendIndicationToApp(SCTP_I_ABANDONED);
                }
            }
            break;
    }

    if (chunk->hasBeenAbandoned) {
        return true;
    }
    return false;
}

void inet::sctp::SCTPAssociation::chunkReschedulingControl ( SCTPPathVariables *  path )

private

Referenced by sendOnPath().

{
    EV << simTime() << ": chunkReschedulingControl:"
       << "\tqueueFillLevel=" << (100.0 * (double)state->queuedSentBytes) / (double)state->sendQueueLimit << "%"
       << "\tpeerRwnd=" << state->peerRwnd
       << endl;

    double totalBandwidth = 0.0;
    unsigned int totalOutstandingBytes = 0;
    unsigned int totalQueuedBytes = 0;
    for (auto & elem : sctpPathMap) {
        const SCTPPathVariables *myPath = elem.second;
        totalQueuedBytes += myPath->queuedBytes;
        totalOutstandingBytes += myPath->outstandingBytes;
        totalBandwidth += (double)myPath->cwnd / myPath->srtt.dbl();
    }
    assert(totalOutstandingBytes == state->outstandingBytes);

    const unsigned int queuedBytes = path->queuedBytes;
    const unsigned int outstandingBytes = path->outstandingBytes;

    /* senderLimit is just the size of the send queue! */
    uint32 senderLimit = ((state->sendQueueLimit != 0) ? state->sendQueueLimit : 0xffffffff);
    if ((state->cmtBufferSplitVariant == SCTPStateVariables::CBSV_BothSides) ||
        (state->cmtBufferSplitVariant == SCTPStateVariables::CBSV_SenderOnly) ||
        (state->cmtBufferSplitVariant == SCTPStateVariables::CBSV_ReceiverOnly))
    {
        senderLimit = senderLimit / sctpPathMap.size();
    }

    /* receiverLimit is the peerRwnd + all bytes queued
       (i.e. waiting or being outstanding)! */
    uint32 receiverLimit = state->peerRwnd + totalQueuedBytes;
    if ((state->cmtBufferSplitVariant == SCTPStateVariables::CBSV_BothSides) ||
        (state->cmtBufferSplitVariant == SCTPStateVariables::CBSV_SenderOnly) ||
        (state->cmtBufferSplitVariant == SCTPStateVariables::CBSV_ReceiverOnly))
    {
        receiverLimit = receiverLimit / sctpPathMap.size();
    }

    const double senderBlockingFraction = (queuedBytes - outstandingBytes) / (double)senderLimit;
    const double receiverBlockingFraction = (queuedBytes - outstandingBytes) / (double)receiverLimit;

    EV << " - " << path->remoteAddress
       << "\tt3=" << (path->T3_RtxTimer->isScheduled() ? path->T3_RtxTimer->getArrivalTime().dbl() : -1.0)
       << "\tssthresh=" << path->ssthresh
       << "\tcwnd=" << path->cwnd
       << "\tsrtt=" << path->srtt
       << "\tbw=" << (8.0 * (double)path->cwnd) / (1000000.0 * path->srtt) << " Mbit/s"
       << "\tosb=" << path->outstandingBytes
       << "\tqueued=" << path->queuedBytes
       << "\tslimit=" << senderLimit
       << "\trlimit=" << receiverLimit
       << "\tsblocking=" << 100.0 * senderBlockingFraction << " %"
       << "\trblocking=" << 100.0 * receiverBlockingFraction << " %"
       << endl;

    path->statisticsPathSenderBlockingFraction->record(senderBlockingFraction);
    path->statisticsPathReceiverBlockingFraction->record(receiverBlockingFraction);

    // ====== Chunk Rescheduling =============================================
    if ((state->cmtChunkReschedulingVariant == SCTPStateVariables::CCRV_SenderOnly) ||
        (state->cmtChunkReschedulingVariant == SCTPStateVariables::CCRV_ReceiverOnly) ||
        (state->cmtChunkReschedulingVariant == SCTPStateVariables::CCRV_BothSides))
    {
        if ((((state->cmtChunkReschedulingVariant == SCTPStateVariables::CCRV_SenderOnly) ||
              (state->cmtChunkReschedulingVariant == SCTPStateVariables::CCRV_BothSides)) &&
             (senderBlockingFraction >= state->cmtChunkReschedulingThreshold)) ||
            (((state->cmtChunkReschedulingVariant == SCTPStateVariables::CCRV_ReceiverOnly) ||
              (state->cmtChunkReschedulingVariant == SCTPStateVariables::CCRV_BothSides)) &&
             (receiverBlockingFraction >= state->cmtChunkReschedulingThreshold)))
        {
            if ((!path->fastRecoveryActive) &&    // Only apply when path is not yet in Fast Recovery!
                ((path->blockingTimeout < 0.0) ||    // Do not move chunks to an already-blocked path!
                 (simTime() >= path->blockingTimeout)))
            {
                // ====== Rescheduling of chunk from other path to current path ====
                auto iterator = retransmissionQ->payloadQueue.begin();
                if (iterator != retransmissionQ->payloadQueue.end()) {
                    SCTPDataVariables *chunk = iterator->second;
                    SCTPPathVariables *lastPath = chunk->getLastDestinationPath();

                    if ((chunk->countsAsOutstanding == true) &&    // T.D. 04.08.2011: Chunk must be outstanding, i.e. in the network!
                        (chunk->hasBeenMoved == false) &&    // T.D. 08.07.2011: Check, whether this chunk has already been moved!
                        ((lastPath != path) ||
                         (chunk->sendTime + (2 * path->srtt) < simTime())))
                    {
                        assert(chunk->numberOfTransmissions > 0);    // It has been transmitted as least once
                        assert(chunk->hasBeenAcked == false);    // It has not been acked (since it is outstanding)

                        EV << simTime() << ": RESCHEDULING TSN " << chunk->tsn << " on "
                           << lastPath->remoteAddress << " to "
                           << path->remoteAddress << endl;

                        // ====== Move chunk ======================================
                        lastPath->vectorPathBlockingTSNsMoved->record(chunk->tsn);
                        moveChunkToOtherPath(chunk, path);

                        // This chunk is important, since it is blocking others ...
                        // If SackNow is supported, ensure that it is SACK'ed quickly!
                        chunk->ibit = sctpMain->sackNow;

                        state->blockingTSNsMoved++;
                        chunk->hasBeenMoved = (lastPath != path);

                        // Restart T3 timer on its old path, if it is scheduled
                        if (lastPath->T3_RtxTimer->isScheduled()) {
                            // Stop timer, if path is empty now.
                            // Else, keep it running, without reset!
                            if (lastPath->queuedBytes == 0) {
                                stopTimer(lastPath->T3_RtxTimer);
                            }
                        }

                        // ====== Handle Congestion Control =======================
                        if (state->cmtMovedChunksReduceCwnd == true) {
                            if (lastPath != path) {
                                if ((lastPath->blockingTimeout >= 0.0) &&
                                    (simTime() < lastPath->blockingTimeout))
                                {
                                    // Path is already blocked
                                    EV << simTime() << "\tCR-3 on path "
                                       << lastPath->remoteAddress << " (blocked until "
                                       << lastPath->blockingTimeout << ")" << endl;
                                }
                                else if (lastPath->fastRecoveryActive) {
                                    // A further problem during Fast Recovery -> block path
                                    const simtime_t pause = lastPath->srtt;
                                    lastPath->blockingTimeout = simTime() + pause;
                                    assert(!lastPath->BlockingTimer->isScheduled());
                                    startTimer(lastPath->BlockingTimer, pause);
                                    EV << simTime() << "\tCR-2 on path "
                                       << lastPath->remoteAddress << " (pause="
                                       << pause << "; blocked until "
                                       << lastPath->blockingTimeout << ")" << endl;
                                }
                                else {
                                    // Go into Fast Recovery mode ...
                                    lastPath->requiresRtx = true;
                                    (this->*ccFunctions.ccUpdateBeforeSack)();
                                    (this->*ccFunctions.ccUpdateAfterSack)();
                                    lastPath->requiresRtx = false;
                                    EV << simTime() << "\tCR-1 on path "
                                       << lastPath->remoteAddress << endl;
                                }
                            }
                            else {
                                EV << simTime() << "\tCR-4 on path "
                                   << path->remoteAddress << " (lastTX="
                                   << simTime() - chunk->sendTime
                                   << ", TSN " << chunk->tsn << ")" << endl;

                                lastPath->requiresRtx = true;
                                (this->*ccFunctions.ccUpdateBeforeSack)();
                                (this->*ccFunctions.ccUpdateAfterSack)();
                                lastPath->requiresRtx = false;
                            }
                        }
                    }
                }
            }
        }
    }
    // ====== Test ===========================================================
    else if (state->cmtChunkReschedulingVariant == SCTPStateVariables::CCRV_Test) {
        abort();
    }
}

uint16 inet::sctp::SCTPAssociation::chunkToInt ( const char *  type )

static

Referenced by cloneAssociation(), and initAssociation().

{
    EV_STATICCONTEXT;

    if (strcmp(type, "DATA") == 0)
        return 0;
    if (strcmp(type, "INIT") == 0)
        return 1;
    if (strcmp(type, "INIT_ACK") == 0)
        return 2;
    if (strcmp(type, "SACK") == 0)
        return 3;
    if (strcmp(type, "HEARTBEAT") == 0)
        return 4;
    if (strcmp(type, "HEARTBEAT_ACK") == 0)
        return 5;
    if (strcmp(type, "ABORT") == 0)
        return 6;
    if (strcmp(type, "SHUTDOWN") == 0)
        return 7;
    if (strcmp(type, "SHUTDOWN_ACK") == 0)
        return 8;
    if (strcmp(type, "ERRORTYPE") == 0)
        return 9;
    if (strcmp(type, "COOKIE_ECHO") == 0)
        return 10;
    if (strcmp(type, "COOKIE_ACK") == 0)
        return 11;
    if (strcmp(type, "SHUTDOWN_COMPLETE") == 0)
        return 14;
    if (strcmp(type, "AUTH") == 0)
        return 15;
    if (strcmp(type, "NR-SACK") == 0)
        return 16;
    if (strcmp(type, "ASCONF_ACK") == 0)
        return 128;
    if (strcmp(type, "PKTDROP") == 0)
        return 129;
    if (strcmp(type, "RE_CONFIG") == 0)
        return 130;
    if (strcmp(type, "FORWARD_TSN") == 0)
        return 192;
    if (strcmp(type, "ASCONF") == 0)
        return 193;
    EV_WARN << "ChunkConversion not successful\n";
    return 0xffff;
}

SCTPAssociation * inet::sctp::SCTPAssociation::cloneAssociation ( )

protected

Utility: clone a listening association.

Used for forking.

Referenced by processInitArrived().

{
    SCTPAssociation *assoc = new SCTPAssociation(sctpMain, appGateIndex, assocId, rt, ift);
    const char *queueClass = transmissionQ->getClassName();
    assoc->transmissionQ = check_and_cast<SCTPQueue *>(inet::utils::createOne(queueClass));
    assoc->retransmissionQ = check_and_cast<SCTPQueue *>(inet::utils::createOne(queueClass));

    const char *sctpAlgorithmClass = sctpAlgorithm->getClassName();
    assoc->sctpAlgorithm = check_and_cast<SCTPAlgorithm *>(inet::utils::createOne(sctpAlgorithmClass));
    assoc->sctpAlgorithm->setAssociation(assoc);
    assoc->sctpAlgorithm->initialize();
    assoc->state = assoc->sctpAlgorithm->createStateVariables();

    if ((bool)sctpMain->par("auth")) {
        const char *chunks = sctpMain->par("chunks").stringValue();
        bool asc = false;
        bool asca = false;
        char *chunkscopy = (char *)malloc(strlen(chunks) + 1);
        strcpy(chunkscopy, chunks);
        char *token;
        token = strtok((char *)chunkscopy, ",");
        while (token != nullptr) {
            if (chunkToInt(token) == ASCONF)
                asc = true;
            if (chunkToInt(token) == ASCONF_ACK)
                asca = true;
            if (!typeInOwnChunkList(chunkToInt(token))) {
                this->state->chunkList.push_back(chunkToInt(token));
            }
            token = strtok(nullptr, ",");
        }
        if ((bool)sctpMain->par("addIP")) {
            if (!asc && !typeInOwnChunkList(ASCONF))
                state->chunkList.push_back(ASCONF);
            if (!asca && !typeInOwnChunkList(ASCONF_ACK))
                state->chunkList.push_back(ASCONF_ACK);
        }
        free(chunkscopy);
    }

    assoc->state->active = false;
    assoc->state->fork = true;
    assoc->localAddr = localAddr;
    assoc->localPort = localPort;
    assoc->localAddressList = localAddressList;
    assoc->listening = true;

    assoc->outboundStreams = outboundStreams;
    assoc->inboundStreams = inboundStreams;
    assoc->fd = fd;

    FSM_Goto((*assoc->fsm), SCTP_S_CLOSED);
    sctpMain->printInfoAssocMap();
    return assoc;
}

bool inet::sctp::SCTPAssociation::compareRandom ( )

protected

Referenced by calculateAssocSharedKey().

{
    int32 i, sizeKeyVector, sizePeerKeyVector, size = 0;

    sizeKeyVector = sizeof(state->keyVector);
    sizePeerKeyVector = sizeof(state->peerKeyVector);

    if (sizeKeyVector != sizePeerKeyVector) {
        if (sizePeerKeyVector > sizeKeyVector) {
            size = sizeKeyVector;
            for (i = sizePeerKeyVector - 1; i > sizeKeyVector; i--) {
                if (state->peerKeyVector[i] != 0)
                    return false;
            }
        }
        else {
            size = sizePeerKeyVector;
            for (i = sizeKeyVector - 1; i > sizePeerKeyVector; i--) {
                if (state->keyVector[i] != 0)
                    return true;
            }
        }
    }
    else
        size = sizeKeyVector;
    for (i = size - 1; i > 0; i--) {
        if (state->keyVector[i] < state->peerKeyVector[i])
            return false;
        if (state->keyVector[i] > state->peerKeyVector[i])
            return true;
    }
    return true;
}

SCTPAsconfAckChunk * inet::sctp::SCTPAssociation::createAsconfAckChunk ( const uint32  serialNumber )

protected

Referenced by processAsconfArrived().

{
    SCTPAsconfAckChunk *asconfAckChunk = new SCTPAsconfAckChunk("ASCONF_ACK");
    asconfAckChunk->setChunkType(ASCONF_ACK);
    asconfAckChunk->setSerialNumber(serialNumber);
    asconfAckChunk->setByteLength(SCTP_ADD_IP_CHUNK_LENGTH);
    return asconfAckChunk;
}

SCTPAuthenticationChunk * inet::sctp::SCTPAssociation::createAuthChunk ( )

protected

Referenced by processAsconfArrived(), processPacketDropArrived(), retransmitAsconf(), retransmitCookieEcho(), sendAbort(), sendAsconf(), sendAsconfAck(), sendCookieAck(), sendCookieEcho(), sendHeartbeat(), sendHeartbeatAck(), sendInvalidStreamError(), sendSack(), and sendShutdown().

{
    SCTPAuthenticationChunk *authChunk = new SCTPAuthenticationChunk("AUTH");

    authChunk->setChunkType(AUTH);
    authChunk->setSharedKey(0);
    authChunk->setHMacIdentifier(1);
    authChunk->setHMacOk(true);
    authChunk->setHMACArraySize(SHA_LENGTH);
    for (int32 i = 0; i < SHA_LENGTH; i++) {
        authChunk->setHMAC(i, 0);
    }
    authChunk->setBitLength((SCTP_AUTH_CHUNK_LENGTH + SHA_LENGTH) * 8);
    return authChunk;
}

SCTPForwardTsnChunk * inet::sctp::SCTPAssociation::createForwardTsnChunk ( const L3Address &  pid )

protected

Referenced by processPacketDropArrived(), and sendOnPath().

{
    uint16 chunkLength = SCTP_FORWARD_TSN_CHUNK_LENGTH;
    SCTPDataVariables *chunk;
    typedef std::map<uint16, int16> SidMap;
    SidMap sidMap;

    EV_INFO << "Create forwardTsnChunk for " << pid << "\n";
    SCTPForwardTsnChunk *forwChunk = new SCTPForwardTsnChunk("FORWARD_TSN");
    forwChunk->setChunkType(FORWARD_TSN);
    advancePeerTsn();
    forwChunk->setNewCumTsn(state->advancedPeerAckPoint);
    for (auto & elem : retransmissionQ->payloadQueue) {
        chunk = elem.second;
        EV_DETAIL << "tsn=" << chunk->tsn << " lastDestination=" << chunk->getLastDestination() << " abandoned=" << chunk->hasBeenAbandoned << "\n";
        if (chunk->getLastDestination() == pid && chunk->hasBeenAbandoned && chunk->tsn <= forwChunk->getNewCumTsn()) {
            if (chunk->ordered) {
                sidMap[chunk->sid] = chunk->ssn;
            }
            else {
                sidMap[chunk->sid] = -1;
            }
            /* Fake chunk retransmission */
            if (chunk->sendForwardIfAbandoned) {
                chunk->gapReports = 0;
                chunk->hasBeenFastRetransmitted = false;
                chunk->sendTime = simTime();
                chunk->numberOfRetransmissions++;
                chunk->sendForwardIfAbandoned = false;

                auto itt = transmissionQ->payloadQueue.find(chunk->tsn);
                if (itt != transmissionQ->payloadQueue.end()) {
                    transmissionQ->payloadQueue.erase(itt);
                    chunk->enqueuedInTransmissionQ = false;
                    auto i = qCounter.roomTransQ.find(pid);
                    i->second -= ADD_PADDING(chunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);
                    auto ib = qCounter.bookedTransQ.find(pid);
                    ib->second -= chunk->booksize;
                }
            }
        }
    }
    forwChunk->setSidArraySize(sidMap.size());
    forwChunk->setSsnArraySize(sidMap.size());
    int32 i = 0;
    for (auto & elem : sidMap) {
        forwChunk->setSid(i, elem.first);
        forwChunk->setSsn(i, elem.second);
        chunkLength += 4;
        i++;
    }
    forwChunk->setByteLength(chunkLength);
    auto iter = sctpMain->assocStatMap.find(assocId);
    iter->second.numForwardTsn++;
    return forwChunk;
}

SCTPSackChunk * inet::sctp::SCTPAssociation::createSack ( )

protected

Referenced by sendInvalidStreamError(), sendOnPath(), sendSack(), and sendStreamResetResponse().

{
    EV_INFO << simTime() << "SCTPAssociationUtil:createSACK localAddress=" << localAddr << "  remoteAddress=" << remoteAddr << "\n";

    EV_INFO << " localRwnd=" << state->localRwnd << " queuedBytes=" << state->queuedReceivedBytes << "\n";

    // ====== Get receiver window size to be advertised ======================
    uint32 arwnd = 0;
    uint32 msgRwnd = 0;
    calculateRcvBuffer();
    if ((state->messageAcceptLimit > 0 && (int32)(state->localMsgRwnd - state->bufferedMessages) <= 0)
        || (state->messageAcceptLimit == 0 && (int32)(state->localRwnd - state->queuedReceivedBytes - state->bufferedMessages * state->bytesToAddPerRcvdChunk) <= 0))
    {
        msgRwnd = 0;
    }
    else if ((state->messageAcceptLimit > 0 && (int32)(state->localMsgRwnd - state->bufferedMessages) < 3)
             || (state->messageAcceptLimit == 0 && state->localRwnd - state->queuedReceivedBytes - state->bufferedMessages * state->bytesToAddPerRcvdChunk < state->swsLimit) || state->swsMsgInvoked == true)
    {
        msgRwnd = 1;
        state->swsMsgInvoked = true;
    }
    else {
        if (state->messageAcceptLimit > 0) {
            msgRwnd = state->localMsgRwnd - state->bufferedMessages;
        }
        else {
            msgRwnd = state->localRwnd
                - state->queuedReceivedBytes
                - state->bufferedMessages * state->bytesToAddPerRcvdChunk;
        }
    }
    if (state->tellArwnd) {
        arwnd = msgRwnd;
    }
    else {
        // ====== Receiver buffer is full =====================================
        if ((int32)(state->localRwnd - state->queuedReceivedBytes) <= 0) {
            arwnd = 0;
            if (state->swsLimit > 0) {
                state->swsAvoidanceInvoked = true;
            }
        }
        // ====== Silly window syndrome avoidance =============================
        else if ((state->localRwnd - state->queuedReceivedBytes < state->swsLimit) ||
                 (state->swsAvoidanceInvoked == true))
        {
            arwnd = 1;
            if (state->swsLimit > 0)
                state->swsAvoidanceInvoked = true;
            EV_DETAIL << "arwnd=1; createSack : SWS Avoidance ACTIVE !!!\n";
        }
        // ====== There is space in the receiver buffer =======================
        else {
            arwnd = state->localRwnd - state->queuedReceivedBytes;
            EV_DETAIL << simTime() << " arwnd = " << state->localRwnd << " - " << state->queuedReceivedBytes << " = " << arwnd << "\n";
        }
    }

    // ====== Record statistics ==============================================
    if (state->messageAcceptLimit > 0) {
        advMsgRwnd->record(msgRwnd);
    }
    statisticsQueuedReceivedBytes->record(state->queuedReceivedBytes);
    advRwnd->record(arwnd);

    // ====== Create SACK chunk ==============================================
    SCTPSackChunk *sackChunk = new SCTPSackChunk("SACK");
    if (state->nrSack == true) {
        sackChunk->setChunkType(NR_SACK);
        sackChunk->setName("NR_SACK");
    }
    else {
        sackChunk->setChunkType(SACK);
    }
    sackChunk->setCumTsnAck(state->gapList.getCumAckTSN());
    sackChunk->setA_rwnd(arwnd);
    sackChunk->setIsNrSack(state->nrSack);
    sackChunk->setSackSeqNum(++state->outgoingSackSeqNum);
    if (state->messageAcceptLimit > 0) {
        sackChunk->setMsg_rwnd(state->messageAcceptLimit - state->bufferedMessages);
    }
    else {
        sackChunk->setMsg_rwnd(0);
    }

    // ====== What has to be stored in the SACK? =============================
    const uint32 mtu = getPath(remoteAddr)->pmtu;

    uint32 hdrSize;
    if (remoteAddr.getType() == L3Address::IPv6)
        hdrSize = 40;
    else if (remoteAddr.getType() == L3Address::IPv4)
        hdrSize = 20;
    else
        throw cRuntimeError("Unknown address type");

    const uint32 allowedLength = mtu
        - hdrSize
        - SCTP_COMMON_HEADER
        - SCTP_SACK_CHUNK_LENGTH;
    uint32 numDups = state->dupList.size();
    uint32 numRevokableGaps = state->gapList.getNumGaps(SCTPGapList::GT_Revokable);
    uint32 numNonRevokableGaps = state->gapList.getNumGaps(SCTPGapList::GT_NonRevokable);
    size_t revokableGapsSpace = ~0;
    size_t nonRevokableGapsSpace = ~0;
    size_t sackHeaderLength = ~0;
    const uint32 totalGaps = state->gapList.getNumGaps(SCTPGapList::GT_Any);
    bool compression = false;

    // ====== Record statistics ==============================================
    statisticsNumTotalGapBlocksStored->record(totalGaps);
    statisticsNumRevokableGapBlocksStored->record(numRevokableGaps);
    statisticsNumNonRevokableGapBlocksStored->record(numNonRevokableGaps);
    statisticsNumDuplicatesStored->record(numDups);

    // ====== Optimization ===================================================
    const int optR = (int)numRevokableGaps - (int)totalGaps;
    const int optNR = (int)numNonRevokableGaps - (int)totalGaps;

    if ((state->gapListOptimizationVariant == SCTPStateVariables::GLOV_Shrunken) &&
        ((numRevokableGaps > 0) || (numNonRevokableGaps > 0)))
    {
        compression = true;
    }

    // ------ Optimization 1: R=ANY, NR=non-revokable ------
    if ((state->nrSack == true) &&
        (((optR > 0) && (state->gapListOptimizationVariant == SCTPStateVariables::GLOV_Optimized1)) ||
         ((optR > 0) && (optR >= optNR) && (state->gapListOptimizationVariant >= SCTPStateVariables::GLOV_Optimized2))))
    {
        assert(totalGaps < numRevokableGaps);
        sackHeaderLength = (compression == true) ? SCTP_COMPRESSED_NRSACK_CHUNK_LENGTH : SCTP_NRSACK_CHUNK_LENGTH;
        numRevokableGaps = copyToRGaps(sackChunk, &state->gapList, SCTPGapList::GT_Any, compression, revokableGapsSpace);    // Add ALL
        numNonRevokableGaps = copyToNRGaps(sackChunk, &state->gapList, SCTPGapList::GT_NonRevokable, compression, nonRevokableGapsSpace);    // Add NR-acks only
        assert(numRevokableGaps == totalGaps);
        // opt += optR;
    }
    // ------ Optimization 2: NR=ANY, R=difference ---------
    else if ((state->nrSack == true) &&
             (optNR > 0) && (state->gapListOptimizationVariant >= SCTPStateVariables::GLOV_Optimized2))
    {
        assert(totalGaps < numNonRevokableGaps);
        sackChunk->setNrSubtractRGaps(true);
        sackHeaderLength = (compression == true) ? SCTP_COMPRESSED_NRSACK_CHUNK_LENGTH : SCTP_NRSACK_CHUNK_LENGTH;
        numRevokableGaps = copyToRGaps(sackChunk, &state->gapList, SCTPGapList::GT_Revokable, compression, revokableGapsSpace);    // Add R-acks only
        numNonRevokableGaps = copyToNRGaps(sackChunk, &state->gapList, SCTPGapList::GT_Any, compression, nonRevokableGapsSpace);    // Add ALL
        assert(numNonRevokableGaps == totalGaps);
        // opt += optNR;
    }
    else {
        // ------ Regular NR-SACK ---------------------------
        if (state->nrSack == true) {
            sackHeaderLength = SCTP_NRSACK_CHUNK_LENGTH;
            if (compression == true) {
                sackHeaderLength = SCTP_COMPRESSED_NRSACK_CHUNK_LENGTH;
            }
            numRevokableGaps = copyToRGaps(sackChunk, &state->gapList, SCTPGapList::GT_Revokable, compression, revokableGapsSpace);    // Add R-acks only
            numNonRevokableGaps = copyToNRGaps(sackChunk, &state->gapList, SCTPGapList::GT_NonRevokable, compression, nonRevokableGapsSpace);    // Add NR-acks only
        }
        // ------ Regular SACK ------------------------------
        else {
            sackHeaderLength = SCTP_SACK_CHUNK_LENGTH;
            numRevokableGaps = copyToRGaps(sackChunk, &state->gapList, SCTPGapList::GT_Any, false, revokableGapsSpace);    // Add ALL
            numNonRevokableGaps = 0;
            nonRevokableGapsSpace = 0;
        }
    }

    // ====== SACK has to be shortened to fit in MTU ===========================
    uint32 sackLength = sackHeaderLength + revokableGapsSpace + nonRevokableGapsSpace + numDups * 4;
    if (sackLength > allowedLength) {
        // Strategy to reduce the SACK size:
        // - Report no duplicates (they are not used for congestion control)
        // - Split the remaining space equally between
        //   revokable and non-revokable GapAcks

        // ====== Drop duplicates list ========================================
        numDups = 0;
        sackLength -= 4 * numDups;

        if (sackLength > allowedLength) {
            // Unfortunately, dropping the duplicates has not solved the problem.
            //    => Now, the gap lists have to be shortened!

            auto iter = sctpMain->assocStatMap.find(assocId);
            iter->second.numOverfullSACKs++;
            // ====== Undo NR optimization ====================================
            if (sackChunk->getNrSubtractRGaps() == true) {
                sackChunk->setNrSubtractRGaps(false);    // Unset SubtractRGaps!
                // This optimization cannot work when lists have to be shortened.
                // Just use regular NR list.
            }
            revokableGapsSpace = allowedLength - sackHeaderLength;
            if (totalGaps < (state->gapList.getNumGaps(SCTPGapList::GT_Revokable))) {
                numRevokableGaps = copyToRGaps(sackChunk, &state->gapList, SCTPGapList::GT_Any, compression, revokableGapsSpace);    // Add ALL
            }
            else {
                numRevokableGaps = copyToRGaps(sackChunk, &state->gapList, SCTPGapList::GT_Revokable, compression, revokableGapsSpace);    // Add R-acks only
            }
            sackLength = sackHeaderLength + revokableGapsSpace + nonRevokableGapsSpace + numDups * 4;

            // ====== Shorten gap lists ========================================
            if (state->smartOverfullSACKHandling) {
                if (sackHeaderLength + revokableGapsSpace < allowedLength) {
                    // Fill NR-acks up to allowed size
                    nonRevokableGapsSpace = allowedLength - sackHeaderLength - revokableGapsSpace;
                    numNonRevokableGaps = copyToNRGaps(sackChunk, &state->gapList, SCTPGapList::GT_NonRevokable, compression, nonRevokableGapsSpace);    // Add NR-acks only
                    sackLength = sackHeaderLength + revokableGapsSpace + nonRevokableGapsSpace + numDups * 4;
                }
                else {
                    // Not even space to set R-acks => cut R-acks, no NR-acks!
                    nonRevokableGapsSpace = allowedLength - sackHeaderLength;
                    numRevokableGaps = copyToRGaps(sackChunk, &state->gapList, SCTPGapList::GT_Any, compression, revokableGapsSpace);    // Add ALL
                }
            }
            else {
                if (sackLength > allowedLength) {
                    double revokableFraction = 1.0;
                    const uint32 blocksBeRemoved = (sackLength - allowedLength) / 4;
                    if (numRevokableGaps + numNonRevokableGaps > 0) {
                        revokableFraction = numRevokableGaps / (double)(numRevokableGaps + numNonRevokableGaps);
                    }
                    const uint32 removeRevokable = (uint32)ceil(blocksBeRemoved * revokableFraction);
                    const uint32 removeNonRevokable = (uint32)ceil(blocksBeRemoved * (1.0 - revokableFraction));
                    numRevokableGaps -= std::min(removeRevokable, numRevokableGaps);
                    numNonRevokableGaps -= std::min(removeNonRevokable, numNonRevokableGaps);
                    revokableGapsSpace = 4 * numRevokableGaps;
                    nonRevokableGapsSpace = 4 * numNonRevokableGaps;
                    numRevokableGaps = copyToRGaps(sackChunk, &state->gapList, SCTPGapList::GT_Revokable, compression, revokableGapsSpace);    // Add R-acks only
                    numNonRevokableGaps = copyToNRGaps(sackChunk, &state->gapList, SCTPGapList::GT_NonRevokable, compression, nonRevokableGapsSpace);    // Add NR-acks only
                    sackLength = sackHeaderLength + revokableGapsSpace + nonRevokableGapsSpace + numDups * 4;
                }
            }

            assert(sackLength <= allowedLength);

            // Update values in SACK chunk ...
            sackChunk->setNumGaps(numRevokableGaps);
            sackChunk->setNumNrGaps(numNonRevokableGaps);
        }
    }
    sackChunk->setNumDupTsns(numDups);
    sackChunk->setByteLength(sackLength);

    // ====== Apply limit ====================================================
    if (state->gapReportLimit < 1000000) {
        if (!compression) {
            numRevokableGaps = std::min(numRevokableGaps, state->gapReportLimit);
            numNonRevokableGaps = std::min(numNonRevokableGaps, state->gapReportLimit);
            // Update values in SACK chunk ...
            sackChunk->setNumGaps(numRevokableGaps);
            sackChunk->setNumNrGaps(numNonRevokableGaps);
            sackLength = sackHeaderLength + revokableGapsSpace + nonRevokableGapsSpace + numDups * 4;
        } else {
            assert(false);    // NOTE: IMPLEMENT ME!
        }
    }

    // ====== Add duplicates =================================================
    if (numDups > 0) {
        sackChunk->setDupTsnsArraySize(numDups);
        uint32 key = 0;
        for (auto & elem : state->dupList) {
            sackChunk->setDupTsns(key, elem);
            key++;
            if (key == numDups)
                break;
        }
        state->dupList.clear();
    }

    // ====== Record statistics ==============================================
    statisticsSACKLengthSent->record(sackLength);
    statisticsNumRevokableGapBlocksSent->record(numRevokableGaps);
    statisticsNumNonRevokableGapBlocksSent->record(numNonRevokableGaps);
    statisticsNumDuplicatesSent->record(numDups);

    // ====== Print information ==============================================
    EV_DEBUG << "createSack:"
             << " bufferedMessages=" << state->bufferedMessages
             << " msgRwnd=" << msgRwnd
             << " arwnd=" << sackChunk->getA_rwnd()
             << " cumAck=" << state->gapList.getCumAckTSN()
             << " numRGaps=" << numRevokableGaps
             << " numNRGaps=" << numNonRevokableGaps
             << " numDups=" << numDups
             << " gapList={" << state->gapList << "}"
             << endl;
    return sackChunk;
}

SCTPSuccessIndication * inet::sctp::SCTPAssociation::createSuccessIndication ( uint32  correlationId )

protected

Referenced by processAsconfArrived().

{
    SCTPSuccessIndication *success = new SCTPSuccessIndication("Success");

    success->setParameterType(SUCCESS_INDICATION);
    success->setResponseCorrelationId(correlationId);
    success->setBitLength(SCTP_ADD_IP_PARAMETER_LENGTH * 8);
    return success;
}

void inet::sctp::SCTPAssociation::cucProcessGapReports ( const SCTPDataVariables *  chunk, SCTPPathVariables *  path, const bool  isAcked  )

inlineprotected

Referenced by processSackArrived().

{
    // We only care for newly acked chunks.
    // Therefore, the previous state must be "unacked".
    if (chunkHasBeenAcked(chunk) == false) {
        // For CUCv2, it has to be checked whether it is the first transmission.
        // Otherwise, the behaviour will be like CUCv1 -> decreasing PseudoCumAck on T3 RTX!
        if ((path->findPseudoCumAck == true) &&
            ((chunk->numberOfRetransmissions == 0) ||
             (state->cmtCUCVariant == SCTPStateVariables::CUCV_PseudoCumAck)))
        {
            path->pseudoCumAck = chunk->tsn;
            path->findPseudoCumAck = false;
        }
        if ((isAcked) &&    /* Not acked before and acked now => ack for the first time */
            (path->pseudoCumAck == chunk->tsn))
        {
            path->newPseudoCumAck = true;
            path->findPseudoCumAck = true;
        }

        // CUCv2
        if ((path->findRTXPseudoCumAck == true) &&
            (chunk->numberOfRetransmissions > 0))
        {
            path->rtxPseudoCumAck = chunk->tsn;
            path->findRTXPseudoCumAck = false;
        }
        if ((isAcked) &&    /* Not acked before and acked now => ack for the first time */
            (path->rtxPseudoCumAck == chunk->tsn))
        {
            path->newRTXPseudoCumAck = true;
            path->findRTXPseudoCumAck = true;
        }
    }
}

void inet::sctp::SCTPAssociation::cwndUpdateAfterCwndTimeout ( SCTPPathVariables *  path )

protected

Referenced by stateEntered().

{
    // When the association does not transmit data on a given transport address
    // within an RTO, the cwnd of the transport address SHOULD be adjusted to 2*MTU.
    EV_INFO << assocId << ": " << simTime() << ":\tCC [cwndUpdateAfterCwndTimeout]\t" << path->remoteAddress
            << " (cmtCCGroup=" << path->cmtCCGroup << ")"
            << "\tsst=" << path->ssthresh
            << "\tcwnd=" << path->cwnd;
    path->cwnd = getInitialCwnd(path);
    EV_INFO << "\t=>\tsst=" << path->ssthresh
            << "\tcwnd=" << path->cwnd << endl;
    recordCwndUpdate(path);
}

void inet::sctp::SCTPAssociation::cwndUpdateAfterRtxTimeout ( SCTPPathVariables *  path )

protected

Referenced by stateEntered().

{
    double decreaseFactor = 0.5;
    path->oliaSentBytes = 0;
    EV << assocId << ": " << simTime() << ":\tCC [cwndUpdateAfterRtxTimeout]\t" << path->remoteAddress
       << " (cmtCCGroup=" << path->cmtCCGroup << ")"
       << "\tsst=" << path->ssthresh
       << "\tcwnd=" << path->cwnd
       << "\tSST=" << path->cmtGroupTotalSsthresh
       << "\tCWND=" << path->cmtGroupTotalCwnd
       << "\tBW.CWND=" << path->cmtGroupTotalCwndBandwidth;
    if (state->highSpeedCC == true) {
        decreaseFactor = HighSpeedCwndAdjustmentTable[path->highSpeedCCThresholdIdx].decreaseFactor;
        EV << "\tHighSpeedDecreaseFactor=" << decreaseFactor;
    }

    // ====== SCTP or CMT-SCTP (independent congestion control) ==============
    if ((state->allowCMT == false) || (state->cmtCCVariant == SCTPStateVariables::CCCV_CMT)) {
        path->ssthresh = max((int32)path->cwnd - (int32)rint(decreaseFactor * (double)path->cwnd),
                    4 * (int32)path->pmtu);
        path->cwnd = path->pmtu;
    }
    // ====== Resource Pooling RTX Timeout ===================================
    else {
        // ====== CMT/RPv1-SCTP RTX Timeout ===================================
        if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRPv1) {
            const double sstRatio = (double)path->ssthresh / (double)path->cmtGroupTotalSsthresh;
            const int32 decreasedWindow = (int32)path->cwnd - (int32)rint(path->cmtGroupTotalCwnd * decreaseFactor);
            path->ssthresh = max(decreasedWindow,
                        max((int32)path->pmtu,
                                (int32)ceil((double)state->rpMinCwnd * (double)path->pmtu * sstRatio)));
            path->cwnd = max((int32)path->pmtu,
                        (int32)ceil((double)path->pmtu * sstRatio));
        }
        // ====== CMT/RPv2-SCTP RTX Timeout ===================================
        else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRPv2) {
            const double pathBandwidth = path->cwnd / GET_SRTT(path->srtt.dbl());
            const double bandwidthToGive = path->cmtGroupTotalCwndBandwidth / 2.0;
            const double reductionFactor = max(0.5, bandwidthToGive / pathBandwidth);

            path->ssthresh = (int32)max((int32)state->rpMinCwnd * (int32)path->pmtu,
                        (int32)ceil(path->cwnd - reductionFactor * path->cwnd));
            path->cwnd = path->pmtu;
        }
        // ====== Like MPTCP RTX Timeout ======================================
        else if(state->cmtCCVariant == SCTPStateVariables::CCCV_CMT_LIA) {
            path->ssthresh = max((int32)path->cwnd - (int32)rint(decreaseFactor * (double)path->cwnd),
                        (int32)state->rpMinCwnd * (int32)path->pmtu);
            path->cwnd = path->pmtu;
        }
        else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMT_OLIA) {
            // like draft
            path->ssthresh = max((int32) path->cwnd - (int32) rint(decreaseFactor * (double) path->cwnd),
                    4 * (int32) path->pmtu);
            path->cwnd = path->pmtu;
        }
        // ====== TEST RTX Timeout ============================================
        else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRP_Test1) {
            const double pathBandwidth = path->cwnd / GET_SRTT(path->srtt.dbl());
            const double bandwidthToGive = path->cmtGroupTotalCwndBandwidth / 2.0;
            const double reductionFactor = max(0.5, bandwidthToGive / pathBandwidth);

            path->ssthresh = (int32)max((int32)state->rpMinCwnd * (int32)path->pmtu,
                        (int32)ceil(path->cwnd - reductionFactor * path->cwnd));
            path->cwnd = path->pmtu;
        }
        // ====== Like MPTCP RTX Timeout ======================================
        else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRP_Test2) {
            path->ssthresh = max((int32)path->cwnd - (int32)rint(decreaseFactor * (double)path->cwnd),
                        (int32)state->rpMinCwnd * (int32)path->pmtu);
            path->cwnd = path->pmtu;
        }
        // ====== Other -> error ==============================================
        else {
            throw cRuntimeError("Implementation for this cmtCCVariant is missing!");
        }
    }
    path->highSpeedCCThresholdIdx = 0;
    path->partialBytesAcked = 0;
    path->vectorPathPbAcked->record(path->partialBytesAcked);
    EV_INFO << "\t=>\tsst=" << path->ssthresh
            << "\tcwnd=" << path->cwnd << endl;
    recordCwndUpdate(path);

    // Leave Fast Recovery mode
    if (path->fastRecoveryActive == true) {
        path->fastRecoveryActive = false;
        path->fastRecoveryExitPoint = 0;
        path->vectorPathFastRecoveryState->record(0);
    }
}

void inet::sctp::SCTPAssociation::cwndUpdateAfterSack ( )

protected

Referenced by stateEntered().

{
    for (auto iter = sctpPathMap.begin(); iter != sctpPathMap.end(); iter++) {
        SCTPPathVariables *path = iter->second;
        if (path->fastRecoveryActive == false) {
            // ====== Retransmission required -> reduce congestion window ======
            if (path->requiresRtx) {
                double decreaseFactor = 0.5;
                EV << assocId << ": " << simTime() << ":\tCC [cwndUpdateAfterSack]\t" << path->remoteAddress
                   << " (cmtCCGroup=" << path->cmtCCGroup << ")"
                   << "\tsst=" << path->ssthresh
                   << "\tcwnd=" << path->cwnd
                   << "\tSST=" << path->cmtGroupTotalSsthresh
                   << "\tCWND=" << path->cmtGroupTotalCwnd
                   << "\tBW.CWND=" << path->cmtGroupTotalCwndBandwidth;
                if (state->highSpeedCC == true) {
                    decreaseFactor = HighSpeedCwndAdjustmentTable[path->highSpeedCCThresholdIdx].decreaseFactor;
                    EV << "\tHighSpeedDecreaseFactor=" << decreaseFactor;
                }

                // ====== SCTP or CMT-SCTP (independent congestion control) =====
                if ((state->allowCMT == false) ||
                    (state->cmtCCVariant == SCTPStateVariables::CCCV_CMT))
                {
                    EV_INFO << simTime() << ":\tCC [cwndUpdateAfterSack]\t" << path->remoteAddress
                            << "\tsst=" << path->ssthresh << " cwnd=" << path->cwnd;

                    path->ssthresh = max((int32)path->cwnd - (int32)rint(decreaseFactor * (double)path->cwnd),
                                4 * (int32)path->pmtu);
                    path->cwnd = path->ssthresh;
                }
                // ====== Resource Pooling ======================================
                else {
                    // ====== CMT/RP-SCTPv1 Fast Retransmit ======================
                    if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRPv1) {
                        const double sstRatio = (double)path->ssthresh / (double)path->cmtGroupTotalSsthresh;
                        const int32 reducedCwnd = rpPathBlockingControl(path, rint(path->cmtGroupTotalCwnd * decreaseFactor));
                        path->ssthresh = max(reducedCwnd,
                                    max((int32)path->pmtu,
                                            (int32)ceil((double)state->rpMinCwnd * (double)path->pmtu * sstRatio)));
                        path->cwnd = path->ssthresh;
                    }
                    // ====== CMT/RPv2-SCTP Fast Retransmit ======================
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRPv2) {
                        // Bandwidth is based on cwnd, *not* ssthresh!
                        const double pathBandwidth = path->cwnd / GET_SRTT(path->srtt.dbl());
                        const double bandwidthToGive = path->cmtGroupTotalCwndBandwidth / 2.0;
                        const double reductionFactor = max(0.5, bandwidthToGive / pathBandwidth);
                        const int32 reducedCwnd = rpPathBlockingControl(path, reductionFactor * path->cwnd);
                        path->ssthresh = (int32)max(reducedCwnd, (int32)state->rpMinCwnd * (int32)path->pmtu);
                        path->cwnd = path->ssthresh;
                    }
                    // ====== Like MPTCP Fast Retransmit =========================
                    else if(state->cmtCCVariant == SCTPStateVariables::CCCV_CMT_LIA) {
                        // Just like plain CMT-SCTP ...
                        const int32 reducedCwnd = rpPathBlockingControl(path, rint(decreaseFactor * (double)path->cwnd));
                        path->ssthresh = max(reducedCwnd, (int32)state->rpMinCwnd * (int32)path->pmtu);
                        path->cwnd = path->ssthresh;
                    }
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMT_OLIA) {
                        // like draft
                        path->ssthresh = max((int32) path->cwnd-(int32) rint(decreaseFactor * (double) path->cwnd),
                                4 * (int32) path->pmtu);
                        path->cwnd = path->ssthresh;
                    }
                    // ====== TEST Fast Retransmit ===============================
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRP_Test1) {
                        // Bandwidth is based on cwnd, *not* ssthresh!
                        const double pathBandwidth = path->cwnd / GET_SRTT(path->srtt.dbl());
                        const double bandwidthToGive = path->cmtGroupTotalCwndBandwidth / 2.0;
                        const double reductionFactor = max(0.5, bandwidthToGive / pathBandwidth);
                        const int32 reducedCwnd = rpPathBlockingControl(path, reductionFactor * path->cwnd);
                        path->ssthresh = (int32)max(reducedCwnd, (int32)state->rpMinCwnd * (int32)path->pmtu);
                        path->cwnd = path->ssthresh;
                    }
                    // ====== TEST Fast Retransmit ===============================
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRP_Test2) {
                        // Just like CMT-SCTP ...
                        const int32 reducedCwnd = rpPathBlockingControl(path, rint(decreaseFactor * (double)path->cwnd));
                        path->ssthresh = max(reducedCwnd, (int32)state->rpMinCwnd * (int32)path->pmtu);
                        path->cwnd = path->ssthresh;
                    }
                    // ====== Other -> error =====================================
                    else {
                        throw cRuntimeError("Implementation for this cmtCCVariant is missing!");
                    }
                }

                EV_INFO << "\t=>\tsst=" << path->ssthresh << " cwnd=" << path->cwnd << endl;
                recordCwndUpdate(path);
                path->partialBytesAcked = 0;
                path->vectorPathPbAcked->record(path->partialBytesAcked);
                if (state->highSpeedCC == true) {
                    updateHighSpeedCCThresholdIdx(path);
                }

                // ====== Fast Recovery ========================================
                if (state->fastRecoverySupported) {
                    uint32 highestAckOnPath = state->lastTsnAck;
                    uint32 highestOutstanding = state->lastTsnAck;
                    for (SCTPQueue::PayloadQueue::const_iterator chunkIterator = retransmissionQ->payloadQueue.begin();
                         chunkIterator != retransmissionQ->payloadQueue.end(); chunkIterator++)
                    {
                        const SCTPDataVariables *chunk = chunkIterator->second;
                        if (chunk->getLastDestinationPath() == path) {
                            if (chunkHasBeenAcked(chunk)) {
                                if (tsnGt(chunk->tsn, highestAckOnPath)) {
                                    highestAckOnPath = chunk->tsn;
                                }
                            }
                            else {
                                if (tsnGt(chunk->tsn, highestOutstanding)) {
                                    highestOutstanding = chunk->tsn;
                                }
                            }
                        }
                    }
                    path->oliaSentBytes = 0;
                    /* this can ONLY become TRUE, when Fast Recovery IS supported */
                    path->fastRecoveryActive = true;
                    path->fastRecoveryExitPoint = highestOutstanding;
                    path->fastRecoveryEnteringTime = simTime();
                    path->vectorPathFastRecoveryState->record(path->cwnd);

                    EV_INFO << simTime() << ":\tCC [cwndUpdateAfterSack] Entering Fast Recovery on path "
                            << path->remoteAddress
                            << ", exit point is " << path->fastRecoveryExitPoint
                            << ", pseudoCumAck=" << path->pseudoCumAck
                            << ", rtxPseudoCumAck=" << path->rtxPseudoCumAck << endl;
                }
            }
        }
        else {
            for (auto & elem : sctpPathMap) {
                SCTPPathVariables *path = elem.second;
                if (path->fastRecoveryActive) {
                    EV_INFO << assocId << ": " << simTime() << ":\tCC [cwndUpdateAfterSack] Still in Fast Recovery on path "
                            << path->remoteAddress
                            << ", exit point is " << path->fastRecoveryExitPoint << endl;
                }
            }
        }
    }
}

void inet::sctp::SCTPAssociation::cwndUpdateBeforeSack ( )

protected

Referenced by stateEntered().

{
    // First, calculate per-path values.
    for (auto & elem : sctpPathMap)
    {
        SCTPPathVariables *otherPath = elem.second;
        otherPath->utilizedCwnd = otherPath->outstandingBytesBeforeUpdate;
    }

    // Calculate per-path-group values.
    for (auto currentPathIterator = sctpPathMap.begin();
         currentPathIterator != sctpPathMap.end(); currentPathIterator++)
    {
        SCTPPathVariables *currentPath = currentPathIterator->second;

        currentPath->cmtGroupPaths = 0;
        currentPath->cmtGroupTotalCwnd = 0;
        currentPath->cmtGroupTotalSsthresh = 0;
        currentPath->cmtGroupTotalUtilizedCwnd = 0;
        currentPath->cmtGroupTotalCwndBandwidth = 0.0;
        currentPath->cmtGroupTotalUtilizedCwndBandwidth = 0.0;

        double qNumerator = 0.0;
        double qDenominator = 0.0;
        for (SCTPPathMap::const_iterator otherPathIterator = sctpPathMap.begin();
             otherPathIterator != sctpPathMap.end(); otherPathIterator++)
        {
            const SCTPPathVariables *otherPath = otherPathIterator->second;
            if (otherPath->cmtCCGroup == currentPath->cmtCCGroup) {
                currentPath->cmtGroupPaths++;

                currentPath->cmtGroupTotalCwnd += otherPath->cwnd;
                currentPath->cmtGroupTotalSsthresh += otherPath->ssthresh;
                currentPath->cmtGroupTotalCwndBandwidth += otherPath->cwnd / GET_SRTT(otherPath->srtt.dbl());

                if ((otherPath->blockingTimeout < 0.0) || (otherPath->blockingTimeout < simTime())) {
                    currentPath->cmtGroupTotalUtilizedCwnd += otherPath->utilizedCwnd;
                    currentPath->cmtGroupTotalUtilizedCwndBandwidth += otherPath->utilizedCwnd / GET_SRTT(otherPath->srtt.dbl());
                }

                qNumerator = max(qNumerator, otherPath->cwnd / (pow(GET_SRTT(otherPath->srtt.dbl()), 2.0)));
                qDenominator = qDenominator + (otherPath->cwnd / GET_SRTT(otherPath->srtt.dbl()));
            }
        }
        currentPath->cmtGroupAlpha = currentPath->cmtGroupTotalCwnd * (qNumerator / pow(qDenominator, 2.0));
    }
}

void inet::sctp::SCTPAssociation::cwndUpdateBytesAcked ( SCTPPathVariables *  path, const uint32  ackedBytes, const bool  ctsnaAdvanced  )

protected

Referenced by stateEntered().

{
    EV_INFO << simTime() << "====> cwndUpdateBytesAcked:"
            << " path=" << path->remoteAddress
            << " ackedBytes=" << ackedBytes
            << " ctsnaAdvanced=" << ((ctsnaAdvanced == true) ? "yes" : "no")
            << " cwnd=" << path->cwnd
            << " ssthresh=" << path->ssthresh
            << " ackedBytes=" << ackedBytes
            << " pathOsbBeforeUpdate=" << path->outstandingBytesBeforeUpdate
            << " pathOsb=" << path->outstandingBytes
            << endl;

    if (path->fastRecoveryActive == false) {
        // T.D. 21.11.09: Increasing cwnd is only allowed when not being in
        //                Fast Recovery mode!

        // ====== Slow Start ==================================================
        if (path->cwnd <= path->ssthresh) {
            // ------ Clear PartialBytesAcked counter --------------------------
            path->partialBytesAcked = 0;

            // ------ Increase Congestion Window -------------------------------
            if ((ctsnaAdvanced == true) &&
                ((path->outstandingBytesBeforeUpdate >= path->cwnd) ||
                 ((state->strictCwndBooking) && (path->outstandingBytesBeforeUpdate + path->pmtu > path->cwnd))))
            {
                EV_INFO << assocId << ": " << simTime() << ":\tCC [cwndUpdateBytesAcked-SlowStart]\t" << path->remoteAddress
                        << " (cmtCCGroup=" << path->cmtCCGroup << ")"
                        << "\tacked=" << ackedBytes
                        << "\tsst=" << path->ssthresh
                        << "\tcwnd=" << path->cwnd
                        << "\tSST=" << path->cmtGroupTotalSsthresh
                        << "\tCWND=" << path->cmtGroupTotalCwnd
                        << "\tBW.CWND=" << path->cmtGroupTotalCwndBandwidth;

                // ====== SCTP or CMT-SCTP (independent congestion control) =====
                if ((state->allowCMT == false) || (state->cmtCCVariant == SCTPStateVariables::CCCV_CMT)) {
                    path->cwnd += (int32)min(path->pmtu, ackedBytes);
                }
                // ====== Resource Pooling Slow Start ===========================
                else {
                    // ====== CMT/RPv1-SCTP Slow Start ===========================
                    if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRPv1) {
                        const double sstRatio = (double)path->ssthresh / (double)path->cmtGroupTotalSsthresh;
                        path->cwnd += (int32)ceil(min(path->pmtu, ackedBytes) * sstRatio);
                    }
                    // ====== CMT/RPv2-SCTP Slow Start ===========================
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRPv2) {
                        // Increase ratio based on cwnd bandwidth share!
                        const double increaseRatio = ((double)path->cwnd / GET_SRTT(path->srtt.dbl()))
                            / (double)path->cmtGroupTotalCwndBandwidth;
                        path->cwnd += (int32)ceil(min(path->pmtu, ackedBytes) * increaseRatio);
                    }
                    // ====== Like MPTCP Slow Start ==============================
                    else if(state->cmtCCVariant == SCTPStateVariables::CCCV_CMT_LIA) {
                        // T.D. 14.08.2011: Rewrote MPTCP-Like CC code
                        path->cwnd = updateMPTCP(path->cwnd, path->cmtGroupTotalCwnd,
                                                 path->cmtGroupAlpha, path->pmtu, ackedBytes);
                    }
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMT_OLIA) {
                        // OLIA see draft
                        path->cwnd = updateOLIA(path->cwnd, path->ssthresh,
                                path->cmtGroupTotalCwnd, path->cmtGroupAlpha,
                                path->pmtu, ackedBytes, path);
                    }
                    // ====== TEST Slow Start ====================================
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRP_Test1) {
                        // Increase ratio based on cwnd bandwidth share!
                        const double increaseRatio = ((double)path->utilizedCwnd / GET_SRTT(path->srtt.dbl()))
                            / (double)path->cmtGroupTotalUtilizedCwndBandwidth;
                        path->cwnd += (int32)ceil(min(path->pmtu, ackedBytes) * increaseRatio);
                    }
                    // ====== Like MPTCP Slow Start ==============================
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRP_Test2) {
                        path->cwnd = updateMPTCP(path->cwnd, path->cmtGroupTotalCwnd,
                                    path->cmtGroupAlpha, path->pmtu, ackedBytes);
                    }
                    // ====== Other -> error =====================================
                    else {
                        throw cRuntimeError("Implementation for this cmtCCVariant is missing!");
                    }
                }
                path->vectorPathPbAcked->record(path->partialBytesAcked);
                EV << "\t=>\tsst=" << path->ssthresh
                   << "\tcwnd=" << path->cwnd << endl;

                recordCwndUpdate(path);
            }
            // ------ No need to increase Congestion Window --------------------
            else {
                EV_INFO << assocId << ": " << simTime() << ":\tCC "
                        << "Not increasing cwnd of path " << path->remoteAddress << " in slow start:\t"
                        << "ctsnaAdvanced=" << ((ctsnaAdvanced == true) ? "yes" : "no") << "\t"
                        << "cwnd=" << path->cwnd << "\t"
                        << "ssthresh=" << path->ssthresh << "\t"
                        << "ackedBytes=" << ackedBytes << "\t"
                        << "pathOsbBeforeUpdate=" << path->outstandingBytesBeforeUpdate << "\t"
                        << "pathOsb=" << path->outstandingBytes << "\t"
                        << "(pathOsbBeforeUpdate >= path->cwnd)="
                        << (path->outstandingBytesBeforeUpdate >= path->cwnd) << endl;
            }
        }
        // ====== Congestion Avoidance ========================================
        else {
            // ------ Increase PartialBytesAcked counter -----------------------
            path->partialBytesAcked += ackedBytes;

            // ------ Increase Congestion Window -------------------------------
            double increaseFactor = 1.0;
            if (state->highSpeedCC == true) {
                updateHighSpeedCCThresholdIdx(path);
                increaseFactor = HighSpeedCwndAdjustmentTable[path->highSpeedCCThresholdIdx].increaseFactor;
                EV << "HighSpeedCC Increase: factor=" << increaseFactor << endl;
            }

            const bool avancedAndEnoughOutstanding =
                (ctsnaAdvanced == true) &&
                ((path->outstandingBytesBeforeUpdate >= path->cwnd) ||
                 ((state->strictCwndBooking) &&
                  (path->outstandingBytesBeforeUpdate + path->pmtu > path->cwnd)));
            const bool enoughPartiallyAcked =
                (path->partialBytesAcked >= path->cwnd) ||
                ((state->strictCwndBooking) &&
                 (path->partialBytesAcked >= path->pmtu) &&
                 (path->partialBytesAcked + path->pmtu > path->cwnd));

            if (avancedAndEnoughOutstanding && enoughPartiallyAcked) {
                EV << assocId << ": " << simTime() << ":\tCC [cwndUpdateBytesAcked-CgAvoidance]\t" << path->remoteAddress
                   << " (cmtCCGroup=" << path->cmtCCGroup << ")"
                   << "\tacked=" << ackedBytes
                   << "\tsst=" << path->ssthresh
                   << "\tcwnd=" << path->cwnd
                   << "\tSST=" << path->cmtGroupTotalSsthresh
                   << "\tCWND=" << path->cmtGroupTotalCwnd
                   << "\tBW.CWND=" << path->cmtGroupTotalCwndBandwidth;

                // ====== SCTP or CMT-SCTP (independent congestion control) =====
                if ((state->allowCMT == false) || (state->cmtCCVariant == SCTPStateVariables::CCCV_CMT)) {
                    path->cwnd += (int32)rint(increaseFactor * path->pmtu);
                }
                // ====== Resource Pooling Congestion Avoidance =================
                else {
                    // ====== CMT/RP-SCTP Congestion Avoidance ===================
                    if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRPv1) {
                        const double sstRatio = (double)path->ssthresh / (double)path->cmtGroupTotalSsthresh;
                        path->cwnd += (int32)ceil(increaseFactor * path->pmtu * sstRatio);
                    }
                    // ====== CMT/RPv2-SCTP Congestion Avoidance =================
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRPv2) {
                        // Increase ratio based on cwnd bandwidth share!
                        const double increaseRatio = ((double)path->cwnd / GET_SRTT(path->srtt.dbl()))
                            / (double)path->cmtGroupTotalCwndBandwidth;
                        path->cwnd += (int32)ceil(increaseFactor * path->pmtu * increaseRatio);
                    }
                    // ====== Like MPTCP Congestion Avoidance ====================
                    else if(state->cmtCCVariant == SCTPStateVariables::CCCV_CMT_LIA) {
                        // T.D. 14.08.2011: Rewrote MPTCP-Like CC code
                        path->cwnd = updateMPTCP(path->cwnd, path->cmtGroupTotalCwnd,
                                    path->cmtGroupAlpha, path->pmtu, path->pmtu);
                    }
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMT_OLIA) {
                        // like draft
                        path->cwnd = updateOLIA(path->cwnd, path->ssthresh,
                                path->cmtGroupTotalCwnd, path->cmtGroupAlpha,
                                path->pmtu, path->pmtu, path);
                    }
                    // ====== TEST Congestion Avoidance ==========================
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRP_Test1) {
                        // Increase ratio based on cwnd bandwidth share!
                        const double increaseRatio = ((double)path->utilizedCwnd / GET_SRTT(path->srtt.dbl()))
                            / (double)path->cmtGroupTotalUtilizedCwndBandwidth;
                        path->cwnd += (int32)ceil(increaseFactor * path->pmtu * increaseRatio);
                    }
                    // ====== TEST Congestion Avoidance ==========================
                    else if (state->cmtCCVariant == SCTPStateVariables::CCCV_CMTRP_Test2) {
                        path->cwnd = updateMPTCP(path->cwnd, path->cmtGroupTotalCwnd,
                                    path->cmtGroupAlpha, path->pmtu, path->pmtu);
                    }
                    // ====== Other -> error =====================================
                    else {
                        throw cRuntimeError("Implementation for this cmtCCVariant is missing!");
                    }
                }
                EV << "\t=>\tsst=" << path->ssthresh
                   << "\tcwnd=" << path->cwnd << endl;

                recordCwndUpdate(path);
                path->partialBytesAcked =
                    ((path->cwnd < path->partialBytesAcked) ?
                     (path->partialBytesAcked - path->cwnd) : 0);
            }
            // ------ No need to increase Congestion Window -------------------
            else {
                EV_INFO << assocId << ": " << simTime() << ":\tCC "
                        << "Not increasing cwnd of path " << path->remoteAddress << " in congestion avoidance: "
                        << "ctsnaAdvanced=" << ((ctsnaAdvanced == true) ? "yes" : "no") << "\t"
                        << "cwnd=" << path->cwnd << "\t"
                        << "ssthresh=" << path->ssthresh << "\t"
                        << "ackedBytes=" << ackedBytes << "\t"
                        << "pathOsbBeforeUpdate=" << path->outstandingBytesBeforeUpdate << "\t"
                        << "pathOsb=" << path->outstandingBytes << "\t"
                        << "(pathOsbBeforeUpdate >= path->cwnd)="
                        << (path->outstandingBytesBeforeUpdate >= path->cwnd) << "\t"
                        << "partialBytesAcked=" << path->partialBytesAcked << "\t"
                        << "(path->partialBytesAcked >= path->cwnd)="
                        << (path->partialBytesAcked >= path->cwnd) << endl;
            }
        }

        // ====== Reset PartialBytesAcked counter if no more outstanding bytes
        if (path->outstandingBytes == 0) {
            path->partialBytesAcked = 0;
        }
        path->vectorPathPbAcked->record(path->partialBytesAcked);
    }
    else {
        EV_INFO << assocId << ": " << simTime() << ":\tCC "
                << "Not increasing cwnd of path " << path->remoteAddress
                << " during Fast Recovery" << endl;
    }
}

void inet::sctp::SCTPAssociation::cwndUpdateMaxBurst ( SCTPPathVariables *  path )

protected

Referenced by stateEntered().

{
    if ((state->maxBurstVariant == SCTPStateVariables::MBV_UseItOrLoseIt) ||
        (state->maxBurstVariant == SCTPStateVariables::MBV_CongestionWindowLimiting) ||
        (state->maxBurstVariant == SCTPStateVariables::MBV_UseItOrLoseItTempCwnd) ||
        (state->maxBurstVariant == SCTPStateVariables::MBV_CongestionWindowLimitingTempCwnd))
    {
        if (path->cwnd > ((path->outstandingBytes + state->maxBurst * path->pmtu))) {
            EV_INFO << assocId << ": " << simTime() << ":\tCC [cwndUpdateMaxBurst]\t"
                    << path->remoteAddress
                    << "\tsst=" << path->ssthresh
                    << "\tcwnd=" << path->cwnd
                    << "\ttempCwnd=" << path->tempCwnd
                    << "\tosb=" << path->outstandingBytes
                    << "\tmaxBurst=" << state->maxBurst * path->pmtu;

            // ====== Update cwnd or tempCwnd, according to MaxBurst variant ===
            if ((state->maxBurstVariant == SCTPStateVariables::MBV_UseItOrLoseIt) ||
                (state->maxBurstVariant == SCTPStateVariables::MBV_CongestionWindowLimiting))
            {
                path->cwnd = path->outstandingBytes + (state->maxBurst * path->pmtu);
            }
            else if ((state->maxBurstVariant == SCTPStateVariables::MBV_UseItOrLoseItTempCwnd) ||
                     (state->maxBurstVariant == SCTPStateVariables::MBV_CongestionWindowLimitingTempCwnd))
            {
                path->tempCwnd = path->outstandingBytes + (state->maxBurst * path->pmtu);
            }
            else {
                assert(false);
            }

            if (state->maxBurstVariant == SCTPStateVariables::MBV_CongestionWindowLimiting) {
                if (path->ssthresh < path->cwnd) {
                    path->ssthresh = path->cwnd;
                }
            }
            if (state->maxBurstVariant == SCTPStateVariables::MBV_CongestionWindowLimitingTempCwnd) {
                if (path->ssthresh < path->tempCwnd) {
                    path->ssthresh = path->tempCwnd;
                }
            }
            recordCwndUpdate(path);

            EV_INFO << "\t=>\tsst=" << path->ssthresh
                    << "\tcwnd=" << path->cwnd
                    << "\ttempCwnd=" << path->tempCwnd
                    << endl;
        }
        // ====== Possible transmission will not exceed burst size ============
        else {
            // Just store current cwnd to tempCwnd
            path->tempCwnd = path->cwnd;
        }
    }
}

void inet::sctp::SCTPAssociation::decreaseOutstandingBytes ( SCTPDataVariables *  chunk )

private

Referenced by chunkMustBeAbandoned(), handleChunkReportedAsMissing(), moveChunkToOtherPath(), nonRenegablyAckChunk(), putInTransmissionQ(), renegablyAckChunk(), storePacket(), and tsnWasReneged().

{
    SCTPPathVariables *lastPath = chunk->getLastDestinationPath();

    if (chunk->countsAsOutstanding) {
        assert(lastPath->outstandingBytes >= chunk->booksize);
        lastPath->outstandingBytes -= chunk->booksize;
        lastPath->statisticsPathOutstandingBytes->record(lastPath->outstandingBytes);
        state->outstandingBytes -= chunk->booksize;
        SCTPSendStream *stream = nullptr;
        auto associter = sendStreams.find(chunk->sid);
        if (associter != sendStreams.end()) {
            stream = associter->second;
        } else {
            throw cRuntimeError("Stream with id %d not found", chunk->sid);
        }
        stream->setBytesInFlight(stream->getBytesInFlight() - chunk->booksize);
        assert((int64)state->outstandingBytes >= 0);
        statisticsOutstandingBytes->record(state->outstandingBytes);

        chunk->countsAsOutstanding = false;

        auto iterator = qCounter.roomRetransQ.find(lastPath->remoteAddress);
        state->outstandingMessages--;
        if (state->osbWithHeader)
            iterator->second -= ADD_PADDING(chunk->booksize);
        else
            iterator->second -= ADD_PADDING(chunk->booksize + SCTP_DATA_CHUNK_LENGTH);
    }
}

void inet::sctp::SCTPAssociation::deleteStreams

(

)

Referenced by inet::sctp::SCTP::removeAssociation().

{
    for (auto & elem : sendStreams) {
        delete elem.second;
    }
    for (auto & elem : receiveStreams) {
        delete elem.second;
    }
}

void inet::sctp::SCTPAssociation::dequeueAckedChunks ( const uint32  tsna, SCTPPathVariables *  path, simtime_t &  rttEstimation  )

protected

Referenced by process_RCV_Message(), and processSackArrived().

{
    SCTP::AssocStat *assocStat = sctpMain->getAssocStat(assocId);

    // Set it ridiculously high
    rttEstimation = SIMTIME_MAX;

    // Are there chunks in the retransmission queue ? If Yes -> check for dequeue.
    auto iterator = retransmissionQ->payloadQueue.begin();
    while (iterator != retransmissionQ->payloadQueue.end()) {
        SCTPDataVariables *chunk = iterator->second;
        if (tsnGe(tsna, chunk->tsn)) {
            EV_DETAIL << simTime() << ": CumAcked TSN " << chunk->tsn
                      << " on path " << chunk->getLastDestination() << endl;

            if (!chunkHasBeenAcked(chunk)) {
                SCTPPathVariables *lastPath = chunk->getLastDestinationPath();
                // CumAck affects lastPath -> reset its T3 timer later.
                lastPath->newCumAck = true;
                // CumAck of SACK has acknowledged this chunk. Handle Pseudo CumAck.
                lastPath->findPseudoCumAck = true;
                lastPath->newPseudoCumAck = true;
                // T.D. 22.11.09: CUCv2
                lastPath->findRTXPseudoCumAck = true;
                lastPath->newRTXPseudoCumAck = true;
            }

            nonRenegablyAckChunk(chunk, sackPath, rttEstimation, assocStat);
        }
        else {
            break;
        }
        iterator = retransmissionQ->payloadQueue.begin();
    }

    EV_DEBUG << "dequeueAckedChunks(): rttEstimation=" << rttEstimation << endl;
}

SCTPDataMsg * inet::sctp::SCTPAssociation::dequeueOutboundDataMsg ( SCTPPathVariables *  path, const int32  availableSpace, const int32  availableCwnd  )

protected

Referenced by sendOnPath().

{
    SCTPDataMsg *datMsg = nullptr;
    cPacketQueue *streamQ = nullptr;
    int32 nextStream = -1;

    EV_INFO << "dequeueOutboundDataMsg: " << availableSpace << " bytes left to be sent" << endl;

    fragmentOutboundDataMsgs();

    /* Only change stream if we don't have to finish a fragmented message */
    if (state->lastMsgWasFragment)
        nextStream = state->lastStreamScheduled;
    else
        nextStream = (this->*ssFunctions.ssGetNextSid)(path, false);

    if (nextStream == -1)
        return nullptr;

    EV_INFO << "dequeueOutboundDataMsg: now stream " << nextStream << endl;

    SCTPSendStream *stream = sendStreams.find(nextStream)->second;
    streamQ = nullptr;

    if (!stream->getUnorderedStreamQ()->isEmpty()) {
        streamQ = stream->getUnorderedStreamQ();
        EV_DETAIL << "DequeueOutboundDataMsg() found chunks in stream " << nextStream << " unordered queue, queue size=" << stream->getUnorderedStreamQ()->getLength() << "\n";
    }
    else if (!stream->getStreamQ()->isEmpty()) {
        streamQ = stream->getStreamQ();
        EV_DETAIL << "DequeueOutboundDataMsg() found chunks in stream " << nextStream << " ordered queue, queue size=" << stream->getStreamQ()->getLength() << "\n";
    }

    if (streamQ) {
        int32 b = ADD_PADDING(((SCTPDataMsg *)streamQ->front())->getEncapsulatedPacket()->getByteLength() + SCTP_DATA_CHUNK_LENGTH);

        if ((b <= availableSpace) &&
            ((int32)((SCTPDataMsg *)streamQ->front())->getBooksize() <= availableCwnd))
        {
            datMsg = (SCTPDataMsg *)streamQ->pop();
            sendQueue->record(streamQ->getLength());

            if (!datMsg->getFragment()) {
                datMsg->setBBit(true);
                datMsg->setEBit(true);
                state->lastMsgWasFragment = false;
            }
            else {
                if (datMsg->getEBit())
                    state->lastMsgWasFragment = false;
                else
                    state->lastMsgWasFragment = true;
            }

            EV_DETAIL << "DequeueOutboundDataMsg() found chunk (" << &datMsg << ") in the stream queue " << nextStream << "(" << streamQ << ") queue size=" << streamQ->getLength() << endl;
        }
    }


    if (datMsg != nullptr) {
        qCounter.roomSumSendStreams -= ADD_PADDING(datMsg->getEncapsulatedPacket()->getByteLength() + SCTP_DATA_CHUNK_LENGTH);
        qCounter.bookedSumSendStreams -= datMsg->getBooksize();
    }
    return datMsg;
}

void inet::sctp::SCTPAssociation::disposeOf ( SCTPMessage *  sctpmsg )

protected

Referenced by process_RCV_Message(), processPacketDropArrived(), and sendPacketDrop().

{
    SCTPChunk *chunk;
    uint32 numberOfChunks = sctpmsg->getChunksArraySize();
    if (numberOfChunks > 0)
        for (uint32 i = 0; i < numberOfChunks; i++) {
            chunk = (SCTPChunk *)(sctpmsg->removeChunk());
            if (chunk->getChunkType() == DATA)
                delete (SCTPSimpleMessage *)chunk->decapsulate();
            delete chunk;
        }
    delete sctpmsg;
}

const char * inet::sctp::SCTPAssociation::eventName ( const int32  event )

staticprotected

Utility: returns name of SCTP_E_xxx constants.

{
#define CASE(x)    case x: \
        s = #x + 7; break
    const char *s = "unknown";
    switch (event) {
        CASE(SCTP_E_OPEN_PASSIVE);
        CASE(SCTP_E_ASSOCIATE);
        CASE(SCTP_E_SHUTDOWN);
        CASE(SCTP_E_CLOSE);
        CASE(SCTP_E_ABORT);
        CASE(SCTP_E_SEND);
        CASE(SCTP_E_RCV_INIT);
        CASE(SCTP_E_RCV_ABORT);
        CASE(SCTP_E_RCV_VALID_COOKIE_ECHO);
        CASE(SCTP_E_RCV_INIT_ACK);
        CASE(SCTP_E_RCV_COOKIE_ACK);
        CASE(SCTP_E_RCV_SHUTDOWN);
        CASE(SCTP_E_RCV_SHUTDOWN_ACK);
        CASE(SCTP_E_RCV_SHUTDOWN_COMPLETE);
        CASE(SCTP_E_TIMEOUT_INIT_TIMER);
        CASE(SCTP_E_TIMEOUT_SHUTDOWN_TIMER);
        CASE(SCTP_E_TIMEOUT_RTX_TIMER);
        CASE(SCTP_E_TIMEOUT_HEARTBEAT_TIMER);
        CASE(SCTP_E_RECEIVE);
        CASE(SCTP_E_DUP_RECEIVED);
        CASE(SCTP_E_PRIMARY);
        CASE(SCTP_E_QUEUE_MSGS_LIMIT);
        CASE(SCTP_E_QUEUE_BYTES_LIMIT);
        CASE(SCTP_E_NO_MORE_OUTSTANDING);
        CASE(SCTP_E_IGNORE);
        CASE(SCTP_E_DELIVERED);
        CASE(SCTP_E_SEND_SHUTDOWN_ACK);
        CASE(SCTP_E_STOP_SENDING);
        CASE(SCTP_E_STREAM_RESET);
        CASE(SCTP_E_RESET_ASSOC);
        CASE(SCTP_E_ADD_STREAMS);
        CASE(SCTP_E_SEND_ASCONF);
        CASE(SCTP_E_SET_STREAM_PRIO);
        CASE(SCTP_E_ACCEPT);
    }
    return s;
#undef CASE
}

void inet::sctp::SCTPAssociation::fragmentOutboundDataMsgs ( )

protected

Referenced by dequeueOutboundDataMsg().

                                               {
    cPacketQueue *streamQ = nullptr;
    for (auto iter = sendStreams.begin(); iter != sendStreams.end(); ++iter) {
        SCTPSendStream *stream = iter->second;
        streamQ = nullptr;

        if (!stream->getUnorderedStreamQ()->isEmpty()) {
            streamQ = stream->getUnorderedStreamQ();
            EV_DETAIL << "fragmentOutboundDataMsgs() found chunks in stream " << iter->first << " unordered queue, queue size=" << stream->getUnorderedStreamQ()->getLength() << "\n";
        }
        else if (!stream->getStreamQ()->isEmpty()) {
            streamQ = stream->getStreamQ();
            EV_DETAIL << "fragmentOutboundDataMsgs() found chunks in stream " << iter->first << " ordered queue, queue size=" << stream->getStreamQ()->getLength() << "\n";
        }

        if (streamQ) {
            int32 b = ADD_PADDING(((SCTPDataMsg *)streamQ->front())->getEncapsulatedPacket()->getByteLength() + SCTP_DATA_CHUNK_LENGTH);

            /* check if chunk found in queue has to be fragmented */
            if (b > (int32)state->fragPoint + (int32)SCTP_DATA_CHUNK_LENGTH) {
                /* START FRAGMENTATION */
                SCTPDataMsg *datMsgQueued = (SCTPDataMsg *)streamQ->pop();
                cPacket *datMsgQueuedEncMsg = datMsgQueued->getEncapsulatedPacket();
                SCTPDataMsg *datMsgLastFragment = nullptr;
                uint32 offset = 0;
                uint32 msgbytes = state->fragPoint;
                const uint16 fullSizedPackets = (uint16)(datMsgQueued->getByteLength() / msgbytes);
                EV_DETAIL << "Fragmentation: chunk " << &datMsgQueued << " - size = " << datMsgQueued->getByteLength() << endl;
                EV_DETAIL << assocId << ": number of fullSizedPackets: " << fullSizedPackets << endl;
                uint16 pcounter = 0;

                while (datMsgQueued) {
                    /* detemine size of fragment, either max payload or what's left */
                    if (msgbytes > datMsgQueuedEncMsg->getByteLength() - offset)
                        msgbytes = datMsgQueuedEncMsg->getByteLength() - offset;

                    /* new DATA msg */
                    SCTPDataMsg *datMsgFragment = new SCTPDataMsg();
                    datMsgFragment->setSid(datMsgQueued->getSid());
                    datMsgFragment->setPpid(datMsgQueued->getPpid());
                    if (++pcounter == fullSizedPackets && sctpMain->sackNow)
                        datMsgFragment->setSackNow(true);
                    else
                        datMsgFragment->setSackNow(datMsgQueued->getSackNow());
                    datMsgFragment->setInitialDestination(datMsgQueued->getInitialDestination());
                    datMsgFragment->setEnqueuingTime(datMsgQueued->getEnqueuingTime());
                    datMsgFragment->setPrMethod(datMsgQueued->getPrMethod());
                    datMsgFragment->setPriority(datMsgQueued->getPriority());
                    //EV_DETAIL << "felix: " << datMsgQueued->getPriority() << endl;
                    datMsgFragment->setStrReset(datMsgQueued->getStrReset());
                    datMsgFragment->setMsgNum(datMsgQueued->getMsgNum());
                    datMsgFragment->setOrdered(datMsgQueued->getOrdered());
                    datMsgFragment->setExpiryTime(datMsgQueued->getExpiryTime());
                    datMsgFragment->setRtx(datMsgQueued->getRtx());
                    datMsgFragment->setFragment(true);

                    if (state->padding)
                        datMsgFragment->setBooksize(ADD_PADDING(msgbytes + state->header));
                    else
                        datMsgFragment->setBooksize(msgbytes + state->header);

                    /* is this the first fragment? */
                    if (offset == 0)
                        datMsgFragment->setBBit(true);

                    /* new msg */
                    cPacket *datMsgFragmentEncMsg = datMsgQueuedEncMsg->dup();

                    datMsgFragmentEncMsg->setByteLength(msgbytes);

                    SCTPSimpleMessage *datMsgQueuedSimple = dynamic_cast<SCTPSimpleMessage *>(datMsgQueuedEncMsg);
                    SCTPSimpleMessage *datMsgFragmentSimple = dynamic_cast<SCTPSimpleMessage *>(datMsgFragmentEncMsg);
                    if ((datMsgQueuedSimple != nullptr) &&
                        (datMsgFragmentSimple != nullptr) &&
                        (datMsgQueuedSimple->getDataArraySize() >= msgbytes + offset))
                    {
                        datMsgFragmentSimple->setDataArraySize(msgbytes);
                        datMsgFragmentSimple->setDataLen(msgbytes);
                        /* copy data */
                        for (uint32 i = offset; i < offset + msgbytes; i++) {
                            datMsgFragmentSimple->setData(i - offset, datMsgQueuedSimple->getData(i));
                        }
                    }

                    offset += msgbytes;
                    datMsgFragment->encapsulate(datMsgFragmentEncMsg);

                    /* insert fragment into queue */
                    if (!streamQ->isEmpty()) {
                        if (!datMsgLastFragment) {
                            /* insert first fragment at the begining of the queue*/
                            streamQ->insertBefore((SCTPDataMsg *)streamQ->front(), datMsgFragment);
                        }
                        else {
                            /* insert fragment after last inserted   */
                            streamQ->insertAfter(datMsgLastFragment, datMsgFragment);
                        }
                    }
                    else
                        streamQ->insert(datMsgFragment);

                    state->queuedMessages++;
                    qCounter.roomSumSendStreams += ADD_PADDING(datMsgFragment->getByteLength() + SCTP_DATA_CHUNK_LENGTH);
                    qCounter.bookedSumSendStreams += datMsgFragment->getBooksize();
                    EV_DETAIL << "Fragmentation: fragment " << &datMsgFragment << " created, length = " << datMsgFragmentEncMsg->getByteLength() << ", queue size = " << streamQ->getLength() << endl;

                    datMsgLastFragment = datMsgFragment;

                    /* all fragments done? */
                    if (datMsgQueuedEncMsg->getByteLength() == offset) {
                        datMsgFragment->setEBit(true);
                        if (sctpMain->sackNow)
                            datMsgFragment->setSackNow(true);
                        /* remove original element */
                        EV_DETAIL << "Fragmentation: delete " << &datMsgQueued << endl;
                        //streamQ->pop();
                        qCounter.roomSumSendStreams -= ADD_PADDING(datMsgQueued->getByteLength() + SCTP_DATA_CHUNK_LENGTH);
                        qCounter.bookedSumSendStreams -= datMsgQueued->getBooksize();
                        delete datMsgQueued;
                        datMsgQueued = nullptr;
                        state->queuedMessages--;
                    }
                } // while
            }
        }
    }

}

void inet::sctp::SCTPAssociation::generateSendQueueAbatedIndication ( const uint64  bytes )

private

Referenced by processSackArrived().

{
    if (state->sendBuffer < state->sendQueueLimit) {
        // Just send SCTP_I_SENDQUEUE_ABATED once, after all newly acked
        // chunks have been dequeued.
        // Only send indication if the sendBuffer size has dropped below the sendQueueLimit
        // assert(state->lastSendQueueAbated < simTime());
        state->appSendAllowed = true;
        EV_DETAIL << simTime() << ":\tSCTP_I_SENDQUEUE_ABATED("
                  << bytes << ") to refill buffer "
                  << state->sendBuffer << "/" << state->sendQueueLimit << endl;

        cPacket *msg = new cPacket(indicationName(SCTP_I_SENDQUEUE_ABATED));
        msg->setKind(SCTP_I_SENDQUEUE_ABATED);

        SCTPSendQueueAbated *sendQueueAbatedIndication =
            new SCTPSendQueueAbated(indicationName(SCTP_I_SENDQUEUE_ABATED));
        sendQueueAbatedIndication->setAssocId(assocId);
        sendQueueAbatedIndication->setLocalAddr(localAddr);
        sendQueueAbatedIndication->setRemoteAddr(remoteAddr);
        sendQueueAbatedIndication->setNumMsgs(bytes);    // NOTE: Legacy API!

        sendQueueAbatedIndication->setQueuedForStreamArraySize(sendStreams.size());
        unsigned int streamID = 0;
        for (auto & elem : sendStreams)
        {
            const SCTPSendStream *stream = elem.second;
            sendQueueAbatedIndication->setQueuedForStream(streamID, stream->getUnorderedStreamQ()->getByteLength() + stream->getStreamQ()->getByteLength());
            streamID++;
        }

        sendQueueAbatedIndication->setBytesAvailable(state->sendQueueLimit - state->sendBuffer);
        sendQueueAbatedIndication->setBytesQueued(state->sendBuffer);
        sendQueueAbatedIndication->setBytesLimit(state->sendQueueLimit);

        msg->setControlInfo(sendQueueAbatedIndication);
        sctpMain->send(msg, "to_appl", appGateIndex);

        state->lastSendQueueAbated = simTime();
    }
}

int inet::sctp::SCTPAssociation::getAddressLevel ( const L3Address &  addr )

static

Utility: return IPv4 or IPv6 address level.

Referenced by inet::sctp::SCTPNatHook::datagramForwardHook(), inet::sctp::SCTPNatHook::datagramPreRoutingHook(), processInitArrived(), sendAsconf(), and sendInit().

{
    if (addr.getType() == L3Address::IPv6) {
        switch (addr.toIPv6().getScope()) {
            case IPv6Address::UNSPECIFIED:
            case IPv6Address::MULTICAST:
                return 0;

            case IPv6Address::LOOPBACK:
                return 1;

            case IPv6Address::LINK:
                return 2;

            case IPv6Address::SITE:
                return 3;

            case IPv6Address::GLOBAL:
                return 4;

            default:
                throw cRuntimeError("Unknown IPv6 scope: %d", (int)(addr.toIPv6().getScope()));
        }
    }
    else if (addr.getType() == L3Address::IPv4) {
        switch (addr.toIPv4().getAddressCategory()) {
            case IPv4Address::UNSPECIFIED:
            case IPv4Address::THIS_NETWORK:
            case IPv4Address::MULTICAST:
            case IPv4Address::BROADCAST:
            case IPv4Address::BENCHMARK:
            case IPv4Address::IPv6_TO_IPv4_RELAY:
            case IPv4Address::IETF:
            case IPv4Address::TEST_NET:
            case IPv4Address::RESERVED:
                return 0;

            case IPv4Address::LOOPBACK:
                return 1;

            case IPv4Address::LINKLOCAL:
                return 2;

            case IPv4Address::PRIVATE_NETWORK:
                return 3;

            case IPv4Address::GLOBAL:
                return 4;

            default:
                throw cRuntimeError("Unknown IPv4 address category: %d", (int)(addr.toIPv4().getAddressCategory()));
        }
    }
    throw cRuntimeError("Unknown address type: %d", (int)(addr.getType()));
}

uint32 inet::sctp::SCTPAssociation::getAllTransQ ( )

protected

Referenced by sendOnPath().

{
    uint32 sum = 0;
    for (auto & elem : qCounter.roomTransQ) {
        sum += elem.second;
    }
    return sum;
}

uint32 inet::sctp::SCTPAssociation::getBytesInFlightOfStream ( uint16  sid )

protected

Referenced by checkStreamsToReset(), process_STREAM_RESET(), and processIncomingResetRequestArrived().

{
    auto streamIterator = sendStreams.find(sid);
    assert(streamIterator != sendStreams.end());
    return (streamIterator->second)->getBytesInFlight();
}

uint32 inet::sctp::SCTPAssociation::getExpectedSsnOfStream ( uint16  id )

protected

Referenced by processOutgoingResetRequestArrived().

{
    uint16 str;
    auto iterator = receiveStreams.find(id);
    str = iterator->second->getExpectedStreamSeqNum();
    return str;
}

bool inet::sctp::SCTPAssociation::getFragInProgressOfStream ( uint16  sid )

protected

Referenced by process_STREAM_RESET(), and processIncomingResetRequestArrived().

{
    auto streamIterator = sendStreams.find(sid);
    assert(streamIterator != sendStreams.end());
    return (streamIterator->second)->getFragInProgress();
}

cFSM* inet::sctp::SCTPAssociation::getFsm ( ) const

inline

{ return fsm; };

int32 inet::sctp::SCTPAssociation::getFsmState ( ) const

inline

{ return fsm->getState(); };

uint32 inet::sctp::SCTPAssociation::getInitialCwnd ( const SCTPPathVariables *  path ) const

private

{
    uint32 newCwnd;

    const uint32 upperLimit = (state->initialWindow > 0) ? (state->initialWindow * path->pmtu) : max(2 * path->pmtu, 4380);
    if ((state->allowCMT == false) || (state->cmtCCVariant == SCTPStateVariables::CCCV_CMT)) {
        newCwnd = (int32)min((state->initialWindow > 0) ? (state->initialWindow * path->pmtu) : (4 * path->pmtu),
                    upperLimit);
    }
    else {
        newCwnd = (int32)min((int32)ceil(((state->initialWindow > 0) ?
                                          (state->initialWindow * path->pmtu) :
                                          (4 * path->pmtu)) / (double)sctpPathMap.size()),
                    upperLimit);
        if (newCwnd < path->pmtu) {    // T.D. 09.09.2010: cwnd < MTU makes no sense ...
            newCwnd = path->pmtu;
        }
    }    return newCwnd;
}

cMessage* inet::sctp::SCTPAssociation::getInitTimer ( ) const

inline

{ return T1_InitTimer; };

const L3Address& inet::sctp::SCTPAssociation::getNextAddress ( const SCTPPathVariables *  oldPath ) const

inlineprotected

Referenced by sendAsconf().

    {
        const SCTPPathVariables *nextPath = getNextPath(oldPath);
        if (nextPath != nullptr) {
            return nextPath->remoteAddress;
        }
        return SCTPDataVariables::zeroAddress;
    }

SCTPPathVariables * inet::sctp::SCTPAssociation::getNextDestination ( SCTPDataVariables *  chunk ) const

protected

Referenced by handleChunkReportedAsMissing(), and process_TIMEOUT_RTX().

{
    SCTPPathVariables *next;

    EV_DEBUG << "Running getNextDestination()" << endl;
    if (chunk->numberOfTransmissions == 0) {
        if (chunk->getInitialDestinationPath() == nullptr) {
            next = state->getPrimaryPath();
        }
        else {
            next = chunk->getInitialDestinationPath();
        }
    }
    else {
        if (chunk->hasBeenFastRetransmitted) {
            EV_DETAIL << "Chunk " << chunk->tsn << " is scheduled for FastRetransmission. Next destination = "
                      << chunk->getLastDestination() << endl;
            return chunk->getLastDestinationPath();
        }
        // If this is a retransmission, we should choose another, active path.
        SCTPPathVariables *last = chunk->getLastDestinationPath();
        next = getNextPath(last);
        if ((next == nullptr) || (next->confirmed == false)) {
            next = last;
        }
    }

    EV_INFO << "getNextDestination(): chunk was last sent to " << chunk->getLastDestination()
            << ", will next be sent to path " << next->remoteAddress << endl;
    return next;
}

SCTPPathVariables * inet::sctp::SCTPAssociation::getNextPath ( const SCTPPathVariables *  oldPath ) const

protected

Referenced by getNextDestination(), process_TIMEOUT_HEARTBEAT(), process_TIMEOUT_RTX(), and updateCounters().

{
    int32 hit = 0;
    if (sctpPathMap.size() > 1) {
        for (const auto & elem : sctpPathMap) {
            SCTPPathVariables *newPath = elem.second;
            if (newPath == oldPath) {
                if (++hit == 1) {
                    continue;
                }
                else {
                    break;
                }
            }
            if ((newPath->activePath) &&
                ((state->allowCMT == false) || (newPath->blockingTimeout <= 0.0) ||
                 (simTime() > newPath->blockingTimeout))) {
                return newPath;
            }
        }
    }
    return nullptr;
}

SCTPDataVariables * inet::sctp::SCTPAssociation::getOutboundDataChunk ( const SCTPPathVariables *  path, const int32  availableSpace, const int32  availableCwnd  )

protected

Referenced by sendOnPath().

{
    /* are there chunks in the transmission queue ? If Yes -> dequeue and return it */
    EV_INFO << "getOutboundDataChunk(" << path->remoteAddress << "):"
            << " availableSpace=" << availableSpace
            << " availableCwnd=" << availableCwnd
            << endl;
    if (!transmissionQ->payloadQueue.empty()) {
        for (auto it = transmissionQ->payloadQueue.begin();
             it != transmissionQ->payloadQueue.end(); it++)
        {
            SCTPDataVariables *chunk = it->second;
            if ((chunkHasBeenAcked(chunk) == false) && !chunk->hasBeenAbandoned &&
                (chunk->getNextDestinationPath() == path))
            {
                const int32 len = ADD_PADDING(chunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);
                EV_DETAIL << "getOutboundDataChunk() found chunk " << chunk->tsn
                          << " in the transmission queue, length=" << len << endl;
                if ((len <= availableSpace) &&
                    ((int32)chunk->booksize <= availableCwnd))
                {
                    // T.D. 05.01.2010: The bookkeeping counters may only be decreased when
                    //                        this chunk is actually dequeued. Therefore, the check
                    //                        for "chunkHasBeenAcked==false" has been moved into the
                    //                        "if" statement above!
                    transmissionQ->payloadQueue.erase(it);
                    chunk->enqueuedInTransmissionQ = false;
                    auto i = qCounter.roomTransQ.find(path->remoteAddress);
                    i->second -= ADD_PADDING(chunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);
                    auto ib = qCounter.bookedTransQ.find(path->remoteAddress);
                    ib->second -= chunk->booksize;
                    return chunk;
                }
            }
        }
    }
    EV_INFO << "no chunk found in transmissionQ\n";
    return nullptr;
}

int32 inet::sctp::SCTPAssociation::getOutstandingBytes ( ) const

protected

Referenced by process_CLOSE(), process_RCV_Message(), processPacketDropArrived(), processSackArrived(), and sendShutdownAck().

{
    int32 osb = 0;
    for (const auto & elem : sctpPathMap) {
        osb += elem.second->outstandingBytes;
    }
    return osb;
}

SCTPPathVariables* inet::sctp::SCTPAssociation::getPath ( const L3Address &  pathId ) const

inline

Referenced by createSack(), process_PRIMARY(), process_RCV_Message(), process_SEND(), process_STATUS(), process_STREAM_RESET(), processAddInAndOutResetRequestArrived(), processAsconfAckArrived(), processAsconfArrived(), processDataArrived(), processHeartbeatAckArrived(), processInitAckArrived(), processInitArrived(), processOutAndResponseArrived(), processOutgoingResetRequestArrived(), processPacketDropArrived(), processResetResponseArrived(), processSackArrived(), sendAddInAndOutStreamsRequest(), sendAddOutgoingStreamsRequest(), sendAsconf(), sendBundledOutgoingResetAndResponse(), sendDoubleStreamResetResponse(), sendInit(), sendInitAck(), sendOutgoingRequestAndResponse(), sendOutgoingResetRequest(), sendPacketDrop(), sendShutdownAck(), sendStreamResetRequest(), sendStreamResetResponse(), and sendToIP().

    {
        SCTPPathMap::const_iterator iterator = sctpPathMap.find(pathId);
        if (iterator != sctpPathMap.end()) {
            return iterator->second;
        }
        return nullptr;
    }

SCTPQueue* inet::sctp::SCTPAssociation::getRetransmissionQueue ( ) const

inline

Referenced by inet::sctp::SCTP::removeAssociation(), and inet::sctp::SCTPAlgorithm::setAssociation().

{ return retransmissionQ; };

cMessage* inet::sctp::SCTPAssociation::getSackTimer ( ) const

inline

{ return SackTimer; };

SCTPAlgorithm* inet::sctp::SCTPAssociation::getSctpAlgorithm ( ) const

inline

{ return sctpAlgorithm; };

SCTP* inet::sctp::SCTPAssociation::getSctpMain ( ) const

inline

Referenced by inet::sctp::SCTPPathVariables::SCTPPathVariables().

{ return sctpMain; };

cMessage* inet::sctp::SCTPAssociation::getShutdownTimer ( ) const

inline

{ return T2_ShutdownTimer; };

std::vector< SCTPPathVariables * > inet::sctp::SCTPAssociation::getSortedPathMap ( )

private

Referenced by sendOnAllPaths().

{
    std::vector<SCTPPathVariables *> sortedPaths;
    for (auto & elem : sctpPathMap) {
        SCTPPathVariables *path = elem.second;
        sortedPaths.insert(sortedPaths.end(), path);
    }
    if (state->cmtSendAllComparisonFunction != nullptr) {
        std::stable_sort(sortedPaths.begin(), sortedPaths.end(), state->cmtSendAllComparisonFunction);
    }

    EV << "SORTED PATH MAP:" << endl;
    for (auto path : sortedPaths) {
        EV << " - " << path->remoteAddress
           << "  cwnd=" << path->cwnd
           << "  ssthresh=" << path->ssthresh
           << "  outstanding=" << path->outstandingBytes
           << "  bytesToRetransmit=" << state->bytesToRetransmit << endl;
    }
    return sortedPaths;
}

uint32 inet::sctp::SCTPAssociation::getSsnOfStream ( uint16  id )

protected

Referenced by processIncomingResetRequestArrived().

{
    auto iterator = sendStreams.find(id);
    return (iterator->second->getNextStreamSeqNum());
}

SCTPStateVariables* inet::sctp::SCTPAssociation::getState ( ) const

inline

Referenced by inet::sctp::SCTP::removeAssociation().

{ return state; };

SCTPQueue* inet::sctp::SCTPAssociation::getTransmissionQueue ( ) const

inline

Referenced by inet::sctp::SCTP::removeAssociation(), and inet::sctp::SCTPAlgorithm::setAssociation().

{ return transmissionQ; };

void inet::sctp::SCTPAssociation::handleChunkReportedAsAcked ( uint32 &  highestNewAck, simtime_t &  rttEstimation, SCTPDataVariables *  myChunk, SCTPPathVariables *  sackPath, const bool  sackIsNonRevokable  )

private

Referenced by processSackArrived().

{
    SCTPPathVariables *myChunkLastPath = myChunk->getLastDestinationPath();
    // SFR algorithm
    if (state->allowCMT == true) {
        EV << "TSN " << myChunk->tsn << " on path " << myChunkLastPath->remoteAddress << ":\t"
           << "findPseudoCumAck=" << ((myChunkLastPath->findPseudoCumAck == true) ? "true" : "false") << "\t"
           << "pseudoCumAck=" << myChunkLastPath->pseudoCumAck << "\t"
           << "newPseudoCumAck=" << ((myChunkLastPath->newPseudoCumAck == true) ? "true" : "false") << "\t"
           << "findRTXPseudoCumAck=" << ((myChunkLastPath->findRTXPseudoCumAck == true) ? "true" : "false") << "\t"
           << "rtxPseudoCumAck=" << myChunkLastPath->rtxPseudoCumAck << "\t"
           << "newRTXPseudoCumAck=" << ((myChunkLastPath->newRTXPseudoCumAck == true) ? "true" : "false") << "\t"
           << endl;

        // This chunk has not been acked before -> new ack on its myChunkLastPath.
        if (myChunkLastPath->sawNewAck == false) {
            EV << "TSN " << myChunk->tsn << " on path " << myChunkLastPath->remoteAddress << ":\t"
               << "Saw new ack -> setting highestNewAckInSack!" << endl;
            myChunkLastPath->sawNewAck = true;
        }

        // Smart Fast RTX
        // If chunk has already been transmitted on another path, do not consider it
        // for fast RTX handling!
        if ((!myChunk->hasBeenTimerBasedRtxed) ||
            (state->cmtSmartFastRTX == false))
        {
            if (myChunkLastPath->lowestNewAckInSack == 0) {
                myChunkLastPath->lowestNewAckInSack = myChunk->tsn;    // The lowest TSN acked
            }
            if (myChunkLastPath->highestNewAckInSack == 0) {
                myChunkLastPath->highestNewAckInSack = myChunk->tsn;    // The highest TSN acked so far
            }
            else if (tsnLt(myChunkLastPath->highestNewAckInSack, myChunk->tsn)) {
                myChunkLastPath->highestNewAckInSack = myChunk->tsn;    // The highest TSN acked so far
            }
        }
    }
    if ((myChunk->numberOfTransmissions == 1) &&
        (myChunk->hasBeenMoved == false) &&
        (myChunk->hasBeenReneged == false))
    {
        if (myChunkLastPath == sackPath) {
            const simtime_t timeDifference = simTime() - myChunk->sendTime;
            if ((timeDifference < rttEstimation) || (rttEstimation == -1.0)) {
                rttEstimation = timeDifference;
            }
            EV_DETAIL << simTime() << " processSackArrived: computed rtt time diff == "
                      << timeDifference << " for TSN " << myChunk->tsn << endl;
        }
        else {
            if ((state->allowCMT == true) &&
                (state->cmtSlowPathRTTUpdate == true) &&
                (myChunkLastPath->waitingForRTTCalculaton == false))
            {
                // numberOfTransmissions==1, hasBeenReneged==false
                // T.D. 25.02.2010: Slow Path Update
                // Remember this chunk's TSN and send time in order to update the
                // path's RTT using a stale SACK on its own path.
                myChunkLastPath->tsnForRTTCalculation = myChunk->tsn;
                myChunkLastPath->txTimeForRTTCalculation = myChunk->sendTime;
                myChunkLastPath->waitingForRTTCalculaton = true;
            }
        }
    }
    if ((myChunk->hasBeenAbandoned == false) &&
        (myChunk->hasBeenReneged == false) &&
        (myChunk->hasBeenAcked == false))
    {
        EV_DETAIL << simTime() << ": GapAcked TSN " << myChunk->tsn
                  << " on path " << myChunkLastPath->remoteAddress << endl;

        if (myChunk->tsn > highestNewAck) {
            highestNewAck = myChunk->tsn;
        }

        if (sackIsNonRevokable == true) {
            myChunkLastPath->gapAckedChunksInLastSACK++;
            myChunkLastPath->gapNRAckedChunksInLastSACK++;
        }
        else {
            myChunkLastPath->gapAckedChunksInLastSACK++;
        }
    }

    // ====== Non-Renegable SACK =============================================
    if (sackIsNonRevokable == true) {
        // NOTE: nonRenegablyAckChunk() will only work with ChunkMap,
        //       since the actual chunk object will be gone ...
        nonRenegablyAckChunk(myChunk, sackPath, rttEstimation,
                sctpMain->getAssocStat(assocId));
    }
    // ====== Renegable SACK =================================================
    else {
        renegablyAckChunk(myChunk, sackPath);
    }
}

void inet::sctp::SCTPAssociation::handleChunkReportedAsMissing ( const SCTPSackChunk *  sackChunk, const uint32  highestNewAck, SCTPDataVariables *  myChunk, SCTPPathVariables *  sackPath  )

private

Referenced by processSackArrived().

{
    SCTPPathVariables *myChunkLastPath = myChunk->getLastDestinationPath();
    EV_INFO << "TSN " << myChunk->tsn << " is missing in gap reports (last "
            << myChunkLastPath->remoteAddress << ") ";
    if (!chunkHasBeenAcked(myChunk)) {
        EV_DETAIL << "has not been acked, highestNewAck=" << highestNewAck
                  << " countsAsOutstanding=" << myChunk->countsAsOutstanding << endl;

        // ===== Check whether a Fast Retransmission is necessary =============
        // Non-CMT behaviour: check for highest TSN
        uint32 chunkReportedAsMissing = (highestNewAck > myChunk->tsn) ? 1 : 0;

        // Split Fast Retransmission (SFR) algorithm for CMT
        if ((state->allowCMT == true) && (state->cmtUseSFR == true)) {
            chunkReportedAsMissing = 0;    // Default: do not assume chunk as missing.

            // If there has been another chunk with highest TSN acked on this path,
            // the current one is missing.
            if ((myChunkLastPath->sawNewAck) &&
                (tsnGt(myChunkLastPath->highestNewAckInSack, myChunk->tsn)))
            {
                if (state->cmtUseDAC == false) {
                    chunkReportedAsMissing = 1;
                }
                else {
                    // ------ DAC algorithm at sender side -----------
                    // Is there a newly acked TSN on another path?
                    bool sawNewAckOnlyOnThisPath = true;
                    for (auto & elem : sctpPathMap) {
                        const SCTPPathVariables *otherPath = elem.second;
                        if ((otherPath != myChunkLastPath) && (otherPath->sawNewAck)) {
                            sawNewAckOnlyOnThisPath = false;
                            break;
                        }
                    }
                    if (sawNewAckOnlyOnThisPath == true) {
                        // All newly acked TSNs were sent on the same path
                        EV << "SplitFastRTX + DAC: all on same path:   "
                           << "TSN=" << myChunk->tsn
                           << " lowestNewAckInSack=" << myChunkLastPath->lowestNewAckInSack
                           << " highestNewAckInSack=" << myChunkLastPath->highestNewAckInSack
                           << " (on path " << myChunkLastPath->remoteAddress << ")" << endl;
                        // Are there newly acked TSNs ta, tb, so that ta < myChunk->tsn < tb?
                        // myChunkLastPath->highestNewAckInSack is highest newly acked TSN on the current path
                        //   -> since all TSNs were on this path, this value can be used as tb
                        // lowestNewAckInSack is the lowest newly acked TSN of this SACK
                        //   -> since all TSNs were on the same path, this value can be used as ta
                        if (tsnLt(myChunkLastPath->lowestNewAckInSack, myChunk->tsn) &&
                            tsnLt(myChunk->tsn, myChunkLastPath->highestNewAckInSack))
                        {
                            EV << "   => conservative increment of 1" << endl;
                            chunkReportedAsMissing = 1;
                        }
                        else if (tsnGt(myChunkLastPath->lowestNewAckInSack, myChunk->tsn)) {    // All newly acked TSNs are larger than myChunk->tsn
                            EV << "   => reported increment of dacPacketsRcvd=" << (unsigned int)sackChunk->getDacPacketsRcvd() << endl;
                            chunkReportedAsMissing = sackChunk->getDacPacketsRcvd();
                        }
                    }
                    else {
                        // Mixed SACKS: newly acked TSNs were sent to multiple paths
                        EV << "SplitFastRTX + DAC: mixed acks, increment is 1" << endl;
                        chunkReportedAsMissing = 1;
                    }
                }
            }    // else: There is no need to increment the missing count.

            EV << "SplitFastRTX: chunkReportedAsMissing="
               << chunkReportedAsMissing << ", "
               << "sawNewAck=" << myChunkLastPath->sawNewAck << ", "
               << "lowestNewAckInSack=" << myChunkLastPath->lowestNewAckInSack
               << "highestNewAckInSack=" << myChunkLastPath->highestNewAckInSack << ", "
               << "TSN=" << myChunk->tsn << endl;
        }
        if (chunkReportedAsMissing > 0) {
            myChunk->gapReports += chunkReportedAsMissing;
            myChunkLastPath->gapUnackedChunksInLastSACK++;

            if (myChunk->gapReports >= state->numGapReports) {
                bool fastRtx = false;
                switch (state->rtxMethod) {
                    case 0:    // Only one Fast RTX after 3 Gap reports
                        fastRtx = ((myChunk->hasBeenFastRetransmitted == false) &&
                                   ((myChunk->numberOfRetransmissions == 0) ||
                                    ((myChunk->hasBeenMoved) &&
                                     (myChunk->countsAsOutstanding) &&
                                     (state->movedChunkFastRTXFactor > 0) &&
                                     ((simTime() - myChunk->sendTime) > state->movedChunkFastRTXFactor * myChunkLastPath->srtt))
                                   ));
                        break;

                    case 1:    // Just 1 Fast RTX per RTT
                        fastRtx = ((myChunk->hasBeenFastRetransmitted == false) &&
                                   (myChunk->numberOfRetransmissions == 0 ||
                                    (simTime() - myChunk->sendTime) > myChunkLastPath->srtt));
                        break;

                    case 2:    // Switch off Fast RTX
                        fastRtx = false;
                        break;

                    case 3:    // Always Fast RTX
                        fastRtx = true;
                        break;
                }
                if (fastRtx) {
                    if (myChunk->hasBeenMoved) {
                        EV << simTime() << ": MovedFastRTX for TSN " << myChunk->tsn << endl;
                    }
                    myChunk->hasBeenMoved = false;    // Just trigger *one* fast RTX ...
                    // ====== Add chunk to transmission queue ========
                    if (transmissionQ->getChunk(myChunk->tsn) == nullptr) {
                        if (!chunkMustBeAbandoned(myChunk, sackPath)) {
                            SCTP::AssocStat *assocStat = sctpMain->getAssocStat(assocId);
                            if (assocStat) {
                                assocStat->numFastRtx++;
                            }
                        }
                        myChunk->hasBeenFastRetransmitted = true;
                        myChunk->sendForwardIfAbandoned = true;

                        EV_DETAIL << simTime() << ": Fast RTX for TSN "
                                  << myChunk->tsn << " on path " << myChunk->getLastDestination() << endl;
                        myChunkLastPath->numberOfFastRetransmissions++;

                        myChunk->setNextDestination(getNextDestination(myChunk));
                        SCTPPathVariables *myChunkNextPath = myChunk->getNextDestinationPath();
                        assert(myChunkNextPath != nullptr);

                        if (myChunk->countsAsOutstanding) {
                            decreaseOutstandingBytes(myChunk);
                        }
                        if (!transmissionQ->checkAndInsertChunk(myChunk->tsn, myChunk)) {
                            EV_DETAIL << "Fast RTX: cannot add message/chunk (TSN="
                                      << myChunk->tsn << ") to the transmissionQ" << endl;
                        }
                        else {
                            myChunk->enqueuedInTransmissionQ = true;
                            auto q = qCounter.roomTransQ.find(myChunk->getNextDestination());
                            q->second += ADD_PADDING(myChunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);
                            auto qb = qCounter.bookedTransQ.find(myChunk->getNextDestination());
                            qb->second += myChunk->booksize;
                        }
                        myChunkNextPath->requiresRtx = true;
                        if (myChunkNextPath->findLowestTSN == true) {
                            // TD 08.12.09: fixed detection of lowest TSN retransmitted
                            myChunkNextPath->lowestTSNRetransmitted = true;
                        }
                    }
                }
            }
        }
        myChunkLastPath->findLowestTSN = false;
    }
    else {
        // Reneging, type 1:
        // A chunk in the gap blocks has been un-acked => reneg it.
        tsnWasReneged(myChunk, sackPath, 1);
    }
}

void inet::sctp::SCTPAssociation::increaseOutstandingBytes ( SCTPDataVariables *  chunk, SCTPPathVariables *  path  )

private

Referenced by loadPacket(), and sendOnPath().

{
    path->outstandingBytes += chunk->booksize;
    path->statisticsPathOutstandingBytes->record(path->outstandingBytes);
    state->outstandingBytes += chunk->booksize;
    SCTPSendStream *stream = nullptr;
    auto associter = sendStreams.find(chunk->sid);
    if (associter != sendStreams.end()) {
        stream = associter->second;
    } else {
        throw cRuntimeError("Stream with id %d not found", chunk->sid);
    }
    stream->setBytesInFlight(stream->getBytesInFlight() + chunk->booksize);
    statisticsOutstandingBytes->record(state->outstandingBytes);

    auto iterator = qCounter.roomRetransQ.find(path->remoteAddress);
    state->outstandingMessages++;
    if (state->osbWithHeader)
        iterator->second += ADD_PADDING(chunk->booksize);
    else
        iterator->second += ADD_PADDING(chunk->booksize + SCTP_DATA_CHUNK_LENGTH);
}

const char * inet::sctp::SCTPAssociation::indicationName ( const int32  code )

static

Utility: returns name of SCTP_I_xxx constants.

Referenced by generateSendQueueAbatedIndication(), inet::SCTPNatServer::handleMessage(), inet::SCTPNatPeer::handleMessage(), sendEstabIndicationToApp(), and sendIndicationToApp().

{
#define CASE(x)    case x: \
        s = #x + 7; break
    const char *s = "unknown";
    switch (code) {
        CASE(SCTP_I_DATA);
        CASE(SCTP_I_DATA_NOTIFICATION);
        CASE(SCTP_I_ESTABLISHED);
        CASE(SCTP_I_PEER_CLOSED);
        CASE(SCTP_I_CLOSED);
        CASE(SCTP_I_CONNECTION_REFUSED);
        CASE(SCTP_I_CONNECTION_RESET);
        CASE(SCTP_I_TIMED_OUT);
        CASE(SCTP_I_STATUS);
        CASE(SCTP_I_ABORT);
        CASE(SCTP_I_SHUTDOWN_RECEIVED);
        CASE(SCTP_I_SEND_MSG);
        CASE(SCTP_I_SENDQUEUE_FULL);
        CASE(SCTP_I_SENDQUEUE_ABATED);
        CASE(SCTP_I_ABANDONED);
        CASE(SCTP_I_SEND_STREAMS_RESETTED);
        CASE(SCTP_I_RCV_STREAMS_RESETTED);
        CASE(SCTP_I_RESET_REQUEST_FAILED);
        CASE(SCTP_I_ADDRESS_ADDED);
    }
    return s;
#undef CASE
}

void inet::sctp::SCTPAssociation::initAssociation ( SCTPOpenCommand *  openCmd )

protected

Utility: creates send/receive queues and sctpAlgorithm.

Referenced by process_ASSOCIATE(), and process_OPEN_PASSIVE().

{
    EV_INFO << "SCTPAssociationUtil:initAssociation\n";
    // create send/receive queues
    const char *queueClass = openCmd->getQueueClass();
    transmissionQ = check_and_cast<SCTPQueue *>(inet::utils::createOne(queueClass));

    retransmissionQ = check_and_cast<SCTPQueue *>(inet::utils::createOne(queueClass));
    inboundStreams = openCmd->getInboundStreams();
    outboundStreams = openCmd->getOutboundStreams();
    // create algorithm
    const char *sctpAlgorithmClass = openCmd->getSctpAlgorithmClass();
    if (!sctpAlgorithmClass || !sctpAlgorithmClass[0])
        sctpAlgorithmClass = sctpMain->par("sctpAlgorithmClass");
    sctpAlgorithm = check_and_cast<SCTPAlgorithm *>(inet::utils::createOne(sctpAlgorithmClass));
    sctpAlgorithm->setAssociation(this);
    sctpAlgorithm->initialize();
    // create state block
    state = sctpAlgorithm->createStateVariables();

    if ((bool)sctpMain->par("auth")) {
        const char *chunks = sctpMain->par("chunks").stringValue();
        bool asc = false;
        bool asca = false;
        char *chunkscopy = (char *)malloc(strlen(chunks) + 1);
        strcpy(chunkscopy, chunks);
        char *token;
        token = strtok((char *)chunkscopy, ",");
        while (token != nullptr) {
            if (chunkToInt(token) == ASCONF)
                asc = true;
            if (chunkToInt(token) == ASCONF_ACK)
                asca = true;
            this->state->chunkList.push_back(chunkToInt(token));
            token = strtok(nullptr, ",");
        }
        if ((bool)sctpMain->par("addIP")) {
            if (!asc)
                state->chunkList.push_back(ASCONF);
            if (!asca)
                state->chunkList.push_back(ASCONF_ACK);
        }
        free(chunkscopy);
    }
}

void inet::sctp::SCTPAssociation::initCCParameters ( SCTPPathVariables *  path )

protected

SCTPCCFunctions.

Referenced by pmStartPathManagement(), and stateEntered().

{
    path->cwnd = getInitialCwnd(path);
    path->ssthresh = state->peerRwnd;
    recordCwndUpdate(path);

    EV_DEBUG << simTime() << ":\tCC [initCCParameters]\t" << path->remoteAddress
             << " (cmtCCGroup=" << path->cmtCCGroup << ")"
             << "\tsst=" << path->ssthresh << " cwnd=" << path->cwnd << endl;
    assocBestPaths.clear();
    assocMaxWndPaths.clear();
}

void inet::sctp::SCTPAssociation::initStreams ( uint32  inStreams, uint32  outStreams  )

protected

Referenced by SCTPAssociation().

{
    uint32 i;

    EV_INFO << "initStreams instreams=" << inStreams << "  outstream=" << outStreams << "\n";
    if (receiveStreams.size() == 0 && sendStreams.size() == 0) {
        for (i = 0; i < inStreams; i++) {
            SCTPReceiveStream *rcvStream = new SCTPReceiveStream(this);

            this->receiveStreams[i] = rcvStream;
            rcvStream->setStreamId(i);
            this->state->numMsgsReq[i] = 0;
        }
        for (i = 0; i < outStreams; i++) {
            SCTPSendStream *sendStream = new SCTPSendStream(this, i);
            sendStream->setStreamId(i);
            this->sendStreams[i] = sendStream;
        }
    }
}

void inet::sctp::SCTPAssociation::listOrderedQ ( )

protected

{
    for (auto & elem : receiveStreams) {
        EV_DEBUG << "stream " << elem.second->getStreamId() << ":\n";
        elem.second->getOrderedQ()->printQueue();
        EV_DEBUG << "\n";
    }
}

void inet::sctp::SCTPAssociation::loadPacket ( SCTPPathVariables *  pathVar, SCTPMessage **  sctpMsg, uint16 *  chunksAdded, uint16 *  dataChunksAdded, bool *  authAdded  )

private

Referenced by sendOnPath().

{
    *sctpMsg = state->sctpMsg;
    state->sctpMsg = nullptr;
    *chunksAdded = state->chunksAdded;
    *dataChunksAdded = state->dataChunksAdded;
    *authAdded = state->authAdded;
    EV_INFO << "loadPacket: path=" << pathVar->remoteAddress << " osb=" << pathVar->outstandingBytes << " -> " << pathVar->outstandingBytes + state->packetBytes << endl;
    if (state->osbWithHeader) {
        qCounter.roomSumSendStreams -= state->packetBytes;
    }
    else {
        qCounter.roomSumSendStreams -= state->packetBytes + ((*dataChunksAdded) * SCTP_DATA_CHUNK_LENGTH);
    }
    qCounter.bookedSumSendStreams -= state->packetBytes;

    for (uint16 i = 0; i < (*sctpMsg)->getChunksArraySize(); i++) {
        cPacketPtr& chunkPtr = (*sctpMsg)->getChunks(i);
        SCTPDataChunk* dataChunk = dynamic_cast<SCTPDataChunk*>(chunkPtr);
        if(dataChunk != nullptr) {
            const uint32_t tsn = dataChunk->getTsn();
            SCTPDataVariables* chunk = retransmissionQ->payloadQueue.find(tsn)->second;
            assert(chunk != nullptr);
            chunk->queuedOnPath = pathVar;
            chunk->queuedOnPath->queuedBytes += chunk->booksize;
            chunk->setLastDestination(pathVar);
            increaseOutstandingBytes(chunk, pathVar);
            chunk->countsAsOutstanding = true;
        }
    }
}

SCTPParameter * inet::sctp::SCTPAssociation::makeAddStreamsRequestParameter ( uint32  srsn, SCTPResetInfo *  info  )

protected

Referenced by sendStreamResetRequest().

{
    SCTPAddStreamsRequestParameter *addStreams = new SCTPAddStreamsRequestParameter("Add_Streams");
    if (info->getInstreams() > 0) {
        addStreams->setParameterType(ADD_INCOMING_STREAMS_REQUEST_PARAMETER);
        addStreams->setNumberOfStreams(info->getInstreams());
        state->localRequestType = ADD_INCOMING;
        state->requests[srsn].type = ADD_INCOMING_STREAMS_REQUEST_PARAMETER;
        state->numAddedInStreams = addStreams->getNumberOfStreams();
    } else if (info->getOutstreams() > 0) {
        addStreams->setParameterType(ADD_OUTGOING_STREAMS_REQUEST_PARAMETER);
        addStreams->setNumberOfStreams(info->getOutstreams());
        state->localRequestType = ADD_OUTGOING;
        state->requests[srsn].type = ADD_OUTGOING_STREAMS_REQUEST_PARAMETER;
        state->numAddedOutStreams = addStreams->getNumberOfStreams();
    }
    addStreams->setSrReqSn(srsn);
    addStreams->setByteLength(SCTP_ADD_STREAMS_REQUEST_PARAMETER_LENGTH);
    return addStreams;
}

SCTPDataVariables * inet::sctp::SCTPAssociation::makeDataVarFromDataMsg ( SCTPDataMsg *  datMsg, SCTPPathVariables *  path  )

private

Referenced by sendOnPath().

{
    SCTPDataVariables *datVar = new SCTPDataVariables();

    datMsg->setInitialDestination(path->remoteAddress);
    datVar->setInitialDestination(path);

    datVar->bbit = datMsg->getBBit();
    datVar->ebit = datMsg->getEBit();
    datVar->ibit = datMsg->getSackNow();
    datVar->enqueuingTime = datMsg->getEnqueuingTime();
    datVar->expiryTime = datMsg->getExpiryTime();
    datVar->ppid = datMsg->getPpid();
    datVar->len = datMsg->getBitLength();
    datVar->sid = datMsg->getSid();
    datVar->allowedNoRetransmissions = datMsg->getRtx();
    datVar->booksize = datMsg->getBooksize();
    datVar->prMethod = datMsg->getPrMethod();
    datVar->priority = datMsg->getPriority();
    datVar->strReset = datMsg->getStrReset();

    // ------ Stream handling ---------------------------------------
    auto iterator = sendStreams.find(datMsg->getSid());
    SCTPSendStream *stream = iterator->second;
    uint32 nextSSN = stream->getNextStreamSeqNum();
    datVar->userData = datMsg->decapsulate();
    if (datMsg->getOrdered()) {
        // ------ Ordered mode: assign SSN ---------
        if (datMsg->getEBit()) {
            datVar->ssn = nextSSN++;
        }
        else {
            datVar->ssn = nextSSN;
        }

        datVar->ordered = true;
        if (nextSSN > 65535) {
            stream->setNextStreamSeqNum(0);
        }
        else {
            stream->setNextStreamSeqNum(nextSSN);
        }
    }
    else {
        // ------ Ordered mode: no SSN needed ------
        datVar->ssn = 0;
        datVar->ordered = false;
    }

    state->ssLastDataChunkSizeSet = true;
    return datVar;
}

SCTPParameter * inet::sctp::SCTPAssociation::makeIncomingStreamResetParameter ( uint32  srsn, SCTPResetInfo *  info  )

protected

Referenced by sendStreamResetRequest().

{
    SCTPIncomingSSNResetRequestParameter *inResetParam;
    inResetParam = new SCTPIncomingSSNResetRequestParameter("Incoming_Request_Param");
    inResetParam->setParameterType(INCOMING_RESET_REQUEST_PARAMETER);
    inResetParam->setSrReqSn(srsn);
    if (info->getStreamsArraySize() > 0) {
        inResetParam->setStreamNumbersArraySize(info->getStreamsArraySize());
        for (uint i = 0; i < info->getStreamsArraySize(); i++) {
            inResetParam->setStreamNumbers(i, info->getStreams(i));
            state->requests[srsn].streams.push_back(inResetParam->getStreamNumbers(i));
            state->resetInStreams.push_back(inResetParam->getStreamNumbers(i));
        }
    }
    state->localRequestType = RESET_INCOMING;
    inResetParam->setByteLength(SCTP_INCOMING_RESET_REQUEST_PARAMETER_LENGTH + (info->getStreamsArraySize() * 2));
    return inResetParam;
}

SCTPParameter * inet::sctp::SCTPAssociation::makeOutgoingStreamResetParameter ( uint32  srsn, SCTPResetInfo *  info  )

protected

Referenced by sendStreamResetRequest().

{
    SCTPOutgoingSSNResetRequestParameter *outResetParam;
    outResetParam = new SCTPOutgoingSSNResetRequestParameter("Outgoing_Request_Param");
    outResetParam->setParameterType(OUTGOING_RESET_REQUEST_PARAMETER);
    outResetParam->setSrReqSn(srsn);
    outResetParam->setSrResSn(state->expectedStreamResetSequenceNumber - 1);
    outResetParam->setLastTsn(state->nextTSN - 1);
    state->requests[srsn].lastTsn = outResetParam->getLastTsn();
    if (state->outstandingBytes == 0 && state->streamsToReset.size() == 0) {
        if (info->getStreamsArraySize() > 0) {
            outResetParam->setStreamNumbersArraySize(info->getStreamsArraySize());
            for (uint i = 0; i < info->getStreamsArraySize(); i++) {
                outResetParam->setStreamNumbers(i, (uint16)info->getStreams(i));
                state->resetOutStreams.push_back(outResetParam->getStreamNumbers(i));
                state->requests[srsn].streams.push_back(outResetParam->getStreamNumbers(i));
            }
        }
    } else if (state->streamsToReset.size() > 0) {
        outResetParam->setStreamNumbersArraySize(state->streamsToReset.size());
        uint16 i = 0;
        for (std::list<uint16>::iterator it = state->streamsToReset.begin(); it != state->streamsToReset.end(); ++it) {
            outResetParam->setStreamNumbers(i, *it);
            state->resetOutStreams.push_back(outResetParam->getStreamNumbers(i));
            state->requests[srsn].streams.push_back(outResetParam->getStreamNumbers(i));
            i++;
        }
        state->streamsToReset.clear();
    }
    state->localRequestType = RESET_OUTGOING;
    outResetParam->setByteLength(SCTP_OUTGOING_RESET_REQUEST_PARAMETER_LENGTH + (outResetParam->getStreamNumbersArraySize() * 2));
    return outResetParam;
}

bool inet::sctp::SCTPAssociation::makeRoomForTsn ( const uint32  tsn, const uint32  length, const bool  uBit  )

protected

Referenced by processDataArrived().

{
    EV_INFO << simTime() << ":\tmakeRoomForTsn:"
            << " tsn=" << tsn
            << " length=" << length
            << " highestTSN=" << state->gapList.getHighestTSNReceived() << endl;
    calculateRcvBuffer();

    // Reneging may not happen when it is turned off!
    assert(state->disableReneging == false);

    // Get the highest TSN of the GapAck blocks.
    uint32 tryTSN = state->gapList.getHighestTSNReceived();
    uint32 sum = 0;
    while ((sum < length) &&
           (tryTSN > state->gapList.getCumAckTSN()))
    {
        // ====== New TSN is larger than highest one in GapList? ==============
        if (tsnGt(tsn, tryTSN)) {
            // There is no space for a TSN that high!
            EV_DETAIL << "makeRoomForTsn:"
                      << " tsn=" << tryTSN
                      << " tryTSN=" << tryTSN << " -> no space" << endl;
            return false;
        }

        const uint32 oldSum = sum;
        // ====== Iterate all streams to find chunk with TSN "tryTSN" =========
        for (auto & elem : receiveStreams) {
            SCTPReceiveStream *receiveStream = elem.second;

            // ====== Get chunk to drop ========================================
            SCTPQueue *queue;
            if (uBit) {
                queue = receiveStream->getUnorderedQ();    // Look in unordered queue
            } else {
                queue = receiveStream->getOrderedQ();    // Look in ordered queue
            }
            SCTPDataVariables *chunk = queue->getChunk(tryTSN);
            if (chunk == nullptr) {    // 12.06.08
                EV_DETAIL << tryTSN << " not found in orderedQ. Try deliveryQ" << endl;
                // Chunk is already in delivery queue.
                queue = receiveStream->getDeliveryQ();
                chunk = queue->getChunk(tryTSN);
            }

            // ====== A chunk has been found -> drop it ========================
            if (chunk != nullptr) {
                sum += chunk->len;
                if (queue->deleteMsg(tryTSN)) {
                    EV_INFO << tryTSN << " found and deleted" << endl;
                    state->bufferedMessages--;
                    state->queuedReceivedBytes -= chunk->len / 8;
                    if (ssnGt(receiveStream->getExpectedStreamSeqNum(), chunk->ssn)) {
                        receiveStream->setExpectedStreamSeqNum(chunk->ssn);
                    }

                    auto iter = sctpMain->assocStatMap.find(assocId);
                    iter->second.numChunksReneged++;
                }
                qCounter.roomSumRcvStreams -= ADD_PADDING(chunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);
                state->gapList.removeFromGapList(tryTSN);

                break;
            } else {
                EV_INFO << "TSN " << tryTSN << " not found in stream "
                        << receiveStream->getStreamId() << endl;
            }
        }
        if (sum == oldSum) {
            EV_INFO << tryTSN << " not found in any stream" << endl;
        }
        tryTSN--;
    }

    return true;
}

SCTPParameter * inet::sctp::SCTPAssociation::makeSSNTSNResetParameter ( uint32  srsn )

protected

Referenced by sendStreamResetRequest().

{
    SCTPSSNTSNResetRequestParameter *resetParam;
    resetParam = new SCTPSSNTSNResetRequestParameter("SSN_TSN_Request_Param");
    resetParam->setParameterType(SSN_TSN_RESET_REQUEST_PARAMETER);
    resetParam->setSrReqSn(srsn);
    resetParam->setByteLength(SCTP_SSN_TSN_RESET_REQUEST_PARAMETER_LENGTH);
    state->localRequestType = SSN_TSN;
    return resetParam;
}

SCTPDataVariables * inet::sctp::SCTPAssociation::makeVarFromMsg ( SCTPDataChunk *  datachunk )

protected

Referenced by processDataArrived().

{
    SCTPDataVariables *chunk = new SCTPDataVariables();

    chunk->bbit = dataChunk->getBBit();
    chunk->ebit = dataChunk->getEBit();
    chunk->ibit = dataChunk->getIBit();
    chunk->sid = dataChunk->getSid();
    chunk->ssn = dataChunk->getSsn();
    chunk->ppid = dataChunk->getPpid();
    chunk->tsn = dataChunk->getTsn();
    if (!dataChunk->getUBit()) {
        chunk->ordered = true;
    }
    else {
        chunk->ordered = false;
    }
    SCTPSimpleMessage *smsg = check_and_cast<SCTPSimpleMessage *>(dataChunk->decapsulate());

    chunk->userData = smsg;
    EV_INFO << "smsg encapsulate? " << smsg->getEncaps() << endl;
    if (smsg->getEncaps())
        chunk->len = smsg->getBitLength();
    else
        chunk->len = smsg->getDataLen() * 8;
    chunk->firstSendTime = dataChunk->getFirstSendTime();
    calculateRcvBuffer();

    EV_INFO << "makeVarFromMsg: queuedBytes has been increased to "
            << state->queuedReceivedBytes << endl;
    return chunk;
}

static int32 inet::sctp::SCTPAssociation::midGt ( const uint32  mid1, const uint32  mid2  )

inlinestatic

{ return SCTP_TSN_GT(mid1, mid2); }

void inet::sctp::SCTPAssociation::moveChunkToOtherPath ( SCTPDataVariables *  chunk, SCTPPathVariables *  newPath  )

private

Referenced by chunkReschedulingControl(), and process_TIMEOUT_RTX().

{
    // ======= Remove chunk from outstanding bytes ===========================
    if (chunk->countsAsOutstanding) {
        decreaseOutstandingBytes(chunk);
    }

    // ====== Prepare next destination =======================================
    chunk->hasBeenFastRetransmitted = false;
    chunk->gapReports = 0;
    chunk->setNextDestination(newPath);

    // ====== Rebook chunk on new path =======================================
    assert(chunk->queuedOnPath->queuedBytes >= chunk->booksize);
    chunk->queuedOnPath->queuedBytes -= chunk->booksize;
    chunk->queuedOnPath->statisticsPathQueuedSentBytes->record(chunk->queuedOnPath->queuedBytes);

    chunk->queuedOnPath = chunk->getNextDestinationPath();
    chunk->queuedOnPath->queuedBytes += chunk->booksize;
    chunk->queuedOnPath->statisticsPathQueuedSentBytes->record(chunk->queuedOnPath->queuedBytes);

    // ====== Perform bookkeeping ============================================
    // Check, if chunk_ptr->tsn is already in transmission queue.
    // This can happen in case multiple timeouts occur in succession.
    if (!transmissionQ->checkAndInsertChunk(chunk->tsn, chunk)) {
        EV_DETAIL << "TSN " << chunk->tsn << " already in transmissionQ" << endl;
        return;
    }
    else {
        chunk->enqueuedInTransmissionQ = true;
        EV_DETAIL << "Inserting TSN " << chunk->tsn << " into transmissionQ" << endl;
        auto q = qCounter.roomTransQ.find(chunk->getNextDestination());
        q->second += ADD_PADDING(chunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);
        auto qb = qCounter.bookedTransQ.find(chunk->getNextDestination());
        qb->second += chunk->booksize;
        state->peerRwnd += (chunk->booksize + state->bytesToAddPerPeerChunk);
        if (state->peerAllowsChunks) {
            state->peerMsgRwnd++;
        }
    }
    if (state->peerRwnd > state->initialPeerRwnd) {
        state->peerRwnd = state->initialPeerRwnd;
    }
    if (state->peerAllowsChunks && state->peerMsgRwnd > state->initialPeerMsgRwnd) {
        state->peerMsgRwnd = state->initialPeerMsgRwnd;
    }

    // T.D. 02.08.2011: The peer window may not be full anymore!
    if ((state->peerWindowFull) && (state->peerRwnd > 0)) {
        state->peerWindowFull = false;
    }

    statisticsPeerRwnd->record(state->peerRwnd);
}

bool inet::sctp::SCTPAssociation::msgMustBeAbandoned ( SCTPDataMsg *  msg, int32  stream, bool  ordered  )

protected

bool inet::sctp::SCTPAssociation::nextChunkFitsIntoPacket ( SCTPPathVariables *  path, int32  bytes  )

protected

Referenced by sendOnPath().

{
    int32 nextStream = -1;
    SCTPSendStream *stream;

    /* Only change stream if we don't have to finish a fragmented message */
    if (state->lastMsgWasFragment)
        nextStream = state->lastStreamScheduled;
    else
        nextStream = (this->*ssFunctions.ssGetNextSid)(path, true);

    if (nextStream == -1)
        return false;

    stream = sendStreams.find(nextStream)->second;

    if (stream) {
        cPacketQueue *streamQ = nullptr;

        if (!stream->getUnorderedStreamQ()->isEmpty())
            streamQ = stream->getUnorderedStreamQ();
        else if (!stream->getStreamQ()->isEmpty())
            streamQ = stream->getStreamQ();

        if (streamQ) {
            int32 b = ADD_PADDING(((SCTPDataMsg *)streamQ->front())->getEncapsulatedPacket()->getByteLength() + SCTP_DATA_CHUNK_LENGTH);

            /* Check if next message would be fragmented */
            if (b > (int32)state->fragPoint + (int32)SCTP_DATA_CHUNK_LENGTH) {
                /* Test if fragment fits */
                if (bytes >= (int32)state->fragPoint)
                    return true;
                else
                    return false;
            }

            /* Message doesn't need to be fragmented, just try if it fits */
            if (b <= bytes)
                return true;
            else
                return false;
        }
    }

    return false;
}

void inet::sctp::SCTPAssociation::nonRenegablyAckChunk ( SCTPDataVariables *  chunk, SCTPPathVariables *  sackPath, simtime_t &  rttEstimation, SCTP::AssocStat *  assocStat  )

private

Referenced by dequeueAckedChunks(), and handleChunkReportedAsAcked().

{
    SCTPPathVariables *lastPath = chunk->getLastDestinationPath();
    assert(lastPath != nullptr);

    // ====== Bookkeeping ====================================================
    // Subtract chunk size from sender buffer size
    state->sendBuffer -= chunk->len / 8;

    // Subtract chunk size from the queue size of its stream
    auto streamIterator = sendStreams.find(chunk->sid);
    assert(streamIterator != sendStreams.end());
    SCTPSendStream *stream = streamIterator->second;
    assert(stream != nullptr);
    cPacketQueue *streamQ = (chunk->ordered == false) ? stream->getUnorderedStreamQ() : stream->getStreamQ();
    assert(streamQ != nullptr);

    if (chunk->priority > 0) {
        state->queuedDroppableBytes -= chunk->len / 8;
    }

    if ((chunk->hasBeenCountedAsNewlyAcked == false) &&
        (chunk->hasBeenAcked == false))
    {
        if ((state->cmtMovedChunksReduceCwnd == false) ||
            (chunk->hasBeenMoved == false))
        {
            chunk->hasBeenCountedAsNewlyAcked = true;
            // The chunk has not been acked before.
            // Therefore, its size may *once* be counted as newly acked.
            lastPath->newlyAckedBytes += chunk->booksize;
        }
    }

    assert(chunk->queuedOnPath->queuedBytes >= chunk->booksize);
    chunk->queuedOnPath->queuedBytes -= chunk->booksize;
    chunk->queuedOnPath->statisticsPathQueuedSentBytes->record(chunk->queuedOnPath->queuedBytes);
    chunk->queuedOnPath = nullptr;

    assert(state->queuedSentBytes >= chunk->booksize);
    state->queuedSentBytes -= chunk->booksize;
    statisticsQueuedSentBytes->record(state->queuedSentBytes);
    if (assocStat) {
        assocStat->ackedBytes += chunk->len / 8;
    }
    if ((assocStat) && (fairTimer)) {
        assocStat->fairAckedBytes += chunk->len / 8;
    }

    if ((state->allowCMT == true) &&
        (state->cmtSlowPathRTTUpdate == true) &&
        (lastPath->waitingForRTTCalculaton == false) &&
        (lastPath != sackPath) &&
        (chunk->numberOfTransmissions == 1) &&
        (chunk->hasBeenMoved == false) &&
        (chunk->hasBeenReneged == false))
    {
        // Slow Path Update
        // Remember this chunk's TSN and send time in order to update the
        // path's RTT using a stale SACK on its own path.
        lastPath->tsnForRTTCalculation = chunk->tsn;
        lastPath->txTimeForRTTCalculation = chunk->sendTime;
        lastPath->waitingForRTTCalculaton = true;
    }

    // ====== RTT calculation ================================================
    if ((chunkHasBeenAcked(chunk) == false) && (chunk->countsAsOutstanding)) {
        if ((chunk->numberOfTransmissions == 1) && (lastPath == sackPath) && (chunk->hasBeenMoved == false)) {
            const simtime_t timeDifference = simTime() - chunk->sendTime;
            if ((timeDifference < rttEstimation) || (rttEstimation == SIMTIME_MAX)) {
                rttEstimation = timeDifference;
            }
        }
        decreaseOutstandingBytes(chunk);
    }

    // ====== Remove chunk pointer from ChunkMap =============================
    // The chunk still has to be remembered as acknowledged!
    ackChunk(chunk, sackPath);

    // ====== Remove chunk from transmission queue ===========================
    // Dequeue chunk, cause it has been acked
    if (transmissionQ->getChunk(chunk->tsn)) {
        transmissionQ->removeMsg(chunk->tsn);
        chunk->enqueuedInTransmissionQ = false;
        auto q = qCounter.roomTransQ.find(chunk->getNextDestination());
        q->second -= ADD_PADDING(chunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);
        auto qb = qCounter.bookedTransQ.find(chunk->getNextDestination());
        qb->second -= chunk->booksize;
    }

    // ====== Remove chunk from retransmission queue =========================
    chunk = retransmissionQ->getAndExtractChunk(chunk->tsn);
    if (chunk->userData != nullptr) {
        delete chunk->userData;
    }
    delete chunk;
}

int32 inet::sctp::SCTPAssociation::numUsableStreams ( void  )

protected

Referenced by SCTPAssociation().

{
    int32 count = 0;

    for (auto & elem : sendStreams)
        if (elem.second->getStreamQ()->getLength() > 0 || elem.second->getUnorderedStreamQ()->getLength() > 0) {
            count++;
        }
    return count;
}

bool inet::sctp::SCTPAssociation::orderedQueueEmptyOfStream ( uint16  sid )

protected

Referenced by process_STREAM_RESET().

{
    auto streamIterator = sendStreams.find(sid);
    assert(streamIterator != sendStreams.end());
    return (streamIterator->second)->getStreamQ()->isEmpty();
}

bool inet::sctp::SCTPAssociation::pathMapLargestSpace ( const SCTPPathVariables *  left, const SCTPPathVariables *  right  )

staticprivate

{
    const int l = (left->cwnd - left->outstandingBytes);
    const int r = (right->cwnd - right->outstandingBytes);
    return l > r;
}

bool inet::sctp::SCTPAssociation::pathMapLargestSpaceAndSSThreshold ( const SCTPPathVariables *  left, const SCTPPathVariables *  right  )

staticprivate

{
    if (left->ssthresh != right->ssthresh) {
        return left->ssthresh > right->ssthresh;
    }

    const int l = (left->cwnd - left->outstandingBytes);
    const int r = (right->cwnd - right->outstandingBytes);
    return l > r;
}

bool inet::sctp::SCTPAssociation::pathMapLargestSSThreshold ( const SCTPPathVariables *  left, const SCTPPathVariables *  right  )

staticprivate

{
    return left->ssthresh > right->ssthresh;
}

bool inet::sctp::SCTPAssociation::pathMapRandomized ( const SCTPPathVariables *  left, const SCTPPathVariables *  right  )

staticprivate

{
    return left->sendAllRandomizer < right->sendAllRandomizer;
}

bool inet::sctp::SCTPAssociation::pathMapSmallestLastTransmission ( const SCTPPathVariables *  left, const SCTPPathVariables *  right  )

staticprivate

{
    return left->lastTransmission < right->lastTransmission;
}

void inet::sctp::SCTPAssociation::pathStatusIndication ( const SCTPPathVariables *  path, const bool  status  )

protected

Referenced by pmClearPathCounter(), process_TIMEOUT_HEARTBEAT(), process_TIMEOUT_RTX(), and updateCounters().

{
    cPacket *msg = new cPacket("StatusInfo");
    msg->setKind(SCTP_I_STATUS);
    SCTPStatusInfo *cmd = new SCTPStatusInfo();
    cmd->setPathId(path->remoteAddress);
    cmd->setAssocId(assocId);
    cmd->setActive(status);
    msg->setControlInfo(cmd);
    if (!status) {
        auto iter = sctpMain->assocStatMap.find(assocId);
        iter->second.numPathFailures++;
    }
    sendToApp(msg);
}

int32 inet::sctp::SCTPAssociation::pathStreamSchedulerManual ( SCTPPathVariables *  path, bool  peek  )

protected

Referenced by SCTPAssociation().

{
    uint32 pathNo = 0;
    int32 testsid, sid = -1;
    uint32 lastsid = state->lastStreamScheduled;

    EV_INFO << "Stream Scheduler: path-aware Manual (peek: " << peek << ")" << endl;

    if (state->ssStreamToPathMap.empty()) {
        for (uint16 str = 0; str < outboundStreams; str++) {
            state->ssStreamToPathMap[str] = 0;
        }

        // Fill Stream to Path map
        uint16 streamNum = 0;
        cStringTokenizer prioTokenizer(sctpMain->par("streamsToPaths").stringValue());
        while (prioTokenizer.hasMoreTokens()) {
            const char *token = prioTokenizer.nextToken();
            state->ssStreamToPathMap[streamNum] = (uint32)atoi(token);
            streamNum++;
        }
        if (state->ssStreamToPathMap.empty())
            throw cRuntimeError("streamsToPaths not defined");
    }

    for (SCTPPathMap::const_iterator iterator = sctpPathMap.begin(); iterator != sctpPathMap.end(); ++iterator) {
        if (path == iterator->second)
            break;
        pathNo++;
    }
    EV_INFO << "Stream Scheduler: about to send on " << pathNo + 1 << ". path" << endl;

    testsid = state->lastStreamScheduled;

    do {
        testsid = (testsid + 1) % outboundStreams;

        if (state->ssStreamToPathMap[testsid] == (int32)pathNo) {
            sid = testsid;
            EV_DETAIL << "Stream Scheduler: chose sid " << sid << ".\n";
            if (!peek)
                state->lastStreamScheduled = sid;
        }
    } while (sid == -1 && testsid != (int32)state->lastStreamScheduled);

    EV_INFO << "streamScheduler sid=" << sid << " lastStream=" << lastsid << " outboundStreams=" << outboundStreams << " next=" << state->ssNextStream << "\n";

    return sid;
}

int32 inet::sctp::SCTPAssociation::pathStreamSchedulerMapToPath ( SCTPPathVariables *  path, bool  peek  )

protected

Referenced by SCTPAssociation().

{
    int32 thisPath = -1;
    int32 workingPaths = 0;
    for (auto & elem : sctpPathMap) {
        SCTPPathVariables *myPath = elem.second;
        if (myPath->activePath) {
            if (myPath == path) {
                thisPath = workingPaths;
            }
            workingPaths++;
        }
    }
    if (thisPath == -1) {
        std::cout << "THIS PATH IS NOT WORKING???" << endl;
        return -1;
    }

    int32 sid = -1;
    for (SCTPSendStreamMap::const_iterator iterator = sendStreams.begin();
         iterator != sendStreams.end(); iterator++)
    {
        SCTPSendStream *stream = iterator->second;
        if ((stream->getStreamId() % workingPaths) == thisPath) {    // Maps to "path" ...
            if ((stream->getUnorderedStreamQ()->getLength() > 0) ||    // Stream has something to send ...
                (stream->getStreamQ()->getLength() > 0))
            {
                assert(sid == -1);
                sid = stream->getStreamId();
                break;
            }
        }
    }

    EV_INFO << "pathStreamSchedulerMapToPath sid=" << sid
            << " path=" << path->remoteAddress
            << " (path " << (1 + thisPath)
            << " of " << workingPaths << ")" << endl;
    return sid;
}

SCTPDataVariables * inet::sctp::SCTPAssociation::peekAbandonedChunk ( const SCTPPathVariables *  path )

protected

Referenced by processPacketDropArrived(), and sendOnPath().

{
    SCTPDataVariables *retChunk = nullptr;

    if (state->prMethod != 0 && !retransmissionQ->payloadQueue.empty()) {
        for (auto & elem : retransmissionQ->payloadQueue) {
            SCTPDataVariables *chunk = elem.second;

            if (chunk->getLastDestinationPath() == path) {
                /* Apply policies if necessary */
                if (!chunk->hasBeenAbandoned && !chunk->hasBeenAcked &&
                    (chunk->hasBeenFastRetransmitted || chunk->hasBeenTimerBasedRtxed))
                {
                    switch (chunk->prMethod) {
                        case PR_TTL:
                            if (chunk->expiryTime > 0 && chunk->expiryTime <= simTime()) {
                                if (!chunk->hasBeenAbandoned) {
                                    EV_DETAIL << "TSN " << chunk->tsn << " will be abandoned"
                                              << " (expiryTime=" << chunk->expiryTime
                                              << " sendTime=" << chunk->sendTime << ")" << endl;
                                    chunk->hasBeenAbandoned = true;
                                    sendIndicationToApp(SCTP_I_ABANDONED);
                                }
                            }
                            break;

                        case PR_RTX:
                            if (chunk->hasBeenFastRetransmitted && chunk->numberOfRetransmissions >= chunk->allowedNoRetransmissions) {
                                if (!chunk->hasBeenAbandoned) {
                                    EV_DETAIL << "peekAbandonedChunk: TSN " << chunk->tsn << " will be abandoned"
                                              << " (maxRetransmissions=" << chunk->allowedNoRetransmissions << ")" << endl;
                                    chunk->hasBeenAbandoned = true;
                                    sendIndicationToApp(SCTP_I_ABANDONED);
                                }
                            }
                            break;
                    }
                }

                if (chunk->hasBeenAbandoned && chunk->sendForwardIfAbandoned) {
                    retChunk = chunk;
                }
            }
        }
    }
    return retChunk;
}

SCTPDataMsg* inet::sctp::SCTPAssociation::peekOutboundDataMsg ( )

protected

bool inet::sctp::SCTPAssociation::performStateTransition ( const SCTPEventCode &  event )

protected

Implemements the pure SCTP state machine.

Referenced by process_RCV_Message(), processCookieAckArrived(), processCookieEchoArrived(), processInitAckArrived(), processInitArrived(), pushUlp(), sendShutdown(), and sendShutdownAck().

{
    EV_TRACE << "performStateTransition\n";

    if (event == SCTP_E_IGNORE) {    // e.g. discarded segment
        EV_DETAIL << "Staying in state: " << stateName(fsm->getState()) << " (no FSM event)\n";
        return true;
    }

    // state machine
    int32 oldState = fsm->getState();

    switch (fsm->getState()) {
        case SCTP_S_CLOSED:
            switch (event) {
                case SCTP_E_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_OPEN_PASSIVE:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_ASSOCIATE:
                    FSM_Goto((*fsm), SCTP_S_COOKIE_WAIT);
                    break;

                case SCTP_E_RCV_INIT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_RCV_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_RCV_VALID_COOKIE_ECHO:
                    FSM_Goto((*fsm), SCTP_S_ESTABLISHED);
                    break;

                case SCTP_E_CLOSE:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                default:
                    break;
            }
            break;

        case SCTP_S_COOKIE_WAIT:
            switch (event) {
                case SCTP_E_RCV_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_RCV_INIT_ACK:
                    FSM_Goto((*fsm), SCTP_S_COOKIE_ECHOED);
                    break;

                case SCTP_E_RCV_VALID_COOKIE_ECHO:
                    FSM_Goto((*fsm), SCTP_S_ESTABLISHED);
                    break;

                default:
                    break;
            }
            break;

        case SCTP_S_COOKIE_ECHOED:
            switch (event) {
                case SCTP_E_RCV_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_RCV_COOKIE_ACK:
                    FSM_Goto((*fsm), SCTP_S_ESTABLISHED);
                    break;

                default:
                    break;
            }
            break;

        case SCTP_S_ESTABLISHED:
            switch (event) {
                case SCTP_E_SEND:
                    FSM_Goto((*fsm), SCTP_S_ESTABLISHED);
                    break;

                case SCTP_E_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_RCV_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_CLOSE:
                case SCTP_E_SHUTDOWN:
                    FSM_Goto((*fsm), SCTP_S_SHUTDOWN_PENDING);
                    break;

                case SCTP_E_STOP_SENDING:
                    FSM_Goto((*fsm), SCTP_S_SHUTDOWN_PENDING);
                    state->stopSending = true;
                    state->lastTSN = state->nextTSN - 1;
                    break;

                case SCTP_E_RCV_SHUTDOWN:
                    FSM_Goto((*fsm), SCTP_S_SHUTDOWN_RECEIVED);
                    break;

                default:
                    break;
            }
            break;

        case SCTP_S_SHUTDOWN_PENDING:
            switch (event) {
                case SCTP_E_RCV_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_NO_MORE_OUTSTANDING:
                    FSM_Goto((*fsm), SCTP_S_SHUTDOWN_SENT);
                    break;

                case SCTP_E_RCV_SHUTDOWN:
                    FSM_Goto((*fsm), SCTP_S_SHUTDOWN_RECEIVED);
                    break;

                case SCTP_E_RCV_SHUTDOWN_ACK:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                default:
                    break;
            }
            break;

        case SCTP_S_SHUTDOWN_RECEIVED:
            switch (event) {
                case SCTP_E_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_RCV_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_NO_MORE_OUTSTANDING:
                    FSM_Goto((*fsm), SCTP_S_SHUTDOWN_ACK_SENT);
                    break;

                case SCTP_E_SHUTDOWN:
                    sendShutdownAck(remoteAddr);
                    break;

                default:
                    break;
            }
            break;

        case SCTP_S_SHUTDOWN_SENT:
            switch (event) {
                case SCTP_E_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_RCV_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_RCV_SHUTDOWN_ACK:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_RCV_SHUTDOWN:
                    sendShutdownAck(remoteAddr);
                    FSM_Goto((*fsm), SCTP_S_SHUTDOWN_ACK_SENT);
                    break;

                default:
                    break;
            }
            break;

        case SCTP_S_SHUTDOWN_ACK_SENT:
            switch (event) {
                case SCTP_E_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_RCV_ABORT:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                case SCTP_E_RCV_SHUTDOWN_COMPLETE:
                    FSM_Goto((*fsm), SCTP_S_CLOSED);
                    break;

                default:
                    break;
            }
            break;
    }

    if (oldState != fsm->getState()) {
        EV_DETAIL << "Transition: " << stateName(oldState) << " --> " << stateName(fsm->getState())
                  << "    (event was: " << eventName(event) << ")\n";
        EV_DETAIL << sctpMain->getName() << ": " << stateName(oldState) << " --> "
                  << stateName(fsm->getState()) << "  (on " << eventName(event) << ")\n";
        stateEntered(fsm->getState());
    }
    else {
        EV << "Staying in state: " << stateName(fsm->getState())
           << " (event was: " << eventName(event) << ")\n";
    }

    if (event == SCTP_E_ABORT && oldState == fsm->getState() && fsm->getState() == SCTP_S_CLOSED)
        return true;

    if (oldState != fsm->getState() && fsm->getState() == SCTP_S_CLOSED) {
        EV_DETAIL << "return false because oldState=" << oldState << " and new state is closed\n";
        return false;
    }
    else
        return true;
}

void inet::sctp::SCTPAssociation::pmClearPathCounter ( SCTPPathVariables *  path )

protected

Referenced by processHeartbeatAckArrived(), and processSackArrived().

{
    state->errorCount = 0;
    path->pathErrorCount = 0;
    if (path->activePath == false) {
        /* notify the application */
        pathStatusIndication(path, true);
        EV_INFO << "Path " << path->remoteAddress
                << " state changes from INACTIVE to ACTIVE !!!" << endl;
        path->activePath = true;    // Mark path as active!
    }
}

void inet::sctp::SCTPAssociation::pmDataIsSentOn ( SCTPPathVariables *  path )

protected

Referenced by sendOnPath().

{
    if ((!state->sendHeartbeatsOnActivePaths) || (!sctpMain->getEnableHeartbeats())) {
        /* restart hb_timer on this path */
        stopTimer(path->HeartbeatTimer);
        if (sctpMain->getEnableHeartbeats()) {
            path->heartbeatTimeout = path->pathRto + (double)sctpMain->getHbInterval();
            startTimer(path->HeartbeatTimer, path->heartbeatTimeout);
            EV_DETAIL << "Restarting HB timer on path " << path->remoteAddress
                      << " to expire at time " << path->heartbeatTimeout << endl;
        }
    }

    path->cwndTimeout = path->pathRto;
    stopTimer(path->CwndTimer);
    startTimer(path->CwndTimer, path->cwndTimeout);

    EV_INFO << "Restarting CWND timer on path " << path->remoteAddress
            << " to expire at time " << path->cwndTimeout << endl;
}

void inet::sctp::SCTPAssociation::pmRttMeasurement ( SCTPPathVariables *  path, const simtime_t &  rttEstimation  )

protected

Referenced by processHeartbeatAckArrived(), and processSackArrived().

{
    if (rttEstimation < SIMTIME_MAX) {
        if (simTime() > path->rttUpdateTime) {
            if (path->rttUpdateTime == SIMTIME_ZERO) {
                path->rttvar = rttEstimation.dbl() / 2;
                path->srtt = rttEstimation;
                path->pathRto = 3.0 * rttEstimation.dbl();
                path->pathRto = max(min(path->pathRto.dbl(), (double)sctpMain->getRtoMax()),
                            (double)sctpMain->getRtoMin());
            }
            else {
                path->rttvar = (1.0 - (double)sctpMain->par("rtoBeta")) * path->rttvar.dbl()
                    + (double)sctpMain->par("rtoBeta") * fabs(path->srtt.dbl() - rttEstimation.dbl());
                path->srtt = (1.0 - (double)sctpMain->par("rtoAlpha")) * path->srtt.dbl()
                    + (double)sctpMain->par("rtoAlpha") * rttEstimation.dbl();
                path->pathRto = path->srtt.dbl() + 4.0 * path->rttvar.dbl();
                path->pathRto = max(min(path->pathRto.dbl(), (double)sctpMain->getRtoMax()),
                            (double)sctpMain->getRtoMin());
            }
            // RFC 2960, sect. 6.3.1: new RTT measurements SHOULD be made no more
            //                                than once per round-trip.
            path->rttUpdateTime = simTime() + path->srtt;
            path->statisticsPathRTO->record(path->pathRto);
            path->statisticsPathRTT->record(rttEstimation);
        }
    }
}

void inet::sctp::SCTPAssociation::pmStartPathManagement ( )

protected

Flow control.

{
    SCTPPathVariables *path;
    const InterfaceEntry *rtie;
    int32 i = 0;
    /* populate path structures !!! */
    /* set a high start value...this is appropriately decreased later (below) */
    state->assocPmtu = state->localRwnd;
    for (auto & elem : sctpPathMap) {
        path = elem.second;
        path->pathErrorCount = 0;
        rtie = rt->getOutputInterfaceForDestination(path->remoteAddress);
        path->pmtu = rtie->getMTU();
        EV_DETAIL << "Path MTU of Interface " << i << " = " << path->pmtu << "\n";
        if (path->pmtu < state->assocPmtu) {
            state->assocPmtu = path->pmtu;
        }
        if (state->fragPoint > path->pmtu - IP_HEADER_LENGTH - SCTP_COMMON_HEADER - SCTP_DATA_CHUNK_LENGTH) {
            state->fragPoint = path->pmtu - IP_HEADER_LENGTH - SCTP_COMMON_HEADER - SCTP_DATA_CHUNK_LENGTH;
        }
        initCCParameters(path);
        path->pathRto = (double)sctpMain->getRtoInitial();
        path->srtt = path->pathRto;
        path->rttvar = SIMTIME_ZERO;
        /* from now on we may have one update per RTO/SRTT */
        path->rttUpdateTime = SIMTIME_ZERO;

        path->partialBytesAcked = 0;
        path->outstandingBytes = 0;
        path->activePath = true;
        // Timer probably not running, but stop it anyway I.R.
        stopTimer(path->T3_RtxTimer);

        if (path->remoteAddress == state->initialPrimaryPath && !path->confirmed) {
            path->confirmed = true;
        }
        EV_DETAIL << getFullPath() << " numberOfLocalAddresses=" << state->localAddresses.size() << "\n";
        if (sctpMain->getEnableHeartbeats()) {
            path->heartbeatTimeout = (double)sctpMain->getHbInterval() + i * path->pathRto;
            stopTimer(path->HeartbeatTimer);
            if (!path->confirmed)
                sendHeartbeat(path);
            startTimer(path->HeartbeatTimer, path->heartbeatTimeout);
            startTimer(path->HeartbeatIntervalTimer, path->heartbeatIntervalTimeout);
        }
        path->statisticsPathRTO->record(path->pathRto);
        i++;
    }
}

SCTPEventCode inet::sctp::SCTPAssociation::preanalyseAppCommandEvent ( int32  commandCode )

protected

Maps app command codes (msg kind of app command msgs) to SCTP_E_xxx event codes.

{
    switch (commandCode) {
        case SCTP_C_ASSOCIATE:
            return SCTP_E_ASSOCIATE;

        case SCTP_C_OPEN_PASSIVE:
            return SCTP_E_OPEN_PASSIVE;

        case SCTP_C_SEND:
            return SCTP_E_SEND;

        case SCTP_C_CLOSE:
            return SCTP_E_CLOSE;

        case SCTP_C_ABORT:
            return SCTP_E_ABORT;

        case SCTP_C_RECEIVE:
            return SCTP_E_RECEIVE;

        case SCTP_C_SEND_UNORDERED:
            return SCTP_E_SEND;

        case SCTP_C_SEND_ORDERED:
            return SCTP_E_SEND;

        case SCTP_C_PRIMARY:
            return SCTP_E_PRIMARY;

        case SCTP_C_QUEUE_MSGS_LIMIT:
            return SCTP_E_QUEUE_MSGS_LIMIT;

        case SCTP_C_QUEUE_BYTES_LIMIT:
            return SCTP_E_QUEUE_BYTES_LIMIT;

        case SCTP_C_SHUTDOWN:
            return SCTP_E_SHUTDOWN;

        case SCTP_C_NO_OUTSTANDING:
            return SCTP_E_SEND_SHUTDOWN_ACK;

        case SCTP_C_STREAM_RESET:
            return SCTP_E_STREAM_RESET;

        case SCTP_C_RESET_ASSOC:
            return SCTP_E_RESET_ASSOC;

        case SCTP_C_ADD_STREAMS:
            return SCTP_E_ADD_STREAMS;

        case SCTP_C_SEND_ASCONF:
            return SCTP_E_SEND_ASCONF;    // Needed for multihomed NAT

        case SCTP_C_SET_STREAM_PRIO:
            return SCTP_E_SET_STREAM_PRIO;

        case SCTP_C_ACCEPT:
            return SCTP_E_ACCEPT;

        case SCTP_C_SET_RTO_INFO:
            return SCTP_E_SET_RTO_INFO;

        default:
            EV_DETAIL << "commandCode=" << commandCode << "\n";
            throw cRuntimeError("Unknown message kind in app command");
    }
}

void inet::sctp::SCTPAssociation::printAssocBrief ( )

protected

Utility: prints local/remote addr/port and app gate index/assocId.

{
    EV_DETAIL << "Connection " << this << " "
              << localAddr << ":" << localPort << " to " << remoteAddr << ":" << remotePort
              << "  on app[" << appGateIndex << "],assocId=" << assocId
              << "  in " << stateName(fsm->getState()) << "\n";
}

void inet::sctp::SCTPAssociation::printOutstandingTsns ( )

protected

void inet::sctp::SCTPAssociation::printSctpPathMap

(

)

const

Referenced by processInitAckArrived(), processInitArrived(), sendInit(), and sendInitAck().

{
    EV_DEBUG << "SCTP PathMap:" << endl;
    for (const auto & elem : sctpPathMap) {
        const SCTPPathVariables *path = elem.second;
        EV_DEBUG << " - " << path->remoteAddress << ":  osb=" << path->outstandingBytes
                 << " cwnd=" << path->cwnd << endl;
    }
}

void inet::sctp::SCTPAssociation::printSegmentBrief ( SCTPMessage *  sctpmsg )

staticprotected

Utility: prints important header fields.

{
    EV_STATICCONTEXT;

    EV_DETAIL << "." << sctpmsg->getSrcPort() << " > "
              << "." << sctpmsg->getDestPort() << ": "
              << "initTag " << sctpmsg->getTag() << "\n";
}

void inet::sctp::SCTPAssociation::process_ABORT ( SCTPEventCode &  event )

protected

{
    EV_DEBUG << "SCTPAssociationEventProc:process_ABORT; assoc=" << assocId << endl;
    switch (fsm->getState()) {
        case SCTP_S_ESTABLISHED:
            sendOnAllPaths(state->getPrimaryPath());
            sendAbort();
            break;
    }
}

void inet::sctp::SCTPAssociation::process_ASSOCIATE ( SCTPEventCode &  event, SCTPCommand *  sctpCommand, cMessage *  msg  )

protected

{
    L3Address lAddr, rAddr;

    SCTPOpenCommand *openCmd = check_and_cast<SCTPOpenCommand *>(sctpCommand);

    EV_INFO << "SCTPAssociationEventProc:process_ASSOCIATE\n";

    switch (fsm->getState()) {
        case SCTP_S_CLOSED:
            if (msg->getContextPointer() != NULL) {
                sctpMain->setSocketOptions((SocketOptions*) (msg->getContextPointer()));
            }
            initAssociation(openCmd);
            state->active = true;
            localAddressList = openCmd->getLocalAddresses();
            lAddr = openCmd->getLocalAddresses().front();
            if (!(openCmd->getRemoteAddresses().empty())) {
                remoteAddressList = openCmd->getRemoteAddresses();
                rAddr = openCmd->getRemoteAddresses().front();
            }
            else
                rAddr = openCmd->getRemoteAddr();
            localPort = openCmd->getLocalPort();
            remotePort = openCmd->getRemotePort();
            EV_DETAIL << "open active with fd=" << fd << " and assocId=" << assocId << endl;
            fd = openCmd->getFd();
            state->streamReset = openCmd->getStreamReset();
            state->prMethod = openCmd->getPrMethod();
            state->numRequests = openCmd->getNumRequests();
            state->appLimited = openCmd->getAppLimited();
            if (rAddr.isUnspecified() || remotePort == 0)
                throw cRuntimeError("Error processing command OPEN_ACTIVE: remote address and port must be specified");

            if (localPort == 0) {
                localPort = sctpMain->getEphemeralPort();
            }
            EV_INFO << "OPEN: " << lAddr << ":" << localPort << " --> " << rAddr << ":" << remotePort << "\n";

            sctpMain->updateSockPair(this, lAddr, rAddr, localPort, remotePort);
            state->localRwnd = (long)sctpMain->par("arwnd");
            sendInit();
            startTimer(T1_InitTimer, state->initRexmitTimeout);
            break;

        default:
            throw cRuntimeError("Error processing command OPEN_ACTIVE: connection already exists");
    }
}

void inet::sctp::SCTPAssociation::process_CLOSE ( SCTPEventCode &  event )

protected

{
    EV_DEBUG << "SCTPAssociationEventProc:process_CLOSE; assoc=" << assocId << endl;
    switch (fsm->getState()) {
        case SCTP_S_ESTABLISHED:
            sendOnAllPaths(state->getPrimaryPath());
            sendShutdown();
            break;

        case SCTP_S_SHUTDOWN_RECEIVED:
            if (getOutstandingBytes() == 0) {
                sendShutdownAck(remoteAddr);
            }
            break;
    }
}

void inet::sctp::SCTPAssociation::process_OPEN_PASSIVE ( SCTPEventCode &  event, SCTPCommand *  sctpCommand, cMessage *  msg  )

protected

{
    L3Address lAddr;
    int16 localPort;

    SCTPOpenCommand *openCmd = check_and_cast<SCTPOpenCommand *>(sctpCommand);

    EV_DEBUG << "SCTPAssociationEventProc:process_OPEN_PASSIVE\n";

    switch (fsm->getState()) {
        case SCTP_S_CLOSED:
            if (msg->getContextPointer() != NULL)
                sctpMain->setSocketOptions((SocketOptions*) (msg->getContextPointer()));
            initAssociation(openCmd);
            state->fork = openCmd->getFork();
            localAddressList = openCmd->getLocalAddresses();
            EV_DEBUG << "process_OPEN_PASSIVE: number of local addresses=" << localAddressList.size() << "\n";
            lAddr = openCmd->getLocalAddresses().front();
            localPort = openCmd->getLocalPort();
            inboundStreams = openCmd->getInboundStreams();
            outboundStreams = openCmd->getOutboundStreams();
            listening = true;
            fd = openCmd->getFd();
            EV_DETAIL << "open listening socket with fd=" << fd << " and assocId=" << assocId << endl;
            state->localRwnd = (long)sctpMain->par("arwnd");
            state->localMsgRwnd = sctpMain->par("messageAcceptLimit");
            state->streamReset = openCmd->getStreamReset();
            state->numRequests = openCmd->getNumRequests();
            state->messagesToPush = openCmd->getMessagesToPush();

            if (localPort == 0)
                throw cRuntimeError("Error processing command OPEN_PASSIVE: local port must be specified");

            EV_DEBUG << "Assoc " << assocId << "::Starting to listen on: " << lAddr << ":" << localPort << "\n";

            sctpMain->updateSockPair(this, lAddr, L3Address(), localPort, 0);
            break;

        default:
            throw cRuntimeError("Error processing command OPEN_PASSIVE: connection already exists");
    }
}

void inet::sctp::SCTPAssociation::process_PRIMARY ( SCTPEventCode &  event, SCTPCommand *  sctpCommand  )

protected

{
    SCTPPathInfo *pinfo = check_and_cast<SCTPPathInfo *>(sctpCommand);
    state->setPrimaryPath(getPath(pinfo->getRemoteAddress()));
}

void inet::sctp::SCTPAssociation::process_QUEUE_BYTES_LIMIT ( const SCTPCommand *  sctpCommand )

protected

{
    const SCTPInfo *qinfo = check_and_cast<const SCTPInfo *>(sctpCommand);
    state->sendQueueLimit = qinfo->getText();
}

void inet::sctp::SCTPAssociation::process_QUEUE_MSGS_LIMIT ( const SCTPCommand *  sctpCommand )

protected

Queue Management.

{
    const SCTPInfo *qinfo = check_and_cast<const SCTPInfo *>(sctpCommand);
    state->queueLimit = qinfo->getText();
    EV_DEBUG << "state->queueLimit set to " << state->queueLimit << "\n";
}

bool inet::sctp::SCTPAssociation::process_RCV_Message ( SCTPMessage *  sctpseg, const L3Address &  src, const L3Address &  dest  )

protected

{
    // ====== Header checks ==================================================
    EV_DEBUG << getFullPath() << " SCTPAssociationRcvMessage:process_RCV_Message"
             << " localAddr=" << localAddr
             << " remoteAddr=" << remoteAddr << endl;
    state->pktDropSent = false;
    if ((sctpmsg->hasBitError() || !sctpmsg->getChecksumOk())) {
        if (((SCTPChunk *)(sctpmsg->getChunks(0)))->getChunkType() == INIT_ACK) {
            stopTimer(T1_InitTimer);
            EV_WARN << "InitAck with bit-error. Retransmit Init" << endl;
            retransmitInit();
            startTimer(T1_InitTimer, state->initRexmitTimeout);
        }
        if (((SCTPChunk *)(sctpmsg->getChunks(0)))->getChunkType() == COOKIE_ACK) {
            stopTimer(T1_InitTimer);
            EV_WARN << "CookieAck with bit-error. Retransmit CookieEcho" << endl;
            retransmitCookieEcho();
            startTimer(T1_InitTimer, state->initRexmitTimeout);
        }
        if (!(sctpMain->pktdrop) || !state->peerPktDrop) {
            EV_WARN << "Packet has bit-error. Return\n";
            return true;
        }
    }

    SCTPPathVariables *path = getPath(src);
    const uint16 srcPort = sctpmsg->getDestPort();
    const uint16 destPort = sctpmsg->getSrcPort();
    const uint32 numberOfChunks = sctpmsg->getChunksArraySize();
    EV_DETAIL << "numberOfChunks=" << numberOfChunks << endl;

    state->sctpmsg = sctpmsg->dup();
    bool authenticationNecessary = state->peerAuth;
    state->sackAlreadySent = false;
    if ((sctpmsg->getChecksumOk() == false || sctpmsg->hasBitError()) &&
        (sctpMain->pktdrop) &&
        (state->peerPktDrop))
    {
        sendPacketDrop(true);
        return true;
    }

    if (fsm->getState() != SCTP_S_CLOSED &&
        fsm->getState() != SCTP_S_COOKIE_WAIT &&
        fsm->getState() != SCTP_S_COOKIE_ECHOED &&
        fsm->getState() != SCTP_S_SHUTDOWN_ACK_SENT &&
        simTime() > state->lastAssocThroughputTime + state->throughputInterval &&
        assocThroughputVector != nullptr)
    {
        assocThroughputVector->record(state->assocThroughput / (simTime() - state->lastAssocThroughputTime) / 1000);
        state->lastAssocThroughputTime = simTime();
        state->assocThroughput = 0;
    }
    state->assocThroughput += sctpmsg->getByteLength();

    // ====== Handle chunks ==================================================
    bool trans = true;
    bool sendAllowed = false;
    bool dupReceived = false;
    bool dataChunkReceived = false;
    bool shutdownCalled = false;
    bool sackWasReceived = false;
    for (uint32 i = 0; i < numberOfChunks; i++) {
        SCTPChunk *header = (SCTPChunk *)(sctpmsg->removeChunk());
        const uint8 type = header->getChunkType();

        if ((type != INIT) &&
            (type != ABORT) &&
            (type != ERRORTYPE) &&
            (sctpmsg->getTag() != peerVTag))
        {
            EV_WARN << " VTag " << sctpmsg->getTag() << " incorrect. Should be "
                    << peerVTag << " localVTag=" << localVTag << endl;
            return true;
        }

        if (authenticationNecessary) {
            if (type == AUTH) {
                EV_INFO << "AUTH received" << endl;
                SCTPAuthenticationChunk *authChunk;
                authChunk = check_and_cast<SCTPAuthenticationChunk *>(header);
                if (authChunk->getHMacIdentifier() != 1) {
                    sendHMacError(authChunk->getHMacIdentifier());
                    auto it = sctpMain->assocStatMap.find(assocId);
                    it->second.numAuthChunksRejected++;
                    delete authChunk;
                    return true;
                }
                if (authChunk->getHMacOk() == false) {
                    delete authChunk;
                    auto it = sctpMain->assocStatMap.find(assocId);
                    it->second.numAuthChunksRejected++;
                    return true;
                }
                authenticationNecessary = false;
                auto it = sctpMain->assocStatMap.find(assocId);
                it->second.numAuthChunksAccepted++;
                delete authChunk;
                continue;
            }
            else {
                if (typeInChunkList(type)) {
                    return true;
                }
            }
        }

        switch (type) {
            case INIT:
                EV_INFO << "INIT received" << endl;
                SCTPInitChunk *initChunk;
                initChunk = check_and_cast<SCTPInitChunk *>(header);
                if ((initChunk->getNoInStreams() != 0) &&
                    (initChunk->getNoOutStreams() != 0) &&
                    (initChunk->getInitTag() != 0))
                {
                    trans = processInitArrived(initChunk, srcPort, destPort);
                }
                i = numberOfChunks - 1;
                delete initChunk;
                break;

            case INIT_ACK:
                EV_INFO << "INIT_ACK received" << endl;
                if (fsm->getState() == SCTP_S_COOKIE_WAIT) {
                    SCTPInitAckChunk *initAckChunk;
                    initAckChunk = check_and_cast<SCTPInitAckChunk *>(header);
                    if ((initAckChunk->getNoInStreams() != 0) &&
                        (initAckChunk->getNoOutStreams() != 0) &&
                        (initAckChunk->getInitTag() != 0))
                    {
                        trans = processInitAckArrived(initAckChunk);
                    }
                    else if (initAckChunk->getInitTag() == 0) {
                        sendAbort();
                        sctpMain->removeAssociation(this);
                        return true;
                    }
                    i = numberOfChunks - 1;
                    delete initAckChunk;
                }
                else {
                    EV_INFO << "INIT_ACK will be ignored" << endl;
                }
                break;

            case COOKIE_ECHO:
                EV_INFO << "COOKIE_ECHO received" << endl;
                SCTPCookieEchoChunk *cookieEchoChunk;
                cookieEchoChunk = check_and_cast<SCTPCookieEchoChunk *>(header);
                trans = processCookieEchoArrived(cookieEchoChunk, src);
                delete cookieEchoChunk;
                break;

            case COOKIE_ACK:
                EV_INFO << "COOKIE_ACK received" << endl;
                if (fsm->getState() == SCTP_S_COOKIE_ECHOED) {
                    SCTPCookieAckChunk *cookieAckChunk;
                    cookieAckChunk = check_and_cast<SCTPCookieAckChunk *>(header);
                    trans = processCookieAckArrived();
                    delete cookieAckChunk;
                }
                break;

            case DATA:
                EV_INFO << "DATA received" << endl;
                if (fsm->getState() == SCTP_S_CLOSED) {
                    sendAbort(1);
                    sctpMain->removeAssociation(this);
                    return true;
                }
                if (fsm->getState() == SCTP_S_COOKIE_ECHOED) {
                    trans = performStateTransition(SCTP_E_RCV_COOKIE_ACK);
                }
                if (state->stopReading) {
                    if (state->shutdownChunk) {
                        delete state->shutdownChunk;
                        state->shutdownChunk = nullptr;
                    }
                    delete header;
                    sendAbort();
                    if (state->sctpmsg) {
                        delete state->sctpmsg;
                        state->sctpmsg = nullptr;
                    }
                    sctpMain->removeAssociation(this);
                    return true;
                }
                if (!(fsm->getState() == SCTP_S_SHUTDOWN_RECEIVED || fsm->getState() == SCTP_S_SHUTDOWN_ACK_SENT)) {
                    SCTPDataChunk *dataChunk;
                    dataChunk = check_and_cast<SCTPDataChunk *>(header);
                    if ((dataChunk->getByteLength() - SCTP_DATA_CHUNK_LENGTH) > 0) {
                        dacPacketsRcvd++;
                        const SCTPEventCode event = processDataArrived(dataChunk);
                        if (event == SCTP_E_DELIVERED) {
                            if ((state->streamReset) && (state->incomingRequest != nullptr || state->resetRequested) &&
                                ((state->lastTsnBeforeReset == state->gapList.getHighestTSNReceived()) ||
                                ((state->lastTsnBeforeReset == state->lastTsnReceived))))
                            {
                                resetExpectedSsns();
                                if (state->inOut) {
                                    sendOutgoingRequestAndResponse(state->inRequestSn, state->peerRequestSn);
                                }
                                else {
                                    sendStreamResetResponse(state->peerRequestSn, PERFORMED);
                                }
                            }
                            dataChunkReceived = true;
                            state->sackAllowed = true;
                        } else if (event == SCTP_E_SEND) {
                            dataChunkReceived = true;
                            state->sackAllowed = true;
                        } else if (event == SCTP_E_DUP_RECEIVED) {
                            dupReceived = true;
                        } else if (event == SCTP_E_ABORT) {
                            sendAbort();
                            sctpMain->removeAssociation(this);
                            return true;
                        } else {
                            dataChunkReceived = false;
                            state->sackAllowed = false;
                        }
                    } else {
                        sendAbort();
                        sctpMain->removeAssociation(this);
                        return true;
                    }
                    delete dataChunk;
                }
                trans = true;
                break;

            case SACK:
            case NR_SACK: {
                EV_INFO << "SACK received" << endl;
                const int32 scount = qCounter.roomSumSendStreams;
                SCTPSackChunk *sackChunk;
                sackChunk = check_and_cast<SCTPSackChunk *>(header);
                processSackArrived(sackChunk);
                trans = true;
                sendAllowed = true;
                delete sackChunk;
                if (getOutstandingBytes() == 0 && transmissionQ->getQueueSize() == 0 && scount == 0) {
                    if (fsm->getState() == SCTP_S_SHUTDOWN_PENDING) {
                        EV_DETAIL << "No more packets: send SHUTDOWN" << endl;
                        sendShutdown();
                        trans = performStateTransition(SCTP_E_NO_MORE_OUTSTANDING);
                        shutdownCalled = true;
                    }
                    else if (fsm->getState() == SCTP_S_SHUTDOWN_RECEIVED) {
                        EV_DETAIL << "No more outstanding" << endl;
                        sendShutdownAck(remoteAddr);
                    }
                }
                sackWasReceived = true;
                break;
            }

            case ABORT:
                SCTPAbortChunk *abortChunk;
                abortChunk = check_and_cast<SCTPAbortChunk *>(header);
                EV_INFO << "ABORT with T-Bit "
                        << abortChunk->getT_Bit() << " received" << endl;
                if (sctpmsg->getTag() == localVTag || sctpmsg->getTag() == peerVTag) {
                    sendIndicationToApp(SCTP_I_ABORT);
                    trans = performStateTransition(SCTP_E_ABORT);
                }
                delete abortChunk;
                break;

            case HEARTBEAT:
                EV_INFO << "HEARTBEAT received" << endl;
                SCTPHeartbeatChunk *heartbeatChunk;
                heartbeatChunk = check_and_cast<SCTPHeartbeatChunk *>(header);
                if (!(fsm->getState() == SCTP_S_CLOSED)) {
                    sendHeartbeatAck(heartbeatChunk, dest, src);
                }
                trans = true;
                delete heartbeatChunk;
                if (path) {
                    path->numberOfHeartbeatsRcvd++;
                    path->vectorPathRcvdHb->record(path->numberOfHeartbeatsRcvd);
                }
                break;

            case HEARTBEAT_ACK:
                EV_INFO << "HEARTBEAT_ACK received" << endl;
                if (fsm->getState() == SCTP_S_COOKIE_ECHOED) {
                    trans = performStateTransition(SCTP_E_RCV_COOKIE_ACK);
                }
                SCTPHeartbeatAckChunk *heartbeatAckChunk;
                heartbeatAckChunk = check_and_cast<SCTPHeartbeatAckChunk *>(header);
                if (path) {
                    processHeartbeatAckArrived(heartbeatAckChunk, path);
                }
                trans = true;
                delete heartbeatAckChunk;
                break;

            case SHUTDOWN:
                EV_INFO << "SHUTDOWN received" << endl;
                SCTPShutdownChunk *shutdownChunk;
                shutdownChunk = check_and_cast<SCTPShutdownChunk *>(header);
                if (shutdownChunk->getCumTsnAck() > state->lastTsnAck) {
                    simtime_t rttEstimation = SIMTIME_MAX;
                    dequeueAckedChunks(shutdownChunk->getCumTsnAck(),
                            getPath(remoteAddr), rttEstimation);
                    state->lastTsnAck = shutdownChunk->getCumTsnAck();
                }
                trans = performStateTransition(SCTP_E_RCV_SHUTDOWN);
                sendIndicationToApp(SCTP_I_SHUTDOWN_RECEIVED);
                trans = true;
                delete shutdownChunk;
                if (state->resetChunk != nullptr) {
                    delete state->resetChunk;
                }
                break;

            case SHUTDOWN_ACK:
                EV_INFO << "SHUTDOWN_ACK received" << endl;
                if (fsm->getState() != SCTP_S_ESTABLISHED) {
                    SCTPShutdownAckChunk *shutdownAckChunk;
                    shutdownAckChunk = check_and_cast<SCTPShutdownAckChunk *>(header);
                    sendShutdownComplete();
                    stopTimers();
                    stopTimer(T2_ShutdownTimer);
                    stopTimer(T5_ShutdownGuardTimer);
                    EV_DETAIL << "state=" << stateName(fsm->getState()) << endl;
                    if ((fsm->getState() == SCTP_S_SHUTDOWN_SENT) ||
                        (fsm->getState() == SCTP_S_SHUTDOWN_ACK_SENT))
                    {
                        trans = performStateTransition(SCTP_E_RCV_SHUTDOWN_ACK);
                        sendIndicationToApp(SCTP_I_CLOSED);
                        if (state->shutdownChunk) {
                            delete state->shutdownChunk;
                            state->shutdownChunk = nullptr;
                        }
                    }
                    delete shutdownAckChunk;
                    if (state->resetChunk != nullptr) {
                        delete state->resetChunk;
                    }
                }
                break;

            case SHUTDOWN_COMPLETE:
                EV_INFO << "Shutdown Complete arrived" << endl;
                SCTPShutdownCompleteChunk *shutdownCompleteChunk;
                shutdownCompleteChunk = check_and_cast<SCTPShutdownCompleteChunk *>(header);
                trans = performStateTransition(SCTP_E_RCV_SHUTDOWN_COMPLETE);
                sendIndicationToApp(SCTP_I_PEER_CLOSED);    // necessary for NAT-Rendezvous
                if (trans == true) {
                    stopTimers();
                }
                stopTimer(T2_ShutdownTimer);
                stopTimer(T5_ShutdownGuardTimer);
                delete state->shutdownAckChunk;
                delete shutdownCompleteChunk;
                break;

            case FORWARD_TSN:
                EV_INFO << "FORWARD_TSN received" << endl;
                SCTPForwardTsnChunk *forwChunk;
                forwChunk = check_and_cast<SCTPForwardTsnChunk *>(header);
                processForwardTsnArrived(forwChunk);
                trans = true;
                sendAllowed = true;
                dataChunkReceived = true;
                delete forwChunk;
                break;

            case RE_CONFIG:
                EV_INFO << "StreamReset received" << endl;
                if (fsm->getState() != SCTP_S_ESTABLISHED) {
                    delete header;
                    break;
                }
                SCTPStreamResetChunk *strResChunk;
                strResChunk = check_and_cast<SCTPStreamResetChunk *>(header);
                processStreamResetArrived(strResChunk);
                trans = true;
                sendAllowed = true;
                delete strResChunk;
                break;

            case ASCONF:
                EV_INFO << "ASCONF received" << endl;
                if (fsm->getState() == SCTP_S_COOKIE_ECHOED) {
                    trans = performStateTransition(SCTP_E_RCV_COOKIE_ACK);
                }
                SCTPAsconfChunk *asconfChunk;
                asconfChunk = check_and_cast<SCTPAsconfChunk *>(header);
                processAsconfArrived(asconfChunk);
                trans = true;
                delete asconfChunk;
                break;

            case ASCONF_ACK:
                EV_INFO << "ASCONF_ACK received" << endl;
                SCTPAsconfAckChunk *asconfAckChunk;
                asconfAckChunk = check_and_cast<SCTPAsconfAckChunk *>(header);
                processAsconfAckArrived(asconfAckChunk);
                trans = true;
                delete state->asconfChunk;
                delete asconfAckChunk;
                break;

            case PKTDROP:
                EV_INFO << "PKTDROP received" << endl;
                if (sctpMain->pktdrop) {
                    SCTPPacketDropChunk *packetDropChunk;
                    packetDropChunk = check_and_cast<SCTPPacketDropChunk *>(header);
                    if (packetDropChunk->getBFlag() && !packetDropChunk->getMFlag())
                        processPacketDropArrived(packetDropChunk);

                    trans = true;
                    sendAllowed = true;
                    delete packetDropChunk;
                }
                break;

            case ERRORTYPE:
                EV_INFO << "ERROR received" << endl;
                SCTPErrorChunk *errorChunk;
                errorChunk = check_and_cast<SCTPErrorChunk *>(header);
                processErrorArrived(errorChunk);
                trans = true;
                delete errorChunk;
                break;

            default:
                EV_ERROR << "different type" << endl;    // TODO
                break;
        }

        if (i == numberOfChunks - 1 && ((dataChunkReceived && !state->sackAlreadySent) || dupReceived)) {
            sendAllowed = true;
            EV_DEBUG << "i=" << i << " sendAllowed=true; scheduleSack" << endl;
            scheduleSack();
            if (fsm->getState() == SCTP_S_SHUTDOWN_SENT && state->ackState >= sackFrequency) {
                sendSack();
            }
        }

        // Send any new DATA chunks, SACK chunks, HEARTBEAT chunks etc.
        EV_DETAIL << "SCTPAssociationRcvMessage: send new data? state=" << stateName(fsm->getState())
                  << " sendAllowed=" << sendAllowed
                  << " shutdownCalled=" << shutdownCalled << endl;
        if (((fsm->getState() == SCTP_S_ESTABLISHED) ||
             (fsm->getState() == SCTP_S_SHUTDOWN_PENDING) ||
             (fsm->getState() == SCTP_S_SHUTDOWN_RECEIVED)) &&
            (sendAllowed) &&
            (!shutdownCalled))
        {
            sendOnAllPaths(state->getPrimaryPath());
        }
    }
    if (state->sendResponse > 0) {
        if (state->sendResponse == PERFORMED_WITH_OPTION) {
            resetExpectedSsns();
            if (state->incomingRequest != nullptr)
                sendStreamResetResponse((SCTPSSNTSNResetRequestParameter *)state->incomingRequest, PERFORMED, true);
        } else if (state->sendResponse == PERFORMED_WITH_ADDOUT) {
            sendAddOutgoingStreamsRequest(((SCTPAddStreamsRequestParameter *)state->incomingRequest)->getNumberOfStreams());
            state->numResetRequests++;
            sendStreamResetResponse(((SCTPAddStreamsRequestParameter *)state->incomingRequest)->getSrReqSn(), PERFORMED);
        } else {
            sendStreamResetResponse(state->responseSn, state->sendResponse);
        }
        state->sendResponse = 0;
        state->responseSn = 0;
    }
    if (sackWasReceived) {
        checkStreamsToReset();
        sackWasReceived = false;
    }

    // ====== Clean-up =======================================================
    if (!state->pktDropSent) {
        disposeOf(state->sctpmsg);
        EV_DEBUG << "state->sctpmsg was disposed" << endl;
    }
    return trans;
}

void inet::sctp::SCTPAssociation::process_RECEIVE_REQUEST ( SCTPEventCode &  event, SCTPCommand *  sctpCommand  )

protected

{
    SCTPSendInfo *sendCommand = check_and_cast<SCTPSendInfo *>(sctpCommand);
    if ((uint32)sendCommand->getSid() > inboundStreams || sendCommand->getSid() < 0) {
        EV_DEBUG << "Application tries to read from invalid stream id....\n";
    }
    state->numMsgsReq[sendCommand->getSid()] += sendCommand->getNumMsgs();
    pushUlp();
}

void inet::sctp::SCTPAssociation::process_SEND ( SCTPEventCode &  event, SCTPCommand *  sctpCommand, cMessage *  msg  )

protected

{
    SCTPSendInfo *sendCommand = check_and_cast<SCTPSendInfo *>(sctpCommand);

    if (fsm->getState() != SCTP_S_ESTABLISHED) {
        // TD 12.03.2009: since SCTP_S_ESTABLISHED is the only case, the
        // switch(...)-block has been removed for enhanced readability.
        EV_DEBUG << "process_SEND: state is not SCTP_S_ESTABLISHED -> returning" << endl;
        return;
    }

    EV_DEBUG << "process_SEND:"
             << " assocId=" << assocId
             << " localAddr=" << localAddr
             << " remoteAddr=" << remoteAddr
             << " cmdRemoteAddr=" << sendCommand->getRemoteAddr()
             << " cmdPrimary=" << (sendCommand->getPrimary() ? "true" : "false")
             << " appGateIndex=" << appGateIndex
             << " streamId=" << sendCommand->getSid() << endl;

    SCTPSimpleMessage *smsg = check_and_cast<SCTPSimpleMessage *>((PK(msg)->decapsulate()));
    auto iter = sctpMain->assocStatMap.find(assocId);
    iter->second.sentBytes += smsg->getByteLength();

    // ------ Prepare SCTPDataMsg -----------------------------------------
    const uint32 streamId = sendCommand->getSid();
    const uint32 sendUnordered = sendCommand->getSendUnordered();
    const uint32 ppid = sendCommand->getPpid();
    SCTPSendStream *stream = nullptr;
    auto associter = sendStreams.find(streamId);
    if (associter != sendStreams.end()) {
        stream = associter->second;
    }
    else {
        throw cRuntimeError("Stream with id %d not found", streamId);
    }

    char name[64];
    snprintf(name, sizeof(name), "SDATA-%d-%d", streamId, state->msgNum);
    smsg->setName(name);

    SCTPDataMsg *datMsg = new SCTPDataMsg();
    datMsg->encapsulate(smsg);
    datMsg->setSid(streamId);
    datMsg->setPpid(ppid);
    datMsg->setEnqueuingTime(simTime());
    datMsg->setSackNow(sendCommand->getSackNow());

    // ------ PR-SCTP & Drop messages to free buffer space ----------------
    datMsg->setPrMethod(sendCommand->getPrMethod());
    switch (sendCommand->getPrMethod()) {
        case PR_TTL:
            if (sendCommand->getPrValue() > 0) {
                datMsg->setExpiryTime(simTime() + sendCommand->getPrValue());
            }
            break;

        case PR_RTX:
            datMsg->setRtx((uint32)sendCommand->getPrValue());
            break;

        case PR_PRIO:
            datMsg->setPriority((uint32)sendCommand->getPrValue());
            state->queuedDroppableBytes += PK(msg)->getByteLength();
            break;
    }

    if ((state->appSendAllowed) &&
        (state->sendQueueLimit > 0) &&
        (state->queuedDroppableBytes > 0) &&
        ((uint64)state->sendBuffer >= state->sendQueueLimit))
    {
        uint32 lowestPriority;
        cQueue *strq;
        int64 dropsize = state->sendBuffer - state->sendQueueLimit;

        if (sendUnordered)
            strq = stream->getUnorderedStreamQ();
        else
            strq = stream->getStreamQ();

        while (dropsize >= 0 && state->queuedDroppableBytes > 0) {
            lowestPriority = 0;

            // Find lowest priority
            for (cQueue::Iterator iter(*strq); !iter.end(); iter++) {
                SCTPDataMsg *msg = (SCTPDataMsg *)(*iter);

                if (msg->getPriority() > lowestPriority)
                    lowestPriority = msg->getPriority();
            }

            // If just passed message has the lowest priority,
            // drop it and we're done.
            if (datMsg->getPriority() > lowestPriority) {
                EV_DEBUG << "msg will be abandoned, buffer is full and priority too low ("
                         << datMsg->getPriority() << ")\n";
                state->queuedDroppableBytes -= PK(msg)->getByteLength();
                delete smsg;
                delete msg;
                sendIndicationToApp(SCTP_I_ABANDONED);
                return;
            }
        }
    }

    // ------ Set initial destination address -----------------------------
    if (sendCommand->getPrimary()) {
        if (sendCommand->getRemoteAddr().isUnspecified()) {
            datMsg->setInitialDestination(remoteAddr);
        }
        else {
            datMsg->setInitialDestination(sendCommand->getRemoteAddr());
        }
    }
    else {
        datMsg->setInitialDestination(state->getPrimaryPathIndex());
    }

    // ------ Optional padding and size calculations ----------------------
    if (state->padding) {
        datMsg->setBooksize(ADD_PADDING(smsg->getByteLength() + state->header));
    }
    else {
        datMsg->setBooksize(smsg->getByteLength() + state->header);
    }

    qCounter.roomSumSendStreams += ADD_PADDING(smsg->getByteLength() + SCTP_DATA_CHUNK_LENGTH);
    qCounter.bookedSumSendStreams += datMsg->getBooksize();
    // Add chunk size to sender buffer size
    state->sendBuffer += smsg->getByteLength();

    datMsg->setMsgNum(++state->msgNum);

    // ------ Ordered/Unordered modes -------------------------------------
    if (sendUnordered == 1) {
        datMsg->setOrdered(false);
        stream->getUnorderedStreamQ()->insert(datMsg);
    }
    else {
        datMsg->setOrdered(true);
        stream->getStreamQ()->insert(datMsg);

        sendQueue->record(stream->getStreamQ()->getLength());
    }

    // ------ Send buffer full? -------------------------------------------
    if ((state->appSendAllowed) &&
        (state->sendQueueLimit > 0) &&
        ((uint64)state->sendBuffer >= state->sendQueueLimit)) {
        // If there are not enough messages that could be dropped,
        // the buffer is really full and the app has to be notified.
        if (state->queuedDroppableBytes < state->sendBuffer - state->sendQueueLimit) {
            sendIndicationToApp(SCTP_I_SENDQUEUE_FULL);
            state->appSendAllowed = false;
        }
    }

    state->queuedMessages++;
    if ((state->queueLimit > 0) && (state->queuedMessages > state->queueLimit)) {
        state->queueUpdate = false;
    }
    EV_DEBUG << "process_SEND:"
             << " last=" << sendCommand->getLast()
             << "    queueLimit=" << state->queueLimit << endl;

    // ------ Call sendCommandInvoked() to send message -------------------
    // sendCommandInvoked() itself will call sendOnAllPaths() ...
    if (sendCommand->getLast() == true) {
        if (sendCommand->getPrimary()) {
            sctpAlgorithm->sendCommandInvoked(nullptr);
        }
        else {
            sctpAlgorithm->sendCommandInvoked(getPath(datMsg->getInitialDestination()));
        }
    }
}

void inet::sctp::SCTPAssociation::process_STATUS ( SCTPEventCode &  event, SCTPCommand *  sctpCommand, cMessage *  msg  )

protected

{
    SCTPStatusInfo *statusInfo = new SCTPStatusInfo();
    statusInfo->setState(fsm->getState());
    statusInfo->setStateName(stateName(fsm->getState()));
    statusInfo->setPathId(remoteAddr);
    statusInfo->setActive(getPath(remoteAddr)->activePath);
    msg->setControlInfo(statusInfo);
    sendToApp(msg);
}

void inet::sctp::SCTPAssociation::process_STREAM_RESET ( SCTPCommand *  sctpCommand )

protected

{
    EV_DEBUG << "process_STREAM_RESET request arriving from App\n";
    SCTPResetInfo *rinfo = check_and_cast<SCTPResetInfo *>(sctpCommand);
    if (!(getPath(remoteAddr)->ResetTimer->isScheduled())) {
        if (rinfo->getRequestType() == ADD_BOTH) {
            sendAddInAndOutStreamsRequest(rinfo);
        } else if (!state->fragInProgress && state->outstandingBytes == 0) {
            sendStreamResetRequest(rinfo);
            if (rinfo->getRequestType() == RESET_OUTGOING || rinfo->getRequestType() == RESET_BOTH ||
                    rinfo->getRequestType() == SSN_TSN || rinfo->getRequestType() == ADD_INCOMING ||
                    rinfo->getRequestType() == ADD_OUTGOING) {
                state->resetPending = true;
            }
        } else if (state->outstandingBytes > 0) {
            if (rinfo->getRequestType() == RESET_OUTGOING || rinfo->getRequestType() == RESET_INCOMING) {
                if (rinfo->getStreamsArraySize() > 0) {
                    for (uint16 i = 0; i < rinfo->getStreamsArraySize(); i++) {
                        if ((getBytesInFlightOfStream(rinfo->getStreams(i)) > 0) ||
                                getFragInProgressOfStream(rinfo->getStreams(i)) ||
                                !orderedQueueEmptyOfStream(rinfo->getStreams(i)) ||
                                !unorderedQueueEmptyOfStream(rinfo->getStreams(i))) {
                            state->streamsPending.push_back(rinfo->getStreams(i));
                        } else {
                            state->streamsToReset.push_back(rinfo->getStreams(i));
                        }
                    }
                } else {
                    if (rinfo->getRequestType() == RESET_OUTGOING) {
                        for (uint16 i = 0; i < outboundStreams; i++) {
                            if ((getBytesInFlightOfStream(i) > 0) || getFragInProgressOfStream(i)) {
                                state->streamsPending.push_back(i);
                            } else {
                                state->streamsToReset.push_back(i);
                            }
                        }
                    }
                }
                if (state->streamsToReset.size() > 0) {
                    sendStreamResetRequest(rinfo);
                    state->resetPending = true;
                }
            }
            if ((rinfo->getRequestType() == SSN_TSN) ||
                    (rinfo->getRequestType() == ADD_INCOMING) ||
                    (rinfo->getRequestType() == ADD_OUTGOING)) {
                state->resetInfo = rinfo;
                state->resetInfo->setName("state-resetLater");
                state->localRequestType = state->resetInfo->getRequestType();
            }
            if (!state->resetPending || state->streamsPending.size() > 0) {
                state->resetInfo = rinfo->dup();
                state->resetInfo->setName("state-resetInfo");
                state->localRequestType = state->resetInfo->getRequestType();
            }
        }

        state->resetRequested = true;
    }
}

void inet::sctp::SCTPAssociation::process_TIMEOUT_ASCONF ( SCTPPathVariables *  path )

protected

{
    int32 value;

    if ((value = updateCounters(path)) == 1) {
        retransmitAsconf();

        /* increase the RTO (by doubling it) */
        path->pathRto = min(2 * path->pathRto.dbl(), sctpMain->getRtoMax());
        path->statisticsPathRTO->record(path->pathRto);

        startTimer(path->AsconfTimer, path->pathRto);
    }
}

void inet::sctp::SCTPAssociation::process_TIMEOUT_BLOCKING ( SCTPPathVariables *  path )

protected

{
    std::cout << "TIMEOUT_BLOCKING on " << path->remoteAddress
              << " cwnd=" << path->cwnd << endl;
    path->blockingTimeout = -1.0;
    sendOnAllPaths(path);
}

void inet::sctp::SCTPAssociation::process_TIMEOUT_HEARTBEAT ( SCTPPathVariables *  path )

protected

{
    bool oldState = path->activePath;

    /* check if error counters must be increased */
    if (path->activePath) {
        state->errorCount++;
        path->pathErrorCount++;

        EV_INFO << "HB timeout timer expired for path " << path->remoteAddress << " --> Increase Error Counters (Assoc: " << state->errorCount << ", Path: " << path->pathErrorCount << ")\n";
    }

    /* RTO must be doubled for this path ! */
    path->pathRto = (simtime_t)min(2 * path->pathRto.dbl(), sctpMain->getRtoMax());
    path->statisticsPathRTO->record(path->pathRto);
    /* check if any thresholds are exceeded, and if so, check if ULP must be notified */
    if (state->errorCount > (uint32)sctpMain->getAssocMaxRtx()) {
        sendIndicationToApp(SCTP_I_CONN_LOST);
        sendAbort();
        sctpMain->removeAssociation(this);
        return;
    }
    else {
        /* set path state to INACTIVE, if the path error counter is exceeded */
        if (path->pathErrorCount > (uint32)sctpMain->getPathMaxRetrans()) {
            oldState = path->activePath;
            path->activePath = false;
            if (path == state->getPrimaryPath()) {
                state->setPrimaryPath(getNextPath(path));
            }
            EV_DETAIL << "pathErrorCount now " << path->pathErrorCount
                      << "; PP now " << state->getPrimaryPathIndex() << endl;
        }
        /* then: we can check, if all paths are INACTIVE ! */
        if (allPathsInactive()) {
            EV_DETAIL << "sctp_do_hb_to_timer() : ALL PATHS INACTIVE --> closing ASSOC\n";
            sendIndicationToApp(SCTP_I_CONN_LOST);
            return;
        }
        else if (path->activePath == false && oldState == true) {    //FIXME oldState may be uninitialized
            /* notify the application, in case the PATH STATE has changed from ACTIVE to INACTIVE */
            pathStatusIndication(path, false);
        }
    }
}

void inet::sctp::SCTPAssociation::process_TIMEOUT_HEARTBEAT_INTERVAL ( SCTPPathVariables *  path, bool  force  )

protected

{
    EV_INFO << "HB Interval timer expired -- sending new HB REQ on path " << path->remoteAddress << "\n";
    /* restart hb_send_timer on this path */
    stopTimer(path->HeartbeatIntervalTimer);
    stopTimer(path->HeartbeatTimer);
    path->heartbeatIntervalTimeout = (double)sctpMain->getHbInterval() + path->pathRto;
    path->heartbeatTimeout = path->pathRto;
    startTimer(path->HeartbeatIntervalTimer, path->heartbeatIntervalTimeout);

    if (sctpMain->getEnableHeartbeats() && (simTime() - path->lastAckTime > path->heartbeatIntervalTimeout / 2 || path->forceHb || state->sendHeartbeatsOnActivePaths)) {
        sendHeartbeat(path);
        startTimer(path->HeartbeatTimer, path->heartbeatTimeout);

        path->forceHb = false;
    }
}

void inet::sctp::SCTPAssociation::process_TIMEOUT_INIT_REXMIT ( SCTPEventCode &  event )

protected

{
    if (++state->initRetransCounter > (int32)sctpMain->getMaxInitRetrans()) {
        EV_INFO << "Retransmission count during connection setup exceeds " << (int32)sctpMain->getMaxInitRetrans() << ", giving up\n";
        sendIndicationToApp(SCTP_I_CLOSED);
        sendAbort();
        return;
    }
    EV_INFO << "Performing retransmission #" << state->initRetransCounter << "\n";
    switch (fsm->getState()) {
        case SCTP_S_COOKIE_WAIT:
            retransmitInit();
            break;

        case SCTP_S_COOKIE_ECHOED:
            retransmitCookieEcho();
            break;

        default:
            throw cRuntimeError("Internal error: INIT-REXMIT timer expired while in state %s",
                stateName(fsm->getState()));
    }
    state->initRexmitTimeout *= 2;
    if (state->initRexmitTimeout > sctpMain->getMaxInitRetransTimeout()) {
        state->initRexmitTimeout = sctpMain->getMaxInitRetransTimeout();
    }
    startTimer(T1_InitTimer, state->initRexmitTimeout);
}

void inet::sctp::SCTPAssociation::process_TIMEOUT_PROBING ( )

protected

void inet::sctp::SCTPAssociation::process_TIMEOUT_RESET ( SCTPPathVariables *  path )

protected

{
    int32 value;
    std::map<uint32, SCTPStateVariables::RequestData>::reverse_iterator rit;
    rit = state->requests.rbegin();
    if (rit->second.result == DEFERRED) {
        value = 1;
    } else {
        value = updateCounters(path);
    }
    if (value == 1) {
        EV_DETAIL << "Performing timeout reset" << endl;
        retransmitReset();

        /* increase the RTO (by doubling it) */
        path->pathRto = min(2 * path->pathRto.dbl(), sctpMain->getRtoMax());
        path->statisticsPathRTO->record(path->pathRto);
        startTimer(path->ResetTimer, path->pathRto);
    }
}

void inet::sctp::SCTPAssociation::process_TIMEOUT_RTX ( SCTPPathVariables *  path )

protected

{
    EV_DETAIL << "Processing retransmission timeout ..." << endl;

    // Stop blocking!
    if (path->BlockingTimer) {
        stopTimer(path->BlockingTimer);
    }
    path->blockingTimeout = -1.0;

    // ====== Increase the RTO (by doubling it) ==============================
    path->pathRto = min(2 * path->pathRto.dbl(), sctpMain->getRtoMax());
    path->statisticsPathRTO->record(path->pathRto);
    EV_DETAIL << "Schedule T3 based retransmission for path " << path->remoteAddress
              << " oldest chunk sent " << simTime() - path->oldestChunkSendTime << " ago"
              << " (TSN " << path->oldestChunkTSN << ")" << endl;
    EV_DEBUG << "Unacked chunks in Retransmission Queue:" << endl;
    for (SCTPQueue::PayloadQueue::const_iterator iterator = retransmissionQ->payloadQueue.begin();
         iterator != retransmissionQ->payloadQueue.end(); ++iterator)
    {
        const SCTPDataVariables *myChunk = iterator->second;
        if (!myChunk->hasBeenAcked) {
            const SCTPPathVariables *myChunkLastPath = myChunk->getLastDestinationPath();
            EV_DEBUG << " - " << myChunk->tsn
                     << "\tsent=now-" << simTime() - myChunk->sendTime
                     << "\tlast=" << myChunkLastPath->remoteAddress
                     << "\tmoved=" << ((myChunk->hasBeenMoved == true) ? "YES!" : "no")
                     << "\tnumTX=" << myChunk->numberOfTransmissions
                     << "\tnumRTX=" << myChunk->numberOfRetransmissions
                     << "\tfastRTX=" << ((myChunk->hasBeenFastRetransmitted == true) ? "YES!" : "no")
                     << endl;
        }
    }
    EV_DEBUG << "----------------------" << endl;

    // ====== Update congestion window =======================================
    (this->*ccFunctions.ccUpdateAfterRtxTimeout)(path);

    // ====== Error Counter Handling =========================================
    if (!state->zeroWindowProbing) {
        state->errorCount++;
        path->pathErrorCount++;
        EV_DETAIL << "RTX-Timeout: errorCount increased to " << path->pathErrorCount << "  state->errorCount=" << state->errorCount << "\n";
    }
    if (state->errorCount > (uint32)sctpMain->getAssocMaxRtx()) {
        /* error counter exceeded terminate the association -- create an SCTPC_EV_CLOSE event and send it to myself */

        EV_DETAIL << "process_TIMEOUT_RTX : ASSOC ERROR COUNTER EXCEEDED, closing ASSOC" << endl;
        sendIndicationToApp(SCTP_I_CONN_LOST);
        sendAbort();
        sctpMain->removeAssociation(this);
        return;
    }
    else {
        if (path->pathErrorCount > (uint32)sctpMain->par("pathMaxRetrans")) {
            bool notifyUlp = false;

            EV_DETAIL << "pathErrorCount exceeded\n";
            if (path->activePath) {
                /* tell the source */
                notifyUlp = true;
            }
            path->activePath = false;
            if (path->remoteAddress == state->getPrimaryPathIndex()) {
                SCTPPathVariables *nextPath = getNextPath(path);
                if (nextPath != nullptr) {
                    state->setPrimaryPath(nextPath);
                }
            }
            EV_DETAIL << "process_TIMEOUT_RTX(" << path->remoteAddress
                      << ") : PATH ERROR COUNTER EXCEEDED, path status is INACTIVE" << endl;
            if (allPathsInactive()) {
                EV_WARN << "process_TIMEOUT_RTX: ALL PATHS INACTIVE --> connection LOST!" << endl;
                sendIndicationToApp(SCTP_I_CONN_LOST);
                sendAbort();
                sctpMain->removeAssociation(this);
                return;
            }
            else if (notifyUlp) {
                // Send notification to the application
                pathStatusIndication(path, false);
            }
        }
        EV_DETAIL << "process_TIMEOUT_RTX(" << path->remoteAddress
                  << ") : PATH ERROR COUNTER now " << path->pathErrorCount << endl;
    }

    // ====== Do Retransmission ==============================================
    // dequeue all chunks not acked so far and put them in the TransmissionQ
    if (!retransmissionQ->payloadQueue.empty()) {
        EV_DETAIL << "Still " << retransmissionQ->payloadQueue.size()
                  << " chunks in retransmissionQ" << endl;

        for (auto & elem : retransmissionQ->payloadQueue)
        {
            SCTPDataVariables *chunk = elem.second;
            assert(chunk != nullptr);

            // ====== Insert chunks into TransmissionQ ============================
            // Only insert chunks that were sent to the path that has timed out
            if (!chunkMustBeAbandoned(chunk, path) && ((chunkHasBeenAcked(chunk) == false && chunk->countsAsOutstanding)
                                                       || chunk->hasBeenReneged) && (chunk->getLastDestinationPath() == path))
            {
                SCTPPathVariables *nextPath = getNextDestination(chunk);
                EV_DETAIL << simTime() << ": Timer-Based RTX for TSN " << chunk->tsn
                          << ": lastDestination=" << chunk->getLastDestination()
                          << " lastPathRTO=" << chunk->getLastDestinationPath()->pathRto
                          << " nextDestination=" << nextPath->remoteAddress
                          << " nextPathRTO=" << nextPath->pathRto
                          << " waiting=" << simTime() - chunk->sendTime
                          << endl;
                nextPath->numberOfTimerBasedRetransmissions++;
                chunk->hasBeenTimerBasedRtxed = true;
                chunk->sendForwardIfAbandoned = true;

                if (!chunk->hasBeenAbandoned) {
                    auto iter = sctpMain->assocStatMap.find(assocId);
                    iter->second.numT3Rtx++;
                }

                moveChunkToOtherPath(chunk, nextPath);
            }
        }
    }

    SCTPPathVariables *nextPath = getNextPath(path);
    EV_DETAIL << "TimeoutRTX: sendOnAllPaths()" << endl;
    sendOnAllPaths(nextPath);
}

void inet::sctp::SCTPAssociation::process_TIMEOUT_SHUTDOWN ( SCTPEventCode &  event )

protected

{
    if (++state->errorCount > (uint32)sctpMain->getAssocMaxRtx()) {
        sendIndicationToApp(SCTP_I_CONN_LOST);
        sendAbort();
        sctpMain->removeAssociation(this);
        return;
    }

    EV_INFO << "Performing shutdown retransmission. Assoc error count now " << state->errorCount << " \n";
    if (fsm->getState() == SCTP_S_SHUTDOWN_SENT) {
        retransmitShutdown();
    }
    else if (fsm->getState() == SCTP_S_SHUTDOWN_ACK_SENT)
        retransmitShutdownAck();

    state->initRexmitTimeout *= 2;
    if (state->initRexmitTimeout > SCTP_TIMEOUT_INIT_REXMIT_MAX)
        state->initRexmitTimeout = SCTP_TIMEOUT_INIT_REXMIT_MAX;
    startTimer(T2_ShutdownTimer, state->initRexmitTimeout);
}

void inet::sctp::SCTPAssociation::processAddInAndOutResetRequestArrived ( SCTPAddStreamsRequestParameter *  addInRequestParam, SCTPAddStreamsRequestParameter *  addOutRequestParam  )

protected

Referenced by processStreamResetArrived().

{
    SCTPMessage *msg = new SCTPMessage();
    msg->setByteLength(SCTP_COMMON_HEADER);
    msg->setSrcPort(localPort);
    msg->setDestPort(remotePort);
    SCTPStreamResetChunk *resetChunk = new SCTPStreamResetChunk("AddInOut_CONFIG");
    resetChunk->setChunkType(RE_CONFIG);
    resetChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
    uint32 srsn = state->streamResetSequenceNumber;
    SCTPResetTimer *rt = new SCTPResetTimer();
    auto it = sctpMain->assocStatMap.find(assocId);
    SCTPAddStreamsRequestParameter *addStreams = new SCTPAddStreamsRequestParameter("Add_Streams");
    addStreams->setParameterType(ADD_OUTGOING_STREAMS_REQUEST_PARAMETER);
    addStreams->setNumberOfStreams(addInRequestParam->getNumberOfStreams());
    state->numAddedOutStreams = addStreams->getNumberOfStreams();
    state->localRequestType = ADD_OUTGOING;
    addStreams->setSrReqSn(srsn);
    state->requests[srsn].result = 100;
    state->requests[srsn].type = ADD_OUTGOING_STREAMS_REQUEST_PARAMETER;
    addStreams->setByteLength(SCTP_ADD_STREAMS_REQUEST_PARAMETER_LENGTH);
    resetChunk->addParameter(addStreams);

    SCTPStreamResetChunk *responseChunk = new SCTPStreamResetChunk("responseRE_CONFIG");
    responseChunk->setChunkType(RE_CONFIG);
    responseChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
    SCTPStreamResetResponseParameter *outResponseParam = new SCTPStreamResetResponseParameter("Out_Response_Param");
    outResponseParam->setParameterType(STREAM_RESET_RESPONSE_PARAMETER);
    outResponseParam->setSrResSn(addOutRequestParam->getSrReqSn());
    outResponseParam->setResult(PERFORMED);
    outResponseParam->setByteLength(SCTP_STREAM_RESET_RESPONSE_PARAMETER_LENGTH);
    responseChunk->addParameter(outResponseParam);
    SCTPStreamResetResponseParameter *inResponseParam = new SCTPStreamResetResponseParameter("In_Response_Param");
    inResponseParam->setParameterType(STREAM_RESET_RESPONSE_PARAMETER);
    inResponseParam->setSrResSn(addInRequestParam->getSrReqSn());
    inResponseParam->setResult(PERFORMED);
    state->peerRequests[addInRequestParam->getSrReqSn()].result = PERFORMED;
    state->peerRequests[addOutRequestParam->getSrReqSn()].result = PERFORMED;
    inResponseParam->setByteLength(SCTP_STREAM_RESET_RESPONSE_PARAMETER_LENGTH);
    responseChunk->addParameter(inResponseParam);
    msg->addChunk(resetChunk);
    msg->addChunk(responseChunk);
    rt->setInSN(0);
    rt->setInAcked(true);
    rt->setOutSN(srsn);
    rt->setOutAcked(false);
    it->second.numResetRequestsSent++;
    state->streamResetSequenceNumber = ++srsn;
    if (state->resetChunk != nullptr) {
        delete state->resetChunk;
        state->resetChunk = nullptr;
    }
    state->resetChunk = check_and_cast<SCTPStreamResetChunk *>(resetChunk->dup());
    state->resetChunk->setName("stateAddResetChunk");
    sendToIP(msg, remoteAddr);
    PK(getPath(remoteAddr)->ResetTimer)->encapsulate(rt);
    startTimer(getPath(remoteAddr)->ResetTimer, getPath(remoteAddr)->pathRto);
}

bool inet::sctp::SCTPAssociation::processAppCommand

(

cMessage *

msg

)

Process commands from the application.

Normally returns true. A return value of false means that the connection structure must be deleted by the caller (SCTP).

Referenced by inet::sctp::SCTP::handleMessage().

{
    printAssocBrief();

    // first do actions
    SCTPCommand *sctpCommand = (SCTPCommand *)(msg->removeControlInfo());
    SCTPEventCode event = preanalyseAppCommandEvent(msg->getKind());

    EV_INFO << "App command: " << eventName(event) << "\n";

    switch (event) {
        case SCTP_E_ASSOCIATE:
            process_ASSOCIATE(event, sctpCommand, msg);
            break;

        case SCTP_E_OPEN_PASSIVE:
            process_OPEN_PASSIVE(event, sctpCommand, msg);
            break;

        case SCTP_E_SEND:
            process_SEND(event, sctpCommand, msg);
            break;

        case SCTP_E_ABORT:
            process_ABORT(event);
            break;

        case SCTP_E_RECEIVE:
            process_RECEIVE_REQUEST(event, sctpCommand);
            break;

        case SCTP_E_PRIMARY:
            process_PRIMARY(event, sctpCommand);
            break;

        case SCTP_E_STREAM_RESET:
        case SCTP_E_RESET_ASSOC:
        case SCTP_E_ADD_STREAMS:
            if (state->peerStreamReset == true) {
                process_STREAM_RESET(sctpCommand);
            }
            event = SCTP_E_IGNORE;
            break;

        case SCTP_E_SEND_ASCONF:
            sendAsconf(sctpMain->par("addIpType"));
            break;

        case SCTP_E_SET_STREAM_PRIO:
            state->ssPriorityMap[((SCTPSendInfo *)sctpCommand)->getSid()] =
                ((SCTPSendInfo *)sctpCommand)->getPpid();
            break;

        case SCTP_E_QUEUE_BYTES_LIMIT:
            process_QUEUE_BYTES_LIMIT(sctpCommand);
            break;

        case SCTP_E_QUEUE_MSGS_LIMIT:
            process_QUEUE_MSGS_LIMIT(sctpCommand);
            break;

        case SCTP_E_CLOSE:
            if (listening) {
                event = SCTP_E_IGNORE;
                break;
            }
            state->stopReading = true;
            /* fall through */

        case SCTP_E_SHUTDOWN:    /*sendShutdown*/
            EV_INFO << "SCTP_E_SHUTDOWN in state " << stateName(fsm->getState()) << "\n";

            if (fsm->getState() == SCTP_S_SHUTDOWN_RECEIVED) {
                EV_INFO << "send shutdown ack\n";
                sendShutdownAck(remoteAddr);
            }
            break;

        case SCTP_E_STOP_SENDING:
            break;

        case SCTP_E_SEND_SHUTDOWN_ACK:
            break;

        case SCTP_E_ACCEPT:
            fd = sctpCommand->getFd();
            EV_DETAIL << "Accepted fd " << fd << " for assoc " << assocId << endl;
            break;

        case SCTP_E_SET_RTO_INFO:
            sctpMain->setRtoInitial(((SCTPRtoInfo *)sctpCommand)->getRtoInitial());
            sctpMain->setRtoMin(((SCTPRtoInfo *)sctpCommand)->getRtoMin());
            sctpMain->setRtoMax(((SCTPRtoInfo *)sctpCommand)->getRtoMax());
            break;
        default:
            throw cRuntimeError("Wrong event code");
    }

    delete sctpCommand;
    // then state transitions
    return performStateTransition(event);
}

SCTPEventCode inet::sctp::SCTPAssociation::processAsconfAckArrived ( SCTPAsconfAckChunk *  asconfAckChunk )

protected

Referenced by process_RCV_Message().

{
    SCTPParameter *sctpParam;
    L3Address addr;
    SCTPAsconfChunk *sctpasconf;
    std::vector<uint32> errorCorrId;
    bool errorFound = false;

    sctpasconf = check_and_cast<SCTPAsconfChunk *>(state->asconfChunk->dup());
    if (asconfAckChunk->getSerialNumber() == sctpasconf->getSerialNumber()) {
        stopTimer(getPath(remoteAddr)->AsconfTimer);
        state->errorCount = 0;
        state->asconfOutstanding = false;
        getPath(remoteAddr)->pathErrorCount = 0;
        std::vector<L3Address> remAddr = (std::vector<L3Address>)remoteAddressList;
        for (uint32 j = 0; j < asconfAckChunk->getAsconfResponseArraySize(); j++) {
            sctpParam = (SCTPParameter *)(asconfAckChunk->getAsconfResponse(j));
            if (sctpParam->getParameterType() == ERROR_CAUSE_INDICATION) {
                SCTPErrorCauseParameter *error = check_and_cast<SCTPErrorCauseParameter *>(sctpParam);
                errorCorrId.push_back(error->getResponseCorrelationId());
                EV_INFO << "error added with id " << error->getResponseCorrelationId() << "\n";
            }
        }
        for (uint32 i = 0; i < sctpasconf->getAsconfParamsArraySize(); i++) {
            sctpParam = check_and_cast<SCTPParameter *>(sctpasconf->removeAsconfParam());
            errorFound = false;
            switch (sctpParam->getParameterType()) {
                case ADD_IP_ADDRESS:
                    SCTPAddIPParameter *ipParam;
                    ipParam = check_and_cast<SCTPAddIPParameter *>(sctpParam);
                    if (errorCorrId.size() > 0) {
                        for (auto & elem : errorCorrId)
                            if ((elem) == ipParam->getRequestCorrelationId()) {
                                errorFound = true;
                                break;
                            }
                    }
                    if (errorFound == true) {
                        delete ipParam;
                        break;
                    }
                    addr = ipParam->getAddressParam();
                    if (addr.isUnspecified()) {
                        addr = localAddr;
                        sendIndicationToApp(SCTP_I_ADDRESS_ADDED);
                    }
                    sctpMain->addLocalAddressToAllRemoteAddresses(this, addr, remAddr);
                    state->localAddresses.push_back(addr);
                    delete ipParam;
                    break;

                case DELETE_IP_ADDRESS:
                    SCTPDeleteIPParameter *delParam;
                    delParam = check_and_cast<SCTPDeleteIPParameter *>(sctpParam);
                    if (errorCorrId.size() > 0) {
                        for (auto & elem : errorCorrId) {
                            if ((elem) == delParam->getRequestCorrelationId()) {
                                errorFound = true;
                                break;
                            }
                        }
                    }
                    if (errorFound == true) {
                        delete delParam;
                        break;
                    }
                    addr = delParam->getAddressParam();
                    sctpMain->removeLocalAddressFromAllRemoteAddresses(this, addr, remAddr);
                    for (auto j = state->localAddresses.begin(); j != state->localAddresses.end(); j++) {
                        if ((*j) == addr) {
                            EV_DETAIL << "erase address " << (*j) << "\n";
                            state->localAddresses.erase(j);
                            break;
                        }
                    }
                    delete delParam;
                    break;

                case SET_PRIMARY_ADDRESS:
                    SCTPSetPrimaryIPParameter *priParam;
                    priParam = check_and_cast<SCTPSetPrimaryIPParameter *>(sctpParam);
                    if (errorCorrId.size() > 0) {
                        for (auto & elem : errorCorrId) {
                            if ((elem) == priParam->getRequestCorrelationId()) {
                                errorFound = true;
                                break;
                            }
                        }
                    }
                    if (errorFound == true) {
                        delete delParam;
                        break;
                    }
                    delete priParam;
                    break;
            }
        }
    }
    delete sctpasconf;
    return SCTP_E_IGNORE;
}

SCTPEventCode inet::sctp::SCTPAssociation::processAsconfArrived ( SCTPAsconfChunk *  asconfChunk )

protected

Referenced by process_RCV_Message().

{
    SCTPParameter *sctpParam;
    SCTPPathVariables *path;
    L3Address addr;
    std::vector<L3Address> locAddr;
    SCTPAuthenticationChunk *authChunk;
    EV_INFO << "Asconf arrived " << asconfChunk->getName() << "\n";
    SCTPMessage *sctpAsconfAck = new SCTPMessage("ASCONF_ACK");
    sctpAsconfAck->setBitLength(SCTP_COMMON_HEADER * 8);
    sctpAsconfAck->setSrcPort(localPort);
    sctpAsconfAck->setDestPort(remotePort);
    if (state->auth && state->peerAuth) {
        authChunk = createAuthChunk();
        sctpAsconfAck->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }
    if (state->numberAsconfReceived > 0 || (state->numberAsconfReceived == 0 && asconfChunk->getSerialNumber() == initPeerTsn + state->numberAsconfReceived)) {
        SCTPAsconfAckChunk *asconfAckChunk = createAsconfAckChunk(asconfChunk->getSerialNumber());
        state->numberAsconfReceived++;
        int32 count = asconfChunk->getAsconfParamsArraySize();
        EV_DETAIL << "Number of Asconf parameters=" << count << "\n";
        for (int32 c = 0; c < count; c++) {
            sctpParam = (SCTPParameter *)(asconfChunk->removeAsconfParam());
            switch (sctpParam->getParameterType()) {
                case ADD_IP_ADDRESS:
                    EV_INFO << "ADD_IP_PARAMETER\n";
                    SCTPAddIPParameter *ipParam;
                    ipParam = check_and_cast<SCTPAddIPParameter *>(sctpParam);
                    addr = ipParam->getAddressParam();
                    if (addr.isUnspecified()) {
                        EV_INFO << "no address specified, add natted address " << remoteAddr << "\n";
                        addr = remoteAddr;
                        sendIndicationToApp(SCTP_I_ADDRESS_ADDED);
                    }
                    for (auto & elem : state->localAddresses) {
                        if (sctpMain->addRemoteAddress(this, (elem), addr)) {
                            addPath(addr);
                            EV_INFO << "add remote address " << addr << " to local address " << (elem) << "\n";
                            this->remoteAddressList.push_back(addr);
                        }
                    }
                    path = getPath(addr);
                    if (sctpMain->getEnableHeartbeats()) {
                        stopTimer(path->HeartbeatTimer);
                        stopTimer(path->HeartbeatIntervalTimer);
                        path->statisticsPathRTO->record(path->pathRto);
                        startTimer(path->HeartbeatIntervalTimer, path->pathRto);
                        path->forceHb = true;
                    }
                    else
                        path->confirmed = true;
                    asconfAckChunk->addAsconfResponse(createSuccessIndication(ipParam->getRequestCorrelationId()));
                    delete ipParam;
                    break;

                case DELETE_IP_ADDRESS:
                    SCTPDeleteIPParameter *delParam;
                    delParam = check_and_cast<SCTPDeleteIPParameter *>(sctpParam);
                    addr = delParam->getAddressParam();
                    if (state->localAddresses.size() == 1) {
                        SCTPErrorCauseParameter *errorParam;
                        errorParam = new SCTPErrorCauseParameter("ErrorCause");
                        errorParam->setParameterType(ERROR_CAUSE_INDICATION);
                        errorParam->setResponseCorrelationId(delParam->getRequestCorrelationId());
                        errorParam->setErrorCauseType(ERROR_DELETE_LAST_IP_ADDRESS);
                        errorParam->setBitLength((SCTP_ADD_IP_PARAMETER_LENGTH + 4) * 8);
                        errorParam->encapsulate((cPacket *)delParam->dup());        //FIXME is the c-style conversion need here?
                        asconfAckChunk->addAsconfResponse(errorParam);
                    }
                    else if (addr == remoteAddr) {
                        EV_INFO << "addr=remoteAddr, make Error Parameter\n";
                        SCTPErrorCauseParameter *errParam;
                        errParam = new SCTPErrorCauseParameter("ErrorCause");
                        errParam->setParameterType(ERROR_CAUSE_INDICATION);
                        errParam->setResponseCorrelationId(delParam->getRequestCorrelationId());
                        errParam->setErrorCauseType(ERROR_DELETE_SOURCE_ADDRESS);
                        errParam->setByteLength(SCTP_ADD_IP_PARAMETER_LENGTH + 4);
                        errParam->encapsulate((cPacket *)delParam->dup());        //FIXME is the c-style conversion need here?
                        asconfAckChunk->addAsconfResponse(errParam);
                    }
                    else {
                        locAddr = (std::vector<L3Address>)state->localAddresses;
                        sctpMain->removeRemoteAddressFromAllAssociations(this, addr, locAddr);
                        removePath(addr);
                        EV_INFO << "remove path from address " << addr << "\n";
                        asconfAckChunk->addAsconfResponse(createSuccessIndication(delParam->getRequestCorrelationId()));
                    }
                    delete delParam;
                    break;

                case SET_PRIMARY_ADDRESS:
                    EV_INFO << "SET_PRIMARY_ADDRESS\n";
                    SCTPSetPrimaryIPParameter *priParam;
                    priParam = check_and_cast<SCTPSetPrimaryIPParameter *>(sctpParam);
                    addr = priParam->getAddressParam();
                    if (addr.isUnspecified()) {
                        EV_INFO << "no address specified, add natted address " << remoteAddr << "\n";
                        addr = remoteAddr;
                    }
                    for (auto & elem : remoteAddressList) {
                        if ((elem) == addr) {
                            if (getPath(addr)->confirmed == true) {
                                state->setPrimaryPath(getPath(addr));
                                EV_INFO << "set primaryPath to " << addr << "\n";
                            }
                            else {
                                getPath(addr)->primaryPathCandidate = true;
                                sendHeartbeat(getPath(addr));
                            }
                            break;
                        }
                    }
                    asconfAckChunk->addAsconfResponse(createSuccessIndication(priParam->getRequestCorrelationId()));
                    delete priParam;
                    break;
            }
        }
        sctpAsconfAck->addChunk(asconfAckChunk);
        sendToIP(sctpAsconfAck, remoteAddr);
        if (StartAddIP->isScheduled()) {
            stopTimer(StartAddIP);
            state->corrIdNum = state->asconfSn;
            const char *type = (const char *)sctpMain->par("addIpType");
            sendAsconf(type, false);
        }
    }
    return SCTP_E_IGNORE;
}

bool inet::sctp::SCTPAssociation::processCookieAckArrived ( )

protected

Referenced by process_RCV_Message().

{
    bool trans = false;

    if (fsm->getState() == SCTP_S_COOKIE_ECHOED) {
        stopTimer(T1_InitTimer);
        trans = performStateTransition(SCTP_E_RCV_COOKIE_ACK);
        if (state->cookieChunk->getCookieArraySize() == 0) {
            delete state->cookieChunk->getStateCookie();
        }
        delete state->cookieChunk;
        return trans;
    }
    else
        EV_DETAIL << "State=" << fsm->getState() << "\n";

    return trans;
}

bool inet::sctp::SCTPAssociation::processCookieEchoArrived ( SCTPCookieEchoChunk *  cookieEcho, L3Address  addr  )

protected

Referenced by process_RCV_Message().

{
    bool trans = false;
    SCTPCookie *cookie = check_and_cast<SCTPCookie *>(cookieEcho->getStateCookie());
    if (cookie->getCreationTime() + (int32)sctpMain->par("validCookieLifetime") < simTime()) {
        EV_INFO << "stale Cookie: sendAbort\n";
        sendAbort();
        delete cookie;
        return trans;
    }
    if (fsm->getState() == SCTP_S_CLOSED) {
        if (cookie->getLocalTag() != localVTag || cookie->getPeerTag() != peerVTag) {
            bool same = true;
            for (int32 i = 0; i < 32; i++) {
                if (cookie->getLocalTieTag(i) != state->localTieTag[i]) {
                    same = false;
                    break;
                }
                if (cookie->getPeerTieTag(i) != state->peerTieTag[i]) {
                    same = false;
                    break;
                }
            }
            if (!same) {
                sendAbort();
                delete cookie;
                return trans;
            }
        }
        EV_INFO << "State is CLOSED, Cookie_Ack has to be sent\n";
        trans = performStateTransition(SCTP_E_RCV_VALID_COOKIE_ECHO);
        if (trans)
            sendCookieAck(addr); //send to address
    }
    else if (fsm->getState() == SCTP_S_ESTABLISHED || fsm->getState() == SCTP_S_COOKIE_WAIT || fsm->getState() == SCTP_S_COOKIE_ECHOED) {
        EV_INFO << "State is not CLOSED, but COOKIE_ECHO received. Compare the Tags\n";
        // case A: Peer restarted, retrieve information from cookie
        if (cookie->getLocalTag() != localVTag && cookie->getPeerTag() != peerVTag) {
            bool same = true;
            for (int32 i = 0; i < 32; i++) {
                if (cookie->getLocalTieTag(i) != state->localTieTag[i]) {
                    same = false;
                    break;
                }
                if (cookie->getPeerTieTag(i) != state->peerTieTag[i]) {
                    same = false;
                    break;
                }
            }
            if (same) {
                localVTag = cookie->getLocalTag();
                peerVTag = cookie->getPeerTag();
                sendCookieAck(addr);
            }
        }
        // case B: Setup collision, retrieve information from cookie
        else if (cookie->getPeerTag() == peerVTag && (cookie->getLocalTag() != localVTag || cookie->getLocalTag() == 0)) {
            localVTag = cookie->getLocalTag();
            peerVTag = cookie->getPeerTag();
            performStateTransition(SCTP_E_RCV_VALID_COOKIE_ECHO);
            sendCookieAck(addr);
        }
        else if (cookie->getPeerTag() == peerVTag && cookie->getLocalTag() == localVTag) {
            sendCookieAck(addr);    //send to address src
        }
        trans = true;
    }
    else {
        EV_DETAIL << "State=" << fsm->getState() << "\n";
        trans = true;
    }
    delete cookie;
    return trans;
}

SCTPEventCode inet::sctp::SCTPAssociation::processDataArrived ( SCTPDataChunk *  dataChunk )

protected

Referenced by process_RCV_Message().

{
    const uint32 tsn = dataChunk->getTsn();
    SCTPPathVariables *path = getPath(remoteAddr);

    state->newChunkReceived = false;
    state->lastTsnReceived = tsn;

    bool found = false;
    for (auto & elem : state->lastDataSourceList) {
        if (elem == path) {
            found = true;
            break;
        }
    }
    if (!found) {
        state->lastDataSourceList.push_back(path);
    }
    state->lastDataSourcePath = path;

    EV_DETAIL << simTime() << " SCTPAssociation::processDataArrived TSN=" << tsn << endl;
    path->vectorPathReceivedTSN->record(tsn);
    if (dataChunk->getIBit()) {
        state->ackState = sackFrequency;
    }
    calculateRcvBuffer();

    SCTPSimpleMessage *smsg = check_and_cast<SCTPSimpleMessage *>(dataChunk->decapsulate());
    dataChunk->setByteLength(SCTP_DATA_CHUNK_LENGTH);
    dataChunk->encapsulate(smsg);
    const uint32 payloadLength = dataChunk->getByteLength() - SCTP_DATA_CHUNK_LENGTH;
    EV_DETAIL << "state->bytesRcvd=" << state->bytesRcvd << endl;
    if (payloadLength == 0) {
        EV_DETAIL << "No user data. Send ABORT" << endl;
        return SCTP_E_ABORT;
    }
    state->bytesRcvd += payloadLength;
    EV_DETAIL << "state->bytesRcvd now=" << state->bytesRcvd << endl;
    path->numberOfBytesReceived += payloadLength;
    auto iter = sctpMain->assocStatMap.find(assocId);
    iter->second.rcvdBytes += dataChunk->getByteLength() - SCTP_DATA_CHUNK_LENGTH;

    if (state->stopReceiving) {
        return SCTP_E_SEND;
    }

    // ====== Duplicate: tsn < CumAckTSN =====================================
    if (tsnLe(tsn, state->gapList.getCumAckTSN())) {
        if (state->stopOldData) {
            if (tsnGe(tsn, state->peerTsnAfterReset)) {
                state->stopOldData = false;
            }
            return SCTP_E_SEND;
        }
        else {
            EV_DETAIL << simTime() << ": Duplicate TSN " << tsn << " (smaller than CumAck)" << endl;
            state->dupList.push_back(tsn);
            state->dupList.unique();
            path->numberOfDuplicates++;
            delete check_and_cast<SCTPSimpleMessage *>(dataChunk->decapsulate());
            return SCTP_E_DUP_RECEIVED;
        }
    }

    // ====== Duplicate ======================================================
    if (tsnIsDuplicate(tsn)) {
        // TSN value is duplicate within a fragment
        EV_DETAIL << "Duplicate TSN " << tsn << " (copy)" << endl;
        state->dupList.push_back(tsn);
        state->dupList.unique();
        path->numberOfDuplicates++;
        return SCTP_E_SEND;
    }

    // ====== Out of receiver buffer space? ==================================
    calculateRcvBuffer();
    if (((state->messageAcceptLimit > 0) &&
         (state->localMsgRwnd - state->bufferedMessages <= 0)) ||
        ((state->messageAcceptLimit == 0) &&
         ((int32)(state->localRwnd - state->queuedReceivedBytes
                  - state->bufferedMessages * state->bytesToAddPerRcvdChunk) <= 0)))
    {
        state->ackState = sackFrequency;

        if (tsnGt(tsn, state->gapList.getHighestTSNReceived())) {
            EV_DETAIL << "DROP: " << (int)tsn << " high=" << (int)state->gapList.getHighestTSNReceived()
                      << " Q=" << (int)state->queuedReceivedBytes << " Rwnd=" << (int)state->localRwnd << endl;
            if ((!state->pktDropSent) && (sctpMain->pktdrop) && (state->peerPktDrop)) {
                EV_DETAIL << "Receive buffer full (case 1): sendPacketDrop" << endl;
                sendPacketDrop(false);
            }
            iter->second.numDropsBecauseNewTSNGreaterThanHighestTSN++;
            return SCTP_E_SEND;
            //          }  ????
        }
        else if ((tsn < state->gapList.getHighestTSNReceived()) &&
                 (state->disableReneging == false) &&
                 (!makeRoomForTsn(tsn, dataChunk->getBitLength() - SCTP_DATA_CHUNK_LENGTH * 8, dataChunk->getUBit())))
        {
            if ((!state->pktDropSent) && (sctpMain->pktdrop) && (state->peerPktDrop)) {
                EV_DETAIL << "Receive buffer full (case 2): sendPacketDrop" << endl;
                sendPacketDrop(false);
            }
            iter->second.numDropsBecauseNoRoomInBuffer++;
            return SCTP_E_SEND;
        }
    }

    // ====== Update of CumAckTSN ============================================
    state->gapList.updateGapList(tsn, state->newChunkReceived,
            (state->disableReneging == false) ? true : false);
    state->gapList.tryToAdvanceCumAckTSN();
    EV_DETAIL << "cumAckTSN=" << state->gapList.getCumAckTSN()
              << " highestTSNReceived=" << state->gapList.getHighestTSNReceived() << endl;

    // ====== Silly Window Syndrome Avoidance ================================
    if (state->swsAvoidanceInvoked) {
        // swsAvoidanceInvoked => schedule a SACK to be sent at once in this case
        EV_TRACE << "swsAvoidanceInvoked" << endl;
        state->ackState = sackFrequency;
    }

    if (dataChunk->getSid() >= inboundStreams) {
        sendInvalidStreamError(dataChunk->getSid());
        return SCTP_E_IGNORE;
    }
    // ====== Enqueue new chunk ==============================================
    SCTPEventCode event = SCTP_E_SEND;
    if (state->newChunkReceived) {
        auto iter = receiveStreams.find(dataChunk->getSid());
        const int ret = iter->second->enqueueNewDataChunk(makeVarFromMsg(dataChunk));
        if (ret > 0) {
            state->queuedReceivedBytes += payloadLength;
            calculateRcvBuffer();

            event = SCTP_E_DELIVERED;
            if (ret < 3) {
                state->bufferedMessages++;
                sendDataArrivedNotification(dataChunk->getSid());
                putInDeliveryQ(dataChunk->getSid());
                if (simTime() > state->lastThroughputTime + 1) {
                    for (uint16 i = 0; i < inboundStreams; i++) {
                        streamThroughputVectors[i]->record(state->streamThroughput[i]
                                / (simTime() - state->lastThroughputTime) / 1024);
                        state->streamThroughput[i] = 0;
                    }
                    state->lastThroughputTime = simTime();
                }
                state->streamThroughput[dataChunk->getSid()] += payloadLength;
            }
            calculateRcvBuffer();
        }
        state->newChunkReceived = false;
    }

    return event;
}

void inet::sctp::SCTPAssociation::processErrorArrived ( SCTPErrorChunk *  error )

protected

Referenced by process_RCV_Message().

{
    uint32 parameterType;
    for (uint32 i = 0; i < errorChunk->getParametersArraySize(); i++) {
        SCTPParameter *param = (SCTPParameter *)errorChunk->getParameters(i);
        parameterType = param->getParameterType();
        switch (parameterType) {
            case MISSING_NAT_ENTRY: {
                if ((bool)sctpMain->par("addIP")) {
                    if (StartAddIP->isScheduled())
                        stopTimer(StartAddIP);
                    state->corrIdNum = state->asconfSn;
                    const char *type = (const char *)sctpMain->par("addIpType");
                    sendAsconf(type, true);
                }
                break;
            }

            case UNSUPPORTED_HMAC: {
                sendAbort();
                break;
            }
        }
    }
}

SCTPEventCode inet::sctp::SCTPAssociation::processForwardTsnArrived ( SCTPForwardTsnChunk *  forChunk )

protected

Referenced by process_RCV_Message().

{
    EV_TRACE << "processForwardTsnArrived\n";
    EV_INFO << "last state->cTsnAck=" << state->gapList.getCumAckTSN() << " fwCumAck=" << fwChunk->getNewCumTsn() << "\n";

    /* Ignore old FORWARD_TSNs, probably stale retransmits. */
    if (state->gapList.getCumAckTSN() >= fwChunk->getNewCumTsn()) {
        return SCTP_E_IGNORE;
    }

    for (uint32 i = 0; i < fwChunk->getSidArraySize(); i++) {
        if (fwChunk->getSsn(i) != -1) {
            auto iter = receiveStreams.find(fwChunk->getSid(i));
            SCTPReceiveStream *rStream = iter->second;

            /* Uncomment the folloing to drop gap-acknowledged messages
             * between two abandonend messages rather then delivering them.
             */

            if (rStream->getOrderedQ()->getQueueSize() > 0)
                rStream->setExpectedStreamSeqNum(rStream->getOrderedQ()->getFirstSsnInQueue(fwChunk->getSid(i)));
            else if (rStream->getExpectedStreamSeqNum() <= fwChunk->getSsn(i))
                rStream->setExpectedStreamSeqNum(fwChunk->getSsn(i) + 1);
            if (rStream->getExpectedStreamSeqNum() > 65535) {
                rStream->setExpectedStreamSeqNum(0);
            }
            sendDataArrivedNotification(fwChunk->getSid(i));
            calculateRcvBuffer();
        }
    }
    /* Update Gap lists with abandoned TSNs and advance CumTSNAck */
    for (uint32 i = state->gapList.getCumAckTSN() + 1; i <= fwChunk->getNewCumTsn(); i++) {
        if (i > state->gapList.getCumAckTSN() && !state->gapList.tsnInGapList(i)) {
            bool dummy;
            state->gapList.updateGapList(i, dummy, false);
            state->gapList.tryToAdvanceCumAckTSN();
        }
    }
    return SCTP_E_IGNORE;
}

SCTPEventCode inet::sctp::SCTPAssociation::processHeartbeatAckArrived ( SCTPHeartbeatAckChunk *  heartbeatack, SCTPPathVariables *  path  )

protected

Referenced by process_RCV_Message().

{
    path->numberOfHeartbeatAcksRcvd++;
    path->vectorPathRcvdHbAck->record(path->numberOfHeartbeatAcksRcvd);
    /* hb-ack goes to pathmanagement, reset error counters, stop timeout timer */
    const L3Address addr = hback->getRemoteAddr();
    const simtime_t hbTimeField = hback->getTimeField();
    stopTimer(path->HeartbeatTimer);
    /* assume a valid RTT measurement on this path */
    simtime_t rttEstimation = simTime() - hbTimeField;
    pmRttMeasurement(path, rttEstimation);
    pmClearPathCounter(path);
    path->confirmed = true;
    path->lastAckTime = simTime();
    if (path->primaryPathCandidate == true) {
        state->setPrimaryPath(getPath(addr));
        path->primaryPathCandidate = false;
        if (path->pmtu < state->assocPmtu) {
            state->assocPmtu = path->pmtu;
        }
        path->ssthresh = state->peerRwnd;
        recordCwndUpdate(path);
        path->heartbeatTimeout = (double)sctpMain->getHbInterval() + path->pathRto;
    }

    if (path->activePath == false) {
        EV_INFO << "HB ACK arrived activePath=false. remoteAddress=" << path->remoteAddress
                << " initialPP=" << state->initialPrimaryPath << endl;
        path->activePath = true;
        if (state->reactivatePrimaryPath && path->remoteAddress == state->initialPrimaryPath) {
            state->setPrimaryPath(path);
        }
        EV_DETAIL << "primaryPath now " << state->getPrimaryPathIndex() << endl;
    }
    EV_INFO << "Received HB ACK chunk...resetting error counters on path " << addr
            << ", rttEstimation=" << rttEstimation << endl;
    path->pathErrorCount = 0;
    return SCTP_E_IGNORE;
}

SCTPEventCode inet::sctp::SCTPAssociation::processInAndOutResetRequestArrived ( SCTPIncomingSSNResetRequestParameter *  inRequestParam, SCTPOutgoingSSNResetRequestParameter *  outRequestParam  )

protected

Referenced by processStreamResetArrived().

{
    uint32 inSrSn = 0;
    uint32 outSrSn = 0;
    uint16 inRes = 0;
    uint16 outRes = 0;
    uint16 num = 0;
    if (tsnGt(outRequestParam->getLastTsn(), state->gapList.getHighestTSNReceived())) {
        state->lastTsnBeforeReset = outRequestParam->getLastTsn();
        state->peerRequestSn = outRequestParam->getSrReqSn();
        state->inRequestSn = inRequestParam->getSrReqSn();
        state->inOut = true;
    } else {
        if (outRequestParam->getStreamNumbersArraySize() > 0) {
            num = 0;
            for (uint16 i = 0; i < outRequestParam->getStreamNumbersArraySize(); i++) {
                if (!receiveStreamPresent(outRequestParam->getStreamNumbers(i))) {
                    outSrSn =  outRequestParam->getSrReqSn();
                    outRes = DENIED;
                    num++;
                    break;
                }
            }
            if (num == 0) {
                for (uint16 i = 0; i < outRequestParam->getStreamNumbersArraySize(); i++) {
                    resetExpectedSsn(outRequestParam->getStreamNumbers(i));
                }
            }
        } else {
            resetExpectedSsns();
            EV_DETAIL << "processInAndOutResetRequestArrived: resetExpectedSsns\n";
            sendOutgoingRequestAndResponse(inRequestParam->getSrReqSn(), outRequestParam->getSrReqSn());
        }
        if (inRequestParam->getStreamNumbersArraySize() > 0) {
            num = 0;
            for (uint16 i = 0; i < inRequestParam->getStreamNumbersArraySize(); i++) {
                if (!receiveStreamPresent(inRequestParam->getStreamNumbers(i))) {
                    inSrSn =  inRequestParam->getSrReqSn();
                    inRes = DENIED;
                    num++;
                   // sendStreamResetResponse(outRequestParam->getSrReqSn(), DENIED);
                    break;
                }
            }
            if (num == 0) {
                sendOutgoingRequestAndResponse(inRequestParam, outRequestParam);
            }
        }
    }
    if (inSrSn > 0 && outSrSn > 0) {
        sendDoubleStreamResetResponse(inSrSn, inRes, outSrSn, outRes);
        state->resetPending = true;
    }
    return SCTP_E_IGNORE;
}

void inet::sctp::SCTPAssociation::processIncomingResetRequestArrived ( SCTPIncomingSSNResetRequestParameter *  requestParam )

protected

Referenced by checkStreamsToReset(), and processStreamResetArrived().

{
    uint16 num = 0;
    if (!state->firstPeerRequest && (requestParam->getSrReqSn() < (state->peerRequestSn)) ) {
        // Retransmission
        sendStreamResetResponse(requestParam->getSrReqSn(), NO_RESET);
        return;
    }
    if (!state->fragInProgress && state->outstandingBytes == 0) {
        if (requestParam->getStreamNumbersArraySize() > 0) {
            for (uint16 i = 0; i < requestParam->getStreamNumbersArraySize(); i++) {
                if (!sendStreamPresent(requestParam->getStreamNumbers(i))) {
                    sendStreamResetResponse(requestParam->getSrReqSn(), DENIED);
                    return;
                }
                if (getSsnOfStream(requestParam->getStreamNumbers(i)) == 0 ) {
                    num++;
                }
            }
            if (num == requestParam->getStreamNumbersArraySize()) {
                sendStreamResetResponse(requestParam->getSrReqSn(), NOTHING_TO_DO);
            return;
            }
            for (uint16 i = 0; i < requestParam->getStreamNumbersArraySize(); i++) {
                if (!state->findPeerStreamToReset(requestParam->getStreamNumbers(i))) {

                   // resetSsn(requestParam->getStreamNumbers(i));
                    state->peerStreamsToReset.push_back(requestParam->getStreamNumbers(i));
                }
            }
        } else {
            resetSsns();
        }
        sendOutgoingResetRequest(requestParam);
       // sendBundledOutgoingResetAndResponse(requestParam);
        EV_TRACE << "processIncomingResetRequestArrived: sendOutgoingResetRequestArrived returned\n";
        state->resetPending = true;
    } else {
        if (requestParam->getStreamNumbersArraySize() > 0) {
            state->streamsPending.clear();
            state->streamsToReset.clear();
            for (uint16 i = 0; i < requestParam->getStreamNumbersArraySize(); i++) {
                if (!sendStreamPresent(requestParam->getStreamNumbers(i))) {
                    sendStreamResetResponse(requestParam->getSrReqSn(), DENIED);
                    return;
                }
                if ((getBytesInFlightOfStream(requestParam->getStreamNumbers(i)) > 0) || getFragInProgressOfStream(requestParam->getStreamNumbers(i))){
                    state->streamsPending.push_back(requestParam->getStreamNumbers(i));
                } else {
                    state->streamsToReset.push_back(requestParam->getStreamNumbers(i));
                    resetSsn(requestParam->getStreamNumbers(i));
                }
            }
        } else {
            for (uint16 i = 0; i < outboundStreams; i++) {
                if (getBytesInFlightOfStream(i) > 0) {
                    state->streamsPending.push_back(i);
                } else {
                    state->streamsToReset.push_back(i);
                    resetSsn(i);
                }
            }
        }
        if (state->streamsToReset.size() > 0) {
           // sendBundledOutgoingResetAndResponse(requestParam);
            sendOutgoingResetRequest(requestParam);
            state->resetPending = true;
        }
        if (!state->resetPending) {
            sendStreamResetResponse(requestParam->getSrReqSn(), DEFERRED);
            state->resetDeferred = true;
        }
        state->peerRequestSn = requestParam->getSrReqSn();
        state->peerRequestType = RESET_INCOMING;
        state->localRequestType = RESET_OUTGOING;
        if (state->streamsPending.size() == 0 && state->incomingRequestSet && state->incomingRequest != nullptr) {
            delete state->incomingRequest;
            state->incomingRequest = nullptr;
            state->incomingRequestSet = false;
        }
        state->incomingRequest = ((SCTPParameter *)requestParam)->dup();        //FIXME is the c-style conversion need here?
        state->incomingRequest->setName("StateIncoming");
        state->incomingRequestSet = true;
    }
}

bool inet::sctp::SCTPAssociation::processInitAckArrived ( SCTPInitAckChunk *  initAckChunk )

protected

Referenced by process_RCV_Message().

{
    bool trans = false;
    uint16 type;

    if (fsm->getState() == SCTP_S_COOKIE_WAIT) {
        EV_INFO << "State is COOKIE_WAIT, Cookie_Echo has to be sent\n";
        stopTimer(T1_InitTimer);
        state->initRexmitTimeout = SCTP_TIMEOUT_INIT_REXMIT;
        trans = performStateTransition(SCTP_E_RCV_INIT_ACK);
        //delete state->initChunk; will be deleted when state ESTABLISHED is entered
        if (trans) {
            initPeerTsn = initAckChunk->getInitTSN();
            localVTag = initAckChunk->getInitTag();
            state->gapList.setInitialCumAckTSN(initPeerTsn - 1);
            state->initialPeerRwnd = initAckChunk->getA_rwnd();
            state->peerRwnd = state->initialPeerRwnd;
            statisticsPeerRwnd->record(state->peerRwnd);
            if (initAckChunk->getMsg_rwnd() > 0) {
                state->peerAllowsChunks = true;
                state->initialPeerMsgRwnd = initAckChunk->getMsg_rwnd();
                state->peerMsgRwnd = state->initialPeerMsgRwnd;
            }
            state->expectedStreamResetSequenceNumber = initPeerTsn;
            remoteAddressList.clear();
            numberOfRemoteAddresses = initAckChunk->getAddressesArraySize();
            EV_INFO << "number of remote addresses in initAck=" << numberOfRemoteAddresses << "\n";
            for (uint32 j = 0; j < numberOfRemoteAddresses; j++) {
                if (initAckChunk->getAddresses(j).getType() == L3Address::IPv6)
                    continue;
                for (auto & elem : state->localAddresses) {
                    if (!((elem).isUnspecified())) {
                        EV_INFO << "addPath " << initAckChunk->getAddresses(j) << "\n";
                        if (sctpMain->addRemoteAddress(this, (elem), initAckChunk->getAddresses(j))) {
                            this->remoteAddressList.push_back(initAckChunk->getAddresses(j));
                            addPath(initAckChunk->getAddresses(j));
                        }
                    }
                }
            }
            auto ite = sctpPathMap.find(remoteAddr);
            if (ite == sctpPathMap.end()) {
                EV_INFO << " get new path for " << remoteAddr << "\n";
                SCTPPathVariables *path = new SCTPPathVariables(remoteAddr, this, rt);
                sctpPathMap[remoteAddr] = path;
                qCounter.roomTransQ[remoteAddr] = 0;
                qCounter.roomRetransQ[remoteAddr] = 0;
                qCounter.bookedTransQ[remoteAddr] = 0;
            }
            state->initialPrimaryPath = remoteAddr;
            state->setPrimaryPath(getPath(remoteAddr));
            inboundStreams = ((initAckChunk->getNoOutStreams() < inboundStreams) ? initAckChunk->getNoOutStreams() : inboundStreams);
            outboundStreams = ((initAckChunk->getNoInStreams() < outboundStreams) ? initAckChunk->getNoInStreams() : outboundStreams);
            (this->*ssFunctions.ssInitStreams)(inboundStreams, outboundStreams);
            if (initAckChunk->getHmacTypesArraySize() != 0) {
                state->peerAuth = true;
                for (uint32 j = 0; j < initAckChunk->getChunkTypesArraySize(); j++) {
                    type = initAckChunk->getChunkTypes(j);
                    if (type != INIT && type != INIT_ACK && type != AUTH && type != SHUTDOWN_COMPLETE) {
                        state->peerChunkList.push_back(type);
                    }
                }
            }
            if (initAckChunk->getSepChunksArraySize() > 0) {
                for (uint32 i = 0; i < initAckChunk->getSepChunksArraySize(); i++) {
                    if (initAckChunk->getSepChunks(i) == RE_CONFIG) {
                        state->peerStreamReset = true;
                        continue;
                    }
                    if (initAckChunk->getSepChunks(i) == PKTDROP) {
                        state->peerPktDrop = true;
                        continue;
                    }
                }
            }
            sendCookieEcho(initAckChunk);
        }
        startTimer(T1_InitTimer, state->initRexmitTimeout);
    }
    else
        EV_DETAIL << "State=" << fsm->getState() << "\n";
    printSctpPathMap();
    return trans;
}

bool inet::sctp::SCTPAssociation::processInitArrived ( SCTPInitChunk *  initChunk, int32  sport, int32  dport  )

protected

Process incoming SCTP packets.

Invoked from process_RCV_Message

Referenced by process_RCV_Message().

{
    SCTPAssociation *assoc;
    char timerName[64];
    bool trans = false;
    uint16 type;
    AddressVector adv;

    EV_TRACE << "processInitArrived\n";
    if (fsm->getState() == SCTP_S_CLOSED) {
        EV_INFO << "fork=" << state->fork << " initReceived=" << state->initReceived << "\n";
        if (state->fork && !state->initReceived) {
            EV_TRACE << "cloneAssociation\n";
            assoc = cloneAssociation();
            EV_TRACE << "addForkedAssociation\n";
            sctpMain->addForkedAssociation(this, assoc, localAddr, remoteAddr, srcPort, destPort);
            assoc->listening = true;
            this->listening = false;

            EV_INFO << "Connection forked: this connection got new assocId=" << assocId << ", "
                                                                                           "spinoff keeps LISTENing with assocId=" << assoc->assocId << "\n";
            snprintf(timerName, sizeof(timerName), "T2_SHUTDOWN of assoc %d", assocId);
            T2_ShutdownTimer->setName(timerName);
            snprintf(timerName, sizeof(timerName), "T5_SHUTDOWN_GUARD of assoc %d", assocId);
            T5_ShutdownGuardTimer->setName(timerName);
            snprintf(timerName, sizeof(timerName), "SACK_TIMER of assoc %d", assocId);
            SackTimer->setName(timerName);
            snprintf(timerName, sizeof(timerName), "T1_INIT of assoc %d", assocId);
            T1_InitTimer->setName(timerName);
        }
        else {
            sctpMain->updateSockPair(this, localAddr, remoteAddr, srcPort, destPort);
        }
        if (!state->initReceived) {
            state->initReceived = true;
            state->initialPrimaryPath = remoteAddr;
            state->setPrimaryPath(getPath(remoteAddr));
            if (initchunk->getAddressesArraySize() == 0) {
                EV_INFO << " get new path for " << remoteAddr << "\n";
                SCTPPathVariables *rPath = new SCTPPathVariables(remoteAddr, this, rt);
                sctpPathMap[rPath->remoteAddress] = rPath;
                qCounter.roomTransQ[rPath->remoteAddress] = 0;
                qCounter.bookedTransQ[rPath->remoteAddress] = 0;
                qCounter.roomRetransQ[rPath->remoteAddress] = 0;
            }
            initPeerTsn = initchunk->getInitTSN();
            state->gapList.setInitialCumAckTSN(initPeerTsn - 1);
            state->initialPeerRwnd = initchunk->getA_rwnd();
            if (initchunk->getMsg_rwnd() > 0) {
                state->peerAllowsChunks = true;
                state->initialPeerMsgRwnd = initchunk->getMsg_rwnd();
                state->peerMsgRwnd = state->initialPeerMsgRwnd;
            }
            state->peerRwnd = state->initialPeerRwnd;
            statisticsPeerRwnd->record(state->peerRwnd);
            localVTag = initchunk->getInitTag();
            numberOfRemoteAddresses = initchunk->getAddressesArraySize();
            state->localAddresses.clear();
            if (localAddressList.front().isUnspecified()) {
                for (int32 i = 0; i < ift->getNumInterfaces(); ++i) {
                    if (ift->getInterface(i)->ipv4Data() != nullptr) {
#ifdef WITH_IPv4
                        adv.push_back(ift->getInterface(i)->ipv4Data()->getIPAddress());
#else // ifdef WITH_IPv4
                        throw cRuntimeError("INET was compiled without IPv4 support");
#endif // ifdef WITH_IPv4
                    }
                    else if (ift->getInterface(i)->ipv6Data() != nullptr) {
#ifdef WITH_IPv6
                        adv.push_back(ift->getInterface(i)->ipv6Data()->getAddress(0));
#else // ifdef WITH_IPv6
                        throw cRuntimeError("INET was compiled without IPv6 support");
#endif // ifdef WITH_IPv6
                    }
                }
            }
            else {
                adv = localAddressList;
            }
            int rlevel = getAddressLevel(remoteAddr);
            if (adv.size() == 1) {
                state->localAddresses.push_back((*adv.begin()));
            }
            else if (rlevel > 0) {
                for (auto & elem : adv) {
                    if (getAddressLevel((elem)) >= rlevel) {
                        sctpMain->addLocalAddress(this, (elem));
                        state->localAddresses.push_back((elem));
                    }
                }
            }
            for (uint32 j = 0; j < initchunk->getAddressesArraySize(); j++) {
                // skip IPv6 because we can't send to them yet
                if (initchunk->getAddresses(j).getType() == L3Address::IPv6)
                    continue;
                // set path variables for this pathlocalAddresses
                if (!getPath(initchunk->getAddresses(j))) {
                    SCTPPathVariables *path = new SCTPPathVariables(initchunk->getAddresses(j), this, rt);
                    EV_INFO << " get new path for " << initchunk->getAddresses(j) << " ptr=" << path << "\n";
                    for (auto & elem : state->localAddresses) {
                        if (sctpMain->addRemoteAddress(this, (elem), initchunk->getAddresses(j))) {
                            this->remoteAddressList.push_back(initchunk->getAddresses(j));
                        }
                    }
                    sctpPathMap[path->remoteAddress] = path;
                    qCounter.roomTransQ[path->remoteAddress] = 0;
                    qCounter.bookedTransQ[path->remoteAddress] = 0;
                    qCounter.roomRetransQ[path->remoteAddress] = 0;
                }
            }
            auto ite = sctpPathMap.find(remoteAddr);
            if (ite == sctpPathMap.end()) {
                SCTPPathVariables *path = new SCTPPathVariables(remoteAddr, this, rt);
                EV_INFO << "Get new path for " << remoteAddr << "\n";
                sctpPathMap[remoteAddr] = path;
                qCounter.roomTransQ[remoteAddr] = 0;
                qCounter.bookedTransQ[remoteAddr] = 0;
                qCounter.roomRetransQ[remoteAddr] = 0;
            }
            if (initchunk->getHmacTypesArraySize() != 0) {
                state->peerAuth = true;
                for (uint32 j = 0; j < initchunk->getChunkTypesArraySize(); j++) {
                    type = initchunk->getChunkTypes(j);
                    if (type != INIT && type != INIT_ACK && type != AUTH && type != SHUTDOWN_COMPLETE) {
                        state->peerChunkList.push_back(type);
                    }
                }
            }
            EV_DETAIL << "number supported extensions:" << initchunk->getSepChunksArraySize() << "\n";
            if (initchunk->getSepChunksArraySize() > 0) {
                for (uint32 i = 0; i < initchunk->getSepChunksArraySize(); i++) {
                    if (initchunk->getSepChunks(i) == RE_CONFIG) {
                        state->peerStreamReset = true;
                        continue;
                    }
                    if (initchunk->getSepChunks(i) == PKTDROP) {
                        state->peerPktDrop = true;
                        EV_DEBUG << "set peerPktDrop to true\n";
                        continue;
                    }
                }
            }
            trans = performStateTransition(SCTP_E_RCV_INIT);
            if (trans) {
                sendInitAck(initchunk);
            }
        }
        else if (fsm->getState() == SCTP_S_CLOSED) {
            trans = performStateTransition(SCTP_E_RCV_INIT);
            if (trans) {
                sendInitAck(initchunk);
            }
        }
        else {
            trans = true;
        }
    }
    else if (fsm->getState() == SCTP_S_COOKIE_WAIT) {    //INIT-Collision
        EV_INFO << "INIT collision: send Init-Ack\n";
        if (initchunk->getHmacTypesArraySize() != 0) {
            state->peerAuth = true;
            if (state->peerChunkList.size() == 0) {
                for (uint32 j = 0; j < initchunk->getChunkTypesArraySize(); j++) {
                    type = initchunk->getChunkTypes(j);
                    if (type != INIT && type != INIT_ACK && type != AUTH && type != SHUTDOWN_COMPLETE) {
                        state->peerChunkList.push_back(type);
                    }
                }
            }
        }
        sendInitAck(initchunk);
        trans = true;
    }
    else if (fsm->getState() == SCTP_S_COOKIE_ECHOED || fsm->getState() == SCTP_S_ESTABLISHED) {
        // check, whether a new address has been added
        bool addressPresent = false;
        for (uint32 j = 0; j < initchunk->getAddressesArraySize(); j++) {
            if (initchunk->getAddresses(j).getType() == L3Address::IPv6)
                continue;
            for (auto & elem : remoteAddressList) {
                if ((elem) == (initchunk->getAddresses(j))) {
                    addressPresent = true;
                    break;
                }
            }
            if (!addressPresent) {
                sendAbort();
                return true;
            }
        }
        sendInitAck(initchunk);
        trans = true;
    }
    else if (fsm->getState() == SCTP_S_SHUTDOWN_ACK_SENT)
        trans = true;
    printSctpPathMap();
    return trans;
}

SCTPEventCode inet::sctp::SCTPAssociation::processOutAndResponseArrived ( SCTPOutgoingSSNResetRequestParameter *  outRequestParam, SCTPStreamResetResponseParameter *  responseParam  )

protected

Referenced by processStreamResetArrived().

{
    EV_TRACE << "processOutAndResponseArrived\n";
    if (getPath(remoteAddr)->ResetTimer->isScheduled()) {
        if (state->numResetRequests == 0) {
            SCTPResetTimer *tm = check_and_cast<SCTPResetTimer *>(PK(getPath(remoteAddr)->ResetTimer)->decapsulate());
            if (tm->getOutSN() == responseParam->getSrResSn()) {
                stopTimer(getPath(remoteAddr)->ResetTimer);
                delete state->resetChunk;
                state->resetChunk = nullptr;
            }
            delete tm;
        }
    }
    if (state->requests[outRequestParam->getSrResSn()].result != PERFORMED) {
        resetExpectedSsns();
        state->requests[outRequestParam->getSrResSn()].result = PERFORMED;
    }
    sendStreamResetResponse(outRequestParam->getSrReqSn(), PERFORMED);
    if (responseParam->getResult() == PERFORMED) {
        if (state->requests[responseParam->getSrResSn()].result != PERFORMED) {
            resetSsns();
          //  resetExpectedSsns();
            state->resetPending = false;
            sendIndicationToApp(SCTP_I_SEND_STREAMS_RESETTED);
            auto it = sctpMain->assocStatMap.find(assocId);
            it->second.numResetRequestsPerformed++;
        }
    }
    else {
        EV_INFO << "Reset Request failed. Send indication to app.\n";
        state->resetPending = false;
        sendIndicationToApp(SCTP_I_RESET_REQUEST_FAILED);
    }
    state->requests[responseParam->getSrResSn()].result = responseParam->getResult();
    return SCTP_E_IGNORE;
}

void inet::sctp::SCTPAssociation::processOutgoingResetRequestArrived ( SCTPOutgoingSSNResetRequestParameter *  requestParam )

protected

Referenced by processStreamResetArrived().

{
    EV_TRACE << "processOutgoingResetRequestArrived\n";
    if (!state->firstPeerRequest && (requestParam->getSrReqSn() < (state->peerRequestSn)) ) {
        // Retransmission
        sendStreamResetResponse(requestParam->getSrReqSn(), NO_RESET);
        return;
    }

    if (state->findRequestNum(requestParam->getSrResSn())) {
        state->requests[requestParam->getSrResSn()].result = PERFORMED;
        state->numResetRequests--;
        state->waitForResponse = false;
    }
    if (getPath(remoteAddr)->ResetTimer->isScheduled()) {
        if (state->numResetRequests == 0) {
            SCTPResetTimer *tm = check_and_cast<SCTPResetTimer *>(PK(getPath(remoteAddr)->ResetTimer)->decapsulate());
            if ((tm->getOutSN() == requestParam->getSrResSn() && !tm->getOutAcked()) ||
                (tm->getInSN() == requestParam->getSrResSn() && !tm->getInAcked())) {
                stopTimer(getPath(remoteAddr)->ResetTimer);
                delete state->resetChunk;
                state->resetChunk = nullptr;
                state->resetPending = false;
                state->localRequestType = 0;
                state->stopReceiving = false;
            }
            delete tm;
        }
    }
    if (requestParam->getStreamNumbersArraySize() > 0) {
        uint16 count = 0;
        for (uint16 i = 0; i < requestParam->getStreamNumbersArraySize(); i++) {
            if (!receiveStreamPresent(requestParam->getStreamNumbers(i))) {
                sendStreamResetResponse(requestParam->getSrReqSn(), DENIED);
                return;
            }
            if (getExpectedSsnOfStream(requestParam->getStreamNumbers(i)) != 0) {
                count++;
            }
        }
        if (count == 0 && !(tsnGt(requestParam->getLastTsn(), state->gapList.getHighestTSNReceived()))) {
            sendStreamResetResponse(requestParam->getSrReqSn(), NOTHING_TO_DO);
            return;
        }
    }
    if (state->streamReset && !(tsnGt(requestParam->getLastTsn(), state->gapList.getHighestTSNReceived()))) {
        if (requestParam->getStreamNumbersArraySize() > 0) {
            for (uint16 i = 0; i < requestParam->getStreamNumbersArraySize(); i++) {
                resetExpectedSsn(requestParam->getStreamNumbers(i));
            }
        } else {
            resetExpectedSsns();
        }
        EV_DETAIL << "processOutgoingResetRequestArrived: resetExpectedSsns\n";
        if (state->sendResponse == PERFORMED) {
            sendStreamResetResponse(requestParam->getSrReqSn(), PERFORMED);
            state->sendResponse = 0;
        } else {
            state->sendResponse = PERFORMED;
            state->responseSn = requestParam->getSrReqSn();
        }
    } else if (tsnGt(requestParam->getLastTsn(), state->gapList.getHighestTSNReceived())) {
        state->lastTsnBeforeReset = requestParam->getLastTsn();
        state->peerRequestSn = requestParam->getSrReqSn();
        sendStreamResetResponse(requestParam->getSrReqSn(), DEFERRED);
        state->incomingRequest = requestParam->dup();
        state->incomingRequestSet = true;
        state->resetDeferred = true;
       // state->firstPeerRequest = false;
    } else {
        sendStreamResetResponse(requestParam->getSrReqSn(), PERFORMED);
    }
}

bool inet::sctp::SCTPAssociation::processPacketDropArrived ( SCTPPacketDropChunk *  pktdrop )

protected

Referenced by process_RCV_Message().

{
    bool dataReceived = false;

    if (packetDropChunk->getMFlag() == false) {
        EV_TRACE << "processPacketDropArrived" << endl;
        if (packetDropChunk->getEncapsulatedPacket() != nullptr) {
            SCTPMessage *sctpmsg = (SCTPMessage *)(packetDropChunk->decapsulate());
            const uint32 numberOfChunks = sctpmsg->getChunksArraySize();
            EV_DETAIL << "numberOfChunks=" << numberOfChunks << endl;
            for (uint32 i = 0; i < numberOfChunks; i++) {
                SCTPChunk *chunk = (SCTPChunk *)(sctpmsg->removeChunk());
                const uint8 type = chunk->getChunkType();
                switch (type) {
                    case DATA: {
                        SCTPDataChunk *dataChunk = check_and_cast<SCTPDataChunk *>(chunk);
                        const uint32 tsn = dataChunk->getTsn();
                        auto pq = retransmissionQ->payloadQueue.find(tsn);
                        if ((pq != retransmissionQ->payloadQueue.end()) &&
                            (!chunkHasBeenAcked(pq->second))) {
                            EV_DETAIL << simTime() << ": Packet Drop for TSN "
                                      << pq->second->tsn << " on path "
                                      << pq->second->getLastDestination()
                                      << " -> transmitting it again" << endl;
                            putInTransmissionQ(pq->first, pq->second);
                        }
                        delete dataChunk->decapsulate();
                        dataReceived = true;
                        break;
                    }

                    case SACK:
                        sendSack();
                        break;

                    case INIT:
                        stopTimer(T1_InitTimer);
                        retransmitInit();
                        startTimer(T1_InitTimer, state->initRexmitTimeout);
                        break;

                    case HEARTBEAT:
                        sendHeartbeat(getPath(remoteAddr));
                        break;

                    case HEARTBEAT_ACK:
                        break;

                    case SHUTDOWN:
                        stopTimer(T2_ShutdownTimer);
                        retransmitShutdown();
                        startTimer(T2_ShutdownTimer, state->initRexmitTimeout);
                        break;

                    case SHUTDOWN_ACK:
                        stopTimer(T2_ShutdownTimer);
                        retransmitShutdownAck();
                        startTimer(T2_ShutdownTimer, state->initRexmitTimeout);
                        break;

                    case COOKIE_ECHO:
                        stopTimer(T1_InitTimer);
                        retransmitCookieEcho();
                        startTimer(T1_InitTimer, state->initRexmitTimeout);
                        break;

                    case COOKIE_ACK:
                        sendCookieAck(remoteAddr);
                        break;

                    case ASCONF:
                        stopTimer(getPath(remoteAddr)->AsconfTimer);
                        retransmitAsconf();
                        startTimer(getPath(remoteAddr)->AsconfTimer, getPath(remoteAddr)->pathRto);
                        break;

                    case FORWARD_TSN:
                        if (peekAbandonedChunk(getPath(remoteAddr)) != nullptr) {
                            SCTPMessage *sctpmsg = new SCTPMessage();
                            sctpmsg->setBitLength(SCTP_COMMON_HEADER * 8);
                            SCTPForwardTsnChunk *forwardChunk = createForwardTsnChunk(remoteAddr);
                            if (state->auth && state->peerAuth && typeInChunkList(FORWARD_TSN)) {
                                SCTPAuthenticationChunk *authChunk = createAuthChunk();
                                sctpmsg->addChunk(authChunk);
                            }
                            sctpmsg->addChunk(forwardChunk);
                        }
                        break;
                    default:
                        throw cRuntimeError("unknown chunk type");
                        break;

                }
                delete chunk;
            }
            disposeOf(sctpmsg);
        } else {
            EV_INFO << "no chunk encapsulated" << endl;
        }
        state->peerRwnd = packetDropChunk->getMaxRwnd()
            - packetDropChunk->getQueuedData()
            - getOutstandingBytes();
        statisticsPeerRwnd->record(state->peerRwnd);
        return dataReceived;
    }
    return false;
}

void inet::sctp::SCTPAssociation::processResetResponseArrived ( SCTPStreamResetResponseParameter *  responseParam )

protected

Referenced by processStreamResetArrived().

{
    EV_TRACE << "processResetResponseArrived \n";
    if (getPath(remoteAddr)->ResetTimer->isScheduled()) {
        if (PK(getPath(remoteAddr)->ResetTimer)->hasEncapsulatedPacket() &&
            (state->numResetRequests == 0 || (state->getNumRequestsNotPerformed() == 1 && responseParam->getResult() != DEFERRED))) {
            SCTPResetTimer *tm = check_and_cast<SCTPResetTimer *>(PK(getPath(remoteAddr)->ResetTimer)->decapsulate());
            EV_DETAIL << "SrResSn=" << responseParam->getSrResSn() << " tmOut=" << tm->getOutSN() << " tmIn= " << tm->getInSN() << "\n";
            if (tm->getOutSN() == responseParam->getSrResSn() || tm->getInSN() == responseParam->getSrResSn() || responseParam->getResult() > DEFERRED) {
                stopTimer(getPath(remoteAddr)->ResetTimer);
                delete state->resetChunk;
                state->resetChunk = nullptr;
                getPath(remoteAddr)->pathErrorCount = 0;
                if (state->streamsPending.size() == 0) {
                    delete state->resetInfo;
                    state->resetInfo = nullptr;
                }
            }
            delete tm;
            if (responseParam->getResult() > DEFERRED) {
                state->resetPending = false;
                state->resetRequested = false;
                state->waitForResponse = false;
                state->streamsPending.clear();
                state->resetOutStreams.clear();
                state->resetInStreams.clear();
                return;
            }
        }
    } else {
        if ((PK(getPath(remoteAddr)->ResetTimer)->hasEncapsulatedPacket())) {
            delete ((PK(getPath(remoteAddr)->ResetTimer)->decapsulate()));
        }
    }
    if (state->requests[responseParam->getSrResSn()].result != PERFORMED) {
        if (responseParam->getResult() == PERFORMED) {
            if (state->resetRequested) {
                if (state->resetOutStreams.size() > 0) {
                    for (auto & elem : state->resetOutStreams) {
                        resetSsn((elem));
                    }
                    state->resetOutStreams.clear();
                } else if (state->numAddedOutStreams == 0 && state->numAddedInStreams == 0) {
                    resetSsns();
                }
                if (state->streamsPending.size() == 0)
                    state->resetRequested = false;
            }
            state->resetPending = false;
            state->waitForResponse = false;
            if (responseParam->getReceiversNextTsn() != 0) {
                state->nextTSN = responseParam->getReceiversNextTsn();
                state->lastTsnAck = responseParam->getReceiversNextTsn() - 1;
                state->gapList.forwardCumAckTSN(responseParam->getSendersNextTsn() - 1);
                state->peerTsnAfterReset = responseParam->getSendersNextTsn();
                state->stopReceiving = false;
                state->stopOldData = true;
                if (state->resetInStreams.size() > 0) {
                    for (auto & elem : state->resetInStreams) {
                        resetExpectedSsn((elem));
                    }
                    state->resetInStreams.clear();
                } else {
                    resetExpectedSsns();
                }
               // sendSack();
            }
            if (state->localRequestType == ADD_BOTH) {
                if (state->numAddedOutStreams > 0) {
                    outboundStreams += state->numAddedOutStreams;
                    (this->*ssFunctions.ssAddOutStreams)(state->numAddedOutStreams);
                    state->numAddedOutStreams = 0;
                } else if (state->numAddedInStreams > 0) {
                    inboundStreams += state->numAddedInStreams;
                    (this->*ssFunctions.ssAddInStreams)(state->numAddedInStreams);
                    state->numAddedInStreams = 0;
                }
            } else if (state->localRequestType == ADD_INCOMING) {
                inboundStreams += state->numAddedInStreams;
                (this->*ssFunctions.ssAddInStreams)(state->numAddedInStreams);
                state->numAddedInStreams = 0;
            } else if (state->localRequestType == ADD_OUTGOING) {
                outboundStreams += state->numAddedOutStreams;
                (this->*ssFunctions.ssAddOutStreams)(state->numAddedOutStreams);
                state->numAddedOutStreams = 0;
            }
            sendIndicationToApp(SCTP_I_SEND_STREAMS_RESETTED);
            auto it = sctpMain->assocStatMap.find(assocId);
            it->second.numResetRequestsPerformed++;
        } else {
            EV_INFO << "Reset Request failed. Send indication to app.\n";
            if (responseParam->getResult() == DEFERRED) {
                state->numResetRequests++;
            } else {
                state->resetPending = false;
                sendIndicationToApp(SCTP_I_RESET_REQUEST_FAILED);
            }
        }
        state->requests[responseParam->getSrResSn()].result = responseParam->getResult();
    }
    if (state->incomingRequestSet && state->incomingRequest != nullptr && state->streamsPending.size() == 0) {
        delete state->incomingRequest;
        state->incomingRequest = nullptr;
        state->incomingRequestSet = false;
    }
}

SCTPEventCode inet::sctp::SCTPAssociation::processSackArrived ( SCTPSackChunk *  sackChunk )

protected

Referenced by process_RCV_Message().

{
    simtime_t rttEstimation = SIMTIME_MAX;
    const uint64 sendBufferBeforeUpdate = state->sendBuffer;
    SCTPPathVariables *path = getPath(remoteAddr);    // Path for *this* SACK!
    const uint64 arwnd = sackChunk->getA_rwnd();
    const uint32 tsna = sackChunk->getCumTsnAck();
    uint32 highestNewAck = tsna;    // Highest newly acked TSN
    const uint16 numDups = sackChunk->getNumDupTsns();
    SCTP::AssocStat *assocStat = sctpMain->getAssocStat(assocId);
    bool dropFilledGap = false;
    const uint32 msgRwnd = sackChunk->getMsg_rwnd();

    // ====== Put information from SACK into GapList =========================
    SCTPGapList sackGapList;
    sackGapList.setInitialCumAckTSN(sackChunk->getCumTsnAck());
    uint32 lastTSN = sackChunk->getCumTsnAck();
    for (uint32 i = 0; i < sackChunk->getNumGaps(); i++) {
        uint32 tsn = sackChunk->getGapStart(i);
        assert(tsnLt(lastTSN + 1, tsn));
        lastTSN = tsn;
        while (tsnLe(tsn, sackChunk->getGapStop(i))) {
            bool dummy;
            sackGapList.updateGapList(tsn, dummy, true);    // revokable TSN
            tsn++;
        }
        lastTSN = sackChunk->getGapStop(i);
    }
    if (assocStat) {
        assocStat->sumRGapRanges += ((sackChunk->getCumTsnAck() <= lastTSN) ?
                                     (uint64)(lastTSN - sackChunk->getCumTsnAck()) :
                                     (uint64)(sackChunk->getCumTsnAck() - lastTSN));
    }
    if (sackChunk->getNrSubtractRGaps() == false) {
        lastTSN = sackChunk->getCumTsnAck();
        for (uint32 i = 0; i < sackChunk->getNumNrGaps(); i++) {
            uint32 tsn = sackChunk->getNrGapStart(i);
            assert(tsnLt(lastTSN + 1, tsn));
            lastTSN = tsn;
            while (tsnLe(tsn, sackChunk->getNrGapStop(i))) {
                bool dummy;
                sackGapList.updateGapList(tsn, dummy, false);    // non-revokable TSN
                tsn++;
            }
            lastTSN = sackChunk->getNrGapStop(i);
        }
    }
    else {
        lastTSN = sackChunk->getCumTsnAck();
        for (uint32 i = 0; i < sackChunk->getNumNrGaps(); i++) {
            uint32 tsn = sackChunk->getNrGapStart(i);
            assert(tsnLt(lastTSN + 1, tsn));
            lastTSN = tsn;
            while (tsnLe(tsn, sackChunk->getNrGapStop(i))) {
                if (sackGapList.tsnIsRevokable(tsn) == false) {
                    bool dummy;
                    sackGapList.updateGapList(tsn, dummy, false);    // non-revokable TSN
                }
                tsn++;
            }
            lastTSN = sackChunk->getNrGapStop(i);
        }
    }
    if (assocStat) {
        assocStat->sumNRGapRanges += (sackChunk->getCumTsnAck() <= lastTSN) ?
            (uint64)(lastTSN - sackChunk->getCumTsnAck()) :
            (uint64)(sackChunk->getCumTsnAck() - lastTSN);
    }
    const uint16 numGaps = sackGapList.getNumGaps(SCTPGapList::GT_Any);

    // ====== Print some information =========================================
    EV_DETAIL << "##### SACK Processing: TSNa=" << tsna << " #####" << endl;
    for (auto & elem : sctpPathMap) {
        SCTPPathVariables *myPath = elem.second;
        EV_DETAIL << "Path " << myPath->remoteAddress << ":\t"
                  << "outstanding=" << path->outstandingBytes << "\t"
                  << "T3scheduled=" << path->T3_RtxTimer->getArrivalTime() << " "
                  << (path->T3_RtxTimer->isScheduled() ? "[ok]" : "[NOT SCHEDULED]") << "\t"
                  << "findPseudoCumAck=" << ((myPath->findPseudoCumAck == true) ? "true" : "false") << "\t"
                  << "pseudoCumAck=" << myPath->pseudoCumAck << "\t"
                  << "newPseudoCumAck=" << ((myPath->newPseudoCumAck == true) ? "true" : "false") << "\t"
                  << "findRTXPseudoCumAck=" << ((myPath->findRTXPseudoCumAck == true) ? "true" : "false") << "\t"
                  << "rtxPseudoCumAck=" << myPath->rtxPseudoCumAck << "\t"
                  << "newRTXPseudoCumAck=" << ((myPath->newRTXPseudoCumAck == true) ? "true" : "false") << "\t"
                  << endl;
    }

    EV_INFO << "Before processSackArrived for path " << path->remoteAddress
            << " with tsna=" << tsna << ":" << endl;

    // ====== SACK Sequence Number Check =====================================
    EV_INFO << "SACK Seq Number = " << sackChunk->getSackSeqNum() << endl;
    if ((state->checkSackSeqNumber == true) &&
        (sackChunk->getSackSeqNum() <= state->incomingSackSeqNum))
    {
        EV_DETAIL << "Out-of-data SACK: " << sackChunk->getSackSeqNum()
                  << " < " << state->incomingSackSeqNum << endl;
        return SCTP_E_IGNORE;
    }
    state->incomingSackSeqNum = sackChunk->getSackSeqNum();

    // ====== Record statistics ==============================================
    numGapBlocks->record(numGaps);
    statisticsRevokableGapBlocksInLastSACK->record(sackGapList.getNumGaps(SCTPGapList::GT_Revokable));
    statisticsNonRevokableGapBlocksInLastSACK->record(sackGapList.getNumGaps(SCTPGapList::GT_NonRevokable));

    path->vectorPathAckedTSNCumAck->record(tsna);
    if (assocStat) {
        assocStat->numDups += numDups;
    }

    // ====== Initialize some variables ======================================
    for (auto & elem : sctpPathMap) {
        SCTPPathVariables *myPath = elem.second;
        // T.D. 26.03.09: Remember outstanding bytes before this update
        // Values are necessary for updating the congestion window!
        myPath->outstandingBytesBeforeUpdate = myPath->outstandingBytes;    // copy from myPath, not from path!
        myPath->requiresRtx = false;
        myPath->lowestTSNRetransmitted = false;
        myPath->findLowestTSN = true;
        myPath->gapAckedChunksInLastSACK = 0;
        myPath->gapNRAckedChunksInLastSACK = 0;
        myPath->gapUnackedChunksInLastSACK = 0;
        myPath->newlyAckedBytes = 0;
        myPath->newCumAck = false;    // Check whether CumAck affects this path
        // for all destinations, set newPseudoCumAck to FALSE.
        myPath->newPseudoCumAck = false;
        myPath->newRTXPseudoCumAck = false;    // CUCv2
        myPath->sawNewAck = false;
        myPath->lowestNewAckInSack = 0;
        myPath->highestNewAckInSack = 0;
        myPath->newOldestChunkSendTime = simTime() + 9999.99;    // initialize to more than simTime()
        if (myPath == path) {
            myPath->lastAckTime = simTime();
        }
    }

    // ====== Zero Window Probing ============================================
    if ((state->peerAllowsChunks) && (msgRwnd > 0) && (state->zeroWindowProbing)) {
        state->zeroWindowProbing = false;
    }
    if ((state->zeroWindowProbing) && (arwnd > 0)) {
        state->zeroWindowProbing = false;
    }

    // #######################################################################
    // #### Processing of CumAck                                          ####
    // #######################################################################

    if (tsnGt(tsna, state->lastTsnAck)) {    // Handle new CumAck
        EV_INFO << "===== Handling new CumAck for TSN " << tsna << " =====" << endl;

        SCTPDataVariables *myChunk = retransmissionQ->getChunk(state->lastTsnAck + 1);
        if ((myChunk != nullptr) && (myChunk->wasPktDropped) &&
            (myChunk->getLastDestinationPath()->fastRecoveryActive))
        {
            dropFilledGap = true;
            EV_DETAIL << "TSN " << myChunk->tsn << " filled gap" << endl;
        }

        // We have got new chunks acked, and our cum ack point is advanced ...
        // Depending on the parameter osbWithHeader ackedBytes are with or without the header bytes.
        // T.D. 23.03.09: path->newlyAckedBytes is updated in dequeueAckedChunks()!
        dequeueAckedChunks(tsna, path, rttEstimation);    // chunks with tsn between lastTsnAck and tsna are removed from the transmissionQ and the retransmissionQ; outstandingBytes are decreased

        state->lastTsnAck = tsna;
        if (tsnGt(tsna, state->advancedPeerAckPoint)) {
            state->advancedPeerAckPoint = tsna;
            state->ackPointAdvanced = true;
        }
        // ====== Slow Path RTT Calculation ===================================
        if ((state->allowCMT == true) &&
            (state->cmtSlowPathRTTUpdate == true) &&
            (path->waitingForRTTCalculaton == true) &&
            ((path->tsnForRTTCalculation == tsna) ||
             (tsnLt(path->tsnForRTTCalculation, tsna))))
        {
            // Got update from CumAck -> no need for Slow Path RTT calculation
            path->waitingForRTTCalculaton = false;
        }
    }
    else if (tsnLt(tsna, state->lastTsnAck)) {
        EV_DETAIL << "Stale CumAck (" << tsna << " < " << state->lastTsnAck << ")"
                  << endl;
        // ====== Slow Path RTT Calculation ===================================
        if ((state->allowCMT == true) &&
            (state->cmtSlowPathRTTUpdate == true) &&
            (path->waitingForRTTCalculaton == true))
        {
            // Slow Path Update
            // Look for a CumAck or GapAck of the remembered chunk on this path.
            // If it has been found, we can compute the RTT of this path.

            // ====== Look for matching CumAck first ===========================
            bool renewRTT = false;
            if ((tsnLt(path->tsnForRTTCalculation, tsna)) ||
                (path->tsnForRTTCalculation == tsna))
            {
                renewRTT = true;
            }
            // ====== Look for matching GapAck =================================
            else if ((numGaps > 0) &&
                     ((path->tsnForRTTCalculation == sackGapList.getGapStop(SCTPGapList::GT_Any, numGaps - 1)) ||
                      (tsnLt(path->tsnForRTTCalculation, sackGapList.getGapStop(SCTPGapList::GT_Any, numGaps - 1)))))
            {
                for (int32 key = 0; key < numGaps; key++) {
                    const uint32 lo = sackGapList.getGapStart(SCTPGapList::GT_Any, key);
                    const uint32 hi = sackGapList.getGapStop(SCTPGapList::GT_Any, key);
                    if ((path->tsnForRTTCalculation == lo) ||
                        (path->tsnForRTTCalculation == hi) ||
                        (tsnLt(lo, path->tsnForRTTCalculation) &&
                         tsnLt(path->tsnForRTTCalculation, hi)))
                    {
                        renewRTT = true;
                        break;
                    }
                }
            }

            if (renewRTT) {
                rttEstimation = simTime() - path->txTimeForRTTCalculation;
                path->waitingForRTTCalculaton = false;
                pmRttMeasurement(path, rttEstimation);

                EV_DETAIL << simTime() << ": SlowPathRTTUpdate from stale SACK - rtt="
                          << rttEstimation << " from TSN "
                          << path->tsnForRTTCalculation
                          << " on path " << path->remoteAddress
                          << " => RTO=" << path->pathRto << endl;
            }
        }
        return SCTP_E_IGNORE;
    }

    // ====== Handle reneging ================================================
    if ((numGaps == 0) && (tsnLt(tsna, state->highestTsnAcked))) {
        // Reneging, type 0:
        // In a previous SACK, chunks up to highestTsnAcked have been acked.
        // This SACK contains a CumAck < highestTsnAcked
        //      => rereg TSNs from CumAck+1 to highestTsnAcked
        //      => new highestTsnAcked = CumAck
        EV_DETAIL << "numGaps=0 && tsna " << tsna
                  << " < highestTsnAcked " << state->highestTsnAcked << endl;
        uint32 i = state->highestTsnAcked;
        while (i >= tsna + 1) {
            SCTPDataVariables *myChunk = retransmissionQ->getChunk(i);
            if (myChunk) {
                if (chunkHasBeenAcked(myChunk)) {
                    tsnWasReneged(myChunk, path, 0);
                }
            }
            i--;
        }
        state->highestTsnAcked = tsna;
    }

    // #######################################################################
    // #### Processing of GapAcks                                         ####
    // #######################################################################

    if ((numGaps > 0) && (!retransmissionQ->payloadQueue.empty())) {
        EV_INFO << "===== Handling GapAcks after CumTSNAck " << tsna << " =====" << endl;
        EV_INFO << "We got " << numGaps << " gap reports" << endl;

        // We got fragment reports... check for newly acked chunks.
        const uint32 queuedChunks = retransmissionQ->payloadQueue.size();
        EV_DETAIL << "Number of chunks in retransmissionQ: " << queuedChunks
                  << " highestGapStop: " << sackGapList.getGapStop(SCTPGapList::GT_Any, numGaps - 1)
                  << " highestTsnAcked: " << state->highestTsnAcked << endl;

        // ====== Handle reneging =============================================
        // highest gapStop smaller than highestTsnAcked: there might have been reneging
        if (tsnLt(sackGapList.getGapStop(SCTPGapList::GT_Any, numGaps - 1), state->highestTsnAcked)) {
            // Reneging, type 2:
            // In a previous SACK, chunks up to highestTsnAcked have been acked.
            // This SACK contains a last gap ack < highestTsnAcked
            //      => rereg TSNs from last gap ack to highestTsnAcked
            //      => new highestTsnAcked = last gap ack
            uint32 i = state->highestTsnAcked;
            while (i >= sackGapList.getGapStop(SCTPGapList::GT_Any, numGaps - 1) + 1) {
                // ====== Looking up TSN in retransmission queue ================
                SCTPDataVariables *myChunk = retransmissionQ->getChunk(i);
                if (myChunk) {
                    if (chunkHasBeenAcked(myChunk)) {
                        EV_INFO << "TSN " << i << " was found. It has been un-acked." << endl;
                        tsnWasReneged(myChunk, path, 2);
                        EV_DETAIL << "highestTsnAcked now " << state->highestTsnAcked << endl;
                    }
                }
                else {
                    EV_INFO << "TSN " << i << " not found in retransmissionQ" << endl;
                }
                i--;
            }
            state->highestTsnAcked = sackGapList.getGapStop(SCTPGapList::GT_Any, numGaps - 1);
        }

        // ====== Looking for changes in the gap reports ======================
        EV_INFO << "Looking for changes in gap reports" << endl;
        // Get Pseudo CumAck for paths
        uint32 lo1 = tsna;
        uint32 tsnCheck = tsna + 1;    // Just to make sure that no TSN is misssed
        for (int32 key = 0; key < numGaps; key++) {
            const uint32 lo = sackGapList.getGapStart(SCTPGapList::GT_Any, key);
            const uint32 hi = sackGapList.getGapStop(SCTPGapList::GT_Any, key);

            // ====== Iterate over TSNs *not* listed in gap reports ============
            for (uint32 pos = lo1 + 1; pos <= lo - 1; pos++) {
                assert(tsnCheck == pos);
                tsnCheck++;
                SCTPDataVariables *myChunk = retransmissionQ->getChunk(pos);
                if (myChunk) {
                    SCTPPathVariables *myChunkLastPath = myChunk->getLastDestinationPath();
                    assert(myChunkLastPath != nullptr);
                    // T.D. 22.11.09: CUCv2 - chunk is *not* acked
                    cucProcessGapReports(myChunk, myChunkLastPath, false);
                }
            }
            lo1 = sackGapList.getGapStop(SCTPGapList::GT_Any, key);
            // ====== Iterate over TSNs in gap reports =========================
            EV_INFO << "Examine TSNs between " << lo << " and " << hi << endl;
            for (uint32 pos = lo; pos <= hi; pos++) {
                bool chunkFirstTime = true;
                assert(tsnCheck == pos);
                tsnCheck++;
                SCTPDataVariables *myChunk = retransmissionQ->getChunkFast(pos, chunkFirstTime);
                if (myChunk) {
                    if (chunkHasBeenAcked(myChunk) == false) {
                        SCTPPathVariables *myChunkLastPath = myChunk->getLastDestinationPath();
                        assert(myChunkLastPath != nullptr);
                        // CUCv2 - chunk is acked
                        cucProcessGapReports(myChunk, myChunkLastPath, true);
                        // This chunk has been acked newly.
                        // Let's process this new acknowledgement!
                        handleChunkReportedAsAcked(highestNewAck, rttEstimation, myChunk,
                                path    /* i.e. the SACK path for RTT measurement! */,
                                sackGapList.tsnIsNonRevokable(myChunk->tsn));
                    }
                    else {
                        // Slow Path RTT Calculation
                        if ((path->tsnForRTTCalculation == myChunk->tsn) &&
                            (path->waitingForRTTCalculaton == true) &&
                            (state->allowCMT == true) &&
                            (state->cmtSlowPathRTTUpdate == true) &&
                            (myChunk->getLastDestinationPath() == path))
                        {
                            const simtime_t rttEstimation = simTime() - path->txTimeForRTTCalculation;
                            path->waitingForRTTCalculaton = false;
                            pmRttMeasurement(path, rttEstimation);

                            EV << simTime() << ": SlowPathRTTUpdate from gap report - rtt="
                               << rttEstimation << " from TSN "
                               << path->tsnForRTTCalculation
                               << " on path " << path->remoteAddress
                               << " => RTO=" << path->pathRto << endl;
                        }
                    }
                }
                // ====== R-acked chunk became NR-acked =========================
                else if (sackGapList.tsnIsNonRevokable(pos)) {
                    bool chunkFirstTime = false;
                    SCTPDataVariables *myChunk = retransmissionQ->getChunkFast(pos, chunkFirstTime);
                    if (myChunk) {
                        // myChunk != nullptr -> R-acked before, but not NR-acked
                        handleChunkReportedAsAcked(highestNewAck, rttEstimation, myChunk,
                                path    /* i.e. the SACK path for RTT measurement! */,
                                sackGapList.tsnIsNonRevokable(myChunk->tsn));
                        // All NR-acked chunks have chunkMap->getChunk(pos) == nullptr!
                    }
                }
            }
        }
        state->highestTsnAcked = sackGapList.getGapStop(SCTPGapList::GT_Any, numGaps - 1);

        // ====== Examine chunks between the gap reports ======================
        // They might have to be retransmitted or they could have been removed
        uint32 lo = tsna;
        for (int32 key = 0; key < numGaps; key++) {
            const uint32 hi = sackGapList.getGapStart(SCTPGapList::GT_Any, key);
            for (uint32 pos = lo + 1; pos <= hi - 1; pos++) {
                bool chunkFirstTime = true;
                SCTPDataVariables *myChunk = retransmissionQ->getChunkFast(pos, chunkFirstTime);
                if (myChunk) {
                    handleChunkReportedAsMissing(sackChunk, highestNewAck, myChunk,
                            path    /* i.e. the SACK path for RTT measurement! */);
                }
                else {
                    EV_INFO << "TSN " << pos << " not found in retransmissionQ" << endl;
                }
            }
            lo = sackGapList.getGapStop(SCTPGapList::GT_Any, key);
        }

        // ====== Validity checks =============================================
        path->vectorPathAckedTSNGapAck->record(state->highestTsnAcked);
    }

    // ====== Buffer space may have been gained => tell application ==========
    if (sendBufferBeforeUpdate != state->sendBuffer) {
        generateSendQueueAbatedIndication(sendBufferBeforeUpdate - state->sendBuffer);
    }

    // ====== Update Fast Recovery status, according to SACK =================
    updateFastRecoveryStatus(state->lastTsnAck);

    // ====== Update RTT measurement for newly acked data chunks =============
    EV_DETAIL << simTime() << ": SACK: rtt=" << rttEstimation
              << ", path=" << path->remoteAddress << endl;
    pmRttMeasurement(path, rttEstimation);

    // ====== Record statistics ==============================================
    for (auto & elem : sctpPathMap) {
        SCTPPathVariables *myPath = elem.second;
        myPath->statisticsPathGapAckedChunksInLastSACK->record(myPath->gapAckedChunksInLastSACK);
        myPath->statisticsPathGapNRAckedChunksInLastSACK->record(myPath->gapNRAckedChunksInLastSACK);
        myPath->statisticsPathGapUnackedChunksInLastSACK->record(myPath->gapUnackedChunksInLastSACK);
    }

    // #######################################################################
    // #### Receiver Window Management                                    ####
    // #######################################################################

    const uint32 osb = getOutstandingBytes();
    if (state->bytesToAddPerPeerChunk > 0) {
        state->peerRwnd = arwnd - osb - (state->outstandingMessages * state->bytesToAddPerPeerChunk);
    }
    else if (state->peerAllowsChunks) {
        state->peerMsgRwnd = msgRwnd - state->outstandingMessages;
        state->peerRwnd = arwnd - osb;
        if ((int32)(state->peerMsgRwnd) < 0) {
            state->peerMsgRwnd = 0;
        }
        if (state->peerMsgRwnd > state->initialPeerMsgRwnd) {
            state->peerMsgRwnd = state->initialPeerMsgRwnd;
        }
    }
    else {
        state->peerRwnd = arwnd - osb;
    }

    // position of statement changed 20.07.05 I.R.
    if ((int32)(state->peerRwnd) < 0) {
        state->peerRwnd = 0;
    }
    if (state->peerRwnd > state->initialPeerRwnd) {
        state->peerRwnd = state->initialPeerRwnd;
    }
    if (state->peerAllowsChunks && msgRwnd == 0) {
        state->peerWindowFull = true;
    }
    if (arwnd == 1 || state->peerRwnd < state->swsLimit || arwnd == 0) {
        EV_INFO << "processSackArrived: arwnd=" << arwnd
                << " state->peerRwnd=" << state->peerRwnd
                << " set peerWindowFull" << endl;
        state->peerWindowFull = true;
    }
    else if ((state->peerAllowsChunks && msgRwnd > 0) || !state->peerAllowsChunks) {
        state->peerWindowFull = false;
        state->zeroWindowProbing = false;
    }
    advancePeerTsn();
    statisticsArwndInLastSACK->record(arwnd);
    statisticsPeerRwnd->record(state->peerRwnd);

    // ====== Need for zero-window probing? ==================================
    if (osb == 0) {
        if ((state->peerAllowsChunks && msgRwnd == 0) || arwnd == 0)
            state->zeroWindowProbing = true;
    }

    // #######################################################################
    // #### Congestion Window Management                                  ####
    // #######################################################################

    // ======= Update congestion window of each path =========================
    EV_DEBUG << "Before ccUpdateBytesAcked: ";
    for (auto & elem : sctpPathMap) {
        SCTPPathVariables *myPath = elem.second;
        const L3Address& myPathId = myPath->remoteAddress;

        if (myPath->newPseudoCumAck) {
            myPath->vectorPathPseudoCumAck->record(myPath->pseudoCumAck);
        }
        if (myPath->newRTXPseudoCumAck) {
            myPath->vectorPathRTXPseudoCumAck->record(myPath->rtxPseudoCumAck);
        }
        if (myPath->newlyAckedBytes > 0) {
            // Only call ccUpdateBytesAcked() when there are
            // acked bytes on this path!
            bool advanceWindow = myPath->newPseudoCumAck || myPath->newRTXPseudoCumAck;
            if (state->allowCMT == true) {
                if (state->cmtCUCVariant == SCTPStateVariables::CUCV_PseudoCumAckV2) {
                    advanceWindow = myPath->newPseudoCumAck || myPath->newRTXPseudoCumAck;
                }
                else if (state->cmtCUCVariant == SCTPStateVariables::CUCV_PseudoCumAck) {
                    advanceWindow = myPath->newPseudoCumAck;
                }
                else if (state->cmtCUCVariant == SCTPStateVariables::CUCV_Normal) {
                    advanceWindow = myPath->newCumAck;
                }
            }
            EV_DETAIL << simTime() << ":\tCC " << myPath->newlyAckedBytes
                      << " newly acked on path " << myPathId << ";"
                      << "\tpath->newPseudoCumAck=" << ((myPath->newPseudoCumAck == true) ? "true" : "false")
                      << "\tpath->newRTXPseudoCumAck=" << ((myPath->newRTXPseudoCumAck == true) ? "true" : "false")
                      << "\tdropFilledGap=" << ((dropFilledGap == true) ? "true" : "false")
                      << "\t->\tadvanceWindow=" << advanceWindow << endl;

            (this->*ccFunctions.ccUpdateBytesAcked)(myPath, myPath->newlyAckedBytes,
                    (advanceWindow && dropFilledGap) ? false :
                    advanceWindow);
            if (state->maxBurstVariant == SCTPStateVariables::MBV_MaxBurst) {
                myPath->packetsInBurst = 0;
            }
        }
    }

    // ====== Update congestion windows on paths (handling decreases) ========
    EV_DEBUG << "Before ccUpdateAfterSack with tsna=" << tsna << endl;
    // ccUpdateAfterSack() will iterate over all paths.
    (this->*ccFunctions.ccUpdateAfterSack)();

    // #######################################################################
    // #### Path Management                                               ####
    // #######################################################################

    if ((state->allowCMT == true) &&
        (state->cmtSmartT3Reset == true))
    {
        // ====== Find oldest unacked chunk on each path ======================
        for (SCTPQueue::PayloadQueue::const_iterator iterator = retransmissionQ->payloadQueue.begin();
             iterator != retransmissionQ->payloadQueue.end(); ++iterator)
        {
            const SCTPDataVariables *myChunk = iterator->second;
            SCTPPathVariables *myChunkLastPath = myChunk->getLastDestinationPath();
            if (!chunkHasBeenAcked(myChunk)) {
                if (myChunkLastPath->newOldestChunkSendTime > myChunk->sendTime) {
                    EV_DETAIL << "TSN " << myChunk->tsn << " is new oldest on path "
                              << myChunkLastPath->remoteAddress << ", rel send time is "
                              << simTime() - myChunk->sendTime << " ago" << endl;
                    myChunkLastPath->newOldestChunkSendTime = myChunk->sendTime;
                    myChunkLastPath->oldestChunkTSN = myChunk->tsn;
                }
            }
        }
    }

    // ====== Need to stop or restart T3 timer? ==============================
    for (auto & elem : sctpPathMap) {
        SCTPPathVariables *myPath = elem.second;
        const L3Address& myPathId = myPath->remoteAddress;

        // ====== Smart T3 Reset ===============================================
        bool updatedOldestChunkSendTime = false;
        if ((state->allowCMT == true) &&
            (state->cmtSmartT3Reset == true))
        {
            // ====== Has oldest chunk send time been updated? =================
            if (myPath->newOldestChunkSendTime > simTime()) {
                myPath->newOldestChunkSendTime = myPath->oldestChunkSendTime;
                // newOldestChunkSendTime > simTime => no old chunk found:
                // Set newOldestChunkSendTime to oldestChunkSendTime
            }
            else if (myPath->newOldestChunkSendTime != myPath->oldestChunkSendTime) {
                // Update oldestChunkSendTime.
                myPath->oldestChunkSendTime = myPath->newOldestChunkSendTime;
                updatedOldestChunkSendTime = true;
            }
            assert(myPath->oldestChunkSendTime <= simTime());
        }
        if (myPath->outstandingBytes == 0) {
            // T.D. 07.01.2010: Only stop T3 timer when there is nothing more to send on this path!
            if (qCounter.roomTransQ.find(myPath->remoteAddress)->second == 0) {
                // Stop T3 timer, if there are no more outstanding bytes.
                stopTimer(myPath->T3_RtxTimer);
                myPath->oldestChunkSendTime = SIMTIME_ZERO;
            }
        }
        else if (myPath->newCumAck) {    // Only care for CumAcks here!
            // NOTE: Due to the existence of retransmissions *before* PseudoCumAck for CUCv2,
            //       it is *not* possible to check PseudoCumAck here!
            //       This would miss retransmissions -> chunks would never be retransmitted!
            stopTimer(myPath->T3_RtxTimer);
            startTimer(myPath->T3_RtxTimer, myPath->pathRto);
        }
        else if (updatedOldestChunkSendTime) {    // Smart T3 Reset
            stopTimer(myPath->T3_RtxTimer);
            startTimer(myPath->T3_RtxTimer, myPath->pathRto);
        }
        else {
            /* Also restart T3 timer, when lowest TSN is rtx'ed */
            if (myPath->lowestTSNRetransmitted == true) {
                EV_INFO << "Lowest TSN retransmitted => restart of T3 timer for path "
                        << myPathId << endl;
                stopTimer(myPath->T3_RtxTimer);
                startTimer(myPath->T3_RtxTimer, myPath->pathRto);
            }
        }

        // ====== Clear error counter if TSNs on path have been acked =========
        if (myPath->newlyAckedBytes > 0) {
            pmClearPathCounter(myPath);
        }
    }

    return SCTP_E_IGNORE;
}

bool inet::sctp::SCTPAssociation::processSCTPMessage	(	SCTPMessage *	sctpmsg,
		const L3Address &	srcAddr,
		const L3Address &	destAddr
	)

Process incoming SCTP segment.

Normally returns true. A return value of false means that the connection structure must be deleted by the caller (SCTP).

Referenced by inet::sctp::SCTP::handleMessage().

{
    printAssocBrief();

    localAddr = msgDestAddr;
    localPort = sctpmsg->getDestPort();
    remoteAddr = msgSrcAddr;
    remotePort = sctpmsg->getSrcPort();

    if (fsm->getState() == SCTP_S_ESTABLISHED) {
        bool found = false;
        for (auto & elem : state->localAddresses) {
            if ((elem) == msgDestAddr) {
                found = true;
                break;
            }
        }
        if (!found) {
            EV_INFO << "destAddr " << msgDestAddr << " is not bound to host\n";
            return true;
        }
    }

    return process_RCV_Message(sctpmsg, msgSrcAddr, msgDestAddr);
}

void inet::sctp::SCTPAssociation::processSSNTSNResetRequestArrived ( SCTPSSNTSNResetRequestParameter *  requestParam )

protected

Referenced by checkStreamsToReset(), and processStreamResetArrived().

{
    EV_TRACE << "processSSNTSNResetRequestArrived\n";
    if (!state->firstPeerRequest && (requestParam->getSrReqSn() < (state->peerRequestSn)) ) {
        // Retransmission
        sendStreamResetResponse(requestParam->getSrReqSn(), NO_RESET);
        return;
    }
    if (!state->fragInProgress && state->outstandingBytes == 0) {
        state->advancedPeerAckPoint = state->nextTSN - 1;
        state->stopOldData = true;
      //  resetExpectedSsns();
        if (state->sendResponse == PERFORMED) {
            sendStreamResetResponse(requestParam, PERFORMED, true);
            state->sendResponse = 0;
        } else {
            state->sendResponse = PERFORMED_WITH_OPTION;
            state->responseSn = requestParam->getSrReqSn();
            state->peerRequestType = SSN_TSN;
            state->incomingRequest = (SCTPParameter *)requestParam->dup();        //FIXME is the c-style conversion need here?
            state->incomingRequestSet = true;
        }
    } else {
        sendStreamResetResponse(requestParam, DEFERRED, true);
        state->incomingRequest = (SCTPParameter *)requestParam->dup();        //FIXME is the c-style conversion need here?
        state->incomingRequestSet = true;
        state->incomingRequest->setName("SSNDeferred");
        state->peerRequestSn = requestParam->getSrReqSn();
      //  state->firstPeerRequest = false;
        state->peerRequestType = SSN_TSN;
        state->resetDeferred = true;
    }
}

SCTPEventCode inet::sctp::SCTPAssociation::processStreamResetArrived ( SCTPStreamResetChunk *  strResChunk )

protected

Referenced by process_RCV_Message().

{
    SCTPParameter *parameter, *nextParam;
    bool requestReceived = false;
    std::map<uint32, SCTPStateVariables::RequestData>::reverse_iterator rit;
    uint32 numberOfParameters = resetChunk->getParametersArraySize();
    EV_TRACE << "processStreamResetArrived\n";

    if (numberOfParameters == 0)
        return SCTP_E_IGNORE;
    for (uint16 i = 0; i < numberOfParameters; i++) {
        parameter = (SCTPParameter *)(resetChunk->getParameters(i));
        switch (parameter->getParameterType()) {
            case OUTGOING_RESET_REQUEST_PARAMETER: {
                SCTPOutgoingSSNResetRequestParameter *outRequestParam;
                outRequestParam = check_and_cast<SCTPOutgoingSSNResetRequestParameter *>(parameter);
                if (state->findPeerRequestNum(outRequestParam->getSrReqSn())) {
                    // retransmission
                    if (state->peerRequests[outRequestParam->getSrReqSn()].type != outRequestParam->getParameterType()) {
                        sendStreamResetResponse(outRequestParam->getSrReqSn(), NO_RESET);
                        return SCTP_E_IGNORE;
                    }
                    if (state->peerRequests[outRequestParam->getSrReqSn()].result != 100) {
                        std::map<uint32, SCTPStateVariables::RequestData>::reverse_iterator rit;
                        rit = state->peerRequests.rbegin();
                        if (state->peerRequests[outRequestParam->getSrReqSn()].sn == rit->first) {
                        // send response with same result
                            sendStreamResetResponse(outRequestParam->getSrReqSn(), state->peerRequests[outRequestParam->getSrReqSn()].result);
                            return SCTP_E_IGNORE;
                        } else {
                            sendStreamResetResponse(outRequestParam->getSrReqSn(), NO_RESET);
                            return SCTP_E_IGNORE;
                        }
                    }
                }
                if (state->firstPeerRequest && outRequestParam->getSrReqSn() != state->expectedStreamResetSequenceNumber) {
                    if (state->peerRequests.size() > 0) {
                        sendStreamResetResponse(outRequestParam->getSrReqSn(), REQUEST_IN_PROGRESS);
                    } else {
                        sendStreamResetResponse(outRequestParam->getSrReqSn(), NO_RESET);
                    }
                    break;
                }
                state->peerRequests[outRequestParam->getSrReqSn()].sn = outRequestParam->getSrReqSn();
                state->peerRequests[outRequestParam->getSrReqSn()].result = 100;
                state->peerRequests[outRequestParam->getSrReqSn()].type = outRequestParam->getParameterType();
                if (numberOfParameters > i + 1) {
                    nextParam = (SCTPParameter *)(resetChunk->getParameters(i + 1));
                    if (nextParam->getParameterType() != INCOMING_RESET_REQUEST_PARAMETER &&
                        nextParam->getParameterType() != STREAM_RESET_RESPONSE_PARAMETER) {
                        processOutgoingResetRequestArrived(outRequestParam);
                        delete nextParam;
                    } else {
                        switch (nextParam->getParameterType()) {
                            case INCOMING_RESET_REQUEST_PARAMETER:
                            SCTPIncomingSSNResetRequestParameter *inRequestParam;
                            inRequestParam = check_and_cast<SCTPIncomingSSNResetRequestParameter *>(nextParam);
                            state->peerRequests[inRequestParam->getSrReqSn()].sn = inRequestParam->getSrReqSn();
                            state->peerRequests[inRequestParam->getSrReqSn()].result = 100;
                            state->peerRequests[inRequestParam->getSrReqSn()].type = inRequestParam->getParameterType();
                            processInAndOutResetRequestArrived(inRequestParam, outRequestParam);
                            i++;
                            break;

                        case STREAM_RESET_RESPONSE_PARAMETER:
                            SCTPStreamResetResponseParameter *responseParam;
                            responseParam = check_and_cast<SCTPStreamResetResponseParameter *>(nextParam);
                            state->numResetRequests -= 2;
                            processOutAndResponseArrived(outRequestParam, responseParam);
                            i++;
                            break;
                        }
                    }
                } else {
                    processOutgoingResetRequestArrived(outRequestParam);
                }
                requestReceived = true;
                break;
            }

            case INCOMING_RESET_REQUEST_PARAMETER: {
                SCTPIncomingSSNResetRequestParameter *inRequestParam;
                inRequestParam = check_and_cast<SCTPIncomingSSNResetRequestParameter *>(parameter);
                rit = state->peerRequests.rbegin();
                if (state->firstPeerRequest && (inRequestParam->getSrReqSn() != state->expectedStreamResetSequenceNumber)) {
                    sendStreamResetResponse(inRequestParam->getSrReqSn(), NO_RESET);
                    return SCTP_E_IGNORE;
                }
                if (!state->firstPeerRequest &&
                    (((inRequestParam->getSrReqSn() < (state->peerRequestSn)) &&
                    (inRequestParam->getSrReqSn() != rit->first + 1)) ||
                    (state->findPeerRequestNum(inRequestParam->getSrReqSn()) && state->peerRequests[inRequestParam->getSrReqSn()].type != inRequestParam->getParameterType()))) {
                    sendStreamResetResponse(inRequestParam->getSrReqSn(), NO_RESET);
                    return SCTP_E_IGNORE;
                }
                rit = state->requests.rbegin();
                if (rit->second.type == OUTGOING_RESET_REQUEST_PARAMETER && (rit->second.result == 100 || rit->second.result == PERFORMED)) {
                    state->requestsOverlap = true;
                    if (state->requests[rit->first].lastTsn == state->nextTSN - 1) {
                    if (inRequestParam->getStreamNumbersArraySize() > 0) {
                        uint16 match = 0;
                        for (uint i = 0; i < inRequestParam->getStreamNumbersArraySize(); i++) {
                            std::list<uint16>::iterator it;
                            for (it = state->requests[rit->first].streams.begin(); it != state->requests[rit->first].streams.end(); it++) {
                                if ((*it) == inRequestParam->getStreamNumbers(i))
                                    match++;
                            }
                        }
                        if (match == inRequestParam->getStreamNumbersArraySize()) {
                            sendStreamResetResponse(inRequestParam->getSrReqSn(), NOTHING_TO_DO);
                            return SCTP_E_IGNORE;
                        }
                    } else {
                        sendStreamResetResponse(inRequestParam->getSrReqSn(), NOTHING_TO_DO);
                        return SCTP_E_IGNORE;
                    }
                    }
                }
                state->peerRequests[inRequestParam->getSrReqSn()].sn = inRequestParam->getSrReqSn();
                state->peerRequests[inRequestParam->getSrReqSn()].result = 100;
                state->peerRequests[inRequestParam->getSrReqSn()].type = inRequestParam->getParameterType();
                if (numberOfParameters > i + 1) {
                    nextParam = (SCTPParameter *)(resetChunk->getParameters(i + 1));
                    if (nextParam->getParameterType() != OUTGOING_RESET_REQUEST_PARAMETER) {
                        processIncomingResetRequestArrived(inRequestParam);
                    } else {
                        if (nextParam->getParameterType() == OUTGOING_RESET_REQUEST_PARAMETER) {
                            i++;
                            SCTPOutgoingSSNResetRequestParameter *outRequestParam;
                            outRequestParam = check_and_cast<SCTPOutgoingSSNResetRequestParameter *>(nextParam->dup());
                            state->peerRequests[outRequestParam->getSrReqSn()].sn = outRequestParam->getSrReqSn();
                            state->peerRequests[outRequestParam->getSrReqSn()].result = 100;
                            state->peerRequests[outRequestParam->getSrReqSn()].type = outRequestParam->getParameterType();
                            processInAndOutResetRequestArrived(inRequestParam, outRequestParam);
                            delete outRequestParam;
                        }
                    }
                } else {
                    processIncomingResetRequestArrived(inRequestParam);
                }
                requestReceived = true;
                break;
            }

            case SSN_TSN_RESET_REQUEST_PARAMETER:
                SCTPSSNTSNResetRequestParameter *ssnRequestParam;
                ssnRequestParam = check_and_cast<SCTPSSNTSNResetRequestParameter *>(parameter);
                rit = state->peerRequests.rbegin();
                if (state->firstPeerRequest && ssnRequestParam->getSrReqSn() != state->expectedStreamResetSequenceNumber) {
                    if (state->peerRequests.size() > 0) {
                        sendStreamResetResponse(ssnRequestParam->getSrReqSn(), REQUEST_IN_PROGRESS);
                    } else {
                        sendStreamResetResponse(ssnRequestParam->getSrReqSn(), NO_RESET);
                    }
                    break;
                }
                if (!state->firstPeerRequest &&
                    ((((ssnRequestParam->getSrReqSn() < (state->peerRequestSn)) && (ssnRequestParam->getSrReqSn() != rit->first + 1))) ||
                    ((state->findPeerRequestNum(ssnRequestParam->getSrReqSn())) &&
                    state->peerRequests[ssnRequestParam->getSrReqSn()].type != ssnRequestParam->getParameterType()))) {
                    sendStreamResetResponse(ssnRequestParam->getSrReqSn(), NO_RESET);
                    return SCTP_E_IGNORE;
                }
                if (state->nextTSN == state->streamResetSequenceNumber && state->gapList.getCumAckTSN() < initPeerTsn) {
                    sendStreamResetResponse(ssnRequestParam, NOTHING_TO_DO, true);
                    break;
                }
                state->peerRequests[ssnRequestParam->getSrReqSn()].sn = ssnRequestParam->getSrReqSn();
                state->peerRequests[ssnRequestParam->getSrReqSn()].result = 100;
                state->peerRequests[ssnRequestParam->getSrReqSn()].type = ssnRequestParam->getParameterType();
                processSSNTSNResetRequestArrived(ssnRequestParam);
                requestReceived = true;
                break;

            case ADD_INCOMING_STREAMS_REQUEST_PARAMETER: {
                SCTPAddStreamsRequestParameter *addStreamsParam =
                    check_and_cast<SCTPAddStreamsRequestParameter *>(parameter);
                if (addStreamsParam->getNumberOfStreams() == 0) {
                    sendStreamResetResponse(addStreamsParam->getSrReqSn(), NOTHING_TO_DO);
                    return SCTP_E_IGNORE;
                }
                rit = state->peerRequests.rbegin();
                if ((state->firstPeerRequest && addStreamsParam->getSrReqSn() != state->expectedStreamResetSequenceNumber) ||
                    (!state->firstPeerRequest && ((addStreamsParam->getSrReqSn() < (state->peerRequestSn)) &&
                    (addStreamsParam->getSrReqSn() != rit->first + 1))) ||
                    (state->findPeerRequestNum(addStreamsParam->getSrReqSn()) &&
                    state->peerRequests[addStreamsParam->getSrReqSn()].type != addStreamsParam->getParameterType())) {
                    sendStreamResetResponse(addStreamsParam->getSrReqSn(), NO_RESET);
                    return SCTP_E_IGNORE;
                }
                if (!(addStreamsParam->getNumberOfStreams() + outboundStreams <= 65535)) {
                    sendStreamResetResponse(addStreamsParam->getSrReqSn(), DENIED);
                    return SCTP_E_IGNORE;
                }
                state->peerRequests[addStreamsParam->getSrReqSn()].sn = addStreamsParam->getSrReqSn();
                state->peerRequests[addStreamsParam->getSrReqSn()].result = 100;
                state->peerRequests[addStreamsParam->getSrReqSn()].type = addStreamsParam->getParameterType();
                if (numberOfParameters > i + 1) {
                    nextParam = (SCTPParameter *)(resetChunk->getParameters(i + 1));
                    if (nextParam->getParameterType() == ADD_OUTGOING_STREAMS_REQUEST_PARAMETER) {
                        SCTPAddStreamsRequestParameter *addOutStreamsParam;
                        addOutStreamsParam = check_and_cast<SCTPAddStreamsRequestParameter *>(nextParam);
                        state->peerRequests[addOutStreamsParam->getSrReqSn()].sn = addOutStreamsParam->getSrReqSn();
                        state->peerRequests[addOutStreamsParam->getSrReqSn()].result = 100;
                        state->peerRequests[addOutStreamsParam->getSrReqSn()].type = addOutStreamsParam->getParameterType();
                        processAddInAndOutResetRequestArrived(addStreamsParam, addOutStreamsParam);
                        i++;
                    }
                } else {
                    state->peerRequestSn = addStreamsParam->getSrReqSn();
                    state->peerRequestType = ADD_INCOMING;
                    state->incomingRequest = ((SCTPParameter *)addStreamsParam)->dup();        //FIXME is the c-style conversion need here?
                    state->incomingRequestSet = true;
                    state->incomingRequest->setName("stateIncoming");
                    state->sendResponse = PERFORMED_WITH_ADDOUT;
                }
                break;
            }

            case ADD_OUTGOING_STREAMS_REQUEST_PARAMETER: {
                SCTPAddStreamsRequestParameter *addOutStreamsParam =
                    check_and_cast<SCTPAddStreamsRequestParameter *>(parameter);
                if (addOutStreamsParam->getNumberOfStreams() == 0) {
                    sendStreamResetResponse(addOutStreamsParam->getSrReqSn(), NOTHING_TO_DO);
                    return SCTP_E_IGNORE;
                }
                rit = state->peerRequests.rbegin();
                if ((!(addOutStreamsParam->getNumberOfStreams() + inboundStreams <= 65535)) ||
                    (state->appLimited && (addOutStreamsParam->getNumberOfStreams() + inboundStreams > initInboundStreams))) {
                    sendStreamResetResponse(addOutStreamsParam->getSrReqSn(), DENIED);
                    return SCTP_E_IGNORE;
                }
                if (state->findPeerRequestNum(addOutStreamsParam->getSrReqSn())) {
                    // retransmission
                    if (state->peerRequests[addOutStreamsParam->getSrReqSn()].type != addOutStreamsParam->getParameterType()) {
                        sendStreamResetResponse(addOutStreamsParam->getSrReqSn(), NO_RESET);
                        return SCTP_E_IGNORE;
                    }
                    if (state->peerRequests[addOutStreamsParam->getSrReqSn()].result != 100) {
                        if (state->peerRequests[addOutStreamsParam->getSrReqSn()].sn == rit->first) {
                        // send response with same result
                            sendStreamResetResponse(addOutStreamsParam->getSrReqSn(), state->peerRequests[addOutStreamsParam->getSrReqSn()].result);
                            return SCTP_E_IGNORE;
                        } else {
                            sendStreamResetResponse(addOutStreamsParam->getSrReqSn(), NO_RESET);
                            return SCTP_E_IGNORE;
                        }
                    }
                }
                if ((state->firstPeerRequest && addOutStreamsParam->getSrReqSn() != state->expectedStreamResetSequenceNumber) ||
                    (!state->firstPeerRequest && ((addOutStreamsParam->getSrReqSn() < (state->peerRequestSn)) &&
                    (addOutStreamsParam->getSrReqSn() != rit->first + 1)))) {
                    // Retransmission
                    sendStreamResetResponse(addOutStreamsParam->getSrReqSn(), NO_RESET);
                    return SCTP_E_IGNORE;
                }
                state->peerRequests[addOutStreamsParam->getSrReqSn()].sn = addOutStreamsParam->getSrReqSn();
                state->peerRequests[addOutStreamsParam->getSrReqSn()].result = 100;
                state->peerRequests[addOutStreamsParam->getSrReqSn()].type = addOutStreamsParam->getParameterType();
                if (state->localRequestType == 0 || state->localRequestType == ADD_INCOMING || state->localRequestType == ADD_BOTH) {
                    inboundStreams += addOutStreamsParam->getNumberOfStreams();
                    if (state->resetRequested && state->numAddedInStreams > 0)
                        state->numAddedInStreams = 0;
                    (this->*ssFunctions.ssAddInStreams)(addOutStreamsParam->getNumberOfStreams());
                }
                if (numberOfParameters > i + 1) {
                    nextParam = (SCTPParameter *)(resetChunk->getParameters(i + 1));
                    if (nextParam->getParameterType() == ADD_INCOMING_STREAMS_REQUEST_PARAMETER) {
                        SCTPAddStreamsRequestParameter *addInStreamsParam;
                        addInStreamsParam = check_and_cast<SCTPAddStreamsRequestParameter *>(nextParam);
                        state->peerRequests[addInStreamsParam->getSrReqSn()].sn = addInStreamsParam->getSrReqSn();
                        state->peerRequests[addInStreamsParam->getSrReqSn()].result = 100;
                        state->peerRequests[addInStreamsParam->getSrReqSn()].type = addInStreamsParam->getParameterType();
                        processAddInAndOutResetRequestArrived(addInStreamsParam, addOutStreamsParam);
                        i++;
                    } else {
                        state->peerRequestSn = addOutStreamsParam->getSrReqSn();
                        state->peerRequestType = ADD_OUTGOING;
                        state->sendResponse = PERFORMED;
                        state->responseSn = addOutStreamsParam->getSrReqSn();
                        state->firstPeerRequest = false;
                       // state->numAddedInStreams = addOutStreamsParam->getNumberOfStreams();
                        state->resetRequested = true;
                    }
                } else {
                    state->peerRequestSn = addOutStreamsParam->getSrReqSn();
                    state->peerRequestType = ADD_OUTGOING;
                    state->sendResponse = PERFORMED;
                    state->responseSn = addOutStreamsParam->getSrReqSn();
                   // state->numAddedInStreams = addOutStreamsParam->getNumberOfStreams();
                    state->firstPeerRequest = false;
                    state->resetRequested = true;
                }
                requestReceived = true;
                break;
            }

            case STREAM_RESET_RESPONSE_PARAMETER: {
                SCTPStreamResetResponseParameter *responseParam;
                responseParam = check_and_cast<SCTPStreamResetResponseParameter *>(parameter);
                if (!state->findRequestNum(responseParam->getSrResSn())) {
                    delete state->resetChunk;
                    state->resetChunk = nullptr;
                    break;
                }
                if (numberOfParameters > i + 1) {
                    nextParam = (SCTPParameter *)(resetChunk->getParameters(i + 1));
                    if (nextParam->getParameterType() != OUTGOING_RESET_REQUEST_PARAMETER) {
                        if (responseParam->getResult() != DEFERRED)
                            state->numResetRequests--;
                        processResetResponseArrived(responseParam);
                    } else {
                        switch (nextParam->getParameterType()) {
                            case OUTGOING_RESET_REQUEST_PARAMETER: {
                                SCTPOutgoingSSNResetRequestParameter *outRequestParam;
                                outRequestParam = check_and_cast<SCTPOutgoingSSNResetRequestParameter *>(nextParam);
                                if ((state->firstPeerRequest && outRequestParam->getSrReqSn() != state->expectedStreamResetSequenceNumber) ||
                                    (!state->firstPeerRequest && (outRequestParam->getSrReqSn() < (state->peerRequestSn)))) {
                                    // Retransmission
                                    sendStreamResetResponse(outRequestParam->getSrReqSn(), NO_RESET);
                                    return SCTP_E_IGNORE;
                                }
                                state->peerRequests[outRequestParam->getSrReqSn()].sn = outRequestParam->getSrReqSn();
                                state->peerRequests[outRequestParam->getSrReqSn()].result = 100;
                                state->peerRequests[outRequestParam->getSrReqSn()].type = outRequestParam->getParameterType();
                                state->numResetRequests -= 2;
                                processOutAndResponseArrived(outRequestParam, responseParam);
                                requestReceived = true;
                                i++;
                                break;
                            }
                        }
                    }
                } else {
                    if (responseParam->getResult() != DEFERRED)
                        state->numResetRequests--;
                    processResetResponseArrived(responseParam);
                }
                break;
            }
        }
    }
    return SCTP_E_IGNORE;
}

bool inet::sctp::SCTPAssociation::processTimer

(

cMessage *

msg

)

Referenced by inet::sctp::SCTP::handleMessage().

{
    SCTPPathVariables *path = nullptr;

    EV_INFO << msg->getName() << " timer expired at " << simTime() << "\n";

    SCTPPathInfo *pinfo = check_and_cast<SCTPPathInfo *>(msg->getControlInfo());
    L3Address addr = pinfo->getRemoteAddress();

    if (!addr.isUnspecified())
        path = getPath(addr);

    // first do actions
    SCTPEventCode event;
    event = SCTP_E_IGNORE;

    if (msg == T1_InitTimer) {
        process_TIMEOUT_INIT_REXMIT(event);
    }
    else if (msg == SackTimer) {
        EV_DETAIL << simTime() << " delayed Sack: cTsnAck=" << state->gapList.getCumAckTSN() << " highestTsnReceived=" << state->gapList.getHighestTSNReceived() << " lastTsnReceived=" << state->lastTsnReceived << " ackState=" << state->ackState << " numGaps=" << state->gapList.getNumGaps(SCTPGapList::GT_Any) << "\n";
        sendSack();
    }
    else if (msg == T2_ShutdownTimer) {
        stopTimer(T2_ShutdownTimer);
        process_TIMEOUT_SHUTDOWN(event);
    }
    else if (msg == T5_ShutdownGuardTimer) {
        stopTimer(T5_ShutdownGuardTimer);
        if (state->shutdownChunk) {
            delete state->shutdownChunk;
            state->shutdownChunk = nullptr;
        }
        sendIndicationToApp(SCTP_I_CONN_LOST);
        sendAbort();
        sctpMain->removeAssociation(this);
        return true;
    }
    else if (path != nullptr && msg == path->HeartbeatIntervalTimer) {
        process_TIMEOUT_HEARTBEAT_INTERVAL(path, path->forceHb);
    }
    else if (path != nullptr && msg == path->HeartbeatTimer) {
        process_TIMEOUT_HEARTBEAT(path);
    }
    else if (path != nullptr && msg == path->T3_RtxTimer) {
        process_TIMEOUT_RTX(path);
    }
    else if (path != nullptr && msg == path->CwndTimer) {
        (this->*ccFunctions.ccUpdateAfterCwndTimeout)(path);
    }
    else if (strcmp(msg->getName(), "StartTesting") == 0) {
        //if (sctpMain->testing == false)
        //{
        //sctpMain->testing = true;
        EV_DEBUG << "set testing to true\n";
        //}
        // todo: testing was removed.
    }
    else if (path != nullptr && msg == path->ResetTimer) {
        process_TIMEOUT_RESET(path);
    }
    else if (path != nullptr && msg == path->AsconfTimer) {
        process_TIMEOUT_ASCONF(path);
    }
    else if (msg == StartAddIP) {
        state->corrIdNum = state->asconfSn;
        const char *type = (const char *)sctpMain->par("addIpType");
        sendAsconf(type);
    }
    else if (msg == FairStartTimer) {
        auto it = sctpMain->assocStatMap.find(assocId);
        if (it != sctpMain->assocStatMap.end()) {
            it->second.fairStart = simTime();
            fairTimer = true;
        }
    }
    else if (msg == FairStopTimer) {
        auto it = sctpMain->assocStatMap.find(assocId);
        if (it != sctpMain->assocStatMap.end()) {
            it->second.fairStop = simTime();
            it->second.fairLifeTime = it->second.fairStop - it->second.fairStart;
            it->second.fairThroughput = it->second.fairAckedBytes / it->second.fairLifeTime.dbl();
            fairTimer = false;
        }
    }
    else {
        sctpAlgorithm->processTimer(msg, event);
    }

    // then state transitions
    return performStateTransition(event);
}

void inet::sctp::SCTPAssociation::pushUlp ( )

protected

Referenced by process_RECEIVE_REQUEST().

{
    int32 count = 0;

    for (unsigned int i = 0; i < inboundStreams; i++) {    //12.06.08
        putInDeliveryQ(i);
    }
    if (state->pushMessagesLeft <= 0) {
        state->pushMessagesLeft = state->messagesToPush;
    }
    bool restrict = false;
    if (state->pushMessagesLeft > 0) {
        restrict = true;
    }

    statisticsQueuedReceivedBytes->record(state->queuedReceivedBytes);

    EV_DETAIL << simTime() << " Calling pushUlp(" << state->queuedReceivedBytes
              << " bytes queued) ..." << endl
              << "messagesToPush=" << state->messagesToPush
              << " pushMessagesLeft=" << state->pushMessagesLeft
              << " restrict=" << restrict
              << " buffered Messages=" << state->bufferedMessages << endl;
    uint32 i = state->nextRSid;
    uint64 tempQueuedBytes = 0;
    do {
        auto iter = receiveStreams.find(i);
        SCTPReceiveStream *rStream = iter->second;
        EV_DETAIL << "Size of stream " << iter->first << ": "
                  << rStream->getDeliveryQ()->getQueueSize() << endl;

        while ((!rStream->getDeliveryQ()->payloadQueue.empty()) &&
               (!restrict || (restrict && state->pushMessagesLeft > 0)))
        {
            SCTPDataVariables *chunk = rStream->getDeliveryQ()->extractMessage();
            qCounter.roomSumRcvStreams -= ADD_PADDING(chunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);

            if (state->pushMessagesLeft > 0)
                state->pushMessagesLeft--;

            // ====== Non-revokably acknowledge chunks of the message ==========
          /*  bool dummy;
            for (uint32 j = chunk->tsn; j < chunk->tsn + chunk->fragments; j++)
                state->gapList.updateGapList(j, dummy, false);*/

            tempQueuedBytes = state->queuedReceivedBytes;
            state->queuedReceivedBytes -= chunk->len / 8;
            state->bufferedMessages--;
            EV_INFO << "buffered Messages now " << state->bufferedMessages << endl;
            if (state->swsAvoidanceInvoked) {
                statisticsQueuedReceivedBytes->record(state->queuedReceivedBytes);
                /* now check, if user has read enough so that window opens up more than one MTU */
                if ((state->messageAcceptLimit > 0 &&
                     (int32)state->localMsgRwnd - state->bufferedMessages >= 3 &&
                     (int32)state->localMsgRwnd - state->bufferedMessages <= 8)
                    ||
                    (state->messageAcceptLimit == 0 &&
                     (int32)(state->localRwnd - state->queuedReceivedBytes - state->bufferedMessages * state->bytesToAddPerRcvdChunk) >= (int32)(state->swsLimit) &&
                     (int32)(state->localRwnd - state->queuedReceivedBytes - state->bufferedMessages * state->bytesToAddPerRcvdChunk) <= (int32)(state->swsLimit + state->assocPmtu)))
                {
                    state->swsMsgInvoked = false;
                    /* only if the window has opened up more than one MTU we will send a SACK */
                    state->swsAvoidanceInvoked = false;
                    EV_DETAIL << "pushUlp: Window opens up to " << (int32)state->localRwnd - state->queuedReceivedBytes << " bytes: sending a SACK. SWS Avoidance INACTIVE\n";

                    sendSack();
                }
            }
            else if ((int32)(state->swsLimit) == 0) {
                sendSack();
            }
            else if ((tempQueuedBytes > state->localRwnd * 3 / 4) && (state->queuedReceivedBytes <= state->localRwnd * 3 / 4)) {
                sendSack();
            }
            EV_DETAIL << "Push TSN " << chunk->tsn
                      << ": sid=" << chunk->sid << " ssn=" << chunk->ssn << endl;
            cMessage *msg = (cMessage *)chunk->userData;
            msg->setKind(SCTP_I_DATA);
            SCTPRcvInfo *cmd = new SCTPRcvInfo("push");
            cmd->setAssocId(assocId);
            cmd->setGate(appGateIndex);
            cmd->setSid(chunk->sid);
            cmd->setSsn(chunk->ssn);
            cmd->setSendUnordered(!chunk->ordered);
            cmd->setLocalAddr(localAddr);
            cmd->setRemoteAddr(remoteAddr);
            cmd->setPpid(chunk->ppid);
            cmd->setTsn(chunk->tsn);
            cmd->setCumTsn(state->lastTsnAck);
            msg->setControlInfo(cmd);
            state->numMsgsReq[count]--;
            EndToEndDelay->record(simTime() - chunk->firstSendTime);
            auto iter = sctpMain->assocStatMap.find(assocId);
            if (iter->second.numEndToEndMessages >= iter->second.startEndToEndDelay &&
                (iter->second.numEndToEndMessages < iter->second.stopEndToEndDelay || !iter->second.stopEndToEndDelay))
            {
                iter->second.cumEndToEndDelay += (simTime() - chunk->firstSendTime);
            }
            iter->second.numEndToEndMessages++;

            // set timestamp to sending time
            chunk->userData->setTimestamp(chunk->firstSendTime);
            delete chunk;
            sendToApp(msg);
        }
        i = (i + 1) % inboundStreams;
        count++;
    } while (i != state->nextRSid);

    state->nextRSid = (state->nextRSid + 1) % inboundStreams;
    if (restrict && state->bufferedMessages > 0) {
        for (auto & elem : receiveStreams) {
            if (!(elem.second->getDeliveryQ()->payloadQueue.empty())) {
                sendDataArrivedNotification(elem.second->getStreamId());
                break;
            }
        }
    }
    if ((state->queuedReceivedBytes == 0) && (fsm->getState() == SCTP_S_SHUTDOWN_ACK_SENT)) {
        EV_INFO << "SCTP_E_CLOSE" << endl;
        performStateTransition(SCTP_E_CLOSE);
    }
}

void inet::sctp::SCTPAssociation::putInDeliveryQ ( uint16  sid )

protected

Referenced by processDataArrived(), and pushUlp().

{
    SCTPReceiveStream *rStream = receiveStreams.find(sid)->second;
    EV_INFO << "putInDeliveryQ: SSN=" << rStream->getExpectedStreamSeqNum()
            << " SID=" << sid
            << " QueueSize=" << rStream->getOrderedQ()->getQueueSize() << endl;
    while (rStream->getOrderedQ()->getQueueSize() > 0) {
        /* dequeue first from reassembly Q */
        SCTPDataVariables *chunk =
            rStream->getOrderedQ()->dequeueChunkBySSN(rStream->getExpectedStreamSeqNum());
        if (chunk) {
            EV_DETAIL << "putInDeliveryQ::chunk " << chunk->tsn
                      << ", sid " << chunk->sid << " and ssn " << chunk->ssn
                      << " dequeued from ordered queue. queuedReceivedBytes="
                      << state->queuedReceivedBytes << " will be reduced by "
                      << chunk->len / 8 << endl;
            state->bufferedMessages--;
            state->queuedReceivedBytes -= chunk->len / 8;
            qCounter.roomSumRcvStreams -= ADD_PADDING(chunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);

            if (rStream->getDeliveryQ()->checkAndInsertChunk(chunk->tsn, chunk)) {
                state->bufferedMessages++;
                state->queuedReceivedBytes += chunk->len / 8;

                EV_DETAIL << "data put in deliveryQ; queuedBytes now "
                          << state->queuedReceivedBytes << endl;
                qCounter.roomSumRcvStreams += ADD_PADDING(chunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);
                int32 seqnum = rStream->getExpectedStreamSeqNum();
                rStream->setExpectedStreamSeqNum(++seqnum);
                if (rStream->getExpectedStreamSeqNum() > 65535) {
                    rStream->setExpectedStreamSeqNum(0);
                }
            }
        }
        else {
            break;
        }
    }
}

void inet::sctp::SCTPAssociation::putInTransmissionQ ( uint32  tsn, SCTPDataVariables *  chunk  )

protected

Referenced by processPacketDropArrived().

{
    if (chunk->countsAsOutstanding) {
        decreaseOutstandingBytes(chunk);
    }
    auto it = transmissionQ->payloadQueue.find(tsn);
    if (it == transmissionQ->payloadQueue.end()) {
        EV_DETAIL << "putInTransmissionQ: insert tsn=" << tsn << endl;
        chunk->wasDropped = true;
        chunk->wasPktDropped = true;
        chunk->hasBeenFastRetransmitted = true;
        chunk->setNextDestination(chunk->getLastDestinationPath());
        if (!transmissionQ->checkAndInsertChunk(chunk->tsn, chunk)) {
            EV_DETAIL << "putInTransmissionQ: cannot add message/chunk (TSN="
                      << tsn << ") to the transmissionQ" << endl;
        }
        else {
            chunk->enqueuedInTransmissionQ = true;
            auto q = qCounter.roomTransQ.find(chunk->getNextDestination());
            q->second += ADD_PADDING(chunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);
            auto qb = qCounter.bookedTransQ.find(chunk->getNextDestination());
            qb->second += chunk->booksize;
            EV_DETAIL << "putInTransmissionQ: " << transmissionQ->getQueueSize() << " chunks="
                      << q->second << " bytes" << endl;
        }
    }
}

void inet::sctp::SCTPAssociation::recalculateOLIABasis ( )

private

                                           {
    // it is necessary to calculate all flow information
    double assoc_best_paths_l_rXl_r__rtt_r = 0.0;
    //max_w_paths: The set of paths in all_paths with largest congestion windows.
    //https://tools.ietf.org/html/draft-khalili-mptcp-congestion-control-05
    uint32 max_w_paths = 0;
    uint32 max_w_paths_cnt = 0; (void)max_w_paths_cnt; // FIXME this variable is unused
    uint32 best_paths_cnt = 0;

    // Create the sets
    int cnt = 0;
    assocCollectedPaths.clear();
    assocBestPaths.clear();
    assocMaxWndPaths.clear();
    for (SCTPPathMap::iterator iter = sctpPathMap.begin();
            iter != sctpPathMap.end(); iter++, cnt++) {
        SCTPPathVariables* path = iter->second;
        bool next = false;
        double r_sRTT = GET_SRTT(path->srtt.dbl());
        double r_l_rXl_r__rtt_r = ((path->oliaSentBytes
                * path->oliaSentBytes) / r_sRTT);
        if (assocBestPaths.empty()) {
            assoc_best_paths_l_rXl_r__rtt_r = r_l_rXl_r__rtt_r;
            assocBestPaths.insert(std::make_pair(cnt, path));
            next = true;
        }
        if (assocMaxWndPaths.empty()) {
            max_w_paths = path->cwnd;
            assocMaxWndPaths.insert(std::make_pair(cnt, path));
            next = true;
        }
        if (next)
            continue;
        // set up the sets
        if (r_l_rXl_r__rtt_r > assoc_best_paths_l_rXl_r__rtt_r) {
            assoc_best_paths_l_rXl_r__rtt_r = r_l_rXl_r__rtt_r;
            assocBestPaths.insert(std::make_pair(cnt, path));
            assocBestPaths.erase(best_paths_cnt);

            best_paths_cnt = cnt;
            next = true;
        }
        if (path->cwnd > max_w_paths) {
            max_w_paths = path->cwnd;
            assocMaxWndPaths.insert(std::make_pair(cnt, path));
            assocMaxWndPaths.erase(best_paths_cnt);
            max_w_paths_cnt = cnt;
            next = true;
        }
        if (next)
            continue;

        assocCollectedPaths.insert(std::make_pair(cnt, path));

    }
}

bool inet::sctp::SCTPAssociation::receiveStreamPresent ( uint16  sid )

protected

Referenced by processInAndOutResetRequestArrived(), and processOutgoingResetRequestArrived().

{
    auto iterator = receiveStreams.find(id);
    if (iterator == receiveStreams.end())
        return false;
    else
        return true;
}

void inet::sctp::SCTPAssociation::recordCwndUpdate ( SCTPPathVariables *  path )

private

Referenced by processHeartbeatAckArrived(), and removePath().

{
    if (path == nullptr) {
        uint32 totalSsthresh = 0.0;
        uint32 totalCwnd = 0.0;
        double totalBandwidth = 0.0;
        for (auto & elem : sctpPathMap)
        {
            SCTPPathVariables *path = elem.second;
            totalSsthresh += path->ssthresh;
            totalCwnd += path->cwnd;
            totalBandwidth += path->cwnd / GET_SRTT(path->srtt.dbl());
        }
        statisticsTotalSSthresh->record(totalSsthresh);
        statisticsTotalCwnd->record(totalCwnd);
        statisticsTotalBandwidth->record(totalBandwidth);
    }
    else {
        path->statisticsPathSSthresh->record(path->ssthresh);
        path->statisticsPathCwnd->record(path->cwnd);
        path->statisticsPathBandwidth->record(path->cwnd / GET_SRTT(path->srtt.dbl()));
    }
}

void inet::sctp::SCTPAssociation::removePath

(

)

Referenced by processAsconfArrived(), and inet::sctp::SCTP::removeAssociation().

{
    while (!sctpPathMap.empty()) {
        auto pathIterator = sctpPathMap.begin();
        SCTPPathVariables *path = pathIterator->second;
        for (auto j = remoteAddressList.begin(); j != remoteAddressList.end(); j++) {
            if ((*j) == path->remoteAddress) {
                remoteAddressList.erase(j);
                break;
            }
        }
        EV_INFO << getFullPath() << " remove path " << path->remoteAddress << endl;
        stopTimer(path->HeartbeatTimer);
        delete path->HeartbeatTimer;
        stopTimer(path->HeartbeatIntervalTimer);
        delete path->HeartbeatIntervalTimer;
        stopTimer(path->T3_RtxTimer);
        delete path->T3_RtxTimer;
        stopTimer(path->CwndTimer);
        delete path->CwndTimer;
        stopTimer(path->ResetTimer);
        delete path->ResetTimer;
        stopTimer(path->AsconfTimer);
        delete path->AsconfTimer;
        stopTimer(path->BlockingTimer);
        delete path->BlockingTimer;
        delete path;
        sctpPathMap.erase(pathIterator);
    }
}

void inet::sctp::SCTPAssociation::removePath

(

const L3Address &

addr

)

{
    auto pathIterator = sctpPathMap.find(addr);
    if (pathIterator != sctpPathMap.end()) {
        SCTPPathVariables *path = pathIterator->second;
        path->cwnd = 0;
        path->ssthresh = 0;
        recordCwndUpdate(path);

        stopTimer(path->HeartbeatTimer);
        delete path->HeartbeatTimer;
        stopTimer(path->HeartbeatIntervalTimer);
        delete path->HeartbeatIntervalTimer;
        stopTimer(path->T3_RtxTimer);
        delete path->T3_RtxTimer;
        stopTimer(path->CwndTimer);
        delete path->CwndTimer;
        sctpPathMap.erase(pathIterator);
        stopTimer(path->ResetTimer);
        delete path->ResetTimer;
        stopTimer(path->AsconfTimer);
        delete path->AsconfTimer;
        delete path;
    }
}

void inet::sctp::SCTPAssociation::renegablyAckChunk ( SCTPDataVariables *  chunk, SCTPPathVariables *  sackPath  )

private

Referenced by handleChunkReportedAsAcked().

{
    // ====== Bookkeeping ====================================================
    if (chunk->countsAsOutstanding) {
        decreaseOutstandingBytes(chunk);
    }

    if ((chunk->hasBeenCountedAsNewlyAcked == false) &&
        (chunk->hasBeenAcked == false))
    {
        if ((state->cmtMovedChunksReduceCwnd == false) ||
            (chunk->hasBeenMoved == false))
        {
            chunk->hasBeenCountedAsNewlyAcked = true;
            // The chunk has not been acked before.
            // Therefore, its size may *once* be counted as newly acked.
            chunk->getLastDestinationPath()->newlyAckedBytes += chunk->booksize;
        }
    }

    // ====== Acknowledge chunk =============================================
    ackChunk(chunk, sackPath);
    chunk->gapReports = 0;

    // ====== Remove chunk from transmission queue ===========================
    if (transmissionQ->getChunk(chunk->tsn)) {    // I.R. 02.01.2007
        EV_INFO << "Found TSN " << chunk->tsn << " in transmissionQ -> remote it" << endl;
        transmissionQ->removeMsg(chunk->tsn);
        chunk->enqueuedInTransmissionQ = false;
        auto q = qCounter.roomTransQ.find(chunk->getNextDestination());
        q->second -= ADD_PADDING(chunk->len / 8 + SCTP_DATA_CHUNK_LENGTH);
        auto qb = qCounter.bookedTransQ.find(chunk->getNextDestination());
        qb->second -= chunk->booksize;
    }
}

void inet::sctp::SCTPAssociation::resetExpectedSsn ( uint16  id )

protected

Referenced by processInAndOutResetRequestArrived(), processOutgoingResetRequestArrived(), and processResetResponseArrived().

{
    auto iterator = receiveStreams.find(id);
    iterator->second->setExpectedStreamSeqNum(0);
    EV_INFO << "Expected Ssn " << id <<" has been resetted on " << localAddr << "\n";
    sendIndicationToApp(SCTP_I_RCV_STREAMS_RESETTED);
}

void inet::sctp::SCTPAssociation::resetExpectedSsns ( )

protected

Referenced by checkStreamsToReset(), process_RCV_Message(), processInAndOutResetRequestArrived(), processOutAndResponseArrived(), processOutgoingResetRequestArrived(), processResetResponseArrived(), and sendStreamResetResponse().

{
    for (auto & elem : receiveStreams)
        elem.second->setExpectedStreamSeqNum(0);
    EV_INFO << "Expected Ssns have been resetted on " << localAddr << "\n";
    sendIndicationToApp(SCTP_I_RCV_STREAMS_RESETTED);
}

void inet::sctp::SCTPAssociation::resetGapLists ( )

protected

Referenced by sendStreamResetResponse().

{
    uint32 newCumAck = state->gapList.getHighestTSNReceived() + (1<<31);
    state->gapList.resetGaps(newCumAck);
}

void inet::sctp::SCTPAssociation::resetSsn ( uint16  id )

protected

Referenced by processIncomingResetRequestArrived(), processResetResponseArrived(), sendBundledOutgoingResetAndResponse(), and sendOutgoingResetRequest().

{
    auto iterator = sendStreams.find(id);
    iterator->second->setNextStreamSeqNum(0);
    EV_INFO << "SSns resetted on " << localAddr << "\n";
}

void inet::sctp::SCTPAssociation::resetSsns ( )

protected

Methods for Stream Reset.

Referenced by processIncomingResetRequestArrived(), processOutAndResponseArrived(), processResetResponseArrived(), and sendStreamResetResponse().

{
    for (auto & elem : sendStreams)
        elem.second->setNextStreamSeqNum(0);
    EV_INFO << "SSns resetted on " << localAddr << "\n";
    sendIndicationToApp(SCTP_I_SEND_STREAMS_RESETTED);
}

void inet::sctp::SCTPAssociation::retransmitAsconf ( )

protected

Referenced by process_TIMEOUT_ASCONF(), and processPacketDropArrived().

{
    SCTPMessage *sctpmsg = new SCTPMessage();
    sctpmsg->setByteLength(SCTP_COMMON_HEADER);

    SCTPAsconfChunk *sctpasconf = new SCTPAsconfChunk("ASCONF-RTX");
    sctpasconf = check_and_cast<SCTPAsconfChunk *>(state->asconfChunk->dup());
    sctpasconf->setChunkType(ASCONF);
    sctpasconf->setByteLength(state->asconfChunk->getByteLength());

    if (state->auth && state->peerAuth) {
        SCTPAuthenticationChunk *authChunk = createAuthChunk();
        sctpmsg->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }
    sctpmsg->addChunk(sctpasconf);

    sendToIP(sctpmsg);
}

void inet::sctp::SCTPAssociation::retransmitCookieEcho ( )

protected

Referenced by process_RCV_Message(), process_TIMEOUT_INIT_REXMIT(), and processPacketDropArrived().

{
    SCTPAuthenticationChunk *authChunk;
    SCTPMessage *sctpmsg = new SCTPMessage();
    sctpmsg->setByteLength(SCTP_COMMON_HEADER);
    SCTPCookieEchoChunk *cookieEchoChunk = check_and_cast<SCTPCookieEchoChunk *>(state->cookieChunk->dup());
    if (cookieEchoChunk->getCookieArraySize() == 0) {
        cookieEchoChunk->setStateCookie(state->cookieChunk->getStateCookie()->dup());
    }
    if (state->auth && state->peerAuth && typeInChunkList(COOKIE_ECHO)) {
        authChunk = createAuthChunk();
        sctpmsg->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }
    sctpmsg->addChunk(cookieEchoChunk);

    EV_INFO << "retransmitCookieEcho localAddr=" << localAddr << "     remoteAddr" << remoteAddr << "\n";

    sendToIP(sctpmsg);
}

void inet::sctp::SCTPAssociation::retransmitInit ( )

protected

Retransmitting chunks.

Referenced by process_RCV_Message(), process_TIMEOUT_INIT_REXMIT(), and processPacketDropArrived().

{
    SCTPMessage *sctpmsg = new SCTPMessage();
    sctpmsg->setByteLength(SCTP_COMMON_HEADER);
    SCTPInitChunk *sctpinit;    // = new SCTPInitChunk("INIT");

    EV_INFO << "Retransmit InitChunk=" << &sctpinit << "\n";

    sctpinit = check_and_cast<SCTPInitChunk *>(state->initChunk->dup());
    sctpinit->setChunkType(INIT);
    sctpmsg->addChunk(sctpinit);

    sendToIP(sctpmsg);
}

void inet::sctp::SCTPAssociation::retransmitReset ( )

protected

Referenced by process_TIMEOUT_RESET().

{
    SCTPMessage *sctpmsg = new SCTPMessage();
    sctpmsg->setByteLength(SCTP_COMMON_HEADER);
    SCTPStreamResetChunk *sctpreset = check_and_cast<SCTPStreamResetChunk *>(state->resetChunk->dup());
    state->numResetRequests = sctpreset->getParametersArraySize();
    sctpreset->setName("RESETRetransmit");
    sctpreset->setChunkType(RE_CONFIG);
    sctpmsg->addChunk(sctpreset);
    state->waitForResponse = true;
    EV_INFO << "retransmitStreamReset localAddr=" << localAddr << "  remoteAddr" << remoteAddr << "\n";

    sendToIP(sctpmsg);
}

void inet::sctp::SCTPAssociation::retransmitShutdown ( )

protected

Referenced by process_TIMEOUT_SHUTDOWN(), and processPacketDropArrived().

{
    SCTPMessage *sctpmsg = new SCTPMessage();
    sctpmsg->setByteLength(SCTP_COMMON_HEADER);
    SCTPShutdownChunk *shutdownChunk;
    shutdownChunk = check_and_cast<SCTPShutdownChunk *>(state->shutdownChunk->dup());
    sctpmsg->addChunk(shutdownChunk);

    EV_INFO << "retransmitShutdown localAddr=" << localAddr << "  remoteAddr" << remoteAddr << "\n";

    sendToIP(sctpmsg);
}

void inet::sctp::SCTPAssociation::retransmitShutdownAck ( )

protected

Referenced by process_TIMEOUT_SHUTDOWN(), and processPacketDropArrived().

{
    SCTPMessage *sctpmsg = new SCTPMessage();
    sctpmsg->setByteLength(SCTP_COMMON_HEADER);
    SCTPShutdownAckChunk *shutdownAckChunk;
    shutdownAckChunk = check_and_cast<SCTPShutdownAckChunk *>(state->shutdownAckChunk->dup());
    sctpmsg->addChunk(shutdownAckChunk);

    EV_INFO << "retransmitShutdownAck localAddr=" << localAddr << "  remoteAddr" << remoteAddr << "\n";

    sendToIP(sctpmsg);
}

int32 inet::sctp::SCTPAssociation::rpPathBlockingControl ( SCTPPathVariables *  path, const double  reduction  )

protected

{
    // ====== Compute new cwnd ===============================================
    const int32 newCwnd = (int32)ceil(path->cwnd - reduction);
    // NOTE: newCwnd may be negative!
    // ====== Block path if newCwnd < 1 MTU ==================================
    if ((state->rpPathBlocking == true) && (newCwnd < (int32)path->pmtu)) {
        if ((path->blockingTimeout < 0.0) || (path->blockingTimeout < simTime())) {
            // printf("a=%1.9f b=%1.9f   a=%d b=%d\n", path->blockingTimeout.dbl(), simTime().dbl(), (path->blockingTimeout < 0.0), (path->blockingTimeout < simTime()) );

            const simtime_t timeout = (state->rpScaleBlockingTimeout == true) ?
                path->cmtGroupPaths * path->pathRto :
                path->pathRto;
            EV << "Blocking " << path->remoteAddress << " for " << timeout << endl;

            path->blockingTimeout = simTime() + timeout;
            assert(!path->BlockingTimer->isScheduled());
            startTimer(path->BlockingTimer, timeout);
        }
    }
    return newCwnd;
}

void inet::sctp::SCTPAssociation::scheduleSack ( )

protected

Referenced by process_RCV_Message().

{
    /* increase SACK counter, we received another data PACKET */
    if (state->firstChunkReceived)
        state->ackState++;
    else {
        state->ackState = sackFrequency;
        state->firstChunkReceived = true;
    }

    EV_DETAIL << "scheduleSack() : ackState is now: " << state->ackState << "\n";

    if (state->ackState <= sackFrequency - 1) {
        /* start a SACK timer if none is running, to expire 200 ms (or parameter) from now */
        if (!SackTimer->isScheduled()) {
            startTimer(SackTimer, sackPeriod);
        }
        /* else: leave timer running, and do nothing... */ else {
            /* is this possible at all ? Check this... */

            EV_DETAIL << "SACK timer running, but scheduleSack() called\n";
        }
    }
}

void inet::sctp::SCTPAssociation::scheduleTimeout ( cMessage *  msg, const simtime_t &  timeout  )

inlineprotected

Utility: start a timer.

Referenced by startTimer().

    {
        sctpMain->scheduleAt(simTime() + timeout, msg);
    }

void inet::sctp::SCTPAssociation::sendAbort ( uint16  tBit = 0 )

protected

Referenced by process_ABORT(), process_RCV_Message(), process_TIMEOUT_HEARTBEAT(), process_TIMEOUT_INIT_REXMIT(), process_TIMEOUT_RTX(), process_TIMEOUT_SHUTDOWN(), processCookieEchoArrived(), processErrorArrived(), processInitArrived(), and updateCounters().

{
    SCTPAuthenticationChunk *authChunk;
    SCTPMessage *msg = new SCTPMessage();
    msg->setByteLength(SCTP_COMMON_HEADER);

    EV_INFO << "SCTPAssociationUtil:sendABORT localPort=" << localPort << "    remotePort=" << remotePort << "\n";

    msg->setSrcPort(localPort);
    msg->setDestPort(remotePort);
    SCTPAbortChunk *abortChunk = new SCTPAbortChunk("ABORT");
    abortChunk->setChunkType(ABORT);
    abortChunk->setT_Bit(tBit);
    abortChunk->setByteLength(SCTP_ABORT_CHUNK_LENGTH);
    if (state->auth && state->peerAuth && typeInChunkList(ABORT)) {
        authChunk = createAuthChunk();
        msg->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }
    msg->addChunk(abortChunk);
    if (state->resetChunk != nullptr) {
        delete state->resetChunk;
    }
    sendToIP(msg, remoteAddr);
}

void inet::sctp::SCTPAssociation::sendAddInAndOutStreamsRequest ( SCTPResetInfo *  info )

protected

Referenced by process_STREAM_RESET().

{
    EV_INFO << "StreamReset:sendAddInandStreamsRequest\n";
    SCTPMessage *msg = new SCTPMessage();
    msg->setByteLength(SCTP_COMMON_HEADER);
    msg->setSrcPort(localPort);
    msg->setDestPort(remotePort);
    SCTPResetTimer *rt = new SCTPResetTimer();
    SCTPStreamResetChunk *resetChunk = new SCTPStreamResetChunk("AddInOutCONFIG");
    resetChunk->setChunkType(RE_CONFIG);
    resetChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
    uint32 srsn = state->streamResetSequenceNumber;
    SCTPAddStreamsRequestParameter *addOutStreams = new SCTPAddStreamsRequestParameter("Add_Out_Streams");
    addOutStreams->setParameterType(ADD_OUTGOING_STREAMS_REQUEST_PARAMETER);
    addOutStreams->setNumberOfStreams(info->getOutstreams());
    state->numAddedOutStreams = info->getOutstreams();
    rt->setOutSN(srsn);
    rt->setOutAcked(false);
    state->numResetRequests++;
    state->requests[srsn].result = 100;
    state->requests[srsn].type = ADD_OUTGOING_STREAMS_REQUEST_PARAMETER;
    addOutStreams->setSrReqSn(srsn++);
    addOutStreams->setByteLength(SCTP_ADD_STREAMS_REQUEST_PARAMETER_LENGTH);
    SCTPAddStreamsRequestParameter *addInStreams = new SCTPAddStreamsRequestParameter("Add_In_Streams");
    addInStreams->setParameterType(ADD_INCOMING_STREAMS_REQUEST_PARAMETER);
    addInStreams->setNumberOfStreams(info->getInstreams());
    state->numAddedInStreams = info->getInstreams();
    rt->setInSN(srsn);
    rt->setInAcked(false);
    state->numResetRequests++;
    state->requests[srsn].result = 100;
    state->requests[srsn].type = ADD_INCOMING_STREAMS_REQUEST_PARAMETER;
    addInStreams->setSrReqSn(srsn++);
    addInStreams->setByteLength(SCTP_ADD_STREAMS_REQUEST_PARAMETER_LENGTH);
    resetChunk->addParameter(addOutStreams);
    resetChunk->addParameter(addInStreams);
    state->localRequestType = ADD_BOTH;
    state->streamResetSequenceNumber = srsn;
    if (state->resetChunk != nullptr) {
        delete state->resetChunk;
        state->resetChunk = nullptr;
    }
    state->resetChunk = check_and_cast<SCTPStreamResetChunk *>(resetChunk->dup());
    state->resetChunk->setName("stateAddInOutResetChunk");
    msg->addChunk(resetChunk);
    sendToIP(msg, remoteAddr);
    PK(getPath(remoteAddr)->ResetTimer)->encapsulate(rt);
    startTimer(getPath(remoteAddr)->ResetTimer, getPath(remoteAddr)->pathRto);
}

void inet::sctp::SCTPAssociation::sendAddOutgoingStreamsRequest ( uint16  numStreams )

protected

Referenced by process_RCV_Message().

{
    EV_INFO << "StreamReset:sendAddOutgoingStreamsRequest\n";
    uint32 srsn = 0;
    SCTPMessage *msg = new SCTPMessage();
    msg->setByteLength(SCTP_COMMON_HEADER);
    msg->setSrcPort(localPort);
    msg->setDestPort(remotePort);
    SCTPStreamResetChunk *resetChunk = new SCTPStreamResetChunk("AddRE_CONFIG");
    resetChunk->setChunkType(RE_CONFIG);
    resetChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
    SCTPStateVariables::RequestData *resDat = state->findTypeInRequests(ADD_OUTGOING_STREAMS_REQUEST_PARAMETER);
    if (resDat != nullptr && resDat->sn == state->streamResetSequenceNumber - 1) {
        srsn = state->streamResetSequenceNumber - 1;
    } else {
        srsn = state->streamResetSequenceNumber;
        state->requests[srsn].result = 100;
        state->requests[srsn].type = ADD_OUTGOING_STREAMS_REQUEST_PARAMETER;
        state->requests[srsn].sn = srsn;
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numResetRequestsSent++;
    }
    SCTPAddStreamsRequestParameter *addStreams = new SCTPAddStreamsRequestParameter("Add_Streams");
    addStreams->setParameterType(ADD_OUTGOING_STREAMS_REQUEST_PARAMETER);
    addStreams->setNumberOfStreams(numStreams);
    state->numAddedOutStreams = addStreams->getNumberOfStreams();
    state->localRequestType = ADD_OUTGOING;
    addStreams->setSrReqSn(srsn);
    addStreams->setByteLength(SCTP_ADD_STREAMS_REQUEST_PARAMETER_LENGTH);
    resetChunk->addParameter(addStreams);
    if (state->resetChunk != nullptr) {
        delete state->resetChunk;
        state->resetChunk = nullptr;
    }
    state->resetChunk = check_and_cast<SCTPStreamResetChunk *>(resetChunk->dup());
    state->resetChunk->setName("stateAddResetChunk");
    msg->addChunk(resetChunk);
    sendToIP(msg, remoteAddr);
    if (!(getPath(remoteAddr)->ResetTimer->isScheduled())) {
        SCTPResetTimer *rt = new SCTPResetTimer();
        rt->setInSN(0);
        rt->setInAcked(true);
        rt->setOutSN(srsn);
        rt->setOutAcked(false);
        PK(getPath(remoteAddr)->ResetTimer)->encapsulate(rt);
        startTimer(getPath(remoteAddr)->ResetTimer, getPath(remoteAddr)->pathRto);
    }
    state->streamResetSequenceNumber = ++srsn;
}

void inet::sctp::SCTPAssociation::sendAsconf ( const char *  type, const bool  remote = false  )

protected

Methods for Add-IP and AUTH.

Referenced by processAsconfArrived(), and processErrorArrived().

{
    SCTPAuthenticationChunk *authChunk = nullptr;
    bool nat = false;
    L3Address targetAddr = remoteAddr;
    uint16 chunkLength = 0;

    if (state->asconfOutstanding == false) {
        EV_DEBUG << "sendAsconf\n";
        SCTPMessage *sctpAsconf = new SCTPMessage("ASCONF-MSG");
        sctpAsconf->setByteLength(SCTP_COMMON_HEADER);
        sctpAsconf->setSrcPort(localPort);
        sctpAsconf->setDestPort(remotePort);
        SCTPAsconfChunk *asconfChunk = new SCTPAsconfChunk("ASCONF-CHUNK");
        asconfChunk->setChunkType(ASCONF);
        asconfChunk->setSerialNumber(state->asconfSn);
        chunkLength = SCTP_ADD_IP_CHUNK_LENGTH;
        EV_INFO << "localAddr=" << localAddr << ", remoteAddr=" << remoteAddr << "\n";
        if (getAddressLevel(localAddr) == 3 && getAddressLevel(remoteAddr) == 4 && (bool)sctpMain->par("natFriendly")) {
            asconfChunk->setAddressParam(L3Address("0.0.0.0"));
            asconfChunk->setPeerVTag(peerVTag);
            nat = true;
        }
        else {
            asconfChunk->setAddressParam(localAddr);
        }

        if (localAddr.getType() == L3Address::IPv6) {
            chunkLength += 20;
        }
        else if (localAddr.getType() == L3Address::IPv4) {
            chunkLength += 8;
        }
        else
            throw cRuntimeError("Unknown address type");

        asconfChunk->setByteLength(chunkLength);

        cStringTokenizer tokenizer(type);
        while (tokenizer.hasMoreTokens()) {
            const char *token = tokenizer.nextToken();
            switch (atoi(token)) {
                case ADD_IP_ADDRESS: {
                    SCTPAddIPParameter *ipParam;
                    ipParam = new SCTPAddIPParameter("AddIP");
                    chunkLength += SCTP_ADD_IP_PARAMETER_LENGTH;
                    ipParam->setParameterType(ADD_IP_ADDRESS);
                    ipParam->setRequestCorrelationId(++state->corrIdNum);
                    if (nat) {
                        ipParam->setAddressParam(L3Address("0.0.0.0"));
                        sctpMain->addLocalAddressToAllRemoteAddresses(this, L3AddressResolver().resolve(sctpMain->par("addAddress"), 1), (std::vector<L3Address>)remoteAddressList);
                        state->localAddresses.push_back(L3AddressResolver().resolve(sctpMain->par("addAddress"), 1));
                        if (remote)
                            targetAddr = remoteAddr;
                        else
                            targetAddr = getNextAddress(getPath(remoteAddr));
                    }
                    else {
                        ipParam->setAddressParam(L3AddressResolver().resolve(sctpMain->par("addAddress"), 1));
                    }
                    if (ipParam->getAddressParam().getType() == L3Address::IPv6) {
                        chunkLength += 20;
                        ipParam->setBitLength((SCTP_ADD_IP_PARAMETER_LENGTH + 20) * 8);
                    }
                    else if (ipParam->getAddressParam().getType() == L3Address::IPv4) {
                        chunkLength += 8;
                        ipParam->setBitLength((SCTP_ADD_IP_PARAMETER_LENGTH + 8) * 8);
                    }
                    else
                        throw cRuntimeError("Unknown address type");
                    asconfChunk->addAsconfParam(ipParam);
                    break;
                }

                case DELETE_IP_ADDRESS: {
                    SCTPDeleteIPParameter *delParam;
                    delParam = new SCTPDeleteIPParameter("DeleteIP");
                    chunkLength += SCTP_ADD_IP_PARAMETER_LENGTH;
                    delParam->setParameterType(DELETE_IP_ADDRESS);
                    delParam->setRequestCorrelationId(++state->corrIdNum);
                    delParam->setAddressParam(L3AddressResolver().resolve(sctpMain->par("addAddress"), 1));
                    if (delParam->getAddressParam().getType() == L3Address::IPv6) {
                        chunkLength += 20;
                        delParam->setBitLength((SCTP_ADD_IP_PARAMETER_LENGTH + 20) * 8);
                    }
                    else if (delParam->getAddressParam().getType() == L3Address::IPv4) {
                        chunkLength += 8;
                        delParam->setBitLength((SCTP_ADD_IP_PARAMETER_LENGTH + 8) * 8);
                    }
                    else
                        throw cRuntimeError("Unknown address type");
                    asconfChunk->addAsconfParam(delParam);
                    break;
                }

                case SET_PRIMARY_ADDRESS: {
                    SCTPSetPrimaryIPParameter *priParam;
                    priParam = new SCTPSetPrimaryIPParameter("SetPrimary");
                    chunkLength += SCTP_ADD_IP_PARAMETER_LENGTH;
                    priParam->setParameterType(SET_PRIMARY_ADDRESS);
                    priParam->setRequestCorrelationId(++state->corrIdNum);
                    priParam->setAddressParam(L3AddressResolver().resolve(sctpMain->par("addAddress"), 1));
                    if (nat) {
                        priParam->setAddressParam(L3Address("0.0.0.0"));
                    }
                    if (priParam->getAddressParam().getType() == L3Address::IPv6) {
                        chunkLength += 20;
                        priParam->setByteLength((SCTP_ADD_IP_PARAMETER_LENGTH + 20));
                    }
                    else if (priParam->getAddressParam().getType() == L3Address::IPv4) {
                        chunkLength += 8;
                        priParam->setByteLength((SCTP_ADD_IP_PARAMETER_LENGTH + 8));
                    }
                    else
                        throw cRuntimeError("Unknown address type");
                    asconfChunk->addAsconfParam(priParam);
                    break;
                }

                default:
                    printf("type %d not known\n", atoi(token));
                    break;
            }
        }
        asconfChunk->setByteLength(chunkLength);

        if (state->auth && state->peerAuth) {
            authChunk = createAuthChunk();
            sctpAsconf->addChunk(authChunk);
            auto it = sctpMain->assocStatMap.find(assocId);
            it->second.numAuthChunksSent++;
        }
        sctpAsconf->addChunk(asconfChunk);

        state->asconfChunk = check_and_cast<SCTPAsconfChunk *>(asconfChunk->dup());
        state->asconfChunk->setName("STATE-ASCONF");

        sendToIP(sctpAsconf, targetAddr);
        state->asconfOutstanding = true;
    }
}

void inet::sctp::SCTPAssociation::sendAsconfAck ( const uint32  serialNumber )

protected

{
    SCTPMessage *sctpAsconfAck = new SCTPMessage("ASCONF_ACK");
    sctpAsconfAck->setByteLength(SCTP_COMMON_HEADER);
    sctpAsconfAck->setSrcPort(localPort);
    sctpAsconfAck->setDestPort(remotePort);

    SCTPAsconfAckChunk *asconfAckChunk = new SCTPAsconfAckChunk("ASCONF_ACK");
    asconfAckChunk->setChunkType(ASCONF_ACK);
    asconfAckChunk->setSerialNumber(serialNumber);
    asconfAckChunk->setByteLength(SCTP_ADD_IP_CHUNK_LENGTH);
    if (state->auth && state->peerAuth) {
        SCTPAuthenticationChunk *authChunk = createAuthChunk();
        sctpAsconfAck->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }
    sctpAsconfAck->addChunk(asconfAckChunk);
    sendToIP(sctpAsconfAck, remoteAddr);
}

void inet::sctp::SCTPAssociation::sendBundledOutgoingResetAndResponse ( SCTPIncomingSSNResetRequestParameter *  requestParam )

protected

{
    EV_INFO << "sendBundledOutgoingResetAndResponse to " << remoteAddr << "\n";
    uint16 len = 0;
    if (!(getPath(remoteAddr)->ResetTimer->isScheduled())) {
        SCTPStreamResetChunk *resetChunk = new SCTPStreamResetChunk("Outbundle_CONFIG");
        resetChunk->setChunkType(RE_CONFIG);
        resetChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
        uint32 srsn = state->streamResetSequenceNumber;
        SCTPOutgoingSSNResetRequestParameter *outResetParam;
        outResetParam = new SCTPOutgoingSSNResetRequestParameter("Outgoing_SSN_B_Request_Param");
        outResetParam->setParameterType(OUTGOING_RESET_REQUEST_PARAMETER);
        state->requests[srsn].result = 100;
        state->requests[srsn].type = OUTGOING_RESET_REQUEST_PARAMETER;
        state->numResetRequests++;
        outResetParam->setSrReqSn(srsn++);
        outResetParam->setSrResSn(requestParam->getSrReqSn());
        outResetParam->setLastTsn(state->nextTSN - 1);
        if (state->streamsToReset.size() > 0) {
            outResetParam->setStreamNumbersArraySize(state->streamsToReset.size());
            uint16 i = 0;
            for (std::list<uint16>::iterator it = state->streamsToReset.begin(); it != state->streamsToReset.end(); ++it) {
                outResetParam->setStreamNumbers(i, *it);
                state->resetOutStreams.push_back(outResetParam->getStreamNumbers(i));
                resetSsn(outResetParam->getStreamNumbers(i));
                i++;
            }
            len = state->streamsToReset.size() * 2;
            state->streamsToReset.clear();
        } else if (requestParam->getStreamNumbersArraySize() > 0) {
            outResetParam->setStreamNumbersArraySize(requestParam->getStreamNumbersArraySize());
            for (uint16 i = 0; i < requestParam->getStreamNumbersArraySize(); i++) {
                outResetParam->setStreamNumbers(i, requestParam->getStreamNumbers(i));
            }
            len = requestParam->getStreamNumbersArraySize() * 2;
        }
        outResetParam->setByteLength(SCTP_OUTGOING_RESET_REQUEST_PARAMETER_LENGTH + len);
        resetChunk->addParameter(outResetParam);
        state->streamResetSequenceNumber = srsn;

        SCTPStreamResetChunk *resetResponseChunk;
        EV_INFO << "sendbundledStreamResetResponse to " << remoteAddr << "\n";
        resetResponseChunk = new SCTPStreamResetChunk("responseRE_CONFIG");
        resetResponseChunk->setChunkType(RE_CONFIG);
        resetResponseChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
        SCTPStreamResetResponseParameter *responseParam = new SCTPStreamResetResponseParameter("Response_Param");
        responseParam->setParameterType(STREAM_RESET_RESPONSE_PARAMETER);
        responseParam->setSrResSn(requestParam->getSrReqSn());
        responseParam->setResult(PERFORMED);
        responseParam->setByteLength(SCTP_STREAM_RESET_RESPONSE_PARAMETER_LENGTH);
        resetResponseChunk->addParameter(responseParam);
        state->resetRequested = false;

        SCTPResetTimer *rt = new SCTPResetTimer();
        rt->setInSN(0);
        rt->setInAcked(true);
        rt->setOutSN(srsn - 1);
        rt->setOutAcked(false);

        SCTPMessage *msg = new SCTPMessage();
        msg->setByteLength(SCTP_COMMON_HEADER);
        msg->setSrcPort(localPort);
        msg->setDestPort(remotePort);
        msg->addChunk(resetChunk);
        msg->addChunk(resetResponseChunk);
        state->localRequestType = RESET_OUTGOING;
        if (state->resetChunk != nullptr) {
            delete state->resetChunk;
            state->resetChunk = nullptr;
        }
        state->resetChunk = check_and_cast<SCTPStreamResetChunk *>(resetChunk->dup());
        state->resetChunk->setName("State_Resetchunk");
        if (qCounter.roomSumSendStreams != 0) {
            storePacket(getPath(remoteAddr), msg, 1, 0, false);
            state->bundleReset = true;
            rt->setName("bundleReset");
            sendOnPath(getPath(remoteAddr), true);
            state->bundleReset = false;
        } else {
            sendToIP(msg, remoteAddr);
        }
        if (PK(getPath(remoteAddr)->ResetTimer)->hasEncapsulatedPacket()) {
            PK(getPath(remoteAddr)->ResetTimer)->decapsulate();
        }
        PK(getPath(remoteAddr)->ResetTimer)->encapsulate(rt);
        if (getPath(remoteAddr)->ResetTimer->isScheduled()) {
            stopTimer(getPath(remoteAddr)->ResetTimer);
        }
        startTimer(getPath(remoteAddr)->ResetTimer, getPath(remoteAddr)->pathRto);
    }
}

void inet::sctp::SCTPAssociation::sendCookieAck ( const L3Address &  dest )

protected

Referenced by processCookieEchoArrived(), and processPacketDropArrived().

{
    SCTPAuthenticationChunk *authChunk;
    SCTPMessage *sctpcookieack = new SCTPMessage();
    sctpcookieack->setByteLength(SCTP_COMMON_HEADER);

    EV_INFO << "SCTPAssociationUtil:sendCookieACK\n";

    sctpcookieack->setSrcPort(localPort);
    sctpcookieack->setDestPort(remotePort);
    SCTPCookieAckChunk *cookieAckChunk = new SCTPCookieAckChunk("COOKIE_ACK");
    cookieAckChunk->setChunkType(COOKIE_ACK);
    cookieAckChunk->setByteLength(SCTP_COOKIE_ACK_LENGTH);
    if (state->auth && state->peerAuth && typeInChunkList(COOKIE_ACK)) {
        authChunk = createAuthChunk();
        sctpcookieack->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }
    sctpcookieack->addChunk(cookieAckChunk);
    sendToIP(sctpcookieack, dest);
}

void inet::sctp::SCTPAssociation::sendCookieEcho ( SCTPInitAckChunk *  initackchunk )

protected

Referenced by processInitAckArrived().

{
    SCTPAuthenticationChunk *authChunk;
    SCTPMessage *sctpcookieecho = new SCTPMessage();
    sctpcookieecho->setByteLength(SCTP_COMMON_HEADER);

    EV_INFO << "SCTPAssociationUtil:sendCookieEcho\n";

    sctpcookieecho->setSrcPort(localPort);
    sctpcookieecho->setDestPort(remotePort);
    SCTPCookieEchoChunk *cookieEchoChunk = new SCTPCookieEchoChunk("COOKIE_ECHO");
    cookieEchoChunk->setChunkType(COOKIE_ECHO);
    int32 len = initAckChunk->getCookieArraySize();
    cookieEchoChunk->setCookieArraySize(len);
    if (len > 0) {
        for (int32 i = 0; i < len; i++)
            cookieEchoChunk->setCookie(i, initAckChunk->getCookie(i));
        cookieEchoChunk->setByteLength((SCTP_COOKIE_ACK_LENGTH + len));
    }
    else {
        SCTPCookie *cookie = check_and_cast<SCTPCookie *>(initAckChunk->getStateCookie());
        cookieEchoChunk->setStateCookie(cookie);
        cookieEchoChunk->setByteLength(SCTP_COOKIE_ACK_LENGTH + cookie->getByteLength());
    }
    uint32 unknownLen = initAckChunk->getUnrecognizedParametersArraySize();
    if (unknownLen > 0) {
        EV_INFO << "Found unrecognized Parameters in INIT-ACK chunk with a length of " << unknownLen << " bytes.\n";
        cookieEchoChunk->setUnrecognizedParametersArraySize(unknownLen);
        for (uint32 i = 0; i < unknownLen; i++)
            cookieEchoChunk->setUnrecognizedParameters(i, initAckChunk->getUnrecognizedParameters(i));
    }
    else
        cookieEchoChunk->setUnrecognizedParametersArraySize(0);
    state->cookieChunk = check_and_cast<SCTPCookieEchoChunk *>(cookieEchoChunk->dup());
    if (len == 0) {
        state->cookieChunk->setStateCookie(initAckChunk->getStateCookie()->dup());
    }

    if (state->auth && state->peerAuth && typeInChunkList(COOKIE_ECHO)) {
        authChunk = createAuthChunk();
        sctpcookieecho->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }

    sctpcookieecho->addChunk(cookieEchoChunk);
    sendToIP(sctpcookieecho);
}

void inet::sctp::SCTPAssociation::sendDataArrivedNotification ( uint16  sid )

protected

Referenced by processDataArrived(), processForwardTsnArrived(), and pushUlp().

{
    EV_INFO << "SendDataArrivedNotification\n";

    cPacket *cmsg = new cPacket("SCTP_I_DATA_NOTIFICATION");
    cmsg->setKind(SCTP_I_DATA_NOTIFICATION);
    SCTPCommand *cmd = new SCTPCommand("notification");
    cmd->setAssocId(assocId);
    cmd->setSid(sid);
    cmd->setNumMsgs(1);
    cmsg->setControlInfo(cmd);

    sendToApp(cmsg);
}

void inet::sctp::SCTPAssociation::sendDoubleStreamResetResponse ( uint32  insrrsn, uint16  inresult, uint32  outsrrsn, uint16  outresult  )

protected

Referenced by processInAndOutResetRequestArrived().

{
    SCTPStreamResetChunk *resetChunk;
    EV_INFO << "sendDoubleStreamResetResponse to " << remoteAddr << "\n";
    SCTPMessage *msg = new SCTPMessage();
    msg->setByteLength(SCTP_COMMON_HEADER);
    msg->setSrcPort(localPort);
    msg->setDestPort(remotePort);
    resetChunk = new SCTPStreamResetChunk("responseRE_CONFIG");
    resetChunk->setChunkType(RE_CONFIG);
    resetChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
    SCTPStreamResetResponseParameter *outResponseParam = new SCTPStreamResetResponseParameter("Out_Response_Param");
    outResponseParam->setParameterType(STREAM_RESET_RESPONSE_PARAMETER);
    outResponseParam->setSrResSn(outsrrsn);
    outResponseParam->setResult(outresult);
    outResponseParam->setByteLength(SCTP_STREAM_RESET_RESPONSE_PARAMETER_LENGTH);
    resetChunk->addParameter(outResponseParam);
    SCTPStreamResetResponseParameter *inResponseParam = new SCTPStreamResetResponseParameter("In_Response_Param");
    inResponseParam->setParameterType(STREAM_RESET_RESPONSE_PARAMETER);
    inResponseParam->setSrResSn(insrrsn);
    inResponseParam->setResult(inresult);
    state->peerRequests[insrrsn].result = inresult;
    state->peerRequests[outsrrsn].result = outresult;
    inResponseParam->setByteLength(SCTP_STREAM_RESET_RESPONSE_PARAMETER_LENGTH);
    resetChunk->addParameter(inResponseParam);
    msg->addChunk(resetChunk);
    if (qCounter.roomSumSendStreams != 0) {
        storePacket(getPath(remoteAddr), msg, 1, 0, false);
        state->bundleReset = true;
        sendOnPath(getPath(remoteAddr), true);
        state->bundleReset = false;
    } else {
        sendToIP(msg, remoteAddr);
    }
    if (outresult == PERFORMED || outresult == DENIED) {
        state->resetRequested = false;
        state->firstPeerRequest = false;
    }
}

void inet::sctp::SCTPAssociation::sendEstabIndicationToApp ( )

protected

Utility: sends SCTP_I_ESTABLISHED indication with SCTPConnectInfo to application.

{
    EV_INFO << "sendEstabIndicationToApp: localPort="
            << localPort << " remotePort=" << remotePort << endl;

    cPacket *msg = new cPacket(indicationName(SCTP_I_ESTABLISHED));
    msg->setKind(SCTP_I_ESTABLISHED);

    SCTPConnectInfo *establishIndication = new SCTPConnectInfo("ConnectInfo");
    establishIndication->setAssocId(assocId);
    establishIndication->setLocalAddr(localAddr);
    establishIndication->setRemoteAddr(remoteAddr);
    establishIndication->setLocalPort(localPort);
    establishIndication->setRemotePort(remotePort);
    establishIndication->setRemoteAddresses(remoteAddressList);
    establishIndication->setInboundStreams(inboundStreams);
    establishIndication->setOutboundStreams(outboundStreams);
    establishIndication->setNumMsgs(state->sendQueueLimit);
    msg->setControlInfo(establishIndication);
    sctpMain->send(msg, "to_appl", appGateIndex);

    char vectorName[128];
    for (uint16 i = 0; i < inboundStreams; i++) {
        snprintf(vectorName, sizeof(vectorName), "Stream %d Throughput", i);
        streamThroughputVectors[i] = new cOutVector(vectorName);
    }
}

void inet::sctp::SCTPAssociation::sendHeartbeat ( const SCTPPathVariables *  path )

protected

Referenced by pmStartPathManagement(), process_TIMEOUT_HEARTBEAT_INTERVAL(), processAsconfArrived(), and processPacketDropArrived().

{
    SCTPAuthenticationChunk *authChunk;
    SCTPMessage *sctpHeartbeatbeat = new SCTPMessage();
    sctpHeartbeatbeat->setByteLength(SCTP_COMMON_HEADER);

    sctpHeartbeatbeat->setSrcPort(localPort);
    sctpHeartbeatbeat->setDestPort(remotePort);
    SCTPHeartbeatChunk *heartbeatChunk = new SCTPHeartbeatChunk("HEARTBEAT");
    heartbeatChunk->setChunkType(HEARTBEAT);
    heartbeatChunk->setRemoteAddr(path->remoteAddress);
    heartbeatChunk->setTimeField(simTime());
    heartbeatChunk->setByteLength(SCTP_HEARTBEAT_CHUNK_LENGTH + 12);
    if (state->auth && state->peerAuth && typeInChunkList(HEARTBEAT)) {
        authChunk = createAuthChunk();
        sctpHeartbeatbeat->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }
    sctpHeartbeatbeat->addChunk(heartbeatChunk);
    EV_INFO << "sendHeartbeat: sendToIP to " << path->remoteAddress << endl;
    sendToIP(sctpHeartbeatbeat, path->remoteAddress);
}

void inet::sctp::SCTPAssociation::sendHeartbeatAck ( const SCTPHeartbeatChunk *  heartbeatChunk, const L3Address &  src, const L3Address &  dest  )

protected

Referenced by process_RCV_Message().

{
    SCTPAuthenticationChunk *authChunk;
    SCTPMessage *sctpHeartbeatAck = new SCTPMessage();
    sctpHeartbeatAck->setByteLength(SCTP_COMMON_HEADER);
    sctpHeartbeatAck->setSrcPort(localPort);
    sctpHeartbeatAck->setDestPort(remotePort);
    SCTPHeartbeatAckChunk *heartbeatAckChunk = new SCTPHeartbeatAckChunk("HEARTBEAT_ACK");
    heartbeatAckChunk->setChunkType(HEARTBEAT_ACK);
    heartbeatAckChunk->setRemoteAddr(heartbeatChunk->getRemoteAddr());
    heartbeatAckChunk->setTimeField(heartbeatChunk->getTimeField());
    const int32 len = heartbeatChunk->getInfoArraySize();
    if (len > 0) {
        heartbeatAckChunk->setInfoArraySize(len);
        for (int32 i = 0; i < len; i++)
            heartbeatAckChunk->setInfo(i, heartbeatChunk->getInfo(i));
    }

    heartbeatAckChunk->setByteLength(heartbeatChunk->getByteLength());
    if (state->auth && state->peerAuth && typeInChunkList(HEARTBEAT_ACK)) {
        authChunk = createAuthChunk();
        sctpHeartbeatAck->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }
    sctpHeartbeatAck->addChunk(heartbeatAckChunk);

    EV_INFO << "sendHeartbeatAck: sendToIP from " << src << " to " << dest << endl;
    sendToIP(sctpHeartbeatAck, dest);
}

void inet::sctp::SCTPAssociation::sendHMacError ( const uint16  id )

protected

Referenced by process_RCV_Message().

{
    SCTPMessage *sctpmsg = new SCTPMessage();
    sctpmsg->setByteLength(SCTP_COMMON_HEADER);
    SCTPErrorChunk *errorChunk = new SCTPErrorChunk("ErrorChunk");
    errorChunk->setChunkType(ERRORTYPE);
    SCTPSimpleErrorCauseParameter *cause = new SCTPSimpleErrorCauseParameter("Cause");
    cause->setParameterType(UNSUPPORTED_HMAC);
    cause->setByteLength(6);
    cause->setValue(id);
    errorChunk->setByteLength(4);
    errorChunk->addParameters(cause);
    sctpmsg->addChunk(errorChunk);
}

void inet::sctp::SCTPAssociation::sendIndicationToApp ( const int32  code, const int32  value = 0  )

protected

Utility: sends status indication (SCTP_I_xxx) to application.

Referenced by chunkMustBeAbandoned(), peekAbandonedChunk(), process_RCV_Message(), process_SEND(), process_TIMEOUT_HEARTBEAT(), process_TIMEOUT_INIT_REXMIT(), process_TIMEOUT_RTX(), process_TIMEOUT_SHUTDOWN(), processAsconfAckArrived(), processAsconfArrived(), processOutAndResponseArrived(), processResetResponseArrived(), resetExpectedSsn(), resetExpectedSsns(), resetSsns(), sendOnPath(), signalConnectionTimeout(), and updateCounters().

{
    EV_INFO << "sendIndicationToApp: " << indicationName(code) << endl;
    assert(code != SCTP_I_SENDQUEUE_ABATED);

    cPacket *msg = new cPacket(indicationName(code));
    msg->setKind(code);

    SCTPCommand *indication = new SCTPCommand(indicationName(code));
    indication->setAssocId(assocId);
    indication->setLocalAddr(localAddr);
    indication->setLocalPort(localPort);
    indication->setRemoteAddr(remoteAddr);
    indication->setRemotePort(remotePort);
    msg->setControlInfo(indication);
    sctpMain->send(msg, "to_appl", appGateIndex);
}

void inet::sctp::SCTPAssociation::sendInit ( )

protected

Methods for creating and sending chunks.

Referenced by process_ASSOCIATE().

{
    AddressVector adv;
    uint32 length = SCTP_INIT_CHUNK_LENGTH;

    if (remoteAddr.isUnspecified() || remotePort == 0)
        throw cRuntimeError("Error processing command ASSOCIATE: foreign socket unspecified");

    if (localPort == 0)
        throw cRuntimeError("Error processing command ASSOCIATE: local port unspecified");

    state->setPrimaryPath(getPath(remoteAddr));
    // create message consisting of INIT chunk
    SCTPMessage *sctpmsg = new SCTPMessage();
    sctpmsg->setByteLength(SCTP_COMMON_HEADER);
    SCTPInitChunk *initChunk = new SCTPInitChunk("INIT");
    initChunk->setChunkType(INIT);
    initChunk->setInitTag((uint32)(fmod(RNGCONTEXT intrand(INT32_MAX), 1.0 + (double)(unsigned)0xffffffffUL)) & 0xffffffffUL);

    peerVTag = initChunk->getInitTag();
    EV_INFO << "INIT from " << localAddr << ":InitTag=" << peerVTag << "\n";
    initChunk->setA_rwnd(sctpMain->par("arwnd"));
    state->localRwnd = (long)sctpMain->par("arwnd");
    initChunk->setNoOutStreams(outboundStreams);
    initInboundStreams = inboundStreams;
    initChunk->setNoInStreams(inboundStreams);
    initChunk->setInitTSN(1000);
    initChunk->setMsg_rwnd(sctpMain->par("messageAcceptLimit"));
    state->nextTSN = initChunk->getInitTSN();
    state->lastTSN = initChunk->getInitTSN() + state->numRequests - 1;
    state->streamResetSequenceNumber = state->nextTSN;
    state->asconfSn = 1000;

    initTsn = initChunk->getInitTSN();
#ifdef WITH_IPv4
    initChunk->setIpv4Supported(true);
#else
    initChunk->setIpv4Supported(false);
#endif
#ifdef WITH_IPv6
    initChunk->setIpv6Supported(true);
#else
    initChunk->setIpv6Supported(false);
#endif
    EV_INFO << "add local address\n";
    if (localAddressList.front().isUnspecified()) {
        for (int32 i = 0; i < ift->getNumInterfaces(); ++i) {
#ifdef WITH_IPv4
            if (ift->getInterface(i)->ipv4Data() != nullptr) {
                adv.push_back(ift->getInterface(i)->ipv4Data()->getIPAddress());
            }
            else
#endif // ifdef WITH_IPv4
#ifdef WITH_IPv6
            if (ift->getInterface(i)->ipv6Data() != nullptr) {
                for (int32 j = 0; j < ift->getInterface(i)->ipv6Data()->getNumAddresses(); j++) {
                    EV_DETAIL << "add address " << ift->getInterface(i)->ipv6Data()->getAddress(j) << "\n";
                    adv.push_back(ift->getInterface(i)->ipv6Data()->getAddress(j));
                }
            }
            else
#endif // ifdef WITH_IPv6
            ;
        }
    }
    else {
        adv = localAddressList;
        EV_DETAIL << "gebundene Adresse " << localAddr << " wird hinzugefuegt\n";    // todo
    }
    if (initChunk->getIpv4Supported() || initChunk->getIpv6Supported()) {
        length += 8;
    }
    uint32 addrNum = 0;
    bool friendly = false;
    if (sctpMain->hasPar("natFriendly")) {
        friendly = sctpMain->par("natFriendly");
    }
    if (remoteAddr.getType() == L3Address::IPv6) {
        for (auto & elem : adv) {
            if (!friendly) {
                initChunk->setAddressesArraySize(addrNum + 1);
                initChunk->setAddresses(addrNum++, (elem));
                length += 20;
            }
            sctpMain->addLocalAddress(this, (elem));
            state->localAddresses.push_back((elem));
            if (localAddr.isUnspecified())
                localAddr = (elem);
        }
    }
    else if (remoteAddr.getType() == L3Address::IPv4) {
        int rlevel = getAddressLevel(remoteAddr);
        EV_DETAIL << "level of remote address=" << rlevel << "\n";
        for (auto & elem : adv) {
            int addressLevel = getAddressLevel(elem);
            EV_DETAIL << "level of address " << (elem) << " = " << addressLevel << "\n";
            if (addressLevel >= rlevel) {
                initChunk->setAddressesArraySize(addrNum + 1);
                initChunk->setAddresses(addrNum++, (elem));
                length += 8;
                sctpMain->addLocalAddress(this, (elem));
                state->localAddresses.push_back((elem));
                if (localAddr.toIPv4().getInt() == 0)
                    localAddr = (elem);
            }
            else if (rlevel == 4 && addressLevel == 3 && friendly) {
                sctpMain->addLocalAddress(this, (elem));
                state->localAddresses.push_back((elem));
                if (localAddr.toIPv4().getInt() == 0)
                    localAddr = (elem);
            }
        }
    }
    else
        throw cRuntimeError("Unknown address type: %d", (int)(remoteAddr.getType()));

    uint16 count = 0;
    if (sctpMain->auth == true) {
        initChunk->setSepChunksArraySize(++count);
        initChunk->setSepChunks(count - 1, AUTH);
        state->keyVector[0] = (uint8_t)RANDOM;
        state->keyVector[2] = 36;
        for (int32 k = 0; k < 32; k++) {
            initChunk->setRandomArraySize(k + 1);
            initChunk->setRandom(k, (uint8)(RNGCONTEXT intrand(256)));
            state->keyVector[k + 2] = initChunk->getRandom(k);
        }
        state->sizeKeyVector = 36;
        state->keyVector[state->sizeKeyVector] = (uint8_t)CHUNKS;
        state->sizeKeyVector += 2;
        state->keyVector[state->sizeKeyVector] = state->chunkList.size() + 4;
        state->sizeKeyVector += 2;
        initChunk->setChunkTypesArraySize(state->chunkList.size());
        int32 k = 0;
        for (auto & elem : state->chunkList) {
            initChunk->setChunkTypes(k, (elem));
            state->keyVector[state->sizeKeyVector] = (elem);
            state->sizeKeyVector++;
            k++;
        }
        state->keyVector[state->sizeKeyVector] = (uint8_t)HMAC_ALGO;
        state->sizeKeyVector += 2;
        state->keyVector[state->sizeKeyVector] = 1 + 4;
        state->sizeKeyVector += 2;
        state->keyVector[state->sizeKeyVector] = 1;
        state->sizeKeyVector++;
        initChunk->setHmacTypesArraySize(1);
        initChunk->setHmacTypes(0, 1);
        length += initChunk->getChunkTypesArraySize() + 50;
    }

    if (sctpMain->pktdrop) {
        initChunk->setSepChunksArraySize(++count);
        initChunk->setSepChunks(count - 1, PKTDROP);
    }
    if (state->streamReset == true) {
        initChunk->setSepChunksArraySize(++count);
        initChunk->setSepChunks(count - 1, RE_CONFIG);
    }
    if ((bool)sctpMain->par("addIP") == true) {
        initChunk->setSepChunksArraySize(++count);
        initChunk->setSepChunks(count - 1, ASCONF);
        initChunk->setSepChunksArraySize(++count);
        initChunk->setSepChunks(count - 1, ASCONF_ACK);
    }
    if (count > 0) {
        length += ADD_PADDING(SCTP_SUPPORTED_EXTENSIONS_PARAMETER_LENGTH + count);
    }
    if (state->prMethod != 0) {
        initChunk->setForwardTsn(true);
        length += 4;
    }

    sctpMain->printInfoAssocMap();
    initChunk->setByteLength(length);
    sctpmsg->addChunk(initChunk);
    // set path variables
    if (remoteAddressList.size() > 0) {
        for (auto & elem : remoteAddressList) {
            EV_DEBUG << " get new path for " << (elem) << " at line " << __LINE__ << "\n";
            SCTPPathVariables *path = new SCTPPathVariables((elem), this, rt);
            sctpPathMap[(elem)] = path;
            qCounter.roomTransQ[(elem)] = 0;
            qCounter.bookedTransQ[(elem)] = 0;
            qCounter.roomRetransQ[(elem)] = 0;
        }
    }
    else {
        EV_DEBUG << " get new path for " << remoteAddr << " at line " << __LINE__ << "\n";
        SCTPPathVariables *path = new SCTPPathVariables(remoteAddr, this, rt);
        sctpPathMap[remoteAddr] = path;
        qCounter.roomTransQ[remoteAddr] = 0;
        qCounter.bookedTransQ[remoteAddr] = 0;
        qCounter.roomRetransQ[remoteAddr] = 0;
    }
    // send it
    state->initChunk = check_and_cast<SCTPInitChunk *>(initChunk->dup());
    state->initChunk->setName("StateInitChunk");
    printSctpPathMap();
    EV_DEBUG << getFullPath() << " sendInit: localVTag=" << localVTag << " peerVTag=" << peerVTag << "\n";
    sendToIP(sctpmsg);
    sctpMain->assocList.push_back(this);
}

void inet::sctp::SCTPAssociation::sendInitAck ( SCTPInitChunk *  initchunk )

protected

Referenced by processInitArrived().

{
    uint32 length = SCTP_INIT_CHUNK_LENGTH;

    state->setPrimaryPath(getPath(remoteAddr));
    // create segment
    SCTPMessage *sctpinitack = new SCTPMessage();
    sctpinitack->setByteLength(SCTP_COMMON_HEADER);

    sctpinitack->setSrcPort(localPort);
    sctpinitack->setDestPort(remotePort);
    EV_INFO << "sendInitAck at " << localAddr << ". Provided InitTag=" << initChunk->getInitTag() << "\n";
    SCTPInitAckChunk *initAckChunk = new SCTPInitAckChunk("INIT_ACK");
    initAckChunk->setChunkType(INIT_ACK);
    SCTPCookie *cookie = new SCTPCookie("CookieUtil");
    cookie->setCreationTime(simTime());
    cookie->setLocalTieTagArraySize(32);
    cookie->setPeerTieTagArraySize(32);
    if (fsm->getState() == SCTP_S_CLOSED) {
        while (peerVTag == 0) {
            peerVTag = (uint32)RNGCONTEXT intrand(INT32_MAX);
        }
        initAckChunk->setInitTag(peerVTag);
        initAckChunk->setInitTSN(2000);
        state->nextTSN = initAckChunk->getInitTSN();
        state->lastTSN = initAckChunk->getInitTSN() + state->numRequests - 1;
        state->asconfSn = 2000;
        state->streamResetSequenceNumber = state->nextTSN;
        cookie->setLocalTag(localVTag);
        cookie->setPeerTag(peerVTag);
        for (int32 i = 0; i < 32; i++) {
            cookie->setLocalTieTag(i, 0);
            cookie->setPeerTieTag(i, 0);
        }
        sctpinitack->setTag(localVTag);
        EV_INFO << "state=closed: localVTag=" << localVTag << " peerVTag=" << peerVTag << "\n";
    }
    else if (fsm->getState() == SCTP_S_COOKIE_WAIT || fsm->getState() == SCTP_S_COOKIE_ECHOED) {
        initAckChunk->setInitTag(peerVTag);
        EV_INFO << "different state:set InitTag in InitAck: " << initAckChunk->getInitTag() << "\n";
        initAckChunk->setInitTSN(state->nextTSN);
        initPeerTsn = initChunk->getInitTSN();
        state->gapList.forwardCumAckTSN(initPeerTsn - 1);
        cookie->setLocalTag(initChunk->getInitTag());
        cookie->setPeerTag(peerVTag);
        for (int32 i = 0; i < 32; i++) {
            cookie->setPeerTieTag(i, (uint8)(RNGCONTEXT intrand(256)));
            state->peerTieTag[i] = cookie->getPeerTieTag(i);
            if (fsm->getState() == SCTP_S_COOKIE_ECHOED) {
                cookie->setLocalTieTag(i, (uint8)(RNGCONTEXT intrand(256)));
                state->localTieTag[i] = cookie->getLocalTieTag(i);
            }
            else
                cookie->setLocalTieTag(i, 0);
        }
        sctpinitack->setTag(initChunk->getInitTag());
        EV_DETAIL << "VTag in InitAck: " << sctpinitack->getTag() << "\n";
    }
    else {
        EV_INFO << "other state\n";
        uint32 tag = 0;
        while (tag == 0) {
            tag = (uint32)(fmod(RNGCONTEXT intrand(INT32_MAX), 1.0 + (double)(unsigned)0xffffffffUL)) & 0xffffffffUL;
        }
        initAckChunk->setInitTag(tag);
        initAckChunk->setInitTSN(state->nextTSN);
        cookie->setLocalTag(localVTag);
        cookie->setPeerTag(peerVTag);
        for (int32 i = 0; i < 32; i++) {
            cookie->setPeerTieTag(i, state->peerTieTag[i]);
            cookie->setLocalTieTag(i, state->localTieTag[i]);
        }
        sctpinitack->setTag(initChunk->getInitTag());
    }
    cookie->setByteLength(SCTP_COOKIE_LENGTH + 4);
    initAckChunk->setStateCookie(cookie);
    initAckChunk->setCookieArraySize(0);
    initAckChunk->setA_rwnd(sctpMain->par("arwnd"));
    state->localRwnd = (long)sctpMain->par("arwnd");
    initAckChunk->setMsg_rwnd(sctpMain->par("messageAcceptLimit"));
    initAckChunk->setNoOutStreams((unsigned int)min(outboundStreams, initChunk->getNoInStreams()));
    initAckChunk->setNoInStreams((unsigned int)min(inboundStreams, initChunk->getNoOutStreams()));
    initTsn = initAckChunk->getInitTSN();
#ifdef WITH_IPv4
    initAckChunk->setIpv4Supported(true);
#else
    initAckChunk->setIpv4Supported(false);
#endif
#ifdef WITH_IPv6
    initAckChunk->setIpv6Supported(true);
#else
    initAckChunk->setIpv6Supported(false);
#endif
    if (initAckChunk->getIpv4Supported() || initAckChunk->getIpv6Supported()) {
        length += 8;
    }
    uint32 addrNum = 0;
    bool friendly = false;
    if (sctpMain->hasPar("natFriendly")) {
        friendly = sctpMain->par("natFriendly");
    }
    if (!friendly)
        for (auto & elem : state->localAddresses) {
            initAckChunk->setAddressesArraySize(addrNum + 1);
            initAckChunk->setAddresses(addrNum++, (elem));
            if ((elem).getType() == L3Address::IPv4) {
                length += 8;
            } else if ((elem).getType() == L3Address::IPv6) {
                length += 20;
            }
        }

    uint16 count = 0;
    if (sctpMain->auth == true) {
        initAckChunk->setSepChunksArraySize(++count);
        initAckChunk->setSepChunks(count - 1, AUTH);
        for (int32 k = 0; k < 32; k++) {
            initAckChunk->setRandomArraySize(k + 1);
            initAckChunk->setRandom(k, (uint8)(RNGCONTEXT intrand(256)));
        }
        initAckChunk->setChunkTypesArraySize(state->chunkList.size());
        int32 k = 0;
        for (auto & elem : state->chunkList) {
            initAckChunk->setChunkTypes(k, (elem));
            k++;
        }
        initAckChunk->setHmacTypesArraySize(1);
        initAckChunk->setHmacTypes(0, 1);
        length += initAckChunk->getChunkTypesArraySize() + 48;
    }
    uint32 unknownLen = initChunk->getUnrecognizedParametersArraySize();
    if (unknownLen > 0) {
        EV_INFO << "Found unrecognized Parameters in INIT chunk with a length of " << unknownLen << " bytes.\n";
        initAckChunk->setUnrecognizedParametersArraySize(unknownLen);
        for (uint32 i = 0; i < unknownLen; i++)
            initAckChunk->setUnrecognizedParameters(i, initChunk->getUnrecognizedParameters(i));
        length += unknownLen;
    }
    else
        initAckChunk->setUnrecognizedParametersArraySize(0);

    if (sctpMain->pktdrop) {
        initAckChunk->setSepChunksArraySize(++count);
        initAckChunk->setSepChunks(count - 1, PKTDROP);
    }

    if (state->streamReset == true) {
        initAckChunk->setSepChunksArraySize(++count);
        initAckChunk->setSepChunks(count - 1, RE_CONFIG);
    }
    if ((bool)sctpMain->par("addIP") == true) {
        initAckChunk->setSepChunksArraySize(++count);
        initAckChunk->setSepChunks(count - 1, ASCONF);
        initAckChunk->setSepChunksArraySize(++count);
        initAckChunk->setSepChunks(count - 1, ASCONF_ACK);
    }
    if (count > 0) {
        length += ADD_PADDING(SCTP_SUPPORTED_EXTENSIONS_PARAMETER_LENGTH + count);
    }
    if (state->prMethod != 0) {
        initAckChunk->setForwardTsn(true);
        length += 4;
    }

    initAckChunk->setByteLength(length + initAckChunk->getCookieArraySize() + cookie->getByteLength());
    inboundStreams = ((initChunk->getNoOutStreams() < initAckChunk->getNoInStreams()) ? initChunk->getNoOutStreams() : initAckChunk->getNoInStreams());
    outboundStreams = ((initChunk->getNoInStreams() < initAckChunk->getNoOutStreams()) ? initChunk->getNoInStreams() : initAckChunk->getNoOutStreams());
    (this->*ssFunctions.ssInitStreams)(inboundStreams, outboundStreams);
    sctpinitack->addChunk(initAckChunk);
    if (fsm->getState() == SCTP_S_CLOSED) {
        sendToIP(sctpinitack, state->initialPrimaryPath);
    }
    else {
        sendToIP(sctpinitack);
    }
    sctpMain->assocList.push_back(this);
    printSctpPathMap();
}

void inet::sctp::SCTPAssociation::sendInvalidStreamError ( uint16  sid )

protected

Referenced by processDataArrived().

{
    SCTPMessage *sctpmsg = new SCTPMessage();
    sctpmsg->setByteLength(SCTP_COMMON_HEADER);
    SCTPErrorChunk *errorChunk = new SCTPErrorChunk("ErrorChunk");
    errorChunk->setChunkType(ERRORTYPE);
    SCTPSimpleErrorCauseParameter *cause = new SCTPSimpleErrorCauseParameter("Cause");
    cause->setParameterType(INVALID_STREAM_IDENTIFIER);
    cause->setByteLength(8);
    cause->setValue(sid);
    errorChunk->setByteLength(4);
    errorChunk->addParameters(cause);
    sctpmsg->addChunk(errorChunk);

    stopTimer(SackTimer);
    state->ackState = 0;
    SCTPSackChunk *sackChunk = createSack();

    if (state->auth && state->peerAuth && typeInChunkList(SACK)) {
        SCTPAuthenticationChunk *authChunk = createAuthChunk();
        sctpmsg->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }
    sctpmsg->addChunk(sackChunk);
    sendSACKviaSelectedPath(sctpmsg);
}

void inet::sctp::SCTPAssociation::sendOnAllPaths

(

SCTPPathVariables *

firstPath

)

Referenced by process_ABORT(), process_CLOSE(), process_RCV_Message(), process_TIMEOUT_BLOCKING(), process_TIMEOUT_RTX(), inet::sctp::SCTPAlg::sendCommandInvoked(), and sendShutdownAck().

{
    if (state->allowCMT) {
        // ------ Send on provided path first ... -----------------------------
        if (firstPath != nullptr) {
            sendOnPath(firstPath);
        }

        // ------ ... then, try sending on all other paths --------------------
        std::vector<SCTPPathVariables *> sortedPaths = getSortedPathMap();
        for (auto path : sortedPaths) {
            EV << path->remoteAddress << " [" << path->lastTransmission << "]\t";
        }
        EV << endl;

        for (auto path : sortedPaths)
        {
            if (path != firstPath) {
                sendOnPath(path);
                path->sendAllRandomizer = RNGCONTEXT uniform(0, (1 << 31));
            }
        }
        if ((state->strictCwndBooking) &&
            (sctpPathMap.size() > 1))    // T.D. 08.02.2010: strict behaviour only for more than 1 paths!
        {    // T.D. 14.01.2010: Second pass for "Strict Cwnd Booking" option.
            for (auto path : sortedPaths)
            {
                sendOnPath(path, false);
            }
        }
    }
    else {
        // ------ Send on provided path first ... -----------------------------
        if (firstPath != nullptr) {
            sendOnPath(firstPath);
        }

        // ------ ... then, try sending on all other paths --------------------
        for (auto & elem : sctpPathMap) {
            SCTPPathVariables *path = elem.second;
            if (path != firstPath) {
                sendOnPath(path);
            }
        }
        if (state->strictCwndBooking) {
            // T.D. 14.01.2010: Second pass for "Strict Cwnd Booking" option.
            sendOnPath(firstPath, false);

            // ------ Then, try sending on all other paths ---------------------------
            for (auto & elem : sctpPathMap) {
                SCTPPathVariables *path = elem.second;
                if (path != firstPath) {
                    sendOnPath(path, false);
                }
            }
        }
    }
    if (state->resetRequested && qCounter.roomSumSendStreams == 0 && state->localRequestType == SSN_TSN && !state->resetPending && state->outstandingBytes == 0) {
        sendStreamResetRequest(state->resetInfo);
        state->resetPending = true;
    }
}

void inet::sctp::SCTPAssociation::sendOnPath	(	SCTPPathVariables *	pathId,
		const bool	firstPass = true
	)

Utility: Send data from sendQueue.

Referenced by sendBundledOutgoingResetAndResponse(), inet::sctp::SCTPAlg::sendCommandInvoked(), sendDoubleStreamResetResponse(), sendOnAllPaths(), sendOutgoingResetRequest(), sendStreamResetRequest(), and sendStreamResetResponse().

{
    // ====== Variables ======================================================
    SCTPPathVariables *path = nullptr;    // Path to send next message to
    SCTPMessage *sctpMsg = nullptr;
    SCTPSackChunk *sackChunk = nullptr;
    SCTPDataChunk *dataChunkPtr = nullptr;
    SCTPForwardTsnChunk *forwardChunk = nullptr;

    uint16 chunksAdded = 0;
    uint16 dataChunksAdded = 0;
    uint32 totalChunksSent = 0;
    uint32 totalPacketsSent = 0;
    uint32 outstandingBytes = 0;

    uint32 tcount = 0;    // Bytes in transmission queue on the selected path
    uint32 Tcount = 0;    // Bytes in transmission queue on all paths
    uint32 scount = 0;    // Bytes in send streams
    int32 bytesToSend = 0;

    bool headerCreated = false;
    bool sendOneMorePacket = false;
    bool sendingAllowed = true;
    bool authAdded = false;
    bool sackAdded = false;
    bool forwardPresent = false;

    // ====== Perform Chunk Rescheduling =====================================
    if ((state->allowCMT) &&
        (state->cmtChunkReschedulingVariant != SCTPStateVariables::CCRV_None))
    {
        chunkReschedulingControl((pathId == nullptr) ? state->getPrimaryPath() : pathId);
    }

    // ====== Obtain path ====================================================
    EV_INFO << endl << "##### sendAll(";
    if (pathId) {
        EV_INFO << pathId->remoteAddress;
    }
    EV_INFO << ") at t=" << simTime() << " #####" << endl;

    unsigned int safetyCounter = 0;
    while (sendingAllowed && (!state->resetPending || state->waitForResponse)) {
        if (safetyCounter++ >= 1000) {
            throw cRuntimeError("Endless loop in SCTPAssociation::sendOnPath()?! This should not happen ...");
        }

        headerCreated = false;
        if (state->bytesToRetransmit > 0) {
            // There are bytes in the transmissionQ. They have to be sent first.
            path = choosePathForRetransmission();
            assert(path != nullptr);
        }
        else {
            if (pathId == nullptr) {    // No path given => use primary path.
                path = state->getPrimaryPath();
            }
            else {
                path = pathId;
            }
        }
        if ((state->maxBurstVariant == SCTPStateVariables::MBV_MaxBurst) ||
            (state->maxBurstVariant == SCTPStateVariables::MBV_AggressiveMaxBurst))
        {
            if (state->lastTransmission < simTime()) {
                state->packetsInTotalBurst = 0;
            }
            if (path->lastTransmission < simTime()) {
                // T.D. 18.07.2011: Only reset packetsInBurst once per time-stamp!
                path->packetsInBurst = 0;
            }
        }
        // packetsInBurst must be checked here!
        // sendOnPath() may be called multiple times at the same simTime!
        if (((state->maxBurstVariant == SCTPStateVariables::MBV_MaxBurst) ||
             (state->maxBurstVariant == SCTPStateVariables::MBV_AggressiveMaxBurst) ||
             (state->maxBurstVariant == SCTPStateVariables::MBV_TotalMaxBurst)) &&
            (path->packetsInBurst >= state->maxBurst))
        {
            break;
        }
        // TotalMaxBurst variant: limit bursts on all paths.
        if ((state->maxBurstVariant == SCTPStateVariables::MBV_TotalMaxBurst) &&
            (state->packetsInTotalBurst >= state->maxBurst))
        {
            break;
        }
        outstandingBytes = path->outstandingBytes;
        assert((int32)outstandingBytes >= 0);
        auto tq = qCounter.roomTransQ.find(path->remoteAddress);
        tcount = tq->second;
        Tcount = getAllTransQ();
        scount = qCounter.roomSumSendStreams;    // includes header and padding
        EV_INFO << "\nsendAll: on " << path->remoteAddress << ":"
                << " tcount=" << tcount
                << " Tcount=" << Tcount
                << " scount=" << scount
                << " nextTSN=" << state->nextTSN << endl;

        bool sackOnly;
        bool sackWithData;
        timeForSack(sackOnly, sackWithData);
        if ((tcount == 0 && scount == 0) || (!state->allowCMT && tcount == 0 && Tcount > 0)) {
            // ====== No DATA chunks to send ===================================
            EV_DETAIL << "No DATA chunk available!" << endl;
            if (!sackOnly) {    // SACK?, no data to send
                EV_DETAIL << "No SACK to send either" << endl;
                if (state->sctpMsg) {
                    EV_DETAIL << "packet was stored -> load packet" << endl;
                    loadPacket(path, &sctpMsg, &chunksAdded, &dataChunksAdded, &authAdded);
                    sendToIP(sctpMsg, path->remoteAddress);
                }
                return;
            }
            else {
                bytes.bytesToSend = 0;
            }
        }
        else {
            bytesAllowedToSend(path, firstPass);
        }
        bytesToSend = bytes.bytesToSend;

        // As there is at least a SACK to be sent, a header can be created

        if (state->sctpMsg) {
            EV_DETAIL << "packet was stored -> load packet" << endl;
            loadPacket(path, &sctpMsg, &chunksAdded, &dataChunksAdded, &authAdded);
            headerCreated = true;
        }
        else if (bytesToSend > 0 || bytes.chunk || bytes.packet || sackWithData || sackOnly || forwardPresent) {
            sctpMsg = new SCTPMessage("send");
            sctpMsg->setByteLength(SCTP_COMMON_HEADER);
            headerCreated = true;
            chunksAdded = 0;
        }

        if (!sackAdded && (sackWithData || sackOnly)) {
            // SACK can be sent
            assert(headerCreated == true);
            sackChunk = createSack();
            // CMT DAC
            if ((state->allowCMT == true) && (state->cmtUseDAC == true)) {
                EV << "Adding dacPacketsRcvd=" << (unsigned int)dacPacketsRcvd << " to SACK" << endl;
                sackChunk->setDacPacketsRcvd(dacPacketsRcvd);
            }
            dacPacketsRcvd = 0;

            chunksAdded++;
            totalChunksSent++;
            // ------ Create AUTH chunk, if necessary --------------------------
            authAdded = addAuthChunkIfNecessary(sctpMsg, SACK, authAdded);

            // ------ Add SACK chunk -------------------------------------------
            sctpMsg->addChunk(sackChunk);
            sackAdded = true;
            EV_DETAIL << assocId << ": SACK added, chunksAdded now " << chunksAdded << " sackOnly=" << sackOnly << " sackWithData=" << sackWithData << "\n";
            if (sackOnly && !(bytesToSend > 0 || bytes.chunk || bytes.packet)) {
                // There is no data to be sent, just the SACK
                path->lastTransmission = simTime();
                path->packetsInBurst++;
                state->lastTransmission = simTime();
                state->packetsInTotalBurst++;
                state->ackState = 0;
                // Stop SACK timer if it is running...
                stopTimer(SackTimer);
                sctpAlgorithm->sackSent();
                state->sackAllowed = false;
                sendSACKviaSelectedPath(sctpMsg);
                sctpMsg = nullptr;
                return;
            }
        }
        // ====== FORWARD_TSN =================================================
        if (!forwardPresent && !state->stopSending) {
            if (peekAbandonedChunk(path) != nullptr) {
                forwardChunk = createForwardTsnChunk(path->remoteAddress);
                chunksAdded++;
                totalChunksSent++;
                state->ackPointAdvanced = false;
                if (!headerCreated) {
                    sctpMsg = new SCTPMessage("send");
                    sctpMsg->setByteLength(SCTP_COMMON_HEADER);
                    headerCreated = true;
                    chunksAdded = 0;
                }
                // ------ Create AUTH chunk, if necessary -----------------------
                authAdded = addAuthChunkIfNecessary(sctpMsg, FORWARD_TSN, authAdded);
                sctpMsg->addChunk(forwardChunk);
                forwardPresent = true;
                if (!path->T3_RtxTimer->isScheduled()) {
                    // Start retransmission timer, if not scheduled before
                    startTimer(path->T3_RtxTimer, path->pathRto);
                }
                if (bytesToSend == 0) {
                    sendToIP(sctpMsg, path->remoteAddress);
                    forwardPresent = false;
                    headerCreated = false;
                    chunksAdded = 0;
                    sctpMsg = nullptr;
                }
            }
        }

        // ####################################################################
        // #### Data Transmission                                          ####
        // ####################################################################

        bool packetFull = false;

        while (!packetFull && headerCreated) {
            assert(headerCreated == true);
            EV_DETAIL << assocId << ": bytesToSend=" << bytesToSend
                      << " bytes.chunk=" << bytes.chunk
                      << " bytes.packet=" << bytes.packet << endl;

            // ====== How many bytes may be transmitted in next packet? ========
            int32 allowance = path->pmtu;    // Default behaviour: send 1 path MTU
            // Restrict amount of data to send to cwnd size.
            if ((state->strictCwndBooking) &&
                (sctpPathMap.size() > 1))    // strict behaviour only for more than 1 paths!
            {    // T.D. 19.01.2010: bytesToSend may be less than 1 MTU on this path.
                 // Allow overbooking in second pass, if *total* cwnd allows it.
                if (!firstPass) {
                    // No "one packet"/"one chunk" in second pass!
                    bytes.packet = false;
                    bytes.chunk = false;
                }

                if (bytes.chunk) {
                    // Send 1 chunk: allow one path MTU.
                }
                else if (bytes.packet) {
                    // Send 1 chunk: allow one path MTU.
                }
                else if ((path->outstandingBytes == 0) && (firstPass)) {
                    // No outstanding data and first pass: allow one path MTU.
                }
                else {    // There *may* be something more to send ...
                    if ((int32)path->cwnd - (int32)path->outstandingBytes >= (int32)path->pmtu) {
                        // Enough space -> allow one path MTU
                    }
                    else {
                        if (firstPass) {
                            // In first pass, disallow overbooking.
                            allowance = 0;
                            bytesToSend = 0;
                        }
                        else {
                            if (!state->allowCMT) {
                                // For non-CMT in second pass, allow 1 more MTU.
                            }
                            else {
                                // Not CMT in second pass, check total space ...
                                int32 totalOutstanding = 0;
                                int32 totalCwnd = 0;
                                for (SCTPPathMap::const_iterator pathMapIterator = sctpPathMap.begin();
                                     pathMapIterator != sctpPathMap.end(); pathMapIterator++)
                                {
                                    const SCTPPathVariables *myPath = pathMapIterator->second;
                                    totalOutstanding += myPath->outstandingBytes;
                                    totalCwnd += myPath->cwnd;
                                }
                                if ((int32)(totalCwnd - totalOutstanding) < (int32)(path->pmtu)) {
                                    // ... and disallow overbooking if there is no more space for 1 MTU
                                    allowance = 0;
                                    bytesToSend = 0;
                                }
                                else {
                                    // ... and allow 1 MTU if there is still space
                                }
                            }
                        }
                    }
                }
            }
            else {
                if ((bytesToSend > 0) || (bytes.chunk) || (bytes.packet)) {
                    // Allow 1 more MTU
                }
                else {
                    // No more sending allowed.
                    allowance = 0;
                    bytesToSend = 0;
                }
            }
            if ((allowance > 0) || (bytes.chunk) || (bytes.packet)) {
                bool firstTime = false;    // Is DATA chunk send for the first time?
                SCTPDataVariables *datVar = nullptr;
                // ------ Create AUTH chunk, if necessary -----------------------
                authAdded = addAuthChunkIfNecessary(sctpMsg, DATA, authAdded);
                if (tcount > 0) {
                    // ====== Retransmission ========================================
                    // If bytes.packet is true, one packet is allowed to be retransmitted!
                    datVar = getOutboundDataChunk(path,
                                path->pmtu - sctpMsg->getByteLength() - 20,
                                (bytes.packet == true) ? path->pmtu : allowance);
                    if (datVar == nullptr) {
                        if (chunksAdded == 1 && sackAdded) {
                            datVar = getOutboundDataChunk(path,
                                        path->pmtu - sctpMsg->getByteLength() + sackChunk->getByteLength() - 20,
                                        (bytes.packet == true) ? path->pmtu : allowance);
                            if (!sackOnly) {
                                sctpMsg->removeChunk();
                                EV_DETAIL << "RTX: Remove SACK chunk\n";
                                delete sackChunk;
                                chunksAdded--;
                                sackAdded = false;
                            }
                            else {
                                path->lastTransmission = simTime();
                                path->packetsInBurst++;
                                state->lastTransmission = simTime();
                                state->packetsInTotalBurst++;
                                if (dataChunksAdded > 0) {
                                    state->ssNextStream = true;
                                }
                                state->ackState = 0;
                                // Stop SACK timer if it is running...
                                stopTimer(SackTimer);
                                sctpAlgorithm->sackSent();
                                state->sackAllowed = false;
                                EV_DETAIL << "RTX: send only SACK\n";
                                sendSACKviaSelectedPath(sctpMsg);
                                sctpMsg = nullptr;

                                // TD 17.02.2015: There is data to send (on current path) -> create new message structure!
                                sctpMsg = new SCTPMessage("send");
                                sctpMsg->setByteLength(SCTP_COMMON_HEADER);
                                headerCreated = true;
                                sackAdded = false;
                                chunksAdded = 0;
                            }
                        }
                    }

                    // Check for FORWARD-TSN again, might just have been triggered...
                    if (datVar == nullptr && !forwardPresent && !state->stopSending) {
                        if (peekAbandonedChunk(path) != nullptr) {
                            forwardChunk = createForwardTsnChunk(path->remoteAddress);
                            chunksAdded++;
                            totalChunksSent++;
                            state->ackPointAdvanced = false;
                            // ------ Create AUTH chunk, if necessary -----------------------
                            authAdded = addAuthChunkIfNecessary(sctpMsg, FORWARD_TSN, authAdded);
                            sctpMsg->addChunk(forwardChunk);
                            forwardPresent = true;
                            if (!path->T3_RtxTimer->isScheduled()) {
                                // Start retransmission timer, if not scheduled before
                                startTimer(path->T3_RtxTimer, path->pathRto);
                            }
                        }
                    }

                    if (datVar != nullptr) {
                        assert(datVar->getNextDestinationPath() == path);
                        datVar->numberOfRetransmissions++;
                        if (chunkHasBeenAcked(datVar) == false) {
                            EV_DETAIL << simTime() << ": Retransmission #" << datVar->numberOfRetransmissions
                                      << " of TSN " << datVar->tsn
                                      << " on path " << datVar->getNextDestination()
                                      << " (last was " << datVar->getLastDestination() << ")" << endl;
                            // The chunk is going to be retransmitted on another path.
                            // On the original path, it is necessary to find another
                            // PseudoCumAck!
                            if (datVar->getLastDestinationPath() != datVar->getNextDestinationPath()) {
                                SCTPPathVariables *oldPath = datVar->getLastDestinationPath();
                                oldPath->findPseudoCumAck = true;
                                oldPath->findRTXPseudoCumAck = true;
                                SCTPPathVariables *newPath = datVar->getNextDestinationPath();
                                newPath->findPseudoCumAck = true;
                                newPath->findRTXPseudoCumAck = true;
                            }
                            datVar->wasDropped = false;
                            datVar->countsAsOutstanding = true;
                            datVar->hasBeenReneged = false;
                            increaseOutstandingBytes(datVar, path);    // NOTE: path == datVar->getNextDestinationPath()
                        }
                    }
                }
                // ====== First Transmission ====================================
                else if (((scount > 0) && (!state->nagleEnabled)) ||    // Data to send and Nagle off
                         ((uint32)scount >= path->pmtu - 32 - 20) ||    // Data to fill at least one path MTU
                         ((scount > 0) && (state->nagleEnabled) && ((outstandingBytes == 0) || (sackOnly && sackAdded))) ||     // Data to send, Nagle on and no outstanding bytes
                         state->bundleReset)
                {    // ====== Buffer Splitting ===================================
                    bool rejected = false;
                    const uint32 bytesOnPath = (state->cmtBufferSplittingUsesOSB == true) ?
                        path->outstandingBytes : path->queuedBytes;
                    if (state->allowCMT) {
                        // ------ Sender Side -------------------------------------
                        if ((state->cmtBufferSplitVariant == SCTPStateVariables::CBSV_SenderOnly) ||
                            (state->cmtBufferSplitVariant == SCTPStateVariables::CBSV_BothSides))
                        {
                            // Limit is 1/n of current sender-side buffer allocation
                            const uint32 limit = ((state->sendQueueLimit != 0) ? state->sendQueueLimit : 0xffffffff) / sctpPathMap.size();
                            if (bytesOnPath + path->pmtu > limit) {
                                rejected = true;
                                EV << simTime() << ":\tSenderBufferSplitting: Rejecting transmission on "
                                   << path->remoteAddress << ", since "
                                   << bytesOnPath << " + " << path->pmtu << " > "
                                   << state->sendQueueLimit / sctpPathMap.size() << endl;
                            }
                        }

                        // ------ Receiver Side -----------------------------------
                        if ((rejected == false) &&
                            ((state->cmtBufferSplitVariant == SCTPStateVariables::CBSV_ReceiverOnly) ||
                             (state->cmtBufferSplitVariant == SCTPStateVariables::CBSV_BothSides)))
                        {
                            // Limit is 1/n of current receiver-side buffer allocation
                            const uint32 limit = (state->peerRwnd + state->outstandingBytes)
                                / sctpPathMap.size();
                            if (bytesOnPath + path->pmtu > limit + path->pmtu) {
                                // T.D. 09.07.2011: Allow overbooking by up to 1 MTU ...
                                EV << simTime() << ":\tReceiverBufferSplitting: Rejecting transmission on "
                                   << path->remoteAddress << ", since "
                                   << bytesOnPath + path->pmtu << " > " << limit << endl;
                                rejected = true;
                            }
                        }
                    }

                    // ====== Buffer Splitting ===================================
                    if (((state->allowCMT) || (path == state->getPrimaryPath())) &&
                        (!rejected))
                    {
                        // ------ Dequeue data message ----------------------------
                        EV_DETAIL << assocId << "sendAll:     sctpMsg->length=" << sctpMsg->getByteLength()
                                  << " length datMsg=" << path->pmtu - sctpMsg->getByteLength() - 20 << endl;
                        SCTPDataMsg *datMsg = dequeueOutboundDataMsg(path, path->pmtu - sctpMsg->getByteLength() - 20,
                                    allowance);
                        if (datMsg == nullptr) {
                            if (chunksAdded == 1 && sackAdded) {
                                datMsg = dequeueOutboundDataMsg(path, path->pmtu - sctpMsg->getByteLength() + sackChunk->getByteLength() - 20,
                                            allowance);
                                if (!sackOnly) {
                                    sctpMsg->removeChunk();
                                    EV_DETAIL << assocId << ": delete SACK chunk to make room for datMsg (" << &datMsg << "). scount=" << scount << "\n";
                                    delete sackChunk;
                                    chunksAdded--;
                                    sackAdded = false;
                                }
                                else {
                                    path->lastTransmission = simTime();
                                    path->packetsInBurst++;
                                    state->lastTransmission = simTime();
                                    state->packetsInTotalBurst++;
                                    if (dataChunksAdded > 0) {
                                        state->ssNextStream = true;
                                    }
                                    state->ackState = 0;
                                    // Stop SACK timer if it is running...
                                    stopTimer(SackTimer);
                                    sctpAlgorithm->sackSent();
                                    state->sackAllowed = false;
                                    EV_DETAIL << assocId << ": send SACK and make new header for datMsg (" << &datMsg << "). scount=" << scount << "\n";
                                    sendSACKviaSelectedPath(sctpMsg);
                                    sctpMsg = nullptr;
                                    if (datMsg != nullptr) {
                                        sctpMsg = new SCTPMessage("send");
                                        sctpMsg->setByteLength(SCTP_COMMON_HEADER);
                                        headerCreated = true;
                                        sackAdded = false;
                                        chunksAdded = 0;
                                    }
                                }
                            }
                        }
                        // ------ Handle data message -----------------------------
                        if (datMsg) {
                            firstTime = true;
                            if (datMsg->getFragment()) {
                                if (datMsg->getBBit() && !datMsg->getEBit()) {
                                    state->fragInProgress = true;
                                    setFragInProgressOfStream(datMsg->getSid(), true);
                                }
                                if (datMsg->getEBit()) {
                                    state->fragInProgress = false;
                                    setFragInProgressOfStream(datMsg->getSid(), true);
                                }
                            }
                            state->queuedMessages--;
                            if ((state->queueLimit > 0) &&
                                (state->queuedMessages < state->queueLimit) &&
                                (state->queueUpdate == false))
                            {
                                // Tell upper layer readiness to accept more data
                                sendIndicationToApp(SCTP_I_SEND_MSG);
                                state->queueUpdate = true;
                            }

                            datVar = makeDataVarFromDataMsg(datMsg, path);
                            delete datMsg;

                            EV_DETAIL << assocId << ":: sendAll: chunk " << datVar << " dequeued from StreamQ "
                                      << datVar->sid << ": tsn=" << datVar->tsn
                                      << ", bytes now " << qCounter.roomSumSendStreams << "\n";
                        }
                        // ------ No data message has been dequeued ---------------
                        else {
                            EV_DETAIL << assocId << ": No data message has been dequeued" << endl;
                            // ------ Are there any chunks to send? ----------------
                            if (chunksAdded == 0) {
                                // No -> nothing more to do.
                                if (state->sctpMsg == sctpMsg) {
                                    state->sctpMsg = nullptr;
                                    state->packetBytes = 0;
                                }
                                packetFull = true;    // chunksAdded==0, packetFull==true => leave inner while loop
                            }
                            else {
                                // Yes.
                                if (state->nagleEnabled && ((outstandingBytes > 0) && !(sackOnly && sackAdded)) &&
                                    nextChunkFitsIntoPacket(path, path->pmtu - sctpMsg->getByteLength() - 20) &&
                                    (sctpMsg->getByteLength() < path->pmtu - 32 - 20) && (tcount == 0))
                                {
                                    EV_DETAIL << "Nagle: Packet has to be stored\n";
                                    storePacket(path, sctpMsg, chunksAdded, dataChunksAdded, authAdded);
                                    sctpMsg = nullptr;
                                    chunksAdded = 0;
                                }
                                packetFull = true;    // chunksAdded==0, packetFull==true => leave inner while loop
                                EV_DETAIL << "sendAll: packetFull: msg length = " << sctpMsg->getByteLength() + 20 << "\n";
                            }
                        }
                    }
                    else if (chunksAdded == 1 && sackAdded && !sackOnly) {
                        sctpMsg->removeChunk();
                        EV_DETAIL << "Nagle or no data: Remove SACK chunk, delete sctpmsg" << endl;
                        delete sackChunk;
                        packetFull = true;
                        sackAdded = false;
                        chunksAdded--;
                    }
                    else if ((chunksAdded == 1 && sackAdded && sackOnly) || headerCreated) {
                        packetFull = true;
                        /* TD 19.02.2015:
                           If we are not on the primary path, and
                           there is a small chunk to send (bytesToSend > 0),
                           and Nagle turned on:
                           leave inner loop. Otherwise, there will be an infinite loop! */
                        bytesToSend = 0;
                    }
                }
                else if (chunksAdded == 1 && sackAdded && !sackOnly) {
                    sctpMsg->removeChunk();
                    EV_DETAIL << "Nagle or no data: Remove SACK chunk, delete sctpmsg\n";
                    delete sackChunk;
                    packetFull = true;
                    sackAdded = false;
                    chunksAdded--;
                }
                else if (chunksAdded == 1 && sackAdded && sackOnly) {
                    packetFull = true;
                }
                else if (datVar == nullptr || chunksAdded == 0) {
                    EV_DETAIL << "HeaderCreated=" << headerCreated << ", chunksAdded=" << chunksAdded << " datVar=" << datVar << "\n";
                    if (headerCreated) {
                        packetFull = true;
                    }
                }

                // ------ Handle DATA chunk -------------------------------------
                if (datVar != nullptr && !packetFull) {
                    // ------ Assign TSN -----------------------------------------
                    if (firstTime) {
                        assert(datVar->tsn == 0);
                        datVar->tsn = state->nextTSN;
                        EV_DETAIL << "sendAll: set TSN=" << datVar->tsn
                                  << " sid=" << datVar->sid << ", ssn=" << datVar->ssn << "\n";
                        state->nextTSN++;
                        path->vectorPathSentTSN->record(datVar->tsn);
                    }
                    else {
                        if (datVar->hasBeenFastRetransmitted) {
                            path->vectorPathTSNFastRTX->record(datVar->tsn);
                        }
                        else {
                            path->vectorPathTSNTimerBased->record(datVar->tsn);
                        }
                    }

                    auto iterator = sctpMain->assocStatMap.find(assocId);
                    iterator->second.transmittedBytes += datVar->len / 8;

                    datVar->setLastDestination(path);
                    datVar->countsAsOutstanding = true;
                    datVar->hasBeenReneged = false;
                    datVar->sendTime = simTime();    //I.R. to send Fast RTX just once a RTT
                    if (datVar->firstSendTime == 0) {
                        datVar->firstSendTime = simTime();
                    }

                    // ------ First transmission of datVar -----------------------
                    if (datVar->numberOfTransmissions == 0) {
                        EV_DETAIL << "sendAll: " << simTime() << " firstTime, TSN "
                                  << datVar->tsn << ": lastDestination set to "
                                  << datVar->getLastDestination() << endl;

                        if (!state->firstDataSent) {
                            state->firstDataSent = true;
                        }
                        EV_DETAIL << "sendAll: insert in retransmissionQ tsn=" << datVar->tsn << "\n";
                        if (!retransmissionQ->checkAndInsertChunk(datVar->tsn, datVar)) {
                            throw cRuntimeError("Cannot add datVar to retransmissionQ!");
                            // Falls es hier aufschlaegt, muss ueberlegt werden, ob es OK ist, dass datVars nicht eingefuegt werden koennen.
                        }
                        else {
                            EV_DETAIL << "sendAll: size of retransmissionQ=" << retransmissionQ->getQueueSize() << "\n";
                            unackChunk(datVar);
                            increaseOutstandingBytes(datVar, path);
                            datVar->queuedOnPath = path;
                            datVar->queuedOnPath->queuedBytes += datVar->booksize;
                            datVar->queuedOnPath->statisticsPathQueuedSentBytes->record(path->queuedBytes);

                            state->queuedSentBytes += datVar->booksize;
                            statisticsQueuedSentBytes->record(state->queuedSentBytes);
                        }
                    }

                    /* datVar is already in the retransmissionQ */
                    datVar->numberOfTransmissions++;
                    datVar->gapReports = 0;
                    datVar->hasBeenFastRetransmitted = false;
                    EV_DETAIL << "sendAll(): adding new outbound data datVar to packet (tsn=" << datVar->tsn << ")...!!!\n";
                    /* update counters */
                    totalChunksSent++;
                    chunksAdded++;
                    dataChunksAdded++;

                    dataChunkPtr = transformDataChunk(datVar);
                    sctpMsg->addChunk(dataChunkPtr);

                    EV_DETAIL << assocId << ": DataChunk added -  TSN:" << dataChunkPtr->getTsn() << " - length:" << dataChunkPtr->getByteLength() << " - ssn:" << dataChunkPtr->getSsn() << "\n";

                    if (datVar->numberOfTransmissions > 1) {
                        auto tq = qCounter.roomTransQ.find(path->remoteAddress);
                        if (tq->second > 0) {
                            if (transmissionQ->getSizeOfFirstChunk(path->remoteAddress) > path->pmtu - sctpMsg->getByteLength() - 20)
                                packetFull = true;
                        }
                        else if (nextChunkFitsIntoPacket(path, path->pmtu - sctpMsg->getByteLength() - 20) == false) {
                            packetFull = true;
                        }
                    }
                    else {
                        if (nextChunkFitsIntoPacket(path, path->pmtu - sctpMsg->getByteLength() - 20) == false) {
                            packetFull = true;
                        }
                    }

                    state->peerRwnd -= (datVar->booksize + state->bytesToAddPerPeerChunk);
                    if (state->peerAllowsChunks) {
                        state->peerMsgRwnd--;
                    }
                    if ((bytes.chunk == false) && (bytes.packet == false)) {
                        bytesToSend -= datVar->booksize;
                    }
                    else if (bytes.chunk) {
                        bytes.chunk = false;
                    }
                    else if ((bytes.packet) && (packetFull)) {
                        bytes.packet = false;
                    }

                    if (bytesToSend <= 0) {
                        if ((!packetFull) && (qCounter.roomSumSendStreams > path->pmtu - 32 - 20 || tcount > 0)) {
                            sendOneMorePacket = true;
                            bytes.packet = true;
                            EV_DETAIL << assocId << ": sendAll: one more packet allowed\n";
                        }
                        else {
                            if (state->nagleEnabled && (outstandingBytes > 0) &&
                                nextChunkFitsIntoPacket(path, path->pmtu - sctpMsg->getByteLength() - 20) &&
                                (sctpMsg->getByteLength() < path->pmtu - 32 - 20) && (tcount == 0))
                            {
                                storePacket(path, sctpMsg, chunksAdded, dataChunksAdded, authAdded);
                                sctpMsg = nullptr;
                                chunksAdded = 0;
                                packetFull = true;    // chunksAdded==0, packetFull==true => leave inner while loop
                            }
                            else {
                                packetFull = true;
                            }
                        }
                        bytesToSend = 0;
                    }
                    else if ((qCounter.roomSumSendStreams == 0) && (tq->second == 0)) {
                        packetFull = true;
                        EV_DETAIL << "sendAll: no data in send and transQ: packet full\n";
                    }
                    EV_DETAIL << "sendAll: bytesToSend after reduction: " << bytesToSend << "\n";
                }    // end if (datVar != nullptr && !packetFull)
                     // ------ There is no DATA chunk, only control chunks possible --
                else {
                    if (chunksAdded == 0) {    // Nothing to do -> return
                        packetFull = true;    // chunksAdded==0, packetFull==true => leave inner while loop
                    }
                    else {
                        packetFull = true;
                        EV_DETAIL << assocId << ": sendAll: packetFull: msg length = " << sctpMsg->getByteLength() + 20 << "\n";
                        datVar = nullptr;
                    }
                    delete datVar;
                }

                // ====== Send packet ===========================================
                if (packetFull) {
                    if (chunksAdded == 0) {    // Nothing to send
                        delete sctpMsg;
                        sctpMsg = nullptr;
                        sendingAllowed = false;    // sendingAllowed==false => leave outer while loop
                    }
                    else {
                        EV_DETAIL << assocId << ":: sendAll: " << simTime() << "    packet full:"
                                  << "    totalLength=" << sctpMsg->getBitLength() / 8 + 20
                                  << ",    path=" << path->remoteAddress
                                  << "     " << dataChunksAdded << " chunks added, outstandingBytes now "
                                  << path->outstandingBytes << "\n";

                        /* new chunks would exceed MTU, so we send old packet and build a new one */
                        /* this implies that at least one data chunk is send here */
                        if (dataChunksAdded > 0) {
                            if (!path->T3_RtxTimer->isScheduled()) {
                                // Start retransmission timer, if not scheduled before
                                startTimer(path->T3_RtxTimer, path->pathRto);
                            }
                            else {
                                EV_DETAIL << "sendAll: RTX Timer already scheduled -> no need to schedule it\n";
                            }
                        }
                        else {
                            bytes.packet = false;   // TD 23.02.2015: no DATA chunks => done.
                        }

                        if (sendOneMorePacket) {
                            sendOneMorePacket = false;
                            bytesToSend = 0;
                            bytes.packet = false;
                            SCTPDataChunk *pkt = check_and_cast<SCTPDataChunk *>(sctpMsg->getChunks(sctpMsg->getChunksArraySize() - 1));
                            pkt->setIBit(sctpMain->sackNow);
                            sctpMsg->replaceChunk(pkt, sctpMsg->getChunksArraySize() - 1);
                        }

                        // Set I-bit when this is the final packet for this path!
                        const int32 a = (int32)path->cwnd - (int32)path->outstandingBytes;
                        if ((((a > 0) && (nextChunkFitsIntoPacket(path, a) == false)) || (!firstPass)) && !forwardPresent) {
                            SCTPDataChunk *pkt = check_and_cast<SCTPDataChunk *>(sctpMsg->getChunks(sctpMsg->getChunksArraySize() - 1));
                            pkt->setIBit(sctpMain->sackNow);
                            sctpMsg->replaceChunk(pkt, sctpMsg->getChunksArraySize() - 1);
                        }

                        if (dataChunksAdded > 0) {
                            state->ssNextStream = true;
                        }
                        EV_DETAIL << assocId << ":sendToIP: packet size=" << sctpMsg->getByteLength() << " numChunks=" << sctpMsg->getChunksArraySize() << "\n";
                        sendToIP(sctpMsg, path->remoteAddress);
                        sctpMsg = nullptr;
                        pmDataIsSentOn(path);
                        totalPacketsSent++;
                        path->lastTransmission = simTime();
                        path->packetsInBurst++;
                        state->lastTransmission = simTime();
                        state->packetsInTotalBurst++;

                        // ------ Reset status ------------------------------------
                        firstTime = false;
                        headerCreated = false;
                        chunksAdded = 0;
                        dataChunksAdded = 0;
                        authAdded = false;

                        EV_INFO << "sendAll: sending Packet to path " << path->remoteAddress
                                << "  scount=" << scount
                                << "  tcount=" << tcount
                                << "  bytesToSend=" << bytesToSend << endl;
                    }
                }
                EV_INFO << "sendAll: still " << bytesToSend
                        << " bytes to send, headerCreated=" << headerCreated << endl;
            }    // if (bytesToSend > 0 || bytes.chunk || bytes.packet)
            else if (headerCreated && state->bundleReset) {
                sendToIP(sctpMsg, path->remoteAddress);
                sctpMsg = nullptr;
                return;
            } else {
                packetFull = true;    // Leave inner while loop
                delete sctpMsg;    // T.D. 19.01.2010: Free unsent message
                sctpMsg = nullptr;
            }

            EV_INFO << "packetFull=" << packetFull << endl;
        }    // while(!packetFull)

        EV_INFO << "bytesToSend=" << bytesToSend
                << " bytes.chunk=" << bytes.chunk
                << " bytes.packet=" << bytes.packet << endl;
        if (!(bytesToSend > 0 || bytes.chunk || bytes.packet)) {
            sendingAllowed = false;
        }
    }    // while(sendingAllowed)

    if (state->ackState >= sackFrequency)
        sendSack();

    EV_INFO << "sendAll: nothing more to send... BYE!\n";
}

void inet::sctp::SCTPAssociation::sendOutgoingRequestAndResponse ( uint32  inRequestSn, uint32  outRequestSn  )

protected

Referenced by process_RCV_Message(), and processInAndOutResetRequestArrived().

{
    EV_INFO << "sendOutgoingResetRequest to " << remoteAddr << "\n";
    SCTPMessage *msg = new SCTPMessage();
    msg->setByteLength(SCTP_COMMON_HEADER);
    msg->setSrcPort(localPort);
    msg->setDestPort(remotePort);
    SCTPStreamResetChunk *resChunk = new SCTPStreamResetChunk("ReqResRE_CONFIG");
    resChunk->setChunkType(RE_CONFIG);
    resChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
    uint32 srsn = state->streamResetSequenceNumber;
    SCTPResetTimer *rt = new SCTPResetTimer();
    SCTPOutgoingSSNResetRequestParameter *outResetParam;
    outResetParam = new SCTPOutgoingSSNResetRequestParameter("Outgoing_Request_Param");
    outResetParam->setParameterType(OUTGOING_RESET_REQUEST_PARAMETER);
    outResetParam->setSrReqSn(srsn++);
    outResetParam->setSrResSn(inRequestSn);
    outResetParam->setLastTsn(state->nextTSN - 1);
    outResetParam->setByteLength(SCTP_OUTGOING_RESET_REQUEST_PARAMETER_LENGTH);
    resChunk->addParameter(outResetParam);
    state->streamResetSequenceNumber = srsn;
    SCTPStreamResetResponseParameter *responseParam = new SCTPStreamResetResponseParameter("Response_Param");
    responseParam->setParameterType(STREAM_RESET_RESPONSE_PARAMETER);
    responseParam->setSrResSn(outRequestSn);
    responseParam->setResult(1);
    responseParam->setByteLength(SCTP_STREAM_RESET_RESPONSE_PARAMETER_LENGTH);
    resChunk->addParameter(responseParam);
    rt->setInSN(srsn - 1);
    rt->setInAcked(false);
    rt->setOutSN(outRequestSn);
    rt->setOutAcked(false);
    if (state->resetChunk != nullptr) {
        delete state->resetChunk;
        state->resetChunk = nullptr;
    }
    state->resetChunk = check_and_cast<SCTPStreamResetChunk *>(resChunk->dup());
    state->resetChunk->setName("stateRstChunk");
    msg->addChunk(resChunk);
    sendToIP(msg, remoteAddr);
    PK(getPath(remoteAddr)->ResetTimer)->encapsulate(rt);
    startTimer(getPath(remoteAddr)->ResetTimer, getPath(remoteAddr)->pathRto);
}

void inet::sctp::SCTPAssociation::sendOutgoingRequestAndResponse ( SCTPIncomingSSNResetRequestParameter *  inRequestParam, SCTPOutgoingSSNResetRequestParameter *  outRequestParam  )

protected

{
    uint16 len = 0;
    EV_INFO << "sendOutgoingRequestAndResponse to " << remoteAddr << "\n";
    SCTPMessage *msg = new SCTPMessage();
    msg->setByteLength(SCTP_COMMON_HEADER);
    msg->setSrcPort(localPort);
    msg->setDestPort(remotePort);
    SCTPStreamResetChunk *resChunk = new SCTPStreamResetChunk("ReqResRE_CONFIG");
    resChunk->setChunkType(RE_CONFIG);
    resChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
    uint32 srsn = state->streamResetSequenceNumber;
    SCTPResetTimer *rt = new SCTPResetTimer();
    SCTPOutgoingSSNResetRequestParameter *outResetParam;
    outResetParam = new SCTPOutgoingSSNResetRequestParameter("Outgoing_Reset_Request_Param");
    outResetParam->setParameterType(OUTGOING_RESET_REQUEST_PARAMETER);
    outResetParam->setSrReqSn(srsn++);
    outResetParam->setSrResSn(inRequestParam->getSrReqSn());
    outResetParam->setLastTsn(state->nextTSN - 1);
    if (inRequestParam->getStreamNumbersArraySize() > 0) {
        outResetParam->setStreamNumbersArraySize(inRequestParam->getStreamNumbersArraySize());
        for (uint i = 0; i < inRequestParam->getStreamNumbersArraySize(); i++) {
            outResetParam->setStreamNumbers(i, (uint16)inRequestParam->getStreamNumbers(i));
            state->resetOutStreams.push_back(outResetParam->getStreamNumbers(i));
            state->requests[srsn].streams.push_back(outResetParam->getStreamNumbers(i));
            len++;
        }
    }
    outResetParam->setByteLength(SCTP_OUTGOING_RESET_REQUEST_PARAMETER_LENGTH + len * 2);
    resChunk->addParameter(outResetParam);
    state->streamResetSequenceNumber = srsn;
    SCTPStreamResetResponseParameter *responseParam = new SCTPStreamResetResponseParameter("Response_Param");
    responseParam->setParameterType(STREAM_RESET_RESPONSE_PARAMETER);
    responseParam->setSrResSn(outRequestParam->getSrReqSn());
    responseParam->setResult(1);
    responseParam->setByteLength(SCTP_STREAM_RESET_RESPONSE_PARAMETER_LENGTH);
    resChunk->addParameter(responseParam);
    rt->setInSN(srsn - 1);
    rt->setInAcked(false);
    rt->setOutSN(outRequestParam->getSrReqSn());
    rt->setOutAcked(false);
    if (state->resetChunk != nullptr) {
        delete state->resetChunk;
        state->resetChunk = nullptr;
    }
    state->resetChunk = check_and_cast<SCTPStreamResetChunk *>(resChunk->dup());
    state->resetChunk->setName("stateRstChunk");
    msg->addChunk(resChunk);
    sendToIP(msg, remoteAddr);
    if (PK(getPath(remoteAddr)->ResetTimer)->hasEncapsulatedPacket()) {
        PK(getPath(remoteAddr)->ResetTimer)->decapsulate();
    }
    PK(getPath(remoteAddr)->ResetTimer)->encapsulate(rt);
    startTimer(getPath(remoteAddr)->ResetTimer, getPath(remoteAddr)->pathRto);
}

void inet::sctp::SCTPAssociation::sendOutgoingResetRequest ( SCTPIncomingSSNResetRequestParameter *  requestParam )

protected

Referenced by processIncomingResetRequestArrived().

{
    EV_INFO << "sendOutgoingResetRequest to " << remoteAddr << "\n";
    uint16 len = 0;
    uint32 srsn = 0;
    if ((!(getPath(remoteAddr)->ResetTimer->isScheduled())) || state->requestsOverlap) {
        state->requestsOverlap = false;
        SCTPStreamResetChunk *resetChunk = new SCTPStreamResetChunk("OutRE_CONFIG");
        resetChunk->setChunkType(RE_CONFIG);
        resetChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
        SCTPOutgoingSSNResetRequestParameter *outResetParam;
        outResetParam = new SCTPOutgoingSSNResetRequestParameter("Outgoing_SSN_Request_Param");
        outResetParam->setParameterType(OUTGOING_RESET_REQUEST_PARAMETER);
        SCTPStateVariables::RequestData *resDat = state->findTypeInRequests(OUTGOING_RESET_REQUEST_PARAMETER);
        if (resDat != nullptr && resDat->sn == state->streamResetSequenceNumber - 1) {
            srsn = state->streamResetSequenceNumber - 1;
        } else {
            srsn = state->streamResetSequenceNumber;
            state->requests[srsn].result = 100;
            state->requests[srsn].type = OUTGOING_RESET_REQUEST_PARAMETER;
            state->requests[srsn].sn = srsn;
            state->numResetRequests++;
        }
        outResetParam->setSrReqSn(srsn++);
        outResetParam->setSrResSn(requestParam->getSrReqSn());
        if (state->findPeerRequestNum(requestParam->getSrReqSn())) {
            state->peerRequests[requestParam->getSrReqSn()].result = PERFORMED;
            state->firstPeerRequest = false;
            if (state->incomingRequestSet && state->incomingRequest != nullptr) {
                delete state->incomingRequest;
                state->incomingRequest = nullptr;
                state->incomingRequestSet = false;
            }
        }
        outResetParam->setLastTsn(state->nextTSN - 1);
        if (state->peerStreamsToReset.size() > 0) {
            outResetParam->setStreamNumbersArraySize(state->peerStreamsToReset.size());
            uint16 i = 0;
            for (std::list<uint16>::iterator it = state->peerStreamsToReset.begin(); it != state->peerStreamsToReset.end(); ++it) {
                outResetParam->setStreamNumbers(i, *it);
                state->resetOutStreams.push_back(outResetParam->getStreamNumbers(i));
                state->requests[srsn-1].streams.push_back(outResetParam->getStreamNumbers(i));
                i++;
            }
            len = state->peerStreamsToReset.size() * 2;
            state->peerStreamsToReset.clear();
        } else if (state->streamsToReset.size() > 0) {
            outResetParam->setStreamNumbersArraySize(state->streamsToReset.size());
            uint16 i = 0;
            for (std::list<uint16>::iterator it = state->streamsToReset.begin(); it != state->streamsToReset.end(); ++it) {
                outResetParam->setStreamNumbers(i, *it);
                state->resetOutStreams.push_back(outResetParam->getStreamNumbers(i));
                state->requests[srsn-1].streams.push_back(outResetParam->getStreamNumbers(i));
                resetSsn(outResetParam->getStreamNumbers(i));
                i++;
            }
            len = state->streamsToReset.size() * 2;
            state->streamsToReset.clear();
        } else if (requestParam->getStreamNumbersArraySize() > 0) {
            outResetParam->setStreamNumbersArraySize(requestParam->getStreamNumbersArraySize());
            for (uint16 i = 0; i < requestParam->getStreamNumbersArraySize(); i++) {
                outResetParam->setStreamNumbers(i, requestParam->getStreamNumbers(i));
                state->requests[srsn-1].streams.push_back(requestParam->getStreamNumbers(i));
            }
            len = requestParam->getStreamNumbersArraySize() * 2;
        }
        outResetParam->setByteLength(SCTP_OUTGOING_RESET_REQUEST_PARAMETER_LENGTH + len);
        resetChunk->addParameter(outResetParam);
        state->streamResetSequenceNumber = srsn;
        state->resetRequested = true;

        SCTPResetTimer *rt = new SCTPResetTimer();
        rt->setInSN(0);
        rt->setInAcked(true);
        rt->setOutSN(srsn - 1);
        rt->setOutAcked(false);

        SCTPMessage *msg = new SCTPMessage();
        msg->setByteLength(SCTP_COMMON_HEADER);
        msg->setSrcPort(localPort);
        msg->setDestPort(remotePort);
        msg->addChunk(resetChunk);
        state->localRequestType = RESET_OUTGOING;
        if (state->resetChunk != nullptr) {
            delete state->resetChunk;
            state->resetChunk = nullptr;
        }
        state->resetChunk = check_and_cast<SCTPStreamResetChunk *>(resetChunk->dup());
        if (qCounter.roomSumSendStreams != 0) {
            storePacket(getPath(remoteAddr), msg, 1, 0, false);
            state->bundleReset = true;
            rt->setName("bundleReset");
            sendOnPath(getPath(remoteAddr), true);
            state->bundleReset = false;
        } else {
            sendToIP(msg, remoteAddr);
        }
        if (PK(getPath(remoteAddr)->ResetTimer)->hasEncapsulatedPacket()) {
            delete (PK(getPath(remoteAddr)->ResetTimer)->decapsulate());
        }
        PK(getPath(remoteAddr)->ResetTimer)->encapsulate(rt);
        if (getPath(remoteAddr)->ResetTimer->isScheduled()) {
            stopTimer(getPath(remoteAddr)->ResetTimer);
        }
        startTimer(getPath(remoteAddr)->ResetTimer, getPath(remoteAddr)->pathRto);
    }
}

void inet::sctp::SCTPAssociation::sendPacketDrop ( const bool  flag )

protected

Referenced by process_RCV_Message(), and processDataArrived().

{
    EV_INFO << "sendPacketDrop:\t";
    SCTPMessage *drop = (SCTPMessage *)state->sctpmsg->dup();        //FIXME is the c-style conversion need here?
    if (drop->getChunksArraySize() == 1) {
        SCTPChunk *header = (SCTPChunk *)(drop->getChunks(0));
        if (header->getChunkType() == PKTDROP) {
            disposeOf(state->sctpmsg);
            delete drop;
            return;
        }
    }
    SCTPMessage *sctpmsg = new SCTPMessage();
    sctpmsg->setByteLength(SCTP_COMMON_HEADER);
    SCTPPacketDropChunk *pktdrop = new SCTPPacketDropChunk("PKTDROP");
    pktdrop->setChunkType(PKTDROP);
    pktdrop->setCFlag(false);
    pktdrop->setTFlag(false);
    pktdrop->setBFlag(flag);
    pktdrop->setMFlag(false);
    pktdrop->setMaxRwnd(sctpMain->par("arwnd"));
    pktdrop->setQueuedData(state->queuedReceivedBytes);
    pktdrop->setTruncLength(0);
    pktdrop->setByteLength(SCTP_PKTDROP_CHUNK_LENGTH);
    uint16 mss = getPath(remoteAddr)->pmtu - SCTP_COMMON_HEADER - SCTP_DATA_CHUNK_LENGTH - IP_HEADER_LENGTH;
    if (drop->getByteLength() > mss) {
        uint16 diff = drop->getByteLength() - mss;
        pktdrop->setTruncLength(drop->getByteLength());
        SCTPChunk *chunk = (SCTPChunk *)(drop->removeLastChunk());
        if (chunk->getChunkType() == DATA) {
            SCTPDataChunk *dataChunk = check_and_cast<SCTPDataChunk *>(chunk);
            SCTPSimpleMessage *smsg = check_and_cast<SCTPSimpleMessage *>(dataChunk->decapsulate());
            if (smsg->getDataLen() > diff) {
                uint16 newLength = smsg->getDataLen() - diff;
                smsg->setDataArraySize(newLength);
                for (uint16 i = 0; i < newLength; i++)
                    smsg->setData(i, 'a');
                smsg->setDataLen(newLength);
                smsg->setEncaps(false);
                smsg->setByteLength(newLength);
                dataChunk->encapsulate(smsg);
                drop->addChunk(dataChunk);
            }
            else if (drop->getChunksArraySize() == 1) {
                delete chunk;
                delete pktdrop;
                disposeOf(state->sctpmsg);
                EV_DETAIL << "laenge=" << drop->getByteLength() << " numberOfChunks=1\n";
                disposeOf(drop);
                return;
            }
        }
        else {
            delete pktdrop;
            disposeOf(state->sctpmsg);
            EV_DETAIL << "laenge=" << drop->getByteLength() << " numberOfChunks=1\n";
            disposeOf(drop);
            return;
        }
        pktdrop->setTFlag(true);
    }
    pktdrop->encapsulate(drop);
    EV_DETAIL << "length of PKTDROP chunk=" << pktdrop->getBitLength() / 8 << "\n";
    sctpmsg->addChunk(pktdrop);
    EV_DETAIL << "total length now " << sctpmsg->getByteLength() << "\n";
    disposeOf(state->sctpmsg);
    state->pktDropSent = true;
    sctpMain->numPktDropReports++;
    sendToIP(sctpmsg);
}

void inet::sctp::SCTPAssociation::sendSack ( )

protected

Referenced by process_RCV_Message(), processPacketDropArrived(), pushUlp(), and sendOnPath().

{
    SCTPAuthenticationChunk *authChunk;
    SCTPSackChunk *sackChunk;

    EV_INFO << "Sending SACK" << endl;

    /* sack timer has expired, reset flag, and send SACK */
    stopTimer(SackTimer);
    state->ackState = 0;
    sackChunk = createSack();

    SCTPMessage *sctpmsg = new SCTPMessage();
    sctpmsg->setByteLength(SCTP_COMMON_HEADER);
    if (state->auth && state->peerAuth && typeInChunkList(SACK)) {
        authChunk = createAuthChunk();
        sctpmsg->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }
    sctpmsg->addChunk(sackChunk);

    sendSACKviaSelectedPath(sctpmsg);
}

void inet::sctp::SCTPAssociation::sendSACKviaSelectedPath ( SCTPMessage *  sctpMsg )

private

Referenced by sendInvalidStreamError(), sendOnPath(), and sendSack().

{
    SCTPPathVariables *sackPath =
        (state->lastDataSourceList.size() > 0) ? state->lastDataSourceList.front() :
        state->lastDataSourcePath;
    assert(sackPath != nullptr);

    if (state->allowCMT) {
        if (state->cmtSackPath == SCTPStateVariables::CSP_RoundRobin) {
            /* Observation:
               For same bandwidths but different delays, chunks on both paths arrive
               with same interleave time =>
               Chunk on A / Chunk on B => SACK on B
               Chunk on A / Chunk on B => SACK on B
               Chunk on A / Chunk on B => SACK on B
               Chunk on A / Chunk on B => SACK on B
               Chunk on A / Chunk on B => SACK on B
               ...
               RESULT: Losts of SACKs on B, no SACK on A  =>  Bad performance! */

            // Solution is now to make a round-robin selection among paths,
            // taking the path with the longest time passed since last SACK.
            for (auto path : state->lastDataSourceList)
            {
                if (path->lastSACKSent < sackPath->lastSACKSent) {
                    sackPath = path;
                }
            }
        }
        else if (state->cmtSackPath == SCTPStateVariables::CSP_SmallestSRTT) {
            /* Instead of RR among last DATA paths, send SACK on
               the DATA path having the smallest SRTT. */
            for (auto path : state->lastDataSourceList)
            {
                if (path->srtt < sackPath->srtt) {
                    sackPath = path;
                }
            }
        }
        else if (state->cmtSackPath == SCTPStateVariables::CSP_Primary) {
            sackPath = state->getPrimaryPath();
        }
    }
    EV_INFO << assocId << ": sending SACK to " << sackPath->remoteAddress << endl;
    sendToIP(sctpMsg, sackPath->remoteAddress);
    sackPath->lastSACKSent = simTime();
    state->lastDataSourceList.clear();    // Clear the address list!
}

void inet::sctp::SCTPAssociation::sendShutdown ( )

protected

Referenced by process_CLOSE(), and process_RCV_Message().

{
    SCTPAuthenticationChunk *authChunk;
    SCTPMessage *msg = new SCTPMessage();
    msg->setByteLength(SCTP_COMMON_HEADER);

    EV_INFO << "SCTPAssociationUtil:sendShutdown localPort=" << localPort << "     remotePort=" << remotePort << "\n";

    msg->setSrcPort(localPort);
    msg->setDestPort(remotePort);
    SCTPShutdownChunk *shutdownChunk = new SCTPShutdownChunk("SHUTDOWN");
    shutdownChunk->setChunkType(SHUTDOWN);
    //shutdownChunk->setCumTsnAck(state->lastTsnAck);
    shutdownChunk->setCumTsnAck(state->gapList.getCumAckTSN());
    shutdownChunk->setByteLength(SCTP_SHUTDOWN_CHUNK_LENGTH);
    if (state->auth && state->peerAuth && typeInChunkList(SHUTDOWN)) {
        authChunk = createAuthChunk();
        msg->addChunk(authChunk);
        auto it = sctpMain->assocStatMap.find(assocId);
        it->second.numAuthChunksSent++;
    }
    state->initRexmitTimeout = SCTP_TIMEOUT_INIT_REXMIT;
    state->initRetransCounter = 0;
    stopTimer(T5_ShutdownGuardTimer);
    startTimer(T5_ShutdownGuardTimer, SHUTDOWN_GUARD_TIMEOUT);
    stopTimer(T2_ShutdownTimer);
    startTimer(T2_ShutdownTimer, state->initRexmitTimeout);
    state->shutdownChunk = check_and_cast<SCTPShutdownChunk *>(shutdownChunk->dup());
    msg->addChunk(shutdownChunk);
    sendToIP(msg, remoteAddr);
    performStateTransition(SCTP_E_NO_MORE_OUTSTANDING);
}

void inet::sctp::SCTPAssociation::sendShutdownAck ( const L3Address &  dest )

protected

Referenced by process_CLOSE(), and process_RCV_Message().

{
    sendOnAllPaths(getPath(dest));
    if (getOutstandingBytes() == 0) {
        performStateTransition(SCTP_E_NO_MORE_OUTSTANDING);
        SCTPMessage *sctpshutdownack = new SCTPMessage();
        sctpshutdownack->setByteLength(SCTP_COMMON_HEADER);

        EV_INFO << "SCTPAssociationUtil:sendShutdownACK" << endl;

        sctpshutdownack->setSrcPort(localPort);
        sctpshutdownack->setDestPort(remotePort);
        SCTPShutdownAckChunk *shutdownAckChunk = new SCTPShutdownAckChunk("SHUTDOWN_ACK");
        shutdownAckChunk->setChunkType(SHUTDOWN_ACK);
        shutdownAckChunk->setByteLength(SCTP_COOKIE_ACK_LENGTH);
        sctpshutdownack->addChunk(shutdownAckChunk);
        state->initRexmitTimeout = SCTP_TIMEOUT_INIT_REXMIT;
        state->initRetransCounter = 0;
        stopTimer(T2_ShutdownTimer);
        startTimer(T2_ShutdownTimer, state->initRexmitTimeout);
        stopTimer(T5_ShutdownGuardTimer);
        startTimer(T5_ShutdownGuardTimer, SHUTDOWN_GUARD_TIMEOUT);
        state->shutdownAckChunk = check_and_cast<SCTPShutdownAckChunk *>(shutdownAckChunk->dup());
        sendToIP(sctpshutdownack, dest);
    }
}

void inet::sctp::SCTPAssociation::sendShutdownComplete ( )

protected

Referenced by process_RCV_Message().

{
    SCTPMessage *sctpshutdowncomplete = new SCTPMessage();
    sctpshutdowncomplete->setByteLength(SCTP_COMMON_HEADER);

    EV_INFO << "SCTPAssociationUtil:sendShutdownComplete\n";

    sctpshutdowncomplete->setSrcPort(localPort);
    sctpshutdowncomplete->setDestPort(remotePort);
    SCTPShutdownCompleteChunk *shutdownCompleteChunk = new SCTPShutdownCompleteChunk("SHUTDOWN_COMPLETE");
    shutdownCompleteChunk->setChunkType(SHUTDOWN_COMPLETE);
    shutdownCompleteChunk->setTBit(0);
    shutdownCompleteChunk->setByteLength(SCTP_SHUTDOWN_ACK_LENGTH);
    sctpshutdowncomplete->addChunk(shutdownCompleteChunk);
    sendToIP(sctpshutdowncomplete);
}

bool inet::sctp::SCTPAssociation::sendStreamPresent ( uint16  sid )

protected

Referenced by processIncomingResetRequestArrived().

{
    auto iterator = sendStreams.find(id);
    if (iterator == sendStreams.end())
        return false;
    else
        return true;
}

void inet::sctp::SCTPAssociation::sendStreamResetRequest ( SCTPResetInfo *  info )

protected

Referenced by checkStreamsToReset(), process_STREAM_RESET(), and sendOnAllPaths().

{
    EV_INFO << "StreamReset:sendStreamResetRequest\n";
    SCTPParameter *param;
    uint16 type;
    SCTPMessage *msg = new SCTPMessage();
    msg->setByteLength(SCTP_COMMON_HEADER);
    msg->setSrcPort(localPort);
    msg->setDestPort(remotePort);
    SCTPStreamResetChunk *resetChunk = new SCTPStreamResetChunk("myRE_CONFIG");
    resetChunk->setChunkType(RE_CONFIG);
    resetChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
    uint32 srsn = state->streamResetSequenceNumber;
    SCTPResetTimer *rt = new SCTPResetTimer();
    auto it = sctpMain->assocStatMap.find(assocId);
    if (rinfo)
        type = rinfo->getRequestType();
    else
        type = state->localRequestType;
    switch (type) {
        case RESET_OUTGOING:
            EV_INFO << "RESET_OUTGOING\n";
            state->requests[srsn].result = 100;
            state->requests[srsn].type = OUTGOING_RESET_REQUEST_PARAMETER;
            state->requests[srsn].sn = srsn;
            param = makeOutgoingStreamResetParameter(srsn, rinfo);
            resetChunk->addParameter(param);
            rt->setInSN(0);
            rt->setInAcked(true);
            rt->setOutSN(srsn);
            rt->setOutAcked(false);
            it->second.numResetRequestsSent++;
            state->numResetRequests++;

            state->waitForResponse = true;
            state->resetRequested = true;
            break;

        case RESET_INCOMING:
            state->requests[srsn].result = 100;
            state->requests[srsn].type = INCOMING_RESET_REQUEST_PARAMETER;
            state->requests[srsn].sn = srsn;
            param = makeIncomingStreamResetParameter(srsn, rinfo);
            resetChunk->addParameter(param);
            rt->setInSN(srsn);
            rt->setInAcked(false);
            rt->setOutSN(0);
            rt->setOutAcked(true);
            it->second.numResetRequestsSent++;
            state->numResetRequests++;
            state->waitForResponse = true;
            break;

        case RESET_BOTH:
            SCTPParameter *outParam;
            state->requests[srsn].result = 100;
            state->requests[srsn].type = OUTGOING_RESET_REQUEST_PARAMETER;
            state->requests[srsn].sn = srsn;
            outParam = makeOutgoingStreamResetParameter(srsn, rinfo);
            rt->setOutSN(srsn++);
            rt->setOutAcked(false);
            resetChunk->addParameter(outParam);
            state->requests[srsn].result = 100;
            state->requests[srsn].type = INCOMING_RESET_REQUEST_PARAMETER;
            state->requests[srsn].sn = srsn;
            SCTPParameter *inParam;
            inParam = makeIncomingStreamResetParameter(srsn, rinfo);
            resetChunk->addParameter(inParam);
            rt->setInSN(srsn);
            rt->setInAcked(false);
            it->second.numResetRequestsSent += 2;
            state->numResetRequests += 2;
            state->waitForResponse = true;
            break;

        case SSN_TSN:
            param = makeSSNTSNResetParameter(srsn);
            resetChunk->addParameter(param);
            rt->setInSN(srsn);
            rt->setInAcked(false);
            rt->setOutSN(srsn);
            rt->setOutAcked(false);
            state->requests[srsn].result = 100;
            state->requests[srsn].type = SSN_TSN_RESET_REQUEST_PARAMETER;
            it->second.numResetRequestsSent++;
            state->numResetRequests++;
            break;

        case ADD_INCOMING:
        case ADD_OUTGOING:
            state->requests[srsn].result = 100;
            param = makeAddStreamsRequestParameter(srsn, rinfo);
            resetChunk->addParameter(param);
            rt->setInSN(srsn);
            rt->setInAcked(false);
            rt->setOutSN(0);
            rt->setOutAcked(true);
            it->second.numResetRequestsSent++;
            state->numResetRequests++;
            break;
        default: printf("Request type %d not known\n", type);

    }
    state->streamResetSequenceNumber = ++srsn;
    if (state->resetChunk != nullptr) {
        state->resetChunk->setName("deletedStateReSetChunk");
        delete state->resetChunk;
        state->resetChunk = nullptr;
    }
    state->resetChunk = check_and_cast<SCTPStreamResetChunk *>(resetChunk->dup());
    state->resetChunk->setName("stateReSetChunk");
    msg->addChunk(resetChunk);
    if (qCounter.roomSumSendStreams != 0) {
        storePacket(getPath(remoteAddr), msg, 1, 0, false);
        state->bundleReset = true;
        rt->setName("bundleReset");
        sendOnPath(getPath(remoteAddr), true);
        state->bundleReset = false;
    } else {
        sendToIP(msg, remoteAddr);
    }
    if (PK(getPath(remoteAddr)->ResetTimer)->hasEncapsulatedPacket()) {
        PK(getPath(remoteAddr)->ResetTimer)->decapsulate();
    }
    PK(getPath(remoteAddr)->ResetTimer)->encapsulate(rt);
    if (getPath(remoteAddr)->ResetTimer->isScheduled()) {
        stopTimer(getPath(remoteAddr)->ResetTimer);
    }
    startTimer(getPath(remoteAddr)->ResetTimer, getPath(remoteAddr)->pathRto);
}

void inet::sctp::SCTPAssociation::sendStreamResetResponse ( uint32  srrsn, int  result  )

protected

Referenced by checkStreamsToReset(), process_RCV_Message(), processIncomingResetRequestArrived(), processOutAndResponseArrived(), processOutgoingResetRequestArrived(), processSSNTSNResetRequestArrived(), and processStreamResetArrived().

{
    SCTPStreamResetChunk *resetChunk;
    EV_INFO << "sendStreamResetResponse to " << remoteAddr << "\n";
    SCTPMessage *msg = new SCTPMessage();
    msg->setByteLength(SCTP_COMMON_HEADER);
    msg->setSrcPort(localPort);
    msg->setDestPort(remotePort);
    resetChunk = new SCTPStreamResetChunk("responseRE_CONFIG");
    resetChunk->setChunkType(RE_CONFIG);
    resetChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
    SCTPStreamResetResponseParameter *responseParam = new SCTPStreamResetResponseParameter("Response_Param");
    responseParam->setParameterType(STREAM_RESET_RESPONSE_PARAMETER);
    responseParam->setSrResSn(srrsn);
    responseParam->setResult(result);
    state->peerRequests[srrsn].result = result;
    responseParam->setByteLength(SCTP_STREAM_RESET_RESPONSE_PARAMETER_LENGTH);
    resetChunk->addParameter(responseParam);
    msg->addChunk(resetChunk);
    if (qCounter.roomSumSendStreams != 0) {
        storePacket(getPath(remoteAddr), msg, 1, 0, false);
        state->bundleReset = true;
        sendOnPath(getPath(remoteAddr), true);
        state->bundleReset = false;
    } else {
        msg->addChunk(createSack());
        stopTimer(SackTimer);
        state->ackState = 0;
        state->sackAlreadySent = true;
        if (state->incomingRequestSet && state->incomingRequest != nullptr) {
            delete state->incomingRequest;
            state->incomingRequest = nullptr;
            state->incomingRequestSet = false;
        }
        sendToIP(msg, remoteAddr);
    }
    if (result != DEFERRED) {
        state->resetRequested = false;
        state->firstPeerRequest = false;
    }
}

void inet::sctp::SCTPAssociation::sendStreamResetResponse ( SCTPSSNTSNResetRequestParameter *  requestParam, int  result, bool  options  )

protected

{
    uint32 len = 0;
    EV_INFO << "sendStreamResetResponse to " << remoteAddr << " with options\n";
    SCTPMessage *msg = new SCTPMessage();
    msg->setByteLength(SCTP_COMMON_HEADER);
    msg->setSrcPort(localPort);
    msg->setDestPort(remotePort);
    SCTPStreamResetChunk *resetChunk = new SCTPStreamResetChunk("STREAM_RESET");
    resetChunk->setChunkType(RE_CONFIG);
    resetChunk->setByteLength(SCTP_STREAM_RESET_CHUNK_LENGTH);
    SCTPStreamResetResponseParameter *responseParam = new SCTPStreamResetResponseParameter("Response_Param");
    responseParam->setParameterType(STREAM_RESET_RESPONSE_PARAMETER);
    responseParam->setSrResSn(requestParam->getSrReqSn());
    responseParam->setResult(result);
    state->peerRequests[requestParam->getSrReqSn()].result = result;
    len = SCTP_STREAM_RESET_RESPONSE_PARAMETER_LENGTH;
    if (options && result == PERFORMED) {
        responseParam->setSendersNextTsn(state->nextTSN);
        responseParam->setReceiversNextTsn(state->gapList.getHighestTSNReceived() + (1<<31) + 1);
        resetSsns();
        resetExpectedSsns();
        state->stopOldData = true;
        if (state->incomingRequestSet && state->incomingRequest != nullptr) {
            delete state->incomingRequest;
            state->incomingRequest = nullptr;
            state->incomingRequestSet = false;
        }
        len += 8;
        resetGapLists();
        state->peerTsnAfterReset = state->gapList.getHighestTSNReceived() + (1<<31);
        state->firstPeerRequest = false;
    }
    responseParam->setByteLength(len);
    resetChunk->addParameter(responseParam);
    msg->addChunk(resetChunk);
    stopTimer(SackTimer);
    msg->addChunk(createSack());
    state->ackState = 0;
    state->sackAlreadySent = true;
    sendToIP(msg);
}

void inet::sctp::SCTPAssociation::sendToApp ( cMessage *  msg )

protected

Utility: sends packet to application.

Referenced by pathStatusIndication(), process_STATUS(), pushUlp(), and sendDataArrivedNotification().

{
    sctpMain->send(msg, "to_appl", appGateIndex);
}

void inet::sctp::SCTPAssociation::sendToIP ( SCTPMessage *  sctpmsg, const L3Address &  dest  )

protected

Utility: adds control info to message and sends it to IP.

Referenced by processAddInAndOutResetRequestArrived(), processAsconfArrived(), retransmitAsconf(), retransmitCookieEcho(), retransmitInit(), retransmitReset(), retransmitShutdown(), retransmitShutdownAck(), sendAbort(), sendAddInAndOutStreamsRequest(), sendAddOutgoingStreamsRequest(), sendAsconf(), sendAsconfAck(), sendBundledOutgoingResetAndResponse(), sendCookieAck(), sendCookieEcho(), sendDoubleStreamResetResponse(), sendHeartbeat(), sendHeartbeatAck(), sendInit(), sendInitAck(), sendOnPath(), sendOutgoingRequestAndResponse(), sendOutgoingResetRequest(), sendPacketDrop(), sendSACKviaSelectedPath(), sendShutdown(), sendShutdownAck(), sendShutdownComplete(), sendStreamResetRequest(), and sendStreamResetResponse().

{
    // Final touches on the segment before sending
    sctpmsg->setSrcPort(localPort);
    sctpmsg->setDestPort(remotePort);
    sctpmsg->setChecksumOk(true);
    EV_INFO << "SendToIP: localPort=" << localPort << " remotePort=" << remotePort << " dest=" << dest << "\n";
    const SCTPChunk *chunk = (const SCTPChunk *)(sctpmsg->peekFirstChunk());
    uint8 chunkType = chunk->getChunkType();
    if (chunkType == ABORT) {
        const SCTPAbortChunk *abortChunk = check_and_cast<const SCTPAbortChunk *>(chunk);
        if (abortChunk->getT_Bit() == 1) {
            sctpmsg->setTag(peerVTag);
        }
        else {
            sctpmsg->setTag(localVTag);
        }
    }
    else if (sctpmsg->getTag() == 0) {
        sctpmsg->setTag(localVTag);
    }

    if ((bool)sctpMain->par("udpEncapsEnabled")) {
        sctpMain->udpSocket.sendTo(sctpmsg, remoteAddr, SCTP_UDP_PORT);
    }
    else {
        IL3AddressType *addressType = dest.getAddressType();
        INetworkProtocolControlInfo *controlInfo = addressType->createNetworkProtocolControlInfo();
        controlInfo->setTransportProtocol(IP_PROT_SCTP);
        //controlInfo->setSourceAddress();
        controlInfo->setDestinationAddress(dest);
        sctpmsg->setControlInfo(check_and_cast<cObject *>(controlInfo));
        sctpMain->send_to_ip(sctpmsg);

        if (chunkType == HEARTBEAT) {
            SCTPPathVariables *path = getPath(dest);
            path->numberOfHeartbeatsSent++;
            path->vectorPathHb->record(path->numberOfHeartbeatsSent);
        }
        else if (chunkType == HEARTBEAT_ACK) {
            SCTPPathVariables *path = getPath(dest);
            path->numberOfHeartbeatAcksSent++;
            path->vectorPathHbAck->record(path->numberOfHeartbeatAcksSent);
        }
    }
    EV_INFO << "Sent to " << dest << endl;
}

void inet::sctp::SCTPAssociation::sendToIP ( SCTPMessage *  sctpmsg )

inlineprotected

    {
        sendToIP(sctpmsg, remoteAddr);
    }

void inet::sctp::SCTPAssociation::setFragInProgressOfStream ( uint16  sid, bool  frag  )

protected

Referenced by sendOnPath().

{
    auto streamIterator = sendStreams.find(sid);
    assert(streamIterator != sendStreams.end());
    return (streamIterator->second)->setFragInProgress(frag);
}

void inet::sctp::SCTPAssociation::signalConnectionTimeout ( )

protected

Utility: signal to user that connection timed out.

{
    sendIndicationToApp(SCTP_I_TIMED_OUT);
}

static int16 inet::sctp::SCTPAssociation::ssnGt ( const uint16  ssn1, const uint16  ssn2  )

inlinestatic

Referenced by makeRoomForTsn().

{ return SCTP_SSN_GT(ssn1, ssn2); }

void inet::sctp::SCTPAssociation::startTimer ( cMessage *  timer, const simtime_t &  timeout  )

protected

Referenced by chunkReschedulingControl(), pmDataIsSentOn(), pmStartPathManagement(), process_ASSOCIATE(), process_RCV_Message(), process_TIMEOUT_ASCONF(), process_TIMEOUT_HEARTBEAT_INTERVAL(), process_TIMEOUT_INIT_REXMIT(), process_TIMEOUT_RESET(), process_TIMEOUT_SHUTDOWN(), processAddInAndOutResetRequestArrived(), processAsconfArrived(), processInitAckArrived(), processPacketDropArrived(), processSackArrived(), scheduleSack(), sendAddInAndOutStreamsRequest(), sendAddOutgoingStreamsRequest(), sendBundledOutgoingResetAndResponse(), sendOnPath(), sendOutgoingRequestAndResponse(), sendOutgoingResetRequest(), sendShutdown(), sendShutdownAck(), sendStreamResetRequest(), and tsnWasReneged().

{
    EV_DETAIL << "startTimer " << timer->getName() << " with timeout "
              << timeout << " to expire at " << simTime() + timeout << endl;
    scheduleTimeout(timer, timeout);
}

void inet::sctp::SCTPAssociation::stateEntered ( int32  state )

protected

{
    switch (status) {
        case SCTP_S_COOKIE_WAIT:
            break;

        case SCTP_S_ESTABLISHED: {
            EV_INFO << "State ESTABLISHED entered" << endl;
            stopTimer(T1_InitTimer);

            if (state->initChunk) {
                delete state->initChunk;
                state->initChunk = nullptr;
            }

            state->nagleEnabled = (bool)sctpMain->getNagle();
            state->enableHeartbeats = (bool)sctpMain->getEnableHeartbeats();
            state->sendHeartbeatsOnActivePaths = (bool)sctpMain->par("sendHeartbeatsOnActivePaths");
            state->numGapReports = sctpMain->par("numGapReports");
            state->maxBurst = (uint32)sctpMain->getMaxBurst();
            state->rtxMethod = sctpMain->par("RTXMethod");
            state->nrSack = (bool)sctpMain->par("nrSack");
            state->disableReneging = (bool)sctpMain->par("disableReneging");
            state->checkSackSeqNumber = (bool)sctpMain->par("checkSackSeqNumber");
            state->outgoingSackSeqNum = 0;
            state->incomingSackSeqNum = 0;
            state->fragPoint = (uint32)sctpMain->getFragPoint();
            state->highSpeedCC = (bool)sctpMain->par("highSpeedCC");
            state->initialWindow = (uint32)sctpMain->par("initialWindow");
            if (strcmp((const char *)sctpMain->par("maxBurstVariant"), "useItOrLoseIt") == 0) {
                state->maxBurstVariant = SCTPStateVariables::MBV_UseItOrLoseIt;
            }
            else if (strcmp((const char *)sctpMain->par("maxBurstVariant"), "congestionWindowLimiting") == 0) {
                state->maxBurstVariant = SCTPStateVariables::MBV_CongestionWindowLimiting;
            }
            else if (strcmp((const char *)sctpMain->par("maxBurstVariant"), "maxBurst") == 0) {
                state->maxBurstVariant = SCTPStateVariables::MBV_MaxBurst;
            }
            else if (strcmp((const char *)sctpMain->par("maxBurstVariant"), "aggressiveMaxBurst") == 0) {
                state->maxBurstVariant = SCTPStateVariables::MBV_AggressiveMaxBurst;
            }
            else if (strcmp((const char *)sctpMain->par("maxBurstVariant"), "totalMaxBurst") == 0) {
                state->maxBurstVariant = SCTPStateVariables::MBV_TotalMaxBurst;
            }
            else if (strcmp((const char *)sctpMain->par("maxBurstVariant"), "useItOrLoseItTempCwnd") == 0) {
                state->maxBurstVariant = SCTPStateVariables::MBV_UseItOrLoseItTempCwnd;
            }
            else if (strcmp((const char *)sctpMain->par("maxBurstVariant"), "congestionWindowLimitingTempCwnd") == 0) {
                state->maxBurstVariant = SCTPStateVariables::MBV_CongestionWindowLimitingTempCwnd;
            }
            else {
                throw cRuntimeError("Invalid setting of maxBurstVariant: %s.",
                        (const char *)sctpMain->par("maxBurstVariant"));
            }

            if (strcmp((const char *)sctpMain->par("cmtSendAllVariant"), "normal") == 0) {
                state->cmtSendAllComparisonFunction = nullptr;
            }
            else if (strcmp((const char *)sctpMain->par("cmtSendAllVariant"), "smallestLastTransmission") == 0) {
                state->cmtSendAllComparisonFunction = pathMapSmallestLastTransmission;
            }
            else if (strcmp((const char *)sctpMain->par("cmtSendAllVariant"), "randomized") == 0) {
                state->cmtSendAllComparisonFunction = pathMapRandomized;
            }
            else if (strcmp((const char *)sctpMain->par("cmtSendAllVariant"), "largestSSThreshold") == 0) {
                state->cmtSendAllComparisonFunction = pathMapLargestSSThreshold;
            }
            else if (strcmp((const char *)sctpMain->par("cmtSendAllVariant"), "largestSpace") == 0) {
                state->cmtSendAllComparisonFunction = pathMapLargestSpace;
            }
            else if (strcmp((const char *)sctpMain->par("cmtSendAllVariant"), "largestSpaceAndSSThreshold") == 0) {
                state->cmtSendAllComparisonFunction = pathMapLargestSpaceAndSSThreshold;
            }
            else {
                throw cRuntimeError("Invalid setting of cmtSendAllVariant: %s.",
                        (const char *)sctpMain->par("cmtSendAllVariant"));
            }

            state->cmtRetransmissionVariant = sctpMain->par("cmtRetransmissionVariant");
            if (strcmp((const char *)sctpMain->par("cmtCUCVariant"), "normal") == 0) {
                state->cmtCUCVariant = SCTPStateVariables::CUCV_Normal;
            }
            else if (strcmp((const char *)sctpMain->par("cmtCUCVariant"), "pseudoCumAck") == 0) {
                state->cmtCUCVariant = SCTPStateVariables::CUCV_PseudoCumAck;
            }
            else if (strcmp((const char *)sctpMain->par("cmtCUCVariant"), "pseudoCumAckV2") == 0) {
                state->cmtCUCVariant = SCTPStateVariables::CUCV_PseudoCumAckV2;
            }
            else {
                throw cRuntimeError("Bad setting for cmtCUCVariant: %s\n",
                        (const char *)sctpMain->par("cmtCUCVariant"));
            }
            state->smartOverfullSACKHandling = (bool)sctpMain->par("smartOverfullSACKHandling");

            if (strcmp((const char *)sctpMain->par("cmtChunkReschedulingVariant"), "none") == 0) {
                state->cmtChunkReschedulingVariant = SCTPStateVariables::CCRV_None;
            }
            else if (strcmp((const char *)sctpMain->par("cmtChunkReschedulingVariant"), "senderOnly") == 0) {
                state->cmtChunkReschedulingVariant = SCTPStateVariables::CCRV_SenderOnly;
            }
            else if (strcmp((const char *)sctpMain->par("cmtChunkReschedulingVariant"), "receiverOnly") == 0) {
                state->cmtChunkReschedulingVariant = SCTPStateVariables::CCRV_ReceiverOnly;
            }
            else if (strcmp((const char *)sctpMain->par("cmtChunkReschedulingVariant"), "bothSides") == 0) {
                state->cmtChunkReschedulingVariant = SCTPStateVariables::CCRV_BothSides;
            }
            else if (strcmp((const char *)sctpMain->par("cmtChunkReschedulingVariant"), "test") == 0) {
                state->cmtChunkReschedulingVariant = SCTPStateVariables::CCRV_Test;
            }
            else {
                throw cRuntimeError("Bad setting for cmtChunkReschedulingVariant: %s\n",
                        (const char *)sctpMain->par("cmtChunkReschedulingVariant"));
            }

            if (strcmp((const char *)sctpMain->par("cmtBufferSplitVariant"), "none") == 0) {
                state->cmtBufferSplitVariant = SCTPStateVariables::CBSV_None;
            }
            else if (strcmp((const char *)sctpMain->par("cmtBufferSplitVariant"), "senderOnly") == 0) {
                state->cmtBufferSplitVariant = SCTPStateVariables::CBSV_SenderOnly;
            }
            else if (strcmp((const char *)sctpMain->par("cmtBufferSplitVariant"), "receiverOnly") == 0) {
                state->cmtBufferSplitVariant = SCTPStateVariables::CBSV_ReceiverOnly;
            }
            else if (strcmp((const char *)sctpMain->par("cmtBufferSplitVariant"), "bothSides") == 0) {
                state->cmtBufferSplitVariant = SCTPStateVariables::CBSV_BothSides;
            }
            else {
                throw cRuntimeError("Bad setting for cmtBufferSplitVariant: %s\n",
                        (const char *)sctpMain->par("cmtBufferSplitVariant"));
            }
            state->cmtBufferSplittingUsesOSB = (bool)sctpMain->par("cmtBufferSplittingUsesOSB");

            if (strcmp((const char *)sctpMain->par("gapListOptimizationVariant"), "none") == 0) {
                state->gapListOptimizationVariant = SCTPStateVariables::GLOV_None;
            }
            else if (strcmp((const char *)sctpMain->par("gapListOptimizationVariant"), "optimized1") == 0) {
                state->gapListOptimizationVariant = SCTPStateVariables::GLOV_Optimized1;
            }
            else if (strcmp((const char *)sctpMain->par("gapListOptimizationVariant"), "optimized2") == 0) {
                state->gapListOptimizationVariant = SCTPStateVariables::GLOV_Optimized2;
            }
            else if (strcmp((const char *)sctpMain->par("gapListOptimizationVariant"), "shrunken") == 0) {
                state->gapListOptimizationVariant = SCTPStateVariables::GLOV_Shrunken;
            }
            else {
                throw cRuntimeError("Bad setting for gapListOptimizationVariant: %s\n",
                        (const char *)sctpMain->par("gapListOptimizationVariant"));
            }

            state->cmtUseSFR = (bool)sctpMain->par("cmtUseSFR");
            state->cmtUseDAC = (bool)sctpMain->par("cmtUseDAC");
            state->cmtUseFRC = (bool)sctpMain->par("cmtUseFRC");
            state->gapReportLimit = (uint32)sctpMain->par("gapReportLimit");
            state->cmtSmartT3Reset = (bool)sctpMain->par("cmtSmartT3Reset");
            state->cmtSmartReneging = (bool)sctpMain->par("cmtSmartReneging");
            state->cmtSmartFastRTX = (bool)sctpMain->par("cmtSmartFastRTX");
            state->cmtSlowPathRTTUpdate = (bool)sctpMain->par("cmtSlowPathRTTUpdate");
            state->cmtMovedChunksReduceCwnd = (bool)sctpMain->par("cmtMovedChunksReduceCwnd");
            state->cmtChunkReschedulingThreshold = (double)sctpMain->par("cmtChunkReschedulingThreshold");
            state->movedChunkFastRTXFactor = (double)sctpMain->par("movedChunkFastRTXFactor");
            state->strictCwndBooking = (bool)sctpMain->par("strictCwndBooking");

            if (strcmp((const char *)sctpMain->par("cmtSackPath"), "standard") == 0) {
                state->cmtSackPath = SCTPStateVariables::CSP_Standard;
            }
            else if (strcmp((const char *)sctpMain->par("cmtSackPath"), "primary") == 0) {
                state->cmtSackPath = SCTPStateVariables::CSP_Primary;
            }
            else if (strcmp((const char *)sctpMain->par("cmtSackPath"), "roundRobin") == 0) {
                state->cmtSackPath = SCTPStateVariables::CSP_RoundRobin;
            }
            else if (strcmp((const char *)sctpMain->par("cmtSackPath"), "smallestSRTT") == 0) {
                state->cmtSackPath = SCTPStateVariables::CSP_SmallestSRTT;
            }
            else {
                throw cRuntimeError("Bad setting for cmtSackPath: %s\n",
                        (const char *)sctpMain->par("cmtSackPath"));
            }

            if (strcmp((const char *)sctpMain->par("cmtCCVariant"), "off") == 0) {
                state->cmtCCVariant = SCTPStateVariables::CCCV_Off;
                state->allowCMT = false;
            }
            else if (strcmp((const char *)sctpMain->par("cmtCCVariant"), "cmt") == 0) {
                state->cmtCCVariant = SCTPStateVariables::CCCV_CMT;
                state->allowCMT = true;
            }
            else if(strcmp((const char*)sctpMain->par("cmtCCVariant"), "lia") == 0){
               state->cmtCCVariant = SCTPStateVariables::CCCV_CMT_LIA;
               state->allowCMT     = true;
            }
            else if(strcmp((const char*)sctpMain->par("cmtCCVariant"), "olia") == 0){
               state->cmtCCVariant = SCTPStateVariables::CCCV_CMT_OLIA;
               state->allowCMT     = true;
            }
            else if ((strcmp((const char *)sctpMain->par("cmtCCVariant"), "cmtrp") == 0) ||
                     (strcmp((const char *)sctpMain->par("cmtCCVariant"), "cmtrpv1") == 0))
            {
                state->cmtCCVariant = SCTPStateVariables::CCCV_CMTRPv1;
                state->allowCMT = true;
            }
            else if (strcmp((const char *)sctpMain->par("cmtCCVariant"), "cmtrpv2") == 0) {
                state->cmtCCVariant = SCTPStateVariables::CCCV_CMTRPv2;
                state->allowCMT = true;
            }
            else if (strcmp((const char *)sctpMain->par("cmtCCVariant"), "cmtrp-t1") == 0) {
                state->cmtCCVariant = SCTPStateVariables::CCCV_CMTRP_Test1;
                state->allowCMT = true;
            }
            else if (strcmp((const char *)sctpMain->par("cmtCCVariant"), "cmtrp-t2") == 0) {
                state->cmtCCVariant = SCTPStateVariables::CCCV_CMTRP_Test2;
                state->allowCMT = true;
            }
            else {
                throw cRuntimeError("Bad setting for cmtCCVariant: %s\n",
                        (const char *)sctpMain->par("cmtCCVariant"));
            }

            state->rpPathBlocking = (bool)sctpMain->par("rpPathBlocking");
            state->rpScaleBlockingTimeout = (bool)sctpMain->par("rpScaleBlockingTimeout");
            state->rpMinCwnd = sctpMain->par("rpMinCwnd");

            cStringTokenizer pathGroupsTokenizer(sctpMain->par("cmtCCPathGroups").stringValue());
            if (pathGroupsTokenizer.hasMoreTokens()) {
                auto pathIterator = sctpPathMap.begin();
                while (pathIterator != sctpPathMap.end()) {
                    const char *token = pathGroupsTokenizer.nextToken();
                    if (token == nullptr) {
                        throw cRuntimeError("Too few cmtCCGroup values to cover all paths!");
                    }
                    SCTPPathVariables *path = pathIterator->second;
                    path->cmtCCGroup = atol(token);
                    pathIterator++;
                }
            }

            state->osbWithHeader = (bool)sctpMain->par("osbWithHeader");
            state->padding = (bool)sctpMain->par("padding");
            if (state->osbWithHeader)
                state->header = SCTP_DATA_CHUNK_LENGTH;
            else
                state->header = 0;
            state->swsLimit = (uint32)sctpMain->par("swsLimit");
            state->fastRecoverySupported = (bool)sctpMain->par("fastRecoverySupported");
            state->reactivatePrimaryPath = (bool)sctpMain->par("reactivatePrimaryPath");
            state->packetsInTotalBurst = 0;
            state->auth = sctpMain->auth;
            state->messageAcceptLimit = sctpMain->par("messageAcceptLimit");
            state->bytesToAddPerRcvdChunk = sctpMain->par("bytesToAddPerRcvdChunk");
            state->bytesToAddPerPeerChunk = sctpMain->par("bytesToAddPerPeerChunk");
            state->tellArwnd = sctpMain->par("tellArwnd");
            state->throughputInterval = (double)sctpMain->par("throughputInterval");
            sackPeriod = (double)sctpMain->getSackPeriod();
            sackFrequency = sctpMain->getSackFrequency();
            SCTP::AssocStat stat;
            stat.assocId = assocId;
            stat.start = simTime();
            stat.stop = 0;
            stat.rcvdBytes = 0;
            stat.ackedBytes = 0;
            stat.sentBytes = 0;
            stat.transmittedBytes = 0;
            stat.numFastRtx = 0;
            stat.numT3Rtx = 0;
            stat.numDups = 0;
            stat.numPathFailures = 0;
            stat.numForwardTsn = 0;
            stat.sumRGapRanges = 0;
            stat.sumNRGapRanges = 0;
            stat.numOverfullSACKs = 0;
            stat.lifeTime = 0;
            stat.throughput = 0;
            stat.numDropsBecauseNewTSNGreaterThanHighestTSN = 0;
            stat.numDropsBecauseNoRoomInBuffer = 0;
            stat.numChunksReneged = 0;
            stat.numAuthChunksSent = 0;
            stat.numAuthChunksAccepted = 0;
            stat.numAuthChunksRejected = 0;
            stat.numResetRequestsSent = 0;
            stat.numResetRequestsPerformed = 0;
            fairTimer = false;
            stat.fairStart = 0;
            stat.fairStop = 0;
            stat.fairLifeTime = 0;
            stat.fairThroughput = 0;
            stat.fairAckedBytes = 0;
            stat.numEndToEndMessages = 0;
            stat.cumEndToEndDelay = 0;
            stat.startEndToEndDelay = (uint32)sctpMain->par("startEndToEndDelay");
            stat.stopEndToEndDelay = (uint32)sctpMain->par("stopEndToEndDelay");
            sctpMain->assocStatMap[stat.assocId] = stat;
            ccModule = sctpMain->par("ccModule");

            switch (ccModule) {
                case RFC4960: {
                    ccFunctions.ccInitParams = &SCTPAssociation::initCCParameters;
                    ccFunctions.ccUpdateBeforeSack = &SCTPAssociation::cwndUpdateBeforeSack;
                    ccFunctions.ccUpdateAfterSack = &SCTPAssociation::cwndUpdateAfterSack;
                    ccFunctions.ccUpdateAfterCwndTimeout = &SCTPAssociation::cwndUpdateAfterCwndTimeout;
                    ccFunctions.ccUpdateAfterRtxTimeout = &SCTPAssociation::cwndUpdateAfterRtxTimeout;
                    ccFunctions.ccUpdateMaxBurst = &SCTPAssociation::cwndUpdateMaxBurst;
                    ccFunctions.ccUpdateBytesAcked = &SCTPAssociation::cwndUpdateBytesAcked;
                    break;
                }
            }

            pmStartPathManagement();
            state->sendQueueLimit = (uint32)sctpMain->par("sendQueueLimit");
            sendEstabIndicationToApp();
            if (sctpMain->hasPar("addIP")) {
                const bool addIP = (bool)sctpMain->par("addIP");
                EV_DETAIL << getFullPath() << ": addIP = " << addIP << " time = " << (double)sctpMain->par("addTime") << "\n";
                if (addIP == true && (double)sctpMain->par("addTime") > 0) {
                    EV_DETAIL << "startTimer addTime to expire at " << simTime() + (double)sctpMain->par("addTime") << "\n";

                    scheduleTimeout(StartAddIP, (double)sctpMain->par("addTime"));
                }
            }
            if ((double)sctpMain->par("fairStart") > 0) {
                sctpMain->scheduleAt(sctpMain->par("fairStart"), FairStartTimer);
                sctpMain->scheduleAt(sctpMain->par("fairStop"), FairStopTimer);
                sctpMain->recordScalar("rtoMin", (double)sctpMain->par("rtoMin"));
            }
            char str[128];
            snprintf(str, sizeof(str), "Cumulated TSN Ack of Association %d", assocId);
            cumTsnAck = new cOutVector(str);
            snprintf(str, sizeof(str), "Number of Gap Blocks in Last SACK of Association %d", assocId);
            numGapBlocks = new cOutVector(str);
            snprintf(str, sizeof(str), "SendQueue of Association %d", assocId);
            sendQueue = new cOutVector(str);
            state->sendQueueLimit = (uint32)sctpMain->par("sendQueueLimit");
            SCTP::VTagPair vtagPair;
            vtagPair.peerVTag = peerVTag;
            vtagPair.localVTag = localVTag;
            vtagPair.localPort = localPort;
            vtagPair.remotePort = remotePort;
            sctpMain->sctpVTagMap[assocId] = vtagPair;
            break;
        }

        case SCTP_S_CLOSED: {
            sendIndicationToApp(SCTP_I_CLOSED);
            break;
        }

        case SCTP_S_SHUTDOWN_PENDING: {
            if (getOutstandingBytes() == 0 && transmissionQ->getQueueSize() == 0 && qCounter.roomSumSendStreams == 0)
                sendShutdown();
            break;
        }

        case SCTP_S_SHUTDOWN_RECEIVED: {
            EV_INFO << "Entered state SHUTDOWN_RECEIVED, osb=" << getOutstandingBytes()
                    << ", transQ=" << transmissionQ->getQueueSize()
                    << ", scount=" << qCounter.roomSumSendStreams << endl;

            if (getOutstandingBytes() == 0 && transmissionQ->getQueueSize() == 0 && qCounter.roomSumSendStreams == 0) {
                sendShutdownAck(remoteAddr);
            }
            else {
                sendOnAllPaths(state->getPrimaryPath());
            }
            break;
        }
    }
}

const char * inet::sctp::SCTPAssociation::stateName ( const int32  state )

static

Utility: returns name of SCTP_S_xxx constants.

Referenced by printAssocBrief(), process_RCV_Message(), process_STATUS(), and process_TIMEOUT_INIT_REXMIT().

{
#define CASE(x)    case x: \
        s = #x + 7; break
    const char *s = "unknown";
    switch (state) {
        CASE(SCTP_S_CLOSED);
        CASE(SCTP_S_COOKIE_WAIT);
        CASE(SCTP_S_COOKIE_ECHOED);
        CASE(SCTP_S_ESTABLISHED);
        CASE(SCTP_S_SHUTDOWN_PENDING);
        CASE(SCTP_S_SHUTDOWN_SENT);
        CASE(SCTP_S_SHUTDOWN_RECEIVED);
        CASE(SCTP_S_SHUTDOWN_ACK_SENT);
    }
    return s;
#undef CASE
}

void inet::sctp::SCTPAssociation::stopTimer

(

cMessage *

timer

)

Referenced by chunkReschedulingControl(), pmDataIsSentOn(), pmStartPathManagement(), process_RCV_Message(), process_TIMEOUT_HEARTBEAT_INTERVAL(), process_TIMEOUT_RTX(), processAsconfAckArrived(), processAsconfArrived(), processCookieAckArrived(), processErrorArrived(), processHeartbeatAckArrived(), processInitAckArrived(), processOutAndResponseArrived(), processOutgoingResetRequestArrived(), processPacketDropArrived(), processResetResponseArrived(), processSackArrived(), inet::sctp::SCTP::removeAssociation(), removePath(), sendBundledOutgoingResetAndResponse(), sendInvalidStreamError(), sendOnPath(), sendOutgoingResetRequest(), sendSack(), sendShutdown(), sendShutdownAck(), sendStreamResetRequest(), sendStreamResetResponse(), and stopTimers().

{
    EV_INFO << "stopTimer " << timer->getName() << endl;
    if (timer->isScheduled()) {
        cancelEvent(timer);
    }
}

void inet::sctp::SCTPAssociation::stopTimers

(

)

Referenced by process_RCV_Message().

{
    for (auto & elem : sctpPathMap) {
        stopTimer(elem.second->HeartbeatTimer);
        stopTimer(elem.second->HeartbeatIntervalTimer);
    }
}

void inet::sctp::SCTPAssociation::storePacket ( SCTPPathVariables *  pathVar, SCTPMessage *  sctpMsg, const uint16  chunksAdded, const uint16  dataChunksAdded, const bool  authAdded  )

private

Referenced by sendBundledOutgoingResetAndResponse(), sendDoubleStreamResetResponse(), sendOnPath(), sendOutgoingResetRequest(), sendStreamResetRequest(), and sendStreamResetResponse().

{
    uint32 packetBytes = 0;
    for (uint16 i = 0; i < sctpMsg->getChunksArraySize(); i++) {
        cPacketPtr& chunkPtr = sctpMsg->getChunks(i);
        SCTPDataChunk* dataChunk = dynamic_cast<SCTPDataChunk*>(chunkPtr);
        if(dataChunk != nullptr) {
            const uint32_t tsn = dataChunk->getTsn();
            SCTPDataVariables* chunk = retransmissionQ->payloadQueue.find(tsn)->second;
            assert(chunk != nullptr);
            decreaseOutstandingBytes(chunk);
            chunk->queuedOnPath->queuedBytes -= chunk->booksize;
            chunk->queuedOnPath = nullptr;
            packetBytes += chunk->booksize;
        }
    }

    state->sctpMsg = sctpMsg;
    state->chunksAdded = chunksAdded;
    state->dataChunksAdded = dataChunksAdded;
    state->packetBytes = packetBytes;
    state->authAdded = authAdded;
    EV_INFO << "storePacket: path=" << pathVar->remoteAddress
              << " state->packetBytes=" << state->packetBytes
              << " osb=" << pathVar->outstandingBytes << " -> "
              << pathVar->outstandingBytes - state->packetBytes << endl;
    if (state->osbWithHeader)
        qCounter.roomSumSendStreams += state->packetBytes;
    else
        qCounter.roomSumSendStreams += state->packetBytes + (dataChunksAdded * SCTP_DATA_CHUNK_LENGTH);
    qCounter.bookedSumSendStreams += state->packetBytes;
}

int32 inet::sctp::SCTPAssociation::streamScheduler ( SCTPPathVariables *  path, bool  peek  )

protected

Dealing with streams.

Referenced by SCTPAssociation().

{
    int32 sid, testsid;

    EV_INFO << "Stream Scheduler: RoundRobin\n";

    sid = -1;

    if ((state->ssLastDataChunkSizeSet == false || state->ssNextStream == false) &&
        (sendStreams.find(state->lastStreamScheduled)->second->getUnorderedStreamQ()->getLength() > 0 ||
         sendStreams.find(state->lastStreamScheduled)->second->getStreamQ()->getLength() > 0)) {
        sid = state->lastStreamScheduled;
        EV_DETAIL << "Stream Scheduler: again sid " << sid << ".\n";
        state->ssNextStream = true;
    } else {
        testsid = state->lastStreamScheduled;

        do {
            testsid = (testsid + 1) % outboundStreams;

            if (sendStreams.find(testsid)->second->getUnorderedStreamQ()->getLength() > 0 ||
                sendStreams.find(testsid)->second->getStreamQ()->getLength() > 0)
            {
                sid = testsid;
                EV_DETAIL << "Stream Scheduler: chose sid " << sid << ".\n";

                if (!peek) {
                    state->lastStreamScheduled = sid;
                    break;
                }
            }
        } while (sid == -1 && testsid != (int32)state->lastStreamScheduled);
    }

    EV_INFO << "streamScheduler sid=" << sid << " lastStream=" << state->lastStreamScheduled << " outboundStreams=" << outboundStreams << " next=" << state->ssNextStream << "\n";

    if (sid >= 0 && !peek)
        state->ssLastDataChunkSizeSet = false;

    return sid;
}

int32 inet::sctp::SCTPAssociation::streamSchedulerFairBandwidth ( SCTPPathVariables *  path, bool  peek  )

protected

Referenced by SCTPAssociation().

{
    EV_INFO << "Stream Scheduler: FairBandwidth (peek: " << peek << ")" << endl;
    state->ssNextStream = true;
    return streamSchedulerFairBandwidthPacket(path, peek);
}

int32 inet::sctp::SCTPAssociation::streamSchedulerFairBandwidthPacket ( SCTPPathVariables *  path, bool  peek  )

protected

Referenced by SCTPAssociation(), and streamSchedulerFairBandwidth().

{
    uint32 bandwidth = 0, packetsize = 0, lastDataChunkSize;
    int32 sid = -1;
    std::map<uint16, int32> peekMap;
    std::map<uint16, int32> *mapPointer = &(state->ssFairBandwidthMap);

    EV_INFO << "Stream Scheduler: FairBandwidthPacket (peek: " << peek << ")" << endl;

    if (state->ssFairBandwidthMap.empty()) {
        for (auto & elem : sendStreams) {
            state->ssFairBandwidthMap[elem.first] = -1;
            EV_DETAIL << "initialize sid " << elem.first << " in fb map." << endl;
        }
    }

    if (peek) {
        EV_DETAIL << "just peeking, use duplicate fb map." << endl;
        for (auto & elem : state->ssFairBandwidthMap) {
            peekMap[elem.first] = elem.second;
        }
        mapPointer = &peekMap;
    }

    lastDataChunkSize = (*mapPointer)[state->lastStreamScheduled];

    for (auto & elem : sendStreams) {
        /* There is data in this stream */
        if (elem.second->getUnorderedStreamQ()->getLength() > 0 || elem.second->getStreamQ()->getLength() > 0) {
            /* Get size of the first packet in stream */
            if (elem.second->getUnorderedStreamQ()->getLength() > 0) {
                packetsize = check_and_cast<SCTPSimpleMessage *>(((SCTPDataMsg *)elem.second->getUnorderedStreamQ()->front())->getEncapsulatedPacket())->getByteLength();
            }
            else if (elem.second->getStreamQ()->getLength() > 0) {
                packetsize = check_and_cast<SCTPSimpleMessage *>(((SCTPDataMsg *)elem.second->getStreamQ()->front())->getEncapsulatedPacket())->getByteLength();
            }

            /* This stream is new to the map, so add it */
            if ((*mapPointer)[elem.first] < 0) {
                if (packetsize > 0) {
                    (*mapPointer)[elem.first] = packetsize;
                    if (!peek)
                        EV_DETAIL << "Stream Scheduler: add sid " << elem.first << " with size " << packetsize << " to fair bandwidth map.\n";
                }
            }
            /* This stream is already in the map, so update it if necessary */
            else if (state->ssLastDataChunkSizeSet) {
                /* Subtract the size of the last scheduled chunk from all streams */
                (*mapPointer)[elem.first] -= lastDataChunkSize;
                if ((*mapPointer)[elem.first] < 0)
                    (*mapPointer)[elem.first] = 0;

                /* We sent from this stream the last time, so add a new message to it */
                if (elem.first == state->lastStreamScheduled) {
                    (*mapPointer)[elem.first] += packetsize;
                    if (!peek)
                        EV_DETAIL << "Stream Scheduler: updated sid " << elem.first << " with new packet of size " << packetsize << endl;
                }

                if (!peek)
                    EV_DETAIL << "Stream Scheduler: updated sid " << elem.first << " entry to size " << (*mapPointer)[elem.first] << endl;
            }
        }
        /* There is no data in this stream, so delete it from map */
        else {
            (*mapPointer)[elem.first] = -1;
            if (!peek)
                EV_DETAIL << "Stream Scheduler: sid " << elem.first << " removed from fb map" << endl;
        }
    }

    if (!peek) {
        state->ssLastDataChunkSizeSet = false;
    }

    if (state->ssNextStream) {
        for (auto & elem : *mapPointer) {
            if ((sid < 0 || (uint32)elem.second < bandwidth) && elem.second >= 0) {
                sid = elem.first;
                bandwidth = elem.second;
                if (!peek)
                    EV_DETAIL << "Stream Scheduler: chose sid " << sid << ".\n";
            }
        }
    }
    else {
        if (sendStreams.find(state->lastStreamScheduled)->second->getUnorderedStreamQ()->getLength() > 0 ||
            sendStreams.find(state->lastStreamScheduled)->second->getStreamQ()->getLength() > 0)
        {
            sid = state->lastStreamScheduled;
            if (!peek)
                EV_DETAIL << "Stream Scheduler: again sid " << sid << ".\n";
        }
    }

    if (sid >= 0 && !peek) {
        state->lastStreamScheduled = sid;
        state->ssNextStream = false;
    }

    return sid;
}

int32 inet::sctp::SCTPAssociation::streamSchedulerFCFS ( SCTPPathVariables *  path, bool  peek  )

protected

Referenced by SCTPAssociation().

{
    int32 sid, testsid;
    simtime_t oldestEnqueuing, testTime;

    EV_INFO << "Stream Scheduler: First-come, first-serve (peek: " << peek << ")" << endl;

    sid = -1;

    if (!state->ssNextStream) {
        testsid = -1;
        state->ssNextStream = true;
    }
    else
        testsid = state->lastStreamScheduled;

    do {
        testsid = (testsid + 1) % outboundStreams;

        if (sendStreams.find(testsid)->second->getUnorderedStreamQ()->getLength() > 0) {
            testTime = ((SCTPDataMsg *)sendStreams.find(testsid)->second->getUnorderedStreamQ()->front())->getEnqueuingTime();
            if (sid < 0 || oldestEnqueuing > testTime) {
                oldestEnqueuing = testTime;
                sid = testsid;
                EV_DETAIL << "Stream Scheduler: chose sid " << sid << ".\n";
            }
        }

        if (sendStreams.find(testsid)->second->getStreamQ()->getLength() > 0) {
            testTime = ((SCTPDataMsg *)sendStreams.find(testsid)->second->getStreamQ()->front())->getEnqueuingTime();
            if (sid < 0 || oldestEnqueuing > testTime) {
                oldestEnqueuing = testTime;
                sid = testsid;
                EV_DETAIL << "Stream Scheduler: chose sid " << sid << ".\n";
            }
        }
    } while (testsid != (int32)state->lastStreamScheduled);

    if (!peek && sid >= 0)
        state->lastStreamScheduled = sid;

    return sid;
}

int32 inet::sctp::SCTPAssociation::streamSchedulerPriority ( SCTPPathVariables *  path, bool  peek  )

protected

Referenced by SCTPAssociation().

{
    int32 sid = 0, testsid;
    std::list<uint32> PriorityList;
    std::list<uint32> StreamList;

    EV_INFO << "Stream Scheduler: Priority (peek: " << peek << ")" << endl;

    sid = -1;

    if ((state->ssLastDataChunkSizeSet == false && state->ssNextStream == true) &&
        (sendStreams.find(state->lastStreamScheduled)->second->getUnorderedStreamQ()->getLength() > 0 ||
         sendStreams.find(state->lastStreamScheduled)->second->getStreamQ()->getLength() > 0))
    {
        sid = state->lastStreamScheduled;
        EV_DETAIL << "Stream Scheduler: again sid " << sid << ".\n";

        return sid;
    }

    if (!state->ssNextStream) {
        testsid = -1;
        state->ssNextStream = true;
    }
    else
        testsid = state->lastStreamScheduled;

    do {
        testsid = (testsid + 1) % outboundStreams;

        if (sendStreams.find(testsid)->second->getUnorderedStreamQ()->getLength() > 0 ||
            sendStreams.find(testsid)->second->getStreamQ()->getLength() > 0)
        {
            if (sid < 0 || state->ssPriorityMap[testsid] < state->ssPriorityMap[sid]) {
                sid = testsid;
                EV_DETAIL << "Stream Scheduler: chose sid " << sid << ".\n";
            }
        }
    } while (testsid != (int32)state->lastStreamScheduled);

    if (!peek && sid >= 0) {
        state->lastStreamScheduled = sid;
        state->ssLastDataChunkSizeSet = false;
    }

    return sid;
}

int32 inet::sctp::SCTPAssociation::streamSchedulerRandom ( SCTPPathVariables *  path, bool  peek  )

protected

Referenced by SCTPAssociation().

{
    EV_INFO << "Stream Scheduler: Random (peek: " << peek << ")" << endl;
    state->ssNextStream = true;
    return streamSchedulerRandomPacket(path, peek);
}

int32 inet::sctp::SCTPAssociation::streamSchedulerRandomPacket ( SCTPPathVariables *  path, bool  peek  )

protected

Referenced by SCTPAssociation(), and streamSchedulerRandom().

{
    int32 sid = -1, rnd;
    uint32 lastsid = state->lastStreamScheduled;
    std::vector<uint32> SCTPWaitingSendStreamsList;

    EV_INFO << "Stream Scheduler: RandomPacket (peek: " << peek << ")" << endl;

    if (state->ssNextStream) {
        for (auto & elem : sendStreams) {
            if (elem.second->getUnorderedStreamQ()->getLength() > 0 ||
                elem.second->getStreamQ()->getLength() > 0)
            {
                SCTPWaitingSendStreamsList.push_back(elem.first);
                EV_DETAIL << "Stream Scheduler: add sid " << elem.first << " to list of waiting streams.\n";
            }
        }
        if (SCTPWaitingSendStreamsList.size() > 0) {
            rnd = (int)(ceil(RNGCONTEXT uniform(1, SCTPWaitingSendStreamsList.size()) - 0.5));
            EV_DETAIL << "Stream Scheduler: go to " << rnd << ". element of waiting stream list.\n";
            sid = SCTPWaitingSendStreamsList[rnd - 1];
            if (!peek)
                state->lastStreamScheduled = sid;
            EV_DETAIL << "Stream Scheduler: chose sid " << sid << ".\n";
        }
    }
    else {
        if (sendStreams.find(state->lastStreamScheduled)->second->getUnorderedStreamQ()->getLength() > 0 ||
            sendStreams.find(state->lastStreamScheduled)->second->getStreamQ()->getLength() > 0)
        {
            sid = state->lastStreamScheduled;
            EV_DETAIL << "Stream Scheduler: again sid " << sid << ".\n";
        }
    }

    EV_INFO << "streamScheduler sid=" << sid << " lastStream=" << lastsid << " outboundStreams=" << outboundStreams << " next=" << state->ssNextStream << "\n";

    if (sid >= 0 && !peek)
        state->ssNextStream = false;

    return sid;
}

int32 inet::sctp::SCTPAssociation::streamSchedulerRoundRobinPacket ( SCTPPathVariables *  path, bool  peek  )

protected

Referenced by SCTPAssociation().

{
    int32 sid, testsid, lastsid = state->lastStreamScheduled;

    EV_INFO << "Stream Scheduler: RoundRobinPacket (peek: " << peek << ")" << endl;

    sid = -1;

    if (state->ssNextStream) {
        testsid = state->lastStreamScheduled;

        do {
            testsid = (testsid + 1) % outboundStreams;

            if (sendStreams.find(testsid)->second->getUnorderedStreamQ()->getLength() > 0 ||
                sendStreams.find(testsid)->second->getStreamQ()->getLength() > 0)
            {
                sid = testsid;
                EV_DETAIL << "Stream Scheduler: chose sid " << sid << ".\n";

                if (!peek)
                    state->lastStreamScheduled = sid;
            }
        } while (sid == -1 && testsid != (int32)state->lastStreamScheduled);
    }
    else {
        if (sendStreams.find(state->lastStreamScheduled)->second->getUnorderedStreamQ()->getLength() > 0 ||
            sendStreams.find(state->lastStreamScheduled)->second->getStreamQ()->getLength() > 0)
        {
            sid = state->lastStreamScheduled;
            EV_DETAIL << "Stream Scheduler: again sid " << sid << ".\n";
        }
    }

    EV_INFO << "streamScheduler sid=" << sid << " lastStream=" << lastsid << " outboundStreams=" << outboundStreams << " next=" << state->ssNextStream << "\n";

    if (sid >= 0 && !peek)
        state->ssNextStream = false;

    return sid;
}

void inet::sctp::SCTPAssociation::timeForSack ( bool &  sackOnly, bool &  sackWithData  )

private

Referenced by sendOnPath().

{
    sackOnly = sackWithData = false;
    // CMT DAC implementation at the receiver side
    // If CMT DAC is used, a SACK is *not* immediately transferred upon reordering
    if (((state->gapList.getNumGaps(SCTPGapList::GT_Any) > 0) || (state->dupList.size() > 0)) &&
        (state->sackAllowed) &&
        (!((state->allowCMT == true) && (state->cmtUseDAC == true))))
    {
        // Schedule sending of SACKs at once, when we have fragments to report
        state->ackState = sackFrequency;
        sackOnly = sackWithData = true;    // SACK necessary, regardless of data available
    }
    if (state->ackState >= sackFrequency) {
        sackOnly = sackWithData = true;    // SACK necessary, regardless of data available
    }
    else if (SackTimer->isScheduled()) {
        sackOnly = false;
        sackWithData = true;    // Only send SACK when data is present.
    }
}

SCTPDataChunk * inet::sctp::SCTPAssociation::transformDataChunk ( SCTPDataVariables *  chunk )

protected

Manipulating chunks.

Referenced by sendOnPath().

{
    SCTPDataChunk *dataChunk = new SCTPDataChunk("DATA");
    SCTPSimpleMessage *msg = check_and_cast<SCTPSimpleMessage *>(chunk->userData->dup());
    dataChunk->setChunkType(DATA);
    dataChunk->setBBit(chunk->bbit);
    dataChunk->setEBit(chunk->ebit);
    if (chunk->ordered) {
        dataChunk->setUBit(0);
    }
    else {
        dataChunk->setUBit(1);
    }
    dataChunk->setTsn(chunk->tsn);
    dataChunk->setSid(chunk->sid);
    dataChunk->setSsn(chunk->ssn);
    dataChunk->setPpid(chunk->ppid);
    dataChunk->setIBit(chunk->ibit);
    dataChunk->setEnqueuingTime(chunk->enqueuingTime);
    dataChunk->setFirstSendTime(chunk->firstSendTime);
    dataChunk->setByteLength(SCTP_DATA_CHUNK_LENGTH);
    msg->setBitLength(chunk->len);
    dataChunk->encapsulate(msg);
    return dataChunk;
}

static int32 inet::sctp::SCTPAssociation::tsnBetween ( const uint32  tsn1, const uint32  midtsn, const uint32  tsn2  )

inlinestatic

Referenced by inet::sctp::SCTPSimpleGapList::removeFromGapList(), inet::sctp::SCTPSimpleGapList::tsnInGapList(), and inet::sctp::SCTPSimpleGapList::updateGapList().

{ return (SCTP_TSN_GE(midtsn, tsn1) && SCTP_TSN_GE(tsn2, midtsn)); }

static int32 inet::sctp::SCTPAssociation::tsnGe ( const uint32  tsn1, const uint32  tsn2  )

inlinestatic

Referenced by createForwardTsnChunk(), dequeueAckedChunks(), inet::sctp::SCTPSimpleGapList::forwardCumAckTSN(), and processDataArrived().

{ return SCTP_TSN_GE(tsn1, tsn2); }

static int32 inet::sctp::SCTPAssociation::tsnGt ( const uint32  tsn1, const uint32  tsn2  )

inlinestatic

Referenced by inet::sctp::SCTPSimpleGapList::check(), checkPseudoCumAck(), createForwardTsnChunk(), handleChunkReportedAsMissing(), makeRoomForTsn(), processDataArrived(), processInAndOutResetRequestArrived(), processOutgoingResetRequestArrived(), processSackArrived(), and inet::sctp::SCTPSimpleGapList::updateGapList().

{ return SCTP_TSN_GT(tsn1, tsn2); }

bool inet::sctp::SCTPAssociation::tsnIsDuplicate ( const uint32  tsn ) const

protected

Methods dealing with the handling of TSNs.

Referenced by processDataArrived().

{
    for (std::list<uint32>::const_iterator iterator = state->dupList.begin();
         iterator != state->dupList.end(); iterator++)
    {
        if ((*iterator) == tsn)
            return true;
    }
    return state->gapList.tsnInGapList(tsn);
}

static int32 inet::sctp::SCTPAssociation::tsnLe ( const uint32  tsn1, const uint32  tsn2  )

inlinestatic

Referenced by inet::sctp::SCTPSimpleGapList::check(), processDataArrived(), processSackArrived(), and inet::sctp::SCTPSimpleGapList::updateGapList().

{ return SCTP_TSN_GE(tsn2, tsn1); }

static int32 inet::sctp::SCTPAssociation::tsnLt ( const uint32  tsn1, const uint32  tsn2  )

inlinestatic

Referenced by handleChunkReportedAsAcked(), handleChunkReportedAsMissing(), and processSackArrived().

{ return SCTP_TSN_GT(tsn2, tsn1); }

void inet::sctp::SCTPAssociation::tsnWasReneged ( SCTPDataVariables *  chunk, const SCTPPathVariables *  sackPath, const int  type  )

protected

Referenced by handleChunkReportedAsMissing(), and processSackArrived().

{
    if ((state->allowCMT) && (state->cmtSmartReneging) &&
        (sackPath != chunk->ackedOnPath))
    {
        return;
    }
    EV_INFO << "TSN " << chunk->tsn << " has been reneged (type "
            << type << ")" << endl;
    unackChunk(chunk);
    if (chunk->countsAsOutstanding) {
        decreaseOutstandingBytes(chunk);
    }
    chunk->hasBeenReneged = true;
    chunk->gapReports = 1;
    if (!chunk->getLastDestinationPath()->T3_RtxTimer->isScheduled()) {
        startTimer(chunk->getLastDestinationPath()->T3_RtxTimer,
                chunk->getLastDestinationPath()->pathRto);
    }
}

bool inet::sctp::SCTPAssociation::typeInChunkList ( const uint16  type )

protected

Referenced by process_RCV_Message(), processPacketDropArrived(), retransmitCookieEcho(), sendAbort(), sendCookieAck(), sendCookieEcho(), sendHeartbeat(), sendHeartbeatAck(), sendInvalidStreamError(), sendSack(), and sendShutdown().

{
    for (auto & elem : state->peerChunkList) {
        if ((elem) == type) {
            return true;
        }
    }
    return false;
}

bool inet::sctp::SCTPAssociation::typeInOwnChunkList ( const uint16  type )

protected

Referenced by cloneAssociation().

{
    for (auto & elem : state->chunkList) {
        if ((elem) == type) {
            return true;
        }
    }
    return false;
}

void inet::sctp::SCTPAssociation::unackChunk ( SCTPDataVariables *  chunk )

inlineprivate

Referenced by sendOnPath(), and tsnWasReneged().

    {
        chunk->hasBeenAcked = false;
    }

bool inet::sctp::SCTPAssociation::unorderedQueueEmptyOfStream ( uint16  sid )

protected

Referenced by process_STREAM_RESET().

{
    auto streamIterator = sendStreams.find(sid);
    assert(streamIterator != sendStreams.end());
    return (streamIterator->second)->getUnorderedStreamQ()->isEmpty();
}

int32 inet::sctp::SCTPAssociation::updateCounters ( SCTPPathVariables *  path )

protected

Referenced by process_TIMEOUT_ASCONF(), and process_TIMEOUT_RESET().

{
    bool notifyUlp = false;
    if (++state->errorCount > (uint32)sctpMain->getAssocMaxRtx()) {
        EV_DETAIL << "Retransmission count during connection setup exceeds " << (int32)sctpMain->getAssocMaxRtx() << ", giving up\n";
        sendIndicationToApp(SCTP_I_CLOSED);
        sendAbort();
        sctpMain->removeAssociation(this);
        return 0;
    }
    else if (++path->pathErrorCount > (uint32)sctpMain->getPathMaxRetrans()) {
        if (path->activePath) {
            /* tell the source */
            notifyUlp = true;
        }

        path->activePath = false;
        if (path == state->getPrimaryPath()) {
            state->setPrimaryPath(getNextPath(path));
        }
        EV_DETAIL << "process_TIMEOUT_RESET(" << (path->remoteAddress) << ") : PATH ERROR COUNTER EXCEEDED, path status is INACTIVE\n";
        if (allPathsInactive()) {
            EV_DETAIL << "process_TIMEOUT_RESET : ALL PATHS INACTIVE --> closing ASSOC\n";
            sendIndicationToApp(SCTP_I_CONN_LOST);
            sendAbort();
            sctpMain->removeAssociation(this);
            return 0;
        }
        else if (notifyUlp) {
            /* notify the application */
            pathStatusIndication(path, false);
        }
        EV_DETAIL << "process_TIMEOUT_RESET(" << (path->remoteAddress) << ") : PATH ERROR COUNTER now " << path->pathErrorCount << "\n";
        return 2;
    }
    return 1;
}

void inet::sctp::SCTPAssociation::updateFastRecoveryStatus ( const uint32  lastTsnAck )

protected

Referenced by processSackArrived().

{
    for (auto & elem : sctpPathMap) {
        SCTPPathVariables *path = elem.second;

        if (path->fastRecoveryActive) {
            if ((tsnGt(lastTsnAck, path->fastRecoveryExitPoint)) ||
                (lastTsnAck == path->fastRecoveryExitPoint) || ((state->allowCMT) && (state->cmtUseFRC) &&
                                                                ((path->newPseudoCumAck && tsnGt(path->pseudoCumAck, path->fastRecoveryExitPoint)) ||
                                                                 (path->newRTXPseudoCumAck && tsnGt(path->rtxPseudoCumAck, path->fastRecoveryExitPoint)))))
            {
                path->fastRecoveryActive = false;
                path->fastRecoveryExitPoint = 0;

                EV_INFO << simTime() << ":\tCC [cwndUpdateAfterSack] Leaving Fast Recovery on path "
                        << path->remoteAddress
                        << ", lastTsnAck=" << lastTsnAck
                        << ", pseudoCumAck=" << path->pseudoCumAck
                        << ", rtxPseudoCumAck=" << path->rtxPseudoCumAck
                        << ", newPseudoCumAck=" << path->newPseudoCumAck
                        << ", newRTXPseudoCumAck=" << path->newRTXPseudoCumAck
                        << endl;
            }
        }
    }
}

void inet::sctp::SCTPAssociation::updateHighSpeedCCThresholdIdx ( SCTPPathVariables *  path )

private

{
    ASSERT(path->highSpeedCCThresholdIdx < HIGHSPEED_ENTRIES);

    if (path->cwnd > HighSpeedCwndAdjustmentTable[path->highSpeedCCThresholdIdx].cwndThreshold * path->pmtu) {
        while ((path->highSpeedCCThresholdIdx < HIGHSPEED_ENTRIES)
                && (path->cwnd > HighSpeedCwndAdjustmentTable[path->highSpeedCCThresholdIdx].cwndThreshold * path->pmtu)) {
            path->highSpeedCCThresholdIdx++;
        }
    } else {
        while ((path->highSpeedCCThresholdIdx > 0)      //FIXME check the condition: '>' or '>='
                && (path->cwnd <= HighSpeedCwndAdjustmentTable[path->highSpeedCCThresholdIdx].cwndThreshold * path->pmtu)) {
            path->highSpeedCCThresholdIdx--;
        }
    }
}

uint32 inet::sctp::SCTPAssociation::updateOLIA ( uint32  w, const uint32  s, const uint32  totalW, double  a, const uint32  mtu, const uint32  ackedBytes, SCTPPathVariables *  path  )

private

w: cwnd of the path s: ssthresh of the path totalW: Sum of all cwnds of the association a: factor alpha of olia calculation - see https://tools.ietf.org/html/draft-khalili-mptcp-congestion-control-05 mtu: mtu of the path ackedBytes: ackednowlged bytes path: path variable (for further investigation, debug, etc)

                                                          {
    int32 increase = 0;
    bool isInCollectedPath = false;
    bool isMaxWndPaths = false;

    if ((!(w < s)) && (!path->fastRecoveryActive)) {
        // in CA
        recalculateOLIABasis();

        int cnt = 0;
        for (SCTPPathCollection::iterator it = assocCollectedPaths.begin();
                it != assocCollectedPaths.end(); it++, cnt++) {
            if (it->second == path) {
                isInCollectedPath = true;
                break;
            }
        }
        cnt = 0;
        for (SCTPPathCollection::iterator it = assocMaxWndPaths.begin();
                it != assocMaxWndPaths.end(); it++, cnt++) {
            if (it->second == path) {
                isMaxWndPaths = true;
                break;
            }
        }

        double r_sRTT = GET_SRTT(path->srtt.dbl());

        double numerator1 = path->cwnd / (r_sRTT * r_sRTT);
        double denominator1 = 0;

        for (auto & elem : sctpPathMap) {
            SCTPPathVariables* p_path = elem.second;
            double p_sRTT = GET_SRTT(p_path->srtt.dbl());
            denominator1 += (p_path->cwnd / p_sRTT);
        }
        denominator1 = denominator1 * denominator1;
        double term1 = numerator1 / denominator1;

        if (isInCollectedPath) {
            /*
             For each ACK on the path r:
             - If r is in collected_paths, increase w_r by

             w_r/rtt_r^2                          1
             -------------------    +     -----------------------       (2)
             (SUM (w_p/rtt_p))^2    w_r * number_of_paths * |collected_paths|

             multiplied by MSS_r * bytes_acked.
             */

            double numerator2 = 1 / sctpPathMap.size();
            double denominator2 = assocCollectedPaths.size();
            double term2 = 0.0;
            if (denominator2 > 0.0) {
                term2 = numerator2 / denominator2;
            }
            increase = (uint32) ceil(
                    (term1 * path->cwnd * path->pmtu) + (term2 * path->pmtu));
        } else if ((isMaxWndPaths) && (!assocCollectedPaths.empty())) {
            /*
             - If r is in max_w_paths and if collected_paths is not empty,
             increase w_r by

             w_r/rtt_r^2                         1
             --------------------    -     ------------------------     (3)
             (SUM (w_p/rtt_p))^2     w_r * number_of_paths * |max_w_paths|

             multiplied by MSS_r * bytes_acked.
             */
            double numerator2 = 1.0 / (double)sctpPathMap.size();
            double denominator2 = assocMaxWndPaths.size();
            double term2 = 0.0;
            if (denominator2 > 0.0) {
                term2 = numerator2 / denominator2;
            }
            increase = (int32) ceil(
                    (term1 * path->cwnd * path->pmtu) - (term2 * path->pmtu)); // TODO
        } else {
            /*
             - Otherwise, increase w_r by

             (w_r/rtt_r^2)
             ----------------------------------           (4)
             (SUM (w_p/rtt_p))^2

             multiplied by MSS_r * bytes_acked.
             */
            increase = (int32) ceil(term1 * path->cwnd * path->pmtu); // TODO std::min(acked,
        }
    } else {
        increase = (int32) min(path->pmtu, ackedBytes);  // slow start
    }
    return (w + increase);
}

Friends And Related Function Documentation

friend class SCTP

friend

friend class SCTPPathVariables

friend

Referenced by addPath(), processInitAckArrived(), processInitArrived(), and sendInit().

Member Data Documentation

cOutVector* inet::sctp::SCTPAssociation::advMsgRwnd

Referenced by createSack().

cOutVector* inet::sctp::SCTPAssociation::advRwnd

protected

Referenced by createSack().

int32 inet::sctp::SCTPAssociation::appGateIndex

Referenced by inet::sctp::SCTP::addForkedAssociation(), cloneAssociation(), generateSendQueueAbatedIndication(), printAssocBrief(), process_SEND(), pushUlp(), inet::sctp::SCTP::removeAssociation(), sendEstabIndicationToApp(), sendIndicationToApp(), and sendToApp().

SCTPPathCollection inet::sctp::SCTPAssociation::assocBestPaths

private

SCTPPathCollection inet::sctp::SCTPAssociation::assocCollectedPaths

private

int32 inet::sctp::SCTPAssociation::assocId

Referenced by inet::sctp::SCTP::addForkedAssociation(), cloneAssociation(), createForwardTsnChunk(), createSack(), dequeueAckedChunks(), inet::sctp::SCTP::findAssocForFd(), fragmentOutboundDataMsgs(), generateSendQueueAbatedIndication(), handleChunkReportedAsAcked(), handleChunkReportedAsMissing(), inet::sctp::SCTP::handleMessage(), makeRoomForTsn(), pathStatusIndication(), printAssocBrief(), inet::sctp::SCTP::printInfoAssocMap(), process_ABORT(), process_ASSOCIATE(), process_CLOSE(), process_OPEN_PASSIVE(), process_RCV_Message(), process_SEND(), process_TIMEOUT_RTX(), processAddInAndOutResetRequestArrived(), processAsconfArrived(), processDataArrived(), processInitArrived(), processOutAndResponseArrived(), processResetResponseArrived(), processSackArrived(), pushUlp(), inet::sctp::SCTP::removeAssociation(), retransmitAsconf(), retransmitCookieEcho(), inet::sctp::SCTPPathVariables::SCTPPathVariables(), sendAbort(), sendAddOutgoingStreamsRequest(), sendAsconf(), sendAsconfAck(), sendCookieAck(), sendCookieEcho(), sendDataArrivedNotification(), sendEstabIndicationToApp(), sendHeartbeat(), sendHeartbeatAck(), sendIndicationToApp(), sendInvalidStreamError(), sendOnPath(), sendSack(), sendSACKviaSelectedPath(), sendShutdown(), and sendStreamResetRequest().

SCTPPathCollection inet::sctp::SCTPAssociation::assocMaxWndPaths

private

cOutVector* inet::sctp::SCTPAssociation::assocThroughputVector

Referenced by process_RCV_Message().

BytesToBeSent inet::sctp::SCTPAssociation::bytes

protected

Referenced by bytesAllowedToSend(), and sendOnPath().

CCFunctions inet::sctp::SCTPAssociation::ccFunctions

protected

Referenced by bytesAllowedToSend(), chunkReschedulingControl(), process_TIMEOUT_RTX(), and processSackArrived().

uint16 inet::sctp::SCTPAssociation::ccModule

protected

cOutVector* inet::sctp::SCTPAssociation::cumTsnAck

protected

uint8_t inet::sctp::SCTPAssociation::dacPacketsRcvd

Referenced by process_RCV_Message(), and sendOnPath().

cOutVector* inet::sctp::SCTPAssociation::EndToEndDelay

Referenced by pushUlp().

cMessage* inet::sctp::SCTPAssociation::FairStartTimer

cMessage* inet::sctp::SCTPAssociation::FairStopTimer

bool inet::sctp::SCTPAssociation::fairTimer

Referenced by nonRenegablyAckChunk().

int32 inet::sctp::SCTPAssociation::fd

Referenced by cloneAssociation(), inet::sctp::SCTP::findAssocForFd(), inet::sctp::SCTP::printInfoAssocMap(), process_ASSOCIATE(), and process_OPEN_PASSIVE().

cFSM* inet::sctp::SCTPAssociation::fsm

protected

Referenced by cloneAssociation(), printAssocBrief(), process_ABORT(), process_ASSOCIATE(), process_CLOSE(), process_OPEN_PASSIVE(), process_RCV_Message(), process_SEND(), process_STATUS(), process_TIMEOUT_INIT_REXMIT(), process_TIMEOUT_SHUTDOWN(), processCookieAckArrived(), processCookieEchoArrived(), processInitAckArrived(), processInitArrived(), pushUlp(), and sendInitAck().

IInterfaceTable* inet::sctp::SCTPAssociation::ift

protected

Referenced by cloneAssociation(), processInitArrived(), and sendInit().

uint32 inet::sctp::SCTPAssociation::inboundStreams

protected

Referenced by cloneAssociation(), initAssociation(), process_OPEN_PASSIVE(), process_RECEIVE_REQUEST(), processDataArrived(), processInitAckArrived(), processResetResponseArrived(), processStreamResetArrived(), pushUlp(), inet::sctp::SCTP::removeAssociation(), sendEstabIndicationToApp(), sendInit(), and sendInitAck().

uint32 inet::sctp::SCTPAssociation::initInboundStreams

protected

Referenced by processStreamResetArrived(), and sendInit().

uint32 inet::sctp::SCTPAssociation::initPeerTsn

protected

Referenced by processAsconfArrived(), processInitAckArrived(), processInitArrived(), processStreamResetArrived(), and sendInitAck().

uint32 inet::sctp::SCTPAssociation::initTsn

protected

Referenced by sendInit(), and sendInitAck().

bool inet::sctp::SCTPAssociation::listening

Referenced by cloneAssociation(), process_OPEN_PASSIVE(), and processInitArrived().

L3Address inet::sctp::SCTPAssociation::localAddr

Referenced by inet::sctp::SCTP::addLocalAddress(), inet::sctp::SCTP::addLocalAddressToAllRemoteAddresses(), cloneAssociation(), createSack(), generateSendQueueAbatedIndication(), printAssocBrief(), process_RCV_Message(), process_SEND(), processAsconfAckArrived(), processInitArrived(), pushUlp(), resetExpectedSsn(), resetExpectedSsns(), resetSsn(), resetSsns(), retransmitCookieEcho(), retransmitReset(), retransmitShutdown(), retransmitShutdownAck(), sendAsconf(), sendEstabIndicationToApp(), sendIndicationToApp(), sendInit(), sendInitAck(), and inet::sctp::SCTP::updateSockPair().

AddressVector inet::sctp::SCTPAssociation::localAddressList

protected

Referenced by cloneAssociation(), process_ASSOCIATE(), process_OPEN_PASSIVE(), processInitArrived(), and sendInit().

uint16 inet::sctp::SCTPAssociation::localPort

Referenced by inet::sctp::SCTP::addLocalAddress(), inet::sctp::SCTP::addLocalAddressToAllRemoteAddresses(), inet::sctp::SCTP::addRemoteAddress(), cloneAssociation(), printAssocBrief(), process_ASSOCIATE(), process_OPEN_PASSIVE(), processAddInAndOutResetRequestArrived(), processAsconfArrived(), inet::sctp::SCTP::removeLocalAddressFromAllRemoteAddresses(), inet::sctp::SCTP::removeRemoteAddressFromAllAssociations(), sendAbort(), sendAddInAndOutStreamsRequest(), sendAddOutgoingStreamsRequest(), sendAsconf(), sendAsconfAck(), sendBundledOutgoingResetAndResponse(), sendCookieAck(), sendCookieEcho(), sendDoubleStreamResetResponse(), sendEstabIndicationToApp(), sendHeartbeat(), sendHeartbeatAck(), sendIndicationToApp(), sendInit(), sendInitAck(), sendOutgoingRequestAndResponse(), sendOutgoingResetRequest(), sendShutdown(), sendShutdownAck(), sendShutdownComplete(), sendStreamResetRequest(), sendStreamResetResponse(), sendToIP(), and inet::sctp::SCTP::updateSockPair().

uint32 inet::sctp::SCTPAssociation::localVTag

Referenced by process_RCV_Message(), processCookieEchoArrived(), processInitAckArrived(), processInitArrived(), sendInit(), sendInitAck(), and sendToIP().

uint32 inet::sctp::SCTPAssociation::numberOfRemoteAddresses

protected

Referenced by processInitAckArrived(), and processInitArrived().

cOutVector* inet::sctp::SCTPAssociation::numGapBlocks

protected

Referenced by processSackArrived().

uint32 inet::sctp::SCTPAssociation::outboundStreams

protected

Referenced by cloneAssociation(), initAssociation(), pathStreamSchedulerManual(), process_OPEN_PASSIVE(), process_STREAM_RESET(), processIncomingResetRequestArrived(), processInitAckArrived(), processResetResponseArrived(), processStreamResetArrived(), sendEstabIndicationToApp(), sendInit(), sendInitAck(), streamScheduler(), streamSchedulerFCFS(), streamSchedulerPriority(), streamSchedulerRandomPacket(), and streamSchedulerRoundRobinPacket().

uint32 inet::sctp::SCTPAssociation::peerVTag

Referenced by process_RCV_Message(), processCookieEchoArrived(), sendAsconf(), sendInit(), sendInitAck(), and sendToIP().

QueueCounter inet::sctp::SCTPAssociation::qCounter

protected

Referenced by addPath(), bytesAllowedToSend(), checkStreamsToReset(), choosePathForRetransmission(), createForwardTsnChunk(), decreaseOutstandingBytes(), dequeueOutboundDataMsg(), fragmentOutboundDataMsgs(), getAllTransQ(), getOutboundDataChunk(), handleChunkReportedAsMissing(), increaseOutstandingBytes(), loadPacket(), makeRoomForTsn(), moveChunkToOtherPath(), nonRenegablyAckChunk(), process_RCV_Message(), process_SEND(), processInitAckArrived(), processInitArrived(), processSackArrived(), pushUlp(), putInDeliveryQ(), putInTransmissionQ(), renegablyAckChunk(), sendBundledOutgoingResetAndResponse(), sendDoubleStreamResetResponse(), sendInit(), sendOnAllPaths(), sendOnPath(), sendOutgoingResetRequest(), sendStreamResetRequest(), sendStreamResetResponse(), and storePacket().

SCTPReceiveStreamMap inet::sctp::SCTPAssociation::receiveStreams

protected

Referenced by addInStreams(), calculateRcvBuffer(), deleteStreams(), getExpectedSsnOfStream(), initStreams(), listOrderedQ(), makeRoomForTsn(), processDataArrived(), processForwardTsnArrived(), pushUlp(), putInDeliveryQ(), receiveStreamPresent(), resetExpectedSsn(), and resetExpectedSsns().

L3Address inet::sctp::SCTPAssociation::remoteAddr

Referenced by inet::sctp::SCTP::addLocalAddress(), createSack(), generateSendQueueAbatedIndication(), printAssocBrief(), process_CLOSE(), process_RCV_Message(), process_SEND(), process_STATUS(), process_STREAM_RESET(), processAddInAndOutResetRequestArrived(), processAsconfAckArrived(), processAsconfArrived(), processDataArrived(), processInitAckArrived(), processInitArrived(), processOutAndResponseArrived(), processOutgoingResetRequestArrived(), processPacketDropArrived(), processResetResponseArrived(), processSackArrived(), pushUlp(), retransmitCookieEcho(), retransmitReset(), retransmitShutdown(), retransmitShutdownAck(), sendAbort(), sendAddInAndOutStreamsRequest(), sendAddOutgoingStreamsRequest(), sendAsconf(), sendAsconfAck(), sendBundledOutgoingResetAndResponse(), sendDoubleStreamResetResponse(), sendEstabIndicationToApp(), sendIndicationToApp(), sendInit(), sendInitAck(), sendOutgoingRequestAndResponse(), sendOutgoingResetRequest(), sendPacketDrop(), sendShutdown(), sendStreamResetRequest(), sendStreamResetResponse(), sendToIP(), and inet::sctp::SCTP::updateSockPair().

AddressVector inet::sctp::SCTPAssociation::remoteAddressList

protected

Referenced by process_ASSOCIATE(), processAsconfAckArrived(), processAsconfArrived(), processInitAckArrived(), processInitArrived(), sendAsconf(), sendEstabIndicationToApp(), and sendInit().

uint16 inet::sctp::SCTPAssociation::remotePort

Referenced by inet::sctp::SCTP::addLocalAddress(), inet::sctp::SCTP::addLocalAddressToAllRemoteAddresses(), inet::sctp::SCTP::addRemoteAddress(), printAssocBrief(), process_ASSOCIATE(), processAddInAndOutResetRequestArrived(), processAsconfArrived(), inet::sctp::SCTP::removeLocalAddressFromAllRemoteAddresses(), inet::sctp::SCTP::removeRemoteAddressFromAllAssociations(), sendAbort(), sendAddInAndOutStreamsRequest(), sendAddOutgoingStreamsRequest(), sendAsconf(), sendAsconfAck(), sendBundledOutgoingResetAndResponse(), sendCookieAck(), sendCookieEcho(), sendDoubleStreamResetResponse(), sendEstabIndicationToApp(), sendHeartbeat(), sendHeartbeatAck(), sendIndicationToApp(), sendInit(), sendInitAck(), sendOutgoingRequestAndResponse(), sendOutgoingResetRequest(), sendShutdown(), sendShutdownAck(), sendShutdownComplete(), sendStreamResetRequest(), sendStreamResetResponse(), sendToIP(), and inet::sctp::SCTP::updateSockPair().

SCTPQueue* inet::sctp::SCTPAssociation::retransmissionQ

protected

Referenced by advancePeerTsn(), checkPseudoCumAck(), chunkReschedulingControl(), cloneAssociation(), createForwardTsnChunk(), dequeueAckedChunks(), initAssociation(), loadPacket(), nonRenegablyAckChunk(), peekAbandonedChunk(), process_TIMEOUT_RTX(), processPacketDropArrived(), processSackArrived(), sendOnPath(), and storePacket().

IRoutingTable* inet::sctp::SCTPAssociation::rt

protected

Referenced by addPath(), cloneAssociation(), pmStartPathManagement(), processAddInAndOutResetRequestArrived(), processInitAckArrived(), processInitArrived(), sendAddInAndOutStreamsRequest(), sendAddOutgoingStreamsRequest(), sendBundledOutgoingResetAndResponse(), sendInit(), sendOutgoingRequestAndResponse(), sendOutgoingResetRequest(), and sendStreamResetRequest().

uint32 inet::sctp::SCTPAssociation::sackFrequency

protected

Referenced by process_RCV_Message(), processDataArrived(), scheduleSack(), sendOnPath(), and timeForSack().

double inet::sctp::SCTPAssociation::sackPeriod

protected

Referenced by scheduleSack().

cMessage* inet::sctp::SCTPAssociation::SackTimer

Referenced by processInitArrived(), inet::sctp::SCTP::removeAssociation(), scheduleSack(), sendInvalidStreamError(), sendOnPath(), sendSack(), sendStreamResetResponse(), and timeForSack().

SCTPAlgorithm* inet::sctp::SCTPAssociation::sctpAlgorithm

protected

Referenced by cloneAssociation(), initAssociation(), process_SEND(), and sendOnPath().

SCTP* inet::sctp::SCTPAssociation::sctpMain

protected

Referenced by chunkReschedulingControl(), cloneAssociation(), createForwardTsnChunk(), createSack(), dequeueAckedChunks(), fragmentOutboundDataMsgs(), generateSendQueueAbatedIndication(), handleChunkReportedAsAcked(), handleChunkReportedAsMissing(), initAssociation(), makeRoomForTsn(), pathStatusIndication(), pathStreamSchedulerManual(), pmDataIsSentOn(), pmRttMeasurement(), pmStartPathManagement(), process_ASSOCIATE(), process_OPEN_PASSIVE(), process_RCV_Message(), process_SEND(), process_TIMEOUT_ASCONF(), process_TIMEOUT_HEARTBEAT(), process_TIMEOUT_HEARTBEAT_INTERVAL(), process_TIMEOUT_INIT_REXMIT(), process_TIMEOUT_RESET(), process_TIMEOUT_RTX(), process_TIMEOUT_SHUTDOWN(), processAddInAndOutResetRequestArrived(), processAsconfAckArrived(), processAsconfArrived(), processCookieEchoArrived(), processDataArrived(), processErrorArrived(), processHeartbeatAckArrived(), processInitAckArrived(), processInitArrived(), processOutAndResponseArrived(), processResetResponseArrived(), processSackArrived(), pushUlp(), retransmitAsconf(), retransmitCookieEcho(), sendAbort(), sendAddOutgoingStreamsRequest(), sendAsconf(), sendAsconfAck(), sendCookieAck(), sendCookieEcho(), sendEstabIndicationToApp(), sendHeartbeat(), sendHeartbeatAck(), sendIndicationToApp(), sendInit(), sendInitAck(), sendInvalidStreamError(), sendOnPath(), sendPacketDrop(), sendSack(), sendShutdown(), sendStreamResetRequest(), sendToApp(), sendToIP(), and updateCounters().

SCTPPathMap inet::sctp::SCTPAssociation::sctpPathMap

protected

Referenced by addPath(), allPathsInactive(), choosePathForRetransmission(), chunkReschedulingControl(), getNextPath(), getOutstandingBytes(), getSortedPathMap(), handleChunkReportedAsMissing(), pathStreamSchedulerManual(), pathStreamSchedulerMapToPath(), pmStartPathManagement(), printSctpPathMap(), processInitAckArrived(), processInitArrived(), processSackArrived(), inet::sctp::SCTP::removeAssociation(), removePath(), sendInit(), sendOnAllPaths(), sendOnPath(), and stopTimers().

cOutVector* inet::sctp::SCTPAssociation::sendQueue

protected

Referenced by dequeueOutboundDataMsg(), and process_SEND().

SCTPSendStreamMap inet::sctp::SCTPAssociation::sendStreams

protected

Referenced by addOutStreams(), decreaseOutstandingBytes(), deleteStreams(), dequeueOutboundDataMsg(), fragmentOutboundDataMsgs(), generateSendQueueAbatedIndication(), getBytesInFlightOfStream(), getFragInProgressOfStream(), getSsnOfStream(), increaseOutstandingBytes(), initStreams(), makeDataVarFromDataMsg(), nextChunkFitsIntoPacket(), nonRenegablyAckChunk(), numUsableStreams(), orderedQueueEmptyOfStream(), pathStreamSchedulerMapToPath(), process_SEND(), resetSsn(), resetSsns(), sendStreamPresent(), setFragInProgressOfStream(), streamScheduler(), streamSchedulerFairBandwidthPacket(), streamSchedulerFCFS(), streamSchedulerPriority(), streamSchedulerRandomPacket(), streamSchedulerRoundRobinPacket(), and unorderedQueueEmptyOfStream().

SSFunctions inet::sctp::SCTPAssociation::ssFunctions

protected

Referenced by dequeueOutboundDataMsg(), nextChunkFitsIntoPacket(), processInitAckArrived(), processResetResponseArrived(), processStreamResetArrived(), and sendInitAck().

uint16 inet::sctp::SCTPAssociation::ssModule

protected

cMessage* inet::sctp::SCTPAssociation::StartAddIP

Referenced by processAsconfArrived(), processErrorArrived(), and inet::sctp::SCTP::removeAssociation().

cMessage* inet::sctp::SCTPAssociation::StartTesting

SCTPStateVariables* inet::sctp::SCTPAssociation::state

protected

Referenced by addInStreams(), advancePeerTsn(), bytesAllowedToSend(), calculateAssocSharedKey(), calculateRcvBuffer(), checkStreamsToReset(), chunkReschedulingControl(), cloneAssociation(), compareRandom(), createForwardTsnChunk(), createSack(), cucProcessGapReports(), decreaseOutstandingBytes(), dequeueOutboundDataMsg(), fragmentOutboundDataMsgs(), generateSendQueueAbatedIndication(), getNextDestination(), getNextPath(), getSortedPathMap(), handleChunkReportedAsAcked(), handleChunkReportedAsMissing(), increaseOutstandingBytes(), initAssociation(), initStreams(), loadPacket(), makeAddStreamsRequestParameter(), makeDataVarFromDataMsg(), makeIncomingStreamResetParameter(), makeOutgoingStreamResetParameter(), makeRoomForTsn(), makeSSNTSNResetParameter(), makeVarFromMsg(), moveChunkToOtherPath(), nextChunkFitsIntoPacket(), nonRenegablyAckChunk(), pathStreamSchedulerManual(), peekAbandonedChunk(), pmClearPathCounter(), pmDataIsSentOn(), pmStartPathManagement(), process_ABORT(), process_ASSOCIATE(), process_CLOSE(), process_OPEN_PASSIVE(), process_PRIMARY(), process_QUEUE_BYTES_LIMIT(), process_QUEUE_MSGS_LIMIT(), process_RCV_Message(), process_RECEIVE_REQUEST(), process_SEND(), process_STREAM_RESET(), process_TIMEOUT_HEARTBEAT(), process_TIMEOUT_HEARTBEAT_INTERVAL(), process_TIMEOUT_INIT_REXMIT(), process_TIMEOUT_RESET(), process_TIMEOUT_RTX(), process_TIMEOUT_SHUTDOWN(), processAddInAndOutResetRequestArrived(), processAsconfAckArrived(), processAsconfArrived(), processCookieAckArrived(), processCookieEchoArrived(), processDataArrived(), processErrorArrived(), processForwardTsnArrived(), processHeartbeatAckArrived(), processInAndOutResetRequestArrived(), processIncomingResetRequestArrived(), processInitAckArrived(), processInitArrived(), processOutAndResponseArrived(), processOutgoingResetRequestArrived(), processPacketDropArrived(), processResetResponseArrived(), processSackArrived(), processSSNTSNResetRequestArrived(), processStreamResetArrived(), pushUlp(), putInDeliveryQ(), inet::sctp::SCTP::removeAssociation(), renegablyAckChunk(), resetGapLists(), retransmitAsconf(), retransmitCookieEcho(), retransmitInit(), retransmitReset(), retransmitShutdown(), retransmitShutdownAck(), scheduleSack(), sendAbort(), sendAddInAndOutStreamsRequest(), sendAddOutgoingStreamsRequest(), sendAsconf(), sendAsconfAck(), sendBundledOutgoingResetAndResponse(), sendCookieAck(), sendCookieEcho(), sendDoubleStreamResetResponse(), sendEstabIndicationToApp(), sendHeartbeat(), sendHeartbeatAck(), sendInit(), sendInitAck(), sendInvalidStreamError(), sendOnAllPaths(), sendOnPath(), sendOutgoingRequestAndResponse(), sendOutgoingResetRequest(), sendPacketDrop(), sendSack(), sendSACKviaSelectedPath(), sendShutdown(), sendShutdownAck(), sendStreamResetRequest(), sendStreamResetResponse(), storePacket(), streamScheduler(), streamSchedulerFairBandwidth(), streamSchedulerFairBandwidthPacket(), streamSchedulerFCFS(), streamSchedulerPriority(), streamSchedulerRandom(), streamSchedulerRandomPacket(), streamSchedulerRoundRobinPacket(), timeForSack(), tsnIsDuplicate(), tsnWasReneged(), typeInChunkList(), typeInOwnChunkList(), and updateCounters().

cOutVector* inet::sctp::SCTPAssociation::statisticsArwndInLastSACK

protected

Referenced by processSackArrived().

cOutVector* inet::sctp::SCTPAssociation::statisticsNonRevokableGapBlocksInLastSACK

protected

Referenced by processSackArrived().

cOutVector* inet::sctp::SCTPAssociation::statisticsNumDuplicatesSent

protected

Referenced by createSack().

cOutVector* inet::sctp::SCTPAssociation::statisticsNumDuplicatesStored

protected

Referenced by createSack().

cOutVector* inet::sctp::SCTPAssociation::statisticsNumNonRevokableGapBlocksSent

protected

Referenced by createSack().

cOutVector* inet::sctp::SCTPAssociation::statisticsNumNonRevokableGapBlocksStored

protected

Referenced by createSack().

cOutVector* inet::sctp::SCTPAssociation::statisticsNumRevokableGapBlocksSent

protected

Referenced by createSack().

cOutVector* inet::sctp::SCTPAssociation::statisticsNumRevokableGapBlocksStored

protected

Referenced by createSack().

cOutVector* inet::sctp::SCTPAssociation::statisticsNumTotalGapBlocksStored

protected

Referenced by createSack().

cOutVector* inet::sctp::SCTPAssociation::statisticsOutstandingBytes

protected

Referenced by decreaseOutstandingBytes(), and increaseOutstandingBytes().

cOutVector* inet::sctp::SCTPAssociation::statisticsPeerRwnd

protected

Referenced by moveChunkToOtherPath(), processInitAckArrived(), processInitArrived(), processPacketDropArrived(), and processSackArrived().

cOutVector* inet::sctp::SCTPAssociation::statisticsQueuedReceivedBytes

protected

Referenced by createSack(), and pushUlp().

cOutVector* inet::sctp::SCTPAssociation::statisticsQueuedSentBytes

protected

Referenced by nonRenegablyAckChunk(), and sendOnPath().

cOutVector* inet::sctp::SCTPAssociation::statisticsRevokableGapBlocksInLastSACK

protected

Referenced by processSackArrived().

cOutVector* inet::sctp::SCTPAssociation::statisticsSACKLengthSent

protected

Referenced by createSack().

cOutVector* inet::sctp::SCTPAssociation::statisticsTotalBandwidth

protected

cOutVector* inet::sctp::SCTPAssociation::statisticsTotalCwnd

protected

cOutVector* inet::sctp::SCTPAssociation::statisticsTotalSSthresh

protected

int32 inet::sctp::SCTPAssociation::status

protected

std::map<uint16, cOutVector *> inet::sctp::SCTPAssociation::streamThroughputVectors

Referenced by addInStreams(), processDataArrived(), and sendEstabIndicationToApp().

cMessage* inet::sctp::SCTPAssociation::T1_InitTimer

Referenced by process_ASSOCIATE(), process_RCV_Message(), process_TIMEOUT_INIT_REXMIT(), processCookieAckArrived(), processInitAckArrived(), processInitArrived(), processPacketDropArrived(), and inet::sctp::SCTP::removeAssociation().

cMessage* inet::sctp::SCTPAssociation::T2_ShutdownTimer

Referenced by process_RCV_Message(), process_TIMEOUT_SHUTDOWN(), processInitArrived(), processPacketDropArrived(), inet::sctp::SCTP::removeAssociation(), sendShutdown(), and sendShutdownAck().

cMessage* inet::sctp::SCTPAssociation::T5_ShutdownGuardTimer

Referenced by process_RCV_Message(), processInitArrived(), inet::sctp::SCTP::removeAssociation(), sendShutdown(), and sendShutdownAck().

SCTPQueue* inet::sctp::SCTPAssociation::transmissionQ

protected

Referenced by cloneAssociation(), createForwardTsnChunk(), getOutboundDataChunk(), handleChunkReportedAsMissing(), initAssociation(), moveChunkToOtherPath(), nonRenegablyAckChunk(), process_RCV_Message(), putInTransmissionQ(), renegablyAckChunk(), and sendOnPath().

---

The documentation for this class was generated from the following files:

• SCTPAssociation.h
• SCTPAssociationAddIP.cc
• SCTPAssociationBase.cc
• SCTPAssociationEventProc.cc
• SCTPAssociationRcvMessage.cc
• SCTPAssociationSendAll.cc
• SCTPAssociationStreamReset.cc
• SCTPAssociationUtil.cc
• SCTPCCFunctions.cc
• SCTPSSFunctions.cc