bsProxy.h File Reference

BotSense bsProxy IP server declarations. More...

#include <sys/time.h>
#include <sys/select.h>
#include <stdarg.h>
#include <pthread.h>
#include <errno.h>
#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "rnr/dlistvoid.h"
#include "rnr/dliststr.h"
#include "rnr/sock.h"
#include "rnr/sockset.h"
#include "rnr/netmsgs.h"
#include "botsense/BotSense.h"
#include "botsense/libBotSense.h"
#include "botsense/bsProxyModIF.h"
#include "botsense/bsProxyMsgs.h"

Go to the source code of this file.

Classes
struct	BsProxyModIF_T
struct	_bsproxy_th_ctl
struct	BsProxyClientCtl_T
struct	BsProxyServerCtl_T
struct	BsProxyVConn_T
struct	_bsproxy_th_req
struct	BsProxyListenIF_T

Macros
#define	BSPROXY_TUNE_T_RECV   1000000
	1.0s receive time out
#define	BSPROXY_TUNE_T_SEND   500000
	0.5s send time out
#define	BSPROXY_TUNE_T_SELECT   5000000
	5.0s send select time out
#define	BSPROXY_FD_SETSIZE   256
	server socket set size
#define	BSPROXY_LOG_WARN(hndClient, ecode, wfmt, ...)
	Log Proxy Server Warning. More...
#define	BSPROXY_LOG_ERROR(hndClient, ecode, efmt, ...)
	Log Proxy Server Error. More...
#define	BSPROXY_LOG_NMERROR(hndClient, nmecode, efmt, ...)
	Log Proxy Server NetMsgs (Un)Packing Error. More...
#define	BSPROXY_LOG_SYSERROR(hndClient, efmt, ...)
	Log Proxy Server System Error. More...
#define	BSPROXY_SEND_ERROR_RSP(hndClient, hndVConn, uTid, ecode, efmt, ...)
	Log BotSense Error and Send Error Response. More...
#define	BSPROXY_SEND_NMERROR_RSP(hndClient, hndVConn, uTid, nmecode, efmt, ...)
	Log NetMsgs (Un)Packing Error and Send Error Response. More...
#define	BSPROXY_SEND_SYSERROR_RSP(hndClient, hndVConn, uTid, efmt, ...)
	Log System Error and Send Error Response. More...
#define	BSPROXY_LOG_REQ(hndClient, pMsgHdr)
	Log client request. More...
#define	BSPROXY_LOG_RSP(hndClient, pMsgHdr)
	Log client request. More...
#define	BSPROXY_CHK_VCONN_HND(hndVConn)
#define	BSPROXY_CHK_MOD_VCONN_HND(hndVConn)

Typedefs
typedef struct _bsproxy_th_ctl *	BsProxyThCtl_P
	service thread control
typedef struct _bsproxy_th_req *	BsProxyThReq_P
	service thread request
typedef int	BsProxyClientHnd_T
	bsProxy server client handle
typedef struct _bsproxy_th_ctl	BsProxyThCtl_T
typedef struct _bsproxy_th_req	BsProxyThReq_T

Enumerations
enum	BsProxyThState_T {   BsProxyThStateUninit,   BsProxyThStateInit,   BsProxyThStateRunning,   BsProxyThStateExit }
	Service thread states. More...
enum	BsProxyClientState_T {   BsProxyClientStateInit,   BsProxyClientStateNominal,   BsProxyClientStateReSync,   BsProxyClientStateZombie }

Functions
static void	timer_mark (struct timeval *pTvMark)
	Mark the current time. Resolution is microseconds. More...
uint_t	timer_elapsed (struct timeval *pTvMark)
	Calculate the elapsed time between the given time mark and this call. More...
INLINE_IN_H BsProxyServerCtl_T *	ServerGet ()
	Get the BotSense server. More...
INLINE_IN_H const char *	ServerHasName ()
	Get the BotSense server's official name. More...
INLINE_IN_H const char *	ServerHasAddr ()
	Get the BotSense server's listening address. More...
INLINE_IN_H int	ServerHasPort ()
	Get the BotSense server's listening port. More...
INLINE_IN_H int	ServerClientHnd2Sd (BsProxyClientHnd_T hndClient)
	Convert the BotSense server client handle to client socket descriptor. More...
INLINE_IN_H BsProxyClientHnd_T	ServerClientSd2Hnd (int sd)
	Convert the BotSense server client socket descriptor to client handle. More...
INLINE_IN_H BsProxyClientCtl_T *	ServerGetClient (BsProxyClientHnd_T hndClient)
	Get the BotSense server client. More...
INLINE_IN_H const char *	ClientThisHasName (BsProxyClientCtl_T *pClient)
	Get this BotSense client official name. More...
INLINE_IN_H const char *	ClientHasName (BsProxyClientHnd_T hndClient)
	Get the BotSense client official name. More...
INLINE_IN_H bool_t	ClientGetTraceState (BsProxyClientHnd_T hndClient)
	Get the BotSense client's server-terminated message trace state. More...
INLINE_IN_H void	ClientSetTraceState (BsProxyClientHnd_T hndClient, bool_t bTrace)
	Set the BotSense client's server-terminated message trace state. More...
void	BsProxyLogMsgHdr (const char *sPreface, BsProxyMsgHdr_T *pMsgHdr)
	Log message header. More...
void	ClientOneTimeInit ()
	The BotSense bsProxy server one-time client control initialization.
BsProxyClientCtl_T *	ClientAcquire (BsProxyClientHnd_T hndClient)
	Acquire client, locking it from other threads. More...
void	ClientRelease (BsProxyClientHnd_T hndClient)
	Release the locked client. More...
BsProxyClientCtl_T *	ClientNew (Socket_T *pSockClient)
	Create new client control structure. More...
void	ClientDelete (BsProxyClientCtl_T *pClient)
	Delete a client with the server. More...
void	ClientSetState (BsProxyClientCtl_T *pClient, BsProxyClientState_T eNewState)
	Set client's state. More...
int	ClientRecvReq (BsProxyClientHnd_T hndClient, BsProxyMsgHdr_T *pMsgHdr, byte_t **addrBuf)
	Receive a request message from client. More...
int	ClientSendOkRsp (BsProxyClientHnd_T hndClient, BsTid_T uTid)
	Send an ok response to the client. More...
int	ClientSendErrorRsp (BsProxyClientHnd_T hndClient, BsTid_T uTid, int nECode, const char *sErrFmt,...)
	Send an error response to the client. More...
int	ClientSendVErrorRsp (BsProxyClientHnd_T hndClient, BsTid_T uTid, int nECode, const char *sErrFmt, va_list ap)
	Send va_list error response to the client. More...
int	ClientSendServerRsp (BsProxyClientHnd_T hndClient, BsTid_T uTid, BsProxyMsgId_T uMsgId, void *pMsgRsp)
	Send a server-terminated response message to client. More...
int	ClientSendRsp (BsProxyClientHnd_T hndClient, BsVConnHnd_T hndVConn, BsTid_T uTid, BsMsgId_T uMsgId, byte_t bufRsp[], size_t uRspSize)
	Send module-specific response to the client. More...
void	VConnOneTimeInit ()
	The bsProxy virtual connections one-time initialization.
BsProxyVConn_T *	VConnNew ()
	Create a new, allocated virtual connection entry. More...
void	VConnDelete (BsProxyVConn_T *pVConn)
	Delete allocated virtual connection entry. More...
BsProxyVConn_T *	VConnGet (BsVConnHnd_T hndVConn)
	Get the virtual connection entry associated with the handle. More...
int	VConnOpenServer ()
	Open special server virtual connection. More...
int	VConnOpenDev (BsProxyClientHnd_T hndClient, const char *sDevName, const char *sModName, byte_t argbuf[], size_t uArgLen, bool_t bTrace)
	Open a virtual device connection. More...
int	VConnClose (BsProxyClientHnd_T hndClient, BsVConnHnd_T hndVConn)
	Close the virtual connection. More...
BsProxyVConn_T *	VConnAcquire (BsVConnHnd_T hndVConn)
	Acquire virtual connection, locking it from other threads. More...
void	VConnRelease (BsVConnHnd_T hndVConn)
	Release the locked virtual client. More...
void	ModOneTimeInit (DListStr_T *pDListLibPath)
	The bsProxy interface module handling one-time initialization. More...
char *	ModNewModUri (const char *sModName)
	Convert the module name to a quasi Uniform Resource Id. More...
BsProxyModIF_T *	ModGetLoadedIF (const char *sModUri)
	Get the defined interface from a previously loaded i/f module. More...
BsProxyModIF_T *	ModLoad (const char *sModUri)
	Load the interface module. More...
void	ModUnload (BsProxyModIF_T *pModIF)
	Unload the interface module. More...
