epics::pvAccess Namespace Reference

Holds all PVA related. More...

Namespaces
	ca
	detail

Classes
class	AbstractServerResponseHandler
class	AtomicBoolean
class	AuthenticationPlugin
	Actor through which authentication exchanges are initiated. More...
class	AuthenticationPluginControl
	Callbacks for use by AuthenticationSession. More...
class	AuthenticationRegistry
class	AuthenticationSession
class	AuthNZHandler
class	AuthorizationPlugin
class	AuthorizationRegistry
class	BaseChannelRequester
class	BaseChannelRequesterFailureMessageTransportSender
class	BaseChannelRequesterMessageTransportSender
class	BeaconEmitter
class	BeaconHandler
class	BeaconServerStatusProvider
class	BlockingTCPAcceptor
class	BlockingTCPConnector
class	BlockingUDPConnector
class	BlockingUDPTransport
class	Channel
class	ChannelArray
class	ChannelArrayRequester
struct	ChannelBaseRequester
	Base for all Requesters (callbacks to client) More...
class	ChannelFind
class	ChannelFindRequester
class	ChannelGet
class	ChannelGetRequester
class	ChannelListRequester
class	ChannelListRequesterImpl
class	ChannelProcess
class	ChannelProcessRequester
class	ChannelProvider
class	ChannelProviderFactory
class	ChannelProviderRegistry
class	ChannelPut
class	ChannelPutGet
class	ChannelPutGetRequester
class	ChannelPutRequester
class	ChannelRequest
class	ChannelRequester
class	ChannelRPC
class	ChannelRPCRequester
class	ChannelRPCServiceImpl
class	ChannelSearchManager
class	ClientChannelImpl
class	ClientContextImpl
class	ClientFactory
struct	comp_osiSock_lt
class	Configuration
struct	ConfigurationBuilder
class	ConfigurationEnviron
	Lookup configuration strings from the process environment. More...
class	ConfigurationFactory
class	ConfigurationMap
	Lookup configuration strings from an in memory store. More...
class	ConfigurationProvider
class	ConfigurationProviderImpl
class	ConfigurationStack
class	Context
class	DefaultBeaconServerStatusProvider
struct	DefaultChannelRequester
	Used when ChannelProvider::createChannel() is passed a NULL ChannelRequester. More...
class	Destroyable
	Instance declaring destroy method. More...
class	EchoTransportSender
class	fair_queue
class	GetFieldRequester
class	HexDump
struct	ifaceNode
class	IntrospectionRegistry
class	Lockable
class	Monitor
class	MonitorElement
	An element for a monitorQueue. More...
class	MonitorFIFO
class	MonitorRequester
	Callback implemented by monitor clients. More...
struct	NetStats
	Expose statistics related to network transport. More...
struct	PeerInfo
	Information provded by a client to a server-type ChannelProvider. More...
class	PipelineChannelProvider
class	PipelineControl
class	PipelineServer
class	PipelineService
class	PipelineSession
class	ReferenceCountingLock
class	Requester
	Callback class for passing messages to a requester. More...
class	ResponseHandler
class	ResponseRequest
class	RPCChannel
class	RPCChannelProvider
class	RPCClient
class	RPCRequestException
class	RPCResponseCallback
class	RPCServer
	Serves (only) RPCServiceAsync and RPCService instances. More...
class	RPCService
class	RPCServiceAsync
class	ScopedLock
class	SearchInstance
class	SerializationHelper
class	ServerArrayHandler
class	ServerBadResponse
class	ServerCancelRequestHandler
class	ServerChannel
class	ServerChannelArrayRequesterImpl
class	ServerChannelFindRequesterImpl
class	ServerChannelGetRequesterImpl
class	ServerChannelProcessRequesterImpl
class	ServerChannelPutGetRequesterImpl
class	ServerChannelPutRequesterImpl
class	ServerChannelRequesterImpl
class	ServerChannelRPCRequesterImpl
class	ServerConnectionValidationHandler
class	ServerContext
class	ServerContextImpl
class	ServerCreateChannelHandler
class	ServerDestroyChannelHandler
class	ServerDestroyChannelHandlerTransportSender
class	ServerDestroyRequestHandler
class	ServerEchoHandler
class	ServerGetFieldHandler
class	ServerGetFieldHandlerTransportSender
class	ServerGetFieldRequesterImpl
class	ServerGetHandler
struct	ServerGUID
class	ServerMonitorHandler
class	ServerMonitorRequesterImpl
class	ServerNoopResponse
class	ServerProcessHandler
class	ServerPutGetHandler
class	ServerPutHandler
class	ServerResponseHandler
class	ServerRPCHandler
class	ServerSearchHandler
struct	SimpleChannelProviderFactory
struct	SingletonChannelProviderFactory
class	SyncChannelFind
struct	ThreadRunnerParam
class	Transport
class	TransportRegistry
class	TransportSendControl
class	TransportSender
class	Version
class	Wildcard

Typedefs
typedef std::tr1::shared_ptr< MonitorElement >	MonitorElementPtr
typedef std::vector< MonitorElementPtr >	MonitorElementPtrArray
typedef std::tr1::shared_ptr< Monitor >	MonitorPtr
typedef Monitor	PipelineMonitor
	Pipeline (streaming) support API (optional). This is used by pvAccess to implement pipeline (streaming) monitors. More...
typedef epicsInt32	pvAccessID
typedef std::vector< BlockingUDPTransport::shared_pointer >	BlockingUDPTransportVector
typedef ConfigurationEnviron	SystemConfigurationImpl
typedef std::vector< osiSockAddr >	InetAddrVector
typedef std::vector< ifaceNode >	IfaceNodeVector
typedef std::map< const short, epics::pvData::FieldConstPtr >	registryMap_t
typedef std::tr1::shared_ptr< Requester >	RequesterPtr

Enumerations
enum	AccessRights { none, read, readWrite }
enum	FlushStrategy { IMMEDIATE, DELAYED, USER_CONTROLED }
	The FlushStrategy enum. More...
