bsproxy/bsproxy.h

Go to the documentation of this file.

////////////////////////////////////////////////////////////////////////////////
//
// Package:   botsense
//
// File:      bsproxy.h
//
/*! \file
 *
 * \version $LastChangedDate$ $Rev$
 *
 * \brief Botsense proxy IP server declarations.
 *
 * \author Robin Knight (robin.knight@roadnarrows.com)
 *
 * \par Copyright:
 * (C) 2007.  RoadNarrows LLC.
 * (http://www.roadnarrows.com)
 * \n All Rights Reserved
 */
// Permission is hereby granted, without written agreement and without
// license or royalty fees, to use, copy, modify, and distribute this
// software and its documentation for any purpose, provided that
// (1) The above copyright notice and the following two paragraphs
// appear in all copies of the source code and (2) redistributions
// including binaries reproduces these notices in the supporting
// documentation.   Substantial modifications to this software may be
// copyrighted by their authors and need not follow the licensing terms
// described here, provided that the new terms are clearly indicated in
// all files where they apply.
//
// IN NO EVENT SHALL THE AUTHOR, ROADNARROWS LLC, OR ANY MEMBERS/EMPLOYEES
// OF ROADNARROW LLC OR DISTRIBUTORS OF THIS SOFTWARE BE LIABLE TO ANY
// PARTY FOR DIRECT, INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL
// DAMAGES ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION,
// EVEN IF THE AUTHORS OR ANY OF THE ABOVE PARTIES HAVE BEEN ADVISED OF
// THE POSSIBILITY OF SUCH DAMAGE.
//
// THE AUTHOR AND ROADNARROWS LLC SPECIFICALLY DISCLAIM ANY WARRANTIES,
// INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
// FITNESS FOR A PARTICULAR PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN
// "AS IS" BASIS, AND THE AUTHORS AND DISTRIBUTORS HAVE NO OBLIGATION TO
// PROVIDE MAINTENANCE, SUPPORT, UPDATES, ENHANCEMENTS, OR MODIFICATIONS.
//
////////////////////////////////////////////////////////////////////////////////

#include <pthread.h>

#include "rnr/rnrconfig.h"
#include "rnr/log.h"
#include "rnr/sock.h"
#include "rnr/sockset.h"

#include "rcb3/rcb3lib.h"


//-----------------------------------------------------------------------------
// Data Types and Defines
//-----------------------------------------------------------------------------

/*!
 * BotSense Proxy Limits
 */
#define BSPROXY_CLIENT_DEV_MAX  8 ///< max. num of proxied devices per client
#define BSPROXY_REG_CLIENT_MAX  8 ///< max. num of simultaneous reg. clients

/*!
 * Device Classes
 */
#define BSPROXY_DEVCLASS_NONE   0 ///< no device
#define BSPROXY_DEVCLASS_I2C    1 ///< shared I2C bus
#define BSPROXY_DEVCLASS_SER    2 ///< point-to-point serial
#define BSPROXY_DEVCLASS_SWR    3 ///< software resource
#define BSPROXY_DEVCLASS_RCB3   4 ///< RCB-3 

/*!
 * Generic I2C proxied device
 */
typedef struct
{
  int           m_fd;                 ///< opened device descriptor
} BsProxyDevI2C_T;

/*!
 * Generic RS-232 proxied device
 */
typedef struct
{
  int           m_fd;         ///< opened device descriptor
  int           m_nBaudRate;  ///< baud rate
  int           m_nByteSize;  ///< byte size
  char          m_cParity;    ///< parity
  int           m_nStopBits;  ///< stop bits
  bool_t        m_bRtsCts;    ///< hardware flow control
  bool_t        m_bXonXoff;   ///< software flow control
} BsProxyDevRS232_T;

/*!
 * RCB-3 robot controller RS-232 proxied device
 */
typedef struct
{
  handle_t      m_nHandle;    ///< libRCB3 created interface handle
} BsProxyDevRCB3_T;

/*!
 * BotSense Proxied Device Control Block Structure
 */
typedef struct
{
  const char       *m_sDevName;     ///< device name
  int               m_eDevClass;    ///< device class
  int               m_nDevRefCnt;   ///< reference count
  pthread_mutex_t   m_mutDev;       ///< shared device mutex
  union
  {
    BsProxyDevI2C_T     i2c;
    BsProxyDevRS232_T   rs232;
    BsProxyDevRCB3_T    rcb3;
  } m_unDevSpec;                    ///< specific proxied device data
} BsProxyDev_T;

/*!
 * BotSense Proxy Client Device Info
 */
typedef struct
{
  int           m_eDevType;   ///< device type
  BsProxyDev_T *m_pProxDev;   ///< proxied device 
  uint_t        m_i2cAddr;    ///< BrainPack I2C device address
} BsProxyClientDev_T;

/*!
 * BotSense Proxy Client Control Block Structure
 */
