server.h File Reference

#include "epicsThread.h"
#include "epicsMutex.h"
#include "epicsEvent.h"
#include "bucketLib.h"
#include "asLib.h"
#include "dbChannel.h"
#include "dbNotify.h"
#include "caProto.h"
#include "ellLib.h"
#include "epicsTime.h"
#include "epicsAssert.h"
#include "osiSock.h"

Include dependency graph for server.h:

This graph shows which files directly or indirectly include this file:

Go to the source code of this file.

Classes
struct	caHdrLargeArray
struct	message_buffer
struct	client
struct	channel_in_use
struct	event_ext
struct	rsrv_iface_config

Macros
#define	CA_MINOR_PROTOCOL_REVISION   13
#define	GLBLTYPE   extern
#define	GLBLTYPE_INIT(A)
#define	DLOG(LEVEL, ARGSINPAREN)
#define	CAS_HASH_TABLE_SIZE   4096
#define	SEND_LOCK(CLIENT)   epicsMutexMustLock((CLIENT)->lock)
#define	SEND_UNLOCK(CLIENT)   epicsMutexUnlock((CLIENT)->lock)
#define	LOCK_CLIENTQ   epicsMutexMustLock (clientQlock);
#define	UNLOCK_CLIENTQ   epicsMutexUnlock (clientQlock);

Typedefs
typedef struct caHdrLargeArray	caHdrLargeArray
typedef struct client	client

Enumerations
enum	messageBufferType { mbtUDP, mbtSmallTCP, mbtLargeTCP }
enum	rsrvChanState {   rsrvCS_invalid, rsrvCS_pendConnectResp, rsrvCS_inService, rsrvCS_pendConnectRespUpdatePendAR,   rsrvCS_inServiceUpdatePendAR, rsrvCS_shutdown }
enum	ctl { ctlInit, ctlRun, ctlPause, ctlExit }

Functions
GLBLTYPE ELLLIST clientQ	GLBLTYPE_INIT (ELLLIST_INIT)
void	camsgtask (void *client)
void	cas_send_bs_msg (struct client *pclient, int lock_needed)
void	cas_send_dg_msg (struct client *pclient)
void	rsrv_online_notify_task (void *)
void	cast_server (void *)
struct client *	create_client (SOCKET sock, int proto)
void	destroy_client (struct client *)
struct client *	create_tcp_client (SOCKET sock, const osiSockAddr *peerAddr)
void	destroy_tcp_client (struct client *)
void	casAttachThreadToClient (struct client *)
int	camessage (struct client *client)
void	rsrv_extra_labor (void *pArg)
int	rsrvCheckPut (const struct channel_in_use *pciu)
int	rsrv_version_reply (struct client *client)
void	rsrvFreePutNotify (struct client *pClient, struct rsrv_put_notify *pNotify)
void	initializePutNotifyFreeList (void)
unsigned	rsrvSizeOfPutNotify (struct rsrv_put_notify *pNotify)
void	casExpandRecvBuffer (struct client *pClient, ca_uint32_t size)
void	casExpandSendBuffer (struct client *pClient, ca_uint32_t size)
int	cas_copy_in_header (struct client *pClient, ca_uint16_t response, ca_uint32_t payloadSize, ca_uint16_t dataType, ca_uint32_t nElem, ca_uint32_t cid, ca_uint32_t responseSpecific, void **pPayload)
void	cas_set_header_cid (struct client *pClient, ca_uint32_t)
void	cas_set_header_count (struct client *pClient, ca_uint32_t count)
void	cas_commit_msg (struct client *pClient, ca_uint32_t size)

Variables
epicsThreadPrivateId	rsrvCurrentClient
GLBLTYPE int	CASDEBUG
GLBLTYPE unsigned short	ca_server_port
GLBLTYPE unsigned short	ca_udp_port
GLBLTYPE unsigned short	ca_beacon_port
GLBLTYPE ELLLIST	servers
GLBLTYPE ELLLIST	beaconAddrList
GLBLTYPE SOCKET	beaconSocket
GLBLTYPE ELLLIST	casIntfAddrList
GLBLTYPE ELLLIST	casMCastAddrList
GLBLTYPE epicsUInt32 *	casIgnoreAddrs
GLBLTYPE epicsMutexId	clientQlock
GLBLTYPE BUCKET *	pCaBucket
GLBLTYPE void *	rsrvClientFreeList
GLBLTYPE void *	rsrvChanFreeList
GLBLTYPE void *	rsrvEventFreeList
GLBLTYPE void *	rsrvSmallBufFreeListTCP
GLBLTYPE void *	rsrvLargeBufFreeListTCP
GLBLTYPE unsigned	rsrvSizeofLargeBufTCP
GLBLTYPE void *	rsrvPutNotifyFreeList
GLBLTYPE unsigned	rsrvChannelCount
GLBLTYPE epicsEventId	casudp_startStopEvent
GLBLTYPE epicsEventId	beacon_startStopEvent
GLBLTYPE epicsEventId	castcp_startStopEvent
GLBLTYPE enum ctl	casudp_ctl
GLBLTYPE enum ctl	beacon_ctl
GLBLTYPE enum ctl	castcp_ctl
GLBLTYPE unsigned int	threadPrios [5]

Macro Definition Documentation

#define CA_MINOR_PROTOCOL_REVISION   13

Definition at line 30 of file server.h.

#define CAS_HASH_TABLE_SIZE   4096

Definition at line 218 of file server.h.

#define DLOG	(		LEVEL,
			ARGSINPAREN
	)

Definition at line 187 of file server.h.

#define GLBLTYPE   extern

Definition at line 176 of file server.h.

#define GLBLTYPE_INIT

(

A

)

Definition at line 177 of file server.h.

#define LOCK_CLIENTQ   epicsMutexMustLock (clientQlock);

Definition at line 223 of file server.h.

#define SEND_LOCK

(

CLIENT

)

epicsMutexMustLock((CLIENT)->lock)

Definition at line 220 of file server.h.

#define SEND_UNLOCK

(

CLIENT

)

epicsMutexUnlock((CLIENT)->lock)

Definition at line 221 of file server.h.

#define UNLOCK_CLIENTQ   epicsMutexUnlock (clientQlock);

Definition at line 224 of file server.h.

Typedef Documentation

typedef struct caHdrLargeArray caHdrLargeArray

typedef struct client client

Enumeration Type Documentation

enum ctl

Enumerator
ctlInit
ctlRun
ctlPause
ctlExit

Definition at line 169 of file server.h.

{ctlInit, ctlRun, ctlPause, ctlExit};

enum messageBufferType

Enumerator
mbtUDP
mbtSmallTCP
mbtLargeTCP

Definition at line 63 of file server.h.

{ mbtUDP, mbtSmallTCP, mbtLargeTCP };

enum rsrvChanState