enum	InetAddressType { inetAddressType_all, inetAddressType_unicast, inetAddressType_broadcast_multicast }
enum	QoS {   QOS_DEFAULT = 0x00, QOS_REPLY_REQUIRED = 0x01, QOS_BESY_EFFORT = 0x02, QOS_PROCESS = 0x04,   QOS_INIT = 0x08, QOS_DESTROY = 0x10, QOS_SHARE = 0x20, QOS_GET = 0x40,   QOS_GET_PUT = 0x80 }
enum	ApplicationCommands {   CMD_BEACON = 0, CMD_CONNECTION_VALIDATION = 1, CMD_ECHO = 2, CMD_SEARCH = 3,   CMD_SEARCH_RESPONSE = 4, CMD_AUTHNZ = 5, CMD_ACL_CHANGE = 6, CMD_CREATE_CHANNEL = 7,   CMD_DESTROY_CHANNEL = 8, CMD_CONNECTION_VALIDATED = 9, CMD_GET = 10, CMD_PUT = 11,   CMD_PUT_GET = 12, CMD_MONITOR = 13, CMD_ARRAY = 14, CMD_DESTROY_REQUEST = 15,   CMD_PROCESS = 16, CMD_GET_FIELD = 17, CMD_MESSAGE = 18, CMD_MULTIPLE_DATA = 19,   CMD_RPC = 20, CMD_CANCEL_REQUEST = 21, CMD_ORIGIN_TAG = 22 }
enum	ControlCommands { CMD_SET_MARKER = 0, CMD_ACK_MARKER = 1, CMD_SET_ENDIANESS = 2 }
enum	pvAccessLogLevel {   logLevelAll = 0, logLevelTrace, logLevelDebug, logLevelInfo,   logLevelWarn, logLevelError, logLevelFatal, logLevelOff }
enum	MessageType { infoMessage, warningMessage, errorMessage, fatalErrorMessage }

Functions
void	providerRegInit (void *)
epicsShareExtern void	refTrackRegistrar ()
Channel::shared_pointer	createPipelineChannel (ChannelProvider::shared_pointer const &provider, std::string const &channelName, ChannelRequester::shared_pointer const &channelRequester, PipelineService::shared_pointer const &pipelineService)
epicsShareFunc std::ostream &	operator<< (std::ostream &o, const Version &v)
const std::string	PVACCESS_DEFAULT_PROVIDER ("local")
const std::string	PVACCESS_ALL_PROVIDERS ("<all>")
const std::string	PVACCESS_DEBUG ("EPICS_PVA_DEBUG")
void	initializeUDPTransports (bool serverFlag, BlockingUDPTransportVector &udpTransports, const IfaceNodeVector &ifaceList, const ResponseHandler::shared_pointer &responseHandler, BlockingUDPTransport::shared_pointer &sendTransport, int32 &listenPort, bool autoAddressList, const std::string &addressList, const std::string &ignoreAddressList)
epicsShareFunc void	osdGetRoles (const std::string &account, PeerInfo::roles_t &roles)
	Query OS specific DB for role/group names assocated with a user account. More...
ChannelProvider::shared_pointer	createClientProvider (const Configuration::shared_pointer &conf)
epicsShareFunc Channel::shared_pointer	createRPCChannel (ChannelProvider::shared_pointer const &provider, std::string const &channelName, ChannelRequester::shared_pointer const &channelRequester, RPCServiceAsync::shared_pointer const &rpcService)
epicsShareFunc ServerContext::shared_pointer	startPVAServer (std::string const &providerNames=PVACCESS_ALL_PROVIDERS, int timeToRun=0, bool runInSeparateThread=false, bool printInfo=false)
epicsShareFunc std::ostream &	operator<< (std::ostream &strm, const HexDump &hex)
void	encodeAsIPv6Address (ByteBuffer *buffer, const osiSockAddr *address)
bool	decodeAsIPv6Address (ByteBuffer *buffer, osiSockAddr *address)
bool	isMulticastAddress (const osiSockAddr *address)
void	getSocketAddressList (InetAddrVector &ret, const std::string &list, int defaultPort, const InetAddrVector *appendList)
string	inetAddressToString (const osiSockAddr &addr, bool displayPort, bool displayHex)
int	discoverInterfaces (IfaceNodeVector &list, SOCKET socket, const osiSockAddr *pMatchAddr)
void	pvAccessLog (pvAccessLogLevel level, const char *format,...)
void	pvAccessSetLogLevel (pvAccessLogLevel level)
bool	pvAccessIsLoggable (pvAccessLogLevel level)
epicsShareExtern std::string	getMessageTypeName (MessageType messageType)

Variables
const epics::pvData::int8	PVA_MAGIC = static_cast<epics::pvData::int8>(0xCA)
const epics::pvData::int8	PVA_SERVER_PROTOCOL_REVISION = 2
const epics::pvData::int8	PVA_CLIENT_PROTOCOL_REVISION = 2
const epics::pvData::int8 PVA_PROTOCOL_REVISION	EPICS_DEPRECATED = 1
const epics::pvData::int32	PVA_SERVER_PORT = 5075
const epics::pvData::int32	PVA_BROADCAST_PORT = 5076
const epics::pvData::int16	PVA_MESSAGE_HEADER_SIZE = 8
const epics::pvData::int32	MAX_UDP_UNFRAGMENTED_SEND = 1440
const epics::pvData::int32	MAX_UDP_RECV = 65487
const epics::pvData::int32	MAX_TCP_RECV = 1024*16
const epics::pvData::int32	MAX_SEARCH_BATCH_COUNT = 0x7FFF
const epics::pvData::int16	PVA_DEFAULT_PRIORITY = 0
const epics::pvData::uint32	MAX_CHANNEL_NAME_LENGTH = 500
const epics::pvData::int16	INVALID_DATA_TYPE = 0xFFFF
const epics::pvData::int32	INVALID_IOID = 0
epicsShareExtern const std::string	PVACCESS_DEFAULT_PROVIDER
epicsShareExtern const std::string	PVACCESS_ALL_PROVIDERS
epicsShareExtern const std::string	PVACCESS_DEBUG
ConfigurationProvider::shared_pointer	configurationProvider
Mutex	conf_factory_mutex

Detailed Description

Holds all PVA related.

Typedef Documentation

typedef std::vector<BlockingUDPTransport::shared_pointer> epics::pvAccess::BlockingUDPTransportVector

Definition at line 403 of file blockingUDP.h.

typedef std::vector<ifaceNode> epics::pvAccess::IfaceNodeVector

Definition at line 33 of file inetAddressUtil.h.

typedef std::vector<osiSockAddr> epics::pvAccess::InetAddrVector

Definition at line 21 of file inetAddressUtil.h.

typedef std::tr1::shared_ptr<MonitorElement> epics::pvAccess::MonitorElementPtr

Definition at line 40 of file monitor.h.

typedef std::vector<MonitorElementPtr> epics::pvAccess::MonitorElementPtrArray

Definition at line 42 of file monitor.h.

typedef std::tr1::shared_ptr<Monitor> epics::pvAccess::MonitorPtr

Definition at line 44 of file monitor.h.

typedef Monitor epics::pvAccess::PipelineMonitor

Pipeline (streaming) support API (optional). This is used by pvAccess to implement pipeline (streaming) monitors.

Definition at line 1563 of file pvAccess.h.

typedef epicsInt32 epics::pvAccess::pvAccessID

Definition at line 18 of file pvaDefs.h.

typedef std::map<const short,epics::pvData::FieldConstPtr> epics::pvAccess::registryMap_t

Definition at line 37 of file introspectionRegistry.h.