typedef struct
{
  const char         *m_sClientName;            ///< client's (remote) name
  Socket_T           *m_pClientSock;            ///< client opened TCP socket
  BsProxyClientDev_T  m_tblClientDev[BSPROXY_CLIENT_DEV_MAX];
                                                ///< client's proxied devices
} BsProxyClient_T;


/*!
 * BotSense Proxy Server Control Block Structure
 */
typedef struct
{
  const char       *m_sServerName;                  ///< server's name
  int               m_nServerPort;                  ///< server's listener port
  SockSet_T        *m_pServerSockSet;               ///< server socket set
  Socket_T         *m_pServerSockListener;          ///< server listener socket
  int               m_nServerRegClientCount;        ///< num of reg. clients
  BsProxyClient_T  *m_pServerRegClient[FD_SETSIZE]; ///< registered clients
} BsProxyServer_T;


//-----------------------------------------------------------------------------
// Command Logging and Checking Macros
//-----------------------------------------------------------------------------

/*!
 * \brief Log command invocation.
 *
 * \param pClient   BotSense client.
 * \param bufCmd    Received command buffer.
 * \param lenCmd    Received command length (number of bytes).
 */
#define BSPROXY_LOG_CMD(pClient, bufCmd, lenCmd) \
  LOGDIAG2("%s: %s(msgid=0x%02x, tid=%u, blen=%u)", \
      pClient->m_sClientName, LOGFUNCNAME, \
      (uint_t)bufCmd[BSPROXY_CMD_HDR_MSGID_IDX], \
      (uint_t)bufCmd[BSPROXY_CMD_HDR_TID_IDX], \
      (uint_t)bufCmd[BSPROXY_CMD_HDR_BLEN_IDX])

/*!
 * \brief Log device specific command invocation.
 *
 * \param pClient   BotSense client.
 * \param bufCmd    Received command buffer.
 * \param lenCmd    Received command length (number of bytes).
 */
#define BSPROXY_LOG_DEV_CMD(pClient, bufCmd, lenCmd) \
  LOGDIAG2("%s: %s(msgid=0x%02x, tid=%u, blen=%u, cmdid=0x%02x)", \
      pClient->m_sClientName, LOGFUNCNAME, \
      (uint_t)bufCmd[BSPROXY_CMD_HDR_MSGID_IDX], \
      (uint_t)bufCmd[BSPROXY_CMD_HDR_TID_IDX] ,\
      (uint_t)bufCmd[BSPROXY_CMD_HDR_BLEN_IDX], \
      (uint_t)bufCmd[BSPROXY_CMD_HDR_LEN+1])

/*!
 * \brief Check that length of command body equals the expected value.
 *
 * Automatically returns from embedding function if false.
 *
 * \param pClient   BotSense client.
 * \param bufCmd    Received command buffer.
 * \param lenValid  Expected length (number of bytes).
 */
#define chkCmdBLenEQ(pClient, bufCmd, lenValid) \
  {if( bufCmd[BSPROXY_CMD_HDR_BLEN_IDX] != lenValid ) \
  { \
    LOGERROR("%s: lenBody=%u != lenValid=%u: bad command body length", \
        pClient->m_sClientName, (uint_t)bufCmd[BSPROXY_CMD_HDR_BLEN_IDX], \
        (uint_t)(lenValid)); \
    return ClientSendFailRsp(pClient, bufCmd, "%u: bad command body length", \
        (uint_t)bufCmd[BSPROXY_CMD_HDR_BLEN_IDX]); \
  }}

/*!
 * \brief Check that length of command body is greater than or equal the
 * minimum value.
 *
 * Automatically returns from embedding function if false.
 *
 * \param pClient   BotSense client.
 * \param bufCmd    Received command buffer.
 * \param lenMin    Expected minimum length (number of bytes).
 */
#define chkCmdBLenGE(pClient, bufCmd, lenMin) \
  {if( bufCmd[BSPROXY_CMD_HDR_BLEN_IDX] < lenMin ) \
  { \
    LOGERROR("%s: lenBody=%u < lenMin=%u: bad command body length", \
        pClient->m_sClientName, (uint_t)bufCmd[BSPROXY_CMD_HDR_BLEN_IDX], \
        (uint_t)(lenMin)); \
    return ClientSendFailRsp(pClient, bufCmd, "%u: bad command body length", \
        (uint_t)bufCmd[BSPROXY_CMD_HDR_BLEN_IDX]); \
  }}


//-----------------------------------------------------------------------------
// Byte Stream Parameter Packing/Unpacking Functions
//-----------------------------------------------------------------------------

/*!
 * \brief Pack lower 16 bits into the next 2 bytes of the byte stream.
 * \param uVal Value to pack.
 * \param bytes[] Output byte stream.
 * \return Returns number of bytes packed.
 */
