inet::tcp::TcpLwipConnection Class Reference

Module for representing a connection in TcpLwip stack. More...

#include <TcpLwipConnection.h>

Inheritance diagram for inet::tcp::TcpLwipConnection:

Public Member Functions
	TcpLwipConnection ()
	~TcpLwipConnection ()
void	initConnection (TcpLwip &tcpLwipP, int connIdP)
void	initConnection (TcpLwipConnection &tcpLwipConnectionP, int connIdP, LwipTcpLayer::tcp_pcb *pcbP)
void	sendAvailableIndicationToApp (int listenConnId)
	Utility: sends TCP_I_AVAILABLE indication with TcpAvailableInfo to application. More...
void	sendEstablishedMsg ()
void	sendIndicationToApp (int code)
void	notifyAboutSending (const TcpHeader &tcpsegP)
void	do_SEND ()
bool	isSendUpEnabled ()
void	sendUpData ()
void	processAppCommand (cMessage *msgP)

Static Public Member Functions
static const char *	indicationName (int code)

Public Attributes
int	connIdM
LwipTcpLayer::tcp_pcb *	pcbM = nullptr
TcpLwipSendQueue *	sendQueueM = nullptr
TcpLwipReceiveQueue *	receiveQueueM = nullptr
TcpLwip *	tcpLwipM = nullptr

Protected Member Functions
	TcpLwipConnection (const TcpLwipConnection &)
void	listen (const L3Address &localAddr, unsigned short localPort)
void	connect (const L3Address &localAddr, unsigned short localPort, const L3Address &remoteAddr, unsigned short remotePort)
void	close ()
void	abort ()
void	accept ()
void	send (Packet *msgP)
int	send_data (void *data, int len)
void	recordSend (const TcpHeader &tcpsegP)
void	recordReceive (const TcpHeader &tcpsegP)
void	process_OPEN_ACTIVE (TcpOpenCommand *tcpCommandP, cMessage *msgP)
void	process_OPEN_PASSIVE (TcpOpenCommand *tcpCommandP, cMessage *msgP)
void	process_ACCEPT (TcpAcceptCommand *tcpCommand, cMessage *msg)
void	process_SEND (Packet *msgP)
void	process_CLOSE (TcpCommand *tcpCommandP, cMessage *msgP)
void	process_ABORT (TcpCommand *tcpCommandP, cMessage *msgP)
void	process_STATUS (TcpCommand *tcpCommandP, cMessage *msgP)
void	fillStatusInfo (TcpStatusInfo &statusInfo)

Protected Attributes
long int	totalSentM = 0
bool	isListenerM = false
bool	onCloseM = false
bool	sendUpEnabled = false

Static Protected Attributes
static simsignal_t	sndWndSignal = registerSignal("sndWnd")
static simsignal_t	sndNxtSignal = registerSignal("sndNxt")
static simsignal_t	sndAckSignal = registerSignal("sndAck")
static simsignal_t	rcvWndSignal = registerSignal("rcvWnd")
static simsignal_t	rcvSeqSignal = registerSignal("rcvSeq")
static simsignal_t	rcvAckSignal = registerSignal("rcvAck")

Detailed Description

Module for representing a connection in TcpLwip stack.

Constructor & Destructor Documentation

TcpLwipConnection() [1/2]

inet::tcp::TcpLwipConnection::TcpLwipConnection ( const TcpLwipConnection &  )

protected

TcpLwipConnection() [2/2]

inet::tcp::TcpLwipConnection::TcpLwipConnection ( )

inline

{}

~TcpLwipConnection()

inet::tcp::TcpLwipConnection::~TcpLwipConnection

(

)

{
    delete receiveQueueM;
    delete sendQueueM;
    if (pcbM) {
        pcbM->callback_arg = nullptr;
        tcpLwipM->getLwipTcpLayer()->tcp_pcb_purge(pcbM);
        memp_free(MEMP_TCP_PCB, pcbM);
        pcbM = nullptr;
    }
}

Member Function Documentation

abort()

void inet::tcp::TcpLwipConnection::abort ( )

protected

