HdlcdClient.h

Go to the documentation of this file.

#ifndef HDLCD_CLIENT_H
#define HDLCD_CLIENT_H

#include <boost/asio.hpp>
#include <vector>
#include <string>
#include "HdlcdPacketEndpoint.h"
#include "HdlcdSessionHeader.h"
#include "HdlcdPacketData.h"
#include "HdlcdPacketCtrl.h"
#include "FrameEndpoint.h"

class HdlcdClient {
public:
    HdlcdClient(boost::asio::io_service& a_IOService, const std::string &a_SerialPortName, HdlcdSessionDescriptor a_HdlcdSessionDescriptor):
        m_IOService(a_IOService),
        m_SerialPortName(a_SerialPortName),
        m_HdlcdSessionDescriptor(a_HdlcdSessionDescriptor),
        m_bClosed(false),
        m_TcpSocketData(a_IOService),
        m_TcpSocketCtrl(a_IOService),
        m_eTcpSocketDataState(SOCKET_STATE_ERROR),
        m_eTcpSocketCtrlState(SOCKET_STATE_ERROR) {
    }
    
    void AsyncConnect(boost::asio::ip::tcp::resolver::iterator a_EndpointIterator, std::function<void(bool a_bSuccess)> a_OnConnectedCallback) {
        // Checks
        assert(a_OnConnectedCallback);
        assert(m_eTcpSocketDataState == SOCKET_STATE_ERROR); // not tried yet, or retrying
        assert(m_eTcpSocketCtrlState == SOCKET_STATE_ERROR); // not tried yet, or retrying

        // Connect the data socket
        m_OnConnectedCallback = a_OnConnectedCallback;
        m_eTcpSocketDataState = SOCKET_STATE_CONNECTING;
        boost::asio::async_connect(m_TcpSocketData, a_EndpointIterator, [this](boost::system::error_code a_ErrorCode, boost::asio::ip::tcp::resolver::iterator) {
            if (a_ErrorCode == boost::asio::error::operation_aborted) return;
            if (a_ErrorCode) {
                OnTcpSocketDataConnected(false);
            } else {
                OnTcpSocketDataConnected(true);
            } // else
        });
        
        // Connect the control socket
        m_eTcpSocketCtrlState = SOCKET_STATE_CONNECTING;
        boost::asio::async_connect(m_TcpSocketCtrl, a_EndpointIterator, [this](boost::system::error_code a_ErrorCode, boost::asio::ip::tcp::resolver::iterator) {
            if (a_ErrorCode == boost::asio::error::operation_aborted) return;
            if (a_ErrorCode) {
                OnTcpSocketCtrlConnected(false);
            } else {
                OnTcpSocketCtrlConnected(true);
            } // else
        });
    }

    ~HdlcdClient() {
        m_OnDataCallback   = nullptr;
        m_OnCtrlCallback   = nullptr;
        m_OnClosedCallback = nullptr;
        Close();
    }

    void Shutdown() {
        if (m_PacketEndpointData) {
            m_PacketEndpointData->Shutdown();
        } // if
        
        if (m_PacketEndpointCtrl) {
            m_PacketEndpointCtrl->Shutdown();
        } // if
    }

    void Close() {
        if (m_bClosed == false) {
            m_bClosed = true;
            if (m_PacketEndpointData) {
                m_PacketEndpointData->Close();
                m_PacketEndpointData.reset();
            } else {
                m_TcpSocketData.cancel();
                m_TcpSocketData.close();
            } // else
            
            if (m_PacketEndpointCtrl) {
                m_PacketEndpointCtrl->Close();
                m_PacketEndpointCtrl.reset();
            } else {
                m_TcpSocketCtrl.cancel();
                m_TcpSocketCtrl.close();
            } // else
            
            if (m_OnClosedCallback) {
                m_OnClosedCallback();
            } // if
        } // if
    }
    
