#include "cac.h"

Inheritance diagram for cac:

Collaboration diagram for cac:

Public Member Functions
	cac (epicsMutex &mutualExclusion, epicsMutex &callbackControl, cacContextNotify &)

virtual	~cac ()

void	beaconNotify (const inetAddrID &addr, const epicsTime &currentTime, ca_uint32_t beaconNumber, unsigned protocolRevision)

unsigned	beaconAnomaliesSinceProgramStart (epicsGuard< epicsMutex > &) const

void	flush (epicsGuard< epicsMutex > &guard)

bool	executeResponse (callbackManager &, tcpiiu &, const epicsTime &currentTime, caHdrLargeArray &, char *pMsgBody)

void	transferChanToVirtCircuit (unsigned cid, unsigned sid, ca_uint16_t typeCode, arrayElementCount count, unsigned minorVersionNumber, const osiSockAddr &, const epicsTime &currentTime)

cacChannel &	createChannel (epicsGuard< epicsMutex > &guard, const char *pChannelName, cacChannelNotify &, cacChannel::priLev)

void	destroyChannel (epicsGuard< epicsMutex > &, nciu &)

void	initiateConnect (epicsGuard< epicsMutex > &, nciu &, netiiu *&)

nciu *	lookupChannel (epicsGuard< epicsMutex > &, const cacChannel::ioid &)

netWriteNotifyIO &	writeNotifyRequest (epicsGuard< epicsMutex > &, nciu &, privateInterfaceForIO &, unsigned type, arrayElementCount nElem, const void *pValue, cacWriteNotify &)

netReadNotifyIO &	readNotifyRequest (epicsGuard< epicsMutex > &, nciu &, privateInterfaceForIO &, unsigned type, arrayElementCount nElem, cacReadNotify &)

netSubscription &	subscriptionRequest (epicsGuard< epicsMutex > &, nciu &, privateInterfaceForIO &, unsigned type, arrayElementCount nElem, unsigned mask, cacStateNotify &, bool channelIsInstalled)

bool	destroyIO (CallbackGuard &callbackGuard, epicsGuard< epicsMutex > &mutualExclusionGuard, const cacChannel::ioid &idIn, nciu &chan)

void	disconnectAllIO (epicsGuard< epicsMutex > &cbGuard, epicsGuard< epicsMutex > &guard, nciu &, tsDLList< baseNMIU > &ioList)

void	ioShow (epicsGuard< epicsMutex > &guard, const cacChannel::ioid &id, unsigned level) const

void	registerSearchDest (epicsGuard< epicsMutex > &, SearchDest &req)

bool	findOrCreateVirtCircuit (epicsGuard< epicsMutex > &, const osiSockAddr &, unsigned, tcpiiu &, unsigned, SearchDestTCP pSearchDest=NULL)

unsigned	circuitCount (epicsGuard< epicsMutex > &) const

void	show (epicsGuard< epicsMutex > &, unsigned level) const

int	printFormated (epicsGuard< epicsMutex > &callbackControl, const char *pformat,...) const

int	varArgsPrintFormated (epicsGuard< epicsMutex > &callbackControl, const char *pformat, va_list args) const

double	connectionTimeout (epicsGuard< epicsMutex > &)

unsigned	maxContiguousFrames (epicsGuard< epicsMutex > &) const

const char *	userNamePointer () const

unsigned	getInitializingThreadsPriority () const

epicsMutex &	mutexRef ()

void	attachToClientCtx ()

void	selfTest (epicsGuard< epicsMutex > &) const

double	beaconPeriod (epicsGuard< epicsMutex > &, const nciu &chan) const

void	destroyIIU (tcpiiu &iiu)

const char *	pLocalHostName ()

Public Member Functions inherited from cacContext
virtual	~cacContext ()

Static Public Member Functions
static unsigned	lowestPriorityLevelAbove (unsigned priority)

static unsigned	highestPriorityLevelBelow (unsigned priority)

Public Attributes
void exception epicsGuard< epicsMutex > &	cbGuard

void exception epicsGuard< epicsMutex > epicsGuard< epicsMutex > &	guard

void exception epicsGuard< epicsMutex > epicsGuard< epicsMutex > int	status

void exception epicsGuard< epicsMutex > epicsGuard< epicsMutex > int const char *	pContext

void exception epicsGuard< epicsMutex > epicsGuard< epicsMutex > int const char const char *	pFileName