{
    tcpLwipM->getLwipTcpLayer()->tcp_abandon(pcbM, false);
    onCloseM = false;
}

Referenced by process_ABORT().

accept()

void inet::tcp::TcpLwipConnection::accept ( )

protected

{
    if (sendUpEnabled)
        throw cRuntimeError("socket already accepted/not a fork of a listening socket");
    sendEstablishedMsg();
    do_SEND();
}

Referenced by process_ACCEPT().

close()

void inet::tcp::TcpLwipConnection::close ( )

protected

{
    onCloseM = true;
 
    if (0 == sendQueueM->getBytesAvailable()) {
        tcpLwipM->getLwipTcpLayer()->tcp_close(pcbM);
        onCloseM = false;
    }
}

Referenced by process_CLOSE().

connect()

void inet::tcp::TcpLwipConnection::connect ( const L3Address &  localAddr, unsigned short  localPort, const L3Address &  remoteAddr, unsigned short  remotePort  )

protected

{
    onCloseM = false;
    struct ip_addr src_addr;
    src_addr.addr = localAddr;
    struct ip_addr dest_addr;
    dest_addr.addr = remoteAddr;
    tcpLwipM->getLwipTcpLayer()->tcp_bind(pcbM, &src_addr, localPort);
    tcpLwipM->getLwipTcpLayer()->tcp_connect(pcbM, &dest_addr, (u16_t)remotePort, nullptr);
    totalSentM = 0;
}

Referenced by process_OPEN_ACTIVE().

do_SEND()

void inet::tcp::TcpLwipConnection::do_SEND

(

)

{
    if (!sendUpEnabled)
        return;
    char buffer[8 * 536];
    int bytes;
    int allsent = 0;
 
    while (0 != (bytes = sendQueueM->getBytesForTcpLayer(buffer, sizeof(buffer)))) {
        int sent = send_data(buffer, bytes);
 
        if (sent > 0) {
            sendQueueM->dequeueTcpLayerMsg(sent);
            allsent += sent;
        }
        else {
            if (sent != ERR_MEM)
                EV_ERROR << "TcpLwip connection: " << connIdM << ": Error do sending, err is " << sent << endl;
            break;
        }
    }
 
    totalSentM += allsent;
    EV_DETAIL << "do_SEND(): " << connIdM
              << " send:" << allsent
              << ", unsent:" << sendQueueM->getBytesAvailable()
              << ", total sent:" << totalSentM
              << ", all bytes:" << totalSentM + sendQueueM->getBytesAvailable()
              << endl;
 
    if (onCloseM && (0 == sendQueueM->getBytesAvailable())) {
        tcpLwipM->getLwipTcpLayer()->tcp_close(pcbM);
        onCloseM = false;
    }
}

Referenced by accept(), sendEstablishedMsg(), inet::tcp::TcpLwip::tcp_event_conn(), inet::tcp::TcpLwip::tcp_event_poll(), inet::tcp::TcpLwip::tcp_event_recv(), and inet::tcp::TcpLwip::tcp_event_sent().

fillStatusInfo()

void inet::tcp::TcpLwipConnection::fillStatusInfo ( TcpStatusInfo &  statusInfo )

protected

{
    // TODO    statusInfo.setState(fsm.getState());
    // TODO    statusInfo.setStateName(stateName(fsm.getState()));
 
    statusInfo.setLocalAddr((pcbM->local_ip.addr));
    statusInfo.setLocalPort(pcbM->local_port);
    statusInfo.setRemoteAddr((pcbM->remote_ip.addr));
    statusInfo.setRemotePort(pcbM->remote_port);
 
    statusInfo.setSnd_mss(pcbM->mss);
    // TODO    statusInfo.setSnd_una(pcbM->snd_una);
    statusInfo.setSnd_nxt(pcbM->snd_nxt);
    // TODO    statusInfo.setSnd_max(pcbM->snd_max);
    statusInfo.setSnd_wnd(pcbM->snd_wnd);
    // TODO    statusInfo.setSnd_up(pcbM->snd_up);
    statusInfo.setSnd_wl1(pcbM->snd_wl1);
    statusInfo.setSnd_wl2(pcbM->snd_wl2);
    // TODO    statusInfo.setIss(pcbM->iss);
    statusInfo.setRcv_nxt(pcbM->rcv_nxt);
    statusInfo.setRcv_wnd(pcbM->rcv_wnd);
    // TODO    statusInfo.setRcv_up(pcbM->rcv_up);
    // TODO    statusInfo.setIrs(pcbM->irs);
    // TODO    statusInfo.setFin_ack_rcvd(pcbM->fin_ack_rcvd);
}

