SCTPSocket.h

Go to the documentation of this file.

//
// Copyright (C) 2008 Irene Ruengeler
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU 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 General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, see <http://www.gnu.org/licenses/>.
//


#ifndef __SCTPSOCKET_H
#define __SCTPSOCKET_H


#include <omnetpp.h>
#include "SCTPCommand_m.h"
#include "IPvXAddress.h"
#include "RoutingTable.h"


class SCTPStatusInfo;
class SCTP;




class  INET_API SCTPSocket
{
  public:
    class CallbackInterface
    {
      public:
        virtual ~CallbackInterface() {}
        virtual void socketDataArrived(int assocId, void *yourPtr, cPacket *msg, bool urgent) = 0;
    virtual void socketDataNotificationArrived(int assocId, void *yourPtr, cPacket *msg) = 0;
        virtual void socketEstablished(int assocId, void *yourPtr, uint64 buffer) {}
        virtual void socketPeerClosed(int assocId, void *yourPtr) {}
        virtual void socketClosed(int assocId, void *yourPtr) {}
        virtual void socketFailure(int assocId, void *yourPtr, int code) {}
        virtual void socketStatusArrived(int assocId, void *yourPtr, SCTPStatusInfo *status){}// {delete status;}
    virtual void sendRequestArrived() {}
    virtual void shutdownReceivedArrived(int connId) {}
    virtual void sendqueueFullArrived(int connId) {}
    virtual void sendqueueAbatedArrived(int connId, uint64 buffer) {}
    virtual void addressAddedArrived(int assocId, IPvXAddress localAddr, IPvXAddress remoteAddr) {}
    };

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

    protected:
        int assocId;
        int sockId;
        int sockstate;
        bool oneToOne;

        IPvXAddress localAddr;
        AddressVector localAddresses;

        int localPrt;
        IPvXAddress remoteAddr;
        AddressVector remoteAddresses;
        int remotePrt;
        int fsmStatus;
        int inboundStreams;
        int outboundStreams;
        int lastStream;


    CallbackInterface *cb;
    void *yourPtr;

  protected:
    void sendToSCTP(cPacket *msg);

  public:
  cGate *gateToSctp;
   // SCTPSocket();
    SCTPSocket(bool type = true);

    SCTPSocket(cPacket *msg);

    ~SCTPSocket();

    int getConnectionId() const  {return assocId;}

    int getState()   {return sockstate;}

    static const char *stateName(int state);

  //  IPvXAddress localAddress() {return localAddr;}
  AddressVector getLocalAddresses()  {return localAddresses;}
    int getLocalPort() {return localPrt;}
  //  IPvXAddress remoteAddress() {return remoteAddr;}
  AddressVector getRemoteAddresses()  {return remoteAddresses;}
    int getRemotePort() {return remotePrt;}
    IPvXAddress getRemoteAddr() {return remoteAddr;}


    void setOutputGate(cGate *toSctp)  {gateToSctp = toSctp;};
    void setOutboundStreams(int streams) {outboundStreams = streams;};
    void setInboundStreams(int streams) {inboundStreams = streams;};
    int getOutboundStreams() {return outboundStreams;};
    int getLastStream() {return lastStream;};
    void bind(int localPort);

   void bind(IPvXAddress localAddr, int localPort);

    void bindx(AddressVector localAddr, int localPort);

    void addAddress(IPvXAddress addr);
    //
    // TBD add support for these options too!
    //  string sendQueueClass;
    //  string receiveQueueClass;
    //  string sctpAlgorithmClass;
    //

     void listen(bool fork=false, uint32 requests=0, uint32 messagesToPush=0);
    void connect(IPvXAddress remoteAddress, int32 remotePort, uint32 numRequests);

     void connectx(AddressVector remoteAddresses, int32 remotePort, uint32 numRequests=0);
    void send(cPacket *msg, bool last=true, bool primary=true);

      void sendNotification(cPacket *msg);
    void sendRequest(cPacket *msg);
    void close();

    void abort();
    void shutdown();
    void requestStatus();

    bool belongsToSocket(cPacket *msg);

    static bool belongsToAnySCTPSocket(cPacket *msg);

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

    void processMessage(cPacket *msg);


    void setState(int state) {sockstate = state; };
};

#endif