typedef std::tr1::shared_ptr<Requester> epics::pvAccess::RequesterPtr

Definition at line 31 of file requester.h.

typedef ConfigurationEnviron epics::pvAccess::SystemConfigurationImpl

Definition at line 160 of file configuration.h.

Enumeration Type Documentation

enum epics::pvAccess::AccessRights

Enumerator
none	Neither read or write access is allowed.
read	Read access is allowed but write access is not allowed.
readWrite	Both read and write access are allowed.

Definition at line 71 of file pvAccess.h.

                  {
    none,
    read,
    readWrite
};

enum epics::pvAccess::ApplicationCommands

Enumerator
CMD_BEACON
CMD_CONNECTION_VALIDATION
CMD_ECHO
CMD_SEARCH
CMD_SEARCH_RESPONSE
CMD_AUTHNZ
CMD_ACL_CHANGE
CMD_CREATE_CHANNEL
CMD_DESTROY_CHANNEL
CMD_CONNECTION_VALIDATED
CMD_GET
CMD_PUT
CMD_PUT_GET
CMD_MONITOR
CMD_ARRAY
CMD_DESTROY_REQUEST
CMD_PROCESS
CMD_GET_FIELD
CMD_MESSAGE
CMD_MULTIPLE_DATA
CMD_RPC
CMD_CANCEL_REQUEST
CMD_ORIGIN_TAG

Definition at line 85 of file remote.h.

                         {
    CMD_BEACON = 0,
    CMD_CONNECTION_VALIDATION = 1,
    CMD_ECHO = 2,
    CMD_SEARCH = 3,
    CMD_SEARCH_RESPONSE = 4,
    CMD_AUTHNZ = 5,
    CMD_ACL_CHANGE = 6,
    CMD_CREATE_CHANNEL = 7,
    CMD_DESTROY_CHANNEL = 8,
    CMD_CONNECTION_VALIDATED = 9,
    CMD_GET = 10,
    CMD_PUT = 11,
    CMD_PUT_GET = 12,
    CMD_MONITOR = 13,
    CMD_ARRAY = 14,
    CMD_DESTROY_REQUEST = 15,
    CMD_PROCESS = 16,
    CMD_GET_FIELD = 17,
    CMD_MESSAGE = 18,
    CMD_MULTIPLE_DATA = 19,
    CMD_RPC = 20,
    CMD_CANCEL_REQUEST = 21,
    CMD_ORIGIN_TAG = 22
};

enum epics::pvAccess::ControlCommands

Enumerator
CMD_SET_MARKER
CMD_ACK_MARKER
CMD_SET_ENDIANESS

Definition at line 111 of file remote.h.

                     {
    CMD_SET_MARKER = 0,
    CMD_ACK_MARKER = 1,
    CMD_SET_ENDIANESS = 2
};

enum epics::pvAccess::FlushStrategy

The FlushStrategy enum.

Enumerator
IMMEDIATE
DELAYED
USER_CONTROLED

Definition at line 1221 of file pvAccess.h.

                   {
    IMMEDIATE, DELAYED, USER_CONTROLED
};

enum epics::pvAccess::InetAddressType

Enumerator
inetAddressType_all
inetAddressType_unicast
inetAddressType_broadcast_multicast

Definition at line 42 of file blockingUDP.h.

{ inetAddressType_all, inetAddressType_unicast, inetAddressType_broadcast_multicast };

enum epics::pvAccess::MessageType

Enumerator
infoMessage
warningMessage
errorMessage
fatalErrorMessage

Definition at line 34 of file requester.h.

                 {
   infoMessage,warningMessage,errorMessage,fatalErrorMessage
};

enum epics::pvAccess::pvAccessLogLevel

Enumerator
logLevelAll
logLevelTrace
logLevelDebug
logLevelInfo
logLevelWarn
logLevelError
logLevelFatal
logLevelOff

Definition at line 18 of file logger.h.

             { logLevelAll = 0, logLevelTrace, logLevelDebug, logLevelInfo,
               logLevelWarn, logLevelError, logLevelFatal, logLevelOff
             } pvAccessLogLevel;

enum epics::pvAccess::QoS

Enumerator
QOS_DEFAULT	Default behavior.
QOS_REPLY_REQUIRED	Require reply (acknowledgment for reliable operation).
QOS_BESY_EFFORT	Best-effort option (no reply).
QOS_PROCESS	Process option.
QOS_INIT	Initialize option.
QOS_DESTROY	Destroy option.
QOS_SHARE	Share data option.
QOS_GET	Get.
QOS_GET_PUT	Get-put.

Definition at line 46 of file remote.h.

         {
    QOS_DEFAULT = 0x00,
    QOS_REPLY_REQUIRED = 0x01,
    QOS_BESY_EFFORT = 0x02,
    QOS_PROCESS = 0x04,
    QOS_INIT = 0x08,
    QOS_DESTROY = 0x10,
    QOS_SHARE = 0x20,
    QOS_GET = 0x40,
    QOS_GET_PUT = 0x80
};

Function Documentation

ChannelProvider::shared_pointer epics::pvAccess::createClientProvider

(

const Configuration::shared_pointer &

conf

)

Definition at line 4747 of file clientContextImpl.cpp.

{
    registerRefCounter("InternalClientContextImpl", &InternalClientContextImpl::num_instances);
    registerRefCounter("InternalChannelImpl", &InternalClientContextImpl::InternalChannelImpl::num_instances);
    registerRefCounter("InternalChannelImpl (Active)", &InternalClientContextImpl::InternalChannelImpl::num_active);
    registerRefCounter("BaseRequestImpl", &BaseRequestImpl::num_instances);
    registerRefCounter("BaseRequestImpl (Active)", &BaseRequestImpl::num_active);
    InternalClientContextImpl::shared_pointer internal(new InternalClientContextImpl(conf)),
                                              external(internal.get(), epics::pvAccess::Destroyable::cleaner(internal));
    const_cast<InternalClientContextImpl::weak_pointer&>(internal->m_external_this) = external;
    const_cast<InternalClientContextImpl::weak_pointer&>(internal->m_internal_this) = internal;
    internal->initialize();
    return external;
}

epicsShareFunc Channel::shared_pointer epics::pvAccess::createPipelineChannel	(	ChannelProvider::shared_pointer const &	provider,
		std::string const &	channelName,
		ChannelRequester::shared_pointer const &	channelRequester,
		PipelineService::shared_pointer const &	pipelineService
	)

Definition at line 436 of file pipelineServer.cpp.

{
    // TODO use std::make_shared
    std::tr1::shared_ptr<PipelineChannel> tp(
        new PipelineChannel(provider, channelName, channelRequester, pipelineService)
    );
    Channel::shared_pointer channel = tp;
    return channel;
}

