bsProxyClient.c File Reference

BotSense bsProxy client routines. More...

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <stdarg.h>
#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "rnr/new.h"
#include "rnr/sock.h"
#include "rnr/netmsgs.h"
#include "botsense/BotSense.h"
#include "botsense/bsProxyMsgs.h"
#include "bsProxy.h"

Go to the source code of this file.

Macros
#define	CLIENT_HND(pClient)   ServerClientSd2Hnd(SocketAttrGetSd(pClient->m_pClientSock))
	Convert pointer to client to client handle. More...

Functions
static void	ClientLockBusy ()
	Lock client's global busy mutual exclusion.
static void	ClientUnlockBusy ()
	Unlock client's global busy mutual exclusion.
static bool_t	ClientBusyTryLock ()
	Try to lock client's global busy mutual exclusion. More...
static void	ClientBroadcastNotBusy ()
	Broadcast that a client has been freed or deleted. More...
static void	ClientWaitNotBusy ()
	Wait on a client to become free.
static void	fdset_nowarn (int fd, fd_set *pset)
	FD_SET() wrapper with no annoying warnings. More...
static ssize_t	ClientRead (BsProxyClientCtl_T *pClient, byte_t buf[], size_t uCount)
	Read count bytes from socket. More...
static ssize_t	ClientWrite (BsProxyClientCtl_T *pClient, byte_t buf[], size_t uCount)
	Write count bytes to socket. More...
static ssize_t	ClientResync (BsProxyClientCtl_T *pClient, byte_t bufHdr[])
	Resync to client message stream. More...
static void	ClientFlushInput (BsProxyClientCtl_T *pClient, size_t uCount)
	Flush receive stream. More...
void	ClientOneTimeInit ()
	The BotSense bsProxy server one-time client control initialization.
BsProxyClientCtl_T *	ClientAcquire (BsProxyClientHnd_T hndClient)
	Acquire client, locking it from other threads. More...
void	ClientRelease (BsProxyClientHnd_T hndClient)
	Release the locked client. More...
BsProxyClientCtl_T *	ClientNew (Socket_T *pSockClient)
	Create new client control structure. More...
void	ClientDelete (BsProxyClientCtl_T *pClient)
	Delete a client with the server. More...
void	ClientSetState (BsProxyClientCtl_T *pClient, BsProxyClientState_T eNewState)
	Set client's state. More...
static int	ClientRecvHdr (BsProxyClientCtl_T *pClient, BsProxyMsgHdr_T *pMsgHdr)
	Receive client request header. More...
static int	ClientRecvBody (BsProxyClientCtl_T *pClient, byte_t buf[], size_t uBodyLen)
	Receive client request message body. More...
int	ClientRecvReq (BsProxyClientHnd_T hndClient, BsProxyMsgHdr_T *pMsgHdr, byte_t **addrBuf)
	Receive a request message from client. More...
int	ClientSendOkRsp (BsProxyClientHnd_T hndClient, BsTid_T uTid)
	Send an ok response to the client. More...
int	ClientSendErrorRsp (BsProxyClientHnd_T hndClient, BsTid_T uTid, int nECode, const char *sErrFmt,...)
	Send an error response to the client. More...
int	ClientSendVErrorRsp (BsProxyClientHnd_T hndClient, BsTid_T uTid, int nECode, const char *sErrFmt, va_list ap)
	Send va_list error response to the client. More...
int	ClientSendServerRsp (BsProxyClientHnd_T hndClient, BsTid_T uTid, BsProxyMsgId_T uMsgId, void *pMsgRsp)
	Send a server-terminated response message to client. More...
int	ClientSendRsp (BsProxyClientHnd_T hndClient, BsVConnHnd_T hndVConn, BsTid_T uTid, BsMsgId_T uMsgId, byte_t bufRsp[], size_t uRspSize)
	Send module-specific response to the client. More...

Variables
static pthread_mutex_t	BsClientBusyMutex
	busy mutex
static pthread_cond_t	BsClientBusyCond
	busy condition

Detailed Description

BotSense bsProxy client routines.

LastChangedDate

2010-08-20 11:36:38 -0600 (Fri, 20 Aug 2010)

Rev

568

Author

Robin Knight (robin.nosp@m..kni.nosp@m.ght@r.nosp@m.oadn.nosp@m.arrow.nosp@m.s.co.nosp@m.m)

Copyright

© 2007-2017. RoadNarrows LLC.
http://www.roadnarrows.com
All Rights Reserved

Definition in file bsProxyClient.c.

Macro Definition Documentation

#define CLIENT_HND

(

pClient

)

ServerClientSd2Hnd(SocketAttrGetSd(pClient->m_pClientSock))

Convert pointer to client to client handle.

Parameters

pClient

Definition at line 81 of file bsProxyClient.c.