BsProxyThReq_T *	ThReqNew (BsProxyClientHnd_T hndClient, BsVConnHnd_T hndVConn, BsTid_T uTid, BsMsgId_T uMsgId, byte_t bufReq[], size_t uReqLen)
	Allocate and initalized a new service thread request. More...
void	ThReqDelete (BsProxyThReq_T *pThReq)
	Delete service thread request. More...
int	ThQueue (BsProxyThCtl_T *pThCtl, BsProxyClientHnd_T hndClient, BsVConnHnd_T hndVConn, BsTid_T uTid, BsMsgId_T uMsgId, byte_t bufReq[], size_t uReqLen)
	Queue a request for the given service thread. More...
BsProxyThReq_T *	ThDequeue (BsProxyThCtl_T *pThCtl)
	Dequeue a request for the given service thread. More...
void	ThOneTimeInit ()
	The service thread one-time global initialization.
char *	ThNewDevUri (const char *sDevName)
	Convert the device name to a quasi Uniform Resource Id. More...
BsProxyThCtl_T *	ThCreateDevThread (const char *sDevUri)
	Create a device service thread. More...
BsProxyThCtl_T *	ThCreateServerThread ()
	Create the special server service thread. More...
void	ThDestroyThread (BsProxyThCtl_T *pThCtl)
	Destroy service thread. More...
int	ServerRequest (BsProxyClientHnd_T hndClient, BsVConnHnd_T hndVConn, BsTid_T uTid, BsMsgId_T uMsgId, byte_t bufReq[], size_t uReqLen)
	Server service thread request handler. More...

Variables
BsProxyServerCtl_T *	BsServerCtl
	The server control block. More...

Detailed Description

BotSense bsProxy IP server declarations.

LastChangedDate

2010-08-23 09:53:11 -0600 (Mon, 23 Aug 2010)

Rev

570

Todo:

Add support for botsense configuration XML files.

Add fork-exec'ing to support multiple interfaces.

Author

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

Copyright

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

Definition in file bsProxy.h.

Macro Definition Documentation

#define BSPROXY_CHK_MOD_VCONN_HND

(

hndVConn

)

Value:

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

Check if handle is in virtual connection device module range.

See also

bsProxyMsg.h

Parameters

hndVConn

Virtual connection handle.

Returns

true or false

Definition at line 441 of file bsProxy.h.

Referenced by VConnClose().

#define BSPROXY_CHK_VCONN_HND

(

hndVConn

)

Value:

(((int)(hndVConn) >= BSPROXY_VCONN_MIN) && \
   ((int)(hndVConn) <= BSPROXY_VCONN_MAX))

Check if handle is in virtual connection range.

The special server handle is included.

See also

bsProxyMsg.h

Parameters

hndVConn

Virtual connection handle.

Returns

true or false

Definition at line 428 of file bsProxy.h.

Referenced by BsProxyDispatch(), VConnAcquire(), VConnDelete(), VConnGet(), and VConnRelease().

#define BSPROXY_LOG_ERROR	(		hndClient,
			ecode,
			efmt,
			...
	)

Value:

LOGERROR("%s: %s: %s(ecode=%d): " efmt, \
      ServerHasName(), ClientHasName(hndClient), \
      bsStrError(ecode), (ecode>=0? ecode: -ecode), \
      ##__VA_ARGS__)

Log Proxy Server Error.

Parameters

hndClient	Client handle.
ecode

Definition at line 288 of file bsProxy.h.

Referenced by ClientRecvBody(), ClientRecvHdr(), ClientSendRsp(), ClientSendServerRsp(), ThDevRequest(), VConnClose(), and VConnOpenDev().

#define BSPROXY_LOG_NMERROR	(		hndClient,
			nmecode,
			efmt,
			...
	)

Value:

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

Log Proxy Server NetMsgs (Un)Packing Error.

Parameters

hndClient	Client handle.
nmecode	NetMsgs error code.
efmt	Error output format string literal.
...	Error variable arguments.

Definition at line 302 of file bsProxy.h.

Referenced by ClientSendServerRsp().

#define BSPROXY_LOG_REQ	(		hndClient,
			pMsgHdr
	)

Value:

do \
  { \
    if( LOGABLE(LOG_LEVEL_DIAG2) ) \
    { \
      LOGDIAG2("%s: %s:", ServerHasName(), ClientHasName(hndClient)); \
      BsProxyLogMsgHdr("Rx Req", pMsgHdr); \
    } \
  } while(0)

Log client request.

Parameters

hndClient	Client handle.
pMsgHdr	Request message header.

Definition at line 384 of file bsProxy.h.

Referenced by ClientRecvReq().

#define BSPROXY_LOG_RSP	(		hndClient,
			pMsgHdr
	)

Value:

do \
  { \
    if( LOGABLE(LOG_LEVEL_DIAG2) ) \
    { \
      LOGDIAG2("%s: %s:", ServerHasName(), ClientHasName(hndClient)); \
      BsProxyLogMsgHdr("Tx Rsp", pMsgHdr); \
    } \
  } while(0)

Log client request.

Parameters

hndClient	Client handle.
pMsgHdr	Request message header.

Definition at line 404 of file bsProxy.h.

Referenced by ClientSendRsp().

#define BSPROXY_LOG_SYSERROR	(		hndClient,
			efmt,
			...
	)

Value:

LOGERROR("%s: %s: %s(ecode=%d): %s(errno=%d)" efmt, \
          ServerHasName(), ClientHasName(hndClient), \
          bsStrError(BS_ECODE_SYS), BS_ECODE_SYS, \
          strerror(errno), errno, ##__VA_ARGS__)

Log Proxy Server System Error.

Parameters

hndClient	Client handle.
efmt	Error output format string litteral.
...	Error variable arguments.

Definition at line 314 of file bsProxy.h.

Referenced by ClientRead(), ClientSendRsp(), and ClientWrite().

#define BSPROXY_LOG_WARN	(		hndClient,
			ecode,
			wfmt,
			...
	)

Value:

LOGDIAG2("Warning: %s: %s: %s(ecode=%d): " wfmt, \
      ServerHasName(), ClientHasName(hndClient), \
      bsStrError(ecode), ((ecode)>=0? (ecode): -(ecode)), \
      ##__VA_ARGS__)

Log Proxy Server Warning.

Parameters

hndClient	Client handle.
ecode

Definition at line 274 of file bsProxy.h.

#define BSPROXY_SEND_ERROR_RSP	(		hndClient,
			hndVConn,
			uTid,
			ecode,
			efmt,
			...
	)

Value:

