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

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

MySQL数据库

开发平台：

Visual C++

connection.c：源码内容
  1. /*
  2.  * Copyright (C) 2000,2001 Onlyer (onlyer@263.net)
  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. #include "setup.h"
  21. #include <ctype.h>
  22. #ifdef HAVE_STRING_H
  23. # include <string.h>
  24. #else
  25. # ifdef HAVE_STRINGS_H
  26. #  include <strings.h>
  27. # endif
  28. # ifdef HAVE_MEMORY_H
  29. #  include <memory.h>
  30. # endif
  31. #endif
  32. #ifdef STDC_HEADERS
  33. # include <stdlib.h>
  34. #else
  35. # ifdef HAVE_MALLOC_H
  36. #  include <malloc.h>
  37. # endif
  38. #endif
  39. #include "compat/memcpy.h"
  40. #include "compat/strdup.h"
  41. #ifdef HAVE_UNISTD_H
  42. # include <unistd.h>
  43. #endif
  44. #ifdef HAVE_SYS_TYPES_H
  45. # include <sys/types.h>
  46. #endif
  47. #ifdef HAVE_SYS_SOCKET_H
  48. # include <sys/socket.h>
  49. #endif
  50. #include "compat/psock.h"
  51. #ifdef HAVE_NETINET_IN_H
  52. # include <netinet/in.h>
  53. #endif
  54. #include "compat/netinet_in.h"
  55. #ifdef HAVE_LIMITS_H
  56. # include <limits.h>
  57. #endif
  58. #include "compat/char_bit.h"
  59. #ifdef TIME_WITH_SYS_TIME
  60. # include <time.h>
  61. # include <sys/time.h>
  62. #else
  63. # ifdef HAVE_SYS_TIME_H
  64. #  include <sys/time.h>
  65. # else
  66. #  include <time.h>
  67. # endif
  68. #endif
  70. #include "compat/psock.h"
  71. #include "compat/strcasecmp.h"
  72. #include "connection.h"
  73. #include "game.h"
  74. #include "gamequeue.h"
  75. #include "prefs.h"
  76. #include "d2gs.h"
  77. #include "net.h"
  78. #include "s2s.h"
  79. #include "handle_d2gs.h"
  80. #include "handle_d2cs.h"
  81. #include "handle_init.h"
  82. #include "handle_bnetd.h"
  83. #include "d2charfile.h"
  84. #include "common/fdwatch.h"
  85. #include "common/addr.h"
  86. #include "common/introtate.h"
  87. #include "common/network.h"
  88. #include "common/packet.h"
  89. #include "common/hashtable.h"
  90. #include "common/queue.h"
  91. #include "common/eventlog.h"
  92. #include "common/setup_after.h"
  94. static t_hashtable  * connlist_head=NULL;
  95. static t_hashtable * conn_charname_list_head=NULL;
  96. static t_list * connlist_dead=NULL;
  97. static unsigned int total_connection=0;
  99. static int conn_handle_connecting(t_connection * c);
  100. static int conn_create_packet(t_connection * c);
  101. static int conn_handle_packet(t_connection * c, t_packet * packet);
  102. static int conn_handle_read(t_connection * c);
  103. static int conn_handle_write(t_connection * c);
  104. static unsigned int conn_charname_hash(char const * charname);
  105. static unsigned int conn_sessionnum_hash(unsigned int sessionnum);
  107. static unsigned int conn_sessionnum_hash(unsigned int sessionnum)
  108. {
  109. return sessionnum;
  110. }
  112. static unsigned int conn_charname_hash(char const * charname)
  113. {
  114. unsigned int hash;
  115. unsigned int i, len, pos;
  116. unsigned int ch;
  118. ASSERT(charname,0);
  119. len=strlen(charname);
  120. for (hash=0, i=0, pos=0; i<len; i++) {
  121. if (isascii((int)charname[i])) {
  122. ch=(unsigned int)(unsigned char)tolower((int)charname[i]);
  123. } else {
  124. ch=(unsigned int)(unsigned char)charname[i];
  125. }
  126. hash ^= ROTL(ch,pos,sizeof(unsigned int) * CHAR_BIT);
  127. pos += CHAR_BIT-1;
  128. }
  129. return hash;
  130. }
  132. extern t_hashtable * d2cs_connlist(void)
  133. {
  134. return connlist_head;
  135. }
  137. extern int d2cs_connlist_create(void)
  138. {
  139. if (!(connlist_head=hashtable_create(200))) return -1;
  140. if (!(conn_charname_list_head=hashtable_create(200))) return -1;
  141. return 0;
  142. }
  144. extern int d2cs_connlist_destroy(void)
  145. {
  146. t_connection  * c;
  148. d2cs_connlist_reap();
  149. if (list_destroy(connlist_dead))
  150. eventlog(eventlog_level_error,__FUNCTION__,"error destroy conndead list");
  151. connlist_dead = NULL;
  153. BEGIN_HASHTABLE_TRAVERSE_DATA(connlist_head, c)
  154. {
  155. d2cs_conn_destroy(c);
  156. }
  157. END_HASHTABLE_TRAVERSE_DATA()
  159. if (hashtable_destroy(connlist_head)<0) {
  160. eventlog(eventlog_level_error,__FUNCTION__,"error destroy connection list");
  161. return -1;
  162. }
  163. connlist_head=NULL;
  165. if (hashtable_destroy(conn_charname_list_head)<0) {
  166. eventlog(eventlog_level_error,__FUNCTION__,"error destroy connection charname list");
  167. return -1;
  168. }
  169. conn_charname_list_head=NULL;
  170. return 0;
  171. }
  173. extern int d2cs_connlist_reap(void)
  174. {
  175. t_connection  * c;
  177. if (!connlist_dead) return 0;
  178. BEGIN_LIST_TRAVERSE_DATA(connlist_dead, c)
  179. {
  180. d2cs_conn_destroy(c);
  181. }
  182. END_LIST_TRAVERSE_DATA()
  184. return 0;
  185. }
  187. extern int conn_check_multilogin(t_connection const * c,char const * charname)
  188. {
  189. t_connection * conn;
  191. ASSERT(charname,-1);
  192. if (!prefs_check_multilogin()) return 0;
  193. if (gamelist_find_character(charname)) {
  194. return -1;
  195. }
  196. conn=d2cs_connlist_find_connection_by_charname(charname);
  197. if (conn && conn!=c) {
  198. return -1;
  199. }
  200. return 0;
  201. }
  203. extern t_connection * d2cs_connlist_find_connection_by_sessionnum(unsigned int sessionnum)
  204. {
  205. t_connection  * c;
  206. t_entry * curr;
  207. unsigned int hash;
  209. hash=conn_sessionnum_hash(sessionnum);
  210. HASHTABLE_TRAVERSE_MATCHING(connlist_head,curr,hash)
  211. {
  212. if (!(c=entry_get_data(curr))) {
  213. eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection in list");
  214. } else if (c->sessionnum==sessionnum) {
  215. hashtable_entry_release(curr);
  216. return c;
  217. }
  218. }
  219. return NULL;
  220. }
  222. extern t_connection * d2cs_connlist_find_connection_by_charname(char const * charname)
  223. {
  224. t_entry * curr;
  225. t_connection  * c;
  226. unsigned int hash;
  228. hash=conn_charname_hash(charname);
  229. HASHTABLE_TRAVERSE_MATCHING(connlist_head,curr,hash)
  230. {
  231. if (!(c=entry_get_data(curr))) {
  232. eventlog(eventlog_level_error,__FUNCTION__,"got NULL connection in list");
  233. } else {
  234. if (!c->charname) continue;
  235. if (!strcmp_charname(c->charname,charname)) {
  236. hashtable_entry_release(curr);
  237. return c;
  238. }
  239. }
  240. }
  241. return NULL;
  242. }
  244. static int conn_create_packet(t_connection * c)
  245. {
  246. t_packet * packet;
  248. switch (c->class) {
  249. CASE(conn_class_init, packet=packet_create(packet_class_init));
  250. CASE(conn_class_d2cs, packet=packet_create(packet_class_d2cs));
  251. CASE(conn_class_d2gs, packet=packet_create(packet_class_d2gs));
  252. CASE(conn_class_bnetd, packet=packet_create(packet_class_d2cs_bnetd));
  253. default:
  254. eventlog(eventlog_level_error,__FUNCTION__,"got bad connection class %d",c->class);
  255. return -1;
  256. }
  257. if (!packet) {
  258. eventlog(eventlog_level_error,__FUNCTION__,"error create packet");
  259. return 0;
  260. }
  261. conn_push_inqueue(c,packet);
  262. packet_del_ref(packet);
  263. return 0;
  264. }
  266. static int conn_handle_connecting(t_connection * c)
  267. {
  268. int retval;
  270. if (net_check_connected(c->sock)<0) {
  271. eventlog(eventlog_level_warn,__FUNCTION__,"can not connect to %s",addr_num_to_addr_str(c->addr, c->port));
  272. return -1;
  273. }
  274. eventlog(eventlog_level_info,__FUNCTION__,"connected to %s",addr_num_to_addr_str(c->addr, c->port));
  275. c->state=conn_state_init;
  276.         /* this is a kind of hack to not update fd but updating breaks kqueue
  277.          * and the clean fix would require a cache a userland copy of the kernel
  278.  * kqueue fds, considering that it also doesnt brake anything else should do
  279.  * for the moment 
  280. fdwatch_update_fd(c->sock, fdwatch_type_read); */
  281. switch (c->class) {
  282. case conn_class_bnetd:
  283. retval=handle_bnetd_init(c);
  284. break;
  285. default:
  286. eventlog(eventlog_level_error,__FUNCTION__,"got bad connection class %d",c->class);
  287. return -1;
  288. }
  289. return retval;
  290. }
  292. static int conn_handle_packet(t_connection * c, t_packet * packet)
  293. {
  294. int retval;
  296. switch (c->class) {
  297. CASE (conn_class_init, retval=d2cs_handle_init_packet(c,packet));
  298. CASE (conn_class_d2cs, retval=d2cs_handle_d2cs_packet(c,packet));
  299. CASE (conn_class_d2gs, retval=handle_d2gs_packet(c,packet));
  300. CASE (conn_class_bnetd, retval=handle_bnetd_packet(c,packet));
  301. default:
  302. eventlog(eventlog_level_error,__FUNCTION__,"got bad connection class %d (close connection)",c->class);
  303. retval=-1;
  304. break;
  305. }
  306. return retval;
  307. }
  309. static int conn_handle_read(t_connection * c)
  310. {
  311. t_packet * packet;
  312. int retval;
  314. if (!queue_get_length((t_queue const * const *)&c->inqueue)) {
  315. if (conn_create_packet(c)<0) return -1;
  316. c->insize=0;
  317. }
  318. if (!(packet=conn_peek_inqueue(c))) return 0;
  320. switch (net_recv_packet(c->sock,packet,&c->insize)) {
  321. case -1:
  322. retval=-1;
  323. break;
  324. case 0:
  325. retval=0;
  326. break;
  327. case 1:
  328. c->insize=0;
  329. packet=conn_pull_inqueue(c);
  330. retval=conn_handle_packet(c,packet);
  331. packet_del_ref(packet);
  332. break;
  333. default:
  334. retval=0;
  335. break;
  336. }
  337. return retval;
  338. }
  340. static int conn_handle_write(t_connection * c)
  341. {
  342. t_packet * packet;
  343. int retval;
  345. if (c->state==conn_state_connecting) {
  346. return conn_handle_connecting(c);
  347. }
  349. if (!(packet=conn_peek_outqueue(c))) return 0;
  351. switch (net_send_packet(c->sock, packet, &c->outsize)) {
  352. case -1:
  353. retval=-1;
  354. break;
  355. case 0:
  356. retval=0;
  357. break;
  358. case 1:
  359. c->outsize=0;
  360. packet=conn_pull_outqueue(c);
  361. packet_del_ref(packet);
  362. retval=0;
  363. break;
  364. default:
  365. retval = -1;
  366. }
  367. return retval;
  368. }
  370. extern int conn_handle_socket(t_connection * c)
  371. {
  372. time_t now;
  374. ASSERT(c,-1);
  375. now=time(NULL);
  376. if (c->socket_flag & SOCKET_FLAG_READ) {
  377. if (conn_handle_read(c)<0) return -1;
  378. c->last_active=now;
  379. }
  380. if (c->socket_flag & SOCKET_FLAG_WRITE) {
  381. if (conn_handle_write(c)<0) return -1;
  382. c->last_active=now;
  383. }
  384. c->socket_flag=0;
  385. return 0;
  386. }
  388. extern int connlist_check_timeout(void)
  389. {
  390. t_connection * c;
  391. time_t now;
  393. now=time(NULL);
  394. BEGIN_HASHTABLE_TRAVERSE_DATA(connlist_head, c)
  395. {
  396. switch (c->class) {
  397. case conn_class_d2cs:
  398. if (prefs_get_idletime() && (now - c->last_active > prefs_get_idletime())) {
  399. eventlog(eventlog_level_info,__FUNCTION__,"client %d idled too long time, destroy it",c->sessionnum);
  400. d2cs_conn_set_state(c,conn_state_destroy);
  401. }
  402. break;
  403. case conn_class_d2gs:
  404. if (prefs_get_s2s_idletime() && now - c->last_active > prefs_get_s2s_idletime()) {
  405. eventlog(eventlog_level_info,__FUNCTION__,"server %d timed out",c->sessionnum);
  406. d2cs_conn_set_state(c,conn_state_destroy);
  407. }
  408. break;
  409. case conn_class_bnetd:
  410. break;
  411. default:
  412. break;
  413. }
  414. }
  415. END_HASHTABLE_TRAVERSE_DATA()
  416. return 0;
  417. }
  419. extern t_connection * d2cs_conn_create(int sock, unsigned int local_addr, unsigned short local_port, 
  420. unsigned int addr, unsigned short port)
  421. {
  422. static unsigned int sessionnum=1;
  423. t_connection * c;
  425. if (sock<0) {
  426. eventlog(eventlog_level_error,__FUNCTION__,"got bad socket");
  427. return NULL;
  428. }
  429. if (!(c=malloc(sizeof(t_connection)))) {
  430. eventlog(eventlog_level_error,__FUNCTION__,"error allocate connection");
  431. return NULL;
  432. }
  433. c->charname=NULL;
  434. c->account=NULL;
  435. c->sock=sock;
  436. c->socket_flag=0;
  437. c->local_addr=local_addr;
  438. c->local_port=local_port;
  439. c->addr=addr;
  440. c->port=port;
  441. c->class=conn_class_init;
  442. c->state=conn_state_init;
  443. c->sessionnum=sessionnum++;
  444. c->outqueue=NULL;
  445. c->inqueue=NULL;
  446. c->outsize=0;
  447. c->outsizep=0;
  448. c->insize=0;
  449. c->charinfo=NULL;
  450. c->d2gs_id=0;
  451. c->gamequeue=NULL;
  452. c->last_active=time(NULL);
  453. c->sessionnum_hash=conn_sessionnum_hash(c->sessionnum);
  454. c->bnetd_sessionnum=0;
  455. c->charname_hash=0;
  456. if (hashtable_insert_data(connlist_head, c, c->sessionnum_hash)<0) {
  457. free(c);
  458. eventlog(eventlog_level_error,__FUNCTION__,"error add connection to list");
  459. return NULL;
  460. }
  461. total_connection++;
  462. eventlog(eventlog_level_info,__FUNCTION__,"created session=%d socket=%d (%d current connections)", c->sessionnum, sock, total_connection);
  463. return c;
  464. }
  466. extern int d2cs_conn_destroy(t_connection * c)
  467. {
  469. ASSERT(c,-1);
  470. if (c->state==conn_state_destroying) return 0;
  471. if (hashtable_remove_data(connlist_head,c,c->sessionnum_hash)<0) {
  472. eventlog(eventlog_level_error,__FUNCTION__,"error remove connection from list");
  473. return -1;
  474. }
  475. c->state=conn_state_destroying;
  476. if (c->d2gs_id && c->class==conn_class_d2gs) {
  477. d2gs_deactive(d2gslist_find_gs(c->d2gs_id),c);
  478. }
  479. if (c->class==conn_class_bnetd) {
  480. s2s_destroy(c);
  481. }
  482. if (c->gamequeue) {
  483. gq_destroy(c->gamequeue);
  484. }
  485. if (c->account) free((void *)c->account);
  486. if (c->charinfo) free((void *)c->charinfo);
  487. if (c->charname) d2cs_conn_set_charname(c,NULL);
  488. queue_clear(&c->inqueue);
  489. queue_clear(&c->outqueue);
  491. if (connlist_dead) list_remove_data(connlist_dead, c);
  492. fdwatch_del_fd(c->sock);
  493. psock_shutdown(c->sock,PSOCK_SHUT_RDWR);
  494. psock_close(c->sock);
  496. total_connection--;
  497. eventlog(eventlog_level_info,__FUNCTION__,"[%d] closed connection %d (%d left)",c->sock,c->sessionnum,total_connection);
  498. free(c);
  499. return 0;
  500. }
  502. extern int d2cs_conn_get_socket(t_connection const * c)
  503. {
  504. ASSERT(c,-1);
  505. return c->sock;
  506. }
  508. extern t_conn_state d2cs_conn_get_state(t_connection const * c)
  509. {
  510. ASSERT(c,conn_state_none);
  511. return c->state;
  512. }
  514. extern int d2cs_conn_set_state(t_connection * c, t_conn_state state)
  515. {
  516. ASSERT(c,-1);
  517. /* special case for destroying connections, add them to connlist_dead list */
  518. if (state == conn_state_destroy && c->state != conn_state_destroy) {
  519.     if (!connlist_dead && !(connlist_dead = list_create())) {
  520. eventlog(eventlog_level_error, __FUNCTION__, "could not initilize connlist_dead list");
  521. return -1;
  522.     }
  523.     list_append_data(connlist_dead, c);
  524. } else if (state != conn_state_destroy && c->state == conn_state_destroy) {
  525.     if (list_remove_data(connlist_dead, c)) {
  526. eventlog(eventlog_level_error, __FUNCTION__, "could not remove dead connection");
  527. return -1;
  528.     }
  529. }
  530. c->state=state;
  531. return 0;
  532. }
  534. extern t_conn_class d2cs_conn_get_class(t_connection const * c)
  535. {
  536. ASSERT(c,conn_class_none);
  537. return c->class;
  538. }
  540. extern int d2cs_conn_set_class(t_connection * c, t_conn_class class)
  541. {
  542. ASSERT(c,-1);
  543. c->class=class;
  544. return 0;
  545. }
  547. extern t_queue * * d2cs_conn_get_in_queue(t_connection const * c)
  548. {
  549. ASSERT(c,NULL);
  550. return (t_queue * *)&c->inqueue;
  551. }
  553. extern unsigned int d2cs_conn_get_out_size(t_connection const * c)
  554. {
  555. ASSERT(c,0);
  556. return c->outsize;
  557. }
  559. extern t_queue * * d2cs_conn_get_out_queue(t_connection const * c)
  560. {
  561. ASSERT(c,NULL);
  562. return (t_queue * *)&c->outqueue;
  563. }
  565. extern unsigned int d2cs_conn_get_in_size(t_connection const * c)
  566. {
  567. ASSERT(c,0);
  568. return c->insize;
  569. }
  571. extern int conn_push_outqueue(t_connection * c, t_packet * packet)
  572. {
  573.     if (!c)
  574.     {
  575.         eventlog(eventlog_level_error, __FUNCTION__, "got NULL connection");
  576.         return -1;
  577.     }
  579.     if (!packet)
  580.     {
  581.         eventlog(eventlog_level_error, __FUNCTION__, "got NULL packet");
  582.         return -1;
  583.     }
  585.     queue_push_packet((t_queue * *)&c->outqueue, packet);
  586.     if (!c->outsizep++) fdwatch_update_fd(c->sock, fdwatch_type_read | fdwatch_type_write);
  588.     return 0;
  589. }
  591. extern t_packet * conn_peek_outqueue(t_connection * c)
  592. {
  593.     if (!c)
  594.     {
  595.         eventlog(eventlog_level_error, __FUNCTION__, "got NULL connection");
  596.         return NULL;
  597.     }
  599.     return queue_peek_packet((t_queue const * const *)&c->outqueue);
  600. }
  602. extern t_packet * conn_pull_outqueue(t_connection * c)
  603. {
  604.     if (!c)
  605.     {
  606.         eventlog(eventlog_level_error, __FUNCTION__, "got NULL connection");
  607.         return NULL;
  608.     }
  610.     if (c->outsizep) {
  611.         if (!(--c->outsizep)) fdwatch_update_fd(c->sock, fdwatch_type_read);
  612.         return queue_pull_packet((t_queue * *)&c->outqueue);
  613.     }
  615.     return NULL;
  616. }
  618. extern int conn_push_inqueue(t_connection * c, t_packet * packet)
  619. {
  620.     if (!c)
  621.     {
  622.         eventlog(eventlog_level_error, __FUNCTION__, "got NULL connection");
  623.         return -1;
  624.     }
  626.     if (!packet)
  627.     {
  628.         eventlog(eventlog_level_error, __FUNCTION__, "got NULL packet");
  629.         return -1;
  630.     }
  632.     queue_push_packet((t_queue * *)&c->inqueue, packet);
  634.     return 0;
  635. }
  637. extern t_packet * conn_peek_inqueue(t_connection * c)
  638. {
  639.     if (!c)
  640.     {
  641.         eventlog(eventlog_level_error, __FUNCTION__, "got NULL connection");
  642.         return NULL;
  643.     }
  645.     return queue_peek_packet((t_queue const * const *)&c->inqueue);
  646. }
  648. extern t_packet * conn_pull_inqueue(t_connection * c)
  649. {
  650.     if (!c)
  651.     {
  652.         eventlog(eventlog_level_error, __FUNCTION__, "got NULL connection");
  653.         return NULL;
  654.     }
  656.     return queue_pull_packet((t_queue * *)&c->inqueue);
  657. }
  659. extern int conn_add_socket_flag(t_connection * c, unsigned int flag)
  660. {
  661. ASSERT(c,-1);
  662. c->socket_flag |= flag;
  663. return 0;
  664. }
  666. extern int conn_process_packet(t_connection * c, t_packet * packet, t_packet_handle_table * table,
  667. unsigned int table_size)
  668. {
  669.         unsigned int     type;
  670.         unsigned int     size;
  672. ASSERT(c,-1);
  673.         ASSERT(packet,-1);
  674. ASSERT(table,-1);
  675.         type=packet_get_type(packet);
  676.         size=packet_get_size(packet);
  678.         if (type >= table_size || !table[type].size) {
  679. eventlog(eventlog_level_error,__FUNCTION__,"got bad packet type %d (class %d)",type,packet_get_class(packet));
  680. return -1;
  681. }
  682. if (size < table[type].size) {
  683. eventlog(eventlog_level_error,__FUNCTION__,"got bad packet size %d (type %d class %d)",size,type,packet_get_class(packet));
  684. return -1;
  685. }
  686. if (!(c->state & table[type].state)) {
  687. eventlog(eventlog_level_error,__FUNCTION__,"connection %d state mismatch for packet type %d (class %d)",c->sessionnum,
  688. type,packet_get_class(packet));
  689. return -1;
  690. }
  691. if (!table[type].handler) {
  692. eventlog(eventlog_level_error,__FUNCTION__,"missing handler for packet type %d (class %d)",type,packet_get_class(packet));
  693. return -1;
  694. }
  695. return table[type].handler(c,packet);
  696. }
  698. extern int d2cs_conn_set_account(t_connection * c, char const * account)
  699. {
  700. char const * temp;
  702. ASSERT(c,-1);
  703. if (!account) {
  704. if (c->account) free((void *)c->account);
  705. c->account=NULL;
  706. }
  707. if (!(temp=strdup(account))) {
  708. eventlog(eventlog_level_error,__FUNCTION__,"error allocate temp for account");
  709. return -1;
  710. }
  711. if (c->account) free((void *)c->account);
  712. c->account=temp;
  713. return 0;
  714. }
  716. extern char const * d2cs_conn_get_account(t_connection const * c)
  717. {
  718. ASSERT(c,NULL);
  719. return c->account;
  720. }
  722. extern int d2cs_conn_set_charname(t_connection * c, char const * charname)
  723. {
  724. char const * temp;
  726. ASSERT(c,-1);
  727. temp=NULL;
  728. if (charname && !(temp=strdup(charname))) {
  729. eventlog(eventlog_level_error,__FUNCTION__,"error allocate temp for charname");
  730. return -1;
  731. }
  732. if (c->charname) {
  733. if (hashtable_remove_data(conn_charname_list_head,c,c->charname_hash) <0) {
  734. eventlog(eventlog_level_error,__FUNCTION__,"error remove charname %s from list",charname);
  735. if (temp) free((void *)temp);
  736. return -1;
  737. }
  738. hashtable_purge(conn_charname_list_head);
  739. free((void *)c->charname);
  740. }
  741. if (charname) {
  742. c->charname=temp;
  743. c->charname_hash=conn_charname_hash(charname);
  744. if (hashtable_insert_data(conn_charname_list_head,c,c->charname_hash) <0) {
  745. eventlog(eventlog_level_error,__FUNCTION__,"error insert charname %s to list",charname);
  746. free((void *)c->charname);
  747. c->charname=NULL;
  748. return -1;
  749. }
  750. } else {
  751. c->charname=NULL;
  752. c->charname_hash=0;
  753. }
  754. return 0;
  755. }
  757. extern char const * d2cs_conn_get_charname(t_connection const * c)
  758. {
  759. ASSERT(c,NULL);
  760. return c->charname;
  761. }
  763. extern unsigned int d2cs_conn_get_sessionnum(t_connection const * c)
  764. {
  765. ASSERT(c,0);
  766. return c->sessionnum;
  767. }
  769. extern unsigned int conn_get_charinfo_ladder(t_connection const * c)
  770. {
  771. ASSERT(c,0);
  772. return d2charinfo_get_ladder(c->charinfo);
  773. }
  775. extern unsigned int conn_get_charinfo_expansion(t_connection const * c)
  776. {
  777. ASSERT(c,0);
  778. return d2charinfo_get_expansion(c->charinfo);
  779. }
  781. extern unsigned int conn_get_charinfo_hardcore(t_connection const * c)
  782. {
  783. ASSERT(c,0);
  784. return d2charinfo_get_hardcore(c->charinfo);
  785. }
  787. extern unsigned int conn_get_charinfo_dead(t_connection const * c)
  788. {
  789. ASSERT(c,0);
  790. return d2charinfo_get_dead(c->charinfo);
  791. }
  793. extern unsigned int conn_get_charinfo_difficulty(t_connection const * c)
  794. {
  795. ASSERT(c,0);
  796. return d2charinfo_get_difficulty(c->charinfo);
  797. }
  799. extern unsigned int conn_get_charinfo_level(t_connection const * c)
  800. {
  801. ASSERT(c,0);
  802. return d2charinfo_get_level(c->charinfo);
  803. }
  805. extern unsigned int conn_get_charinfo_class(t_connection const * c)
  806. {
  807. ASSERT(c,0);
  808. return d2charinfo_get_class(c->charinfo);
  809. }
  811. extern int conn_set_charinfo(t_connection * c, t_d2charinfo_summary const * charinfo)
  812. {
  813. t_d2charinfo_summary * temp;
  815. ASSERT(c,-1);
  816. if (!charinfo) {
  817. if (c->charinfo) free((void *)c->charinfo);
  818. c->charinfo=NULL;
  819. return 0;
  820. }
  821. if (!(temp=malloc(sizeof(t_d2charinfo_summary)))) {
  822. eventlog(eventlog_level_error,__FUNCTION__,"error allocate temp for charinfo");
  823. return -1;
  824. }
  825. if (c->charinfo) free((void *)c->charinfo);
  826. memcpy(temp,charinfo,sizeof(t_d2charinfo_summary));
  827. c->charinfo=temp;
  828. return 0;
  829. }
  831. extern int conn_set_d2gs_id(t_connection * c, unsigned int d2gs_id)
  832. {
  833. ASSERT(c,-1)
  834. c->d2gs_id=d2gs_id;
  835. return 0;
  836. }
  838. extern unsigned int conn_get_d2gs_id(t_connection const * c)
  839. {
  840. ASSERT(c,0)
  841. return c->d2gs_id;
  842. }
  844. extern unsigned int d2cs_conn_get_addr(t_connection const * c)
  845. {
  846. ASSERT(c,0);
  847. return c->addr;
  848. }
  850. extern unsigned short d2cs_conn_get_port(t_connection const * c)
  851. {
  852. ASSERT(c,0);
  853. return c->port;
  854. }
  856. extern t_gq * conn_get_gamequeue(t_connection const * c)
  857. {
  858. ASSERT(c,NULL);
  859. return c->gamequeue;
  860. }
  862. extern int conn_set_gamequeue(t_connection * c, t_gq * gq)
  863. {
  864. ASSERT(c,-1);
  865. c->gamequeue=gq;
  866. return 0;
  867. }
  869. extern int conn_set_bnetd_sessionnum(t_connection * c, unsigned int sessionnum)
  870. {
  871. ASSERT(c,-1);
  872. c->bnetd_sessionnum=sessionnum;
  873. return 0;
  874. }
  876. extern unsigned int conn_get_bnetd_sessionnum(t_connection const * c)
  877. {
  878. ASSERT(c,-1);
  879. return c->bnetd_sessionnum;
  880. }