bsLibClient.c File Reference

Client base functions. More...

#include <stdio.h>
#include <stdlib.h>
#include <libgen.h>
#include <string.h>
#include <errno.h>
#include <pthread.h>
#include <limits.h>
#include <sys/select.h>
#include <sys/time.h>
#include "rnr/rnrconfig.h"
#include "rnr/new.h"
#include "rnr/log.h"
#include "rnr/netmsgs.h"
#include "botsense/BotSense.h"
#include "botsense/libBotSense.h"
#include "botsense/bsProxyMsgs.h"
#include "bsLibInternal.h"

Go to the source code of this file.

Functions
static void	fdset_nowarn (int fd, fd_set *pset)
	FD_SET() wrapper with no annoying warnings. More...
static void	bsTransLock (BsClient_T *pClient)
	Lock client's transaction mutual exclusion. More...
static void	bsTransUnlock (BsClient_T *pClient)
	Unlock client's transaction mutual exclusion. More...
static bool_t	bsTransTryLock (BsClient_T *pClient)
	Try to lock client's transaction mutual exclusion. More...
static void	bsTransMark (BsClient_T *pClient, BsTid_T uTid)
	Mark the start of a client's server transaction in the transaction cache. More...
static void	bsTransForget (BsClient_T *pClient, BsTid_T uTid)
	Delete any cached transaction state from the cache. More...
static void	bsTransCacheRsp (BsClient_T *pClient, BsTid_T uTid, BsProxyMsgHdr_T *pMsgHdr, byte_t bufRsp[])
	Cache a transaction response. More...
static int	bsTransLoadCached (BsClient_T *pClient, BsTid_T uTid, BsProxyMsgHdr_T *pMsgHdr, byte_t bufRsp[], size_t sizeRsp)
	Load cached response from transaction cache. More...
static BsTid_T	bsNextTid (BsClient_T *pClient)
	Atomically get the next available transaction id. More...
static void	timer_mark (struct timeval *pTvMark)
	Mark the current time. Resolution is microseconds. More...
static uint_t	timer_elapsed (struct timeval *pTvMark)
	Calculate the elapsed time between the given time mark and this call. More...
static int	bsClientPackMsgHdr (BsClient_T *pClient, BsProxyMsgHdr_T *pMsgHdr, byte_t buf[], size_t bufSize)
	Pack BotSense client message header. More...
static int	bsClientUnpackMsgHdr (BsClient_T *pClient, byte_t buf[], size_t bufSize, BsProxyMsgHdr_T *pMsgHdr)
	Unpack BotSense client message header. More...
static int	bsClientRead (BsClient_T *pClient, int sd, byte_t buf[], size_t count, uint_t usec)
	Read bytes from socket. More...
static int	bsClientWrite (BsClient_T *pClient, int sd, byte_t buf[], size_t count, uint_t usec)
	Write bytes to socket. More...
static void	bsFlushInput (BsClient_T *pClient, size_t count)
	Flush input of count bytes. More...
static void	bsResync (BsClient_T *pClient)
	Resync client with server. More...
static int	bsClientSendReq (BsClient_T *pClient, BsProxyMsgHdr_T *pMsgHdr, byte_t bufReq[], size_t bufSize)
	Send a request message to the server. More...
static int	bsClientRecvRsp (BsClient_T *pClient, BsProxyMsgHdr_T *pMsgHdr, byte_t bufRsp[], size_t bufSize)
	Read response message from server. More...
const char *	bsClientAttrGetName (BsClient_P pClient)
	Get client name. More...
void	bsClientAttrGetTimeouts (BsClient_P pClient, uint_t *pReqTimeout, uint_t *pRspTimeout)
	Get client request (write) and response (read) timeouts. More...
void	bsClientAttrSetTimeouts (BsClient_P pClient, uint_t uReqTimeout, uint_t uRspTimeout)
	Set client request (write) and response (read) timeouts. More...
bool_t	bsClientAttrGetTraceState (BsClient_P pClient, BsVConnHnd_T hndVConn)
	Get client virtual connection trace state. More...
int	bsClientAttrGetVConnCount (BsClient_P pClient)
	Get the number of active virtual connections for this client. More...
bool_t	bsClientAttrHasVConn (BsClient_P pClient, BsVConnHnd_T hndVConn)
	Test if client has a virtual connection identified by the handle. More...
const char *	bsClientAttrGetDevName (BsClient_P pClient, BsVConnHnd_T hndVConn)
	Get client virtual connection device name. More...
const char *	bsClientAttrGetModName (BsClient_P pClient, BsVConnHnd_T hndVConn)
	Get client virtual connection interface module name. More...
void	bsClientAttrSetLogging (BsClient_P pClient, int nLevel)
	Set client's diagnostics logging threshold. More...
void	bsClientAttrGetConnState (BsClient_P pClient, BsClientConnState_T *pConnState)
	Get client's connection state. More...
void	bsClientFillMsgHdr (BsClient_P pClient, int hndVConn, uint_t uMsgId, size_t uBodyLen, BsProxyMsgHdr_T *pMsgHdr)
	Fill in message header. More...
const char *	bsClientGetMsgName (BsClient_P pClient, BsVConnHnd_T hndVConn, uint_t uMsgId)
	Get the message name. More...
void	bsClientLogMsgHdr (BsClient_P pClient, const char *sPreface, BsProxyMsgHdr_T *pMsgHdr)
	Log [pre/un]packed message header. More...
int	bsClientTrans (BsClient_P pClient, int hndVConn, uint_t uReqMsgId, byte_t bufReq[], size_t uReqBodyLen, uint_t uRspMsgId, byte_t bufRsp[], size_t sizeRspBuf)
	Execute a request - response transaction with the server. More...
BsClient_T *	bsClientNew (const char *sClientName)
	Create a new unconnected proxied client. More...
void	bsClientDelete (BsClient_P pClient)
	Delete a proxied client. More...
void	bsVConnClearAll (BsClient_T *pClient)
	Remove and delete all of a client's vConnections. More...
int	bsVConnAdd (BsClient_T *pClient, BsVConnHnd_T hndVConn, int index)
	Add a created vConnection to the client's tblHndIndex table. More...
int	bsVConnRemove (BsClient_T *pClient, BsVConnHnd_T hndVConn)
	Remove a vConnection from the client's tblHndIndex table. More...
int	bsVConnNew (BsClient_T *pClient, const char *sDevName, const char *sModName, const BsClientAppInfo_T *pAppInfo, bool_t bTrace)
	Reserve a new client vConnection (and proxied device) in the client's tblVConn table. More...
int	bsVConnDelete (BsClient_T *pClient, int index)
	Delete a vConnection (and proxied device) from the client's tblVConn table. More...

Detailed Description

Client base functions.

LastChangedDate

2012-11-25 10:42:41 -0700 (Sun, 25 Nov 2012)

Rev

2544

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

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

Definition in file bsLibClient.c.

Function Documentation

void bsClientAttrGetConnState	(	BsClient_P	pClient,
		BsClientConnState_T *	pConnState
	)

Get client's connection state.

Parameters

pClient

Definition at line 1120 of file bsLibClient.c.

References BsClientConnState_T::m_bIsConnected, _bsClientStruct::m_pSocket, and BsClientConnState_T::m_sServerHostName.

