px_ss_module_cl.c

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

/* must been first include begin */
#include "..\ProjectX_Common\ProjectX_Copyright.h"
#include "..\ProjectX_Common\ProjectX_Common.h"
/* must been first include end */


/* std and common include */
#include <windows.h>
#include <stdio.h>
#include <stdlib.h>
#include <winsock2.h>

/* program specify include */
#include "..\ProjectX_Common\ProjectX_MessageCode.h"
#include "..\ProjectX_Common\ProjectX_Shared.h"
#include "..\ProjectX_Common\ProjectX_Utils.h"
#include "px_ss_config.h"
#include "px_ss_state.h"
#include "px_ss_ui.h"
#include "px_ss_time_service.h"
#include "px_ss_statistic.h"
#include "px_ss_module_cl.h"
#include "px_ss_module_rs.h"
#include "px_ss_module_work.h"

SOCKET							sck_module_cl = NULL;
SOCKADDR_IN						addr_module_cl;
HANDLE							h_iocp_module_cl = NULL;
HANDLE							h_event_module_cl = NULL;
PX_SS_CL_KEY				*	module_cl_key_head = NULL;
extern PX_SS_CL_VERSION		*	cl_version_head;
extern PX_SS_CONFIG			*	g_config;
extern PX_SS_STAT			*	g_stat;
extern PX_SS_STATE			*	g_state;
extern PX_SS_TIME_SERVICE	*	g_time_service;
extern PX_SS_AREA			*	module_rs_area_head;
extern char					*	area_send_buf;
extern int						area_send_buf_len;
extern int						pxmc[PROJECTX_MESSAGECODE_FINAL];
void init_module_cl(){
	if ((!valid_ss_state(STATE_MAIN_REQUEST_INIT))&&(!valid_ss_state(STATE_MAIN_RUN))) {
		return;
	}
	sck_module_cl = WSASocket(AF_INET,SOCK_STREAM,0,NULL,0,WSA_FLAG_OVERLAPPED);
	if (sck_module_cl == INVALID_SOCKET) {
		x_debug_info("init module cl fail");
		set_module_cl_state(STATE_MODULE_ERROR_FOUND);
		return;
	}
	memset(&addr_module_cl,0,sizeof(addr_module_cl));
	addr_module_cl.sin_family = AF_INET;
	addr_module_cl.sin_addr.s_addr = inet_addr(g_config->ip_to_client);
	addr_module_cl.sin_port = htons(g_config->port_to_client);
	if (bind(sck_module_cl,(SOCKADDR *)&addr_module_cl,sizeof(addr_module_cl)) == SOCKET_ERROR) {
		x_debug_info("bind module cl fail");
		set_module_cl_state(STATE_MODULE_ERROR_FOUND);
		return;
	}
	if (h_iocp_module_cl == NULL) {
		h_iocp_module_cl = CreateIoCompletionPort(INVALID_HANDLE_VALUE,NULL,0,g_config->num_cl_iocp_thread);
		if (h_iocp_module_cl == NULL) {
			x_debug_info("Create Iocp of module cl fail");
			set_module_cl_state(STATE_MODULE_ERROR_FOUND);
			return;
		}
	}
	if (h_event_module_cl == NULL) {
		h_event_module_cl = CreateEvent(NULL,TRUE,FALSE,NULL);
	}
	if (_beginthread(module_cl_accept_thread,0,h_iocp_module_cl) == NULL) {
		x_debug_info("Create module cl accept thread fail");
		set_module_cl_state(STATE_MODULE_ERROR_FOUND);
		return;
	}
	set_module_cl_state(STATE_MODULE_INIT_DONE);
	return;
}
void set_module_cl_state(byte state){
	EnterCriticalSection(g_state->cts_state);
	g_state->cl_state = state;
	g_state->frame_cl = g_time_service->frame_theory;
	LeaveCriticalSection(g_state->cts_state);
	return;
}

BOOL valid_module_cl_state(byte state){
	EnterCriticalSection(g_state->cts_state);
	if (g_state->cl_state == state) {
		LeaveCriticalSection(g_state->cts_state);
		return TRUE;
	}else{
		LeaveCriticalSection(g_state->cts_state);
		return FALSE;
	}
}

