oldChannelNotify.cpp File Reference

#include <string>
#include <stdexcept>
#include "errlog.h"
#include "iocinf.h"
#include "oldAccess.h"
#include "cac.h"
#include "autoPtrFreeList.h"

Include dependency graph for oldChannelNotify.cpp:

Go to the source code of this file.

Macros
#define	epicsAssertAuthor   "Jeff Hill johill@lanl.gov"

Functions
void	cacNoopAccesRightsHandler (struct access_rights_handler_args)
unsigned epicsStdCall	ca_get_host_name (chid pChan, char *pBuf, unsigned bufLength)
const char *epicsStdCall	ca_host_name (chid pChan)
void epicsStdCall	ca_set_puser (chid pChan, void *puser)
void *epicsStdCall	ca_puser (chid pChan)
int epicsStdCall	ca_change_connection_event (chid pChan, caCh *pfunc)
int epicsStdCall	ca_replace_access_rights_event (chid pChan, caArh *pfunc)
int epicsStdCall	ca_array_get (chtype type, arrayElementCount count, chid pChan, void *pValue)
int epicsStdCall	ca_array_get_callback (chtype type, arrayElementCount count, chid pChan, caEventCallBackFunc *pfunc, void *arg)
int epicsStdCall	ca_array_put_callback (chtype type, arrayElementCount count, chid pChan, const void *pValue, caEventCallBackFunc *pfunc, void *usrarg)
int epicsStdCall	ca_array_put (chtype type, arrayElementCount count, chid pChan, const void *pValue)
int epicsStdCall	ca_create_subscription (chtype type, arrayElementCount count, chid pChan, long mask, caEventCallBackFunc *pCallBack, void *pCallBackArg, evid *monixptr)
short epicsStdCall	ca_field_type (chid pChan)
arrayElementCount epicsStdCall	ca_element_count (chid pChan)
enum channel_state epicsStdCall	ca_state (chid pChan)
unsigned epicsStdCall	ca_read_access (chid pChan)
unsigned epicsStdCall	ca_write_access (chid pChan)
const char *epicsStdCall	ca_name (chid pChan)
unsigned epicsStdCall	ca_search_attempts (chid pChan)
double epicsStdCall	ca_beacon_period (chid pChan)
double epicsStdCall	ca_receive_watchdog_delay (chid pChan)
int epicsStdCall	ca_v42_ok (chid pChan)

Macro Definition Documentation

#define epicsAssertAuthor   "Jeff Hill johill@lanl.gov"

Definition at line 31 of file oldChannelNotify.cpp.

Function Documentation

int epicsStdCall ca_array_get	(	chtype	type,
		arrayElementCount	count,
		chid	pChan,
		void *	pValue
	)

Definition at line 267 of file oldChannelNotify.cpp.

{
    int caStatus;
    try {
        if ( type < 0 ) {
            return ECA_BADTYPE;
        }
        if ( count == 0 )
            return ECA_BADCOUNT;

        unsigned tmpType = static_cast < unsigned > ( type );
        epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
        pChan->eliminateExcessiveSendBacklog ( guard );
        autoPtrFreeList < getCopy, 0x400, epicsMutexNOOP > pNotify
            ( pChan->getClientCtx().getCopyFreeList,
                new ( pChan->getClientCtx().getCopyFreeList )
                    getCopy ( guard, pChan->getClientCtx(), *pChan,
                                tmpType, count, pValue ) );
        pChan->io.read ( guard, type, count, *pNotify, 0 );
        pNotify.release ();
        caStatus = ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        caStatus = ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        caStatus = ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        caStatus = ECA_BADCOUNT;
    }
    catch ( cacChannel::noReadAccess & )
    {
        caStatus = ECA_NORDACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        caStatus = ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        caStatus = ECA_UNAVAILINSERV;
    }
    catch ( cacChannel::requestTimedOut & )
    {
        caStatus = ECA_TIMEOUT;
    }
    catch ( std::bad_alloc & )
    {
        caStatus = ECA_ALLOCMEM;
    }
    catch ( cacChannel::msgBodyCacheTooSmall & ) {
        caStatus = ECA_TOLARGE;
    }
    catch ( ... )
    {
        caStatus = ECA_GETFAIL;
    }
    return caStatus;
}

