handle_d2cs.c

打魔兽战网的都知道他是什么

	t_packet	* rpacket;
	char		* motd;
	int		motd_len;

	if (!packet)
	    return -1;
	
	/* client will crash if motd is too long */
	motd = xstrdup(prefs_get_motd());
	motd_len = strlen(motd);
	if (motd_len > MAX_MOTD_LENGTH) {
		WARN2("motd length (%i) exceeds maximun value (%i)",motd_len,MAX_MOTD_LENGTH);
		motd[MAX_MOTD_LENGTH]='\0';
	}
	if ((rpacket=packet_create(packet_class_d2cs))) {
		packet_set_size(rpacket,sizeof(t_d2cs_client_motdreply));
		packet_set_type(rpacket,D2CS_CLIENT_MOTDREPLY);
		bn_byte_set(&rpacket->u.d2cs_client_motdreply.u1,0);
		packet_append_string(rpacket,motd);
		conn_push_outqueue(c,rpacket);
		packet_del_ref(rpacket);
	}
	xfree(motd);
	return 0;
}

static int on_client_cancelcreategame(t_connection * c, t_packet * packet)
{
	t_gq	* gq;
	t_elem	* elem;

	if (!packet)
	    return -1;
	
	if (!(gq=conn_get_gamequeue(c))) {
		return 0;
	}
	conn_set_gamequeue(c,NULL);
	gq_destroy(gq,&elem);
	return 0;
}

static int on_client_charladderreq(t_connection * c, t_packet * packet)
{
	t_packet	* rpacket;
	char const	* charname;
	unsigned int	expansion, hardcore, type;
	int		pos;

	if (!(charname=packet_get_str_const(packet,sizeof(t_client_d2cs_charladderreq),MAX_CHARNAME_LEN))) {
		eventlog(eventlog_level_error,__FUNCTION__,"got bad character name");
		return -1;
	}
	expansion=bn_int_get(packet->u.client_d2cs_charladderreq.expansion);
	hardcore=bn_int_get(packet->u.client_d2cs_charladderreq.hardcore);
	type=0;					/* avoid warning */
	if (hardcore && expansion) {
		type=D2LADDER_EXP_HC_OVERALL;
	} else if (!hardcore && expansion) {
		type=D2LADDER_EXP_STD_OVERALL;
	} else if (hardcore && !expansion) {
		type=D2LADDER_HC_OVERALL;
	} else if (!hardcore && !expansion) {
		type=D2LADDER_STD_OVERALL;
	}
	if ((pos=d2ladder_find_character_pos(type,charname))<0) {
		if ((rpacket=packet_create(packet_class_d2cs))) {
			packet_set_size(rpacket,sizeof(t_d2cs_client_ladderreply));
			packet_set_type(rpacket,D2CS_CLIENT_LADDERREPLY);
			bn_byte_set(&rpacket->u.d2cs_client_ladderreply.type, type);
			bn_short_set(&rpacket->u.d2cs_client_ladderreply.total_len,0);
			bn_short_set(&rpacket->u.d2cs_client_ladderreply.curr_len,0);
			bn_short_set(&rpacket->u.d2cs_client_ladderreply.cont_len,0);
			conn_push_outqueue(c,rpacket);
			packet_del_ref(rpacket);
		}
		return 0;
	}
	pos -= prefs_get_ladderlist_count()/2;
	if (pos < 0) pos=0;
	d2cs_send_client_ladder(c,type,pos);
	return 0;
}