{
  static BsClientConnState_T  noconn = {false, ""};

  Socket_T *pSocket = pClient->m_pSocket;

  if( (pSocket == NULL) || !SocketStateIsOpen(pSocket) )
  {
    *pConnState = noconn;
  }

  else
  {
    pConnState->m_bIsConnected    = true;
    pConnState->m_sServerHostName = SocketAttrGetRemoteName(pSocket);
  }
}

const char* bsClientAttrGetDevName	(	BsClient_P	pClient,
		BsVConnHnd_T	hndVConn
	)

Get client virtual connection device name.

Parameters

pClient

Definition at line 1054 of file bsLibClient.c.

References bsClientAttrHasVConn(), BSPROXY_VCONN_SERVER, BsVConn_T::m_sDevName, and _bsClientStruct::m_tblVConn.

{
  if( pClient == NULL )
  {
    return NULL;
  }
  else if( hndVConn == BSPROXY_VCONN_SERVER )
  {
    return "server";
  }
  else if( !bsClientAttrHasVConn(pClient, hndVConn) )
  {
    return NULL;
  }
  else
  {
    return pClient->m_tblVConn[hndVConn]->m_sDevName;
  }
}

const char* bsClientAttrGetModName	(	BsClient_P	pClient,
		BsVConnHnd_T	hndVConn
	)

Get client virtual connection interface module name.

Parameters

pClient

Definition at line 1083 of file bsLibClient.c.

References bsClientAttrHasVConn(), BSPROXY_VCONN_SERVER, BsVConn_T::m_sModName, and _bsClientStruct::m_tblVConn.

{
  if( pClient == NULL )
  {
    return NULL;
  }
  else if( hndVConn == BSPROXY_VCONN_SERVER )
  {
    return "server";
  }
  else if( !bsClientAttrHasVConn(pClient, hndVConn) )
  {
    return NULL;
  }
  else
  {
    return pClient->m_tblVConn[hndVConn]->m_sModName;
  }
}

const char* bsClientAttrGetName

(

BsClient_P

pClient

)

Get client name.

Parameters

pClient

Definition at line 918 of file bsLibClient.c.

References _bsClientStruct::m_sClientName.

Referenced by bsTransCacheRsp(), and bsTransLoadCached().

{
  return pClient!=NULL? pClient->m_sClientName: NULL;
}

void bsClientAttrGetTimeouts	(	BsClient_P	pClient,
		uint_t *	pReqTimeout,
		uint_t *	pRspTimeout
	)

Get client request (write) and response (read) timeouts.

Parameters

pClient

Definition at line 930 of file bsLibClient.c.

References _bsClientStruct::m_uReqTimeout, and _bsClientStruct::m_uRspTimeout.

{
  if( pClient != NULL )
  {
    *pReqTimeout = pClient->m_uReqTimeout / 1000000;
    *pRspTimeout = pClient->m_uRspTimeout / 1000000;
  }
}

bool_t bsClientAttrGetTraceState	(	BsClient_P	pClient,
		BsVConnHnd_T	hndVConn
	)

Get client virtual connection trace state.

Parameters

pClient

Definition at line 970 of file bsLibClient.c.

References bsClientAttrHasVConn(), bsGetVConn(), BSPROXY_VCONN_SERVER, BsVConn_T::m_bTrace, and _bsClientStruct::m_bTraceServer.

{
  if( pClient == NULL )
  {
    return false;
  }
  else if( hndVConn == BSPROXY_VCONN_SERVER )
  {
    return pClient->m_bTraceServer;
  }
  else if( bsClientAttrHasVConn(pClient, hndVConn) )
  {
    return bsGetVConn(pClient, hndVConn)->m_bTrace;
  }
  else
  {
    return false;
  }
}

int bsClientAttrGetVConnCount

(

BsClient_P

pClient

)

Get the number of active virtual connections for this client.

Parameters

pClient

Definition at line 998 of file bsLibClient.c.

References _bsClientStruct::m_nVConnCount.

Referenced by bsVConnNew().

{
  if( pClient == NULL )
  {
    return 0;
  }
  else
  {
    return pClient->m_nVConnCount;
  }
}

bool_t bsClientAttrHasVConn	(	BsClient_P	pClient,
		BsVConnHnd_T	hndVConn
	)

Test if client has a virtual connection identified by the handle.

Parameters

pClient

Definition at line 1019 of file bsLibClient.c.

References BSCLIENT_IS_VCONN_HANDLE, BSPROXY_VCONN_UNDEF, _bsClientStruct::m_tblHndIndex, and _bsClientStruct::m_tblVConn.

Referenced by bsClientAttrGetDevName(), bsClientAttrGetModName(), bsClientAttrGetTraceState(), and bsClientGetMsgName().

{
  int   index;

  if( pClient == NULL )
  {
    return false;
  }
  else if( !BSCLIENT_IS_VCONN_HANDLE(hndVConn) )
  {
    return false;
  }
  else if( (index = pClient->m_tblHndIndex[hndVConn]) == BSPROXY_VCONN_UNDEF )
  {
    return false;
  }
  else if( pClient->m_tblVConn[index] == NULL )
  {
    return false;
  }
  else
  {
    return true;
  }
}

void bsClientAttrSetLogging	(	BsClient_P	pClient,
		int	nLevel
	)

Set client's diagnostics logging threshold.

Parameters

pClient

Definition at line 1109 of file bsLibClient.c.

{
  LOG_SET_THRESHOLD(nLevel);
}

void bsClientAttrSetTimeouts	(	BsClient_P	pClient,
		uint_t	uReqTimeout,
		uint_t	uRspTimeout
	)

Set client request (write) and response (read) timeouts.

A timeout value of 0 means block forever until i/o operation is complete.

Parameters

pClient

Definition at line 950 of file bsLibClient.c.

References _bsClientStruct::m_uReqTimeout, and _bsClientStruct::m_uRspTimeout.

{
  if( pClient != NULL )
  {
    pClient->m_uReqTimeout = uReqTimeout * 1000000;
    pClient->m_uRspTimeout = uRspTimeout * 1000000;
  }
}

void bsClientDelete

(

BsClient_P

pClient

)

Delete a proxied client.

Warning

The client should disconnect prior to deletion.

Parameters

pClient

Definition at line 1438 of file bsLibClient.c.

References BS_ECODE_GEN, BSCLIENT_LOG_WARN, bsTransForget(), bsVConnClearAll(), _bsClientStruct::m_mutexTrans, _bsClientStruct::m_pSocket, _bsClientStruct::m_sClientName, and _bsClientStruct::m_tblTransCache.

{
  size_t i;

  if( pClient == NULL )
  {
    return;
  }

  if( SocketStateIsOpen(pClient->m_pSocket) )
  {
    BSCLIENT_LOG_WARN(pClient, BS_ECODE_GEN,
        "Connection still open, auto-disconnecting.");
    (void)bsServerDisconnect(pClient);
  }

  for(i=0; i<arraysize(pClient->m_tblTransCache); ++i)
  {
    bsTransForget(pClient, (BsTid_T)i);
  }

  bsVConnClearAll(pClient);

  pthread_mutex_destroy(&(pClient->m_mutexTrans));

  delete((void *)(pClient->m_sClientName));

  delete(pClient);
}

void bsClientFillMsgHdr	(	BsClient_P	pClient,
		int	hndVConn,
		uint_t	uMsgId,
		size_t	uBodyLen,
		BsProxyMsgHdr_T *	pMsgHdr
	)

Fill in message header.

Parameters

pClient

Definition at line 1148 of file bsLibClient.c.