int epicsStdCall ca_array_get_callback	(	chtype	type,
		arrayElementCount	count,
		chid	pChan,
		caEventCallBackFunc *	pfunc,
		void *	arg
	)

Definition at line 335 of file oldChannelNotify.cpp.

{
    int caStatus;
    try {
        if ( type < 0 ) {
            return ECA_BADTYPE;
        }
        if ( pfunc == NULL ) {
            return ECA_BADFUNCPTR;
        }
        unsigned tmpType = static_cast < unsigned > ( type );

        epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
        pChan->eliminateExcessiveSendBacklog ( guard );
        autoPtrFreeList < getCallback, 0x400, epicsMutexNOOP > pNotify
            ( pChan->getClientCtx().getCallbackFreeList,
            new ( pChan->getClientCtx().getCallbackFreeList )
                getCallback ( *pChan, pfunc, arg ) );
        pChan->io.read ( guard, tmpType, count, *pNotify, 0 );
        pNotify.release ();
        caStatus = ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        caStatus = ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        caStatus = ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        caStatus = ECA_BADCOUNT;
    }
    catch ( cacChannel::noReadAccess & )
    {
        caStatus = ECA_NORDACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        caStatus = ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        caStatus = ECA_UNAVAILINSERV;
    }
    catch ( cacChannel::requestTimedOut & )
    {
        caStatus = ECA_TIMEOUT;
    }
    catch ( std::bad_alloc & )
    {
        caStatus = ECA_ALLOCMEM;
    }
    catch ( cacChannel::msgBodyCacheTooSmall & ) {
        caStatus = ECA_TOLARGE;
    }
    catch ( ... )
    {
        caStatus = ECA_GETFAIL;
    }
    return caStatus;
}

int epicsStdCall ca_array_put	(	chtype	type,
		arrayElementCount	count,
		chid	pChan,
		const void *	pValue
	)

Definition at line 476 of file oldChannelNotify.cpp.

{
    if ( type < 0 ) {
        return ECA_BADTYPE;
    }
    unsigned tmpType = static_cast < unsigned > ( type );

    int caStatus;
    try {
        epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
        pChan->eliminateExcessiveSendBacklog ( guard );
        pChan->io.write ( guard, tmpType, count, pValue );
        caStatus = ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        caStatus = ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        caStatus = ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        caStatus = ECA_BADCOUNT;
    }
    catch ( cacChannel::noWriteAccess & )
    {
        caStatus = ECA_NOWTACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        caStatus = ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        caStatus = ECA_UNAVAILINSERV;
    }
    catch ( cacChannel::requestTimedOut & )
    {
        caStatus = ECA_TIMEOUT;
    }
    catch ( std::bad_alloc & )
    {
        caStatus = ECA_ALLOCMEM;
    }
    catch ( ... )
    {
        caStatus = ECA_PUTFAIL;
    }
    return caStatus;
}

int epicsStdCall ca_array_put_callback	(	chtype	type,
		arrayElementCount	count,
		chid	pChan,
		const void *	pValue,
		caEventCallBackFunc *	pfunc,
		void *	usrarg
	)

Definition at line 412 of file oldChannelNotify.cpp.

