px_ss_module_cl.c

MMORPG游戏服务器端架构及函数

	DWORD				flags;
	int					iret;
	char				cache[FILENAME_MAX] = "";
	BOOL				succ = FALSE;
	while (TRUE) {
		iret = GetQueuedCompletionStatus(iocp,&bytes_trans,(LPDWORD)&per_data,(LPOVERLAPPED *)&io_data,INFINITE);
		overlapped = &(io_data->overlapped);
		if ((iret == 0)&&(overlapped == NULL)) {
			x_debug_info("严重情况,iocp需要关闭");
			g_stat->num_thread_cl--;
			if (g_stat->num_thread_cl <= 0) {
				g_stat->num_thread_cl = 0;
				set_module_cl_state(STATE_MODULE_ERROR_FOUND);
			}
			return 0;
		}else if ((iret == 0)&&(overlapped != NULL)) {
			shutdown(per_data->pcli->s_client,SD_BOTH);
			closesocket(per_data->pcli->s_client);
			set_specify_cl_state(per_data->pcli,STATE_PX_SS_CL_DISCONNECTED);
			continue;
		}else if ((iret != 0)&&(overlapped != NULL)) {
			if (bytes_trans == 0) {
				x_debug_info("与iocp相关的socket断开,可以是主动断开,也可以是被动断开");
				set_specify_cl_state(per_data->pcli,STATE_PX_SS_CL_DISCONNECTED);
			}
			switch(io_data->io_type) {
			case IOCP_IO_TYPE_RECV:
				add_buf_to_specify_cl_recv_buf(per_data->pcli,bytes_trans,io_data->buf);
				recv_bytes = 0;
				flags = 0;
				iret = WSARecv(per_data->pcli->s_client,&(io_data->wsabuf),1,&recv_bytes,&flags,&(io_data->overlapped),NULL);
				if ((iret == 0)||((iret == SOCKET_ERROR)&&(WSAGetLastError() == WSA_IO_PENDING))){
					//succ
				}else{
					close_specify_client(per_data->pcli);
				}
				break;
			case IOCP_IO_TYPE_SEND:
				update_specify_cl_send_buf(per_data->pcli,bytes_trans);
				iret = get_specify_cl_send_buf(per_data->pcli,io_data->buf);
				if (iret > 0) {
					send_bytes = 0;
					flags = 0;
					iret = WSASend(per_data->pcli->s_client,&(io_data->wsabuf),1,&send_bytes,&flags,&(io_data->overlapped),NULL);
					if ((iret == 0)||((iret == SOCKET_ERROR)&&(WSAGetLastError() == WSA_IO_PENDING))){
						//succ
					}else{
						close_specify_client(per_data->pcli);
					}
				}
				break;
			case IOCP_IO_TYPE_POST_SPACE_SEND:
				iret = get_specify_cl_send_buf(per_data->pcli,io_data->buf);
				if (iret > 0) {
					send_bytes = 0;
					flags = 0;
					iret = WSASend(per_data->pcli->s_client,&(io_data->wsabuf),1,&send_bytes,&flags,&(io_data->overlapped),NULL);
					if ((iret == 0)||((iret == SOCKET_ERROR)&&(WSAGetLastError() == WSA_IO_PENDING))){
						//succ
					}else{
						close_specify_client(per_data->pcli);
					}
				}
				break;
			case IOCP_IO_TYPE_POST_QUIT_THREAD:
				g_stat->num_thread_cl--;
				if (g_stat->num_thread_cl <= 0) {
					g_stat->num_thread_cl = 0;
					ms_free(per_data);
					per_data = NULL;
					ms_free(io_data);
					io_data = NULL;
				}else{
					memset(io_data,0,sizeof(OVERLAPPED));
					io_data->io_type = IOCP_IO_TYPE_POST_QUIT_THREAD;
					bytes_trans = 1;
					PostQueuedCompletionStatus(iocp,&bytes_trans,(DWORD)per_data,&(io_data->overlapped));
				}
				break;
			case IOCP_IO_TYPE_CLOSE_TARGET:
				close_specify_client(per_data->pcli);
				break;
			default:
				break;
			}
		}
	}
	return 0;
}


void module_cl_packet_request_connect(PX_SS_CL_INFO * pci,WORD size,char * packet){
	int n = 3;
	WORD mc = MC_SS_CL_ACK_REQUEST_CONNECT;
	WORD length;
	char cache[3];
	memcpy(cache,&mc,sizeof(WORD));
	if (valid_ss_state(STATE_MAIN_RUN)) {
		cache[2] = '1';
	}else{
		cache[2] = '2';
	}
	add_buf_to_specify_cl_send_buf(pci,n,cache);
	return;
}

