mirror of
https://github.com/gamedig/node-gamedig.git
synced 2024-11-18 17:50:37 +01:00
404 lines
9.8 KiB
Text
404 lines
9.8 KiB
Text
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
|
|
*/
|
|
|
|
|
|
char ottd_serverinfo[] = {
|
|
0x03, 0x00, // packet length
|
|
0x00, // packet type
|
|
};
|
|
|
|
char ottd_serverdetails[] = {
|
|
0x03, 0x00, // packet length
|
|
0x02, // packet type
|
|
};
|
|
|
|
|
|
{
|
|
/* openTTD */
|
|
OTTD_SERVER, /* id */
|
|
"OTTDS", /* type_prefix */
|
|
"ottds", /* type_string */
|
|
"-ottds", /* type_option */
|
|
"OpenTTD", /* game_name */
|
|
0, /* master */
|
|
3979, /* default_port */
|
|
0, /* port_offset */
|
|
0, /* flags */
|
|
"", /* game_rule */
|
|
"OPENTTD", /* template_var */
|
|
(char*) &ottd_serverinfo, /* status_packet */
|
|
sizeof( ottd_serverinfo), /* status_len */
|
|
NULL, /* player_packet */
|
|
0, /* player_len */
|
|
(char*) &ottd_serverdetails,/* rule_packet */
|
|
sizeof( ottd_serverdetails), /* rule_len */
|
|
NULL, /* master_packet */
|
|
0, /* master_len */
|
|
NULL, /* master_protocol */
|
|
NULL, /* master_query */
|
|
display_q2_player_info, /* display_player_func */
|
|
display_server_rules, /* display_rule_func */
|
|
raw_display_q2_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_ottd_request_packet, /* status_query_func */
|
|
NULL, /* rule_query_func */
|
|
NULL, /* player_query_func */
|
|
deal_with_ottd_packet, /* packet_func */
|
|
},
|
|
|
|
|
|
|
|
/*
|
|
* qstat 2.11
|
|
*
|
|
* opentTTD protocol
|
|
* Copyright 2007 Ludwig Nussel
|
|
*
|
|
* Licensed under the Artistic License, see LICENSE.txt for license terms
|
|
*/
|
|
|
|
#include <sys/types.h>
|
|
#ifndef _WIN32
|
|
#include <sys/socket.h>
|
|
#endif
|
|
#include <stdio.h>
|
|
#include <stdlib.h>
|
|
|
|
#include "qstat.h"
|
|
#include "qserver.h"
|
|
#include "debug.h"
|
|
|
|
enum { MAX_VEHICLE_TYPES = 5, MAX_STATION_TYPES = 5 };
|
|
|
|
static const char* vehicle_types[] = {
|
|
"num_trains",
|
|
"num_trucks",
|
|
"num_busses",
|
|
"num_aircrafts",
|
|
"num_ships",
|
|
};
|
|
|
|
static const char* station_types[] = {
|
|
"num_stations",
|
|
"num_truckbays",
|
|
"num_busstations",
|
|
"num_airports",
|
|
"num_docks",
|
|
};
|
|
|
|
query_status_t deal_with_ottdmaster_packet(struct qserver *server, char *rawpkt, int pktlen)
|
|
{
|
|
unsigned num;
|
|
server->ping_total += time_delta(&packet_recv_time, &server->packet_time1);
|
|
server->server_name = MASTER;
|
|
|
|
if(swap_short_from_little(rawpkt) != pktlen)
|
|
{
|
|
malformed_packet( server, "invalid packet length" );
|
|
return PKT_ERROR;
|
|
}
|
|
if(rawpkt[2] != 7)
|
|
{
|
|
malformed_packet( server, "invalid packet type" );
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
if(rawpkt[3] != 1)
|
|
{
|
|
malformed_packet( server, "invalid packet version" );
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
num = swap_short_from_little(&rawpkt[4]);
|
|
rawpkt += 6;
|
|
pktlen -= 6;
|
|
if( num && num*6 <= pktlen )
|
|
{
|
|
unsigned i;
|
|
server->master_pkt = (char*)realloc(server->master_pkt, server->master_pkt_len + pktlen );
|
|
memset(server->master_pkt + server->master_pkt_len, 0, pktlen );
|
|
server->master_pkt_len += pktlen;
|
|
for( i = 0; i < num * 6; i += 6 )
|
|
{
|
|
memcpy(&server->master_pkt[i], &rawpkt[i], 4);
|
|
server->master_pkt[i+4] = rawpkt[i+5];
|
|
server->master_pkt[i+5] = rawpkt[i+4];
|
|
}
|
|
server->n_servers += num;
|
|
}
|
|
else
|
|
{
|
|
malformed_packet( server, "invalid packet" );
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
bind_sockets();
|
|
|
|
return DONE_AUTO;
|
|
}
|
|
|
|
#define xstr(s) str(s)
|
|
#define str(s) #s
|
|
|
|
#define GET_STRING do { \
|
|
str = (char*)ptr; \
|
|
ptr = memchr(ptr, '\0', end-ptr); \
|
|
if ( !ptr ) \
|
|
{ \
|
|
malformed_packet( server, "%s:%s invalid packet", __FILE__, xstr(__LINE__) ); \
|
|
return PKT_ERROR; \
|
|
} \
|
|
++ptr; \
|
|
} while(0)
|
|
|
|
#define FAIL_IF(cond, msg) \
|
|
if((cond)) { \
|
|
malformed_packet( server, "%s:%s %s", __FILE__, xstr(__LINE__), msg ); \
|
|
return PKT_ERROR; \
|
|
}
|
|
|
|
#define INVALID_IF(cond) \
|
|
FAIL_IF(cond, "invalid packet")
|
|
|
|
query_status_t deal_with_ottd_packet(struct qserver *server, char *rawpkt, int pktlen)
|
|
{
|
|
unsigned char *ptr = (unsigned char*)rawpkt;
|
|
unsigned char *end = (unsigned char*)(rawpkt + pktlen);
|
|
unsigned char type;
|
|
char* str;
|
|
char buf[32];
|
|
unsigned ver;
|
|
|
|
server->n_servers++;
|
|
if ( server->server_name == NULL)
|
|
{
|
|
server->ping_total += time_delta( &packet_recv_time, &server->packet_time1);
|
|
server->n_requests++;
|
|
}
|
|
else
|
|
{
|
|
gettimeofday( &server->packet_time1, NULL);
|
|
}
|
|
|
|
FAIL_IF(pktlen < 4 || swap_short_from_little(rawpkt) > pktlen, "invalid packet");
|
|
|
|
type = ptr[2];
|
|
ver = ptr[3];
|
|
ptr += 4;
|
|
|
|
debug(3, "len %hu type %hhu ver %hhu", swap_short_from_little(rawpkt), type, ver);
|
|
|
|
FAIL_IF(ver != 4 && ver != 5, "only version 4 and 5 servers are supported");
|
|
|
|
if(type == 1) // info packet
|
|
{
|
|
unsigned numgrf = *ptr;
|
|
FAIL_IF(ptr + numgrf * 20 + 1 > end, "invalid newgrf number");
|
|
ptr += numgrf * 20 + 1;
|
|
|
|
snprintf(buf, sizeof(buf), "%u", swap_long_from_little(ptr));
|
|
add_rule(server, "date_days", buf, NO_FLAGS);
|
|
ptr += 4;
|
|
|
|
snprintf(buf, sizeof(buf), "%u", swap_long_from_little(ptr));
|
|
add_rule(server, "startdate_days", buf, NO_FLAGS);
|
|
ptr += 4;
|
|
|
|
FAIL_IF(ptr + 3 > end, "invalid packet");
|
|
|
|
snprintf(buf, sizeof(buf), "%hhu", ptr[0]);
|
|
add_rule(server, "maxcompanies", buf, NO_FLAGS);
|
|
snprintf(buf, sizeof(buf), "%hhu", ptr[1]);
|
|
add_rule(server, "numcompanies", buf, NO_FLAGS);
|
|
server->max_spectators = ptr[2];
|
|
ptr += 3;
|
|
|
|
GET_STRING;
|
|
server->server_name = strdup(str);
|
|
|
|
GET_STRING;
|
|
add_rule(server, "version", str, NO_FLAGS);
|
|
|
|
FAIL_IF(ptr + 7 > end, "invalid packet");
|
|
|
|
{
|
|
static const char* langs[] = {
|
|
"any",
|
|
"English",
|
|
"German",
|
|
"French"
|
|
};
|
|
unsigned i = *ptr++;
|
|
if(i > 3) i = 0;
|
|
add_rule(server, "language", (char*)langs[i], NO_FLAGS);
|
|
}
|
|
|
|
add_rule(server, "password", *ptr++ ? "1" : "0", NO_FLAGS);
|
|
|
|
server->max_players = *ptr++;
|
|
server->num_players = *ptr++;
|
|
server->num_spectators = *ptr++;
|
|
|
|
GET_STRING;
|
|
|
|
server->map_name = strdup(str);
|
|
|
|
snprintf(buf, sizeof(buf), "%hu", swap_short_from_little(ptr));
|
|
add_rule(server, "map_width", buf, NO_FLAGS);
|
|
snprintf(buf, sizeof(buf), "%hu", swap_short_from_little(ptr));
|
|
add_rule(server, "map_height", buf, NO_FLAGS);
|
|
|
|
{
|
|
static const char* sets[] = {
|
|
"temperate",
|
|
"arctic",
|
|
"desert",
|
|
"toyland"
|
|
};
|
|
unsigned i = *ptr++;
|
|
if(i > 3) i = 0;
|
|
add_rule(server, "map_set", (char*)sets[i], NO_FLAGS);
|
|
}
|
|
|
|
add_rule(server, "dedicated", *ptr++ ? "1" : "0", NO_FLAGS);
|
|
}
|
|
else if(type == 3) // player packet
|
|
{
|
|
unsigned i, j;
|
|
INVALID_IF(ptr + 2 > end);
|
|
|
|
server->num_players = *ptr++;
|
|
|
|
for(i = 0; i < server->num_players; ++i)
|
|
{
|
|
unsigned long long lli;
|
|
struct player* player;
|
|
unsigned char nr;
|
|
|
|
nr = *ptr++;
|
|
|
|
debug(3, "player number %d", nr);
|
|
player = add_player(server, i);
|
|
FAIL_IF(!player, "can't allocate player");
|
|
|
|
GET_STRING;
|
|
player->name = strdup(str);
|
|
debug(3, "name %s", str);
|
|
player->frags = 0;
|
|
|
|
INVALID_IF(ptr + 4 + 3*8 + 2 + 1 + 2*MAX_VEHICLE_TYPES + 2*MAX_STATION_TYPES > end);
|
|
|
|
snprintf(buf, sizeof(buf), "%u", swap_long_from_little(ptr));
|
|
player_add_info(player, "startdate", buf, 0);
|
|
ptr += 4;
|
|
|
|
lli = swap_long_from_little(ptr+4);
|
|
lli <<= 32;
|
|
lli += swap_long_from_little(ptr);
|
|
snprintf(buf, sizeof(buf), "%lld", lli);
|
|
player_add_info(player, "value", buf, 0);
|
|
ptr += 8;
|
|
|
|
lli = swap_long_from_little(ptr+4);
|
|
lli <<= 32;
|
|
lli = swap_long_from_little(ptr);
|
|
snprintf(buf, sizeof(buf), "%lld", lli);
|
|
player_add_info(player, "money", buf, 0);
|
|
ptr += 8;
|
|
|
|
lli = swap_long_from_little(ptr+4);
|
|
lli <<= 32;
|
|
lli += swap_long_from_little(ptr);
|
|
snprintf(buf, sizeof(buf), "%lld", lli);
|
|
player_add_info(player, "income", buf, 0);
|
|
ptr += 8;
|
|
|
|
snprintf(buf, sizeof(buf), "%hu", swap_short_from_little(ptr));
|
|
player_add_info(player, "performance", buf, 0);
|
|
ptr += 2;
|
|
|
|
player_add_info(player, "password", *ptr?"1":"0", 0);
|
|
++ptr;
|
|
|
|
for (j = 0; j < MAX_VEHICLE_TYPES; ++j)
|
|
{
|
|
snprintf(buf, sizeof(buf), "%hu", swap_short_from_little(ptr));
|
|
player_add_info(player, (char*)vehicle_types[j], buf, 0);
|
|
ptr += 2;
|
|
}
|
|
for (j = 0; j < MAX_STATION_TYPES; ++j)
|
|
{
|
|
snprintf(buf, sizeof(buf), "%hu", swap_short_from_little(ptr));
|
|
player_add_info(player, (char*)station_types[j], buf, 0);
|
|
ptr += 2;
|
|
}
|
|
|
|
if (ver != 5)
|
|
{
|
|
// connections
|
|
while(ptr + 1 < end && *ptr)
|
|
{
|
|
++ptr;
|
|
GET_STRING; // client name
|
|
debug(3, "%s played by %s", str, player->name);
|
|
GET_STRING; // id
|
|
INVALID_IF(ptr + 4 > end);
|
|
ptr += 4;
|
|
}
|
|
|
|
++ptr; // record terminated by zero byte
|
|
}
|
|
}
|
|
|
|
// spectators
|
|
while(ptr + 1 < end && *ptr)
|
|
{
|
|
++ptr;
|
|
GET_STRING; // client name
|
|
debug(3, "spectator %s", str);
|
|
GET_STRING; // id
|
|
INVALID_IF(ptr + 4 > end);
|
|
ptr += 4;
|
|
}
|
|
++ptr; // record terminated by zero byte
|
|
|
|
server->next_rule = NO_SERVER_RULES; // we're done
|
|
server->next_player_info = server->num_players; // we're done
|
|
}
|
|
else
|
|
{
|
|
malformed_packet( server, "invalid type" );
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
server->retry1 = n_retries; // we're done with this packet, reset retry counter
|
|
|
|
return DONE_AUTO;
|
|
}
|
|
|
|
query_status_t send_ottdmaster_request_packet(struct qserver *server)
|
|
{
|
|
return qserver_send_initial(server, server->type->master_packet, server->type->master_len);
|
|
}
|
|
|
|
query_status_t send_ottd_request_packet(struct qserver *server)
|
|
{
|
|
qserver_send_initial(server, server->type->status_packet, server->type->status_len);
|
|
|
|
if(get_server_rules || get_player_info)
|
|
{
|
|
server->next_rule = ""; // trigger calling send_a2s_rule_request_packet
|
|
}
|
|
|
|
return INPROGRESS;
|
|
}
|