void exception epicsGuard< epicsMutex > epicsGuard< epicsMutex > int const char const char unsigned	lineNo

Friends
class	tcpiiu

Detailed Description

Definition at line 97 of file cac.h.

Constructor & Destructor Documentation

cac::cac	(	epicsMutex &	mutualExclusion,
		epicsMutex &	callbackControl,
		cacContextNotify &	notifyIn
	)

Definition at line 127 of file cac.cpp.

                                   :
     _refLocalHostName ( localHostNameCache.getReference () ),
     programBeginTime ( epicsTime::getCurrent() ),
     connTMO ( CA_CONN_VERIFY_PERIOD ),
     mutex ( mutualExclusionIn ),
     cbMutex ( callbackControlIn ),
     ipToAEngine ( ipAddrToAsciiEngine::allocate () ),
     timerQueue ( epicsTimerQueueActive::allocate ( false,
         lowestPriorityLevelAbove(epicsThreadGetPrioritySelf()) ) ),
     pUserName ( 0 ),
     pudpiiu ( 0 ),
     tcpSmallRecvBufFreeList ( 0 ),
     tcpLargeRecvBufFreeList ( 0 ),
     notify ( notifyIn ),
     initializingThreadsId ( epicsThreadGetIdSelf() ),
     initializingThreadsPriority ( epicsThreadGetPrioritySelf() ),
     maxRecvBytesTCP ( MAX_TCP ),
     maxContigFrames ( contiguousMsgCountWhichTriggersFlowControl ),
     beaconAnomalyCount ( 0u ),
     iiuExistenceCount ( 0u ),
     cacShutdownInProgress ( false )
 {
     if ( ! osiSockAttach () ) {
         throwWithLocation ( udpiiu :: noSocket () );
     }
 
     try {
         long status;
 
         /*
          * Certain os, such as HPUX, do not unblock a socket system call
          * when another thread asynchronously calls both shutdown() and
          * close(). To solve this problem we need to employ OS specific
          * mechanisms.
          */
         epicsSignalInstallSigAlarmIgnore ();
         epicsSignalInstallSigPipeIgnore ();
 
         {
             char tmp[256];
             size_t len;
             osiGetUserNameReturn gunRet;
 
             gunRet = osiGetUserName ( tmp, sizeof (tmp) );
             if ( gunRet != osiGetUserNameSuccess ) {
                 tmp[0] = '\0';
             }
             len = strlen ( tmp ) + 1;
             this->pUserName = new char [ len ];
             strncpy ( this->pUserName, tmp, len );
         }
 
         this->_serverPort =
             envGetInetPortConfigParam ( &EPICS_CA_SERVER_PORT,
                                         static_cast <unsigned short> (CA_SERVER_PORT) );
 
         status = envGetDoubleConfigParam ( &EPICS_CA_CONN_TMO, &this->connTMO );
         if ( status ) {
             this->connTMO = CA_CONN_VERIFY_PERIOD;
             epicsGuard < epicsMutex > cbGuard ( this->cbMutex );
             errlogPrintf ( "EPICS \"%s\" double fetch failed\n", EPICS_CA_CONN_TMO.name );
             errlogPrintf ( "Defaulting \"%s\" = %f\n", EPICS_CA_CONN_TMO.name, this->connTMO );
         }
 
         long maxBytesAsALong;
         status =  envGetLongConfigParam ( &EPICS_CA_MAX_ARRAY_BYTES, &maxBytesAsALong );
         if ( status || maxBytesAsALong < 0 ) {
             errlogPrintf ( "cac: EPICS_CA_MAX_ARRAY_BYTES was not a positive integer\n" );
         }
         else {
             /* allow room for the protocol header so that they get the array size they requested */
             static const unsigned headerSize = sizeof ( caHdr ) + 2 * sizeof ( ca_uint32_t );
             ca_uint32_t maxBytes = ( unsigned ) maxBytesAsALong;
             if ( maxBytes < 0xffffffff - headerSize ) {
                 maxBytes += headerSize;
             }
             else {
                 maxBytes = 0xffffffff;
             }
             if ( maxBytes < MAX_TCP ) {
                 errlogPrintf ( "cac: EPICS_CA_MAX_ARRAY_BYTES was rounded up to %u\n", MAX_TCP );
             }
             else {
                 this->maxRecvBytesTCP = maxBytes;
             }
         }
         freeListInitPvt ( &this->tcpSmallRecvBufFreeList, MAX_TCP, 1 );
         if ( ! this->tcpSmallRecvBufFreeList ) {
             throw std::bad_alloc ();
         }
 
         int autoMaxBytes;
         if(envGetBoolConfigParam(&EPICS_CA_AUTO_ARRAY_BYTES, &autoMaxBytes))
             autoMaxBytes = 1;
 
         if(!autoMaxBytes) {
             freeListInitPvt ( &this->tcpLargeRecvBufFreeList, this->maxRecvBytesTCP, 1 );
             if ( ! this->tcpLargeRecvBufFreeList ) {
                 throw std::bad_alloc ();
             }
         }
         unsigned bufsPerArray = this->maxRecvBytesTCP / comBuf::capacityBytes ();
         if ( bufsPerArray > 1u ) {
             maxContigFrames = bufsPerArray *
                 contiguousMsgCountWhichTriggersFlowControl;
         }
     }
     catch ( ... ) {
         osiSockRelease ();
         delete [] this->pUserName;
         freeListCleanup ( this->tcpSmallRecvBufFreeList );
         if ( this->tcpLargeRecvBufFreeList ) {
             freeListCleanup ( this->tcpLargeRecvBufFreeList );
         }
         this->timerQueue.release ();
         throw;
     }
 
     /*
      * load user configured tcp name server address list,
      * create virtual circuits, and add them to server table
      */
     ELLLIST dest, tmpList;
 
     ellInit ( & dest );
     ellInit ( & tmpList );
 
     addAddrToChannelAccessAddressList ( &tmpList, &EPICS_CA_NAME_SERVERS, this->_serverPort, false );
     removeDuplicateAddresses ( &dest, &tmpList, 0 );
 
     epicsGuard < epicsMutex > guard ( this->mutex );
 
     while ( osiSockAddrNode *
         pNode = reinterpret_cast < osiSockAddrNode * > ( ellGet ( & dest ) ) ) {
         tcpiiu * piiu = NULL;
         SearchDestTCP * pdst = new SearchDestTCP ( *this, pNode->addr );
         this->registerSearchDest ( guard, * pdst );
         /* Initially assume that servers listed in EPICS_CA_NAME_SERVERS support at least minor
          * version 11.  This causes tcpiiu to send the user and host name authentication
          * messages.  When the actual Version message is received from the server it will
          * be overwrite this assumption.
          */
         bool newIIU = findOrCreateVirtCircuit (
             guard, pNode->addr, cacChannel::priorityDefault,
             piiu, 11, pdst );
         free ( pNode );
         if ( newIIU ) {
             piiu->start ( guard );
         }
     }
 }