Referenced by ClientRecvBody(), and ClientRecvHdr().

Function Documentation

BsProxyClientCtl_T* ClientAcquire

(

BsProxyClientHnd_T

hndClient

)

Acquire client, locking it from other threads.

The calling thread is blocked until the client is availble or has been deleted.

Parameters

hndClient

Client handle.

Returns

On success, returns pointer to locked client control block. On failure, NULL is returned.

Definition at line 546 of file bsProxyClient.c.

References ClientLockBusy(), ClientUnlockBusy(), ClientWaitNotBusy(), BsProxyClientCtl_T::m_bBusy, and ServerGetClient().

Referenced by BsProxyClientUnregister(), ClientRecvReq(), ClientSendRsp(), ClientSetTraceState(), ReqDevClose(), and ReqDevOpen().

{
  BsProxyClientCtl_T *pClient;

  ClientLockBusy();

  while( ((pClient = ServerGetClient(hndClient)) != NULL) && pClient->m_bBusy )
  {
    ClientWaitNotBusy();
  }

  if( pClient )
  {
    pClient->m_bBusy = true;
  }

  ClientUnlockBusy();

  return pClient;
}

static void ClientBroadcastNotBusy ( )

inlinestatic

Broadcast that a client has been freed or deleted.

A broadcast will unblock all threads currently blocked on the busy condition variable. Only those threads waiting on the client whose condition has changed will run. If multiple threads are waiting on the same client, then only one is schedule to run.

Definition at line 136 of file bsProxyClient.c.

References BsClientBusyCond.

Referenced by ClientRelease().

{
  int rc;

  if( (rc = pthread_cond_broadcast(&BsClientBusyCond)) != 0 )
  { 
    errno = rc;
    LOGSYSERROR("pthread_cond_broadcast()");
  }
}

static bool_t ClientBusyTryLock ( )

inlinestatic

Try to lock client's global busy mutual exclusion.

Returns

Returns true if lock is acquired. Otherwise returns false if mutex already locked.

Definition at line 123 of file bsProxyClient.c.

References BsClientBusyMutex.

{
  return pthread_mutex_trylock(&BsClientBusyMutex) == 0? true: false;
}

void ClientDelete

(

BsProxyClientCtl_T *

pClient

)

Delete a client with the server.

Parameters

pClient

Definition at line 621 of file bsProxyClient.c.

References BsProxyClientCtl_T::m_pClientSock, and BsProxyClientCtl_T::m_sClientName.

Referenced by BsProxyClientUnregister(), and ClientSetTraceState().

{
  if( pClient != NULL )
  {
    SocketClose(pClient->m_pClientSock);
    SocketDelete(pClient->m_pClientSock);
    delete((char *)pClient->m_sClientName);
    delete(pClient);
  }
}

static void ClientFlushInput ( BsProxyClientCtl_T *  pClient, size_t  uCount  )

static

Flush receive stream.

Parameters

pClient

Definition at line 501 of file bsProxyClient.c.

References ClientRead().

Referenced by ClientRecvHdr().

{
  byte_t  buf[256];
  ssize_t k = 0;
  size_t  n;

  do
  {
    uCount -= (size_t)k;
    n = sizeof(buf) < uCount? sizeof(buf): uCount;
  } while( (n > 0) && ((k = ClientRead(pClient, buf, n)) > 0) );
}

BsProxyClientCtl_T* ClientNew

(

Socket_T *

pSockClient

)

Create new client control structure.

Parameters

pSockClient

Accecpted client socket.

Returns

Returns a newly allocated and intialized client control block.

Definition at line 602 of file bsProxyClient.c.

References BsProxyClientStateNominal, BsProxyClientCtl_T::m_bServerTrace, BsProxyClientCtl_T::m_eClientState, BsProxyClientCtl_T::m_pClientSock, BsProxyClientCtl_T::m_sClientName, and BsProxyClientCtl_T::m_uRefCnt.

Referenced by BsProxyClientRegister(), and ClientSetTraceState().

{
  BsProxyClientCtl_T  *pClient;

  pClient                 = NEW(BsProxyClientCtl_T);
  pClient->m_sClientName  = new_strdup(SocketAttrGetRemoteName(pSockClient));
  pClient->m_pClientSock  = pSockClient;
  pClient->m_eClientState = BsProxyClientStateNominal;
  pClient->m_uRefCnt      = 0;
  pClient->m_bServerTrace = false;

  return pClient;
}

static ssize_t ClientRead ( BsProxyClientCtl_T *  pClient, byte_t  buf[], size_t  uCount  )

static

Read count bytes from socket.

Parameters

pClient

Definition at line 188 of file bsProxyClient.c.