BOOL valid_specify_cl_state(PX_SS_CL_INFO * pci,byte state){
	BOOL ret;
	EnterCriticalSection(pci->cts_state);
	if (pci->state == state) {
		ret = TRUE;
	}else {
		ret = FALSE;
	}
	LeaveCriticalSection(pci->cts_state);
	return ret;
}
BOOL init_cl_key_new(PX_SS_CL_KEY * pck){
	PX_SS_CL_INFO * pci;
	//init state
	pck->state = STATE_KEY_NORMAL_USE;
	//init redirect
	pck->prdi = (LPPX_SS_CL_REDIRECT)ms_malloc(sizeof(LPPX_SS_CL_REDIRECT));
	//init io_recv
	pck->prdi->io_recv = (LPPX_SS_CL_IO_DATA)ms_malloc(sizeof(PX_SS_CL_IO_DATA));
	memset(pck->prdi->io_recv,0,sizeof(OVERLAPPED));
	pck->prdi->io_recv->buf = (char *)ms_malloc(g_config->cl_iocp_buf_len*sizeof(char));
	pck->prdi->io_recv->size = g_config->cl_iocp_buf_len;
	pck->prdi->io_recv->io_type = IOCP_IO_TYPE_RECV;
	pck->prdi->io_recv->wsabuf.buf = &(pck->prdi->io_recv->buf);
	pck->prdi->io_recv->wsabuf.len = g_config->cl_iocp_buf_len;
	
	//init io_send
	pck->prdi->io_send = (LPPX_SS_CL_IO_DATA)ms_malloc(sizeof(PX_SS_CL_IO_DATA));
	memset(pck->prdi->io_send,0,sizeof(OVERLAPPED));
	pck->prdi->io_send->buf = (char *)ms_malloc(g_config->cl_iocp_buf_len*sizeof(char));
	pck->prdi->io_send->size = g_config->cl_iocp_buf_len;
	pck->prdi->io_send->io_type = IOCP_IO_TYPE_WAIT_SEND_BUF;
	pck->prdi->io_send->wsabuf.buf = pck->prdi->io_send->buf;
	pck->prdi->io_send->wsabuf.len = g_config->cl_iocp_buf_len;
	//init per_data
	pck->prdi->per_data = (LPPX_SS_CL_PER_DATA)ms_malloc(sizeof(PX_SS_CL_PER_DATA));
	pck->prdi->per_data->pcli = (LPPX_SS_CL_INFO)ms_malloc(sizeof(PX_SS_CL_INFO));
	pci = pck->prdi->per_data->pcli;
	
	//init cl_info 
	memset(pci,0,sizeof(PX_SS_CL_INFO));

	pci->cts_state = (LPCRITICAL_SECTION)ms_malloc(sizeof(CRITICAL_SECTION));
	memset(pci->cts_state,0,sizeof(CRITICAL_SECTION));
	InitializeCriticalSectionAndSpinCount(pci->cts_state,0x4000);
	
	pci->cts_recv = (LPCRITICAL_SECTION)ms_malloc(sizeof(CRITICAL_SECTION));
	memset(pci->cts_recv,0,sizeof(CRITICAL_SECTION));
	InitializeCriticalSectionAndSpinCount(pci->cts_recv,0x4000);

	pci->cts_send = (LPCRITICAL_SECTION)ms_malloc(sizeof(CRITICAL_SECTION));
	memset(pci->cts_send,0,sizeof(CRITICAL_SECTION));
	InitializeCriticalSectionAndSpinCount(pci->cts_send,0x4000);
	
	pci->state = STATE_PX_SS_CL_CONNECTED;
	pci->version_sign = 0;
	pci->send_sign = IOCP_IO_TYPE_WAIT_SEND_BUF;

	pci->recv_buf = (char *)ms_malloc(g_config->cl_recv_buf_len*sizeof(char));
	pci->precv_start = pci->recv_buf;
	pci->precv_end = pci->recv_buf;
	pci->precv_append = NULL;
	pci->size_recv_append = 0;

	pci->send_buf = (char *)ms_malloc(g_config->cl_send_buf_len*sizeof(char));
	pci->psend_start = pci->send_buf;
	pci->psend_end = pci->send_buf;
	pci->psend_append = NULL;
	pci->size_send_append = 0;

	srand(pci->port*3.5);
	pci->heartbreak = rand();
	if (pci->heartbreak >= 2500) {
		pci->heartbreak = pci->port*1.3;
	}else if (pci->heartbreak <= 0) {
		pci->heartbreak = 2;
	}
	pci->frame_heartbreak = g_time_service->frame_theory;

	pci->frame_prev = g_time_service->frame_theory;
	return TRUE;
}

