libBotSense.h File Reference

BotSense client library declarations. More...

#include "errno.h"
#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "botsense/BotSense.h"

Go to the source code of this file.

Classes
struct	BsClientAppInfo_T
	BotSense client library information and callbacks to application-specific data. More...
struct	BsClientConnState_T
struct	BsVecHandles_T
struct	BsVConnInfo_T

Macros
#define	BSCLIENT_INFO_STR_MAX_SIZE   256
#define	BSCLIENT_LOG_WARN(pClient, ecode, wfmt, ...)
	Log Warning. More...
#define	BSCLIENT_LOG_ERROR(pClient, ecode, efmt, ...)
	Log Error. More...
#define	BSCLIENT_LOG_NM_ERROR(pClient, nmecode, efmt, ...)
	Log NetMsgs Error. More...
#define	BSCLIENT_LOG_SYSERROR(pClient, ecode, efmt, ...)
	Log System Error. More...
#define	BSCLIENT_TRY_ECODE(pClient, ecode, efmt, ...)
	Check if BotSense return value is not an error ( < 0). More...
#define	BSCLIENT_TRY_NM_ECODE(pClient, nmecode, efmt, ...)
	Check if NetMsgs (un)packing return value is not an error ( < 0). More...
#define	BSCLIENT_TRY_EXPR(pClient, expr, ecode, efmt, ...)
	Check if expression evaluates to true. More...
#define	BSCLIENT_IS_VCONN_HANDLE(hnd)
	Test if the handle is in the valid client virtual connection range. More...
#define	BSCLIENT_HAS_VCONN(pClient, hnd)   (BSCLIENT_IS_VCONN_HANDLE(hnd) && bsClientAttrHasVConn(pClient, hnd))
	Tests if the handle is valid and there is an established virtual connection. More...

Typedefs
typedef struct _bsClientStruct *	BsClient_P
	Pointer to client structure forward declaration.

Functions
const char *	bsStrError (int nECode)
	Get the error string describing the BotSense error code. More...
int	bsPackMsgHdr (BsProxyMsgHdr_T *pMsgHdr, byte_t buf[], size_t bufSize)
	Pack BotSense bsProxy message header. More...
int	bsUnpackMsgHdr (byte_t buf[], size_t bufSize, BsProxyMsgHdr_T *pMsgHdr)
	Unpack BotSense bsProxy message header. More...
void	bsLogBuf (const char *sBufName, byte_t buf[], size_t uCount)
	Log data bytes. More...
void	bsLogAsciiBuf (const char *sBufName, byte_t buf[], size_t uCount)
	Log ascii data bytes. More...
BsClient_P	bsClientNew (const char *sClientName)
	Create a new unconnected proxied client. More...
void	bsClientDelete (BsClient_P pClient)
	Delete a proxied client. 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...
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, BsVConnHnd_T 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	bsServerConnect (BsClient_P pClient, const char *sServerHostName, int ipPortServer)
	Connect to the bsProxy server. More...
int	bsServerDisconnect (BsClient_P pClient)
	Disconnect from the bsProxy server. More...
int	bsServerReqGetVersion (BsClient_P pClient, char buf[], size_t sizeBuf)
	Request server to return the server's version string. More...
int	bsServerReqLoopback (BsClient_P pClient, char sLoopbackMsg[])
	Request server to loopback the requested message data. More...
int	bsServerReqSetLogging (BsClient_P pClient, int nLogLevel)
	Request server to set the server's logging level. More...
int	bsServerReqMsgTrace (BsClient_P pClient, BsVConnHnd_T hndVConn, bool_t bTrace)
	Request server to enable/disable message tracing on a virtual connection. More...
int	bsServerReqOpenDev (BsClient_P pClient, const char *sDevName, const char *sModName, byte_t argbuf[], size_t arglen, const BsClientAppInfo_T *pAppInfo, bool_t bTrace)
	Request server to establish a virtual connection to the device end point. More...
int	bsServerReqCloseDev (BsClient_P pClient, BsVConnHnd_T hndVConn)
	Request server to close a client's vitual connection. More...
int	bsServerReqGetVConnList (BsClient_P pClient, BsVecHandles_T *pVecHandles)
	Request server to retrieve the server's list of virtual connection handles for this client. More...
int	bsServerReqGetVConnInfo (BsClient_P pClient, BsVConnHnd_T hndVConn, BsVConnInfo_T *pVConnInfo)
	Request server to retrieve the server's information for a given virtual connection. More...

Detailed Description

BotSense client library declarations.

LastChangedDate

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

Rev

2544

Note

This file must be swig-able to generate a python extension module.

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 libBotSense.h.

Macro Definition Documentation

#define BSCLIENT_HAS_VCONN	(		pClient,
			hnd
	)		(BSCLIENT_IS_VCONN_HANDLE(hnd) && bsClientAttrHasVConn(pClient, hnd))

Tests if the handle is valid and there is an established virtual connection.

Parameters

pClient

Definition at line 285 of file libBotSense.h.