References BS_ECODE_BAD_RECV, BS_ECODE_SERVER_BAD_CLIENT, BSPROXY_LOG_SYSERROR, BSPROXY_TUNE_T_RECV, BsProxyClientStateZombie, ClientThisHasName(), fdset_nowarn(), ServerClientSd2Hnd(), timer_elapsed(), and timer_mark().

Referenced by ClientFlushInput(), ClientRecvBody(), ClientRecvHdr(), and ClientResync().

{
  uint_t          usec = BSPROXY_TUNE_T_RECV;
  struct timeval  tstart;
  uint_t          tdelta;
  struct timeval  timeout;
  fd_set          rset;
  int             sd;
  int             nFd;
  ssize_t         n;
  ssize_t         nBytes = 0;

  LOGDIAG4CALL(_TSTR(ClientThisHasName(pClient)), _TPTR(buf), _TUINT(uCount));

  // client is disconnected or in an unrecoverable state
  if( pClient->m_eClientState == BsProxyClientStateZombie )
  {
    return -BS_ECODE_SERVER_BAD_CLIENT;
  }

  // socket descriptor
  sd = SocketAttrGetSd(pClient->m_pClientSock);

  //
  // Read the data until either 1) count bytes are read, 2) a time out occurs,
  // or 3) an error occurs.
  //
  while( nBytes < uCount )
  {
    FD_ZERO(&rset);
    fdset_nowarn(sd, &rset);

    // mark now
    timer_mark(&tstart);

    // (re)load timeout (gets munged after each select())
    timeout.tv_sec  = (time_t)(usec / 1000000);
    timeout.tv_usec = (time_t)(usec % 1000000);

    // wait to bytes to be available to be read
    nFd = select(sd+1, &rset, NULL, NULL, &timeout);

    // system error occurred on select - interpret
    if( nFd < 0 )
    {
      switch(errno)
      {
        case EAGAIN:        // non-blocking timeout
        case EINTR:         // read was interrupted
          break;
        default:            // non-recoverable error
          BSPROXY_LOG_SYSERROR(ServerClientSd2Hnd(sd), "select(%d,...)", sd);
          return -BS_ECODE_BAD_RECV;
      }
    }

    // select() timeout occurred
    else if( nFd == 0 )
    {
      LOGDIAG4("select() on read timed out.");
      break;
    }

    // read the available data from the socket
    n = read(sd, buf+nBytes, uCount-(size_t)nBytes);

    // system error occurred on read - interpret
    if( n < 0 )
    {
      switch(errno)
      {
        case EAGAIN:        // non-blocking timeout
        case EINTR:         // read was interrupted
          n = 0;
          break;
        default:            // non-recoverable error
          BSPROXY_LOG_SYSERROR(ServerClientSd2Hnd(sd), "select(%d,...)", sd);
          return -BS_ECODE_BAD_RECV;
      }
    }

    // got some data
    nBytes += n;

    // all of the requested bytes have been read
    if( nBytes == uCount )
    {
      break;
    }

    // determine time left for the non-blocking read timeout
    if( nBytes < uCount )
    {
      tdelta = timer_elapsed(&tstart);
      if( tdelta >= usec )
      {
        LOGDIAG4("%s() timed out.", LOGFUNCNAME);
        break;
      }
      else
      {
        usec -= tdelta;
      }
    }
  }

  LOGDIAG4("%s(): %zd bytes read.", LOGFUNCNAME, nBytes);

  return nBytes;
}

static int ClientRecvBody ( BsProxyClientCtl_T *  pClient, byte_t  buf[], size_t  uBodyLen  )

static

Receive client request message body.

Sanity checks are performed on the message.

Parameters

pClient

Definition at line 798 of file bsProxyClient.c.

References BS_ECODE_BAD_RECV, BS_ECODE_MSG_FRAG, BSPROXY_LOG_ERROR, BsProxyClientStateReSync, CLIENT_HND, ClientRead(), and ClientSetState().

Referenced by ClientRecvReq().

{
  int     nBytes;       // bytes read        

  // read failed
  if( (nBytes = (int)ClientRead(pClient, buf, uBodyLen)) < 0 )
  {
    BSPROXY_LOG_ERROR(CLIENT_HND(pClient), BS_ECODE_BAD_RECV,
        "Failed to receive client message body.");
    return -BS_ECODE_BAD_RECV;
  }

  // read a message fragment
  else if( nBytes < (ssize_t)uBodyLen )
  {
    BSPROXY_LOG_ERROR(CLIENT_HND(pClient), BS_ECODE_MSG_FRAG,
        "Received length=%zd, expected length=%zu.", nBytes, uBodyLen);
    ClientSetState(pClient, BsProxyClientStateReSync);
    nBytes = 0;
  }

  return nBytes;
}

static int ClientRecvHdr ( BsProxyClientCtl_T *  pClient, BsProxyMsgHdr_T *  pMsgHdr  )