References bsNextTid(), BSPROXY_MSG_MAGIC, BsProxyMsgHdr_T::m_hdrBodyLen, BsProxyMsgHdr_T::m_hdrMagic, BsProxyMsgHdr_T::m_hdrMsgId, BsProxyMsgHdr_T::m_hdrTid, and BsProxyMsgHdr_T::m_hdrVConn.

Referenced by bsClientTrans().

{
  pMsgHdr->m_hdrMagic   = (ushort_t)BSPROXY_MSG_MAGIC;
  pMsgHdr->m_hdrTid     = (byte_t)bsNextTid(pClient);
  pMsgHdr->m_hdrVConn   = (byte_t)hndVConn;
  pMsgHdr->m_hdrMsgId   = (ushort_t)uMsgId;
  pMsgHdr->m_hdrBodyLen = (ushort_t)uBodyLen;
}

const char* bsClientGetMsgName	(	BsClient_P	pClient,
		BsVConnHnd_T	hndVConn,
		uint_t	uMsgId
	)

Get the message name.

For each (virtual connection, message id) 2-tuple, there can be a known name string (provided the id is valid and an application provides the information).

Parameters

pClient

Definition at line 1175 of file bsLibClient.c.

References bsClientAttrHasVConn(), bsGetVConn(), BSPROXY_VCONN_SERVER, BsProxyLookupMsgDef(), BsClientAppInfo_T::fnGetMsgName, and BsVConn_T::m_pAppInfo.

Referenced by bsClientLogMsgHdr().

{
  static const char       *sUnknown = "unknown";
  const NMMsgDef_T        *pMsgDef;
  BsVConn_T               *pVConn;
  const BsClientAppInfo_T *pAppInfo;

  if( hndVConn == BSPROXY_VCONN_SERVER )
  {
    pMsgDef = BsProxyLookupMsgDef((BsProxyMsgId_T)uMsgId);
    return pMsgDef!=NULL? pMsgDef->m_sMsgName: sUnknown;
  }
  else if( !bsClientAttrHasVConn(pClient, hndVConn) )
  {
    return sUnknown;
  }
  else if( (pVConn = bsGetVConn(pClient, hndVConn)) == NULL )
  {
    return sUnknown;
  }
  else if( (pAppInfo = pVConn->m_pAppInfo) == NULL ) 
  {
    return sUnknown;
  }
  else if( pAppInfo->fnGetMsgName == NULL )
  {
    return sUnknown;
  }
  else
  {
    return pAppInfo->fnGetMsgName(pClient, hndVConn, uMsgId);
  }
}

void bsClientLogMsgHdr	(	BsClient_P	pClient,
		const char *	sPreface,
		BsProxyMsgHdr_T *	pMsgHdr
	)

Log [pre/un]packed message header.

Parameters

pClient

Definition at line 1219 of file bsLibClient.c.

References bsClientGetMsgName(), BsProxyMsgHdr_T::m_hdrBodyLen, BsProxyMsgHdr_T::m_hdrMagic, BsProxyMsgHdr_T::m_hdrMsgId, BsProxyMsgHdr_T::m_hdrTid, and BsProxyMsgHdr_T::m_hdrVConn.

{
  FILE        *fp;
  const char  *sMsgName;

  fp = LOG_GET_LOGFP();

  if( pMsgHdr != NULL )
  {
    sMsgName = bsClientGetMsgName(pClient,
                                  (BsVConnHnd_T)pMsgHdr->m_hdrVConn,
                                  (uint_t)pMsgHdr->m_hdrMsgId);

    fprintf(fp, "%s MsgHdr = {\n", sPreface);
    fprintf(fp, "  Magic:   0x%04x\n",  pMsgHdr->m_hdrMagic);
    fprintf(fp, "  Tid:     %u\n",      (uint_t)(pMsgHdr->m_hdrTid));
    fprintf(fp, "  VConn:   %u\n",      (uint_t)(pMsgHdr->m_hdrVConn));
    fprintf(fp, "  MsgId:   %u %s \n",  pMsgHdr->m_hdrMsgId, sMsgName);
    fprintf(fp, "  BodyLen: %u\n",      pMsgHdr->m_hdrBodyLen);
    fprintf(fp, "}\n");
  }
  else
  {
    fprintf(fp, "%s MsgHdr: (null)\n", sPreface);
  }
}

BsClient_T* bsClientNew

(

const char *

sClientName

)

Create a new unconnected proxied client.

Parameters

sClientName

Proxied client (robot)'s name.

Returns

Returns pointer to new client on success. Else returns NULL.

Definition at line 1396 of file bsLibClient.c.

References BSCLIENT_T_READ, BSCLIENT_T_WRITE, BSPROXY_VCONN_UNDEF, _bsClientStruct::m_bTraceServer, _bsClientStruct::m_mutexTrans, _bsClientStruct::m_nVConnCount, _bsClientStruct::m_pSocket, _bsClientStruct::m_sClientName, _bsClientStruct::m_tblHndIndex, _bsClientStruct::m_tblTransCache, _bsClientStruct::m_tblVConn, _bsClientStruct::m_uReqTimeout, _bsClientStruct::m_uRspTimeout, and _bsClientStruct::m_uTidCounter.

{
  BsClient_T     *pClient = NEW(BsClient_T);
  size_t          i;

  pClient->m_sClientName  = new_strdup(sClientName);
  pClient->m_pSocket      = NULL;

  pthread_mutex_init(&(pClient->m_mutexTrans), NULL);

  pClient->m_uReqTimeout  = BSCLIENT_T_WRITE;
  pClient->m_uRspTimeout  = BSCLIENT_T_READ;
  pClient->m_uTidCounter  = 0;
  pClient->m_bTraceServer = false;
      
  for(i=0; i<arraysize(pClient->m_tblTransCache); ++i)
  {
    pClient->m_tblTransCache[i] = NULL;
  }

  pClient->m_nVConnCount = 0;

  for(i=0; i<arraysize(pClient->m_tblHndIndex); ++i)
  {
    pClient->m_tblHndIndex[i] = BSPROXY_VCONN_UNDEF;
  }

  for(i=0; i<arraysize(pClient->m_tblVConn); ++i)
  {
    pClient->m_tblVConn[i] = NULL;
  }

  return pClient;
}

static int bsClientPackMsgHdr ( BsClient_T *  pClient, BsProxyMsgHdr_T *  pMsgHdr, byte_t  buf[], size_t  bufSize  )

inlinestatic

Pack BotSense client message header.

Parameters

pClient

Definition at line 397 of file bsLibClient.c.

References BS_ECODE_BUF_TOO_SMALL, BSCLIENT_TRY_EXPR, and BSPROXY_MSG_HDR_LEN.

Referenced by bsClientSendReq().

{
  BSCLIENT_TRY_EXPR(pClient, (bufSize >= BSPROXY_MSG_HDR_LEN),
                    BS_ECODE_BUF_TOO_SMALL, "bufSize=%zu < %u",
                    bufSize, BSPROXY_MSG_HDR_LEN);

  return bsPackMsgHdr(pMsgHdr, buf, bufSize);
}

static int bsClientRead ( BsClient_T *  pClient, int  sd, byte_t  buf[], size_t  count, uint_t  usec  )

static

Read bytes from socket.

Read up to count bytes into buf from the socket. This call is non-blocking if the timeout value usec is greater than zero. Otherwise the read can block indefinitely.

Note that on return the bytes read can be less than count.

Parameters

pClient

Definition at line 457 of file bsLibClient.c.

