static void
reactor_proc_enterlist(struct net_reactor* reactor)
{
struct rwlist_entermsg_data* enter_msg = NULL;
struct rwlist_s* enter_list = reactor->enter_list;
struct server_s* server = reactor->server;
while((enter_msg = (struct rwlist_entermsg_data*)ox_rwlist_pop(enter_list, 0)) != NULL)
{
struct net_session_s* session = net_session_malloc();
if(session != NULL)
{
session->reactor = reactor;
session->ud = enter_msg->ud;
if(!server_register(server, session, enter_msg->fd))
{
printf("register failed , free session \n");
free(session);
}
}
else
{
ox_socket_close(enter_msg->fd);
}
}
}
static void
reactor_proc_rwlist(struct net_reactor* reactor)
{
struct rwlist_msg_data* rwlist_msg = NULL;
struct rwlist_s* rwlist = reactor->fromlogic_rwlist;
while((rwlist_msg = (struct rwlist_msg_data*)ox_rwlist_pop(rwlist, 0)) != NULL)
{
if(rwlist_msg->msg_type == RMT_SENDMSG)
{
reactor_proc_sendmsg(reactor, rwlist_msg->data.send.session, rwlist_msg->data.send.data);
}
else if(rwlist_msg->msg_type == RMT_CLOSE)
{
if (!rwlist_msg->data.close.session->active)
{
ox_stack_push(reactor->waitclose_list, &rwlist_msg->data.close.session);
}
}
else if(rwlist_msg->msg_type == RMT_REQUEST_CLOSE)
{
if(rwlist_msg->data.close.session->active)
{
ox_stack_push(reactor->waitclose_list, &rwlist_msg->data.close.session);
}
}
else if(rwlist_msg->msg_type == RMT_REQUEST_FREENETMSG)
{
free(rwlist_msg->data.free.msg);
rwlist_msg->data.free.msg = NULL;
}
}
}
static void
reactor_logicmsg_handle(struct net_reactor* reactor, pfn_nrmgr_logicmsg callback, int64_t timeout)
{
struct nrmgr_net_msg** msg_pp = NULL;
struct nr_mgr* mgr = reactor->mgr;
struct rwlist_s* logic_msglist = reactor->logic_msglist;
int64_t current_time = ox_getnowtime();
const int64_t end_time = current_time+timeout;
struct rwlist_msg_data msg;
struct rwlist_s* rwlist = reactor->fromlogic_rwlist;
msg.msg_type = RMT_REQUEST_FREENETMSG;
while(true)
{
msg_pp = (struct nrmgr_net_msg**)ox_rwlist_pop(logic_msglist, end_time-current_time);
current_time = ox_getnowtime();
if(msg_pp != NULL)
{
(callback)(mgr, *msg_pp);
msg.data.free.msg = *msg_pp;
ox_rwlist_push(rwlist, &msg);
}
else
{
if(current_time >= end_time)
{
break;
}
}
}
}
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);
}
static void
connection_free_netmsglist(struct connection_s* self)
{
struct rwlist_s* freenetmsg_list = self->free_netmsg_list;
struct msg_data_s** msg_p = NULL;
while((msg_p = (struct msg_data_s**)ox_rwlist_pop(freenetmsg_list, 0)) != NULL)
{
struct msg_data_s* msg = *msg_p;
free(msg);
}
}
static void
reactor_freesendmsg_handle(struct net_reactor* reactor)
{
struct nrmgr_send_msg_data** msg = NULL;
struct rwlist_s* free_sendmsg_list = reactor->free_sendmsg_list;
while((msg = (struct nrmgr_send_msg_data**)ox_rwlist_pop(free_sendmsg_list, 0)) != NULL)
{
struct nrmgr_send_msg_data* data = *msg;
data->ref -= 1;
assert(data->ref >= 0);
if(data->ref == 0)
{
free(data);
}
}
}
static void
connection_proclist_handle(struct connection_s* self)
{
struct rwlist_s* proc_list = self->proc_list;
struct msg_data_s** pmsg = NULL;
while((pmsg = (struct msg_data_s**)ox_rwlist_pop(proc_list, 0)) != NULL)
{
struct msg_data_s* msg = *pmsg;
if(msg->type == send_msg_connect)
{
connection_connect_help(self, (struct connect_msg*)msg->data);
}
else if(msg->type == send_msg_close)
{
connection_close(self);
}
free(msg);
}
}
void
ox_connection_logicpoll(struct connection_s* self, int64_t millisecond)
{
/* 逻辑层调度函数:处理来自网络层投递的网络消息,以及释放逻辑层投递出的消息 */
struct rwlist_s* logicmsg_list = self->netmsg_list;
struct msg_data_s** msg_p = NULL;
struct msg_data_s* msg = NULL;
pfn_packet_handle handle = self->handle;
void* ext = self->ext;
struct rwlist_s* free_netmsg_list = self->free_netmsg_list;
int64_t current_time = ox_getnowtime();
int64_t end_time = current_time;
if(millisecond < 0)
{
millisecond = 0;
}
end_time += millisecond;
do
{
msg_p = (struct msg_data_s**)ox_rwlist_pop(logicmsg_list, end_time-current_time);
if(msg_p != NULL)
{
msg = *msg_p;
(handle)(self, msg, ext);
ox_rwlist_push(free_netmsg_list, msg_p);
current_time = ox_getnowtime();
}
else
{
break;
}
}while(end_time > current_time);
ox_rwlist_flush(self->sendmsg_list);
connection_free_sendmsglist(self);
}
static void
connection_sendmsg_handle(struct connection_s* self)
{
if(self->status == connection_establish)
{
struct buffer_s* send_buffer = self->send_buffer;
int send_len = 0;
proc_send:
{
struct rwlist_s* free_sendmsg_list = self->free_sendmsg_list;
struct rwlist_s* sendmsg_list = self->sendmsg_list;
struct msg_data_s** msg = NULL;
while((msg = (struct msg_data_s**)ox_rwlist_front(sendmsg_list, 0)) != NULL)
{
struct msg_data_s* data = *msg;
/* 只处理发送数据的消息 */
if(data->type == send_msg_data)
{
/* 先写入内置缓冲区 */
if(ox_buffer_write(send_buffer, data->data, data->len))
{
assert(data->msg_id == self->last_send_msg_id+1);
self->last_send_msg_id++;
ox_rwlist_pop(sendmsg_list, 0);
ox_rwlist_push(free_sendmsg_list, msg);
}
else
{
break;
}
}
else
{
ox_rwlist_pop(sendmsg_list, 0);
ox_rwlist_push(free_sendmsg_list, msg);
}
}
}
send_len = ox_buffer_getreadvalidcount(send_buffer);
if(send_len > 0)
{
/* 发送内置缓冲区 */
int ret_len = send(self->fd, ox_buffer_getreadptr(send_buffer), send_len, 0);
if(ret_len > 0)
{
ox_buffer_addreadpos(send_buffer, ret_len);
if(send_len == ret_len)
{
/* 如果发送全部成功,则继续处理发送消息队列中的消息 */
goto proc_send;
}
}
else if(ret_len == SOCKET_ERROR)
{
if(S_EWOULDBLOCK == sErrno)
{
self->writable = false;
ox_fdset_add(self->fdset, self->fd, WriteCheck);
}
}
}
}
}