static

Receive client request header.

Sanity checks are performed on the header.

Parameters

pClient

< normal operation

< resyncing server with client

< disconnected/bad state, but not deleted

Definition at line 702 of file bsProxyClient.c.

References BS_ECODE_BAD_RECV, BS_ECODE_MSG_BAD_HDR, BS_ECODE_MSG_FRAG, BS_ECODE_MSG_TOO_BIG, BS_ECODE_SERVER_BAD_CLIENT, BSPROXY_LOG_ERROR, BSPROXY_MSG_BODY_MAX, BSPROXY_MSG_HDR_LEN, BSPROXY_MSG_MAGIC, BsProxyClientStateNominal, BsProxyClientStateReSync, BsProxyClientStateZombie, CLIENT_HND, ClientFlushInput(), ClientRead(), ClientResync(), ClientSetState(), BsProxyClientCtl_T::m_eClientState, BsProxyMsgHdr_T::m_hdrBodyLen, and BsProxyMsgHdr_T::m_hdrMagic.

Referenced by ClientRecvReq().

{
  byte_t  bufHdr[BSPROXY_MSG_HDR_LEN];  // header buffer
  int     nBytes;                       // bytes read        
  size_t  uBodyLen;                     // length of message body

  //
  // Read the message header. The method depends on the client's state.
  //  Nominal   Normal operation
  //  Resync    Need to find the start of a header in stream, then read header
  //  Zombie    Client is disconnecting, simply return error.
  //
  switch( pClient->m_eClientState )
  {
    case BsProxyClientStateNominal: ///< normal operation
      nBytes = (int)ClientRead(pClient, bufHdr, BSPROXY_MSG_HDR_LEN);
      break;
    case BsProxyClientStateReSync:  ///< resyncing server with client
      nBytes = (int)ClientResync(pClient, bufHdr);
      break;
    case BsProxyClientStateZombie:  ///< disconnected/bad state, but not deleted
    default:
      return -BS_ECODE_SERVER_BAD_CLIENT;
  }

  // receive error
  if( nBytes < 0 )
  {
    return -BS_ECODE_BAD_RECV;
  }

  // nothing to receive
  else if( nBytes == 0 )
  {
    return 0;
  }

  // received header fragment, enter resync state
  else if( nBytes < BSPROXY_MSG_HDR_LEN )
  {
    BSPROXY_LOG_ERROR(CLIENT_HND(pClient), BS_ECODE_MSG_FRAG,
        "Received %d bytes, expected %d byte header.",
        nBytes, BSPROXY_MSG_HDR_LEN);
    ClientSetState(pClient, BsProxyClientStateReSync);
    return 0;
  }

  // unpack message header
  else if( bsUnpackMsgHdr(bufHdr, (size_t)nBytes, pMsgHdr) < 0 )
  {
    BSPROXY_LOG_ERROR(CLIENT_HND(pClient), BS_ECODE_MSG_BAD_HDR,
        "Received bad message header.");
    ClientSetState(pClient, BsProxyClientStateReSync);
    return 0;
  }

  // validate magic
  else if( pMsgHdr->m_hdrMagic != BSPROXY_MSG_MAGIC )
  {
    BSPROXY_LOG_ERROR(CLIENT_HND(pClient), BS_ECODE_MSG_BAD_HDR,
      "Received bad magic 0x%04x in message header.",
      pMsgHdr->m_hdrMagic);
    ClientSetState(pClient, BsProxyClientStateReSync);
    return 0;
  }

  //
  // The message body is too long.
  //
  else if( pMsgHdr->m_hdrBodyLen > BSPROXY_MSG_BODY_MAX )
  {
    uBodyLen = (size_t)pMsgHdr->m_hdrBodyLen;
    BSPROXY_LOG_ERROR(CLIENT_HND(pClient), BS_ECODE_MSG_TOO_BIG,
        "Received body length=%zu, flushing.", uBodyLen);
    ClientFlushInput(pClient, uBodyLen);
    return 0;
  }

  else
  {
    return nBytes;
  }
}

int ClientRecvReq	(	BsProxyClientHnd_T	hndClient,
		BsProxyMsgHdr_T *	pMsgHdr,
		byte_t **	addrBuf
	)

Receive a request message from client.

Parameters

hndClient

Definition at line 836 of file bsProxyClient.c.

References BS_ECODE_SERVER_BAD_CLIENT, BSPROXY_LOG_REQ, BsProxyClientStateNominal, ClientAcquire(), ClientRecvBody(), ClientRecvHdr(), ClientRelease(), ClientSetState(), ClientThisHasName(), BsProxyClientCtl_T::m_eClientState, BsProxyMsgHdr_T::m_hdrBodyLen, and ServerHasName().

