epics::pvAccess::ServerSearchHandler Class Reference

#include "responseHandlers.h"

Inheritance diagram for epics::pvAccess::ServerSearchHandler:

Collaboration diagram for epics::pvAccess::ServerSearchHandler:

Public Member Functions
	ServerSearchHandler (ServerContextImpl::shared_pointer const &context)
virtual	~ServerSearchHandler ()
virtual void	handleResponse (osiSockAddr *responseFrom, Transport::shared_pointer const &transport, epics::pvData::int8 version, epics::pvData::int8 command, std::size_t payloadSize, epics::pvData::ByteBuffer *payloadBuffer) OVERRIDE FINAL
Public Member Functions inherited from epics::pvAccess::AbstractServerResponseHandler
	AbstractServerResponseHandler (ServerContextImpl::shared_pointer const &context, std::string description)
virtual	~AbstractServerResponseHandler ()
Public Member Functions inherited from epics::pvAccess::ResponseHandler
	POINTER_DEFINITIONS (ResponseHandler)
	ResponseHandler (Context *context, const std::string &description)
virtual	~ResponseHandler ()

Static Public Attributes
static const std::string	SUPPORTED_PROTOCOL = "tcp"
Static Public Attributes inherited from epics::pvAccess::ResponseHandler
static size_t	num_instances

Additional Inherited Members
Protected Attributes inherited from epics::pvAccess::AbstractServerResponseHandler
ServerContextImpl::shared_pointer	_context
Protected Attributes inherited from epics::pvAccess::ResponseHandler
std::string	_description
epics::pvData::int32	_debugLevel

Detailed Description

Search channel request handler.

Definition at line 120 of file responseHandlers.h.

Constructor & Destructor Documentation

epics::pvAccess::ServerSearchHandler::ServerSearchHandler

(

ServerContextImpl::shared_pointer const &

context

)

Definition at line 240 of file responseHandlers.cpp.

                                                                                        :
    AbstractServerResponseHandler(context, "Search request")
{
    // initialize random seed with some random value
    srand ( time(NULL) );
}

virtual epics::pvAccess::ServerSearchHandler::~ServerSearchHandler ( )

inlinevirtual

Definition at line 126 of file responseHandlers.h.

{}

Member Function Documentation

void epics::pvAccess::ServerSearchHandler::handleResponse ( osiSockAddr *  responseFrom, Transport::shared_pointer const &  transport, epics::pvData::int8  version, epics::pvData::int8  command, std::size_t  payloadSize, epics::pvData::ByteBuffer *  payloadBuffer  )

virtual

Handle response.

Parameters

[in]	responseFrom	remote address of the responder, 0 if unknown.
[in]	transport	response source transport.
[in]	version	message version.
[in]	payloadSize	size of this message data available in the payloadBuffer.
[in]	payloadBuffer	message payload data. Note that this might not be the only message in the buffer. Code must not manipulate buffer.

Reimplemented from epics::pvAccess::ResponseHandler.

Definition at line 247 of file responseHandlers.cpp.