Referenced by process_STATUS().

indicationName()

const char * inet::tcp::TcpLwipConnection::indicationName ( int  code )

static

{
#define CASE(x)    case x: \
        s = #x; s += 6; break
    const char *s = "unknown";
 
    switch (code) {
        CASE(TCP_I_DATA);
        CASE(TCP_I_URGENT_DATA);
        CASE(TCP_I_AVAILABLE);
        CASE(TCP_I_ESTABLISHED);
        CASE(TCP_I_PEER_CLOSED);
        CASE(TCP_I_CLOSED);
        CASE(TCP_I_CONNECTION_REFUSED);
        CASE(TCP_I_CONNECTION_RESET);
        CASE(TCP_I_TIMED_OUT);
        CASE(TCP_I_STATUS);
    }
 
    return s;
#undef CASE
}

Referenced by sendAvailableIndicationToApp(), and sendIndicationToApp().

initConnection() [1/2]

void inet::tcp::TcpLwipConnection::initConnection	(	TcpLwip &	tcpLwipP,
		int	connIdP
	)

{
    connIdM = connIdP;
    sendQueueM = tcpLwipP.createSendQueue();
    receiveQueueM = tcpLwipP.createReceiveQueue();
    tcpLwipM = &tcpLwipP;
    totalSentM = 0;
    isListenerM = false;
    onCloseM = false;
    ASSERT(!pcbM);
    pcbM = tcpLwipM->getLwipTcpLayer()->tcp_new(); // FIXME memory leak
    ASSERT(pcbM);
    pcbM->callback_arg = this;
    sendQueueM->setConnection(this);
    receiveQueueM->setConnection(this);
}

Referenced by inet::tcp::TcpLwip::handleUpperCommand().

initConnection() [2/2]

void inet::tcp::TcpLwipConnection::initConnection	(	TcpLwipConnection &	tcpLwipConnectionP,
		int	connIdP,
		LwipTcpLayer::tcp_pcb *	pcbP
	)

{
    connIdM = connIdP;
    sendQueueM = check_and_cast<TcpLwipSendQueue *>(inet::utils::createOne(connP.sendQueueM->getClassName()));
    receiveQueueM = check_and_cast<TcpLwipReceiveQueue *>(inet::utils::createOne(connP.receiveQueueM->getClassName()));
    tcpLwipM = connP.tcpLwipM;
    totalSentM = 0;
    isListenerM = false;
    onCloseM = false;
    ASSERT(!pcbM);
    pcbM = pcbP;
    pcbM->callback_arg = this;
    sendQueueM->setConnection(this);
    receiveQueueM->setConnection(this);
}

isSendUpEnabled()

bool inet::tcp::TcpLwipConnection::isSendUpEnabled ( )

inline

{ return sendUpEnabled; }

listen()

void inet::tcp::TcpLwipConnection::listen ( const L3Address &  localAddr, unsigned short  localPort  )

protected

{
    onCloseM = false;
    tcpLwipM->getLwipTcpLayer()->tcp_bind(pcbM, nullptr, localPort);
    // The next returns a tcp_pcb: need to do some research on how
    // it works; does it actually accept a connection as well? It
    // shouldn't, as there is a tcp_accept
    LwipTcpLayer::tcp_pcb *pcb = pcbM;
    pcbM = nullptr; // unlink old pcb from this, otherwise lwip_free_pcb_event destroy this conn.
    pcbM = tcpLwipM->getLwipTcpLayer()->tcp_listen(pcb);
    totalSentM = 0;
}

Referenced by process_OPEN_PASSIVE().

notifyAboutSending()