Referenced by bsI2CReqRead(), bsI2CReqScan(), bsI2CReqTrans(), bsI2CReqWrite(), bsNullReqWrite(), bsSerialReqRead(), bsSerialReqTrans(), bsSerialReqWrite(), bsServerReqCloseDev(), and bsServerReqGetVConnInfo().

#define BSCLIENT_INFO_STR_MAX_SIZE   256

Maximum size (including null) of a virtual connection information string.

Definition at line 132 of file libBotSense.h.

#define BSCLIENT_IS_VCONN_HANDLE

(

hnd

)

Value:

(((int)(hnd) >= BSPROXY_VCONN_MOD_MIN) && \
   ((int)(hnd) <= BSPROXY_VCONN_MOD_MAX))

Test if the handle is in the valid client virtual connection range.

Parameters

hnd	Virtual connection handle.

Definition at line 274 of file libBotSense.h.

Referenced by bsClientAttrHasVConn(), bsGetVConn(), bsVConnAdd(), and bsVConnRemove().

#define BSCLIENT_LOG_ERROR	(		pClient,
			ecode,
			efmt,
			...
	)

Value:

LOGERROR("%s: %s(): %s(ecode=%d): " efmt, \
      bsClientAttrGetName(pClient), LOGFUNCNAME, \
      bsStrError(ecode), (ecode>=0? ecode: -ecode), \
      ##__VA_ARGS__)

Log Error.

Parameters

pClient

Definition at line 170 of file libBotSense.h.

Referenced by bsClientRecvRsp(), bsClientTrans(), bsResync(), bsServerReqOpenDev(), bsTransLoadCached(), bsVConnAdd(), bsVConnDelete(), bsVConnNew(), bsVConnRemove(), LtThreadI2C(), LtThreadNull(), and LtThreadSerial().

#define BSCLIENT_LOG_NM_ERROR	(		pClient,
			nmecode,
			efmt,
			...
	)

Value:

BSCLIENT_LOG_ERROR(pClient, BS_ECODE_BAD_MSG, "%s(nmecode=%d): " efmt, \
        nmStrError(nmecode), (nmecode>=0? nmecode: -nmecode), ##__VA_ARGS__)

Log NetMsgs Error.

Parameters

pClient

Definition at line 184 of file libBotSense.h.

Referenced by bsServerReqOpenDev().

#define BSCLIENT_LOG_SYSERROR	(		pClient,
			ecode,
			efmt,
			...
	)

Value:

LOGERROR("%s: %s(): %s(ecode=%d): %s(errno=%d)" efmt, \
          bsClientAttrGetName(pClient), LOGFUNCNAME, \
          bsStrError(ecode), ((ecode)>=0? (ecode): -(ecode)), \
          strerror(errno), errno, ##__VA_ARGS__)

Log System Error.

Parameters

pClient

Definition at line 196 of file libBotSense.h.

Referenced by bsClientRead(), bsClientWrite(), bsServerConnect(), bsTransLock(), bsTransUnlock(), ClientStartTestThreadI2C(), ClientStartTestThreadNull(), ClientStartTestThreadSerial(), and ClientStartTestThreadServer().

#define BSCLIENT_LOG_WARN	(		pClient,
			ecode,
			wfmt,
			...
	)

Value:

LOGDIAG3("Warning: %s: %s(): %s(ecode=%d): " wfmt, \
      bsClientAttrGetName(pClient), LOGFUNCNAME, \
      bsStrError(ecode), ((ecode)>=0? (ecode): -(ecode)), \
      ##__VA_ARGS__)

Log Warning.

Parameters

pClient

Definition at line 156 of file libBotSense.h.

Referenced by bsClientDelete().

#define BSCLIENT_TRY_ECODE	(		pClient,
			ecode,
			efmt,
			...
	)

Value:

do \
  { \
    if( (ecode) < 0 ) \
    { \
      BSCLIENT_LOG_ERROR(pClient, ecode, efmt, ##__VA_ARGS__); \
      return (ecode); \
    } \
  } while(0)

Check if BotSense return value is not an error ( < 0).

If the check is false, an appropriate error is logged and the calling function is immediately exited by invoking a return with the < 0 error code.

Parameters

pClient

Definition at line 214 of file libBotSense.h.

Referenced by bsClientRecvRsp(), bsClientSendReq(), bsClientTrans(), bsI2CReqOpen(), bsI2CReqRead(), bsI2CReqScan(), bsI2CReqTrans(), bsI2CReqWrite(), bsNullReqOpen(), bsNullReqWrite(), bsSerialReqOpen(), bsSerialReqRead(), bsSerialReqTrans(), bsSerialReqWrite(), bsServerReqCloseDev(), bsServerReqGetVConnInfo(), bsServerReqGetVConnList(), bsServerReqGetVersion(), bsServerReqLoopback(), bsServerReqMsgTrace(), and bsServerReqSetLogging().

#define BSCLIENT_TRY_EXPR	(		pClient,
			expr,
			ecode,
			efmt,
			...
	)

Value:

do \
  { \
    if( !(expr) ) \
    { \
      BSCLIENT_LOG_ERROR(pClient, ecode, "%s: " efmt, #expr, ##__VA_ARGS__); \
      return (ecode)>0? -(ecode): (ecode); \
    } \
  } while(0)

Check if expression evaluates to true.

If the check is false, an appropriate error is logged and the calling function is immediately exited by invoking a return with the < 0 error code.

Parameters

pClient

Definition at line 259 of file libBotSense.h.

Referenced by bsClientPackMsgHdr(), bsClientRecvRsp(), bsClientSendReq(), bsClientTrans(), bsClientUnpackMsgHdr(), bsI2CReqRead(), bsI2CReqScan(), bsI2CReqTrans(), bsI2CReqWrite(), bsNullReqWrite(), bsSerialReqRead(), bsSerialReqTrans(), bsSerialReqWrite(), bsServerReqCloseDev(), bsServerReqGetVConnInfo(), bsServerReqOpenDev(), bsVConnAdd(), bsVConnDelete(), and bsVConnRemove().

#define BSCLIENT_TRY_NM_ECODE	(		pClient,
			nmecode,
			efmt,
			...
	)

Value:

do \
  { \
    if( (nmecode) < 0 ) \
    { \
      BSCLIENT_LOG_NM_ERROR(pClient, nmecode, efmt, ##__VA_ARGS__); \
      return -BS_ECODE_BAD_MSG; \
    } \
  } while(0)

Check if NetMsgs (un)packing return value is not an error ( < 0).

If the check is false, an appropriate error is logged and the calling function is immediately exited by invoking a return with the < 0 error code.

Parameters

pClient

Definition at line 236 of file libBotSense.h.

Referenced by bsI2CReqRead(), bsI2CReqScan(), bsI2CReqTrans(), bsI2CReqWrite(), bsNullReqWrite(), bsSerialReqOpen(), bsSerialReqRead(), bsSerialReqTrans(), bsSerialReqWrite(), bsServerReqCloseDev(), bsServerReqGetVConnInfo(), bsServerReqGetVConnList(), bsServerReqGetVersion(), bsServerReqLoopback(), bsServerReqMsgTrace(), and bsServerReqSetLogging().

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_P 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;
}

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;
}

void bsLogAsciiBuf	(	const char *	sBufName,
		byte_t	buf[],
		size_t	uCount
	)

Log ascii data bytes.

Print diagnostic logging of the contents of a buffer of ASCII bytes.

Parameters

sBufName	Name of buffer.
buf	Buffer.
uCount	Number of bytes to log.

Definition at line 175 of file bsLibUtils.c.

{
  FILE   *fp;   // log file pointer
  size_t  i;    // working index

  fp = LOG_GET_LOGFP();

  fprintf(fp, "%sDiag%d: %s=", LOG_PREFACE, LOG_GET_THRESHOLD()-1, sBufName);
  for(i=0; i<uCount; ++i)
  {
    if( isprint(buf[i]) || isspace(buf[i]) )
    {
      switch(buf[i])
      {
        case '\f':
          fprintf(fp, "\\f");
          break;
        case '\n':
          fprintf(fp, "\\n");
          break;
        case '\r':
          fprintf(fp, "\\r");
          break;
        case '\t':
          fprintf(fp, "\\t");
          break;
        case '\v':
          fprintf(fp, "\\v");
          break;
        default:
          fprintf(fp, "%c", buf[i]);
          break;
      }
    }
    else
    {
      fprintf(fp, "\\x%02x", buf[i]);
    }
  }
  fprintf(fp, "\n");
}

void bsLogBuf	(	const char *	sBufName,
		byte_t	buf[],
		size_t	uCount
	)

Log data bytes.

Print diagnostic logging of the contents of a buffer of bytes.

Parameters

sBufName	Name of buffer.
buf	Buffer.
uCount	Number of bytes to log.

Definition at line 145 of file bsLibUtils.c.

{
  FILE   *fp;   // log file pointer
  size_t  i;    // working index

  fp = LOG_GET_LOGFP();

  fprintf(fp, "%sDiag%d: %s=", LOG_PREFACE, LOG_GET_THRESHOLD()-1, sBufName);
  for(i=0; i<uCount; ++i)
  {
    if( (i % 16) == 0 )
    {
      fprintf(fp, "\n");
    }
    fprintf(fp, " 0x%02x", buf[i]);
  }
  fprintf(fp, "\n");
}

int bsPackMsgHdr	(	BsProxyMsgHdr_T *	pMsgHdr,
		byte_t	buf[],
		size_t	bufSize
	)

Pack BotSense bsProxy message header.

Parameters

[in]	pMsgHdr	Pointer to message header structure.
[out]	buf	Output message buffer.
	bufSize	Size of output buffer.

Returns

On success, returns the number of bytes packed.

On error, the appropriate < 0 negated BotSense Error Code is returned.

Definition at line 85 of file bsLibUtils.c.

References BS_ECODE_INTERNAL, BSPROXY_MSG_HDR_LEN, BsProxyMsgHdr_T::m_hdrBodyLen, BsProxyMsgHdr_T::m_hdrMagic, BsProxyMsgHdr_T::m_hdrMsgId, BsProxyMsgHdr_T::m_hdrTid, and BsProxyMsgHdr_T::m_hdrVConn.