Enumerator
rsrvCS_invalid
rsrvCS_pendConnectResp
rsrvCS_inService
rsrvCS_pendConnectRespUpdatePendAR
rsrvCS_inServiceUpdatePendAR
rsrvCS_shutdown

Definition at line 118 of file server.h.

                   {
    rsrvCS_invalid,
    rsrvCS_pendConnectResp,
    rsrvCS_inService,
    rsrvCS_pendConnectRespUpdatePendAR,
    rsrvCS_inServiceUpdatePendAR,
    rsrvCS_shutdown
};

Function Documentation

int camessage

(

struct client *

client

)

Definition at line 2391 of file camessage.c.

{
    unsigned nmsg = 0;
    unsigned msgsize;
    unsigned bytes_left;
    int status = RSRV_ERROR;

    assert(pCaBucket);

    /* drain remnents of large messages that will not fit */
    if ( client->recvBytesToDrain ) {
        if ( client->recvBytesToDrain >= client->recv.cnt ) {
            client->recvBytesToDrain -= client->recv.cnt;
            client->recv.stk = client->recv.cnt;
            return RSRV_OK;
        }
        else {
            client->recv.stk += client->recvBytesToDrain;
            client->recvBytesToDrain = 0u;
        }
    }

    DLOG ( 2, ( "CAS: Parsing %d(decimal) bytes\n", recv->cnt ) );

    while ( 1 )
    {
        caHdrLargeArray msg;
        caHdr *mp;
        void *pBody;

        /* wait for at least a complete caHdr */
        bytes_left = client->recv.cnt - client->recv.stk;
        if ( bytes_left < sizeof(*mp) ) {
            status = RSRV_OK;
            break;
        }

        mp = (caHdr *) &client->recv.buf[client->recv.stk];
        msg.m_cmmd      = ntohs ( mp->m_cmmd );
        msg.m_postsize  = ntohs ( mp->m_postsize );
        msg.m_dataType  = ntohs ( mp->m_dataType );
        msg.m_count     = ntohs ( mp->m_count );
        msg.m_cid       = ntohl ( mp->m_cid );
        msg.m_available = ntohl ( mp->m_available );

        if ( CA_V49(client->minor_version_number) && msg.m_postsize == 0xffff  ) {
            ca_uint32_t *pLW = ( ca_uint32_t * ) ( mp + 1 );
            if ( bytes_left < sizeof(*mp) + 2 * sizeof(*pLW) ) {
                status = RSRV_OK;
                break;
            }
            msg.m_postsize  = ntohl ( pLW[0] );
            msg.m_count     = ntohl ( pLW[1] );
            msgsize = msg.m_postsize + sizeof(*mp) + 2 * sizeof ( *pLW );
            pBody = ( void * ) ( pLW + 2 );
        }
        else {
            msgsize = msg.m_postsize + sizeof(*mp);
            pBody = ( void * ) ( mp + 1 );
        }

        /* ignore deprecated clients, but let newer clients identify themselves. */
        if (msg.m_cmmd!=CA_PROTO_VERSION && !CA_VSUPPORTED(client->minor_version_number)) {
            if (client->proto==IPPROTO_TCP) {
                /* log and error for too old clients, but keep the connection open to avoid a
                 * re-connect loop.
                 */
                SEND_LOCK(client);
                send_err ( &msg, ECA_DEFUNCT, client,
                    "CAS: Client version %u too old", client->minor_version_number );
                SEND_UNLOCK(client);
                log_header ( "CAS: Client version too old",
                    client, &msg, 0, nmsg );
                client->recvBytesToDrain = msgsize - bytes_left;
                client->recv.stk = client->recv.cnt;
                status = RSRV_OK;
            } else {
                /* silently ignore UDP from old clients */
                status = RSRV_ERROR;
            }
            break;
        }

        /*
         * disconnect clients that dont send 8 byte
         * aligned payloads
         */
        if ( msgsize & 0x7 ) {
            if (client->proto==IPPROTO_TCP) {
                SEND_LOCK(client);
                send_err ( &msg, ECA_INTERNAL, client,
                    "CAS: Missaligned protocol rejected" );
                SEND_UNLOCK(client);
                log_header ( "CAS: Missaligned protocol rejected",
                    client, &msg, 0, nmsg );
            }
            status = RSRV_ERROR;
            break;
        }

        /* problem: we have a complete header,
         * but before we check msgsize we don't know
         * if we have a complete message body
         * -> we may be called again with the same header
         *    after receiving the full message
         */
        if ( msgsize > client->recv.maxstk ) {
            casExpandRecvBuffer ( client, msgsize );
            if ( msgsize > client->recv.maxstk ) {
                if (client->proto==IPPROTO_TCP) {
                    SEND_LOCK(client);
                    send_err ( &msg, ECA_TOLARGE, client,
                        "CAS: Server unable to load large request message. Max bytes=%lu",
                        rsrvSizeofLargeBufTCP );
                    SEND_UNLOCK(client);
                    log_header ( "CAS: server unable to load large request message",
                        client, &msg, 0, nmsg );
                }
                assert ( client->recv.cnt <= client->recv.maxstk );
                assert ( msgsize >= bytes_left );
                client->recvBytesToDrain = msgsize - bytes_left;
                client->recv.stk = client->recv.cnt;
                status = RSRV_OK;
                break;
            }
        }

        /*
         * wait for complete message body
         */
        if ( msgsize > bytes_left ) {
            status = RSRV_OK;
            break;
        }

        nmsg++;

        if ( CASDEBUG > 2 )
            log_header (NULL, client, &msg, pBody, nmsg);

        if ( client->proto==IPPROTO_UDP ) {
            if ( msg.m_cmmd < NELEMENTS ( udpJumpTable ) ) {
                status = ( *udpJumpTable[msg.m_cmmd] )( &msg, pBody, client );
                if (status!=RSRV_OK) {
                    status = RSRV_ERROR;
                    break;
                }
            }
            else {
                status = bad_udp_cmd_action ( &msg, pBody, client );
                break;
            }
        }
        else {
            if ( msg.m_cmmd < NELEMENTS(tcpJumpTable) ) {
                status = ( *tcpJumpTable[msg.m_cmmd] ) ( &msg, pBody, client );
                if ( status != RSRV_OK ) {
                    status = RSRV_ERROR;
                    break;
                }
            }
            else {
                return bad_tcp_cmd_action ( &msg, pBody, client );
            }
        }

        client->recv.stk += msgsize;
    }

    return status;
}

void camsgtask

(

void *

client

)

Definition at line 42 of file camsgtask.c.

