#include "virtualCircuit.h"

Inheritance diagram for tcpiiu:

Collaboration diagram for tcpiiu:

Public Types
enum	iiu_conn_state { iiucs_connecting, iiucs_connected, iiucs_clean_shutdown, iiucs_disconnected, iiucs_abort_shutdown }

Public Member Functions
	tcpiiu (cac &cac, epicsMutex &mutualExclusion, epicsMutex &callbackControl, cacContextNotify &, double connectionTimeout, epicsTimerQueue &timerQueue, const osiSockAddr &addrIn, comBufMemoryManager &, unsigned minorVersion, ipAddrToAsciiEngine &engineIn, const cacChannel::priLev &priorityIn, SearchDestTCP *pSearchDestIn=NULL)

	~tcpiiu ()

void	start (epicsGuard< epicsMutex > &)

void	responsiveCircuitNotify (epicsGuard< epicsMutex > &cbGuard, epicsGuard< epicsMutex > &guard)

void	sendTimeoutNotify (callbackManager &cbMgr, epicsGuard< epicsMutex > &guard)

void	receiveTimeoutNotify (callbackManager &, epicsGuard< epicsMutex > &)

void	beaconAnomalyNotify (epicsGuard< epicsMutex > &)

void	beaconArrivalNotify (epicsGuard< epicsMutex > &)

void	probeResponseNotify (epicsGuard< epicsMutex > &)

void	flushRequest (epicsGuard< epicsMutex > &)

unsigned	requestMessageBytesPending (epicsGuard< epicsMutex > &mutualExclusionGuard)

void	flush (epicsGuard< epicsMutex > &mutualExclusionGuard)

void	show (unsigned level) const

bool	setEchoRequestPending (epicsGuard< epicsMutex > &)

void	requestRecvProcessPostponedFlush (epicsGuard< epicsMutex > &)

void	clearChannelRequest (epicsGuard< epicsMutex > &, ca_uint32_t sid, ca_uint32_t cid)

bool	ca_v41_ok (epicsGuard< epicsMutex > &) const

bool	ca_v42_ok (epicsGuard< epicsMutex > &) const

bool	ca_v44_ok (epicsGuard< epicsMutex > &) const

bool	ca_v49_ok (epicsGuard< epicsMutex > &) const

unsigned	getHostName (epicsGuard< epicsMutex > &, char *pBuf, unsigned bufLength) const throw ()

bool	alive (epicsGuard< epicsMutex > &) const

bool	connecting (epicsGuard< epicsMutex > &) const

bool	receiveThreadIsBusy (epicsGuard< epicsMutex > &)

osiSockAddr	getNetworkAddress (epicsGuard< epicsMutex > &) const

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

unsigned	channelCount (epicsGuard< epicsMutex > &)

void	disconnectAllChannels (epicsGuard< epicsMutex > &cbGuard, epicsGuard< epicsMutex > &guard, class udpiiu &)

void	unlinkAllChannels (epicsGuard< epicsMutex > &cbGuard, epicsGuard< epicsMutex > &guard)

void	installChannel (epicsGuard< epicsMutex > &, nciu &chan, unsigned sidIn, ca_uint16_t typeIn, arrayElementCount countIn)

void	uninstallChan (epicsGuard< epicsMutex > &guard, nciu &chan)

bool	connectNotify (epicsGuard< epicsMutex > &, nciu &chan)

void	searchRespNotify (const epicsTime &, const caHdrLargeArray &)

void	versionRespNotify (const caHdrLargeArray &)

void *	operator new (size_t size, tsFreeList< class tcpiiu, 32, epicsMutexNOOP > &)

bool	processIncoming (const epicsTime &currentTime, callbackManager &)

unsigned	sendBytes (const void *pBuf, unsigned nBytesInBuf, const epicsTime &currentTime)

void	recvBytes (void *pBuf, unsigned nBytesInBuf, statusWireIO &)

const char *	pHostName (epicsGuard< epicsMutex > &) const throw ()

double	receiveWatchdogDelay (epicsGuard< epicsMutex > &) const

void	unresponsiveCircuitNotify (epicsGuard< epicsMutex > &cbGuard, epicsGuard< epicsMutex > &guard)

void	initiateCleanShutdown (epicsGuard< epicsMutex > &)

void	initiateAbortShutdown (epicsGuard< epicsMutex > &)

void	disconnectNotify (epicsGuard< epicsMutex > &)

bool	bytesArePendingInOS () const

void	decrementBlockingForFlushCount (epicsGuard< epicsMutex > &guard)

bool	isNameService () const

void	echoRequest (epicsGuard< epicsMutex > &)

void	versionMessage (epicsGuard< epicsMutex > &, const cacChannel::priLev &priority)

void	disableFlowControlRequest (epicsGuard< epicsMutex > &)

void	enableFlowControlRequest (epicsGuard< epicsMutex > &)

void	hostNameSetRequest (epicsGuard< epicsMutex > &)

void	userNameSetRequest (epicsGuard< epicsMutex > &)

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

void	writeRequest (epicsGuard< epicsMutex > &, nciu &, unsigned type, arrayElementCount nElem, const void *pValue)

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

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

void	subscriptionRequest (epicsGuard< epicsMutex > &, nciu &, netSubscription &subscr)

void	subscriptionUpdateRequest (epicsGuard< epicsMutex > &, nciu &chan, netSubscription &subscr)

void	subscriptionCancelRequest (epicsGuard< epicsMutex > &, nciu &chan, netSubscription &subscr)

void	flushIfRecvProcessRequested (epicsGuard< epicsMutex > &)

bool	sendThreadFlush (epicsGuard< epicsMutex > &)

void	uninstallChanDueToSuccessfulSearchResponse (epicsGuard< epicsMutex > &, nciu &, const class epicsTime &)

bool	searchMsg (epicsGuard< epicsMutex > &, ca_uint32_t id, const char *pName, unsigned nameLength)

	tcpiiu (const tcpiiu &)

tcpiiu &	operator= (const tcpiiu &)

void	operator delete (void *)

Public Member Functions inherited from netiiu
virtual	~netiiu ()=0

Public Member Functions inherited from tsDLNode< tcpiiu >
	tsDLNode ()

	tsDLNode (const tsDLNode< tcpiiu > &)

const tsDLNode< tcpiiu > &	operator= (const tsDLNode< tcpiiu > &)

Public Member Functions inherited from tsSLNode< tcpiiu >
	tsSLNode ()

tsSLNode< tcpiiu > &	operator= (const tsSLNode< tcpiiu > &)

Public Member Functions inherited from caServerID
	caServerID (const struct sockaddr_in &addrIn, unsigned priority)

bool	operator== (const caServerID &) const

resTableIndex	hash () const

osiSockAddr	address () const

unsigned	priority () const

Public Attributes
epicsPlacementDeleteOperator((void *, tsFreeList< class tcpiiu, 32, epicsMutexNOOP > &)) private tcpRecvThrea	recvThread )

tcpSendThread	sendThread

tcpRecvWatchdog	recvDog

tcpSendWatchdog	sendDog

comQueSend	sendQue

comQueRecv	recvQue

tsDLList< nciu >	createReqPend

tsDLList< nciu >	createRespPend

tsDLList< nciu >	v42ConnCallbackPend

tsDLList< nciu >	subscripReqPend

tsDLList< nciu >	connectedList

tsDLList< nciu >	unrespCircuit

tsDLList< nciu >	subscripUpdateReqPend

caHdrLargeArray	curMsg

arrayElementCount	curDataMax

arrayElementCount	curDataBytes

comBufMemoryManager &	comBufMemMgr

cac &	cacRef

char *	pCurData

SearchDestTCP *	pSearchDest

epicsMutex &	mutex

epicsMutex &	cbMutex

unsigned	minorProtocolVersion

enum tcpiiu::iiu_conn_state	state

epicsEvent	sendThreadFlushEvent

epicsEvent	flushBlockEvent

SOCKET	sock

unsigned	contigRecvMsgCount

unsigned	blockingForFlush

unsigned	socketLibrarySendBufferSize

unsigned	unacknowledgedSendBytes

unsigned	channelCountTot

bool	_receiveThreadIsBusy

bool	busyStateDetected

bool	flowControlActive

bool	echoRequestPending

bool	oldMsgHeaderAvailable

bool	msgHeaderAvailable

bool	earlyFlush

bool	recvProcessPostponedFlush

bool	discardingPendingData

bool	socketHasBeenClosed

bool	unresponsiveCircuit

Friends
class	tcpRecvThread

class	tcpSendThread

void	SearchDestTCP::searchRequest (epicsGuard< epicsMutex > &guard, const char *pbuf, size_t len)

Detailed Description

Definition at line 111 of file virtualCircuit.h.

Member Enumeration Documentation

enum tcpiiu::iiu_conn_state

Enumerator
iiucs_connecting
iiucs_connected
iiucs_clean_shutdown
iiucs_disconnected
iiucs_abort_shutdown

Definition at line 233 of file virtualCircuit.h.

                         {
         iiucs_connecting, // pending circuit connect
         iiucs_connected, // live circuit
         iiucs_clean_shutdown, // live circuit will shutdown when flush completes
         iiucs_disconnected, // socket informed us of disconnect
         iiucs_abort_shutdown // socket has been closed
                 } state;

Constructor & Destructor Documentation

tcpiiu::tcpiiu	(	cac &	cac,
		epicsMutex &	mutualExclusion,
		epicsMutex &	callbackControl,
		cacContextNotify &	ctxNotifyIn,
		double	connectionTimeout,
		epicsTimerQueue &	timerQueue,
		const osiSockAddr &	addrIn,
		comBufMemoryManager &	comBufMemMgrIn,
		unsigned	minorVersion,
		ipAddrToAsciiEngine &	engineIn,
		const cacChannel::priLev &	priorityIn,
		SearchDestTCP *	pSearchDestIn = `NULL`
	)