References BS_ECODE_BAD_RECV, BSCLIENT_LOG_SYSERROR, fdset_nowarn(), timer_elapsed(), and timer_mark().

Referenced by bsClientRecvRsp(), and bsFlushInput().

{
  bool_t          bNonBlocking;
  struct timeval  tstart;
  uint_t          tdelta;
  fd_set          rset;
  struct timeval  timeout;
  int             nFd;
  ssize_t         n;
  int             nBytes = 0;

  LOGDIAG4CALL(_TINT(sd), _TPTR(buf), _TUINT(count), _TUINT(usec));

  bNonBlocking = usec > 0? true: false;

  while( nBytes < count )
  {
    FD_ZERO(&rset);
    fdset_nowarn(sd, &rset);

    // wait for input with timeout
    if( bNonBlocking )
    {
      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, &rset, NULL, NULL, &timeout);
    }

    // block indefinitely for input
    else 
    {
      nFd = select(sd+1, &rset, NULL, NULL, NULL);
    }

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

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

    // data available from serial device 
    n = read(sd, buf+nBytes, count-(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:
          BSCLIENT_LOG_SYSERROR(pClient, BS_ECODE_BAD_RECV,
              "select(%d,...)", sd);
          return -BS_ECODE_BAD_RECV;
      }
    }

    // got some data
    nBytes += (int)n;

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

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

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

  return nBytes;
}

static int bsClientRecvRsp ( BsClient_T *  pClient, BsProxyMsgHdr_T *  pMsgHdr, byte_t  bufRsp[], size_t  bufSize  )

static

Read response message from server.

Parameters

pClient

Definition at line 829 of file bsLibClient.c.

References _BS_LOG_MSGHDR, BS_ECODE_BAD_RECV, BS_ECODE_MSG_BAD_HDR, BS_ECODE_MSG_TOO_BIG, BSCLIENT_LOG_ERROR, BSCLIENT_TRY_ECODE, BSCLIENT_TRY_EXPR, bsClientRead(), bsClientUnpackMsgHdr(), bsFlushInput(), BSPROXY_MSG_HDR_LEN, BSPROXY_MSG_MAGIC, bsResync(), bsTransLock(), bsTransUnlock(), BsProxyMsgHdr_T::m_hdrBodyLen, BsProxyMsgHdr_T::m_hdrMagic, BsProxyMsgHdr_T::m_hdrMsgId, _bsClientStruct::m_pSocket, and _bsClientStruct::m_uRspTimeout.

Referenced by bsClientTrans().

{
  int         sd;
  size_t      uBodyLen;
  uint_t      uMsgId;
  int         nBytes;             
  byte_t      bufHdr[BSPROXY_MSG_HDR_LEN];
  int         n;

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

  bsTransLock(pClient);

  // read response header
  n = bsClientRead(pClient, sd, bufHdr, BSPROXY_MSG_HDR_LEN,
                                      pClient->m_uRspTimeout);

  bsTransUnlock(pClient);

  BSCLIENT_TRY_EXPR(pClient, (n == BSPROXY_MSG_HDR_LEN), BS_ECODE_BAD_RECV,
        "Failed to receive response message header, %d bytes received.", n);

  // unpack message header
  n = bsClientUnpackMsgHdr(pClient, bufHdr, (size_t)BSPROXY_MSG_HDR_LEN,
                            pMsgHdr);

  BSCLIENT_TRY_ECODE(pClient, n,   
        "Received bad response message header, discarding.");

  _BS_LOG_MSGHDR(pClient, "Rx Rsp", pMsgHdr);

  uBodyLen  = (size_t)(pMsgHdr->m_hdrBodyLen);
  uMsgId    = pMsgHdr->m_hdrMsgId;
  nBytes    = BSPROXY_MSG_HDR_LEN + (int)uBodyLen;

  // validate magic
  if( pMsgHdr->m_hdrMagic != BSPROXY_MSG_MAGIC )
  {
    BSCLIENT_LOG_ERROR(pClient, BS_ECODE_MSG_BAD_HDR,
      "MsgId=%u: " 
      "Received bad magic 0x%04x in response message header, resyncing.",
      uMsgId, pMsgHdr->m_hdrMagic);
    bsResync(pClient);
    return -BS_ECODE_MSG_BAD_HDR;
  }

  // message too long
  if( uBodyLen > bufSize )
  {
    BSCLIENT_LOG_ERROR(pClient, BS_ECODE_MSG_TOO_BIG,
      "MsgId=%u: Message body_len=%zu > buf_size=%zu, discarding.",
      uMsgId, uBodyLen, bufSize);
    bsFlushInput(pClient, uBodyLen);
    return -BS_ECODE_MSG_TOO_BIG;
  }

  // read response body
  if( uBodyLen > 0 )
  {
    // read response body
    n = bsClientRead(pClient, sd, bufRsp, uBodyLen, pClient->m_uRspTimeout);

    BSCLIENT_TRY_EXPR(pClient, (n == (int)uBodyLen), BS_ECODE_BAD_RECV,
      "MsgId=%u: Failed to receive response message body.", uMsgId);
  }

  LOGDIAG3("MsgId=%u: Received %d byte response.", uMsgId, nBytes);

  return nBytes;
}

static int bsClientSendReq ( BsClient_T *  pClient, BsProxyMsgHdr_T *  pMsgHdr, byte_t  bufReq[], size_t  bufSize  )

static

Send a request message to the server.

Parameters

pClient

Definition at line 771 of file bsLibClient.c.

References _BS_LOG_MSGHDR, BS_ECODE_BAD_SEND, BS_ECODE_BUF_TOO_SMALL, BS_ECODE_MSG_TOO_BIG, BSCLIENT_TRY_ECODE, BSCLIENT_TRY_EXPR, bsClientPackMsgHdr(), bsClientWrite(), BSPROXY_MSG_BODY_MAX, BSPROXY_MSG_HDR_LEN, bsTransLock(), bsTransUnlock(), BsProxyMsgHdr_T::m_hdrBodyLen, BsProxyMsgHdr_T::m_hdrMsgId, _bsClientStruct::m_pSocket, and _bsClientStruct::m_uReqTimeout.

Referenced by bsClientTrans().

{
  int         sd;
  size_t      uBodyLen;
  uint_t      uMsgId;
  int         nBytes;
  int         n;

  sd        = SocketAttrGetSd(pClient->m_pSocket);
  uMsgId    = pMsgHdr->m_hdrMsgId;
  uBodyLen  = (size_t)(pMsgHdr->m_hdrBodyLen);
  nBytes    = BSPROXY_MSG_HDR_LEN + (int)uBodyLen;

  _BS_LOG_MSGHDR(pClient, "Tx Req", pMsgHdr);

  BSCLIENT_TRY_EXPR(pClient, (bufSize >= BSPROXY_MSG_HDR_LEN),
      BS_ECODE_BUF_TOO_SMALL, "MsgId=%u: buf_size=%zu", bufSize);

  BSCLIENT_TRY_EXPR(pClient, (uBodyLen <= BSPROXY_MSG_BODY_MAX),
      BS_ECODE_MSG_TOO_BIG, "MsgId=%u: Message body_len=%zu > max=%zu",
      uMsgId, uBodyLen, BSPROXY_MSG_BODY_MAX);

  // prepend header to request buffer
  n = bsClientPackMsgHdr(pClient, pMsgHdr, bufReq, BSPROXY_MSG_HDR_LEN);

  BSCLIENT_TRY_ECODE(pClient, n,
      "MsgId=%u: Failed to pack message header", uMsgId);

  bsTransLock(pClient);

  // send the message to the server
  n = bsClientWrite(pClient, sd, bufReq, (size_t)nBytes,
                                                    pClient->m_uReqTimeout);

  bsTransUnlock(pClient);

  BSCLIENT_TRY_EXPR(pClient, (n == nBytes), BS_ECODE_BAD_SEND,
      "MsgId=%u: Failed to send message", uMsgId);

  LOGDIAG3("MsgId=%u: Sent %d byte request.", uMsgId, nBytes);

  return nBytes;
}