{
    struct client *client = (struct client *) pParm;

    casAttachThreadToClient ( client );

    while (castcp_ctl == ctlRun && !client->disconnect) {
        osiSockIoctl_t check_nchars;
        long nchars;
        int status;

        /*
         * allow message to batch up if more are comming
         */
        status = socket_ioctl (client->sock, FIONREAD, &check_nchars);
        if (status < 0) {
            char sockErrBuf[64];

            epicsSocketConvertErrnoToString (
                sockErrBuf, sizeof ( sockErrBuf ) );
            errlogPrintf("CAS: FIONREAD error: %s\n",
                sockErrBuf);
            cas_send_bs_msg(client, TRUE);
        }
        else if (check_nchars == 0){
            cas_send_bs_msg(client, TRUE);
        }

        client->recv.stk = 0;
        assert ( client->recv.maxstk >= client->recv.cnt );
        nchars = recv ( client->sock, &client->recv.buf[client->recv.cnt],
                (int) ( client->recv.maxstk - client->recv.cnt ), 0 );
        if ( nchars == 0 ){
            if ( CASDEBUG > 0 ) {
                /* convert to u long so that %lu works on both 32 and 64 bit archs */
                unsigned long cnt = sizeof ( client->recv.buf ) - client->recv.cnt;
                errlogPrintf ( "CAS: nill message disconnect ( %lu bytes request )\n",
                    cnt );
            }
            break;
        }
        else if ( nchars < 0 ) {
            int anerrno = SOCKERRNO;

            if ( anerrno == SOCK_EINTR ) {
                continue;
            }

            if ( anerrno == SOCK_ENOBUFS ) {
                errlogPrintf (
                    "CAS: Out of network buffers, retring receive in 15 seconds\n" );
                epicsThreadSleep ( 15.0 );
                continue;
            }

            /*
             * normal conn lost conditions
             */
            if (    ( anerrno != SOCK_ECONNABORTED &&
                anerrno != SOCK_ECONNRESET &&
                anerrno != SOCK_ETIMEDOUT ) ||
                CASDEBUG > 2 ) {
                char sockErrBuf[64];

                epicsSocketConvertErrorToString(
                    sockErrBuf, sizeof ( sockErrBuf ), anerrno);
                errlogPrintf ( "CAS: Client disconnected - %s\n",
                    sockErrBuf );
            }
            break;
        }

        epicsTimeGetCurrent ( &client->time_at_last_recv );
        client->recv.cnt += ( unsigned ) nchars;

        status = camessage ( client );
        if (status == 0) {
            /*
             * if there is a partial message
             * align it with the start of the buffer
             */
            if (client->recv.cnt > client->recv.stk) {
                unsigned bytes_left;

                bytes_left = client->recv.cnt - client->recv.stk;

                /*
                 * overlapping regions handled
                 * properly by memmove
                 */
                memmove (client->recv.buf,
                    &client->recv.buf[client->recv.stk], bytes_left);
                client->recv.cnt = bytes_left;
            }
            else {
                client->recv.cnt = 0ul;
            }
        }
        else {
            char buf[64];

            /* flush any queued messages before shutdown */
            cas_send_bs_msg(client, 1);

            client->recv.cnt = 0ul;

            /*
             * disconnect when there are severe message errors
             */
            ipAddrToDottedIP (&client->addr, buf, sizeof(buf));
            epicsPrintf ("CAS: forcing disconnect from %s\n", buf);
                break;
        }
    }

    LOCK_CLIENTQ;
    ellDelete ( &clientQ, &client->node );
    UNLOCK_CLIENTQ;

    destroy_tcp_client ( client );
}

void cas_commit_msg	(	struct client *	pClient,
		ca_uint32_t	size
	)

Definition at line 351 of file caserverio.c.

{
    caHdr * pMsg = ( caHdr * ) &pClient->send.buf[pClient->send.stk];
    size = CA_MESSAGE_ALIGN ( size );
    if ( pMsg->m_postsize == htons ( 0xffff ) ) {
        ca_uint32_t * pLW = ( ca_uint32_t * ) ( pMsg + 1 );
        assert ( size <= ntohl ( *pLW ) );
        pLW[0] = htonl ( size );
        size += sizeof ( caHdr ) + 2 * sizeof ( *pLW );
    }
    else {
        assert ( size <= ntohs ( pMsg->m_postsize ) );
        pMsg->m_postsize = htons ( (ca_uint16_t) size );
        size += sizeof ( caHdr );
    }
    pClient->send.stk += size;
}

int cas_copy_in_header	(	struct client *	pClient,
		ca_uint16_t	response,
		ca_uint32_t	payloadSize,
		ca_uint16_t	dataType,
		ca_uint32_t	nElem,
		ca_uint32_t	cid,
		ca_uint32_t	responseSpecific,
		void **	pPayload
	)

Definition at line 251 of file caserverio.c.

{
    unsigned    msgSize;
    ca_uint32_t alignedPayloadSize;
    caHdr *pMsg;

    if ( payloadSize > UINT_MAX - sizeof ( caHdr ) - 8u ) {
        return ECA_TOLARGE;
    }

    alignedPayloadSize = CA_MESSAGE_ALIGN ( payloadSize );

    msgSize = alignedPayloadSize + sizeof ( caHdr );
    if ( alignedPayloadSize >= 0xffff || nElem >= 0xffff ) {
        if ( ! CA_V49 ( pclient->minor_version_number ) ) {
            return ECA_16KARRAYCLIENT;
        }
        msgSize += 2 * sizeof ( ca_uint32_t );
    }

    if ( msgSize > pclient->send.maxstk ) {
        casExpandSendBuffer ( pclient, msgSize );
        if ( msgSize > pclient->send.maxstk ) {
            return ECA_TOLARGE;
        }
    }

    if ( pclient->send.stk > pclient->send.maxstk - msgSize ) {
        if ( pclient->disconnect ) {
            pclient->send.stk = 0;
        }
        else{
            if ( pclient->proto == IPPROTO_TCP) {
                cas_send_bs_msg ( pclient, FALSE );
            }
            else if ( pclient->proto == IPPROTO_UDP ) {
                cas_send_dg_msg ( pclient );
            }
            else {
                return ECA_INTERNAL;
            }
        }
    }

    pMsg = (caHdr *) &pclient->send.buf[pclient->send.stk];
    pMsg->m_cmmd = htons(response);
    pMsg->m_dataType = htons(dataType);
    pMsg->m_cid = htonl(cid);
    pMsg->m_available = htonl(responseSpecific);
    if (alignedPayloadSize < 0xffff && nElem < 0xffff) {
        pMsg->m_postsize = htons(((ca_uint16_t) alignedPayloadSize));
        pMsg->m_count = htons(((ca_uint16_t) nElem));
        if (ppPayload)
            *ppPayload = (void *) (pMsg + 1);
    }
    else {
        ca_uint32_t *pW32 = (ca_uint32_t *) (pMsg + 1);
        pMsg->m_postsize = htons(0xffff);
        pMsg->m_count = htons(0u);
        pW32[0] = htonl(alignedPayloadSize);
        pW32[1] = htonl(nElem);
        if (ppPayload)
            *ppPayload = (void *) (pW32 + 2);
    }

    /* zero out pad bytes */
    if ( alignedPayloadSize > payloadSize ) {
        char *p = ( char * ) *ppPayload;
        memset ( p + payloadSize, '\0',
            alignedPayloadSize - payloadSize );
    }

    return ECA_NORMAL;
}