static int on_client_charlistreq(t_connection * c, t_packet * packet)
{
	t_packet		* rpacket;
	t_pdir			* dir;
	char const		* account; 
	char const		* charname; 
	char			* path;
	t_d2charinfo_file       * charinfo;
	unsigned int		n, maxchar;
	t_elist			charlist_head;
	char const		* charlist_sort_order;

	if (!packet)
	    return -1;
	
	if (!(account=d2cs_conn_get_account(c))) {
		eventlog(eventlog_level_error,__FUNCTION__,"missing account for connection");
		return -1;
	}
	path=xmalloc(strlen(prefs_get_charinfo_dir())+1+strlen(account)+1);
	charlist_sort_order = prefs_get_charlist_sort_order();

	elist_init(&charlist_head);
	
	d2char_get_infodir_name(path,account);
	maxchar=prefs_get_maxchar();
	if ((rpacket=packet_create(packet_class_d2cs))) {
		packet_set_size(rpacket,sizeof(t_d2cs_client_charlistreply));
		packet_set_type(rpacket,D2CS_CLIENT_CHARLISTREPLY);
		bn_short_set(&rpacket->u.d2cs_client_charlistreply.u1,0);
		n=0;
		if (!(dir=p_opendir(path))) {
			eventlog(eventlog_level_info,__FUNCTION__,"(*%s) charinfo directory do not exist, building it",account);
			p_mkdir(path,S_IRWXU);
		} else {
			while ((charname=p_readdir(dir))) {
				if (charname[0]=='.') continue;
				charinfo = xmalloc(sizeof(t_d2charinfo_file));
				if (d2charinfo_load(account,charname,charinfo)<0) {
					eventlog(eventlog_level_error,__FUNCTION__,"error loading charinfo for %s(*%s)",charname,account);
					xfree((void *)charinfo);
					continue;
				}
				eventlog(eventlog_level_debug,__FUNCTION__,"adding char %s (*%s)", charname, account);
				d2charlist_add_char(&charlist_head,charinfo,0);
				n++;
				if (n>=maxchar) break;
			}
			if (prefs_allow_newchar() && (n<maxchar)) {
				bn_short_set(&rpacket->u.d2cs_client_charlistreply.maxchar,maxchar);
			} else {
				bn_short_set(&rpacket->u.d2cs_client_charlistreply.maxchar,0);
			}
			p_closedir(dir);
			if (!strcmp(charlist_sort_order, "ASC"))
			{
			    t_elist * curr, * safe;
			    t_d2charlist * ccharlist;
			
			    elist_for_each_safe(curr,&charlist_head,safe)
			    {
				ccharlist = elist_entry(curr,t_d2charlist,list);
				packet_append_string(rpacket,ccharlist->charinfo->header.charname);
				packet_append_string(rpacket,(char *)&ccharlist->charinfo->portrait);
				xfree((void *)ccharlist->charinfo);
				xfree((void *)ccharlist);
			    }
			}
			else
			{
			    t_elist * curr, * safe;
			    t_d2charlist * ccharlist;
			
			    elist_for_each_safe_rev(curr,&charlist_head,safe)
			    {
				ccharlist = elist_entry(curr,t_d2charlist,list);
				packet_append_string(rpacket,ccharlist->charinfo->header.charname);
				packet_append_string(rpacket,(char *)&ccharlist->charinfo->portrait);
				xfree((void *)ccharlist->charinfo);
				xfree((void *)ccharlist);

			    }
			}
		}
		bn_short_set(&rpacket->u.d2cs_client_charlistreply.currchar,n);
		bn_short_set(&rpacket->u.d2cs_client_charlistreply.currchar2,n);
		conn_push_outqueue(c,rpacket);
		packet_del_ref(rpacket);
	}
	xfree(path);
	return 0;
}

