695 lines
15 KiB
Plaintext
695 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
|
|
*/
|
|
|
|
|
|
|
|
unsigned char ghostrecon_serverquery[] = {
|
|
0xc0,0xde,0xf1,0x11, /* const ? header */
|
|
0x42, /* start flag */
|
|
0x03,0x00, /* data len */
|
|
0xe9,0x03,0x00 /* server request ?? */
|
|
};
|
|
|
|
unsigned char ghostrecon_playerquery[] = {
|
|
0xc0,0xde,0xf1,0x11, /* const ? header */
|
|
0x42, /* start flag */
|
|
0x06,0x00, /* data len */
|
|
0xf5,0x03,0x00,0x78,0x30,0x63 /* player request ?? may be flag 0xf5; len 0x03,0x00; data 0x78, 0x30, 0x63 */
|
|
};
|
|
|
|
|
|
{
|
|
/* GHOSTRECON PROTOCOL */
|
|
GHOSTRECON_SERVER, /* id */
|
|
"GRS", /* type_prefix */
|
|
"grs", /* type_string */
|
|
"-grs", /* type_option */
|
|
"Ghost Recon", /* game_name */
|
|
0, /* master */
|
|
GHOSTRECON_PLAYER_DEFAULT_PORT, /* default_port */
|
|
2, /* port_offset */
|
|
TF_QUERY_ARG, /* flags */
|
|
"gametype", /* game_rule */
|
|
"GHOSTRECON", /* template_var */
|
|
(char*) &ghostrecon_playerquery, /* status_packet */
|
|
sizeof( ghostrecon_playerquery), /* status_len */
|
|
NULL, /* player_packet */
|
|
0, /* player_len */
|
|
NULL, /* rule_packet */
|
|
0, /* rule_len */
|
|
NULL, /* master_packet */
|
|
0, /* master_len */
|
|
NULL, /* master_protocol */
|
|
NULL, /* master_query */
|
|
display_ghostrecon_player_info, /* display_player_func */
|
|
display_server_rules, /* display_rule_func */
|
|
raw_display_ghostrecon_player_info, /* display_raw_player_func */
|
|
raw_display_server_rules, /* display_raw_rule_func */
|
|
xml_display_ghostrecon_player_info, /* display_xml_player_func */
|
|
xml_display_server_rules, /* display_xml_rule_func */
|
|
send_qserver_request_packet, /* status_query_func */
|
|
NULL, /* rule_query_func */
|
|
NULL, /* player_query_func */
|
|
deal_with_ghostrecon_packet, /* packet_func */
|
|
},
|
|
|
|
|
|
|
|
|
|
static const char GrPacketHead[] =
|
|
{
|
|
'\xc0', '\xde', '\xf1', '\x11'
|
|
};
|
|
static const char PacketStart = '\x42';
|
|
static char Dat2Reply1_2_10[] =
|
|
{
|
|
'\xf4', '\x03', '\x14', '\x02', '\x0a', '\x41', '\x02', '\x0a', '\x41', '\x00', '\x00', '\x78', '\x30', '\x63'
|
|
};
|
|
static char Dat2Reply1_3[] =
|
|
{
|
|
'\xf4', '\x03', '\x14', '\x03', '\x05', '\x41', '\x03', '\x05', '\x41', '\x00', '\x00', '\x78', '\x30', '\x63'
|
|
};
|
|
static char Dat2Reply1_4[] =
|
|
{
|
|
'\xf4', '\x03', '\x14', '\x04', '\x00', '\x41', '\x04', '\x00', '\x41', '\x00', '\x00', '\x78', '\x30', '\x63'
|
|
};
|
|
//static char HDat2[]={'\xea','\x03','\x02','\x00','\x14'};
|
|
|
|
#define SHORT_GR_LEN 75
|
|
#define LONG_GR_LEN 500
|
|
#define UNKNOWN_VERSION 0
|
|
#define VERSION_1_2_10 1
|
|
#define VERSION_1_3 2
|
|
#define VERSION_1_4 3
|
|
|
|
query_status_t deal_with_ghostrecon_packet(struct qserver *server, char *pkt, int pktlen)
|
|
{
|
|
char str[256], *start, *end, StartFlag, *lpszIgnoreServerPlayer;
|
|
char *lpszMission;
|
|
unsigned int iIgnoreServerPlayer, iDedicatedServer, iUseStartTimer;
|
|
unsigned short GrPayloadLen;
|
|
int i;
|
|
struct player *player;
|
|
int iLen, iTemp;
|
|
short sLen;
|
|
int iSecsPlayed;
|
|
long iSpawnType;
|
|
int ServerVersion = UNKNOWN_VERSION;
|
|
float flStartTimerSetPoint;
|
|
|
|
debug( 2, "deal_with_ghostrecon_packet %p, %d", server, pktlen );
|
|
|
|
start = pkt;
|
|
end = &pkt[pktlen];
|
|
pkt[pktlen] = '\0';
|
|
|
|
/*
|
|
This function walks a packet that is recieved from a ghost recon server - default from port 2348. It does quite a few
|
|
sanity checks along the way as the structure is not documented. The packet is mostly binary in nature with many string
|
|
fields being variable in length, ie the length is listed foloowed by that many bytes. There are two structure arrays
|
|
that have an array size followed by structure size * number of elements (player name and player data). This routine
|
|
walks this packet and increments a pointer "pkt" to extract the info.
|
|
*/
|
|
|
|
|
|
if (server->server_name == NULL)
|
|
{
|
|
server->ping_total += time_delta(&packet_recv_time, &server->packet_time1);
|
|
}
|
|
|
|
/* sanity check against packet */
|
|
if (memcmp(pkt, GrPacketHead, sizeof(GrPacketHead)) != 0)
|
|
{
|
|
server->server_name = strdup("Unknown Packet Header");
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
pkt += sizeof(GrPacketHead);
|
|
StartFlag = pkt[0];
|
|
pkt += 1;
|
|
if (StartFlag != 0x42)
|
|
{
|
|
server->server_name = strdup("Unknown Start Flag");
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
/* compare packet length recieved to included size - header info */
|
|
sLen = swap_short_from_little(pkt);
|
|
pkt += 2;
|
|
GrPayloadLen = pktlen - sizeof(GrPacketHead) - 3;
|
|
// 3 = size slen + size start flag
|
|
|
|
if (sLen != GrPayloadLen)
|
|
{
|
|
server->server_name = strdup("Packet Size Mismatch");
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
/*
|
|
Will likely need to verify and add to this "if" construct with every patch / add-on.
|
|
*/
|
|
if (memcmp(pkt, Dat2Reply1_2_10, sizeof(Dat2Reply1_2_10)) == 0)
|
|
{
|
|
ServerVersion = VERSION_1_2_10;
|
|
}
|
|
else if (memcmp(pkt, Dat2Reply1_3, sizeof(Dat2Reply1_3)) == 0)
|
|
{
|
|
ServerVersion = VERSION_1_3;
|
|
}
|
|
else if (memcmp(pkt, Dat2Reply1_4, sizeof(Dat2Reply1_4)) == 0)
|
|
{
|
|
ServerVersion = VERSION_1_4;
|
|
}
|
|
|
|
if (ServerVersion == UNKNOWN_VERSION)
|
|
{
|
|
server->server_name = strdup("Unknown GR Version");
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
switch (ServerVersion)
|
|
{
|
|
case VERSION_1_2_10:
|
|
strcpy(str, "1.2.10");
|
|
pkt += sizeof(Dat2Reply1_2_10);
|
|
break;
|
|
|
|
case VERSION_1_3:
|
|
strcpy(str, "1.3");
|
|
pkt += sizeof(Dat2Reply1_3);
|
|
break;
|
|
|
|
case VERSION_1_4:
|
|
strcpy(str, "1.4");
|
|
pkt += sizeof(Dat2Reply1_4);
|
|
break;
|
|
|
|
}
|
|
add_rule(server, "patch", str, NO_FLAGS);
|
|
|
|
/* have player packet */
|
|
|
|
// Ghost recon has one of the player slots filled up with the server program itself. By default we will
|
|
// drop the first player listed. This causes a bit of a mess here and below but makes for the best display
|
|
// a user can specify -grs,ignoreserverplayer=no to override this behaviour.
|
|
|
|
lpszIgnoreServerPlayer = get_param_value(server, "ignoreserverplayer", "yes");
|
|
for (i = 0; i < 4; i++)
|
|
{
|
|
str[i] = tolower(lpszIgnoreServerPlayer[i]);
|
|
}
|
|
if (strcmp(str, "yes") == 0)
|
|
{
|
|
iIgnoreServerPlayer = 1;
|
|
}
|
|
else
|
|
{
|
|
iIgnoreServerPlayer = 0;
|
|
}
|
|
|
|
pkt += 4; /* unknown */
|
|
|
|
|
|
// this is the first of many variable strings. get the length,
|
|
// increment pointer over length, check for sanity,
|
|
// get the string, increment the pointer over string (using length)
|
|
|
|
iLen = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
if ((iLen < 1) || (iLen > SHORT_GR_LEN))
|
|
{
|
|
server->server_name = strdup("Server Name too Long");
|
|
return PKT_ERROR;
|
|
}
|
|
server->server_name = strndup(pkt, iLen);
|
|
pkt += iLen;
|
|
|
|
iLen = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
if ((iLen < 1) || (iLen > SHORT_GR_LEN))
|
|
{
|
|
add_rule(server, "error", "Map Name too Long", NO_FLAGS);
|
|
return PKT_ERROR;
|
|
}
|
|
server->map_name = strndup(pkt, iLen);
|
|
pkt += iLen;
|
|
|
|
iLen = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
if ((iLen < 1) || (iLen > SHORT_GR_LEN))
|
|
{
|
|
add_rule(server, "error", "Mission Name too Long", NO_FLAGS);
|
|
return PKT_ERROR;
|
|
}
|
|
/* mission does not make sense unless a coop game type. Since
|
|
we dont know that now, we will save the mission and set
|
|
the rule and free memory below when we know game type */
|
|
lpszMission = strndup(pkt, iLen);
|
|
pkt += iLen;
|
|
|
|
|
|
iLen = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
if ((iLen < 1) || (iLen > SHORT_GR_LEN))
|
|
{
|
|
add_rule(server, "error", "Mission Type too Long", NO_FLAGS);
|
|
return PKT_ERROR;
|
|
}
|
|
add_nrule(server, "missiontype", pkt, iLen);
|
|
pkt += iLen;
|
|
|
|
if (pkt[1])
|
|
{
|
|
add_rule(server, "password", "Yes", NO_FLAGS);
|
|
}
|
|
else
|
|
{
|
|
add_rule(server, "password", "No", NO_FLAGS);
|
|
}
|
|
pkt += 2;
|
|
|
|
server->max_players = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
if (server->max_players > 36)
|
|
{
|
|
add_rule(server, "error", "Max players more then 36", NO_FLAGS);
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
server->num_players = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
if (server->num_players > server->max_players)
|
|
{
|
|
add_rule(server, "error", "More then MAX Players", NO_FLAGS);
|
|
return PKT_ERROR;
|
|
}
|
|
|
|
if (iIgnoreServerPlayer)
|
|
// skip past first player
|
|
{
|
|
server->num_players--;
|
|
server->max_players--;
|
|
iLen = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
pkt += iLen;
|
|
}
|
|
|
|
for (i = 0; i < server->num_players; i++)
|
|
// read each player name
|
|
{
|
|
iLen = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
|
|
player = (struct player*)calloc(1, sizeof(struct player));
|
|
|
|
if ((iLen < 1) || (iLen > SHORT_GR_LEN))
|
|
{
|
|
add_rule(server, "error", "Player Name too Long", NO_FLAGS);
|
|
return PKT_ERROR;
|
|
}
|
|
player->name = strndup(pkt, iLen);
|
|
pkt += iLen; /* player name */
|
|
player->team = i; // tag so we can find this record when we have player dat.
|
|
player->team_name = "Unassigned";
|
|
player->flags |= PLAYER_FLAG_DO_NOT_FREE_TEAM;
|
|
player->frags = 0;
|
|
|
|
player->next = server->players;
|
|
server->players = player;
|
|
}
|
|
|
|
pkt += 17;
|
|
|
|
iLen = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
if ((iLen < 1) || (iLen > SHORT_GR_LEN))
|
|
{
|
|
add_rule(server, "error", "Version too Long", NO_FLAGS);
|
|
return PKT_ERROR;
|
|
}
|
|
strncpy(str, pkt, iLen);
|
|
add_rule(server, "version", str, NO_FLAGS);
|
|
pkt += iLen; /* version */
|
|
|
|
iLen = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
if ((iLen < 1) || (iLen > LONG_GR_LEN))
|
|
{
|
|
add_rule(server, "error", "Mods too Long", NO_FLAGS);
|
|
return PKT_ERROR;
|
|
}
|
|
server->game = strndup(pkt, iLen);
|
|
|
|
for (i = 0; i < (int)strlen(server->game) - 5; i++)
|
|
// clean the "/mods/" part from every entry
|
|
{
|
|
if (memcmp(&server->game[i], "\\mods\\", 6) == 0)
|
|
{
|
|
server->game[i] = ' ';
|
|
strcpy(&server->game[i + 1], &server->game[i + 6]);
|
|
}
|
|
}
|
|
add_rule(server, "game", server->game, NO_FLAGS);
|
|
|
|
pkt += iLen; /* mods */
|
|
|
|
iDedicatedServer = pkt[0];
|
|
if (iDedicatedServer)
|
|
{
|
|
add_rule(server, "dedicated", "Yes", NO_FLAGS);
|
|
}
|
|
else
|
|
{
|
|
add_rule(server, "dedicated", "No", NO_FLAGS);
|
|
}
|
|
|
|
pkt += 1; /* unknown */
|
|
|
|
iSecsPlayed = swap_float_from_little(pkt);
|
|
|
|
add_rule(server, "timeplayed", play_time(iSecsPlayed, 2), NO_FLAGS);
|
|
|
|
pkt += 4; /* time played */
|
|
|
|
switch (pkt[0])
|
|
{
|
|
case 3:
|
|
strcpy(str, "Joining");
|
|
break;
|
|
case 4:
|
|
strcpy(str, "Playing");
|
|
break;
|
|
case 5:
|
|
strcpy(str, "Debrief");
|
|
break;
|
|
default:
|
|
strcpy(str, "Undefined");
|
|
}
|
|
add_rule(server, "status", str, NO_FLAGS);
|
|
|
|
pkt += 1;
|
|
|
|
pkt += 3; /* unknown */
|
|
|
|
|
|
switch (pkt[0])
|
|
{
|
|
case 2:
|
|
strcpy(str, "COOP");
|
|
break;
|
|
case 3:
|
|
strcpy(str, "SOLO");
|
|
break;
|
|
case 4:
|
|
strcpy(str, "TEAM");
|
|
break;
|
|
default:
|
|
sprintf(str, "UNKOWN %u", pkt[0]);
|
|
break;
|
|
}
|
|
|
|
add_rule(server, "gamemode", str, NO_FLAGS);
|
|
|
|
if (pkt[0] == 2)
|
|
{
|
|
add_rule(server, "mission", lpszMission, NO_FLAGS);
|
|
}
|
|
else
|
|
{
|
|
add_rule(server, "mission", "No Mission", NO_FLAGS);
|
|
}
|
|
|
|
free(lpszMission);
|
|
|
|
pkt += 1; /* Game Mode */
|
|
|
|
pkt += 3; /* unknown */
|
|
|
|
iLen = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
if ((iLen < 1) || (iLen > LONG_GR_LEN))
|
|
{
|
|
add_rule(server, "error", "MOTD too Long", NO_FLAGS);
|
|
return PKT_ERROR;
|
|
}
|
|
strncpy(str, pkt, sizeof(str));
|
|
str[sizeof(str) - 1] = 0;
|
|
add_rule(server, "motd", str, NO_FLAGS);
|
|
pkt += iLen; /* MOTD */
|
|
|
|
iSpawnType = swap_long_from_little(pkt);
|
|
|
|
switch (iSpawnType)
|
|
{
|
|
case 0:
|
|
strcpy(str, "None");
|
|
break;
|
|
case 1:
|
|
strcpy(str, "Individual");
|
|
break;
|
|
case 2:
|
|
strcpy(str, "Team");
|
|
break;
|
|
case 3:
|
|
strcpy(str, "Infinite");
|
|
break;
|
|
default:
|
|
strcpy(str, "Unknown");
|
|
}
|
|
|
|
add_rule(server, "spawntype", str, NO_FLAGS);
|
|
pkt += 4; /* spawn type */
|
|
|
|
iTemp = swap_float_from_little(pkt);
|
|
add_rule(server, "gametime", play_time(iTemp, 2), NO_FLAGS);
|
|
|
|
iTemp = iTemp - iSecsPlayed;
|
|
|
|
if (iTemp <= 0)
|
|
{
|
|
iTemp = 0;
|
|
}
|
|
add_rule(server, "remainingtime", play_time(iTemp, 2), NO_FLAGS);
|
|
pkt += 4; /* Game time */
|
|
|
|
|
|
iTemp = swap_long_from_little(pkt);
|
|
if (iIgnoreServerPlayer)
|
|
{
|
|
iTemp--;
|
|
}
|
|
if (iTemp != server->num_players)
|
|
{
|
|
add_rule(server, "error", "Number of Players Mismatch", NO_FLAGS);
|
|
}
|
|
|
|
|
|
pkt += 4; /* player count 2 */
|
|
|
|
if (iIgnoreServerPlayer)
|
|
{
|
|
pkt += 5; // skip first player data
|
|
}
|
|
|
|
for (i = 0; i < server->num_players; i++)
|
|
// for each player get binary data
|
|
{
|
|
player = server->players;
|
|
// first we must find the player - lets look for the tag
|
|
while (player && (player->team != i))
|
|
{
|
|
player = player->next;
|
|
}
|
|
/* get to player - linked list is in reverse order */
|
|
|
|
if (player)
|
|
{
|
|
player->team = pkt[2];
|
|
switch (player->team)
|
|
{
|
|
case 1:
|
|
player->team_name = "Red";
|
|
break;
|
|
case 2:
|
|
player->team_name = "Blue";
|
|
break;
|
|
case 3:
|
|
player->team_name = "Yellow";
|
|
break;
|
|
case 4:
|
|
player->team_name = "Green";
|
|
break;
|
|
case 5:
|
|
player->team_name = "Unassigned";
|
|
break;
|
|
default:
|
|
player->team_name = "Not Known";
|
|
break;
|
|
}
|
|
player->flags |= PLAYER_FLAG_DO_NOT_FREE_TEAM;
|
|
player->deaths = pkt[1];
|
|
}
|
|
pkt += 5; /* player data*/
|
|
}
|
|
|
|
for (i = 0; i < 5; i++)
|
|
{
|
|
pkt += 8; /* team data who knows what they have in here */
|
|
}
|
|
|
|
pkt += 1;
|
|
iUseStartTimer = pkt[0]; // UseStartTimer
|
|
|
|
pkt += 1;
|
|
|
|
iTemp = flStartTimerSetPoint = swap_float_from_little(pkt);
|
|
// Start Timer Set Point
|
|
pkt += 4;
|
|
|
|
if (iUseStartTimer)
|
|
{
|
|
add_rule(server, "usestarttime", "Yes", NO_FLAGS);
|
|
add_rule(server, "starttimeset", play_time(iTemp, 2), NO_FLAGS);
|
|
}
|
|
else
|
|
{
|
|
add_rule(server, "usestarttime", "No", NO_FLAGS);
|
|
add_rule(server, "starttimeset", play_time(0, 2), NO_FLAGS);
|
|
}
|
|
|
|
if ((ServerVersion == VERSION_1_3) || // stuff added in patch 1.3
|
|
(ServerVersion == VERSION_1_4))
|
|
{
|
|
iTemp = swap_float_from_little(pkt); // Debrief Time
|
|
add_rule(server, "debrieftime", play_time(iTemp, 2), NO_FLAGS);
|
|
pkt += 4;
|
|
|
|
iTemp = swap_float_from_little(pkt); // Respawn Min
|
|
add_rule(server, "respawnmin", play_time(iTemp, 2), NO_FLAGS);
|
|
pkt += 4;
|
|
|
|
iTemp = swap_float_from_little(pkt); // Respawn Max
|
|
add_rule(server, "respawnmax", play_time(iTemp, 2), NO_FLAGS);
|
|
pkt += 4;
|
|
|
|
iTemp = swap_float_from_little(pkt); // Respawn Invulnerable
|
|
add_rule(server, "respawnsafe", play_time(iTemp, 2), NO_FLAGS);
|
|
pkt += 4;
|
|
}
|
|
else
|
|
{
|
|
add_rule(server, "debrieftime", "Undefined", NO_FLAGS);
|
|
add_rule(server, "respawnmin", "Undefined", NO_FLAGS);
|
|
add_rule(server, "respawnmax", "Undefined", NO_FLAGS);
|
|
add_rule(server, "respawnsafe", "Undefined", NO_FLAGS);
|
|
|
|
}
|
|
|
|
|
|
pkt += 4; // 4
|
|
iTemp = pkt[0]; // Spawn Count
|
|
|
|
if ((iSpawnType == 1) || (iSpawnType == 2))
|
|
/* Individual or team */
|
|
{
|
|
sprintf(str, "%u", iTemp);
|
|
}
|
|
else
|
|
/* else not used */
|
|
{
|
|
sprintf(str, "%u", 0);
|
|
}
|
|
add_rule(server, "spawncount", str, NO_FLAGS);
|
|
pkt += 1; // 5
|
|
|
|
pkt += 4; // 9
|
|
|
|
iTemp = pkt[0]; // Allow Observers
|
|
if (iTemp)
|
|
{
|
|
strcpy(str, "Yes");
|
|
}
|
|
else
|
|
/* else not used */
|
|
{
|
|
strcpy(str, "No");
|
|
}
|
|
add_rule(server, "allowobservers", str, NO_FLAGS);
|
|
pkt += 1; // 10
|
|
|
|
pkt += 3; // 13
|
|
|
|
// pkt += 13;
|
|
|
|
if (iUseStartTimer)
|
|
{
|
|
iTemp = swap_float_from_little(pkt); // Start Timer Count
|
|
add_rule(server, "startwait", play_time(iTemp, 2), NO_FLAGS);
|
|
}
|
|
else
|
|
{
|
|
add_rule(server, "startwait", play_time(0, 2), NO_FLAGS);
|
|
}
|
|
pkt += 4; //17
|
|
|
|
iTemp = pkt[0]; // IFF
|
|
switch (iTemp)
|
|
{
|
|
case 0:
|
|
strcpy(str, "None");
|
|
break;
|
|
case 1:
|
|
strcpy(str, "Reticule");
|
|
break;
|
|
case 2:
|
|
strcpy(str, "Names");
|
|
break;
|
|
default:
|
|
strcpy(str, "Unknown");
|
|
break;
|
|
}
|
|
add_rule(server, "iff", str, NO_FLAGS);
|
|
pkt += 1; // 18
|
|
|
|
iTemp = pkt[0]; // Threat Indicator
|
|
if (iTemp)
|
|
{
|
|
add_rule(server, "ti", "ON ", NO_FLAGS);
|
|
}
|
|
else
|
|
{
|
|
add_rule(server, "ti", "OFF", NO_FLAGS);
|
|
}
|
|
|
|
pkt += 1; // 19
|
|
|
|
pkt += 5; // 24
|
|
|
|
|
|
iLen = swap_long_from_little(pkt);
|
|
pkt += 4;
|
|
if ((iLen < 1) || (iLen > SHORT_GR_LEN))
|
|
{
|
|
add_rule(server, "error", "Restrictions too Long", NO_FLAGS);
|
|
return PKT_ERROR;
|
|
}
|
|
add_rule(server, "restrict", pkt, NO_FLAGS);
|
|
pkt += iLen; /* restrictions */
|
|
|
|
pkt += 23;
|
|
|
|
/*
|
|
if ( ghostrecon_debug) print_packet( pkt, GrPayloadLen);
|
|
*/
|
|
|
|
return DONE_FORCE;
|
|
}
|