void cas_send_bs_msg	(	struct client *	pclient,
		int	lock_needed
	)

Definition at line 44 of file caserverio.c.

{
    int status;

    if ( lock_needed ) {
        SEND_LOCK ( pclient );
    }

    if ( CASDEBUG > 2 && pclient->send.stk ) {
        errlogPrintf ( "CAS: Sending a message of %d bytes\n", pclient->send.stk );
    }

    if ( pclient->disconnect ) {
        if ( CASDEBUG > 2 ) {
            errlogPrintf ( "CAS: msg Discard for sock %d addr %x\n",
                (int)pclient->sock, (unsigned) pclient->addr.sin_addr.s_addr );
        }
        pclient->send.stk = 0u;
        if(lock_needed)
            SEND_UNLOCK(pclient);
        return;
    }

    while ( pclient->send.stk && ! pclient->disconnect ) {
        status = send ( pclient->sock, pclient->send.buf, pclient->send.stk, 0 );
        if ( status >= 0 ) {
            unsigned transferSize = (unsigned) status;
            if ( transferSize >= pclient->send.stk ) {
                pclient->send.stk = 0;
                epicsTimeGetCurrent ( &pclient->time_at_last_send );
                break;
            }
            else {
                unsigned bytesLeft = pclient->send.stk - transferSize;
                memmove ( pclient->send.buf, &pclient->send.buf[transferSize],
                    bytesLeft );
                pclient->send.stk = bytesLeft;
            }
        }
        else {
            int causeWasSocketHangup = 0;
            int anerrno = SOCKERRNO;
            char buf[64];

            if ( pclient->disconnect ) {
                pclient->send.stk = 0u;
                break;
            }

            if ( anerrno == SOCK_EINTR ) {
                continue;
            }

            if ( anerrno == SOCK_ENOBUFS ) {
                errlogPrintf (
                    "CAS: Out of network buffers, retrying send in 15 seconds\n" );
                epicsThreadSleep ( 15.0 );
                continue;
            }

            ipAddrToDottedIP ( &pclient->addr, buf, sizeof(buf) );

            if (
                anerrno == SOCK_ECONNABORTED ||
                anerrno == SOCK_ECONNRESET ||
                anerrno == SOCK_EPIPE ||
                anerrno == SOCK_ETIMEDOUT ) {
                causeWasSocketHangup = 1;
            }
            else {
                char sockErrBuf[64];
                epicsSocketConvertErrnoToString (
                    sockErrBuf, sizeof ( sockErrBuf ) );
                errlogPrintf ( "CAS: TCP send to %s failed: %s\n",
                    buf, sockErrBuf);
            }
            pclient->disconnect = TRUE;
            pclient->send.stk = 0u;

            /*
             * wakeup the receive thread
             */
            if ( ! causeWasSocketHangup ) {
                enum epicsSocketSystemCallInterruptMechanismQueryInfo info  =
                    epicsSocketSystemCallInterruptMechanismQuery ();
                switch ( info ) {
                case esscimqi_socketCloseRequired:
                    if ( pclient->sock != INVALID_SOCKET ) {
                        epicsSocketDestroy ( pclient->sock );
                        pclient->sock = INVALID_SOCKET;
                    }
                    break;
                case esscimqi_socketBothShutdownRequired:
                    {
                        int status = shutdown ( pclient->sock, SHUT_RDWR );
                        if ( status ) {
                            char sockErrBuf[64];
                            epicsSocketConvertErrnoToString (
                                sockErrBuf, sizeof ( sockErrBuf ) );
                            errlogPrintf ("CAS: Socket shutdown error: %s\n",
                                sockErrBuf );
                        }
                    }
                    break;
                case esscimqi_socketSigAlarmRequired:
                    epicsSignalRaiseSigAlarm ( pclient->tid );
                    break;
                default:
                    break;
                };
                break;
            }
        }
    }

    if ( lock_needed ) {
        SEND_UNLOCK(pclient);
    }

    DLOG ( 3, ( "------------------------------\n\n" ) );

    return;
}

void cas_send_dg_msg

(

struct client *

pclient

)

Definition at line 173 of file caserverio.c.

{
    int status;
    int sizeDG;
    char * pDG;
    caHdr * pMsg;

    if ( CASDEBUG > 2 && pclient->send.stk ) {
        errlogPrintf ( "CAS: Sending a udp message of %d bytes\n", pclient->send.stk );
    }

    SEND_LOCK ( pclient );

    if ( pclient->send.stk <= sizeof (caHdr) ) {
        SEND_UNLOCK(pclient);
        return;
    }

    pDG = pclient->send.buf;
    pMsg = ( caHdr * ) pDG;
    sizeDG = pclient->send.stk;
    assert ( ntohs ( pMsg->m_cmmd ) == CA_PROTO_VERSION );
    if ( CA_V411 ( pclient->minor_version_number ) ) {
        pMsg->m_cid = htonl ( pclient->seqNoOfReq );
        pMsg->m_dataType = htons ( sequenceNoIsValid );
    }
    else {
        pDG += sizeof (caHdr);
        sizeDG -= sizeof (caHdr);
    }

    status = sendto ( pclient->sock, pDG, sizeDG, 0,
       (struct sockaddr *)&pclient->addr, sizeof(pclient->addr) );
    if ( status >= 0 ) {
        if ( status >= sizeDG ) {
            epicsTimeGetCurrent ( &pclient->time_at_last_send );
        }
        else {
            errlogPrintf (
                "CAS: System failed to send entire udp frame?\n" );
        }
    }
    else {
        char sockErrBuf[64];
        char buf[128];
        epicsSocketConvertErrnoToString (
            sockErrBuf, sizeof ( sockErrBuf ) );
        ipAddrToDottedIP ( &pclient->addr, buf, sizeof(buf) );
        errlogPrintf( "CAS: UDP send to %s failed: %s\n",
            buf, sockErrBuf);
    }

    pclient->send.stk = 0u;

    /*
     * add placeholder for the first version message should it be needed
     */
    rsrv_version_reply ( pclient );

    SEND_UNLOCK(pclient);

    DLOG ( 3, ( "------------------------------\n\n" ) );

    return;
}

void cas_set_header_cid	(	struct client *	pClient,
		ca_uint32_t
	)

Definition at line 329 of file caserverio.c.

{
    caHdr *pMsg = ( caHdr * ) &pClient->send.buf[pClient->send.stk];
    pMsg->m_cid = htonl ( cid );
}

void cas_set_header_count	(	struct client *	pClient,
		ca_uint32_t	count
	)