void inet::tcp::TcpLwipConnection::notifyAboutSending

(

const TcpHeader &

tcpsegP

)

{
    receiveQueueM->notifyAboutSending(&tcpsegP);
    recordSend(tcpsegP);
}

Referenced by inet::tcp::TcpLwip::ip_output().

process_ABORT()

void inet::tcp::TcpLwipConnection::process_ABORT ( TcpCommand *  tcpCommandP, cMessage *  msgP  )

protected

{
    EV_INFO << this << ": processing ABORT(" << connIdM << ") command\n";
    delete tcpCommandP;
    delete msgP;
    abort();
}

Referenced by processAppCommand().

process_ACCEPT()

void inet::tcp::TcpLwipConnection::process_ACCEPT ( TcpAcceptCommand *  tcpCommand, cMessage *  msg  )

protected

{
    accept();
    delete tcpCommand;
    delete msg;
}

Referenced by processAppCommand().

process_CLOSE()

void inet::tcp::TcpLwipConnection::process_CLOSE ( TcpCommand *  tcpCommandP, cMessage *  msgP  )

protected

{
    EV_INFO << this << ": processing CLOSE(" << connIdM << ") command\n";
    delete tcpCommandP;
    delete msgP;
    close();
}

Referenced by processAppCommand().

process_OPEN_ACTIVE()

void inet::tcp::TcpLwipConnection::process_OPEN_ACTIVE ( TcpOpenCommand *  tcpCommandP, cMessage *  msgP  )

protected

{
    ASSERT(tcpLwipM->getLwipTcpLayer());
 
    if (tcpCommandP->getRemoteAddr().isUnspecified() || tcpCommandP->getRemotePort() == -1)
        throw cRuntimeError("Error processing command OPEN_ACTIVE: remote address and port must be specified");
 
    int localPort = tcpCommandP->getLocalPort();
    if (localPort == -1)
        localPort = 0;
 
    EV_INFO << this << ": OPEN: "
            << tcpCommandP->getLocalAddr() << ":" << localPort << " --> "
            << tcpCommandP->getRemoteAddr() << ":" << tcpCommandP->getRemotePort() << "\n";
    connect(tcpCommandP->getLocalAddr(), localPort,
            tcpCommandP->getRemoteAddr(), tcpCommandP->getRemotePort());
    delete tcpCommandP;
    delete msgP;
}

Referenced by processAppCommand().

process_OPEN_PASSIVE()

void inet::tcp::TcpLwipConnection::process_OPEN_PASSIVE ( TcpOpenCommand *  tcpCommandP, cMessage *  msgP  )

protected

{
    ASSERT(tcpLwipM->getLwipTcpLayer());
 
    if (tcpCommandP->getFork() == false)
        throw cRuntimeError("Error processing command OPEN_PASSIVE: non-forking listening connections are not supported yet");
 
    if (tcpCommandP->getLocalPort() == -1)
        throw cRuntimeError("Error processing command OPEN_PASSIVE: local port must be specified");
 
    EV_INFO << this << "Starting to listen on: " << tcpCommandP->getLocalAddr() << ":"
            << tcpCommandP->getLocalPort() << "\n";
    listen(tcpCommandP->getLocalAddr(), tcpCommandP->getLocalPort());
    delete tcpCommandP;
    delete msgP;
}

Referenced by processAppCommand().

process_SEND()

void inet::tcp::TcpLwipConnection::process_SEND ( Packet *  msgP )

protected

{
    EV_INFO << this << ": processing SEND command, len=" << msgP->getByteLength() << endl;
    send(msgP);
}

Referenced by processAppCommand().

process_STATUS()

void inet::tcp::TcpLwipConnection::process_STATUS ( TcpCommand *  tcpCommandP, cMessage *  msgP  )

protected

{
    EV_INFO << this << ": processing STATUS(" << connIdM << ") command\n";
    delete tcpCommandP; // but we'll reuse msg for reply
    TcpStatusInfo *statusInfo = new TcpStatusInfo();
    fillStatusInfo(*statusInfo);
    msgP->setControlInfo(statusInfo);
    msgP->setKind(TCP_I_STATUS);
    tcpLwipM->send(msgP, "appOut");
}

