inet::Ipv6Socket Class Reference

This class implements a raw IPv6 socket. More...

#include <Ipv6Socket.h>

Inheritance diagram for inet::Ipv6Socket:

Classes
class	ICallback

Public Member Functions
	Ipv6Socket (cGate *outputGate=nullptr)
virtual	~Ipv6Socket ()
void	setOutputGate (cGate *outputGate)
	Sets the gate on which to send raw packets. More...
virtual void	setCallback (INetworkSocket::ICallback *callback) override
	Sets a callback object, to be used with processMessage(). More...
void *	getUserData () const
void	setUserData (void *userData)
virtual int	getSocketId () const override
	Returns the socket Id which is unique within the network node. More...
virtual const Protocol *	getNetworkProtocol () const override
	Returns the associated network protocol used to deliver datagrams by this socket. More...
virtual bool	belongsToSocket (cMessage *msg) const override
	Returns true if the message belongs to this socket. More...
virtual void	processMessage (cMessage *msg) override
	Examines the message, takes ownership, and updates socket state. More...
virtual void	bind (const Protocol *protocol, Ipv6Address localAddress)
virtual void	connect (Ipv6Address remoteAddress)
virtual void	send (Packet *packet) override
virtual void	sendTo (Packet *packet, Ipv6Address destAddress)
virtual void	close () override
	Closes this socket releasing all resources. More...
virtual void	destroy () override
	Notify the protocol that the owner of ISocket has destroyed the socket. More...
virtual bool	isOpen () const override
Public Member Functions inherited from inet::ISocket
virtual	~ISocket ()

Protected Member Functions
void	sendToOutput (cMessage *message)
virtual void	bind (const Protocol *protocol, L3Address localAddress) override
	Binds this socket to the given protocol and local address. More...
virtual void	connect (L3Address remoteAddress) override
	Connects to a remote socket. More...
virtual void	sendTo (Packet *packet, L3Address destAddress) override
	Sends a packet to the given remote address using the associated network protocol. More...

Protected Attributes
bool	bound = false
bool	isOpen_ = false
int	socketId = -1
INetworkSocket::ICallback *	callback = nullptr
void *	userData = nullptr
cGate *	outputGate = nullptr

Detailed Description

This class implements a raw IPv6 socket.

Constructor & Destructor Documentation

Ipv6Socket()

inet::Ipv6Socket::Ipv6Socket

(

cGate *

outputGate = nullptr

)

                                        :
    socketId(getEnvir()->getUniqueNumber()),
    outputGate(outputGate)
{
}

~Ipv6Socket()

virtual inet::Ipv6Socket::~Ipv6Socket ( )

inlinevirtual

{}

Member Function Documentation

belongsToSocket()

bool inet::Ipv6Socket::belongsToSocket ( cMessage *  msg ) const

overridevirtual

Returns true if the message belongs to this socket.

Implements inet::ISocket.

{
    auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
    int msgSocketId = tags.getTag<SocketInd>()->getSocketId();
    return socketId == msgSocketId;
}

Referenced by processMessage().

bind() [1/2]

void inet::Ipv6Socket::bind ( const Protocol *  protocol, Ipv6Address  localAddress  )

virtual

{
    ASSERT(!bound);
    auto *command = new Ipv6SocketBindCommand();
    command->setProtocol(protocol);
    command->setLocalAddress(localAddress);
    auto request = new Request("bind", IPv6_C_BIND);
    request->setControlInfo(command);
    sendToOutput(request);
    bound = true;
    isOpen_ = true;
}

bind() [2/2]

virtual void inet::Ipv6Socket::bind ( const Protocol *  protocol, L3Address  localAddress  )

inlineoverrideprotectedvirtual

Binds this socket to the given protocol and local address.

All incoming packets matching the given parameters will be delivered via the callback interface.

Implements inet::INetworkSocket.

{ bind(protocol, localAddress.toIpv6()); }

Referenced by bind().

close()

void inet::Ipv6Socket::close ( )

overridevirtual

Closes this socket releasing all resources.

Once closed, a closed socket may be bound to another (or the same) protocol, and reused.

Implements inet::INetworkSocket.

{
    ASSERT(bound);
    Ipv6SocketCloseCommand *command = new Ipv6SocketCloseCommand();
    auto request = new Request("close", IPv6_C_CLOSE);
    request->setControlInfo(command);
    sendToOutput(request);
}

connect() [1/2]

void inet::Ipv6Socket::connect ( Ipv6Address  remoteAddress )

virtual

{
    isOpen_ = true;
    auto *command = new Ipv6SocketConnectCommand();
    command->setRemoteAddress(remoteAddress);
    auto request = new Request("connect", IPv6_C_CONNECT);
    request->setControlInfo(command);
    sendToOutput(request);
}

connect() [2/2]

virtual void inet::Ipv6Socket::connect ( L3Address  remoteAddress )

inlineoverrideprotectedvirtual

Connects to a remote socket.

The socket will only receive packets from the specified address, and you can use send() as opposed to sendTo() to send packets.

Implements inet::INetworkSocket.

{ connect(remoteAddress.toIpv6()); }

Referenced by connect().

destroy()

void inet::Ipv6Socket::destroy ( )

overridevirtual

