transport.h

sspi_workbench

#pragma once

#include "MessageProtection.h"
#include "SimpleThreadPool.h"

class Transport {
public:
    typedef SimpleThreadPool::WM_DISPATCH_FCN WM_DISPATCH_FCN;
    typedef void (*ERR_FCN)(const wchar_t*, bool, DWORD);

    static void Init(ERR_FCN errFcn);
    static void Shutdown();

    Transport(ERR_FCN errFcn, WM_DISPATCH_FCN wmDispatchFcn);
    virtual ~Transport();

    bool sendMessage(MsgProtection msgProtection, DWORD cbMsg, DWORD cbTotal, const void* pMsg);
    bool recvMessage(MsgProtection* pmsgProtection, DWORD* pcbMsg, DWORD* pcbTotal, void** ppMsg);

protected:
    void operator=(const Transport&); // not impl

    void _err(const wchar_t* psz, bool bRecoverable = false, DWORD err = WSAGetLastError()) {
        m_errFcn(psz, bRecoverable, err);
    }
    struct MessageHeader {
        DWORD magic;
        DWORD version;
        DWORD cbMsg;
        DWORD cbTotal;
        DWORD msgProtection;
    };
    enum JobTypes { jtSendMsg = 1, jtRecvMsg, _jtNext };
    
    struct SendMessageJob {
        SendMessageJob(DWORD _msgProtection, DWORD _cbMsg, DWORD _cbTotal, const void* _pMsg)
          : msgProtection(_msgProtection), cbMsg(_cbMsg), cbTotal(_cbTotal), pMsg(_pMsg)
        {}
        DWORD       msgProtection;
        DWORD       cbMsg;
        DWORD       cbTotal;
        const void* pMsg;
    };

    struct RecvMessageJob {
        RecvMessageJob(DWORD* _pmsgProtection, DWORD* _pcbMsg, DWORD* _pcbTotal, void** _ppMsg)
          : pmsgProtection(_pmsgProtection), pcbMsg(_pcbMsg), pcbTotal(_pcbTotal), ppMsg(_ppMsg)
        {}
        DWORD* pmsgProtection;
        DWORD* pcbMsg;
        DWORD* pcbTotal;
        void** ppMsg;
    };

    void _sendMessage(DWORD msgProtection, DWORD cbMsg, DWORD cbTotal, const void* pMsg);
    void _recvMessage(DWORD* pmsgProtection, DWORD* pcbMsg, DWORD* pcbTotal, void** ppMsg);

    static void _workerThreadProc(void* pCtx, int nType, void* pv);

    virtual void _handleJob(int nType, void* pv);

    DWORD _waitAndPumpMessages(DWORD cHandles, HANDLE* prgHandles);
    void _drainMessageQueue();

    const ERR_FCN            m_errFcn;
    const WM_DISPATCH_FCN    m_wmDispatchFcn;
    SOCKET                   m_socket;
    static SimpleThreadPool* s_pThreadPool;
};

class ClientTransport : public Transport {
public:
    ClientTransport(ERR_FCN errFcn, WM_DISPATCH_FCN wmDispatchFcn);
   ~ClientTransport();
    bool connect(const char* pszHostAddr, WORD port);
private:
    void operator=(const ClientTransport&); // not impl
};

class ServerTransport : public Transport {
public:
	ServerTransport(WORD port, ERR_FCN errFcn, WM_DISPATCH_FCN wmDispatchFcn);
   ~ServerTransport();

    bool listenAndAcceptSingleConnection();
private:
    void operator=(const ServerTransport&); // not impl
    enum JobTypes { jtListenAndAcceptSingleConnection = _jtNext };
    
    void _listenAndAcceptSingleConnection();
    void _handleJob(int nType, void* pv);

    const WORD m_port;     // native byte order
};