예제 #1
0
void
ox_nrmgr_delete(struct nr_mgr* self)
{
    int i = 0;
    for(; i < self->reactor_num; ++i)
    {
        ox_thread_delete(self->reactors[i].thread);
    }

    i = 0;
    for(; i < self->reactor_num; ++i)
    {
        struct net_reactor* reactor = self->reactors+i;

        ox_stack_delete(reactor->waitclose_list);
        ox_stack_delete(reactor->waitsend_list);

        ox_rwlist_force_flush(reactor->free_sendmsg_list);
        reactor_freesendmsg_handle(reactor);
        ox_rwlist_delete(reactor->free_sendmsg_list);
        ox_rwlist_delete(reactor->logic_msglist);
        ox_rwlist_delete(reactor->enter_list);

        {
            struct rwlist_s*    rwlist = reactor->fromlogic_rwlist;
            struct rwlist_msg_data* rwlist_msg = NULL;
            ox_rwlist_force_flush(reactor->fromlogic_rwlist);

            while((rwlist_msg = (struct rwlist_msg_data*)ox_rwlist_pop(rwlist, 0)) != NULL)
            {
                if(rwlist_msg->msg_type == RMT_SENDMSG)
                {
                    free(rwlist_msg->data.send.data);
                }
                else if(rwlist_msg->msg_type == RMT_CLOSE)
                {
                }
                else if(rwlist_msg->msg_type == RMT_REQUEST_CLOSE)
                {
                }
                else if(rwlist_msg->msg_type == RMT_REQUEST_FREENETMSG)
                {
                    free(rwlist_msg->data.free.msg);
                }
            }

            ox_rwlist_delete(reactor->fromlogic_rwlist);
        }
        

        server_stop(reactor->server);
    }

    free(self->reactors);

    free(self);
}
예제 #2
0
struct rwlist_s* 
ox_rwlist_new(int num, int element_size, int max_pengding_num)
{
    struct rwlist_s* ret = (struct rwlist_s*)malloc(sizeof(struct rwlist_s));

    if(ret != NULL)
    {
        memset(ret, 0, sizeof(*ret));

        ret->local_write = ox_stack_new(num, element_size);
        ret->shared = ox_stack_new(num, element_size);
        ret->local_read = ox_stack_new(num, element_size);

        ret->mutex = ox_mutex_new();
        ret->cond = ox_thread_cond_new();

        ret->max_pengding_num = max_pengding_num;

        if(ret->local_write == NULL || ret->shared == NULL || ret->shared == NULL || ret->mutex == NULL)
        {
            ox_rwlist_delete(ret);
            ret = NULL;
        }
    }

    return ret;
}
예제 #3
0
void
ox_connection_delete(struct connection_s* self)
{
    ox_fdset_delete(self->fdset);
    ox_buffer_delete(self->send_buffer);
    ox_buffer_delete(self->recv_buffer);

    ox_rwlist_delete(self->sendmsg_list);
    ox_rwlist_delete(self->free_sendmsg_list);
    ox_rwlist_delete(self->netmsg_list);
    ox_rwlist_delete(self->free_netmsg_list);
    ox_rwlist_delete(self->proc_list);

    if(self->fd != SOCKET_ERROR)
    {
        ox_socket_close(self->fd);
        self->fd = SOCKET_ERROR;
    }

    free(self);
}