inet::L3Socket Class Reference

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

#include <L3Socket.h>

Inheritance diagram for inet::L3Socket:

Classes
class	ICallback

Public Member Functions
	L3Socket (const Protocol *l3Protocol, cGate *outputGate=nullptr)
virtual	~L3Socket ()
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, 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	send (Packet *packet) override
virtual void	sendTo (Packet *packet, L3Address destAddress) override
	Sends a packet to the given remote address using the associated network protocol. More...
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)

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

Detailed Description

This class implements a raw L3 socket.

Constructor & Destructor Documentation

L3Socket()

inet::L3Socket::L3Socket	(	const Protocol *	l3Protocol,
		cGate *	outputGate = nullptr
	)

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

~L3Socket()

virtual inet::L3Socket::~L3Socket ( )

inlinevirtual

{}

Member Function Documentation

belongsToSocket()

bool inet::L3Socket::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()

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

overridevirtual

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.

{
    ASSERT(!bound);
    ASSERT(l3Protocol != nullptr);
    L3SocketBindCommand *command = new L3SocketBindCommand();
    command->setProtocol(protocol);
    auto request = new Request("bind", L3_C_BIND);
    request->setControlInfo(command);
    sendToOutput(request);
    bound = true;
    isOpen_ = true;
}

close()

void inet::L3Socket::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);
    ASSERT(l3Protocol != nullptr);
    L3SocketCloseCommand *command = new L3SocketCloseCommand();
    auto request = new Request("close", L3_C_CLOSE);
    request->setControlInfo(command);
    sendToOutput(request);
}

connect()

void inet::L3Socket::connect ( L3Address  remoteAddress )

overridevirtual

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.

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

destroy()

void inet::L3Socket::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.

{
    ASSERT(l3Protocol != nullptr);
    auto *command = new L3SocketDestroyCommand();
    auto request = new Request("destroy", L3_C_DESTROY);
    request->setControlInfo(command);
    sendToOutput(request);
}

getNetworkProtocol()

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

inlineoverridevirtual

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

Implements inet::INetworkSocket.

{ return l3Protocol; }

getSocketId()

virtual int inet::L3Socket::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::L3Socket::getUserData ( ) const

inline

{ return userData; }

isOpen()

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

inlineoverridevirtual

Implements inet::ISocket.

{ return isOpen_; }

processMessage()

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

overridevirtual

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

Implements inet::ISocket.

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

send()

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

overridevirtual

Implements inet::ISocket.

{
    sendToOutput(packet);
}

Referenced by sendTo().

sendTo()

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

overridevirtual

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

Implements inet::INetworkSocket.

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

sendToOutput()

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

protected

{
    if (!outputGate)
        throw cRuntimeError("L3Socket: setOutputGate() must be invoked before the socket can be used");
    auto& tags = check_and_cast<ITaggedObject *>(message)->getTags();
    tags.addTagIfAbsent<DispatchProtocolReq>()->setProtocol(l3Protocol);
    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::L3Socket::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::L3Socket::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::L3Socket::setUserData ( void *  userData )

inline

{ this->userData = userData; }

Member Data Documentation

bound

bool inet::L3Socket::bound = false

protected

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

callback

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

protected

Referenced by processMessage(), and setCallback().

isOpen_

bool inet::L3Socket::isOpen_ = false

protected

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

l3Protocol

const Protocol* inet::L3Socket::l3Protocol = nullptr

protected

Referenced by bind(), close(), destroy(), and sendToOutput().

outputGate

cGate* inet::L3Socket::outputGate = nullptr

protected

Referenced by sendToOutput().

socketId

int inet::L3Socket::socketId = -1

protected

Referenced by belongsToSocket(), and sendToOutput().

userData

void* inet::L3Socket::userData = nullptr

protected

---

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

• L3Socket.h
• L3Socket.cc