Definition at line 665 of file tcpiiu.cpp.

                                         :
     caServerID ( addrIn.ia, priorityIn ),
     hostNameCacheInstance ( addrIn, engineIn ),
     recvThread ( *this, cbMutexIn, ctxNotifyIn, "CAC-TCP-recv",
         epicsThreadGetStackSize ( epicsThreadStackBig ),
         cac::highestPriorityLevelBelow ( cac.getInitializingThreadsPriority() ) ),
     sendThread ( *this, "CAC-TCP-send",
         epicsThreadGetStackSize ( epicsThreadStackMedium ),
         cac::lowestPriorityLevelAbove (
             cac.getInitializingThreadsPriority() ) ),
     recvDog ( cbMutexIn, ctxNotifyIn, mutexIn,
         *this, connectionTimeout, timerQueue ),
     sendDog ( cbMutexIn, ctxNotifyIn, mutexIn,
         *this, connectionTimeout, timerQueue ),
     sendQue ( *this, comBufMemMgrIn ),
     recvQue ( comBufMemMgrIn ),
     curDataMax ( MAX_TCP ),
     curDataBytes ( 0ul ),
     comBufMemMgr ( comBufMemMgrIn ),
     cacRef ( cac ),
     pCurData ( (char*) freeListMalloc(this->cacRef.tcpSmallRecvBufFreeList) ),
     pSearchDest ( pSearchDestIn ),
     mutex ( mutexIn ),
     cbMutex ( cbMutexIn ),
     minorProtocolVersion ( minorVersion ),
     state ( iiucs_connecting ),
     sock ( INVALID_SOCKET ),
     contigRecvMsgCount ( 0u ),
     blockingForFlush ( 0u ),
     socketLibrarySendBufferSize ( 0x1000 ),
     unacknowledgedSendBytes ( 0u ),
     channelCountTot ( 0u ),
     _receiveThreadIsBusy ( false ),
     busyStateDetected ( false ),
     flowControlActive ( false ),
     echoRequestPending ( false ),
     oldMsgHeaderAvailable ( false ),
     msgHeaderAvailable ( false ),
     earlyFlush ( false ),
     recvProcessPostponedFlush ( false ),
     discardingPendingData ( false ),
     socketHasBeenClosed ( false ),
     unresponsiveCircuit ( false )
 {
     if(!pCurData)
         throw std::bad_alloc();
 
     this->sock = epicsSocketCreate ( AF_INET, SOCK_STREAM, IPPROTO_TCP );
     if ( this->sock == INVALID_SOCKET ) {
         freeListFree(this->cacRef.tcpSmallRecvBufFreeList, this->pCurData);
         char sockErrBuf[64];
         epicsSocketConvertErrnoToString (
             sockErrBuf, sizeof ( sockErrBuf ) );
         std :: string reason =
             "CAC: TCP circuit creation failure because \"";
         reason += sockErrBuf;
         reason += "\"";
         throw runtime_error ( reason );
     }
 
     int flag = true;
     int status = setsockopt ( this->sock, IPPROTO_TCP, TCP_NODELAY,
                 (char *) &flag, sizeof ( flag ) );
     if ( status < 0 ) {
         char sockErrBuf[64];
         epicsSocketConvertErrnoToString (
             sockErrBuf, sizeof ( sockErrBuf ) );
         errlogPrintf ( "CAC: problems setting socket option TCP_NODELAY = \"%s\"\n",
             sockErrBuf );
     }
 
     flag = true;
     status = setsockopt ( this->sock , SOL_SOCKET, SO_KEEPALIVE,
                 ( char * ) &flag, sizeof ( flag ) );
     if ( status < 0 ) {
         char sockErrBuf[64];
         epicsSocketConvertErrnoToString (
             sockErrBuf, sizeof ( sockErrBuf ) );
         errlogPrintf ( "CAC: problems setting socket option SO_KEEPALIVE = \"%s\"\n",
             sockErrBuf );
     }
 
     // load message queue with messages informing server
     // of version, user, and host name of client
     {
         epicsGuard < epicsMutex > guard ( this->mutex );
         this->versionMessage ( guard, this->priority() );
         this->userNameSetRequest ( guard );
         this->hostNameSetRequest ( guard );
     }
 
 #   if 0
     {
         int i;
 
         /*
          * some concern that vxWorks will run out of mBuf's
          * if this change is made joh 11-10-98
          */
         i = MAX_MSG_SIZE;
         status = setsockopt ( this->sock, SOL_SOCKET, SO_SNDBUF,
                 ( char * ) &i, sizeof ( i ) );
         if (status < 0) {
             char sockErrBuf[64];
             epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
             errlogPrintf ( "CAC: problems setting socket option SO_SNDBUF = \"%s\"\n",
                 sockErrBuf );
         }
         i = MAX_MSG_SIZE;
         status = setsockopt ( this->sock, SOL_SOCKET, SO_RCVBUF,
                 ( char * ) &i, sizeof ( i ) );
         if ( status < 0 ) {
             char sockErrBuf[64];
             epicsSocketConvertErrnoToString ( sockErrBuf, sizeof ( sockErrBuf ) );
             errlogPrintf ( "CAC: problems setting socket option SO_RCVBUF = \"%s\"\n",
                 sockErrBuf );
         }
     }
 #   endif
 
     {
         int nBytes;
         osiSocklen_t sizeOfParameter = static_cast < int > ( sizeof ( nBytes ) );
         status = getsockopt ( this->sock, SOL_SOCKET, SO_SNDBUF,
                 ( char * ) &nBytes, &sizeOfParameter );
         if ( status < 0 || nBytes < 0 ||
                 sizeOfParameter != static_cast < int > ( sizeof ( nBytes ) ) ) {
             char sockErrBuf[64];
             epicsSocketConvertErrnoToString (
                 sockErrBuf, sizeof ( sockErrBuf ) );
             errlogPrintf ("CAC: problems getting socket option SO_SNDBUF = \"%s\"\n",
                 sockErrBuf );
         }
         else {
             this->socketLibrarySendBufferSize = static_cast < unsigned > ( nBytes );
         }
     }
 
     if ( isNameService() ) {
         pSearchDest->setCircuit ( this );
     }
 
     memset ( (void *) &this->curMsg, '\0', sizeof ( this->curMsg ) );
 }

tcpiiu::~tcpiiu ( )

Definition at line 1014 of file tcpiiu.cpp.

 {
     if ( this->pSearchDest ) {
         this->pSearchDest->disable ();
     }
 
     this->sendThread.exitWait ();
     this->recvThread.exitWait ();
     this->sendDog.cancel ();
     this->recvDog.shutdown ();
 
     if ( ! this->socketHasBeenClosed ) {
         epicsSocketDestroy ( this->sock );
     }
 
     // free message body cache
     if ( this->pCurData ) {
         if ( this->curDataMax <= MAX_TCP ) {
             freeListFree(this->cacRef.tcpSmallRecvBufFreeList, this->pCurData);
         }
         else if ( this->cacRef.tcpLargeRecvBufFreeList ) {
             freeListFree(this->cacRef.tcpLargeRecvBufFreeList, this->pCurData);
         }
         else {
             free ( this->pCurData );
         }
     }
 }

tcpiiu::tcpiiu ( const tcpiiu & )

Member Function Documentation

bool tcpiiu::alive ( epicsGuard< epicsMutex > & ) const

inline

Definition at line 371 of file virtualCircuit.h.

 {
     return ( this->state == iiucs_connecting ||
         this->state == iiucs_connected );
 }

void tcpiiu::beaconAnomalyNotify ( epicsGuard< epicsMutex > & guard )

inline

Definition at line 391 of file virtualCircuit.h.

 {
     //guard.assertIdenticalMutex ( this->cacRef.mutexRef () );
     this->recvDog.beaconAnomalyNotify ( guard );
 }

void tcpiiu::beaconArrivalNotify ( epicsGuard< epicsMutex > & guard )

inline

Definition at line 398 of file virtualCircuit.h.

 {
     //guard.assertIdenticalMutex ( this->cacRef.mutexRef () );
     this->recvDog.beaconArrivalNotify ( guard );
 }

bool tcpiiu::bytesArePendingInOS ( ) const

Definition at line 2045 of file tcpiiu.cpp.

 {
 #if 0
     FD_SET readBits;
     FD_ZERO ( & readBits );
     FD_SET ( this->sock, & readBits );
     struct timeval tmo;
     tmo.tv_sec = 0;
     tmo.tv_usec = 0;
     int status = select ( this->sock + 1, & readBits, NULL, NULL, & tmo );
     if ( status > 0 ) {
         if ( FD_ISSET ( this->sock, & readBits ) ) {
             return true;
         }
     }
     return false;
 #else
     osiSockIoctl_t bytesPending = 0; /* shut up purifys yapping */
     int status = socket_ioctl ( this->sock,
                             FIONREAD, & bytesPending );
     if ( status >= 0 ) {
         if ( bytesPending > 0 ) {
             return true;
         }
     }
     return false;
 #endif
 }

bool tcpiiu::ca_v41_ok ( epicsGuard< epicsMutex > & ) const

inlinevirtual

Implements netiiu.

Definition at line 353 of file virtualCircuit.h.

 {
     return CA_V41 ( this->minorProtocolVersion );
 }

bool tcpiiu::ca_v42_ok ( epicsGuard< epicsMutex > & guard ) const

virtual

Implements netiiu.

Definition at line 1777 of file tcpiiu.cpp.

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