int bsClientTrans	(	BsClient_P	pClient,
		int	hndVConn,
		uint_t	uReqMsgId,
		byte_t	bufReq[],
		size_t	uReqBodyLen,
		uint_t	uRspMsgId,
		byte_t	bufRsp[],
		size_t	sizeRspBuf
	)

Execute a request - response transaction with the server.

Note

The request and response buffer can be the same buffer if packed request contents does not need to be preserved.

Warning

There must be exactly BSPROXY_MSG_HDR_LEN bytes at the front of the request buffer available to pack the BotSense header. (Reduces the number of buffer copies.)

Request Format:

msghdr msgbody

Response Format:

msghdr msgbody

Parameters

pClient

Definition at line 1279 of file bsLibClient.c.

References _BS_LOG_REQ, _BS_LOG_RSP, BS_ECODE_MSG_BAD_HDR, BSCLIENT_LOG_ERROR, BSCLIENT_TRY_ECODE, BSCLIENT_TRY_EXPR, bsClientFillMsgHdr(), bsClientRecvRsp(), bsClientSendReq(), BSPROXY_MSG_HDR_LEN, BSPROXY_VCONN_SERVER, BsProxyMsgIdRspErr, BsProxyUnpackRspErr(), bsTransCacheRsp(), bsTransForget(), bsTransLoadCached(), bsTransMark(), BsProxyRspErr_T::m_ecode, BsProxyRspErr_T::m_emsg, BsProxyMsgHdr_T::m_hdrBodyLen, BsProxyMsgHdr_T::m_hdrMsgId, BsProxyMsgHdr_T::m_hdrTid, and BsProxyMsgHdr_T::m_hdrVConn.

{
  BsProxyMsgHdr_T   hdrReq;       // request message header
  BsProxyMsgHdr_T   hdrRsp;       // response message header
  BsTid_T           tidReq;       // request transaction id
  BsProxyRspErr_T   msgRspErr;    // common error response message
  bool_t            bPending;     // resposne is [not] pending
  int               n;            // number of bytes/return code

  // fill request header
  bsClientFillMsgHdr(pClient, hndVConn, uReqMsgId, uReqBodyLen, &hdrReq);

  // this request's transaction id
  tidReq = hdrReq.m_hdrTid;

  // mark request for tracking
  bsTransMark(pClient, tidReq);

  // send request
  n = bsClientSendReq(pClient, &hdrReq, bufReq,
                            BSPROXY_MSG_HDR_LEN+uReqBodyLen);

  BSCLIENT_TRY_ECODE(pClient, n,
      "MsgId=%u: Failed to send request.", uReqMsgId);

  // log successful request sent event
  _BS_LOG_REQ(pClient, &hdrReq);

  bPending = true;

  // receive response
  while( bPending )
  {
    // check transaction cache for any cached response.
    n = bsTransLoadCached(pClient, tidReq, &hdrRsp, bufRsp, sizeRspBuf);

    BSCLIENT_TRY_ECODE(pClient, n,
        "MsgId=%u: Cached response failed for request.", uReqMsgId);

    // found a good, cached response
    if( n > 0 )
    {
      bsTransForget(pClient, tidReq);
      bPending = false;
    }

    // receive a response
    else
    {
      n = (int)bsClientRecvRsp(pClient, &hdrRsp, bufRsp, sizeRspBuf);

      BSCLIENT_TRY_ECODE(pClient, n,
        "MsgId=%u: Receive response failed for request.", uReqMsgId);

      // response was for this request
      if( tidReq == hdrRsp.m_hdrTid )
      {
        bsTransForget(pClient, tidReq);
        bPending = false;
      }

      // response is for another thread - cache it
      else
      {
        bsTransCacheRsp(pClient, tidReq, &hdrRsp, bufRsp);
      }
    }
  }

  n = (int)hdrRsp.m_hdrBodyLen;

  // received common error response
  if( (hdrRsp.m_hdrVConn == BSPROXY_VCONN_SERVER) &&
      (hdrRsp.m_hdrMsgId == BsProxyMsgIdRspErr) )
  {
    n = BsProxyUnpackRspErr(bufRsp, (size_t)n, &msgRspErr, false);

    BSCLIENT_TRY_ECODE(pClient, n,
        "MsgId=%u: Failed to unpack error response message body.",
        hdrRsp.m_hdrMsgId);

    n = -(int)(msgRspErr.m_ecode);

    BSCLIENT_LOG_ERROR(pClient, n, "%s", msgRspErr.m_emsg);

    return n;
  }

  // received application-specific response
  else
  {
    BSCLIENT_TRY_EXPR(pClient, (hdrRsp.m_hdrMsgId == uRspMsgId),
        BS_ECODE_MSG_BAD_HDR,
        "MsgId=%u: Unexpected response message id, expected MsgId=%u.",
        hdrRsp.m_hdrMsgId, uRspMsgId);
  }

  // log response received event
  _BS_LOG_RSP(pClient, &hdrRsp);

  return n;
}

static int bsClientUnpackMsgHdr ( BsClient_T *  pClient, byte_t  buf[], size_t  bufSize, BsProxyMsgHdr_T *  pMsgHdr  )

inlinestatic

Unpack BotSense client message header.

Parameters

pClient

Definition at line 421 of file bsLibClient.c.

References BS_ECODE_BUF_TOO_SMALL, BSCLIENT_TRY_EXPR, and BSPROXY_MSG_HDR_LEN.

Referenced by bsClientRecvRsp().

{
  BSCLIENT_TRY_EXPR(pClient, (bufSize >= BSPROXY_MSG_HDR_LEN),
                    BS_ECODE_BUF_TOO_SMALL, "bufSize=%zu < %u",
                    bufSize, BSPROXY_MSG_HDR_LEN);

  return bsUnpackMsgHdr(buf, bufSize, pMsgHdr);
}

static int bsClientWrite ( BsClient_T *  pClient, int  sd, byte_t  buf[], size_t  count, uint_t  usec  )

static

Write bytes to socket.

Write up to count bytes from buf to the socket. This call is non-blocking if the timeout value usec is greater than zero. Otherwise the read can block indefinitely.

Note that the number of bytes written can be less than the count.

Parameters

pClient

Definition at line 594 of file bsLibClient.c.

References BS_ECODE_BAD_RECV, BS_ECODE_BAD_SEND, BSCLIENT_LOG_SYSERROR, fdset_nowarn(), timer_elapsed(), and timer_mark().

Referenced by bsClientSendReq().

