EchoLinkProxy.h

Go to the documentation of this file.

 
#ifndef ECHOLINK_PROXY_INCLUDED
#define ECHOLINK_PROXY_INCLUDED
 
 
/****************************************************************************
 *
 * System Includes
 *
 ****************************************************************************/
 
#include <string>
#include <sigc++/sigc++.h>
 
 
/****************************************************************************
 *
 * Project Includes
 *
 ****************************************************************************/
 
#include <AsyncTcpClient.h>
#include <AsyncTimer.h>
 
 
/****************************************************************************
 *
 * Local Includes
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Forward declarations
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Namespace
 *
 ****************************************************************************/
 
namespace EchoLink
{
 
 
/****************************************************************************
 *
 * Forward declarations of classes inside of the declared namespace
 *
 ****************************************************************************/
 
  
 
/****************************************************************************
 *
 * Defines & typedefs
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Exported Global Variables
 *
 ****************************************************************************/
 
 
 
/****************************************************************************
 *
 * Class definitions
 *
 ****************************************************************************/
 
class Proxy : public sigc::trackable
{
  public:
    typedef enum
    {
      STATE_DISCONNECTED, STATE_WAITING_FOR_DIGEST, STATE_CONNECTED
    } ProxyState;
 
    typedef enum
    {
      TCP_STATE_DISCONNECTED, TCP_STATE_DISCONNECTING, TCP_STATE_CONNECTING,
      TCP_STATE_CONNECTED
    } TcpState;
 
    static Proxy *instance(void) { return the_instance; }
 
    Proxy(const std::string &host, uint16_t port, const std::string &callsign,
          const std::string &password);
  
    ~Proxy(void);
  
    void connect(void);
 
    void disconnect(void);
    
    void reset(void);
 
    bool tcpOpen(const Async::IpAddress &remote_ip);
 
    bool tcpClose(void);
 
    TcpState tcpState(void) { return tcp_state; }
 
    bool tcpData(const void *data, unsigned len);
 
    bool udpData(const Async::IpAddress &addr, const void *data, unsigned len);
 
    bool udpCtrl(const Async::IpAddress &addr, const void *data, unsigned len);
 
    sigc::signal<void, bool> proxyReady;
 
    sigc::signal<void> tcpConnected;
 
    sigc::signal<void> tcpDisconnected;
 
    sigc::signal<int, void*, unsigned> tcpDataReceived;
 
    sigc::signal<void, const Async::IpAddress&, uint16_t, void*,
                 unsigned> udpDataReceived;
 
    sigc::signal<void, const Async::IpAddress&, uint16_t, void*,
                 unsigned> udpCtrlReceived;
 
    sigc::signal<void, uint32_t> tcpStatusReceived;
 
    sigc::signal<void> tcpCloseReceived;
 
  protected:
    
  private:
    typedef enum
    {
      MSG_TYPE_TCP_OPEN=1, MSG_TYPE_TCP_DATA, MSG_TYPE_TCP_CLOSE,
      MSG_TYPE_TCP_STATUS, MSG_TYPE_UDP_DATA, MSG_TYPE_UDP_CONTROL,
      MSG_TYPE_SYSTEM
    } MsgBlockType;
 
    static const int NONCE_SIZE         = 8;
    static const int MSG_HEADER_SIZE    = 1 + 4 + 4;
    static const int RECONNECT_INTERVAL = 10000;
    static const int CMD_TIMEOUT        = 10000;
    static const int recv_buf_size      = 16384;
 
    static Proxy *the_instance;
 
    Async::TcpClient<>  con;
    const std::string   callsign;
    std::string         password;
    ProxyState          state;
    TcpState            tcp_state;
    uint8_t             recv_buf[recv_buf_size];
    int                 recv_buf_cnt;
    Async::Timer        reconnect_timer;
    Async::Timer        cmd_timer;
 
    Proxy(const Proxy&);
    Proxy& operator=(const Proxy&);
    bool sendMsgBlock(MsgBlockType type,
                      const Async::IpAddress &remote_ip=Async::IpAddress(),
                      const void *data=0, unsigned len=0);
    void onConnected(void);
    int onDataReceived(Async::TcpConnection *con, void *data, int len);
    void onDisconnected(Async::TcpConnection *con,
        Async::TcpClient<>::DisconnectReason reason);
    void disconnectHandler(void);
    int handleAuthentication(const unsigned char *buf, int len);
    int parseProxyMessageBlock(unsigned char *buf, int len);
    void handleProxyMessageBlock(MsgBlockType type,
        const Async::IpAddress &remote_ip, uint32_t len,
        unsigned char *data);
    void handleTcpDataMsg(uint8_t *buf, int len);
    void handleTcpCloseMsg(const uint8_t *buf, int len);
    void handleTcpStatusMsg(const uint8_t *buf, int len);
    void handleUdpDataMsg(const Async::IpAddress &remote_ip, uint8_t *buf,
                          int len);
    void handleUdpCtrlMsg(const Async::IpAddress &remote_ip, uint8_t *buf,
                          int len);
    void handleSystemMsg(const unsigned char *buf, int len);
    void cmdTimeout(void);
    
};  /* class Proxy */
 
 
} /* namespace */
 
#endif /* ECHOLINK_PROXY_INCLUDED */
 
 
 
/*
 * This file has not been truncated
 */