Definition at line 335 of file caserverio.c.

{
    caHdr *pMsg = (caHdr *) &pClient->send.buf[pClient->send.stk];
    if (pMsg->m_postsize == htons(0xffff)) {
        ca_uint32_t *pLW;

        assert(pMsg->m_count == 0);
        pLW = (ca_uint32_t *) (pMsg + 1);
        pLW[1] = htonl(count);
    }
    else {
        assert(count < 65536);
        pMsg->m_count = htons((ca_uint16_t) count);
    }
}

void casAttachThreadToClient

(

struct client *

)

Definition at line 1307 of file caservertask.c.

{
    epicsSignalInstallSigAlarmIgnore ();
    epicsSignalInstallSigPipeIgnore ();
    pClient->tid = epicsThreadGetIdSelf ();
    epicsThreadPrivateSet ( rsrvCurrentClient, pClient );
    taskwdInsert ( pClient->tid, NULL, NULL );
}

void casExpandRecvBuffer	(	struct client *	pClient,
		ca_uint32_t	size
	)

Definition at line 1394 of file caservertask.c.

{
    casExpandBuffer (&pClient->recv, size, 0);
}

void casExpandSendBuffer	(	struct client *	pClient,
		ca_uint32_t	size
	)

Definition at line 1389 of file caservertask.c.

{
    casExpandBuffer (&pClient->send, size, 1);
}

void cast_server

(

void *

)

Definition at line 116 of file cast_server.c.

{
    rsrv_iface_config *conf = pParm;
    int                 status;
    int                 count=0;
    int                 mysocket=0;
    struct sockaddr_in  new_recv_addr;
    osiSocklen_t        recv_addr_size;
    osiSockIoctl_t      nchars;
    SOCKET              recv_sock, reply_sock;
    struct client      *client;

    recv_addr_size = sizeof(new_recv_addr);

    reply_sock = conf->udp;

    /*
     * setup new client structure but reuse old structure if
     * possible
     *
     */
    while ( TRUE ) {
        client = create_client ( reply_sock, IPPROTO_UDP );
        if ( client ) {
            break;
        }
        epicsThreadSleep(300.0);
    }
    if (conf->startbcast) {
        recv_sock = conf->udpbcast;
        conf->bclient = client;
    }
    else {
        recv_sock = conf->udp;
        conf->client = client;
    }
    client->udpRecv = recv_sock;

    casAttachThreadToClient ( client );

    /*
     * add placeholder for the first version message should it be needed
     */
    rsrv_version_reply ( client );

    /* these pointers become invalid after signaling casudp_startStopEvent */
    conf = NULL;

    epicsEventSignal(casudp_startStopEvent);

    while (TRUE) {
        status = recvfrom (
            recv_sock,
            client->recv.buf,
            client->recv.maxstk,
            0,
            (struct sockaddr *)&new_recv_addr,
            &recv_addr_size);
        if (status < 0) {
            if (SOCKERRNO != SOCK_EINTR) {
                char sockErrBuf[64];
                epicsSocketConvertErrnoToString (
                    sockErrBuf, sizeof ( sockErrBuf ) );
                epicsPrintf ("CAS: UDP recv error: %s\n",
                        sockErrBuf);
                epicsThreadSleep(1.0);
            }

        } else {
            size_t idx;
            for(idx=0; casIgnoreAddrs[idx]; idx++)
            {
                if(new_recv_addr.sin_addr.s_addr==casIgnoreAddrs[idx]) {
                    status = -1; /* ignore */
                    break;
                }
            }
        }

        if (status >= 0 && casudp_ctl == ctlRun) {
            client->recv.cnt = (unsigned) status;
            client->recv.stk = 0ul;
            epicsTimeGetCurrent(&client->time_at_last_recv);

            client->minor_version_number = CA_UKN_MINOR_VERSION;
            client->seqNoOfReq = 0;

            /*
             * If we are talking to a new client flush to the old one
             * in case we are holding UDP messages waiting to
             * see if the next message is for this same client.
             */
            if (client->send.stk>sizeof(caHdr)) {
                status = memcmp(&client->addr,
                    &new_recv_addr, recv_addr_size);
                if(status){
                    /*
                     * if the address is different
                     */
                    cas_send_dg_msg(client);
                    client->addr = new_recv_addr;
                }
            }
            else {
                client->addr = new_recv_addr;
            }

            if (CASDEBUG>1) {
                char    buf[40];

                ipAddrToDottedIP (&client->addr, buf, sizeof(buf));
                errlogPrintf ("CAS: cast server msg of %d bytes from addr %s\n",
                    client->recv.cnt, buf);
            }

            if (CASDEBUG>2)
                count = ellCount (&client->chanList);

            status = camessage ( client );
            if(status == RSRV_OK){
                if(client->recv.cnt !=
                    client->recv.stk){
                    char buf[40];

                    ipAddrToDottedIP (&client->addr, buf, sizeof(buf));

                    epicsPrintf ("CAS: partial (damaged?) UDP msg of %d bytes from %s ?\n",
                        client->recv.cnt - client->recv.stk, buf);

                    epicsTimeToStrftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S",
                        &client->time_at_last_recv);
                    epicsPrintf ("CAS: message received at %s\n", buf);
                }
            }
            else if (CASDEBUG>0){
                char buf[40];

                ipAddrToDottedIP (&client->addr, buf, sizeof(buf));

                epicsPrintf ("CAS: invalid (damaged?) UDP request from %s ?\n", buf);

                epicsTimeToStrftime(buf, sizeof(buf), "%Y-%m-%d %H:%M:%S",
                    &client->time_at_last_recv);
                epicsPrintf ("CAS: message received at %s\n", buf);
            }

            if (CASDEBUG>2) {
                if ( ellCount (&client->chanList) ) {
                    errlogPrintf ("CAS: Fnd %d name matches (%d tot)\n",
                        ellCount(&client->chanList)-count,
                        ellCount(&client->chanList));
                }
            }
        }

        /*
         * allow messages to batch up if more are comming
         */
        nchars = 0; /* supress purify warning */
        status = socket_ioctl(recv_sock, FIONREAD, &nchars);
        if (status<0) {
            errlogPrintf ("CA cast server: Unable to fetch N characters pending\n");
            cas_send_dg_msg (client);
            clean_addrq (client);
        }
        else if (nchars == 0) {
            cas_send_dg_msg (client);
            clean_addrq (client);
        }
    }

    /* ATM never reached, just a placeholder */

    if(!mysocket)
        client->sock = INVALID_SOCKET; /* only one cast_server should destroy the reply socket */
    destroy_client(client);
    epicsSocketDestroy(recv_sock);
}

struct client* create_client	(	SOCKET	sock,
		int	proto
	)

Definition at line 1225 of file caservertask.c.

