inet::tcp::TcpLwipConnection Class Reference

#include <TcpLwipConnection.h>

Classes
class	Stats

Public Member Functions
	TcpLwipConnection (TCP_lwIP &tcpLwipP, int connIdP, int gateIndexP, TCPDataTransferMode dataTransferModeP)
	TcpLwipConnection (TcpLwipConnection &tcpLwipConnectionP, int connIdP, LwipTcpLayer::tcp_pcb *pcbP)
	~TcpLwipConnection ()
void	sendEstablishedMsg ()
void	sendIndicationToApp (int code)
void	listen (L3Address &localAddr, unsigned short localPort)
void	connect (L3Address &localAddr, unsigned short localPort, L3Address &remoteAddr, unsigned short remotePort)
void	close ()
void	abort ()
void	send (cPacket *msgP)
void	fillStatusInfo (TCPStatusInfo &statusInfo)
void	notifyAboutSending (const TCPSegment &tcpsegP)
int	send_data (void *data, int len)
void	do_SEND ()
INetStreamSocket *	getSocket ()
void	initStats ()

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

Public Attributes
int	connIdM
int	appGateIndexM
LwipTcpLayer::tcp_pcb *	pcbM
TcpLwipSendQueue *	sendQueueM
TcpLwipReceiveQueue *	receiveQueueM
TCP_lwIP &	tcpLwipM

Protected Member Functions
	TcpLwipConnection (const TcpLwipConnection &)

Protected Attributes
long int	totalSentM
bool	isListenerM
bool	onCloseM
Stats *	statsM

Constructor & Destructor Documentation

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

protected

inet::tcp::TcpLwipConnection::TcpLwipConnection	(	TCP_lwIP &	tcpLwipP,
		int	connIdP,
		int	gateIndexP,
		TCPDataTransferMode	dataTransferModeP
	)

    :
    connIdM(connIdP),
    appGateIndexM(gateIndexP),
    pcbM(nullptr),
    sendQueueM(tcpLwipP.createSendQueue(dataTransferModeP)),
    receiveQueueM(tcpLwipP.createReceiveQueue(dataTransferModeP)),
    tcpLwipM(tcpLwipP),
    totalSentM(0),
    isListenerM(false),
    onCloseM(false),
    statsM(nullptr)
{
    pcbM = tcpLwipM.getLwipTcpLayer()->tcp_new();       //FIXME memory leak
    ASSERT(pcbM);

    pcbM->callback_arg = this;

    sendQueueM->setConnection(this);
    receiveQueueM->setConnection(this);

    if (tcpLwipM.recordStatisticsM)
        statsM = new Stats();
}

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

    :
    connIdM(connIdP),
    appGateIndexM(connP.appGateIndexM),
    pcbM(pcbP),
    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),
    statsM(nullptr)
{
    pcbM = pcbP;
    pcbM->callback_arg = this;

    sendQueueM->setConnection(this);
    receiveQueueM->setConnection(this);

    if (tcpLwipM.recordStatisticsM)
        statsM = new Stats();
}

inet::tcp::TcpLwipConnection::~TcpLwipConnection

(

)

{
    if (pcbM)
        pcbM->callback_arg = nullptr;
    //FIXME memory leak, who will free pcbM?

    delete receiveQueueM;
    delete sendQueueM;
    delete statsM;
}

Member Function Documentation

void inet::tcp::TcpLwipConnection::abort

(

)

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

{
    tcpLwipM.getLwipTcpLayer()->tcp_close(pcbM);
    onCloseM = false;
}

void inet::tcp::TcpLwipConnection::close

(

)

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

{
    onCloseM = true;

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

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

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

{
    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;
}

void inet::tcp::TcpLwipConnection::do_SEND

(

)

Referenced by inet::tcp::TCP_lwIP::tcp_event_accept(), inet::tcp::TCP_lwIP::tcp_event_conn(), inet::tcp::TCP_lwIP::tcp_event_poll(), inet::tcp::TCP_lwIP::tcp_event_recv(), and inet::tcp::TCP_lwIP::tcp_event_sent().

{
    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 << "TCP_lwIP 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;
    }
}

void inet::tcp::TcpLwipConnection::fillStatusInfo

(

TCPStatusInfo &

statusInfo

)

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

{
//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);
}

INetStreamSocket* inet::tcp::TcpLwipConnection::getSocket

(

)

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

static

Referenced by sendIndicationToApp().