Channel::shared_pointer epics::pvAccess::createRPCChannel	(	ChannelProvider::shared_pointer const &	provider,
		std::string const &	channelName,
		ChannelRequester::shared_pointer const &	channelRequester,
		RPCServiceAsync::shared_pointer const &	rpcService
	)

Definition at line 229 of file rpcServer.cpp.

{
    // TODO use std::make_shared
    std::tr1::shared_ptr<RPCChannel> tp(
        new RPCChannel(provider, channelName, channelRequester, rpcService)
    );
    Channel::shared_pointer channel = tp;
    return channel;
}

epicsShareFunc bool epics::pvAccess::decodeAsIPv6Address	(	epics::pvData::ByteBuffer *	buffer,
		osiSockAddr *	address
	)

Decode IPv6 address (as IPv4 address).

Parameters

buffer	byte-buffer where to get encoded data.
address	address where to decode.

Returns

success status (true on success).

Definition at line 50 of file inetAddressUtil.cpp.

                                                                   {

    // IPv4 compatible IPv6 address expected
    // first 80-bit are 0
    if (buffer->getLong() != 0) return false;
    if (buffer->getShort() != 0) return false;
    int16 ffff = buffer->getShort();
    // allow all zeros address
    //if (ffff != (int16)0xFFFF) return false;

    uint32 ipv4Addr = uint8(buffer->getByte());
    ipv4Addr <<= 8;
    ipv4Addr |= uint8(buffer->getByte());
    ipv4Addr <<= 8;
    ipv4Addr |= uint8(buffer->getByte());
    ipv4Addr <<= 8;
    ipv4Addr |= uint8(buffer->getByte());

    if (ffff != (int16)0xFFFF && ipv4Addr != (uint32_t)0)
        return false;

    address->ia.sin_addr.s_addr = htonl(ipv4Addr);

    return true;
}

epicsShareFunc int epics::pvAccess::discoverInterfaces	(	IfaceNodeVector &	list,
		SOCKET	socket,
		const osiSockAddr *	pMatchAddr
	)

Definition at line 196 of file inetAddressUtil.cpp.

{
    static const unsigned           nelem = 100;
    int                             status;
    struct ifconf                   ifconf;
    struct ifreq                    *pIfreqList;
    struct ifreq                    *pIfreqListEnd;
    struct ifreq                    *pifreq;
    struct ifreq                    *pnextifreq;
    int                             match;

    /*
     * use pool so that we avoid using too much stack space
     *
     * nelem is set to the maximum interfaces
     * on one machine here
     */
    pIfreqList = (struct ifreq *) calloc ( nelem, sizeof(*pifreq) );
    if (!pIfreqList) {
        errlogPrintf ("discoverInterfaces(): no memory to complete request\n");
        return -1;
    }

    ifconf.ifc_len = nelem * sizeof(*pifreq);
    ifconf.ifc_req = pIfreqList;
    status = socket_ioctl (socket, SIOCGIFCONF, &ifconf);
    if (status < 0 || ifconf.ifc_len == 0) {
        errlogPrintf ("discoverInterfaces(): unable to fetch network interface configuration\n");
        free (pIfreqList);
        return -1;
    }

    pIfreqListEnd = (struct ifreq *) (ifconf.ifc_len + (char *) pIfreqList);
    pIfreqListEnd--;

    for ( pifreq = pIfreqList; pifreq <= pIfreqListEnd; pifreq = pnextifreq ) {
        uint32_t  current_ifreqsize;

        /*
         * find the next ifreq
         */
        pnextifreq = ifreqNext (pifreq);

        /* determine ifreq size */
        current_ifreqsize = ifreqSize ( pifreq );
        /* copy current ifreq to aligned bufferspace (to start of pIfreqList buffer) */
        /* be careful as we re-use part of this space several times below.
         * Any member other than ifr_name is invalidated by an ioctl() call
         */
        memmove(pIfreqList, pifreq, current_ifreqsize);

        /*
         * If its not an internet interface then dont use it
         */
        if ( pIfreqList->ifr_addr.sa_family != AF_INET ) {
            continue;
        }

        /*
         * if it isnt a wildcarded interface then look for
         * an exact match
         */
        match = 0;
        if ( pMatchAddr && pMatchAddr->sa.sa_family != AF_UNSPEC ) {
            if ( pMatchAddr->sa.sa_family != AF_INET ) {
                continue;
            }
            if ( pMatchAddr->ia.sin_addr.s_addr != htonl (INADDR_ANY) ) {
                struct sockaddr_in *pInetAddr = (struct sockaddr_in *) &pIfreqList->ifr_addr;
                if ( pInetAddr->sin_addr.s_addr != pMatchAddr->ia.sin_addr.s_addr ) {
                    continue;
                }
                else
                    match = 1;
            }
        }

        ifaceNode node;
        node.addr.sa = pIfreqList->ifr_addr;

        status = socket_ioctl ( socket, SIOCGIFFLAGS, pIfreqList );
        if ( status ) {
            errlogPrintf ("discoverInterfaces(): net intf flags fetch for \"%s\" failed\n", pIfreqList->ifr_name);
            continue;
        }

        unsigned short ifflags = pIfreqList->ifr_flags;
        node.loopback = ifflags & IFF_LOOPBACK;

        /*
         * dont bother with interfaces that have been disabled
         */
        if ( ! ( ifflags & IFF_UP ) ) {
            continue;
        }

        /*
         * dont use the loop back interface, unless it maches pMatchAddr
         */
        if (!match) {
            if ( ifflags & IFF_LOOPBACK ) {
                continue;
            }
        }

        /*
         * If this is an interface that supports
         * broadcast fetch the broadcast address.
         *
         * Otherwise if this is a point to point
         * interface then use the destination address.
         *
         * Otherwise CA will not query through the
         * interface.
         */
        if ( ifflags & IFF_BROADCAST ) {
            status = socket_ioctl (socket, SIOCGIFBRDADDR, pIfreqList);
            if ( status ) {
                errlogPrintf ("discoverInterfaces(): net intf \"%s\": bcast addr fetch fail\n", pIfreqList->ifr_name);
                continue;
            }
            node.bcast.sa = pIfreqList->ifr_broadaddr;

            status = socket_ioctl (socket, SIOCGIFNETMASK, pIfreqList);
            if ( status ) {
                errlogPrintf ("discoverInterfaces(): net intf \"%s\": netmask fetch fail\n", pIfreqList->ifr_name);
                continue;
            }
            node.mask.sa = pIfreqList->ifr_netmask;

            checkNode(node);

            node.validBcast = true;
        }
#if defined (IFF_POINTOPOINT)
        else if ( ifflags & IFF_POINTOPOINT ) {
            status = socket_ioctl ( socket, SIOCGIFDSTADDR, pIfreqList);
            if ( status ) {
                continue;
            }
            node.peer.sa = pIfreqList->ifr_dstaddr;
            node.validP2P = true;
        }
#endif
        else {
            // if it is a match, accept the interface even if it does not support broadcast (i.e. 127.0.0.1 or point to point)
            if (!match)
            {
                continue;
            }
        }

        list.push_back(node);
    }

    free ( pIfreqList );
    return 0;
}