{
    struct client *client;
    int           spaceAvailOnFreeList;
    size_t        spaceNeeded;

    /*
     * stop further use of server if memory becomes scarse
     */
    spaceAvailOnFreeList =     freeListItemsAvail ( rsrvClientFreeList ) > 0
                            && freeListItemsAvail ( rsrvSmallBufFreeListTCP ) > 0;
    spaceNeeded = sizeof (struct client) + MAX_TCP;
    if ( ! ( osiSufficentSpaceInPool(spaceNeeded) || spaceAvailOnFreeList ) ) {
        epicsSocketDestroy ( sock );
        epicsPrintf ("CAS: no space in pool for a new client (below max block thresh)\n");
        return NULL;
    }

    client = freeListCalloc ( rsrvClientFreeList );
    if ( ! client ) {
        epicsSocketDestroy ( sock );
        epicsPrintf ("CAS: no space in pool for a new client (alloc failed)\n");
        return NULL;
    }

    client->sock = sock;
    client->proto = proto;

    client->blockSem = epicsEventCreate ( epicsEventEmpty );
    client->lock = epicsMutexCreate();
    client->putNotifyLock = epicsMutexCreate();
    client->chanListLock = epicsMutexCreate();
    client->eventqLock = epicsMutexCreate();
    if ( ! client->blockSem || ! client->lock || ! client->putNotifyLock ||
        ! client->chanListLock || ! client->eventqLock ) {
        destroy_client ( client );
        return NULL;
    }

    client->pUserName = NULL;
    client->pHostName = NULL;
    ellInit ( & client->chanList );
    ellInit ( & client->chanPendingUpdateARList );
    ellInit ( & client->putNotifyQue );
    memset ( (char *)&client->addr, 0, sizeof (client->addr) );
    client->tid = 0;

    if ( proto == IPPROTO_TCP ) {
        client->send.buf = (char *) freeListCalloc ( rsrvSmallBufFreeListTCP );
        client->send.maxstk = MAX_TCP;
        client->send.type = mbtSmallTCP;
        client->recv.buf =  (char *) freeListCalloc ( rsrvSmallBufFreeListTCP );
        client->recv.maxstk = MAX_TCP;
        client->recv.type = mbtSmallTCP;
    }
    else if ( proto == IPPROTO_UDP ) {
        client->send.buf = malloc ( MAX_UDP_SEND );
        client->send.maxstk = MAX_UDP_SEND;
        client->send.type = mbtUDP;
        client->recv.buf = malloc ( MAX_UDP_RECV );
        client->recv.maxstk = MAX_UDP_RECV;
        client->recv.type = mbtUDP;
    }
    if ( ! client->send.buf || ! client->recv.buf ) {
        destroy_client ( client );
        return NULL;
    }
    client->send.stk = 0u;
    client->send.cnt = 0u;
    client->recv.stk = 0u;
    client->recv.cnt = 0u;
    client->evuser = NULL;
    client->priority = CA_PROTO_PRIORITY_MIN;
    client->disconnect = FALSE;
    epicsTimeGetCurrent ( &client->time_at_last_send );
    epicsTimeGetCurrent ( &client->time_at_last_recv );
    client->minor_version_number = CA_UKN_MINOR_VERSION;
    client->recvBytesToDrain = 0u;

    return client;
}

struct client* create_tcp_client	(	SOCKET	sock,
		const osiSockAddr *	peerAddr
	)

Definition at line 1402 of file caservertask.c.

{
    int                     status;
    struct client           *client;
    int                     intTrue = TRUE;
    unsigned                priorityOfEvents;

    /* socket passed in is destroyed here if unsuccessful */
    client = create_client ( sock, IPPROTO_TCP );
    if ( ! client ) {
        return NULL;
    }

    client->addr = peerAddr->ia;
    if(asCheckClientIP) {
        epicsUInt32 ip = ntohl(client->addr.sin_addr.s_addr);
        client->pHostName = malloc(24);
        if(!client->pHostName) {
            destroy_client ( client );
            return NULL;
        }
        epicsSnprintf(client->pHostName, 24,
                      "%u.%u.%u.%u",
                      (ip>>24)&0xff,
                      (ip>>16)&0xff,
                      (ip>>8)&0xff,
                      (ip>>0)&0xff);
    }

    /*
     * see TCP(4P) this seems to make unsolicited single events much
     * faster. I take care of queue up as load increases.
     */
    status = setsockopt ( sock, IPPROTO_TCP, TCP_NODELAY,
                (char *) &intTrue, sizeof (intTrue) );
    if (status < 0) {
        errlogPrintf ( "CAS: TCP_NODELAY option set failed\n" );
        destroy_client ( client );
        return NULL;
    }

    /*
     * turn on KEEPALIVE so if the client crashes
     * this task will find out and exit
     */
    status = setsockopt ( sock, SOL_SOCKET, SO_KEEPALIVE,
                    (char *) &intTrue, sizeof (intTrue) );
    if ( status < 0 ) {
        errlogPrintf ( "CAS: SO_KEEPALIVE option set failed\n" );
        destroy_client ( client );
        return NULL;
    }

    /*
     * some concern that vxWorks will run out of mBuf's
     * if this change is made
     *
     * joh 11-10-98
     */
#if 0
    /*
     * set TCP buffer sizes to be synergistic
     * with CA internal buffering
     */
    i = MAX_MSG_SIZE;
    status = setsockopt ( sock, SOL_SOCKET, SO_SNDBUF, (char *) &i, sizeof (i) );
    if (status < 0) {
        errlogPrintf ( "CAS: SO_SNDBUF set failed\n" );
        destroy_client ( client );
        return NULL;
    }
    i = MAX_MSG_SIZE;
    status = setsockopt ( sock, SOL_SOCKET, SO_RCVBUF, (char *) &i, sizeof (i) );
    if (status < 0) {
        errlogPrintf ( "CAS: SO_RCVBUF set failed\n" );
        destroy_client ( client );
        return NULL;
    }
#endif

    client->evuser = (struct event_user *) db_init_events ();
    if ( ! client->evuser ) {
        errlogPrintf ("CAS: unable to init the event facility\n");
        destroy_tcp_client (client);
        return NULL;
    }

    status = db_add_extra_labor_event ( client->evuser, rsrv_extra_labor, client );
    if (status != DB_EVENT_OK) {
        errlogPrintf("CAS: unable to setup the event facility\n");
        destroy_tcp_client (client);
        return NULL;
    }

    {
        epicsThreadBooleanStatus    tbs;

        tbs  = epicsThreadHighestPriorityLevelBelow ( epicsThreadPriorityCAServerLow, &priorityOfEvents );
        if ( tbs != epicsThreadBooleanStatusSuccess ) {
            priorityOfEvents = epicsThreadPriorityCAServerLow;
        }
    }

    status = db_start_events ( client->evuser, "CAS-event",
                NULL, NULL, priorityOfEvents );
    if ( status != DB_EVENT_OK ) {
        errlogPrintf ( "CAS: unable to start the event facility\n" );
        destroy_tcp_client ( client );
        return NULL;
    }

    /*
     * add first version message should it be needed
     */
    rsrv_version_reply ( client );

    if ( CASDEBUG > 0 ) {
        char buf[64];
        ipAddrToDottedIP ( &client->addr, buf, sizeof(buf) );
        errlogPrintf ( "CAS: conn req from %s\n", buf );
    }

    return client;
}

