开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > MySQL数据库 > 查看源码
handle_auth.c
资源名称：pvpgn-1.6.2.rar　[点击查看]
上传用户：tany51
上传日期：2013-06-12
资源大小：1397k
文件大小：27k
源码类别：

MySQL数据库

开发平台：

Visual C++

handle_auth.c：源码内容
  1. /*
  2.  * Copyright (C) 2000  Ross Combs (rocombs@cs.nmsu.edu)
  3.  *
  4.  * This program is free software; you can redistribute it and/or
  5.  * modify it under the terms of the GNU General Public License
  6.  * as published by the Free Software Foundation; either version 2
  7.  * of the License, or (at your option) any later version.
  8.  *
  9.  * This program is distributed in the hope that it will be useful,
  10.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12.  * GNU General Public License for more details.
  13.  *
  14.  * You should have received a copy of the GNU General Public License
  15.  * along with this program; if not, write to the Free Software
  16.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  17.  */
  18. #include "common/setup_before.h"
  19. #ifdef HAVE_STRING_H
  20. # include <string.h>
  21. #else
  22. # ifdef HAVE_STRINGS_H
  23. #  include <strings.h>
  24. # endif
  25. #endif
  26. #include "compat/strcasecmp.h"
  27. #include "common/packet.h"
  28. #include "common/eventlog.h"
  29. #include "account.h"
  30. #include "connection.h"
  31. #include "common/queue.h"
  32. #include "common/bnethash.h"
  33. #include "common/bnethashconv.h"
  34. #include "common/bn_type.h"
  35. #include "common/field_sizes.h"
  36. #include "common/auth_protocol.h"
  37. #include "character.h"
  38. #include "common/util.h"
  39. #include "handle_auth.h"
  40. #include "common/setup_after.h"
  43. static int add_charlistreq_packet (t_packet * rpacket, t_account * account, char const * clienttag, char const * realmname, char const * name);
  46. extern int handle_auth_packet(t_connection * c, t_packet const * const packet)
  47. {
  48.     t_packet * rpacket;
  49.     
  50.     if (!c)
  51.     {
  52. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got NULL connection",conn_get_socket(c));
  53. return -1;
  54.     }
  55.     if (!packet)
  56.     {
  57. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got NULL packet",conn_get_socket(c));
  58. return -1;
  59.     }
  60.     if (packet_get_class(packet)!=packet_class_auth)
  61.     {
  62. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad packet (class %d)",conn_get_socket(c),(int)packet_get_class(packet));
  63. return -1;
  64.     }
  65.     
  66.     switch (conn_get_state(c))
  67.     {
  68.     case conn_state_connected:
  69. switch (packet_get_type(packet))
  70. {
  71. case CLIENT_AUTHLOGINREQ:
  72.     if (packet_get_size(packet)<sizeof(t_client_authloginreq))
  73.     {
  74. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad AUTHLOGINREQ packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_authloginreq),packet_get_size(packet));
  75. break;
  76.     }
  77.     
  78.     {
  79. char const   * username;
  80. t_connection * normalcon;
  81. unsigned int   reply;
  83. if (!(username = packet_get_str_const(packet,sizeof(t_client_authloginreq),USER_NAME_MAX)))
  84. {
  85.     eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad AUTHLOGINREQ packet (missing or too long username)",conn_get_socket(c));
  86.     break;
  87. }
  89. eventlog(eventlog_level_debug,"handle_auth_packet","[%d] username = "%s"",conn_get_socket(c),username);
  91. if (!(normalcon = connlist_find_connection_by_sessionkey(bn_int_get(packet->u.client_authloginreq.sessionkey))))
  92. {
  93.     eventlog(eventlog_level_info,"handle_auth_packet","[%d] auth login for "%s" refused (bad session key %u)",conn_get_socket(c),username,bn_int_get(packet->u.client_authloginreq.sessionkey));
  94.     reply = SERVER_AUTHLOGINREPLY_REPLY_BANNED;
  95. }
  96. else
  97. {
  98.     unsigned int salt;
  99.     struct
  100.     {
  101. bn_int   salt;
  102. bn_int   sessionkey;
  103. bn_int   sessionnum;
  104. bn_int   secret;
  105.     } temp;
  106.     t_hash       secret_hash;
  107.     t_hash       try_hash;
  108.     char const * tname;
  109.     
  110.     salt = bn_int_get(packet->u.client_authloginreq.unknown9);
  111.     bn_int_set(&temp.salt,salt);
  112.     bn_int_set(&temp.sessionkey,conn_get_sessionkey(normalcon));
  113.     bn_int_set(&temp.sessionnum,conn_get_sessionnum(normalcon));
  114.     bn_int_set(&temp.secret,conn_get_secret(normalcon));
  115.     bnet_hash(&secret_hash,sizeof(temp),&temp);
  116.     
  117.     bnhash_to_hash(packet->u.client_authloginreq.secret_hash,&try_hash);
  118.     
  119.     if (hash_eq(try_hash,secret_hash)!=1)
  120.     {
  121. eventlog(eventlog_level_info,"handle_auth_packet","[%d] auth login for "%s" refused (bad password)",conn_get_socket(c),username);
  122. conn_increment_passfail_count (c);
  123. reply = SERVER_AUTHLOGINREPLY_REPLY_BANNED;
  124.     }
  125.     else
  126.     {
  127. if (strcasecmp(username,(tname = conn_get_username(normalcon)))!=0)
  128. {
  129.     eventlog(eventlog_level_info,"handle_auth_packet","[%d] auth login for "%s" refused (username does not match "%s")",conn_get_socket(c),username,tname);
  130.     conn_unget_username(normalcon,tname);
  131.     reply = SERVER_AUTHLOGINREPLY_REPLY_BANNED;
  132. }
  133. else
  134. {
  135.     conn_unget_username(normalcon,tname);
  136.     eventlog(eventlog_level_info,"handle_auth_packet","[%d] auth login for "%s" accepted (correct password)",conn_get_socket(c),username);
  137.     reply = SERVER_AUTHLOGINREPLY_REPLY_SUCCESS;
  138.     conn_bind(c,normalcon);
  139.     conn_set_state(c,conn_state_loggedin); /* FIXME: what about the other connection? */
  140. }
  141.     }
  142. }
  144. if ((rpacket = packet_create(packet_class_auth)))
  145. {
  146.     packet_set_size(rpacket,sizeof(t_server_authloginreply));
  147.     packet_set_type(rpacket,SERVER_AUTHLOGINREPLY);
  148.     bn_int_set(&rpacket->u.server_authloginreply.reply,reply);
  149.     conn_push_outqueue(c,rpacket);
  150.     packet_del_ref(rpacket);
  151. }
  152.     }
  153.     break;
  154.     
  155. default:
  156.     eventlog(eventlog_level_error,"handle_auth_packet","[%d] unknown (unlogged in) auth packet type 0x%02hx, len %u",conn_get_socket(c),packet_get_type(packet),packet_get_size(packet));
  157. }
  158. break;
  160.     case conn_state_loggedin:
  161. switch (packet_get_type(packet))
  162. {
  163. case CLIENT_CREATECHARREQ:
  164.     if (packet_get_size(packet)<sizeof(t_client_createcharreq))
  165.     {
  166. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad CREATECHARREQ packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_createcharreq),packet_get_size(packet));
  167. break;
  168.     }
  169.     
  170.     {
  171. char const *          charname;
  172. unsigned int          reply;
  173. t_character_class     charclass;
  174. t_character_expansion charexpansion;
  176. if (!(charname = packet_get_str_const(packet,sizeof(t_client_createcharreq),UNCHECKED_NAME_STR)))
  177. {
  178.     eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad CREATECHARREQ packet (missing or too long charname)",conn_get_socket(c));
  179.     break;
  180. }
  182. eventlog(eventlog_level_debug,"handle_auth_packet","[%d] CREATECHARREQ %u %04x %04x",
  183.  conn_get_socket(c),
  184.  bn_short_get(packet->u.client_createcharreq.class),
  185.  bn_short_get(packet->u.client_createcharreq.unknown1),
  186.  bn_short_get(packet->u.client_createcharreq.expansion));
  188. switch (bn_short_get(packet->u.client_createcharreq.class))
  189. {
  190. case CLIENT_CREATECHARREQ_CLASS_AMAZON:
  191.     charclass = character_class_amazon;
  192.     break;
  193. case CLIENT_CREATECHARREQ_CLASS_SORCERESS:
  194.     charclass = character_class_sorceress;
  195.     break;
  196. case CLIENT_CREATECHARREQ_CLASS_NECROMANCER:
  197.     charclass = character_class_necromancer;
  198.     break;
  199. case CLIENT_CREATECHARREQ_CLASS_PALADIN:
  200.     charclass = character_class_paladin;
  201.     break;
  202. case CLIENT_CREATECHARREQ_CLASS_BARBARIAN:
  203.     charclass = character_class_barbarian;
  204.     break;
  205. case CLIENT_CREATECHARREQ_CLASS_DRUID:
  206.     charclass = character_class_druid;
  207.     break;
  208. case CLIENT_CREATECHARREQ_CLASS_ASSASSIN:
  209.     charclass = character_class_assassin;
  210.     break;
  211. default:
  212.     eventlog(eventlog_level_error,"handle_auth_packet","[%d] got unknown character class %u",conn_get_socket(c),bn_short_get(packet->u.client_createcharreq.class));
  213.     charclass = character_class_none;
  214. }
  216. switch (bn_short_get(packet->u.client_createcharreq.expansion))
  217. {
  218. case CLIENT_CREATECHARREQ_EXPANSION_CLASSIC:
  219.     charexpansion = character_expansion_classic;
  220.     break;
  221. case CLIENT_CREATECHARREQ_EXPANSION_LOD:
  222.     charexpansion = character_expansion_lod;
  223.     break;
  224. default:
  225.     eventlog(eventlog_level_error,"handle_auth_packet","[%d] got unknown character expansion %04x",conn_get_socket(c),bn_short_get(packet->u.client_createcharreq.expansion));
  226.     charexpansion = character_expansion_none;
  227. }
  229. if (character_create(conn_get_account(c),
  230.      conn_get_clienttag(c),
  231.      conn_get_realmname(c),
  232.      charname,
  233.      charclass,
  234.      charexpansion)<0)
  235. {
  236.     eventlog(eventlog_level_error,"handle_auth_packet","[%d] could not create character "%s"",conn_get_socket(c),charname);
  237.     reply = SERVER_CREATECHARREPLY_REPLY_REJECTED;
  238. }
  239. else
  240. {
  241.     conn_set_character(c,characterlist_find_character(conn_get_realmname(c),charname));
  242.     reply = SERVER_CREATECHARREPLY_REPLY_SUCCESS;
  243. }
  245. if ((rpacket = packet_create(packet_class_auth)))
  246. {
  247.     packet_set_size(rpacket,sizeof(t_server_createcharreply));
  248.     packet_set_type(rpacket,SERVER_CREATECHARREPLY);
  249.     bn_int_set(&rpacket->u.server_createcharreply.reply,reply);
  250.     conn_push_outqueue(c,rpacket);
  251.     packet_del_ref(rpacket);
  252. }
  253.     }
  254.     break;
  255.     
  256. case CLIENT_CREATEGAMEREQ:
  257.     if (packet_get_size(packet)<sizeof(t_client_creategamereq))
  258.     {
  259. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad CREATEGAMEREQ packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_creategamereq),packet_get_size(packet));
  260. break;
  261.     }
  262.     
  263.     /* FIXME: actually create game */
  264.     if ((rpacket = packet_create(packet_class_auth)))
  265.     {
  266. packet_set_size(rpacket,sizeof(t_server_creategamereply));
  267. packet_set_type(rpacket,SERVER_CREATEGAMEREPLY);
  268. bn_short_set(&rpacket->u.server_creategamereply.unknown1,bn_short_get(packet->u.client_creategamereq.unknown1));
  269. bn_short_set(&rpacket->u.server_creategamereply.unknown2,SERVER_CREATEGAMEREPLY_UNKNOWN2);
  270. bn_short_set(&rpacket->u.server_creategamereply.unknown3,SERVER_CREATEGAMEREPLY_UNKNOWN3);
  271. bn_int_set(&rpacket->u.server_creategamereply.reply,SERVER_CREATEGAMEREPLY_REPLY_OK);
  272. conn_push_outqueue(c,rpacket);
  273. packet_del_ref(rpacket);
  274.     }
  275.     break;
  276.     
  277. case CLIENT_JOINGAMEREQ2:
  278.     if (packet_get_size(packet)<sizeof(t_client_joingamereq2))
  279.     {
  280. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad JOINGAMEREQ2 packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_joingamereq2),packet_get_size(packet));
  281. break;
  282.     }
  283.     
  284.     if ((rpacket = packet_create(packet_class_auth)))
  285.     {
  286. packet_set_size(rpacket,sizeof(t_server_joingamereply2));
  287. packet_set_type(rpacket,SERVER_JOINGAMEREPLY2);
  288. bn_short_set(&rpacket->u.server_joingamereply2.unknown1,bn_short_get(packet->u.client_joingamereq2.unknown1));
  289. bn_int_set(&rpacket->u.server_joingamereply2.unknown2,SERVER_JOINGAMEREPLY2_UNKNOWN2);
  290. #ifdef SENDSERVER
  291. bn_int_nset(&rpacket->u.server_joingamereply2.addr,conn_get_real_local_addr(c)); /* FIXME: game server may be on another machine */
  292. #else
  293. bn_int_nset(&rpacket->u.server_joingamereply2.addr,conn_get_game_addr(c));
  294. #endif
  295. bn_int_set(&rpacket->u.server_joingamereply2.unknown4,SERVER_JOINGAMEREPLY2_UNKNOWN4);
  296. bn_int_set(&rpacket->u.server_joingamereply2.reply,SERVER_JOINGAMEREPLY2_REPLY_OK);
  297. conn_push_outqueue(c,rpacket);
  298. packet_del_ref(rpacket);
  299.     }
  300.     break;
  301.     
  302. case CLIENT_D2GAMELISTREQ:
  303.     if (packet_get_size(packet)<sizeof(t_client_d2gamelistreq))
  304.     {
  305. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad D2GAMELISTREQ packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_d2gamelistreq),packet_get_size(packet));
  306. break;
  307.     }
  308.     
  309.     /* FIXME: actually get game list */
  310.     if ((rpacket = packet_create(packet_class_auth)))
  311.     {
  312. packet_set_size(rpacket,sizeof(t_server_d2gamelistreply));
  313. packet_set_type(rpacket,SERVER_D2GAMELISTREPLY);
  314. bn_short_set(&rpacket->u.server_d2gamelistreply.unknown1,bn_short_get(packet->u.client_d2gamelistreq.unknown1));
  315. bn_int_set(&rpacket->u.server_d2gamelistreply.unknown2,SERVER_D2GAMELISTREPLY_UNKNOWN2);
  316. bn_byte_set(&rpacket->u.server_d2gamelistreply.unknown3,SERVER_D2GAMELISTREPLY_UNKNOWN3);
  317. bn_int_set(&rpacket->u.server_d2gamelistreply.unknown4,SERVER_D2GAMELISTREPLY_UNKNOWN4);
  318. packet_append_string(rpacket,"Nope"); /* game name */
  319. packet_append_string(rpacket,""); /* game pass? */
  320. conn_push_outqueue(c,rpacket);
  321. packet_del_ref(rpacket);
  322.     }
  323.     if ((rpacket = packet_create(packet_class_auth)))
  324.     {
  325. packet_set_size(rpacket,sizeof(t_server_d2gamelistreply));
  326. packet_set_type(rpacket,SERVER_D2GAMELISTREPLY);
  327. bn_short_set(&rpacket->u.server_d2gamelistreply.unknown1,bn_short_get(packet->u.client_d2gamelistreq.unknown1));
  328. bn_int_set(&rpacket->u.server_d2gamelistreply.unknown2,SERVER_D2GAMELISTREPLY_UNKNOWN2);
  329. bn_byte_set(&rpacket->u.server_d2gamelistreply.unknown3,SERVER_D2GAMELISTREPLY_UNKNOWN3);
  330. bn_int_set(&rpacket->u.server_d2gamelistreply.unknown4,SERVER_D2GAMELISTREPLY_UNKNOWN4_END);
  331. packet_append_string(rpacket,"");
  332. packet_append_string(rpacket,"");
  333. packet_append_string(rpacket,"");
  334. conn_push_outqueue(c,rpacket);
  335. packet_del_ref(rpacket);
  336.     }
  337.     break;
  338.     
  339. case CLIENT_GAMEINFOREQ:
  340.     if (packet_get_size(packet)<sizeof(t_client_gameinforeq))
  341.     {
  342. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad GAMEINFOREQ packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_gameinforeq),packet_get_size(packet));
  343. break;
  344.     }
  345.     
  346.     /* FIXME: send real game info */
  347.     if ((rpacket = packet_create(packet_class_auth)))
  348.     {
  349. packet_set_size(rpacket,sizeof(t_server_gameinforeply));
  350. packet_set_type(rpacket,SERVER_GAMEINFOREPLY);
  351. bn_short_set(&rpacket->u.server_gameinforeply.unknown1,bn_short_get(packet->u.client_gameinforeq.unknown1));
  352. bn_int_set(&rpacket->u.server_gameinforeply.unknown2,SERVER_GAMEINFOREPLY_UNKNOWN2);
  353. bn_int_set(&rpacket->u.server_gameinforeply.unknown3,SERVER_GAMEINFOREPLY_UNKNOWN3);
  354. bn_byte_set(&rpacket->u.server_gameinforeply.gamelevel,0x01);
  355. bn_byte_set(&rpacket->u.server_gameinforeply.leveldiff,0xff);
  356. bn_byte_set(&rpacket->u.server_gameinforeply.maxchar,0x08);
  357. bn_byte_set(&rpacket->u.server_gameinforeply.currchar,0x01);
  358.                 memset(rpacket->u.server_gameinforeply.class,0xcc,16);
  359.                 memset(rpacket->u.server_gameinforeply.level,0xcc,16);
  360. bn_byte_set(&rpacket->u.server_gameinforeply.unknown4,SERVER_GAMEINFOREPLY_UNKNOWN4);
  361. packet_append_string(rpacket,"Player1");
  362. packet_append_string(rpacket,"Player2");
  363. conn_push_outqueue(c,rpacket);
  364. packet_del_ref(rpacket);
  365.     }
  366.     break;
  367.     
  368. case CLIENT_CHARLOGINREQ:
  369.     if (packet_get_size(packet)<sizeof(t_client_charloginreq))
  370.     {
  371. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad CHARLOGINREQ packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_charloginreq),packet_get_size(packet));
  372. break;
  373.     }
  374.     
  375.     {
  376. char const *  charname;
  377. t_character * ch;
  378. char const *  charlist;
  380. if (!(charname = packet_get_str_const(packet,sizeof(t_client_charloginreq),UNCHECKED_NAME_STR)))
  381. {
  382.     eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad CHARLOGINREQ packet (missing or too long charname)",conn_get_socket(c));
  383.     break;
  384. }
  385.         
  386.         if ((rpacket = packet_create(packet_class_auth)))
  387.         {
  388.     packet_set_size(rpacket,sizeof(t_server_charloginreply));
  389.     packet_set_type(rpacket,SERVER_CHARLOGINREPLY);
  390.     if ((ch = characterlist_find_character(conn_get_realmname(c),charname)))
  391.     {
  392. if (!(charlist = account_get_closed_characterlist(conn_get_account(c),conn_get_clienttag(c),conn_get_realmname(c))))
  393. {
  394.     eventlog(eventlog_level_info,"handle_auth_packet","[%d] character login for "%s" refused (account has no charlist)",conn_get_socket(c),charname);
  395.     bn_int_set(&rpacket->u.server_charloginreply.reply,0xffffffff); /* FIXME */
  396. }
  397. else
  398. {
  399.     if (character_verify_charlist(ch,charlist)<0)
  400.     {
  401. eventlog(eventlog_level_info,"handle_auth_packet","[%d] character login for "%s" refused (character not in account charlist)",conn_get_socket(c),charname);
  402. bn_int_set(&rpacket->u.server_charloginreply.reply,0xffffffff); /* FIXME */
  403.     }
  404.     else
  405.     {
  406. conn_set_character(c,ch);
  407. bn_int_set(&rpacket->u.server_charloginreply.reply,SERVER_CHARLOGINREPLY_REPLY_SUCCESS);
  408.     }
  409.     account_unget_closed_characterlist(conn_get_account(c),charlist);
  410. }
  411.     }
  412.     else
  413.     {
  414. eventlog(eventlog_level_info,"handle_auth_packet","[%d] character login for "%s" refused (no such character in realm "%s")",conn_get_socket(c),charname,conn_get_realmname(c));
  415. bn_int_set(&rpacket->u.server_charloginreply.reply,0xffffffff); /* FIXME */
  416.     }
  417.     conn_push_outqueue(c,rpacket);
  418.     packet_del_ref(rpacket);
  419.         }
  420.     }
  421.     break;
  422.     
  423. case CLIENT_DELETECHARREQ:
  424.     if (packet_get_size(packet)<sizeof(t_client_deletecharreq))
  425.     {
  426. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad DELETECHARREQ packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_deletecharreq),packet_get_size(packet));
  427. break;
  428.     }
  429.     
  430.     if ((rpacket = packet_create(packet_class_auth)))
  431.     {
  432. packet_set_size(rpacket,sizeof(t_server_deletecharreply));
  433. packet_set_type(rpacket,SERVER_DELETECHARREPLY);
  434. bn_short_set(&rpacket->u.server_deletecharreply.unknown1,bn_short_get(packet->u.client_deletecharreq.unknown1));
  435. bn_int_set(&rpacket->u.server_deletecharreply.reply,SERVER_DELETECHARREPLY_REPLY_SUCCESS);
  436. conn_push_outqueue(c,rpacket);
  437. packet_del_ref(rpacket);
  438.     }
  439.     break;
  440.     
  441. case CLIENT_LADDERREQ2:
  442.     if (packet_get_size(packet)<sizeof(t_client_ladderreq2))
  443.     {
  444. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad LADDERREQ2 packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_ladderreq2),packet_get_size(packet));
  445. break;
  446.     }
  447.     
  448.     if ((rpacket = packet_create(packet_class_auth)))
  449.     {
  450. packet_set_size(rpacket,sizeof(t_server_ladderreply2));
  451. packet_set_type(rpacket,SERVER_LADDERREPLY2);
  452. bn_byte_set(&rpacket->u.server_ladderreply2.unknown1,bn_byte_get(packet->u.client_ladderreq2.class));
  453. bn_short_set(&rpacket->u.server_ladderreply2.unknown2,SERVER_LADDERREPLY2_UNKNOWN2);
  454. bn_short_set(&rpacket->u.server_ladderreply2.unknown3,SERVER_LADDERREPLY2_UNKNOWN3);
  455. bn_short_set(&rpacket->u.server_ladderreply2.unknown4,SERVER_LADDERREPLY2_UNKNOWN4);
  456. bn_int_set(&rpacket->u.server_ladderreply2.unknown5,SERVER_LADDERREPLY2_UNKNOWN5);
  457. bn_int_set(&rpacket->u.server_ladderreply2.unknown6,SERVER_LADDERREPLY2_UNKNOWN6);
  458. conn_push_outqueue(c,rpacket);
  459. packet_del_ref(rpacket);
  460.     }
  461.     break;
  462.     
  463. case CLIENT_AUTHMOTDREQ:
  464.     if (packet_get_size(packet)<sizeof(t_client_authmotdreq))
  465.     {
  466. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad AUTHMOTDREQ packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_authmotdreq),packet_get_size(packet));
  467. break;
  468.     }
  469.     
  470.     if ((rpacket = packet_create(packet_class_auth)))
  471.     {
  472. packet_set_size(rpacket,sizeof(t_server_authmotdreply));
  473. packet_set_type(rpacket,SERVER_AUTHMOTDREPLY);
  474. bn_byte_set(&rpacket->u.server_authmotdreply.unknown1,SERVER_AUTHMOTDREPLY_UNKNOWN1);
  475. packet_append_string(rpacket,"Hello.");
  476. conn_push_outqueue(c,rpacket);
  477. packet_del_ref(rpacket);
  478.     }
  479.     break;
  480.     
  481. case CLIENT_CHARLISTREQ:
  482.     if (packet_get_size(packet)<sizeof(t_client_charlistreq))
  483.     {
  484. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad CHARLISTREQ packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_charlistreq),packet_get_size(packet));
  485. break;
  486.     }
  488.             eventlog(eventlog_level_debug,"handle_auth_packet","CHARLISTREQ.unknown1 = 0x%04x", bn_short_get(packet->u.client_charlistreq.unknown1));
  489.             eventlog(eventlog_level_debug,"handle_auth_packet","CHARLISTREQ.unknown2 = 0x%04x", bn_short_get(packet->u.client_charlistreq.unknown2));
  491.     if ((rpacket = packet_create(packet_class_auth)))
  492.     {
  493.            /* FIXME: Set *real* Number of characters here */
  494.         int number_of_characters = 0;
  496. packet_set_size(rpacket,sizeof(t_server_charlistreply));
  497. packet_set_type(rpacket,SERVER_CHARLISTREPLY);
  499. bn_short_set(&rpacket->u.server_charlistreply.unknown1, bn_short_get(packet->u.client_charlistreq.unknown1));
  500. bn_short_set(&rpacket->u.server_charlistreply.unknown2, 0);
  502. {
  503.     char const * realmname = conn_get_realmname(c);
  504.     char const * charlist = account_get_closed_characterlist (conn_get_account(c), conn_get_clienttag(c), realmname);
  505.     char         tempname[32];
  507.     if (charlist == NULL)
  508.     {
  509.         eventlog(eventlog_level_debug,"handle_auth_packet","no characters in Realm %s",realmname);
  510.     }
  511.     else
  512.     {
  513.         char const * start;
  514. char const * next_char;
  515. int    list_len;
  516. int    name_len;
  517. int    i;
  519. eventlog(eventlog_level_debug,"handle_auth_packet","got characterlist "%s" for Realm %s",charlist,realmname);
  521. list_len  = strlen(charlist);
  522. start     = charlist;
  523. next_char = start;
  524. for (i = 0; i < list_len; i++, next_char++)
  525. {
  526.     if (',' == *next_char)
  527.     {
  528.         name_len = next_char - start;
  530. strncpy(tempname, start, name_len);
  531. tempname[name_len] = '';
  533. number_of_characters += add_charlistreq_packet(rpacket, conn_get_account(c), conn_get_clienttag(c), realmname, tempname);
  535. start = next_char + 1;
  536.     }
  537. }
  539. name_len = next_char - start;
  541. strncpy(tempname, start, name_len);
  542. tempname[name_len] = '';
  544. number_of_characters += add_charlistreq_packet(rpacket, conn_get_account(c), conn_get_clienttag(c), realmname, tempname);
  546. start = next_char + 1;
  547.     }    
  548. }
  550. bn_short_set(&rpacket->u.server_charlistreply.nchars_1, number_of_characters);
  551. bn_short_set(&rpacket->u.server_charlistreply.nchars_2, number_of_characters);
  553. eventlog(eventlog_level_debug,"handle_auth_packet","CHARLISTREPLY.unknown1 = 0x%04x", bn_short_get(rpacket->u.server_charlistreply.unknown1));
  554. eventlog(eventlog_level_debug,"handle_auth_packet","CHARLISTREPLY.nchars_1 = 0x%04x", bn_short_get(rpacket->u.server_charlistreply.nchars_1));
  555. eventlog(eventlog_level_debug,"handle_auth_packet","CHARLISTREPLY.unknown2 = 0x%04x", bn_short_get(rpacket->u.server_charlistreply.unknown2));
  556. eventlog(eventlog_level_debug,"handle_auth_packet","CHARLISTREPLY.nchars_2 = 0x%04x", bn_short_get(rpacket->u.server_charlistreply.nchars_2));
  558. conn_push_outqueue(c,rpacket);
  559. packet_del_ref(rpacket);
  560.     }
  561.     break;
  563. case CLIENT_CONVERTCHARREQ:
  564.     if (packet_get_size(packet)<sizeof(t_client_convertcharreq))
  565.     {
  566. eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad CONVERTCHARREQ packet (expected %u bytes, got %u)",conn_get_socket(c),sizeof(t_client_convertcharreq),packet_get_size(packet));
  567. break;
  568.     }
  570.     {
  571. char const * charname;
  573. if (!(charname = packet_get_str_const(packet,sizeof(t_client_convertcharreq),UNCHECKED_NAME_STR)))
  574. {
  575.     eventlog(eventlog_level_error,"handle_auth_packet","[%d] got bad CONVERTCHARREQ packet (missing or too long charname)",conn_get_socket(c));
  576.     break;
  577. }
  579. eventlog(eventlog_level_debug,"handle_auth_packet","[%d] CONVERTCHARREQ %s, FIXME: Add code later",
  580.  conn_get_socket(c),
  581.                          charname);
  583. if ((rpacket = packet_create(packet_class_auth)))
  584. {
  585.     packet_set_size(rpacket,sizeof(t_server_convertcharreply));
  586.     packet_set_type(rpacket,SERVER_CONVERTCHARREPLY);
  587.                     bn_int_set(&rpacket->u.server_convertcharreply.unknown1, SERVER_CONVERTCHARREPLY_UNKNOWN1);
  588.     conn_push_outqueue(c,rpacket);
  589.     packet_del_ref(rpacket);
  590. }
  591.             }
  592.             break;
  593.             
  594. default:
  595.     eventlog(eventlog_level_error,"handle_auth_packet","[%d] unknown (logged in) auth packet type 0x%02hx, len %u",conn_get_socket(c),packet_get_type(packet),packet_get_size(packet));
  596. }
  597. break;
  599.     default:
  600. eventlog(eventlog_level_error,"handle_auth_packet","[%d] unknown auth connection state %d",conn_get_socket(c),(int)conn_get_state(c));
  601.     }
  602.     
  603.     return 0;
  604. }
  607. static int add_charlistreq_packet (t_packet * rpacket, t_account * account, char const * clienttag, char const * realmname, char const * name)
  608. {
  609.     char const * chardata_as_hex;
  610.     char         chardata_key[256]; /* FIXME: buffer overflow on realmnname or name */
  612.     eventlog(eventlog_level_debug, "add_charlistreq_packet", "about to add charlist data for "%s" in realm "%s"", name, realmname);
  614.     sprintf (chardata_key, "BNET\Characters\%s\%s\%s\0", clienttag, realmname, name);
  615.     chardata_as_hex = account_get_strattr(account, chardata_key);
  617.     eventlog(eventlog_level_debug, "add_charlistreq_packet", "key "%s"", chardata_key);
  618.     eventlog(eventlog_level_debug, "add_charlistreq_packet", "value "%s"", chardata_as_hex);
  620.     /* FIXME: This seems to be a request for character lists, try the following canned request
  621.      *        that I tcpdump(1)'ed from a real Battle Net connection
  623. # 569 packet from server: type=0x0017(SERVER_CHARLISTREPLY) length=199 class=auth
  624. 0000:   C7 00 17 08 00 04 00 00   00 04 00 68 61 6B 61 6E    ...........hakan
  625. 0010:   41 73 73 54 65 6D 70 00   84 80 FF FF FF FF FF FF    AssTemp.........
  626. 0020:   FF FF FF FF FF 07 FF FF   FF FF FF FF FF FF FF FF    ................
  627. 0030:   FF 01 A1 80 80 80 FF FF   FF 00 68 61 6B 61 6E 44    ..........hakanD
  628. 0040:   72 75 54 65 6D 70 00 84   80 FF FF FF FF FF FF FF    ruTemp..........
  629. 0050:   FF FF FF FF 06 FF FF FF   FF FF FF FF FF FF FF FF    ................
  630. 0060:   01 A1 80 80 80 FF FF FF   00 68 61 6B 61 6E 50 61    .........hakanPa
  631. 0070:   6C 4F 6C 5F 64 00 84 80   FF FF FF FF FF FF FF FF    lOl_d...........
  632. 0080:   FF FF FF 04 FF FF FF FF   FF FF FF FF FF FF FF 01    ................
  633. 0090:   81 80 80 80 FF FF FF 00   68 61 6B 61 6E 50 61 6C    ........hakanPal
  634. 00A0:   54 65 6D 70 00 84 80 FF   FF FF FF FF FF FF FF FF    Temp............
  635. 00B0:   FF FF 04 FF FF FF FF FF   FF FF FF FF FF FF 01 A1    ................
  636. 00C0:   80 80 80 FF FF FF 00                                 .......         
  638. # 20 packet from server: type=0x0017(SERVER_CHARLISTREPLY) length=164 class=auth
  639. 0000:   A4 00 17 08 00 00 00 00   00 00 00 61 73 61 00 84    ...........asa..
  640. 0010:   80 FF FF FF FF FF FF FF   FF FF FF FF 07 FF FF FF    ................
  641. 0020:   FF FF FF FF FF FF FF FF   01 A1 80 80 80 FF FF FF    ................
  642. 0030:   00 70 61 6C 00 84 80 FF   FF FF FF FF FF FF FF FF    .pal............
  643. 0040:   FF FF 04 FF FF FF FF FF   FF FF FF FF FF FF 01 A1    ................
  644. 0050:   80 80 80 FF FF FF 00 73   6F 72 63 00 84 80 FF FF    .......sorc.....
  645. 0060:   FF FF FF FF FF FF FF FF   FF 02 FF FF FF FF FF FF    ................
  646. 0070:   FF FF FF FF FF 01 A1 80   80 80 FF FF FF 00 61 6D    ..............am
  647. 0080:   61 00 84 80 FF FF FF FF   FF FF FF FF FF FF FF 01    a...............
  648. 0090:   FF FF FF FF FF FF FF FF   FF FF FF 01 A1 80 80 80    ................
  649. 00A0:   FF FF FF 00                                          ....            
  652.      */
  654.     if (chardata_as_hex != NULL)
  655.     {
  656.         int  append_length;
  657.         char chardata[64];
  658. int  length;
  660.         length = hex_to_str(chardata_as_hex, chardata, 33); /* FIXME: make sure chardata_as_hex is long enough (33*3 (+1?) ) */
  661. /* Append a '' as terminator to character data */
  662. chardata[length] = '';
  663. length++;
  665.         append_length = packet_append_string (rpacket, name);
  666. eventlog(eventlog_level_debug, "add_charlistreq_packet", "length %d for name "%s"", append_length, name);
  668. append_length = packet_append_string (rpacket, chardata);
  669. eventlog(eventlog_level_debug, "add_charlistreq_packet", "length %d [%d] for character data", append_length, length); /* length should be == strlen(chardata) */
  671. return 1;
  672.     }
  674.     return 0;
  675. }