epicsShareFunc void epics::pvAccess::encodeAsIPv6Address	(	epics::pvData::ByteBuffer *	buffer,
		const osiSockAddr *	address
	)

Encode IPv4 address as IPv6 address.

Parameters

buffer	byte-buffer where to put encoded data.
address	address to encode.

Definition at line 35 of file inetAddressUtil.cpp.

                                                                         {
    // IPv4 compatible IPv6 address
    // first 80-bit are 0
    buffer->putLong(0);
    buffer->putShort(0);
    // next 16-bits are 1
    buffer->putShort(0xFFFF);
    // following IPv4 address in big-endian (network) byte order
    uint32_t ipv4Addr = ntohl(address->ia.sin_addr.s_addr);
    buffer->putByte((int8)((ipv4Addr>>24)&0xFF));
    buffer->putByte((int8)((ipv4Addr>>16)&0xFF));
    buffer->putByte((int8)((ipv4Addr>>8)&0xFF));
    buffer->putByte((int8)(ipv4Addr&0xFF));
}

string epics::pvAccess::getMessageTypeName

(

MessageType

messageType

)

Definition at line 25 of file requester.cpp.

{
    switch(messageType) {
    case infoMessage: return "info";
    case warningMessage: return "warning";
    case errorMessage: return "error";
    case fatalErrorMessage: return "fatalError";
    default: return "unknown";
    }
}

epicsShareFunc void epics::pvAccess::getSocketAddressList	(	InetAddrVector &	ret,
		const std::string &	list,
		int	defaultPort,
		const InetAddrVector *	appendList = NULL
	)

Parse space delimited addresss[:port] string and populate array of InetSocketAddress.

Parameters

ret	results stored hre
list	space delimited addresss[:port] string.
defaultPort	port take if not specified.
appendList	list to be appended.

Returns

array of InetSocketAddress.

Definition at line 82 of file inetAddressUtil.cpp.

                                                                       {
    ret.clear();

    // skip leading spaces
    size_t len = list.length();
    size_t subStart = 0;
    while (subStart < len && isspace(list[subStart]))
        subStart++;

    // parse string
    size_t subEnd;
    while((subEnd = list.find(' ', subStart))!=std::string::npos) {
        string address = list.substr(subStart, (subEnd-subStart));
        osiSockAddr addr;
        if (aToIPAddr(address.c_str(), defaultPort, &addr.ia) == 0)
            ret.push_back(addr);
        subStart = list.find_first_not_of(" \t\r\n\v", subEnd);
    }

    if(subStart!=std::string::npos && subStart<len) {
        osiSockAddr addr;
        if (aToIPAddr(list.substr(subStart).c_str(), defaultPort, &addr.ia) == 0)
            ret.push_back(addr);
    }

    if(appendList!=NULL) {
        for(size_t i = 0; i<appendList->size(); i++)
            ret.push_back((*appendList)[i]);
    }
}

epicsShareFunc std::string epics::pvAccess::inetAddressToString	(	const osiSockAddr &	addr,
		bool	displayPort,
		bool	displayHex
	)

Definition at line 115 of file inetAddressUtil.cpp.

                                                              {
    stringstream saddr;

    int ipa = ntohl(addr.ia.sin_addr.s_addr);

    saddr<<((int)(ipa>>24)&0xFF)<<'.';
    saddr<<((int)(ipa>>16)&0xFF)<<'.';
    saddr<<((int)(ipa>>8)&0xFF)<<'.';
    saddr<<((int)ipa&0xFF);
    if(displayPort) saddr<<":"<<ntohs(addr.ia.sin_port);
    if(displayHex) saddr<<" ("<<hex<<ntohl(addr.ia.sin_addr.s_addr)
                            <<")";

    return saddr.str();
}

void epics::pvAccess::initializeUDPTransports	(	bool	serverFlag,
		BlockingUDPTransportVector &	udpTransports,
		const IfaceNodeVector &	ifaceList,
		const ResponseHandler::shared_pointer &	responseHandler,
		BlockingUDPTransport::shared_pointer &	sendTransport,
		int32 &	listenPort,
		bool	autoAddressList,
		const std::string &	addressList,
		const std::string &	ignoreAddressList
	)

Definition at line 576 of file blockingUDPTransport.cpp.

