inet::Ieee8021qSocket Class Reference

#include <Ieee8021qSocket.h>

Inheritance diagram for inet::Ieee8021qSocket:

Classes
class	ICallback

Public Member Functions
Opening and closing connections, sending data
void	setCallback (ICallback *callback)
	Sets a callback object, to be used with processMessage(). More...
void	setNetworkInterface (NetworkInterface *networkInterface)
void	setProtocol (const Protocol *protocol)
void	bind (const Protocol *protocol, int vlanId, bool steal)
	Binds the socket to the MAC address. More...
Handling of messages arriving from Ieee8021q
virtual void	processMessage (cMessage *msg) override
	Returns true if the message belongs to this socket instance. More...
Public Member Functions inherited from inet::SocketBase
	SocketBase ()
virtual	~SocketBase ()
void	setOutputGate (cGate *gate)
	Sets the gate on which to send messages. More...
int	getSocketId () const override
	Returns the internal socket Id. More...
virtual void	send (Packet *packet) override
	Sends a data packet to the address and port specified previously in a connect() call. More...
virtual bool	isOpen () const override
	Returns true if the socket is open. More...
virtual void	close () override
	Unbinds the socket. More...
virtual void	destroy () override
	Notify the protocol that the owner of ISocket has destroyed the socket. More...
virtual bool	belongsToSocket (cMessage *msg) const override
	Returns true if the message belongs to this socket instance. More...
void *	getUserData () const
void	setUserData (void *userData)
Public Member Functions inherited from inet::ISocket
virtual	~ISocket ()

Protected Member Functions
virtual void	sendOut (cMessage *msg) override

Protected Attributes
ICallback *	callback = nullptr
NetworkInterface *	networkInterface = nullptr
const Protocol *	protocol = nullptr
Protected Attributes inherited from inet::SocketBase
cGate *	outputGate = nullptr
int	socketId = -1
bool	isOpen_ = false
void *	userData = nullptr

Member Function Documentation

bind()

void inet::Ieee8021qSocket::bind	(	const Protocol *	protocol,
		int	vlanId,
		bool	steal
	)

Binds the socket to the MAC address.

{
    auto request = new Request("BIND", SOCKET_C_BIND);
    Ieee8021qBindCommand *ctrl = new Ieee8021qBindCommand();
    ctrl->setProtocol(protocol);
    ctrl->setVlanId(vlanId);
    ctrl->setSteal(steal);
    request->setControlInfo(ctrl);
    isOpen_ = true;
    sendOut(request);
}

processMessage()

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

overridevirtual

Returns true if the message belongs to this socket instance.

Implements inet::ISocket.

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

sendOut()

void inet::Ieee8021qSocket::sendOut ( cMessage *  msg )

overrideprotectedvirtual

Reimplemented from inet::SocketBase.

{
    auto& tags = check_and_cast<ITaggedObject *>(msg)->getTags();
    tags.addTagIfAbsent<InterfaceReq>()->setInterfaceId(networkInterface->getInterfaceId());
    if (tags.findTag<DispatchProtocolReq>() == nullptr)
        tags.addTag<DispatchProtocolReq>()->setProtocol(protocol);
    SocketBase::sendOut(msg);
}

Referenced by bind().

setCallback()

void inet::Ieee8021qSocket::setCallback ( ICallback *  callback )

inline

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 Ieee8021qSocket::ICallback

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

Ieee8021qSocket doesn't delete the callback object in the destructor or on any other occasion.

{ this->callback = callback; }

setNetworkInterface()

void inet::Ieee8021qSocket::setNetworkInterface ( NetworkInterface *  networkInterface )

inline

{ this->networkInterface = networkInterface; }

setProtocol()

void inet::Ieee8021qSocket::setProtocol ( const Protocol *  protocol )

inline

{ this->protocol = protocol; }

Member Data Documentation

callback

ICallback* inet::Ieee8021qSocket::callback = nullptr

protected

Referenced by processMessage().

networkInterface

NetworkInterface* inet::Ieee8021qSocket::networkInterface = nullptr

protected

Referenced by sendOut().

protocol

const Protocol* inet::Ieee8021qSocket::protocol = nullptr

protected

Referenced by bind(), and sendOut().

---

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

• Ieee8021qSocket.h
• Ieee8021qSocket.cc