cac::~cac ( )

virtual

Definition at line 282 of file cac.cpp.

 {
     // this blocks until the UDP thread exits so that
     // it will not sneak in any new clients
     //
     // lock intentionally not held here so that we dont deadlock
     // waiting for the UDP thread to exit while it is waiting to
     // get the lock.
     {
         epicsGuard < epicsMutex > cbGuard ( this->cbMutex );
         epicsGuard < epicsMutex > guard ( this->mutex );
         if ( this->pudpiiu ) {
             this->pudpiiu->shutdown ( cbGuard, guard );
 
             // make sure no new tcp circuits are created
             this->cacShutdownInProgress = true;
 
             //
             // shutdown all tcp circuits
             //
             tsDLIter < tcpiiu > iter = this->circuitList.firstIter ();
             while ( iter.valid() ) {
                 // this causes a clean shutdown to occur
                 iter->unlinkAllChannels ( cbGuard, guard );
                 iter++;
             }
         }
     }
 
     //
     // wait for all tcp threads to exit
     //
     // this will block for oustanding sends to go out so dont
     // hold a lock while waiting
     //
     {
         epicsGuard < epicsMutex > guard ( this->mutex );
         while ( this->iiuExistenceCount > 0 ) {
             epicsGuardRelease < epicsMutex > unguard ( guard );
             this->iiuUninstall.wait ();
         }
     }
 
     if ( this->pudpiiu ) {
         delete this->pudpiiu;
     }
 
     freeListCleanup ( this->tcpSmallRecvBufFreeList );
     if ( this->tcpLargeRecvBufFreeList ) {
         freeListCleanup ( this->tcpLargeRecvBufFreeList );
     }
 
     delete [] this->pUserName;
 
     tsSLList < bhe > tmpBeaconList;
     this->beaconTable.removeAll ( tmpBeaconList );
     while ( bhe * pBHE = tmpBeaconList.get() ) {
         pBHE->~bhe ();
         this->bheFreeList.release ( pBHE );
     }
 
     this->timerQueue.release ();
 
     this->ipToAEngine.release ();
 
     // clean-up the list of un-notified msg objects
     while ( msgForMultiplyDefinedPV * msg = this->msgMultiPVList.get() ) {
         msg->~msgForMultiplyDefinedPV ();
         this->mdpvFreeList.release ( msg );
     }
 
     errlogFlush ();
 
     osiSockRelease ();
 
     // its ok for channels and subscriptions to still
     // exist at this point. The user created them and
     // its his responsibility to clean them up.
 }