bool tcpiiu::ca_v44_ok ( epicsGuard< epicsMutex > & ) const

inline

Definition at line 359 of file virtualCircuit.h.

 {
     return CA_V44 ( this->minorProtocolVersion );
 }

bool tcpiiu::ca_v49_ok ( epicsGuard< epicsMutex > & ) const

inline

Definition at line 365 of file virtualCircuit.h.

 {
     return CA_V49 ( this->minorProtocolVersion );
 }

unsigned tcpiiu::channelCount ( epicsGuard< epicsMutex > & guard )

Definition at line 2113 of file tcpiiu.cpp.

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

void tcpiiu::clearChannelRequest	(	epicsGuard< epicsMutex > &	guard,
		ca_uint32_t	sid,
		ca_uint32_t	cid
	)

virtual

Implements netiiu.

Definition at line 1536 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     // there are situations where the circuit is disconnected, but
     // the channel does not know this yet
     if ( this->state != iiucs_connected ) {
         return;
     }
     comQueSendMsgMinder minder ( this->sendQue, guard );
     this->sendQue.insertRequestHeader (
         CA_PROTO_CLEAR_CHANNEL, 0u,
         0u, 0u, sid, cid,
         CA_V49 ( this->minorProtocolVersion ) );
     minder.commit ();
 }

bool tcpiiu::connecting ( epicsGuard< epicsMutex > & ) const

inline

Definition at line 378 of file virtualCircuit.h.

 {
     return ( this->state == iiucs_connecting );
 }

bool tcpiiu::connectNotify	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan
	)

Definition at line 1958 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     bool wasExpected = false;
     // this improves robustness in the face of a server sending
     // protocol that does not match its declared protocol revision
     if ( chan.channelNode::listMember == channelNode::cs_createRespPend ) {
         this->createRespPend.remove ( chan );
         this->subscripReqPend.add ( chan );
         chan.channelNode::listMember = channelNode::cs_subscripReqPend;
         wasExpected = true;
     }
     else if ( chan.channelNode::listMember == channelNode::cs_v42ConnCallbackPend ) {
         this->v42ConnCallbackPend.remove ( chan );
         this->subscripReqPend.add ( chan );
         chan.channelNode::listMember = channelNode::cs_subscripReqPend;
         wasExpected = true;
     }
     // the TCP send thread is awakened by its receive thread whenever the receive thread
     // is about to block if this->subscripReqPend has items in it
     return wasExpected;
 }

void tcpiiu::createChannelRequest	(	nciu &	chan,
		epicsGuard< epicsMutex > &	guard
	)

Definition at line 1487 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     if ( this->state != iiucs_connected &&
         this->state != iiucs_connecting ) {
         return;
     }
 
     const char *pName;
     unsigned nameLength;
     ca_uint32_t identity;
     if ( this->ca_v44_ok ( guard ) ) {
         identity = chan.getCID ( guard );
         pName = chan.pName ( guard );
         nameLength = chan.nameLen ( guard );
     }
     else {
         identity = chan.getSID ( guard );
         pName = 0;
         nameLength = 0u;
     }
 
     unsigned postCnt = CA_MESSAGE_ALIGN ( nameLength );
 
     if ( postCnt >= 0xffff ) {
         throw cacChannel::unsupportedByService();
     }
 
     comQueSendMsgMinder minder ( this->sendQue, guard );
     //
     // The available field is used (abused)
     // here to communicate the minor version number
     // starting with CA 4.1.
     //
     this->sendQue.insertRequestHeader (
         CA_PROTO_CREATE_CHAN, postCnt,
         0u, 0u, identity, CA_MINOR_PROTOCOL_REVISION,
         CA_V49 ( this->minorProtocolVersion ) );
     if ( nameLength ) {
         this->sendQue.pushString ( pName, nameLength );
     }
     if ( postCnt > nameLength ) {
         this->sendQue.pushString ( cacNillBytes, postCnt - nameLength );
     }
     minder.commit ();
 }

void tcpiiu::decrementBlockingForFlushCount ( epicsGuard< epicsMutex > & guard )

Definition at line 1758 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     assert ( this->blockingForFlush > 0u );
     this->blockingForFlush--;
     if ( this->blockingForFlush > 0 ) {
         this->flushBlockEvent.signal ();
     }
 }

void tcpiiu::disableFlowControlRequest ( epicsGuard< epicsMutex > & guard )

Definition at line 1348 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     if ( this->sendQue.flushEarlyThreshold ( 16u ) ) {
         this->flushRequest ( guard );
     }
     comQueSendMsgMinder minder ( this->sendQue, guard );
     this->sendQue.insertRequestHeader (
         CA_PROTO_EVENTS_ON, 0u,
         0u, 0u, 0u, 0u,
         CA_V49 ( this->minorProtocolVersion ) );
     minder.commit ();
 }

void tcpiiu::disconnectAllChannels	(	epicsGuard< epicsMutex > &	cbGuard,
		epicsGuard< epicsMutex > &	guard,
		class udpiiu &	discIIU
	)

Definition at line 1806 of file tcpiiu.cpp.

 {
     cbGuard.assertIdenticalMutex ( this->cbMutex );
     guard.assertIdenticalMutex ( this->mutex );
 
     while ( nciu * pChan = this->createReqPend.get () ) {
         discIIU.installDisconnectedChannel ( guard, *pChan );
     }
 
     while ( nciu * pChan = this->createRespPend.get () ) {
         // we dont yet know the server's id so we cant
         // send a channel delete request and will instead
         // trust that the server can do the proper cleanup
         // when the circuit disconnects
         discIIU.installDisconnectedChannel ( guard, *pChan );
     }
 
     while ( nciu * pChan = this->v42ConnCallbackPend.get () ) {
         this->clearChannelRequest ( guard,
             pChan->getSID(guard), pChan->getCID(guard) );
         discIIU.installDisconnectedChannel ( guard, *pChan );
     }
 
     while ( nciu * pChan = this->subscripReqPend.get () ) {
         pChan->disconnectAllIO ( cbGuard, guard );
         this->clearChannelRequest ( guard,
             pChan->getSID(guard), pChan->getCID(guard) );
         discIIU.installDisconnectedChannel ( guard, *pChan );
         pChan->unresponsiveCircuitNotify ( cbGuard, guard );
     }
 
     while ( nciu * pChan = this->connectedList.get () ) {
         pChan->disconnectAllIO ( cbGuard, guard );
         this->clearChannelRequest ( guard,
             pChan->getSID(guard), pChan->getCID(guard) );
         discIIU.installDisconnectedChannel ( guard, *pChan );
         pChan->unresponsiveCircuitNotify ( cbGuard, guard );
     }
 
     while ( nciu * pChan = this->unrespCircuit.get () ) {
         // if we know that the circuit is unresponsive
         // then we dont send a channel delete request and
         // will instead trust that the server can do the
         // proper cleanup when the circuit disconnects
         pChan->disconnectAllIO ( cbGuard, guard );
         discIIU.installDisconnectedChannel ( guard, *pChan );
     }
 
     while ( nciu * pChan = this->subscripUpdateReqPend.get () ) {
         pChan->disconnectAllIO ( cbGuard, guard );
         this->clearChannelRequest ( guard,
             pChan->getSID(guard), pChan->getCID(guard) );
         discIIU.installDisconnectedChannel ( guard, *pChan );
         pChan->unresponsiveCircuitNotify ( cbGuard, guard );
     }
 
     this->channelCountTot = 0u;
     this->initiateCleanShutdown ( guard );
 }

void tcpiiu::disconnectNotify ( epicsGuard< epicsMutex > & guard )

Definition at line 851 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     this->state = iiucs_disconnected;
     this->sendThreadFlushEvent.signal ();
     this->flushBlockEvent.signal ();
 }

void tcpiiu::echoRequest ( epicsGuard< epicsMutex > & guard )

Definition at line 1400 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     epicsUInt16 command = CA_PROTO_ECHO;
     if ( ! CA_V43 ( this->minorProtocolVersion ) ) {
         // we fake an echo to early server using a read sync
         command = CA_PROTO_READ_SYNC;
     }
 
     if ( this->sendQue.flushEarlyThreshold ( 16u ) ) {
         this->flushRequest ( guard );
     }
     comQueSendMsgMinder minder ( this->sendQue, guard );
     this->sendQue.insertRequestHeader (
         command, 0u,
         0u, 0u, 0u, 0u,
         CA_V49 ( this->minorProtocolVersion ) );
     minder.commit ();
 }

void tcpiiu::enableFlowControlRequest ( epicsGuard< epicsMutex > & guard )

Definition at line 1364 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     if ( this->sendQue.flushEarlyThreshold ( 16u ) ) {
         this->flushRequest ( guard );
     }
     comQueSendMsgMinder minder ( this->sendQue, guard );
     this->sendQue.insertRequestHeader (
         CA_PROTO_EVENTS_OFF, 0u,
         0u, 0u, 0u, 0u,
         CA_V49 ( this->minorProtocolVersion ) );
     minder.commit ();
 }

void tcpiiu::flush ( epicsGuard< epicsMutex > & mutualExclusionGuard )

virtual

Implements netiiu.

