717 lines
15 KiB
Plaintext
717 lines
15 KiB
Plaintext
LICENSE: The Artistic License 2.0
|
|
|
|
/*
|
|
* qstat.h
|
|
* by Steve Jankowski
|
|
* steve@qstat.org
|
|
* http://www.qstat.org
|
|
*
|
|
* Copyright 1996,1997,1998,1999,2000,2001,2002 by Steve Jankowski
|
|
*/
|
|
|
|
|
|
#define HAZE_BASIC_INFO 0x01
|
|
#define HAZE_GAME_RULES 0x02
|
|
#define HAZE_PLAYER_INFO 0x04
|
|
#define HAZE_TEAM_INFO 0x08
|
|
|
|
|
|
// Format:
|
|
// 1 - 8: Query Request
|
|
// 9 - 12: Query Header
|
|
// 13: Query ID
|
|
|
|
// Query ID is made up of the following
|
|
// 0x01: Basic Info
|
|
// 0x02: Game Rules
|
|
// 0x03: Player Information
|
|
// 0x04: Team Information
|
|
unsigned char haze_status_query[] = {
|
|
'f', 'r', 'd', 'q', 'u', 'e', 'r', 'y',
|
|
0x10,0x20,0x30,0x40,
|
|
0x0A
|
|
};
|
|
|
|
// Format:
|
|
// 1 - 8: Query Request
|
|
// 9 - 12: Query Header
|
|
// 13: Query ID
|
|
|
|
// Query ID is made up of the following
|
|
// 0x01: Basic Info
|
|
// 0x02: Game Rules
|
|
// 0x03: Player Information
|
|
// 0x04: Team Information
|
|
unsigned char haze_player_query[] = {
|
|
'f', 'r', 'd', 'q', 'u', 'e', 'r', 'y',
|
|
0x10,0x20,0x30,0x40,
|
|
0x03
|
|
};
|
|
|
|
|
|
{
|
|
/* HAZE PROTOCOL */
|
|
HAZE_SERVER, /* id */
|
|
"HAZES", /* type_prefix */
|
|
"hazes", /* type_string */
|
|
"-hazes", /* type_option */
|
|
"Haze Protocol", /* game_name */
|
|
0, /* master */
|
|
0, /* default_port */
|
|
0, /* port_offset */
|
|
TF_SINGLE_QUERY, /* flags */
|
|
"gametype", /* game_rule */
|
|
"HAZE", /* template_var */
|
|
(char*) &haze_status_query, /* status_packet */
|
|
sizeof( haze_status_query), /* status_len */
|
|
(char*) &haze_player_query, /* player_packet */
|
|
sizeof( haze_player_query), /* player_len */
|
|
NULL, /* rule_packet */
|
|
0, /* rule_len */
|
|
NULL, /* master_packet */
|
|
0, /* master_len */
|
|
NULL, /* master_protocol */
|
|
NULL, /* master_query */
|
|
display_gs2_player_info, /* display_player_func */
|
|
display_server_rules, /* display_rule_func */
|
|
raw_display_gs2_player_info, /* display_raw_player_func */
|
|
raw_display_server_rules, /* display_raw_rule_func */
|
|
xml_display_player_info, /* display_xml_player_func */
|
|
xml_display_server_rules, /* display_xml_rule_func */
|
|
send_haze_request_packet, /* status_query_func */
|
|
NULL, /* rule_query_func */
|
|
NULL, /* player_query_func */
|
|
deal_with_haze_packet, /* packet_func */
|
|
},
|
|
|
|
|
|
/*
|
|
* qstat 2.8
|
|
* by Steve Jankowski
|
|
*
|
|
* New Haze query protocol
|
|
* Copyright 2005 Steven Hartland
|
|
*
|
|
* Licensed under the Artistic License, see LICENSE.txt for license terms
|
|
*
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#ifndef _WIN32
|
|
#include <netinet/in.h>
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#include <stdlib.h>
|
|
#include <stdio.h>
|
|
|
|
#include "debug.h"
|
|
#include "qstat.h"
|
|
#include "packet_manip.h"
|
|
|
|
|
|
// Format:
|
|
// 1 - 8: Challenge Request / Response
|
|
char haze_challenge[] = {
|
|
'f', 'r', 'd', 'c', '_', '_', '_', '_'
|
|
};
|
|
|
|
int process_haze_packet( struct qserver *server );
|
|
|
|
// Player headers
|
|
#define PLAYER_NAME_HEADER 1
|
|
#define PLAYER_SCORE_HEADER 2
|
|
#define PLAYER_DEATHS_HEADER 3
|
|
#define PLAYER_PING_HEADER 4
|
|
#define PLAYER_KILLS_HEADER 5
|
|
#define PLAYER_TEAM_HEADER 6
|
|
#define PLAYER_OTHER_HEADER 7
|
|
|
|
// Team headers
|
|
#define TEAM_NAME_HEADER 1
|
|
#define TEAM_OTHER_HEADER 2
|
|
|
|
// Challenge response algorithum
|
|
// Before sending a qr2 query (type 0x00) the client must first send a
|
|
// challenge request (type 0x09). The host will respond with the same
|
|
// packet type containing a string signed integer.
|
|
//
|
|
// Once the challenge is received the client should convert the string to a
|
|
// network byte order integer and embed it in the keys query.
|
|
//
|
|
// Example:
|
|
//
|
|
// challenge request: [0xFE][0xFD][0x09][0x.. 4-byte-instance]
|
|
// challenge response: [0x09][0x.. 4-byte-instance]["-1287574694"]
|
|
// query: [0xFE][0xFD][0x00][0x.. 4-byte-instance][0xb3412b5a "-1287574694"]
|
|
//
|
|
|
|
query_status_t deal_with_haze_packet( struct qserver *server, char *rawpkt, int pktlen )
|
|
{
|
|
char *ptr = rawpkt;
|
|
unsigned int pkt_id;
|
|
unsigned short len;
|
|
unsigned char pkt_max, pkt_index;
|
|
|
|
debug( 2, "packet..." );
|
|
|
|
if ( pktlen < 8 )
|
|
{
|
|
// invalid packet
|
|
malformed_packet( server, "too short" );
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
if ( 0 == strncmp( ptr, "frdcr", 5 ) )
|
|
{
|
|
// challenge response
|
|
ptr += 8;
|
|
server->challenge = 1;
|
|
|
|
// Correct the stats due to two phase protocol
|
|
server->retry1++;
|
|
server->n_packets--;
|
|
if ( server->retry1 == n_retries || server->flags & FLAG_BROADCAST )
|
|
{
|
|
//server->n_requests--;
|
|
}
|
|
else
|
|
{
|
|
server->n_retries--;
|
|
}
|
|
return send_haze_request_packet( server );
|
|
}
|
|
|
|
if ( pktlen < 12 )
|
|
{
|
|
// invalid packet
|
|
malformed_packet( server, "too short" );
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
server->n_servers++;
|
|
if ( server->server_name == NULL )
|
|
{
|
|
server->ping_total += time_delta( &packet_recv_time, &server->packet_time1 );
|
|
}
|
|
else
|
|
{
|
|
gettimeofday( &server->packet_time1, NULL);
|
|
}
|
|
|
|
// Query version ID
|
|
ptr += 4;
|
|
|
|
// Could check the header here should
|
|
// match the 4 byte id sent
|
|
memcpy( &pkt_id, ptr, 4 );
|
|
ptr += 4;
|
|
|
|
|
|
// Max plackets
|
|
pkt_max = ((unsigned char)*ptr);
|
|
ptr++;
|
|
|
|
// Packet ID
|
|
pkt_index = ((unsigned char)*ptr);
|
|
ptr++;
|
|
|
|
// Query Length
|
|
//len = (unsigned short)ptr[0] | ((unsigned short)ptr[1] << 8);
|
|
//len = swap_short_from_little( ptr );
|
|
debug( 1, "%04hx, %04hx", (unsigned short)ptr[0], ((unsigned short)ptr[1] << 8) );
|
|
//len = (unsigned short)(unsigned short)ptr[0] | ((unsigned short)ptr[1] << 8);
|
|
// TODO: fix this crap
|
|
memcpy( &len, ptr+1, 1 );
|
|
//memcpy( &len+1, ptr, 1 );
|
|
//memcpy( &len, ptr, 2 );
|
|
ptr += 2;
|
|
|
|
debug( 1, "pkt_index = %d, pkt_max = %d, len = %d", pkt_index, pkt_max, len );
|
|
if ( 0 != pkt_max )
|
|
{
|
|
// not a single packet response or callback
|
|
debug( 2, "pkt_max %d", pkt_max );
|
|
|
|
if ( 0 == pkt_index )
|
|
{
|
|
// to prevent reprocessing when we get the call back
|
|
// override the packet flag so it looks like a single
|
|
// packet response
|
|
rawpkt[8] = '\0';
|
|
}
|
|
|
|
// add the packet recalcing maxes
|
|
if ( ! add_packet( server, pkt_id, pkt_index, pkt_max, pktlen, rawpkt, 1 ) )
|
|
{
|
|
// fatal error e.g. out of memory
|
|
return MEM_ERROR;
|
|
}
|
|
|
|
// combine_packets will call us recursively
|
|
return combine_packets( server );
|
|
}
|
|
|
|
// if we get here we have what should be a full packet
|
|
return process_haze_packet( server );
|
|
}
|
|
|
|
query_status_t deal_with_haze_status( struct qserver *server, char *rawpkt, int pktlen )
|
|
{
|
|
char *pkt = rawpkt;
|
|
int len;
|
|
debug( 1, "status packet" );
|
|
|
|
|
|
// Server name
|
|
server->server_name = strdup( pkt );
|
|
pkt += strlen( pkt ) + 1;
|
|
|
|
// gametype
|
|
add_rule( server, "gametype", pkt, NO_FLAGS );
|
|
pkt += strlen( pkt ) + 1;
|
|
|
|
// map
|
|
len = strlen( pkt );
|
|
// remove .res from map names
|
|
if ( 0 == strncmp( pkt + len - 4, ".res", 4 ) )
|
|
{
|
|
*(pkt + len - 4) = '\0';
|
|
}
|
|
server->map_name = strdup( pkt );
|
|
pkt += len + 1;
|
|
|
|
// num players
|
|
server->num_players = atoi( pkt );
|
|
pkt += strlen( pkt ) + 1;
|
|
|
|
// max_players
|
|
server->max_players = atoi( pkt );
|
|
pkt += strlen( pkt ) + 1;
|
|
|
|
// hostport
|
|
change_server_port( server, atoi( pkt ), 0 );
|
|
pkt += strlen( pkt ) + 1;
|
|
|
|
return DONE_FORCE;
|
|
}
|
|
|
|
int process_haze_packet( struct qserver *server )
|
|
{
|
|
unsigned char state = 0;
|
|
unsigned char no_players = 0;
|
|
unsigned char total_players = 0;
|
|
unsigned char no_teams = 0;
|
|
unsigned char total_teams = 0;
|
|
int pkt_index = 0;
|
|
SavedData *fragment;
|
|
|
|
debug( 2, "processing packet..." );
|
|
|
|
while ( NULL != ( fragment = get_packet_fragment( pkt_index++ ) ) )
|
|
{
|
|
int pktlen = fragment->datalen;
|
|
char *ptr = fragment->data;
|
|
char *end = ptr + pktlen;
|
|
debug( 2, "processing fragment[%d]...", fragment->pkt_index );
|
|
|
|
// check we have a full header
|
|
if ( pktlen < 12 )
|
|
{
|
|
// invalid packet
|
|
malformed_packet( server, "too short" );
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
// skip over the header
|
|
//server->protocol_version = atoi( val+1 );
|
|
ptr += 12;
|
|
|
|
// 4 * null's signifies the end of a section
|
|
|
|
// Basic Info
|
|
while ( 0 == state && ptr < end )
|
|
{
|
|
// name value pairs null seperated
|
|
char *var, *val;
|
|
int var_len, val_len;
|
|
|
|
if ( ptr+4 <= end && 0x00 == ptr[0] && 0x00 == ptr[1] && 0x00 == ptr[2] && 0x00 == ptr[3] )
|
|
{
|
|
// end of rules
|
|
state++;
|
|
ptr += 4;
|
|
break;
|
|
}
|
|
|
|
var = ptr;
|
|
var_len = strlen( var );
|
|
ptr += var_len + 1;
|
|
|
|
if ( ptr + 1 > end )
|
|
{
|
|
malformed_packet( server, "no basic value" );
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
val = ptr;
|
|
val_len = strlen( val );
|
|
ptr += val_len + 1;
|
|
debug( 2, "var:%s (%d)=%s (%d)\n", var, var_len, val, val_len );
|
|
|
|
// Lets see what we've got
|
|
if ( 0 == strcmp( var, "serverName" ) )
|
|
{
|
|
server->server_name = strdup( val );
|
|
}
|
|
else if( 0 == strcmp( var, "map" ) )
|
|
{
|
|
// remove .res from map names
|
|
if ( 0 == strncmp( val + val_len - 4, ".res", 4 ) )
|
|
{
|
|
*(val + val_len - 4) = '\0';
|
|
}
|
|
server->map_name = strdup( val );
|
|
}
|
|
else if( 0 == strcmp( var, "maxPlayers" ) )
|
|
{
|
|
server->max_players = atoi( val );
|
|
|
|
}
|
|
else if( 0 == strcmp( var, "currentPlayers" ) )
|
|
{
|
|
server->num_players = no_players = atoi( val );
|
|
}
|
|
else
|
|
{
|
|
add_rule( server, var, val, NO_FLAGS );
|
|
}
|
|
}
|
|
|
|
// rules
|
|
while ( 1 == state && ptr < end )
|
|
{
|
|
// name value pairs null seperated
|
|
char *var, *val;
|
|
int var_len, val_len;
|
|
|
|
if ( ptr+4 <= end && 0x00 == ptr[0] && 0x00 == ptr[1] && 0x00 == ptr[2] && 0x00 == ptr[3] )
|
|
{
|
|
// end of basic
|
|
state++;
|
|
ptr += 4;
|
|
break;
|
|
}
|
|
var = ptr;
|
|
var_len = strlen( var );
|
|
ptr += var_len + 1;
|
|
|
|
if ( ptr + 1 > end )
|
|
{
|
|
malformed_packet( server, "no basic value" );
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
val = ptr;
|
|
val_len = strlen( val );
|
|
ptr += val_len + 1;
|
|
debug( 2, "var:%s (%d)=%s (%d)\n", var, var_len, val, val_len );
|
|
|
|
// add the rule
|
|
add_rule( server, var, val, NO_FLAGS );
|
|
}
|
|
|
|
// players
|
|
while ( 2 == state && ptr < end )
|
|
{
|
|
// first we have the header
|
|
char *header = ptr;
|
|
int head_len = strlen( header );
|
|
ptr += head_len + 1;
|
|
|
|
if ( ptr+2 <= end && 0x00 == ptr[0] && 0x00 == ptr[1] )
|
|
{
|
|
// end of player headers
|
|
state++;
|
|
ptr += 2;
|
|
break;
|
|
}
|
|
|
|
if ( 0 == head_len )
|
|
{
|
|
// no more info
|
|
debug( 3, "All done" );
|
|
return DONE_FORCE;
|
|
}
|
|
|
|
debug( 2, "player header '%s'", header );
|
|
|
|
if ( ptr > end )
|
|
{
|
|
malformed_packet( server, "no details for header '%s'", header );
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
}
|
|
|
|
while ( 3 == state && ptr < end )
|
|
{
|
|
char *header = ptr;
|
|
int head_len = strlen( header );
|
|
int header_type;
|
|
// the next byte is the starting number
|
|
total_players = *ptr++;
|
|
|
|
if ( 0 == strcmp( header, "player_" ) || 0 == strcmp( header, "name_" ) )
|
|
{
|
|
header_type = PLAYER_NAME_HEADER;
|
|
}
|
|
else if ( 0 == strcmp( header, "score_" ) )
|
|
{
|
|
header_type = PLAYER_SCORE_HEADER;
|
|
}
|
|
else if ( 0 == strcmp( header, "deaths_" ) )
|
|
{
|
|
header_type = PLAYER_DEATHS_HEADER;
|
|
}
|
|
else if ( 0 == strcmp( header, "ping_" ) )
|
|
{
|
|
header_type = PLAYER_PING_HEADER;
|
|
}
|
|
else if ( 0 == strcmp( header, "kills_" ) )
|
|
{
|
|
header_type = PLAYER_KILLS_HEADER;
|
|
}
|
|
else if ( 0 == strcmp( header, "team_" ) )
|
|
{
|
|
header_type = PLAYER_TEAM_HEADER;
|
|
}
|
|
else
|
|
{
|
|
header_type = PLAYER_OTHER_HEADER;
|
|
}
|
|
|
|
while( ptr < end )
|
|
{
|
|
// now each player details
|
|
// add the player
|
|
struct player *player;
|
|
char *val;
|
|
int val_len;
|
|
|
|
// check for end of this headers player info
|
|
if ( 0x00 == *ptr )
|
|
{
|
|
debug( 3, "end of '%s' detail", header );
|
|
ptr++;
|
|
// Note: can't check ( total_players != no_players ) here as we may have more packets
|
|
if ( ptr < end && 0x00 == *ptr )
|
|
{
|
|
debug( 3, "end of players" );
|
|
// end of all player headers / detail
|
|
state = 2;
|
|
ptr++;
|
|
}
|
|
break;
|
|
}
|
|
|
|
player = get_player_by_number( server, total_players );
|
|
if ( NULL == player )
|
|
{
|
|
player = add_player( server, total_players );
|
|
}
|
|
|
|
if ( ptr >= end )
|
|
{
|
|
malformed_packet( server, "short player detail" );
|
|
return PKT_ERROR;
|
|
}
|
|
val = ptr;
|
|
val_len = strlen( val );
|
|
ptr += val_len + 1;
|
|
|
|
debug( 2, "Player[%d][%s]=%s\n", total_players, header, val );
|
|
|
|
// lets see what we got
|
|
switch( header_type )
|
|
{
|
|
case PLAYER_NAME_HEADER:
|
|
player->name = strdup( val );
|
|
break;
|
|
|
|
case PLAYER_SCORE_HEADER:
|
|
player->score = atoi( val );
|
|
break;
|
|
|
|
case PLAYER_DEATHS_HEADER:
|
|
player->deaths = atoi( val );
|
|
break;
|
|
|
|
case PLAYER_PING_HEADER:
|
|
player->ping = atoi( val );
|
|
break;
|
|
|
|
case PLAYER_KILLS_HEADER:
|
|
player->frags = atoi( val );
|
|
break;
|
|
|
|
case PLAYER_TEAM_HEADER:
|
|
player->team = atoi( val );
|
|
break;
|
|
|
|
case PLAYER_OTHER_HEADER:
|
|
default:
|
|
if ( '_' == header[head_len-1] )
|
|
{
|
|
header[head_len-1] = '\0';
|
|
player_add_info( player, header, val, NO_FLAGS );
|
|
header[head_len-1] = '_';
|
|
}
|
|
else
|
|
{
|
|
player_add_info( player, header, val, NO_FLAGS );
|
|
}
|
|
break;
|
|
}
|
|
|
|
total_players++;
|
|
|
|
if ( total_players > no_players )
|
|
{
|
|
malformed_packet( server, "to many players %d > %d", total_players, no_players );
|
|
return PKT_ERROR;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( 3 == state )
|
|
{
|
|
no_teams = (unsigned char)*ptr;
|
|
ptr++;
|
|
|
|
debug( 2, "No teams:%d\n", no_teams );
|
|
state = 3;
|
|
}
|
|
|
|
while ( 4 == state && ptr < end )
|
|
{
|
|
// first we have the header
|
|
char *header = ptr;
|
|
int head_len = strlen( header );
|
|
int header_type;
|
|
ptr += head_len + 1;
|
|
|
|
if ( 0 == head_len )
|
|
{
|
|
// no more info
|
|
debug( 3, "All done" );
|
|
return DONE_FORCE;
|
|
}
|
|
|
|
debug( 2, "team header '%s'", header );
|
|
if ( 0 == strcmp( header, "team_t" ) )
|
|
{
|
|
header_type = TEAM_NAME_HEADER;
|
|
}
|
|
else
|
|
{
|
|
header_type = TEAM_OTHER_HEADER;
|
|
}
|
|
|
|
// the next byte is the starting number
|
|
total_teams = *ptr++;
|
|
|
|
while( ptr < end )
|
|
{
|
|
// now each teams details
|
|
char *val;
|
|
int val_len;
|
|
char rule[512];
|
|
|
|
if ( ptr >= end )
|
|
{
|
|
malformed_packet( server, "short team detail" );
|
|
return PKT_ERROR;
|
|
}
|
|
val = ptr;
|
|
val_len = strlen( val );
|
|
ptr += val_len + 1;
|
|
|
|
debug( 2, "Team[%d][%s]=%s\n", total_teams, header, val );
|
|
|
|
// lets see what we got
|
|
switch ( header_type )
|
|
{
|
|
case TEAM_NAME_HEADER:
|
|
// BF being stupid again teams 1 based instead of 0
|
|
players_set_teamname( server, total_teams + 1, val );
|
|
// N.B. yes no break
|
|
|
|
case TEAM_OTHER_HEADER:
|
|
default:
|
|
// add as a server rule
|
|
sprintf( rule, "%s%d", header, total_teams );
|
|
add_rule( server, rule, val, NO_FLAGS );
|
|
break;
|
|
}
|
|
|
|
total_teams++;
|
|
if ( 0x00 == *ptr )
|
|
{
|
|
// end of this headers teams
|
|
ptr++;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return DONE_FORCE;
|
|
}
|
|
|
|
query_status_t send_haze_request_packet( struct qserver *server )
|
|
{
|
|
char *packet;
|
|
char query_buf[128];
|
|
size_t len;
|
|
unsigned char required = HAZE_BASIC_INFO;
|
|
|
|
if ( get_server_rules )
|
|
{
|
|
required |= HAZE_GAME_RULES;
|
|
server->flags |= TF_PLAYER_QUERY;
|
|
}
|
|
|
|
if ( get_player_info )
|
|
{
|
|
required |= HAZE_PLAYER_INFO;
|
|
required |= HAZE_TEAM_INFO;
|
|
server->flags |= TF_RULES_QUERY;
|
|
}
|
|
|
|
server->flags |= TF_STATUS_QUERY;
|
|
|
|
if ( server->challenge )
|
|
{
|
|
// we've recieved a challenge response, send the query + challenge id
|
|
len = sprintf(
|
|
query_buf,
|
|
"frdquery%c%c%c%c%c",
|
|
(unsigned char)(server->challenge >> 24),
|
|
(unsigned char)(server->challenge >> 16),
|
|
(unsigned char)(server->challenge >> 8),
|
|
(unsigned char)(server->challenge >> 0),
|
|
required
|
|
);
|
|
packet = query_buf;
|
|
}
|
|
else
|
|
{
|
|
// Either basic v3 protocol or challenge request
|
|
packet = haze_challenge;
|
|
len = sizeof( haze_challenge );
|
|
}
|
|
|
|
return send_packet( server, packet, len );
|
|
}
|
|
|