Member Function Documentation

void cac::attachToClientCtx ( )

inline

Definition at line 371 of file cac.h.

 {
     this->notify.attachToClientCtx ();
 }

unsigned cac::beaconAnomaliesSinceProgramStart ( epicsGuard< epicsMutex > & guard ) const

inlinevirtual

Implements cacContext.

Definition at line 376 of file cac.h.

 {
     guard.assertIdenticalMutex ( this->mutex );
     return this->beaconAnomalyCount;
 }

void cac::beaconNotify	(	const inetAddrID &	addr,
		const epicsTime &	currentTime,
		ca_uint32_t	beaconNumber,
		unsigned	protocolRevision
	)

Definition at line 454 of file cac.cpp.

 {
     epicsGuard < epicsMutex > guard ( this->mutex );
 
     if ( ! this->pudpiiu ) {
         return;
     }
 
     /*
      * look for it in the hash table
      */
     bhe *pBHE = this->beaconTable.lookup ( addr );
     if ( pBHE ) {
         /*
          * return if the beacon period has not changed significantly
          */
         if ( ! pBHE->updatePeriod ( guard, this->programBeginTime,
                 currentTime, beaconNumber, protocolRevision ) ) {
             return;
         }
     }
     else {
         /*
          * This is the first beacon seen from this server.
          * Wait until 2nd beacon is seen before deciding
          * if it is a new server (or just the first
          * time that we have seen a server's beacon
          * shortly after the program started up)
          */
         pBHE = new ( this->bheFreeList )
                 bhe ( this->mutex, currentTime, beaconNumber, addr );
         if ( pBHE ) {
             if ( this->beaconTable.add ( *pBHE ) < 0 ) {
                 pBHE->~bhe ();
                 this->bheFreeList.release ( pBHE );
             }
         }
         return;
     }
 
     this->beaconAnomalyCount++;
 
     this->pudpiiu->beaconAnomalyNotify ( guard );
 
 #   ifdef DEBUG
     {
         char buf[128];
         addr.name ( buf, sizeof ( buf ) );
         ::printf ( "New server available: %s\n", buf );
     }
 #   endif
 }

double cac::beaconPeriod	(	epicsGuard< epicsMutex > &	guard,
		const nciu &	chan
	)		const

Definition at line 1273 of file cac.cpp.

 {
     const netiiu * pIIU = chan.getConstPIIU ( guard );
     if ( pIIU ) {
         osiSockAddr addr = pIIU->getNetworkAddress ( guard );
         if ( addr.sa.sa_family == AF_INET ) {
             inetAddrID tmp ( addr.ia );
             bhe *pBHE = this->beaconTable.lookup ( tmp );
             if ( pBHE ) {
                 return pBHE->period ( guard );
             }
         }
     }
     return - DBL_MAX;
 }

unsigned cac::circuitCount ( epicsGuard< epicsMutex > & guard ) const

virtual

Implements cacContext.

Definition at line 399 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     return this->circuitList.count ();
 }

double cac::connectionTimeout ( epicsGuard< epicsMutex > & guard )

inline

Definition at line 420 of file cac.h.

 {
     guard.assertIdenticalMutex ( this->mutex );
     return this->connTMO;
 }

cacChannel & cac::createChannel	(	epicsGuard< epicsMutex > &	guard,
		const char *	pChannelName,
		cacChannelNotify &	chan,
		cacChannel::priLev	pri
	)

virtual

Implements cacContext.