Definition at line 1709 of file tcpiiu.cpp.

 {
     this->flushRequest ( guard );
     // the process thread is not permitted to flush as this
     // can result in a push / pull deadlock on the TCP pipe.
     // Instead, the process thread scheduals the flush with the
     // send thread which runs at a higher priority than the
     // receive thread. The same applies to the UDP thread for
     // locking hierarchy reasons.
     if ( ! epicsThreadPrivateGet ( caClientCallbackThreadId ) ) {
         // enable / disable of call back preemption must occur here
         // because the tcpiiu might disconnect while waiting and its
         // pointer to this cac might become invalid
         assert ( this->blockingForFlush < UINT_MAX );
         this->blockingForFlush++;
         while ( this->sendQue.flushBlockThreshold() ) {
 
             bool userRequestsCanBeAccepted =
                 this->state == iiucs_connected ||
                 ( ! this->ca_v42_ok ( guard ) &&
                     this->state == iiucs_connecting );
             // fail the users request if we have a disconnected
             // or unresponsive circuit
             if ( ! userRequestsCanBeAccepted ||
                     this->unresponsiveCircuit ) {
                 this->decrementBlockingForFlushCount ( guard );
                 throw cacChannel::notConnected ();
             }
 
             epicsGuardRelease < epicsMutex > unguard ( guard );
             this->flushBlockEvent.wait ( 30.0 );
         }
         this->decrementBlockingForFlushCount ( guard );
     }
 }

void tcpiiu::flushIfRecvProcessRequested ( epicsGuard< epicsMutex > & guard )

Definition at line 1137 of file tcpiiu.cpp.

 {
     if ( this->recvProcessPostponedFlush ) {
         this->flushRequest ( guard );
         this->recvProcessPostponedFlush = false;
     }
 }

void tcpiiu::flushRequest ( epicsGuard< epicsMutex > & )

virtual

Implements netiiu.

Definition at line 2038 of file tcpiiu.cpp.

 {
     if ( this->sendQue.occupiedBytes () > 0 ) {
         this->sendThreadFlushEvent.signal ();
     }
 }

unsigned tcpiiu::getHostName	(	epicsGuard< epicsMutex > &	guard,
		char *	pBuf,
		unsigned	bufLength
	)		const
throw	(
	)

virtual

Implements netiiu.

Definition at line 1791 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     return this->hostNameCacheInstance.getName ( pBuf, bufLength );
 }

osiSockAddr tcpiiu::getNetworkAddress ( epicsGuard< epicsMutex > & guard ) const

virtual

Implements netiiu.

Definition at line 1769 of file tcpiiu.cpp.

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

void tcpiiu::hostNameSetRequest ( epicsGuard< epicsMutex > & guard )

Definition at line 1291 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     if ( ! CA_V41 ( this->minorProtocolVersion ) ) {
         return;
     }
 
     const char * pName = this->cacRef.pLocalHostName ();
     unsigned size = strlen ( pName ) + 1u;
     unsigned postSize = CA_MESSAGE_ALIGN ( size );
     assert ( postSize < 0xffff );
 
     if ( this->sendQue.flushEarlyThreshold ( postSize + 16u ) ) {
         this->flushRequest ( guard );
     }
 
     comQueSendMsgMinder minder ( this->sendQue, guard );
     this->sendQue.insertRequestHeader (
         CA_PROTO_HOST_NAME, postSize,
         0u, 0u, 0u, 0u,
         CA_V49 ( this->minorProtocolVersion ) );
     this->sendQue.pushString ( pName, size );
     this->sendQue.pushString ( cacNillBytes, postSize - size );
     minder.commit ();
 }

void tcpiiu::initiateAbortShutdown ( epicsGuard< epicsMutex > & guard )

Definition at line 942 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     if ( ! this->discardingPendingData ) {
         // force abortive shutdown sequence
         // (discard outstanding sends and receives)
         struct linger tmpLinger;
         tmpLinger.l_onoff = true;
         tmpLinger.l_linger = 0u;
         int status = setsockopt ( this->sock, SOL_SOCKET, SO_LINGER,
             reinterpret_cast <char *> ( &tmpLinger ), sizeof (tmpLinger) );
         if ( status != 0 ) {
             char sockErrBuf[64];
             epicsSocketConvertErrnoToString (
                 sockErrBuf, sizeof ( sockErrBuf ) );
             errlogPrintf ( "CAC TCP socket linger set error was %s\n",
                 sockErrBuf );
         }
         this->discardingPendingData = true;
     }
 
     iiu_conn_state oldState = this->state;
     if ( oldState != iiucs_abort_shutdown && oldState != iiucs_disconnected ) {
         this->state = iiucs_abort_shutdown;
 
         epicsSocketSystemCallInterruptMechanismQueryInfo info  =
             epicsSocketSystemCallInterruptMechanismQuery ();
         switch ( info ) {
         case esscimqi_socketCloseRequired:
             //
             // on winsock and probably vxWorks shutdown() does not
             // unblock a thread in recv() so we use close() and introduce
             // some complexity because we must unregister the fd early
             //
             if ( ! this->socketHasBeenClosed ) {
                 epicsSocketDestroy ( this->sock );
                 this->socketHasBeenClosed = true;
             }
             break;
         case esscimqi_socketBothShutdownRequired:
             {
                 int status = ::shutdown ( this->sock, SHUT_RDWR );
                 if ( status ) {
                     char sockErrBuf[64];
                     epicsSocketConvertErrnoToString (
                         sockErrBuf, sizeof ( sockErrBuf ) );
                     errlogPrintf ("CAC TCP socket shutdown error was %s\n",
                         sockErrBuf );
                 }
             }
             break;
         case esscimqi_socketSigAlarmRequired:
             this->recvThread.interruptSocketRecv ();
             this->sendThread.interruptSocketSend ();
             break;
         default:
             break;
         };
 
         //
         // wake up the send thread if it isnt blocking in send()
         //
         this->sendThreadFlushEvent.signal ();
         this->flushBlockEvent.signal ();
     }
 }

void tcpiiu::initiateCleanShutdown ( epicsGuard< epicsMutex > & guard )

Definition at line 826 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     if ( this->state == iiucs_connected ) {
         if ( this->unresponsiveCircuit ) {
             this->initiateAbortShutdown ( guard );
         }
         else {
             this->state = iiucs_clean_shutdown;
             this->sendThreadFlushEvent.signal ();
             this->flushBlockEvent.signal ();
         }
     }
     else if ( this->state == iiucs_clean_shutdown ) {
         if ( this->unresponsiveCircuit ) {
             this->initiateAbortShutdown ( guard );
         }
     }
     else if ( this->state == iiucs_connecting ) {
         this->initiateAbortShutdown ( guard );
     }
 }

void tcpiiu::installChannel	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		unsigned	sidIn,
		ca_uint16_t	typeIn,
		arrayElementCount	countIn
	)

Definition at line 1942 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     this->createReqPend.add ( chan );
     this->channelCountTot++;
     chan.channelNode::listMember = channelNode::cs_createReqPend;
     chan.searchReplySetUp ( *this, sidIn, typeIn, countIn, guard );
     // The tcp send thread runs at apriority below the udp thread
     // so that this will not send small packets
     this->sendThreadFlushEvent.signal ();
 }

bool tcpiiu::isNameService ( ) const

inline

Definition at line 411 of file virtualCircuit.h.

 {
     return ( this->pSearchDest != NULL );
 }

void tcpiiu::operator delete ( void * )

Definition at line 2101 of file tcpiiu.cpp.

 {
     // Visual C++ .net appears to require operator delete if
     // placement operator delete is defined? I smell a ms rat
     // because if I declare placement new and delete, but
     // comment out the placement delete definition there are
     // no undefined symbols.
     errlogPrintf ( "%s:%d this compiler is confused about "
         "placement delete - memory was probably leaked",
         __FILE__, __LINE__ );
 }

void * tcpiiu::operator new	(	size_t	size,
		tsFreeList< class tcpiiu, 32, epicsMutexNOOP > &	mgr
	)

inline

Definition at line 339 of file virtualCircuit.h.

 {
     return mgr.allocate ( size );
 }

tcpiiu& tcpiiu::operator= ( const tcpiiu & )

const char * tcpiiu::pHostName	(	epicsGuard< epicsMutex > &	guard	)	const
throw	(
	)

virtual

Implements netiiu.

Definition at line 1799 of file tcpiiu.cpp.

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

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

Definition at line 2020 of file tcpiiu.cpp.

 {
     cbGuard.assertIdenticalMutex ( this->cbMutex );
 
     va_list theArgs;
     int status;
 
     va_start ( theArgs, pformat );
 
     status = this->cacRef.varArgsPrintFormated ( cbGuard, pformat, theArgs );
 
     va_end ( theArgs );
 
     return status;
 }

void tcpiiu::probeResponseNotify ( epicsGuard< epicsMutex > & cbGuard )

inline

Definition at line 405 of file virtualCircuit.h.

 {
     this->recvDog.probeResponseNotify ( cbGuard );
 }

bool tcpiiu::processIncoming	(	const epicsTime &	currentTime,
		callbackManager &	mgr
	)