BOOL init_cl_key_reuse(PX_SS_CL_KEY * pck){
	PX_SS_CL_INFO * pci;

	pck->state = STATE_KEY_NORMAL_USE;
	
	memset(pck->prdi->io_recv,0,sizeof(OVERLAPPED));
	pck->prdi->io_recv->io_type = IOCP_IO_TYPE_RECV;
	pck->prdi->io_recv->size = g_config->cl_iocp_buf_len;
	pck->prdi->io_recv->wsabuf.buf = pck->prdi->io_recv->buf;
	pck->prdi->io_recv->wsabuf.len = g_config->cl_iocp_buf_len;
	
	memset(pck->prdi->io_send,0,sizeof(OVERLAPPED));
	pck->prdi->io_send->io_type = IOCP_IO_TYPE_WAIT_SEND_BUF;
	pck->prdi->io_send->size = g_config->cl_iocp_buf_len;
	pck->prdi->io_send->wsabuf.buf = pck->prdi->io_send->buf;
	pck->prdi->io_send->wsabuf.len = g_config->cl_iocp_buf_len;
	
	pci = pck->prdi->per_data->pcli;

	pci->size_recv_append = 0;
	pci->size_send_append = 0;
	if (pci->precv_append != NULL) {
		ms_free(pci->precv_append);
		pci->precv_append = NULL;
	}
	if (pci->psend_append != NULL) {
		ms_free(pci->psend_append);
		pci->psend_append = NULL;
	}
	
	srand(pci->port*3.5);
	pci->heartbreak = rand();
	if (pci->heartbreak >= 2500) {
		pci->heartbreak = pci->port*1.3;
	}else if (pci->heartbreak <= 0) {
		pci->heartbreak = 2;
	}
	pci->frame_heartbreak = g_time_service->frame_theory;

	pci->frame_prev = g_time_service->frame_theory;

	pci->state = STATE_PX_SS_CL_CONNECTED;
	pci->send_sign = IOCP_IO_TYPE_WAIT_SEND_BUF;
	pci->version_sign = 0;

	pci->precv_start = pci->recv_buf;
	pci->precv_end = pci->recv_buf;

	pci->psend_start = pci->send_buf;
	pci->psend_end = pci->send_buf;
	return TRUE;
}

BOOL close_specify_client(PX_SS_CL_INFO * pci){
	shutdown(pci->s_client,SD_BOTH);
	closesocket(pci->s_client);
	set_specify_cl_state(pci,STATE_PX_SS_CL_DISCONNECTED);
	return TRUE;
}

void set_specify_cl_state(PX_SS_CL_INFO * pci,byte state){
	EnterCriticalSection(pci->cts_state);
	pci->state = state;
	LeaveCriticalSection(pci->cts_state);
	return;
}

void set_specify_cl_send_state(PX_SS_CL_INFO * pci,byte state){
	EnterCriticalSection(pci->cts_send);
	pci->send_sign = state;
	LeaveCriticalSection(pci->cts_send);
	return;
}

void add_buf_to_specify_cl_recv_buf(PX_SS_CL_INFO * pci,int size,char * packet){
	int surplus_size;
	char * poffset;
	tidy_specify_cl_recv_buf(pci);
	EnterCriticalSection(pci->cts_recv);
	if (pci->size_recv_append > 0) {
		surplus_size = pci->size_recv_append + size;
		poffset = (char *)ms_malloc(surplus_size*sizeof(char));
		memcpy(poffset,pci->precv_append,pci->size_recv_append);
		memcpy(poffset+pci->size_recv_append,packet,size);
		ms_free(pci->precv_append);
		pci->precv_append = poffset;
		pci->size_recv_append = surplus_size;
	}else{
		surplus_size = pci->precv_end - pci->precv_start;
		surplus_size = g_config->cl_recv_buf_len - surplus_size;
		if (surplus_size >= size) {
			memcpy(pci->precv_end,packet,size);
			pci->precv_end += size;
		}else{
			memcpy(pci->precv_end,packet,surplus_size);
			pci->precv_end += surplus_size;
			pci->size_recv_append = size - surplus_size;
			pci->precv_append = (char *)ms_malloc(pci->size_recv_append*sizeof(char));
			memcpy(pci->precv_append,packet+surplus_size,pci->size_recv_append);
		}
	}
	LeaveCriticalSection(pci->cts_recv);
	return;
}