Definition at line 508 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     if ( pri > cacChannel::priorityMax ) {
         throw cacChannel::badPriority ();
     }
 
     if ( pName == 0 || pName[0] == '\0' ) {
         throw cacChannel::badString ();
     }
 
     if ( ! this->pudpiiu ) {
         this->pudpiiu = new udpiiu (
             guard, this->timerQueue, this->cbMutex,
             this->mutex, this->notify, *this, this->_serverPort,
             this->searchDestList );
     }
 
     nciu * pNetChan = new ( this->channelFreeList )
             nciu ( *this, noopIIU, chan, pName, pri );
     this->chanTable.idAssignAdd ( *pNetChan );
     return *pNetChan;
 }

void cac::destroyChannel	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan
	)

Definition at line 659 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     // uninstall channel so that recv threads
     // will not start a new callback for this channel's IO.
     if ( this->chanTable.remove ( chan ) != & chan ) {
         throw std::logic_error ( "Invalid channel identifier" );
     }
     chan.~nciu ();
     this->channelFreeList.release ( & chan );
 }

void cac::destroyIIU ( tcpiiu & iiu )

Definition at line 1227 of file cac.cpp.

 {
     {
         callbackManager mgr ( this->notify, this->cbMutex );
         epicsGuard < epicsMutex > guard ( this->mutex );
 
         if ( iiu.channelCount ( guard ) ) {
             char hostNameTmp[64];
             iiu.getHostName ( guard, hostNameTmp, sizeof ( hostNameTmp ) );
             genLocalExcep ( mgr.cbGuard, guard, *this, ECA_DISCONN, hostNameTmp );
         }
         osiSockAddr addr = iiu.getNetworkAddress ( guard );
         if ( addr.sa.sa_family == AF_INET ) {
             inetAddrID tmp ( addr.ia );
             bhe * pBHE = this->beaconTable.lookup ( tmp );
             if ( pBHE ) {
                 pBHE->unregisterIIU ( guard, iiu );
             }
         }
 
         assert ( this->pudpiiu );
         iiu.disconnectAllChannels ( mgr.cbGuard, guard, *this->pudpiiu );
 
         this->serverTable.remove ( iiu );
         this->circuitList.remove ( iiu );
     }
 
     // this destroys a timer that takes the primary mutex
     // so we must not hold the primary mutex here
     //
     // this waits for send/recv threads to exit
     // this also uses the cac free lists so cac must wait
     // for this to finish before it shuts down
 
     iiu.~tcpiiu ();
 
     {
         epicsGuard < epicsMutex > guard ( this->mutex );
         this->freeListVirtualCircuit.release ( & iiu );
         this->iiuExistenceCount--;
         // signal iiu uninstall event so that cac can properly shut down
         this->iiuUninstall.signal();
     }
     // do not touch "this" after lock is released above
 }

bool cac::destroyIO	(	CallbackGuard &	callbackGuard,
		epicsGuard< epicsMutex > &	mutualExclusionGuard,
		const cacChannel::ioid &	idIn,
		nciu &	chan
	)

Definition at line 734 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     baseNMIU * pIO = this->ioTable.remove ( idIn );
     if ( pIO ) {
         class netSubscription * pSubscr = pIO->isSubscription ();
         if ( pSubscr ) {
             pSubscr->unsubscribeIfRequired ( guard, chan );
         }
 
         // this uninstalls from the list and destroys the IO
         pIO->exception ( guard, *this,
             ECA_CHANDESTROY, chan.pName ( guard ) );
         return true;
     }
     return false;
 }

void cac::disconnectAllIO	(	epicsGuard< epicsMutex > &	cbGuard,
		epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		tsDLList< baseNMIU > &	ioList
	)

Definition at line 674 of file cac.cpp.

 {
     cbGuard.assertIdenticalMutex ( this->cbMutex );
     guard.assertIdenticalMutex ( this->mutex );
     char buf[128];
     chan.getHostName ( guard, buf, sizeof ( buf ) );
 
     tsDLIter < baseNMIU > pNetIO = ioList.firstIter();
     while ( pNetIO.valid () ) {
         tsDLIter < baseNMIU > pNext = pNetIO;
         pNext++;
         if ( ! pNetIO->isSubscription() ) {
             this->ioTable.remove ( pNetIO->getId () );
         }
         pNetIO->exception ( guard, *this, ECA_DISCONN, buf );
         pNetIO = pNext;
     }
 }