void module_cl_packet_send_version(PX_SS_CL_INFO * pci,WORD size,char * packet){
	int i;	
	int n = 3;
	char cache[3];		
	WORD mc= MC_SS_CL_ACK_VERSION_CHECK;
	BOOL pass = FALSE;
	PX_SS_CL_VERSION * pcv;
	for(i = 0;i < g_stat->num_cl_version;i++){
		pcv = cl_version_head + i;
		if (strncmp(pcv->version,packet,size) == 0) {
			if (pcv->accept) {
				pass = TRUE;
				break;
			}
		}
	}		
	memcpy(cache,&mc,sizeof(WORD));
	if (pass) {
		pci->version_sign ^= 0x1;
		cache[2] = '1';
		add_buf_to_specify_cl_send_buf(pci,n,cache);
	}else{
		cache[2] = '2';
		add_buf_to_specify_cl_send_buf(pci,n,cache);
		close_specify_client(pci);
	}
	return;
}

void module_cl_packet_send_md5_code(PX_SS_CL_INFO * pci,WORD size,char * packet){
	int i;	
	int n = 3;
	char cache[3];		
	WORD mc= MC_SS_CL_ACK_MD5_CODE_CHECK;
	BOOL pass = FALSE;
	PX_SS_CL_VERSION * pcv;
	for(i = 0;i < g_stat->num_cl_version;i++){
		pcv = cl_version_head + i;
		if (strncmp(pcv->md5code,packet,size) == 0) {
			if (pcv->accept) {
				pass = TRUE;
				break;
			}
		}
	}
	memcpy(cache,&mc,sizeof(WORD));
	if (pass) {
		pci->version_sign ^= 0x2;
		cache[2] = '1';
		add_buf_to_specify_cl_send_buf(pci,n,cache);
	}else{
		cache[2] = '2';
		add_buf_to_specify_cl_send_buf(pci,n,cache);
		close_specify_client(pci);
	}
	return;
}

void module_cl_packet_send_specify_code(PX_SS_CL_INFO * pci,WORD size,char * packet){
	int i;	
	int n;
	char cache[9];		
	WORD mc= MC_SS_CL_ACK_SPECIFY_CODE_CHECK;
	BOOL pass = FALSE;
	PX_SS_CL_VERSION * pcv;
	for(i = 0;i < g_stat->num_cl_version;i++){
		pcv = cl_version_head + i;
		if (strncmp(pcv->md5code,packet,size) == 0) {
			if (pcv->accept) {
				pass = TRUE;
				break;
			}
		}
	}
	memcpy(cache,&mc,sizeof(WORD));
	if (!pass) {
		cache[2] = '2';
		n = 3;
		add_buf_to_specify_cl_send_buf(pci,n,cache);
		close_specify_client(pci);
		return;
	}
	if ((pci->version_sign & 0x7) == 7) {
		cache[2] = '1';
		mc = MC_SS_CL_SEND_HEARTBREAK;
		memcpy(&cache[3],&mc,sizeof(WORD));
		memcpy(&cache[5],&pci->heartbreak,sizeof(int));
		n = 9;
		add_buf_to_specify_cl_send_buf(pci,n,cache);
		set_specify_cl_state(pci,STATE_PX_SS_CL_NORMAL_USE);
	}
	
	return;
}

void module_cl_packet_request_get_area_server_list(PX_SS_CL_INFO * pci,WORD size,char * packet){
	WORD mc = MC_SS_CL_SEND_AREA_SERVER_LIST;
	char * cache;
	int n;
	if (!valid_specify_cl_state(pci,STATE_PX_SS_CL_NORMAL_USE)) {
		close_specify_client(pci);
		return;
	}
	n = area_send_buf_len + sizeof(WORD);
	cache = (char *)ms_malloc(n*sizeof(char));
	memcpy(cache,&mc,sizeof(WORD));
	memcpy(cache + sizeof(WORD),area_send_buf,area_send_buf_len);
	add_buf_to_specify_cl_send_buf(pci,n,cache);
	ms_free(cache);
	cache = NULL;
	return;
}

