static void reactor_proc_sendmsg(struct net_reactor* reactor, struct net_session_s* session, struct nrmgr_send_msg_data* data) { if(session->active) { struct pending_send_msg_s* pending = (struct pending_send_msg_s*)malloc(sizeof *pending); if(pending != NULL) { /* 直接放入链表 */ pending->node.next = pending->node.prior = NULL; pending->msg = data; pending->left_len = data->data_len; double_link_push_back(&(session->packet_list), (struct double_link_node_s*)pending); /* 添加到待send列表 */ if (session->can_send) { add_session_to_waitsendlist(reactor, session); } } else { ox_rwlist_push(reactor->free_sendmsg_list, &data); } } else { ox_rwlist_push(reactor->free_sendmsg_list, &data); } }
/* 移除已经发送的数据 */ static void session_remove_sended_data(struct net_reactor* reactor, struct net_session_s* session, int sendbytes) { struct double_link_node_s* current = double_link_begin(&session->packet_list); struct double_link_node_s* end = double_link_end(&session->packet_list); while (current != end && sendbytes > 0) { struct pending_send_msg_s* node = (struct pending_send_msg_s*)current; struct double_link_node_s* next = current->next; if (node->left_len <= sendbytes) { /* 当前packet已经发送完毕 */ double_link_erase(&session->packet_list, current); sendbytes -= node->left_len; ox_rwlist_push(reactor->free_sendmsg_list, &(node->msg)); free(node); } else { node->left_len -= sendbytes; break; } current = next; } }
static int reactor_logic_on_recved_callback(struct server_s* self, void* ud, const char* buffer, int len) { struct net_reactor* reactor = (struct net_reactor*)server_getext(self); struct net_session_s* session = (struct net_session_s*)ud; int proc_len = 0; int left_len = len; const char* check_buffer = buffer; struct rwlist_s* logic_msglist = reactor->logic_msglist; while(left_len > 0) { int check_len = (reactor->check_packet)(session->ud, check_buffer, left_len); if(check_len > 0) { struct nrmgr_net_msg* msg = make_logicmsg(reactor, nrmgr_net_msg_data, session, check_buffer, check_len); if(msg != NULL) { ox_rwlist_push(logic_msglist, &msg); } check_buffer += check_len; left_len -= check_len; proc_len += check_len; } else { break; } } return proc_len; }
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_sendmsg(struct nr_mgr* mgr, struct nrmgr_send_msg_data* data, struct net_session_s* session) { struct rwlist_msg_data msg; msg.msg_type = RMT_SENDMSG; msg.data.send.data = data; msg.data.send.session = session; data->ref += 1; ox_rwlist_push(session->reactor->fromlogic_rwlist, &msg); }
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); }
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); } }
void ox_connection_send(struct connection_s* self, struct msg_data_s* msg) { /* 逻辑层请求网络层发送数据(投递消息给网络层) */ msg->type = send_msg_data; #ifdef CONNECTION_SEND_CHECK self->current_msg_id++; msg->msg_id = self->current_msg_id; #endif ox_rwlist_push(self->sendmsg_list, &msg); }
static void reactor_logic_on_enter_callback(struct server_s* self, void* ud, void* handle) { struct net_session_s* session = (struct net_session_s*)ud; struct net_reactor* reactor = (struct net_reactor*)server_getext(self); struct nrmgr_net_msg* msg = make_logicmsg(reactor, nrmgr_net_msg_connect, session, NULL, 0); session->handle = handle; if(msg != NULL) { session->active = true; reactor->active_num ++; ox_rwlist_push(reactor->logic_msglist, &msg); } }
static void reactor_logic_on_disconnection_callback(struct server_s* self, void* ud) { struct net_session_s* session = (struct net_session_s*)ud; struct net_reactor* reactor = (struct net_reactor*)server_getext(self); if(session->active) { struct nrmgr_net_msg* msg = make_logicmsg(reactor, nrmgr_net_msg_close, session, NULL, 0); /* 设置网络已断开,并告诉上层 */ session->active = false; if(msg != NULL) { ox_rwlist_push(reactor->logic_msglist, &msg); } } }
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); } }
static void connection_send_logicmsg(struct connection_s* self, enum net_msg_type type, const char* data, int data_len) { struct msg_data_s* msg = (struct msg_data_s*)malloc(data_len+sizeof(struct msg_data_s)); assert(msg != NULL); if(msg != NULL) { /* 网络层投递消息给逻辑层 */ msg->type = type; msg->len = data_len; if(data != NULL) { memcpy(msg->data, data, data_len); } ox_rwlist_push(self->netmsg_list, &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 session_destroy(struct net_reactor* reactor, struct net_session_s* session) { struct double_link_node_s* current = double_link_begin(&session->packet_list); struct double_link_node_s* end = double_link_end(&session->packet_list); while(current != end) { struct pending_send_msg_s* node = (struct pending_send_msg_s*)current; struct double_link_node_s* next = current->next; double_link_erase(&session->packet_list, current); ox_rwlist_push(reactor->free_sendmsg_list, &(node->msg)); free(node); current = next; } double_link_init(&session->packet_list); session->active = false; session->wait_flush = false; free(session); reactor->active_num--; }
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); } }
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); } } } } }