bool cac::executeResponse	(	callbackManager &	mgr,
		tcpiiu &	iiu,
		const epicsTime &	currentTime,
		caHdrLargeArray &	hdr,
		char *	pMsgBody
	)

Definition at line 1204 of file cac.cpp.

 {
     // execute the response message
     pProtoStubTCP pStub;
     if ( hdr.m_cmmd >= NELEMENTS ( cac::tcpJumpTableCAC ) ) {
         pStub = &cac::badTCPRespAction;
     }
     else {
         pStub = cac::tcpJumpTableCAC [hdr.m_cmmd];
     }
     return ( this->*pStub ) ( mgr, iiu, currentTime, hdr, pMshBody );
 }

bool cac::findOrCreateVirtCircuit	(	epicsGuard< epicsMutex > &	guard,
		const osiSockAddr &	addr,
		unsigned	priority,
		tcpiiu *&	piiu,
		unsigned	minorVersionNumber,
		SearchDestTCP *	pSearchDest = `NULL`
	)

Definition at line 535 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     bool newIIU = false;
 
     if ( piiu ) {
         if ( ! piiu->alive ( guard ) ) {
             return newIIU;
         }
     }
     else {
         try {
             autoPtrFreeList < tcpiiu, 32, epicsMutexNOOP > pnewiiu (
                     this->freeListVirtualCircuit,
                     new ( this->freeListVirtualCircuit ) tcpiiu (
                         *this, this->mutex, this->cbMutex, this->notify, this->connTMO,
                         this->timerQueue, addr, this->comBufMemMgr, minorVersionNumber,
                         this->ipToAEngine, priority, pSearchDest ) );
 
             bhe * pBHE = this->beaconTable.lookup ( addr.ia );
             if ( ! pBHE ) {
                 pBHE = new ( this->bheFreeList )
                                     bhe ( this->mutex, epicsTime (), 0u, addr.ia );
                 if ( this->beaconTable.add ( *pBHE ) < 0 ) {
                     return newIIU;
                 }
             }
             this->serverTable.add ( *pnewiiu );
             this->circuitList.add ( *pnewiiu );
             this->iiuExistenceCount++;
             pBHE->registerIIU ( guard, *pnewiiu );
             piiu = pnewiiu.release ();
             newIIU = true;
         }
         catch ( std :: exception & except ) {
             errlogPrintf (
                 "CAC: exception during virtual circuit creation \"%s\"\n",
                 except.what () );
             return newIIU;
         }
         catch ( ... ) {
             errlogPrintf (
                 "CAC: Nonstandard exception during virtual circuit creation\n" );
             return newIIU;
         }
     }
     return newIIU;
 }

void cac::flush ( epicsGuard< epicsMutex > & guard )

virtual

Implements cacContext.

Definition at line 389 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     tsDLIter < tcpiiu > iter = this->circuitList.firstIter ();
     while ( iter.valid () ) {
         iter->flushRequest ( guard );
         iter++;
     }
 }

unsigned cac::getInitializingThreadsPriority ( ) const

inline

Definition at line 353 of file cac.h.

 {
     return this->initializingThreadsPriority;
 }

unsigned cac::highestPriorityLevelBelow ( unsigned priority )

static

Definition at line 374 of file cac.cpp.

 {
     unsigned belowPriority;
     epicsThreadBooleanStatus tbs;
     tbs = epicsThreadHighestPriorityLevelBelow (
         priority, & belowPriority );
     if ( tbs != epicsThreadBooleanStatusSuccess ) {
         belowPriority = priority;
     }
     return belowPriority;
 }

void cac::initiateConnect	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		netiiu *&	piiu
	)

Definition at line 1291 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     assert ( this->pudpiiu );
     this->pudpiiu->installNewChannel ( guard, chan, piiu );
 }

void cac::ioShow	(	epicsGuard< epicsMutex > &	guard,
		const cacChannel::ioid &	id,
		unsigned	level
	)		const

Definition at line 756 of file cac.cpp.

 {
     baseNMIU * pmiu = this->ioTable.lookup ( idIn );
     if ( pmiu ) {
         pmiu->show ( guard, level );
     }
 }

nciu * cac::lookupChannel	(	epicsGuard< epicsMutex > &	guard,
		const cacChannel::ioid &	idIn
	)

inline

