/*******************************************************************************
 * File Name         : Socket.c
 * Description       :
 * Created on        : 2018Äê5ÔÂ17ÈÕ
 * Author            : www.hido-studio.com
 *******************************************************************************/

/*******************************************************************************
 *                              Include Files                                  *
 *******************************************************************************/
#include "string.h"
#include "Socket.h"
#include "HIDO_Util.h"
#include "HIDO_Debug.h"
#include "HIDO_ArraryQueue.h"

/*******************************************************************************
 *                                  Macro                                      *
 *******************************************************************************/
/* SOICKETÏà¹Ø */
#define SOCKET_SEND_QUEUE_BUF_SIZE                    (512)
#define SOCKET_RECV_QUEUE_BUF_SIZE                    (2000)
#define SOCKET_SEND_QUEUE_MEMBER_CNT                  16
#define SOCKET_RECV_QUEUE_MEMBER_CNT                  16

/*******************************************************************************
 *                             Type Definition                                 *
 *******************************************************************************/

typedef struct
{
    E_SocketState m_eState;
    E_SocketType m_eType;
    HIDO_BOOL m_bHasRecvData;
    HIDO_INT32 m_i32ID;
    FN_SocketEventProc m_fnEventProc;
    HIDO_VOID *m_pArg;

    HIDO_CHAR m_acRemoteAddr[42];
    HIDO_UINT16 m_u16RemotePort;

    HIDO_VLQStruct m_stSendQueue;
    HIDO_VLQStruct m_stRecvQueue;
    HIDO_ArraryQueueStruct m_stRecvInfoQueue;
    HIDO_ArraryQueueStruct m_stTCPRecvQueue;

    HIDO_UINT8 l_au8SendQueueBuf[SOCKET_SEND_QUEUE_BUF_SIZE];
    HIDO_UINT8 l_au8RecvQueueBuf[SOCKET_RECV_QUEUE_BUF_SIZE];

    HIDO_BOOL m_bUseHeartbeat;
    HIDO_UINT32 m_u32HeartbeatFreq;
    HIDO_CHAR m_acHeartbeatData[128];
}ST_SocketData;

/*******************************************************************************
 *                             Local Variable                                  *
 *******************************************************************************/
static ST_SocketData l_astSocketData[SOCKET_NUM];

/*******************************************************************************
 *                        Local Function Declaration                           *
 *******************************************************************************/

/*******************************************************************************
 *                             Local Function                                  *
 *******************************************************************************/

/*******************************************************************************
 *                             Global Function                                 *
 *******************************************************************************/