{
    int caStatus;
    try {
        if ( type < 0 ) {
            return ECA_BADTYPE;
        }
        if ( pfunc == NULL ) {
            return ECA_BADFUNCPTR;
        }
        epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
        pChan->eliminateExcessiveSendBacklog ( guard );
        unsigned tmpType = static_cast < unsigned > ( type );
        autoPtrFreeList < putCallback, 0x400, epicsMutexNOOP > pNotify
                ( pChan->getClientCtx().putCallbackFreeList,
                    new ( pChan->getClientCtx().putCallbackFreeList )
                        putCallback ( *pChan, pfunc, usrarg ) );
        pChan->io.write ( guard, tmpType, count, pValue, *pNotify, 0 );
        pNotify.release ();
        caStatus = ECA_NORMAL;
    }
    catch ( cacChannel::badString & )
    {
        caStatus = ECA_BADSTR;
    }
    catch ( cacChannel::badType & )
    {
        caStatus = ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        caStatus = ECA_BADCOUNT;
    }
    catch ( cacChannel::noWriteAccess & )
    {
        caStatus = ECA_NOWTACCESS;
    }
    catch ( cacChannel::notConnected & )
    {
        caStatus = ECA_DISCONN;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        caStatus = ECA_UNAVAILINSERV;
    }
    catch ( cacChannel::requestTimedOut & )
    {
        caStatus = ECA_TIMEOUT;
    }
    catch ( std::bad_alloc & )
    {
        caStatus = ECA_ALLOCMEM;
    }
    catch ( ... )
    {
        caStatus = ECA_PUTFAIL;
    }
    return caStatus;
}

double epicsStdCall ca_beacon_period

(

chid

pChan

)

Definition at line 686 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    return pChan->io.beaconPeriod ( guard );
}

int epicsStdCall ca_change_connection_event	(	chid	pChan,
		caCh *	pfunc
	)

Definition at line 218 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    if ( ! pChan->currentlyConnected ) {
         if ( pfunc ) {
            if ( ! pChan->pConnCallBack ) {
                pChan->cacCtx.decrementOutstandingIO ( guard, pChan->ioSeqNo );
            }
        }
        else {
            if ( pChan->pConnCallBack ) {
                pChan->cacCtx.incrementOutstandingIO ( guard, pChan->ioSeqNo );
            }
        }
    }
    pChan->pConnCallBack = pfunc;
    return ECA_NORMAL;
}

int epicsStdCall ca_create_subscription	(	chtype	type,
		arrayElementCount	count,
		chid	pChan,
		long	mask,
		caEventCallBackFunc *	pCallBack,
		void *	pCallBackArg,
		evid *	monixptr
	)

Definition at line 530 of file oldChannelNotify.cpp.

{
    if ( type < 0 ) {
        return ECA_BADTYPE;
    }
    unsigned tmpType = static_cast < unsigned > ( type );

    if ( INVALID_DB_REQ (type) ) {
        return ECA_BADTYPE;
    }

    if ( pCallBack == NULL ) {
        return ECA_BADFUNCPTR;
    }

    static const long maskMask = 0xffff;
    if ( ( mask & maskMask ) == 0) {
        return ECA_BADMASK;
    }

    if ( mask & ~maskMask ) {
        return ECA_BADMASK;
    }

    try {
        epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
        try {
            // if this stalls out on a live circuit then an exception
            // can be forthcoming which we must ignore (this is a
            // special case preserving legacy ca_create_subscription
            // behavior)
            pChan->eliminateExcessiveSendBacklog ( guard );
        }
        catch ( cacChannel::notConnected & ) {
            // intentionally ignored (its ok to subscribe when not connected)
        }
        new ( pChan->getClientCtx().subscriptionFreeList )
            oldSubscription  (
                guard, *pChan, pChan->io, tmpType, count, mask,
                pCallBack, pCallBackArg, monixptr );
        // dont touch object created after above new because
        // the first callback might have canceled, and therefore
        // destroyed, it
        return ECA_NORMAL;
    }
    catch ( cacChannel::badType & )
    {
        return ECA_BADTYPE;
    }
    catch ( cacChannel::outOfBounds & )
    {
        return ECA_BADCOUNT;
    }
    catch ( cacChannel::badEventSelection & )
    {
        return ECA_BADMASK;
    }
    catch ( cacChannel::noReadAccess & )
    {
        return ECA_NORDACCESS;
    }
    catch ( cacChannel::unsupportedByService & )
    {
        return ECA_UNAVAILINSERV;
    }
    catch ( std::bad_alloc & )
    {
        return ECA_ALLOCMEM;
    }
    catch ( cacChannel::msgBodyCacheTooSmall & ) {
        return ECA_TOLARGE;
    }
    catch ( ... )
    {
        return ECA_INTERNAL;
    }
}