{
    BlockingUDPConnector connector(serverFlag);

    const int8_t protoVer = serverFlag ? PVA_SERVER_PROTOCOL_REVISION : PVA_CLIENT_PROTOCOL_REVISION;

    //
    // Create UDP transport for sending (to all network interfaces)
    //

    osiSockAddr anyAddress;
    memset(&anyAddress, 0, sizeof(anyAddress));
    anyAddress.ia.sin_family = AF_INET;
    anyAddress.ia.sin_port = htons(0);
    anyAddress.ia.sin_addr.s_addr = htonl(INADDR_ANY);

    sendTransport = connector.connect(responseHandler, anyAddress, protoVer);
    if (!sendTransport)
    {
        THROW_BASE_EXCEPTION("Failed to initialize UDP transport.");
    }

    // to allow automatic assignment of listen port (for testing)
    if (listenPort == 0)
    {
        listenPort = ntohs(sendTransport->getRemoteAddress().ia.sin_port);
        LOG(logLevelDebug, "Dynamic listen UDP port set to %u.", (unsigned)listenPort);
    }

    // TODO current implementation shares the port (aka beacon and search port)
    int32 sendPort = listenPort;

    //
    // compile auto address list - where to send packets
    //

    InetAddrVector autoBCastAddr;
    for (IfaceNodeVector::const_iterator iter = ifaceList.begin(); iter != ifaceList.end(); iter++)
    {
        ifaceNode node = *iter;

        // in practice, interface will have either destination (PPP)
        // or broadcast, but never both.
        if (node.validP2P && node.peer.ia.sin_family != AF_UNSPEC)
        {
            node.peer.ia.sin_port = htons(sendPort);
            autoBCastAddr.push_back(node.peer);
        }
        if (node.validBcast && node.bcast.ia.sin_family != AF_UNSPEC)
        {
            node.bcast.ia.sin_port = htons(sendPort);
            autoBCastAddr.push_back(node.bcast);
        }
    }

    //
    // set send address list
    //
    {
        InetAddrVector list;
        getSocketAddressList(list, addressList, sendPort, autoAddressList ? &autoBCastAddr : NULL);

        // avoid duplicates in address list
        {
            InetAddrVector dedup;

            for (InetAddrVector::const_iterator iter = list.begin(); iter != list.end(); iter++)
            {
                bool match = false;

                for(InetAddrVector::const_iterator inner = dedup.begin(); !match && inner != dedup.end(); inner++)
                {
                    match = iter->ia.sin_family==inner->ia.sin_family && iter->ia.sin_addr.s_addr==inner->ia.sin_addr.s_addr;
                }

                if(!match)
                    dedup.push_back(*iter);
            }
            list.swap(dedup);
        }

        std::vector<bool> isunicast(list.size());

        if (list.empty()) {
            LOG(logLevelError,
                "No %s broadcast addresses found or specified - empty address list!", serverFlag ? "server" : "client");
        }

        for (size_t i = 0; i < list.size(); i++) {

            isunicast[i] = !isMulticastAddress(&list[i]);

            for (IfaceNodeVector::const_iterator iter = ifaceList.begin(); isunicast[i] && iter != ifaceList.end(); iter++)
            {
                ifaceNode node = *iter;
                // compare with all iface bcasts
                if(node.validBcast && list[i].ia.sin_family==iter->bcast.ia.sin_family
                        && list[i].ia.sin_addr.s_addr==iter->bcast.ia.sin_addr.s_addr) {
                    isunicast[i] = false;
                }
            }
            LOG(logLevelDebug,
                "Broadcast address #%zu: %s. (%sunicast)", i, inetAddressToString(list[i]).c_str(),
                isunicast[i]?"":"not ");
        }

        sendTransport->setSendAddresses(list, isunicast);
    }

    sendTransport->start();
    udpTransports.push_back(sendTransport);

    // TODO configurable local NIF, address
    osiSockAddr loAddr;
    memset(&loAddr, 0, sizeof(loAddr));
    loAddr.ia.sin_family = AF_INET;
    loAddr.ia.sin_port = ntohs(0);
    loAddr.ia.sin_addr.s_addr = htonl(INADDR_LOOPBACK);

    // TODO configurable local multicast address
    std::string mcastAddress("224.0.0.128");

    osiSockAddr group;
    aToIPAddr(mcastAddress.c_str(), listenPort, &group.ia);

    //
    // set ignore address list
    //
    InetAddrVector ignoreAddressVector;
    getSocketAddressList(ignoreAddressVector, ignoreAddressList, 0, 0);

    //
    // Setup UDP trasport(s) (per interface)
    //

    InetAddrVector tappedNIF;

    for (IfaceNodeVector::const_iterator iter = ifaceList.begin(); iter != ifaceList.end(); iter++)
    {
        ifaceNode node = *iter;

        LOG(logLevelDebug, "Setting up UDP for interface %s/%s, broadcast %s, dest %s.",
            inetAddressToString(node.addr, false).c_str(),
            node.validBcast ? inetAddressToString(node.mask, false).c_str() : "<none>",
            node.validBcast ? inetAddressToString(node.bcast, false).c_str() : "<none>",
            node.validP2P ? inetAddressToString(node.peer, false).c_str() : "<none>");
        try
        {
            // where to bind (listen) address
            osiSockAddr listenLocalAddress;
            memset(&listenLocalAddress, 0, sizeof(listenLocalAddress));
            listenLocalAddress.ia.sin_family = AF_INET;
            listenLocalAddress.ia.sin_port = htons(listenPort);
            listenLocalAddress.ia.sin_addr.s_addr = node.addr.ia.sin_addr.s_addr;

            BlockingUDPTransport::shared_pointer transport = connector.connect(
                        responseHandler, listenLocalAddress, protoVer);
            if (!transport)
                continue;
            listenLocalAddress = transport->getRemoteAddress();

            transport->setIgnoredAddresses(ignoreAddressVector);

            tappedNIF.push_back(listenLocalAddress);


            BlockingUDPTransport::shared_pointer transport2;

            if(!node.validBcast || node.bcast.sa.sa_family != AF_INET ||
                    node.bcast.ia.sin_addr.s_addr == listenLocalAddress.ia.sin_addr.s_addr) {
                // warning if not point-to-point
                LOG(node.bcast.sa.sa_family != AF_INET ? logLevelDebug : logLevelWarn,
                    "Unable to find broadcast address of interface %s.", inetAddressToString(node.addr, false).c_str());
            }
#if !defined(_WIN32)
            else
            {
                /* An oddness of BSD sockets (not winsock) is that binding to
                 * INADDR_ANY will receive unicast and broadcast, but binding to
                 * a specific interface address receives only unicast.  The trick
                 * is to bind a second socket to the interface broadcast address,
                 * which will then receive only broadcasts.
                 */

                osiSockAddr bcastAddress;
                memset(&bcastAddress, 0, sizeof(bcastAddress));
                bcastAddress.ia.sin_family = AF_INET;
                bcastAddress.ia.sin_port = htons(listenPort);
                bcastAddress.ia.sin_addr.s_addr = node.bcast.ia.sin_addr.s_addr;

                transport2 = connector.connect(responseHandler, bcastAddress, protoVer);
                if (transport2)
                {
                    /* The other wrinkle is that nothing should be sent from this second
                     * socket. So replies are made through the unicast socket.
                     *
                    transport2->setReplyTransport(transport);
                    */
                    // NOTE: search responses all always send from sendTransport

                    transport2->setIgnoredAddresses(ignoreAddressVector);

                    tappedNIF.push_back(bcastAddress);
                }
            }
#endif

            transport->setMutlicastNIF(loAddr, true);
            transport->setLocalMulticastAddress(group);

            transport->start();
            udpTransports.push_back(transport);

            if (transport2)
            {
                transport2->start();
                udpTransports.push_back(transport2);
            }
        }
        catch (std::exception& e)
        {
            THROW_BASE_EXCEPTION_CAUSE("Failed to initialize UDP transport.", e);
        }
        catch (...)
        {
            THROW_BASE_EXCEPTION("Failed to initialize UDP transport.");
        }
    }


    //
    // Setup local multicasting
    //

    // WIN32 do not allow binding to multicast address, use any address w/ port
#if defined(_WIN32)
    anyAddress.ia.sin_port = htons(listenPort);
#endif

    BlockingUDPTransport::shared_pointer localMulticastTransport;
    try
    {
        // NOTE: multicast receiver socket must be "bound" to INADDR_ANY or multicast address
        localMulticastTransport = connector.connect(
                                      responseHandler,
#if !defined(_WIN32)
                                      group,
#else
                                      anyAddress,
#endif
                                      protoVer);
        if (!localMulticastTransport)
            throw std::runtime_error("Failed to bind UDP socket.");

        localMulticastTransport->setTappedNIF(tappedNIF);
        localMulticastTransport->join(group, loAddr);
        localMulticastTransport->start();
        udpTransports.push_back(localMulticastTransport);

        LOG(logLevelDebug, "Local multicast enabled on %s/%s.",
            inetAddressToString(loAddr, false).c_str(),
            inetAddressToString(group).c_str());
    }
    catch (std::exception& ex)
    {
        LOG(logLevelDebug, "Failed to initialize local multicast, functionality disabled. Reason: %s.", ex.what());
    }
}