    void SetOnDataCallback(std::function<void(const HdlcdPacketData& a_PacketData)> a_OnDataCallback) {
        m_OnDataCallback = a_OnDataCallback;
    }
    
    void SetOnCtrlCallback(std::function<void(const HdlcdPacketCtrl& a_PacketCtrl)> a_OnCtrlCallback) {
        m_OnCtrlCallback = a_OnCtrlCallback;
    }
    
    void SetOnClosedCallback(std::function<void()> a_OnClosedCallback) {
        m_OnClosedCallback = a_OnClosedCallback;
    }
    
    bool Send(const HdlcdPacketData& a_PacketData, std::function<void()> a_OnSendDoneCallback = nullptr) {
        bool l_bRetVal = false;
        if (m_PacketEndpointData) {
            l_bRetVal = m_PacketEndpointData->Send(a_PacketData, a_OnSendDoneCallback);
        } else {
            if (a_OnSendDoneCallback) {
                m_IOService.post([a_OnSendDoneCallback](){ a_OnSendDoneCallback(); });
            } // if
        } // else
        
        return l_bRetVal;
    }

    bool Send(const HdlcdPacketCtrl& a_PacketCtrl, std::function<void()> a_OnSendDoneCallback = nullptr) {
        bool l_bRetVal = false;
        if (m_PacketEndpointCtrl) {
            l_bRetVal= m_PacketEndpointCtrl->Send(a_PacketCtrl, a_OnSendDoneCallback);
        } else {
            if (a_OnSendDoneCallback) {
                m_IOService.post([a_OnSendDoneCallback](){ a_OnSendDoneCallback(); });
            } // if
        } // else

        return l_bRetVal;
    }
    
private:
    void OnTcpSocketDataConnected(bool l_bSuccess) {
        // Checks
        assert(m_eTcpSocketDataState == SOCKET_STATE_CONNECTING);
        if (l_bSuccess) {
            m_eTcpSocketDataState = SOCKET_STATE_CONNECTED;
        } else {
            m_eTcpSocketDataState = SOCKET_STATE_ERROR;
    } // else
        
        OnTcpSocketConnected();
    }

    void OnTcpSocketCtrlConnected(bool l_bSuccess) {
        // Checks
        assert(m_eTcpSocketCtrlState == SOCKET_STATE_CONNECTING);
        if (l_bSuccess) {
            m_eTcpSocketCtrlState = SOCKET_STATE_CONNECTED;
        } else {
            m_eTcpSocketCtrlState = SOCKET_STATE_ERROR;
    } // else
        
        OnTcpSocketConnected();
    }
    