Notify the protocol that the owner of ISocket has destroyed the socket.

Typically used when the owner of ISocket has crashed.

Implements inet::ISocket.

{
    auto *command = new Ipv6SocketDestroyCommand();
    auto request = new Request("destroy", IPv6_C_DESTROY);
    request->setControlInfo(command);
    sendToOutput(request);
}

getNetworkProtocol()

virtual const Protocol* inet::Ipv6Socket::getNetworkProtocol ( ) const

inlineoverridevirtual

Returns the associated network protocol used to deliver datagrams by this socket.

Implements inet::INetworkSocket.

{ return &Protocol::ipv6; }

getSocketId()

virtual int inet::Ipv6Socket::getSocketId ( ) const

inlineoverridevirtual

Returns the socket Id which is unique within the network node.

Implements inet::ISocket.

{ return socketId; }

Referenced by belongsToSocket().

getUserData()

void* inet::Ipv6Socket::getUserData ( ) const

inline

{ return userData; }

isOpen()

virtual bool inet::Ipv6Socket::isOpen ( ) const

inlineoverridevirtual

Implements inet::ISocket.

{ return isOpen_; }

processMessage()

void inet::Ipv6Socket::processMessage ( cMessage *  msg )

overridevirtual

Examines the message, takes ownership, and updates socket state.

Implements inet::ISocket.

{
    ASSERT(belongsToSocket(msg));
    switch (msg->getKind()) {
        case IPv6_I_DATA:
            if (callback)
                callback->socketDataArrived(this, check_and_cast<Packet *>(msg));
            else
                delete msg;
            break;
        case IPv6_I_SOCKET_CLOSED:
            check_and_cast<Indication *>(msg);
            bound = isOpen_ = false;
            if (callback)
                callback->socketClosed(this);
            delete msg;
            break;
        default:
            throw cRuntimeError("Ipv6Socket: invalid msg kind %d, one of the IPv6_I_xxx constants expected", msg->getKind());
            break;
    }
}

send()

void inet::Ipv6Socket::send ( Packet *  packet )

overridevirtual

Implements inet::ISocket.

{
    sendToOutput(packet);
}

Referenced by sendTo().

sendTo() [1/2]

void inet::Ipv6Socket::sendTo ( Packet *  packet, Ipv6Address  destAddress  )

virtual

{
    auto addressReq = packet->addTagIfAbsent<L3AddressReq>();
    addressReq->setDestAddress(destAddress);
    send(packet);
}

sendTo() [2/2]

virtual void inet::Ipv6Socket::sendTo ( Packet *  packet, L3Address  remoteAddress  )

inlineoverrideprotectedvirtual

Sends a packet to the given remote address using the associated network protocol.

Implements inet::INetworkSocket.

{ sendTo(packet, destAddress.toIpv6()); }

Referenced by sendTo().

sendToOutput()

void inet::Ipv6Socket::sendToOutput ( cMessage *  message )

protected

{
    if (!outputGate)
        throw cRuntimeError("Ipv6Socket: setOutputGate() must be invoked before the socket can be used");
    auto& tags = check_and_cast<ITaggedObject *>(message)->getTags();
    tags.addTagIfAbsent<DispatchProtocolReq>()->setProtocol(&Protocol::ipv6);
    tags.addTagIfAbsent<SocketReq>()->setSocketId(socketId);
    check_and_cast<cSimpleModule *>(outputGate->getOwnerModule())->send(message, outputGate);
}

Referenced by bind(), close(), connect(), destroy(), and send().

setCallback()

void inet::Ipv6Socket::setCallback ( INetworkSocket::ICallback *  callback )

overridevirtual

Sets a callback object, to be used with processMessage().

This callback object may be your simple module itself (if it multiply inherits from ICallback too, that is you declared it as

class MyAppModule : public cSimpleModule, public ICallback

and redefined the necessary virtual functions; or you may use dedicated class (and objects) for this purpose.

Sockets don't delete the callback object in the destructor or on any other occasion.

Implements inet::INetworkSocket.

{
    this->callback = callback;
}

setOutputGate()

void inet::Ipv6Socket::setOutputGate ( cGate *  outputGate )

inline

Sets the gate on which to send raw packets.

Must be invoked before socket can be used. Example: socket.setOutputGate(gate("ipOut"));

{ this->outputGate = outputGate; }

setUserData()

void inet::Ipv6Socket::setUserData ( void *  userData )

inline

{ this->userData = userData; }

Member Data Documentation

bound

bool inet::Ipv6Socket::bound = false

protected

Referenced by bind(), close(), and processMessage().

callback

INetworkSocket::ICallback* inet::Ipv6Socket::callback = nullptr

protected

Referenced by processMessage(), and setCallback().

isOpen_

bool inet::Ipv6Socket::isOpen_ = false

protected

Referenced by bind(), connect(), and processMessage().

outputGate

cGate* inet::Ipv6Socket::outputGate = nullptr

protected

Referenced by sendToOutput().

socketId

int inet::Ipv6Socket::socketId = -1

protected

Referenced by belongsToSocket(), and sendToOutput().

userData

void* inet::Ipv6Socket::userData = nullptr

protected

---

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

• Ipv6Socket.h
• Ipv6Socket.cc