void destroy_client

(

struct client *

)

Definition at line 1047 of file caservertask.c.

{
    if ( ! client ) {
        return;
    }

    if ( client->tid != 0 ) {
        taskwdRemove ( client->tid );
    }

    if ( client->sock != INVALID_SOCKET ) {
        epicsSocketDestroy ( client->sock );
    }

    if ( client->proto == IPPROTO_TCP ) {
        if ( client->send.buf ) {
            if ( client->send.type == mbtSmallTCP ) {
                freeListFree ( rsrvSmallBufFreeListTCP,  client->send.buf );
            }
            else if ( client->send.type == mbtLargeTCP ) {
                if(rsrvLargeBufFreeListTCP)
                    freeListFree ( rsrvLargeBufFreeListTCP,  client->send.buf );
                else
                    free(client->send.buf);
            }
            else {
                errlogPrintf ( "CAS: Corrupt send buffer free list type code=%u during client cleanup?\n",
                    client->send.type );
            }
        }
        if ( client->recv.buf ) {
            if ( client->recv.type == mbtSmallTCP ) {
                freeListFree ( rsrvSmallBufFreeListTCP,  client->recv.buf );
            }
            else if ( client->recv.type == mbtLargeTCP ) {
                if(rsrvLargeBufFreeListTCP)
                    freeListFree ( rsrvLargeBufFreeListTCP,  client->recv.buf );
                else
                    free(client->recv.buf);
            }
            else {
                errlogPrintf ( "CAS: Corrupt recv buffer free list type code=%u during client cleanup?\n",
                    client->send.type );
            }
        }
    }
    else if ( client->proto == IPPROTO_UDP ) {
        if ( client->send.buf ) {
            free ( client->send.buf );
        }
        if ( client->recv.buf ) {
            free ( client->recv.buf );
        }
    }

    if ( client->eventqLock ) {
        epicsMutexDestroy ( client->eventqLock );
    }

    if ( client->chanListLock ) {
        epicsMutexDestroy ( client->chanListLock );
    }

    if ( client->putNotifyLock ) {
        epicsMutexDestroy ( client->putNotifyLock );
    }

    if ( client->lock ) {
        epicsMutexDestroy ( client->lock );
    }

    if ( client->blockSem ) {
        epicsEventDestroy ( client->blockSem );
    }

    if ( client->pUserName ) {
        free ( client->pUserName );
    }

    if ( client->pHostName ) {
        free ( client->pHostName );
    }

    freeListFree ( rsrvClientFreeList, client );
}

void destroy_tcp_client

(

struct client *

)

Definition at line 1191 of file caservertask.c.

{
    int                     status;

    if ( CASDEBUG > 0 ) {
        errlogPrintf ( "CAS: Connection %d Terminated\n", (int)client->sock );
    }

    if ( client->evuser ) {
        /*
         * turn off extra labor callbacks from the event thread
         */
        status = db_add_extra_labor_event ( client->evuser, NULL, NULL );
        assert ( ! status );

        /*
         * wait for extra labor in progress to comple
         */
        db_flush_extra_labor_event ( client->evuser );
    }

    destroyAllChannels ( client, & client->chanList );
    destroyAllChannels ( client, & client->chanPendingUpdateARList );

    if ( client->evuser ) {
        db_close_events (client->evuser);
    }

    destroy_client ( client );
}

GLBLTYPE ELLLIST clientQ GLBLTYPE_INIT

(

ELLLIST_INIT

)

void initializePutNotifyFreeList

(

void

)

Definition at line 1530 of file camessage.c.

{
    if ( ! rsrvPutNotifyFreeList ) {
        freeListInitPvt ( &rsrvPutNotifyFreeList,
            sizeof(struct rsrv_put_notify), 512 );
        assert ( rsrvPutNotifyFreeList );
    }
}

void rsrv_extra_labor

(

void *

pArg

)

Definition at line 1497 of file camessage.c.

{
    struct client * pClient = pArg;
    write_notify_reply ( pClient );
    sendAllUpdateAS ( pClient );
    cas_send_bs_msg ( pClient, TRUE );
}

void rsrv_online_notify_task

(

void *

)

Definition at line 40 of file online_notify.c.

{
    double                      delay;
    double                      maxdelay;
    long                        longStatus;
    double                      maxPeriod;
    caHdr                       msg;
    int                         status;
    ca_uint32_t                 beaconCounter = 0;
    int *lastError;

    taskwdInsert (epicsThreadGetIdSelf(),NULL,NULL);

    if ( envGetConfigParamPtr ( & EPICS_CAS_BEACON_PERIOD ) ) {
        longStatus = envGetDoubleConfigParam ( & EPICS_CAS_BEACON_PERIOD, & maxPeriod );
    }
    else {
        longStatus = envGetDoubleConfigParam ( & EPICS_CA_BEACON_PERIOD, & maxPeriod );
    }
    if (longStatus || maxPeriod<=0.0) {
        maxPeriod = 15.0;
        epicsPrintf ("EPICS \"%s\" float fetch failed\n",
                        EPICS_CAS_BEACON_PERIOD.name);
        epicsPrintf ("Setting \"%s\" = %f\n",
            EPICS_CAS_BEACON_PERIOD.name, maxPeriod);
    }

    delay = 0.02; /* initial beacon period in sec */
    maxdelay = maxPeriod;

    memset((char *)&msg, 0, sizeof msg);
    msg.m_cmmd = htons (CA_PROTO_RSRV_IS_UP);
    msg.m_count = htons (ca_server_port);
    msg.m_dataType = htons (CA_MINOR_PROTOCOL_REVISION);

    /* beaconAddrList should not change after rsrv_init(), which then starts this thread */
    lastError = callocMustSucceed(ellCount(&beaconAddrList), sizeof(*lastError), "rsrv_online_notify_task lastError");

    epicsEventSignal(beacon_startStopEvent);

    while (TRUE) {
        ELLNODE *cur;
        unsigned i;

        /* send beacon to each interface */
        for(i=0, cur=ellFirst(&beaconAddrList); cur; i++, cur=ellNext(cur))
        {
            osiSockAddrNode *pAddr = CONTAINER(cur, osiSockAddrNode, node);
            status = sendto (beaconSocket, (char *)&msg, sizeof(msg), 0,
                             &pAddr->addr.sa, sizeof(pAddr->addr));
            if (status < 0) {
                int err = SOCKERRNO;
                if(err != lastError[i]) {
                    char sockErrBuf[64];
                    char sockDipBuf[22];

                    epicsSocketConvertErrorToString(sockErrBuf, sizeof(sockErrBuf), err);
                    ipAddrToDottedIP(&pAddr->addr.ia, sockDipBuf, sizeof(sockDipBuf));
                    errlogPrintf ( "CAS: CA beacon send to %s error: %s\n",
                        sockDipBuf, sockErrBuf);

                    lastError[i] = err;
                }
            }
            else {
                assert (status == sizeof(msg));
                if(lastError[i]) {
                    char sockDipBuf[22];

                    ipAddrToDottedIP(&pAddr->addr.ia, sockDipBuf, sizeof(sockDipBuf));
                    errlogPrintf ( "CAS: CA beacon send to %s ok\n",
                        sockDipBuf);
                }
                lastError[i] = 0;
            }
        }

        epicsThreadSleep(delay);
        if (delay<maxdelay) {
            delay *= 2.0;
            if (delay>maxdelay) {
                delay = maxdelay;
            }
        }

        msg.m_cid = htonl ( beaconCounter++ ); /* expected to overflow */

        while (beacon_ctl == ctlPause) {
            epicsThreadSleep(0.1);
            delay = 0.02; /* Restart beacon timing if paused */
        }
    }

    free(lastError);
}