/*******************************************************************************
 * Function Name     : Socket_HaveRecvData
 * Description       : ֪ͨSocketÓÐÊý¾ÝÐèÒª½ÓÊÕ
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_HaveRecvData(HIDO_INT32 _i32SockID)
{
    if(_i32SockID < SOCKET_NUM)
    {
        l_astSocketData[_i32SockID].m_bHasRecvData = HIDO_TRUE;

        return HIDO_OK;
    }

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : Socket_NoRecvData
 * Description       : ֪ͨSocketûÓÐÊý¾ÝÐèÒª½ÓÊÕ
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_NoRecvData(HIDO_INT32 _i32SockID)
{
    if(_i32SockID < SOCKET_NUM)
    {
        l_astSocketData[_i32SockID].m_bHasRecvData = HIDO_FALSE;

        return HIDO_OK;
    }

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : Socket_HasRecvData
 * Description       : »ñÈ¡SocketÊÇ·ñÓÐÊý¾ÝÐèÒª½ÓÊÕ
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : HIDO_TRUE ÓÐÊý¾ÝÐèÒª½ÓÊÕ, HIDO_FALSE ûÓÐÊý¾ÝÐèÒª½ÓÊÕ
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_BOOL Socket_HasRecvData(HIDO_INT32 _i32SockID)
{
    if(_i32SockID < SOCKET_NUM)
    {
        return l_astSocketData[_i32SockID].m_bHasRecvData;
    }

    return HIDO_FALSE;
}

/*******************************************************************************
 * Function Name     : Socket_GetSocketRecvQueue
 * Description       : »ñÈ¡Socket½ÓÊÕ¶ÓÁÐ
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : Socket½ÓÊÕ¶ÓÁÐ
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_VLQStruct *Socket_GetSocketRecvQueue(HIDO_INT32 _i32SockID)
{
    if(_i32SockID < SOCKET_NUM)
    {
        return &l_astSocketData[_i32SockID].m_stRecvQueue;
    }

    return HIDO_NULL;
}

/*******************************************************************************
 * Function Name     : Socket_GetSocketSendQueue
 * Description       : »ñÈ¡Socket·¢ËͶÓÁÐ
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : Socket·¢ËͶÓÁÐ
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_VLQStruct *Socket_GetSocketSendQueue(HIDO_INT32 _i32SockID)
{
    if(_i32SockID < SOCKET_NUM)
    {
        return &l_astSocketData[_i32SockID].m_stSendQueue;
    }

    return HIDO_NULL;
}

/*******************************************************************************
 * Function Name     : Socket_GetType
 * Description       : »ñÈ¡SockeÀàÐÍ
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : SockeÀàÐÍ
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
E_SocketType Socket_GetType(HIDO_INT32 _i32SockID)
{
    if(_i32SockID < SOCKET_NUM)
    {
        return l_astSocketData[_i32SockID].m_eType;
    }

    return SOCKET_TYPE_NONE;
}

/*******************************************************************************
 * Function Name     : Socket_GetSocketState
 * Description       : »ñÈ¡SockeÄÚ²¿×´Ì¬
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : SockeÄÚ²¿×´Ì¬
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
E_SocketState Socket_GetSocketState(HIDO_INT32 _i32SockID)
{
    if(_i32SockID < SOCKET_NUM)
    {
        return l_astSocketData[_i32SockID].m_eState;
    }

    return SOCKET_STATE_IDLE;
}

/*******************************************************************************
 * Function Name     : Socket_SetSocketState
 * Description       : ÉèÖÃSockeÄÚ²¿×´Ì¬
 * Input             : _i32Sock SocketÃèÊö·û
 *                   : _eState SockeÄÚ²¿×´Ì¬
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_SetSocketState(HIDO_INT32 _i32SockID, E_SocketState _eState)
{
    if(_i32SockID < SOCKET_NUM)
    {
        l_astSocketData[_i32SockID].m_eState = _eState;

        return HIDO_OK;
    }

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : Socket_GetRemoteAddr
 * Description       : »ñÈ¡SocketÔ¶³ÌµØÖ·
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : Ô¶³ÌµØÖ·
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_CHAR *Socket_GetRemoteAddr(HIDO_INT32 _i32SockID)
{
    if(_i32SockID < SOCKET_NUM)
    {
        return l_astSocketData[_i32SockID].m_acRemoteAddr;
    }

    return "";
}

/*******************************************************************************
 * Function Name     : Socket_GetRemotePort
 * Description       : »ñÈ¡SocketÔ¶³Ì¶Ë¿Ú
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : Ô¶³Ì¶Ë¿Ú
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_UINT16 Socket_GetRemotePort(HIDO_INT32 _i32SockID)
{
    if(_i32SockID < SOCKET_NUM)
    {
        return l_astSocketData[_i32SockID].m_u16RemotePort;
    }

    return 0;
}

/*******************************************************************************
 * Function Name     : Socket_RecvAll
 * Description       : È«²¿SocketÐèÒª½ÓÊÕÊý¾ÝµÄ֪ͨ
 * Input             : None
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_RecvAll(void)
{
    HIDO_INT32 i32SockID = 0;
    ST_SocketData *pstSocketData = HIDO_NULL;

    for(i32SockID = 0; i32SockID < SOCKET_NUM; i32SockID++)
    {
        pstSocketData = &l_astSocketData[i32SockID];
        if(pstSocketData != HIDO_NULL && SOCKET_STATE_CONNECTED == pstSocketData->m_eState)
        {
            pstSocketData->m_bHasRecvData = HIDO_TRUE;
        }
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_ClosedAll
 * Description       : È«²¿Socket±»¶Ï¿ªµÄ֪ͨ
 * Input             : None
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_ClosedAll(void)
{
    HIDO_INT32 i32SockID = 0;
    ST_SocketData *pstSocketData = HIDO_NULL;

    for(i32SockID = 0; i32SockID < SOCKET_NUM; i32SockID++)
    {
        pstSocketData = &l_astSocketData[i32SockID];

        switch (pstSocketData->m_eState)
        {
            case SOCKET_STATE_CONNECT:
            case SOCKET_STATE_CLOSE_BEFORE_CONNECT:
            case SOCKET_STATE_CONNECTED:
            {
                pstSocketData->m_bHasRecvData = HIDO_FALSE;
                pstSocketData->m_eState = SOCKET_STATE_CLOSED;

                if (pstSocketData->m_fnEventProc != HIDO_NULL)
                {
                    pstSocketData->m_fnEventProc(i32SockID, SOCKET_EVENT_CLOSED, pstSocketData->m_pArg);
                }
                break;
            }
            default:
            {
                break;
            }
        }
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_OnConnectFailed
 * Description       : SocketÁ¬½Óʧ°ÜʱµÄÄÚ²¿Í¨Öª
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_OnConnectFailed(HIDO_INT32 _i32SockID)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || pstSocketData == HIDO_NULL)
    {
        return HIDO_ERR;
    }

    pstSocketData->m_eState = SOCKET_STATE_CONNECT_FAILED;
    if(pstSocketData->m_fnEventProc != HIDO_NULL)
    {
        pstSocketData->m_fnEventProc(_i32SockID, SOCKET_EVENT_CONNECT_FAILED, pstSocketData->m_pArg);
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_OnConnected
 * Description       : SocketÁ¬½Ó³É¹¦Ê±µÄÄÚ²¿Í¨Öª
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_OnConnected(HIDO_INT32 _i32SockID)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || pstSocketData == HIDO_NULL)
    {
        return HIDO_ERR;
    }

    pstSocketData->m_eState = SOCKET_STATE_CONNECTED;

    /* ÖØÖöÓÁÐ */
