void Server::Loop(){
while(1){
SystemAddress addresClient = peer->HasNewIncomingConnection();
if(addresClient!=UNASSIGNED_SYSTEM_ADDRESS){
std::cout << "[Client Connected]: "<<addresClient.ToString() <<std::endl;
playersManager.AddPlayer(addresClient);
SendPlayerList();
printf("\n");
}else{
break;
}
}
while(1){
SystemAddress addresClient = peer->HasLostConnection();
if(addresClient!=UNASSIGNED_SYSTEM_ADDRESS){
std::cout << "[Client DisConnected]: "<<addresClient.ToString() <<std::endl;
playersManager.RemovePlayer(addresClient);
SendPlayerList();
printf("\n");
}else{
break;
}
}
Connector::Loop();
}
void NatPunchthroughClient::SendOutOfBand(SystemAddress sa, MessageID oobId)
{
if (sa==UNASSIGNED_SYSTEM_ADDRESS)
return;
if (sa.GetPort()==0)
return;
RakNet::BitStream oob;
oob.Write(oobId);
oob.Write(sp.sessionId);
// RakAssert(sp.sessionId<100);
if (oobId==ID_NAT_ESTABLISH_BIDIRECTIONAL)
oob.Write(sa.GetPort());
char ipAddressString[32];
sa.ToString(false, ipAddressString);
rakPeerInterface->SendOutOfBand((const char*) ipAddressString,sa.GetPort(),(const char*) oob.GetData(),oob.GetNumberOfBytesUsed());
if (natPunchthroughDebugInterface)
{
sa.ToString(true,ipAddressString);
char guidString[128];
sp.targetGuid.ToString(guidString);
if (oobId==ID_NAT_ESTABLISH_UNIDIRECTIONAL)
natPunchthroughDebugInterface->OnClientMessage(RakNet::RakString("Sent OOB ID_NAT_ESTABLISH_UNIDIRECTIONAL to guid %s, system address %s.", guidString, ipAddressString));
else
natPunchthroughDebugInterface->OnClientMessage(RakNet::RakString("Sent OOB ID_NAT_ESTABLISH_BIDIRECTIONAL to guid %s, system address %s.", guidString, ipAddressString));
}
}
void PacketLogger::FormatLine(
char* into, const char* dir, const char* type, unsigned int packet, unsigned int frame, const char* idToPrint
, const BitSize_t bitLen, unsigned long long time, const SystemAddress& local, const SystemAddress& remote,
unsigned int splitPacketId, unsigned int splitPacketIndex, unsigned int splitPacketCount, unsigned int orderingIndex)
{
char str1[64], str2[62];
local.ToString(true, str1);
remote.ToString(true, str2);
char localtime[128];
GetLocalTime(localtime);
sprintf(into, "%s,%s%s,%s,%5u,%5u,%s,%u,%"PRINTF_TIME_MODIFIER"u,%s,%s,%i,%i,%i,%i,%s,"
, localtime
, prefix
, dir
, type
, packet
, frame
, idToPrint
, bitLen
, time
, str1
, str2
, splitPacketId
, splitPacketIndex
, splitPacketCount
, orderingIndex
, suffix
);
}
void NatPunchthroughClient::SendOutOfBand(SystemAddress sa, MessageID oobId)
{
if (sa==UNASSIGNED_SYSTEM_ADDRESS)
return;
if (sa.GetPort()==0)
return;
RakNet::BitStream oob;
oob.Write(oobId);
oob.Write(sp.sessionId);
// RakAssert(sp.sessionId<100);
if (oobId==ID_NAT_ESTABLISH_BIDIRECTIONAL)
oob.Write(sa.GetPort());
char ipAddressString[32];
sa.ToString(false, ipAddressString);
rakPeerInterface->SendOutOfBand((const char*) ipAddressString,sa.GetPort(),(const char*) oob.GetData(),oob.GetNumberOfBytesUsed());
if (natPunchthroughDebugInterface)
{
sa.ToString(true,ipAddressString);
char guidString[128];
sp.targetGuid.ToString(guidString);
// server - diff = my time
// server = myTime + diff
RakNet::Time clockDifferential = rakPeerInterface->GetClockDifferential(sp.facilitator);
RakNet::Time serverTime = RakNet::GetTime() + clockDifferential;
if (oobId==ID_NAT_ESTABLISH_UNIDIRECTIONAL)
natPunchthroughDebugInterface->OnClientMessage(RakNet::RakString("%I64d: %s: OOB ID_NAT_ESTABLISH_UNIDIRECTIONAL to guid %s, system address %s.\n", serverTime, TestModeToString(sp.testMode), guidString, ipAddressString));
else
natPunchthroughDebugInterface->OnClientMessage(RakNet::RakString("%I64d: %s: OOB ID_NAT_ESTABLISH_BIDIRECTIONAL to guid %s, system address %s.\n", serverTime, TestModeToString(sp.testMode), guidString, ipAddressString));
}
}
void CommandParserInterface::ReturnResult(SystemAddress res, const char *command, TransportInterface *transport, const SystemAddress &systemAddress)
{
char addr[128];
systemAddress.ToString(false,addr,static_cast<size_t>(128));
char addr2[128];
res.ToString(false,addr2,static_cast<size_t>(128));
transport->Send(systemAddress, "%s returned %s %s:%i\r\n", command,addr,addr2,res.GetPort());
}
void FullyConnectedMesh2::AddParticipant(SystemAddress participant)
{
if (rakPeerInterface->IsConnected(participant,false,false)==false)
{
#ifdef DEBUG_FCM2
printf("AddParticipant to %s failed (not connected)\n", participant.ToString());
#endif
return;
}
// Account for different system addresses between different participants
RakNetGUID newParticipantGuid = rakPeerInterface->GetGuidFromSystemAddress(participant);
for (unsigned int i=0; i < participantList.Size(); i++)
{
if (participantList[i].rakNetGuid==newParticipantGuid)
{
if (participantList[i].systemAddress!=participant)
{
participantList[i].systemAddress=participant;
if (ourFCMGuid==0)
{
SendFCMGuidRequest(participant);
return;
}
else
{
SendOurFCMGuid(participant);
return;
}
}
#ifdef DEBUG_FCM2
printf("AddParticipant to %s failed (Same Guid and System address)\n", participant.ToString());
#endif
// else already added
return;
}
}
// Not in the list at all
if (ourFCMGuid==0)
{
SendFCMGuidRequest(participant);
guidRequestRetryList.Push(rakPeerInterface->GetGuidFromSystemAddress(participant),__FILE__,__LINE__);
}
else
{
SendOurFCMGuid(participant);
}
}
bool Server::Start(void)
{
printf("Starting server!\n\n");
printf("Port: %i\n", m_port);
printf("Maximum clients: %i\n", m_noOfConnections);
m_server->SetIncomingPassword(m_password.c_str(), (int)strlen(m_password.c_str()));
m_server->SetTimeoutTime(30000, UNASSIGNED_SYSTEM_ADDRESS);
//m_server->AttachPlugin(&m_logger);
SocketDescriptor socketDesc[1];
socketDesc[0].port = m_port;
socketDesc[0].socketFamily = AF_INET;
bool started = m_server->Startup(m_noOfConnections, socketDesc, 1) == RAKNET_STARTED;
if (!started)
{
printf("Failed to start server!\n");
return false;
}
m_server->SetMaximumIncomingConnections(m_noOfConnections);
m_server->SetOccasionalPing(true);
m_server->SetUnreliableTimeout(true);
DataStructures::List<RakNetSocket2*> sockets;
m_server->GetSockets(sockets);
printf("\nSocket addresses used by RakNet:\n");
for (unsigned int i = 0; i < sockets.Size(); ++i)
{
printf("%i. %s\n", i + 1, sockets[i]->GetBoundAddress().ToString(true));
}
printf("\nIP Addresses:\n");
for (unsigned int i = 0; i < m_server->GetNumberOfAddresses(); ++i)
{
SystemAddress sa = m_server->GetInternalID(UNASSIGNED_SYSTEM_ADDRESS, i);
printf("%i. %s (LAN=%i)\n", i + 1, sa.ToString(true), sa.IsLANAddress());
SetConsoleTitle(sa.ToString(true));// (sa.ToString(true)));
}
printf("\nGUID: %s\n", m_server->GetGuidFromSystemAddress(UNASSIGNED_SYSTEM_ADDRESS).ToString());
printf("\nServer started!!\n\n\n");
return true;
}
PluginReceiveResult FullyConnectedMesh2::OnReceive(Packet *packet)
{
switch (packet->data[0])
{
case ID_REMOTE_NEW_INCOMING_CONNECTION:
{
unsigned int count;
RakNet::BitStream bsIn(packet->data, packet->length, false);
bsIn.IgnoreBytes(sizeof(MessageID));
bsIn.Read(count);
SystemAddress remoteAddress;
RakNetGUID remoteGuid;
char str[64];
for (unsigned int i=0; i < count; i++)
{
bsIn.Read(remoteAddress);
bsIn.Read(remoteGuid);
remoteAddress.ToString(false,str);
rakPeerInterface->Connect(str,remoteAddress.port,0,0);
}
}
break;
case ID_FCM2_REQUEST_FCMGUID:
OnRequestFCMGuid(packet);
break;
case ID_FCM2_RESPOND_FCMGUID:
OnRespondFCMGuid(packet);
break;
case ID_FCM2_INFORM_FCMGUID:
OnInformFCMGuid(packet);
break;
}
return RR_CONTINUE_PROCESSING;
}
ACTIONSCRIPT_CALLABLE_FUNCTION(RoomsBrowserGFx3_RakNet, f2c_JoinByFilter)
{
if (pparams.GetArgCount()<1)
return;
RakNet::JoinByFilter_Func func;
func.userName=loginUsername;
func.gameIdentifier=titleName;
func.roomMemberMode=RMM_ANY_PLAYABLE;
bool roomIsFromServer=pparams[0].GetBool();
double roomGuid=pparams[1].GetNumber();
if (roomIsFromServer)
{
// See RoomTypes.h for other default columns
func.query.AddQuery_NUMERIC( DefaultRoomColumns::GetColumnName(DefaultRoomColumns::TC_ROOM_ID), roomGuid);
roomsPlugin->ExecuteFunc(&func);
}
else
{
SystemAddress sa;
sa.FromString(pparams[2].GetString());
char ipPart[32];
sa.ToString(false,ipPart);
rakPeer->Connect(ipPart,sa.GetPort(),0,0);
}
}
//-------------------------------------------------------------------------------------
void UDPClientOnRakNet::ResponsePeerConnect(Packet* p)
{
char buf[512]={0};
tostringstream Log_Info;
char cond=raknet_wrapper::ID_IGT_CLIENT;
memcpy(buf,(void *)(&cond),sizeof(char));
int nSendLength=0;
SystemAddress PeerSysAddr;
P2P_COMMAND::CCmdHandshake * pCmd=new P2P_COMMAND::CCmdHandshake();
PeerSysAddr=p->systemAddress;
Log_Info.str(_T(""));
Log_Info<<"响应Peer连接发送握手包 客户端外部IP:"<<PeerSysAddr.ToString()<<_T("\r\n");
LOG(Log_Debug,Log_Info.str().c_str());
pCmd->m_nSessionID=m_client_sessionID;
nSendLength=0;
if ( pCmd->Create(buf+sizeof(char),nSendLength ) > 0 )
{
Send(buf, (const int) nSendLength+sizeof(char),HIGH_PRIORITY, RELIABLE_ORDERED,0,PeerSysAddr,false);
}
delete pCmd;
}
void CDemo::OnForwardingSuccess(const char *proxyIPAddress, unsigned short proxyPort,
SystemAddress proxyCoordinator, SystemAddress sourceAddress, SystemAddress targetAddress, RakNet::UDPProxyClient *proxyClientPlugin)
{
RakNet::RakString targetName = targetAddress.ToString();
PushMessage(RakNet::RakString("Proxy forwarding to ") + targetName + RakNet::RakString(" through %s:%i succeeded. Connecting.", proxyIPAddress, proxyPort));
rakPeer->Connect(proxyIPAddress, proxyPort,0,0);
}
bool Network::ConnectToPlayer( SystemAddress host )
{
ConnectionAttemptResult result = mp_peer->Connect(host.ToString(false), host.port, 0, 0);
switch (result)
{
case CONNECTION_ATTEMPT_STARTED:
cout << "Connected to player" << endl;
return true;
break;
case INVALID_PARAMETER:
cout << "invalid parameter when connecting to peer" << endl;
break;
case CANNOT_RESOLVE_DOMAIN_NAME:
cout << "can not resolve the domain in in connection attempt." << endl;
break;
case ALREADY_CONNECTED_TO_ENDPOINT:
cout << "already connected to peer" << endl;
break;
case CONNECTION_ATTEMPT_ALREADY_IN_PROGRESS:
cout << "already attempting to connect to peer" << endl;
break;
case SECURITY_INITIALIZATION_FAILED:
cout << "no security, very insecure" << endl;
break;
}
return false;
}
void NatTypeDetectionClient::DetectNATType(SystemAddress _serverAddress)
{
if (IsInProgress())
return;
if (c2==INVALID_SOCKET)
{
DataStructures::List<RakNetSmartPtr<RakNetSocket> > sockets;
rakPeerInterface->GetSockets(sockets);
SystemAddress sockAddr;
SocketLayer::GetSystemAddress(sockets[0]->s, &sockAddr);
char str[64];
sockAddr.ToString(false,str);
c2=CreateNonblockingBoundSocket(str
#ifdef __native_client__
, sockets[0]->chromeInstance
#endif
);
c2Port=SocketLayer::GetLocalPort(c2);
}
serverAddress=_serverAddress;
RakNet::BitStream bs;
bs.Write((unsigned char)ID_NAT_TYPE_DETECTION_REQUEST);
bs.Write(true); // IsRequest
bs.Write(c2Port);
rakPeerInterface->Send(&bs,MEDIUM_PRIORITY,RELIABLE,0,serverAddress,false);
}
void InstancesTable::unregisterInstance(SystemAddress addr){
std::stringstream str;
str << "DELETE FROM `instances` WHERE `server_address` = '" << addr.ToString() << "');";
auto qr = Database::Query(str.str());
if (qr == NULL){
std::cout << "[ACDB] [MYSQL] " << mysql_error(Database::getConnection()) << std::endl;
}
}
void FLP_Printf::OnFilePushesComplete( SystemAddress systemAddress, unsigned short setID )
{
(void) setID;
char str[32];
systemAddress.ToString(true, (char*) str);
RAKNET_DEBUG_PRINTF("File pushes complete to %s\n", str);
}
void MessageFilter::OnInvalidMessage(RakPeerInterface *peer, FilterSet *filterSet, SystemAddress systemAddress, unsigned char messageID)
{
if (filterSet->invalidMessageCallback)
filterSet->invalidMessageCallback(peer, systemAddress, filterSet->filterSetID, filterSet->disallowedCallbackUserData, messageID);
if (filterSet->banOnDisallowedMessage)
peer->AddToBanList(systemAddress.ToString(false), filterSet->disallowedMessageBanTimeMS);
if (filterSet->kickOnDisallowedMessage)
peer->CloseConnection(systemAddress, true, 0);
}
void PacketLogger::OnAck(unsigned int messageNumber, SystemAddress remoteSystemAddress, RakNetTime time)
{
char str[256];
char str1[64], str2[62];
SystemAddress localSystemAddress = rakPeerInterface->GetExternalID(remoteSystemAddress);
localSystemAddress.ToString(true, str1);
remoteSystemAddress.ToString(true, str2);
char localtime[128];
GetLocalTime(localtime);
sprintf(str, "%s,Rcv,Ack,%i,,,,%"PRINTF_TIME_MODIFIER"u,%s,%s,,,,,,"
, localtime
, messageNumber
, (unsigned long long) time
, str1
, str2
);
AddToLog(str);
}
void NetworkUtils::SendNetworkMessage( NetworkMessage& message, const SystemAddress& destination, RakPeerInterface* networkInterface )
{
BitStream* bitStream = NetworkUtils::Serialize( message );
networkInterface->Send( bitStream, MEDIUM_PRIORITY, RELIABLE, 0, destination, false );
delete bitStream;
if ( message.messageId == System::Messages::Network::ComponentUpdate.c_str( ) )
{
std::string messageText = message.parameters[ System::Parameters::Network::ComponentMessage ].As< System::Message >( );
messageText = ( messageText.empty( ) ) ? message.messageId.C_String( ) : messageText;
Debug( messageText, "to", destination.ToString( false ) );
}
else
{
Debug( message.messageId, "to", destination.ToString( false ) );
}
}
void PacketLogger::FormatLine(
char* into, const char* dir, const char* type, unsigned int reliableMessageNumber, unsigned int frame, const char* idToPrint
, const BitSize_t bitLen, unsigned long long time, const SystemAddress& local, const SystemAddress& remote,
unsigned int splitPacketId, unsigned int splitPacketIndex, unsigned int splitPacketCount, unsigned int orderingIndex)
{
char str1[64], str2[62];
local.ToString(true, str1);
remote.ToString(true, str2);
char localtime[128];
GetLocalTime(localtime);
char str3[64];
if (reliableMessageNumber==(unsigned int)-1)
{
str3[0]='N';
str3[1]='/';
str3[2]='A';
str3[3]=0;
}
else
{
sprintf(str3,"%5u",reliableMessageNumber);
}
sprintf(into, "%s,%s%s,%s,%s,%5u,%s,%u,%" PRINTF_64_BIT_MODIFIER "u,%s,%s,%i,%i,%i,%i,%s,"
, localtime
, prefix
, dir
, type
, str3
, frame
, idToPrint
, bitLen
, time
, str1
, str2
, splitPacketId
, splitPacketIndex
, splitPacketCount
, orderingIndex
, suffix
);
}
void NatPunchthroughClient::SendTTL(SystemAddress sa)
{
if (sa==UNASSIGNED_SYSTEM_ADDRESS)
return;
if (sa.port==0)
return;
char ipAddressString[32];
sa.ToString(false, ipAddressString);
rakPeerInterface->SendTTL(ipAddressString,sa.port, 3);
}
void FullyConnectedMesh2::SendFCMGuidRequest(SystemAddress addr)
{
#ifdef DEBUG_FCM2
printf("SendFCMGuidRequest to %s. guid=%s.\n", addr.ToString(), rakPeerInterface->GetGuidFromSystemAddress(addr).ToString());
#endif
RakNet::BitStream bsOut;
bsOut.Write((MessageID)ID_FCM2_REQUEST_FCMGUID);
bsOut.Write(GetElapsedRuntime());
rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,addr,false);
}
void PacketLogger::OnPushBackPacket(const char *data, const BitSize_t bitsUsed, SystemAddress remoteSystemAddress)
{
char str[256];
char str1[64], str2[62];
SystemAddress localSystemAddress = rakPeerInterface->GetExternalID(remoteSystemAddress);
localSystemAddress.ToString(true, str1);
remoteSystemAddress.ToString(true, str2);
RakNetTime time = RakNet::GetTime();
char localtime[128];
GetLocalTime(localtime);
sprintf(str, "%s,Lcl,PBP,,,%s,%i,%"PRINTF_TIME_MODIFIER"u,%s,%s,,,,,,"
, localtime
, BaseIDTOString(data[0])
, bitsUsed
, (unsigned long long) time
, str1
, str2
);
AddToLog(str);
}
void MessageFilter::OnInvalidMessage(FilterSet *filterSet, SystemAddress systemAddress, unsigned char messageID)
{
if (filterSet->invalidMessageCallback)
filterSet->invalidMessageCallback(rakPeerInterface, systemAddress, filterSet->filterSetID, filterSet->disallowedCallbackUserData, messageID);
if (filterSet->banOnDisallowedMessage) {
char str1[64];
systemAddress.ToString(false, str1);
rakPeerInterface->AddToBanList(str1, filterSet->disallowedMessageBanTimeMS);
}
if (filterSet->kickOnDisallowedMessage)
rakPeerInterface->CloseConnection(systemAddress, true, 0);
}
void FullyConnectedMesh2::SendFCMGuidResponse(SystemAddress addr, unsigned int responseAssignedConnectionCount, unsigned int responseTotalConnectionCount)
{
#ifdef DEBUG_FCM2
printf("SendFCMGuidResponse to %s. guid=%s.\n", addr.ToString(), rakPeerInterface->GetGuidFromSystemAddress(addr).ToString());
#endif
RakNet::BitStream bsOut;
bsOut.Write((MessageID)ID_FCM2_RESPOND_FCMGUID);
bsOut.Write(responseAssignedConnectionCount);
bsOut.Write(responseTotalConnectionCount);
rakPeerInterface->Send(&bsOut,HIGH_PRIORITY,RELIABLE_ORDERED,0,addr,false);
}
void NatPunchthroughClient::SendTTL(const SystemAddress &sa)
{
if (sa==UNASSIGNED_SYSTEM_ADDRESS)
return;
if (sa.GetPort()==0)
return;
char ipAddressString[32];
sa.ToString(false, ipAddressString);
// TTL of 1 doesn't get past the router, 2 might hit the other system on a LAN
rakPeerInterface->SendTTL(ipAddressString,sa.GetPort(), 2);
}
void Router2::SendOOBFromRakNetPort(OutOfBandIdentifiers oob, BitStream *extraData, SystemAddress sa)
{
RakNet::BitStream oobBs;
oobBs.Write((unsigned char)oob);
if (extraData)
{
extraData->ResetReadPointer();
oobBs.Write(*extraData);
}
char ipAddressString[32];
sa.ToString(false, ipAddressString);
rakPeerInterface->SendOutOfBand((const char*) ipAddressString,sa.GetPort(),(const char*) oobBs.GetData(),oobBs.GetNumberOfBytesUsed());
}
void Server::Loop(){
while(1){
SystemAddress addresClient = peer->HasNewIncomingConnection();
if(addresClient!=UNASSIGNED_SYSTEM_ADDRESS){
std::cout << "[Client Connected]: "<<addresClient.ToString() <<std::endl;
std::cout << "[Client Connected]: client count: " << peer->GetConnectionCount() <<std::endl;
//std::cout << "[Client Connected]: client count: " << <<std::endl;
SystemAddress iplist[Settings::maxPlayers];
unsigned short numberofSystems;
peer->GetConnectionList(iplist,&numberofSystems);
for(unsigned short i = 0;i<numberofSystems;i++){
std::cout << "[Client Connected]: client " << i << ":" << iplist[i].ToString() <<std::endl;
}
playersManager.AddPlayer(addresClient);
SendPlayerList();
printf("\n");
}else{
break;
}
}
while(1){
SystemAddress addresClient = peer->HasLostConnection();
if(addresClient!=UNASSIGNED_SYSTEM_ADDRESS){
peer->CloseConnection(addresClient);
std::cout << "[Client DisConnected]: "<<addresClient.ToString() <<std::endl;
playersManager.RemovePlayer(addresClient);
SendPlayerList();
SendPlayerIsAdmin();
printf("\n");
}else{
break;
}
}
if(game != NULL){
game->Loop();
}
Connector::Loop();
}
void DoHandshake(RakPeerInterface *rakServer, const SystemAddress& systemAddress, RakNet::BitStream * data, std::string SERVER){
unsigned long s_remoteConnectionType = 4;
if (SERVER == "AUTH") s_remoteConnectionType = 1;
unsigned long version;
data->Read(version);
unsigned long unknown;
data->Read(unknown);
unsigned long remoteConnectionType;
data->Read(remoteConnectionType);
unsigned long processid;
data->Read(processid);
unsigned short port;
data->Read(port);
std::vector<unsigned char> addv;
addv.reserve(33);
bool flag = true;
std::string address = PacketTools::ReadStrFromPacket(data, 33); //Unused, no data
Logger::log(SERVER, "", "Client: " + std::string(systemAddress.ToString()), LOG_ALL);
Logger::log(SERVER, "", "Client Handshake Request", LOG_DEBUG);
Logger::log(SERVER, "", "Version: " + std::to_string(version), LOG_ALL);
Logger::log(SERVER, "", "ProcessID: " + std::to_string(processid), LOG_ALL);
Logger::log(SERVER, "", "ConnectionType: " + std::to_string(remoteConnectionType), LOG_ALL);
Logger::log(SERVER, "", "Port: " + std::to_string(port), LOG_ALL);
//Preparing answer:
RakNet::BitStream *aw = new RakNet::BitStream(59);
CreatePacketHeader(ID_USER_PACKET_ENUM, 0, 0, aw);
unsigned long s_version = 171022UL;
unsigned long s_unknown = 0x93;
unsigned long s_processid = GetCurrentProcessId();
short s_unknown2 = -1; //port = 0xFFFF = -1 -> no port?
std::string s_ip = rakServer->GetLocalIP(0);
Logger::log(SERVER, "", "Server Handshake Response", LOG_DEBUG);
Logger::log(SERVER, "", "Version: " + std::to_string(s_version), LOG_ALL);
Logger::log(SERVER, "", "ProcessID: " + std::to_string(s_processid), LOG_ALL);
Logger::log(SERVER, "", "ConnectionType: " + std::to_string(s_remoteConnectionType), LOG_ALL);
Logger::log(SERVER, "", "Address: " + s_ip, LOG_ALL);
aw->Write(s_version);
aw->Write(s_unknown);
aw->Write(s_remoteConnectionType);
aw->Write(s_processid);
aw->Write(s_unknown2);
for (unsigned char k = 0; k < 33; k++){
if (k < s_ip.size()) aw->Write((unsigned char)s_ip.at(k));
else aw->Write((unsigned char)0);
}
rakServer->Send(aw, SYSTEM_PRIORITY, RELIABLE_ORDERED, 0, systemAddress, false);
}
void FullyConnectedMesh2::ConnectToRemoteNewIncomingConnections(Packet *packet)
{
unsigned int count;
RakNet::BitStream bsIn(packet->data, packet->length, false);
bsIn.IgnoreBytes(sizeof(MessageID));
bsIn.Read(count);
SystemAddress remoteAddress;
RakNetGUID remoteGuid;
char str[64];
for (unsigned int i=0; i < count; i++)
{
bsIn.Read(remoteAddress);
bsIn.Read(remoteGuid);
remoteAddress.ToString(false,str);
rakPeerInterface->Connect(str,remoteAddress.GetPort(),connectionPassword.C_String(),(int) connectionPassword.GetLength());
}
}
int InstancesTable::getInstanceId(SystemAddress addr){
std::stringstream str;
str << "SELECT `instanceid` FROM `instances` WHERE `server_address` = '" << addr.ToString() << "');";
auto qr = Database::Query(str.str());
if (qr == NULL){
return -1;
}
else{
if (mysql_num_rows(qr) == 0){
return -1;
}
else{
auto row = mysql_fetch_row(qr);
return std::stoi(row[0]);
}
}
}
