tiberium/CnC_Renegade
Archived
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
This repository has been archived on 2025-02-27. You can view files and clone it, but cannot push or open issues or pull requests.
CnC_Renegade/Code/Commando/NAT.cpp

3690 lines
138 KiB
C++
Raw Permalink Normal View History

Initial commit of Command & Conquer Renegade source code.
2025-02-27 16:39:46 +00:00
/*
** Command & Conquer Renegade(tm)
** Copyright 2025 Electronic Arts Inc.
**
** This program is free software: you can redistribute it and/or modify
** it under the terms of the GNU General Public License as published by
** the Free Software Foundation, either version 3 of the License, or
** (at your option) any later version.
**
** This program is distributed in the hope that it will be useful,
** but WITHOUT ANY WARRANTY; without even the implied warranty of
** MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
** GNU General Public License for more details.
**
** You should have received a copy of the GNU General Public License
** along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/***********************************************************************************************
*** C O N F I D E N T I A L --- W E S T W O O D S T U D I O S ***
***********************************************************************************************
* *
* Project Name : Command & Conquer *
* *
* $Archive:: /Commando/Code/Commando/NAT.cpp $*
* *
* $Author:: Steve_t $*
* *
* $Modtime:: 3/26/02 3:04p $*
* *
* $Revision:: 37 $*
* *
* *
*---------------------------------------------------------------------------------------------*
* *
* *
*---------------------------------------------------------------------------------------------*
* *
* Functions: *
* - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - */
/*
** Disable warning about exception handling not being enabled.
*/
#pragma warning(disable : 4530)
#include "always.h"
#include <windows.h>
#include "systimer.h"
#include <snmp.h>
#include <stddef.h>
#include <process.h>
#include "crandom.h"
#include "except.h"
#include "nat.h"
#include "natsock.h"
#include "nataddr.h"
#include "slavemaster.h"
#include "gamedata.h"
/*
** Set this flag in the debugger to cause the client to fail to connect.
*/
//bool CrapFlag = false;
/*
** Single instance of firewall helper class.
*/
FirewallHelperClass FirewallHelper;
/***********************************************************************************************
* FirewallHelperClass::FirewallHelperClass -- Constructor *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/15/01 5:03PM ST : Created *
*=============================================================================================*/
FirewallHelperClass::FirewallHelperClass(void)
{
Behavior = FIREWALL_TYPE_UNKNOWN;
LastBehavior = FIREWALL_TYPE_UNKNOWN;
SourcePortAllocationDelta = 0;
LastSourcePortAllocationDelta = 0;
NumManglerServers = 0;
CurrentManglerServer = -1;
SourcePortPool = 0;
ThreadActive = false;
ThreadState = THREAD_IDLE;
ThreadEvent = INVALID_HANDLE_VALUE;
NATThreadMutex = CreateMutex(NULL, false, NULL);
NATDataMutex = CreateMutex(NULL, false, NULL);
ThreadHandle = INVALID_HANDLE_VALUE;
QueueNotifyPtr = NULL;
SuccessFlagPtr = NULL;
CancelPlayer[0] = 0;
SendDelay = false;
Confidence = 0;
}
/***********************************************************************************************
* FirewallHelperClass::Startup -- Start up the firewall thread *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/31/2001 12:35PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Startup(void)
{
/*
** Start the firewall thread.
*/
WWDEBUG_SAY(("FirewallHelper: Starting firewall thread\n"));
ThreadState = THREAD_IDLE;
ThreadEvent = INVALID_HANDLE_VALUE;
ThreadActive = true;
//ThreadHandle = CreateThread(NULL, 128*1024, &NAT_Thread_Start, this, 0, &ThreadID);
ThreadHandle = (HANDLE)_beginthreadex(NULL, 128*1024, &NAT_Thread_Start, this, 0, (unsigned int*)&ThreadID);
fw_assert(ThreadHandle != NULL);
}
/***********************************************************************************************
* FirewallHelperClass::Shutdown -- Shut down the firewall thread *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/31/2001 12:35PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Shutdown(void)
{
if (ThreadActive) {
WWDEBUG_SAY(("FirewallHelper: Stopping firewall thread\n"));
/*
** Signal the thread to go away.
*/
ThreadActive = false;
/*
** Wait for the thread to go away.
*/
int deadlock = WaitForSingleObject(NATThreadMutex, 5 * 1000);
if (deadlock == WAIT_TIMEOUT) {
WWDEBUG_SAY(("FirewallHelperClass - Timeout waiting for firewall thread mutex\n"));
fw_assert(deadlock != WAIT_TIMEOUT);
} else {
ReleaseMutex(NATThreadMutex);
}
}
// Release the thread
if (INVALID_HANDLE_VALUE != ThreadHandle) {
CloseHandle(ThreadHandle);
ThreadHandle = INVALID_HANDLE_VALUE;
}
}
/***********************************************************************************************
* FirewallHelperClass::Set_Firewall_Info -- Set firewall info from the game *
* *
* *
* *
* INPUT: last_behavior - how the firewall behaved last time we tried it *
* last_delta - the firewalls last known good port delta *
* port_pool - base port number to use when allocating temporary ports *
* send_delay - value of send delay flag used for netgear firewalls. *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/20/2001 12:16PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Set_Firewall_Info(unsigned long last_behavior, int last_delta, unsigned short port_pool, bool send_delay, int confidence)
{
if (port_pool) {
SourcePortPool = port_pool;
} else {
if (SourcePortPool == 0) {
SourcePortPool = PORT_POOL_MIN + FreeRandom.Get_Int(0, 32768);
}
}
LastBehavior = (FirewallBehaviorType) last_behavior;
LastSourcePortAllocationDelta = last_delta;
SendDelay = send_delay;
Confidence = confidence;
}
/***********************************************************************************************
* FirewallHelperClass::Set_Firewall_Info -- Set firewall info from the game *
* *
* *
* *
* INPUT: last_behavior - how the firewall behaved last time we tried it *
* last_delta - the firewalls last known good port delta *
* port_pool - base port number to use when allocating temporary ports *
* send_delay - value of send delay flag used for netgear firewalls. *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/20/2001 12:16PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Get_Firewall_Info(unsigned long &last_behavior, int &last_delta, unsigned short &port_pool, bool &send_delay, int &confidence) const
{
port_pool = SourcePortPool;
last_behavior = (unsigned long) LastBehavior;
last_delta = LastSourcePortAllocationDelta;
send_delay = SendDelay;
confidence = Confidence;
}
/***********************************************************************************************
* *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/7/2001 2:15PM ST : Created *
*=============================================================================================*/
FirewallHelperClass::~FirewallHelperClass(void)
{
Shutdown();
CloseHandle(NATThreadMutex);
CloseHandle(NATDataMutex);
}
/***********************************************************************************************
* FirewallHelperClass::NAT_Thread_Start -- Thread start for NAT thread *
* *
* *
* *
* INPUT: This ptr *
* *
* OUTPUT: Undefined *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/7/2001 2:39PM ST : Created *
*=============================================================================================*/
unsigned int __stdcall FirewallHelperClass::NAT_Thread_Start(void *thisptr)
{
unsigned int thread_exit_code = 0;
Register_Thread_ID(GetCurrentThreadId(), "Firewall thread");
__try {
thread_exit_code = ((FirewallHelperClass*)thisptr)->NAT_Thread_Main_Loop();
} __except(Exception_Handler(GetExceptionCode(), GetExceptionInformation())) {};
Unregister_Thread_ID(GetCurrentThreadId(), "Firewall thread");
return(thread_exit_code);
}
/***********************************************************************************************
* FirewallHelperClass::NAT_Thread_Main_Loop -- Main loop for NAT thread *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/7/2001 2:42PM ST : Created *
*=============================================================================================*/
unsigned long FirewallHelperClass::NAT_Thread_Main_Loop(void)
{
/*
** Take ownership of the thread mutex.
*/
int deadlock = WaitForSingleObject(NATThreadMutex, 10 * 1000);
if (deadlock == WAIT_TIMEOUT) {
WWDEBUG_SAY(("FirewallHelperClass - Timeout waiting for thread mutex\n"));
fw_assert(deadlock != WAIT_TIMEOUT);
}
/*
** Thread main loop.
*/
while (ThreadActive) {
/*
** Always do some sleeping here since this thread is a relatively low priority compared to stuff like running the
** game engine.
** If we are not doing anything much then sleep for longer.
*/
if (ThreadState == THREAD_IDLE && ThreadQueue.Count() == 0) {
Sleep(50);
} else {
Sleep(0);
}
/*
** Check for incoming private game options packets.
*/
Process_Game_Options();
/*
** Lock data access while we process each loop.
*/
ThreadLockClass locker(this);
switch (ThreadState) {
/*
** Idle state, no activity required.
*/
case THREAD_IDLE:
/*
** See if there is a pending thread action to execute.
*/
if (ThreadQueue.Count()) {
ThreadState = ThreadQueue[0].ThreadAction;
ThreadEvent = ThreadQueue[0].ThreadEvent;
//delete ThreadQueue[0];
ThreadQueue.Delete(0);
} else {
if (WOLNATInterface.Am_I_Server()) {
if (ClientQueue.Count()) {
WWDEBUG_SAY(("Client with no thread action!\n"));
Add_Thread_Action(THREAD_CONNECT_FIREWALL, INVALID_HANDLE_VALUE);
}
}
}
break;
/*
** Time to connect to another player.
*/
case THREAD_CONNECT_FIREWALL:
{
int connected = Negotiate_Port();
if (connected == FW_RESULT_SUCCEEDED && !WOLNATInterface.Am_I_Server()) {
WOLNATInterface.Set_Server_Negotiated_Address(&PlayersFirewallAddress);
}
Set_Client_Success(connected);
ThreadState = THREAD_CONNECT_FIREWALL_DONE;
break;
}
/*
** Connection done, signal as required.
*/
case THREAD_CONNECT_FIREWALL_DONE:
Set_Thread_Event();
Send_Queue_States();
ThreadState = THREAD_IDLE;
break;
/*
** Detect the firewall settings.
*/
case THREAD_DETECT_FIREWALL:
Behavior = Detect_Firewall_Behavior();
WWDEBUG_SAY(("FirewallHelper: Behavior is = %08x\n", (unsigned long)Behavior));
ThreadState = THREAD_DETECT_FIREWALL_DONE;
Set_Thread_Event();
break;
/*
** Detection done, signal as required.
*/
case THREAD_DETECT_FIREWALL_DONE:
Set_Thread_Event();
ThreadState = THREAD_IDLE;
break;
/*
** Get the local chat connection address.
*/
case THREAD_GET_LOCAL_ADDRESS:
Get_Local_Chat_Connection_Address();
ThreadState = THREAD_IDLE;
break;
/*
** We finished getting the local chat connection address.
*/
case THREAD_GET_LOCAL_ADDRESS_DONE:
ThreadState = THREAD_IDLE;
Set_Thread_Event();
break;
default:
fw_assert(false);
break;
}
}
ReleaseMutex(NATThreadMutex);
return(0);
}
/***********************************************************************************************
* FirewallHelperClass::Reset -- Causes a re-detect of the firewall *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/29/01 1:04AM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Reset(void)
{
ThreadLockClass locker(this);
Behavior = FIREWALL_TYPE_UNKNOWN;
}
/***********************************************************************************************
* FirewallHelperClass::Reset_Server -- Reset server side variables *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/10/2001 3:23PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Reset_Server(void)
{
ConnectionHistory.Delete_All();
MangledPortHistory.Delete_All();
}
/***********************************************************************************************
* FirewallHelperClass::Detect_Firewall -- See what our firewall is up to *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/15/01 6:47PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Detect_Firewall(HANDLE event)
{
ThreadLockClass locker(this);
if (Behavior == FIREWALL_TYPE_UNKNOWN) {
Add_Thread_Action(THREAD_DETECT_FIREWALL, event);
} else {
SetEvent(event);
}
}
/***********************************************************************************************
* FirewallHelperClass::Connected_To_WWOnline_Server *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/7/2001 10:02PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Connected_To_WWOnline_Server(void)
{
/*
** Don't need to go through this again if we already got the local chat connection address.
*/
if (!LocalChatConnectionAddress.Is_Valid()) {
/*
** Get the local chat connection address.
*/
ThreadLockClass locker(this);
Add_Thread_Action(THREAD_GET_LOCAL_ADDRESS, INVALID_HANDLE_VALUE);
}
}
/***********************************************************************************************
* FHC::Get_Next_Temporary_Source_Port -- Get a throwaway source port for temporary use *
* *
* *
* *
* INPUT: number of ports in sequence to skip *
* *
* OUTPUT: port number *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/15/01 12:06PM ST : Created *
*=============================================================================================*/
unsigned short FirewallHelperClass::Get_Next_Temporary_Source_Port(int skip)
{
unsigned short return_port = (unsigned short) SourcePortPool;
/*
** Try max 256 ports until we find one we can bind to a socket.
*/
int tries = 256;
if (skip == 0) {
skip = 1;
}
while (tries--) {
SourcePortPool += skip;
return_port = (unsigned short) SourcePortPool;
if (SourcePortPool > PORT_POOL_MAX) {
SourcePortPool = PORT_POOL_MIN;
}
/*
** Validate the port by trying to bind it to a socket.
*/
SocketHandlerClass *temp = new SocketHandlerClass;
bool result = temp->Open(return_port, 0);
delete temp;
if (result) {
return(return_port);
}
}
return(return_port);
}
/***********************************************************************************************
* FHC::Send_To_Mangler -- Send to the mangler from the specified socket handler *
* *
* *
* *
* INPUT: Address of mangler server *
* Socket handler to use when sending *
* ID to insert into the packet *
* blitzme flag (obsolete, must be false) *
* *
* OUTPUT: True if sent OK *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/15/01 12:47PM ST : Created *
*=============================================================================================*/
bool FirewallHelperClass::Send_To_Mangler(IPAddressClass *address, SocketHandlerClass *socket_handler, unsigned long packet_id, bool blitzme)
{
/*
** Build the packet to send out.
*/
unsigned char packet_buf[512];
int packet_size = Build_Mangler_Packet(packet_buf, socket_handler->Get_Incoming_Port(), packet_id, blitzme);
WWDEBUG_SAY(("FirewallHelper: Sending from port %d to %s\n", (unsigned int)(socket_handler->Get_Incoming_Port()), address->As_String()));
/*
** Send it.
*/
socket_handler->Write(packet_buf, packet_size, address, address->Get_Port());
return(true);
}
/***********************************************************************************************
* FHC::Get_Mangler_Response -- Get the manglers response to a specific query *
* *
* *
* *
* INPUT: Packet id of packet we are looking for *
* Ptr to socket handler class to query for packets *
* Timeout, 0=default *
* service_all - true if all sockets should be serviced *
* *
* OUTPUT: Port the mangler saw this packet come from. *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/15/01 12:51PM ST : Created *
*=============================================================================================*/
unsigned short FirewallHelperClass::Get_Mangler_Response(unsigned long packet_id, SocketHandlerClass *socket_handler, int time, bool all_service)
{
/*
** Locals.
*/
int peek_packet = 0;
CnCPacketType *packet;
unsigned char packet_buf[1024];
int packet_size = sizeof(packet_buf);
IPAddressClass address;
unsigned long id;
unsigned long timeout = TIMEGETTIME();
unsigned char temp_address[4];
unsigned short temp_port;
/*
** Asserts.
*/
fw_assert(socket_handler != NULL);
if (time) {
timeout += (unsigned long) time;
} else {
timeout += (unsigned long) TIMER_SECOND;
}
while (timeout > TIMEGETTIME()) {
if (all_service) {
SocketHandlerClass::Service_All();
} else {
socket_handler->Service();
}
/*
** Get a copy of the global packet we want to examine. This doesn't remove it from the queue.
*/
int result = socket_handler->Peek(packet_buf, packet_size, &temp_address, &temp_port, peek_packet);
/*
** Check if we got a packet from the mangler.
*/
if (result) {
packet = (CnCPacketType*)packet_buf;
if (packet->Packet.Command == NET_MANGLER_RESPONSE) {
WWDEBUG_SAY(("FirewallHelper: Got NET_MANGLER_RESPONSE packet\n"));
/*
** We got a mangler packet, see if it's the one we are looking for.
*/
#ifdef WWDEBUG
int original_port = packet->Packet.ManglerData.OriginalPortNumber;
#endif //WWDEBUG
id = packet->GHeader.Header.PacketID;
if (packet_id == id) {
/*
** Looks good, lets get the mangled port number out.
*/
unsigned short mangled_port = packet->Packet.ManglerData.MangledPortNumber;
WWDEBUG_SAY(("FirewallHelper: Mangler is seeing packets from port %d as coming from port %d\n", (unsigned int)original_port, (unsigned int)mangled_port));
/*
** Now the mangled address. This should never change.
*/
ExternalAddress.Set_Address(packet->Packet.ManglerData.MangledAddress);
WWDEBUG_SAY(("FirewallHelper: Mangler is seeing our packets coming from address %s\n", ExternalAddress.As_String()));
/*
** Remove the packet from the queue.
*/
result = socket_handler->Read(packet_buf, packet_size, &temp_address, &temp_port, peek_packet);
fw_assert(result != NULL);
return(mangled_port);
}
}
peek_packet++;
} else {
peek_packet = 0;
}
Sleep(0);
}
return(0);
}
/***********************************************************************************************
* FHC::Detect_Firewall_Behavior -- What is that wacky firewall doing to our packet headers? *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Firewall behavior *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/15/01 12:30PM ST : Created *
*=============================================================================================*/
FirewallHelperClass::FirewallBehaviorType FirewallHelperClass::Detect_Firewall_Behavior(void)
{
unsigned short mangler_port = 4321;
char temp_mangler_name[128];
unsigned long packet_id = 0x7f000000;
/*
** Well, we are going to need some manglers.
*/
static char _manglername[5][80] = {
"mangler1.westwood.com",
"mangler2.westwood.com",
"mangler3.westwood.com",
"mangler.westwood.com",
""
};
unsigned char mangler_addresses[4][4];
int num_mangler_addresses = 0;
FirewallBehaviorType behavior = FIREWALL_TYPE_SIMPLE;
IPAddressClass manglers[4];
unsigned long timeout;
int mangler_index_offset = 0;
unsigned short source_ports[NUM_TEST_PORTS];
unsigned short mangled_ports[NUM_TEST_PORTS];
SocketHandlerClass *port_sockets[NUM_TEST_PORTS];
int delta = 0;
bool save_firewall_type = true;
bool looks_good = true;
/*
** Figure out which mangler to use this time. Pick randomly from the available manglers.
*/
NumManglerServers = WOLNATInterface.Get_Num_Mangler_Servers();
if (CurrentManglerServer == -1) {
CurrentManglerServer = FreeRandom.Get_Int(0, NumManglerServers-1);
WWDEBUG_SAY(("FirewallHelper - Using mangler server %d\n", CurrentManglerServer));
}
/*
** If the user specified a particular port to use then we act as if there is no firewall.
*/
if (WOLNATInterface.Get_Force_Port()) {
behavior = FIREWALL_TYPE_SIMPLE;
WWDEBUG_SAY(("FirewallHelper: Source port %d specified by user\n", WOLNATInterface.Get_Force_Port()));
if (SendDelay) {
unsigned long addbehavior = FIREWALL_TYPE_NETGEAR_BUG;
addbehavior |= (unsigned long)behavior;
behavior = (FirewallBehaviorType) addbehavior;
WWDEBUG_SAY(("FirewallHelper: Netgear bug specified by command line or SendDelay flag\n"));
}
return(behavior);
}
/*
** Slave servers inherit their firewall info from the master server.
*/
if (SlaveMaster.Am_I_Slave()) {
behavior = LastBehavior;
SourcePortAllocationDelta = LastSourcePortAllocationDelta;
ExternalAddress.Set_Address(WOLNATInterface.Get_Reg_External_IP(), WOLNATInterface.Get_Reg_External_Port());
return(behavior);
}
timeout = TIMEGETTIME() + (5*TIMER_SECOND);
WWDEBUG_SAY(("FirewallHelper: About to call gethostbyname for the mangler address\n"));
int namenum = 0;
/*
** Convert the list of mangler servers to numeric IP addresses.
**
*/
do {
char *mangler_name_ptr = &_manglername[namenum][0];
/*
** Use the wolapi supplied mangler info if available.
*/
bool got_name = WOLNATInterface.Get_Mangler_Name_By_Index(namenum, temp_mangler_name);
if (got_name) {
mangler_name_ptr = temp_mangler_name;
unsigned short servserv_port = WOLNATInterface.Get_Mangler_Port_By_Index(namenum);
fw_assert(servserv_port != 0);
if (servserv_port) {
mangler_port = servserv_port;
}
WWDEBUG_SAY(("FirewallHelper - Using mangler server from servserv - address is %s ; %d\n", mangler_name_ptr, mangler_port));
} else {
WWDEBUG_SAY(("FirewallHelper - Using default mangler name for mangler %d\n", namenum));
}
namenum++;
if (strlen(mangler_name_ptr) == 0) {
break;
}
/*
** Do the lookup.
*/
char temp_name[256];
strcpy(temp_name, mangler_name_ptr);
struct hostent *host_info = gethostbyname(temp_name);
if (!host_info) {
WWDEBUG_SAY(("FirewallHelper: gethostbyname failed! Error code %d\n", WSAGetLastError()));
break;
}
/*
** See if we already have that address in the list.
*/
bool found = false;
for (int i=0 ; i<num_mangler_addresses ; i++) {
if (memcmp(mangler_addresses[i], &host_info->h_addr_list[0][0], 4) == 0) {
found = true;
break;
}
}
/*
** Add the address in if we didn't find it.
*/
if (!found) {
int m = num_mangler_addresses++;
memcpy(&mangler_addresses[m][0], &host_info->h_addr_list[0][0], 4);
WWDEBUG_SAY(("FirewallHelper: Found mangler address at %d.%d.%d.%d\n", mangler_addresses[m][0], mangler_addresses[m][1], mangler_addresses[m][2], mangler_addresses[m][3]));
}
} while (num_mangler_addresses < 4 && TIMEGETTIME() < timeout);
/*
** We need a certain number of manglers to be able to do the detection.
*/
fw_assert(num_mangler_addresses > 2);
if (num_mangler_addresses < 3) {
WWDEBUG_SAY(("FirewallHelper: Not enough manglers - returning default behavior\n"));
if (Confidence > 0) {
behavior = LastBehavior;
SourcePortAllocationDelta = LastSourcePortAllocationDelta;
}
return(behavior);
}
/*
** Convert the mangler addresses to IPAddressClass format.
*/
for (int i=0 ; i<num_mangler_addresses ; i++) {
unsigned char addr[4];
memcpy(addr, &mangler_addresses[i][0], 4);
manglers[i].Set_Address(addr, mangler_port);
}
/*
** OK, we have our manglers.
**
** First test, see if there is any port mangling at all.
**
**
**
*/
/*
** Get a spare port number and create a new socket to bind it to.
*/
unsigned short port = Get_Next_Temporary_Source_Port(0);
SocketHandlerClass socket;
if (!socket.Open(port, 4321)) {
WWDEBUG_SAY(("FirewallHelper: Unable to open temp source port - returning default behavior\n"));
return(behavior);
}
/*
** Send to the mangler from this port until we get a response.
*/
timeout = TIMEGETTIME() + TIMER_SECOND * 6;
unsigned short mangled_port = 0;
while (TIMEGETTIME() < timeout && mangled_port == 0) {
Send_To_Mangler(&manglers[0], &socket, packet_id);
mangled_port = Get_Mangler_Response(packet_id, &socket);
}
if (mangled_port == 0) {
/*
** No response from mangler 0. That's bad. I guess we could try the other manglers.
** We already tried the first one so skip that. Don't use the last one either since that will be needed later to detect
** port per ip behavior.
*/
for (int m=1 ; m<num_mangler_addresses - 1 ; m++) {
mangler_index_offset = m;
timeout = TIMEGETTIME() + TIMER_SECOND * 3;
while (TIMEGETTIME() < timeout && mangled_port == 0) {
Send_To_Mangler(&manglers[mangler_index_offset], &socket, packet_id);
mangled_port = Get_Mangler_Response(packet_id, &socket);
}
}
}
/*
** See if we got no response or a non-mangled response.
*/
if (mangled_port == 0 || mangled_port == port) {
if (mangled_port == port) {
SourcePortAllocationDelta = 0;
LastSourcePortAllocationDelta = 0;
LastBehavior = FIREWALL_TYPE_SIMPLE;
Confidence = 0;
} else {
WWASSERT(mangled_port == 0);
if (Confidence) {
SourcePortAllocationDelta = LastSourcePortAllocationDelta;
return(LastBehavior);
}
}
return(FIREWALL_TYPE_SIMPLE);
}
/*
**
** Second test. See if the ports are mangled differently for different destination IPs.
**
** We can use the spare socket from the last test and send to a different mangler.
**
*/
/*
** Send to the mangler from this port until we get a response.
*/
timeout = TIMEGETTIME() + (TIMER_SECOND * 6);
unsigned short second_ip_mangled_port = 0;
while (TIMEGETTIME() < timeout && second_ip_mangled_port == 0) {
Send_To_Mangler(&manglers[mangler_index_offset + 1], &socket, packet_id+1);
second_ip_mangled_port = Get_Mangler_Response(packet_id+1, &socket);
};
/*
** We are done with this socket/port
*/
socket.Close();
/*
** See if we got no response or a non-mangled response.
*/
if (second_ip_mangled_port == 0 || second_ip_mangled_port == port) {
WWDEBUG_SAY(("FirewallHelper: No response or response is unmangled - returning simple firewall behavior\n"));
return(FIREWALL_TYPE_SIMPLE);
}
/*
** Got a mangled port. Is it the same as the last one (mangles the same regardless of destination IP).
*/
if (mangled_port == second_ip_mangled_port) {
behavior = FIREWALL_TYPE_DUMB_MANGLING;
WWDEBUG_SAY(("FirewallHelper: Source ports mangled the same way regardless of destination IP\n"));
} else {
behavior = FIREWALL_TYPE_SMART_MANGLING;
WWDEBUG_SAY(("FirewallHelper: Source ports mangled differently per destination IP\n"));
}
/*
** Third test.
**
** This test tries to detect a pattern in the ports allocated by the NAT.
** We use several source ports for this one.
**
*/
/*
** Try this whole thing a max of 3 times.
*/
int try_again;
for (try_again = 0 ; try_again < 3 ; try_again++) {
memset(source_ports, 0, sizeof(source_ports));
memset(mangled_ports, 0, sizeof(source_ports));
memset(port_sockets, 0, sizeof(port_sockets));
/*
** Open a socket for each source port.
** We should use a non-linear set of source ports so we can detect the NAT32 relative offset
** case.
*/
bool port_open_failed = false;
for (i=0 ; i<NUM_TEST_PORTS ; i++) {
source_ports[i] = Get_Next_Temporary_Source_Port(i);
port_sockets[i] = new SocketHandlerClass;
if (!port_sockets[i]->Open(source_ports[i], 4321)) {
port_open_failed = true;
/*
** Close any spare ports we allocated already before we bail.
*/
for (int j=0 ; j<i ; j++) {
if (port_sockets[j]) {
delete port_sockets[j];
port_sockets[j] = NULL;
}
}
WWDEBUG_SAY(("FirewallHelper: Unable to open all source ports for allocation pattern test - returning default behavior\n"));
break; //return(behavior);
}
}
if (port_open_failed) {
continue;
}
/*
** OK, lets get some numbers from the mangler.
**
** Keep sending from each port until we get a response to all the sends. There's a implied
** delay between initial sends due to the timeout in Get_Mangler_Response.
*/
int num_responses = 0;
packet_id = packet_id + 10;
timeout = TIMEGETTIME() + (TIMER_SECOND * 12);
while (TIMEGETTIME() < timeout && num_responses < NUM_TEST_PORTS) {
for (i=0 ; i<NUM_TEST_PORTS ; i++) {
if (mangled_ports[i] == 0) {
Send_To_Mangler(&manglers[mangler_index_offset], port_sockets[i], packet_id+i);
mangled_ports[i] = Get_Mangler_Response(packet_id+i, port_sockets[i], 0, true);
if (mangled_ports[i] != 0) {
num_responses++;
}
}
}
}
/*
** Close down those sockets - we are finished with them.
*/
for (int j=0 ; j<i ; j++) {
if (port_sockets[j]) {
delete port_sockets[j];
port_sockets[j] = NULL;
}
}
/*
** We need at least 4 responses to be sure of the port allocation scheme.
*/
if (num_responses < 4) {
if (LastSourcePortAllocationDelta != 0 && (int)LastBehavior > (int)FIREWALL_TYPE_SIMPLE) {
/*
** If the delta we got last time we played looks good then use that.
*/
SourcePortAllocationDelta = LastSourcePortAllocationDelta;
WWDEBUG_SAY(("FirewallHelper: Unable to verify responses from 4 mangler servers - returning default behavior\n"));
return(behavior);
}
/*
** Try again.
*/
continue;
}
bool relative_delta = false;
delta = Get_NAT_Port_Allocation_Scheme(num_responses, source_ports, mangled_ports, relative_delta, looks_good);
if (delta) {
/*
** Hey, we got it!
*/
unsigned long addbehavior = 0;
if (relative_delta) {
addbehavior = (unsigned long)FIREWALL_TYPE_RELATIVE_PORT_ALLOCATION;
} else {
addbehavior = (unsigned long)FIREWALL_TYPE_SIMPLE_PORT_ALLOCATION;
}
addbehavior |= (unsigned long)behavior;
behavior = (FirewallBehaviorType) addbehavior;
SourcePortAllocationDelta = delta;
if (!looks_good) {
save_firewall_type = false;
}
break;
} else {
if (LastSourcePortAllocationDelta != 0 && (int)LastBehavior > (int)FIREWALL_TYPE_SIMPLE) {
/*
** If the delta we got last time we played looks good then use that.
*/
SourcePortAllocationDelta = LastSourcePortAllocationDelta;
behavior = LastBehavior;
save_firewall_type = false;
break;
}
}
}
/*
** See if we screwed up.
*/
if (try_again == 3) {
/*
** We know it mangles differently per IP but we don't know how. Make something up.
*/
SourcePortAllocationDelta = 1;
save_firewall_type = false;
}
/*
** Test to see if the NAT mangles differently per destination port at the same IP.
**
**
*/
if ((behavior & FIREWALL_TYPE_SMART_MANGLING) != 0) {
if ((behavior & FIREWALL_TYPE_SIMPLE_PORT_ALLOCATION) != 0) {
WWDEBUG_SAY(("FirewallHelper: Testing to see if the NAT mangles differently per destination port at the same IP\n"));
/*
** We need 2 source ports for this.
*/
unsigned short port1 = Get_Next_Temporary_Source_Port(0);
SocketHandlerClass socket1;
if (!socket1.Open(port1, 4321)) {
return(behavior);
}
unsigned short port2 = Get_Next_Temporary_Source_Port(0);
SocketHandlerClass socket2;
if (!socket2.Open(port2, 4321)) {
return(behavior);
}
/*
** Get a reference port.
*/
timeout = TIMEGETTIME() + (TIMER_SECOND * 4);
mangled_port = 0;
packet_id = packet_id + 10;
/*
** Wait for a response.
*/
while (TIMEGETTIME() < timeout && mangled_port == 0) {
Send_To_Mangler(&manglers[mangler_index_offset], &socket1, packet_id);
mangled_port = Get_Mangler_Response(packet_id, &socket1);
}
if (mangled_port == 0) {
return(behavior);
}
/*
** Send out to a different port at that IP.
** We won't get a response for this.
*/
IPAddressClass addr = manglers[mangler_index_offset];
addr.Set_Port(addr.Get_Port() + 1);
Send_To_Mangler(&addr, &socket1, packet_id);
Send_To_Mangler(&addr, &socket1, packet_id);
Send_To_Mangler(&addr, &socket1, packet_id);
/*
** We can't get a response from a different destination port so the only way to detect
** this behavior is to check the next mangled port allocation to see if it's double
** what we would normally expect.
*/
packet_id++;
unsigned short new_mangled_port = 0;
timeout = TIMEGETTIME() + (TIMER_SECOND * 4);
while (TIMEGETTIME() < timeout && new_mangled_port == 0) {
Send_To_Mangler(&manglers[mangler_index_offset], &socket2, packet_id);
new_mangled_port = Get_Mangler_Response(packet_id, &socket2);
}
if (new_mangled_port != 0) {
if (new_mangled_port != mangled_port + SourcePortAllocationDelta) {
WWDEBUG_SAY(("FirewallHelper: NAT uses different source ports for different destination ports\n"));
unsigned long addbehavior = 0;
addbehavior = (unsigned long)FIREWALL_TYPE_DESTINATION_PORT_DELTA;
addbehavior |= (unsigned long)behavior;
behavior = (FirewallBehaviorType) addbehavior;
} else {
fw_assert(new_mangled_port == mangled_port + SourcePortAllocationDelta);
if (new_mangled_port == mangled_port + SourcePortAllocationDelta) {
WWDEBUG_SAY(("FirewallHelper: NAT uses the same source port for different destination ports\n"));
} else {
WWDEBUG_SAY(("FirewallHelper: Unable to complete destination port mangling test\n"));
fw_assert(false);
}
}
}
} else {
/*
** NAT32 uses different mangled source ports for different destination ports.
*/
unsigned long addbehavior = 0;
addbehavior = (unsigned long)FIREWALL_TYPE_DESTINATION_PORT_DELTA;
addbehavior |= (unsigned long)behavior;
behavior = (FirewallBehaviorType) addbehavior;
}
}
/*
** See if the user specified a netgear firewall - that will save us the trouble of detecting it.
*/
if (SendDelay) {
unsigned long addbehavior = FIREWALL_TYPE_NETGEAR_BUG;
addbehavior |= (unsigned long)behavior;
behavior = (FirewallBehaviorType) addbehavior;
WWDEBUG_SAY(("FirewallHelper: Netgear bug specified by command line or SendDelay flag\n"));
}
/*
** Remember this firewall type for next time.
*/
if (save_firewall_type) {
LastBehavior = behavior;
LastSourcePortAllocationDelta = SourcePortAllocationDelta;
Confidence = 0;
} else {
/*
** If we have high confidence in the last settings we detected then we might want to use those in preference.
*/
if (LastBehavior == behavior && LastSourcePortAllocationDelta != SourcePortAllocationDelta) {
if (Confidence > 0) {
/*
** Only do this max 3 times before accepting the new delta.
*/
Confidence = (Confidence / 3) - 1;
SourcePortAllocationDelta = LastSourcePortAllocationDelta;
}
}
}
return(behavior);
}
/***********************************************************************************************
* FHC::Get_NAT_Port_Allocation_Scheme -- Find out how a NAT is allocating ports *
* *
* *
* *
* INPUT: Number of ports we should analyze *
* List of original port numbers *
* List of mangled port numbers *
* relative_delta (out) Is the delta relative to the original port number? *
* looks_good (out) Do all the values point to the same delta? *
* *
* OUTPUT: Port allocation delta *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/15/01 4:45PM ST : Created *
*=============================================================================================*/
int FirewallHelperClass::Get_NAT_Port_Allocation_Scheme(int num_ports, unsigned short *original_ports, unsigned short *mangled_ports, bool &relative_delta, bool &looks_good)
{
fw_assert(num_ports > 3);
WWDEBUG_SAY(("FirewallHelper: Looking for port allocation pattern in original_ports %d, %d, %d, %d\n", original_ports[0], original_ports[1], original_ports[2], original_ports[3]));
/*
** Sort the mangled ports into order - should be easier to detect patterns.
** Stupid bubble sort will do. original_ports may be out of oder after the sort.
*/
for (int x=0 ; x<num_ports ; x++) {
for (int y=0 ; y<num_ports-1 ; y++) {
if (mangled_ports[y] > mangled_ports[y+1]) {
int temp = mangled_ports[y];
mangled_ports[y] = mangled_ports[y+1];
mangled_ports[y+1] = temp;
temp = original_ports[y];
original_ports[y] = original_ports[y+1];
original_ports[y+1] = temp;
}
}
}
/*
** Now start looking for patterns in the port numbers. Possible patterns include.
**
** Incremental. Port numbers are allocated incrementally.
** Every 'n' ports. NAT adds 'n' port numbers when allocating ports.
**
** Also, schemes may be absolute or relative to the original port number.
*/
/*
** 1. Check for absolute sequential allocation.
*/
if (mangled_ports[1] - mangled_ports[0] == 1) {
if (mangled_ports[2] - mangled_ports[1] == 1) {
if (mangled_ports[3] - mangled_ports[2] == 1) {
WWDEBUG_SAY(("FirewallHelper: Incremental port allocation detected\n"));
relative_delta = false;
looks_good = true;
return(1);
}
}
}
/*
** 2. Check for semi sequential.
*/
if (mangled_ports[1] - mangled_ports[0] == 2) {
if (mangled_ports[2] - mangled_ports[1] == 2) {
if (mangled_ports[3] - mangled_ports[2] == 2) {
WWDEBUG_SAY(("FirewallHelper: Semi-incremental port allocation detected\n"));
relative_delta = false;
looks_good = true;
return(2);
}
}
}
int diff1 = mangled_ports[1] - mangled_ports[0];
int diff2 = mangled_ports[2] - mangled_ports[1];
int diff3 = mangled_ports[3] - mangled_ports[2];
/*
** 3. Check for absolute scheme skipping 'n' ports.
*/
if (diff1 == diff2 && diff2 == diff3) {
WWDEBUG_SAY(("FirewallHelper: Looks good for absolute allocation sequence delta of %d\n", diff1));
relative_delta = false;
looks_good = true;
return(diff1);
}
if (diff1 == diff2) {
WWDEBUG_SAY(("FirewallHelper: Probable absolute allocation sequence delta of %d\n", diff1));
relative_delta = false;
looks_good = false;
return(diff1);
}
if (diff2 == diff3) {
WWDEBUG_SAY(("FirewallHelper: Probable absolute allocation sequence delta of %d\n", diff2));
relative_delta = false;
looks_good = false;
return(diff2);
}
/*
** Insert more tests here if we can think of any!!!!!
*/
/*
** 4. Check for relative scheme skipping 'n' ports. NAT32 behaves this way, it skips 100 ports
** each time.
*/
for (int i=0 ; i<num_ports ; i++) {
mangled_ports[i] -= original_ports[i];
}
diff1 = mangled_ports[1] - mangled_ports[0];
diff2 = mangled_ports[2] - mangled_ports[1];
diff3 = mangled_ports[3] - mangled_ports[2];
/*
** Look for a linear pattern.
*/
if (diff1 == diff2 && diff2 == diff3) {
/*
** Return a -ve result to indicate that port mangling is relative.
*/
WWDEBUG_SAY(("FirewallHelper: Looks good for a relative port range delta of %d\n", diff1));
relative_delta = true;
looks_good = true;
return(diff1);
}
/*
** Look for a broken pattern. Maybe the NAT skipped a whole range.
*/
if (diff1 == diff2 || diff1 == diff3) {
WWDEBUG_SAY(("FirewallHelper: Detected probable broken relative port range delta of %d\n", diff1));
relative_delta = true;
looks_good = false;
return(diff1);
}
if (diff2 == diff3) {
WWDEBUG_SAY(("FirewallHelper: Detected probable broken relative port range delta of %d\n", diff2));
relative_delta = true;
looks_good = false;
return(diff2);
}
/*
** Aw hell, I don't know what it is.
*/
looks_good = false;
relative_delta = false;
return(0);
}
/***********************************************************************************************
* FHC::Get_Firewall_Hardness -- How hard is it to connect to this firewall *
* *
* *
* *
* INPUT: Firewall behavior *
* *
* OUTPUT: Hardness *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/16/01 11:43AM ST : Created *
*=============================================================================================*/
int FirewallHelperClass::Get_Firewall_Hardness(FirewallBehaviorType behavior)
{
int hardness = 0;
unsigned long fw = (unsigned long) behavior;
if (((unsigned long)FIREWALL_TYPE_SIMPLE & fw) != 0) {
hardness++;
}
if (((unsigned long)FIREWALL_TYPE_DUMB_MANGLING & fw) != 0) {
hardness += 2;
}
if (((unsigned long)FIREWALL_TYPE_SMART_MANGLING & fw) != 0) {
hardness += 3;
}
if (((unsigned long)FIREWALL_TYPE_NETGEAR_BUG & fw) != 0) {
hardness += 10;
}
if (((unsigned long)FIREWALL_TYPE_SIMPLE_PORT_ALLOCATION & fw) != 0) {
hardness += 1;
}
if (((unsigned long)FIREWALL_TYPE_RELATIVE_PORT_ALLOCATION & fw) != 0) {
hardness += 2;
}
return(hardness);
}
/***********************************************************************************************
* FHC::Get_Firewall_Retries -- How many retries is it likely to take before we connect? *
* *
* *
* *
* INPUT: Firewall behavior *
* *
* OUTPUT: Hardness *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/16/01 11:43AM ST : Created *
*=============================================================================================*/
int FirewallHelperClass::Get_Firewall_Retries(FirewallBehaviorType behavior)
{
int retries = 2;
unsigned long fw = (unsigned long) behavior;
if (((unsigned long)FIREWALL_TYPE_SIMPLE & fw) != 0) {
retries++;
}
if (((unsigned long)FIREWALL_TYPE_DUMB_MANGLING & fw) != 0) {
retries += 1;
}
if (((unsigned long)FIREWALL_TYPE_SMART_MANGLING & fw) != 0) {
retries += 1;
}
if (((unsigned long)FIREWALL_TYPE_NETGEAR_BUG & fw) != 0) {
//retries += 10;
}
if (((unsigned long)FIREWALL_TYPE_SIMPLE_PORT_ALLOCATION & fw) != 0) {
//retries += 1;
}
if (((unsigned long)FIREWALL_TYPE_RELATIVE_PORT_ALLOCATION & fw) != 0) {
retries += 5;
}
return(retries);
}
/***********************************************************************************************
* FHC::Get_Next_Mangled_Source_Port -- How will the firewall mangle our next source port *
* *
* *
* *
* INPUT: Source port that we will use *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/16/01 3:30PM ST : Created *
*=============================================================================================*/
unsigned short FirewallHelperClass::Get_Next_Mangled_Source_Port(unsigned short source_port)
{
/*
** Locals.
*/
static unsigned long _packet_id = 0x7f100000;
unsigned long timeout;
int return_port = source_port;
SocketHandlerClass socket;
/*
** If our firewall is stupid then just return the source port.
*/
unsigned long fw = (unsigned long) Behavior;
if (fw == 0) {
return(source_port);
}
if (((unsigned long)FIREWALL_TYPE_SIMPLE & fw) != 0) {
return(source_port);
}
/*
** If our NAT uses the same mangled source port regardless of the dest IP then we can use any previous connection to a different IP.
*/
if (WOLNATInterface.Am_I_Server() && ((unsigned long)FIREWALL_TYPE_DUMB_MANGLING & fw) != 0) {
for (int h=0 ; h<ConnectionHistory.Count() ; h++) {
/*
** Make sure it isn't my address (should never be, even with players from behind the same firewall).
*/
if (!ConnectionHistory[h].Is_IP_Equal(ExternalAddress)) {
WWDEBUG_SAY(("FirewallHelper - same port regardless of dest ip - using port %d from connection to %s ; %d\n", (unsigned long) MangledPortHistory[h], ConnectionHistory[h].As_String()));
return(MangledPortHistory[h]);
}
}
}
/*
** Get the address of a mangler server.
*/
unsigned short mangler_port = 4321;
char mangler_name[256];
strcpy(mangler_name, "mangler2.westwood.com");
unsigned char maddress[4];
if (NumManglerServers > 0) {
fw_assert(CurrentManglerServer >= 0 && CurrentManglerServer < NumManglerServers);
bool got_name = WOLNATInterface.Get_Mangler_Name_By_Index(CurrentManglerServer, mangler_name);
if (got_name) {
unsigned short servserv_port = WOLNATInterface.Get_Mangler_Port_By_Index(CurrentManglerServer);
fw_assert(servserv_port != 0);
if (servserv_port) {
mangler_port = servserv_port;
}
WWDEBUG_SAY(("FirewallHelper - Using mangler server from servserv - address is %s ; %d\n", mangler_name, mangler_port));
} else {
WWDEBUG_SAY(("FirewallHelper - Using default mangler name for mangler %d\n", CurrentManglerServer));
}
}
/*
** Get the address to send the packets to.
*/
//WWDEBUG_SAY (("Firewall helper - About to call gethostbyname for %s\n", mangler_name));
struct hostent *host_info = gethostbyname(mangler_name);
if (!host_info) {
WWDEBUG_SAY(("FirewallHelper - gethostbyname failed! Error code %d\n", WSAGetLastError()));
return(source_port);
}
memcpy(maddress, &host_info->h_addr_list[0][0], 4);
//WWDEBUG_SAY(("FirewallHelper: Mangler address is %d.%d.%d.%d ; %d\n", maddress[0], maddress[1], maddress[2], maddress[3], (int)mangler_port));
IPAddressClass mangler_address;
mangler_address.Set_Address(maddress, mangler_port);
//WWDEBUG_SAY(("FirewallHelper: Mangler address is %s\n", mangler_address.As_String()));
//WWDEBUG_SAY(("FirewallHelper: fw = %08x\n", fw));
/*
** Send to the mangler to establish a reference port.
*/
unsigned short port = Get_Next_Temporary_Source_Port(0);
fw_assert(port != source_port);
if (!socket.Open(port, 4321)) {
return(source_port);
}
WWDEBUG_SAY(("FirewallHelper - Getting mangling for temp source port %d\n", (int)port));
/*
** Send to the mangler from this port until we get a response.
*/
timeout = TIMEGETTIME() + (TIMER_SECOND * 3);
unsigned short mangled_port = 0;
while (TIMEGETTIME() < timeout && mangled_port == 0) {
Send_To_Mangler(&mangler_address, &socket, _packet_id);
mangled_port = Get_Mangler_Response(_packet_id, &socket, TIMER_SECOND / 2);
if (mangled_port != 0) {
WWDEBUG_SAY(("FirewallHelper - Mangled port = %d\n", (int)mangled_port));
}
}
_packet_id++;
fw_assert(mangled_port != 0 && mangled_port != source_port);
if (mangled_port == 0) {
/*
** We failed to get a response from the mangler, try a different one next retry.
*/
CurrentManglerServer++;
if (CurrentManglerServer >= NumManglerServers) {
CurrentManglerServer = 0;
}
WWDEBUG_SAY(("FirewallHelper: Couldn't find mangled port, returning source port\n"));
return(source_port);
}
/*
** Our new reference port is 'mangled port'. If we don't care about IP then we are done.
*/
if (((unsigned long)FIREWALL_TYPE_DUMB_MANGLING & fw) != 0) {
WWDEBUG_SAY(("FirewallHelper - Dumb firewall, returning next mangled port as %d\n", mangled_port));
return(mangled_port);
}
/*
** Apply our known delta to the mangled port.
*/
if (((unsigned long)FIREWALL_TYPE_SIMPLE_PORT_ALLOCATION & fw) != 0) {
/*
** Simple port allocation.
*/
return_port = (int)mangled_port + SourcePortAllocationDelta;
} else {
/*
** Rats. It's a relative mangler. This is much harder. Damn NAT32 guy.
*/
if (SourcePortAllocationDelta == 100) {
/*
** Special NAT32 section.
**
** NAT32 mangles source UDP port by adding 1700 + 100 * internal table index
**
** To get the current index we need to take the mangled port and subtract 1700 and the source port
*/
return_port = mangled_port - port;
return_port -= 1700;
return_port += SourcePortAllocationDelta;
return_port += source_port;
return_port += 1700;
} else {
WWASSERT(SourcePortAllocationDelta != 0);
if (SourcePortAllocationDelta == 0) {
/*
** This should never happen....
*/
return_port = mangled_port;
} else {
return_port = mangled_port / SourcePortAllocationDelta;
return_port = return_port * SourcePortAllocationDelta;
return_port += (source_port % SourcePortAllocationDelta);
return_port += SourcePortAllocationDelta;
}
}
}
/*
** This bit is probably doomed.
*/
if (return_port > 65535) {
return_port -= 65535;
}
if (return_port < 1024) {
return_port += 1024;
}
WWDEBUG_SAY(("FirewallHelper - Returning next mangled port as %d\n", return_port));
return(unsigned short(return_port));
}
/***********************************************************************************************
* NatterClass::Build_Mangler_Packet -- Build a packet to send to the mangler. *
* *
* *
* *
* INPUT: Buffer to build packet in *
* Port to set into the packets Port area *
* Packet ID. *
* Blitzme flag (shouldn't be used) *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/6/2001 1:11PM ST : Created *
*=============================================================================================*/
int FirewallHelperClass::Build_Mangler_Packet(unsigned char *buffer, unsigned short port, unsigned long packet_id, bool blitzme)
{
/*
** Asserts.
*/
fw_assert(buffer != NULL);
fw_assert(blitzme == false);
/*
** Need the buffer to exist.
*/
if (buffer == NULL) {
return(0);
}
/*
** Cast the buffer to a CnCPacketType.
*/
CnCPacketType *packet = (CnCPacketType*)buffer;
/*
** Clear out the buffer prior to setting fields.
*/
memset(packet, 0, sizeof(CnCPacketType));
/*
** Set the required Global Header firelds.
*/
packet->GHeader.Header.MagicNumber = GLOBAL_MAGICNUM;
packet->GHeader.Header.Code = PACKET_DATA_NOACK;
packet->GHeader.Header.ForwardTo = 0;
packet->GHeader.Header.PacketID = packet_id;
packet->GHeader.ProductID = COMMAND_AND_CONQUER_RA2;
/*
** Set the Global Packet fields.
*/
packet->Packet.Command = NET_MANGLER_REQUEST;
strcpy(packet->Packet.Name, "ren");
packet->Packet.ManglerData.MangledPortNumber = port;
packet->Packet.ManglerData.OriginalPortNumber = port;
packet->Packet.ManglerData.BlitzMe = 0;
/*
** Blitzme field is obsolete and should never be used.
*/
if (blitzme) {
packet->Packet.ManglerData.BlitzMe = 1;
}
/*
** Return success.
*/
return(sizeof(CnCPacketType));
}
/***********************************************************************************************
* FirewallHelperClass::Add_Thread_Action -- Add a new action to the thread control FIFO *
* *
* *
* *
* INPUT: Thread action *
* Notification event *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/9/2001 9:06PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Add_Thread_Action(int thread_action, HANDLE thread_event)
{
ThreadLockClass locker(this);
ThreadActionClass thread;
thread.ThreadAction = thread_action;
thread.ThreadEvent = thread_event;
ThreadQueue.Add(thread);
}
/***********************************************************************************************
* FirewallHelperClass::Set_Thread_Event -- Set the event associated with action completion *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/9/2001 9:09PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Set_Thread_Event(void)
{
ThreadLockClass locker(this);
if (ThreadEvent != INVALID_HANDLE_VALUE) {
SetEvent(ThreadEvent);
ThreadEvent = INVALID_HANDLE_VALUE;
}
}
/***********************************************************************************************
* FirewallHelperClass::Talk_To_New_Player -- A new player wants to negotiate a NAT port *
* *
* *
* *
* INPUT: User struct for player *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/7/2001 8:31PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Talk_To_New_Player(WOL::User *user)
{
/*
** We are only reading here - no need to get exclusive access.
*/
//ThreadLockClass locker(this);
WWASSERT(PTheGameData != NULL);
/*
** Fill in an invitation options packet to send to the guest.
*/
WOLNATInterfaceClass::PrivateGameOptionsStruct options;
strcpy(options.NATOptionsPrefix, "NAT:");
options.Option = WOLNATInterfaceClass::OPTION_INVITE_PORT_NEGOTIATION;
sprintf(options.OptionData.Invitation.LocalIP, "%08x,", (unsigned long) LocalChatConnectionAddress.Get_Address());
sprintf(options.OptionData.Invitation.LocalPort, "%04x,", The_Game()->Get_Port());
sprintf(options.OptionData.Invitation.ExternalIP, "%08x,", (unsigned long) ExternalAddress.Get_Address());
sprintf(options.OptionData.Invitation.FirewallType, "%08x,", Get_Raw_Firewall_Behavior());
sprintf(options.OptionData.Invitation.Queued, "%04x", ClientQueue.Count());
/*
** Send it.
*/
WOLNATInterface.Send_Private_Game_Options(user, (char*)&options);
}
/***********************************************************************************************
* FirewallHelperClass::Process_Game_Options -- Process private game options packets *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/9/2001 10:01PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Process_Game_Options(void)
{
/*
** Locals.
*/
WOL::User user;
char options_buffer[OPTIONS_STAGING_BUFFER_SIZE];
unsigned long addr_ip = 0;
unsigned short addr_port = 0;
unsigned long firewall = 0;
ThreadLockClass locker(this);
/*
** See if there are any pending game options packets.
*/
if (WOLNATInterface.Get_Private_Game_Options(&user, options_buffer, OPTIONS_STAGING_BUFFER_SIZE)) {
/*
** Cast the options buffer to a more manageable type.
*/
WOLNATInterfaceClass::PrivateGameOptionsStruct *options = (WOLNATInterfaceClass::PrivateGameOptionsStruct*) options_buffer;
/*
** Get the option type.
*/
switch (options->Option) {
/*
** This option represents a game server inviting us to negotiate a connection through firewalls. It will contain his
** local IP and port. This is a client side message only.
*/
case WOLNATInterfaceClass::OPTION_INVITE_PORT_NEGOTIATION:
WWDEBUG_SAY(("FirewallHelper - Got OPTION_INVITE_PORT_NEGOTIATION\n"));
fw_assert(!WOLNATInterface.Am_I_Server());
if (!WOLNATInterface.Am_I_Server()) {
/*
** Pull out the players info from the packet.
*/
sscanf(options->OptionData.Invitation.LocalIP, "%08x", &addr_ip);
sscanf(options->OptionData.Invitation.LocalPort, "%04hx", &addr_port);
PlayersLocalAddress.Set_Address(addr_ip, addr_port);
sscanf(options->OptionData.Invitation.ExternalIP, "%08x", &addr_ip);
PlayersExternalAddress.Set_Address(addr_ip, addr_port);
sscanf(options->OptionData.Invitation.FirewallType, "%08x", (unsigned long*)(&PlayersFirewallType));
sscanf(options->OptionData.Invitation.Queued, "%04x", &QueuedPlayers);
strcpy(PlayersName, (char*)user.name);
PlayerAsUser = user;
if (QueueNotifyPtr) {
*QueueNotifyPtr = QueuedPlayers;
}
WWDEBUG_SAY(("FirewallHelper - Received port negotiation invitation. %d players in the queue ahead of me\n", QueuedPlayers));
WWDEBUG_SAY(("FirewallHelper - Server is %s. Local addr = %s, ", PlayersName, PlayersLocalAddress.As_String()));
WWDEBUG_SAY(("external addr = %s, firewall = %08x\n", PlayersExternalAddress.As_String(), (unsigned long) PlayersFirewallType));
/*
** Wait for queue notification.
*/
if (QueuedPlayers == 0) {
QueuedPlayers = -1;
}
/*
** Respond to the server with my info.
*/
ClientPort = WOLNATInterface.Get_Next_Client_Port();
WOLNATInterfaceClass::PrivateGameOptionsStruct send_options;
strcpy(send_options.NATOptionsPrefix, "NAT:");
send_options.Option = WOLNATInterfaceClass::OPTION_ACCEPT_PORT_NEGOTIATION_INVITATION;
sprintf(send_options.OptionData.Accept.LocalIP, "%08x,", (unsigned long) LocalChatConnectionAddress.Get_Address());
sprintf(send_options.OptionData.Accept.LocalPort, "%04x,", ClientPort);
sprintf(send_options.OptionData.Accept.ExternalIP, "%08x,", (unsigned long) ExternalAddress.Get_Address());
sprintf(send_options.OptionData.Accept.FirewallType, "%08x", Get_Raw_Firewall_Behavior());
/*
** Send it.
*/
WOLNATInterface.Send_Private_Game_Options(&user, (char*)&send_options);
/*
** Go into connect mode.
** Don't do this until we get a confirmation of our queue position.
*/
Add_Thread_Action(THREAD_CONNECT_FIREWALL, INVALID_HANDLE_VALUE);
}
break;
/*
** This option represents a game client accepting our invitation to negotiate a connection through firewalls. It
** will contain his local IP and port. This is a server side message only.
*/
case WOLNATInterfaceClass::OPTION_ACCEPT_PORT_NEGOTIATION_INVITATION:
WWDEBUG_SAY(("FirewallHelper - Got OPTION_ACCEPT_PORT_NEGOTIATION_INVITATION\n"));
fw_assert(WOLNATInterface.Am_I_Server());
if (WOLNATInterface.Am_I_Server()) {
/*
** Pull out the players info from the packet.
*/
unsigned long ext_ip = 0;
sscanf(options->OptionData.Accept.LocalIP, "%08x", &addr_ip);
sscanf(options->OptionData.Accept.LocalPort, "%04hx", &addr_port);
sscanf(options->OptionData.Accept.ExternalIP, "%08x", &ext_ip);
sscanf(options->OptionData.Accept.FirewallType, "%08x", &firewall);
/*
** Create a queue entry for the player.
*/
ClientStruct *client = new ClientStruct;
strcpy(client->Name, (char*)user.name);
client->LocalAddress.Set_Address(addr_ip, addr_port);
client->ExternalAddress.Set_Address(ext_ip, addr_port);
client->FirewallType = (FirewallBehaviorType) firewall;
client->User = user;
/*
** Make sure this client isn't in the client list already (Should never happen but...)
*/
if (Remove_Player_From_Negotiation_Queue(client->Name)) {
WWDEBUG_SAY(("FirewallHelper OPTION_ACCEPT_PORT_NEGOTIATION_INVITATION - Removed %s from ClientQueue\n", client->Name));
}
/*
** Add this player to the negotiation queue.
*/
ClientQueue.Add(client);
WWDEBUG_SAY(("FirewallHelper - Got client accept from %s. Local addr = %s,", client->Name, client->LocalAddress.As_String()));
WWDEBUG_SAY((" external addr = %s, firewall = %08x\n", client->ExternalAddress.As_String(), (unsigned long) firewall));
Add_Thread_Action(THREAD_CONNECT_FIREWALL, INVALID_HANDLE_VALUE);
}
break;
/*
** Handle connection result message.
**
*/
case WOLNATInterfaceClass::OPTION_CONNECTION_RESULT:
{
int result = options->OptionData.ConnectionResult.Result[0] - 'a';
WWDEBUG_SAY(("FirewallHelper - Got OPTION_CONNECTION_RESULT %d from %s\n", result, options->OptionData.ConnectionResult.Name));
if (stricmp(PlayersName, options->OptionData.ConnectionResult.Name) == 0) {
PlayersConnectionResult = result;
unsigned long port;
sscanf(options->OptionData.ConnectionResult.Port, "%04x", &port);
PlayersConnectionResultPort = (unsigned short) port;
if (WOLNATInterface.Am_I_Server()) {
LastOptionsFromClient = TIMEGETTIME();
}
}
break;
}
/*
** Other player is telling us what port to use when talking to him.
*/
case WOLNATInterfaceClass::OPTION_PORT_NOTIFICATION:
{
WWDEBUG_SAY(("FirewallHelper - Got OPTION_PORT_NOTIFICATION from %s\n", options->OptionData.Port.Name));
unsigned long port;
sscanf(options->OptionData.Port.MangledPort, "%04x", &port);
WWDEBUG_SAY(("FirewallHelper - Port is %d\n", port));
//fw_assert(port >= 1024 && port < 65536);
//if (port >= 1024 && port < 65536) {
if (stricmp(PlayersName, options->OptionData.Port.Name) == 0) {
PlayersMangledPort = (unsigned short) port;
if (WOLNATInterface.Am_I_Server()) {
LastOptionsFromClient = TIMEGETTIME();
}
}
//}
break;
}
/*
** Server is telling us how close to the front of the queue we are.
*/
case WOLNATInterfaceClass::OPTION_QUEUE_STATE:
{
WWDEBUG_SAY(("FirewallHelper - Got OPTION_QUEUE_STATE\n"));
int queue;
sscanf(options->OptionData.QueueState.Position, "%02x", &queue);
WWDEBUG_SAY(("FirewallHelper - Queue position is %d\n", queue));
QueuedPlayers = queue;
if (QueueNotifyPtr) {
*QueueNotifyPtr = queue;
}
//if (QueuedPlayers == 0) {
// if (ThreadState != THREAD_DETECT_FIREWALL) {
// Add_Thread_Action(THREAD_CONNECT_FIREWALL, INVALID_HANDLE_VALUE);
// }
//}
break;
}
/*
** Client has cancelled out of the game channel.
*/
case WOLNATInterfaceClass::OPTION_ABORT_NEGOTIATION:
WWDEBUG_SAY(("FirewallHelper - Got OPTION_ABORT_NEGOTIATION from %s\n", (char*)user.name));
{
ThreadLockClass locker(this);
if (WOLNATInterface.Am_I_Server()) {
if (stricmp((char*)user.name, PlayersName) == 0) {
strcpy(CancelPlayer, (char*)user.name);
}
}
/*
** Remove this player from the client queue if he is in there.
*/
if (Remove_Player_From_Negotiation_Queue((char*)user.name)) {
WWDEBUG_SAY(("FirewallHelper OPTION_ABORT_NEGOTIATION - Removed %s from ClientQueue\n", (char*)user.name));
}
break;
}
/*
** Client has joined a channel and is available for negotiation.
*/
case WOLNATInterfaceClass::OPTION_CLIENT_IN_CHANNEL:
WWDEBUG_SAY(("FirewallHelper - Got OPTION_CLIENT_IN_CHANNEL from %s\n", (char*)user.name));
if (WOLNATInterface.Am_I_Server()) {
Talk_To_New_Player(&user);
}
break;
default:
fw_assert(false);
break;
}
}
}
/***********************************************************************************************
* FirewallHelperClass::Cleanup_Client_Queue -- Remove pending entries from client queue *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: ONLY CALL THIS FROM THE MAIN THREAD *
* *
* HISTORY: *
* 3/22/2002 4:09PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Cleanup_Client_Queue(void)
{
/*
** This is the main thread removing entries from the client queue that it wasn't able to remove before due to thread
** contention.
*/
fw_assert(Get_Main_Thread_ID() == GetCurrentThreadId());
while (ClientQueueRemoveList.Count()) {
if (Remove_Player_From_Negotiation_Queue_If_Mutex_Available(ClientQueueRemoveList[0]->Name)) {
delete ClientQueueRemoveList[0];
ClientQueueRemoveList.Delete(0);
} else {
break;
}
}
}
/***********************************************************************************************
* FirewallHelperClass::Remove_Player_From_Negotiation_Queue_If_Mutex_Available - What it says *
* *
* *
* *
* *
* INPUT: Player name *
* *
* OUTPUT: True if mutex was available *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/22/2002 3:41PM ST : Created *
*=============================================================================================*/
bool FirewallHelperClass::Remove_Player_From_Negotiation_Queue_If_Mutex_Available(char *player_name)
{
ThreadLockClass locker(this, 0);
/*
** If we can grab the mutex then remove the item immediately, otherwise add it to a list and return.
*/
if (locker.WaitResult == WAIT_OBJECT_0) {
Remove_Player_From_Negotiation_Queue(player_name);
return(true);
} else {
/*
** Just add the name to a list that will be checked later when it's safe to remove stuff from the client queue.
** This list must only ever be accessed from the main thread.
*/
fw_assert(Get_Main_Thread_ID() == GetCurrentThreadId());
for (int i=0 ; i<ClientQueueRemoveList.Count() ; i++) {
if (stricmp(ClientQueueRemoveList[i]->Name, player_name) == 0) {
return(false);
}
}
ClientStruct *clientptr = new ClientStruct;
strcpy(clientptr->Name, player_name);
ClientQueueRemoveList.Add(clientptr);
}
return(false);
}
/***********************************************************************************************
* FirewallHelperClass::Remove_Player_From_Negotiation_Queue - What it says *
* *
* *
* *
* INPUT: Player name *
* *
* OUTPUT: True if player was in queue *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 3/3/2002 10:20PM ST : Created *
*=============================================================================================*/
bool FirewallHelperClass::Remove_Player_From_Negotiation_Queue(char *player_name)
{
fw_assert(WOLNATInterface.Am_I_Server());
if (ClientQueue.Count() == 0) {
return(false);
}
ThreadLockClass locker(this);
ClientStruct *clientptr = NULL;
bool retcode = false;
for (int i=0 ; i<ClientQueue.Count() ; i++) {
clientptr = ClientQueue[i];
if (stricmp(clientptr->Name, player_name) == 0) {
WWDEBUG_SAY(("FirewallHelper - Removed %s from ClientQueue\n", clientptr->Name));
delete clientptr;
ClientQueue.Delete(i);
i--;
retcode = true;
}
}
return(retcode);
}
/***********************************************************************************************
* FirewallHelperClass::Send_My_Port -- Send my mangled port number to the other guy *
* *
* *
* *
* INPUT: Port *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/13/2001 11:37AM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Send_My_Port(unsigned short port)
{
ThreadLockClass locker(this);
WWDEBUG_SAY(("FirewallHelper - Sending my port number (%d) to %s\n", (unsigned int)port, PlayersName));
/*
** Fill in an port notification options packet to send to the guest.
*/
WOLNATInterfaceClass::PrivateGameOptionsStruct options;
strcpy(options.NATOptionsPrefix, "NAT:");
options.Option = WOLNATInterfaceClass::OPTION_PORT_NOTIFICATION;
sprintf(options.OptionData.Port.MangledPort, "%04x,", port);
char my_name[64];
WOLNATInterface.Get_My_Name(my_name);
strcpy(options.OptionData.Port.Name, my_name);
/*
** Send it.
*/
WOLNATInterface.Send_Private_Game_Options(&PlayerAsUser, (char*)&options);
}
/***********************************************************************************************
* FirewallHelperClass::Send_Connection_Result -- Send connection result game option *
* *
* *
* *
* INPUT: Result enum *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/13/2001 2:17PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Send_Connection_Result(int result, unsigned short port)
{
ThreadLockClass locker(this);
/*
** Fill in a connection result options packet to send to the other player.
*/
WOLNATInterfaceClass::PrivateGameOptionsStruct options;
strcpy(options.NATOptionsPrefix, "NAT:");
options.Option = WOLNATInterfaceClass::OPTION_CONNECTION_RESULT;
options.OptionData.ConnectionResult.Result[0] = 'a' + result;
options.OptionData.ConnectionResult.Result[1] = ',';
sprintf(options.OptionData.ConnectionResult.Port, "%04x,", (unsigned long) port);
char my_name[64];
WOLNATInterface.Get_My_Name(my_name);
strcpy(options.OptionData.ConnectionResult.Name, my_name);
/*
** Send it.
*/
WOLNATInterface.Send_Private_Game_Options(&PlayerAsUser, (char*)&options);
}
/***********************************************************************************************
* FirewallHelperClass::Send_Connection_Result -- Send connection result game option *
* *
* *
* *
* INPUT: Result enum *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/13/2001 2:17PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Send_Queue_States(void)
{
if (WOLNATInterface.Am_I_Server()) {
if (ClientQueue.Count()) {
ThreadLockClass locker(this);
/*
** Fill in a queue state options packet to send to the other players.
*/
WOLNATInterfaceClass::PrivateGameOptionsStruct options;
strcpy(options.NATOptionsPrefix, "NAT:");
options.Option = WOLNATInterfaceClass::OPTION_QUEUE_STATE;
char my_name[64];
WOLNATInterface.Get_My_Name(my_name);
strcpy(options.OptionData.ConnectionResult.Name, my_name);
/*
** Send updates to all queued players.
*/
for (int i=0 ; i<ClientQueue.Count() ; i++) {
sprintf(options.OptionData.QueueState.Position, "%02x", i);
ClientStruct *client = ClientQueue[i];
fw_assert(client != NULL);
if (client) {
/*
** Send it.
*/
WOLNATInterface.Send_Private_Game_Options(&client->User, (char*)&options);
}
}
}
}
}
/***********************************************************************************************
* FirewallHelperClass::Set_Client_Connect_Event -- Set client event completion info *
* *
* *
* *
* INPUT: Event *
* Ptr to success flag *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/14/2001 10:56PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Set_Client_Connect_Event(HANDLE thread_event, HANDLE cancel_event, int *flag_ptr, int *queue_ptr)
{
ThreadLockClass locker(this);
fw_assert(!WOLNATInterface.Am_I_Server());
if (!WOLNATInterface.Am_I_Server()) {
SuccessFlagPtr = flag_ptr;
ClientConnectEvent = thread_event;
ClientCancelEvent = cancel_event;
QueueNotifyPtr = queue_ptr;
}
}
/***********************************************************************************************
* FirewallHelperClass::Set_Client_Success -- Set the client connect return status *
* *
* *
* *
* INPUT: Success - Did the client get a good port and IP for the server *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/14/2001 10:59PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Set_Client_Success(int success)
{
if (!WOLNATInterface.Am_I_Server()) {
if (SuccessFlagPtr) {
*SuccessFlagPtr = success;
}
SuccessFlagPtr = NULL;
if (QueueNotifyPtr) {
*QueueNotifyPtr = 0;
}
QueueNotifyPtr = NULL;
if (ClientConnectEvent != INVALID_HANDLE_VALUE) {
SetEvent(ClientConnectEvent);
}
ClientConnectEvent = INVALID_HANDLE_VALUE;
ClientCancelEvent = INVALID_HANDLE_VALUE;
}
}
/***********************************************************************************************
* FirewallHelperClass::Client_Cancelled -- Checks to see if the player hit cancel. *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: True if player cancelled *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/17/2001 12:04PM ST : Created *
*=============================================================================================*/
bool FirewallHelperClass::Client_Cancelled(void)
{
if (!WOLNATInterface.Am_I_Server()) {
ThreadLockClass locker(this);
if (ClientCancelEvent != INVALID_HANDLE_VALUE) {
int result = WaitForSingleObject(ClientCancelEvent, 0);
if (result == WAIT_OBJECT_0) {
WWDEBUG_SAY(("FirewallHelper - Client cancelled\n"));
return(true);
}
}
}
return(false);
}
/***********************************************************************************************
* FirewallHelperClass::Remote_Client_Cancelled -- Did the remote client hit cancel? *
* *
* *
* *
* INPUT: True if our client cancelled *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: Requres PlayersName variable to be correctly set up *
* Will only return true once for each cancellation *
* *
* HISTORY: *
* 8/19/2001 9:26PM ST : Created *
*=============================================================================================*/
bool FirewallHelperClass::Remote_Client_Cancelled(void)
{
ThreadLockClass locker(this);
if (WOLNATInterface.Am_I_Server() && CancelPlayer[0] != 0) {
if (stricmp(CancelPlayer, PlayersName) == 0) {
CancelPlayer[0] = 0;
return(true);
}
}
return(false);
}
/***********************************************************************************************
* FirewallHelperClass::Send_Cancel_Notification -- Send abort to host *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Nothing *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/19/2001 9:32PM ST : Created *
*=============================================================================================*/
void FirewallHelperClass::Send_Cancel_Notification(void)
{
fw_assert(!WOLNATInterface.Am_I_Server());
if (!WOLNATInterface.Am_I_Server()) {
ThreadLockClass locker(this);
WWDEBUG_SAY(("FirewallHelper - Sending my cancellation notice to the server\n"));
/*
** Fill in an abort notification options packet to send to the host.
*/
WOLNATInterfaceClass::PrivateGameOptionsStruct options;
strcpy(options.NATOptionsPrefix, "NAT:");
options.Option = WOLNATInterfaceClass::OPTION_ABORT_NEGOTIATION;
options.OptionData.QuitTalking.Nothing = 0;
/*
** Send it.
*/
WOLNATInterface.Send_Private_Game_Options(&PlayerAsUser, (char*)&options);
}
}
/***********************************************************************************************
* FirewallHelperClass::Negotiate_Port -- Option communications with one other player *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: True if we heard from the other player directly *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 8/7/2001 8:54PM ST : Created *
*=============================================================================================*/
int FirewallHelperClass::Negotiate_Port(void)
{
int retries = 5;
unsigned long timeout;
unsigned long resend_timer;
bool mangling = true;
bool sharing_a_nat = false;
int result;
IPAddressClass address;
bool gotit = false;
SocketHandlerClass *socket = NULL;
char receive_packet[512];
char my_name[256];
my_name[0] = 0;
bool server = WOLNATInterface.Am_I_Server();
bool got_name = WOLNATInterface.Get_My_Name(my_name);
fw_assert(got_name);
if (!got_name) {
WWDEBUG_SAY(("FirewallHelper - Failed to get user log on name\n"));
return(FW_RESULT_FAILED);
}
PlayersMangledPort = 0;
PlayersConnectionResult = -1;
PlayersConnectionResultPort = 0;
/*
** On the server side, we need to find out who we are supposed to be connecting to.
** We will use the game comms to send and receive on the server side since we already have a socket bound to the port
** we want to use.
*/
if (server) {
if (ClientQueue.Count() == 0) {
return(FW_RESULT_FAILED);
}
/*
** Update everyones queue state.
*/
Send_Queue_States();
ClientStruct *client = ClientQueue[0];
PlayersLocalAddress = client->LocalAddress;
PlayersExternalAddress = client->ExternalAddress;
PlayersFirewallType = client->FirewallType;
PlayerAsUser = client->User;
strcpy(PlayersName, client->Name);
LastOptionsFromClient = TIMEGETTIME();
delete client;
ClientQueue.Delete(0);
WWDEBUG_SAY(("FirewallHelper - Removed next player %s from client queue\n", PlayersName));
if (Remote_Client_Cancelled()) {
return(FW_RESULT_FAILED);
}
CancelPlayer[0] = 0;
} else {
/*
** On the client side, we need to open a new socket using the client side port number. Use any port number for the
** second parameter since it's the default send port and will always be overridden when we send anyway.
*/
socket = new SocketHandlerClass;
socket->Service_Never();
if (!socket->Open(ClientPort, PlayersLocalAddress.Get_Port())) {
WWDEBUG_SAY(("FirewallHelperClass: Failed to open socket for client\n"));
fw_assert(false);
delete socket;
return(FW_RESULT_FAILED);
}
WOLNATInterface.Set_Service_Socket_Handler(socket);
/*
** If we aren't sure of the queue size then wait until we are.
*/
if (QueuedPlayers == -1) {
timeout = TIMEGETTIME() + (8 * TIMER_SECOND);
while (TIMEGETTIME() < timeout && QueuedPlayers == -1) {
Process_Game_Options();
Sleep(5);
/*
** See if the user cancelled.
*/
if (Client_Cancelled()) {
Send_Cancel_Notification();
WOLNATInterface.Set_Service_Socket_Handler(NULL);
delete socket;
return(FW_RESULT_CANCELLED);
}
}
}
if (QueuedPlayers == -1) {
/*
** This should never happen right....?
*/
if (socket) {
WOLNATInterface.Set_Service_Socket_Handler(NULL);
delete socket;
}
return(FW_RESULT_FAILED);
}
/*
** If there are players queued ahead of us, wait til we get to the front of the queue.
*/
timeout = TIMEGETTIME() + (QueuedPlayers * 32 * TIMER_SECOND);
while (TIMEGETTIME() < timeout && QueuedPlayers != 0) {
Process_Game_Options();
Sleep(5);
/*
** See if the user cancelled.
*/
if (Client_Cancelled()) {
Send_Cancel_Notification();
WOLNATInterface.Set_Service_Socket_Handler(NULL);
delete socket;
return(FW_RESULT_CANCELLED);
}
}
}
PlayersFirewallAddress = PlayersExternalAddress;
PlayersFirewallAddress.Set_Port(PlayersLocalAddress.Get_Port());
WWDEBUG_SAY(("FirewallHelper - Negotiating port with player %s, local address = %s,", PlayersName, PlayersLocalAddress.As_String()));
WWDEBUG_SAY((" ext address = %s, firewall = %08x\n", PlayersExternalAddress.As_String(), PlayersFirewallType));
/*
** What will our mangled port be if we try to talk to this player?
**
** If they are behind the same firewall then there will be no mangling.
**
*/
if (PlayersExternalAddress.Is_IP_Equal(ExternalAddress)) {
mangling = false;
sharing_a_nat = true;
PlayersFirewallAddress = PlayersLocalAddress;
WWDEBUG_SAY(("Both external IPs match - we are behind the same firewall\n"));
}
/*
** Maybe neither of our firewalls use port mangling. If so, then we can use the default port number.
*/
if (mangling) {
if (Behavior == 0 || (Behavior & FIREWALL_TYPE_SIMPLE) != 0) {
if (PlayersFirewallType == 0 || (PlayersFirewallType & FIREWALL_TYPE_SIMPLE) != 0) {
/*
** Ok, we both have crap firewalls or modems or somesuch. Anyway, this should be easy.
*/
mangling = false;
}
}
}
int trying = 0;
unsigned short last_send_port = 0;
unsigned short my_last_mangled_port = 0;
unsigned short verified_mangled_port = 0;
bool used_old_port = false;
do {
Sleep(0);
/*
** See if the user cancelled.
*/
if (Client_Cancelled()) {
Send_Cancel_Notification();
WOLNATInterface.Set_Service_Socket_Handler(NULL);
delete socket;
return(FW_RESULT_CANCELLED);
}
if (Remote_Client_Cancelled()) {
return(FW_RESULT_FAILED);
}
/*
** If we haven't got any kind of options at all from the client for 10 seconds then give up.
*/
if (trying > 0 && server && (TIMEGETTIME() - LastOptionsFromClient > TIMER_SECOND * 10)) {
break;
}
if (!mangling) {
/*
** Use their unmangled port number. Nothing fancy needed here.
*/
PlayersMangledPort = PlayersLocalAddress.Get_Port();
} else {
unsigned short mangled_port = 0;
/*
** If our firewall uses the same source port regardless of destination port and we have
** already connected to someone at this address (two players behind the same NAT) then
** we have to try the same source port we are already talking to the other guy on.
**
** If that's not working out then try a different port after two attempts.
*/
if (server && trying < 2) {
if ((Behavior & FirewallHelperClass::FIREWALL_TYPE_DESTINATION_PORT_DELTA) == 0) {
WWDEBUG_SAY(("FirewallHelper: No destination port delta - looking for earlier connections at the same address\n"));
for (int r = 0 ; r < ConnectionHistory.Count() ; r++) {
if (ConnectionHistory[r].Is_IP_Equal(PlayersExternalAddress)) {
mangled_port = MangledPortHistory[r];
used_old_port = true;
WWDEBUG_SAY(("FirewallHelper - Found old connection port number to use - port number %d\n", mangled_port));
break;
}
}
}
}
/*
** If this isn't the first try then we might already know what the port will be since it can't change between tries.
*/
if (mangled_port == 0) {
if ((Behavior & FirewallHelperClass::FIREWALL_TYPE_DESTINATION_PORT_DELTA) == 0) {
if (trying > 0) {
if (!used_old_port) {
mangled_port = my_last_mangled_port;
WWDEBUG_SAY(("FirewallHelper - No dest port delta - using last port number %d\n", mangled_port));
} else {
used_old_port = false;
}
}
}
}
if (mangled_port == 0) {
/*
** Work out what my port will be.
*/
unsigned short base_port = 0;
if (server) {
base_port = WOLNATInterface.Get_Port_As_Server();
} else {
/*
** Client only. Roll onto the next port and try that.
*/
if (trying > 0) {
WOLNATInterface.Set_Service_Socket_Handler(NULL);
Sleep(100);
socket->Close();
for (int cp=0 ; cp < 2048 ; cp++) {
ClientPort = WOLNATInterface.Get_Next_Client_Port();
if (socket->Open(ClientPort, PlayersLocalAddress.Get_Port())) {
break;
} else {
socket->Close();
ClientPort = 0;
}
}
fw_assert(ClientPort != 0);
WOLNATInterface.Set_Service_Socket_Handler(socket);
}
if (ClientPort != 0) {
base_port = ClientPort;
}
}
/*
** Get my mangled port. This can take up to 4 seconds.
*/
mangled_port = FirewallHelper.Get_Next_Mangled_Source_Port(base_port);
}
/*
** Send my mangled port to the other chap.
*/
fw_assert(mangled_port != 0);
Send_My_Port(mangled_port);
my_last_mangled_port = mangled_port;
}
/*
** Wait until we know what port to send to. Allow plenty of time for slow chat server response.
** Players are more likely to be in 'sync' with each other after the first try.
*/
timeout = TIMEGETTIME() + (6 * TIMER_SECOND);
if (trying > 0) {
timeout = timeout - (3*TIMER_SECOND);
}
while (TIMEGETTIME() < timeout && ((mangling == true && PlayersMangledPort == last_send_port) || (mangling == false && PlayersMangledPort == 0))) {
Process_Game_Options();
Sleep(5);
/*
** See if the user cancelled.
*/
if (Client_Cancelled()) {
Send_Cancel_Notification();
WOLNATInterface.Set_Service_Socket_Handler(NULL);
delete socket;
return(FW_RESULT_CANCELLED);
}
if (Remote_Client_Cancelled()) {
return(FW_RESULT_FAILED);
}
}
if (verified_mangled_port != 0) {
PlayersMangledPort = verified_mangled_port;
}
last_send_port = PlayersMangledPort;
PlayersFirewallAddress.Set_Port(PlayersMangledPort);
if (PlayersMangledPort == 0) {
WWDEBUG_SAY(("FirewallHelper: PlayersMangledPort = 0 - skipping packet send\n"));
}
if (PlayersMangledPort != 0) {
/*
** OK, we know what port to send to. Let dooooo it.
*/
/*
** Build the port probe packet to send.
*/
char packet[256];
strcpy(packet, my_name);
/*
** If we are a netgear and talking to a non netgear then pause before sending.
**
** This is needed when playing a netgear against a linksys. If the netgear sends first
** then the linksys can respond with a ICMP port unreachable message in the case that
** it already has an open port table mapping with a pre-existing player.
**
** When it gets an ICMP port unreachable, the netgear invalidates any existing port mappings.
**
** The delay has to be long enough for our port number to be passed through the chat server
** to the other guy and for him to start sending.
*/
if (Is_Netgear() && !Is_Netgear(PlayersFirewallType)) {
WWDEBUG_SAY(("FirewallHelper: Doing the netgear sleep thing\n"));
Sleep(TIMER_SECOND * 4);
}
/*
** Send the packet to the other player. If a NAT mangles an outgoing port number then it will be noted
** as the packet comes in.
*/
WWDEBUG_SAY(("FirewallHelper: Sending PACKETTYPE_FIREWALL_PROBE packet to %s at port %d\n", PlayersName, PlayersMangledPort));
timeout = TIMEGETTIME() + (TIMER_SECOND * 6);
resend_timer = 0;
do {
if (resend_timer < TIMEGETTIME()) {
//if (!CrapFlag)
WOLNATInterface.Send_Game_Format_Packet_To(&PlayersFirewallAddress, packet, strlen(packet)+1, socket);
resend_timer = TIMEGETTIME() + (TIMER_SECOND / 2);
}
Sleep(5);
Process_Game_Options();
/*
** See if the user cancelled.
*/
if (Client_Cancelled()) {
Send_Cancel_Notification();
WOLNATInterface.Set_Service_Socket_Handler(NULL);
delete socket;
return(FW_RESULT_CANCELLED);
}
if (Remote_Client_Cancelled()) {
return(FW_RESULT_FAILED);
}
//if (!gotit) {
/*
** See if a port probe came in from this player.
*/
IPAddressClass receive_address;
result = WOLNATInterface.Get_Packet(receive_packet, sizeof(receive_packet), receive_address);
/*
** Check if we got a packet from this game.
*/
if (result) {
WWDEBUG_SAY(("FirewallHelper: Got a packet from player %s at address %s\n", receive_packet, receive_address.As_String()));
/*
** Is it from the guy we are trying to talk to?
*/
if (stricmp(receive_packet, PlayersName) == 0) {
WWDEBUG_SAY(("FirewallHelper: Packet is from other guy\n"));
/*
** Send a connection result game option.
*/
Send_Connection_Result(CONNRESULT_CONNECTED, receive_address.Get_Port());
/*
** Note the address the packet came in on.
*/
PlayersFirewallAddress = receive_address;
verified_mangled_port = receive_address.Get_Port();
/*
** Got it.
*/
gotit = true;
}
}
//}
/*
** If the other player got our packet and we got theirs then we are finished.
*/
if (gotit && PlayersConnectionResult == CONNRESULT_CONNECTED) {
WWDEBUG_SAY(("FirewallHelper: Got connection result - my packet must have got through\n"));
break;
}
/*
** If the other guy has started re-trying then we might as well do that too.
*/
if (PlayersConnectionResult >= CONNRESULT_TRY1 && PlayersConnectionResult < CONNRESULT_CONNECTED) {
int their_try = PlayersConnectionResult - CONNRESULT_TRY1;
if (their_try > trying) {
WWDEBUG_SAY(("FirewallHelper: Other player is trying again - their_try = %d\n", their_try));
trying = their_try - 1;
break;
}
}
} while(TIMEGETTIME() < timeout);
}
if (gotit && PlayersConnectionResult == CONNRESULT_CONNECTED) {
break;
}
if (trying >= retries) {
break;
}
/*
** Well, that didn't go too well, let's try again.
*/
trying++;
Send_Connection_Result(CONNRESULT_TRY1 + trying, 0);
WWDEBUG_SAY(("FirewallHelper: Trying again - trying = %d\n", trying));
} while(true);
if (socket) {
WOLNATInterface.Set_Service_Socket_Handler(NULL);
delete socket;
}
if (gotit && PlayersConnectionResult == CONNRESULT_CONNECTED) {
WWDEBUG_SAY(("FirewallHelper: Port negotiation successful! Correct address is %s\n", PlayersFirewallAddress.As_String()));
WWDEBUG_SAY(("Player saw our port as %d\n", (unsigned long)PlayersConnectionResultPort));
/*
** Well it worked so we have more confidence in our firewall settings.
*/
Confidence++;
/*
** Save the port number in case we have to connect to this guy again.
*/
if (server) {
unsigned short history_port = PlayersConnectionResultPort;
if (history_port == 0) {
history_port = my_last_mangled_port;
}
bool found_history = false;
for (int h=0 ; h<ConnectionHistory.Count() ; h++) {
if (ConnectionHistory[h].Is_IP_Equal(PlayersExternalAddress)) {
MangledPortHistory[h] = history_port;
found_history = true;
break;
}
}
if (!found_history) {
ConnectionHistory.Add(PlayersExternalAddress);
MangledPortHistory.Add(history_port);
}
fw_assert(ConnectionHistory.Count() == MangledPortHistory.Count());
}
return(FW_RESULT_SUCCEEDED);
} else {
WWDEBUG_SAY(("FirewallHelper: *** Port negotiation failed! ***\n"));
Confidence--;
if (Confidence < 0) {
Confidence = 0;
}
}
return(FW_RESULT_FAILED);
}
/*
** Function definitions for the MIB-II entry points.
*/
BOOL (__stdcall *SnmpExtensionInitPtr)(IN DWORD dwUpTimeReference, OUT HANDLE *phSubagentTrapEvent, OUT AsnObjectIdentifier *pFirstSupportedRegion);
BOOL (__stdcall *SnmpExtensionQueryPtr)(IN BYTE bPduType, IN OUT RFC1157VarBindList *pVarBindList, OUT AsnInteger32 *pErrorStatus, OUT AsnInteger32 *pErrorIndex);
LPVOID (__stdcall *SnmpUtilMemAllocPtr)(IN DWORD bytes);
VOID (__stdcall *SnmpUtilMemFreePtr)(IN LPVOID pMem);
typedef struct tConnInfoStruct {
unsigned int State;
unsigned long LocalIP;
unsigned short LocalPort;
unsigned long RemoteIP;
unsigned short RemotePort;
} ConnInfoStruct;
/***********************************************************************************************
* Get_Local_Chat_Connection_Address -- Which address are we using to talk to the chat server? *
* *
* *
* *
* INPUT: Ptr to address to return local address * *
* *
* OUTPUT: True if success *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 10/27/00 3:24PM ST : Created *
*=============================================================================================*/
bool FirewallHelperClass::Get_Local_Chat_Connection_Address(void)
{
/*
** Local defines.
*/
enum {
CLOSED = 1,
LISTENING,
SYN_SENT,
SEN_RECEIVED,
ESTABLISHED,
FIN_WAIT,
FIN_WAIT2,
CLOSE_WAIT,
LAST_ACK,
CLOSING,
TIME_WAIT,
DELETE_TCB
};
enum {
tcpConnState = 1,
tcpConnLocalAddress,
tcpConnLocalPort,
tcpConnRemAddress,
tcpConnRemPort
};
/*
** Locals.
*/
char server_name[128];
unsigned char server_address[4];
unsigned char remote_address[4];
HANDLE trap_handle;
AsnObjectIdentifier first_supported_region;
DynamicVectorClass<ConnInfoStruct*> connection_list;
int last_field;
int index;
AsnInteger error_status;
AsnInteger error_index;
int conn_entry_type_index;
int conn_entry_type;
bool found;
unsigned int server_port = 0;
IPAddressClass my_address;
/*
** Statics.
*/
static char _conn_state[][32] = {
"?",
"CLOSED",
"LISTENING",
"SYN_SENT",
"SEN_RECEIVED",
"ESTABLISHED",
"FIN_WAIT",
"FIN_WAIT2",
"CLOSE_WAIT",
"LAST_ACK",
"CLOSING",
"TIME_WAIT",
"DELETE_TCB"
};
/*
** If we already did this then there's no need to do it again.
*/
if (LocalChatConnectionAddress.Is_Valid()) {
return(true);
}
WWDEBUG_SAY(("FirewallHelper - Finding local address used to talk to the chat server\n"));
/*
** Get the name of the current server.
*/
WOLNATInterface.Get_Current_Server_ConnData(server_name, sizeof(server_name));
if (strlen(server_name) == 0) {
return(false);
}
/*
** the conndata field will look something like
**
** TCP;ra2chat.westwood.com;7000
*/
fw_assert(strnicmp((char*)server_name, "TCP;", 4) == 0);
char *server_name_ptr = &server_name[4];
char *semi_colon_ptr = strchr(server_name_ptr, ';');
if (semi_colon_ptr) {
*semi_colon_ptr = 0;
sscanf(semi_colon_ptr+1, "%d", &server_port);
} else {
WWDEBUG_SAY(("FirewallHelper - Failed to parse server name\n"));
return(false);
}
WWDEBUG_SAY(("FirewallHelper - Current chat server name is %s\n", server_name_ptr));
WWDEBUG_SAY(("FirewallHelper - Chat server port is %d\n", server_port));
/*
** Get the address of the chat server.
*/
WWDEBUG_SAY(("FirewallHelper - About to call gethostbyname\n"));
struct hostent *host_info = gethostbyname(server_name_ptr);
if (!host_info) {
WWDEBUG_SAY(("FirewallHelper - gethostbyname failed! Error code %d\n", WSAGetLastError()));
return(false);
}
memcpy(server_address, &host_info->h_addr_list[0][0], 4);
unsigned long temp = *((unsigned long*)(&server_address[0]));
temp = ntohl(temp);
*((unsigned long*)(&server_address[0])) = temp;
WWDEBUG_SAY(("FirewallHelper - Host address is %d.%d.%d.%d\n", server_address[3], server_address[2], server_address[1], server_address[0]));
/*
** Load the MIB-II SNMP DLL.
*/
WWDEBUG_SAY(("FirewallHelper - About to load INETMIB1.DLL\n"));
HINSTANCE mib_ii_dll = LoadLibrary("inetmib1.dll");
if (mib_ii_dll == NULL) {
WWDEBUG_SAY(("FirewallHelper - Failed to load INETMIB1.DLL\n"));
return(false);
}
WWDEBUG_SAY(("FirewallHelper - About to load SNMPAPI.DLL\n"));
HINSTANCE snmpapi_dll = LoadLibrary("snmpapi.dll");
if (snmpapi_dll == NULL) {
WWDEBUG_SAY(("FirewallHelper - Failed to load SNMPAPI.DLL\n"));
FreeLibrary(mib_ii_dll);
return(false);
}
/*
** Get the function pointers into the .dll
*/
SnmpExtensionInitPtr = (int (__stdcall *)(unsigned long,void ** ,AsnObjectIdentifier *)) GetProcAddress(mib_ii_dll, "SnmpExtensionInit");
SnmpExtensionQueryPtr = (int (__stdcall *)(unsigned char,SnmpVarBindList *,long *,long *)) GetProcAddress(mib_ii_dll, "SnmpExtensionQuery");
SnmpUtilMemAllocPtr = (void *(__stdcall *)(unsigned long)) GetProcAddress(snmpapi_dll, "SnmpUtilMemAlloc");
SnmpUtilMemFreePtr = (void (__stdcall *)(void *)) GetProcAddress(snmpapi_dll, "SnmpUtilMemFree");
if (SnmpExtensionInitPtr == NULL || SnmpExtensionQueryPtr == NULL || SnmpUtilMemAllocPtr == NULL || SnmpUtilMemFreePtr == NULL) {
WWDEBUG_SAY(("FirewallHelper - Failed to get proc addresses for linked functions\n"));
FreeLibrary(snmpapi_dll);
FreeLibrary(mib_ii_dll);
return(false);
}
RFC1157VarBindList *bind_list_ptr = (RFC1157VarBindList *) SnmpUtilMemAllocPtr(sizeof(RFC1157VarBindList) + 8192);
RFC1157VarBind *bind_ptr = (RFC1157VarBind *) SnmpUtilMemAllocPtr(sizeof(RFC1157VarBind) + 128);
/*
** OK, here we go. Try to initialise the .dll
*/
WWDEBUG_SAY(("FirewallHelper - About to init INETMIB1.DLL\n"));
int ok = SnmpExtensionInitPtr(GetCurrentTime(), &trap_handle, &first_supported_region);
if (!ok) {
/*
** Aw crap.
*/
WWDEBUG_SAY(("FirewallHelper - Failed to init the .dll\n"));
SnmpUtilMemFreePtr(bind_list_ptr);
SnmpUtilMemFreePtr(bind_ptr);
FreeLibrary(snmpapi_dll);
FreeLibrary(mib_ii_dll);
return(false);
}
/*
** Name of mib_ii object we want to query. See RFC 1213.
**
** iso.org.dod.internet.mgmt.mib-2.tcp.tcpConnTable.TcpConnEntry.tcpConnState
** 1 3 6 1 2 1 6 13 1 1
*/
unsigned int mib_ii_name[] = {1,3,6,1,2,1,6,13,1,1};
unsigned int *mib_ii_name_ptr = (unsigned int *) SnmpUtilMemAllocPtr(sizeof(mib_ii_name) + 1024);
memcpy(mib_ii_name_ptr, mib_ii_name, sizeof(mib_ii_name));
/*
** Get the index of the conn entry data.
*/
conn_entry_type_index = ARRAY_SIZE(mib_ii_name) - 1;
/*
** Set up the bind list.
*/
bind_ptr->name.idLength = ARRAY_SIZE(mib_ii_name);
bind_ptr->name.ids = mib_ii_name_ptr;
bind_list_ptr->list = bind_ptr;
bind_list_ptr->len = 1;
/*
** We start with the tcpConnLocalAddress field.
*/
last_field = 1;
/*
** First connection.
*/
index = 0;
/*
** Suck out that tcp connection info....
*/
while (true) {
if (!SnmpExtensionQueryPtr(ASN_RFC1157_GETNEXTREQUEST, bind_list_ptr, &error_status, &error_index)) {
WWDEBUG_SAY(("FirewallHelper - SnmpExtensionQuery returned false\n"));
SnmpUtilMemFreePtr(bind_list_ptr);
SnmpUtilMemFreePtr(bind_ptr);
FreeLibrary(snmpapi_dll);
FreeLibrary(mib_ii_dll);
return(false);
}
/*
** If this is something new we aren't looking for then we are done.
*/
if (bind_ptr->name.idLength < ARRAY_SIZE(mib_ii_name)) {
break;
}
/*
** Get the type of info we are looking at. See RFC1213.
**
** 1 = tcpConnState
** 2 = tcpConnLocalAddress
** 3 = tcpConnLocalPort
** 4 = tcpConnRemAddress
** 5 = tcpConnRemPort
**
** tcpConnState is one of the following...
**
** 1 closed
** 2 listen
** 3 synSent
** 4 synReceived
** 5 established
** 6 finWait1
** 7 finWait2
** 8 closeWait
** 9 lastAck
** 10 closing
** 11 timeWait
** 12 deleteTCB
*/
conn_entry_type = bind_ptr->name.ids[conn_entry_type_index];
if (last_field != conn_entry_type) {
index = 0;
last_field = conn_entry_type;
}
switch (conn_entry_type) {
/*
** 1. First field in the entry. Need to create a new connection info struct
** here to store this connection in.
*/
case tcpConnState:
{
ConnInfoStruct *new_conn = new ConnInfoStruct;
new_conn->State = bind_ptr->value.asnValue.number;
connection_list.Add(new_conn);
break;
}
/*
** 2. Local address field.
*/
case tcpConnLocalAddress:
fw_assert(index < connection_list.Count());
connection_list[index]->LocalIP = *((unsigned long*)bind_ptr->value.asnValue.address.stream);
index++;
break;
/*
** 3. Local port field.
*/
case tcpConnLocalPort:
fw_assert(index < connection_list.Count());
connection_list[index]->LocalPort = bind_ptr->value.asnValue.number;
index++;
break;
/*
** 4. Remote address field.
*/
case tcpConnRemAddress:
fw_assert(index < connection_list.Count());
connection_list[index]->RemoteIP = *((unsigned long*)bind_ptr->value.asnValue.address.stream);
index++;
break;
/*
** 5. Remote port field.
*/
case tcpConnRemPort:
fw_assert(index < connection_list.Count());
connection_list[index]->RemotePort = bind_ptr->value.asnValue.number;
index++;
break;
}
}
SnmpUtilMemFreePtr(bind_list_ptr);
SnmpUtilMemFreePtr(bind_ptr);
//SnmpUtilMemFreePtr(mib_ii_name_ptr); // Don't free this - the SnmpExtensionQueryPtr call frees it apparently
WWDEBUG_SAY(("FirewallHelper - Got %d connections in list, parsing...\n", connection_list.Count()));
/*
** Right, we got the lot. Lets see if any of them have the same address as the chat
** server we think we are talking to.
*/
found = false;
while (connection_list.Count()) {
ConnInfoStruct *connection = connection_list[0];
temp = ntohl(connection->RemoteIP);
memcpy(remote_address, (unsigned char*)&temp, 4);
/*
** See if this connection has the same address as our server.
*/
if (!found && memcmp(remote_address, server_address, 4) == 0) {
WWDEBUG_SAY(("FirewallHelper - Found connection with same remote address as server\n"));
if (server_port == 0 || server_port == (unsigned int)connection->RemotePort) {
WWDEBUG_SAY(("FirewallHelper - Connection has same port\n"));
/*
** Make sure the connection is current.
*/
if (connection->State == ESTABLISHED) {
WWDEBUG_SAY(("FirewallHelper - Connection is ESTABLISHED\n"));
my_address.Set_Address((unsigned char*)&connection->LocalIP, connection->LocalPort);
found = true;
} else {
WWDEBUG_SAY(("FirewallHelper - Connection is not ESTABLISHED - skipping\n"));
}
} else {
WWDEBUG_SAY(("FirewallHelper - Connection has different port. Port is %d, looking for %d\n", connection->RemotePort, server_port));
}
}
/*
** Free the memory.
*/
delete connection_list[0];
connection_list.Delete(0);
}
if (found) {
WWDEBUG_SAY(("FirewallHelper - Using address %s to talk to chat server\n", my_address.As_String()));
LocalChatConnectionAddress = my_address;
}
FreeLibrary(snmpapi_dll);
FreeLibrary(mib_ii_dll);
ThreadLockClass locker(this);
ThreadState = THREAD_GET_LOCAL_ADDRESS_DONE;
return(found);
}
/***********************************************************************************************
* FirewallHelperClass::Get_Local_Address -- Get local chat address ip as a long *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Local IP - 0 if unknown *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 10/11/2001 4:30PM ST : Created *
*=============================================================================================*/
unsigned long FirewallHelperClass::Get_Local_Address(void)
{
unsigned long ip = 0;
if (LocalChatConnectionAddress.Is_Valid()) {
ip = LocalChatConnectionAddress.Get_Address();
ip = htonl(ip);
}
return(ip);
}
/***********************************************************************************************
* FirewallHelperClass::Get_Raw_Firewall_Behavior -- Get firewall behavior bits *
* *
* *
* *
* INPUT: Nothing *
* *
* OUTPUT: Firewall behavior *
* *
* WARNINGS: None *
* *
* HISTORY: *
* 11/3/2001 8:50PM ST : Created *
*=============================================================================================*/
unsigned short FirewallHelperClass::Get_Raw_Firewall_Behavior(void)
{
unsigned short behave = (unsigned short)Behavior;
/*
** If we are forcing a particular port to be used then set the behavior type to be as if there was no firewall there at all.
*/
if (WOLNATInterface.Get_Force_Port() != 0) {
behave = (unsigned short) FIREWALL_TYPE_SIMPLE;
}
return(behave);
}
Reference in a new issue Copy permalink