do \
  { \
    BSPROXY_LOG_ERROR(hndClient, ecode, "req_vconn=%u: " efmt, \
        hndVConn, ##__VA_ARGS__); \
    ClientSendErrorRsp(hndClient, uTid, ecode, efmt, ##__VA_ARGS__); \
  } while(0)

Log BotSense Error and Send Error Response.

Parameters

hndClient	Client handle.
hndVConn	Requestor's virtual connection handle.
uTid	Request-Response transaction id.
ecode

Definition at line 330 of file bsProxy.h.

Referenced by BsProxyDispatch(), ReqDevClose(), ReqDevOpen(), ReqMsgTrace(), ServerRequest(), and ThDevRequest().

#define BSPROXY_SEND_NMERROR_RSP	(		hndClient,
			hndVConn,
			uTid,
			nmecode,
			efmt,
			...
	)

Value:

do \
  { \
    BSPROXY_LOG_NMERROR(hndClient, nmecode, "req_vconn=%u: " efmt, \
        hndVConn, ##__VA_ARGS__); \
    ClientSendErrorRsp(hndClient, uTid, BS_ECODE_BAD_MSG, efmt, \
                          ##__VA_ARGS__); \
  } while(0)

Log NetMsgs (Un)Packing Error and Send Error Response.

Parameters

hndClient	Client handle.
hndVConn	Requestor's virtual connection handle.
uTid	Request-Response transaction id.
nmecode	NetMsgs error code.
efmt	Error output format string literal.
...	Error variable arguments.

Definition at line 348 of file bsProxy.h.

Referenced by ReqDevClose(), ReqDevOpen(), ReqGetVConnInfo(), ReqLoopback(), ReqMsgTrace(), and ReqSetLogging().

#define BSPROXY_SEND_SYSERROR_RSP	(		hndClient,
			hndVConn,
			uTid,
			efmt,
			...
	)

Value:

do \
  { \
    BSPROXY_LOG_SYSERROR(hndClient, "req_vconn=%u: " efmt, \
        hndVConn, ##__VA_ARGS__); \
    ClientSendErrorRsp(hndClient, uTid, BS_ECODE_SYS, \
        "%s(errno=%d): vconn=%u:" efmt, \
        strerror(errno), errno, hndVConn, ##__VA_ARGS__); \
  } while(0)

Log System Error and Send Error Response.

Parameters

hndClient	Client handle.
hndVConn	Requestor's virtual connection handle.
uTid	Request-Response transaction id.
efmt	Error output format string literal.
...	Error variable arguments.

Definition at line 366 of file bsProxy.h.

Typedef Documentation

typedef struct _bsproxy_th_ctl BsProxyThCtl_T

BotSense Service Thread Control Block Structure Type

typedef struct _bsproxy_th_req BsProxyThReq_T

BotSense Service Thread Request Structure Type

Enumeration Type Documentation

enum BsProxyClientState_T

BotSense Proxy Client States

Enumerator
BsProxyClientStateInit	initialization state
BsProxyClientStateNominal	normal operation
BsProxyClientStateReSync	resyncing server with client
BsProxyClientStateZombie	disconnected or fatal, not deleted

Definition at line 181 of file bsProxy.h.

{
  BsProxyClientStateInit,     ///< initialization state
  BsProxyClientStateNominal,  ///< normal operation
  BsProxyClientStateReSync,   ///< resyncing server with client
  BsProxyClientStateZombie,   ///< disconnected or fatal, not deleted
} BsProxyClientState_T;

enum BsProxyThState_T

Service thread states.

Enumerator
BsProxyThStateUninit	thread is not fully initialized
BsProxyThStateInit	thread is initialized
BsProxyThStateRunning	thread is running (nominal state)
BsProxyThStateExit	thread is exiting

Definition at line 137 of file bsProxy.h.

{
  BsProxyThStateUninit,      ///< thread is not fully initialized
  BsProxyThStateInit,        ///< thread is initialized
  BsProxyThStateRunning,     ///< thread is running (nominal state)
  BsProxyThStateExit         ///< thread is exiting
} BsProxyThState_T;

Function Documentation

void BsProxyLogMsgHdr	(	const char *	sPreface,
		BsProxyMsgHdr_T *	pMsgHdr
	)

Log message header.

Parameters

sPreface	Preface string.
pMsgHdr	Pointer to message header structure.

Definition at line 108 of file bsProxyUtils.c.

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

Referenced by ClientSetTraceState().

{
  FILE             *fp;
  const NMMsgDef_T *pMsgDef;
  const char       *sMsgName;

  fp = LOG_GET_LOGFP();

  if( pMsgHdr != NULL )
  {
    if( pMsgHdr->m_hdrVConn == BSPROXY_VCONN_SERVER )
    {
      pMsgDef = BsProxyLookupMsgDef((BsProxyMsgId_T)pMsgHdr->m_hdrMsgId);
      sMsgName = pMsgDef!=NULL? pMsgDef->m_sMsgName: "";
    }
    else
    {
      sMsgName = "";
    }
    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);
  }
}

BsProxyClientCtl_T* ClientAcquire

(

BsProxyClientHnd_T

hndClient

)

Acquire client, locking it from other threads.

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

Parameters

hndClient

Client handle.

Returns

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

Definition at line 546 of file bsProxyClient.c.

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

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

{
  BsProxyClientCtl_T *pClient;

  ClientLockBusy();

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

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

  ClientUnlockBusy();

  return pClient;
}

void ClientDelete

(

BsProxyClientCtl_T *

pClient

)

Delete a client with the server.

Parameters

pClient

Definition at line 621 of file bsProxyClient.c.

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

Referenced by BsProxyClientUnregister(), and ClientSetTraceState().

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

INLINE_IN_H bool_t ClientGetTraceState

(

BsProxyClientHnd_T

hndClient

)

Get the BotSense client's server-terminated message trace state.

Warning

The client is not locked. Use in a safe context.

Parameters

hndClient

Definition at line 602 of file bsProxy.h.

References BsProxyClientCtl_T::m_bServerTrace, and ServerGetClient().

Referenced by ClientSendServerRsp(), and ServerRequest().

{
  BsProxyClientCtl_T *pClient = ServerGetClient(hndClient);
  
  return pClient != NULL? pClient->m_bServerTrace: false;
}

INLINE_IN_H const char* ClientHasName

(

BsProxyClientHnd_T

hndClient

)

Get the BotSense client official name.

Warning

The client is not locked. Use in a safe context.

Parameters

hndClient

Definition at line 588 of file bsProxy.h.

References ClientThisHasName(), and ServerGetClient().

Referenced by BsProxyServer(), ReqGetVConnInfo(), ReqLoopback(), VConnClose(), and VConnOpenDev().

{
  return ClientThisHasName(ServerGetClient(hndClient));
}

BsProxyClientCtl_T* ClientNew

(

Socket_T *

pSockClient

)

Create new client control structure.

Parameters

pSockClient

Accecpted client socket.

Returns

Returns a newly allocated and intialized client control block.

Definition at line 602 of file bsProxyClient.c.

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

Referenced by BsProxyClientRegister(), and ClientSetTraceState().

{
  BsProxyClientCtl_T  *pClient;

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

  return pClient;
}

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

Receive a request message from client.

Parameters

hndClient

Definition at line 836 of file bsProxyClient.c.

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

Referenced by BsProxyServer(), and ClientSetTraceState().

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

  *addrBuf  = NULL;

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

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

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

    BSPROXY_LOG_REQ(hndClient, pMsgHdr);

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

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

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

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

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

  // set allocated buffer
  *addrBuf = pBuf;

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

  // unlock client
  ClientRelease(hndClient);

  return nMsgLen;
}

void ClientRelease

(

BsProxyClientHnd_T

hndClient

)

Release the locked client.

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

Parameters

hndClient

Client handle.

Definition at line 574 of file bsProxyClient.c.

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

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

{
  BsProxyClientCtl_T *pClient;

  ClientLockBusy();

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

  ClientBroadcastNotBusy();

  ClientUnlockBusy();
}

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

Send an error response to the client.

Parameters

hndClient

Definition at line 960 of file bsProxyClient.c.

References ClientSendVErrorRsp().

Referenced by ClientSetTraceState().

{
  va_list ap;
  int     rc;

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

int ClientSendOkRsp	(	BsProxyClientHnd_T	hndClient,
		BsTid_T	uTid
	)

Send an ok response to the client.

Parameters

hndClient

Definition at line 936 of file bsProxyClient.c.

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

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

{
  byte_t bufRsp[BSPROXY_MSG_HDR_LEN];

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

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

Send module-specific response to the client.

Parameters

hndClient

Definition at line 1084 of file bsProxyClient.c.

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

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

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

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

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

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

  nBytes = (size_t)n + uRspSize;

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

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

  ClientRelease(hndClient);

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

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

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

Send a server-terminated response message to client.

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

Parameters

hndClient

Definition at line 1025 of file bsProxyClient.c.

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

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

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

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

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

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

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

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

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

Send va_list error response to the client.

Parameters

hndClient

Definition at line 986 of file bsProxyClient.c.

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

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

{
  BsProxyRspErr_T  msgRsp;

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

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

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

  return -nECode;
}

void ClientSetState	(	BsProxyClientCtl_T *	pClient,
		BsProxyClientState_T	eNewState
	)

Set client's state.

Parameters

pClient

< disconnected but not deleted

< normal operation

< resyncing server with client

Definition at line 643 of file bsProxyClient.c.

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

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

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

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

  if( pClient == NULL )
  {
    return;
  }

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

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

  pClient->m_eClientState = eNewState;

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

INLINE_IN_H void ClientSetTraceState	(	BsProxyClientHnd_T	hndClient,
		bool_t	bTrace
	)

Set the BotSense client's server-terminated message trace state.

Warning

The client is not locked. Use in a safe context.

Parameters

hndClient

Definition at line 617 of file bsProxy.h.

References BsProxyLogMsgHdr(), ClientAcquire(), ClientDelete(), ClientNew(), ClientOneTimeInit(), ClientRecvReq(), ClientRelease(), ClientSendErrorRsp(), ClientSendOkRsp(), ClientSendRsp(), ClientSendServerRsp(), ClientSendVErrorRsp(), ClientSetState(), BsProxyClientCtl_T::m_bServerTrace, ModGetLoadedIF(), ModLoad(), ModNewModUri(), ModOneTimeInit(), ModUnload(), ServerGetClient(), ServerRequest(), ThCreateDevThread(), ThCreateServerThread(), ThDequeue(), ThDestroyThread(), ThNewDevUri(), ThOneTimeInit(), ThQueue(), ThReqDelete(), ThReqNew(), VConnAcquire(), VConnClose(), VConnDelete(), VConnGet(), VConnNew(), VConnOneTimeInit(), VConnOpenDev(), VConnOpenServer(), and VConnRelease().

Referenced by ReqMsgTrace().

{
  BsProxyClientCtl_T *pClient = ServerGetClient(hndClient);
  
  if( pClient != NULL )
  {
    pClient->m_bServerTrace = bTrace;
  }
}

INLINE_IN_H const char* ClientThisHasName

(

BsProxyClientCtl_T *

pClient

)

Get this BotSense client official name.

Warning

The client is not locked. Use in a safe context.

Parameters

pClient

Definition at line 574 of file bsProxy.h.

References BsProxyClientCtl_T::m_sClientName.

Referenced by ClientHasName(), ClientRead(), ClientRecvReq(), ClientSetState(), and ClientWrite().

{
  return pClient != NULL? pClient->m_sClientName: "(none)";
}

BsProxyModIF_T* ModGetLoadedIF

(

const char *

sModUri

)

Get the defined interface from a previously loaded i/f module.

Multi-Thread safe.

Parameters

sModUri

Interface module expanded, canonical name.

Returns

On success, returns a pointer to the module's exported interface.
Returns NULL if no interface is found.

Definition at line 1058 of file bsProxyMod.c.

References ModHashGetIF(), ModLock(), and ModUnlock().

Referenced by ClientSetTraceState().

{
  BsProxyModIF_T  *pModIF;

  ModLock();

  pModIF = ModHashGetIF(sModUri);

  ModUnlock();

  return pModIF;
}

BsProxyModIF_T* ModLoad

(

const char *

sModUri

)

Load the interface module.

The module's expanded, canonical name is determined, the dynamic library is loaded, the module's exported interface is attached, and the module's initialization routine is called.

The the same module is loaded again, the reference count is bumped and the already attached interface is returned.

Multi-Thread safe.

Parameters

sModUri

Interface module expanded, canonical name.

Returns

On success, returns a pointer to the module's exported interface.
On failure, returns NULL.

Definition at line 1089 of file bsProxyMod.c.

References BS_ECODE_BAD_MOD, BS_ECODE_NO_MOD, BS_ECODE_NO_RSRC, BS_OK, BSPROXY_MOD_LOG_ERROR, BsProxyModIF_T::m_fnModInit, BsProxyModIF_T::m_sModUri, BsProxyModIF_T::m_uRefCnt, ModDllDeleteIF(), ModDllNewIF(), ModDllOpen(), ModHashAdd(), ModHashGetIF(), ModLock(), and ModUnlock().

Referenced by ClientSetTraceState(), and VConnOpenDev().

{
  BsProxyModIF_T *pModIF      = NULL;
  void           *dllHandle   = NULL;
  int             rc;

  // lock global mutex
  ModLock();

  //
  // Check if module is already loaded.
  //
  if( (pModIF = ModHashGetIF(sModUri)) != NULL )
  {
    rc = BS_OK;
    pModIF->m_uRefCnt++;
    LOGDIAG1("Interface Module \"%s\" attached (refcnt=%u).",
          pModIF->m_sModUri, pModIF->m_uRefCnt);
  }

  //
  // Load the dynamic library.
  //
  else if( (dllHandle = ModDllOpen(sModUri)) == NULL )
  {
    rc = -BS_ECODE_NO_MOD;
    BSPROXY_MOD_LOG_ERROR(sModUri, rc, "Failed to open.");
  }

  //
  // Allocate new interface control blcok and attach module's exported
  // interface.
  //
  else if( (pModIF = ModDllNewIF(sModUri, dllHandle)) == NULL )
  {
    rc = -BS_ECODE_BAD_MOD;
    BSPROXY_MOD_LOG_ERROR(sModUri, rc, "Failed to get interface.");
  }

  //
  // Call the newly loaded module's exported initialization function to
  // initialize any module specific data and resources.
  //
  else if( (rc = pModIF->m_fnModInit(sModUri, &BsModProxyCallbacks)) < 0 )
  {
    rc = -BS_ECODE_BAD_MOD;
    BSPROXY_MOD_LOG_ERROR(sModUri, rc, "Failed to initialize.");
  }

  //
  // Add the module to the hash table (failure auto-deletes node data).
  //
  else if( (rc = ModHashAdd(sModUri, pModIF)) < 0 )
  {
    rc = -BS_ECODE_NO_RSRC;
    BSPROXY_MOD_LOG_ERROR(sModUri, rc, "Failed to add module to hash table.");
  }

  //
  // Successfully loaded new module.
  //
  else
  {
    rc = BS_OK;
    LOGDIAG1("Interface Module \"%s\" loaded (refcnt=%u).",
          pModIF->m_sModUri, pModIF->m_uRefCnt);
  }

  ModUnlock();

  //
  // Error clean up.
  //
  if( rc < 0 )
  {
    if( dllHandle != NULL )
    {
      dlclose(dllHandle);
      dllHandle = NULL;
    }

    if( pModIF != NULL )
    {
      ModDllDeleteIF(pModIF);
      pModIF = NULL;
    }
  }

  return pModIF;
}

char* ModNewModUri

(

const char *

sModName

)

Convert the module name to a quasi Uniform Resource Id.

Parameters

sModName

Module path name.

Returns

On success, an allocated, canonical library path name is returned.
On failure, NULL is returned.

Definition at line 1042 of file bsProxyMod.c.

References ModDllNewCanonicalName().

Referenced by ClientSetTraceState(), and VConnOpenDev().

{
  return ModDllNewCanonicalName(sModName);
}

void ModOneTimeInit

(

DListStr_T *

pDListLibPath

)

The bsProxy interface module handling one-time initialization.

Parameters

pDListLibPath

List of optional library search paths.

Definition at line 1013 of file bsProxyMod.c.

References BsModHashTbl, BsModMutex, BSPROXY_MOD_HASH_MAX, BSPROXY_MOD_HASH_MIN, ModDllInit(), and ModHashDeleteData().

Referenced by ClientSetTraceState(), and main().

{
  // create mutex
  pthread_mutex_init(&BsModMutex, NULL);
  
  BsModHashTbl = hash_table_create(
        true,                               // dynamic table sizing
        (hashcount_t)BSPROXY_MOD_HASH_MIN,  // minimum size
        (hashcount_t)BSPROXY_MOD_HASH_MAX,  // maximum size
        NULL,                               // use default comparator function
        NULL,                               // use default hashing function
        ModHashDeleteData);                 // hash node data deletion function

  // turn off most asserts()
  hash_set_self_verify(false);

  // initialize DLL environment
  ModDllInit(pDListLibPath);
}

void ModUnload

(

BsProxyModIF_T *

pModIF

)

Unload the interface module.

The module's reference count is decremented. If the count is zero, then the module's exit routine is called and the module dynamic library is unloaded from bsProxy server application.

Multi-Thread safe.

Parameters

pModIF

Exported module interface.

Definition at line 1191 of file bsProxyMod.c.

References BsProxyModIF_T::m_dllHandle, BsProxyModIF_T::m_fnModExit, BsProxyModIF_T::m_sModUri, BsProxyModIF_T::m_uRefCnt, ModDllClose(), ModHashDelete(), ModHashGetIF(), ModLock(), and ModUnlock().

Referenced by ClientSetTraceState(), VConnClose(), and VConnOpenDev().

{

  ModLock();

  if( (pModIF = ModHashGetIF(pModIF->m_sModUri)) != NULL )
  {
    if( pModIF->m_uRefCnt > 0 )
    {
      pModIF->m_uRefCnt--;
    }

    if( pModIF->m_uRefCnt == 0 )
    {
      // call module specific exported exit function
      pModIF->m_fnModExit();

      // unload the dll
      ModDllClose(pModIF->m_sModUri, pModIF->m_dllHandle);

      LOGDIAG1("Interface Module \"%s\" unloaded (refcnt=%u).",
          pModIF->m_sModUri, pModIF->m_uRefCnt);

      // delete data
      ModHashDelete(pModIF);
    }
    else
    {
      LOGDIAG1("Interface Module \"%s\" detached (refcnt=%u).",
          pModIF->m_sModUri, pModIF->m_uRefCnt);
    }
  }

  ModUnlock();
}

INLINE_IN_H int ServerClientHnd2Sd

(

BsProxyClientHnd_T

hndClient

)

Convert the BotSense server client handle to client socket descriptor.

Note

Currently, the handle and socket descriptor are one and the same. But this mapping could change in the future.

Parameters

hndClient

Definition at line 521 of file bsProxy.h.

Referenced by BsProxyClientUnregister(), BsProxyServerDelete(), and ServerGetClient().

{
  return (int)hndClient;
}

INLINE_IN_H BsProxyClientHnd_T ServerClientSd2Hnd

(

int

sd

)

Convert the BotSense server client socket descriptor to client handle.

Note

Currently, the handle and socket descriptor are one and the same. But this mapping could change in the future.

Parameters

sd

Definition at line 537 of file bsProxy.h.

Referenced by BsProxyClientRegister(), BsProxyServer(), ClientRead(), and ClientWrite().

{
  return (BsProxyClientHnd_T)sd;
}

INLINE_IN_H BsProxyServerCtl_T* ServerGet

(

)

Get the BotSense server.

Note

In the future, if bsProxy is expanded to be multi-threaded multi-server then this call will return the correct server given the caller's context.

Returns

Pointer to the server's control block.

Definition at line 475 of file bsProxy.h.

References BsServerCtl.

Referenced by BsProxyClientRegister(), BsProxyClientUnregister(), ServerGetClient(), ServerHasAddr(), ServerHasName(), and ServerHasPort().

{
  return BsServerCtl;
}

INLINE_IN_H BsProxyClientCtl_T* ServerGetClient

(

BsProxyClientHnd_T

hndClient

)

Get the BotSense server client.

Note

The client is not locked.

Parameters

hndClient

Definition at line 551 of file bsProxy.h.

References BSPROXY_FD_SETSIZE, BsProxyServerCtl_T::m_pServerRegClient, ServerClientHnd2Sd(), and ServerGet().

Referenced by BsProxyServer(), ClientAcquire(), ClientGetTraceState(), ClientHasName(), ClientRelease(), and ClientSetTraceState().

{
  int sd = ServerClientHnd2Sd(hndClient);

  if( (sd >= 0) && (sd < BSPROXY_FD_SETSIZE) )
  {
    return ServerGet()->m_pServerRegClient[sd];
  }
  else
  {
    return NULL;
  }
}

INLINE_IN_H const char* ServerHasAddr

(

)

Get the BotSense server's listening address.

Returns

Null-terminated server address string.

Definition at line 495 of file bsProxy.h.

References ServerGet().

{
  return SocketAttrGetLocalName(ServerGet()->m_pServerSockListener);
}

INLINE_IN_H const char* ServerHasName

(

)

Get the BotSense server's official name.

Returns

Null-terminated server name string.

Definition at line 485 of file bsProxy.h.

References BsProxyServerCtl_T::m_sServerName, and ServerGet().

Referenced by BsProxyServer(), ClientRecvReq(), ClientSetState(), main(), ModCbSendErrorRsp(), ModCbSendOkRsp(), ModCbSendRsp(), ModDllOpen(), ThQueue(), VConnClose(), VConnOpenDev(), and VConnOpenServer().

{
  return ServerGet()->m_sServerName;
}

INLINE_IN_H int ServerHasPort

(

)

Get the BotSense server's listening port.

Returns

Port.

Definition at line 505 of file bsProxy.h.

References BsProxyServerCtl_T::m_nServerPort, and ServerGet().

Referenced by BsProxyServer().

{
  return ServerGet()->m_nServerPort;
}

int ServerRequest	(	BsProxyClientHnd_T	hndClient,
		BsVConnHnd_T	hndVConn,
		BsTid_T	uTid,
		BsMsgId_T	uMsgId,
		byte_t	bufReq[],
		size_t	uReqLen
	)

Server service thread request handler.

Execution Context:

Server service thread.

Parameters

hndClient

Definition at line 610 of file bsProxyRequest.c.

References BS_ECODE_UNKNOWN_REQ, BSPROXY_SEND_ERROR_RSP, BsProxyMsgIdReqDevClose, BsProxyMsgIdReqDevOpen, BsProxyMsgIdReqGetVConnInfo, BsProxyMsgIdReqGetVConnList, BsProxyMsgIdReqGetVersion, BsProxyMsgIdReqLoopback, BsProxyMsgIdReqMsgTrace, BsProxyMsgIdReqSetLogging, ClientGetTraceState(), ReqDevClose(), ReqDevOpen(), ReqGetVConnInfo(), ReqGetVConnList(), ReqGetVersion(), ReqLoopback(), ReqMsgTrace(), and ReqSetLogging().

Referenced by ClientSetTraceState(), and ThCreateServerThread().

{
  bool_t bServerTrace = ClientGetTraceState(hndClient);

  switch( uMsgId )
  {
    case BsProxyMsgIdReqLoopback:
      return ReqLoopback(hndClient, hndVConn, uTid, uMsgId, bufReq, uReqLen,
                        bServerTrace);

    case BsProxyMsgIdReqSetLogging:
      return ReqSetLogging(hndClient, hndVConn, uTid, uMsgId, bufReq, uReqLen,
                            bServerTrace);

    case BsProxyMsgIdReqMsgTrace:
      return ReqMsgTrace(hndClient, hndVConn, uTid, uMsgId, bufReq, uReqLen,
                          bServerTrace);

    case BsProxyMsgIdReqGetVersion:
      return ReqGetVersion(hndClient, hndVConn, uTid, uMsgId, bufReq, uReqLen,
                          bServerTrace);

    case BsProxyMsgIdReqDevOpen:
      return ReqDevOpen(hndClient, hndVConn, uTid, uMsgId, bufReq, uReqLen,
                          bServerTrace);

    case BsProxyMsgIdReqDevClose:
      return ReqDevClose(hndClient, hndVConn, uTid, uMsgId, bufReq, uReqLen,
                          bServerTrace);

    case BsProxyMsgIdReqGetVConnList:
      return ReqGetVConnList(hndClient, hndVConn, uTid, uMsgId, bufReq, uReqLen,
                              bServerTrace);

    case BsProxyMsgIdReqGetVConnInfo:
      return ReqGetVConnInfo(hndClient, hndVConn, uTid, uMsgId, bufReq, uReqLen,
                              bServerTrace);

    default:
      BSPROXY_SEND_ERROR_RSP(hndClient, hndVConn, uTid, BS_ECODE_UNKNOWN_REQ,
          "MsgId=%u", uMsgId);
      return -BS_ECODE_UNKNOWN_REQ;
  }
}

BsProxyThCtl_T* ThCreateDevThread

(

const char *

sDevUri

)

Create a device service thread.

The actual thread is only created if it does not already exists. The internal reference count is incremented to keep track of the users of this thread.

Execution Context:

Calling thread.

Parameters

sDevUri

Device URI.

Returns

On success, returns the service thread control block. On failure, NULL is returned.

Definition at line 756 of file bsProxyThread.c.

References BsProxyThStateInit, _bsproxy_th_ctl::m_eState, _bsproxy_th_ctl::m_fnRequest, _bsproxy_th_ctl::m_sDevUri, _bsproxy_th_ctl::m_thread, _bsproxy_th_ctl::m_uRefCnt, ThCtlBlkDelete(), ThCtlBlkNew(), ThDevRequest(), ThGlobalLock(), ThGlobalUnlock(), ThHashAdd(), ThHashDelete(), ThHashGetCtl(), ThServiceThread(), and ThSyncRun().

Referenced by ClientSetTraceState(), and VConnOpenDev().

{
  BsProxyThCtl_T *pThCtl;
  int             rc;

  // lock global mutex
  ThGlobalLock();

  //
  // Device thread already exists. 
  //
  if( (pThCtl = ThHashGetCtl(sDevUri)) != NULL )
  {
    pThCtl->m_uRefCnt++;
    LOGDIAG1("Service Thread \"%s\" attached (refcnt=%u).",
        pThCtl->m_sDevUri, pThCtl->m_uRefCnt);
  }

  //
  // Create new device thread.
  //
  else
  {
    //
    // Create a new thread control block.
    //
    pThCtl = ThCtlBlkNew(sDevUri);

    pThCtl->m_fnRequest = ThDevRequest;       // device request handler
    pThCtl->m_uRefCnt   = 1;                  // thread reference count
    pThCtl->m_eState    = BsProxyThStateInit; // control is (mostly) initialized

    //
    // Add thread control to thread hash table
    //
    if( (rc = ThHashAdd(sDevUri, pThCtl)) < 0 )
    {
      LOGERROR("\"%s\": Failed to add thread control to hash table.", sDevUri);
      ThCtlBlkDelete(pThCtl);
      pThCtl = NULL;
    }

    //
    // Start the device service thread. The thread will block until the run
    // state is set this context.
    //
    else if( pthread_create(&pThCtl->m_thread, NULL, ThServiceThread,
                            (void *)pThCtl) )
    {
      LOGSYSERROR("pthread_create(\"%s\")", sDevUri);
      ThHashDelete(pThCtl);
      pThCtl = NULL;
    }

    //
    // Signal the thread to run.
    //
    else
    {
      ThSyncRun(pThCtl);
    }
  }

  // unlock thread mutex
  ThGlobalUnlock();

  return pThCtl;
}

BsProxyThCtl_T* ThCreateServerThread

(

)

Create the special server service thread.

There is only one server service thread per server. The server thread processes all server terminated requests.

Execution Context:

Calling thread.

Returns

On success, returns the service thread control block. On failure, NULL is returned.

Definition at line 837 of file bsProxyThread.c.

References BS_ECODE_INTERNAL, BSPROXY_TH_LOG_ERROR, BSPROXY_TH_SERVER_URI, BsProxyThStateInit, _bsproxy_th_ctl::m_eState, _bsproxy_th_ctl::m_fnRequest, _bsproxy_th_ctl::m_thread, _bsproxy_th_ctl::m_uRefCnt, ServerRequest(), ThCtlBlkDelete(), ThCtlBlkNew(), ThGlobalLock(), ThGlobalUnlock(), ThHashAdd(), ThHashDelete(), ThHashGetCtl(), ThServiceThread(), and ThSyncRun().

Referenced by ClientSetTraceState(), and VConnOpenServer().

{
  char           *sDevUri;
  BsProxyThCtl_T *pThCtl;
  int             rc;

  // Server URI
  sDevUri = new_strdup(BSPROXY_TH_SERVER_URI);

  // lock global mutex
  ThGlobalLock();

  //
  // There should only be one server thread.
  //
  if( (pThCtl = ThHashGetCtl(sDevUri)) != NULL )
  {
    BSPROXY_TH_LOG_ERROR(sDevUri, BS_ECODE_INTERNAL,
        "Server service thread already exists.");
  }

  //
  // Create new device thread.
  //
  else
  {
    //
    // Create a new thread control block.
    //
    pThCtl = ThCtlBlkNew(sDevUri);

    pThCtl->m_fnRequest = ServerRequest;      // server request handler
    pThCtl->m_uRefCnt   = 1;                  // thread reference count
    pThCtl->m_eState    = BsProxyThStateInit; // control is (mostly) initialized

    //
    // Add thread control to thread hash table
    //
    if( (rc = ThHashAdd(sDevUri, pThCtl)) < 0 )
    {
      LOGERROR("\"%s\": Failed to add thread control to hash table.", sDevUri);
      ThCtlBlkDelete(pThCtl);
      pThCtl = NULL;
    }

    //
    // Start the device service thread. The thread will block until the run
    // state is set this context.
    //
    else if( pthread_create(&pThCtl->m_thread, NULL, ThServiceThread,
                            (void *)pThCtl) )
    {
      LOGSYSERROR("pthread_create(\"%s\")", sDevUri);
      ThHashDelete(pThCtl);
      pThCtl = NULL;
    }

    //
    // Signal the thread to run.
    //
    else
    {
      ThSyncRun(pThCtl);
    }
  }

  // unlock global mutex
  ThGlobalUnlock();

  return pThCtl;
}

BsProxyThReq_T* ThDequeue

(

BsProxyThCtl_T *

pThCtl

)

Dequeue a request for the given service thread.

The service thread will block if no queued request is present.

Execution Context:

Service thread.

Returns

On success, returns removed request at the front of the queue.
On failure, NULL is returned.

Definition at line 675 of file bsProxyThread.c.

References BsProxyThStateRunning, _bsproxy_th_ctl::m_eState, _bsproxy_th_ctl::m_queue, ThSyncLock(), ThSyncUnlock(), and ThSyncWait().

Referenced by ClientSetTraceState(), and ThServiceThread().

{
  BsProxyThReq_T  *pThReq;

  // lock thread and queue
  ThSyncLock(pThCtl);

  //
  // Block waiting for queued request or state change event.
  //
  while( (pThCtl->m_eState == BsProxyThStateRunning) &&
         (DListVoidCount(pThCtl->m_queue) == 0) )
  {
    // Release mutex, block on conditional variable, auto-lock mutex on return.
    ThSyncWait(pThCtl);
  }

  if( pThCtl->m_eState == BsProxyThStateRunning )
  {
    pThReq = (BsProxyThReq_T *)DListVoidDequeue(pThCtl->m_queue);
  }
  else
  {
    pThReq = NULL;
  }

  // unlock thread and queue
  ThSyncUnlock(pThCtl);

  return pThReq;
}

void ThDestroyThread

(

BsProxyThCtl_T *

pThCtl

)

Destroy service thread.

The thread's reference count is decremented. If the count is zero, then the thread is actually destroyed with all queued requests deleted. The calling thread is suspended until the target service thread terminates.

Execution Context:

Calling thread.

Parameters

pThCtl

Service thread control block.

Definition at line 921 of file bsProxyThread.c.

References _bsproxy_th_ctl::m_sDevUri, _bsproxy_th_ctl::m_thread, _bsproxy_th_ctl::m_uRefCnt, ThGlobalLock(), ThGlobalUnlock(), ThHashDelete(), and ThSyncExit().

Referenced by ClientSetTraceState(), VConnClose(), and VConnOpenDev().

{
  if( pThCtl == NULL )
  {
    return;
  }

  // lock global mutex
  ThGlobalLock();

  // do not destroy the thread since there exists users of this thread
  if( pThCtl->m_uRefCnt > 0 )
  {
    pThCtl->m_uRefCnt--;
  }

  // thread is not being used anymore - destroy
  if( pThCtl->m_uRefCnt == 0 )
  {
    // signal thread of exit state change
    ThSyncExit(pThCtl);

    // wait for thread to terminate
    pthread_join(pThCtl->m_thread, NULL);

    // delete the thread hash entry's control block (including its queue)
    ThHashDelete(pThCtl);
  }

  else
  {
    LOGDIAG1("Service Thread \"%s\" detached (refcnt=%u).",
        pThCtl->m_sDevUri, pThCtl->m_uRefCnt);
  }

  // unlock global mutex
  ThGlobalUnlock();
}

char* ThNewDevUri

(

const char *

sDevName

)

Convert the device name to a quasi Uniform Resource Id.

Parameters

sDevName

Device path name.

Returns

On success, an allocated, canonical device path name is returned.
On failure, NULL is returned.

Definition at line 737 of file bsProxyThread.c.

Referenced by ClientSetTraceState(), and VConnOpenDev().

{
  return NewSearchPathCanonicalized(sDevName);
}

int ThQueue	(	BsProxyThCtl_T *	pThCtl,
		BsProxyClientHnd_T	hndClient,
		BsVConnHnd_T	hndVConn,
		BsTid_T	uTid,
		BsMsgId_T	uMsgId,
		byte_t	bufReq[],
		size_t	uReqLen
	)

Queue a request for the given service thread.

Execution Context:

Calling thread.

Parameters

pThCtl	Service thread control block.
hndClient	Client handle.
hndVConn	Virtual connection handle.
uTid	Request-Response transaction id.
uMsgId	Request message id.
bufReq	Allocated packed request message body.
uReqLen	Length of request in buffer (number of bytes).

Returns

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

Definition at line 626 of file bsProxyThread.c.

References BS_ECODE_NO_RSRC, BS_OK, BSPROXY_TH_LOG_ERROR, BSPROXY_TH_MAX_QUEUE_SIZE, _bsproxy_th_ctl::m_queue, _bsproxy_th_ctl::m_sDevUri, ServerHasName(), ThReqNew(), ThSyncLock(), ThSyncSignal(), and ThSyncUnlock().

Referenced by BsProxyDispatch(), and ClientSetTraceState().

{
  BsProxyThReq_T *pThReq;
  int             rc;

  // lock thread and queue
  ThSyncLock(pThCtl);

  //
  // Queue request on thread's message queue.
  //
  if( DListVoidCount(pThCtl->m_queue) < BSPROXY_TH_MAX_QUEUE_SIZE )
  {
    pThReq = ThReqNew(hndClient, hndVConn, uTid, uMsgId, bufReq, uReqLen);
    DListVoidQueue(pThCtl->m_queue, pThReq);
    ThSyncSignal(pThCtl);
    LOGDIAG3("%s: Service Thread \"%s\": queue depth=%u.",
      ServerHasName(), pThCtl->m_sDevUri, DListVoidCount(pThCtl->m_queue)); 
    rc = BS_OK;
  }
  else
  {
    rc = -BS_ECODE_NO_RSRC;
    BSPROXY_TH_LOG_ERROR(pThCtl->m_sDevUri, rc, "Queue overflow.");
  }

  // unlock thread and queue
  ThSyncUnlock(pThCtl);

  return rc;
}

void ThReqDelete

(

BsProxyThReq_T *

pThReq

)

Delete service thread request.

Parameters

pThReq

Service thread request.

Definition at line 601 of file bsProxyThread.c.

References _bsproxy_th_req::m_bufReq.

Referenced by ClientSetTraceState(), ThQReqDelete(), and ThServiceThread().

{
  if( pThReq != NULL )
  {
    delete(pThReq->m_bufReq);
    delete(pThReq);
  }
}

BsProxyThReq_T* ThReqNew	(	BsProxyClientHnd_T	hndClient,
		BsVConnHnd_T	hndVConn,
		BsTid_T	uTid,
		BsMsgId_T	uMsgId,
		byte_t	bufReq[],
		size_t	uReqLen
	)

Allocate and initalized a new service thread request.

Parameters

hndClient	Client handle.
hndVConn	Virtual connection handle.
uTid	Request-Response transaction id.
uMsgId	Request message id.
bufReq	Allocated packed request message body.
uReqLen	Length of request in buffer (number of bytes).

Returns

Pointer to allocated request.

Definition at line 577 of file bsProxyThread.c.

References _bsproxy_th_req::m_bufReq, _bsproxy_th_req::m_hndClient, _bsproxy_th_req::m_hndVConn, _bsproxy_th_req::m_uMsgId, _bsproxy_th_req::m_uReqLen, and _bsproxy_th_req::m_uTid.

Referenced by ClientSetTraceState(), and ThQueue().

{
  BsProxyThReq_T *pThReq = NEW(BsProxyThReq_T);

  pThReq->m_hndClient = hndClient;
  pThReq->m_hndVConn  = hndVConn;
  pThReq->m_uTid      = uTid;
  pThReq->m_uMsgId    = uMsgId;
  pThReq->m_bufReq    = bufReq;
  pThReq->m_uReqLen   = uReqLen;

  return pThReq;
}

uint_t timer_elapsed

(

struct timeval *

pTvMark

)

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 79 of file bsProxyUtils.c.

References timer_mark().

Referenced by timer_mark().

{
  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 seconds and useconds.

Definition at line 456 of file bsProxy.h.

References timer_elapsed().

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

BsProxyVConn_T* VConnAcquire

(

BsVConnHnd_T

hndVConn

)

Acquire virtual connection, locking it from other threads.

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

Parameters

hndVConn

Definition at line 552 of file bsProxyVConn.c.

References BSPROXY_CHK_VCONN_HND, BsProxyVConn_T::m_bBusy, VConnLockBusy(), VConnUnlockBusy(), and VConnWaitNotBusy().

Referenced by BsProxyDispatch(), ClientSetTraceState(), ModCbGetDevUri(), ModCbIterNext(), ReqGetVConnInfo(), ReqGetVConnList(), ReqMsgTrace(), ThDevRequest(), and VConnClose().

{
  BsProxyVConn_T  *pVConn;

  if( !BSPROXY_CHK_VCONN_HND(hndVConn) )
  {
    return NULL;
  }

  VConnLockBusy();

  while( (BsVConnTbl[hndVConn] != NULL) && BsVConnTbl[hndVConn]->m_bBusy )
  {
    VConnWaitNotBusy();
  }

  if( (pVConn = BsVConnTbl[hndVConn]) != NULL )
  {
    pVConn->m_bBusy = true;
  }

  VConnUnlockBusy();

  return pVConn;
}

int VConnClose	(	BsProxyClientHnd_T	hndClient,
		BsVConnHnd_T	hndVConn
	)

Close the virtual connection.

Closing a virtual connections may close the resource (file) descriptor associated with the device, unload the interface module associated with the device, and terminate the device thread. These actions occur only when the reference counts are zero.

Parameters

hndClient

Definition at line 478 of file bsProxyVConn.c.

References BS_ECODE_BAD_VCONN_HND, BS_ECODE_NO_VCONN, BS_OK, BSPROXY_CHK_MOD_VCONN_HND, BSPROXY_LOG_ERROR, BsVConnActiveCnt, ClientHasName(), BsProxyModIF_T::m_fnModClose, BsProxyVConn_T::m_hndVConn, BsProxyVConn_T::m_pModIF, BsProxyVConn_T::m_pThCtl, ModUnload(), ServerHasName(), ThDestroyThread(), VConnAcquire(), and VConnDelete().

Referenced by BsProxyClientUnregister(), ClientSetTraceState(), and ReqDevClose().

{
  BsProxyVConn_T *pVConn;
  int             rc;

  // Only virtual connections associated with devices can be closed.
  if( !BSPROXY_CHK_MOD_VCONN_HND(hndVConn) )
  {
    rc = -BS_ECODE_BAD_VCONN_HND;
  }

  //
  // Acquire virtual connection associated with handle. Aquiring a virtual
  // connections locks out other thread access to the vConnection until it 
  // is released.
  //
  else if( (pVConn = VConnAcquire(hndVConn)) == NULL )
  {
    rc = -BS_ECODE_NO_VCONN;
    BSPROXY_LOG_ERROR(hndClient, rc, "VConn=%d", hndVConn);
  }

  else
  {
    //
    // Destroy the device thread. The thread reference count is decremented and
    // only when it drops to zero is the thread actually terminated.
    //
    ThDestroyThread(pVConn->m_pThCtl);

    //
    // Close the device associated with virtual connection. The actual device
    // may or may not be closed, depending on the device and module
    // implementation.  For example, for an \h_i2c Bus device, the device is
    // only closed when the last reference to that device is closed.
    //
    pVConn->m_pModIF->m_fnModClose(pVConn->m_hndVConn);

    //
    // Dynamically unload the interface module from the bsProxy application. The
    // module's reference count is decremented and only when it drops to zero is
    // the module actually unloaded.
    //
    ModUnload(pVConn->m_pModIF);

    LOGDIAG1("%s: %s: Virtual connection %d closed.",
        ServerHasName(), ClientHasName(hndClient), pVConn->m_hndVConn);

    //
    // Delete the virtual connection. The slot is now available for a new
    // virtual connection.
    //
    VConnDelete(pVConn);

    LOGDIAG2("%s: %u active module virtual connections.",
        ServerHasName(), BsVConnActiveCnt-1);

    rc = BS_OK;
  }

  return rc;
}

void VConnDelete

(

BsProxyVConn_T *

pVConn

)

Delete allocated virtual connection entry.

The deletion event is broadcasted to all blocked threads waiting on this connection.

Definition at line 220 of file bsProxyVConn.c.

References BSPROXY_CHK_VCONN_HND, BsVConnActiveCnt, BsProxyVConn_T::m_hndVConn, VConnBroadcastNotBusy(), VConnLockBusy(), and VConnUnlockBusy().

Referenced by ClientSetTraceState(), VConnClose(), and VConnOpenDev().

{
  VConnLockBusy();

  if( pVConn != NULL )
  {
    if( BSPROXY_CHK_VCONN_HND(pVConn->m_hndVConn) )
    {
      BsVConnTbl[pVConn->m_hndVConn] = NULL;
      BsVConnActiveCnt--;
    }
    delete(pVConn);
  }

  VConnBroadcastNotBusy();

  VConnUnlockBusy();
}

BsProxyVConn_T* VConnGet

(

BsVConnHnd_T

hndVConn

)

Get the virtual connection entry associated with the handle.

Warning

The virtual connection is not locked.

Parameters

hndVConn

Definition at line 248 of file bsProxyVConn.c.

References BSPROXY_CHK_VCONN_HND.

Referenced by BsProxyClientUnregister(), ClientSetTraceState(), ModCbSendErrorRsp(), ModCbSendOkRsp(), and ModCbSendRsp().

{
  if( !BSPROXY_CHK_VCONN_HND(hndVConn) )
  {
    return NULL;
  }
  else
  {
    return BsVConnTbl[hndVConn];
  }
}

BsProxyVConn_T* VConnNew

(

)

Create a new, allocated virtual connection entry.

The new virtual connection is added to the virtual connection table. It is marked busy (i.e. locked). The caller must call VConnRelease() or VConnDelete() to free the entry.

Returns

Allocated virtual connection on success, NULL on failure.

Definition at line 183 of file bsProxyVConn.c.

References BSPROXY_VCONN_MOD_NUMOF, BSPROXY_VCONN_NUMOF, BsVConnActiveCnt, BsProxyVConn_T::m_bBusy, BsProxyVConn_T::m_hndVConn, VConnLockBusy(), and VConnUnlockBusy().

Referenced by ClientSetTraceState(), and VConnOpenDev().

{
  BsProxyVConn_T *pVConn = NULL;
  BsVConnHnd_T    hndVConn;

  // lock virtual connection table
  VConnLockBusy();

  // find an empty virtual connection table slot
  if( BsVConnActiveCnt < BSPROXY_VCONN_NUMOF )
  {
    for(hndVConn=0; hndVConn<BSPROXY_VCONN_MOD_NUMOF; ++hndVConn)
    {
      if( BsVConnTbl[hndVConn] == NULL )
      {
        pVConn               = NEW(BsProxyVConn_T);
        pVConn->m_bBusy      = true;
        pVConn->m_hndVConn   = hndVConn;
        BsVConnTbl[hndVConn] = pVConn;
        BsVConnActiveCnt++;
        break;
      }
    }
  }

  // unlock virtual connection table
  VConnUnlockBusy();

  return pVConn;
}

int VConnOpenDev	(	BsProxyClientHnd_T	hndClient,
		const char *	sDevName,
		const char *	sModName,
		byte_t	argbuf[],
		size_t	uArgLen,
		bool_t	bTrace
	)

Open a virtual device connection.

To open a virtual connection:

• A new entry is created.
• The associated device thread is located or created.
• The associated interface module is located or loaded.
• The module's exported ModOpen() routine is called.

Parameters

hndClient

Definition at line 325 of file bsProxyVConn.c.

References BS_ECODE_BAD_VAL, BS_ECODE_NO_EXEC, BS_ECODE_NO_MOD, BS_ECODE_NO_RSRC, BSPROXY_LOG_ERROR, BsVConnActiveCnt, ClientHasName(), BsProxyModIF_T::m_fnModOpen, BsProxyVConn_T::m_hndClient, BsProxyVConn_T::m_hndVConn, BsProxyVConn_T::m_pModIF, BsProxyVConn_T::m_pThCtl, BsProxyVConn_T::m_rd, BsProxyModIF_T::m_sModUri, ModLoad(), ModNewModUri(), ModUnload(), ServerHasName(), ThCreateDevThread(), ThDestroyThread(), ThNewDevUri(), VConnDelete(), VConnNew(), and VConnRelease().

Referenced by ClientSetTraceState(), and ReqDevOpen().

{
  BsProxyVConn_T *pVConn  = NULL; // new virtual connection entry
  char           *sModUri = NULL; // module URI
  char           *sDevUri = NULL; // device URI
  BsProxyModIF_T *pModIF  = NULL; // interface module interface
  BsProxyThCtl_T *pThCtl  = NULL; // device thread control block
  int             rc;             // return code
  int             rd;             // resource descriptor

  //
  // Allocate a new virtual connection. If no more virtual connections are
  // available, NULL is returned. The return virtual connection is left in
  // the acquired state which requires releasing prior to becoming available
  // for normal operations.
  //
  if( (pVConn = VConnNew()) == NULL )
  {
    rc = -BS_ECODE_NO_RSRC;
    BSPROXY_LOG_ERROR(hndClient, rc,
        "No more virtual connections are available.");
  }

  //
  // Convert module path name to canonical uniform resource identifier.
  //
  else if( (sModUri = ModNewModUri(sModName)) == NULL )
  {
    rc = -BS_ECODE_BAD_VAL;
    BSPROXY_LOG_ERROR(hndClient, rc, "\"%s\": Bad module name.", sModName);
  }

  //
  // Convert device path name to canonical uniform resource identifier.
  //
  else if( (sDevUri = ThNewDevUri(sDevName)) == NULL )
  {
    rc = -BS_ECODE_BAD_VAL;
    BSPROXY_LOG_ERROR(hndClient, rc, "\"%s\": Bad device name.", sDevName);
  }

  //
  // Dynamically load and initialize library interface module and return the
  // module's interface. If the module already exists, then the same interface
  // is returned. The module interface maintains a reference count which is 
  // incremented.
  //
  else if( (pModIF = ModLoad(sModUri)) == NULL )
  {
    rc = -BS_ECODE_NO_MOD;
    BSPROXY_LOG_ERROR(hndClient, rc,
        "Could not load or attach to \"%s\" interface module.", sModUri);
  }

  //
  // Call the interface module's open() function to open the device and allocate
  // any internal resources. The return resource descriptor is typically a
  // file or socket descript, but may be any unique non-negative integer
  // defined by the module.
  //
  else if( (rd = pModIF->m_fnModOpen(pVConn->m_hndVConn, bTrace,
                                     sDevUri, argbuf, uArgLen)) < 0 )
  {
    rc = -BS_ECODE_NO_EXEC;
    BSPROXY_LOG_ERROR(hndClient, rd,
        "Could not open \"%s\" interface module.", pModIF->m_sModUri);
  }

  //
  // Create a device thread returning the thread's control. If the thread
  // already exists, then the same thread control is returned. The thread 
  // control maintains a reference count which is incremented.
  //
  else if( (pThCtl = ThCreateDevThread(sDevUri)) == NULL )
  {
    rc = -BS_ECODE_NO_EXEC;
    BSPROXY_LOG_ERROR(hndClient, rc,
        "Could not create or attach to \"%s\" device service thread.",
        sDevUri);
  }

  //
  // Success.
  //
  // Populate the virtual connection's data. All allocated data are not owned by
  // the virtual connection. That is, any allocated data will not be deleted
  // when the virtual connection is deleted.
  //
  else
  {
    pVConn->m_hndClient = hndClient;
    pVConn->m_pThCtl    = pThCtl;
    pVConn->m_pModIF    = pModIF;
    pVConn->m_rd        = rd;

    VConnRelease(pVConn->m_hndVConn);

    rc = (int)pVConn->m_hndVConn;

    LOGDIAG1("%s: %s: Virtual connection %d opened: %s('%s',rd=%d).",
        ServerHasName(), ClientHasName(hndClient), pVConn->m_hndVConn,
        sModUri, sDevUri, rd);

    LOGDIAG2("%s: %u active module virtual connections.",
        ServerHasName(), BsVConnActiveCnt-1);
  }

  //
  // Error occurred, so clean up before returning.
  //
  if( rc < 0 )
  {
    if( pThCtl != NULL )
    {
      ThDestroyThread(pThCtl);
    }
    if( pModIF != NULL )
    {
      ModUnload(pModIF);
    }
    if( pVConn != NULL )
    {
      VConnDelete(pVConn);
    }
  }

  //
  // Fixed clean up.
  //
  delete(sModUri);
  delete(sDevUri);

  return rc;
}

int VConnOpenServer

(

)

Open special server virtual connection.

Returns

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

Definition at line 265 of file bsProxyVConn.c.

References BS_ECODE_NO_EXEC, BS_OK, BSPROXY_VCONN_SERVER, BsVConnActiveCnt, BsProxyVConn_T::m_bBusy, BsProxyVConn_T::m_hndClient, BsProxyVConn_T::m_hndVConn, BsProxyVConn_T::m_pModIF, BsProxyVConn_T::m_pThCtl, BsProxyVConn_T::m_rd, ServerHasName(), and ThCreateServerThread().

Referenced by ClientSetTraceState(), and main().

{
  BsProxyThCtl_T *pThCtl;       // server service thread control
  BsProxyVConn_T *pVConn;       // new virtual connection entry
  BsVConnHnd_T    hndVConn = BSPROXY_VCONN_SERVER;  // reserved server handle
  int             rc;           // return code

  //
  // Create the one server thread.
  //
  if( (pThCtl = ThCreateServerThread()) == NULL )
  {
    rc = -BS_ECODE_NO_EXEC;
    LOGERROR("%s: Could not create server service thread.", ServerHasName());
  }

  //
  // Add this special virtual connection to the table. No mutual exclusion is
  // done since the server should be started prior to servicing an client
  // requests.
  //
  else
  {
    pVConn              = NEW(BsProxyVConn_T);
    pVConn->m_bBusy     = false;
    pVConn->m_hndClient = -1;
    pVConn->m_hndVConn  = hndVConn;
    pVConn->m_pThCtl    = pThCtl;
    pVConn->m_pModIF    = NULL;
    pVConn->m_rd        = -1;

    BsVConnTbl[hndVConn] = pVConn;
    BsVConnActiveCnt++;

    rc = BS_OK;
  }

  return rc;
}

void VConnRelease

(

BsVConnHnd_T

hndVConn

)

Release the locked virtual client.

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

Parameters

hndVConn

Definition at line 585 of file bsProxyVConn.c.

References BSPROXY_CHK_VCONN_HND, BsProxyVConn_T::m_bBusy, VConnBroadcastNotBusy(), VConnLockBusy(), and VConnUnlockBusy().

Referenced by BsProxyDispatch(), ClientSetTraceState(), ModCbGetDevUri(), ModCbIterNext(), ReqGetVConnInfo(), ReqGetVConnList(), ReqMsgTrace(), ThDevRequest(), and VConnOpenDev().

{
  if( !BSPROXY_CHK_VCONN_HND(hndVConn) )
  {
    return;
  }

  VConnLockBusy();

  if( BsVConnTbl[hndVConn] != NULL )
  {
    BsVConnTbl[hndVConn]->m_bBusy = false;
  }

  VConnBroadcastNotBusy();

  VConnUnlockBusy();
}

Variable Documentation

BsProxyServerCtl_T* BsServerCtl

The server control block.

Note

In a future bsProxy implementation, multiple server instance threads could be running in the same application. But currently there is only one server per application instance.

Definition at line 831 of file bsProxy.c.

Referenced by ServerGet(), ServerLock(), ServerTryLock(), and ServerUnlock().