720 lines
26 KiB
C++
720 lines
26 KiB
C++
#include "stdafx.h"
|
|
#include "ConfigIni.h"
|
|
#include "Logger.h"
|
|
#include "LoginClient.h"
|
|
|
|
extern class CConfig g_cfg;
|
|
|
|
/**
|
|
* Function replaces IP and port of server with ID = serverID
|
|
* in ServerList packet.
|
|
* Usage:
|
|
* unsigned char IP_new = {127,0,0,1};
|
|
* int port_new = 7777;
|
|
* unsigned int serverID = 1;
|
|
* bool ret = FL_ReplaceServerIPPort( rawBytes, rawBytesLen, serverID, IP_new, port_new );
|
|
*
|
|
* returns true on success, false on error
|
|
*/
|
|
bool FL_ReplaceServerIPPort( unsigned char *b, unsigned int blen )
|
|
{
|
|
if( !b || (blen<26) ) return false;
|
|
unsigned char fake_gsip[4] = {0,0,0,0};
|
|
unsigned long lInetAddr = L2PNet_inet_addr( g_cfg.FakeListenGameIP );
|
|
memcpy( (void *)&fake_gsip, (const void *)&lInetAddr, sizeof(lInetAddr) );
|
|
unsigned short int sport = (unsigned short int)g_cfg.FakeListenGamePort;
|
|
unsigned char cport[2] = {
|
|
(unsigned char)( sport & 0x00FF),
|
|
(unsigned char)((sport & 0xFF00) >> 8)
|
|
};
|
|
int gscount = (int)b[3];
|
|
const int ServerList_Header_Size = 5;
|
|
const int ServerList_OneServerInfo_Size = 21;
|
|
int pos = ServerList_Header_Size; // pass packet header
|
|
int i;
|
|
//while( pos < (int)blen )
|
|
log_error( LOG_DEBUG, "FL_ReplaceServerIPPort(): replacing IPs and ports for %d servers in list\n", gscount );
|
|
for( i=0; i<gscount; i++ )
|
|
{
|
|
pos = ServerList_Header_Size + (i * ServerList_OneServerInfo_Size);
|
|
//if( b[pos] == serverID )
|
|
//{
|
|
// found!
|
|
//log_error( LOG_DEBUG, "FL_ReplaceServerIPPort(): found server ID %d at offset %d\n",
|
|
// (int)serverID, pos );
|
|
// b[pos] is ServerID
|
|
// set new IP
|
|
b[pos+1] = fake_gsip[0];
|
|
b[pos+2] = fake_gsip[1];
|
|
b[pos+3] = fake_gsip[2];
|
|
b[pos+4] = fake_gsip[3];
|
|
// set new port
|
|
b[pos+5] = cport[0];
|
|
b[pos+6] = cport[1];
|
|
b[pos+7] = 0x00;
|
|
b[pos+8] = 0x00;
|
|
//return true;
|
|
//}
|
|
//else
|
|
//pos += ServerList_OneServerInfo_Size; // go to next serverID...
|
|
}
|
|
//log_error( LOG_WARNING, "FL_ReplaceServerIPPort(): not found server ID %d",
|
|
// (int)serverID );
|
|
//return false;
|
|
return true;
|
|
}
|
|
|
|
bool FL_RecalculateChechksum(
|
|
unsigned char *b,
|
|
unsigned int blen )
|
|
{
|
|
if( !b || (blen<26) ) return false; // some error?
|
|
L2LoginPacket lp;
|
|
unsigned int newlen = 0;
|
|
// set bytes, copy all except last 4 bytes - old checksum
|
|
if( !lp.setBytes( b, blen-4 ) )
|
|
{
|
|
log_error( LOG_ERROR,
|
|
"FL_RecalculateChechksum(): L2LoginPacket::setBytes( 0x%p, %u ) failed!\n",
|
|
b, blen-4 );
|
|
return false;
|
|
}
|
|
// append new checksum
|
|
lp.appendChecksum( false ); // do not append 4 bytes
|
|
// check resulting packet length - must be as original
|
|
newlen = lp.getPacketSize();
|
|
if( newlen == blen )
|
|
{
|
|
log_error( LOG_DEBUG, "FL_RecalculateChechksum(): newlen == blen, all OK\n" );
|
|
memcpy( b, lp.getBytesPtr(), newlen );
|
|
return true;
|
|
}
|
|
//else
|
|
log_error( LOG_ERROR, "FL_RecalculateChechksum(): newlen (%u) != oldlen (%u)\n", newlen, blen );
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* Was only for debugging
|
|
void GenerateFakePacket( L2Login_ServerList *p_sl )
|
|
{
|
|
if( !p_sl ) return;
|
|
// ugly! but this packet is known sure to work!
|
|
unsigned char b[] = {
|
|
0x22, 0x00, // length
|
|
0x04, 0x01, 0x01, // ptype, lastServer, nServers
|
|
0x01, // serverID
|
|
0x7F, 0x00, 0x00, 0x01, // serverIP
|
|
0x61, 0x1E, 0x00, 0x00, // serverPort
|
|
0x00, // age limit
|
|
0x01, // is PvP
|
|
0x00, 0x00, // current online
|
|
0x0A, 0x00, // max online
|
|
0x01, // is up
|
|
0x00, 0x00, 0x00, 0x00, 0x00, // flags...
|
|
0xA5, 0x4A, 0xAA, 0xCE, // <-- WTF is here????
|
|
0xB5, 0x54, 0xAA, 0xCE }; // here must be checksum
|
|
p_sl->setBytes( b, sizeof(b) );
|
|
}
|
|
*/
|
|
|
|
LoginClient::LoginClient()
|
|
{
|
|
memset( sessionKey1, 0, sizeof(sessionKey1) );
|
|
memset( sessionKey2, 0, sizeof(sessionKey2) );
|
|
gsIP[0] = gsIP[1] = gsIP[2] = gsIP[3] = 0;
|
|
gsPort = 0;
|
|
g_login_client = this;
|
|
state = LCST_OFFLINE;
|
|
}
|
|
|
|
LoginClient::~LoginClient()
|
|
{
|
|
g_login_client = NULL;
|
|
memset( sessionKey1, 0, sizeof(sessionKey1) );
|
|
memset( sessionKey2, 0, sizeof(sessionKey2) );
|
|
gsIP[0] = gsIP[1] = gsIP[2] = gsIP[3] = 0;
|
|
gsPort = 0;
|
|
state = LCST_OFFLINE;
|
|
}
|
|
|
|
bool LoginClient::getSessionKeys( unsigned char *sKey1, unsigned char *sKey2 )
|
|
{
|
|
if( !sKey1 || !sKey2 ) return false;
|
|
memcpy( sKey1, this->sessionKey1, 8 );
|
|
memcpy( sKey2, this->sessionKey2, 8 );
|
|
return true;
|
|
}
|
|
|
|
bool LoginClient::getPlayServerAddress( unsigned char *ip, unsigned short int *port )
|
|
{
|
|
if( !ip || !port ) return false;
|
|
memcpy( ip, this->gsIP, sizeof(this->gsIP) );
|
|
(*port) = this->gsPort;
|
|
return true;
|
|
}
|
|
|
|
bool LoginClient::ProcessClient( SOCKET scl )
|
|
{
|
|
bool retVal = false;
|
|
state = LCST_OFFLINE;
|
|
|
|
// connect to real login server
|
|
log_error( LOG_DEBUG, "Establishing redirecting connection to %s:%d ",
|
|
g_cfg.RealLoginServerIP, g_cfg.RealLoginServerPort );
|
|
|
|
SOCKET sr = L2PNet_TCPsocket_create( true );
|
|
if( sr == INVALID_SOCKET )
|
|
{
|
|
log_error_np( LOG_ERROR, "\n" );
|
|
log_error( LOG_ERROR, "ProcessClient(): cannot create socket!\n" );
|
|
return false;
|
|
}
|
|
|
|
L2PNet_connect( sr, g_cfg.RealLoginServerIP, (unsigned short)g_cfg.RealLoginServerPort );
|
|
int nTries = 20;
|
|
int r = 0;
|
|
while( nTries > 0 )
|
|
{
|
|
log_error_np( LOG_DEBUG, "." );
|
|
r = L2PNet_select( sr, L2PNET_SELECT_WRITE, 20000, NULL, NULL );
|
|
if( r == 1 ) break;
|
|
nTries--;
|
|
}
|
|
|
|
if( r == 1 )
|
|
{
|
|
log_error_np( LOG_DEBUG, " Connected. Tries left: %d\n", nTries );
|
|
state = LCST_CONNECTED;
|
|
}
|
|
else
|
|
{
|
|
state = LCST_OFFLINE;
|
|
// close sockets
|
|
L2PNet_shutdown( scl );
|
|
L2PNet_closesocket( scl );
|
|
L2PNet_shutdown( sr );
|
|
L2PNet_closesocket( sr );
|
|
log_error_np( LOG_DEBUG, " Not connected.\n" );
|
|
return false;
|
|
}
|
|
|
|
this->postNotify( LCN_STATECHANGE, 1 ); // connected
|
|
|
|
// TODO: Login server session vars
|
|
// login server session vars
|
|
unsigned char ls_sessionID[4] = {0,0,0,0};
|
|
unsigned int ls_sessionIDUInt = 0;
|
|
unsigned int ls_protoVer = 0;
|
|
unsigned char ls_RSA_pubKeyMod[128];
|
|
unsigned char ls_ggShit[16] = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0};
|
|
unsigned char ls_newBFKey[16] = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0};
|
|
unsigned int ls_ggAuthResponse = 0;
|
|
unsigned char ls_sessionKey1[8] = {0,0,0,0, 0,0,0,0};
|
|
unsigned char ls_sessionKey2[8] = {0,0,0,0, 0,0,0,0};
|
|
unsigned char ls_nGameServersCount = 0;
|
|
unsigned char ls_lastServerID = 0; // last server ID
|
|
unsigned char myGameServerIP[4] = {0,0,0,0};
|
|
//char sMyGSIP[16] = {0,0,0,0, 0,0,0,0, 0,0,0,0, 0,0,0,0};
|
|
unsigned short int myGameServerPort = 0;
|
|
int ls_chosenGameServer = -1;
|
|
// login server session vars memset
|
|
memset( ls_RSA_pubKeyMod, 0, sizeof(ls_RSA_pubKeyMod) );
|
|
|
|
// network vars
|
|
int netTimeout = 30;
|
|
int i = 0;
|
|
unsigned char ptype = 0; // packet type byte
|
|
unsigned char *rraw = NULL; // raw packet bytes
|
|
unsigned int rcvdLen = 0;
|
|
unsigned int sentLen = 0;
|
|
|
|
// packet objects
|
|
L2LoginPacket *pack = NULL;
|
|
L2Login_Init *p_init = NULL;
|
|
//L2Login_RequestGGAuth *p_rgga = NULL;
|
|
L2Login_GGAuthResponse *p_ggar = NULL;
|
|
L2Login_LoginOK *p_lok = NULL;
|
|
//L2Login_LoginFail *p_lfail = NULL;
|
|
L2Login_ServerList *p_sl = NULL;
|
|
L2Login_RequestServerLogin *p_rgsl = NULL;
|
|
L2Login_PlayOK *p_pok = NULL;
|
|
//L2Login_PlayFail *p_pfail = NULL;
|
|
|
|
// ServerInfo struct
|
|
struct L2GameServerInfo gsi;
|
|
memset( &gsi, 0, sizeof(gsi) );
|
|
struct L2GameServerInfo gameservers_info[32];
|
|
memset( gameservers_info, 0, sizeof(gameservers_info) );
|
|
|
|
// debug file
|
|
//FILE *f = NULL;
|
|
|
|
// Init: receive Init packet from real login server
|
|
rcvdLen = 0;
|
|
rraw = L2PacketReceive_malloc( sr, netTimeout*1000, &rcvdLen );
|
|
if( !rraw ) { log_error( LOG_ERROR, "receive failed!\n" ); goto l_netError; }
|
|
log_error( LOG_DEBUG, "ProcessClient(): rcvd %u bytes of Init packet from server.\n", rcvdLen );
|
|
// resend it to client
|
|
sentLen = 0;
|
|
L2PacketSend2( rraw, scl, netTimeout*1000, &sentLen );
|
|
log_error( LOG_DEBUG, "ProcessClient(): resent %u bytes of Init packet to client.\n", sentLen );
|
|
if( sentLen != rcvdLen ) { log_error( LOG_ERROR, "rcvd != sent! (%u != %u)\n", rcvdLen, sentLen ); goto l_netError; }
|
|
|
|
// decode and parse server's Init packet
|
|
p_init = new L2Login_Init( rraw, rcvdLen );
|
|
if( p_init->decodeBlowfish( true ) ) // true - Use Static BF Key
|
|
{
|
|
if( p_init->decodeXOR() )
|
|
{
|
|
// read packet data
|
|
p_init->read_SessionID( ls_sessionID );
|
|
memcpy( &ls_sessionIDUInt, ls_sessionID, sizeof(ls_sessionID) );
|
|
ls_protoVer = p_init->read_ProtoVer();
|
|
p_init->read_RSA_pubKeyMod( ls_RSA_pubKeyMod );
|
|
p_init->read_GGShit( ls_ggShit );
|
|
p_init->read_DynamicBFKey( ls_newBFKey );
|
|
// printfs
|
|
log_error( LOG_DEBUGDUMP, "SessionID: %02X %02X %02X %02X\n",
|
|
ls_sessionID[0], ls_sessionID[1], ls_sessionID[2], ls_sessionID[3] );
|
|
log_error( LOG_DEBUGDUMP, "Protocol ver: %08X\n", ls_protoVer );
|
|
p_init->unscramble_RSA_PubKeyMod( ls_RSA_pubKeyMod );
|
|
log_error( LOG_DEBUGDUMP, "Dynamic Blowfish key: " );
|
|
i = 0;
|
|
while( i < 16 ) log_error_np( LOG_DEBUGDUMP, "%02X ", ls_newBFKey[i++] );
|
|
log_error_np( LOG_DEBUGDUMP, "\n" );
|
|
}
|
|
else log_error( LOG_ERROR, "XOR decode failed\n" );
|
|
}
|
|
else log_error( LOG_ERROR, "BF decode failed\n" );
|
|
delete p_init;
|
|
p_init = NULL;
|
|
// free raw pack buffer
|
|
free( rraw );
|
|
rraw = NULL;
|
|
|
|
// RequestGGAuth
|
|
// receive client's answer to server's Init packet. probably it is RequestGGAuth packet
|
|
rcvdLen = 0;
|
|
rraw = L2PacketReceive_malloc( scl, netTimeout*1000, &rcvdLen );
|
|
if( !rraw ) { log_error( LOG_ERROR, "receive failed!\n" ); goto l_netError; }
|
|
log_error( LOG_DEBUG, "ProcessClient(): rcvd %u bytes of RequestGGAuth packet from client.\n", rcvdLen );
|
|
// resend it to server
|
|
sentLen = 0;
|
|
L2PacketSend2( rraw, sr, netTimeout*1000, &sentLen );
|
|
log_error( LOG_DEBUG, "ProcessClient(): resent %u bytes of RequestGGAuth packet to server.\n", sentLen );
|
|
if( sentLen != rcvdLen ) { log_error( LOG_ERROR, "rcvd != sent! (%u != %u)\n", rcvdLen, sentLen ); goto l_netError; }
|
|
// try to decode and parse client's response
|
|
//p_rgga = new L2Login_RequestGGAuth( rraw, rcvdLen );
|
|
//p_rgga->setDynamicBFKey( ls_newBFKey, 16 );
|
|
//p_rgga->decodeBlowfish( false );
|
|
//p_rgga->dumpToFile( stdout );
|
|
//delete p_rgga;
|
|
//p_rgga = NULL;
|
|
// free raw pack buffer
|
|
free( rraw );
|
|
rraw = NULL;
|
|
|
|
// GGAuthResponse
|
|
// receive server's answer to client's RequstGGAuth packet
|
|
rcvdLen = 0;
|
|
rraw = L2PacketReceive_malloc( sr, netTimeout*1000, &rcvdLen );
|
|
if( !rraw ) { log_error( LOG_ERROR, "receive failed!\n" ); goto l_netError; }
|
|
log_error( LOG_DEBUG, "ProcessClient(): rcvd %u bytes of GGAuthResponse packet from server.\n", rcvdLen );
|
|
// resend it to client
|
|
sentLen = 0;
|
|
L2PacketSend2( rraw, scl, netTimeout*1000, &sentLen );
|
|
log_error( LOG_DEBUG, "ProcessClient(): resent %u bytes of GGAuthResponse packet to client.\n", sentLen );
|
|
if( sentLen != rcvdLen ) { log_error( LOG_ERROR, "rcvd != sent! (%u != %u)\n", rcvdLen, sentLen ); goto l_netError; }
|
|
p_ggar = new L2Login_GGAuthResponse( rraw, rcvdLen );
|
|
//if( p_ggar ) printf( "GGAuthResponse object created\n" );
|
|
//printf( "Setting bytes 0x%p %u len\n", rraw, rcvdLen );
|
|
//if( p_ggar->setBytes( rraw, rcvdLen ) )
|
|
// printf( "ProcessClient(): GGAuthResponse bytes set OK\n" );
|
|
p_ggar->setDynamicBFKey( ls_newBFKey, 16 );
|
|
p_ggar->decodeBlowfish( false );
|
|
ptype = p_ggar->getPacketType();
|
|
if( ptype != 0x0B )
|
|
log_error( LOG_WARNING, "Unknown GGAuthResponse code 0x%02X!!!!\n",
|
|
(unsigned int)ptype );
|
|
else
|
|
log_error( LOG_OK, "GGAuthResponse: bypass GameGuard authorization...\n" );
|
|
ls_ggAuthResponse = p_ggar->read_Response();
|
|
if( ls_ggAuthResponse != ls_sessionIDUInt )
|
|
{
|
|
log_error( LOG_WARNING, "sessionID != ggAuthResponse (%04X != %04X)\n",
|
|
ls_sessionIDUInt, ls_ggAuthResponse );
|
|
}
|
|
else log_error( LOG_DEBUG, "++++ SessionID == ggAuthResponse ++++\n" );
|
|
delete p_ggar;
|
|
p_ggar = NULL;
|
|
// free raw pack buffer
|
|
free( rraw );
|
|
rraw = NULL;
|
|
|
|
state = LCST_AUTHED_GG;
|
|
|
|
// RequestAuthLogin
|
|
// client must now attempt to login to server with its login and password
|
|
rcvdLen = 0;
|
|
rraw = L2PacketReceive_malloc( scl, netTimeout*1000, &rcvdLen );
|
|
if( !rraw ) { log_error( LOG_ERROR, "receive failed!\n" ); goto l_netError; }
|
|
log_error( LOG_DEBUG, "ProcessClient(): rcvd %u bytes of RequestAuthLogin packet from client.\n", rcvdLen );
|
|
// resend it to server
|
|
sentLen = 0;
|
|
//L2PacketSend( rraw, sr, netTimeout, 0, &sentLen );
|
|
L2PacketSend2( rraw, sr, netTimeout*1000, &sentLen );
|
|
log_error( LOG_DEBUG, "ProcessClient(): resent %u bytes of RequestAuthLogin packet to server.\n", sentLen );
|
|
if( sentLen != rcvdLen ) { log_error( LOG_ERROR, "rcvd != sent! (%u != %u)\n", rcvdLen, sentLen ); goto l_netError; }
|
|
// display RequestAuthLogin contents
|
|
//pack = new L2LoginPacket();
|
|
//pack->setBytes( rraw, sentLen );
|
|
//pack->setDynamicBFKey( ls_newBFKey, 16 );
|
|
//pack->decodeBlowfish( false );
|
|
//pack->dumpToFile( stdout );
|
|
//delete pack;
|
|
//pack = NULL;
|
|
// free raw pack buffer
|
|
free( rraw );
|
|
rraw = NULL;
|
|
|
|
// LoginOK / LoginFail
|
|
// Login server must now reply to RequestAuthLogin and tell us about result
|
|
rcvdLen = 0;
|
|
rraw = L2PacketReceive_malloc( sr, netTimeout*1000, &rcvdLen );
|
|
if( !rraw ) { log_error( LOG_ERROR, "receive failed!\n" ); goto l_netError; }
|
|
log_error( LOG_DEBUG, "ProcessClient(): rcvd %u bytes of response to RequestAuthLogin from server.\n", rcvdLen );
|
|
// resend it to client
|
|
sentLen = 0;
|
|
L2PacketSend2( rraw, scl, netTimeout*1000, &sentLen );
|
|
log_error( LOG_DEBUG, "ProcessClient(): resent %u bytes of response to client.\n", sentLen );
|
|
if( sentLen != rcvdLen ) { log_error( LOG_ERROR, "rcvd != sent! (%u != %u)\n", rcvdLen, sentLen ); goto l_netError; }
|
|
log_error( LOG_DEBUG, "Server answer to RequestAuthLogin:\n" );
|
|
pack = new L2LoginPacket( rraw, rcvdLen );
|
|
pack->setDynamicBFKey( ls_newBFKey, 16 );
|
|
pack->decodeBlowfish( false );
|
|
//pack->dumpToFile( stdout );
|
|
ptype = pack->getPacketType();
|
|
if( ptype == 0x03 )
|
|
{
|
|
log_error( LOG_DEBUG, "++++ Login OK! ++++\n" );
|
|
state = LCST_AUTHED_LOGIN;
|
|
p_lok = new L2Login_LoginOK();
|
|
p_lok->setBytes( pack->getBytesPtr(), pack->getPacketSize() );
|
|
p_lok->read_sessionKey1( ls_sessionKey1 );
|
|
delete p_lok;
|
|
p_lok = NULL;
|
|
log_error( LOG_DEBUGDUMP, "SessionKey1: " );
|
|
for( i=0; i<sizeof(ls_sessionKey1); i++ )
|
|
log_error_np( LOG_DEBUGDUMP, "%02X ", ls_sessionKey1[i] );
|
|
log_error_np( LOG_DEBUGDUMP, "\n" );
|
|
}
|
|
else if( ptype == 0x01 )
|
|
{
|
|
state = LCST_AUTH_ERROR;
|
|
log_error( LOG_ERROR, "---- Login failed! (invalid user/pass? server offline?) ----\n" );
|
|
goto l_netError;
|
|
}
|
|
else if( ptype == 0x02 )
|
|
{
|
|
state = LCST_AUTH_ERROR;
|
|
log_error( LOG_ERROR, "---- Login failed! (account banned?)----\n" );
|
|
goto l_netError;
|
|
}
|
|
else
|
|
log_error( LOG_WARNING, "???? unknown reply to RequestAuthLogin: packet type: 0x%02X\n",
|
|
(unsigned int)ptype );
|
|
delete pack;
|
|
pack = NULL;
|
|
// free raw pack buffer
|
|
free( rraw );
|
|
rraw = NULL;
|
|
|
|
// RequestServerList
|
|
// after receiving packet LoginOK client displays license agreement
|
|
// and after user clicks 'Agree' client sends RequestServerList packet
|
|
rcvdLen = 0;
|
|
rraw = L2PacketReceive_malloc( scl, netTimeout*1000, &rcvdLen );
|
|
if( !rraw ) { log_error( LOG_ERROR, "receive failed!\n" ); goto l_netError; }
|
|
log_error( LOG_DEBUG, "ProcessClient(): rcvd %u bytes of RequestServerList packet from client.\n", rcvdLen );
|
|
// resend it to server
|
|
sentLen = 0;
|
|
L2PacketSend2( rraw, sr, netTimeout*1000, &sentLen );
|
|
log_error( LOG_DEBUG, "ProcessClient(): resent %u bytes of RequestServerList packet to server.\n", sentLen );
|
|
if( sentLen != rcvdLen ) { log_error( LOG_ERROR, "rcvd != sent! (%u != %u)\n", rcvdLen, sentLen ); goto l_netError; }
|
|
// dump info about RequestServerList packet
|
|
// [cut]
|
|
// free raw pack buffer
|
|
free( rraw );
|
|
rraw = NULL;
|
|
|
|
// ServerList
|
|
// login server now sends to client list of Game servers
|
|
rcvdLen = 0;
|
|
rraw = L2PacketReceive_malloc( sr, netTimeout*1000, &rcvdLen );
|
|
if( !rraw ) { log_error( LOG_ERROR, "receive failed!\n" ); goto l_netError; }
|
|
log_error( LOG_DEBUG, "ProcessClient(): rcvd %u bytes of ServerList packet from server.\n", rcvdLen );
|
|
// TODO: ServerList: NO, do not resend! :) modify it!!!
|
|
// resend it to client
|
|
/*sentLen = 0;
|
|
L2PacketSend( rraw, scl, 5, 0, &sentLen );
|
|
log_error( LOG_DEBUG, "ProcessClient(): resent %u bytes of ServerList packet to client.\n", sentLen );
|
|
if( sentLen != rcvdLen ) { log_error( LOG_ERROR, "rcvd != sent! (%u != %u)\n", rcvdLen, sentLen ); goto l_netError; }*/
|
|
|
|
log_error( LOG_DEBUG, "ServerList packet:\n" );
|
|
p_sl = new L2Login_ServerList();
|
|
p_sl->setBytes( rraw, rcvdLen );
|
|
// out RAW
|
|
//printf( "RAW ServerList packet:\n" );
|
|
//p_sl->dumpToFile( stdout );
|
|
p_sl->setDynamicBFKey( ls_newBFKey, 16 );
|
|
p_sl->decodeBlowfish( false );
|
|
// out BF decoded
|
|
//printf( "BF Decoded ServerList packet:\n" );
|
|
//p_sl->dumpToFile( stdout );
|
|
// save to file :)
|
|
//f = fopen( "ServerList.txt", "wt" );
|
|
//if( f ) p_sl->dumpToFile( f );
|
|
//fclose( f );
|
|
// parse
|
|
ptype = p_sl->getPacketType();
|
|
if( ptype == 0x04 ) log_error( LOG_DEBUG, "++++ ServerList ++++\n" );
|
|
p_sl->read_header( &ls_nGameServersCount, &ls_lastServerID );
|
|
log_error_np( LOG_DEBUGDUMP, "\n" );
|
|
log_error( LOG_DEBUGDUMP, "ServerList: %d game servers, last server: %d\n",
|
|
(int)ls_nGameServersCount, (int)ls_lastServerID );
|
|
for( i=0; i<ls_nGameServersCount; i++ )
|
|
{
|
|
memset( &gsi, 0, sizeof(gsi) );
|
|
if( p_sl->read_next_GS_Info( &gsi ) )
|
|
{
|
|
log_error( LOG_DEBUGDUMP, "*** Server %d Info ***\n", i );
|
|
log_error( LOG_DEBUGDUMP, "*** Server ID: %d\n", (int)gsi.gsID );
|
|
log_error( LOG_DEBUGDUMP, "*** Server addr: %d.%d.%d.%d:%d\n",
|
|
(int)gsi.gsIP[0],
|
|
(int)gsi.gsIP[1],
|
|
(int)gsi.gsIP[2],
|
|
(int)gsi.gsIP[3],
|
|
(int)gsi.gsPort );
|
|
log_error( LOG_DEBUGDUMP, "*** Online: %d / %d (up: %d)\n", (int)gsi.gsPlayersOnline,
|
|
(int)gsi.gsPlayersMax, (int)gsi.gsIsUp );
|
|
log_error_np( LOG_DEBUGDUMP, "\n" );
|
|
// save this gameserver in array
|
|
memcpy( (&gameservers_info[i]), &gsi, sizeof(L2GameServerInfo) );
|
|
// is this GS chosen to play on? // ignore
|
|
/*if( ((int)gsi.gsID) == g_cfg.PlayGameServerNo )
|
|
{
|
|
log_error( LOG_DEBUGDUMP, "^^^^ we play here! ^^^^\n\n" );
|
|
memcpy( myGameServerIP, gsi.gsIP, 4 );
|
|
myGameServerPort = gsi.gsPort;
|
|
}*/
|
|
}
|
|
else
|
|
{
|
|
log_error( LOG_ERROR, "p_sl->read_next_GS_Info( &gsi ) failed!\n" );
|
|
}
|
|
}
|
|
|
|
// replace server IP and port to what we need to intercept GS connection
|
|
if( FL_ReplaceServerIPPort(
|
|
(unsigned char *)p_sl->getBytesPtr(),
|
|
p_sl->getPacketSize() ) )
|
|
{
|
|
log_error( LOG_DEBUG, "[++++] OK: ServerList packet modified\n" );
|
|
// packet modified, we must update checksum in it
|
|
if( FL_RecalculateChechksum(
|
|
(unsigned char *)p_sl->getBytesPtr(),
|
|
p_sl->getPacketSize() ) )
|
|
{
|
|
log_error( LOG_DEBUGDUMP, "[++++] OK: ServerList packet checksum recalculated\n" );
|
|
}
|
|
else
|
|
{
|
|
log_error( LOG_ERROR, "ServerList packet checksum recalculate error!\n" );
|
|
}
|
|
}
|
|
else log_error( LOG_ERROR, "ServerList packet modify error\n" );
|
|
//GenerateFakePacket( p_sl ); // was called for debug only
|
|
|
|
//printf( "================\n" );
|
|
//printf( "[I] ServerList packet after replacing its IP & port:\n" );
|
|
//p_sl->dumpToFile( stdout );
|
|
//printf( "=================\n" );
|
|
|
|
// encode modified packet again
|
|
p_sl->encodeBlowfish( false );
|
|
// out encoded
|
|
//printf( "BF Encoded ServerList packet:\n" );
|
|
//p_sl->dumpToFile( stdout );
|
|
//rcvdLen = p_sl->getPacketSize();
|
|
// resend it to client
|
|
log_error( LOG_DEBUG, "Now resend %u bytes of ServerList to client...\n", rcvdLen );
|
|
sentLen = 0;
|
|
//L2PacketSend( p_sl->getBytesPtr(), scl, netTimeout, 0, &sentLen );
|
|
L2PacketSend2( p_sl->getBytesPtr(), scl, netTimeout*1000, &sentLen );
|
|
log_error( LOG_DEBUG, "ProcessClient(): resent %u bytes of ServerList packet to client.\n", sentLen );
|
|
if( sentLen != rcvdLen ) { log_error( LOG_ERROR, "rcvd != sent! (%u != %u)\n", rcvdLen, sentLen ); goto l_netError; }
|
|
delete p_sl;
|
|
p_sl = NULL;
|
|
// free raw pack buffer
|
|
free( rraw );
|
|
rraw = NULL;
|
|
|
|
// RequestServerLogin
|
|
// client now must request server login
|
|
rcvdLen = 0;
|
|
//rraw = L2PacketReceive( scl, netTimeout, 0, &rcvdLen );
|
|
rraw = L2PacketReceive_malloc( scl, netTimeout*1000, &rcvdLen );
|
|
if( !rraw ) { log_error( LOG_ERROR, "receive failed!\n" ); goto l_netError; }
|
|
log_error( LOG_DEBUG, "ProcessClient(): rcvd %u bytes of RequestServerLogin packet from client.\n", rcvdLen );
|
|
// resend it to server
|
|
sentLen = 0;
|
|
//L2PacketSend( rraw, sr, netTimeout, 0, &sentLen );
|
|
L2PacketSend2( rraw, sr, netTimeout*1000, &sentLen );
|
|
log_error( LOG_DEBUG, "ProcessClient(): resent %u bytes of RequestServerLogin packet to server.\n", sentLen );
|
|
if( sentLen != rcvdLen ) { log_error( LOG_ERROR, "rcvd != sent! (%u != %u)\n", rcvdLen, sentLen ); goto l_netError; }
|
|
// dump info about RequestServerLogin packet
|
|
p_rgsl = new L2Login_RequestServerLogin( rraw, rcvdLen );
|
|
p_rgsl->setDynamicBFKey( ls_newBFKey, 16 );
|
|
p_rgsl->decodeBlowfish( false );
|
|
// out
|
|
//pack->dumpToFile( stdout );
|
|
ptype = p_rgsl->getPacketType();
|
|
if( ptype == 0x02 ) log_error( LOG_DEBUG, "++++ RequestServerLogin ++++\n" );
|
|
p_rgsl->readInt(); p_rgsl->readInt(); // pass sessionKey1
|
|
ls_chosenGameServer = (int)p_rgsl->read_GameServerID();
|
|
log_error( LOG_DEBUG, "[INFO]: Client chooses to play on gameserver %d\n", ls_chosenGameServer );
|
|
delete p_rgsl;
|
|
p_rgsl = NULL;
|
|
// free raw pack buffer
|
|
free( rraw );
|
|
rraw = NULL;
|
|
|
|
// copy info about chosen game server
|
|
if( (ls_chosenGameServer>=1) && (ls_chosenGameServer<=255) )
|
|
{
|
|
for( i=0; i<(int)ls_nGameServersCount; i++ )
|
|
{
|
|
if( gameservers_info[i].gsID == ls_chosenGameServer )
|
|
{
|
|
memcpy( &(myGameServerIP), &(gameservers_info[i].gsIP), 4 );
|
|
myGameServerPort = gameservers_info[i].gsPort;
|
|
break;
|
|
}
|
|
}
|
|
//g_cfg.PlayGameServerNo = ls_chosenGameServer; // PlayGameServerNo removed from config
|
|
log_error( LOG_DEBUG, "we play on GS #%d: %d.%d.%d.%d:%d\n",
|
|
ls_chosenGameServer,
|
|
(int)myGameServerIP[0], (int)myGameServerIP[1], (int)myGameServerIP[2], (int)myGameServerIP[3],
|
|
myGameServerPort );
|
|
}
|
|
else
|
|
{
|
|
log_error( LOG_ERROR, "Client choosed GS ID %d, which is INVALID! must be [1..255]\n", ls_chosenGameServer );
|
|
}
|
|
|
|
// PlayOK / PlayFail
|
|
// login server now sends to client if client can play o selected server
|
|
rcvdLen = 0;
|
|
//rraw = L2PacketReceive( sr, netTimeout, 0, &rcvdLen );
|
|
rraw = L2PacketReceive_malloc( sr, netTimeout*1000, &rcvdLen );
|
|
if( !rraw ) { log_error( LOG_ERROR, "receive failed!\n" ); goto l_netError; }
|
|
log_error( LOG_DEBUG, "ProcessClient(): rcvd %u bytes of response to RequestServerLogin packet from server.\n", rcvdLen );
|
|
// resend it to client
|
|
sentLen = 0;
|
|
L2PacketSend2( rraw, scl, netTimeout*1000, &sentLen );
|
|
log_error( LOG_DEBUG, "ProcessClient(): resent %u bytes of response to RequestServerLogin packet to client.\n", sentLen );
|
|
if( sentLen != rcvdLen ) { log_error( LOG_ERROR, "rcvd != sent! (%u != %u)\n", rcvdLen, sentLen ); goto l_netError; }
|
|
pack = new L2LoginPacket();
|
|
pack->setBytes( rraw, sentLen );
|
|
pack->setDynamicBFKey( ls_newBFKey, 16 );
|
|
pack->decodeBlowfish( false );
|
|
// out...
|
|
//printf( "\nResponse to RequestServerLogin:\n" );
|
|
//pack->dumpToFile( stdout );
|
|
// parse result
|
|
ptype = pack->getPacketType();
|
|
if( ptype == 0x06 ) // PlayFail
|
|
{
|
|
log_error( LOG_ERROR, "---- PlayFail! ----\n" );
|
|
goto l_netError;
|
|
}
|
|
else if( ptype == 0x07 ) // PlayOK!
|
|
{
|
|
log_error( LOG_DEBUG, "++++ PlayOK! ++++\n" );
|
|
p_pok = new L2Login_PlayOK();
|
|
p_pok->setBytes( pack->getBytesPtr(), pack->getPacketSize() );
|
|
p_pok->read_sessionKey2( ls_sessionKey2 );
|
|
delete p_pok;
|
|
p_pok = NULL;
|
|
log_error( LOG_DEBUGDUMP, "SessionKey#2: " );
|
|
for( i=0; i<8; i++ ) log_error_np( LOG_DEBUGDUMP, "%02X ", ls_sessionKey2[i] );
|
|
log_error_np( LOG_DEBUGDUMP, "\n" );
|
|
}
|
|
else
|
|
{
|
|
log_error( LOG_ERROR, "=====================================\n" );
|
|
log_error( LOG_ERROR, "???? Unknown packet type 0x%02X! ????\n",
|
|
(unsigned int)ptype );
|
|
pack->dumpToFile( stdout );
|
|
log_error( LOG_ERROR, "=====================================\n" );
|
|
goto l_netError;
|
|
}
|
|
// delete...
|
|
delete pack;
|
|
pack = NULL;
|
|
// free raw packet data
|
|
free( rraw );
|
|
rraw = NULL;
|
|
|
|
// mark as connected OK
|
|
retVal = true;
|
|
|
|
goto l_closeSockets; // jump over netError handler
|
|
l_netError:
|
|
log_error( LOG_ERROR, "ProcessClient(): some network error :\\\n" );
|
|
if( rraw ) free( rraw );
|
|
rraw = NULL;
|
|
retVal = false; // mark as connection failed
|
|
l_closeSockets:
|
|
// close sockets
|
|
L2PNet_shutdown( scl );
|
|
L2PNet_closesocket( scl );
|
|
L2PNet_shutdown( sr );
|
|
L2PNet_closesocket( sr );
|
|
state = LCST_OFFLINE;
|
|
|
|
// save data
|
|
memcpy( this->sessionKey1, ls_sessionKey1, sizeof(ls_sessionKey1) );
|
|
memcpy( this->sessionKey2, ls_sessionKey2, sizeof(ls_sessionKey2) );
|
|
this->gsPort = myGameServerPort;
|
|
memcpy( this->gsIP, myGameServerIP, sizeof(myGameServerIP) );
|
|
|
|
// notify radar window about disconnection
|
|
this->postNotify( LCN_STATECHANGE, 0 ); // disconnected
|
|
|
|
log_error( LOG_DEBUG, "ProcessClient(): ended client processing. Returning %d\n",
|
|
(int)retVal );
|
|
|
|
// return indicator
|
|
return retVal;
|
|
}
|
|
|
|
|
|
void LoginClient::setNotifyWindow( HWND notifyHwnd, UINT notifyMsg )
|
|
{
|
|
this->hWndNotify = notifyHwnd;
|
|
this->uMsgNotify = notifyMsg;
|
|
}
|
|
|
|
extern HWND g_radardll_hwnd;
|
|
|
|
void LoginClient::postNotify( WPARAM wParam, LPARAM lParam )
|
|
{
|
|
//if( hWndNotify == NULL || (uMsgNotify < WM_USER) ) return;
|
|
//PostMessage( hWndNotify, uMsgNotify, wParam, lParam );
|
|
PostMessage( g_radardll_hwnd, (WM_USER+106), wParam, lParam );
|
|
}
|
|
|
|
LoginClient *g_login_client = NULL;
|