{
  bool_t          bNonBlocking;
  struct timeval  tstart;
  uint_t          tdelta;
  fd_set          wset;
  struct timeval  timeout;
  int             nFd;
  ssize_t         n;
  int             nBytes = 0;

  LOGDIAG4CALL(_TINT(sd), _TPTR(buf), _TUINT(count), _TUINT(usec));

  bNonBlocking = usec > 0? true: false;

  while( nBytes < count )
  {
    FD_ZERO(&wset);
    fdset_nowarn(sd, &wset);

    // wait for input with timeout
    if( bNonBlocking )
    {
      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);
    }

    // block indefinitely for input
    else 
    {
      nFd = select(sd+1, NULL, &wset, NULL, NULL);
    }

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

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

    // data available from serial device 
    n = write(sd, buf+nBytes, count-(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:
          BSCLIENT_LOG_SYSERROR(pClient, BS_ECODE_BAD_SEND,
              "select(%d,...)", sd);
          return -BS_ECODE_BAD_RECV;
      }
    }

    // sent some data
    nBytes += (int)n;

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

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

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

  return nBytes;
}

static void bsFlushInput ( BsClient_T *  pClient, size_t  count  )

static

Flush input of count bytes.

Parameters

pClient

Definition at line 713 of file bsLibClient.c.

References BSCLIENT_T_FLUSH, bsClientRead(), and _bsClientStruct::m_pSocket.

Referenced by bsClientRecvRsp(), and bsResync().

{
  int     sd;
  byte_t  buf[1024];
  size_t  block;
  int     n;

  sd = SocketAttrGetSd(pClient->m_pSocket);

  while( count > 0 )
  {
    block = sizeof(buf) >= count? count: sizeof(buf);
    n = bsClientRead(pClient, sd, buf, block, BSCLIENT_T_FLUSH);
    if( n <= 0 )
    {
      return;
    }
    count -= (size_t)n;
  }
}

static BsTid_T bsNextTid ( BsClient_T *  pClient )

static

Atomically get the next available transaction id.

Parameters

pClient

Definition at line 315 of file bsLibClient.c.

References BSPROXY_TID_MASK, bsTransLock(), bsTransUnlock(), and _bsClientStruct::m_uTidCounter.

Referenced by bsClientFillMsgHdr().

{
  BsTid_T uTid;

  bsTransLock(pClient);

  uTid = pClient->m_uTidCounter;
  pClient->m_uTidCounter = (uTid + 1) & BSPROXY_TID_MASK;

  bsTransUnlock(pClient);

  return uTid;
}

static void bsResync ( BsClient_T *  pClient )

static

Resync client with server.

Lost message alignment with the server (if this is possible). Perfomr a series of flush-request cycles to try to get back in sync.

Parameters

pClient

Definition at line 742 of file bsLibClient.c.

References BS_ECODE_BAD_RESYNC, BS_OK, BSCLIENT_LOG_ERROR, bsFlushInput(), and BSPROXY_MSG_MAX_LEN.

Referenced by bsClientRecvRsp().

{
  int   nMaxTries = 5;
  int   nTries;
  int   rc;

  for(nTries=0; nTries<nMaxTries; ++nTries)
  {
    bsFlushInput(pClient, BSPROXY_MSG_MAX_LEN);
    if( (rc = bsServerReqLoopback(pClient, "resync")) == BS_OK )
    {
      return;
    }
  }
  BSCLIENT_LOG_ERROR(pClient, BS_ECODE_BAD_RESYNC, "");
}

static void bsTransCacheRsp ( BsClient_T *  pClient, BsTid_T  uTid, BsProxyMsgHdr_T *  pMsgHdr, byte_t  bufRsp[]  )

static

Cache a transaction response.

Cashing a response occurs when this client thread receives a response fo another client thread.

Parameters

pClient

Definition at line 214 of file bsLibClient.c.

References bsClientAttrGetName(), BSPROXY_TID_MASK, bsTransLock(), bsTransUnlock(), BsTransInfo_T::m_bCached, BsProxyMsgHdr_T::m_hdrBodyLen, BsProxyMsgHdr_T::m_hdrMsgId, BsTransInfo_T::m_pBuf, BsTransInfo_T::m_pMsgHdr, and _bsClientStruct::m_tblTransCache.

Referenced by bsClientTrans().

{
  BsTransInfo_T  *pInfo;
  size_t          uBodyLen;

  bsTransLock(pClient);

  pInfo = pClient->m_tblTransCache[uTid & BSPROXY_TID_MASK];

  delete(pInfo->m_pMsgHdr);
  delete(pInfo->m_pBuf);

  uBodyLen = (size_t)(pMsgHdr->m_hdrBodyLen);

  pInfo->m_pMsgHdr  = new_memdup(sizeof(BsProxyMsgHdr_T), pMsgHdr);
  pInfo->m_pBuf     = uBodyLen>0? new_memdup(uBodyLen, bufRsp): NULL;
  pInfo->m_bCached  = true;

  LOGDIAG3("%s: Tid=%u, MsgId=%u cached.",
      bsClientAttrGetName(pClient), uTid, pMsgHdr->m_hdrMsgId);

  bsTransUnlock(pClient);
}

static void bsTransForget ( BsClient_T *  pClient, BsTid_T  uTid  )

static

Delete any cached transaction state from the cache.

Parameters

pClient

Definition at line 184 of file bsLibClient.c.

References BSPROXY_TID_MASK, bsTransLock(), bsTransUnlock(), BsTransInfo_T::m_pBuf, BsTransInfo_T::m_pMsgHdr, and _bsClientStruct::m_tblTransCache.

Referenced by bsClientDelete(), and bsClientTrans().

{
  BsTransInfo_T *pInfo;

  bsTransLock(pClient);

  pInfo = pClient->m_tblTransCache[uTid & BSPROXY_TID_MASK];

  if( pInfo != NULL )
  {
    delete(pInfo->m_pMsgHdr);
    delete(pInfo->m_pBuf);
    delete(pInfo);
    pClient->m_tblTransCache[uTid & BSPROXY_TID_MASK] = NULL;
  }

  bsTransUnlock(pClient);
}

static int bsTransLoadCached ( BsClient_T *  pClient, BsTid_T  uTid, BsProxyMsgHdr_T *  pMsgHdr, byte_t  bufRsp[], size_t  sizeRsp  )

static

Load cached response from transaction cache.

Cashing a response occurs when this client thread receives a response fo another client thread.

Parameters

pClient

Definition at line 258 of file bsLibClient.c.

References BS_ECODE_MSG_TOO_BIG, BSCLIENT_LOG_ERROR, bsClientAttrGetName(), BSPROXY_TID_MASK, bsTransLock(), bsTransUnlock(), BsTransInfo_T::m_bCached, BsProxyMsgHdr_T::m_hdrBodyLen, BsProxyMsgHdr_T::m_hdrMsgId, BsTransInfo_T::m_pBuf, BsTransInfo_T::m_pMsgHdr, and _bsClientStruct::m_tblTransCache.

Referenced by bsClientTrans().

{
  BsTransInfo_T  *pInfo;
  size_t          uBodyLen;
  int             rc = 0;

  bsTransLock(pClient);

  pInfo = pClient->m_tblTransCache[uTid & BSPROXY_TID_MASK];

  if( (pInfo == NULL) || !pInfo->m_bCached )
  {
    rc = 0;
  }

  else
  {
    uBodyLen = (size_t)(pMsgHdr->m_hdrBodyLen);
    if( uBodyLen > sizeRsp )
    {
      BSCLIENT_LOG_ERROR(pClient, BS_ECODE_MSG_TOO_BIG,
        "body_len=%zu > buf_size=%zu.", uBodyLen, sizeRsp);
      rc = -BS_ECODE_MSG_TOO_BIG;
    }

    // load from cache
    else
    {
      *pMsgHdr = *(pInfo->m_pMsgHdr);
      if( uBodyLen > 0 )
      {
        memcpy(bufRsp, pInfo->m_pBuf, uBodyLen);
      }

      LOGDIAG3("%s: Tid=%u, MsgId=%u loaded from cached.",
        bsClientAttrGetName(pClient), uTid, pMsgHdr->m_hdrMsgId);

      rc = 1;
    }
  }

  bsTransUnlock(pClient);

  return rc;
}