#if 0
    HIDO_VLQInit(&pstSocketData->m_stSendQueue, pstSocketData->l_au8SendQueueBuf,
            SOCKET_SEND_QUEUE_BUF_SIZE, SOCKET_SEND_QUEUE_MEMBER_CNT);
    if(SOCKET_TYPE_TCP == pstSocketData->m_eType)
    {
        HIDO_ArraryQueueInit(&pstSocketData->m_stTCPRecvQueue, pstSocketData->l_au8RecvQueueBuf,
                SOCKET_RECV_QUEUE_BUF_SIZE, sizeof(HIDO_UINT8));
    }
    else
    {
        HIDO_VLQInit(&pstSocketData->m_stRecvQueue, pstSocketData->l_au8RecvQueueBuf,
                SOCKET_RECV_QUEUE_BUF_SIZE, SOCKET_RECV_QUEUE_MEMBER_CNT);
    }
#endif
		
    /* ֪ͨÉϲã */
    if(pstSocketData->m_fnEventProc != HIDO_NULL)
    {
        pstSocketData->m_fnEventProc(_i32SockID, SOCKET_EVENT_CONNECTED, pstSocketData->m_pArg);
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_OnClosed
 * Description       : Socket±»¹Ø±ÕʱµÄÄÚ²¿Í¨Öª
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_OnClosed(HIDO_INT32 _i32SockID)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || pstSocketData == HIDO_NULL)
    {
        return HIDO_ERR;
    }

    if(SOCKET_STATE_CLOSE_BEFORE_CONNECT == pstSocketData->m_eState)
    {
    	return HIDO_ERR;
    }

    pstSocketData->m_eState = SOCKET_STATE_CLOSED;
    if(pstSocketData->m_fnEventProc != HIDO_NULL)
    {
        pstSocketData->m_fnEventProc(_i32SockID, SOCKET_EVENT_CLOSED, pstSocketData->m_pArg);
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_RecvData
 * Description       : SocketÊÕµ½Êý¾ÝʱµÄÄÚ²¿´¦Àí
 * Input             : _i32Sock SocketÃèÊö·û
 *                   : _pu8Data ÊÕµ½µÄÊý¾Ý
 *                   : _u32Len ÊÕµ½µÄÊý¾Ý³¤¶È
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_RecvData(HIDO_INT32 _i32SockID, HIDO_UINT8 *_pu8Data, HIDO_UINT32 _u32Len)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];
    HIDO_UINT32 i = 0;

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || pstSocketData == HIDO_NULL)
    {
        return HIDO_ERR;
    }

    if(SOCKET_TYPE_TCP == pstSocketData->m_eType)
    {
        for(i = 0; i < _u32Len; i++)
        {
        	if(HIDO_ArraryQueueIn(&(pstSocketData->m_stTCPRecvQueue), &_pu8Data[i]) != HIDO_OK)
        	{
        	    return HIDO_ERR;
        	}
        }
    }
    else
    {
    	HIDO_VLQMemberStruct *pstMember = HIDO_NULL;

        pstMember = HIDO_VLQGetEnqueueMember(&l_astSocketData[_i32SockID].m_stRecvQueue, _u32Len);
        if (pstMember != HIDO_NULL)
        {
            memcpy(pstMember->m_pDataAddr, _pu8Data, _u32Len);

            HIDO_VLQEnqueue(&l_astSocketData[_i32SockID].m_stRecvQueue, pstMember);
        }
        else
        {
            HIDO_Debug("Socket[%u] Recv Buffer Full\r\n", _i32SockID);
        }
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_OnRecv
 * Description       : SocketÊÕµ½Êý¾ÝʱµÄÄÚ²¿Í¨Öª
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_OnRecv(HIDO_INT32 _i32SockID)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || pstSocketData == HIDO_NULL)
    {
        return HIDO_ERR;
    }

    if(pstSocketData->m_fnEventProc != HIDO_NULL)
    {
        pstSocketData->m_fnEventProc(_i32SockID, SOCKET_EVENT_RECV_DATA, pstSocketData->m_pArg);
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_Create
 * Description       : Socket´´½¨
 * Input             : _eSocketType SocketÀàÐÍ
 *                   : _fnEventProc Socketʼþ´¦Àíº¯Êý
 *                   : _pArg ²ÎÊý
 * Output            : _pi32SockID SocketÃèÊö·û
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_Create(HIDO_INT32 *_pi32SockID, E_SocketType _eSocketType, FN_SocketEventProc _fnEventProc, HIDO_VOID *_pArg)
{
    HIDO_INT32 i32SockID = 0;
    ST_SocketData *pstSocketData = HIDO_NULL;

    for(i32SockID = 0; i32SockID < SOCKET_NUM; i32SockID++)
    {
        pstSocketData = &l_astSocketData[i32SockID];
        if(pstSocketData != HIDO_NULL && (SOCKET_STATE_IDLE == pstSocketData->m_eState))
        {
            HIDO_UtilBzero(pstSocketData, sizeof(ST_SocketData));

            pstSocketData->m_i32ID = i32SockID;
            pstSocketData->m_eType = _eSocketType;
            pstSocketData->m_eState = SOCKET_STATE_CREATED;
            pstSocketData->m_fnEventProc = _fnEventProc;
            pstSocketData->m_pArg = _pArg;
            
            HIDO_VLQInit(&pstSocketData->m_stSendQueue, pstSocketData->l_au8SendQueueBuf,
                    SOCKET_SEND_QUEUE_BUF_SIZE, SOCKET_SEND_QUEUE_MEMBER_CNT);
            
            if(SOCKET_TYPE_TCP == _eSocketType)
            {
            	HIDO_ArraryQueueInit(&pstSocketData->m_stTCPRecvQueue, pstSocketData->l_au8RecvQueueBuf,
            			SOCKET_RECV_QUEUE_BUF_SIZE, sizeof(HIDO_UINT8));
            }
            else
            {
                HIDO_VLQInit(&pstSocketData->m_stRecvQueue, pstSocketData->l_au8RecvQueueBuf,
                		SOCKET_RECV_QUEUE_BUF_SIZE, SOCKET_RECV_QUEUE_MEMBER_CNT);
            }

            *_pi32SockID = i32SockID;

            return HIDO_OK;
        }
    }

    return HIDO_ERR;
}

/*******************************************************************************
 * Function Name     : Socket_Connect
 * Description       : SocketÁ¬½Ó
 * Input             : _i32Sock SocketÃèÊö·û
 *                   : _pcRemoteAddr Ä¿±êµØÖ·
 *                   : _u16RemotePort Ä¿±ê¶Ë¿Ú
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_Connect(HIDO_INT32 _i32SockID, HIDO_CHAR *_pcRemoteAddr, HIDO_UINT16 _u16RemotePort)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || pstSocketData == HIDO_NULL)
    {
        return HIDO_ERR;
    }

    HIDO_UtilSnprintf(pstSocketData->m_acRemoteAddr, sizeof(pstSocketData->m_acRemoteAddr), "%s", _pcRemoteAddr);
    pstSocketData->m_u16RemotePort = _u16RemotePort;
    pstSocketData->m_eState = SOCKET_STATE_CONNECT;

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_Close
 * Description       : ¹Ø±ÕÒ»¸öSocket
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_Close(HIDO_INT32 _i32SockID)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || pstSocketData == HIDO_NULL)
    {
        return HIDO_ERR;
    }

    if(pstSocketData->m_eState != SOCKET_STATE_IDLE && pstSocketData->m_eState != SOCKET_STATE_CLOSED)
    {
        pstSocketData->m_eState = SOCKET_STATE_CLOSE;
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_Destroy
 * Description       : Ïú»ÙÒ»¸öSocket
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_Destroy(HIDO_INT32 _i32SockID)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || pstSocketData == HIDO_NULL)
    {
        return HIDO_ERR;
    }

    pstSocketData->m_eState = SOCKET_STATE_IDLE;

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_IsSendQueueEmpty
 * Description       : ÅжϷ¢ËͶÓÁÐÊÇ·ñΪ¿Õ
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : None
 * Return            : HIDO_TRUE ·¢ËͶÓÁÐΪ¿Õ, HIDO_FALSE ·¢ËͶÓÁв»Îª¿Õ
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_BOOL Socket_IsSendQueueEmpty(HIDO_INT32 _i32SockID)
{
    HIDO_VLQMemberStruct *pstMember = HIDO_NULL;
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || pstSocketData == HIDO_NULL)
    {
        return HIDO_FALSE;
    }

    pstMember = HIDO_VLQGetDequeueMember(&pstSocketData->m_stSendQueue);
    if(HIDO_NULL == pstMember)
    {
        return HIDO_TRUE;
    }

    return HIDO_FALSE;
}

/*******************************************************************************
 * Function Name     : Socket_Send
 * Description       : Socket·¢ËÍÊý¾Ý
 * Input             : _i32Sock SocketÃèÊö·û
 *                   : _pu8Data ·¢Ë͵ÄÊý¾Ý
 *                   : _u32DataLen ·¢Ë͵ÄÊý¾Ý³¤¶È
 * Output            : None
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_Send(HIDO_INT32 _i32SockID, HIDO_UINT8 *_pu8Data, HIDO_UINT32 _u32DataLen)
{
    HIDO_VLQMemberStruct *pstMember = HIDO_NULL;
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || pstSocketData == HIDO_NULL || _u32DataLen == 0)
    {
        return HIDO_ERR;
    }

    pstMember = HIDO_VLQGetEnqueueMember(&pstSocketData->m_stSendQueue, _u32DataLen); /* »ñÈ¡Èë¶Ó¿Õ¼ä */
    if(HIDO_NULL == pstMember)
    {
        HIDO_Debug("socket[%d] send buf full\r\n", _i32SockID);

        return HIDO_ERR;
    }

    memcpy(pstMember->m_pDataAddr, _pu8Data, _u32DataLen);
    HIDO_VLQEnqueue(&pstSocketData->m_stSendQueue, pstMember); /* Èë¶Ó */

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_IsClosed
 * Description       : ¼ì²éSocketÊÇ·ñÒѶϿª
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : _pbResult ¶Ï¿ª×´Ì¬ HIDO_TRUE ÒѶϿª  HIDO_FALSE δ¶Ï¿ª
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_IsClosed(HIDO_INT32 _i32SockID, HIDO_BOOL *_pbResult)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || HIDO_NULL == _pbResult)
    {
        return HIDO_ERR;
    }

    if(SOCKET_STATE_CLOSED == pstSocketData->m_eState || SOCKET_STATE_IDLE == pstSocketData->m_eState
    		|| SOCKET_STATE_CONNECT_FAILED == pstSocketData->m_eState || SOCKET_STATE_CREATED == pstSocketData->m_eState)
    {
    	*_pbResult = HIDO_TRUE;
    }
    else
    {
    	*_pbResult = HIDO_FALSE;
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_IsConnected
 * Description       : ¼ì²éSocketÊÇ·ñÒÑÁ¬½Ó
 * Input             : _i32Sock SocketÃèÊö·û
 * Output            : _pbResult Á¬½Ó״̬ HIDO_TRUE ÒÑÁ¬½Ó  HIDO_FALSE δÁ¬½Ó
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_IsConnected(HIDO_INT32 _i32SockID, HIDO_BOOL *_pbResult)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || HIDO_NULL == _pbResult)
    {
        return HIDO_ERR;
    }

    if(SOCKET_STATE_CONNECTED == pstSocketData->m_eState)
    {
        *_pbResult = HIDO_TRUE;
    }
    else
    {
        *_pbResult = HIDO_FALSE;
    }

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_UseHeartbeat
 *******************************************************************************/