epicsShareFunc bool epics::pvAccess::isMulticastAddress

(

const osiSockAddr *

address

)

Check if an IPv4 address is a multicast address.

Parameters

address

IPv4 address to check.

Returns

true if the adress is a multicast address.

Definition at line 76 of file inetAddressUtil.cpp.

                                                    {
    uint32_t ipv4Addr = ntohl(address->ia.sin_addr.s_addr);
    uint8_t msB = (uint8_t)((ipv4Addr>>24)&0xFF);
    return msB >= 224 && msB <= 239;
}

epicsShareFunc std::ostream & epics::pvAccess::operator<<	(	std::ostream &	strm,
		const HexDump &	hex
	)

Definition at line 69 of file hexDump.cpp.

{
    const size_t len = std::min(hex.buflen, hex._limit);
    // find address width in hex chars
    // find bit width, rounded up to 8 bits, divide down to bytes
    const size_t addrwidth = bits2bytes(ilog2(len))*2u;
    size_t nlines = len/hex._perLine;

    if(len%hex._perLine)
        nlines++;

    for(size_t l=0; l<nlines; l++)
    {
        size_t start = l*hex._perLine;
        strm<<"0x"<<std::hex<<std::setw(addrwidth)<<std::setfill('0')<<start;

        // print hex chars
        for(size_t col=0; col<hex._perLine; col++)
        {
            if(col%hex._groupBy == 0) {
                strm<<' ';
            }
            if(start+col < len) {
                strm<<std::hex<<std::setw(2)<<std::setfill('0')<<unsigned(hex.buf[start+col]&0xff);
            } else {
                strm<<"  ";
            }
        }

        strm<<' ';

        // printable ascii
        for(size_t col=0; col<hex._perLine && start+col<len; col++)
        {
            if(col%hex._groupBy == 0) {
                strm<<' ';
            }
            char val = hex.buf[start+col]&0xff;
            if(val>=' ' && val<='~') {
                strm<<val;
            } else {
                strm<<'.';
            }
        }

        strm<<'\n';
    }

    return strm;
}

std::ostream & epics::pvAccess::operator<<	(	std::ostream &	o,
		const Version &	v
	)

Definition at line 69 of file pvaVersion.cpp.

                                                        {
    return o << v.getVersionString();
}

void epics::pvAccess::osdGetRoles	(	const std::string &	account,
		PeerInfo::roles_t &	roles
	)

Query OS specific DB for role/group names assocated with a user account.

Parameters

account	User name
roles	Role names are added to this set. Existing names are not removed.

Definition at line 51 of file getgroups.cpp.

{
    passwd *user = getpwnam(account.c_str());
    if(!user)
        return; // don't know who this is

    typedef std::set<gid_t> gids_t;
    gids_t gids;

    gids.insert(user->pw_gid); // include primary group

    /* List supplementary groups.
     *
     * Rant...
     * getgrouplist() differs subtly when the *count is too short.
     * Some libc (Mac) don't update the count
     * Some libc (glibc) don't write a truncated list.
     *
     * We might also use getgrent(), but this isn't reentrant, and
     * would anyway require visiting all groups.
     * The GNU alternative getgrent_r() would require us to allocate
     * enough space to hold the list of all members of the largest
     * group.  This may be hundreds.
     *
     * So we iterate with getgrouplist() as the lesser evil...
     */
    {
        // start with a guess
        std::vector<osi_gid_t> gtemp(16, (osi_gid_t)-1);

        while(true) {
            int gcount = int(gtemp.size());
            int ret = getgrouplist(user->pw_name, user->pw_gid, &gtemp[0], &gcount);

            if(ret>=0 && gcount>=0 && gcount <= int(gtemp.size())) {
                // success
                gtemp.resize(gcount);
                break;

            } else if(ret>=0) {
                // success, but invalid count?  give up
                gtemp.clear();
                break;

            } else if(gcount == int(gtemp.size())) {
                // too small, but gcount not updated.  (Mac)
                // arbitrary increase to size and retry
                gtemp.resize(gtemp.size()*2u, (osi_gid_t)-1);

            } else if(gcount > int(gtemp.size())) {
                // too small, gcount holds actual size.  retry
                gtemp.resize(gcount, (osi_gid_t)-1);

            } else {
                // too small, but gcount got smaller?  give up
                gtemp.clear();
                break;
            }
        }

        for(size_t i=0, N=gtemp.size(); i<N; i++)
            gids.insert(gtemp[i]);
    }

    // map GIDs to names
    for(gids_t::iterator it(gids.begin()), end(gids.end()); it!=end; it++) {
        group* gr = getgrgid(*it);
        if(!gr)
            continue;
        roles.insert(gr->gr_name);
    }
}

void epics::pvAccess::providerRegInit

(

void *

)

Definition at line 208 of file ChannelAccessFactory.cpp.

{
    epicsSignalInstallSigAlarmIgnore();
    epicsSignalInstallSigPipeIgnore();

    providerRegGbl = new providerRegGbl_t;
    providerRegGbl->clients->add("pva", createClientProvider);

    registerRefCounter("ServerContextImpl", &ServerContextImpl::num_instances);
    registerRefCounter("ServerChannel", &ServerChannel::num_instances);
    registerRefCounter("Transport (ABC)", &Transport::num_instances);
    registerRefCounter("BlockingTCPTransportCodec", &detail::BlockingTCPTransportCodec::num_instances);
    registerRefCounter("BlockingUDPTransport", &BlockingUDPTransport::num_instances);
    registerRefCounter("ChannelProvider (ABC)", &ChannelProvider::num_instances);
    registerRefCounter("Channel (ABC)", &Channel::num_instances);
    registerRefCounter("ChannelRequester (ABC)", &ChannelRequester::num_instances);
    registerRefCounter("ChannelBaseRequester (ABC)", &ChannelBaseRequester::num_instances);
    registerRefCounter("ChannelRequest (ABC)", &ChannelRequest::num_instances);
    registerRefCounter("ResponseHandler (ABC)", &ResponseHandler::num_instances);
    registerRefCounter("MonitorFIFO", &MonitorFIFO::num_instances);
    pvas::registerRefTrackServer();
    registerRefCounter("pvas::SharedChannel", &pvas::detail::SharedChannel::num_instances);
    registerRefCounter("pvas::SharedPut", &pvas::detail::SharedPut::num_instances);
    registerRefCounter("pvas::SharedRPC", &pvas::detail::SharedRPC::num_instances);
    registerRefCounter("pvas::SharedPV", &pvas::SharedPV::num_instances);
}

