コード例 #1
0
ファイル: buffer.c プロジェクト: chenbk85/accumulation-dev
bool 
ox_buffer_write(struct buffer_s* self, const char* data, size_t len)
{
    bool write_ret = true;

    if(ox_buffer_getwritevalidcount(self) >= len)
    {
        /*  直接写入    */
        memcpy(ox_buffer_getwriteptr(self), data, len);
        ox_buffer_addwritepos(self, len);
    }
    else
    {
        size_t left_len = self->data_len - ox_buffer_getreadvalidcount(self);
        if(left_len >= len)
        {
            ox_buffer_adjustto_head(self);
            ox_buffer_write(self, data, len);
        }
        else
        {
            write_ret = false;
        }
    }

    return write_ret;
}
コード例 #2
0
ファイル: SSDBProtocol.cpp プロジェクト: IronsDu/DBProxy
void SSDBProtocolRequest::appendBlock(const char* data, size_t len)
{
    if (ox_buffer_getwritevalidcount(m_request) < len)
    {
        buffer_s* temp = ox_buffer_new(ox_buffer_getsize(m_request) + len);
        memcpy(ox_buffer_getwriteptr(temp), ox_buffer_getreadptr(m_request), ox_buffer_getreadvalidcount(m_request));
        ox_buffer_addwritepos(temp, ox_buffer_getreadvalidcount(m_request));
        ox_buffer_delete(m_request);
        m_request = temp;
    }

    ox_buffer_write(m_request, data, len);
}
コード例 #3
0
static void
connection_read_handle(struct connection_s* self)
{
    struct buffer_s* recv_buffer =self->recv_buffer;
    bool is_close = false;
    bool proc_begin = false;
    int all_recv_len = 0;

procbegin:
    proc_begin = false;
    all_recv_len = 0;

    for(;;)
    {
        int can_recvlen = 0;
        int recv_len = 0;

        if(ox_buffer_getwritevalidcount(recv_buffer) <= 0)
        {
            ox_buffer_adjustto_head(recv_buffer);
        }

        can_recvlen = ox_buffer_getwritevalidcount(recv_buffer);

        if(can_recvlen > 0)
        {
            recv_len = recv(self->fd, ox_buffer_getwriteptr(recv_buffer), can_recvlen, 0);
            if(recv_len == 0)
            {
                is_close = true;
            }
            else if(SOCKET_ERROR == recv_len)
            {
                is_close = (S_EWOULDBLOCK != sErrno);
            }
            else
            {
                ox_buffer_addwritepos(recv_buffer, recv_len);
                all_recv_len += recv_len;

                if(recv_len == can_recvlen)
                {
                    /*  如果全部读取,则设置标志:处理完刚接收的数据后应该继续读取 */
                    proc_begin = true;
                }
            }
        }

        break;
    }

    if(is_close)
    {
        connection_send_logicmsg(self, net_msg_close, NULL, 0);
        connection_close(self);
    }
    else if(all_recv_len > 0)
    {
        int len = connection_split_packet(self);
        ox_buffer_addreadpos(recv_buffer, len);
    }

    if(proc_begin && self->fd != SOCKET_ERROR)
    {
        goto procbegin;
    }
}
コード例 #4
0
static void
epoll_recvdata_callback(void* msg)
{
    struct session_s*   session = (struct session_s*)msg;
    struct buffer_s*    recv_buffer = session->recv_buffer;
    struct server_s*    server = &(session->server->base);
    int all_recvlen = 0;
    bool is_close = false;

    bool proc_begin = false;

    if(session->fd == SOCKET_ERROR)
    {
        return;
    }

procbegin:
    proc_begin = false;
    all_recvlen = 0;

    for(;;)
    {
        int can_recvlen = 0;
        int recv_len = 0;

        if(ox_buffer_getwritevalidcount(recv_buffer) <= 0)
        {
            ox_buffer_adjustto_head(recv_buffer);
        }

        can_recvlen = ox_buffer_getwritevalidcount(recv_buffer);

        if(can_recvlen > 0)
        {
            recv_len = recv(session->fd, ox_buffer_getwriteptr(recv_buffer), can_recvlen, 0);
            if(recv_len == 0)
            {
                is_close = true;
            }
            else if(SOCKET_ERROR == recv_len)
            {
                is_close = (S_EWOULDBLOCK != sErrno);
            }
            else
            {
                all_recvlen += recv_len;
                ox_buffer_addwritepos(recv_buffer, recv_len);

                if(recv_len == can_recvlen)
                {
                    proc_begin = true;
                }
            }
        }

        break;
    }

    if(is_close)
    {
        epollserver_halfclose_session(session->server, session);
        (*server->logic_on_close)(server, session->ud);
    }
    else if(all_recvlen > 0)
    {
        int proc_len = (*server->logic_on_recved)(server, session->ud, ox_buffer_getreadptr(recv_buffer), ox_buffer_getreadvalidcount(recv_buffer));
        ox_buffer_addreadpos(recv_buffer, proc_len);
    }

    if(proc_begin && session->fd != SOCKET_ERROR)   /*  确保逻辑层在logic_on_recved中没有调用关闭session */
    {
        goto procbegin;
    }
}