Referenced by BsProxyServer(), and ClientSetTraceState().

{
  BsProxyClientCtl_T *pClient;      // BotSense client
  size_t              uBodyLen;     // expected message body length
  byte_t             *pBuf = NULL;  // allocated request packed message body
  int                 nBytesHdr;    // read message header bytes/return code
  int                 nBytesBody;   // read message body bytes/return code
  int                 nMsgLen;      // total message length/return code

  *addrBuf  = NULL;

  // lock client
  if( (pClient = ClientAcquire(hndClient)) == NULL )
  {
    return -BS_ECODE_SERVER_BAD_CLIENT;
  }

  // receive message header
  if( (nBytesHdr = ClientRecvHdr(pClient, pMsgHdr)) <= 0 )
  {
    nMsgLen = nBytesHdr;    // return code
  }

  // received a good header, now receive any message body 
  else
  {
    // (reenter) nominal state
    if( pClient->m_eClientState != BsProxyClientStateNominal )
    {
      ClientSetState(pClient, BsProxyClientStateNominal);
    }

    BSPROXY_LOG_REQ(hndClient, pMsgHdr);

    // specified message body length
    uBodyLen = (size_t)pMsgHdr->m_hdrBodyLen;

    //
    // Get the message body.
    //
    if( uBodyLen > 0 )
    {
      // allocate buffer
      pBuf = (byte_t *)new(uBodyLen);

      // receive 
      if( (nBytesBody = ClientRecvBody(pClient, pBuf, uBodyLen)) <= 0 )
      {
        delete(pBuf);
        pBuf = NULL;
        nMsgLen = nBytesBody;   // return code
      }

      // success
      else
      {
        nMsgLen = nBytesHdr + nBytesBody;
      }
    }

    //
    // No message body
    //
    else
    {
      pBuf = NULL;
      nMsgLen = nBytesHdr;
    }
  }

  // set allocated buffer
  *addrBuf = pBuf;

  if( nMsgLen > 0 )
  {
    LOGDIAG3("%s: %s: received message length=%d",
            ServerHasName(), ClientThisHasName(pClient), nMsgLen);
  }

  // unlock client
  ClientRelease(hndClient);

  return nMsgLen;
}

void ClientRelease

(

BsProxyClientHnd_T

hndClient

)

Release the locked client.

A broadcast is sent to all blocking threads on the freed event.

Parameters

hndClient

Client handle.

Definition at line 574 of file bsProxyClient.c.

References ClientBroadcastNotBusy(), ClientLockBusy(), ClientUnlockBusy(), BsProxyClientCtl_T::m_bBusy, and ServerGetClient().

Referenced by ClientRecvReq(), ClientSendRsp(), ClientSetTraceState(), ReqDevClose(), and ReqDevOpen().

{
  BsProxyClientCtl_T *pClient;

  ClientLockBusy();

  if( (pClient = ServerGetClient(hndClient)) != NULL )
  {
    pClient->m_bBusy = false;
  }

  ClientBroadcastNotBusy();

  ClientUnlockBusy();
}

static ssize_t ClientResync ( BsProxyClientCtl_T *  pClient, byte_t  bufHdr[]  )

static

Resync to client message stream.

If a client receieve stream becomes unsynchronized, the message headers are aliased to some offset into the stream. To resync, bsProxy searches the stream for the magic bytes in the message header. Once found, the reset of the header is read.

Parameters

pClient

Definition at line 436 of file bsProxyClient.c.

References BSPROXY_MSG_HDR_LEN, BSPROXY_MSG_MAGIC, and ClientRead().

Referenced by ClientRecvHdr().

{
  enum          ReSyncState_T     {GetMagicHi, GetMagicLo, GetRoH};
  byte_t        byMagicHi       = (byte_t)((BSPROXY_MSG_MAGIC >> 8) & 0xff);
  byte_t        byMagicLo       = (byte_t)(BSPROXY_MSG_MAGIC & 0xff);
  size_t        uCount          = BSPROXY_MSG_HDR_LEN;
  size_t        n               = 0;
  enum ReSyncState_T eCurState  = GetMagicHi;

  byte_t  buf[BSPROXY_MSG_HDR_LEN];
  ssize_t nBytes;
  int     i;

  //
  // Search stream for message header.
  //
  while( (nBytes = ClientRead(pClient, buf, uCount)) > 0 )
  {
    for(i=0; i<nBytes; ++i)
    {
      switch( eCurState )
      {
        case GetMagicHi:      // get some high magic
          if( buf[i] == byMagicHi )
          {
            bufHdr[n++] = buf[i];
            eCurState = GetMagicLo;
          }
          break;
        case GetMagicLo:      // now get some low magic
          if( buf[i] == byMagicLo )
          {
            bufHdr[n++] = buf[i];
            eCurState = GetRoH;
          }
          else    // false magic
          {
            n = 0;
            eCurState = GetMagicHi;
          }
          break;
        case GetRoH:        // get rest of header
          bufHdr[n++] = buf[i];
          break;
      }
    }

    uCount = BSPROXY_MSG_HDR_LEN - n;  

    if( uCount == 0 )
    {
      nBytes = BSPROXY_MSG_HDR_LEN;
      break;
    }
  }

  return nBytes;
}