{
  int   n = 0;

  if( bufSize < BSPROXY_MSG_HDR_LEN )
  {
    LOGERROR("Buffer size=%zu too small.", bufSize);
    return -BS_ECODE_INTERNAL;
  }

  n += nmPackU16(pMsgHdr->m_hdrMagic, buf+n, bufSize-(size_t)n, NMEndianBig);
  n += nmPackU8(pMsgHdr->m_hdrTid, buf+n, bufSize-(size_t)n, NMEndianBig);
  n += nmPackU8(pMsgHdr->m_hdrVConn, buf+n, bufSize-(size_t)n, NMEndianBig);
  n += nmPackU16(pMsgHdr->m_hdrMsgId, buf+n, bufSize-(size_t)n, NMEndianBig);
  n += nmPackU16(pMsgHdr->m_hdrBodyLen, buf+n, bufSize-(size_t)n, NMEndianBig);

  return n;
}

int bsServerConnect	(	BsClient_P	pClient,
		const char *	sServerHostName,
		int	ipServerPort
	)

Connect to the bsProxy server.

Parameters

pClient

Definition at line 167 of file bsLibServer.c.

References BS_ECODE_SERVER_CONN_FAIL, BS_OK, BSCLIENT_LOG_SYSERROR, bsServerDisconnect(), _bsClientStruct::m_pSocket, and _bsClientStruct::m_sClientName.

{
  Socket_T  *pSocket;

  // close socket if already opened
  if( SocketStateIsOpen(pClient->m_pSocket) )
  {
    bsServerDisconnect(pClient);
  }

  // make TCP connection
  pSocket = SocketOpenTcpConnection(sServerHostName, ipServerPort);

  if( pSocket == NULL )
  {
    BSCLIENT_LOG_SYSERROR(pClient, BS_ECODE_SERVER_CONN_FAIL,
        "%s:%d", sServerHostName, ipServerPort);
    return -BS_ECODE_SERVER_CONN_FAIL;
  }

  // set socket for non-block I/O
  SocketAttrSetNonBlocking(pSocket);

  LOGDIAG2("%s: Connected to server at %s.\n",
      pClient->m_sClientName, SocketAttrGetRemoteName(pSocket));

  pClient->m_pSocket = pSocket;

  return BS_OK;
} 

int bsServerDisconnect

(

BsClient_P

pClient

)

Disconnect from the bsProxy server.

Parameters

pClient

Definition at line 207 of file bsLibServer.c.

References BS_OK, bsVConnClearAll(), _bsClientStruct::m_pSocket, and _bsClientStruct::m_sClientName.

Referenced by bsServerConnect().

{
  if( SocketStateIsOpen(pClient->m_pSocket) )
  {
    LOGDIAG2("%s: Disconnected from server at %s.\n",
        pClient->m_sClientName, SocketAttrGetRemoteName(pClient->m_pSocket));
    SocketClose(pClient->m_pSocket);
    SocketDelete(pClient->m_pSocket);
    pClient->m_pSocket = NULL;
    bsVConnClearAll(pClient);
  }

  return BS_OK;
}

int bsServerReqCloseDev	(	BsClient_P	pClient,
		BsVConnHnd_T	hndVConn
	)

Request server to close a client's vitual connection.

Parameters

pClient

Definition at line 597 of file bsLibServer.c.

References BS_ECODE_BAD_VAL, BS_OK, BSCLIENT_HAS_VCONN, BSCLIENT_TRY_ECODE, BSCLIENT_TRY_EXPR, BSCLIENT_TRY_NM_ECODE, BSPROXY_BUF_BODY, BSPROXY_MSG_MAX_LEN, BSPROXY_VCONN_SERVER, BsProxyMsgIdReqDevClose, BsProxyMsgIdRspOk, BsProxyPackReqDevClose(), bsVConnDelete(), bsVConnRemove(), _bsClientStruct::m_sClientName, and BsProxyReqDevClose_T::m_vconn.

{
  static BsProxyMsgId_T msgIdReq = BsProxyMsgIdReqDevClose;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspOk;

  BsProxyReqDevClose_T  msgReq;                   // request message 
  byte_t                buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                bTrace;                   // do [not] trace messages
  int                   n;                        // number of bytes/return code
  int                   index;                    // internal vconn index

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_HAS_VCONN(pClient, hndVConn),
      BS_ECODE_BAD_VAL, "VConn=%d", hndVConn);


  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, BSPROXY_VCONN_SERVER);

  //
  // Set request message values.
  //
  msgReq.m_vconn = (byte_t)hndVConn;

  //
  // Pack request.
  //
  n = BsProxyPackReqDevClose(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  BSPROXY_VCONN_SERVER,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response. No response body.
  //

  //
  // Set return values from response. No response values.
  //

  //
  // Remove and delete client vConnection.
  //
  if( (index = bsVConnRemove(pClient, hndVConn)) >= 0 )
  {
    bsVConnDelete(pClient, index);
  }

  LOGDIAG2("%s: Virtual connecton %u closed.",
            pClient->m_sClientName, (uint_t)hndVConn);

  return BS_OK;
}