Definition at line 1146 of file tcpiiu.cpp.

 {
     mgr.cbGuard.assertIdenticalMutex ( this->cbMutex );
 
     while ( true ) {
 
         //
         // fetch a complete message header
         //
         if ( ! this->msgHeaderAvailable ) {
             if ( ! this->oldMsgHeaderAvailable ) {
                 this->oldMsgHeaderAvailable =
                     this->recvQue.popOldMsgHeader ( this->curMsg );
                 if ( ! this->oldMsgHeaderAvailable ) {
                     epicsGuard < epicsMutex > guard ( this->mutex );
                     this->flushIfRecvProcessRequested ( guard );
                     return true;
                 }
             }
             if ( this->curMsg.m_postsize == 0xffff ) {
                 static const unsigned annexSize =
                     sizeof ( this->curMsg.m_postsize ) +
                     sizeof ( this->curMsg.m_count );
                 if ( this->recvQue.occupiedBytes () < annexSize ) {
                     epicsGuard < epicsMutex > guard ( this->mutex );
                     this->flushIfRecvProcessRequested ( guard );
                     return true;
                 }
                 this->curMsg.m_postsize = this->recvQue.popUInt32 ();
                 this->curMsg.m_count = this->recvQue.popUInt32 ();
             }
             this->msgHeaderAvailable = true;
 #           ifdef DEBUG
                 epicsGuard < epicsMutex > guard ( this->mutex );
                 debugPrintf (
                     ( "%s Cmd=%3u Type=%3u Count=%8u Size=%8u",
                       this->pHostName ( guard ),
                       this->curMsg.m_cmmd,
                       this->curMsg.m_dataType,
                       this->curMsg.m_count,
                       this->curMsg.m_postsize) );
                 debugPrintf (
                     ( " Avail=%8u Cid=%8u\n",
                       this->curMsg.m_available,
                       this->curMsg.m_cid) );
 #           endif
         }
 
         // check for 8 byte aligned protocol
         if ( this->curMsg.m_postsize & 0x7 ) {
             this->printFormated ( mgr.cbGuard,
                 "CAC: server sent missaligned payload 0x%x\n",
                 this->curMsg.m_postsize );
             return false;
         }
 
         //
         // make sure we have a large enough message body cache
         //
         if ( this->curMsg.m_postsize > this->curDataMax ) {
             assert (this->curMsg.m_postsize > MAX_TCP);
 
             char * newbuf = NULL;
             arrayElementCount newsize;
 
             if ( !this->cacRef.tcpLargeRecvBufFreeList ) {
                 // round size up to multiple of 4K
                 newsize = ((this->curMsg.m_postsize-1)|0xfff)+1;
 
                 if ( this->curDataMax <= MAX_TCP ) {
                     // small -> large
                     newbuf = (char*)malloc(newsize);
 
                 } else {
                     // expand large to larger
                     newbuf = (char*)realloc(this->pCurData, newsize);
                 }
 
             } else if ( this->curMsg.m_postsize <= this->cacRef.maxRecvBytesTCP ) {
                 newbuf = (char*) freeListMalloc(this->cacRef.tcpLargeRecvBufFreeList);
                 newsize = this->cacRef.maxRecvBytesTCP;
 
             }
 
             if ( newbuf) {
                 if (this->curDataMax <= MAX_TCP) {
                     freeListFree(this->cacRef.tcpSmallRecvBufFreeList, this->pCurData );
 
                 } else if (this->cacRef.tcpLargeRecvBufFreeList) {
                     freeListFree(this->cacRef.tcpLargeRecvBufFreeList, this->pCurData );
 
                 } else {
                     // called realloc()
                 }
                 this->pCurData = newbuf;
                 this->curDataMax = newsize;
 
             } else {
                 this->printFormated ( mgr.cbGuard,
                     "CAC: not enough memory for message body cache (ignoring response message)\n");
             }
         }
 
         if ( this->curMsg.m_postsize <= this->curDataMax ) {
             if ( this->curMsg.m_postsize > 0u ) {
                 this->curDataBytes += this->recvQue.copyOutBytes (
                             &this->pCurData[this->curDataBytes],
                             this->curMsg.m_postsize - this->curDataBytes );
                 if ( this->curDataBytes < this->curMsg.m_postsize ) {
                     epicsGuard < epicsMutex > guard ( this->mutex );
                     this->flushIfRecvProcessRequested ( guard );
                     return true;
                 }
             }
             bool msgOK = this->cacRef.executeResponse ( mgr, *this,
                                 currentTime, this->curMsg, this->pCurData );
             if ( ! msgOK ) {
                 return false;
             }
         }
         else {
             static bool once = false;
             if ( ! once ) {
                 this->printFormated ( mgr.cbGuard,
     "CAC: response with payload size=%u > EPICS_CA_MAX_ARRAY_BYTES ignored\n",
                     this->curMsg.m_postsize );
                 once = true;
             }
             this->curDataBytes += this->recvQue.removeBytes (
                     this->curMsg.m_postsize - this->curDataBytes );
             if ( this->curDataBytes < this->curMsg.m_postsize  ) {
                 epicsGuard < epicsMutex > guard ( this->mutex );
                 this->flushIfRecvProcessRequested ( guard );
                 return true;
             }
         }
 
         this->oldMsgHeaderAvailable = false;
         this->msgHeaderAvailable = false;
         this->curDataBytes = 0u;
     }
 }

void tcpiiu::readNotifyRequest	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		netReadNotifyIO &	io,
		unsigned	type,
		arrayElementCount	nElem
	)

virtual

Implements netiiu.

Definition at line 1455 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     if ( INVALID_DB_REQ ( dataType ) ) {
         throw cacChannel::badType ();
     }
     arrayElementCount maxBytes;
     if ( CA_V49 ( this->minorProtocolVersion ) ) {
         maxBytes = 0xfffffff0;
     }
     else {
         maxBytes = MAX_TCP;
     }
     arrayElementCount maxElem =
         ( maxBytes - dbr_size[dataType] ) / dbr_value_size[dataType];
     if ( nElem > maxElem ) {
         throw cacChannel::msgBodyCacheTooSmall ();
     }
     if (nElem == 0 && !CA_V413(this->minorProtocolVersion))
        nElem = chan.getcount();
     comQueSendMsgMinder minder ( this->sendQue, guard );
     this->sendQue.insertRequestHeader (
         CA_PROTO_READ_NOTIFY, 0u,
         static_cast < ca_uint16_t > ( dataType ),
         static_cast < ca_uint32_t > ( nElem ),
         chan.getSID(guard), io.getId(),
         CA_V49 ( this->minorProtocolVersion ) );
     minder.commit ();
 }

bool tcpiiu::receiveThreadIsBusy ( epicsGuard< epicsMutex > & guard )

inline

Definition at line 384 of file virtualCircuit.h.

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

void tcpiiu::receiveTimeoutNotify	(	callbackManager &	mgr,
		epicsGuard< epicsMutex > &	guard
	)

Definition at line 889 of file tcpiiu.cpp.

 {
     mgr.cbGuard.assertIdenticalMutex ( this->cbMutex );
     guard.assertIdenticalMutex ( this->mutex );
     this->unresponsiveCircuitNotify ( mgr.cbGuard, guard );
 }

double tcpiiu::receiveWatchdogDelay ( epicsGuard< epicsMutex > & ) const

virtual

Implements netiiu.

Definition at line 2074 of file tcpiiu.cpp.

 {
     return this->recvDog.delay ();
 }

void tcpiiu::recvBytes	(	void *	pBuf,
		unsigned	nBytesInBuf,
		statusWireIO &	stat
	)

virtual

Implements wireRecvAdapter.

Definition at line 299 of file tcpiiu.cpp.

 {
     assert ( nBytesInBuf <= INT_MAX );
 
     while ( true ) {
         int status = ::recv ( this->sock, static_cast <char *> ( pBuf ),
             static_cast <int> ( nBytesInBuf ), 0 );
 
         if ( status > 0 ) {
             stat.bytesCopied = static_cast <unsigned> ( status );
             assert ( stat.bytesCopied <= nBytesInBuf );
             stat.circuitState = swioConnected;
             return;
         }
         else {
             epicsGuard < epicsMutex > guard ( this->mutex );
 
             if ( status == 0 ) {
                 this->disconnectNotify ( guard );
                 stat.bytesCopied = 0u;
                 stat.circuitState = swioPeerHangup;
                 return;
             }
 
             // if the circuit was locally aborted then supress
             // warning messages about bad file descriptor etc
             if ( this->state != iiucs_connected &&
                     this->state != iiucs_clean_shutdown ) {
                 stat.bytesCopied = 0u;
                 stat.circuitState = swioLocalAbort;
                 return;
             }
 
             int localErrno = SOCKERRNO;
 
             if ( localErrno == SOCK_SHUTDOWN ) {
                 stat.bytesCopied = 0u;
                 stat.circuitState = swioPeerHangup;
                 return;
             }
 
             if ( localErrno == SOCK_EINTR ) {
                 continue;
             }
 
             if ( localErrno == SOCK_ENOBUFS ) {
                 errlogPrintf (
                     "CAC: system low on network buffers "
                     "- receive retry in 15 seconds\n" );
                 {
                     epicsGuardRelease < epicsMutex > unguard ( guard );
                     epicsThreadSleep ( 15.0 );
                 }
                 continue;
             }
 
             char sockErrBuf[64];
             epicsSocketConvertErrnoToString (
                 sockErrBuf, sizeof ( sockErrBuf ) );
 
             // the replacable printf handler isnt called here
             // because it reqires a callback lock which probably
             // isnt appropriate here
             char name[64];
             this->hostNameCacheInstance.getName (
                 name, sizeof ( name ) );
             errlogPrintf (
                 "Unexpected problem with CA circuit to"
                 " server \"%s\" was \"%s\" - disconnecting\n",
                         name, sockErrBuf );
 
             stat.bytesCopied = 0u;
             stat.circuitState = swioPeerAbort;
             return;
         }
     }
 }

unsigned tcpiiu::requestMessageBytesPending ( epicsGuard< epicsMutex > & mutualExclusionGuard )

virtual

Implements netiiu.

Definition at line 1745 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 #if 0
     if ( ! this->earlyFlush && this->sendQue.flushEarlyThreshold(0u) ) {
         this->earlyFlush = true;
         this->sendThreadFlushEvent.signal ();
     }
 #endif
     return sendQue.occupiedBytes ();
 }

void tcpiiu::requestRecvProcessPostponedFlush ( epicsGuard< epicsMutex > & guard )

virtual

Implements netiiu.

Definition at line 1784 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     this->recvProcessPostponedFlush = true;
 }