    void OnTcpSocketConnected() {
        // Checks
        if ((m_eTcpSocketDataState == SOCKET_STATE_CONNECTING) && (m_eTcpSocketCtrlState == SOCKET_STATE_CONNECTING)) {
            // Invalid state
            assert(false);
            return;
        } // if
        
        if ((m_eTcpSocketDataState == SOCKET_STATE_CONNECTED) && (m_eTcpSocketCtrlState == SOCKET_STATE_CONNECTED)) {
            // Success!
            // Create and start the packet endpoint for the exchange of user data packets
            m_PacketEndpointData = std::make_shared<HdlcdPacketEndpoint>(m_IOService, std::make_shared<FrameEndpoint>(m_IOService, m_TcpSocketData));
            m_PacketEndpointData->SetOnDataCallback([this](std::shared_ptr<const HdlcdPacketData> a_PacketData){ return OnDataReceived(a_PacketData); });
            m_PacketEndpointData->SetOnClosedCallback([this](){ OnClosed(); });
            m_PacketEndpointData->Start();
            m_PacketEndpointData->Send(HdlcdSessionHeader::Create(m_HdlcdSessionDescriptor, m_SerialPortName));
            
            // Create and start the packet endpoint for the exchange of control packets
            m_PacketEndpointCtrl = std::make_shared<HdlcdPacketEndpoint>(m_IOService, std::make_shared<FrameEndpoint>(m_IOService, m_TcpSocketCtrl));
            m_PacketEndpointCtrl->SetOnCtrlCallback([this](const HdlcdPacketCtrl& a_PacketCtrl){ return OnCtrlReceived(a_PacketCtrl); });
            m_PacketEndpointCtrl->SetOnClosedCallback([this](){ OnClosed(); });
            m_PacketEndpointCtrl->Start();
            m_PacketEndpointCtrl->Send(HdlcdSessionHeader::Create(HdlcdSessionDescriptor(SESSION_TYPE_TRX_STATUS, SESSION_FLAGS_NONE), m_SerialPortName));
            m_OnConnectedCallback(true);
            return;
        } // if
        
        if ((m_eTcpSocketDataState == SOCKET_STATE_CONNECTING) || (m_eTcpSocketCtrlState == SOCKET_STATE_CONNECTING)) {
            // Needs to wait for the second socket
            return;
        } // if
        
        
        if (m_eTcpSocketDataState == SOCKET_STATE_CONNECTED) {
            // The control socket failed after the data socket succeeded
            assert(m_eTcpSocketCtrlState == SOCKET_STATE_ERROR);
            m_eTcpSocketDataState = SOCKET_STATE_ERROR;
            m_TcpSocketData.close();
            m_OnConnectedCallback(false);
            return;
        } // else if
        
        if (m_eTcpSocketCtrlState == SOCKET_STATE_CONNECTED) {
            // The data socket failed after the control socket succeeded
            assert(m_eTcpSocketDataState == SOCKET_STATE_ERROR);
            m_eTcpSocketCtrlState = SOCKET_STATE_ERROR;
            m_TcpSocketCtrl.close();
            m_OnConnectedCallback(false);
            return;
        } // else if
        
        // Both sockets failed
        assert(m_eTcpSocketDataState == SOCKET_STATE_ERROR);
        assert(m_eTcpSocketCtrlState == SOCKET_STATE_ERROR);
        m_OnConnectedCallback(false);
        return;
    }
    
    bool OnDataReceived(std::shared_ptr<const HdlcdPacketData> a_PacketData) {
        if (m_OnDataCallback) {
            m_OnDataCallback(*(a_PacketData.get()));
        } // if
        
        return true; // Do not stall the receiver
    }

    void OnCtrlReceived(const HdlcdPacketCtrl& a_PacketCtrl) {
        if (m_OnCtrlCallback) {
            m_OnCtrlCallback(a_PacketCtrl);
        } // if
    }

    void OnClosed() {
        Close();
    }
    
    // Members
    boost::asio::io_service& m_IOService; 
    const std::string m_SerialPortName; 
    const HdlcdSessionDescriptor m_HdlcdSessionDescriptor; 
    bool m_bClosed; 
    
    std::function<void(bool a_bSuccess)> m_OnConnectedCallback;
    boost::asio::ip::tcp::socket m_TcpSocketData; 
    boost::asio::ip::tcp::socket m_TcpSocketCtrl; 
    typedef enum {
        SOCKET_STATE_ERROR      = 0,
        SOCKET_STATE_CONNECTING = 1,
        SOCKET_STATE_CONNECTED  = 2,
    } E_SOCKET_STATE;
    E_SOCKET_STATE m_eTcpSocketDataState; 
    E_SOCKET_STATE m_eTcpSocketCtrlState; 
    
    std::shared_ptr<HdlcdPacketEndpoint> m_PacketEndpointData; 
    std::shared_ptr<HdlcdPacketEndpoint> m_PacketEndpointCtrl; 
    
    // All possible callbacks for a user of this class
    std::function<void(const HdlcdPacketData&)> m_OnDataCallback; 
    std::function<void(const HdlcdPacketCtrl&)> m_OnCtrlCallback; 
    std::function<void()> m_OnClosedCallback;  
};

#endif // HDLCD_CLIENT_H