Referenced by processAppCommand().

processAppCommand()

void inet::tcp::TcpLwipConnection::processAppCommand

(

cMessage *

msgP

)

{
    // first do actions
    TcpCommand *tcpCommand = check_and_cast_nullable<TcpCommand *>(msgP->removeControlInfo());
 
    switch (msgP->getKind()) {
        case TCP_C_OPEN_ACTIVE:
            process_OPEN_ACTIVE(check_and_cast<TcpOpenCommand *>(tcpCommand), msgP);
            break;
 
        case TCP_C_OPEN_PASSIVE:
            process_OPEN_PASSIVE(check_and_cast<TcpOpenCommand *>(tcpCommand), msgP);
            break;
 
        case TCP_C_ACCEPT:
            process_ACCEPT(check_and_cast<TcpAcceptCommand *>(tcpCommand), msgP);
            break;
 
        case TCP_C_SEND:
            process_SEND(check_and_cast<Packet *>(msgP));
            break;
 
        case TCP_C_CLOSE:
            ASSERT(tcpCommand);
            process_CLOSE(tcpCommand, msgP);
            break;
 
        case TCP_C_ABORT:
            ASSERT(tcpCommand);
            process_ABORT(tcpCommand, msgP);
            break;
 
        case TCP_C_STATUS:
            ASSERT(tcpCommand);
            process_STATUS(tcpCommand, msgP);
            break;
 
        default:
            throw cRuntimeError("Wrong command from app: %d", msgP->getKind());
    }
}

Referenced by inet::tcp::TcpLwip::handleUpperCommand().

recordReceive()

void inet::tcp::TcpLwipConnection::recordReceive ( const TcpHeader &  tcpsegP )

protected

{
    emit(rcvWndSignal, tcpsegP.getWindow());
    emit(rcvSeqSignal, tcpsegP.getSequenceNo());
 
    if (tcpsegP.getAckBit())
        emit(rcvAckSignal, tcpsegP.getAckNo());
}

recordSend()

void inet::tcp::TcpLwipConnection::recordSend ( const TcpHeader &  tcpsegP )

protected

{
    emit(sndWndSignal, tcpsegP.getWindow());
    emit(sndNxtSignal, tcpsegP.getSequenceNo());
 
    if (tcpsegP.getAckBit())
        emit(sndAckSignal, tcpsegP.getAckNo());
}

Referenced by notifyAboutSending().

send()

void inet::tcp::TcpLwipConnection::send ( Packet *  msgP )

protected

{
    sendQueueM->enqueueAppData(msgP);
}

Referenced by process_SEND().

send_data()

int inet::tcp::TcpLwipConnection::send_data ( void *  data, int  len  )

protected

{
    int error;
    int written = 0;
 
    if (datalen > 0xFFFF)
        datalen = 0xFFFF; // tcp_write() length argument is uint16_t
 
    u32_t ss = pcbM->snd_lbb;
    error = tcpLwipM->getLwipTcpLayer()->tcp_write(pcbM, data, datalen, 1);
 
    if (error == ERR_OK) {
        written = datalen;
    }
    else if (error == ERR_MEM) {
        // Chances are that datalen is too large to fit in the send
        // buffer. If it is really large (larger than a typical MSS,
        // say), we should try segmenting the data ourselves.
        while (1) {
            u16_t snd_buf = pcbM->snd_buf;
            if (0 == snd_buf)
                break;
 
            if (datalen < snd_buf)
                break;
 
            error = tcpLwipM->getLwipTcpLayer()->tcp_write(pcbM, ((const char *)data) + written, snd_buf, 1);
 
            if (error != ERR_OK)
                break;
 
            written += snd_buf;
            datalen -= snd_buf;
        }
    }
 
    if (written > 0) {
        ASSERT(pcbM->snd_lbb - ss == (u32_t)written);
        return written;
    }
 
    return error;
}

Referenced by do_SEND().

sendAvailableIndicationToApp()

void inet::tcp::TcpLwipConnection::sendAvailableIndicationToApp