static void bsTransLock ( BsClient_T *  pClient )

inlinestatic

Lock client's transaction mutual exclusion.

Parameters

pClient

Definition at line 97 of file bsLibClient.c.

References BS_ECODE_SYS, and BSCLIENT_LOG_SYSERROR.

Referenced by bsClientRecvRsp(), bsClientSendReq(), bsNextTid(), bsTransCacheRsp(), bsTransForget(), bsTransLoadCached(), bsTransMark(), bsVConnAdd(), bsVConnDelete(), bsVConnNew(), and bsVConnRemove().

{
  int rc;

  if( (rc = pthread_mutex_lock(&(pClient->m_mutexTrans))) != 0 ) 
  { 
    errno = rc;
    BSCLIENT_LOG_SYSERROR(pClient, BS_ECODE_SYS, "pthread_mutex_lock()");
  }
}

static void bsTransMark ( BsClient_T *  pClient, BsTid_T  uTid  )

static

Mark the start of a client's server transaction in the transaction cache.

A client can be multi-threaded, and so the responses from the server may come out of order with respect to the client thread.

Parameters

pClient

Definition at line 152 of file bsLibClient.c.

References BSPROXY_TID_MASK, bsTransLock(), bsTransUnlock(), BsTransInfo_T::m_bCached, BsTransInfo_T::m_pBuf, BsTransInfo_T::m_pMsgHdr, and _bsClientStruct::m_tblTransCache.

Referenced by bsClientTrans().

{
  BsTransInfo_T *pInfo;

  bsTransLock(pClient);

  pInfo = pClient->m_tblTransCache[uTid & BSPROXY_TID_MASK];

  if( pInfo != NULL )
  {
    delete(pInfo->m_pMsgHdr);
    delete(pInfo->m_pBuf);
    delete(pInfo);
  }

  pInfo = NEW(BsTransInfo_T);

  pInfo->m_pMsgHdr  = NULL;
  pInfo->m_pBuf     = NULL;
  pInfo->m_bCached  = false;

  pClient->m_tblTransCache[uTid & BSPROXY_TID_MASK] = pInfo;

  bsTransUnlock(pClient);
}

static bool_t bsTransTryLock ( BsClient_T *  pClient )

inlinestatic

Try to lock client's transaction mutual exclusion.

Parameters

pClient

Definition at line 132 of file bsLibClient.c.

References _bsClientStruct::m_mutexTrans.

{
  return pthread_mutex_trylock(&(pClient->m_mutexTrans)) == 0? true: false;
}

static void bsTransUnlock ( BsClient_T *  pClient )

inlinestatic

Unlock client's transaction mutual exclusion.

Parameters

pClient

Definition at line 113 of file bsLibClient.c.

References BS_ECODE_SYS, BSCLIENT_LOG_SYSERROR, and _bsClientStruct::m_mutexTrans.

Referenced by bsClientRecvRsp(), bsClientSendReq(), bsNextTid(), bsTransCacheRsp(), bsTransForget(), bsTransLoadCached(), bsTransMark(), bsVConnAdd(), bsVConnDelete(), bsVConnNew(), and bsVConnRemove().

{
  int rc;

  if( (rc = pthread_mutex_unlock(&(pClient->m_mutexTrans))) != 0 ) 
  { 
    errno = rc;
    BSCLIENT_LOG_SYSERROR(pClient, BS_ECODE_SYS, "pthread_mutex_unlock()");
  }
}

int bsVConnAdd	(	BsClient_T *	pClient,
		BsVConnHnd_T	hndVConn,
		int	index
	)

Add a created vConnection to the client's tblHndIndex table.

Note

The new vConnection should have been created and reserved prior to adding.

Parameters

pClient

Definition at line 1506 of file bsLibClient.c.

References BS_ECODE_INTERNAL, BS_OK, BSCLIENT_IS_VCONN_HANDLE, BSCLIENT_LOG_ERROR, BSCLIENT_TRY_EXPR, BSPROXY_VCONN_CLIENT_MAX, BSPROXY_VCONN_UNDEF, bsTransLock(), bsTransUnlock(), BsVConn_T::m_hndVConn, _bsClientStruct::m_nVConnCount, _bsClientStruct::m_tblHndIndex, and _bsClientStruct::m_tblVConn.

Referenced by bsGetVConn(), and bsServerReqOpenDev().

{
  int   i;
  int   rc;

  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_IS_VCONN_HANDLE(hndVConn),
      BS_ECODE_INTERNAL, "VConn=%d: out-of-range.", hndVConn);

  BSCLIENT_TRY_EXPR(pClient, (index < BSPROXY_VCONN_CLIENT_MAX),
      BS_ECODE_INTERNAL, "index=%d: out-of-range.", index);

  bsTransLock(pClient);

  i = (int)pClient->m_tblHndIndex[hndVConn];

  if( i != BSPROXY_VCONN_UNDEF )
  {
    BSCLIENT_LOG_ERROR(pClient, BS_ECODE_INTERNAL,
      "VConn=%d: index=%d: handle already assigned: "
      "Internal vconn tables corrupted.", hndVConn, i);
    rc = -BS_ECODE_INTERNAL;
  }

  else if( pClient->m_tblVConn[index] == NULL )
  {
    BSCLIENT_LOG_ERROR(pClient, BS_ECODE_INTERNAL,
      "VConn=%d: index=%d: No vConnection present: "
      "Internal vconn tables corrupted.", hndVConn, index);
    rc = -BS_ECODE_INTERNAL;
  }

  else
  {
    pClient->m_tblVConn[index]->m_hndVConn = hndVConn;
    pClient->m_tblHndIndex[hndVConn] = (byte_t)index;
    pClient->m_nVConnCount++;
    rc = BS_OK;
  }

  bsTransUnlock(pClient);

  return rc;
}

void bsVConnClearAll

(

BsClient_T *

pClient

)

Remove and delete all of a client's vConnections.

Parameters

pClient

Definition at line 1478 of file bsLibClient.c.

References BSPROXY_VCONN_UNDEF, bsVConnDelete(), bsVConnRemove(), and _bsClientStruct::m_tblHndIndex.

Referenced by bsClientDelete(), bsGetVConn(), and bsServerDisconnect().

{
  size_t  nHnd;
  int     index;

  for(nHnd=0; nHnd<arraysize(pClient->m_tblHndIndex); ++nHnd)
  {
    index = (int)pClient->m_tblHndIndex[nHnd];
    if( index != BSPROXY_VCONN_UNDEF )
    {
      bsVConnRemove(pClient, (BsVConnHnd_T)nHnd);
      bsVConnDelete(pClient, index);
    }
  }
}

int bsVConnDelete	(	BsClient_T *	pClient,
		int	index
	)

Delete a vConnection (and proxied device) from the client's tblVConn table.

Note

The vConnection should be removed first prior to deletion.

Parameters

pClient

Definition at line 1684 of file bsLibClient.c.

