map/das-dn/inc/netproc.h

#ifndef _ZJD_NET_PROCESS_H_
#define _ZJD_NET_PROCESS_H_

#include "process.h"
#include <sys/uio.h>

#define MAX_CONN_COUNT  8
#define MAX_IOVEC_COUNT 1024

class CNetProcessItem : public CProcessItem
{
public:
    SOCKET  m_sock;
    DWORD   m_peer_addr;
    WORD    m_peer_port;

protected:
    BYTE    m_recv_data_buffer[MAX_NET_BUFFER_SIZE];
    int     m_recv_data_len;

    BYTE    m_send_data_buffer[MAX_NET_BUFFER_SIZE];
    int     m_send_data_len;

public:
    CNetProcessItem();
    virtual ~CNetProcessItem();

    virtual void Attach(int uid, int sock = -1, DWORD peer_addr = 0, WORD peer_port = 0);
    virtual void Release(void);           //释放相应的资源
    inline int GetSock(void) const
    {
        return ((int)m_sock);
    }

    inline int GetBufferSpace(void) const
    {
        return (MAX_NET_BUFFER_SIZE - m_recv_data_len);
    }

    inline int AppendBuffer(BYTE *pBuf, int count)
    {
        memcpy(&m_recv_data_buffer[m_recv_data_len], pBuf, count);
        m_recv_data_len += count;
        return m_recv_data_len;
    }

    inline BYTE *GetBuffer(void)
    {
        return m_recv_data_buffer;
    }

    inline int GetBufferLength(void) const
    {
        return m_recv_data_len;
    }

    inline int PopBuffer(int count)
    {
        if (m_recv_data_len < count) return -1;
        m_recv_data_len -= count;
        if (m_recv_data_len == 0) return 0;
        memcpy(m_recv_data_buffer, &m_recv_data_buffer[count], m_recv_data_len);
        return m_recv_data_len;
    }

    //int RecvFromNetwork(long timeout = -1);
    inline int WriteData(const BYTE* pBuf, int count, int ord = -1)
    {
        if (m_send_data_len + count > MAX_NET_BUFFER_SIZE)
        {
            //数据量大,将数据发送结束
            WriteToNetwork();
            //直接将数据发送结束。
            WriteToNetwork(pBuf, count);
        }
        else
        {
            memcpy(&m_send_data_buffer[m_send_data_len], (void *)pBuf, count);
            m_send_data_len += count;
        }

        return m_send_data_len;
    }
    inline int WriteToNetwork(void)
    {
        if (m_send_data_len > 0)
        {
            WriteToNetwork(m_send_data_buffer, m_send_data_len);
            m_send_data_len = 0;
        }

        return 0;
    }
    int WriteToNetwork(const BYTE* pBuf, int count);
    int ReadFromNetwork(BYTE* pBuf, int count);
};

class CNetProcess : public CProcess
{
//private:
public:
    SOCKET  m_sock;
    DWORD   last_addr;
    WORD    last_port;
//public:
    //以下变量须在今后变更为配置参数
    int     socket_type;            //socket类型，TCP - SOCK_STREAM, UDP - SOCK_DGRAM
    DWORD   bind_addr;              //本地绑定地址
    WORD    bind_port;              //本地绑定端口

    BOOLEAN ignored_source;         //忽略来源地址
    DWORD   target_addr;            //目标地址，对于UDP若target_addr != 0则发送报文送往target_addr，否则送往单元地址
    WORD    target_port;            //目标端口

    struNetWorkOption    network;
private:
    
public:
    CNetProcess();
    virtual ~CNetProcess();

    virtual BOOLEAN OnPreCreate(int id);
    virtual void Destroy(void);
    virtual BOOLEAN Run(void);
    virtual BOOLEAN OnTimer(void);
    virtual int OnPackageReceived(BYTE* pBuf, int count, int ord = -1);

    BOOLEAN isClient(void);
    BOOLEAN Connect(CNetProcessItem* pItem, int ord, BOOLEAN bDefault = FALSE);

    DWORD WriteData(const BYTE* pData, int count, int ord = -1);
#if 0
    DWORD ReadData(BYTE* pData, int count, int ord = -1);
#endif
    virtual CNetProcessItem *CreateItem(int ord);
    virtual void DestroyItem(int ord, BOOLEAN bDeleted = FALSE);    //bDeleted代表该对象是否已经被删除,用于在子类递归时防止重复删除对象
    inline virtual CNetProcessItem *GetItem(int ord) const
    {
        if (ord < 0 || ord >= PROCESS_UNIT_NUM) return NULL;
        return (CNetProcessItem *)m_pItems[ord];
    }

    inline virtual CNetProcessItem *GetCurItem(void) const
    {
        return (CNetProcessItem *)GetItem(GetCurOrder());
    }

    inline virtual CNetProcessItem *GetNextItem(void)
    {
        GetNextUnit();
        return (CNetProcessItem *)GetCurItem();
    }

    BOOLEAN net_socket_nonblock(SOCKET sock, BOOLEAN blocking);
#if 0
    int net__try_connect(const char *host, WORD port, SOCKET *sock, const char *bind_address, BOOLEAN blocking = FALSE);
    int net__try_connect_tcp(const char *host, WORD port, SOCKET *sock, const char *bind_address, BOOLEAN blocking = FALSE);
#endif
};



#endif //_ZJD_NET_PROCESS_H_