arrayElementCount epicsStdCall ca_element_count

(

chid

pChan

)

Definition at line 630 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    return pChan->io.nativeElementCount ( guard );
}

short epicsStdCall ca_field_type

(

chid

pChan

)

Definition at line 621 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    return pChan->io.nativeType ( guard );
}

unsigned epicsStdCall ca_get_host_name	(	chid	pChan,
		char *	pBuf,
		unsigned	bufLength
	)

Definition at line 175 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef() );
    return pChan->io.getHostName ( guard, pBuf, bufLength );
}

const char* epicsStdCall ca_host_name

(

chid

pChan

)

Definition at line 188 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    return pChan->io.pHostName ( guard );
}

const char* epicsStdCall ca_name

(

chid

pChan

)

Definition at line 674 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    return pChan->io.pName ( guard );
}

void* epicsStdCall ca_puser

(

chid

pChan

)

Definition at line 208 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    return pChan->pPrivate;
}

unsigned epicsStdCall ca_read_access

(

chid

pChan

)

Definition at line 656 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    return pChan->io.accessRights(guard).readPermit();
}

double epicsStdCall ca_receive_watchdog_delay

(

chid

pChan

)

Definition at line 692 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    return pChan->io.receiveWatchdogDelay ( guard );
}

int epicsStdCall ca_replace_access_rights_event	(	chid	pChan,
		caArh *	pfunc
	)

Definition at line 240 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );

    // The order of the following is significant to guarantee that the
    // access rights handler is always gets called even if the channel connects
    // while this is running. There is some very small chance that the
    // handler could be called twice here with the same access rights state, but
    // that will not upset the application.
    pChan->pAccessRightsFunc = pfunc ? pfunc : cacNoopAccesRightsHandler;
    caAccessRights tmp = pChan->io.accessRights ( guard );

    if ( pChan->currentlyConnected ) {
        struct access_rights_handler_args args;
        args.chid = pChan;
        args.ar.read_access = tmp.readPermit ();
        args.ar.write_access = tmp.writePermit ();
        epicsGuardRelease < epicsMutex > unguard ( guard );
        ( *pChan->pAccessRightsFunc ) ( args );
    }
    return ECA_NORMAL;
}

unsigned epicsStdCall ca_search_attempts

(

chid

pChan

)

Definition at line 680 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    return pChan->io.searchAttempts ( guard );
}

void epicsStdCall ca_set_puser	(	chid	pChan,
		void *	puser
	)

Definition at line 198 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    pChan->pPrivate = puser;
}

enum channel_state epicsStdCall ca_state

(

chid

pChan

)

Definition at line 639 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    if ( pChan->io.connected ( guard ) ) {
        return cs_conn;
    }
    else if ( pChan->prevConnected ){
        return cs_prev_conn;
    }
    else {
        return cs_never_conn;
    }
}

int epicsStdCall ca_v42_ok

(

chid

pChan

)

Definition at line 701 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    return pChan->io.ca_v42_ok ( guard );
}

unsigned epicsStdCall ca_write_access

(

chid

pChan

)

Definition at line 665 of file oldChannelNotify.cpp.

{
    epicsGuard < epicsMutex > guard ( pChan->cacCtx.mutexRef () );
    return pChan->io.accessRights(guard).writePermit();
}

void cacNoopAccesRightsHandler

(

struct access_rights_handler_args

)

Definition at line 40 of file oldChannelNotify.cpp.

{
}