References BS_ECODE_INTERNAL, BS_OK, BSCLIENT_LOG_ERROR, BSCLIENT_TRY_EXPR, BSPROXY_VCONN_CLIENT_MAX, bsTransLock(), bsTransUnlock(), BsVConn_T::m_sDevName, BsVConn_T::m_sModName, and _bsClientStruct::m_tblVConn.

Referenced by bsGetVConn(), bsServerReqCloseDev(), bsServerReqOpenDev(), and bsVConnClearAll().

{
  BsVConn_T  *pVConn;
  int         rc;

  BSCLIENT_TRY_EXPR(pClient, (index < BSPROXY_VCONN_CLIENT_MAX),
      BS_ECODE_INTERNAL, "index=%d: out-of-range.", index);

  bsTransLock(pClient);

  pVConn = pClient->m_tblVConn[index];

  if( pVConn == NULL )
  {
    BSCLIENT_LOG_ERROR(pClient, BS_ECODE_INTERNAL,
      "index=%u: vConnection not present in table.", index);
    rc = -BS_ECODE_INTERNAL;
  }

  else
  {
    delete((char *)(pVConn->m_sDevName));
    delete((char *)(pVConn->m_sModName));
    delete(pVConn);

    // free slot
    pClient->m_tblVConn[index] = NULL;

    rc = BS_OK;
  }

  bsTransUnlock(pClient);

  return rc;
}

int bsVConnNew	(	BsClient_T *	pClient,
		const char *	sDevName,
		const char *	sModName,
		const BsClientAppInfo_T *	pAppInfo,
		bool_t	bTrace
	)

Reserve a new client vConnection (and proxied device) in the client's tblVConn table.

Note

The new vConnection still needs to be added.

Parameters

pClient

Definition at line 1614 of file bsLibClient.c.

References BS_ECODE_INTERNAL, BS_ECODE_NO_RSRC, BS_OK, BSCLIENT_LOG_ERROR, bsClientAttrGetVConnCount(), BSPROXY_VCONN_CLIENT_MAX, BSPROXY_VCONN_UNDEF, bsTransLock(), bsTransUnlock(), BsVConn_T::m_bTrace, BsVConn_T::m_hndVConn, BsVConn_T::m_pAppInfo, BsVConn_T::m_sDevName, BsVConn_T::m_sModName, and _bsClientStruct::m_tblVConn.

Referenced by bsGetVConn(), and bsServerReqOpenDev().

{
  int         index;
  BsVConn_T  *pVConn;
  int         rc = BS_OK;

  bsTransLock(pClient);

  if( bsClientAttrGetVConnCount(pClient) >= BSPROXY_VCONN_CLIENT_MAX )
  {
    BSCLIENT_LOG_ERROR(pClient, BS_ECODE_NO_RSRC,
        "Client has the maximum=%d virtual connections.",
        BSPROXY_VCONN_CLIENT_MAX);
    rc = -BS_ECODE_NO_RSRC;
  }

  else
  {
    for(index=0; index<BSPROXY_VCONN_CLIENT_MAX; ++index)
    {
      if( pClient->m_tblVConn[index] == NULL )
      {
        break;
      }
    }

    if( index >= BSPROXY_VCONN_CLIENT_MAX )
    {
      BSCLIENT_LOG_ERROR(pClient, BS_ECODE_INTERNAL,
                      "Internal vconn tables corrupted.");
      rc = -BS_ECODE_INTERNAL;
    }
  }

  if( rc == BS_OK )
  {
    pVConn = NEW(BsVConn_T);

    pVConn->m_hndVConn  = BSPROXY_VCONN_UNDEF;
    pVConn->m_bTrace    = bTrace;
    pVConn->m_sDevName  = new_strdup(sDevName);
    pVConn->m_sModName  = new_strdup(sModName);
    pVConn->m_pAppInfo  = pAppInfo;

    // reserve slot
    pClient->m_tblVConn[index] = pVConn;
    
    rc = index;
  }

  bsTransUnlock(pClient);

  return rc;
}

int bsVConnRemove	(	BsClient_T *	pClient,
		BsVConnHnd_T	hndVConn
	)

Remove a vConnection from the client's tblHndIndex table.

Note

The vConnection stills needs to be deleted.

Parameters

pClient

Definition at line 1565 of file bsLibClient.c.

References BS_ECODE_INTERNAL, BSCLIENT_IS_VCONN_HANDLE, BSCLIENT_LOG_ERROR, BSCLIENT_TRY_EXPR, BSPROXY_VCONN_UNDEF, bsTransLock(), bsTransUnlock(), BsVConn_T::m_hndVConn, _bsClientStruct::m_nVConnCount, _bsClientStruct::m_tblHndIndex, and _bsClientStruct::m_tblVConn.

Referenced by bsGetVConn(), bsServerReqCloseDev(), and bsVConnClearAll().

{
  int   index;
  int   rc;

  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_IS_VCONN_HANDLE(hndVConn),
      BS_ECODE_INTERNAL, "VConn=%d: out-of-range.", hndVConn);

  bsTransLock(pClient);

  index = pClient->m_tblHndIndex[hndVConn];

  if( index == BSPROXY_VCONN_UNDEF )
  {
    BSCLIENT_LOG_ERROR(pClient, BS_ECODE_INTERNAL,
      "VConn=%d: vConnection not present in table.", hndVConn);
    rc = -BS_ECODE_INTERNAL;
  }

  else
  {
    pClient->m_tblVConn[index]->m_hndVConn = BSPROXY_VCONN_UNDEF;
    pClient->m_tblHndIndex[hndVConn] = BSPROXY_VCONN_UNDEF;
    pClient->m_nVConnCount--;

    rc = index;
  }

  bsTransUnlock(pClient);

  return rc;
}

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 81 of file bsLibClient.c.

Referenced by bsClientRead(), and bsClientWrite().

{
  FD_SET(fd, pset);
}

static uint_t timer_elapsed ( struct timeval *  pTvMark )

static

Calculate the elapsed time between the given time mark and this call.

Parameters

pTvMark

Pointer to timeval holding time mark.

Returns

Number of microseconds elasped. If the marked time is invalid or the current time cannot be ascertained, UINT_MAX is returned.

Definition at line 358 of file bsLibClient.c.

References timer_mark().

Referenced by bsClientRead(), bsClientWrite(), ClientRead(), and ClientWrite().

{
  struct timeval  tvEnd, tvDelta;

  timer_mark(&tvEnd);

  if( !timerisset(pTvMark) || !timerisset(&tvEnd) )
  {
    return UINT_MAX;
  }

  tvDelta.tv_sec = tvEnd.tv_sec - pTvMark->tv_sec;
  if( tvEnd.tv_usec < pTvMark->tv_usec )
  {
    tvDelta.tv_sec--;
    tvEnd.tv_usec += 1000000;
  }
  tvDelta.tv_usec = tvEnd.tv_usec - pTvMark->tv_usec;

  return (uint_t)(tvDelta.tv_sec * 1000000 + tvDelta.tv_usec);
}

static void timer_mark ( struct timeval *  pTvMark )

inlinestatic

Mark the current time. Resolution is microseconds.

Parameters

pTvMark

Pointer to timeval structure to be populated with the current system time in seconds and useconds.

Definition at line 340 of file bsLibClient.c.

Referenced by bsClientRead(), bsClientWrite(), ClientRead(), ClientWrite(), and timer_elapsed().

{
  if( gettimeofday(pTvMark, NULL) != OK )
  {
    LOGSYSERROR("gettimeofday()");
    timerclear(pTvMark);
  }
}