bsLibServer.c File Reference

Server-Client connection, control, and information functions. More...

#include <stdio.h>
#include <stdlib.h>
#include <libgen.h>
#include <string.h>
#include "rnr/rnrconfig.h"
#include "rnr/sock.h"
#include "rnr/new.h"
#include "rnr/log.h"
#include "botsense/BotSense.h"
#include "botsense/libBotSense.h"
#include "botsense/bsProxyMsgs.h"
#include "bsLibInternal.h"

Go to the source code of this file.

Macros
#define	_BS_LOG_VCONN_OPEN(pClient, index)
	Log virtual connection open event. More...

Functions
static void	bsLogVConnOpenEvent (BsClient_T *pClient, int index)
	Log virtual connection open event. More...
int	bsServerConnect (BsClient_P pClient, const char *sServerHostName, int ipServerPort)
	Connect to the bsProxy server. More...
int	bsServerDisconnect (BsClient_P pClient)
	Disconnect from the bsProxy server. 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	bsServerReqGetVersion (BsClient_P pClient, char bufVer[], size_t bufSize)
	Request server to return the server's version string. More...
int	bsServerReqMsgTrace (BsClient_P pClient, BsVConnHnd_T hndVConn, bool_t bNewTrace)
	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 bInitTrace)
	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

Server-Client connection, control, and information functions.

LastChangedDate

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

Rev

568

Author

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

Copyright

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

Definition in file bsLibServer.c.

Macro Definition Documentation

#define _BS_LOG_VCONN_OPEN	(		pClient,
			index
	)

Value:

do \
  { \
    if( LOGABLE(LOG_LEVEL_DIAG2) ) \
    { \
      bsLogVConnOpenEvent(pClient, index); \
    } \
  } while(0)

Log virtual connection open event.

Parameters

pClient

Definition at line 76 of file bsLibServer.c.

Referenced by bsServerReqOpenDev().

Function Documentation

static void bsLogVConnOpenEvent ( BsClient_T *  pClient, int  index  )

static

Log virtual connection open event.

Parameters

pClient

Definition at line 91 of file bsLibServer.c.

References BsClientAppInfo_T::app_name, BsClientAppInfo_T::brief, BsClientAppInfo_T::date, BsVConn_T::m_hndVConn, BsVConn_T::m_pAppInfo, _bsClientStruct::m_sClientName, BsVConn_T::m_sDevName, BsVConn_T::m_sModName, _bsClientStruct::m_tblVConn, BsClientAppInfo_T::maintainer, and BsClientAppInfo_T::version.

{
  FILE                    *fp;
  BsVConn_T               *pVConn;
  const BsClientAppInfo_T *pAppInfo;

  fp        = LOG_GET_LOGFP();
  pVConn    = pClient->m_tblVConn[index];

  if( pVConn == NULL )
  {
    fprintf(fp, "%s: internal data corruption.\n", pClient->m_sClientName);
    return;
  }

  pAppInfo  = pVConn->m_pAppInfo;

  fprintf(fp, "%s: Opened Virtual Connection\n", pClient->m_sClientName); 
  fprintf(fp, "{\n");
  fprintf(fp, "  VConn:      %d\n", pVConn->m_hndVConn);
  fprintf(fp, "  Device:     %s\n", pVConn->m_sDevName);
  fprintf(fp, "  I/F Module: %s\n", pVConn->m_sModName);
  if( pAppInfo != NULL )
  {
    fprintf(fp, "  Application = {\n");
    if( pAppInfo->app_name != NULL )
    {
      fprintf(fp, "    Name:       %s\n", pAppInfo->app_name);
    }
    if( pAppInfo->brief != NULL )
    {
      fprintf(fp, "    Brief:      %s\n", pAppInfo->brief);
    }
    if( pAppInfo->version != NULL )
    {
      fprintf(fp, "    Version:    %s\n", pAppInfo->version);
    }
    if( pAppInfo->date != NULL )
    {
      fprintf(fp, "    Date:       %s\n", pAppInfo->date);
    }
    if( pAppInfo->maintainer != NULL )
    {
      fprintf(fp, "    Maintainer: %s\n", pAppInfo->maintainer);
    }
    fprintf(fp, "  }\n");
  }
  fprintf(fp, "}\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;
}