void add_buf_to_specify_cl_send_buf(PX_SS_CL_INFO * pci,int size,char * packet){
	int surplus_size;
	char * poffset;
	EnterCriticalSection(pci->cts_send);
	if (pci->size_send_append != 0) {
		surplus_size = pci->size_send_append + size;
		poffset = (char *)ms_malloc(surplus_size*sizeof(char));
		memcpy(poffset,pci->psend_append,pci->size_send_append);
		memcpy(poffset + pci->size_send_append,packet,size);
		ms_free(pci->psend_append);
		pci->psend_append = poffset;
		pci->size_send_append += size;
	}else{
		surplus_size = pci->psend_end - pci->psend_start;
		surplus_size = g_config->cl_send_buf_len - surplus_size;
		if (surplus_size >= size) {
			memcpy(pci->psend_end,packet,size);
			pci->psend_end += size;
		}else{
			memcpy(pci->psend_end,packet,surplus_size);
			pci->psend_end += surplus_size;
			pci->size_send_append = size - surplus_size;
			pci->psend_append = (char *)ms_malloc(pci->size_send_append*sizeof(char));
			memcpy(pci->psend_append,packet + surplus_size,pci->size_send_append);
		}
	}
	LeaveCriticalSection(pci->cts_send);
	return;
}

void update_specify_cl_send_buf(PX_SS_CL_INFO * pci,int size){
	EnterCriticalSection(pci->cts_send);
	pci->psend_start += size;
	LeaveCriticalSection(pci->cts_send);
	return;
}

int get_specify_cl_send_buf(PX_SS_CL_INFO * pci, char * packet){
	int iret;
	tidy_specify_cl_send_buf(pci);
	EnterCriticalSection(pci->cts_send);
	iret = pci->psend_end - pci->psend_start;
	if (iret == 0) {
		pci->send_sign = IOCP_IO_TYPE_WAIT_SEND_BUF;
	}else if (iret >= g_config->cl_iocp_buf_len) {
		memcpy(packet,pci->psend_start,g_config->cl_iocp_buf_len);
		iret = g_config->cl_iocp_buf_len;
	}else{
		memcpy(packet,pci->psend_start,iret);
	}
	LeaveCriticalSection(pci->cts_send);
	return iret;
}

void tidy_specify_cl_recv_buf(PX_SS_CL_INFO * pci){
	int surplus_size;
	EnterCriticalSection(pci->cts_recv);
	surplus_size = pci->precv_end - pci->precv_start;
	if (surplus_size == g_config->cl_recv_buf_len) {
		LeaveCriticalSection(pci->cts_recv);
		return;
	}
	memcpy(pci->recv_buf,pci->precv_start,surplus_size);
	pci->precv_start = pci->recv_buf;
	pci->precv_end = pci->recv_buf + surplus_size;

	if (pci->size_recv_append > 0) {
		surplus_size = g_config->cl_recv_buf_len - surplus_size;
		if (surplus_size >= pci->size_recv_append) {
			memcpy(pci->precv_end,pci->precv_append,pci->size_recv_append);
			pci->precv_end += pci->size_recv_append;
			pci->size_recv_append = 0;
			ms_free(pci->precv_append);
			pci->precv_append = NULL;
		}else{
			memcpy(pci->precv_end,pci->precv_append,surplus_size);
			pci->precv_end += surplus_size;
			memcpy(pci->precv_append,pci->precv_append + surplus_size,pci->size_recv_append - surplus_size);
			pci->size_recv_append -= surplus_size;
		}
	}
	LeaveCriticalSection(pci->cts_recv);
	return;
}

void tidy_specify_cl_send_buf(PX_SS_CL_INFO * pci){
	int surplus_size;
	EnterCriticalSection(pci->cts_send);
	surplus_size = pci->psend_end - pci->psend_start;
	if (surplus_size == g_config->cl_send_buf_len) {
		LeaveCriticalSection(pci->cts_send);
		return;
	}
	memcpy(pci->send_buf,pci->psend_start,surplus_size);
	pci->psend_start = pci->send_buf;
	pci->psend_end = pci->send_buf + surplus_size;

	if (pci->size_send_append > 0) {
		surplus_size = g_config->cl_send_buf_len - surplus_size;
		if (surplus_size >= pci->size_send_append) {
			memcpy(pci->psend_end,pci->psend_append,pci->size_send_append);
			pci->psend_end += pci->size_send_append;
			pci->size_send_append = 0;
			ms_free(pci->psend_append);
			pci->psend_append = NULL;
		}else{
			memcpy(pci->psend_end,pci->psend_append,surplus_size);
			pci->psend_end += surplus_size;
			memcpy(pci->psend_append,pci->psend_append + surplus_size,pci->size_send_append - surplus_size);
			pci->size_send_append -= surplus_size;
		}
	}
	LeaveCriticalSection(pci->cts_send);
	return;
}

void close_all_client(){
	int i;