void tcpiiu::responsiveCircuitNotify	(	epicsGuard< epicsMutex > &	cbGuard,
		epicsGuard< epicsMutex > &	guard
	)

Definition at line 860 of file tcpiiu.cpp.

 {
     cbGuard.assertIdenticalMutex ( this->cbMutex );
     guard.assertIdenticalMutex ( this->mutex );
     if ( this->unresponsiveCircuit ) {
         this->unresponsiveCircuit = false;
         while ( nciu * pChan = this->unrespCircuit.get() ) {
             this->subscripUpdateReqPend.add ( *pChan );
             pChan->channelNode::listMember =
                 channelNode::cs_subscripUpdateReqPend;
             pChan->connect ( cbGuard, guard );
         }
         this->sendThreadFlushEvent.signal ();
     }
 }

bool tcpiiu::searchMsg	(	epicsGuard< epicsMutex > &	guard,
		ca_uint32_t	id,
		const char *	pName,
		unsigned	nameLength
	)

virtual

Implements netiiu.

Definition at line 2127 of file tcpiiu.cpp.

 {
     return netiiu::searchMsg (
         guard, id, pName, nameLength );
 }

void tcpiiu::searchRespNotify	(	const epicsTime &	currentTime,
		const caHdrLargeArray &	msg
	)

Definition at line 2193 of file tcpiiu.cpp.

 {
    /*
      * the type field is abused to carry the port number
      * so that we can have multiple servers on one host
      */
     osiSockAddr serverAddr;
     if ( msg.m_cid != INADDR_BROADCAST ) {
         serverAddr.ia.sin_family = AF_INET;
         serverAddr.ia.sin_addr.s_addr = htonl ( msg.m_cid );
         serverAddr.ia.sin_port = htons ( msg.m_dataType );
     }
     else {
         serverAddr = this->address ();
     }
     cacRef.transferChanToVirtCircuit
             ( msg.m_available, msg.m_cid, 0xffff,
                 0, minorProtocolVersion, serverAddr, currentTime );
 }

unsigned tcpiiu::sendBytes	(	const void *	pBuf,
		unsigned	nBytesInBuf,
		const epicsTime &	currentTime
	)

Definition at line 231 of file tcpiiu.cpp.

 {
     unsigned nBytes = 0u;
     assert ( nBytesInBuf <= INT_MAX );
 
     this->sendDog.start ( currentTime );
 
     while ( true ) {
         int status = ::send ( this->sock,
             static_cast < const char * > (pBuf), (int) nBytesInBuf, 0 );
         if ( status > 0 ) {
             nBytes = static_cast <unsigned> ( status );
             // printf("SEND: %u\n", nBytes );
             break;
         }
         else {
             epicsGuard < epicsMutex > guard ( this->mutex );
             if ( this->state != iiucs_connected &&
                 this->state != iiucs_clean_shutdown ) {
                 break;
             }
             // winsock indicates disconnect by returning zero here
             if ( status == 0 ) {
                 this->disconnectNotify ( guard );
                 break;
             }
 
             int localError = SOCKERRNO;
 
             if ( localError == SOCK_EINTR ) {
                 continue;
             }
 
             if ( localError == SOCK_ENOBUFS ) {
                 errlogPrintf (
                     "CAC: system low on network buffers "
                     "- send retry in 15 seconds\n" );
                 {
                     epicsGuardRelease < epicsMutex > unguard ( guard );
                     epicsThreadSleep ( 15.0 );
                 }
                 continue;
             }
 
             if (
                     localError != SOCK_EPIPE &&
                     localError != SOCK_ECONNRESET &&
                     localError != SOCK_ETIMEDOUT &&
                     localError != SOCK_ECONNABORTED &&
                     localError != SOCK_SHUTDOWN ) {
                 char sockErrBuf[64];
                 epicsSocketConvertErrnoToString (
                     sockErrBuf, sizeof ( sockErrBuf ) );
                 errlogPrintf ( "CAC: unexpected TCP send error: %s\n",
                     sockErrBuf );
             }
 
             this->disconnectNotify ( guard );
             break;
         }
     }
 
     this->sendDog.cancel ();
 
     return nBytes;
 }

bool tcpiiu::sendThreadFlush ( epicsGuard< epicsMutex > & guard )

Definition at line 1665 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     if ( this->sendQue.occupiedBytes() > 0 ) {
         while ( comBuf * pBuf = this->sendQue.popNextComBufToSend () ) {
             epicsTime current = epicsTime::getCurrent ();
 
             unsigned bytesToBeSent = pBuf->occupiedBytes ();
             bool success = false;
             {
                 // no lock while blocking to send
                 epicsGuardRelease < epicsMutex > unguard ( guard );
                 success = pBuf->flushToWire ( *this, current );
                 pBuf->~comBuf ();
                 this->comBufMemMgr.release ( pBuf );
             }
 
             if ( ! success ) {
                 while ( ( pBuf = this->sendQue.popNextComBufToSend () ) ) {
                     pBuf->~comBuf ();
                     this->comBufMemMgr.release ( pBuf );
                 }
                 return false;
             }
 
             // set it here with this odd order because we must have
             // the lock and we must have already sent the bytes
             this->unacknowledgedSendBytes += bytesToBeSent;
             if ( this->unacknowledgedSendBytes >
                 this->socketLibrarySendBufferSize ) {
                 this->recvDog.sendBacklogProgressNotify ( guard );
             }
         }
     }
 
     this->earlyFlush = false;
     if ( this->blockingForFlush ) {
         this->flushBlockEvent.signal ();
     }
 
     return true;
 }

void tcpiiu::sendTimeoutNotify	(	callbackManager &	cbMgr,
		epicsGuard< epicsMutex > &	guard
	)

Definition at line 878 of file tcpiiu.cpp.

 {
     mgr.cbGuard.assertIdenticalMutex ( this-> cbMutex );
     guard.assertIdenticalMutex ( this->mutex );
     this->unresponsiveCircuitNotify ( mgr.cbGuard, guard );
     // setup circuit probe sequence
     this->recvDog.sendTimeoutNotify ( mgr.cbGuard, guard );
 }

bool tcpiiu::setEchoRequestPending ( epicsGuard< epicsMutex > & guard )

Definition at line 1121 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     this->echoRequestPending = true;
     this->sendThreadFlushEvent.signal ();
     if ( CA_V43 ( this->minorProtocolVersion ) ) {
         // we send an echo
         return true;
     }
     else {
         // we send a NOOP
         return false;
     }
 }

void tcpiiu::show ( unsigned level ) const

Definition at line 1043 of file tcpiiu.cpp.

 {
     epicsGuard < epicsMutex > locker ( this->mutex );
     char buf[256];
     this->hostNameCacheInstance.getName ( buf, sizeof ( buf ) );
     ::printf ( "Virtual circuit to \"%s\" at version V%u.%u state %u\n",
         buf, CA_MAJOR_PROTOCOL_REVISION,
         this->minorProtocolVersion, this->state );
     if ( level > 1u ) {
         ::printf ( "\tcurrent data cache pointer = %p current data cache size = %lu\n",
             static_cast < void * > ( this->pCurData ), this->curDataMax );
         ::printf ( "\tcontiguous receive message count=%u, busy detect bool=%u, flow control bool=%u\n",
             this->contigRecvMsgCount, this->busyStateDetected, this->flowControlActive );
         ::printf ( "\receive thread is busy=%u\n",
             this->_receiveThreadIsBusy );
     }
     if ( level > 2u ) {
         ::printf ( "\tvirtual circuit socket identifier %d\n", this->sock );
         ::printf ( "\tsend thread flush signal:\n" );
         this->sendThreadFlushEvent.show ( level-2u );
         ::printf ( "\tsend thread:\n" );
         this->sendThread.show ( level-2u );
         ::printf ( "\trecv thread:\n" );
         this->recvThread.show ( level-2u );
         ::printf ("\techo pending bool = %u\n", this->echoRequestPending );
         ::printf ( "IO identifier hash table:\n" );
 
         if ( this->createReqPend.count () ) {
             ::printf ( "Create request pending channels\n" );
             tsDLIterConst < nciu > pChan = this->createReqPend.firstIter ();
             while ( pChan.valid () ) {
                 pChan->show ( level - 2u );
                 pChan++;
             }
         }
         if ( this->createRespPend.count () ) {
             ::printf ( "Create response pending channels\n" );
             tsDLIterConst < nciu > pChan = this->createRespPend.firstIter ();
             while ( pChan.valid () ) {
                 pChan->show ( level - 2u );
                 pChan++;
             }
         }
         if ( this->v42ConnCallbackPend.count () ) {
             ::printf ( "V42 Conn Callback pending channels\n" );
             tsDLIterConst < nciu > pChan = this->v42ConnCallbackPend.firstIter ();
             while ( pChan.valid () ) {
                 pChan->show ( level - 2u );
                 pChan++;
             }
         }
         if ( this->subscripReqPend.count () ) {
             ::printf ( "Subscription request pending channels\n" );
             tsDLIterConst < nciu > pChan = this->subscripReqPend.firstIter ();
             while ( pChan.valid () ) {
                 pChan->show ( level - 2u );
                 pChan++;
             }
         }
         if ( this->connectedList.count () ) {
             ::printf ( "Connected channels\n" );
             tsDLIterConst < nciu > pChan = this->connectedList.firstIter ();
             while ( pChan.valid () ) {
                 pChan->show ( level - 2u );
                 pChan++;
             }
         }
         if ( this->unrespCircuit.count () ) {
             ::printf ( "Unresponsive circuit channels\n" );
             tsDLIterConst < nciu > pChan = this->unrespCircuit.firstIter ();
             while ( pChan.valid () ) {
                 pChan->show ( level - 2u );
                 pChan++;
             }
         }
     }
 }