(

int

listenConnId

)

Utility: sends TCP_I_AVAILABLE indication with TcpAvailableInfo to application.

{
    EV_INFO << "Notifying app: " << indicationName(TCP_I_AVAILABLE) << "\n";
    auto indication = new Indication(indicationName(TCP_I_AVAILABLE), TCP_I_AVAILABLE);
    L3Address localAddr(pcbM->local_ip.addr), remoteAddr(pcbM->remote_ip.addr);
 
    TcpAvailableInfo *ind = new TcpAvailableInfo();
    ind->setNewSocketId(connIdM);
    ind->setLocalAddr(localAddr);
    ind->setRemoteAddr(remoteAddr);
    ind->setLocalPort(pcbM->local_port);
    ind->setRemotePort(pcbM->remote_port);
 
    indication->setControlInfo(ind);
    indication->addTag<TransportProtocolInd>()->setProtocol(&Protocol::tcp);
    indication->addTag<SocketInd>()->setSocketId(listenConnId);
    tcpLwipM->send(indication, "appOut");
    // TODO shouldn't read from lwip until accept arrived
}

sendEstablishedMsg()

void inet::tcp::TcpLwipConnection::sendEstablishedMsg

(

)

{
    auto indication = new Indication("TCP_I_ESTABLISHED", TCP_I_ESTABLISHED);
    TcpConnectInfo *tcpConnectInfo = new TcpConnectInfo();
 
    L3Address localAddr(pcbM->local_ip.addr), remoteAddr(pcbM->remote_ip.addr);
 
    tcpConnectInfo->setLocalAddr(localAddr);
    tcpConnectInfo->setRemoteAddr(remoteAddr);
    tcpConnectInfo->setLocalPort(pcbM->local_port);
    tcpConnectInfo->setRemotePort(pcbM->remote_port);
 
    indication->setControlInfo(tcpConnectInfo);
    indication->addTag<TransportProtocolInd>()->setProtocol(&Protocol::udp);
    indication->addTag<SocketInd>()->setSocketId(connIdM);
 
    tcpLwipM->send(indication, "appOut");
    sendUpEnabled = true;
    do_SEND();
    // TODO now can read from lwip
    sendUpData();
}

Referenced by accept(), and inet::tcp::TcpLwip::tcp_event_conn().

sendIndicationToApp()

void inet::tcp::TcpLwipConnection::sendIndicationToApp

(

int

code

)

{
    const char *nameOfIndication = indicationName(code);
    EV_DETAIL << "Notifying app: " << nameOfIndication << "\n";
    auto indication = new Indication(nameOfIndication, code);
    TcpCommand *ind = new TcpCommand();
    indication->setControlInfo(ind);
    indication->addTag<TransportProtocolInd>()->setProtocol(&Protocol::tcp);
    indication->addTag<SocketInd>()->setSocketId(connIdM);
    tcpLwipM->send(indication, "appOut");
}

Referenced by inet::tcp::TcpLwip::tcp_event_err(), and inet::tcp::TcpLwip::tcp_event_recv().

sendUpData()

void inet::tcp::TcpLwipConnection::sendUpData

(

)

{
    if (sendUpEnabled) {
        while (Packet *dataMsg = receiveQueueM->extractBytesUpTo()) {
            dataMsg->setKind(TCP_I_DATA);
            dataMsg->addTag<TransportProtocolInd>()->setProtocol(&Protocol::tcp);
            dataMsg->addTag<SocketInd>()->setSocketId(connIdM);
//            int64_t len = dataMsg->getByteLength();
            // send Msg to Application layer:
            tcpLwipM->send(dataMsg, "appOut");
//            while (len > 0) {
//                unsigned int slen = len > 0xffff ? 0xffff : len;
//                tcpLwipM->getLwipTcpLayer()->tcp_recved(pcbM, slen);
//                len -= slen;
//            }
        }
    }
}

Referenced by sendEstablishedMsg(), and inet::tcp::TcpLwip::tcp_event_recv().

Member Data Documentation

connIdM

int inet::tcp::TcpLwipConnection::connIdM

