TCPSocket.h

Go to the documentation of this file.

//
// Copyright (C) 2004 Andras Varga
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with this program; if not, see <http://www.gnu.org/licenses/>.
//


#ifndef __INET_TCPSOCKET_H
#define __INET_TCPSOCKET_H

#include <omnetpp.h>
#include "TCPCommand_m.h"
#include "IPvXAddress.h"

class TCPStatusInfo;


class INET_API TCPSocket
{
  public:
    class CallbackInterface
    {
      public:
        virtual ~CallbackInterface() {}
        virtual void socketDataArrived(int connId, void *yourPtr, cPacket *msg, bool urgent) = 0;
        virtual void socketEstablished(int connId, void *yourPtr) {}
        virtual void socketPeerClosed(int connId, void *yourPtr) {}
        virtual void socketClosed(int connId, void *yourPtr) {}
        virtual void socketFailure(int connId, void *yourPtr, int code) {}
        virtual void socketStatusArrived(int connId, void *yourPtr, TCPStatusInfo *status) {delete status;}
    };

    enum State {NOT_BOUND, BOUND, LISTENING, CONNECTING, CONNECTED, PEER_CLOSED, LOCALLY_CLOSED, CLOSED, SOCKERROR};

  protected:
    int connId;
    int sockstate;

    IPvXAddress localAddr;
    int localPrt;
    IPvXAddress remoteAddr;
    int remotePrt;

    CallbackInterface *cb;
    void *yourPtr;

    cGate *gateToTcp;

    std::string sendQueueClass;
    std::string receiveQueueClass;
    std::string tcpAlgorithmClass;


  protected:
    void sendToTCP(cMessage *msg);

    // internal: implementation behind listen() and listenOnce()
    void listen(bool fork);

  public:
    TCPSocket();

    TCPSocket(cMessage *msg);

    ~TCPSocket() {}

    int getConnectionId() const  {return connId;}

    int getState()   {return sockstate;}

    static const char *stateName(int state);

    IPvXAddress getLocalAddress() {return localAddr;}
    int getLocalPort() {return localPrt;}
    IPvXAddress getRemoteAddress() {return remoteAddr;}
    int getRemotePort() {return remotePrt;}


    void setOutputGate(cGate *toTcp)  {gateToTcp = toTcp;}

    void bind(int localPort);

    void bind(IPvXAddress localAddr, int localPort);

    const char *getSendQueueClass() const {return sendQueueClass.c_str();}

    const char *getReceiveQueueClass() const {return receiveQueueClass.c_str();}

    const char *getTCPAlgorithmClass() const {return tcpAlgorithmClass.c_str();}

    void setSendQueueClass(const char *sendQueueClass) { this->sendQueueClass = sendQueueClass; }

    void setReceiveQueueClass(const char *receiveQueueClass) { this->receiveQueueClass = receiveQueueClass; }

    void setTCPAlgorithmClass(const char *tcpAlgorithmClass) { this->tcpAlgorithmClass = tcpAlgorithmClass; }

    void listen()  {listen(true);}

    void listenOnce()  {listen(false);}

    void connect(IPvXAddress remoteAddr, int remotePort);

    void send(cMessage *msg);

    void close();

    void abort();

    void requestStatus();

    void renewSocket();

    bool belongsToSocket(cMessage *msg);

    static bool belongsToAnyTCPSocket(cMessage *msg);

    void setCallbackObject(CallbackInterface *cb, void *yourPtr=NULL);

    void processMessage(cMessage *msg);
};

#endif