void tcpiiu::start ( epicsGuard< epicsMutex > & guard )

Definition at line 819 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     this->recvThread.start ();
 }

void tcpiiu::subscriptionCancelRequest	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		netSubscription &	subscr
	)

virtual

Implements netiiu.

Definition at line 1645 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     // there are situations where the circuit is disconnected, but
     // the channel does not know this yet
     if ( this->state != iiucs_connected ) {
         return;
     }
     comQueSendMsgMinder minder ( this->sendQue, guard );
     this->sendQue.insertRequestHeader (
         CA_PROTO_EVENT_CANCEL, 0u,
         static_cast < ca_uint16_t > ( subscr.getType ( guard ) ),
         static_cast < ca_uint16_t > ( subscr.getCount (
             guard, CA_V413(this->minorProtocolVersion) ) ),
         chan.getSID(guard), subscr.getId(),
         CA_V49 ( this->minorProtocolVersion ) );
     minder.commit ();
 }

void tcpiiu::subscriptionRequest	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		netSubscription &	subscr
	)

virtual

Implements netiiu.

Definition at line 1557 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     // there are situations where the circuit is disconnected, but
     // the channel does not know this yet
     if ( this->state != iiucs_connected &&
         this->state != iiucs_connecting ) {
         return;
     }
     unsigned mask = subscr.getMask(guard);
     if ( mask > 0xffff ) {
         throw cacChannel::badEventSelection ();
     }
     arrayElementCount nElem = subscr.getCount (
         guard, CA_V413(this->minorProtocolVersion) );
     arrayElementCount maxBytes;
     if ( CA_V49 ( this->minorProtocolVersion ) ) {
         maxBytes = 0xfffffff0;
     }
     else {
         maxBytes = MAX_TCP;
     }
     unsigned dataType = subscr.getType ( guard );
     // data type bounds checked when sunscription created
     arrayElementCount maxElem = ( maxBytes - dbr_size[dataType] ) / dbr_value_size[dataType];
     if ( nElem > maxElem ) {
         throw cacChannel::msgBodyCacheTooSmall ();
     }
     comQueSendMsgMinder minder ( this->sendQue, guard );
     // nElement bounds checked above
     this->sendQue.insertRequestHeader (
         CA_PROTO_EVENT_ADD, 16u,
         static_cast < ca_uint16_t > ( dataType ),
         static_cast < ca_uint32_t > ( nElem ),
         chan.getSID(guard), subscr.getId(),
         CA_V49 ( this->minorProtocolVersion ) );
 
     // extension
     this->sendQue.pushFloat32 ( 0.0f ); // m_lval
     this->sendQue.pushFloat32 ( 0.0f ); // m_hval
     this->sendQue.pushFloat32 ( 0.0f ); // m_toval
     this->sendQue.pushUInt16 ( static_cast < ca_uint16_t > ( mask ) ); // m_mask
     this->sendQue.pushUInt16 ( 0u ); // m_pad
     minder.commit ();
 }

void tcpiiu::subscriptionUpdateRequest	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		netSubscription &	subscr
	)

virtual

Implements netiiu.

Definition at line 1609 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     // there are situations where the circuit is disconnected, but
     // the channel does not know this yet
     if ( this->state != iiucs_connected ) {
         return;
     }
     arrayElementCount nElem = subscr.getCount (
         guard, CA_V413(this->minorProtocolVersion) );
     arrayElementCount maxBytes;
     if ( CA_V49 ( this->minorProtocolVersion ) ) {
         maxBytes = 0xfffffff0;
     }
     else {
         maxBytes = MAX_TCP;
     }
     unsigned dataType = subscr.getType ( guard );
     // data type bounds checked when subscription constructed
     arrayElementCount maxElem = ( maxBytes - dbr_size[dataType] ) / dbr_value_size[dataType];
     if ( nElem > maxElem ) {
         throw cacChannel::msgBodyCacheTooSmall ();
     }
     comQueSendMsgMinder minder ( this->sendQue, guard );
     // nElem boounds checked above
     this->sendQue.insertRequestHeader (
         CA_PROTO_READ_NOTIFY, 0u,
         static_cast < ca_uint16_t > ( dataType ),
         static_cast < ca_uint32_t > ( nElem ),
         chan.getSID (guard), subscr.getId (),
         CA_V49 ( this->minorProtocolVersion ) );
     minder.commit ();
 }

void tcpiiu::uninstallChan	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan
	)

virtual

Implements netiiu.

Definition at line 1982 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     switch ( chan.channelNode::listMember ) {
     case channelNode::cs_createReqPend:
         this->createReqPend.remove ( chan );
         break;
     case channelNode::cs_createRespPend:
         this->createRespPend.remove ( chan );
         break;
     case channelNode::cs_v42ConnCallbackPend:
         this->v42ConnCallbackPend.remove ( chan );
         break;
     case channelNode::cs_subscripReqPend:
         this->subscripReqPend.remove ( chan );
         break;
     case channelNode::cs_connected:
         this->connectedList.remove ( chan );
         break;
     case channelNode::cs_unrespCircuit:
         this->unrespCircuit.remove ( chan );
         break;
     case channelNode::cs_subscripUpdateReqPend:
         this->subscripUpdateReqPend.remove ( chan );
         break;
     default:
         errlogPrintf (
             "cac: attempt to uninstall channel from tcp iiu, but it inst installed there?" );
     }
     chan.channelNode::listMember = channelNode::cs_none;
     this->channelCountTot--;
     if ( this->channelCountTot == 0 && ! this->isNameService() ) {
         this->initiateCleanShutdown ( guard );
     }
 }

void tcpiiu::uninstallChanDueToSuccessfulSearchResponse	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		const class epicsTime &	currentTime
	)

virtual

Implements netiiu.

Definition at line 2119 of file tcpiiu.cpp.

 {
     netiiu::uninstallChanDueToSuccessfulSearchResponse (
         guard, chan, currentTime );
 }

void tcpiiu::unlinkAllChannels	(	epicsGuard< epicsMutex > &	cbGuard,
		epicsGuard< epicsMutex > &	guard
	)

Definition at line 1869 of file tcpiiu.cpp.

 {
     cbGuard.assertIdenticalMutex ( this->cbMutex );
     guard.assertIdenticalMutex ( this->mutex );
 
     while ( nciu * pChan = this->createReqPend.get () ) {
         pChan->channelNode::listMember =
             channelNode::cs_none;
         pChan->serviceShutdownNotify ( cbGuard, guard );
     }
 
     while ( nciu * pChan = this->createRespPend.get () ) {
         pChan->channelNode::listMember =
             channelNode::cs_none;
         // we dont yet know the server's id so we cant
         // send a channel delete request and will instead
         // trust that the server can do the proper cleanup
         // when the circuit disconnects
         pChan->serviceShutdownNotify ( cbGuard, guard );
     }
 
     while ( nciu * pChan = this->v42ConnCallbackPend.get () ) {
         pChan->channelNode::listMember =
             channelNode::cs_none;
         this->clearChannelRequest ( guard,
             pChan->getSID(guard), pChan->getCID(guard) );
         pChan->serviceShutdownNotify ( cbGuard, guard );
     }
 
     while ( nciu * pChan = this->subscripReqPend.get () ) {
         pChan->channelNode::listMember =
             channelNode::cs_none;
         pChan->disconnectAllIO ( cbGuard, guard );
         this->clearChannelRequest ( guard,
             pChan->getSID(guard), pChan->getCID(guard) );
         pChan->serviceShutdownNotify ( cbGuard, guard );
     }
 
     while ( nciu * pChan = this->connectedList.get () ) {
         pChan->channelNode::listMember =
             channelNode::cs_none;
         pChan->disconnectAllIO ( cbGuard, guard );
         this->clearChannelRequest ( guard,
             pChan->getSID(guard), pChan->getCID(guard) );
         pChan->serviceShutdownNotify ( cbGuard, guard );
     }
 
     while ( nciu * pChan = this->unrespCircuit.get () ) {
         pChan->channelNode::listMember =
             channelNode::cs_none;
         pChan->disconnectAllIO ( cbGuard, guard );
         // if we know that the circuit is unresponsive
         // then we dont send a channel delete request and
         // will instead trust that the server can do the
         // proper cleanup when the circuit disconnects
         pChan->serviceShutdownNotify ( cbGuard, guard );
     }
 
      while ( nciu * pChan = this->subscripUpdateReqPend.get () ) {
         pChan->channelNode::listMember =
             channelNode::cs_none;
         pChan->disconnectAllIO ( cbGuard, guard );
         this->clearChannelRequest ( guard,
             pChan->getSID(guard), pChan->getCID(guard) );
         pChan->serviceShutdownNotify ( cbGuard, guard );
     }
 
     this->channelCountTot = 0u;
     this->initiateCleanShutdown ( guard );
 }

void tcpiiu::unresponsiveCircuitNotify	(	epicsGuard< epicsMutex > &	cbGuard,
		epicsGuard< epicsMutex > &	guard
	)