int rsrv_version_reply

(

struct client *

client

)

Definition at line 2141 of file camessage.c.

{
    int status;
    SEND_LOCK ( client );
    /*
     * sequence number is specified zero when we copy in the
     * header because we dont know it until we receive a datagram
     * from the client
     */
    status = cas_copy_in_header ( client, CA_PROTO_VERSION,
        0, 0, CA_MINOR_PROTOCOL_REVISION,
        0, 0, 0 );
    if ( status != ECA_NORMAL ) {
        SEND_UNLOCK ( client );
        return RSRV_ERROR;
    }
    cas_commit_msg ( client, 0 );
    SEND_UNLOCK ( client );
    return RSRV_OK;
}

int rsrvCheckPut

(

const struct channel_in_use *

pciu

)

Definition at line 2566 of file camessage.c.

{
    /*
     * SPC_NOMOD fields are always unwritable
     */
    if (dbChannelSpecial(pciu->dbch) == SPC_NOMOD) {
        return 0;
    }
    else {
        return asCheckPut (pciu->asClientPVT);
    }
}

void rsrvFreePutNotify	(	struct client *	pClient,
		struct rsrv_put_notify *	pNotify
	)

Definition at line 1616 of file camessage.c.

{
     if ( pNotify ) {
        char busyTmp;
        void * asWritePvtTmp = 0;

        epicsMutexMustLock ( pClient->putNotifyLock );
        busyTmp = pNotify->busy;
        epicsMutexUnlock ( pClient->putNotifyLock );

        /*
         * if any possiblity that the put notify is
         * outstanding then cancel it
         */
        if ( busyTmp ) {
            dbNotifyCancel ( &pNotify->dbPutNotify );
        }

        epicsMutexMustLock ( pClient->putNotifyLock );
        if ( pNotify->onExtraLaborQueue ) {
            ellDelete ( &pClient->putNotifyQue,
                        &pNotify->node );
        }
        busyTmp = pNotify->busy;
        asWritePvtTmp = pNotify->asWritePvt;
        pNotify->asWritePvt = 0;
        epicsMutexUnlock ( pClient->putNotifyLock );

        if ( busyTmp ) {
            asTrapWriteAfter ( asWritePvtTmp );
        }

        if ( pNotify->valueSize >
                sizeof(pNotify->dbrScalarValue) ) {
            free ( pNotify->pbuffer );
        }
        freeListFree ( rsrvPutNotifyFreeList, pNotify );
     }
}

unsigned rsrvSizeOfPutNotify

(

struct rsrv_put_notify *

pNotify

)

Definition at line 1604 of file camessage.c.

{
    unsigned size = sizeof ( *pNotify );
    if ( pNotify ) {
        if ( pNotify->valueSize >
                sizeof ( pNotify->dbrScalarValue ) ) {
            size += pNotify->valueSize;
        }
    }
    return size;
}

Variable Documentation

GLBLTYPE enum ctl beacon_ctl

Definition at line 213 of file server.h.

GLBLTYPE epicsEventId beacon_startStopEvent

Definition at line 210 of file server.h.

GLBLTYPE ELLLIST beaconAddrList

Definition at line 194 of file server.h.

GLBLTYPE SOCKET beaconSocket

Definition at line 195 of file server.h.

GLBLTYPE unsigned short ca_beacon_port

Definition at line 191 of file server.h.

GLBLTYPE unsigned short ca_server_port

Definition at line 191 of file server.h.

GLBLTYPE unsigned short ca_udp_port

Definition at line 191 of file server.h.

GLBLTYPE int CASDEBUG

Definition at line 190 of file server.h.

GLBLTYPE epicsUInt32* casIgnoreAddrs

Definition at line 197 of file server.h.

GLBLTYPE ELLLIST casIntfAddrList

Definition at line 196 of file server.h.

GLBLTYPE ELLLIST casMCastAddrList

Definition at line 196 of file server.h.

GLBLTYPE enum ctl castcp_ctl

Definition at line 214 of file server.h.

GLBLTYPE epicsEventId castcp_startStopEvent

Definition at line 211 of file server.h.

GLBLTYPE enum ctl casudp_ctl

Definition at line 212 of file server.h.

GLBLTYPE epicsEventId casudp_startStopEvent

Definition at line 209 of file server.h.

GLBLTYPE epicsMutexId clientQlock

Definition at line 198 of file server.h.

GLBLTYPE BUCKET* pCaBucket

Definition at line 199 of file server.h.

GLBLTYPE void* rsrvChanFreeList

Definition at line 201 of file server.h.

GLBLTYPE unsigned rsrvChannelCount

Definition at line 207 of file server.h.

GLBLTYPE void* rsrvClientFreeList

Definition at line 200 of file server.h.

epicsThreadPrivateId rsrvCurrentClient

Definition at line 50 of file caservertask.c.

GLBLTYPE void* rsrvEventFreeList

Definition at line 202 of file server.h.

GLBLTYPE void* rsrvLargeBufFreeListTCP

Definition at line 204 of file server.h.

GLBLTYPE void* rsrvPutNotifyFreeList

Definition at line 206 of file server.h.

GLBLTYPE unsigned rsrvSizeofLargeBufTCP

Definition at line 205 of file server.h.

GLBLTYPE void* rsrvSmallBufFreeListTCP

Definition at line 203 of file server.h.

GLBLTYPE ELLLIST servers

Definition at line 193 of file server.h.

GLBLTYPE unsigned int threadPrios[5]

Definition at line 216 of file server.h.