const std::string epics::pvAccess::PVACCESS_ALL_PROVIDERS

(

"<all>"

)

const std::string epics::pvAccess::PVACCESS_DEBUG

(

"EPICS_PVA_DEBUG"

)

const std::string epics::pvAccess::PVACCESS_DEFAULT_PROVIDER

(

"local"

)

epicsShareFunc bool epics::pvAccess::pvAccessIsLoggable

(

pvAccessLogLevel

level

)

Definition at line 64 of file logger.cpp.

{
    return level >= g_pvAccessLogLevel;
}

epicsShareFunc void epics::pvAccess::pvAccessLog	(	pvAccessLogLevel	level,
		const char *	format,
			...
	)

Definition at line 36 of file logger.cpp.

{
    // TODO lock
    if (level >= g_pvAccessLogLevel)
    {
        char timeText[TIMETEXTLEN];
        epicsTimeStamp tsNow;

        epicsTimeGetCurrent(&tsNow);
        epicsTimeToStrftime(timeText, TIMETEXTLEN, "%Y-%m-%dT%H:%M:%S.%03f", &tsNow);

        printf("%s ", timeText);

        va_list arg;
        va_start(arg, format);
        vprintf(format, arg);
        va_end(arg);

        printf("\n");
        fflush(stdout);    // needed for WIN32
    }
}

epicsShareFunc void epicsShareFunc void epics::pvAccess::pvAccessSetLogLevel

(

pvAccessLogLevel

level

)

Definition at line 59 of file logger.cpp.

{
    g_pvAccessLogLevel = level;
}

void epics::pvAccess::refTrackRegistrar

(

)

Definition at line 84 of file reftrackioc.cpp.

{
    epics::iocshRegister<int, &refshow>("refshow", "detail level");
    epics::iocshRegister<&refsave>("refsave");
    epics::iocshRegister<int, &refdiff>("refdiff", "detail level");
    epics::iocshRegister<double, int, &refmon>("refmon", "update period", "detail level");
}

ServerContext::shared_pointer epics::pvAccess::startPVAServer	(	std::string const &	providerNames = PVACCESS_ALL_PROVIDERS,
		int	timeToRun = 0,
		bool	runInSeparateThread = false,
		bool	printInfo = false
	)

Definition at line 544 of file serverContext.cpp.

{
    ServerContext::shared_pointer ret(ServerContext::create(ServerContext::Config()
                                 .config(ConfigurationBuilder()
                                         .add("EPICS_PVAS_PROVIDER_NAMES", providerNames)
                                         .push_map()
                                         .push_env() // environment takes precidence (top of stack)
                                         .build())));
    if(printInfo)
        ret->printInfo();

    if(!runInSeparateThread) {
        ret->run(timeToRun);
        ret->shutdown();
    } else if(timeToRun!=0) {
        LOG(logLevelWarn, "startPVAServer() timeToRun!=0 only supported when runInSeparateThread==false\n");
    }

    return ret;
}

Variable Documentation

Mutex epics::pvAccess::conf_factory_mutex

Definition at line 244 of file configuration.cpp.

ConfigurationProvider::shared_pointer epics::pvAccess::configurationProvider

Definition at line 243 of file configuration.cpp.

const epics::pvData::int8 PVA_VERSION epics::pvAccess::EPICS_DEPRECATED = 1

PVA protocol revision (implemented by this library).

PVA version signature used to report this implementation version in header.

Definition at line 35 of file pvaConstants.h.

const epics::pvData::int16 epics::pvAccess::INVALID_DATA_TYPE = 0xFFFF

Invalid data type.

Definition at line 76 of file pvaConstants.h.

const epics::pvData::int32 epics::pvAccess::INVALID_IOID = 0

Invalid IOID.

Definition at line 79 of file pvaConstants.h.

const epics::pvData::uint32 epics::pvAccess::MAX_CHANNEL_NAME_LENGTH = 500

Unreasonable channel name length.

Definition at line 73 of file pvaConstants.h.

const epics::pvData::int32 epics::pvAccess::MAX_SEARCH_BATCH_COUNT = 0x7FFF

Maximum number of search requests in one search message.

Definition at line 67 of file pvaConstants.h.

const epics::pvData::int32 epics::pvAccess::MAX_TCP_RECV = 1024*16

TCP maximum receive message size.

Definition at line 64 of file pvaConstants.h.

const epics::pvData::int32 epics::pvAccess::MAX_UDP_RECV = 65487

UDP maximum receive message size. MAX_UDP: 65535 (max UDP packet size) - 20/40(IPv4/IPv6) - 8(UDP)

Definition at line 61 of file pvaConstants.h.

const epics::pvData::int32 epics::pvAccess::MAX_UDP_UNFRAGMENTED_SEND = 1440

UDP maximum send message size. MAX_UDP: 1500 (max of ethernet and 802.{2,3} MTU) - 20/40(IPv4/IPv6)

• 8(UDP) - some reserve (the MTU of Ethernet is currently independent of its speed variant)

Definition at line 55 of file pvaConstants.h.

const epics::pvData::int32 epics::pvAccess::PVA_BROADCAST_PORT = 5076

Default PVA beacon port.

Definition at line 44 of file pvaConstants.h.

const epics::pvData::int8 epics::pvAccess::PVA_CLIENT_PROTOCOL_REVISION = 2

Definition at line 32 of file pvaConstants.h.

const epics::pvData::int16 epics::pvAccess::PVA_DEFAULT_PRIORITY = 0

Default priority (corresponds to POSIX SCHED_OTHER)

Definition at line 70 of file pvaConstants.h.

const epics::pvData::int8 epics::pvAccess::PVA_MAGIC = static_cast<epics::pvData::int8>(0xCA)

PVA protocol magic number

Definition at line 29 of file pvaConstants.h.

const epics::pvData::int16 epics::pvAccess::PVA_MESSAGE_HEADER_SIZE = 8

PVA protocol message header size.

Definition at line 47 of file pvaConstants.h.

const epics::pvData::int32 epics::pvAccess::PVA_SERVER_PORT = 5075

Default PVA server port.

Definition at line 41 of file pvaConstants.h.

const epics::pvData::int8 epics::pvAccess::PVA_SERVER_PROTOCOL_REVISION = 2

Definition at line 31 of file pvaConstants.h.

epicsShareExtern const std::string epics::pvAccess::PVACCESS_ALL_PROVIDERS

"All-providers registered" PVA provider name.

Definition at line 85 of file pvaConstants.h.

epicsShareExtern const std::string epics::pvAccess::PVACCESS_DEBUG

Name of the system env. variable to turn on debugging.

Definition at line 88 of file pvaConstants.h.

epicsShareExtern const std::string epics::pvAccess::PVACCESS_DEFAULT_PROVIDER

Default PVA provider name.

Definition at line 82 of file pvaConstants.h.