Definition at line 400 of file cac.h.

 {
     guard.assertIdenticalMutex ( this->mutex );
     return this->chanTable.lookup ( idIn );
 }

unsigned cac::lowestPriorityLevelAbove ( unsigned priority )

static

Definition at line 362 of file cac.cpp.

 {
     unsigned abovePriority;
     epicsThreadBooleanStatus tbs;
     tbs = epicsThreadLowestPriorityLevelAbove (
         priority, & abovePriority );
     if ( tbs != epicsThreadBooleanStatusSuccess ) {
         abovePriority = priority;
     }
     return abovePriority;
 }

unsigned cac::maxContiguousFrames ( epicsGuard< epicsMutex > & ) const

inline

Definition at line 414 of file cac.h.

 {
     return maxContigFrames;
 }

epicsMutex & cac::mutexRef ( )

inline

Definition at line 358 of file cac.h.

 {
     return this->mutex;
 }

const char * cac::pLocalHostName ( )

inline

Definition at line 408 of file cac.h.

 {
     return _refLocalHostName->pointer ();
 }

int cac::printFormated	(	epicsGuard< epicsMutex > &	callbackControl,
		const char *	pformat,
			...
	)		const

Definition at line 696 of file cac.cpp.

 {
     va_list theArgs;
     va_start ( theArgs, pformat );
     int status = this->varArgsPrintFormated ( callbackControl, pformat, theArgs );
     va_end ( theArgs );
     return status;
 }

netReadNotifyIO & cac::readNotifyRequest	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		privateInterfaceForIO &	icni,
		unsigned	type,
		arrayElementCount	nElem,
		cacReadNotify &	notifyIn
	)

Definition at line 721 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     autoPtrRecycle  < netReadNotifyIO > pIO (
         guard, this->ioTable, *this,
         netReadNotifyIO::factory ( this->freeListReadNotifyIO, icni, notifyIn ) );
     this->ioTable.idAssignAdd ( *pIO );
     chan.getPIIU(guard)->readNotifyRequest ( guard, chan, *pIO, type, nElem );
     return *pIO.release();
 }

void cac::registerSearchDest	(	epicsGuard< epicsMutex > &	guard,
		SearchDest &	req
	)

Definition at line 1329 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     this->searchDestList.add ( req );
 }

void cac::selfTest ( epicsGuard< epicsMutex > & guard ) const

virtual

Implements cacContext.

Definition at line 1218 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     this->chanTable.verify ();
     this->ioTable.verify ();
     this->beaconTable.verify ();
 }

void cac::show	(	epicsGuard< epicsMutex > &	guard,
		unsigned	level
	)		const

virtual

Implements cacContext.

Definition at line 406 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     ::printf ( "Channel Access Client Context at %p for user %s\n",
         static_cast <const void *> ( this ), this->pUserName );
     // this also supresses the "defined, but not used"
     // warning message
     ::printf ( "\trevision \"%s\"\n", pVersionCAC );
 
     if ( level > 0u ) {
         this->serverTable.show ( level - 1u );
         ::printf ( "\tconnection time out watchdog period %f\n", this->connTMO );
     }
 
     if ( level > 1u ) {
         if ( this->pudpiiu ) {
             this->pudpiiu->show ( level - 2u );
         }
     }
 
     if ( level > 2u ) {
         ::printf ( "Program begin time:\n");
         this->programBeginTime.show ( level - 3u );
         ::printf ( "Channel identifier hash table:\n" );
         this->chanTable.show ( level - 3u );
         ::printf ( "IO identifier hash table:\n" );
         this->ioTable.show ( level - 3u );
         ::printf ( "Beacon source identifier hash table:\n" );
         this->beaconTable.show ( level - 3u );
         ::printf ( "Timer queue:\n" );
         this->timerQueue.show ( level - 3u );
         ::printf ( "IP address to name conversion engine:\n" );
         this->ipToAEngine.show ( level - 3u );
     }
 
     if ( level > 3u ) {
         ::printf ( "Default mutex:\n");
         this->mutex.show ( level - 4u );
         ::printf ( "mutex:\n" );
         this->mutex.show ( level - 4u );
     }
 }

netSubscription & cac::subscriptionRequest	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		privateInterfaceForIO &	privChan,
		unsigned	type,
		arrayElementCount	nElem,
		unsigned	mask,
		cacStateNotify &	notifyIn,
		bool	channelIsInstalled
	)