int bsServerReqGetVConnInfo	(	BsClient_P	pClient,
		BsVConnHnd_T	hndVConn,
		BsVConnInfo_T *	pVConnInfo
	)

Request server to retrieve the server's information for a given virtual connection.

Parameters

pClient

Definition at line 735 of file bsLibServer.c.

References BS_ECODE_BAD_VAL, BS_OK, BSCLIENT_HAS_VCONN, BSCLIENT_TRY_ECODE, BSCLIENT_TRY_EXPR, BSCLIENT_TRY_NM_ECODE, BSPROXY_BUF_BODY, BSPROXY_MSG_MAX_LEN, BSPROXY_VCONN_SERVER, BsProxyMsgIdReqGetVConnInfo, BsProxyMsgIdRspGetVConnInfo, BsProxyPackReqGetVConnInfo(), BsProxyUnpackRspGetVConnInfo(), BsVConnInfo_T::m_client, BsProxyRspGetVConnInfo_T::m_client, BsVConnInfo_T::m_devuri, BsProxyRspGetVConnInfo_T::m_devuri, BsVConnInfo_T::m_moddate, BsProxyRspGetVConnInfo_T::m_moddate, BsVConnInfo_T::m_moduri, BsProxyRspGetVConnInfo_T::m_moduri, BsVConnInfo_T::m_modver, BsProxyRspGetVConnInfo_T::m_modver, BsVConnInfo_T::m_rd, BsProxyRspGetVConnInfo_T::m_rd, BsVConnInfo_T::m_vconn, BsProxyReqGetVConnInfo_T::m_vconn, and BsProxyRspGetVConnInfo_T::m_vconn.

{
  static BsProxyMsgId_T msgIdReq = BsProxyMsgIdReqGetVConnInfo;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspGetVConnInfo;

  BsProxyReqGetVConnInfo_T  msgReq;                   // request message 
  BsProxyRspGetVConnInfo_T  msgRsp;                   // response message
  byte_t                    buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                    bTrace;                   // do [not] trace messages
  int                       n;                        // num bytes/return code

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, BSCLIENT_HAS_VCONN(pClient, hndVConn),
      BS_ECODE_BAD_VAL, "VConn=%d", hndVConn);


  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, BSPROXY_VCONN_SERVER);

  //
  // Set request message values.
  //
  msgReq.m_vconn = (byte_t)hndVConn;

  //
  // Pack request.
  //
  n = BsProxyPackReqGetVConnInfo(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  BSPROXY_VCONN_SERVER,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response.
  //
  n = BsProxyUnpackRspGetVConnInfo(buf, (size_t)n, &msgRsp, bTrace);

  // check unpack return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdRsp);

  //
  // Set return values from response.
  //
  pVConnInfo->m_vconn = msgRsp.m_vconn;
  pVConnInfo->m_rd = msgRsp.m_rd;
  strcpy_s(pVConnInfo->m_client, sizeof(pVConnInfo->m_client),
      msgRsp.m_client);
  strcpy_s(pVConnInfo->m_devuri, sizeof(pVConnInfo->m_devuri), msgRsp.m_devuri);
  strcpy_s(pVConnInfo->m_moduri, sizeof(pVConnInfo->m_moduri), msgRsp.m_moduri);
  strcpy_s(pVConnInfo->m_modver, sizeof(pVConnInfo->m_modver), msgRsp.m_modver);
  strcpy_s(pVConnInfo->m_moddate, sizeof(pVConnInfo->m_moddate),
      msgRsp.m_moddate);

  return BS_OK;
}

int bsServerReqGetVConnList	(	BsClient_P	pClient,
		BsVecHandles_T *	pVecHandles
	)

Request server to retrieve the server's list of virtual connection handles for this client.

Parameters

pClient

Definition at line 672 of file bsLibServer.c.

References BS_OK, BSCLIENT_TRY_ECODE, BSCLIENT_TRY_NM_ECODE, BSPROXY_MSG_MAX_LEN, BSPROXY_VCONN_CLIENT_MAX, BSPROXY_VCONN_SERVER, BsProxyMsgIdReqGetVConnList, BsProxyMsgIdRspGetVConnList, BsProxyUnpackRspGetVConnList(), BsProxyRspGetVConnList_T::m_count, BsVecHandles_T::m_uCount, BsProxyRspGetVConnList_T::m_vconn, BsVecHandles_T::m_vecHnd, and BsProxyRspGetVConnList_T::u.

{
  static BsProxyMsgId_T msgIdReq = BsProxyMsgIdReqGetVConnList;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspGetVConnList;

  BsProxyRspGetVConnList_T  msgRsp;                   // response message
  byte_t                    buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                    bTrace;                   // do [not] trace messages
  int                       n;                        // num bytes/return code
  int                       i;                        // working index

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, BSPROXY_VCONN_SERVER);

  //
  // Set request message values. No request values.
  //

  //
  // Pack request. No request body.
  //

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  BSPROXY_VCONN_SERVER,
                    msgIdReq, buf, (size_t)0,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response.
  //
  n = BsProxyUnpackRspGetVConnList(buf, (size_t)n, &msgRsp, bTrace);

  // check unpack return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdRsp);

  //
  // Set return values from response.
  //
  for(i=0; (i<msgRsp.m_vconn.m_count) && (i<BSPROXY_VCONN_CLIENT_MAX); ++i)
  {
    pVecHandles->m_vecHnd[i] = (BsVConnHnd_T)msgRsp.m_vconn.u.m_buf[i];
  }
  pVecHandles->m_uCount = msgRsp.m_vconn.m_count;

  return BS_OK;
}

