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

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

MySQL数据库

开发平台：

Visual C++

server.c：源码内容
  1. /*
  2.  * Copyright (C) 1998,1999  Mark Baysinger (mbaysing@ucsd.edu)
  3.  * Copyright (C) 1998,1999,2000,2001  Ross Combs (rocombs@cs.nmsu.edu)
  4.  * Copyright (C) 2000,2001  Marco Ziech (mmz@gmx.net)
  5.  *
  6.  * This program is free software; you can redistribute it and/or
  7.  * modify it under the terms of the GNU General Public License
  8.  * as published by the Free Software Foundation; either version 2
  9.  * of the License, or (at your option) any later version.
  10.  *
  11.  * This program is distributed in the hope that it will be useful,
  12.  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.  * GNU General Public License for more details.
  15.  *
  16.  * You should have received a copy of the GNU General Public License
  17.  * along with this program; if not, write to the Free Software
  18.  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  19.  */
  20. #define SERVER_INTERNAL_ACCESS
  21. #include "common/setup_before.h"
  22. #include <stdio.h>
  23. #ifdef WIN32
  24. # include <conio.h> /* for kbhit() and getch() */
  25. #endif
  26. #ifdef HAVE_STDDEF_H
  27. # include <stddef.h>
  28. #else
  29. # ifndef NULL
  30. #  define NULL ((void *)0)
  31. # endif
  32. #endif
  33. #ifdef STDC_HEADERS
  34. # include <stdlib.h>
  35. #else
  36. # ifdef HAVE_MALLOC_H
  37. #  include <malloc.h>
  38. # endif
  39. #endif
  40. #ifdef HAVE_UNISTD_H
  41. # include <unistd.h>
  42. #endif
  43. #ifdef HAVE_FCNTL_H
  44. # include <fcntl.h>
  45. #else
  46. # ifdef HAVE_SYS_FILE_H
  47. #  include <sys/file.h>
  48. # endif
  49. #endif
  50. #ifdef HAVE_STRING_H
  51. # include <string.h>
  52. #else
  53. # ifdef HAVE_STRINGS_H
  54. #  include <strings.h>
  55. # endif
  56. # ifdef HAVE_MEMORY_H
  57. #  include <memory.h>
  58. # endif
  59. #endif
  60. #include "compat/memset.h"
  61. #include <errno.h>
  62. #include "compat/strerror.h"
  63. #ifdef TIME_WITH_SYS_TIME
  64. # include <sys/time.h>
  65. # include <time.h>
  66. #else
  67. # ifdef HAVE_SYS_TIME_H
  68. #  include <sys/time.h>
  69. # else
  70. #  include <time.h>
  71. # endif
  72. #endif
  73. #include "compat/difftime.h"
  74. #ifdef HAVE_SYS_TYPES_H
  75. # include <sys/types.h>
  76. #endif
  77. #ifdef DO_POSIXSIG
  78. # include <signal.h>
  79. # include "compat/signal.h"
  80. #endif
  81. #ifdef HAVE_SYS_SOCKET_H
  82. # include <sys/socket.h>
  83. #endif
  84. #include "compat/socket.h"
  85. #ifdef HAVE_SYS_PARAM_H
  86. # include <sys/param.h>
  87. #endif
  88. #ifdef HAVE_NETINET_IN_H
  89. # include <netinet/in.h>
  90. #endif
  91. #include "compat/netinet_in.h"
  92. #ifdef HAVE_ARPA_INET_H
  93. # include <arpa/inet.h>
  94. #endif
  95. #ifdef HAVE_NETDB_H
  96. # include <netdb.h>
  97. #endif
  98. #include "compat/inet_ntoa.h"
  99. #include "compat/psock.h"
  100. #include "common/packet.h"
  101. #include "connection.h"
  102. #include "common/hexdump.h"
  103. #include "common/eventlog.h"
  104. #include "message.h"
  105. #include "common/queue.h"
  106. #include "handle_auth.h"
  107. #include "handle_bnet.h"
  108. #include "handle_bot.h"
  109. #include "handle_telnet.h"
  110. #include "handle_file.h"
  111. #include "handle_init.h"
  112. #include "handle_d2cs.h"
  113. #include "handle_irc.h"
  114. #include "handle_udp.h"
  115. #include "common/network.h"
  116. #include "prefs.h"
  117. #include "account.h"
  118. #include "common/tracker.h"
  119. #include "common/list.h"
  120. #include "adbanner.h"
  121. #include "timer.h"
  122. #include "common/addr.h"
  123. #include "common/util.h"
  124. #include "common/rlimit.h"
  125. #include "ipban.h"
  126. #include "helpfile.h"
  127. #include "gametrans.h"
  128. #include "autoupdate.h"
  129. #include "versioncheck.h"
  130. #include "realm.h"
  131. #include "channel.h"
  132. #include "game.h"
  133. #include "anongame.h"
  134. #include "server.h"
  135. #include "command_groups.h"
  136. #ifdef WIN32
  137. # include "win32/service.h"
  138. #endif
  139. // aaron
  140. #include "ladder.h"
  141. #include "output.h"
  142. #include "alias_command.h"
  143. #include "anongame_infos.h"
  144. #include "news.h"
  145. #include "common/fdwatch.h"
  146. #include "clan.h"
  147. #include "w3trans.h"
  148. #include "tournament.h"
  149. #include "common/setup_after.h"
  151. extern FILE * hexstrm; /* from main.c */
  152. extern int g_ServiceStatus;
  154. #ifdef DO_POSIXSIG
  155. static void quit_sig_handle(int unused);
  156. static void restart_sig_handle(int unused);
  157. static void save_sig_handle(int unused);
  158. #ifdef HAVE_SETITIMER
  159. static void timer_sig_handle(int unused);
  160. #endif
  161. #endif
  162. #ifdef USE_CHECK_ALLOC
  163. static void memstat_sig_handle(int unused);
  164. #endif
  167. time_t now;
  168. static time_t starttime;
  169. static time_t curr_exittime;
  170. static volatile time_t sigexittime=0;
  171. static volatile int do_restart=0;
  172. static volatile int do_save=0;
  173. static volatile int got_epipe=0;
  174. #ifdef USE_CHECK_ALLOC
  175. static volatile int do_report_usage=0;
  176. #endif
  177. static char const * server_name=NULL;
  179. extern void server_quit_delay(unsigned int delay)
  180. {
  181.     if (delay)
  182. sigexittime = time(NULL)+(time_t)delay;
  183.     else
  184. sigexittime = 0;
  185. }
  188. extern void server_quit_wraper(void)
  189. {
  190.     if (sigexittime)
  191. sigexittime -= prefs_get_shutdown_decr();
  192.     else
  193. sigexittime = time(NULL)+(time_t)prefs_get_shutdown_delay();
  194. }
  196. extern void server_restart_wraper(void){
  197.     do_restart = 1;
  198. }
  200. extern void server_save_wraper(void){
  201.     do_save = 1;
  202. }
  204. #ifdef DO_POSIXSIG
  205. static void quit_sig_handle(int unused)
  206. {
  207.     server_quit_wraper();
  208. }
  211. static void restart_sig_handle(int unused)
  212. {
  213.     do_restart = 1;
  214. }
  217. static void save_sig_handle(int unused)
  218. {
  219.     do_save = 1;
  220. }
  222. static void pipe_sig_handle(int unused)
  223. {
  224.     got_epipe = 1;
  225. }
  227. #ifdef HAVE_SETITIMER
  228. static void timer_sig_handle(int unused)
  229. {
  230.     time(&now);
  231. }
  232. #endif
  233. #endif
  236. #ifdef USE_CHECK_ALLOC
  237. static void memstat_sig_handle(int unused)
  238. {
  239.     do_report_usage = 1;
  240. }
  241. #endif
  244. extern unsigned int server_get_uptime(void)
  245. {
  246.     return (unsigned int)difftime(time(NULL),starttime);
  247. }
  250. extern unsigned int server_get_starttime(void)
  251. {
  252.     return (unsigned int)starttime;
  253. }
  256. static char const * laddr_type_get_str(t_laddr_type laddr_type)
  257. {
  258.     switch (laddr_type)
  259.     {
  260.     case laddr_type_bnet:
  261. return "bnet";
  262. case laddr_type_w3route:
  263. return "w3route";
  264.     case laddr_type_irc:
  265. return "irc";
  266.     case laddr_type_telnet:
  267. return "telnet";
  268.     default:
  269. return "UNKNOWN";
  270.     }
  271. }
  274. static int handle_accept(void *data, t_fdwatch_type rw);
  275. static int handle_tcp(void *data, t_fdwatch_type rw);
  276. static int handle_udp(void *data, t_fdwatch_type rw);
  279. static int sd_accept(t_addr const * curr_laddr, t_laddr_info const * laddr_info, int ssocket, int usocket)
  280. {
  281.     char               tempa[32];
  282.     int                csocket;
  283.     struct sockaddr_in caddr;
  284.     psock_t_socklen    caddr_len;
  285.     unsigned int       raddr;
  286.     unsigned short     rport;
  287.     
  288.     /* dont accept new connections while shutdowning */
  289.     if (curr_exittime) {
  290. if ((csocket = psock_accept(ssocket, NULL, NULL)) > 0) {
  291.     psock_shutdown(csocket,PSOCK_SHUT_RDWR);
  292.     psock_close(csocket);
  293. }
  294. return 0;
  295.     }
  297.     if (!addr_get_addr_str(curr_laddr,tempa,sizeof(tempa)))
  298. strcpy(tempa,"x.x.x.x:x");
  299.     
  300.     /* accept the connection */
  301.     memset(&caddr,0,sizeof(caddr)); /* not sure if this is needed... modern systems are ok anyway */
  302.     caddr_len = sizeof(caddr);
  303.     if ((csocket = psock_accept(ssocket,(struct sockaddr *)&caddr,&caddr_len))<0)
  304.     {
  305. /* BSD, POSIX error for aborted connections, SYSV often uses EAGAIN or EPROTO */
  306. if (
  307. #ifdef PSOCK_EWOULDBLOCK
  308.     psock_errno()==PSOCK_EWOULDBLOCK ||
  309. #endif
  310. #ifdef PSOCK_ECONNABORTED
  311.     psock_errno()==PSOCK_ECONNABORTED ||
  312. #endif
  313. #ifdef PSOCK_EPROTO
  314.     psock_errno()==PSOCK_EPROTO ||
  315. #endif
  316.     0)
  317.     eventlog(eventlog_level_error,"sd_accept","client aborted connection on %s (psock_accept: %s)",tempa,strerror(psock_errno()));
  318. else /* EAGAIN can mean out of resources _or_ connection aborted :( */
  319.     if (
  320. #ifdef PSOCK_EINTR
  321. psock_errno()!=PSOCK_EINTR &&
  322. #endif
  323. 1)
  324. eventlog(eventlog_level_error,"sd_accept","could not accept new connection on %s (psock_accept: %s)",tempa,strerror(psock_errno()));
  325. return -1;
  326.     }
  327.     if (csocket >= fdw_maxfd)       /* This check is a bit too strict (csocket is probably
  328.                                      * greater than the number of connections) but this makes
  329.                                      * life easier later.
  330.                                      */
  331.     {
  332. eventlog(eventlog_level_error,"sd_accept","csocket is beyond range allowed by get_socket_limit() (%d>=%d)",csocket,fdw_maxfd);
  333. psock_close(csocket);
  334. return -1;
  335.     }
  337.     if (ipbanlist_check(inet_ntoa(caddr.sin_addr))!=0)
  338.     {
  339. eventlog(eventlog_level_error,"sd_accept","[%d] connection from banned address %s denied (closing connection)",csocket,inet_ntoa(caddr.sin_addr));
  340. psock_close(csocket);
  341. return -1;
  342.     }
  344.     if ((prefs_get_max_conns_per_IP()!=0) && 
  345. (connlist_count_connections(ntohl(caddr.sin_addr.s_addr)) > prefs_get_max_conns_per_IP()))
  346.     {
  347. eventlog(eventlog_level_error,__FUNCTION__,"[%d] too many connections from address %s (closing connection)",csocket,inet_ntoa(caddr.sin_addr));
  348. psock_close(csocket);
  349. return -1;
  350.     }
  351.     
  352.     eventlog(eventlog_level_info,"sd_accept","[%d] accepted connection from %s on %s",csocket,addr_num_to_addr_str(ntohl(caddr.sin_addr.s_addr),ntohs(caddr.sin_port)),tempa);
  353.     
  354.     if (prefs_get_use_keepalive())
  355.     {
  356. int val=1;
  358. if (psock_setsockopt(csocket,PSOCK_SOL_SOCKET,PSOCK_SO_KEEPALIVE,&val,(psock_t_socklen)sizeof(val))<0)
  359.     eventlog(eventlog_level_error,"sd_accept","[%d] could not set socket option SO_KEEPALIVE (psock_setsockopt: %s)",csocket,strerror(psock_errno()));
  360. /* not a fatal error */
  361.     }
  362.     
  363.     {
  364. struct sockaddr_in rsaddr;
  365. psock_t_socklen    rlen;
  367. memset(&rsaddr,0,sizeof(rsaddr)); /* not sure if this is needed... modern systems are ok anyway */
  368. rlen = sizeof(rsaddr);
  369. if (psock_getsockname(csocket,(struct sockaddr *)&rsaddr,&rlen)<0)
  370. {
  371.     eventlog(eventlog_level_error,"sd_accept","[%d] unable to determine real local port (psock_getsockname: %s)",csocket,strerror(psock_errno()));
  372.     /* not a fatal error */
  373.     raddr = addr_get_ip(curr_laddr);
  374.     rport = addr_get_port(curr_laddr);
  375. }
  376. else
  377. {
  378.     if (rsaddr.sin_family!=PSOCK_AF_INET)
  379.     {
  380. eventlog(eventlog_level_error,"sd_accept","local address returned with bad address family %d",(int)rsaddr.sin_family);
  381. /* not a fatal error */
  382. raddr = addr_get_ip(curr_laddr);
  383. rport = addr_get_port(curr_laddr);
  384.     }
  385.     else
  386.     {
  387. raddr = ntohl(rsaddr.sin_addr.s_addr);
  388. rport = ntohs(rsaddr.sin_port);
  389.     }
  390. }
  391.     }
  392.     
  393.     if (psock_ctl(csocket,PSOCK_NONBLOCK)<0)
  394.     {
  395. eventlog(eventlog_level_error,"sd_accept","[%d] could not set TCP socket to non-blocking mode (closing connection) (psock_ctl: %s)",csocket,strerror(psock_errno()));
  396. psock_close(csocket);
  397. return -1;
  398.     }
  399.     
  400.     {
  401. t_connection * c;
  403. if (!(c = conn_create(csocket,usocket,raddr,rport,addr_get_ip(curr_laddr),addr_get_port(curr_laddr),ntohl(caddr.sin_addr.s_addr),ntohs(caddr.sin_port))))
  404. {
  405.     eventlog(eventlog_level_error,"sd_accept","[%d] unable to create new connection (closing connection)",csocket);
  406.     psock_close(csocket);
  407.     return -1;
  408. }
  410. eventlog(eventlog_level_debug,"sd_accept","[%d] client connected to a %s listening address",csocket,laddr_type_get_str(laddr_info->type));
  411. fdwatch_add_fd(csocket, fdwatch_type_read, handle_tcp, c);
  412. switch (laddr_info->type)
  413. {
  414. case laddr_type_irc:
  415.     conn_set_class(c,conn_class_irc);
  416.     conn_set_state(c,conn_state_connected);
  417.     break;
  418. case laddr_type_w3route:
  419. conn_set_class(c,conn_class_w3route);
  420. conn_set_state(c,conn_state_connected);
  421. break;
  422. case laddr_type_telnet:
  423.     conn_set_class(c,conn_class_telnet);
  424.     conn_set_state(c,conn_state_connected);
  425.     break;
  426. case laddr_type_bnet:
  427. default:
  428.     /* We have to wait for an initial "magic" byte on bnet connections to
  429.              * tell us exactly what connection class we are dealing with.
  430.              */
  431.     break;
  432. }
  433.     }
  435.     return 0;
  436. }
  439. static int sd_udpinput(t_addr * const curr_laddr, t_laddr_info const * laddr_info, int ssocket, int usocket)
  440. {
  441.     int             err;
  442.     psock_t_socklen errlen;
  443.     t_packet *      upacket;
  444.     
  445.     err = 0;
  446.     errlen = sizeof(err);
  447.     if (psock_getsockopt(usocket,PSOCK_SOL_SOCKET,PSOCK_SO_ERROR,&err,&errlen)<0)
  448.     {
  449.         eventlog(eventlog_level_error,"sd_udpinput","[%d] unable to read socket error (psock_getsockopt: %s)",usocket,strerror(psock_errno()));
  450. return -1;
  451.     }
  452.     if (errlen && err) /* if it was an error, there is no packet to read */
  453.     {
  454. eventlog(eventlog_level_error,"sd_udpinput","[%d] async UDP socket error notification (psock_getsockopt: %s)",usocket,strerror(err));
  455. return -1;
  456.     }
  457.     if (!(upacket = packet_create(packet_class_udp)))
  458.     {
  459. eventlog(eventlog_level_error,"sd_udpinput","could not allocate raw packet for input");
  460. return -1;
  461.     }
  462.     
  463.     {
  464. struct sockaddr_in fromaddr;
  465. psock_t_socklen    fromlen;
  466. int                len;
  468. fromlen = sizeof(fromaddr);
  469. if ((len = psock_recvfrom(usocket,packet_get_raw_data_build(upacket,0),MAX_PACKET_SIZE,0,(struct sockaddr *)&fromaddr,&fromlen))<0)
  470. {
  471.     if (
  472. #ifdef PSOCK_EINTR
  473. psock_errno()!=PSOCK_EINTR &&
  474. #endif
  475. #ifdef PSOCK_EAGAIN
  476. psock_errno()!=PSOCK_EAGAIN &&
  477. #endif
  478. #ifdef PSOCK_EWOULDBLOCK
  479. psock_errno()!=PSOCK_EWOULDBLOCK &&
  480. #endif
  481. #ifdef PSOCK_ECONNRESET
  482. psock_errno()!=PSOCK_ECONNRESET && // this is a win2k/winxp issue
  483. // their socket implementation returns this value
  484. // although it shouldn't
  485. #endif
  486. 1)
  487. eventlog(eventlog_level_error,"sd_udpinput","could not recv UDP datagram (psock_recvfrom: %s)",strerror(psock_errno()));
  488.     packet_del_ref(upacket);
  489.     return -1;
  490. }
  492. if (fromaddr.sin_family!=PSOCK_AF_INET)
  493. {
  494.     eventlog(eventlog_level_error,"sd_udpinput","got UDP datagram with bad address family %d",(int)fromaddr.sin_family);
  495.     packet_del_ref(upacket);
  496.     return -1;
  497. }
  499. packet_set_size(upacket,len);
  501. if (hexstrm)
  502. {
  503.     char tempa[32];
  504.     
  505.     if (!addr_get_addr_str(curr_laddr,tempa,sizeof(tempa)))
  506. strcpy(tempa,"x.x.x.x:x");
  507.     fprintf(hexstrm,"%d: recv class=%s[0x%02x] type=%s[0x%04x] from=%s to=%s length=%un",
  508.     usocket,
  509.     packet_get_class_str(upacket),(unsigned int)packet_get_class(upacket),
  510.     packet_get_type_str(upacket,packet_dir_from_client),packet_get_type(upacket),
  511.     addr_num_to_addr_str(ntohl(fromaddr.sin_addr.s_addr),ntohs(fromaddr.sin_port)),
  512.     tempa,
  513.     packet_get_size(upacket));
  514.     hexdump(hexstrm,packet_get_raw_data(upacket,0),packet_get_size(upacket));
  515. }
  517. handle_udp_packet(usocket,ntohl(fromaddr.sin_addr.s_addr),ntohs(fromaddr.sin_port),upacket);
  518. packet_del_ref(upacket);
  519.     }
  520.     
  521.     return 0;
  522. }
  525. static int sd_tcpinput(t_connection * c)
  526. {
  527.     unsigned int currsize;
  528.     t_packet *   packet;
  529.     int  csocket = conn_get_socket(c);
  530.     
  531.     currsize = conn_get_in_size(c);
  533.     if (!queue_get_length((t_queue const * const *)conn_get_in_queue(c)))
  534.     {
  535. switch (conn_get_class(c))
  536. {
  537. case conn_class_init:
  538.     if (!(packet = packet_create(packet_class_init)))
  539.     {
  540. eventlog(eventlog_level_error,"sd_tcpinput","could not allocate init packet for input");
  541. return -1;
  542.     }
  543.     break;
  544.          case conn_class_d2cs_bnetd:
  545.             if (!(packet = packet_create(packet_class_d2cs_bnetd)))
  546.             {
  547.                 eventlog(eventlog_level_error,"server_process","could not allocate d2cs_bnetd packet");
  548.                 return -1;
  549.             }
  550.             break;
  551. case conn_class_bnet:
  552.     if (!(packet = packet_create(packet_class_bnet)))
  553.     {
  554. eventlog(eventlog_level_error,"sd_tcpinput","could not allocate bnet packet for input");
  555. return -1;
  556.     }
  557.     break;
  558. case conn_class_file:
  559.     switch(conn_get_state(c)) {
  560. case conn_state_pending_raw:
  561.     if (!(packet = packet_create(packet_class_raw)))
  562.     {
  563. eventlog(eventlog_level_error,"sd_tcpinput","could not allocate raw packet for input");
  564. return -1;
  565.     }
  566.     packet_set_size(packet, sizeof(t_client_war3113_file_req));
  567.     break;
  568. default:
  569.     if (!(packet = packet_create(packet_class_file)))
  570.     {
  571. eventlog(eventlog_level_error,"sd_tcpinput","could not allocate file packet for input");
  572. return -1;
  573.     }
  574.     break;
  575.     }
  576.     break;
  577. case conn_class_defer:
  578. case conn_class_bot:
  579. case conn_class_irc:
  580. case conn_class_telnet:
  581.     if (!(packet = packet_create(packet_class_raw)))
  582.     {
  583. eventlog(eventlog_level_error,"sd_tcpinput","could not allocate raw packet for input");
  584. return -1;
  585.     }
  586.     packet_set_size(packet,1); /* start by only reading one char */
  587.     break;
  588. case conn_class_auth:
  589.     if (!(packet = packet_create(packet_class_auth)))
  590.     {
  591. eventlog(eventlog_level_error,"sd_tcpinput","could not allocate auth packet for input");
  592. return -1;
  593.     }
  594.     break;
  595. case conn_class_w3route:
  596.     if (!(packet = packet_create(packet_class_w3route)))
  597.     {
  598. eventlog(eventlog_level_error,"sd_tcpinput","could not allocate w3route packet for input");
  599. return -1;
  600.     }
  601.     break;
  603. default:
  604.     eventlog(eventlog_level_error,"sd_tcpinput","[%d] connection has bad class (closing connection)",conn_get_socket(c));
  605.     // [quetzal] 20020808 - marking connection as "destroyed", memory will be freed later
  606. conn_set_state(c, conn_state_destroy);
  607.     return -2;
  608. }
  609. conn_push_inqueue(c,packet);
  610. packet_del_ref(packet);
  611. if (!queue_get_length((t_queue const * const *)conn_get_in_queue(c)))
  612.     return -1; /* push failed */
  613. currsize = 0;
  614.     }
  615.     
  616.     packet = conn_peek_inqueue(c);
  617.     switch (net_recv_packet(csocket,packet,&currsize))
  618.     {
  619.     case -1:
  620. eventlog(eventlog_level_debug,"sd_tcpinput","[%d] read FAILED (closing connection)",conn_get_socket(c));
  621. // [quetzal] 20020808 - marking connection as "destroyed", memory will be freed later
  622. conn_set_state(c, conn_state_destroy);
  623. return -2;
  625.     case 0: /* still working on it */
  626. /* eventlog(eventlog_level_debug,"sd_tcpinput","[%d] still reading "%s" packet (%u of %u bytes so far)",conn_get_socket(c),packet_get_class_str(packet),conn_get_in_size(c),packet_get_size(packet)); */
  627. conn_set_in_size(c,currsize);
  628. break;
  630.     case 1: /* done reading */
  631. switch (conn_get_class(c))
  632. {
  633. case conn_class_defer:
  634.     {
  635. unsigned char const * const temp=packet_get_raw_data_const(packet,0);
  637. eventlog(eventlog_level_debug,"sd_tcpinput","[%d] got first packet byte %02x",conn_get_socket(c),(unsigned int)temp[0]);
  638. if (temp[0]==(unsigned char)0xff) /* HACK: thankfully all bnet packet types end with ff */
  639. {
  640.     conn_set_class(c,conn_class_bnet);
  641.     conn_set_in_size(c,currsize);
  642.     packet_set_class(packet,packet_class_bnet);
  643.     eventlog(eventlog_level_debug,"sd_tcpinput","[%d] defered connection class is bnet",conn_get_socket(c));
  644. } else {
  645.     conn_set_class(c,conn_class_auth);
  646.     conn_set_in_size(c,currsize);
  647.     packet_set_class(packet,packet_class_auth);
  648.     eventlog(eventlog_level_debug,"sd_tcpinput","[%d] defered connection class is auth",conn_get_socket(c));
  649. }
  650.     }
  651.     break;
  653. case conn_class_bot:
  654. case conn_class_telnet:
  655.     if (currsize<MAX_PACKET_SIZE) /* if we overflow, we can't wait for the end of the line.
  656.      handle_*_packet() should take care of it */
  657.     {
  658. char const * const temp=packet_get_raw_data_const(packet,0);
  660. if ((temp[currsize-1]=='03')||(temp[currsize-1]=='04')) {
  661.     /* we have to ignore these special characters, since 
  662.      * some bots even send them after login (eg. UltimateBot)
  663.      */
  664.     currsize--;
  665.     break;  
  666. }
  668. if (temp[currsize-1]!='r' && temp[currsize-1]!='n')
  669. {
  670.     conn_set_in_size(c,currsize);
  671.     packet_set_size(packet,currsize+1);
  672.     break; /* no end of line, get another char */
  673. }
  674.     }
  675.     /* got a complete line or overflow... fall through */
  677. default:
  678.     packet = conn_pull_inqueue(c);
  680.     if (hexstrm)
  681.     {
  682. fprintf(hexstrm,"%d: recv class=%s[0x%02x] type=%s[0x%04x] length=%un",
  683. csocket,
  684. packet_get_class_str(packet),(unsigned int)packet_get_class(packet),
  685. packet_get_type_str(packet,packet_dir_from_client),packet_get_type(packet),
  686. packet_get_size(packet));
  687. hexdump(hexstrm,packet_get_raw_data_const(packet,0),packet_get_size(packet));
  688.     }
  689.     
  690.     if (conn_get_class(c)==conn_class_bot ||
  691. conn_get_class(c)==conn_class_telnet) /* NUL terminate the line to make life easier */
  692.     {
  693. char * const temp=packet_get_raw_data(packet,0);
  695. if (temp[currsize-1]=='r' || temp[currsize-1]=='n')
  696.     temp[currsize-1] = ''; /* have to do it here instead of above so everything
  697. is intact for the hexdump */
  698.     }
  699.     
  700.     {
  701. int ret;
  703. switch (conn_get_class(c))
  704. {
  705. case conn_class_init:
  706.     ret = handle_init_packet(c,packet);
  707.     break;
  708. case conn_class_bnet:
  709.     ret = handle_bnet_packet(c,packet);
  710.     break;
  711. case conn_class_d2cs_bnetd:
  712. ret = handle_d2cs_packet(c,packet);
  713. break;
  714. case conn_class_bot:
  715.     ret = handle_bot_packet(c,packet);
  716.     break;
  717. case conn_class_telnet:
  718.     ret = handle_telnet_packet(c,packet);
  719.     break;
  720. case conn_class_file:
  721.     ret = handle_file_packet(c,packet);
  722.     break;
  723. case conn_class_auth:
  724.     ret = handle_auth_packet(c,packet);
  725.     break;
  726. case conn_class_irc:
  727.     ret = handle_irc_packet(c,packet);
  728.     break;
  729. case conn_class_w3route:
  730.     ret = handle_w3route_packet(c,packet);
  731.     break;
  732. default:
  733.     eventlog(eventlog_level_error,"sd_tcpinput","[%d] bad packet class %d (closing connection)",conn_get_socket(c),(int)packet_get_class(packet));
  734.     ret = -1;
  735. }
  736. packet_del_ref(packet);
  737. if (ret<0)
  738. {
  739. // [quetzal] 20020808 - marking connection as "destroyed", memory will be freed later
  740. conn_set_state(c, conn_state_destroy);
  741.     return -2;
  742. }
  743.     }
  744.     
  745.     conn_set_in_size(c,0);
  746. }
  747.     }
  748.     
  749.     return 0;
  750. }
  753. static int sd_tcpoutput(t_connection * c)
  754. {
  755.     unsigned int currsize;
  756.     unsigned int totsize;
  757.     t_packet *   packet;
  758.     int  csocket = conn_get_socket(c);
  759.     
  760.     totsize = 0;
  761.     for (;;)
  762.     {
  763. currsize = conn_get_out_size(c);
  765.         if ((packet = conn_peek_outqueue(c)) == NULL)
  766.             return -2;
  768. switch (net_send_packet(csocket,packet,&currsize)) /* avoid warning */
  769. {
  770. case -1:
  771. // [quetzal] 20020808 - marking connection as "destroyed", memory will be freed later
  772. conn_set_state(c, conn_state_destroy);
  773.     return -2;
  774.     
  775. case 0: /* still working on it */
  776.     conn_set_out_size(c,currsize);
  777.     return 0; /* bail out */
  778.     
  779. case 1: /* done sending */
  780.     if (hexstrm)
  781.     {
  782. fprintf(hexstrm,"%d: send class=%s[0x%02x] type=%s[0x%04x] length=%un",
  783. csocket,
  784. packet_get_class_str(packet),(unsigned int)packet_get_class(packet),
  785. packet_get_type_str(packet,packet_dir_from_server),packet_get_type(packet),
  786. packet_get_size(packet));
  787. hexdump(hexstrm,packet_get_raw_data(packet,0),packet_get_size(packet));
  788.     }
  790.     packet = conn_pull_outqueue(c);
  791.     packet_del_ref(packet);
  792.     conn_set_out_size(c,0);
  793.     
  794.     /* stop at about 2KB (or until out of packets or EWOULDBLOCK) */
  795.     if (totsize>2048 || queue_get_length((t_queue const * const *)conn_get_out_queue(c))<1)
  796. return 0;
  797.     totsize += currsize;
  798.     break;
  799. }
  800.     }
  801.     
  802.     /* not reached */
  803. }
  805. extern void server_set_name(void)
  806. {
  807.     char temp[250];
  808.     char const * sn;
  809. #ifdef HAVE_GETHOSTBYNAME
  810.     struct hostent *   hp;
  811. #endif
  813.     if (server_name) {
  814. free((void *)server_name); /* avoid warning */
  815. server_name = NULL;
  816.     }
  817.     
  818.     sn = prefs_get_servername();
  819.     if ((!sn)||(sn[0]=='')) {
  820.      if (gethostname(temp,sizeof(temp))<0) {
  821. #ifdef WIN32
  822.     sprintf(temp,"localhost");
  823. #else
  824.     eventlog(eventlog_level_error,"server_set_name","could not get hostname: %s",strerror(errno));
  825.     return;
  826. #endif
  827.      }
  828. #ifdef HAVE_GETHOSTBYNAME
  829.      hp = gethostbyname(temp);
  830.      if (!hp || !hp->h_name) {
  831. #endif
  832.          server_name = strdup(temp);
  833. #ifdef HAVE_GETHOSTBYNAME
  834.      } else {
  835.     int i=0;
  837.     if (strchr(hp->h_name,'.'))
  838.      /* Default name is already a FQDN */
  839.      server_name = strdup(hp->h_name);
  840.     /* ... if not we have to examine the aliases */
  841.     while (!server_name && hp->h_aliases && hp->h_aliases[i]) {
  842. if (strchr(hp->h_aliases[i],'.'))
  843.     server_name = strdup(hp->h_aliases[i]);
  844.      i++;
  845.     }
  846.     if (!server_name)
  847. /* Fall back to default name which might not be a FQDN */
  848.           server_name = strdup(hp->h_name);
  849.      }
  850. #endif
  851.     } else {
  852. server_name = strdup(sn);
  853.     }
  854.     eventlog(eventlog_level_info,"server_set_name","set servername to "%s"",server_name);
  855. }
  857. extern char const * server_get_name(void)
  858. {
  859.     if (!server_name)
  860.      return "(null)"; /* avoid crashes */
  861.     else
  862.      return server_name;
  863. }
  866. extern void server_clear_name(void)
  867. {
  868.     if (server_name) {
  869. free((void *)server_name); /* avoid warning */
  870.         server_name = NULL;
  871.     }
  872. }
  875. static void _server_setup_listensock(t_addrlist *laddrs)
  876. {
  877.     t_elem const *  acurr;
  878.     t_addr *        curr_laddr;
  879.     t_laddr_info *  laddr_info;
  881.     LIST_TRAVERSE_CONST(laddrs,acurr)
  882.     {
  883. curr_laddr = elem_get_data(acurr);
  884. if (!(laddr_info = addr_get_data(curr_laddr).p))
  885. {
  886.     eventlog(eventlog_level_error,"server_process","NULL address info");
  887.     continue;
  888. }
  890. if (laddr_info->ssocket!=-1) fdwatch_add_fd(laddr_info->ssocket, fdwatch_type_read, handle_accept, curr_laddr);
  891. if (laddr_info->usocket!=-1) fdwatch_add_fd(laddr_info->usocket, fdwatch_type_read, handle_udp, curr_laddr);
  892.     }
  893. }
  896. static int handle_accept(void *data, t_fdwatch_type rw)
  897. {
  898.     t_laddr_info *laddr_info = addr_get_data((t_addr *)data).p;
  900.     return sd_accept((t_addr *)data, laddr_info, laddr_info->ssocket, laddr_info->usocket);
  901. }
  904. static int handle_udp(void *data, t_fdwatch_type rw)
  905. {
  906.     t_laddr_info *laddr_info = addr_get_data((t_addr *)data).p;
  908.     return sd_udpinput((t_addr *)data, laddr_info, laddr_info->ssocket, laddr_info->usocket);
  909. }
  912. static int handle_tcp(void *data, t_fdwatch_type rw)
  913. {
  914.     switch(rw) {
  915. case fdwatch_type_read: return sd_tcpinput((t_connection *)data);
  916. case fdwatch_type_write: return sd_tcpoutput((t_connection *)data);
  917. default:
  918.     return -1;
  919.     }
  920. }
  923. extern int server_process(void)
  924. {
  925.     t_addrlist *    laddrs;
  926.     t_addr *        curr_laddr;
  927.     t_addr_data     laddr_data;
  928.     t_laddr_info *  laddr_info;
  929.     time_t          prev_exittime, prev_savetime, track_time;
  930.     time_t          war3_ladder_updatetime;
  931.     time_t          output_updatetime;
  932.     int             syncdelta;
  933.     t_connection *  c;
  934.     t_elem const *  acurr;
  935.     t_elem const *  ccurr;
  936. #ifdef DO_POSIXSIG
  937.     sigset_t        block_set;
  938.     sigset_t        save_set;
  939. #endif
  940.     unsigned int    count;
  941.     
  942.     if (psock_init()<0)
  943.     {
  944. eventlog(eventlog_level_error,"server_process","could not initialize socket functions");
  945. return -1;
  946.     }
  947.     
  948.     /* Start with the Battle.net address list */
  949.     if (!(laddrs = addrlist_create(prefs_get_bnetdserv_addrs(),INADDR_ANY,BNETD_SERV_PORT)))
  950.     {
  951. eventlog(eventlog_level_error,"server_process","could not create %s server address list from "%s"",laddr_type_get_str(laddr_type_bnet),prefs_get_bnetdserv_addrs());
  952. return -1;
  953.     }
  954.     /* Mark all these laddrs for being classic Battle.net service */
  955.     LIST_TRAVERSE_CONST(laddrs,acurr)
  956.     {
  957. curr_laddr = elem_get_data(acurr);
  958. if (addr_get_data(curr_laddr).p)
  959.     continue;
  960. if (!(laddr_info = malloc(sizeof(t_laddr_info))))
  961. {
  962.     eventlog(eventlog_level_error,"server_process","could not create %s address info (malloc: %s)",laddr_type_get_str(laddr_type_bnet),strerror(psock_errno()));
  963.     goto error_addr_list;
  964. }
  965.         laddr_info->usocket = -1;
  966.         laddr_info->ssocket = -1;
  967.         laddr_info->type = laddr_type_bnet;
  968. laddr_data.p = laddr_info;
  969.         if (addr_set_data(curr_laddr,laddr_data)<0)
  970. {
  971.     eventlog(eventlog_level_error,"server_process","could not set address data");
  972.     if (laddr_info->usocket!=-1)
  973.     {
  974. psock_close(laddr_info->usocket);
  975. laddr_info->usocket = -1;
  976.     }
  977.     if (laddr_info->ssocket!=-1)
  978.     {
  979. psock_close(laddr_info->ssocket);
  980. laddr_info->ssocket = -1;
  981.     }
  982.     goto error_poll;
  983. }
  984.     }
  985.     
  986.     /* Append list of addresses to listen for IRC connections */
  987.     if (addrlist_append(laddrs,prefs_get_irc_addrs(),INADDR_ANY,BNETD_IRC_PORT)<0)
  988.     {
  989. eventlog(eventlog_level_error,"server_process","could not create %s server address list from "%s"",laddr_type_get_str(laddr_type_irc),prefs_get_irc_addrs());
  990. goto error_addr_list;
  991.     }
  992.     /* Mark all new laddrs for being IRC service */
  993.     LIST_TRAVERSE_CONST(laddrs,acurr)
  994.     { 
  995. curr_laddr = elem_get_data(acurr);
  996. if (addr_get_data(curr_laddr).p)
  997.     continue;
  998. if (!(laddr_info = malloc(sizeof(t_laddr_info))))
  999. {
  1000.     eventlog(eventlog_level_error,"server_process","could not create %s address info (malloc: %s)",laddr_type_get_str(laddr_type_irc),strerror(psock_errno()));
  1001.     goto error_addr_list;
  1002. }
  1003.         laddr_info->usocket = -1;
  1004.         laddr_info->ssocket = -1;
  1005.         laddr_info->type = laddr_type_irc;
  1006. laddr_data.p = laddr_info;
  1007. if (addr_set_data(curr_laddr,laddr_data)<0)
  1008. {
  1009.     eventlog(eventlog_level_error,"server_process","could not set address data");
  1010.     if (laddr_info->usocket!=-1)
  1011.     {
  1012. psock_close(laddr_info->usocket);
  1013. laddr_info->usocket = -1;
  1014.     }
  1015.     if (laddr_info->ssocket!=-1)
  1016.     {
  1017. psock_close(laddr_info->ssocket);
  1018. laddr_info->ssocket = -1;
  1019.     }
  1020.     goto error_poll;
  1021. }
  1022.     }
  1024.     /* Append list of addresses to listen for W3ROUTE connections */
  1025.     if (addrlist_append(laddrs,prefs_get_w3route_addr(),INADDR_ANY,BNETD_W3ROUTE_PORT)<0)
  1026.     {
  1027. eventlog(eventlog_level_error,"server_process","could not create %s server address list from "%s"",laddr_type_get_str(laddr_type_w3route),prefs_get_w3route_addr());
  1028. goto error_addr_list;
  1029.     }
  1030.     /* Mark all new laddrs for being W3ROUTE service */
  1031.     LIST_TRAVERSE_CONST(laddrs,acurr)
  1032.     { 
  1033. curr_laddr = elem_get_data(acurr);
  1034. if (addr_get_data(curr_laddr).p)
  1035.     continue;
  1036. if (!(laddr_info = malloc(sizeof(t_laddr_info))))
  1037. {
  1038.     eventlog(eventlog_level_error,"server_process","could not create %s address info (malloc: %s)",laddr_type_get_str(laddr_type_w3route),strerror(psock_errno()));
  1039.     goto error_addr_list;
  1040. }
  1041.         laddr_info->usocket = -1;
  1042.         laddr_info->ssocket = -1;
  1043.         laddr_info->type = laddr_type_w3route;
  1044. laddr_data.p = laddr_info;
  1045. if (addr_set_data(curr_laddr,laddr_data)<0)
  1046. {
  1047.     eventlog(eventlog_level_error,"server_process","could not set address data");
  1048.     if (laddr_info->usocket!=-1)
  1049.     {
  1050. psock_close(laddr_info->usocket);
  1051. laddr_info->usocket = -1;
  1052.     }
  1053.     if (laddr_info->ssocket!=-1)
  1054.     {
  1055. psock_close(laddr_info->ssocket);
  1056. laddr_info->ssocket = -1;
  1057.     }
  1058.     goto error_poll;
  1059. }
  1060.     }
  1062.     
  1063.     /* Append list of addresses to listen for telnet connections */
  1064.     if (addrlist_append(laddrs,prefs_get_telnet_addrs(),INADDR_ANY,BNETD_TELNET_PORT)<0)
  1065.     {
  1066. eventlog(eventlog_level_error,"server_process","could not create %s server address list from "%s"",laddr_type_get_str(laddr_type_telnet),prefs_get_telnet_addrs());
  1067. goto error_addr_list;
  1068.     }
  1069.     /* Mark all new laddrs for being telnet service */
  1070.     LIST_TRAVERSE_CONST(laddrs,acurr)
  1071.     { 
  1072. curr_laddr = elem_get_data(acurr);
  1073. if (addr_get_data(curr_laddr).p)
  1074.     continue;
  1075. if (!(laddr_info = malloc(sizeof(t_laddr_info))))
  1076. {
  1077.     eventlog(eventlog_level_error,"server_process","could not create %s address info (malloc: %s)",laddr_type_get_str(laddr_type_telnet),strerror(psock_errno()));
  1078.     goto error_addr_list;
  1079. }
  1080.         laddr_info->usocket = -1;
  1081.         laddr_info->ssocket = -1;
  1082.         laddr_info->type = laddr_type_telnet;
  1083. laddr_data.p = laddr_info;
  1084. if (addr_set_data(curr_laddr,laddr_data)<0)
  1085. {
  1086.     eventlog(eventlog_level_error,"server_process","could not set address data");
  1087.     if (laddr_info->usocket!=-1)
  1088.     {
  1089. psock_close(laddr_info->usocket);
  1090. laddr_info->usocket = -1;
  1091.     }
  1092.     if (laddr_info->ssocket!=-1)
  1093.     {
  1094. psock_close(laddr_info->ssocket);
  1095. laddr_info->ssocket = -1;
  1096.     }
  1097.     goto error_poll;
  1098. }
  1099.     }
  1100.     
  1101.     if (fdwatch_init()) {
  1102. eventlog(eventlog_level_error, __FUNCTION__, "could not initilized fdwatch layer");
  1103. goto error_poll;
  1104.     }
  1106.     LIST_TRAVERSE_CONST(laddrs,acurr)
  1107.     {
  1108. curr_laddr = elem_get_data(acurr);
  1109. if (!(laddr_info = addr_get_data(curr_laddr).p))
  1110. {
  1111.     eventlog(eventlog_level_error,"server_process","NULL address info");
  1112.     goto error_poll;
  1113. }
  1115. if ((laddr_info->ssocket = psock_socket(PSOCK_PF_INET,PSOCK_SOCK_STREAM,PSOCK_IPPROTO_TCP))<0)
  1116. {
  1117.     eventlog(eventlog_level_error,"server_process","could not create a %s listening socket (psock_socket: %s)",laddr_type_get_str(laddr_info->type),strerror(psock_errno()));
  1118.     goto error_poll;
  1119. }
  1121. if (laddr_info->ssocket >= fdw_maxfd)
  1122. {
  1123.     eventlog(eventlog_level_error,"server_process","%s TCP socket is beyond range allowed by FD_SETSIZE for select() (%d>=%d)",laddr_type_get_str(laddr_info->type),laddr_info->ssocket,fdw_maxfd);
  1124.     psock_close(laddr_info->ssocket);
  1125.     laddr_info->ssocket = -1;
  1126.     goto error_poll;
  1127. }
  1129. if (laddr_info->type==laddr_type_bnet)
  1130. {
  1131.     if ((laddr_info->usocket = psock_socket(PSOCK_PF_INET,PSOCK_SOCK_DGRAM,PSOCK_IPPROTO_UDP))<0)
  1132.     {
  1133. eventlog(eventlog_level_error,"server_process","could not create UDP socket (psock_socket: %s)",strerror(psock_errno()));
  1134. psock_close(laddr_info->ssocket);
  1135. laddr_info->ssocket = -1;
  1136. goto error_poll;
  1137.     }
  1139.     if (laddr_info->usocket >= fdw_maxfd)
  1140.     {
  1141. eventlog(eventlog_level_error,"server_process","%s UDP socket is beyond range allowed by FD_SETSIZE for select() (%d>=%d)",laddr_type_get_str(laddr_info->type),laddr_info->usocket,fdw_maxfd);
  1142. psock_close(laddr_info->usocket);
  1143. laddr_info->usocket = -1;
  1144. psock_close(laddr_info->ssocket);
  1145. laddr_info->ssocket = -1;
  1146. goto error_poll;
  1147.     }
  1148. }
  1150. {
  1151.     int val;
  1152.     
  1153.     if (laddr_info->ssocket!=-1)
  1154.     {
  1155. val = 1;
  1156. if (psock_setsockopt(laddr_info->ssocket,PSOCK_SOL_SOCKET,PSOCK_SO_REUSEADDR,&val,(psock_t_socklen)sizeof(int))<0)
  1157.     eventlog(eventlog_level_error,"server_process","could not set option SO_REUSEADDR on %s socket %d (psock_setsockopt: %s)",laddr_type_get_str(laddr_info->type),laddr_info->usocket,strerror(psock_errno()));
  1158. /* not a fatal error... */
  1159.     }
  1160.     
  1161.     if (laddr_info->usocket!=-1)
  1162.     {
  1163. val = 1;
  1164. if (psock_setsockopt(laddr_info->usocket,PSOCK_SOL_SOCKET,PSOCK_SO_REUSEADDR,&val,(psock_t_socklen)sizeof(int))<0)
  1165.     eventlog(eventlog_level_error,"server_process","could not set option SO_REUSEADDR on %s socket %d (psock_setsockopt: %s)",laddr_type_get_str(laddr_info->type),laddr_info->usocket,strerror(psock_errno()));
  1166. /* not a fatal error... */
  1167.     }
  1168. }
  1170. {
  1171.     char               tempa[32];
  1172.     struct sockaddr_in saddr;
  1173.     
  1174.     if (laddr_info->ssocket!=-1)
  1175.     {
  1176. memset(&saddr,0,sizeof(saddr));
  1177. saddr.sin_family = PSOCK_AF_INET;
  1178. saddr.sin_port = htons(addr_get_port(curr_laddr));
  1179. saddr.sin_addr.s_addr = htonl(addr_get_ip(curr_laddr));
  1180. if (psock_bind(laddr_info->ssocket,(struct sockaddr *)&saddr,(psock_t_socklen)sizeof(saddr))<0)
  1181. {
  1182.     if (!addr_get_addr_str(curr_laddr,tempa,sizeof(tempa)))
  1183. strcpy(tempa,"x.x.x.x:x");
  1184.     eventlog(eventlog_level_error,"server_process","could not bind %s socket to address %s TCP (psock_bind: %s)",laddr_type_get_str(laddr_info->type),tempa,strerror(psock_errno()));
  1185.     goto error_poll;
  1186. }
  1187.     }
  1188.     
  1189.     if (laddr_info->usocket!=-1)
  1190.     {
  1191. memset(&saddr,0,sizeof(saddr));
  1192. saddr.sin_family = PSOCK_AF_INET;
  1193. saddr.sin_port = htons(addr_get_port(curr_laddr));
  1194. saddr.sin_addr.s_addr = htonl(addr_get_ip(curr_laddr));
  1195. if (psock_bind(laddr_info->usocket,(struct sockaddr *)&saddr,(psock_t_socklen)sizeof(saddr))<0)
  1196. {
  1197.     if (!addr_get_addr_str(curr_laddr,tempa,sizeof(tempa)))
  1198. strcpy(tempa,"x.x.x.x:x");
  1199.     eventlog(eventlog_level_error,"server_process","could not bind %s socket to address %s UDP (psock_bind: %s)",laddr_type_get_str(laddr_info->type),tempa,strerror(psock_errno()));
  1200.     goto error_poll;
  1201. }
  1202.     }
  1203.     
  1204.     if (laddr_info->ssocket!=-1)
  1205.     {
  1206. /* tell socket to listen for connections */
  1207. if (psock_listen(laddr_info->ssocket,LISTEN_QUEUE)<0)
  1208. {
  1209.     eventlog(eventlog_level_error,"server_process","could not set %s socket %d to listen (psock_listen: %s)",laddr_type_get_str(laddr_info->type),laddr_info->ssocket,strerror(psock_errno()));
  1210.     goto error_poll;
  1211. }
  1212.     }
  1213.     
  1214.     if (!addr_get_addr_str(curr_laddr,tempa,sizeof(tempa)))
  1215. strcpy(tempa,"x.x.x.x:x");
  1216.     eventlog(eventlog_level_info,"server_process","listening for %s connections on %s TCP",laddr_type_get_str(laddr_info->type),tempa);
  1217. }
  1219. if (laddr_info->ssocket!=-1)
  1220.     if (psock_ctl(laddr_info->ssocket,PSOCK_NONBLOCK)<0)
  1221. eventlog(eventlog_level_error,"server_process","could not set %s TCP listen socket to non-blocking mode (psock_ctl: %s)",laddr_type_get_str(laddr_info->type),strerror(psock_errno()));
  1222. if (laddr_info->usocket!=-1)
  1223.     if (psock_ctl(laddr_info->usocket,PSOCK_NONBLOCK)<0)
  1224. eventlog(eventlog_level_error,"server_process","could not set %s UDP socket to non-blocking mode (psock_ctl: %s)",laddr_type_get_str(laddr_info->type),strerror(psock_errno()));
  1225.     }
  1226.     
  1227.     /* setup signal handlers */
  1228.     prev_exittime = sigexittime;
  1229.     
  1230. #ifdef DO_POSIXSIG
  1231.     if (sigemptyset(&save_set)<0)
  1232.     {
  1233. eventlog(eventlog_level_error,"server_process","could not initialize signal set (sigemptyset: %s)",strerror(errno));
  1234. goto error_poll;
  1235.     }
  1236.     if (sigemptyset(&block_set)<0)
  1237.     {
  1238. eventlog(eventlog_level_error,"server_process","could not initialize signal set (sigemptyset: %s)",strerror(errno));
  1239. goto error_poll;
  1240.     }
  1241.     if (sigaddset(&block_set,SIGINT)<0)
  1242.     {
  1243. eventlog(eventlog_level_error,"server_process","could not add signal to set (sigemptyset: %s)",strerror(errno));
  1244. goto error_poll;
  1245.     }
  1246.     if (sigaddset(&block_set,SIGHUP)<0)
  1247.     {
  1248. eventlog(eventlog_level_error,"server_process","could not add signal to set (sigemptyset: %s)",strerror(errno));
  1249. goto error_poll;
  1250.     }
  1251.     if (sigaddset(&block_set,SIGTERM)<0)
  1252.     {
  1253. eventlog(eventlog_level_error,"server_process","could not add signal to set (sigemptyset: %s)",strerror(errno));
  1254. goto error_poll;
  1255.     }
  1256.     if (sigaddset(&block_set,SIGUSR1)<0)
  1257.     {
  1258. eventlog(eventlog_level_error,"server_process","could not add signal to set (sigemptyset: %s)",strerror(errno));
  1259. goto error_poll;
  1260.     }
  1261.     if (sigaddset(&block_set,SIGUSR2)<0)
  1262.     {
  1263. eventlog(eventlog_level_error,"server_process","could not add signal to set (sigemptyset: %s)",strerror(errno));
  1264. goto error_poll;
  1265.     }
  1266.     if (sigaddset(&block_set,SIGALRM)<0)
  1267.     {
  1268. eventlog(eventlog_level_error,"server_process","could not add signal to set (sigemptyset: %s)",strerror(errno));
  1269. goto error_poll;
  1270.     }
  1271.     
  1272.     {
  1273. struct sigaction quit_action;
  1274. struct sigaction restart_action;
  1275. struct sigaction save_action;
  1276. struct sigaction pipe_action;
  1277. # ifdef USE_CHECK_ALLOC
  1278. struct sigaction memstat_action;
  1279. # endif
  1280. #ifdef HAVE_SETITIMER
  1281. struct sigaction timer_action;
  1282. #endif
  1284. quit_action.sa_handler = quit_sig_handle;
  1285. if (sigemptyset(&quit_action.sa_mask)<0)
  1286.     eventlog(eventlog_level_error,"server_process","could not initialize signal set (sigemptyset: %s)",strerror(errno));
  1287. quit_action.sa_flags = SA_RESTART;
  1289. restart_action.sa_handler = restart_sig_handle;
  1290. if (sigemptyset(&restart_action.sa_mask)<0)
  1291.     eventlog(eventlog_level_error,"server_process","could not initialize signal set (sigemptyset: %s)",strerror(errno));
  1292. restart_action.sa_flags = SA_RESTART;
  1294. save_action.sa_handler = save_sig_handle;
  1295. if (sigemptyset(&save_action.sa_mask)<0)
  1296.     eventlog(eventlog_level_error,"server_process","could not initialize signal set (sigemptyset: %s)",strerror(errno));
  1297. save_action.sa_flags = SA_RESTART;
  1299. # ifdef USE_CHECK_ALLOC
  1300. memstat_action.sa_handler = memstat_sig_handle;
  1301. if (sigemptyset(&memstat_action.sa_mask)<0)
  1302.     eventlog(eventlog_level_error,"server_process","could not initialize signal set (sigemptyset: %s)",strerror(errno));
  1303. memstat_action.sa_flags = SA_RESTART;
  1304. # endif
  1306. pipe_action.sa_handler = pipe_sig_handle;
  1307. if (sigemptyset(&pipe_action.sa_mask)<0)
  1308.     eventlog(eventlog_level_error,"server_process","could not initialize signal set (sigemptyset: %s)",strerror(errno));
  1309. pipe_action.sa_flags = SA_RESTART;
  1310. #ifdef HAVE_SETITIMER
  1311. timer_action.sa_handler = timer_sig_handle;
  1312. if (sigemptyset(&timer_action.sa_mask)<0)
  1313.     eventlog(eventlog_level_error,"server_process","could not initialize signal set (sigemptyset: %s)",strerror(errno));
  1314. timer_action.sa_flags = SA_RESTART;
  1315. #endif /* HAVE_SETITIMER */
  1317. if (sigaction(SIGINT,&quit_action,NULL)<0) /* control-c */
  1318.     eventlog(eventlog_level_error,"server_process","could not set SIGINT signal handler (sigaction: %s)",strerror(errno));
  1319. if (sigaction(SIGHUP,&restart_action,NULL)<0)
  1320.     eventlog(eventlog_level_error,"server_process","could not set SIGHUP signal handler (sigaction: %s)",strerror(errno));
  1321. if (sigaction(SIGTERM,&quit_action,NULL)<0)
  1322.     eventlog(eventlog_level_error,"server_process","could not set SIGTERM signal handler (sigaction: %s)",strerror(errno));
  1323. if (sigaction(SIGUSR1,&save_action,NULL)<0)
  1324.     eventlog(eventlog_level_error,"server_process","could not set SIGUSR1 signal handler (sigaction: %s)",strerror(errno));
  1325. # ifdef USE_CHECK_ALLOC
  1326. if (sigaction(SIGUSR2,&memstat_action,NULL)<0)
  1327.     eventlog(eventlog_level_error,"server_process","could not set SIGUSR2 signal handler (sigaction: %s)",strerror(errno));
  1328. # endif
  1329. if (sigaction(SIGPIPE,&pipe_action,NULL)<0)
  1330.     eventlog(eventlog_level_error,"server_process","could not set SIGPIPE signal handler (sigaction: %s)",strerror(errno));
  1331. #ifdef HAVE_SETITIMER
  1332. /* setup asynchronus timestamp update timer */
  1333. if (sigaction(SIGALRM,&timer_action,NULL)<0)
  1334.     eventlog(eventlog_level_error,"server_process","could not set SIGALRM signal handler (sigaction: %s)",strerror(errno));
  1336. {
  1337.     struct itimerval it;
  1339.     it.it_interval.tv_sec = BNETD_JIFFIES / 1000;
  1340.     it.it_interval.tv_usec = BNETD_JIFFIES % 1000;
  1341.     it.it_value.tv_sec = BNETD_JIFFIES / 1000;
  1342.     it.it_value.tv_usec = BNETD_JIFFIES % 1000;
  1344.     if (setitimer(ITIMER_REAL, &it, NULL)) {
  1345. eventlog(eventlog_level_fatal, __FUNCTION__, "failed to set timers (setitimer(): %s)", strerror(errno));
  1346. goto error_poll;
  1347.     }
  1348. }
  1349. #endif
  1350.     }
  1351. #endif
  1353.     /* setup listening sockets */
  1354.     _server_setup_listensock(laddrs);
  1356.     syncdelta = prefs_get_user_sync_timer();
  1358.     track_time = time(NULL)-prefs_get_track();
  1359.     starttime=prev_savetime = time(NULL);
  1360.     war3_ladder_updatetime  = time(NULL)-prefs_get_war3_ladder_update_secs();
  1361.     output_updatetime = time(NULL)-prefs_get_output_update_secs();
  1362.     count = 0;
  1363.     
  1364.     for (;;)
  1365.     {
  1366. #ifdef WIN32
  1367. # ifndef WIN32_GUI
  1368. if (kbhit() && getch()=='q')
  1369.     server_quit_wraper();
  1370. # endif
  1371. if (g_ServiceStatus == 0) server_quit_wraper();
  1373. while (g_ServiceStatus == 2) Sleep(1000);
  1374. #endif
  1376. #ifdef DO_POSIXSIG
  1377. if (sigprocmask(SIG_SETMASK,&save_set,NULL)<0)
  1378.     eventlog(eventlog_level_error,"server_process","could not unblock signals");
  1379. /* receive signals here */
  1380. if (sigprocmask(SIG_SETMASK,&block_set,NULL)<0)
  1381.     eventlog(eventlog_level_error,"server_process","could not block signals");
  1382. #else
  1383. #endif
  1384. if (got_epipe)
  1385. {
  1386.     got_epipe = 0;
  1387.     eventlog(eventlog_level_info,"server_process","handled SIGPIPE");
  1388. }
  1390. #if !defined(DO_POSIXSIG) || !defined(HAVE_SETITIMER)
  1391. /* if no DO_POSIXSIG or no HAVE_SETITIMER so we must read timestamp each loop */
  1392. time(&now);
  1393. #endif
  1394. curr_exittime = sigexittime;
  1395. if (curr_exittime && (curr_exittime<=now || connlist_get_length()<1))
  1396. {
  1397.     eventlog(eventlog_level_info,"server_process","the server is shutting down (%d connections left)",connlist_get_length());
  1398.          clanlist_save();
  1399.     accountlist_save(0, NULL);
  1400.     break;
  1401. }
  1402. if (prev_exittime!=curr_exittime)
  1403. {
  1404.     t_message *  message;
  1405.     char const * tstr;
  1406.     
  1407.     if (curr_exittime!=0)
  1408.     {
  1409. char text[29+256+2+32+24+1]; /* "The ... in " + time + " (" num + " connection ...)." + NUL */
  1410.         
  1411. tstr = seconds_to_timestr(curr_exittime-now);
  1412. sprintf(text,"The server will shut down in %s (%d connections remaining).",tstr,connlist_get_length());
  1413.          if ((message = message_create(message_type_error,NULL,NULL,text)))
  1414. {
  1415.     message_send_all(message);
  1416.     message_destroy(message);
  1417. }
  1418. eventlog(eventlog_level_info,"server_process","the server will shut down in %s (%d connections remaining)",tstr,connlist_get_length());
  1419.     }
  1420.     else
  1421.     {
  1422. if ((message = message_create(message_type_error,NULL,NULL,"Server shutdown has been canceled.")))
  1423. {
  1424.     message_send_all(message);
  1425.     message_destroy(message);
  1426. }
  1427. eventlog(eventlog_level_info,"server_process","server shutdown canceled");
  1428.     }
  1429. }
  1430. prev_exittime = curr_exittime;
  1432. if (syncdelta && prev_savetime+(time_t)syncdelta<=now)
  1433. {
  1434.     if (syncdelta > 0) { /* do this stuff only first step of save */
  1435.      clanlist_save();
  1436.          gamelist_check_voidgame();
  1437.     }
  1438.     accountlist_save(prefs_get_user_sync_timer(), &syncdelta);
  1439.     prev_savetime = now;
  1440. }
  1442. if (prefs_get_track() && track_time+(time_t)prefs_get_track()<=now)
  1443. {
  1444.     track_time = now;
  1445.     tracker_send_report(laddrs);
  1446. }
  1448. if (prefs_get_war3_ladder_update_secs() && war3_ladder_updatetime+(time_t)prefs_get_war3_ladder_update_secs()<=now)
  1449. {
  1450.            war3_ladder_updatetime = now;
  1451.        ladders_write_to_file();
  1452. }
  1454. if (prefs_get_output_update_secs() && output_updatetime+(time_t)prefs_get_output_update_secs()<=now)
  1455. {
  1456.            output_updatetime = now;
  1457.    output_write_to_file();
  1458. }
  1461. if (do_save)
  1462. {
  1463.     eventlog(eventlog_level_info,"server_process","saving accounts due to signal");
  1464.          clanlist_save();
  1465.     accountlist_save(0, NULL);
  1466.     do_save = 0;
  1467. }
  1469. if (do_restart)
  1470. {
  1471.     eventlog(eventlog_level_info,"server_process","reading configuration files");
  1472.     if (preffile)
  1473.     {
  1474.          if (prefs_load(preffile)<0)
  1475.     eventlog(eventlog_level_error,"server_process","could not parse configuration file");
  1476.     }
  1477.     else
  1478. if (prefs_load(BNETD_DEFAULT_CONF_FILE)<0)
  1479.     eventlog(eventlog_level_error,"server_process","using default configuration");
  1480.     
  1481.     if (eventlog_open(prefs_get_logfile())<0)
  1482. eventlog(eventlog_level_error,"server_process","could not use the file "%s" for the eventlog",prefs_get_logfile());
  1484.     /* FIXME: load new network settings */
  1486.     /* reload server name */
  1487.     server_set_name();
  1488.     
  1489.     accountlist_load_default(); /* FIXME: free old one */
  1490.     /* Dizzy: disabled for the moment, lets see who really needs it, 
  1491.     also it can be the cause for a lot of problems
  1492.     accountlist_reload(); */
  1493.     
  1494.     channellist_reload();
  1496.             realmlist_destroy();
  1497.             if (realmlist_create(prefs_get_realmfile())<0)
  1498.         eventlog(eventlog_level_error,"main","could not load realm list");
  1500.     autoupdate_unload();
  1501.     if (autoupdate_load(prefs_get_mpqfile())<0)
  1502.       eventlog(eventlog_level_error,"main","could not load autoupdate list");
  1504.     news_unload();
  1505.     if (news_load(prefs_get_newsfile())<0)
  1506. eventlog(eventlog_level_error,__FUNCTION__,"could not load news list");
  1508.     versioncheck_unload();
  1509.     if (versioncheck_load(prefs_get_versioncheck_file())<0)
  1510.       eventlog(eventlog_level_error,"main","could not load versioncheck list");
  1511.          
  1512.     if (ipbanlist_destroy()<0)
  1513. eventlog(eventlog_level_error,"server_process","could not unload old IP ban list");
  1514.             if (ipbanlist_create()<0)
  1515.                 eventlog(eventlog_level_error,"server_process","could not create new IP ban list");
  1516.     if (ipbanlist_load(prefs_get_ipbanfile())<0)
  1517. eventlog(eventlog_level_error,"server_process","could not load new IP ban list");
  1518.     
  1519.     helpfile_unload();
  1520.     if (helpfile_init(prefs_get_helpfile())<0)
  1521. eventlog(eventlog_level_error,"server_process","could not load the helpfile");
  1522.     
  1523.     if (adbannerlist_destroy()<0)
  1524. eventlog(eventlog_level_error,"server_process","could not unload old adbanner list");
  1525.     if (adbannerlist_create(prefs_get_adfile())<0)
  1526. eventlog(eventlog_level_error,"server_process","could not load new adbanner list");
  1527.     
  1528.     if (gametrans_unload()<0)
  1529. eventlog(eventlog_level_error,"server_process","could not unload old gametrans list");
  1530.     if (gametrans_load(prefs_get_transfile())<0)
  1531. eventlog(eventlog_level_error,"server_process","could not load new gametrans list");
  1533.     ladder_reload_conf();
  1534.     
  1535.     if (prefs_get_track())
  1536. tracker_set_servers(prefs_get_trackserv_addrs());
  1537.     if (command_groups_reload(prefs_get_command_groups_file())<0)
  1538. eventlog(eventlog_level_error,"server_process","could not load new command_groups list");
  1540.     aliasfile_unload();
  1541.     aliasfile_load(prefs_get_aliasfile());
  1542.     
  1543.     if(w3trans_reload(prefs_get_w3trans_file())<0)
  1544. eventlog(eventlog_level_error,__FUNCTION__,"could not reload w3trans list");
  1546.     tournament_reload(prefs_get_tournament_file());
  1548.     anongame_infos_unload();
  1549.     anongame_infos_load(prefs_get_anongame_infos_file());
  1550.     
  1551.     syncdelta = prefs_get_user_sync_timer();
  1552.     
  1553.     eventlog(eventlog_level_info,"server_process","done reconfiguring");
  1554.     
  1555.     do_restart = 0;
  1556. }
  1558. #ifdef USE_CHECK_ALLOC
  1559. if (do_report_usage)
  1560. {
  1561.     check_report_usage();
  1562.     do_report_usage = 0;
  1563. }
  1564. #endif
  1566. count += BNETD_POLL_INTERVAL;
  1567. if (count>=1000) /* only check timers once a second */
  1568. {
  1569.     timerlist_check_timers(now);
  1570.     count = 0;
  1571. }
  1573. /* no need to populate the fdwatch structures as they are populated on the fly 
  1574.  * by sd_accept, conn_push_outqueue, conn_pull_outqueue, conn_destory */
  1576. /* find which sockets need servicing */
  1577. switch (fdwatch(BNETD_POLL_INTERVAL))
  1578. {
  1579. case -1: /* error */
  1580.     if (
  1581. #ifdef PSOCK_EINTR
  1582. /* FIXME: psock_select() uses psock_errno() instead of errno */
  1583. errno!=PSOCK_EINTR &&
  1584. #endif
  1585. 1)
  1586.         eventlog(eventlog_level_error,"server_process","fdwatch() failed (errno: %s)",strerror(errno));
  1587. case 0: /* timeout... no sockets need checking */
  1588.     continue;
  1589. }
  1591. /* cycle through the ready sockets and handle them */
  1592. fdwatch_handle();
  1594. /* reap dead connections */
  1595. connlist_reap();
  1596.     }
  1597.     
  1598.     /* cleanup for server shutdown */
  1599.     
  1600.     LIST_TRAVERSE_CONST(connlist(),ccurr)
  1601.     {
  1602. c = elem_get_data(ccurr);
  1603. conn_destroy(c);
  1604.     }
  1605.     
  1606.     fdwatch_close();
  1608.     LIST_TRAVERSE_CONST(laddrs,acurr)
  1609.     {
  1610. curr_laddr = elem_get_data(acurr);
  1611. if ((laddr_info = addr_get_data(curr_laddr).p))
  1612. {
  1613.     if (laddr_info->usocket!=-1)
  1614. psock_close(laddr_info->usocket);
  1615.     if (laddr_info->ssocket!=-1)
  1616. psock_close(laddr_info->ssocket);
  1617.     free(laddr_info);
  1618. }
  1619.     }
  1620.     addrlist_destroy(laddrs);
  1621.     
  1622.     return 0;
  1623.     
  1624.     /************************************************************************/
  1625.     
  1626.     /* error cleanup */
  1627.     
  1628. error_poll:
  1629.     
  1630. error_addr_list:
  1631.     LIST_TRAVERSE_CONST(laddrs,acurr)
  1632.     {
  1633. curr_laddr = elem_get_data(acurr);
  1634. if ((laddr_info = addr_get_data(curr_laddr).p))
  1635. {
  1636.     if (laddr_info->usocket!=-1)
  1637. psock_close(laddr_info->usocket);
  1638.     if (laddr_info->ssocket!=-1)
  1639. psock_close(laddr_info->ssocket);
  1640.     free(laddr_info);
  1641. }
  1642.     }
  1643.     addrlist_destroy(laddrs);
  1645.     return -1;
  1646. }