int ClientSendErrorRsp	(	BsProxyClientHnd_T	hndClient,
		BsTid_T	uTid,
		int	nECode,
		const char *	sErrFmt,
			...
	)

Send an error response to the client.

Parameters

hndClient

Definition at line 960 of file bsProxyClient.c.

References ClientSendVErrorRsp().

Referenced by ClientSetTraceState().

{
  va_list ap;
  int     rc;

  va_start(ap, sErrFmt);
  rc = ClientSendVErrorRsp(hndClient, uTid, nECode, sErrFmt,ap);
  va_end(ap);
  return rc;
}

int ClientSendOkRsp	(	BsProxyClientHnd_T	hndClient,
		BsTid_T	uTid
	)

Send an ok response to the client.

Parameters

hndClient

Definition at line 936 of file bsProxyClient.c.

References BSPROXY_MSG_HDR_LEN, BSPROXY_VCONN_SERVER, BsProxyMsgIdRspOk, and ClientSendRsp().

Referenced by ClientSetTraceState(), ModCbSendOkRsp(), ReqDevClose(), ReqMsgTrace(), and ReqSetLogging().

{
  byte_t bufRsp[BSPROXY_MSG_HDR_LEN];

  //
  // Send the ok message.
  // Note:  Even though this is a server defined message, there is no message
  //        body, so use the lower level send function directly. 
  //
  return ClientSendRsp(hndClient, BSPROXY_VCONN_SERVER, uTid,
                        BsProxyMsgIdRspOk, bufRsp, (size_t)0);
}

int ClientSendRsp	(	BsProxyClientHnd_T	hndClient,
		BsVConnHnd_T	hndVConn,
		BsTid_T	uTid,
		BsMsgId_T	uMsgId,
		byte_t	bufRsp[],
		size_t	uRspSize
	)

Send module-specific response to the client.

Parameters

hndClient

Definition at line 1084 of file bsProxyClient.c.

References BS_ECODE_BAD_SEND, BS_ECODE_INTERNAL, BS_ECODE_SERVER_BAD_CLIENT, BSPROXY_LOG_ERROR, BSPROXY_LOG_RSP, BSPROXY_LOG_SYSERROR, BSPROXY_MSG_HDR_LEN, BSPROXY_MSG_MAGIC, ClientAcquire(), ClientRelease(), ClientWrite(), BsProxyMsgHdr_T::m_hdrBodyLen, BsProxyMsgHdr_T::m_hdrMagic, BsProxyMsgHdr_T::m_hdrMsgId, BsProxyMsgHdr_T::m_hdrTid, and BsProxyMsgHdr_T::m_hdrVConn.

Referenced by ClientSendOkRsp(), ClientSendServerRsp(), ClientSetTraceState(), and ModCbSendRsp().

{
  BsProxyClientCtl_T *pClient;
  BsProxyMsgHdr_T     msgHdr;
  size_t              nBytes;
  int                 n;

  // message header
  msgHdr.m_hdrMagic   = (ushort_t)BSPROXY_MSG_MAGIC;
  msgHdr.m_hdrTid     = (byte_t)uTid;
  msgHdr.m_hdrVConn   = (byte_t)hndVConn;
  msgHdr.m_hdrMsgId   = (ushort_t)uMsgId;
  msgHdr.m_hdrBodyLen = (ushort_t)uRspSize;

  n = bsPackMsgHdr(&msgHdr, bufRsp, BSPROXY_MSG_HDR_LEN);

  if( n < 0 )
  {
    BSPROXY_LOG_ERROR(hndClient, n,
        "Failed to pack message header for MsgId=%u.", uMsgId);
    return -BS_ECODE_INTERNAL;
  }

  nBytes = (size_t)n + uRspSize;

  if( (pClient = ClientAcquire(hndClient)) == NULL )
  {
    BSPROXY_LOG_ERROR(hndClient, BS_ECODE_SERVER_BAD_CLIENT,
        "Failed to acquire Client=%d.", hndClient);
    return -BS_ECODE_SERVER_BAD_CLIENT;
  }

  // send message to client
  n = (int)ClientWrite(pClient, bufRsp, nBytes);

  ClientRelease(hndClient);

  if( n < 0 )
  {
    BSPROXY_LOG_SYSERROR(hndClient,
        "Failed to send message, MsgId=%u", uMsgId);
    return -BS_ECODE_BAD_SEND;
  }

  // success
  else
  {
    BSPROXY_LOG_RSP(hndClient, &msgHdr);
    return n;
  }
}