HIDO_BOOL Socket_UseHeartbeat(HIDO_INT32 _i32SockID)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM)
    {
        return HIDO_FALSE;
    }

    return pstSocketData->m_bUseHeartbeat;
}

/*******************************************************************************
 * Function Name     : Socket_SetHeartbeatData
 *******************************************************************************/
HIDO_INT32 Socket_HeartbeatConfig(HIDO_INT32 _i32SockID, HIDO_UINT8 *_pu8Data, HIDO_UINT32 _u32Len, HIDO_UINT32 _u32HeartbeatFreq)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM)
    {
        return HIDO_ERR;
    }

    pstSocketData->m_bUseHeartbeat = HIDO_TRUE;
    pstSocketData->m_u32HeartbeatFreq = _u32HeartbeatFreq;
    HIDO_UtilByteArrayToHexString(_pu8Data, _u32Len, pstSocketData->m_acHeartbeatData, sizeof(pstSocketData->m_acHeartbeatData), HIDO_FALSE);

    return HIDO_OK;
}

/*******************************************************************************
 * Function Name     : Socket_GetHeartbeatFreq
 *******************************************************************************/
HIDO_UINT32 Socket_GetHeartbeatFreq(HIDO_INT32 _i32SockID)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM)
    {
        return 300;
    }

    return pstSocketData->m_u32HeartbeatFreq;
}