Definition at line 809 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     autoPtrRecycle  < netSubscription > pIO (
         guard, this->ioTable, *this,
         netSubscription::factory ( this->freeListSubscription,
                                    privChan, type, nElem, mask, notifyIn ) );
     this->ioTable.idAssignAdd ( *pIO );
     if ( chanIsInstalled ) {
         pIO->subscribeIfRequired ( guard, chan );
     }
     return *pIO.release ();
 }

void cac::transferChanToVirtCircuit	(	unsigned	cid,
		unsigned	sid,
		ca_uint16_t	typeCode,
		arrayElementCount	count,
		unsigned	minorVersionNumber,
		const osiSockAddr &	addr,
		const epicsTime &	currentTime
	)

Definition at line 587 of file cac.cpp.

 {
     if ( addr.sa.sa_family != AF_INET ) {
         return;
     }
 
     epicsGuard < epicsMutex > guard ( this->mutex );
 
     /*
      * Do not open new circuits while the cac is shutting down
      */
     if ( this->cacShutdownInProgress ) {
         return;
     }
 
     /*
      * ignore search replies for deleted channels
      */
     nciu * pChan = this->chanTable.lookup ( cid );
     if ( ! pChan ) {
         return;
     }
 
     /*
      * Ignore duplicate search replies
      */
     osiSockAddr chanAddr = pChan->getPIIU(guard)->getNetworkAddress (guard);
 
     if ( chanAddr.sa.sa_family != AF_UNSPEC ) {
         if ( ! sockAddrAreIdentical ( &addr, &chanAddr ) ) {
             char acc[64];
             pChan->getPIIU(guard)->getHostName ( guard, acc, sizeof ( acc ) );
             msgForMultiplyDefinedPV * pMsg = new ( this->mdpvFreeList )
                 msgForMultiplyDefinedPV ( this->ipToAEngine,
                     *this, pChan->pName ( guard ), acc );
             // cac keeps a list of these objects for proper clean-up in ~cac
             this->msgMultiPVList.add ( *pMsg );
             // It is possible for the ioInitiate call below to
             // call the callback directly if queue quota is exceeded.
             // This callback takes the callback lock and therefore we
             // must release the primary mutex here to avoid a lock
             // hierarchy inversion.
             epicsGuardRelease < epicsMutex > unguard ( guard );
             pMsg->ioInitiate ( addr );
         }
         return;
     }
 
     caServerID servID ( addr.ia, pChan->getPriority(guard) );
     tcpiiu * piiu = this->serverTable.lookup ( servID );
 
     bool newIIU = findOrCreateVirtCircuit (
         guard, addr,
         pChan->getPriority(guard), piiu, minorVersionNumber );
 
     // must occur before moving to new iiu
     pChan->getPIIU(guard)->uninstallChanDueToSuccessfulSearchResponse (
         guard, *pChan, currentTime );
     if ( piiu ) {
         piiu->installChannel (
             guard, *pChan, sid, typeCode, count );
 
         if ( newIIU ) {
             piiu->start ( guard );
         }
     }
 }

const char * cac::userNamePointer ( ) const

inline

Definition at line 348 of file cac.h.

 {
     return this->pUserName;
 }

int cac::varArgsPrintFormated	(	epicsGuard< epicsMutex > &	callbackControl,
		const char *	pformat,
		va_list	args
	)		const

inline

Definition at line 363 of file cac.h.

 {
     callbackControl.assertIdenticalMutex ( this->cbMutex );
     return this->notify.varArgsPrintFormated ( pformat, args );
 }

netWriteNotifyIO & cac::writeNotifyRequest	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		privateInterfaceForIO &	icni,
		unsigned	type,
		arrayElementCount	nElem,
		const void *	pValue,
		cacWriteNotify &	notifyIn
	)

Definition at line 707 of file cac.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     autoPtrRecycle  < netWriteNotifyIO > pIO (
         guard, this->ioTable, *this,
         netWriteNotifyIO::factory ( this->freeListWriteNotifyIO, icni, notifyIn ) );
     this->ioTable.idAssignAdd ( *pIO );
     chan.getPIIU(guard)->writeNotifyRequest (
         guard, chan, *pIO, type, nElem, pValue );
     return *pIO.release();
 }

Friends And Related Function Documentation

friend class tcpiiu

friend

Definition at line 345 of file cac.h.