int ClientSendServerRsp	(	BsProxyClientHnd_T	hndClient,
		BsTid_T	uTid,
		BsProxyMsgId_T	uMsgId,
		void *	pMsgRsp
	)

Send a server-terminated response message to client.

The response message header must contain the information except for the body length which will be automatically calculated.

Parameters

hndClient

Definition at line 1025 of file bsProxyClient.c.

References BS_ECODE_INTERNAL, BSPROXY_BUF_BODY, BSPROXY_LOG_ERROR, BSPROXY_LOG_NMERROR, BSPROXY_MSG_MAX_LEN, BSPROXY_VCONN_SERVER, BsProxyLookupMsgDef(), BsProxyPackMsg(), ClientGetTraceState(), and ClientSendRsp().

Referenced by ClientSendVErrorRsp(), ClientSetTraceState(), ReqDevOpen(), ReqGetVConnInfo(), ReqGetVConnList(), ReqGetVersion(), and ReqLoopback().

{
  const NMMsgDef_T *pMsgDef;
  byte_t            bufRsp[BSPROXY_MSG_MAX_LEN];
  int               n;

  // find the bsProxy server message definition
  pMsgDef = BsProxyLookupMsgDef(uMsgId);

  if( pMsgDef == NULL )
  {
    BSPROXY_LOG_ERROR(hndClient, BS_ECODE_INTERNAL,
        "Cannot find message definition for MsgId=%u.", uMsgId);
    return -BS_ECODE_INTERNAL;
  }
  
  //
  // Pack response message body
  //
  if( pMsgRsp != NULL )
  {
    n = BsProxyPackMsg(uMsgId, pMsgRsp, BSPROXY_BUF_BODY(bufRsp),
                       ClientGetTraceState(hndClient));

    if( n < 0 )
    {
      BSPROXY_LOG_NMERROR(hndClient, n,
        "Failed to pack message body for MsgId=%u.", uMsgId);
      return -BS_ECODE_INTERNAL;
    }
  }

  //
  // No response message body
  //
  else
  {
    n = 0;
  }

  return ClientSendRsp(hndClient, BSPROXY_VCONN_SERVER, uTid, uMsgId,
                        bufRsp, (size_t)n);
}

int ClientSendVErrorRsp	(	BsProxyClientHnd_T	hndClient,
		BsTid_T	uTid,
		int	nECode,
		const char *	sErrFmt,
		va_list	ap
	)

Send va_list error response to the client.

Parameters

hndClient

Definition at line 986 of file bsProxyClient.c.

References BSPROXY_RSPERR_EMSG_LEN, BsProxyMsgIdRspErr, ClientSendServerRsp(), BsProxyRspErr_T::m_ecode, and BsProxyRspErr_T::m_emsg.

Referenced by ClientSendErrorRsp(), ClientSetTraceState(), and ModCbSendErrorRsp().

{
  BsProxyRspErr_T  msgRsp;

  // Fill in formatted error string as the response message body.
  vsnprintf(msgRsp.m_emsg, BSPROXY_RSPERR_EMSG_LEN+1, sErrFmt, ap);
  msgRsp.m_emsg[BSPROXY_RSPERR_EMSG_LEN] = 0;

  // set error code
  if( nECode < 0 )
  {
    nECode = -nECode;
  }
  msgRsp.m_ecode = (byte_t)nECode;

  // send error message
  ClientSendServerRsp(hndClient, uTid, BsProxyMsgIdRspErr, &msgRsp);

  return -nECode;
}

void ClientSetState	(	BsProxyClientCtl_T *	pClient,
		BsProxyClientState_T	eNewState
	)

Set client's state.

Parameters

pClient

< disconnected but not deleted

< normal operation

< resyncing server with client

Definition at line 643 of file bsProxyClient.c.

References BsProxyClientStateNominal, BsProxyClientStateReSync, BsProxyClientStateZombie, ClientThisHasName(), BsProxyClientCtl_T::m_eClientState, BsProxyClientCtl_T::m_sClientName, and ServerHasName().

Referenced by BsProxyClientUnregister(), ClientRecvBody(), ClientRecvHdr(), ClientRecvReq(), and ClientSetTraceState().

