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);
}
void
ox_nrmgr_closesession(struct nr_mgr* mgr, struct net_session_s* session)
{
    struct net_reactor* reactor = session->reactor;
    struct rwlist_msg_data msg;
    msg.msg_type = RMT_CLOSE;
    msg.data.close.session = session;

    ox_rwlist_push(reactor->fromlogic_rwlist, &msg);
    ox_rwlist_force_flush(reactor->fromlogic_rwlist);
}
Example #3
0
void
ox_connection_send_close(struct connection_s* self)
{
    struct msg_data_s* msg = (struct msg_data_s*)malloc(sizeof(struct msg_data_s));
    if(msg != NULL)
    {
        msg->type = send_msg_close;
        msg->len = 0;
        ox_rwlist_push(self->proc_list, &msg);
        ox_rwlist_force_flush(self->proc_list);
    }
}
Example #4
0
void
ox_connection_send_connect(struct connection_s* self, const char* ip, int port, int timeout)
{
    struct msg_data_s* msg = (struct msg_data_s*)malloc(sizeof(struct msg_data_s)+sizeof(struct connect_msg));
    if(msg != NULL)
    {
        struct connect_msg* connect_data = (struct connect_msg*)msg->data;
        msg->type = send_msg_connect;
        msg->len = 0;

        memcpy(connect_data->ip, ip, strlen(ip)+1);
        connect_data->port = port;
        connect_data->timeout = timeout;

        ox_rwlist_push(self->proc_list, &msg);
        ox_rwlist_force_flush(self->proc_list);
    }
}
void
ox_nrmgr_addfd(struct nr_mgr* mgr, void* ud, int fd)
{
    struct net_reactor* nr = mgr->reactors+0;
    int i = 1;
    for(; i < mgr->reactor_num; ++i)
    {
        struct net_reactor* temp = mgr->reactors+i;
        if(temp->active_num < nr->active_num)
        {
            nr = temp;
        }
    }

    {
        struct rwlist_entermsg_data msg;
        msg.ud = ud;
        msg.fd = fd;

        ox_rwlist_push(nr->enter_list, &msg);
        ox_rwlist_force_flush(nr->enter_list);
    }
}