static int on_client_charlistreq_110(t_connection * c, t_packet * packet)
{
	t_packet		* rpacket;
	t_pdir			* dir;
	char const		* account; 
	char const		* charname; 
	char			* path;

	t_d2charinfo_file       * charinfo;
	unsigned int		n, maxchar;
	t_elist			charlist_head;

	unsigned int		exp_time;
	unsigned int		curr_exp_time;
	char const		* charlist_sort_order;

	if (!packet)
	    return -1;
	
	if (!(account=d2cs_conn_get_account(c))) {
		eventlog(eventlog_level_error,__FUNCTION__,"missing account for connection");
		return -1;
	}
	path=xmalloc(strlen(prefs_get_charinfo_dir())+1+strlen(account)+1);
	charlist_sort_order = prefs_get_charlist_sort_order();
	
	elist_init(&charlist_head);
	
	d2char_get_infodir_name(path,account);
	if (prefs_allow_newchar()) 
		maxchar=prefs_get_maxchar();
	else
		maxchar=0;
	
	if ((rpacket=packet_create(packet_class_d2cs))) {
		packet_set_size(rpacket,sizeof(t_d2cs_client_charlistreply_110));
		packet_set_type(rpacket,D2CS_CLIENT_CHARLISTREPLY_110);
		bn_short_set(&rpacket->u.d2cs_client_charlistreply_110.u1,0);
		n=0;
		if (!(dir=p_opendir(path))) {
			eventlog(eventlog_level_info,__FUNCTION__,"(*%s) charinfo directory do not exist, building it",account);
			p_mkdir(path,S_IRWXU);
		} else {
			exp_time = prefs_get_char_expire_time();
			while ((charname=p_readdir(dir))) {
				if (charname[0]=='.') continue;
				charinfo = xmalloc(sizeof(t_d2charinfo_file));
				if (d2charinfo_load(account,charname,charinfo)<0) {
					eventlog(eventlog_level_error,__FUNCTION__,"error loading charinfo for %s(*%s)",charname,account);
					xfree(charinfo);
					continue;
				}
				if (exp_time) {
					curr_exp_time = bn_int_get(charinfo->header.last_time)+exp_time;
				} else {
					curr_exp_time = 0x7FFFFFFF;
				}
				eventlog(eventlog_level_debug,__FUNCTION__,"adding char %s (*%s)", charname, account);
				d2charlist_add_char(&charlist_head,charinfo,curr_exp_time);
				n++;
				if (n>=maxchar) break;
			}
			if (n>=maxchar) 
				maxchar = 0;
			
			p_closedir(dir);
			if (!strcmp(charlist_sort_order, "ASC"))
			{
			    t_elist * curr, *safe;
			    t_d2charlist * ccharlist;
			
			    elist_for_each_safe(curr,&charlist_head,safe)
			    {
			    	bn_int bn_exp_time;

				ccharlist = elist_entry(curr,t_d2charlist,list);
				bn_int_set(&bn_exp_time,ccharlist->expiration_time);
				packet_append_data(rpacket,bn_exp_time,sizeof(bn_exp_time));
				packet_append_string(rpacket,ccharlist->charinfo->header.charname);
				packet_append_string(rpacket,(char *)&ccharlist->charinfo->portrait);
				xfree((void *)ccharlist->charinfo);
				xfree((void *)ccharlist);
			    }
			}
			else
			{
			    t_elist * curr, *safe;
			    t_d2charlist * ccharlist;
			
			    elist_for_each_safe_rev(curr,&charlist_head,safe)
			    {
			    	bn_int bn_exp_time;

				ccharlist = elist_entry(curr,t_d2charlist,list);
				bn_int_set(&bn_exp_time,ccharlist->expiration_time);
				packet_append_data(rpacket,bn_exp_time,sizeof(bn_exp_time));
				packet_append_string(rpacket,ccharlist->charinfo->header.charname);
				packet_append_string(rpacket,(char *)&ccharlist->charinfo->portrait);
				xfree((void *)ccharlist->charinfo);
				xfree((void *)ccharlist);
			    }
			}
		}
		bn_short_set(&rpacket->u.d2cs_client_charlistreply.currchar,n);
		bn_short_set(&rpacket->u.d2cs_client_charlistreply.currchar2,n);
		bn_short_set(&rpacket->u.d2cs_client_charlistreply.maxchar,maxchar);

		conn_push_outqueue(c,rpacket);
		packet_del_ref(rpacket);
	}
	xfree(path);
	return 0;
}