{
    AbstractServerResponseHandler::handleResponse(responseFrom,
            transport, version, command, payloadSize, payloadBuffer);

    transport->ensureData(4+1+3+16+2);

    size_t startPosition = payloadBuffer->getPosition();

    const int32 searchSequenceId = payloadBuffer->getInt();
    const int8 qosCode = payloadBuffer->getByte();

    // reserved part
    payloadBuffer->getByte();
    payloadBuffer->getShort();

    osiSockAddr responseAddress;
    memset(&responseAddress, 0, sizeof(responseAddress));
    responseAddress.ia.sin_family = AF_INET;

    // 128-bit IPv6 address
    if (!decodeAsIPv6Address(payloadBuffer, &responseAddress)) return;

    // accept given address if explicitly specified by sender
    if (responseAddress.ia.sin_addr.s_addr == INADDR_ANY)
        responseAddress.ia.sin_addr = responseFrom->ia.sin_addr;

    // NOTE: htons might be a macro (e.g. vxWorks)
    int16 port = payloadBuffer->getShort();
    responseAddress.ia.sin_port = htons(port);

    size_t protocolsCount = SerializeHelper::readSize(payloadBuffer, transport.get());
    bool allowed = (protocolsCount == 0);
    for (size_t i = 0; i < protocolsCount; i++)
    {
        string protocol = SerializeHelper::deserializeString(payloadBuffer, transport.get());
        if (SUPPORTED_PROTOCOL == protocol)
            allowed = true;
    }

    // NOTE: we do not stop reading the buffer

    transport->ensureData(2);
    const int32 count = payloadBuffer->getShort() & 0xFFFF;

    // TODO DoS attack?
    //   You bet!  With a reply address encoded in the request we don't even need a forged UDP header.
    const bool responseRequired = (QOS_REPLY_REQUIRED & qosCode) != 0;

    //
    // locally broadcast if unicast (qosCode & 0x80 == 0x80) via UDP
    //
    if ((qosCode & 0x80) == 0x80)
    {
        BlockingUDPTransport::shared_pointer bt = dynamic_pointer_cast<BlockingUDPTransport>(transport);
        if (bt && bt->hasLocalMulticastAddress())
        {
            // RECEIVE_BUFFER_PRE_RESERVE allows to pre-fix message
            size_t newStartPos = (startPosition-PVA_MESSAGE_HEADER_SIZE)-PVA_MESSAGE_HEADER_SIZE-16;
            payloadBuffer->setPosition(newStartPos);

            // copy part of a header, and add: command, payloadSize, NIF address
            payloadBuffer->put(payloadBuffer->getBuffer(), startPosition-PVA_MESSAGE_HEADER_SIZE, PVA_MESSAGE_HEADER_SIZE-5);
            payloadBuffer->putByte(CMD_ORIGIN_TAG);
            payloadBuffer->putInt(16);
            // encode this socket bind address
            encodeAsIPv6Address(payloadBuffer, bt->getBindAddress());

            // clear unicast flag
            payloadBuffer->put(startPosition+4, (int8)(qosCode & ~0x80));

            // update response address
            payloadBuffer->setPosition(startPosition+8);
            encodeAsIPv6Address(payloadBuffer, &responseAddress);

            // set to end of a message
            payloadBuffer->setPosition(payloadBuffer->getLimit());

            bt->send(payloadBuffer->getBuffer()+newStartPos, payloadBuffer->getPosition()-newStartPos,
                     bt->getLocalMulticastAddress());

            return;
        }
    }

    PeerInfo::shared_pointer info;
    if(allowed) {
        info.reset(new PeerInfo);
        info->transport = "pva";
        info->peer = inetAddressToString(*responseFrom);
        info->transportVersion = version;
    }

    if (count > 0)
    {
        // regular name search
        for (int32 i = 0; i < count; i++)
        {
            transport->ensureData(4);
            const int32 cid = payloadBuffer->getInt();
            const string name = SerializeHelper::deserializeString(payloadBuffer, transport.get());
            // no name check here...

            if (allowed)
            {
                const std::vector<ChannelProvider::shared_pointer>& _providers = _context->getChannelProviders();

                int providerCount = _providers.size();
                std::tr1::shared_ptr<ServerChannelFindRequesterImpl> tp(new ServerChannelFindRequesterImpl(_context, info, providerCount));
                tp->set(name, searchSequenceId, cid, responseAddress, responseRequired, false);

                for (int i = 0; i < providerCount; i++)
                    _providers[i]->channelFind(name, tp);
            }
        }
    }
    else
    {
        // server discovery ping by pvlist
        if (allowed)
        {
            // ~random hold-off to reduce impact of all servers responding.
            // in [0.05, 0.15]
            double delay = double(rand())/RAND_MAX; // [0, 1]
            delay = delay*0.1 + 0.05;

            std::tr1::shared_ptr<ServerChannelFindRequesterImpl> tp(new ServerChannelFindRequesterImpl(_context, info, 1));
            tp->set("", searchSequenceId, 0, responseAddress, true, true);

            TimerCallback::shared_pointer tc = tp;
            _context->getTimer()->scheduleAfterDelay(tc, delay);
        }
    }
}

Member Data Documentation

const std::string epics::pvAccess::ServerSearchHandler::SUPPORTED_PROTOCOL = "tcp"

static

Definition at line 123 of file responseHandlers.h.

---

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

• modules/pvAccess/src/server/pv/responseHandlers.h
• modules/pvAccess/src/server/responseHandlers.cpp