int bsServerReqGetVersion	(	BsClient_P	pClient,
		char	bufVer[],
		size_t	bufSize
	)

Request server to return the server's version string.

Parameters

pClient

Definition at line 354 of file bsLibServer.c.

References BS_OK, BSCLIENT_TRY_ECODE, BSCLIENT_TRY_NM_ECODE, BSPROXY_MSG_MAX_LEN, BSPROXY_VCONN_SERVER, BsProxyMsgIdReqGetVersion, BsProxyMsgIdRspGetVersion, BsProxyUnpackRspGetVersion(), and BsProxyRspGetVersion_T::m_version.

{
  static BsProxyMsgId_T msgIdReq = BsProxyMsgIdReqGetVersion;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspGetVersion;

  BsProxyRspGetVersion_T  msgRsp;                   // response message
  byte_t                  buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                  bTrace;                   // do [not] trace messages
  int                     n;                        // num. of bytes/return code

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, BSPROXY_VCONN_SERVER);

  //
  // Set request message values. No request values.
  //

  //
  // Pack request. No request body.
  //

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  BSPROXY_VCONN_SERVER,
                    msgIdReq, buf, (size_t)0,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response.
  //
  n = BsProxyUnpackRspGetVersion(buf, (size_t)n, &msgRsp, bTrace);

  // check unpack return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdRsp);

  //
  // Set return values from response.
  //
  strcpy_s(bufVer, bufSize, msgRsp.m_version);

  return BS_OK;
}

int bsServerReqLoopback	(	BsClient_P	pClient,
		char	sLoopbackMsg[]
	)

Request server to loopback the requested message data.

Parameters

pClient

Definition at line 230 of file bsLibServer.c.

References BS_OK, BSCLIENT_TRY_ECODE, BSCLIENT_TRY_NM_ECODE, BSPROXY_BUF_BODY, BSPROXY_MSG_MAX_LEN, BSPROXY_VCONN_SERVER, BsProxyMsgIdReqLoopback, BsProxyMsgIdRspLoopback, BsProxyPackReqLoopback(), BsProxyUnpackRspLoopback(), BsProxyReqLoopback_T::m_cdata, and BsProxyRspLoopback_T::m_cdata.

{
  static BsProxyMsgId_T msgIdReq = BsProxyMsgIdReqLoopback;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspLoopback;

  BsProxyReqLoopback_T  msgReq;                   // request message 
  BsProxyRspLoopback_T  msgRsp;                   // response message
  byte_t                buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                bTrace;                   // do [not] trace messages
  int                   n;                        // number of bytes/return code
  size_t                m;                        // loopback cdata length

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, BSPROXY_VCONN_SERVER);

  //
  // Set request message values.
  //
  m = strlen(sLoopbackMsg) + 1;
  if( sizeof(msgReq.m_cdata) < m )
  {
    m = sizeof(msgReq.m_cdata);
  }

  strcpy_s(msgReq.m_cdata, m, sLoopbackMsg);

  //
  // Pack request.
  //
  n = BsProxyPackReqLoopback(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  BSPROXY_VCONN_SERVER,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response.
  //
  n = BsProxyUnpackRspLoopback(buf, (size_t)n, &msgRsp, bTrace);

  // check unpack return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdRsp);

  //
  // Set return values from response.
  //
  strcpy_s(sLoopbackMsg, m, msgRsp.m_cdata);

  return BS_OK;
}

int bsServerReqMsgTrace	(	BsClient_P	pClient,
		BsVConnHnd_T	hndVConn,
		bool_t	bNewTrace
	)

Request server to enable/disable message tracing on a virtual connection.

Parameters

pClient

Definition at line 411 of file bsLibServer.c.

References BS_OK, BSCLIENT_TRY_ECODE, BSCLIENT_TRY_NM_ECODE, BSPROXY_BUF_BODY, BSPROXY_MSG_MAX_LEN, BSPROXY_VCONN_SERVER, BsProxyMsgIdReqMsgTrace, BsProxyMsgIdRspOk, BsProxyPackReqMsgTrace(), BsProxyReqMsgTrace_T::m_trace, and BsProxyReqMsgTrace_T::m_vconn.

{
  static BsProxyMsgId_T msgIdReq = BsProxyMsgIdReqMsgTrace;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspOk;

  BsProxyReqMsgTrace_T  msgReq;                   // request message 
  byte_t                buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                bTrace;                   // do [not] trace messages
  int                   n;                        // number of bytes/return code

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, BSPROXY_VCONN_SERVER);

  //
  // Set request message values.
  //
  msgReq.m_vconn = (byte_t)hndVConn;
  msgReq.m_trace  = bNewTrace;

  //
  // Pack request.
  //
  n = BsProxyPackReqMsgTrace(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  BSPROXY_VCONN_SERVER,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response. No response body.
  //

  //
  // Set return values from response. No response values.
  //

  return BS_OK;
}