/*******************************************************************************
 * Function Name     : Socket_GetHeartbeatFreq
 *******************************************************************************/
HIDO_CHAR *Socket_GetHeartbeatData(HIDO_INT32 _i32SockID)
{
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM)
    {
        return 300;
    }

    return pstSocketData->m_acHeartbeatData;
}

/*******************************************************************************
 * Function Name     : Socket_Recv
 * Description       : ´ÓSocket½ÓÊÕ¶ÓÁÐÖжÁÈ¡Êý¾Ý
 * Input             : _i32Sock SocketÃèÊö·û
 *                   : _u32RecvBuffSize ¶ÁÈ¡Êý¾ÝµÄ»º´æµØÖ·
 * Output            : _pu8RecvBuff ¶ÁÈ¡Êý¾ÝµÄ»º´æ
 *                   : _pu32RecvLen Êý¾Ý³¤¶È
 * Return            : HIDO_OK ³É¹¦, HIDO_ERR ʧ°Ü
 * Author            : www.hido-studio.com
 * Modified Date:    : 2018Äê5ÔÂ17ÈÕ
 *******************************************************************************/
HIDO_INT32 Socket_Recv(HIDO_INT32 _i32SockID, HIDO_UINT8 *_pu8RecvBuff, HIDO_UINT32 _u32RecvBuffSize, HIDO_UINT32 *_pu32RecvLen)
{
    HIDO_INT32 i32Result = HIDO_ERR;
    HIDO_VLQMemberStruct *pstMember = HIDO_NULL;
    ST_SocketData *pstSocketData = &l_astSocketData[_i32SockID];

    if(_i32SockID < 0 || _i32SockID >= SOCKET_NUM || pstSocketData == HIDO_NULL || _pu32RecvLen == HIDO_NULL)
    {
        return HIDO_ERR;
    }

    if(SOCKET_TYPE_TCP == pstSocketData->m_eType)
    {
    	HIDO_UINT32 i = 0;
    	HIDO_UINT32 u32RecvLen = 0;

    	for(i = 0; i < _u32RecvBuffSize; i++)
    	{
    		if(HIDO_ArraryQueueOut(&pstSocketData->m_stTCPRecvQueue, &_pu8RecvBuff[i]) != HIDO_OK)
    		{
    			*_pu32RecvLen = u32RecvLen;
    			return HIDO_OK;
    		}

    		u32RecvLen++;
    	}

    	*_pu32RecvLen = u32RecvLen;
    	i32Result = HIDO_OK;
    }
    else
    {
        pstMember = HIDO_VLQGetDequeueMember(&pstSocketData->m_stRecvQueue);
        if(pstMember != HIDO_NULL)
        {
            if(_u32RecvBuffSize > pstMember->m_u32DataLen)
            {
                memcpy(_pu8RecvBuff, pstMember->m_pDataAddr, pstMember->m_u32DataLen);
                *_pu32RecvLen = pstMember->m_u32DataLen;
                i32Result = HIDO_OK;
            }

            HIDO_VLQDequeue(&pstSocketData->m_stRecvQueue, pstMember);
        }
    }

    return i32Result;
}