Definition at line 898 of file tcpiiu.cpp.

 {
     cbGuard.assertIdenticalMutex ( this->cbMutex );
     guard.assertIdenticalMutex ( this->mutex );
 
     if ( ! this->unresponsiveCircuit ) {
         this->unresponsiveCircuit = true;
         this->echoRequestPending = true;
         this->sendThreadFlushEvent.signal ();
         this->flushBlockEvent.signal ();
 
         // must not hold lock when canceling timer
         {
             epicsGuardRelease < epicsMutex > unguard ( guard );
             {
                 epicsGuardRelease < epicsMutex > cbUnguard ( cbGuard );
                 this->recvDog.cancel ();
                 this->sendDog.cancel ();
             }
         }
 
         if ( this->connectedList.count() ) {
             char hostNameTmp[128];
             this->getHostName ( guard, hostNameTmp, sizeof ( hostNameTmp ) );
             genLocalExcep ( cbGuard, guard, this->cacRef,
                 ECA_UNRESPTMO, hostNameTmp );
             while ( nciu * pChan = this->connectedList.get () ) {
                 // The cac lock is released herein so there is concern that
                 // the list could be changed while we are traversing it.
                 // However, this occurs only if a circuit disconnects,
                 // a user deletes a channel, or a server disconnects a
                 // channel. The callback lock must be taken in all of
                 // these situations so this code is protected.
                 this->unrespCircuit.add ( *pChan );
                 pChan->channelNode::listMember =
                     channelNode::cs_unrespCircuit;
                 pChan->unresponsiveCircuitNotify ( cbGuard, guard );
             }
         }
     }
 }

void tcpiiu::userNameSetRequest ( epicsGuard< epicsMutex > & guard )

Definition at line 1321 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     if ( ! CA_V41 ( this->minorProtocolVersion ) ) {
         return;
     }
 
     const char *pName = this->cacRef.userNamePointer ();
     unsigned size = strlen ( pName ) + 1u;
     unsigned postSize = CA_MESSAGE_ALIGN ( size );
     assert ( postSize < 0xffff );
 
     if ( this->sendQue.flushEarlyThreshold ( postSize + 16u ) ) {
         this->flushRequest ( guard );
     }
 
     comQueSendMsgMinder minder ( this->sendQue, guard );
     this->sendQue.insertRequestHeader (
         CA_PROTO_CLIENT_NAME, postSize,
         0u, 0u, 0u, 0u,
         CA_V49 ( this->minorProtocolVersion ) );
     this->sendQue.pushString ( pName, size );
     this->sendQue.pushString ( cacNillBytes, postSize - size );
     minder.commit ();
 }

void tcpiiu::versionMessage	(	epicsGuard< epicsMutex > &	guard,
		const cacChannel::priLev &	priority
	)

Definition at line 1380 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     assert ( priority <= 0xffff );
 
     if ( this->sendQue.flushEarlyThreshold ( 16u ) ) {
         this->flushRequest ( guard );
     }
 
     comQueSendMsgMinder minder ( this->sendQue, guard );
     this->sendQue.insertRequestHeader (
         CA_PROTO_VERSION, 0u,
         static_cast < ca_uint16_t > ( priority ),
         CA_MINOR_PROTOCOL_REVISION, 0u, 0u,
         CA_V49 ( this->minorProtocolVersion ) );
     minder.commit ();
 }

void tcpiiu::versionRespNotify ( const caHdrLargeArray & msg )

Definition at line 2188 of file tcpiiu.cpp.

 {
     this->minorProtocolVersion = msg.m_count;
 }

void tcpiiu::writeNotifyRequest	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		netWriteNotifyIO &	io,
		unsigned	type,
		arrayElementCount	nElem,
		const void *	pValue
	)

virtual

Implements netiiu.

Definition at line 1436 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
 
     if ( ! this->ca_v41_ok ( guard ) ) {
         throw cacChannel::unsupportedByService();
     }
     if ( INVALID_DB_REQ ( type ) ) {
         throw cacChannel::badType ();
     }
     comQueSendMsgMinder minder ( this->sendQue, guard );
     this->sendQue.insertRequestWithPayLoad ( CA_PROTO_WRITE_NOTIFY,
         type, nElem, chan.getSID(guard), io.getId(), pValue,
         CA_V49 ( this->minorProtocolVersion ) );
     minder.commit ();
 }

void tcpiiu::writeRequest	(	epicsGuard< epicsMutex > &	guard,
		nciu &	chan,
		unsigned	type,
		arrayElementCount	nElem,
		const void *	pValue
	)

virtual

Implements netiiu.

Definition at line 1421 of file tcpiiu.cpp.

 {
     guard.assertIdenticalMutex ( this->mutex );
     if ( INVALID_DB_REQ ( type ) ) {
         throw cacChannel::badType ();
     }
     comQueSendMsgMinder minder ( this->sendQue, guard );
     this->sendQue.insertRequestWithPayLoad ( CA_PROTO_WRITE,
         type, nElem, chan.getSID(guard), chan.getCID(guard), pValue,
         CA_V49 ( this->minorProtocolVersion ) );
     minder.commit ();
 }

Friends And Related Function Documentation

void SearchDestTCP::searchRequest	(	epicsGuard< epicsMutex > &	guard,
		const char *	pbuf,
		size_t	len
	)

friend

friend class tcpRecvThread

friend

Definition at line 331 of file virtualCircuit.h.

friend class tcpSendThread

friend

Definition at line 332 of file virtualCircuit.h.

Member Data Documentation

bool tcpiiu::_receiveThreadIsBusy

Definition at line 248 of file virtualCircuit.h.

unsigned tcpiiu::blockingForFlush

Definition at line 244 of file virtualCircuit.h.

bool tcpiiu::busyStateDetected

Definition at line 249 of file virtualCircuit.h.

cac& tcpiiu::cacRef

Definition at line 227 of file virtualCircuit.h.

epicsMutex& tcpiiu::cbMutex

Definition at line 231 of file virtualCircuit.h.

unsigned tcpiiu::channelCountTot

Definition at line 247 of file virtualCircuit.h.

comBufMemoryManager& tcpiiu::comBufMemMgr

Definition at line 226 of file virtualCircuit.h.

tsDLList< nciu > tcpiiu::connectedList

Definition at line 220 of file virtualCircuit.h.

unsigned tcpiiu::contigRecvMsgCount

Definition at line 243 of file virtualCircuit.h.

tsDLList< nciu > tcpiiu::createReqPend

Definition at line 216 of file virtualCircuit.h.

tsDLList< nciu > tcpiiu::createRespPend

Definition at line 217 of file virtualCircuit.h.

arrayElementCount tcpiiu::curDataBytes

Definition at line 225 of file virtualCircuit.h.

arrayElementCount tcpiiu::curDataMax

Definition at line 224 of file virtualCircuit.h.

caHdrLargeArray tcpiiu::curMsg

Definition at line 223 of file virtualCircuit.h.

bool tcpiiu::discardingPendingData

Definition at line 256 of file virtualCircuit.h.

bool tcpiiu::earlyFlush

Definition at line 254 of file virtualCircuit.h.

bool tcpiiu::echoRequestPending

Definition at line 251 of file virtualCircuit.h.

bool tcpiiu::flowControlActive

Definition at line 250 of file virtualCircuit.h.

epicsEvent tcpiiu::flushBlockEvent

Definition at line 241 of file virtualCircuit.h.

unsigned tcpiiu::minorProtocolVersion

Definition at line 232 of file virtualCircuit.h.

bool tcpiiu::msgHeaderAvailable

Definition at line 253 of file virtualCircuit.h.

epicsMutex& tcpiiu::mutex

Definition at line 230 of file virtualCircuit.h.

bool tcpiiu::oldMsgHeaderAvailable

Definition at line 252 of file virtualCircuit.h.

char* tcpiiu::pCurData

Definition at line 228 of file virtualCircuit.h.

SearchDestTCP* tcpiiu::pSearchDest

Definition at line 229 of file virtualCircuit.h.

tcpRecvWatchdog tcpiiu::recvDog

Definition at line 210 of file virtualCircuit.h.

bool tcpiiu::recvProcessPostponedFlush

Definition at line 255 of file virtualCircuit.h.

comQueRecv tcpiiu::recvQue

Definition at line 213 of file virtualCircuit.h.

epicsPlacementDeleteOperator (( void *, tsFreeList < class tcpiiu, 32, epicsMutexNOOP > & )) private tcpRecvThrea tcpiiu::recvThread)

Definition at line 203 of file virtualCircuit.h.

tcpSendWatchdog tcpiiu::sendDog

Definition at line 211 of file virtualCircuit.h.

comQueSend tcpiiu::sendQue

Definition at line 212 of file virtualCircuit.h.

tcpSendThread tcpiiu::sendThread

Definition at line 209 of file virtualCircuit.h.

epicsEvent tcpiiu::sendThreadFlushEvent

Definition at line 240 of file virtualCircuit.h.

SOCKET tcpiiu::sock

Definition at line 242 of file virtualCircuit.h.

bool tcpiiu::socketHasBeenClosed

Definition at line 257 of file virtualCircuit.h.

unsigned tcpiiu::socketLibrarySendBufferSize

Definition at line 245 of file virtualCircuit.h.

enum tcpiiu::iiu_conn_state tcpiiu::state

tsDLList< nciu > tcpiiu::subscripReqPend

Definition at line 219 of file virtualCircuit.h.

tsDLList< nciu > tcpiiu::subscripUpdateReqPend

Definition at line 222 of file virtualCircuit.h.

unsigned tcpiiu::unacknowledgedSendBytes

Definition at line 246 of file virtualCircuit.h.

tsDLList< nciu > tcpiiu::unrespCircuit

Definition at line 221 of file virtualCircuit.h.

bool tcpiiu::unresponsiveCircuit

Definition at line 258 of file virtualCircuit.h.

tsDLList< nciu > tcpiiu::v42ConnCallbackPend

Definition at line 218 of file virtualCircuit.h.

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

modules/ca/src/client/virtualCircuit.h
modules/ca/src/client/tcpiiu.cpp

Public Types

Public Member Functions

Public Attributes

Friends

Detailed Description

Member Enumeration Documentation

Constructor & Destructor Documentation

Member Function Documentation

Friends And Related Function Documentation

Member Data Documentation