int bsServerReqOpenDev	(	BsClient_P	pClient,
		const char *	sDevName,
		const char *	sModName,
		byte_t	argbuf[],
		size_t	arglen,
		const BsClientAppInfo_T *	pAppInfo,
		bool_t	bInitTrace
	)

Request server to establish a virtual connection to the device end point.

The device is open if not already opened by another virtual connection. Otherwise it is attached to this vconn.

The interface module is dynamically loaded into the server and provides the set of services for the client application communicating with the device.

Parameters

pClient

Definition at line 485 of file bsLibServer.c.

References _BS_LOG_VCONN_OPEN, BS_ECODE_BAD_MSG, BS_ECODE_BAD_VAL, BSCLIENT_LOG_ERROR, BSCLIENT_LOG_NM_ERROR, BSCLIENT_TRY_EXPR, BSPROXY_BUF_BODY, BSPROXY_MSG_MAX_LEN, BSPROXY_REQDEVOPEN_ARGBUF_LEN, BSPROXY_REQDEVOPEN_DEVNAME_LEN, BSPROXY_REQDEVOPEN_MODNAME_LEN, BSPROXY_VCONN_SERVER, BsProxyMsgIdReqDevOpen, BsProxyMsgIdRspDevOpen, BsProxyPackReqDevOpen(), BsProxyUnpackRspDevOpen(), bsVConnAdd(), bsVConnDelete(), bsVConnNew(), BsProxyReqDevOpen_T::m_argbuf, BsProxyReqDevOpen_T::m_count, BsProxyReqDevOpen_T::m_devname, BsProxyReqDevOpen_T::m_modname, BsProxyReqDevOpen_T::m_trace, BsProxyRspDevOpen_T::m_vconn, and BsProxyReqDevOpen_T::u.

{
  static BsProxyMsgId_T msgIdReq = BsProxyMsgIdReqDevOpen;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspDevOpen;

  BsProxyReqDevOpen_T   msgReq;                   // request message 
  BsProxyRspDevOpen_T   msgRsp;                   // response message
  byte_t                buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                bTrace;                   // do [not] trace messages
  int                   index;                    // internal vconn index
  int                   n;                        // number of bytes/return code
  int                   rc;                       // return code

  //
  // Parameter checks.
  //
  BSCLIENT_TRY_EXPR(pClient, (strlen(sDevName)<=BSPROXY_REQDEVOPEN_DEVNAME_LEN),
      BS_ECODE_BAD_VAL,
      "%zu > %u", strlen(sDevName), BSPROXY_REQDEVOPEN_DEVNAME_LEN);

  BSCLIENT_TRY_EXPR(pClient, (strlen(sModName)<=BSPROXY_REQDEVOPEN_MODNAME_LEN),
      BS_ECODE_BAD_VAL,
      "%zu > %u", strlen(sModName), BSPROXY_REQDEVOPEN_MODNAME_LEN);

  BSCLIENT_TRY_EXPR(pClient, (arglen<=BSPROXY_REQDEVOPEN_ARGBUF_LEN),
      BS_ECODE_BAD_VAL,
      "%zu > %u", arglen, BSPROXY_REQDEVOPEN_ARGBUF_LEN);

  //
  // Create and reserve new client vConnection.
  //
  if((index=bsVConnNew(pClient, sDevName, sModName, pAppInfo, bInitTrace)) < 0)
  {
    return index;
  }

  // server-ended trace state
  bTrace = bsClientAttrGetTraceState(pClient, BSPROXY_VCONN_SERVER);

  //
  // Set request message values.
  //
  msgReq.m_trace = bInitTrace;
  strcpy(msgReq.m_devname, sDevName);
  strcpy(msgReq.m_modname, sModName);
  memcpy(msgReq.m_argbuf.u.m_buf, argbuf, arglen);
  msgReq.m_argbuf.m_count = arglen;

  //
  // Pack request.
  //
  if( (n = BsProxyPackReqDevOpen(&msgReq, BSPROXY_BUF_BODY(buf), bTrace)) < 0 )
  {
    BSCLIENT_LOG_NM_ERROR(pClient, n, "MsgId=%u", msgIdReq);
    rc = -BS_ECODE_BAD_MSG;
  }

  //
  // Execute request-response transaction.
  //
  else if( (n = bsClientTrans(pClient,  BSPROXY_VCONN_SERVER,
                              msgIdReq, buf, (size_t)n,
                              msgIdRsp, buf, sizeof(buf))) < 0 )
  {
    BSCLIENT_LOG_ERROR(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);
    rc = n;
  }

  //
  // Unpack response.
  //
  else if( (n = BsProxyUnpackRspDevOpen(buf, (size_t)n, &msgRsp, bTrace)) < 0 )
  {
    BSCLIENT_LOG_NM_ERROR(pClient, n, "MsgId=%u", msgIdRsp);
    rc = -BS_ECODE_BAD_MSG;
  }

  //
  // Success
  //
  else
  {
    bsVConnAdd(pClient, msgRsp.m_vconn, index);
    _BS_LOG_VCONN_OPEN(pClient, index);
    rc = (int)msgRsp.m_vconn;
  }

  //
  // Error clean up
  //
  if( rc < 0 )
  {
    bsVConnDelete(pClient, index);
  }

  return rc;
}