static int on_client_convertcharreq(t_connection * c, t_packet * packet)
{
	t_packet	* rpacket;
	char const	* charname;
	char const	* account;
	unsigned int	reply;

	if (!(charname=packet_get_str_const(packet,sizeof(t_client_d2cs_convertcharreq),MAX_CHARNAME_LEN))) {
		eventlog(eventlog_level_error,__FUNCTION__,"got bad character name");
		return -1;
	}
	if (conn_check_multilogin(c,charname)<0) {
		eventlog(eventlog_level_error,__FUNCTION__,"character %s is already logged in",charname);
		return -1;
	}
	account=d2cs_conn_get_account(c);
	if (d2char_convert(account,charname)<0) {
		eventlog(eventlog_level_error,__FUNCTION__,"failed to convert character %s(*%s)",charname,account);
		reply = D2CS_CLIENT_CONVERTCHARREPLY_FAILED;
	} else {
		reply = D2CS_CLIENT_CONVERTCHARREPLY_SUCCEED;
	}
	if ((rpacket=packet_create(packet_class_d2cs))) {
		packet_set_size(rpacket,sizeof(t_d2cs_client_convertcharreply));
		packet_set_type(rpacket,D2CS_CLIENT_CONVERTCHARREPLY);
		bn_int_set(&rpacket->u.d2cs_client_convertcharreply.reply,reply);
		conn_push_outqueue(c,rpacket);
		packet_del_ref(rpacket);
	}
	return 0;
}

extern int d2cs_send_client_creategamewait(t_connection * c, unsigned int position)
{
	t_packet	* packet;

	ASSERT(c,-1);
	if ((packet=packet_create(packet_class_d2cs))) {
		packet_set_size(packet,sizeof(t_d2cs_client_creategamewait));
		packet_set_type(packet,D2CS_CLIENT_CREATEGAMEWAIT);
		bn_int_set(&packet->u.d2cs_client_creategamewait.position,position);
		conn_push_outqueue(c,packet);
		packet_del_ref(packet);
	}
	return 0;
}

extern int d2cs_handle_client_creategame(t_connection * c, t_packet * packet)
{
	return on_client_creategamereq(c,packet);
}

static unsigned int d2cs_try_joingame(t_connection const * c, t_game const * game, char const * gamepass)
{
	unsigned int reply;

	ASSERT(c,D2CS_CLIENT_JOINGAMEREPLY_NOT_EXIST);
	ASSERT(game,D2CS_CLIENT_JOINGAMEREPLY_NOT_EXIST);
	if (!game_get_created(game)) {
		reply=D2CS_CLIENT_JOINGAMEREPLY_NOT_EXIST;
	} else if (!game_get_d2gs(game)) {
		reply=D2CS_CLIENT_JOINGAMEREPLY_NOT_EXIST;
	} else if (conn_get_charinfo_ladder(c) != game_get_gameflag_ladder(game)) {
		reply=D2CS_CLIENT_JOINGAMEREPLY_NORMAL_LADDER;
	} else if (conn_get_charinfo_expansion(c) != game_get_gameflag_expansion(game)) {
		reply=D2CS_CLIENT_JOINGAMEREPLY_CLASSIC_EXPANSION;
	} else if (conn_get_charinfo_hardcore(c) != game_get_gameflag_hardcore(game)) {
		reply=D2CS_CLIENT_JOINGAMEREPLY_HARDCORE_SOFTCORE;
	} else if (conn_get_charinfo_difficulty(c) < game_get_gameflag_difficulty(game))  {
		reply=D2CS_CLIENT_JOINGAMEREPLY_NORMAL_NIGHTMARE;
	} else if (prefs_allow_gamelimit()) {
		if (game_get_maxchar(game) <= game_get_currchar(game)) {
			reply=D2CS_CLIENT_JOINGAMEREPLY_GAME_FULL;
		} else if (conn_get_charinfo_level(c) > game_get_maxlevel(game)) {
			reply=D2CS_CLIENT_JOINGAMEREPLY_LEVEL_LIMIT;
		} else if (conn_get_charinfo_level(c) < game_get_minlevel(game)) {
			reply=D2CS_CLIENT_JOINGAMEREPLY_LEVEL_LIMIT;
		} else if (strcmp(d2cs_game_get_pass(game),gamepass)) {
			reply=D2CS_CLIENT_JOINGAMEREPLY_BAD_PASS;
		} else {
			reply=D2CS_CLIENT_JOINGAMEREPLY_SUCCEED;
		}
	} else {
		if (game_get_currchar(game) >= MAX_CHAR_PER_GAME) {
			reply=D2CS_CLIENT_JOINGAMEREPLY_GAME_FULL;
		} else {
			reply=D2CS_CLIENT_JOINGAMEREPLY_SUCCEED;
		}
	}
	return reply;
}