{
  static const char *sZombie = "(zombie)";

  const char *sState;
  char       *sName;
  size_t      n;

  if( pClient == NULL )
  {
    return;
  }

  else if( pClient->m_eClientState == eNewState )
  {
    return;
  }

  switch( eNewState )
  {
    case BsProxyClientStateZombie:    ///< disconnected but not deleted
      sState = "disconnected";
      n = strlen(pClient->m_sClientName) + strlen(sZombie) + 2;
      sName = NEWSTR(n);
      sprintf(sName, "%s %s", pClient->m_sClientName, sZombie);
      delete((char *)pClient->m_sClientName);
      pClient->m_sClientName = sName;
      break;
    case BsProxyClientStateNominal:   ///< normal operation
      sState = "nominal";
      break;
    case BsProxyClientStateReSync:    ///< resyncing server with client
      sState = "resyncing";
      break;
    default:
      return;
  }

  pClient->m_eClientState = eNewState;

  LOGDIAG2("%s: %s: %s.", ServerHasName(), ClientThisHasName(pClient), sState);
}

static ssize_t ClientWrite ( BsProxyClientCtl_T *  pClient, byte_t  buf[], size_t  uCount  )

static

Write count bytes to socket.

Parameters

pClient

Definition at line 311 of file bsProxyClient.c.

References BS_ECODE_BAD_SEND, BS_ECODE_SERVER_BAD_CLIENT, BSPROXY_LOG_SYSERROR, BSPROXY_TUNE_T_SEND, BsProxyClientStateZombie, ClientThisHasName(), fdset_nowarn(), BsProxyClientCtl_T::m_eClientState, BsProxyClientCtl_T::m_pClientSock, ServerClientSd2Hnd(), timer_elapsed(), and timer_mark().

Referenced by ClientSendRsp().

{
  uint_t          usec = BSPROXY_TUNE_T_SEND;
  struct timeval  tstart;
  uint_t          tdelta;
  struct timeval  timeout;
  fd_set          wset;
  int             sd;
  int             nFd;
  ssize_t         n;
  ssize_t         nBytes = 0;

  LOGDIAG4CALL(_TSTR(ClientThisHasName(pClient)), _TPTR(buf), _TUINT(uCount));

  // client is disconnected or in an unrecoverable state
  if( pClient->m_eClientState == BsProxyClientStateZombie )
  {
    return -BS_ECODE_SERVER_BAD_CLIENT;
  }

  // socket descriptor
  sd = SocketAttrGetSd(pClient->m_pClientSock);

  //
  // Write the data until either 1) count bytes are written, 2) a time out
  // occurs, or 3) an error occurs.
  //
  while( nBytes < uCount )
  {
    FD_ZERO(&wset);
    fdset_nowarn(sd, &wset);

    // mark now
    timer_mark(&tstart);

    // (re)load timeout (gets munged after each select())
    timeout.tv_sec  = (time_t)(usec / 1000000);
    timeout.tv_usec = (time_t)(usec % 1000000);

    nFd = select(sd+1, NULL, &wset, NULL, &timeout);

    // system error occurred on select - interpret
    if( nFd < 0 )
    {
      switch(errno)
      {
        case EAGAIN:        // non-blocking timeout
        case EINTR:         // write was interrupted
          break;
        default:            // non-recoverable error
          BSPROXY_LOG_SYSERROR(ServerClientSd2Hnd(sd), "select(%d,...)", sd);
          return -BS_ECODE_BAD_SEND;
      }
    }

    // select() timeout occurred
    else if( nFd == 0 )
    {
      LOGDIAG4("select() on write timed out.");
      break;
    }

    // socket is available for writing
    n = write(sd, buf+nBytes, uCount-(size_t)nBytes);

    // system error occurred on write - interpret
    if( n < 0 )
    {
      switch(errno)
      {
        case EAGAIN:        // non-blocking timeout
        case EINTR:         // write was interrupted
          n = 0;
          break;
        default:            // non-recoverable error
          BSPROXY_LOG_SYSERROR(ServerClientSd2Hnd(sd), "select(%d,...)", sd);
          return -BS_ECODE_BAD_SEND;
      }
    }

    // wrote some data
    nBytes += n;

    // all of the requested bytes have been written
    if( nBytes == uCount )
    {
      break;
    }

    // determine time left for non-blocking write timeout
    if( nBytes < uCount )
    {
      tdelta = timer_elapsed(&tstart);
      if( tdelta >= usec )
      {
        LOGDIAG4("%s() timed out.", LOGFUNCNAME);
        break;
      }
      else
      {
        usec -= tdelta;
      }
    }
  }

  LOGDIAG4("%s(): %zd bytes written.", LOGFUNCNAME, nBytes);

  return nBytes;
}

static void fdset_nowarn ( int  fd, fd_set *  pset  )

inlinestatic

FD_SET() wrapper with no annoying warnings.

Parameters

fd	File descriptor to add to set.
pset	Pointer to fd set.

Definition at line 172 of file bsProxyClient.c.

Referenced by ClientRead(), and ClientWrite().

{
  FD_SET(fd, pset);
}