int bsServerReqSetLogging	(	BsClient_P	pClient,
		int	nLogLevel
	)

Request server to set the server's logging level.

Parameters

pClient

Definition at line 298 of file bsLibServer.c.

References BS_OK, BSCLIENT_TRY_ECODE, BSCLIENT_TRY_NM_ECODE, BSPROXY_BUF_BODY, BSPROXY_MSG_MAX_LEN, BSPROXY_VCONN_SERVER, BsProxyMsgIdReqSetLogging, BsProxyMsgIdRspOk, BsProxyPackReqSetLogging(), and BsProxyReqSetLogging_T::m_level.

{
  static BsProxyMsgId_T msgIdReq = BsProxyMsgIdReqSetLogging;
  static BsProxyMsgId_T msgIdRsp = BsProxyMsgIdRspOk;

  BsProxyReqSetLogging_T  msgReq;                   // request message 
  byte_t                  buf[BSPROXY_MSG_MAX_LEN]; // req/rsp buffer
  bool_t                  bTrace;                   // do [not] trace messages
  int                     n;                        // num. of bytes/return code

  // trace state
  bTrace = bsClientAttrGetTraceState(pClient, BSPROXY_VCONN_SERVER);

  //
  // Set request message values.
  //
  msgReq.m_level = nLogLevel;

  //
  // Pack request.
  //
  n = BsProxyPackReqSetLogging(&msgReq, BSPROXY_BUF_BODY(buf), bTrace);

  // check packing return code
  BSCLIENT_TRY_NM_ECODE(pClient, n, "MsgId=%u", msgIdReq);

  //
  // Execute request-response transaction.
  //
  n = bsClientTrans(pClient,  BSPROXY_VCONN_SERVER,
                    msgIdReq, buf, (size_t)n,
                    msgIdRsp, buf, sizeof(buf));

  // check transaction return code
  BSCLIENT_TRY_ECODE(pClient, n, "MsgId=%u: Transaction failed.", msgIdReq);

  //
  // Unpack response. No response body.
  //

  //
  // Set return values from response. No response values.
  //

  return BS_OK;
}

const char* bsStrError

(

int

ecode

)

Get the error string describing the BotSense error code.

The absolute value of the error code is taken prior retrieving the string. An unknown or out-of-range error code will be mapped to BS_ECODE_BADEC.

Parameters

ecode

Definition at line 122 of file bsLibError.c.

References BS_ECODE_BADEC, and bsEcodeStrTbl.

{
  if( ecode < 0 )
  {
    ecode = -ecode;
  }

  if( ecode >= arraysize(bsEcodeStrTbl) )
  {
    ecode = BS_ECODE_BADEC;
  }
  return bsEcodeStrTbl[ecode];
}

int bsUnpackMsgHdr	(	byte_t	buf[],
		size_t	bufSize,
		BsProxyMsgHdr_T *	pMsgHdr
	)

Unpack BotSense bsProxy message header.

Parameters

[in]	buf	Input message buffer.
	bufSize	Size of input buffer.
[out]	pMsgHdr	Pointer to message header structure.

Returns

On success, returns the number of bytes unpacked.

On error, the appropriate < 0 negated BotSense Error Code is returned.

Definition at line 115 of file bsLibUtils.c.

References BS_ECODE_INTERNAL, BSPROXY_MSG_HDR_LEN, BsProxyMsgHdr_T::m_hdrBodyLen, BsProxyMsgHdr_T::m_hdrMagic, BsProxyMsgHdr_T::m_hdrMsgId, BsProxyMsgHdr_T::m_hdrTid, and BsProxyMsgHdr_T::m_hdrVConn.

{
  int   n = 0;

  if( bufSize < BSPROXY_MSG_HDR_LEN )
  {
    LOGERROR("Buffer size=%zu too small.", bufSize);
    return -BS_ECODE_INTERNAL;
  }

  n += nmUnpackU16(buf+n, bufSize-(size_t)n, &pMsgHdr->m_hdrMagic, NMEndianBig);
  n += nmUnpackU8(buf+n,  bufSize-(size_t)n, &pMsgHdr->m_hdrTid, NMEndianBig);
  n += nmUnpackU8(buf+n,  bufSize-(size_t)n, &pMsgHdr->m_hdrVConn, NMEndianBig);
  n += nmUnpackU16(buf+n, bufSize-(size_t)n, &pMsgHdr->m_hdrMsgId, NMEndianBig);
  n += nmUnpackU16(buf+n, bufSize-(size_t)n, &pMsgHdr->m_hdrBodyLen,
                                                                  NMEndianBig);

  return n;
}