int SHOW_MODULE_INFO(const char *filename, const char *fmtstr)
{
int fp;
struct obj_file *f;
/* Locate the file to be loaded. */
if (!strchr(filename, '/') && !strchr(filename, '.')) {
char *tmp = search_module_path(filename);
if (tmp == NULL) {
error("%s: no module by that name found", filename);
return 1;
}
filename = tmp;
}
error_file = filename;
/* Attempt to open and parse the module file. */
if ((fp = gzf_open(filename, O_RDONLY)) < 0) {
error("%s: %m", filename);
return -1;
} else if ((f = obj_load(fp, ET_REL, filename)) == NULL)
return -1;
gzf_close(fp);
format_query_string(f, fmtstr);
return 0;
}
void query_game_server( serv_addr *game_server )
{
int addr_len, ret_val;
struct packet message;
client.sin_addr = game_server->addr;
client.sin_port = game_server->port;
addr_len = sizeof( client );
message.type = htons( GAMESPY_QUERY );
int fill_size = format_query_string( message.data);
ret_val = sendto(gSocket, (char *) &message,
HEADER_SIZE+fill_size, 0,
(struct sockaddr *)&client, addr_len);
}
bool process_socket( BYTE response_type )
{
int addr_len, ret_val;
serv_addr game_server;
struct packet receive_packet, send_packet;
int num_servers, fill_size, current_byte;
int packets_to_send;
BYTE packet_num, packet_tot;
addr_len = sizeof( client );
ret_val = recvfrom(gSocket, (char *) &receive_packet, packet_size, 0,
(struct sockaddr *)&client, &addr_len);
if( ret_val == SOCKET_ERROR )
{
ret_val = WSAGetLastError(); // if WSAWOULDBLOCK, no message was waiting
if( ret_val != WSAEWOULDBLOCK )
{
printf("Function recvfrom failure, error: %d\n", ret_val);
WSACleanup();
exit(EXIT_FAILURE);
}
return false;
}
/* check to seee if server is banned */
game_server.addr.s_addr = client.sin_addr.s_addr;
game_server.port = client.sin_port;
if( banned_list.IsInList( &game_server ) )
{
log_file.log("Ignoring message from banned server %s",inet_ntoa(client.sin_addr));
return false;
}
/*---------------------------------------------*/
/* check version number */
/* for now, only support exact version matches */
/*---------------------------------------------*/
if( receive_packet.version != version_number )
{
log_file.log("Ignoring message: Invalid version %d",(int)receive_packet.version);
return false;
}
DWORD time = GetTickCount();
switch( receive_packet.type )
{
case GAMESPY_QUERY: // reply to GAMESPY_QUERY with list of GameServers
log_file.log("Query from %s:%ld, id = %ld",inet_ntoa(client.sin_addr),(long)ntohs(client.sin_port),(long)ntohs(receive_packet.key));
// get rid of old entries before sending off
server_list.TimeoutList(time, timeout_value);
/*--------------------------------------------------------------------*/
/* The first packet we send will have the MASTER_NAME and MOTD string */
/* Note that the null byte is not sent. */
/*--------------------------------------------------------------------*/
current_byte = 0;
send_packet.data[current_byte++] = (BYTE)strlen(master_name);
strcpy(&send_packet.data[current_byte],master_name);
current_byte += strlen(master_name);
send_packet.data[current_byte++] = (BYTE)strlen(motd_string);
strcpy(&send_packet.data[current_byte],motd_string);
current_byte += strlen(motd_string);
/*---------------------------------------------------------------*/
/* Since the buffer may not be large enough to handle all of the */
/* servers, keep sending packets until all the data gets across. */
/*---------------------------------------------------------------*/
packet_tot = get_total_packets(server_list.Size(), SERVER_INFO_SIZE, packet_size-HEADER_SIZE-sizeof(short), current_byte);
packets_to_send = receive_packet.packet_num;
if( packets_to_send == REQUEST_ALL_PACKETS )
packets_to_send = packet_tot;
//cout<<" Sending "<< packets_to_send <<" packets out of "<< (int)packet_tot << endl;
server_list.ResetFillIndex();
for( packet_num = 1; packet_num <= packet_tot; packet_num++ )
{
// FillBuffer fills the data buffer with server information
// 2 byte are reserved in data buffer for num_servers
server_list.FillBuffer( &num_servers, &fill_size,
packet_size-HEADER_SIZE-current_byte,
&send_packet.data[current_byte+sizeof(short)] );
if( receive_packet.packet_num == REQUEST_ALL_PACKETS ||
receive_packet.packet_num == packet_num )
{
send_packet.packet_num = (BYTE)packet_num;
send_packet.packet_tot = (BYTE)packet_tot;
send_packet.version = (BYTE)version_number;
send_packet.type = (BYTE)MSTRSVR_REPLY;
send_packet.key = receive_packet.key;
send_packet.id = htons(master_id);
*((short *)&send_packet.data[current_byte]) = htons((short)num_servers);
current_byte += sizeof(short);
ret_val = sendto(gSocket, (char *) &send_packet,
HEADER_SIZE+current_byte+fill_size, 0,
(struct sockaddr *)&client, addr_len);
if (ret_val == SOCKET_ERROR) {
cout<<" Sent "<< (int)packet_num << " ret_val = " << (int)ret_val << endl;
cout << " error code : " << int(WSAGetLastError()) << endl;
}
}
current_byte = 0;
}
break;
case HEARTBT_MESSAGE:
server_list.TimeoutList(time, timeout_value); // get rid of old entries
// if server already in list, just update new heartbeat time
if( server_list.IsInList( &game_server ) )
server_list.UpdateServer( &game_server, time, NORMAL_SERVER_KEY );
// If server not in list, add to verification list
// and query game server for verification
else
{
// max sure that we don't already have too many addresses from same IP
if(!server_list.MaxServersReached( &game_server ))
{
// assign verification key and add server to verify list
WORD key=NORMAL_SERVER_KEY;
do
{
key = (WORD)GetTickCount();
}
while (key <= VERIFY_SERVER_KEY );
// get rid of old entries
verify_list.TimeoutList(time, timeout_value);
// don't want duplicate entries, so if already in verify
// list for some reason, just update key
if( verify_list.IsInList( &game_server ))
{
if(verify_list.UpdateServer( &game_server, time, key))
return false;
}
else
verify_list.AddServer( &game_server, time, key, NULL);
// send off verification message
send_packet.version = version_number;
send_packet.type = (BYTE)GAMESPY_QUERY;
send_packet.key = htons(key);
send_packet.id = htons(master_id);
fill_size=format_query_string( send_packet.data);
ret_val = sendto(gSocket, (char *) &send_packet,
HEADER_SIZE+fill_size, 0,
(struct sockaddr *)&client, addr_len);
}
}
break;
case GAMESVR_REPLY:
// first, see if server is in verify list at all
if(BYTE(receive_packet.packet_tot) == 0xf0) // check game type
{
if( verify_list.IsInList( &game_server ) )
{
// is in list, now check key (we could do all this in one step but we get better error checking this way
if( verify_list.IsInList( &game_server, ntohs(receive_packet.key) ))
{
// make sure max servers haven't been reached for this server (this will rarely happen at this stage)
if(!server_list.MaxServersReached( &game_server ))
{
// server name should be part of message
server_list.AddServer( &game_server, time, NORMAL_SERVER_KEY, &receive_packet.data[2]);
verify_list.DeleteNode( &game_server );
}
}
else
{
log_file.log("Error: Wrong verification key sent by server: %s:%ld",inet_ntoa(game_server.addr),ntohs(game_server.port));
}
}
else
{
log_file.log("Received unsolicited GAMESVR_REPLY");
}
}
break;
case GAMESVR_VERIFY:
break;
default:
log_file.log("Unknown message %ld recvfrom %ld\n",(long)receive_packet.type,(long)ntohs(client.sin_port));
break;
}
return false;
}
