MYSQL *mysql_init( void *unused ) {
MYSQL *m = (MYSQL*)malloc(sizeof(struct _MYSQL));
psock_init();
memset(m,0,sizeof(struct _MYSQL));
m->s = INVALID_SOCKET;
error(m,"NO ERROR",NULL);
m->errcode = 0;
m->last_field_count = -1;
m->last_insert_id = -1;
m->affected_rows = -1;
return m;
}
extern char const * host_lookup(char const * hoststr, unsigned int * ipaddr)
{
struct sockaddr_in tsa;
#ifdef HAVE_GETHOSTBYNAME
struct hostent * hp;
#endif
if (!hoststr)
{
eventlog(eventlog_level_error,"host_lookup","got NULL hoststr");
return NULL;
}
if (!ipaddr)
{
eventlog(eventlog_level_error,"host_lookup","got NULL ipaddr");
return NULL;
}
memset(&tsa,0,sizeof(tsa));
tsa.sin_family = PSOCK_AF_INET;
tsa.sin_port = htons(0);
#ifdef HAVE_GETHOSTBYNAME
#ifdef WIN32
psock_init();
#endif
hp = gethostbyname(hoststr);
if (!hp || !hp->h_addr_list)
#endif
{
if (inet_aton(hoststr,&tsa.sin_addr))
{
*ipaddr = ntohl(tsa.sin_addr.s_addr);
return hoststr; /* We could call gethostbyaddr() on tsa to try and get the
official hostname but most systems would have already found
it when sending a dotted-quad to gethostbyname(). This is
good enough when that fails. */
}
eventlog(eventlog_level_error,"host_lookup","could not lookup host \"%s\"",hoststr);
return NULL;
}
#ifdef HAVE_GETHOSTBYNAME
memcpy(&tsa.sin_addr,(void *)hp->h_addr_list[0],sizeof(struct in_addr)); /* avoid warning */
*ipaddr = ntohl(tsa.sin_addr.s_addr);
if (hp->h_name)
return hp->h_name;
return hoststr;
#endif
}
/* FIXME: No it doesn't! pcAddress is not ever referenced in this
* function.
* CreepLord: Fixed much better way (will accept dns hostnames)
*/
int dbs_server_init(void)
{
int sd;
struct sockaddr_in sinInterface;
int val;
t_addr * servaddr;
dbs_server_connection_list=list_create();
if (d2dbs_d2ladder_init()==-1)
{
eventlog(eventlog_level_error,__FUNCTION__,"d2ladder_init() failed");
return -1;
}
if (cl_init(DEFAULT_HASHTBL_LEN, DEFAULT_GS_MAX)==-1)
{
eventlog(eventlog_level_error,__FUNCTION__,"cl_init() failed");
return -1;
}
if (psock_init()<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"psock_init() failed");
return -1;
}
sd = psock_socket(PSOCK_PF_INET, PSOCK_SOCK_STREAM, PSOCK_IPPROTO_TCP);
if (sd==-1)
{
eventlog(eventlog_level_error,__FUNCTION__,"psock_socket() failed : %s",strerror(psock_errno()));
return -1;
}
val = 1;
if (psock_setsockopt(sd, PSOCK_SOL_SOCKET, PSOCK_SO_REUSEADDR, &val, sizeof(val)) < 0)
{
eventlog(eventlog_level_error,__FUNCTION__,"psock_setsockopt() failed : %s",strerror(psock_errno()));
}
if (!(servaddr=addr_create_str(d2dbs_prefs_get_servaddrs(),INADDR_ANY,DEFAULT_LISTEN_PORT)))
{
eventlog(eventlog_level_error,__FUNCTION__,"could not get servaddr");
return -1;
}
sinInterface.sin_family = PSOCK_AF_INET;
sinInterface.sin_addr.s_addr = htonl(addr_get_ip(servaddr));
sinInterface.sin_port = htons(addr_get_port(servaddr));
if (psock_bind(sd, (struct sockaddr*)&sinInterface, (psock_t_socklen)sizeof(struct sockaddr_in)) < 0)
{
eventlog(eventlog_level_error,__FUNCTION__,"psock_bind() failed : %s",strerror(psock_errno()));
return -1;
}
if (psock_listen(sd, LISTEN_QUEUE) < 0)
{
eventlog(eventlog_level_error,__FUNCTION__,"psock_listen() failed : %s",strerror(psock_errno()));
return -1;
}
addr_destroy(servaddr);
return sd;
}
int pre_server_startup(void)
{
pvpgn_greeting();
if (oom_setup() < 0) {
eventlog(eventlog_level_error, __FUNCTION__, "OOM init failed");
return STATUS_OOM_FAILURE;
}
if (storage_init(prefs_get_storage_path()) < 0) {
eventlog(eventlog_level_error, "pre_server_startup", "storage init failed");
return STATUS_STORAGE_FAILURE;
}
if (psock_init() < 0) {
eventlog(eventlog_level_error, __FUNCTION__, "could not initialize socket functions");
return STATUS_PSOCK_FAILURE;
}
if (support_check_files(prefs_get_supportfile()) < 0) {
eventlog(eventlog_level_error, "pre_server_startup","some needed files are missing");
eventlog(eventlog_level_error, "pre_server_startup","please make sure you installed the supportfiles in %s",prefs_get_filedir());
return STATUS_SUPPORT_FAILURE;
}
if (anongame_maplists_create() < 0) {
eventlog(eventlog_level_error, "pre_server_startup", "could not load maps");
return STATUS_MAPLISTS_FAILURE;
}
if (anongame_matchlists_create() < 0) {
eventlog(eventlog_level_error, "pre_server_startup", "could not create matchlists");
return STATUS_MATCHLISTS_FAILURE;
}
if (fdwatch_init(prefs_get_max_connections())) {
eventlog(eventlog_level_error, __FUNCTION__, "error initilizing fdwatch");
return STATUS_FDWATCH_FAILURE;
}
connlist_create();
gamelist_create();
timerlist_create();
server_set_hostname();
channellist_create();
if (helpfile_init(prefs_get_helpfile())<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not load helpfile");
ipbanlist_create();
if (ipbanlist_load(prefs_get_ipbanfile())<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not load IP ban list");
if (adbannerlist_create(prefs_get_adfile())<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not load adbanner list");
if (autoupdate_load(prefs_get_mpqfile())<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not load autoupdate list");
if (versioncheck_load(prefs_get_versioncheck_file())<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not load versioncheck list");
if (news_load(prefs_get_newsfile())<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not load news list");
watchlist_create();
output_init();
attrlayer_init();
accountlist_create();
if (ladder_createxptable(prefs_get_xplevel_file(),prefs_get_xpcalc_file())<0) {
eventlog(eventlog_level_error, "pre_server_startup", "could not load WAR3 xp calc tables");
return STATUS_WAR3XPTABLES_FAILURE;
}
ladders_init();
ladders_load_accounts_to_ladderlists();
ladder_update_all_accounts();
if (characterlist_create("")<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not load character list");
if (prefs_get_track()) /* setup the tracking mechanism */
tracker_set_servers(prefs_get_trackserv_addrs());
if (command_groups_load(prefs_get_command_groups_file())<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not load command_groups list");
aliasfile_load(prefs_get_aliasfile());
if (trans_load(prefs_get_transfile(),TRANS_BNETD)<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not load trans list");
tournament_init(prefs_get_tournament_file());
anongame_infos_load(prefs_get_anongame_infos_file());
clanlist_load();
teamlist_load();
if (realmlist_create(prefs_get_realmfile())<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not load realm list");
topiclist_load(prefs_get_topicfile());
return 0;
}
extern int main(int argc, char * argv[])
{
int sockfd;
if (argc<1 || !argv || !argv[0])
{
fprintf(stderr,"bad arguments\n");
return STATUS_FAILURE;
}
getprefs(argc,argv);
if (!prefs.debug)
eventlog_del_level("debug");
if (prefs.logfile)
{
eventlog_set(stderr);
if (eventlog_open(prefs.logfile)<0)
{
eventlog(eventlog_level_fatal,__FUNCTION__,"could not use file \"%s\" for the eventlog (exiting)",prefs.logfile);
return STATUS_FAILURE;
}
}
#ifdef DO_DAEMONIZE
if (!prefs.foreground)
{
switch (fork())
{
case -1:
eventlog(eventlog_level_error,__FUNCTION__,"could not fork (fork: %s)\n",pstrerror(errno));
return STATUS_FAILURE;
case 0: /* child */
break;
default: /* parent */
return STATUS_SUCCESS;
}
close(STDINFD);
close(STDOUTFD);
close(STDERRFD);
# ifdef HAVE_SETPGID
if (setpgid(0,0)<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not create new process group (setpgid: %s)\n",pstrerror(errno));
return STATUS_FAILURE;
}
# else
# ifdef HAVE_SETPGRP
# ifdef SETPGRP_VOID
if (setpgrp()<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not create new process group (setpgrp: %s)\n",pstrerror(errno));
return STATUS_FAILURE;
}
# else
if (setpgrp(0,0)<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not create new process group (setpgrp: %s)\n",pstrerror(errno));
return STATUS_FAILURE;
}
# endif
# else
# ifdef HAVE_SETSID
if (setsid()<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not create new process group (setsid: %s)\n",pstrerror(errno));
return STATUS_FAILURE;
}
# else
# error "One of setpgid(), setpgrp(), or setsid() is required"
# endif
# endif
# endif
}
#endif
if (prefs.pidfile)
{
#ifdef HAVE_GETPID
FILE * fp;
if (!(fp = fopen(prefs.pidfile,"w")))
{
eventlog(eventlog_level_error,__FUNCTION__,"unable to open pid file \"%s\" for writing (fopen: %s)",prefs.pidfile,pstrerror(errno));
prefs.pidfile = NULL;
}
else
{
fprintf(fp,"%u",(unsigned int)getpid());
if (fclose(fp)<0)
eventlog(eventlog_level_error,__FUNCTION__,"could not close pid file \"%s\" after writing (fclose: %s)",prefs.pidfile,pstrerror(errno));
}
#else
eventlog(eventlog_level_warn,__FUNCTION__,"no getpid() system call, do not use the -P or the --pidfile option");
prefs.pidfile = NULL;
#endif
}
#ifdef HAVE_GETPID
eventlog(eventlog_level_info,__FUNCTION__,"bntrackd version "PVPGN_VERSION" process %u",(unsigned int)getpid());
#else
eventlog(eventlog_level_info,__FUNCTION__,"bntrackd version "PVPGN_VERSION);
#endif
if (psock_init()<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not initialize socket functions");
return STATUS_FAILURE;
}
/* create the socket */
if ((sockfd = psock_socket(PSOCK_PF_INET,PSOCK_SOCK_DGRAM,PSOCK_IPPROTO_UDP))<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not create UDP listen socket (psock_socket: %s)\n",pstrerror(psock_errno()));
return STATUS_FAILURE;
}
{
struct sockaddr_in servaddr;
/* bind the socket to correct port and interface */
memset(&servaddr,0,sizeof(servaddr));
servaddr.sin_family = PSOCK_AF_INET;
servaddr.sin_addr.s_addr = htonl(INADDR_ANY);
servaddr.sin_port = htons(prefs.port);
if (psock_bind(sockfd,(struct sockaddr *)&servaddr,sizeof(servaddr))<0)
{
eventlog(eventlog_level_error,__FUNCTION__,"could not bind to UDP port %hu (psock_bind: %s)\n",prefs.port,pstrerror(psock_errno()));
return STATUS_FAILURE;
}
}
if (server_process(sockfd)<0)
return STATUS_FAILURE;
return STATUS_SUCCESS;
}
extern int main(int argc, char * argv[])
{
int a;
int sd;
struct sockaddr_in saddr;
t_packet * packet;
t_packet * rpacket;
t_packet * fpacket;
char const * clienttag=NULL;
char const * archtag=NULL;
char const * servname=NULL;
unsigned short servport=0;
char const * hexfile=NULL;
char text[MAX_MESSAGE_LEN];
char const * reqfile=NULL;
struct hostent * host;
unsigned int commpos;
struct termios in_attr_old;
struct termios in_attr_new;
int changed_in;
unsigned int currsize;
unsigned int filelen;
unsigned int startoffset;
int startoffsetoverride=0;
#define EXIST_ACTION_UNSPEC -1
#define EXIST_ACTION_ASK 0
#define EXIST_ACTION_OVERWRITE 1
#define EXIST_ACTION_BACKUP 2
#define EXIST_ACTION_RESUME 3
int exist_action=EXIST_ACTION_UNSPEC;
struct stat exist_buf;
char const * filename;
FILE * fp;
FILE * hexstrm=NULL;
int fd_stdin;
t_bnettime bntime;
time_t tm;
char timestr[FILE_TIME_MAXLEN];
unsigned int screen_width,screen_height;
int munged;
if (argc<1 || !argv || !argv[0])
{
fprintf(stderr,"bad arguments\n");
return STATUS_FAILURE;
}
for (a=1; a<argc; a++)
if (servname && isdigit((int)argv[a][0]) && a+1>=argc)
{
if (str_to_ushort(argv[a],&servport)<0)
{
fprintf(stderr,"%s: \"%s\" should be a positive integer\n",argv[0],argv[a]);
usage(argv[0]);
}
}
else if (!servname && argv[a][0]!='-' && a+2>=argc)
servname = argv[a];
else if (strcmp(argv[a],"-b")==0 || strcmp(argv[a],"--client=SEXP")==0)
{
if (clienttag)
{
fprintf(stderr,"%s: client type was already specified as \"%s\"\n",argv[0],clienttag);
usage(argv[0]);
}
clienttag = CLIENTTAG_BROODWARS;
}
else if (strcmp(argv[a],"-d")==0 || strcmp(argv[a],"--client=DRTL")==0)
{
if (clienttag)
{
fprintf(stderr,"%s: client type was already specified as \"%s\"\n",argv[0],clienttag);
usage(argv[0]);
}
clienttag = CLIENTTAG_DIABLORTL;
}
else if (strcmp(argv[a],"--client=DSHR")==0)
{
if (clienttag)
{
fprintf(stderr,"%s: client type was already specified as \"%s\"\n",argv[0],clienttag);
usage(argv[0]);
}
clienttag = CLIENTTAG_DIABLOSHR;
}
else if (strcmp(argv[a],"-s")==0 || strcmp(argv[a],"--client=STAR")==0)
{
if (clienttag)
{
fprintf(stderr,"%s: client type was already specified as \"%s\"\n",argv[0],clienttag);
usage(argv[0]);
}
clienttag = CLIENTTAG_STARCRAFT;
}
else if (strcmp(argv[a],"--client=SSHR")==0)
{
if (clienttag)
{
fprintf(stderr,"%s: client type was already specified as \"%s\"\n",argv[0],clienttag);
usage(argv[0]);
}
clienttag = CLIENTTAG_SHAREWARE;
}
else if (strcmp(argv[a],"-w")==0 || strcmp(argv[a],"--client=W2BN")==0)
{
if (clienttag)
{
fprintf(stderr,"%s: client type was already specified as \"%s\"\n",argv[0],clienttag);
usage(argv[0]);
}
clienttag = CLIENTTAG_WARCIIBNE;
}
else if (strcmp(argv[a],"--client=D2DV")==0)
{
if (clienttag)
{
fprintf(stderr,"%s: client type was already specified as \"%s\"\n",argv[0],clienttag);
usage(argv[0]);
}
clienttag = CLIENTTAG_DIABLO2DV;
}
else if (strcmp(argv[a],"--client=D2XP")==0)
{
if (clienttag)
{
fprintf(stderr,"%s: client type was already specified as \"%s\"\n",argv[0],clienttag);
usage(argv[0]);
}
clienttag = CLIENTTAG_DIABLO2XP;
}
else if (strcmp(argv[a],"--client=WAR3")==0)
{
if (clienttag)
{
fprintf(stderr,"%s: client type was already specified as \"%s\"\n",argv[0],clienttag);
usage(argv[0]);
}
clienttag = CLIENTTAG_WARCRAFT3;
}
else if (strncmp(argv[a],"--client=",9)==0)
{
fprintf(stderr,"%s: unknown client tag \"%s\"\n",argv[0],&argv[a][9]);
usage(argv[0]);
}
else if (strncmp(argv[a],"--hexdump=",10)==0)
{
if (hexfile)
{
fprintf(stderr,"%s: hexdump file was already specified as \"%s\"\n",argv[0],hexfile);
usage(argv[0]);
}
hexfile = &argv[a][10];
}
else if (strcmp(argv[a],"--arch=IX86")==0)
{
if (archtag)
{
fprintf(stderr,"%s: client arch was already specified as \"%s\"\n",argv[0],archtag);
usage(argv[0]);
}
archtag = ARCHTAG_WINX86;
}
else if (strcmp(argv[a],"--arch=PMAC")==0)
{
if (archtag)
{
fprintf(stderr,"%s: client arch was already specified as \"%s\"\n",argv[0],archtag);
usage(argv[0]);
}
archtag = ARCHTAG_MACPPC;
}
else if (strcmp(argv[a],"--arch=XMAC")==0)
{
if (archtag)
{
fprintf(stderr,"%s: client arch was already specified as \"%s\"\n",argv[0],archtag);
usage(argv[0]);
}
archtag = ARCHTAG_OSXPPC;
}
else if (strncmp(argv[a],"--arch=",7)==0)
{
fprintf(stderr,"%s: unknown arch tag \"%s\"\n",argv[0],&argv[a][9]);
usage(argv[0]);
}
else if (strncmp(argv[a],"--startoffset=",14)==0)
{
if (startoffsetoverride)
{
fprintf(stderr,"%s: startoffset was already specified as %u\n",argv[0],startoffset);
usage(argv[0]);
}
if (str_to_uint(&argv[a][14],&startoffset)<0)
{
fprintf(stderr,"%s: startoffset \"%s\" should be a positive integer\n",argv[0],&argv[a][14]);
usage(argv[0]);
}
startoffsetoverride = 1;
}
else if (strncmp(argv[a],"--exists=",9)==0)
{
if (exist_action!=EXIST_ACTION_UNSPEC)
{
fprintf(stderr,"%s: exists was already specified\n",argv[0]);
usage(argv[0]);
}
if (argv[a][9]=='o' || argv[a][9]=='O')
exist_action = EXIST_ACTION_OVERWRITE;
else if (argv[a][9]=='a' || argv[a][9]=='A')
exist_action = EXIST_ACTION_ASK;
else if (argv[a][9]=='b' || argv[a][9]=='B')
exist_action = EXIST_ACTION_BACKUP;
else if (argv[a][9]=='r' || argv[a][9]=='R')
exist_action = EXIST_ACTION_RESUME;
else {
fprintf(stderr,"%s: exists must begin with a,A,o,O,b,B,r or R",argv[0]);
usage(argv[0]);
}
}
else if (strncmp(argv[a],"--file=",7)==0)
{
if (reqfile)
{
fprintf(stderr,"%s: file was already specified as \"%s\"\n",argv[0],reqfile);
usage(argv[0]);
}
reqfile = &argv[a][7];
}
else if (strcmp(argv[a],"-v")==0 || strcmp(argv[a],"--version")==0)
{
printf("version "BNETD_VERSION"\n");
return 0;
}
else if (strcmp(argv[a],"-h")==0 || strcmp(argv[a],"--help")==0 || strcmp(argv[a],"--usage")==0)
usage(argv[0]);
else if (strcmp(argv[a],"--client")==0 || strcmp(argv[a],"--hexdump")==0)
{
fprintf(stderr,"%s: option \"%s\" requires an argument\n",argv[0],argv[a]);
usage(argv[0]);
}
else
{
fprintf(stderr,"%s: unknown option \"%s\"\n",argv[0],argv[a]);
usage(argv[0]);
}
if (servport==0)
servport = BNETD_SERV_PORT;
if (!clienttag)
clienttag = CLIENTTAG_STARCRAFT;
if (!archtag)
archtag = ARCHTAG_WINX86;
if (!servname)
servname = BNETD_DEFAULT_HOST;
if (exist_action==EXIST_ACTION_UNSPEC)
exist_action = EXIST_ACTION_ASK;
if (hexfile)
if (!(hexstrm = fopen(hexfile,"w")))
fprintf(stderr,"%s: could not open file \"%s\" for writing the hexdump (fopen: %s)",argv[0],hexfile,strerror(errno));
else
fprintf(hexstrm,"# dump generated by bnftp version "BNETD_VERSION"\n");
if (psock_init()<0)
{
fprintf(stderr,"%s: could not inialialize socket functions\n",argv[0]);
return STATUS_FAILURE;
}
if (!(host = gethostbyname(servname)))
{
fprintf(stderr,"%s: unknown host \"%s\"\n",argv[0],servname);
return STATUS_FAILURE;
}
fd_stdin = fileno(stdin);
if (tcgetattr(fd_stdin,&in_attr_old)>=0)
{
in_attr_new = in_attr_old;
in_attr_new.c_lflag &= ~(ECHO | ICANON); /* turn off ECHO and ICANON */
in_attr_new.c_cc[VMIN] = 1; /* require reads to return at least one byte */
in_attr_new.c_cc[VTIME] = 0; /* no timeout */
tcsetattr(fd_stdin,TCSANOW,&in_attr_new);
changed_in = 1;
}
else
{
fprintf(stderr,"%s: could not get terminal attributes for stdin\n",argv[0]);
changed_in = 0;
}
if (client_get_termsize(fd_stdin,&screen_width,&screen_height)<0)
{
fprintf(stderr,"%s: could not determine screen size\n",argv[0]);
if (changed_in)
tcsetattr(fd_stdin,TCSAFLUSH,&in_attr_old);
return STATUS_FAILURE;
}
if ((sd = psock_socket(PSOCK_PF_INET,PSOCK_SOCK_STREAM,PSOCK_IPPROTO_TCP))<0)
{
fprintf(stderr,"%s: could not create socket (psock_socket: %s)\n",argv[0],strerror(psock_errno()));
if (changed_in)
tcsetattr(fd_stdin,TCSAFLUSH,&in_attr_old);
return STATUS_FAILURE;
}
memset(&saddr,0,sizeof(saddr));
saddr.sin_family = PSOCK_AF_INET;
saddr.sin_port = htons(servport);
memcpy(&saddr.sin_addr.s_addr,host->h_addr_list[0],host->h_length);
if (psock_connect(sd,(struct sockaddr *)&saddr,sizeof(saddr))<0)
{
fprintf(stderr,"%s: could not connect to server \"%s\" port %hu (psock_connect: %s)\n",argv[0],servname,servport,strerror(psock_errno()));
if (changed_in)
tcsetattr(fd_stdin,TCSAFLUSH,&in_attr_old);
return STATUS_FAILURE;
}
printf("Connected to %s:%hu.\n",inet_ntoa(saddr.sin_addr),servport);
#ifdef CLIENTDEBUG
eventlog_set(stderr);
#endif
if (!(packet = packet_create(packet_class_init)))
{
fprintf(stderr,"%s: could not create packet\n",argv[0]);
if (changed_in)
tcsetattr(fd_stdin,TCSAFLUSH,&in_attr_old);
return STATUS_FAILURE;
}
bn_byte_set(&packet->u.client_initconn.class,CLIENT_INITCONN_CLASS_FILE);
if (hexstrm)
{
fprintf(hexstrm,"%d: send class=%s[0x%02hx] type=%s[0x%04hx] length=%u\n",
sd,
packet_get_class_str(packet),(unsigned int)packet_get_class(packet),
packet_get_type_str(packet,packet_dir_from_client),packet_get_type(packet),
packet_get_size(packet));
hexdump(hexstrm,packet_get_raw_data(packet,0),packet_get_size(packet));
}
client_blocksend_packet(sd,packet);
packet_del_ref(packet);
if (!(rpacket = packet_create(packet_class_file)))
{
fprintf(stderr,"%s: could not create packet\n",argv[0]);
if (changed_in)
tcsetattr(fd_stdin,TCSAFLUSH,&in_attr_old);
return STATUS_FAILURE;
}
if (!(fpacket = packet_create(packet_class_raw)))
{
fprintf(stderr,"%s: could not create packet\n",argv[0]);
if (changed_in)
tcsetattr(fd_stdin,TCSAFLUSH,&in_attr_old);
packet_del_ref(rpacket);
return STATUS_FAILURE;
}
if (!reqfile) /* if not specified on the command line then prompt for it */
{
munged = 1;
commpos = 0;
text[0] = '\0';
for (;;)
{
switch (client_get_comm("filename: ",text,sizeof(text),&commpos,1,munged,screen_width))
{
case -1: /* cancel or error */
printf("\n");
if (changed_in)
tcsetattr(fd_stdin,TCSAFLUSH,&in_attr_old);
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
case 0: /* timeout */
munged = 0;
continue;
case 1:
munged = 0;
if (text[0]=='\0')
continue;
printf("\n");
}
break;
}
reqfile = text;
}
if (stat(reqfile,&exist_buf)==0) /* check if the file exists */
{
char text2[MAX_MESSAGE_LEN];
munged = 1;
commpos = 0;
text2[0] = '\0';
while (exist_action==EXIST_ACTION_ASK)
{
switch (client_get_comm("File exists [O]verwrite, [B]ackup or [R]esume?: ",text2,sizeof(text2),&commpos,1,munged,screen_width))
{
case -1: /* cancel or error */
printf("\n");
if (changed_in)
tcsetattr(fd_stdin,TCSAFLUSH,&in_attr_old);
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
case 0: /* timeout */
munged = 0;
continue;
case 1:
munged = 0;
if (text2[0]=='\0')
continue;
printf("\n");
break;
}
switch (text2[0])
{
case 'o':
case 'O':
exist_action = EXIST_ACTION_OVERWRITE;
break;
case 'b':
case 'B':
exist_action = EXIST_ACTION_BACKUP;
break;
case 'r':
case 'R':
exist_action = EXIST_ACTION_RESUME;
break;
default:
printf("Please answer with o,O,b,B,r or R.\n");
munged = 1;
continue;
}
break;
}
switch (exist_action)
{
case EXIST_ACTION_OVERWRITE:
if (!startoffsetoverride)
startoffset = 0;
break;
case EXIST_ACTION_BACKUP:
{
char * bakfile;
unsigned int bnr;
int renamed=0;
if (!(bakfile = malloc(strlen(reqfile)+1+2+1))) /* assuming we go up to bnr 99 we need reqfile+'.'+'99'+'\0' */
{
fprintf(stderr,"%s: unable to allocate memory for backup filename.\n",argv[0]);
if (changed_in)
tcsetattr(fd_stdin,TCSAFLUSH,&in_attr_old);
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
}
for (bnr=0; bnr<100; bnr++)
{
sprintf(bakfile,"%s.%d",reqfile,bnr);
if (stat(bakfile,&exist_buf)==0)
continue; /* backup exists */
/* backup does not exist */
if (rename(reqfile,bakfile)<0) /* just rename the existing file to the backup */
fprintf(stderr,"%s: could not create backup file \"%s\" (rename: %s)\n",argv[0],bakfile,strerror(errno));
else
{
renamed = 1;
printf("Renaming \"%s\" to \"%s\".\n",reqfile,bakfile);
}
break;
}
free(bakfile);
if (!renamed)
{
fprintf(stderr,"%s: could not create backup for \"%s\".\n",argv[0],reqfile);
if (changed_in)
tcsetattr(fd_stdin,TCSAFLUSH,&in_attr_old);
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
}
if (!startoffsetoverride)
startoffset = 0;
}
break;
case EXIST_ACTION_RESUME:
if (!startoffsetoverride)
startoffset = exist_buf.st_size;
break;
}
}
else
if (!startoffsetoverride)
startoffset = 0;
if (changed_in)
tcsetattr(fd_stdin,TCSAFLUSH,&in_attr_old);
if (!(packet = packet_create(packet_class_file)))
{
fprintf(stderr,"%s: could not create packet\n",argv[0]);
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
}
packet_set_size(packet,sizeof(t_client_file_req));
packet_set_type(packet,CLIENT_FILE_REQ);
bn_int_tag_set(&packet->u.client_file_req.archtag,archtag);
bn_int_tag_set(&packet->u.client_file_req.clienttag,clienttag);
bn_int_set(&packet->u.client_file_req.adid,0);
bn_int_set(&packet->u.client_file_req.extensiontag,0);
bn_int_set(&packet->u.client_file_req.startoffset,startoffset);
bn_long_set_a_b(&packet->u.client_file_req.timestamp,0x00000000,0x00000000);
packet_append_string(packet,reqfile);
if (hexstrm)
{
fprintf(hexstrm,"%d: send class=%s[0x%02hx] type=%s[0x%04hx] length=%u\n",
sd,
packet_get_class_str(packet),(unsigned int)packet_get_class(packet),
packet_get_type_str(packet,packet_dir_from_client),packet_get_type(packet),
packet_get_size(packet));
hexdump(hexstrm,packet_get_raw_data(packet,0),packet_get_size(packet));
}
printf("\nRequesting info...");
fflush(stdout);
client_blocksend_packet(sd,packet);
packet_del_ref(packet);
do
{
if (client_blockrecv_packet(sd,rpacket)<0)
{
fprintf(stderr,"%s: server closed connection\n",argv[0]);
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
}
if (hexstrm)
{
fprintf(hexstrm,"%d: recv class=%s[0x%02hx] type=%s[0x%04hx] length=%u\n",
sd,
packet_get_class_str(rpacket),(unsigned int)packet_get_class(rpacket),
packet_get_type_str(rpacket,packet_dir_from_server),packet_get_type(rpacket),
packet_get_size(rpacket));
hexdump(hexstrm,packet_get_raw_data(rpacket,0),packet_get_size(rpacket));
}
}
while (packet_get_type(rpacket)!=SERVER_FILE_REPLY);
filelen = bn_int_get(rpacket->u.server_file_reply.filelen);
bn_long_to_bnettime(rpacket->u.server_file_reply.timestamp,&bntime);
tm = bnettime_to_time(bntime);
strftime(timestr,FILE_TIME_MAXLEN,FILE_TIME_FORMAT,localtime(&tm));
filename = packet_get_str_const(rpacket,sizeof(t_server_file_reply),MAX_FILENAME_STR);
if (exist_action==EXIST_ACTION_RESUME)
{
if (!(fp = fopen(reqfile,"ab")))
{
fprintf(stderr,"%s: could not open file \"%s\" for appending (fopen: %s)\n",argv[0],reqfile,strerror(errno));
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
}
}
else
{
if (!(fp = fopen(reqfile,"wb")))
{
fprintf(stderr,"%s: could not open file \"%s\" for writing (fopen: %s)\n",argv[0],reqfile,strerror(errno));
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
}
}
printf("\n name: \"");
str_print_term(stdout,filename,0,0);
printf("\"\n changed: %s\n length: %u bytes\n",timestr,filelen);
fflush(stdout);
if (startoffset>0) {
filelen -= startoffset; /* for resuming files */
printf("Resuming at position %u (%u bytes remaining).\n",startoffset,filelen);
}
printf("\nSaving to \"%s\"...",reqfile);
for (currsize=0; currsize+MAX_PACKET_SIZE<=filelen; currsize+=MAX_PACKET_SIZE)
{
printf(".");
fflush(stdout);
if (client_blockrecv_raw_packet(sd,fpacket,MAX_PACKET_SIZE)<0)
{
printf("error\n");
fprintf(stderr,"%s: server closed connection\n",argv[0]);
if (fclose(fp)<0)
fprintf(stderr,"%s: could not close file \"%s\" after writing (fclose: %s)\n",argv[0],reqfile,strerror(errno));
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
}
if (hexstrm)
{
fprintf(hexstrm,"%d: recv class=%s[0x%02hx] type=%s[0x%04hx] length=%u\n",
sd,
packet_get_class_str(fpacket),(unsigned int)packet_get_class(fpacket),
packet_get_type_str(fpacket,packet_dir_from_server),packet_get_type(fpacket),
packet_get_size(fpacket));
hexdump(hexstrm,packet_get_raw_data(fpacket,0),packet_get_size(fpacket));
}
if (fwrite(packet_get_raw_data_const(fpacket,0),1,MAX_PACKET_SIZE,fp)<MAX_PACKET_SIZE)
{
printf("error\n");
fprintf(stderr,"%s: could not write to file \"%s\" (fwrite: %s)\n",argv[0],reqfile,strerror(errno));
if (fclose(fp)<0)
fprintf(stderr,"%s: could not close file \"%s\" after writing (fclose: %s)\n",argv[0],reqfile,strerror(errno));
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
}
}
filelen -= currsize;
if (filelen)
{
printf(".");
fflush(stdout);
if (client_blockrecv_raw_packet(sd,fpacket,filelen)<0)
{
printf("error\n");
fprintf(stderr,"%s: server closed connection\n",argv[0]);
if (fclose(fp)<0)
fprintf(stderr,"%s: could not close file \"%s\" after writing (fclose: %s)\n",argv[0],reqfile,strerror(errno));
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
}
if (hexstrm)
{
fprintf(hexstrm,"%d: recv class=%s[0x%02hx] type=%s[0x%04hx] length=%u\n",
sd,
packet_get_class_str(fpacket),(unsigned int)packet_get_class(fpacket),
packet_get_type_str(fpacket,packet_dir_from_server),packet_get_type(fpacket),
packet_get_size(fpacket));
hexdump(hexstrm,packet_get_raw_data(fpacket,0),packet_get_size(fpacket));
}
if (fwrite(packet_get_raw_data_const(fpacket,0),1,filelen,fp)<filelen)
{
printf("error\n");
fprintf(stderr,"%s: could not write to file \"%s\"\n",argv[0],reqfile);
if (fclose(fp)<0)
fprintf(stderr,"%s: could not close file \"%s\" after writing (fclose: %s)\n",argv[0],reqfile,strerror(errno));
packet_del_ref(fpacket);
packet_del_ref(rpacket);
return STATUS_FAILURE;
}
}
packet_del_ref(fpacket);
packet_del_ref(rpacket);
if (hexstrm)
{
fprintf(hexstrm,"# end of dump\n");
if (fclose(hexstrm)<0)
fprintf(stderr,"%s: could not close hexdump file \"%s\" after writing (fclose: %s)",argv[0],hexfile,strerror(errno));
}
if (fclose(fp)<0)
{
fprintf(stderr,"%s: could not close file \"%s\" after writing (fclose: %s)\n",argv[0],reqfile,strerror(errno));
return STATUS_FAILURE;
}
printf("done\n");
return STATUS_FAILURE;
}
extern int server_process(void)
{
t_addrlist * laddrs;
t_addr * curr_laddr;
t_addr_data laddr_data;
t_laddr_info * laddr_info;
#ifdef HAVE_POLL
struct pollfd * fds = NULL;
int num_fd;
#else
struct timeval tv;
t_psock_fd_set rfds, wfds;
int highest_fd;
#endif
time_t curr_exittime, prev_exittime, prev_savetime, track_time, now;
unsigned int syncdelta;
t_connection * c;
t_elem const * acurr;
t_elem const * ccurr;
int csocket;
#ifdef DO_POSIXSIG
sigset_t block_set;
sigset_t save_set;
#endif
unsigned int count;
if (psock_init()<0)
{
eventlog(eventlog_level_error,"server_process","could not initialize socket functions");
return -1;
}
server_set_name();
/* Start with the Battle.net address list */
if (!(laddrs = addrlist_create(prefs_get_bnetdserv_addrs(),INADDR_ANY,BNETD_SERV_PORT)))
{
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());
if (psock_deinit()<0)
eventlog(eventlog_level_error,"server_process","could not deinitialize socket functions");
return -1;
}
/* Mark all these laddrs for being classic Battle.net service */
LIST_TRAVERSE_CONST(laddrs,acurr)
{
curr_laddr = elem_get_data(acurr);
if (addr_get_data(curr_laddr).p)
continue;
if (!(laddr_info = malloc(sizeof(t_laddr_info))))
{
eventlog(eventlog_level_error,"server_process","could not create %s address info (malloc: %s)",laddr_type_get_str(laddr_type_bnet),strerror(psock_errno()));
goto error_addr_list;
}
laddr_info->usocket = -1;
laddr_info->ssocket = -1;
laddr_info->type = laddr_type_bnet;
laddr_data.p = laddr_info;
if (addr_set_data(curr_laddr,laddr_data)<0)
{
eventlog(eventlog_level_error,"server_process","could not set address data");
if (laddr_info->usocket!=-1)
{
psock_close(laddr_info->usocket);
laddr_info->usocket = -1;
}
if (laddr_info->ssocket!=-1)
{
psock_close(laddr_info->ssocket);
laddr_info->ssocket = -1;
}
goto error_poll;
}
}
