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
 */