BreakInSocket.h

Go to the documentation of this file.

#pragma once
#include <bzsnet/BufferedSocket.h>
#include <bzscore/sync.h>
#include <bzscore/thread.h>

namespace GDBServerFoundation
{
    class IBreakInTarget
    {
    public:
        virtual void OnBreakInRequest()=0;
    };


    class BreakInSocket
    {
    public:
        enum {kBreakInByte = 0x03};

    private:
        BazisLib::Network::TCPSocketEx *m_pSocket;

    private:
        BazisLib::MemberThread m_WorkerThread;
        BazisLib::Mutex m_RecvMutex;
        BazisLib::Semaphore m_Semaphore;
        bool m_bTerminating;

        IBreakInTarget *m_pTarget;

    private:
        int WorkerThreadBody()
        {
            BazisLib::MutexLocker lck(m_RecvMutex);
            while (!m_bTerminating)
            {
                size_t total = 0;
                void *pData = m_pSocket->PeekAbs(1, &total);
                if (!pData || !total || *((char *)pData) == kBreakInByte)
                {
                    if (total)
                        m_pSocket->Discard(pData, 1);

                    IBreakInTarget *pTarget = m_pTarget;
                    if (pTarget)
                    {
                        m_RecvMutex.Unlock();
                        pTarget->OnBreakInRequest();
                        m_RecvMutex.Lock();
                    }

                    continue;
                }

                m_RecvMutex.Unlock();
                m_Semaphore.Wait();
                m_RecvMutex.Lock();
            }
            return 0;
        }

    public:
        BreakInSocket(BazisLib::Network::TCPSocketEx *pSock)
            : m_pSocket(pSock)
            , m_WorkerThread(this, &BreakInSocket::WorkerThreadBody)
            , m_bTerminating(false)
            , m_pTarget(NULL)
        {
            m_WorkerThread.Start();
        }

        ~BreakInSocket()
        {
            m_bTerminating = true;
            m_Semaphore.Signal();
            m_WorkerThread.Join();
        }

        size_t Send(const void *pBuffer, size_t size)
        {
            return m_pSocket->Send(pBuffer, size);
        }

        void SetTarget(IBreakInTarget *pTarget)
        {
            m_pTarget = pTarget;
        }

        class SocketWrapper
        {
        private:
            BreakInSocket &m_Socket;

        public:
            SocketWrapper(BreakInSocket &sock)
                : m_Socket(sock)
            {
                m_Socket.m_RecvMutex.Lock();
            }

            BazisLib::Network::TCPSocketEx *operator->()
            {
                return m_Socket.m_pSocket;
            }

            ~SocketWrapper()
            {
                m_Socket.m_RecvMutex.Unlock();
                m_Socket.m_Semaphore.Signal();
            }
        };
    };
}