{
#define CASE(x)    case x: \
        s = #x + 6; break
    const char *s = "unknown";

    switch (code) {
        CASE(TCP_I_DATA);
        CASE(TCP_I_URGENT_DATA);
        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
}

void inet::tcp::TcpLwipConnection::initStats

(

)

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

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

{
    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;
}

void inet::tcp::TcpLwipConnection::notifyAboutSending

(

const TCPSegment &

tcpsegP

)

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

{
    receiveQueueM->notifyAboutSending(&tcpsegP);

    if (statsM)
        statsM->recordSend(tcpsegP);
}

void inet::tcp::TcpLwipConnection::send

(

cPacket *

msgP

)

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

{
    sendQueueM->enqueueAppData(msgP);
}

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

Referenced by do_SEND().

{
    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;
}

void inet::tcp::TcpLwipConnection::sendEstablishedMsg

(

)

Referenced by inet::tcp::TCP_lwIP::sendEstablishedMsg(), inet::tcp::TCP_lwIP::tcp_event_accept(), and inet::tcp::TCP_lwIP::tcp_event_conn().

{
    cMessage *msg = new cMessage("TCP_I_ESTABLISHED");
    msg->setKind(TCP_I_ESTABLISHED);

    TCPConnectInfo *tcpConnectInfo = new TCPConnectInfo();

    L3Address localAddr(pcbM->local_ip.addr), remoteAddr(pcbM->remote_ip.addr);

    tcpConnectInfo->setConnId(connIdM);
    tcpConnectInfo->setLocalAddr(localAddr);
    tcpConnectInfo->setRemoteAddr(remoteAddr);
    tcpConnectInfo->setLocalPort(pcbM->local_port);
    tcpConnectInfo->setRemotePort(pcbM->remote_port);

    msg->setControlInfo(tcpConnectInfo);

    tcpLwipM.send(msg, "appOut", appGateIndexM);
}

void inet::tcp::TcpLwipConnection::sendIndicationToApp

(

int

code

)

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

{
    const char *nameOfIndication = indicationName(code);
    EV_DETAIL << "Notifying app: " << nameOfIndication << "\n";
    cMessage *msg = new cMessage(nameOfIndication);
    msg->setKind(code);
    TCPCommand *ind = new TCPCommand();
    ind->setConnId(connIdM);
    msg->setControlInfo(ind);
    tcpLwipM.send(msg, "appOut", appGateIndexM);
}

Member Data Documentation

int inet::tcp::TcpLwipConnection::appGateIndexM

Referenced by inet::tcp::TCP_lwIP::printConnBrief(), inet::tcp::TCP_lwIP::process_STATUS(), sendEstablishedMsg(), sendIndicationToApp(), and inet::tcp::TCP_lwIP::tcp_event_recv().

int inet::tcp::TcpLwipConnection::connIdM

Referenced by inet::tcp::TcpLwipMsgBasedSendQueue::createSegmentWithBytes(), do_SEND(), inet::tcp::TCP_lwIP::ip_output(), inet::tcp::TCP_lwIP::printConnBrief(), inet::tcp::TCP_lwIP::process_ABORT(), inet::tcp::TCP_lwIP::process_CLOSE(), inet::tcp::TCP_lwIP::process_STATUS(), inet::tcp::TCP_lwIP::removeConnection(), sendEstablishedMsg(), sendIndicationToApp(), inet::tcp::TCP_lwIP::tcp_event_err(), and inet::tcp::TCP_lwIP::tcp_event_recv().

bool inet::tcp::TcpLwipConnection::isListenerM

protected

bool inet::tcp::TcpLwipConnection::onCloseM

protected

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

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

Referenced by abort(), close(), connect(), inet::tcp::TcpLwipMsgBasedSendQueue::discardAckedBytes(), do_SEND(), inet::tcp::TcpLwipMsgBasedReceiveQueue::extractBytesUpTo(), fillStatusInfo(), listen(), inet::tcp::TCP_lwIP::lwip_free_pcb_event(), inet::tcp::TCP_lwIP::lwip_tcp_event(), inet::tcp::TCP_lwIP::removeConnection(), send_data(), sendEstablishedMsg(), inet::tcp::TCP_lwIP::tcp_event_recv(), TcpLwipConnection(), and ~TcpLwipConnection().

TcpLwipReceiveQueue* inet::tcp::TcpLwipConnection::receiveQueueM

Referenced by inet::tcp::TCP_lwIP::notifyAboutIncomingSegmentProcessing(), notifyAboutSending(), inet::tcp::TCP_lwIP::tcp_event_recv(), TcpLwipConnection(), and ~TcpLwipConnection().

TcpLwipSendQueue* inet::tcp::TcpLwipConnection::sendQueueM

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

Stats* inet::tcp::TcpLwipConnection::statsM

protected

Referenced by notifyAboutSending(), TcpLwipConnection(), and ~TcpLwipConnection().

TCP_lwIP& inet::tcp::TcpLwipConnection::tcpLwipM

Referenced by abort(), close(), connect(), do_SEND(), listen(), send_data(), sendEstablishedMsg(), sendIndicationToApp(), TcpLwipConnection(), and inet::tcp::TcpLwipMsgBasedSendQueue::~TcpLwipMsgBasedSendQueue().

long int inet::tcp::TcpLwipConnection::totalSentM

protected

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

---

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

• TcpLwipConnection.h
• TcpLwipConnection.cc