void module_cl_packet_request_get_server_list(PX_SS_CL_INFO * pci,WORD size,char * packet){
	WORD mc = MC_SS_CL_SEND_SERVER_LIST;
	char * cache;
	char uid[5];
	int n;
	WORD size_t;
	PX_SS_AREA * psa;
	if (!valid_specify_cl_state(pci,STATE_PX_SS_CL_NORMAL_USE)) {
		close_specify_client(pci);
		return;
	}
	strncpy(uid,packet,4);
	uid[4] = '\0';
	n = atoi(uid);
	for(psa = module_rs_area_head; psa != NULL;psa = psa->pNext){
		if (psa->area_uid == n) {
			break;
		}
	}
	if (psa != NULL) {
		n = psa->size_buf + sizeof(WORD)*2;
		cache = (char *)ms_malloc(n*sizeof(char));
		memcpy(cache,&mc,sizeof(WORD));
		memcpy(cache + 2,&size_t,sizeof(WORD));
		memcpy(cache + 4,psa->send_buf,psa->size_buf);
		add_buf_to_specify_cl_send_buf(pci,n,cache);
		ms_free(cache);
		cache = NULL;
	}else{
		close_specify_client(pci);
	}
	return;
}

void module_cl_packet_request_get_line_server_list(PX_SS_CL_INFO * pci,WORD size,char * packet){
	int i;
	WORD w;
	char * cache;
	PX_SS_AREA * psa;
	PX_SS_SRV * psr;
	char uid[5];
	if (!valid_specify_cl_state(pci,STATE_PX_SS_CL_NORMAL_USE)) {
		close_specify_client(pci);
		return;
	}
	strncpy(uid,packet,4);
	uid[4] = '\0';
	i = atoi(uid);
	for(psa = module_rs_area_head;psa != NULL;psa = psa->pNext){
		for(psr = psa->psrv_list;psr != NULL;psr = psr->pNext){
			if (psr->srv_uid == i) {
				break;
			}
		}
	}
	if (psr != NULL) {
		i = psr->size_buf + sizeof(WORD)*2;
		cache = (char *)ms_malloc(i*sizeof(char));
		w = MC_SS_CL_SEND_LINE_SERVER_LIST;
		memcpy(cache,&w,sizeof(WORD));
		w = psr->size_buf;
		memcpy(cache + 2,&w,sizeof(WORD));
		memcpy(cache + 4,psr->send_buf,psr->size_buf);
		add_buf_to_specify_cl_send_buf(pci,i,cache);
		ms_free(cache);
		cache = NULL;
	}else{
		close_specify_client(pci);
	}
	return;
}

void module_cl_packet_request_specify_line_server_address(PX_SS_CL_INFO * pci,WORD size,char * packet){
	char uid[5];
	int i;
	WORD w;
	char  cache[10];
	PX_SS_AREA * psa;
	PX_SS_SRV  * psr;
	PX_SS_LINE_SERVER * psl;
	if (!valid_specify_cl_state(pci,STATE_PX_SS_CL_NORMAL_USE)) {
		close_specify_client(pci);
		return;
	}
	strncpy(uid,packet,4);
	uid[4] = '\0';
	i = atoi(uid);
	for(psa = module_rs_area_head;psa != NULL;psa = psa->pNext){
		for(psr = psa->psrv_list;psr != NULL;psr = psr->pNext){
			for(psl = psr->pline_list;psl != NULL;psl = psl->pNext){
				if (psl->line_uid == i) {
					break;
				}
			}
		}
	}
	if (psl != NULL) {
		w = MC_SS_CL_SEND_SPECIFY_LINE_SERVER_ADDRESS;
		memcpy(cache,&w,sizeof(WORD));
		w = 6;
		memcpy(cache + 2,&w,sizeof(WORD));
		memcpy(cache + 4,&psl->ip,sizeof(unsigned int));
		memcpy(cache + 8,&psl->port,sizeof(u_short));
		i = 10;
		add_buf_to_specify_cl_send_buf(pci,i,cache);
	}
	return;
}

void module_cl_packet_send_heartbreak(PX_SS_CL_INFO * pci,WORD size,char * packet){
	int ihb;
	char hb[5];
	if (!valid_specify_cl_state(pci,STATE_PX_SS_CL_NORMAL_USE)) {
		close_specify_client(pci);
		return;
	}
	strncpy(hb,packet,4);
	hb[4] = '\0';
	ihb = atoi(hb);
	if (pci->heartbreak <= ihb) {
		pci->heartbreak = ihb;
		pci->frame_heartbreak = g_time_service->frame_theory;
	}else{
		close_specify_client(pci);
	}
	return;
}

void module_cl_packet_request_disconnect(PX_SS_CL_INFO * pci,WORD size,char * packet){
	int i = 2;
	WORD mc = MC_SS_CL_ACK_DISCONNECT;
	char cache[2];
	memcpy(cache,&mc,sizeof(WORD));
	add_buf_to_specify_cl_send_buf(pci,i,cache);
	close_specify_client(pci);
	return;
}

void module_cl_packet_send_frame_counter(PX_SS_CL_INFO * pci,WORD size,char * packet){
#ifdef DEVELOPER
	//do something,but current version no support
	return;
#else
	//no use for no-developer
	return;
#endif
}