INLINE_IN_H int BSPACK16(uint_t uVal, byte_t bytes[/*2+*/])
{
  bytes[0] = (byte_t)((uVal >> 8) & 0xFF);    
  bytes[1] = (byte_t)(uVal & 0xFF);
  return 2;
}

/*!
 * \brief Unpack the next 2 bytes from the byte stream into lower 16 bits.
 * \param bytes[] Input byte stream.
 * \param pVal Output unpacked value. 
 * \return Returns number of bytes unpacked.
 */
INLINE_IN_H int BSUNPACK16(byte_t bytes[/*2+*/], uint_t *pVal)
{
  *pVal = (uint_t)((((uint_t)bytes[0]) << 8) + (uint_t)bytes[1]);
  return 2;
}

/*!
 * \brief Pack lower 32 bits into the next 4 bytes of the byte stream.
 * \param uVal Value to pack.
 * \param bytes[] Output byte stream.
 * \return Returns number of bytes packed.
 */
INLINE_IN_H int BSPACK32(uint_t uVal, byte_t bytes[/*4+*/])
{
  bytes[0] = (byte_t)((uVal >> 24) & 0xFF);    
  bytes[1] = (byte_t)((uVal >> 16) & 0xFF);    
  bytes[2] = (byte_t)((uVal >>  8) & 0xFF);    
  bytes[3] = (byte_t)(uVal & 0xFF);
  return 4;
}

/*!
 * \brief Unpack the next 4 bytes from the byte stream into lower 32 bits.
 * \param bytes[] Input byte stream.
 * \param pVal Output unpacked value. 
 * \return Returns number of bytes unpacked.
 */
INLINE_IN_H int BSUNPACK32(byte_t bytes[/*4+*/], uint_t *pVal)
{
  *pVal = (uint_t)((((uint_t)bytes[0]) << 24) + 
          (uint_t)(((uint_t)bytes[1]) << 16) + 
          (uint_t)(((uint_t)bytes[2]) <<  8) + 
          (uint_t)bytes[1]);
  return 4;
}


//-----------------------------------------------------------------------------
// Proxied Devices Prototypes
//-----------------------------------------------------------------------------

extern BsProxyDev_T *ProxDevOpen(int eDevType, const char *sDevName);

extern void ProxDevClose(BsProxyDev_T *pProxDev);

extern int ProxDevI2CScan(BsProxyDev_T *pProxDev,
                          byte_t bufScan[], size_t sizeBuf);

extern int ProxDevI2CTrans(BsProxyDev_T *pProxDev, uint_t i2cAddr,
                    byte_t bufWrite[], size_t countWrite,
                    byte_t bufRead[], size_t countRead);

extern int ProxDevI2CWrite(BsProxyDev_T *pProxDev, uint_t i2cAddr,
                    byte_t bufWrite[], size_t countWrite);

extern int ProxDevI2CRead(BsProxyDev_T *pProxDev, uint_t i2cAddr,
                   byte_t bufRead[], size_t countRead);

extern int ProxDevRCB3Read(BsProxyDev_T *pProxDev,
                    byte_t bufRead[], size_t countRead);

extern int ProxDevRCB3Write(BsProxyDev_T *pProxDev,
                    byte_t bufWrite[], size_t countWrite);

extern int ProxDevRCB3Trans(BsProxyDev_T *pProxDev,
                      byte_t bufWrite[], size_t countWrite,
                      byte_t bufRead[], size_t countRead);


//-----------------------------------------------------------------------------
// Client General Support Prototypes
//-----------------------------------------------------------------------------

extern int ClientDispatch(BsProxyServer_T *pServer, BsProxyClient_T *pClient,
                          byte_t bufCmd[], size_t lenCmd);

extern int ClientSendPassRsp(BsProxyClient_T *pClient, byte_t bufCmd[],
                             byte_t bufRsp[], size_t lenRsp);

extern int ClientSendFailRsp(BsProxyClient_T *pClient, byte_t bufCmd[],
                             const char *sErrFmt, ...);

extern BsProxyClient_T *ClientNew(Socket_T *pSockClient);

extern void ClientDelete(BsProxyClient_T *pClient);


//-----------------------------------------------------------------------------
// Proxied Device Specific SubDispather Prototypes
//-----------------------------------------------------------------------------

extern int BPFootDispatch(BsProxyServer_T *pServer, BsProxyClient_T *pClient,
                        BsProxyClientDev_T *pDev,
                        byte_t bufCmd[], size_t lenCmd);

extern int BPIMUDispatch(BsProxyServer_T *pServer, BsProxyClient_T *pClient,
                        BsProxyClientDev_T *pDev,
                        byte_t bufCmd[], size_t lenCmd);

extern int RCB3Dispatch(BsProxyServer_T *pServer, BsProxyClient_T *pClient,
                        BsProxyClientDev_T *pDev,
                        byte_t bufCmd[], size_t lenCmd);

---