Referenced by do_SEND(), initConnection(), inet::tcp::TcpLwip::ip_output(), inet::tcp::TcpLwip::printConnBrief(), process_ABORT(), process_CLOSE(), process_STATUS(), inet::tcp::TcpLwip::removeConnection(), sendAvailableIndicationToApp(), sendEstablishedMsg(), sendIndicationToApp(), sendUpData(), inet::tcp::TcpLwip::tcp_event_accept(), inet::tcp::TcpLwip::tcp_event_err(), and inet::tcp::TcpLwip::tcp_event_recv().

isListenerM

bool inet::tcp::TcpLwipConnection::isListenerM = false

protected

Referenced by initConnection().

onCloseM

bool inet::tcp::TcpLwipConnection::onCloseM = false

protected

Referenced by abort(), close(), connect(), do_SEND(), initConnection(), and listen().

pcbM

LwipTcpLayer::tcp_pcb* inet::tcp::TcpLwipConnection::pcbM = nullptr

Referenced by abort(), close(), connect(), do_SEND(), fillStatusInfo(), initConnection(), listen(), inet::tcp::TcpLwip::lwip_free_pcb_event(), inet::tcp::TcpLwip::lwip_tcp_event(), inet::tcp::TcpLwip::removeConnection(), send_data(), sendAvailableIndicationToApp(), sendEstablishedMsg(), inet::tcp::TcpLwip::tcp_event_recv(), and ~TcpLwipConnection().

rcvAckSignal

simsignal_t inet::tcp::TcpLwipConnection::rcvAckSignal = registerSignal("rcvAck")

staticprotected

Referenced by recordReceive().

rcvSeqSignal

simsignal_t inet::tcp::TcpLwipConnection::rcvSeqSignal = registerSignal("rcvSeq")

staticprotected

Referenced by recordReceive().

rcvWndSignal

simsignal_t inet::tcp::TcpLwipConnection::rcvWndSignal = registerSignal("rcvWnd")

staticprotected

Referenced by recordReceive().

receiveQueueM

TcpLwipReceiveQueue* inet::tcp::TcpLwipConnection::receiveQueueM = nullptr

Referenced by initConnection(), inet::tcp::TcpLwip::notifyAboutIncomingSegmentProcessing(), notifyAboutSending(), sendUpData(), inet::tcp::TcpLwip::tcp_event_recv(), and ~TcpLwipConnection().

sendQueueM

TcpLwipSendQueue* inet::tcp::TcpLwipConnection::sendQueueM = nullptr

Referenced by close(), do_SEND(), initConnection(), inet::tcp::TcpLwip::ip_output(), send(), and ~TcpLwipConnection().

sendUpEnabled

bool inet::tcp::TcpLwipConnection::sendUpEnabled = false

protected

Referenced by accept(), do_SEND(), sendEstablishedMsg(), and sendUpData().

sndAckSignal

simsignal_t inet::tcp::TcpLwipConnection::sndAckSignal = registerSignal("sndAck")

staticprotected

Referenced by recordSend().

sndNxtSignal

simsignal_t inet::tcp::TcpLwipConnection::sndNxtSignal = registerSignal("sndNxt")

staticprotected

Referenced by recordSend().

sndWndSignal

simsignal_t inet::tcp::TcpLwipConnection::sndWndSignal = registerSignal("sndWnd")

staticprotected

Referenced by recordSend().

tcpLwipM

TcpLwip* inet::tcp::TcpLwipConnection::tcpLwipM = nullptr

Referenced by abort(), close(), connect(), do_SEND(), initConnection(), listen(), process_OPEN_ACTIVE(), process_OPEN_PASSIVE(), process_STATUS(), send_data(), sendAvailableIndicationToApp(), sendEstablishedMsg(), sendIndicationToApp(), sendUpData(), and ~TcpLwipConnection().

totalSentM

long int inet::tcp::TcpLwipConnection::totalSentM = 0

protected

Referenced by connect(), do_SEND(), initConnection(), and listen().

---

The documentation for this class was generated from the following files:

• TcpLwipConnection.h
• TcpLwipConnection.cc