void
CProxy::updateThread()
{
// Threaded update loop
while (!m_bQuit)
{
try
{
while (m_pListenInterface->Receive())
;
{
RakNet::Packet* pPacket = NULL;
for (pPacket = m_pLoginSrvInterface->Receive(); pPacket; m_pLoginSrvInterface->DeallocatePacket(pPacket), pPacket = m_pLoginSrvInterface->Receive())
if (!OnLoginSrvReceive(pPacket))
break;
}
}
catch (std::exception ex)
{
ff::fmt(pan::critical, "Caught an exception in updateThread ({0}).", ex.what());
}
RakSleep(10);
}
}
bool CommonFunctions::WaitAndConnect(RakPeerInterface *peer,char* ip,unsigned short int port,int millisecondsToWait)
{
SystemAddress connectToAddress;
connectToAddress.SetBinaryAddress(ip);
connectToAddress.port=port;
TimeMS entryTime=GetTimeMS();
while(!CommonFunctions::ConnectionStateMatchesOptions (peer,connectToAddress,true)&&GetTimeMS()-entryTime<millisecondsToWait)
{
if(!CommonFunctions::ConnectionStateMatchesOptions (peer,connectToAddress,true,true,true,true))
{
peer->Connect(ip,port,0,0);
}
RakSleep(100);
}
if (ConnectionStateMatchesOptions (peer,connectToAddress,true))
{
return 1;
}
return 0;
}
bool UPNPNAT::tcp_connect(const char * _host,unsigned short int _port)
{
int ret;
tcp_socket_fd=(int) socket(AF_INET,SOCK_STREAM,0);
struct sockaddr_in r_address;
r_address.sin_family = AF_INET;
r_address.sin_port=htons(_port);
r_address.sin_addr.s_addr=inet_addr(_host);
RakNetTime stopWaiting = RakNet::GetTime() + time_out;
while (RakNet::GetTime() < stopWaiting)
{
ret=connect(tcp_socket_fd,(const struct sockaddr *)&r_address,sizeof(struct sockaddr_in) );
RakSleep(50);
if(ret==0)
{
status=NAT_TCP_CONNECTED;
return true;
}
}
status=NAT_ERROR;
char temp[100];
sprintf(temp,"Fail to connect to %s:%i (using TCP)\n",_host,_port);
last_error=temp;
return false;
}
unsigned RNS2_Berkley::RecvFromLoopInt(void)
{
isRecvFromLoopThreadActive.Increment();
while ( endThreads == false )
{
RNS2RecvStruct *recvFromStruct;
recvFromStruct=binding.eventHandler->AllocRNS2RecvStruct(_FILE_AND_LINE_);
if (recvFromStruct != NULL)
{
recvFromStruct->socket=this;
RecvFromBlocking(recvFromStruct);
if (recvFromStruct->bytesRead>0)
{
RakAssert(recvFromStruct->systemAddress.GetPort());
binding.eventHandler->OnRNS2Recv(recvFromStruct);
}
else
{
RakSleep(0);
binding.eventHandler->DeallocRNS2RecvStruct(recvFromStruct, _FILE_AND_LINE_);
}
}
}
isRecvFromLoopThreadActive.Decrement();
return 0;
}
void MasterList::pulse()
{
RakNet::RakString post;
RakNet::Packet* packet;
while (ServerCore::getInstance().isActive())
{
if ((utility::TimeUtility::getMsTime() - m_lastUpdateTime) < 3000)
continue;
if (m_tcp->Connect(ProjectGlobals::getMasterlistUrl().c_str(), 80, true) == RakNet::UNASSIGNED_SYSTEM_ADDRESS)
continue;
RakSleep(100);
if (m_state == masterListState::STATE_ADD)
m_token = utility::StringUtility::random_string(42);
post = RakNet::RakString::FormatForPOST(std::string(ProjectGlobals::getMasterlistUrl()).append("/api/v1/server/update").c_str(),
"application/x-www-form-urlencoded",
RakNet::RakString("token=%s&ip=%s&port=%d&players=%d",
m_token.c_str(),
ServerCore::getInstance().getServerCoreConfiguration().getAddress().c_str(),
ServerCore::getInstance().getServerCoreConfiguration().getPort(),
ServerCore::getInstance().getPlayerManager().getPoolSize()),
"User-Agent: Malefice/1.0");
m_tcp->Send(post.C_String(), post.GetLength(), m_tcp->HasCompletedConnectionAttempt(), false);
RakSleep(1000);
packet = m_tcp->Receive();
if (!packet)
continue;
if (m_state == masterListState::STATE_ADD) {
LOG_INFO(NETWORK) << "Server successfully posted to the MasterList";
m_state = masterListState::STATE_UPDATE;
}
m_lastUpdateTime = utility::TimeUtility::getMsTime();
m_tcp->DeallocatePacket(packet);
RakSleep(100);
}
}
RNS2BindResult RNS2_Windows::Bind( RNS2_BerkleyBindParameters *bindParameters, const char *file, unsigned int line ) {
RNS2BindResult bindResult = BindShared(bindParameters, file, line);
if (bindResult == BR_FAILED_TO_BIND_SOCKET)
{
// Sometimes windows will fail if the socket is recreated too quickly
RakSleep(100);
bindResult = BindShared(bindParameters, file, line);
}
return bindResult;
}
bool TCPInterface::Start(unsigned short port, unsigned short maxIncomingConnections, unsigned short maxConnections, int _threadPriority)
{
if (isStarted)
return false;
threadPriority=_threadPriority;
if (threadPriority==-99999)
{
#if defined(_XBOX) || defined(X360)
#elif defined(_WIN32)
threadPriority=0;
#elif defined(_PS3) || defined(__PS3__) || defined(SN_TARGET_PS3)
#else
threadPriority=1000;
#endif
}
isStarted=true;
if (maxConnections==0)
maxConnections=maxIncomingConnections;
if (maxConnections==0)
maxConnections=1;
remoteClientsLength=maxConnections;
remoteClients=RakNet::OP_NEW_ARRAY<RemoteClient>(maxConnections,__FILE__,__LINE__);
if (maxIncomingConnections>0)
{
listenSocket = socket(AF_INET, SOCK_STREAM, 0);
if ((int)listenSocket ==-1)
return false;
struct sockaddr_in serverAddress;
serverAddress.sin_family = AF_INET;
serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddress.sin_port = htons(port);
if (bind(listenSocket,(struct sockaddr *) &serverAddress,sizeof(serverAddress)) < 0)
return false;
listen(listenSocket, maxIncomingConnections);
}
// Start the update thread
int errorCode = RakNet::RakThread::Create(UpdateTCPInterfaceLoop, this, threadPriority);
if (errorCode!=0)
return false;
while (threadRunning==false)
RakSleep(0);
return true;
}
void serverThread(std::recursive_mutex *mutex_, TestValues *testValues,
BaseClassA *serverAPtr, ClassC *serverCPtr, ClassD *serverDPtr,
RakNet::RPC3 *serverRpc, unsigned int peerCount,
unsigned int callCount) {
RakNet::RPC3 *emptyRpc = 0;
unsigned int count = callCount;
uint64_t startTime = RakNet::GetTimeUS();
while (count) {
for (size_t i = 1; i < peerCount; i++) {
uint64_t callNumber = i * callCount + count;
RakNet::BitStream testBitStream1, testBitStream2;
testBitStream1.Write("CPP TEST STRING");
testBitStream2.Write("CPP Remote call timestamp test string.");
RakNet::BitStream *testBitStream1Ptr = &testBitStream1;
uint64_t callTime = RakNet::GetTimeUS();
serverCPtr->ClassMemberFuncTest(
serverAPtr, *serverAPtr, serverCPtr, serverDPtr,
testBitStream1Ptr, testBitStream2, callNumber, callTime, emptyRpc
);
serverRpc->CallCPP(
"&ClassC::ClassMemberFuncTest", serverCPtr->GetNetworkID(),
serverAPtr, *serverAPtr, serverCPtr, serverDPtr,
testBitStream1Ptr, testBitStream2, callNumber, callTime, emptyRpc
);
RakNet::RakString rs("C Function call test string.");
const char *str = "C Remote call char * test.";
callTime = RakNet::GetTimeUS();
CFuncTest(rs, serverCPtr, str, callNumber, callTime, emptyRpc);
serverRpc->CallC("CFuncTest",
rs, serverCPtr, str, callNumber, callTime, emptyRpc);
callTime = RakNet::GetTimeUS();
serverRpc->Signal("TestSlotTest", callNumber, callTime);
}
count--;
RakSleep(16);
}
mutex_->lock();
testValues->callFunctionsTime = RakNet::GetTimeUS() - startTime;
mutex_->unlock();
delete emptyRpc;
}
RakNet::SystemAddress ServerConnectBlocking(RakNet::RakPeerInterface *rakPeer, const char *hostName)
{
char ipAddr[64];
printf("Enter IP of system %s is running on: ", hostName);
//Gets(ipAddr, sizeof(ipAddr));
if (ipAddr[0] == 0)
{
printf("Failed. Not connected to %s.\n", hostName);
return RakNet::UNASSIGNED_SYSTEM_ADDRESS;
}
char port[64];
printf("Enter port of system %s is running on: ", hostName);
//Gets(port, sizeof(port));
if (port[0] == 0)
{
printf("Failed. Not connected to %s.\n", hostName);
return RakNet::UNASSIGNED_SYSTEM_ADDRESS;
}
if (rakPeer->Connect(ipAddr, atoi(port), 0, 0) != RakNet::CONNECTION_ATTEMPT_STARTED)
{
printf("Failed connect call for %s.\n", hostName);
return RakNet::UNASSIGNED_SYSTEM_ADDRESS;
}
printf("Connecting...\n");
RakNet::Packet *packet;
while (1)
{
for (packet = rakPeer->Receive(); packet; rakPeer->DeallocatePacket(packet), packet = rakPeer->Receive())
{
if (packet->data[0] == ID_CONNECTION_REQUEST_ACCEPTED)
{
return packet->systemAddress;
}
else
{
return RakNet::UNASSIGNED_SYSTEM_ADDRESS;
}
RakSleep(100);
}
}
}
void RNS2_Berkley::BlockOnStopRecvPollingThread(void)
{
endThreads=true;
// Get recvfrom to unblock
RNS2_SendParameters bsp;
unsigned long zero=0;
bsp.data=(char*) &zero;
bsp.length=4;
bsp.systemAddress=boundAddress;
bsp.ttl=0;
Send(&bsp, _FILE_AND_LINE_);
RakNet::TimeMS timeout = RakNet::GetTimeMS()+1000;
while ( isRecvFromLoopThreadActive.GetValue()>0 && RakNet::GetTimeMS()<timeout )
{
// Get recvfrom to unblock
Send(&bsp, _FILE_AND_LINE_);
RakSleep(30);
}
}
std::vector<RakNet::RakString> NetworkEngine::getLanServers()
{
//En el server browser se utiliza getLanServersList()
std::vector<RakNet::RakString> serverList;
RakNet::Packet *packet;
peer->Ping("255.255.255.255", SERVER_PORT, false);
RakNet::TimeMS timeout = RakNet::GetTimeMS() + 1000;
while(RakNet::GetTimeMS() < timeout) // Bloquea durante 1s el juego
{
packet = peer->Receive();
while(packet != 0) //Ha llegado un paquete
{
if (packet->data[0]==ID_UNCONNECTED_PONG)
{
RakNet::TimeMS time;
RakNet::BitStream bsIn(packet->data,packet->length,false);
bsIn.IgnoreBytes(1);
bsIn.Read(time);
//char playerData;
//bsIn.Read(playerData);
std::cout<<peer->NumberOfConnections()<<std::endl;
//std::cout << "Server: " << packet->systemAddress.ToString() << ", players: "<< playerData << "/4, ping: "<< RakNet::GetTimeMS() - time << "ms\n";
std::cout << "Server: " << packet->systemAddress.ToString() << ", ping: "<< RakNet::GetTimeMS() - time << "ms\n";
serverList.push_back((RakNet::RakString) packet->systemAddress.ToString(false));
timeout -= 500; // Si ha encontrado un servidor termina antes
}
peer->DeallocatePacket(packet);
packet = peer->Receive();
}
RakSleep(30);
}
return serverList;
}
bool TCPInterface::Start(unsigned short port, unsigned short maxIncomingConnections, unsigned short maxConnections)
{
if (isStarted)
return false;
isStarted=true;
if (maxConnections==0)
maxConnections=maxIncomingConnections;
if (maxConnections==0)
maxConnections=1;
remoteClientsLength=maxConnections;
remoteClients=RakNet::OP_NEW_ARRAY<RemoteClient>(maxConnections,__FILE__,__LINE__);
if (maxIncomingConnections>0)
{
listenSocket = socket(AF_INET, SOCK_STREAM, 0);
if ((int)listenSocket ==-1)
return false;
struct sockaddr_in serverAddress;
serverAddress.sin_family = AF_INET;
serverAddress.sin_addr.s_addr = htonl(INADDR_ANY);
serverAddress.sin_port = htons(port);
if (bind(listenSocket,(struct sockaddr *) &serverAddress,sizeof(serverAddress)) < 0)
return false;
listen(listenSocket, maxIncomingConnections);
}
// Start the update thread
int errorCode = RakNet::RakThread::Create(UpdateTCPInterfaceLoop, this);
if (errorCode!=0)
return false;
while (threadRunning==false)
RakSleep(0);
return true;
}
void FrameTimer::step()
{
double timeToSleep = 1 / _framerate;
timeToSleep -= now() - _frameTime;
if (timeToSleep < 0)
timeToSleep = 0;
// Always sleep, even if 0, to play nice with other programs
RakSleep(static_cast<unsigned int>(toTimestamp(timeToSleep)));
double previous = _frameTime;
_frameTime = now();
_elapsed = _frameTime - previous;
// Framerate computation
if (_totalFrameTiming > FRAMERATE_SECONDS && !_frameTiming.empty()) {
_totalFrameTiming -= _frameTiming.front();
_frameTiming.pop_front();
}
_totalFrameTiming += _elapsed;
_frameTiming.push_back(_elapsed);
}
void ServerHost::run( int port )
{
RakNet::SocketDescriptor socketDescriptors;
socketDescriptors.port=port;
socketDescriptors.socketFamily=AF_INET; // Test out IPV4
m_server->SetMaximumIncomingConnections(400);
// Try again, but leave out IPV6
bool b = m_server->Startup(400, &socketDescriptors, 1 )==RakNet::RAKNET_STARTED;
if (!b)
{
puts("Server failed to start. Terminating.");
exit(1);
}
m_server->SetTimeoutTime(10000,RakNet::UNASSIGNED_SYSTEM_ADDRESS);
m_server->SetOccasionalPing(true);
//m_server->SetUnreliableTimeout(1000);
prerun(port);
RakNet::TimeMS time0 = RakNet::GetTimeMS();
while(true)
{
doTick();
runtick();
RakSleep(30);
RakNet::TimeMS time1 = RakNet::GetTimeMS();
RakNet::TimeMS difference = time1 - time0;
if(difference >= 1000)
{
time0 = RakNet::GetTimeMS();
tick();
}
}
postrun();
}
void ManyClientsOneServerDeallocateBlockingTest::WaitForConnectionRequestsToComplete(RakPeerInterface **clientList, int clientNum, bool isVerbose)
{
SystemAddress currentSystem;
bool msgWasPrinted=false;
for (int i=0;i<clientNum;i++)
{
currentSystem.SetBinaryAddress("127.0.0.1");
currentSystem.port=60000;
while (clientList[i]->IsConnectionAttemptPending (currentSystem) )
{
if (msgWasPrinted==false)
{
printf("Waiting for connection requests to complete.\n");
msgWasPrinted=true;
}
RakSleep(30);
}
}
}
void ManyClientsOneServerBlockingTest::WaitForConnectionRequestsToComplete(RakPeerInterface **clientList, int clientNum, bool isVerbose)
{
SystemAddress currentSystem;
bool msgWasPrinted=false;
for (int i=0;i<clientNum;i++)
{
currentSystem.SetBinaryAddress("127.0.0.1");
currentSystem.port=60000;
while (CommonFunctions::ConnectionStateMatchesOptions (clientList[i],currentSystem,false,true,true) )
{
if (msgWasPrinted==false)
{
printf("Waiting for connection requests to complete.\n");
msgWasPrinted=true;
}
RakSleep(30);
}
}
}
/*
What is being done here is having 8 peers all connect to eachother and be
connected. Then it check if they all connect. If so send data in ordered reliable mode for 100
loops.
Possible ideas for changes:
Possibly use rakpeerinterfaces GetSystemList() for number of
connected peers instead of manually tracking. Would be slower though,
shouldn't be significant at this number but the recieve speed it part of the test.
Success conditions:
Peers connect and receive all packets in order.
No disconnections allowed in this version of the test.
Failure conditions:
If cannot connect to all peers for 20 seconds.
All packets are not recieved.
All packets are not in order.
Disconnection.
*/
int EightPeerTest::RunTest(DataStructures::List<RakNet::RakString> params,bool isVerbose,bool noPauses)
{
const int peerNum= 8;
RakPeerInterface *peerList[peerNum];//A list of 8 peers
int connectionAmount[peerNum];//Counter for me to keep track of connection requests and accepts
int recievedFromList[peerNum][peerNum];//Counter for me to keep track of packets received
int lastNumberReceivedFromList[peerNum][peerNum];//Counter for me to keep track of last recieved sequence number
Packet *packet;
RakNet::BitStream bitStream;
destroyList.Clear(false,__FILE__,__LINE__);
//Initializations of the arrays
for (int i=0;i<peerNum;i++)
{
peerList[i]=RakNetworkFactory::GetRakPeerInterface();
destroyList.Push(peerList[i],__FILE__,__LINE__);
connectionAmount[i]=0;
for (int j=0;j<peerNum;j++)
{
recievedFromList[i][j]=0;
lastNumberReceivedFromList[i][j]=0;
}
peerList[i]->Startup(peerNum*2, 30, &SocketDescriptor(60000+i,0), 1);
peerList[i]->SetMaximumIncomingConnections(peerNum);
}
//Connect all the peers together
for (int i=0;i<peerNum;i++)
{
for (int j=i+1;j<peerNum;j++)//Start at i+1 so don't connect two of the same together.
{
if (!peerList[i]->Connect("127.0.0.1", 60000+j, 0,0))
{
if (isVerbose)
{
DebugTools::ShowError("Problem while calling connect. \n",!noPauses && isVerbose,__LINE__,__FILE__);
}
return 1;//This fails the test, don't bother going on.
}
}
}
RakNetTime entryTime=RakNet::GetTime();//Loop entry time
bool initialConnectOver=false;//Our initial connect all has been done.
for (int k=0;k<100;)//Quit after we send 100 messages while connected, if not all connected and not failure, otherwise fail after 20 seconds and exit
{
bool allConnected=true;//Start true, only one failed case makes it all fail
for (int i=0;i<peerNum;i++)//Make sure all peers are connected to eachother
{
if (connectionAmount[i]<peerNum-1)
{
allConnected=false;
}
}
if (RakNet::GetTime()-entryTime>20000 &&!initialConnectOver &&!allConnected)//failed for 20 seconds
{
if (isVerbose)
DebugTools::ShowError("Failed to connect to all peers after 20 seconds",!noPauses && isVerbose,__LINE__,__FILE__);
return 2;
break;
}
if (allConnected)
{
if(!initialConnectOver)
initialConnectOver=true;
for (int i=0;i<peerNum;i++)//Have all peers send a message to all peers
{
bitStream.Reset();
bitStream.Write((unsigned char) (ID_USER_PACKET_ENUM+1));
bitStream.Write(k);
bitStream.Write(i);
peerList[i]->Send(&bitStream, HIGH_PRIORITY, RELIABLE_ORDERED ,0, UNASSIGNED_SYSTEM_ADDRESS, true);
}
k++;
}
if (k>=97)//This is our last 3 loops, give it time to send packet and arrive on interface, 2 seconds is more than enough
{
RakSleep(2000);
}
for (int i=0;i<peerNum;i++)//Receive for all peers
{
if (allConnected)//If all connected try to make the data more visually appealing by bunching it in one receive
{
int waittime=0;
do
{
packet=peerList[i]->Receive();
waittime++;
if (!packet)
{
RakSleep(1);
}
if (waittime>1000)//Check for packet every millisec and if one second has passed move on, don't block execution
{
break;
}
}
while(!packet);//For testing purposes wait for packet a little while, go if not recieved
}
else//Otherwise just keep recieving quickly until connected
{
packet=peerList[i]->Receive();
}
if (isVerbose)
printf("For peer %i with %i connected peers.\n",i,connectionAmount[i]);
while(packet)
{
switch (packet->data[0])
{
case ID_REMOTE_DISCONNECTION_NOTIFICATION:
if (isVerbose)
{
printf("Another client has disconnected.\n");
DebugTools::ShowError("Test failed.\n",!noPauses && isVerbose,__LINE__,__FILE__);
}
return 3;
break;
case ID_REMOTE_CONNECTION_LOST:
if (isVerbose)
{
printf("Another client has lost the connection.\n");
DebugTools::ShowError("Test failed.\n",!noPauses && isVerbose,__LINE__,__FILE__);
}
return 3;
break;
case ID_REMOTE_NEW_INCOMING_CONNECTION:
if (isVerbose)
printf("Another client has connected.\n");
break;
case ID_CONNECTION_REQUEST_ACCEPTED:
if (isVerbose)
printf("Our connection request has been accepted.\n");
connectionAmount[i]++;
break;
case ID_CONNECTION_ATTEMPT_FAILED:
if (isVerbose)
DebugTools::ShowError("A connection has failed.\n Test failed.\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 2;
break;
case ID_NEW_INCOMING_CONNECTION:
if (isVerbose)
printf("A connection is incoming.\n");
connectionAmount[i]++;//For this test assume connection. Test will fail if connection fails.
break;
case ID_NO_FREE_INCOMING_CONNECTIONS://Should not happend
if (isVerbose)
{
printf("The server is full. This shouldn't happen in this test ever.\n");
DebugTools::ShowError("Test failed.\n",!noPauses && isVerbose,__LINE__,__FILE__);
}
return 2;
break;
case ID_ALREADY_CONNECTED:
if (isVerbose)
printf("Already connected\n");//Shouldn't happen
break;
case ID_DISCONNECTION_NOTIFICATION:
if (isVerbose)
{
printf("We have been disconnected.\n");
DebugTools::ShowError("Test failed.\n",!noPauses && isVerbose,__LINE__,__FILE__);
}
return 3;
break;
case ID_CONNECTION_LOST:
allConnected=false;
connectionAmount[i]--;
if (isVerbose)
{
printf("Connection lost.\n");
DebugTools::ShowError("Test failed.\n",!noPauses && isVerbose,__LINE__,__FILE__);
}
return 3;
break;
default:
if (packet->data[0]==ID_USER_PACKET_ENUM+1)
{
int thePeerNum;
int sequenceNum;
bitStream.Reset();
bitStream.Write((char*)packet->data, packet->length);
bitStream.IgnoreBits(8);
bitStream.Read(sequenceNum);
bitStream.Read(thePeerNum);
if (isVerbose)
printf("Message %i from %i\n",sequenceNum,thePeerNum );
if (thePeerNum>=0&&thePeerNum<peerNum)
{
if (lastNumberReceivedFromList[i][thePeerNum]==sequenceNum)
{
lastNumberReceivedFromList[i][thePeerNum]++;
}
else
{
if (isVerbose)
{
printf("Packets out of order");
DebugTools::ShowError("Test failed.\n",!noPauses && isVerbose,__LINE__,__FILE__);
}
return 4;
}
recievedFromList[i][thePeerNum]++;}
}
break;
}
peerList[i]->DeallocatePacket(packet);
// Stay in the loop as long as there are more packets.
packet = peerList[i]->Receive();
}
}
RakSleep(0);//If needed for testing
}
for (int i=0;i<peerNum;i++)
{
for (int j=0;j<peerNum;j++)
{
if (i!=j)
{
if (isVerbose)
printf("%i recieved %i packets from %i\n",i,recievedFromList[i][j],j);
if (recievedFromList[i][j]!=100)
{
if (isVerbose)
{
printf("Not all packets recieved. it was in reliable ordered mode so that means test failed or wait time needs increasing\n");
DebugTools::ShowError("Test failed.\n",!noPauses && isVerbose,__LINE__,__FILE__);
}
return 5;
}
}
}
}
printf("All packets recieved in order,pass\n");
return 0;
}
/*
Description:
Tests:
virtual void RakPeerInterface::AddToSecurityExceptionList ( const char * ip )
virtual void RakPeerInterface::AddToBanList ( const char * IP, TimeMS milliseconds = 0 )
virtual void RakPeerInterface::GetIncomingPassword ( char * passwordData, int * passwordDataLength )
virtual void RakPeerInterface::InitializeSecurity ( const char * pubKeyE, const char * pubKeyN, const char * privKeyP, const char * privKeyQ )
virtual bool RakPeerInterface::IsBanned ( const char * IP )
virtual bool RakPeerInterface::IsInSecurityExceptionList ( const char * ip )
virtual void RakPeerInterface::RemoveFromSecurityExceptionList ( const char * ip )
virtual void RakPeerInterface::RemoveFromBanList ( const char * IP )
virtual void RakPeerInterface::SetIncomingPassword ( const char * passwordData, int passwordDataLength )
virtual void ClearBanList (void)=0
Success conditions:
All functions pass tests.
Failure conditions:
Any function fails test.
Client connects with no password
Client connects with wrong password
Client failed to connect with correct password
Client was banned but connected anyways
GetIncomingPassword returned wrong password
IsBanned does not show localhost as banned
Localhost was not unbanned
Client failed to connect after banlist removal
Client failed to connect after banlist removal with clear function
Client did not connect encrypted
Client connected encrypted but shouldn't have
IsInSecurityExceptionList does not register localhost addition
RakPeerInterface Functions used, tested indirectly by its use:
Startup
SetMaximumIncomingConnections
Receive
DeallocatePacket
Send
IsConnected
GetStatistics
RakPeerInterface Functions Explicitly Tested:
SetIncomingPassword
GetIncomingPassword
AddToBanList
IsBanned
RemoveFromBanList
ClearBanList
InitializeSecurity //Disabled because of RakNetStatistics changes
AddToSecurityExceptionList //Disabled because of RakNetStatistics changes
IsInSecurityExceptionList //Disabled because of RakNetStatistics changes
RemoveFromSecurityExceptionList //Disabled because of RakNetStatistics changes
*/
int SecurityFunctionsTest::RunTest(DataStructures::List<RakString> params,bool isVerbose,bool noPauses)
{
char thePassword[]="password";
server=RakPeerInterface::GetInstance();
client=RakPeerInterface::GetInstance();
client->Startup(1,&SocketDescriptor(),1);
server->Startup(1,&SocketDescriptor(60000,0),1);
server->SetMaximumIncomingConnections(1);
server->SetIncomingPassword(thePassword,(int)strlen(thePassword));
char returnedPass[22];
int returnedLen=22;
server->GetIncomingPassword(returnedPass,&returnedLen);
returnedPass[returnedLen]=0;//Password is a data block convert to null terminated string to make the test easier
if (strcmp(returnedPass,thePassword)!=0)
{
if (isVerbose)
{
printf("%s was returned but %s is the password\n",returnedPass,thePassword);
DebugTools::ShowError("GetIncomingPassword returned wrong password\n",!noPauses && isVerbose,__LINE__,__FILE__);
}
return 5;
}
SystemAddress serverAddress;
serverAddress.SetBinaryAddress("127.0.0.1");
serverAddress.port=60000;
TimeMS entryTime=GetTimeMS();
if (isVerbose)
printf("Testing if no password is rejected\n");
while(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true)&&GetTimeMS()-entryTime<5000)
{
if(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))
{
client->Connect("127.0.0.1",serverAddress.port,0,0);
}
RakSleep(100);
}
if (CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true))
{
if (isVerbose)
DebugTools::ShowError("Client connected with no password\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 1;
}
if (isVerbose)
printf("Testing if incorrect password is rejected\n");
char badPass[]="badpass";
entryTime=GetTimeMS();
while(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true)&&GetTimeMS()-entryTime<5000)
{
if(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))
{
client->Connect("127.0.0.1",serverAddress.port,badPass,(int)strlen(badPass));
}
RakSleep(100);
}
if (CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true))
{
if (isVerbose)
DebugTools::ShowError("Client connected with wrong password\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 2;
}
if (isVerbose)
printf("Testing if correct password is accepted\n");
entryTime=GetTimeMS();
while(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true)&&GetTimeMS()-entryTime<5000)
{
if(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))
{
client->Connect("127.0.0.1",serverAddress.port,thePassword,(int)strlen(thePassword));
}
RakSleep(100);
}
if (!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true))
{
if (isVerbose)
DebugTools::ShowError("Client failed to connect with correct password\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 3;
}
while(CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))//disconnect client
{
client->CloseConnection (serverAddress,true,0,LOW_PRIORITY);
}
if (isVerbose)
printf("Testing if connection is rejected after adding to ban list\n");
server->AddToBanList("127.0.0.1",0);
entryTime=GetTimeMS();
while(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true)&&GetTimeMS()-entryTime<5000)
{
if(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))
{
client->Connect("127.0.0.1",serverAddress.port,thePassword,(int)strlen(thePassword));
}
RakSleep(100);
}
if(!server->IsBanned("127.0.0.1"))
{
if (isVerbose)
DebugTools::ShowError("IsBanned does not show localhost as banned\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 6;
}
if (CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true))
{
if (isVerbose)
DebugTools::ShowError("Client was banned but connected anyways\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 4;
}
if (isVerbose)
printf("Testing if connection is accepted after ban removal by RemoveFromBanList\n");
server->RemoveFromBanList("127.0.0.1");
if(server->IsBanned("127.0.0.1"))
{
if (isVerbose)
DebugTools::ShowError("Localhost was not unbanned\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 7;
}
entryTime=GetTimeMS();
while(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true)&&GetTimeMS()-entryTime<5000)
{
if(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))
{
client->Connect("127.0.0.1",serverAddress.port,thePassword,(int)strlen(thePassword));
}
RakSleep(100);
}
if (!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true))
{
if (isVerbose)
DebugTools::ShowError("Client failed to connect after banlist removal\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 8;
}
while(CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))//disconnect client
{
client->CloseConnection (serverAddress,true,0,LOW_PRIORITY);
}
if (isVerbose)
printf("Testing if connection is rejected after adding to ban list\n");
server->AddToBanList("127.0.0.1",0);
entryTime=GetTimeMS();
while(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true)&&GetTimeMS()-entryTime<5000)
{
if(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))
{
client->Connect("127.0.0.1",serverAddress.port,thePassword,(int)strlen(thePassword));
}
RakSleep(100);
}
if(!server->IsBanned("127.0.0.1"))
{
if (isVerbose)
DebugTools::ShowError("IsBanned does not show localhost as banned\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 6;
}
if (CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true))
{
if (isVerbose)
DebugTools::ShowError("Client was banned but connected anyways\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 4;
}
if (isVerbose)
printf("Testing if connection is accepted after ban removal by ClearBanList\n");
server->ClearBanList();
if(server->IsBanned("127.0.0.1"))
{
if (isVerbose)
DebugTools::ShowError("Localhost was not unbanned\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 7;
}
entryTime=GetTimeMS();
while(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true)&&GetTimeMS()-entryTime<5000)
{
if(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))
{
client->Connect("127.0.0.1",serverAddress.port,thePassword,(int)strlen(thePassword));
}
RakSleep(100);
}
if (!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true))
{
if (isVerbose)
DebugTools::ShowError("Client failed to connect after banlist removal with clear function\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 9;
}
while(CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))//disconnect client
{
client->CloseConnection (serverAddress,true,0,LOW_PRIORITY);
}
/*//Disabled because of statistics changes
if (isVerbose)
printf("Testing InitializeSecurity on server\n");
//-----------------------------
// RSACrypt is a using namespace RakNet;
class that handles RSA encryption/decryption internally
RSACrypt rsacrypt;
uint32_t e;
uint32_t modulus[RAKNET_RSA_FACTOR_LIMBS];
uint32_t p[RAKNET_RSA_FACTOR_LIMBS/2],q[RAKNET_RSA_FACTOR_LIMBS/2];
printf("Generating %i bit key. This will take a while...\n", RAKNET_RSA_FACTOR_LIMBS*32);
rsacrypt.generatePrivateKey(RAKNET_RSA_FACTOR_LIMBS);
e=rsacrypt.getPublicExponent();
rsacrypt.getPublicModulus(modulus);
rsacrypt.getPrivateP(p);
rsacrypt.getPrivateQ(q);
RakPeerInterface::DestroyInstance(server);
server=RakPeerInterface::GetInstance();
server->InitializeSecurity(0,0,(char*)p, (char*)q);
server->Startup(1,30,&SocketDescriptor(60000,0),1);
server->SetMaximumIncomingConnections(1);
server->SetIncomingPassword(thePassword,strlen(thePassword));
if (isVerbose)
printf("Testing if client connects encrypted\n");
entryTime=GetTimeMS();
while(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true)&&GetTimeMS()-entryTime<5000)
{
if(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))
{
client->Connect("127.0.0.1",serverAddress.port,thePassword,strlen(thePassword));
}
RakSleep(100);
}
char str2[]="AAAAAAAAAA";
str2[0]=(char)(ID_USER_PACKET_ENUM+1);
client->Send(str2,(int) strlen(str2)+1, HIGH_PRIORITY, RELIABLE_ORDERED ,0, UNASSIGNED_SYSTEM_ADDRESS, true);
client->Send(str2,(int) strlen(str2)+1, HIGH_PRIORITY, RELIABLE_ORDERED ,0, UNASSIGNED_SYSTEM_ADDRESS, true);
Packet *packet;
entryTime=GetTimeMS();
while(GetTimeMS()-entryTime<1000)
{
for (packet=server->Receive(); packet;server->DeallocatePacket(packet), packet=server->Receive())
{
}
}
RakNetStatistics *rss;
rss=client->GetStatistics(serverAddress);
if (rss->encryptionBitsSent<=0)//If we did connect encrypted we should see encryptionBitsSent
{
if (isVerbose)
DebugTools::ShowError("Client did not connect encrypted\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 10;
}
while(CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))//disconnect client
{
client->CloseConnection (serverAddress,true,0,LOW_PRIORITY);
}
//Destroy to clear statistics
RakPeerInterface::DestroyInstance(client);
client=RakPeerInterface::GetInstance();
client->Startup(1,30,&SocketDescriptor(),1);
if (isVerbose)
printf("Testing AddToSecurityExceptionList client should connect without encryption\n");
server->AddToSecurityExceptionList("127.0.0.1");
if (!server->IsInSecurityExceptionList("127.0.0.1"))
{
if (isVerbose)
DebugTools::ShowError("IsInSecurityExceptionList does not register localhost addition\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 12;
}
entryTime=GetTimeMS();
while(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true)&&GetTimeMS()-entryTime<5000)
{
if(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))
{
client->Connect("127.0.0.1",serverAddress.port,thePassword,strlen(thePassword));
}
RakSleep(100);
}
str2[0]=(char)(ID_USER_PACKET_ENUM+1);
client->Send(str2,(int) strlen(str2)+1, HIGH_PRIORITY, RELIABLE_ORDERED ,0, UNASSIGNED_SYSTEM_ADDRESS, true);
client->Send(str2,(int) strlen(str2)+1, HIGH_PRIORITY, RELIABLE_ORDERED ,0, UNASSIGNED_SYSTEM_ADDRESS, true);
// Packet *packet;
entryTime=GetTimeMS();
while(GetTimeMS()-entryTime<1000)
{
for (packet=server->Receive(); packet;server->DeallocatePacket(packet), packet=server->Receive())
{
}
}
rss=client->GetStatistics(serverAddress);
if (rss->encryptionBitsSent>0)//If we did connect encrypted we should see encryptionBitsSent
{
if (isVerbose)
DebugTools::ShowError("Client connected encrypted but shouldn't have\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 11;
}
if (isVerbose)
printf("Testing RemoveFromSecurityExceptionList\n");
while(CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))//disconnect client
{
client->CloseConnection (serverAddress,true,0,LOW_PRIORITY);
}
server->RemoveFromSecurityExceptionList("127.0.0.1");
if (isVerbose)
printf("Testing if client connects encrypted\n");
entryTime=GetTimeMS();
while(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true)&&GetTimeMS()-entryTime<5000)
{
if(!CommonFunctions::ConnectionStateMatchesOptions (client,serverAddress,true,true,true,true))
{
client->Connect("127.0.0.1",serverAddress.port,thePassword,strlen(thePassword));
}
RakSleep(100);
}
str2[0]=(char)(ID_USER_PACKET_ENUM+1);
client->Send(str2,(int) strlen(str2)+1, HIGH_PRIORITY, RELIABLE_ORDERED ,0, UNASSIGNED_SYSTEM_ADDRESS, true);
client->Send(str2,(int) strlen(str2)+1, HIGH_PRIORITY, RELIABLE_ORDERED ,0, UNASSIGNED_SYSTEM_ADDRESS, true);
entryTime=GetTimeMS();
while(GetTimeMS()-entryTime<1000)
{
for (packet=server->Receive(); packet;server->DeallocatePacket(packet), packet=server->Receive())
{
}
}
rss=client->GetStatistics(serverAddress);
if (rss->encryptionBitsSent<=0)//If we did connect encrypted we should see encryptionBitsSent
{
if (isVerbose)
DebugTools::ShowError("Client did not connect encrypted\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 10;
}
*/
return 0;
}
int main(void)
{
printf("A sample on how to use RakVoice together with DirectSound.\n");
printf("You need a microphone for this sample.\n");
printf("RakVoice relies on Speex for voice encoding and decoding.\n");
printf("See DependentExtensions/RakVoice/speex-1.2beta3 for speex projects.\n");
printf("For windows, I had to define HAVE_CONFIG_H, include win32/config.h,\n");
printf("and include the files under libspeex, except those that start with test.\n");
printf("Difficulty: Advanced\n\n");
bool mute=false;
bool quit;
char ch;
char port[256];
rakPeer = RakNetworkFactory::GetRakPeerInterface();
#if defined(INTERACTIVE)
printf("Enter local port: ");
gets(port);
if (port[0]==0)
#endif
strcpy(port, "60000");
SocketDescriptor socketDescriptor(atoi(port),0);
rakPeer->Startup(4, 30, &socketDescriptor, 1);
rakPeer->SetMaximumIncomingConnections(4);
rakPeer->AttachPlugin(&rakVoice);
rakVoice.Init(SAMPLE_RATE, FRAMES_PER_BUFFER*sizeof(SAMPLE));
// Initialize our connection with DirectSound
if (!DSoundVoiceAdapter::Instance()->SetupAdapter(&rakVoice, GetConsoleHwnd(), DSSCL_EXCLUSIVE))
{
printf("An error occurred while initializing DirectSound.\n");
exit(-1);
}
Packet *p;
quit=false;
#if defined(INTERACTIVE)
printf("(Q)uit. (C)onnect. (D)isconnect. (M)ute. ' ' for stats.\n");
printf("(+/-)encoder complexity. (N)oise filter on/off. (V)AD on/off. (B)vbr on/off.\n");
#else
rakPeer->Connect("1.1.1.1", 60000, 0,0);
#endif
PrintParameters();
while (!quit)
{
#if defined(INTERACTIVE)
if (kbhit())
{
ch=getch();
if (ch=='+'){
// Increase encoder complexity
int v = rakVoice.GetEncoderComplexity();
if (v<10) rakVoice.SetEncoderComplexity(v+1);
PrintParameters();
}
else if (ch=='-'){
// Decrease encoder complexity
int v = rakVoice.GetEncoderComplexity();
if (v>0) rakVoice.SetEncoderComplexity(v-1);
PrintParameters();
}
else if (ch=='n'){
// Turn on/off noise filter
rakVoice.SetNoiseFilter(!rakVoice.IsNoiseFilterActive());
PrintParameters();
}
else if (ch=='v') {
// Turn on/off Voice detection
rakVoice.SetVAD(!rakVoice.IsVADActive());
PrintParameters();
}
else if (ch=='b') {
// Turn on/off VBR
rakVoice.SetVBR(!rakVoice.IsVBRActive());
PrintParameters();
}
else if (ch=='y')
{
quit=true;
}
else if (ch=='c')
{
char ip[256];
printf("\nEnter IP of remote system: ");
gets(ip);
if (ip[0]==0)
strcpy(ip, "127.0.0.1");
printf("\nEnter port of remote system: ");
gets(port);
if (port[0]==0)
strcpy(port, "60000");
rakPeer->Connect(ip, atoi(port), 0,0);
}
else if (ch=='m')
{
mute=!mute;
DSoundVoiceAdapter::Instance()->SetMute(mute);
if (mute)
printf("\nNow muted.\n");
else
printf("\nNo longer muted.\n");
}
else if (ch=='d')
{
rakPeer->Shutdown(100,0);
}
else if (ch==' ')
{
char message[2048];
RakNetStatistics *rss=rakPeer->GetStatistics(rakPeer->GetSystemAddressFromIndex(0));
StatisticsToString(rss, message, 2);
printf("%s", message);
}
else if (ch=='q')
quit=true;
ch=0;
}
#endif
p=rakPeer->Receive();
while (p)
{
if (p->data[0]==ID_CONNECTION_REQUEST_ACCEPTED)
{
printf("\nID_CONNECTION_REQUEST_ACCEPTED from %s\n", p->systemAddress.ToString());
rakVoice.RequestVoiceChannel(p->systemAddress);
}
else if (p->data[0]==ID_RAKVOICE_OPEN_CHANNEL_REQUEST)
{
printf("\nOpen Channel request from %s\n", p->systemAddress.ToString());
}
else if (p->data[0]==ID_RAKVOICE_OPEN_CHANNEL_REPLY)
{
printf("\nGot new channel from %s\n", p->systemAddress.ToString());
}
rakPeer->DeallocatePacket(p);
p=rakPeer->Receive();
}
// Update our connection with DirectSound
DSoundVoiceAdapter::Instance()->Update();
LogStats();
RakSleep(20);
}
// Release any FMOD resources we used, and shutdown FMOD itself
DSoundVoiceAdapter::Instance()->Release();
rakPeer->Shutdown(300);
RakNetworkFactory::DestroyRakPeerInterface(rakPeer);
return 0;
}
/*
Description: Tests what happens if two instances of RakNet connect to each other at the same time. This has caused handshaking problems in the past.
Success conditions:
Everything connects and sends normally.
Failure conditions:
Expected values from ping/pong do not occur within expected time.
*/
int CrossConnectionConvertTest::RunTest(DataStructures::List<RakString> params,bool isVerbose,bool noPauses)
{
static const unsigned short SERVER_PORT=1234;
// char serverMode[32];
char serverIP[64];
strcpy(serverIP,"127.0.0.1");
char clientIP[64];
RakPeerInterface *server,*client;
unsigned short clientPort;
bool gotNotification;
server=RakPeerInterface::GetInstance();
destroyList.Clear(false,_FILE_AND_LINE_);
destroyList.Push(server,_FILE_AND_LINE_);
client=RakPeerInterface::GetInstance();
destroyList.Push(client,_FILE_AND_LINE_);
server->Startup(1,&SocketDescriptor(SERVER_PORT,0), 1);
server->SetMaximumIncomingConnections(1);
client->Startup(1,&SocketDescriptor(0,0), 1);
client->Ping(serverIP,SERVER_PORT,false);
// PacketLogger pl;
// pl.LogHeader();
// rakPeer->AttachPlugin(&pl);
TimeMS connectionAttemptTime=0,connectionResultDeterminationTime=0,nextTestStartTime=0;
TimeMS entryTime=GetTimeMS();//Loop entry time
bool printedYet=false;
while(GetTimeMS()-entryTime<10000)//Run for 10 Secoonds
{
Packet *p;
printedYet=false;
for (p=server->Receive(); p; server->DeallocatePacket(p), p=server->Receive())
{
if (isVerbose&&!printedYet)
{
printf("Server:\n");
printedYet=true;
}
if (p->data[0]==ID_NEW_INCOMING_CONNECTION)
{
if (isVerbose)
printf("ID_NEW_INCOMING_CONNECTION\n");
gotNotification=true;
}
else if (p->data[0]==ID_CONNECTION_REQUEST_ACCEPTED)
{
if (isVerbose)
printf("ID_CONNECTION_REQUEST_ACCEPTED\n");
gotNotification=true;
}
else if (p->data[0]==ID_UNCONNECTED_PING)
{
if (isVerbose)
printf("ID_PING\n");
connectionAttemptTime=GetTimeMS()+1000;
p->systemAddress.ToString(false,clientIP);
clientPort=p->systemAddress.port;
gotNotification=false;
}
else if (p->data[0]==ID_UNCONNECTED_PONG)
{
if (isVerbose)
printf("ID_UNCONNECTED_PONG\n");
TimeMS sendPingTime;
BitStream bs(p->data,p->length,false);
bs.IgnoreBytes(1);
bs.Read(sendPingTime);
TimeMS rtt = GetTimeMS() - sendPingTime;
if (rtt/2<=500)
connectionAttemptTime=GetTimeMS()+1000-rtt/2;
else
connectionAttemptTime=GetTimeMS();
gotNotification=false;
}
}
printedYet=false;
for (p=client->Receive(); p; client->DeallocatePacket(p), p=client->Receive())
{
if (isVerbose&&!printedYet)
{
printf("Client:\n");
printedYet=true;
}
if (p->data[0]==ID_NEW_INCOMING_CONNECTION)
{
if (isVerbose)
printf("ID_NEW_INCOMING_CONNECTION\n");
gotNotification=true;
}
else if (p->data[0]==ID_CONNECTION_REQUEST_ACCEPTED)
{
if (isVerbose)
printf("ID_CONNECTION_REQUEST_ACCEPTED\n");
gotNotification=true;
}
else if (p->data[0]==ID_UNCONNECTED_PING)
{
if (isVerbose)
printf("ID_PING\n");
connectionAttemptTime=GetTimeMS()+1000;
p->systemAddress.ToString(false,clientIP);
clientPort=p->systemAddress.port;
gotNotification=false;
}
else if (p->data[0]==ID_UNCONNECTED_PONG)
{
if (isVerbose)
printf("ID_UNCONNECTED_PONG\n");
TimeMS sendPingTime;
BitStream bs(p->data,p->length,false);
bs.IgnoreBytes(1);
bs.Read(sendPingTime);
TimeMS rtt = GetTimeMS() - sendPingTime;
if (rtt/2<=500)
connectionAttemptTime=GetTimeMS()+1000-rtt/2;
else
connectionAttemptTime=GetTimeMS();
gotNotification=false;
}
}
if (connectionAttemptTime!=0 && GetTimeMS()>=connectionAttemptTime)
{
if (isVerbose)
printf("Attemping connection\n");
connectionAttemptTime=0;
server->Connect(clientIP,clientPort,0,0);
client->Connect(serverIP,SERVER_PORT,0,0);
connectionResultDeterminationTime=GetTimeMS()+2000;
}
if (connectionResultDeterminationTime!=0 && GetTimeMS()>=connectionResultDeterminationTime)
{
connectionResultDeterminationTime=0;
if (gotNotification==false)
{
DebugTools::ShowError("Did not recieve expected response. \n",!noPauses && isVerbose,__LINE__,__FILE__);
return 1;
}
SystemAddress sa;
sa.SetBinaryAddress(serverIP);
sa.port=SERVER_PORT;
client->CancelConnectionAttempt(sa);
sa.SetBinaryAddress(clientIP);
sa.port=clientPort;
server->CancelConnectionAttempt(sa);
server->CloseConnection(server->GetSystemAddressFromIndex(0),true,0);
client->CloseConnection(client->GetSystemAddressFromIndex(0),true,0);
//if (isServer==false)
nextTestStartTime=GetTimeMS()+1000;
}
if (nextTestStartTime!=0 && GetTimeMS()>=nextTestStartTime)
{
client->Ping(serverIP,SERVER_PORT,false);
nextTestStartTime=0;
}
RakSleep(0);
}
if (isVerbose)
printf("Test succeeded.\n");
return 0;
}
int main()
{
printf("TODO Rename RackspaceConsole.\nAdd RackspaceServerManager, uses CloudClient to monitor load, reboot lost servers.\n");
#if OPEN_SSL_CLIENT_SUPPORT!=1
printf("RakNet must be built with OPEN_SSL_CLIENT_SUPPORT");
return 1;
#endif
RakNet::Rackspace rackspaceApi;
RakNet::TCPInterface tcpInterface;
DisplayHTMLPage callback;
rackspaceApi.AddEventCallback(&callback);
tcpInterface.Start(0, 0, 1);
if (!Authenticate(&rackspaceApi, &tcpInterface))
{
return 1;
}
//rackspaceApi.ListImages();
PrintCommands();
RakNet::SystemAddress systemAddress;
RakNet::Packet *packet;
while (1)
{
for (packet=tcpInterface.Receive(); packet; tcpInterface.DeallocatePacket(packet), packet=tcpInterface.Receive())
{
rackspaceApi.OnReceive(packet);
}
RakNet::SystemAddress lostConnectionAddress = tcpInterface.HasLostConnection();
if (lostConnectionAddress!=RakNet::UNASSIGNED_SYSTEM_ADDRESS)
rackspaceApi.OnClosedConnection(lostConnectionAddress);
if (kbhit())
{
printf("Command: ");
char command[128];
Gets(command, sizeof(command));
if (stricmp(command,"Help")==0)
{
PrintCommands();
}
else if (stricmp(command,"Quit")==0)
{
break;
}
else if (stricmp(command,"Authenticate")==0)
{
Authenticate(&rackspaceApi, &tcpInterface);
}
else if (stricmp(command,"ListServers")==0)
{
rackspaceApi.ListServers();
}
else if (stricmp(command,"ListServersWithDetails")==0)
{
rackspaceApi.ListServersWithDetails();
}
else if (stricmp(command,"CreateServer")==0)
{
RakNet::RakString name;
printf("Enter server name: ");
Gets(command, sizeof(command));
name=command;
RakNet::RakString imageId;
printf("Enter imageId: ");
Gets(command, sizeof(command));
imageId=command;
RakNet::RakString flavorId;
printf("Enter flavorId: ");
Gets(command, sizeof(command));
flavorId=command;
rackspaceApi.CreateServer(name, imageId, flavorId);
}
else if (stricmp(command,"GetServerDetails")==0)
{
printf("Enter server id: ");
Gets(command, sizeof(command));
rackspaceApi.GetServerDetails(command);
}
else if (stricmp(command,"UpdateServerNameOrPassword")==0)
{
RakNet::RakString serverId;
printf("Enter server id: ");
Gets(command, sizeof(command));
serverId=command;
RakNet::RakString newName;
printf("Enter newName: ");
Gets(command, sizeof(command));
newName=command;
RakNet::RakString newPassword;
printf("Enter newPassword: "******"DeleteServer")==0)
{
printf("Enter server id: ");
Gets(command, sizeof(command));
rackspaceApi.DeleteServer(command);
}
else if (stricmp(command,"ListServerAddresses")==0)
{
printf("Enter server id: ");
Gets(command, sizeof(command));
rackspaceApi.ListServerAddresses(command);
}
else if (stricmp(command,"ShareServerAddress")==0)
{
RakNet::RakString serverId;
printf("Enter server id: ");
Gets(command, sizeof(command));
serverId=command;
RakNet::RakString serverAddress;
printf("Enter server serverAddress: ");
Gets(command, sizeof(command));
serverAddress=command;
rackspaceApi.ShareServerAddress(serverId, serverAddress);
}
else if (stricmp(command,"DeleteServerAddress")==0)
{
RakNet::RakString serverId;
printf("Enter server id: ");
Gets(command, sizeof(command));
serverId=command;
RakNet::RakString serverAddress;
printf("Enter server serverAddress: ");
Gets(command, sizeof(command));
serverAddress=command;
rackspaceApi.DeleteServerAddress(serverId, serverAddress);
}
else if (stricmp(command,"RebootServer")==0)
{
RakNet::RakString serverId;
printf("Enter server id: ");
Gets(command, sizeof(command));
serverId=command;
RakNet::RakString rebootType;
printf("Enter rebootType: ");
Gets(command, sizeof(command));
rebootType=command;
rackspaceApi.RebootServer(serverId,rebootType);
}
else if (stricmp(command,"RebuildServer")==0)
{
RakNet::RakString serverId;
printf("Enter server id: ");
Gets(command, sizeof(command));
serverId=command;
RakNet::RakString imageId;
printf("Enter imageId: ");
Gets(command, sizeof(command));
imageId=command;
rackspaceApi.RebuildServer(serverId,imageId);
}
else if (stricmp(command,"ResizeServer")==0)
{
RakNet::RakString serverId;
printf("Enter server id: ");
Gets(command, sizeof(command));
serverId=command;
RakNet::RakString flavorId;
printf("Enter flavorId: ");
Gets(command, sizeof(command));
flavorId=command;
rackspaceApi.ResizeServer(serverId,flavorId);
}
else if (stricmp(command,"ConfirmResizedServer")==0)
{
printf("Enter server id: ");
Gets(command, sizeof(command));
rackspaceApi.ConfirmResizedServer(command);
}
else if (stricmp(command,"RevertResizedServer")==0)
{
printf("Enter server id: ");
Gets(command, sizeof(command));
rackspaceApi.RevertResizedServer(command);
}
else if (stricmp(command,"ListFlavors")==0)
{
rackspaceApi.ListFlavors();
}
else if (stricmp(command,"GetFlavorDetails")==0)
{
printf("Enter flavor id: ");
Gets(command, sizeof(command));
rackspaceApi.GetFlavorDetails(command);
}
else if (stricmp(command,"ListImages")==0)
{
rackspaceApi.ListImages();
}
else if (stricmp(command,"CreateImage")==0)
{
RakNet::RakString serverId;
printf("Enter server id: ");
Gets(command, sizeof(command));
serverId=command;
RakNet::RakString imageName;
printf("Enter imageName: ");
Gets(command, sizeof(command));
imageName=command;
rackspaceApi.CreateImage(serverId,imageName);
}
else if (stricmp(command,"GetImageDetails")==0)
{
printf("Enter image id: ");
Gets(command, sizeof(command));
rackspaceApi.GetImageDetails(command);
}
else if (stricmp(command,"DeleteImage")==0)
{
printf("Enter image id: ");
Gets(command, sizeof(command));
rackspaceApi.DeleteImage(command);
}
else if (stricmp(command,"ListSharedIPGroups")==0)
{
rackspaceApi.ListSharedIPGroups();
}
else if (stricmp(command,"ListSharedIPGroupsWithDetails")==0)
{
rackspaceApi.ListSharedIPGroupsWithDetails();
}
else if (stricmp(command,"CreateSharedIPGroup")==0)
{
rackspaceApi.CreateSharedIPGroup("testSharedIPGroup","");
}
else if (stricmp(command,"GetSharedIPGroupDetails")==0)
{
printf("Enter group id: ");
Gets(command, sizeof(command));
rackspaceApi.GetSharedIPGroupDetails(command);
}
else if (stricmp(command,"DeleteSharedIPGroup")==0)
{
printf("Enter group id: ");
Gets(command, sizeof(command));
rackspaceApi.DeleteSharedIPGroup(command);
}
else
{
printf("Unknown command. Type 'help' for help.\n");
}
}
RakSleep(30);
}
return 0;
}
void main(void)
{
printf("The 2nd interation of the lobby server.\n");
printf("Difficulty: Intermediate\n\n");
char serverPort[30];
RakPeerInterface *rakPeer=RakNetworkFactory::GetRakPeerInterface();
rakPeer->SetTimeoutTime(5000,UNASSIGNED_SYSTEM_ADDRESS);
//rakPeer->SetTimeoutTime(3000,UNASSIGNED_SYSTEM_ADDRESS);
// puts("Enter the rakPeer port to listen on");
serverPort[0]=0;
//gets(serverPort);
if (serverPort[0]==0)
strcpy(serverPort, "61111");
SocketDescriptor socketDescriptor(atoi(serverPort),0);
rakPeer->SetMaximumIncomingConnections(32);
if (rakPeer->Startup(32,30,&socketDescriptor, 1)==false)
{
printf("Startup call failed\n");
return;
}
else
printf("Started on port %i\n", socketDescriptor.port);
// Attach the plugin Lobby2Server
// The class factory will create messages with server functionality
RakNet::Lobby2Server_PGSQL lobby2Server;
rakPeer->AttachPlugin(&lobby2Server);
RakNet::Lobby2MessageFactory_PGSQL messageFactory;
lobby2Server.SetMessageFactory(&messageFactory);
// This is optional:
#ifdef __INTEGRATE_LOBBY2_WITH_ROOMS_PLUGIN
RakNet::RoomsPlugin roomsPluginServer;
rakPeer->AttachPlugin(&roomsPluginServer);
lobby2Server.SetRoomsPlugin(&roomsPluginServer);
ProfanityFilter profanityFilter;
profanityFilter.AddWord("Penis");
roomsPluginServer.SetProfanityFilter(&profanityFilter);
roomsPluginServer.roomsContainer.AddTitle("Test Title Name");
#endif
printf("Enter database password:\n");
char connectionString[256],password[128];
char username[256];
strcpy(username, "postgres");
password[0]=0;
gets(password);
if (password[0]==0) strcpy(password, "aaaa");
strcpy(connectionString, "user="******" password="******"Database connection failed\n");
return;
}
printf("Lobby2Server started and waiting for connections\n");
RakNet::Lobby2Server::ConfigurationProperties c;
c.requiresEmailAddressValidationToLogin=false;
c.requiresTitleToLogin=true;
c.accountRegistrationRequiresCDKey=false;
c.accountRegistrationRequiredAgeYears=0;
lobby2Server.SetConfigurationProperties(c);
#ifdef _ALSO_ACT_AS_NAT_PUNCH_SERVER
NatPunchthroughServer natPunchthroughServer;
RakNet::UDPProxyCoordinator udpProxyCoordinator;
RakNet::UDPProxyServer udpProxyServer;
RakNet::NatTypeDetectionServer natTypeDetectionServer;
udpProxyCoordinator.SetRemoteLoginPassword(COORDINATOR_PASSWORD);
rakPeer->AttachPlugin(&natPunchthroughServer);
rakPeer->AttachPlugin(&udpProxyServer);
rakPeer->AttachPlugin(&udpProxyCoordinator);
rakPeer->AttachPlugin(&natTypeDetectionServer);
char ipList[ MAXIMUM_NUMBER_OF_INTERNAL_IDS ][ 16 ];
unsigned int binaryAddresses[MAXIMUM_NUMBER_OF_INTERNAL_IDS];
SocketLayer::GetMyIP( ipList, binaryAddresses );
natTypeDetectionServer.Startup(ipList[1], ipList[2], ipList[3]);
// Login proxy server to proxy coordinator
// Normally the proxy server is on a different computer. Here, we login to our own IP address since the plugin is on the same system
udpProxyServer.LoginToCoordinator(COORDINATOR_PASSWORD, rakPeer->GetInternalID(UNASSIGNED_SYSTEM_ADDRESS));
#endif
Packet *packet;
// Loop for input
while (1)
{
for (packet=rakPeer->Receive(); packet; rakPeer->DeallocatePacket(packet), packet=rakPeer->Receive())
{
switch (packet->data[0])
{
case ID_DISCONNECTION_NOTIFICATION:
// Connection lost normally
printf("ID_DISCONNECTION_NOTIFICATION\n");
break;
case ID_NEW_INCOMING_CONNECTION:
// Connection lost normally
printf("ID_NEW_INCOMING_CONNECTION\n");
printf("Allowing all operations from remote client for testing (insecure)\n");
printf("Use Lobby2Server::ExecuteCommand for local server operations\n");
// For this test, allow all operations
lobby2Server.AddAdminAddress(packet->systemAddress);
lobby2Server.AddRankingAddress(packet->systemAddress);
break;
case ID_MODIFIED_PACKET:
// Cheater!
printf("ID_MODIFIED_PACKET\n");
break;
case ID_CONNECTION_LOST:
// Couldn't deliver a reliable packet - i.e. the other system was abnormally
// terminated
printf("ID_CONNECTION_LOST\n");
break;
}
}
// This sleep keeps RakNet responsive
RakSleep(30);
//printf("%i ", lobby2Server.GetUsers().Size());
}
RakNetworkFactory::DestroyRakPeerInterface(rakPeer);
}
void TCPInterface::Stop(void)
{
if (isStarted==false)
return;
unsigned i;
#if defined(OPEN_SSL_CLIENT_SUPPORT)
for (i=0; i < remoteClientsLength; i++)
remoteClients[i].DisconnectSSL();
#endif
isStarted=false;
if (listenSocket!=(SOCKET) -1)
{
#ifdef _WIN32
shutdown(listenSocket, SD_BOTH);
#else
shutdown(listenSocket, SHUT_RDWR);
#endif
closesocket(listenSocket);
listenSocket=(SOCKET) -1;
}
// Abort waiting connect calls
blockingSocketListMutex.Lock();
for (i=0; i < blockingSocketList.Size(); i++)
{
closesocket(blockingSocketList[i]);
}
blockingSocketListMutex.Unlock();
// Wait for the thread to stop
while ( threadRunning )
RakSleep(15);
RakSleep(100);
// Stuff from here on to the end of the function is not threadsafe
for (i=0; i < (unsigned int) remoteClientsLength; i++)
{
closesocket(remoteClients[i].socket);
#if defined(OPEN_SSL_CLIENT_SUPPORT)
remoteClients[i].FreeSSL();
#endif
}
remoteClientsLength=0;
RakNet::OP_DELETE_ARRAY(remoteClients,__FILE__,__LINE__);
remoteClients=0;
incomingMessages.Clear(__FILE__, __LINE__);
newIncomingConnections.Clear(__FILE__, __LINE__);
newRemoteClients.Clear(__FILE__, __LINE__);
lostConnections.Clear(__FILE__, __LINE__);
requestedCloseConnections.Clear(__FILE__, __LINE__);
failedConnectionAttempts.Clear(__FILE__, __LINE__);
completedConnectionAttempts.Clear(__FILE__, __LINE__);
failedConnectionAttempts.Clear(__FILE__, __LINE__);
for (i=0; i < headPush.Size(); i++)
DeallocatePacket(headPush[i]);
headPush.Clear(__FILE__, __LINE__);
for (i=0; i < tailPush.Size(); i++)
DeallocatePacket(tailPush[i]);
tailPush.Clear(__FILE__, __LINE__);
#if defined(OPEN_SSL_CLIENT_SUPPORT)
SSL_CTX_free (ctx);
startSSL.Clear(__FILE__, __LINE__);
activeSSLConnections.Clear(false, __FILE__, __LINE__);
#endif
}
int main()
{
RakNet::RakPeerInterface *rakPeer[2];
rakPeer[0]=RakNet::RakPeerInterface::GetInstance();
rakPeer[1]=RakNet::RakPeerInterface::GetInstance();
RakNet::SocketDescriptor sd1(50000,0),sd2(50002,0);
rakPeer[0]->Startup(1,&sd1, 1);
rakPeer[1]->Startup(1,&sd2, 1);
rakPeer[1]->SetMaximumIncomingConnections(1);
RakNet::UDPForwarder udpForwarder;
printf("Demonstrates the UDP Forwarder class\n");
printf("It routes datagrams from system to another, at the UDP level.\n");
printf("You probably won't use UDPForwarder directly.\n");
printf("See UDPProxyClient, UDPProxyServer, UDPProxyCoordinator.\n");
// Start the forwarder
udpForwarder.Startup();
// RakNet will send a message at least every 5 seconds. Add another second to account for thread latency
const RakNet::TimeMS timeoutOnNoDataMS=6000;
// Address is probably 192.168.0.1. Fix it to be 127.0.0.1.
// Only necessary to do this when connecting through the loopback on the local system. In a real system we'd stick with the external IP
RakNet::SystemAddress peer0Addr = rakPeer[0]->GetMyBoundAddress();
RakAssert(peer0Addr!=RakNet::UNASSIGNED_SYSTEM_ADDRESS);
RakNet::SystemAddress peer1Addr = rakPeer[1]->GetMyBoundAddress();
RakAssert(peer1Addr!=RakNet::UNASSIGNED_SYSTEM_ADDRESS);
// peer0Addr.FromString("127.0.0.1");
// peer1Addr.FromString("127.0.0.1");
unsigned short fowardPort;
if (!udpForwarder.StartForwarding(peer0Addr,peer1Addr, timeoutOnNoDataMS, 0, AF_INET, &fowardPort,0))
{
printf("Socket error\n");
return 1;
}
// Send a connect message to the forwarder, on the port to forward to rakPeer[1]
rakPeer[0]->Connect(peer1Addr.ToString(false), fowardPort, 0, 0);
printf("'q'uit.\n");
RakNet::Packet *p;
while (1)
{
for (int i=0; i < 2 ; i++)
{
p=rakPeer[i]->Receive();
while (p)
{
if (p->data[0]==ID_DISCONNECTION_NOTIFICATION)
printf("%s disconnected\n", p->systemAddress.ToString(true));
else if (p->data[0]==ID_CONNECTION_LOST)
printf("Lost connection to %s (failure)\n", p->systemAddress.ToString(true));
else if (p->data[0]==ID_NO_FREE_INCOMING_CONNECTIONS)
printf("%s has no free incoming connections.\n", p->systemAddress.ToString(true));
else if (p->data[0]==ID_NEW_INCOMING_CONNECTION)
printf("%s connected to us (success)\n", p->systemAddress.ToString(true));
else if (p->data[0]==ID_CONNECTION_REQUEST_ACCEPTED)
printf("Connection request accepted from %s (success)\n", p->systemAddress.ToString(true));
else if (p->data[0]==ID_CONNECTION_ATTEMPT_FAILED)
printf("Failed to connect to %s (failure)\n", p->systemAddress.ToString(true));
rakPeer[i]->DeallocatePacket(p);
p=rakPeer[i]->Receive();
}
}
udpForwarder.Update();
if (kbhit())
{
char ch = getch();
if (ch=='q' || ch=='Q')
break;
}
RakSleep(30);
}
rakPeer[0]->Shutdown(100,0);
rakPeer[1]->Shutdown(100,0);
RakNet::RakPeerInterface::DestroyInstance(rakPeer[0]);
RakNet::RakPeerInterface::DestroyInstance(rakPeer[1]);
return 0;
}
void RunAsClient(void)
{
rakClient = RakNetworkFactory::GetRakPeerInterface();
// Apple is defined in "Common.h", and it's our class derived from NetworkIDObject
Apple *serverApple = 0;
#if DOLOG
clientLogger.SetPrefix("CLIENT> ");
clientLogger.SetSuffix("\n");
rakClient->AttachPlugin(&clientLogger);
#endif
char serverip[256];
printf("Enter ip of the server (ENTER defaults to 127.0.0.1): ");
gets(serverip);
if (serverip[0]==0) strcpy(serverip, "127.0.0.1");
char serverport[256];
printf("Enter port of the server (ENTER defaults to 60000): ");
gets(serverport);
if (serverport[0]==0) strcpy(serverport, "60000");
rakClient->Startup(1, 30, &SocketDescriptor(), 1);
rakClient->Connect(serverip, atoi(serverport), 0,0);
// In a client/server architecture, only the server can create NetworkIDs
clientNetworkIDManager.SetIsNetworkIDAuthority(false);
rakClient->SetNetworkIDManager(&clientNetworkIDManager);
// Clear keyboard buffer before entering loop
while(kbhit()) getch();
do{
Packet *p = rakClient->Receive();
while(p){
unsigned char msgID = p->data[0];
// Check if the server has sent us the NetworkID of his Apple object
if (msgID==ID_USER_SERVERAPPLE_CREATED) {
RakNet::BitStream bs(p->data, p->length, false);
// Ignore the message ID
bs.IgnoreBits(8);
NetworkID appleNetworkID;
bs.Read(appleNetworkID);
// Create the object on the client side
serverApple = new GrannySmith;
serverApple->SetNetworkIDManager(&clientNetworkIDManager);
serverApple->SetNetworkID(appleNetworkID);
// Now that we have the object created, we can use RPC on it.
const char *hello="Hello World!!!!!";
rakClient->RPC(CLASS_MEMBER_ID(Apple,func1), hello, (unsigned int) (strlen(hello)+1)*8, HIGH_PRIORITY, RELIABLE_ORDERED,0, UNASSIGNED_SYSTEM_ADDRESS, true, 0, serverApple->GetNetworkID(),0);
rakClient->RPC(CLASS_MEMBER_ID(Apple,func2), hello, (unsigned int) (strlen(hello)+1)*8, HIGH_PRIORITY, RELIABLE_ORDERED,0, UNASSIGNED_SYSTEM_ADDRESS, true, 0, serverApple->GetNetworkID(),0);
rakClient->RPC(CLASS_MEMBER_ID(Apple,func3), hello, (unsigned int) (strlen(hello)+1)*8, HIGH_PRIORITY, RELIABLE_ORDERED,0, UNASSIGNED_SYSTEM_ADDRESS, true, 0, serverApple->GetNetworkID(),0);
}
rakClient->DeallocatePacket(p);
p = rakClient->Receive();
}
// Sleep for a while, so we don't eat all the CPU time with such a simple program.
// In a real game, you probably won't need this, as you want your game to run at full speed.
RakSleep(30);
} while(!kbhit());
// Shutdown
if (serverApple) delete serverApple;
rakClient->Shutdown(300);
RakNetworkFactory::DestroyRakPeerInterface(rakClient);
}
int ReliableOrderedConvertedTest::RunTest(DataStructures::List<RakString> params,bool isVerbose,bool noPauses)
{
RakPeerInterface *sender, *receiver;
unsigned int packetNumberSender[32],packetNumberReceiver[32], receivedPacketNumberReceiver, receivedTimeReceiver;
char str[256];
char ip[32];
TimeMS sendInterval, nextSend, currentTime, quitTime;
unsigned short remotePort, localPort;
unsigned char streamNumberSender,streamNumberReceiver;
BitStream bitStream;
Packet *packet;
bool doSend=false;
for (int i=0; i < 32; i++)
{
packetNumberSender[i]=0;
packetNumberReceiver[i]=0;
}
/*
if (argc==2)
{
fp = fopen(argv[1],"wt");
SetMalloc_Ex(LoggedMalloc);
SetRealloc_Ex(LoggedRealloc);
SetFree_Ex(LoggedFree);
}
else
*/
fp=0;
destroyList.Clear(false,_FILE_AND_LINE_);
sender =RakPeerInterface::GetInstance();
destroyList.Push( sender ,_FILE_AND_LINE_);
//sender->ApplyNetworkSimulator(.02, 100, 50);
/*
if (str[0]==0)
sendInterval=30;
else
sendInterval=atoi(str);*///possible future params
sendInterval=30;
/*
printf("Enter remote IP: ");
Gets(ip, sizeof(ip));
if (ip[0]==0)*/
strcpy(ip, "127.0.0.1");
/*
printf("Enter remote port: ");
Gets(str, sizeof(str));
if (str[0]==0)*/
strcpy(str, "60000");
remotePort=atoi(str);
/*
printf("Enter local port: ");
Gets(str, sizeof(str));
if (str[0]==0)*/
strcpy(str, "0");
localPort=atoi(str);
if (isVerbose)
printf("Connecting...\n");
sender->Startup(1, &SocketDescriptor(localPort,0), 1);
sender->Connect(ip, remotePort, 0, 0);
receiver =RakPeerInterface::GetInstance();
destroyList.Push( receiver ,_FILE_AND_LINE_);
/*
printf("Enter local port: ");
Gets(str, sizeof(str));
if (str[0]==0)*/
strcpy(str, "60000");
localPort=atoi(str);
if (isVerbose)
printf("Waiting for connections...\n");
receiver->Startup(32, &SocketDescriptor(localPort,0), 1);
receiver->SetMaximumIncomingConnections(32);
// if (sender)
// sender->ApplyNetworkSimulator(128000, 50, 100);
// if (receiver)
// receiver->ApplyNetworkSimulator(128000, 50, 100);
/*printf("How long to run this test for, in seconds?\n");
Gets(str, sizeof(str));
if (str[0]==0)*/
strcpy(str, "12");
currentTime = GetTimeMS();
quitTime = atoi(str) * 1000 + currentTime;
nextSend=currentTime;
while (currentTime < quitTime)
//while (1)
{
packet = sender->Receive();
while (packet)
{
// PARSE TYPES
switch(packet->data[0])
{
case ID_CONNECTION_REQUEST_ACCEPTED:
if (isVerbose)
printf("ID_CONNECTION_REQUEST_ACCEPTED\n");
doSend=true;
nextSend=currentTime;
break;
case ID_NO_FREE_INCOMING_CONNECTIONS:
if (isVerbose)
printf("ID_NO_FREE_INCOMING_CONNECTIONS\n");
break;
case ID_DISCONNECTION_NOTIFICATION:
if (isVerbose)
printf("ID_DISCONNECTION_NOTIFICATION\n");
break;
case ID_CONNECTION_LOST:
if (isVerbose)
printf("ID_CONNECTION_LOST\n");
break;
case ID_CONNECTION_ATTEMPT_FAILED:
if (isVerbose)
printf("Connection attempt failed\n");
break;
}
sender->DeallocatePacket(packet);
packet = sender->Receive();
}
while (doSend && currentTime > nextSend)
{
streamNumberSender=0;
// streamNumber = randomMT() % 32;
// Do the send
bitStream.Reset();
bitStream.Write((unsigned char) (ID_USER_PACKET_ENUM+1));
bitStream.Write(packetNumberSender[streamNumberSender]++);
bitStream.Write(streamNumberSender);
bitStream.Write(currentTime);
char *pad;
int padLength = (randomMT() % 5000) + 1;
pad = new char [padLength];
bitStream.Write(pad, padLength);
delete [] pad;
// Send on a random priority with a random stream
// if (sender->Send(&bitStream, HIGH_PRIORITY, (PacketReliability) (RELIABLE + (randomMT() %2)) ,streamNumber, UNASSIGNED_SYSTEM_ADDRESS, true)==false)
if (sender->Send(&bitStream, HIGH_PRIORITY, RELIABLE_ORDERED ,streamNumberSender, UNASSIGNED_SYSTEM_ADDRESS, true)==false)
packetNumberSender[streamNumberSender]--; // Didn't finish connecting yet?
RakNetStatistics *rssSender;
rssSender=sender->GetStatistics(sender->GetSystemAddressFromIndex(0));
if (isVerbose)
printf("Snd: %i.\n", packetNumberSender[streamNumberSender]);
nextSend+=sendInterval;
// Test halting
// if (rand()%20==0)
// nextSend+=1000;
}
packet = receiver->Receive();
while (packet)
{
switch(packet->data[0])
{
case ID_NEW_INCOMING_CONNECTION:
if (isVerbose)
printf("ID_NEW_INCOMING_CONNECTION\n");
break;
case ID_DISCONNECTION_NOTIFICATION:
if (isVerbose)
printf("ID_DISCONNECTION_NOTIFICATION\n");
break;
case ID_CONNECTION_LOST:
if (isVerbose)
printf("ID_CONNECTION_LOST\n");
break;
case ID_USER_PACKET_ENUM+1:
bitStream.Reset();
bitStream.Write((char*)packet->data, packet->length);
bitStream.IgnoreBits(8); // Ignore ID_USER_PACKET_ENUM+1
bitStream.Read(receivedPacketNumberReceiver);
bitStream.Read(streamNumberReceiver);
bitStream.Read(receivedTimeReceiver);
if (receivedPacketNumberReceiver!=packetNumberReceiver[streamNumberReceiver])
{
//WARNING: If you modify the below code make sure the whole string remains in bounds, sprintf will NOT do it for you.
//The error string is 512 in length
//Note: Removed buffer checking because chance is insignificant, left code if wanted in future. Needs limits.h ISO C standard.
/*
int maxIntWorkingCopy= INT_MAX;
int maxIntCharLen =0;
while (maxIntWorkingCopy>0)
{maxIntCharLen++;
maxIntWorkingCopy/=10;
}
if (strlen(lastError)>maxIntCharLen* 3 +27)//512 should be a good len for now
{*/
sprintf(lastError,"Expecting %i got %i (channel %i).",packetNumberReceiver[streamNumberReceiver], receivedPacketNumberReceiver, streamNumberReceiver);
/*
}
else
{
sprintf(lastError,"Did not get what was expected. More details can be given if the error string buffer size is increased.");
}*/
if (isVerbose)
{
RakNetStatistics *rssSender,*rssReceiver;
char message[2048];
rssSender=sender->GetStatistics(sender->GetSystemAddressFromIndex(0));
rssReceiver=receiver->GetStatistics(receiver->GetSystemAddressFromIndex(0));
StatisticsToString(rssSender, message, 2);
printf("Server stats %s\n", message);
StatisticsToString(rssReceiver, message, 2);
printf("Client stats%s", message);
DebugTools::ShowError(lastError,!noPauses && isVerbose,__LINE__,__FILE__);
}
return 1;
}
else
if (isVerbose)
{
printf("Got %i.Channel %i.Len %i.", packetNumberReceiver[streamNumberReceiver], streamNumberReceiver, packet->length);
printf("Sent=%u Received=%u Diff=%i.\n", receivedTimeReceiver, currentTime, (int)currentTime - (int) receivedTimeReceiver);
}
packetNumberReceiver[streamNumberReceiver]++;
break;
}
receiver->DeallocatePacket(packet);
packet = receiver->Receive();
}
RakSleep(0);
currentTime=GetTimeMS();
}
if (isVerbose)
{
RakNetStatistics *rssSender,*rssReceiver;
char message[2048];
rssSender=sender->GetStatistics(sender->GetSystemAddressFromIndex(0));
rssReceiver=receiver->GetStatistics(receiver->GetSystemAddressFromIndex(0));
StatisticsToString(rssSender, message, 2);
printf("Server stats %s\n", message);
StatisticsToString(rssReceiver, message, 2);
printf("Client stats%s", message);
}
if (fp)
fclose(fp);
return 0;
}
/*
What is being done here is having 8 peers all connect to eachother over the max defined connection.
It runs the connect, wait 20 seconds then see the current connections.
Success conditions:
All extra connections Refused.
Failure conditions:
There are more connected than allowed.
The connect function fails, the test is not even done.
GetMaximumIncomingConnections returns wrong value.
RakPeerInterface Functions used, tested indirectly by its use:
Startup
Connect
SetMaximumIncomingConnections
Receive
DeallocatePacket
GetSystemList
RakPeerInterface Functions Explicitly Tested:
SetMaximumIncomingConnections
GetMaximumIncomingConnections
*/
int MaximumConnectTest::RunTest(DataStructures::List<RakString> params,bool isVerbose,bool noPauses)
{
const int peerNum= 8;
const int maxConnections=4;//Max allowed connections for test
RakPeerInterface *peerList[peerNum];//A list of 8 peers
Packet *packet;
destroyList.Clear(false,_FILE_AND_LINE_);
int connReturn;
//Initializations of the arrays
for (int i=0;i<peerNum;i++)
{
peerList[i]=RakPeerInterface::GetInstance();
destroyList.Push(peerList[i],_FILE_AND_LINE_);
peerList[i]->Startup(maxConnections, &SocketDescriptor(60000+i,0), 1);
peerList[i]->SetMaximumIncomingConnections(maxConnections);
connReturn=peerList[i]->GetMaximumIncomingConnections();
if (connReturn!=maxConnections)
{
if (isVerbose)
{
printf("Getmaxconnections wrong for peer %i, %i should be the value but the value is %i.Fail\n",i,maxConnections,connReturn);
DebugTools::ShowError("",!noPauses && isVerbose,__LINE__,__FILE__);
}
}
}
//Connect all the peers together
for (int i=0;i<peerNum;i++)
{
for (int j=i+1;j<peerNum;j++)//Start at i+1 so don't connect two of the same together.
{
if (peerList[i]->Connect("127.0.0.1", 60000+j, 0,0)!=CONNECTION_ATTEMPT_STARTED)
{
if (isVerbose)
DebugTools::ShowError("Problem while calling connect.\n",!noPauses && isVerbose,__LINE__,__FILE__);
return 1;//This fails the test, don't bother going on.
}
}
}
TimeMS entryTime=GetTimeMS();//Loop entry time
while(GetTimeMS()-entryTime<20000)//Run for 20 Secoonds
{
for (int i=0;i<peerNum;i++)//Receive for all peers
{
packet=peerList[i]->Receive();
if (isVerbose&&packet)
printf("For peer %i\n",i);
while(packet)
{
switch (packet->data[0])
{
case ID_REMOTE_DISCONNECTION_NOTIFICATION:
if (isVerbose)
printf("Another client has disconnected.\n");
break;
case ID_REMOTE_CONNECTION_LOST:
if (isVerbose)
printf("Another client has lost the connection.\n");
break;
case ID_REMOTE_NEW_INCOMING_CONNECTION:
if (isVerbose)
printf("Another client has connected.\n");
break;
case ID_CONNECTION_REQUEST_ACCEPTED:
if (isVerbose)
printf("Our connection request has been accepted.\n");
break;
case ID_CONNECTION_ATTEMPT_FAILED:
if (isVerbose)
printf("A connection has failed.\n");//Should happen in this test
break;
case ID_NEW_INCOMING_CONNECTION:
if (isVerbose)
printf("A connection is incoming.\n");
break;
case ID_NO_FREE_INCOMING_CONNECTIONS:
if (isVerbose)
printf("The server is full.\n");
break;
case ID_ALREADY_CONNECTED:
if (isVerbose)
printf("Already connected\n");//Shouldn't happen
break;
case ID_DISCONNECTION_NOTIFICATION:
if (isVerbose)
printf("We have been disconnected.\n");
break;
case ID_CONNECTION_LOST:
if (isVerbose)
printf("Connection lost.\n");
break;
default:
break;
}
peerList[i]->DeallocatePacket(packet);
// Stay in the loop as long as there are more packets.
packet = peerList[i]->Receive();
}
}
RakSleep(0);//If needed for testing
}
DataStructures::List< SystemAddress > systemList;
DataStructures::List< RakNetGUID > guidList;
for (int i=0;i<peerNum;i++)
{
peerList[i]->GetSystemList(systemList,guidList);
int connNum=guidList.Size();//Get the number of connections for the current peer
if (connNum>maxConnections)//Did we connect to more?
{
if (isVerbose)
{
printf("More connections were allowed to peer %i, %i total.Fail\n",i,connNum);
DebugTools::ShowError("",!noPauses && isVerbose,__LINE__,__FILE__);
}
return 2;
}
}
if (isVerbose)
printf("Pass\n");
return 0;
}
_CONSOLE_2_SetSystemProcessParams
#endif
int main(void)
{
// Pointers to the interfaces of our server and client.
// Note we can easily have both in the same program
RakPeerInterface *server=RakNetworkFactory::GetRakPeerInterface();
RakNetStatistics *rss;
server->SetIncomingPassword("Rumpelstiltskin", (int)strlen("Rumpelstiltskin"));
server->SetTimeoutTime(30000,UNASSIGNED_SYSTEM_ADDRESS);
// PacketLogger packetLogger;
// server->AttachPlugin(&packetLogger);
// Holds packets
Packet* p;
// GetPacketIdentifier returns this
unsigned char packetIdentifier;
// Record the first client that connects to us so we can pass it to the ping function
SystemAddress clientID=UNASSIGNED_SYSTEM_ADDRESS;
// Holds user data
char portstring[30];
printf("This is a sample implementation of a text based chat server.\n");
printf("Connect to the project 'Chat Example Client'.\n");
printf("Difficulty: Beginner\n\n");
// A server
puts("Enter the server port to listen on");
gets(portstring);
if (portstring[0]==0)
strcpy(portstring, "1234");
puts("Starting server.");
// Starting the server is very simple. 2 players allowed.
// 0 means we don't care about a connectionValidationInteger, and false
// for low priority threads
SocketDescriptor socketDescriptor(atoi(portstring),0);
bool b = server->Startup(4, 30, &socketDescriptor, 1 );
server->SetMaximumIncomingConnections(4);
if (b)
puts("Server started, waiting for connections.");
else
{
puts("Server failed to start. Terminating.");
exit(1);
}
server->SetOccasionalPing(true);
server->SetUnreliableTimeout(1000);
DataStructures::List<RakNetSmartPtr<RakNetSocket> > sockets;
server->GetSockets(sockets);
printf("Ports used by RakNet:\n");
for (unsigned int i=0; i < sockets.Size(); i++)
{
printf("%i. %i\n", i+1, sockets[i]->boundAddress.port);
}
printf("My IP is %s\n", server->GetLocalIP(0));
printf("My GUID is %s\n", server->GetGuidFromSystemAddress(UNASSIGNED_SYSTEM_ADDRESS).ToString());
puts("'quit' to quit. 'stat' to show stats. 'ping' to ping.\n'ban' to ban an IP from connecting.\n'kick to kick the first connected player.\nType to talk.");
char message[2048];
// Loop for input
while (1)
{
// This sleep keeps RakNet responsive
RakSleep(30);
#ifdef _WIN32
if (kbhit())
{
// Notice what is not here: something to keep our network running. It's
// fine to block on gets or anything we want
// Because the network engine was painstakingly written using threads.
gets(message);
if (strcmp(message, "quit")==0)
{
puts("Quitting.");
break;
}
if (strcmp(message, "stat")==0)
{
rss=server->GetStatistics(server->GetSystemAddressFromIndex(0));
StatisticsToString(rss, message, 2);
printf("%s", message);
printf("Ping %i\n", server->GetAveragePing(server->GetSystemAddressFromIndex(0)));
continue;
}
if (strcmp(message, "ping")==0)
{
server->Ping(clientID);
continue;
}
if (strcmp(message, "kick")==0)
{
server->CloseConnection(clientID, true, 0);
continue;
}
if (strcmp(message, "getconnectionlist")==0)
{
SystemAddress systems[10];
unsigned short numConnections=10;
server->GetConnectionList((SystemAddress*) &systems, &numConnections);
for (int i=0; i < numConnections; i++)
{
printf("%i. %s\n", i+1, systems[i].ToString(true));
}
continue;
}
if (strcmp(message, "ban")==0)
{
printf("Enter IP to ban. You can use * as a wildcard\n");
gets(message);
server->AddToBanList(message);
printf("IP %s added to ban list.\n", message);
continue;
}
// Message now holds what we want to broadcast
char message2[2048];
// Append Server: to the message so clients know that it ORIGINATED from the server
// All messages to all clients come from the server either directly or by being
// relayed from other clients
message2[0]=0;
strcpy(message2, "Server: ");
strcat(message2, message);
// message2 is the data to send
// strlen(message2)+1 is to send the null terminator
// HIGH_PRIORITY doesn't actually matter here because we don't use any other priority
// RELIABLE_ORDERED means make sure the message arrives in the right order
// We arbitrarily pick 0 for the ordering stream
// UNASSIGNED_SYSTEM_ADDRESS means don't exclude anyone from the broadcast
// true means broadcast the message to everyone connected
server->Send(message2, (const int) strlen(message2)+1, HIGH_PRIORITY, RELIABLE_ORDERED, 0, UNASSIGNED_SYSTEM_ADDRESS, true);
}
#endif
// Get a packet from either the server or the client
for (p=server->Receive(); p; server->DeallocatePacket(p), p=server->Receive())
{
// We got a packet, get the identifier with our handy function
packetIdentifier = GetPacketIdentifier(p);
// Check if this is a network message packet
switch (packetIdentifier)
{
case ID_DISCONNECTION_NOTIFICATION:
// Connection lost normally
printf("ID_DISCONNECTION_NOTIFICATION from %s\n", p->systemAddress.ToString(true));;
break;
case ID_NEW_INCOMING_CONNECTION:
// Somebody connected. We have their IP now
printf("ID_NEW_INCOMING_CONNECTION from %s with GUID %s\n", p->systemAddress.ToString(true), p->guid.ToString());
clientID=p->systemAddress; // Record the player ID of the client
break;
case ID_INCOMPATIBLE_PROTOCOL_VERSION:
printf("ID_INCOMPATIBLE_PROTOCOL_VERSION\n");
break;
case ID_MODIFIED_PACKET:
// Cheater!
printf("ID_MODIFIED_PACKET\n");
break;
case ID_CONNECTION_LOST:
// Couldn't deliver a reliable packet - i.e. the other system was abnormally
// terminated
printf("ID_CONNECTION_LOST from %s\n", p->systemAddress.ToString(true));;
break;
default:
// The server knows the static data of all clients, so we can prefix the message
// With the name data
printf("%s\n", p->data);
// Relay the message. We prefix the name for other clients. This demonstrates
// That messages can be changed on the server before being broadcast
// Sending is the same as before
sprintf(message, "%s", p->data);
server->Send(message, (const int) strlen(message)+1, HIGH_PRIORITY, RELIABLE_ORDERED, 0, p->systemAddress, true);
break;
}
}
}
server->Shutdown(300);
// We're done with the network
RakNetworkFactory::DestroyRakPeerInterface(server);
return 0;
}
int main(void)
{
char ch;
#ifdef USE_TCP
RakNet::PacketizedTCP tcp1;
#else
RakNet::RakPeerInterface *rakPeer;
#endif
// directoryDeltaTransfer is the main plugin that does the work for this sample.
RakNet::DirectoryDeltaTransfer directoryDeltaTransfer;
// The fileListTransfer plugin is used by the DirectoryDeltaTransfer plugin and must also be registered (you could use this yourself too if you wanted, of course).
RakNet::FileListTransfer fileListTransfer;
// Read files in parts, rather than the whole file from disk at once
RakNet::IncrementalReadInterface iri;
directoryDeltaTransfer.SetDownloadRequestIncrementalReadInterface(&iri, 1000000);
#ifdef USE_TCP
tcp1.AttachPlugin(&directoryDeltaTransfer);
tcp1.AttachPlugin(&fileListTransfer);
#else
rakPeer = RakNet::RakPeerInterface::GetInstance();
rakPeer->AttachPlugin(&directoryDeltaTransfer);
rakPeer->AttachPlugin(&fileListTransfer);
// Get download progress notifications. Handled by the plugin.
rakPeer->SetSplitMessageProgressInterval(100);
#endif
directoryDeltaTransfer.SetFileListTransferPlugin(&fileListTransfer);
printf("This sample demonstrates the plugin to incrementally transfer compressed\n");
printf("deltas of directories. In essence, it's a simple autopatcher.\n");
printf("Unlike the full autopatcher, it has no dependencies. It is suitable for\n");
printf("patching from non-dedicated servers at runtime.\n");
printf("Difficulty: Intermediate\n\n");
printf("Enter listen port. Enter for default. If running two instances on the\nsame computer, use 0 for the client.\n");
unsigned short localPort;
char str[256];
Gets(str, sizeof(str));
if (str[0]==0)
localPort=60000;
else
localPort=atoi(str);
RakNet::SocketDescriptor socketDescriptor(localPort,0);
#ifdef USE_TCP
bool b=tcp1.Start(localPort,8);
RakAssert(b);
#else
if (rakPeer->Startup(8,&socketDescriptor, 1)!=RakNet::RAKNET_STARTED)
{
RakNet::RakPeerInterface::DestroyInstance(rakPeer);
printf("RakNet initialize failed. Possibly duplicate port.\n");
return 1;
}
rakPeer->SetMaximumIncomingConnections(8);
#endif
printf("Commands:\n");
printf("(S)et application directory.\n");
printf("(A)dd allowed uploads from subdirectory.\n");
printf("(D)ownload from subdirectory.\n");
printf("(C)lear allowed uploads.\n");
printf("C(o)nnect to another system.\n");
printf("(Q)uit.\n");
RakNet::SystemAddress sysAddrZero=RakNet::UNASSIGNED_SYSTEM_ADDRESS;
RakNet::TimeMS nextStatTime = RakNet::GetTimeMS() + 1000;
RakNet::Packet *p;
while (1)
{
/*
if (//directoryDeltaTransfer.GetNumberOfFilesForUpload()>0 &&
RakNet::GetTimeMS() > nextStatTime)
{
// If sending, periodically show connection stats
char statData[2048];
RakNetStatistics *statistics = rakPeer->GetStatistics(rakPeer->GetSystemAddressFromIndex(0));
// if (statistics->messagesOnResendQueue>0 || statistics->internalOutputQueueSize>0)
if (rakPeer->GetSystemAddressFromIndex(0)!=RakNet::UNASSIGNED_SYSTEM_ADDRESS)
{
StatisticsToString(statistics, statData, 2);
printf("%s\n", statData);
}
nextStatTime=RakNet::GetTimeMS()+5000;
}
*/
// Process packets
#ifdef USE_TCP
p=tcp1.Receive();
#else
p=rakPeer->Receive();
#endif
#ifdef USE_TCP
RakNet::SystemAddress sa;
sa=tcp1.HasNewIncomingConnection();
if (sa!=RakNet::UNASSIGNED_SYSTEM_ADDRESS)
{
printf("ID_NEW_INCOMING_CONNECTION\n");
sysAddrZero=sa;
}
if (tcp1.HasLostConnection()!=RakNet::UNASSIGNED_SYSTEM_ADDRESS)
printf("ID_DISCONNECTION_NOTIFICATION\n");
if (tcp1.HasFailedConnectionAttempt()!=RakNet::UNASSIGNED_SYSTEM_ADDRESS)
printf("ID_CONNECTION_ATTEMPT_FAILED\n");
sa=tcp1.HasCompletedConnectionAttempt();
if (sa!=RakNet::UNASSIGNED_SYSTEM_ADDRESS)
{
printf("ID_CONNECTION_REQUEST_ACCEPTED\n");
sysAddrZero=sa;
}
#endif
while (p)
{
#ifdef USE_TCP
tcp1.DeallocatePacket(p);
tcp1.Receive();
#else
if (p->data[0]==ID_NEW_INCOMING_CONNECTION)
{
printf("ID_NEW_INCOMING_CONNECTION\n");
sysAddrZero=p->systemAddress;
}
else if (p->data[0]==ID_CONNECTION_REQUEST_ACCEPTED)
{
printf("ID_CONNECTION_REQUEST_ACCEPTED\n");
sysAddrZero=p->systemAddress;
}
else if (p->data[0]==ID_DISCONNECTION_NOTIFICATION)
printf("ID_DISCONNECTION_NOTIFICATION\n");
else if (p->data[0]==ID_CONNECTION_LOST)
printf("ID_CONNECTION_LOST\n");
else if (p->data[0]==ID_CONNECTION_ATTEMPT_FAILED)
printf("ID_CONNECTION_ATTEMPT_FAILED\n");
rakPeer->DeallocatePacket(p);
p=rakPeer->Receive();
#endif
}
if (kbhit())
{
ch=getch();
if (ch=='s')
{
printf("Enter application directory\n");
Gets(str, sizeof(str));
if (str[0]==0)
strcpy(str, "C:/Temp");
directoryDeltaTransfer.SetApplicationDirectory(str);
printf("This directory will be prefixed to upload and download subdirectories.\n");
}
else if (ch=='a')
{
printf("Enter uploads subdirectory\n");
Gets(str, sizeof(str));
directoryDeltaTransfer.AddUploadsFromSubdirectory(str);
printf("%i files for upload.\n", directoryDeltaTransfer.GetNumberOfFilesForUpload());
}
else if (ch=='d')
{
char subdir[256];
char outputSubdir[256];
printf("Enter remote subdirectory to download from.\n");
printf("This directory may be any uploaded directory, or a subdir therein.\n");
Gets(subdir,sizeof(subdir));
printf("Enter subdirectory to output to.\n");
Gets(outputSubdir,sizeof(outputSubdir));
unsigned short setId;
setId=directoryDeltaTransfer.DownloadFromSubdirectory(subdir, outputSubdir, true, sysAddrZero, &transferCallback, HIGH_PRIORITY, 0, 0);
if (setId==(unsigned short)-1)
printf("Download failed. Host unreachable.\n");
else
printf("Downloading set %i\n", setId);
}
else if (ch=='c')
{
directoryDeltaTransfer.ClearUploads();
printf("Uploads cleared.\n");
}
else if (ch=='o')
{
char host[256];
printf("Enter host IP: ");
Gets(host,sizeof(host));
if (host[0]==0)
strcpy(host, "127.0.0.1");
unsigned short remotePort;
printf("Enter host port: ");
Gets(str, sizeof(str));
if (str[0]==0)
remotePort=60000;
else
remotePort=atoi(str);
#ifdef USE_TCP
tcp1.Connect(host,remotePort,false);
#else
rakPeer->Connect(host, remotePort, 0, 0);
#endif
printf("Connecting.\n");
}
else if (ch=='q')
{
printf("Bye!\n");
#ifdef USE_TCP
tcp1.Stop();
#else
rakPeer->Shutdown(1000,0);
#endif
break;
}
}
// Keeps the threads responsive
RakSleep(0);
}
#ifdef USE_TCP
#else
RakNet::RakPeerInterface::DestroyInstance(rakPeer);
#endif
return 0;
}
void TCPInterface::Stop(void)
{
if (isStarted==false)
return;
unsigned i;
#if defined(OPEN_SSL_CLIENT_SUPPORT)
for (i=0; i < remoteClients.Size(); i++)
remoteClients[i]->DisconnectSSL();
#endif
isStarted=false;
if (listenSocket!=(SOCKET) -1)
{
#ifdef _WIN32
shutdown(listenSocket, SD_BOTH);
#else
shutdown(listenSocket, SHUT_RDWR);
#endif
closesocket(listenSocket);
listenSocket=(SOCKET) -1;
}
// Abort waiting connect calls
blockingSocketListMutex.Lock();
for (i=0; i < blockingSocketList.Size(); i++)
{
closesocket(blockingSocketList[i]);
}
blockingSocketListMutex.Unlock();
// Wait for the thread to stop
while ( threadRunning )
RakSleep(15);
RakSleep(100);
// Stuff from here on to the end of the function is not threadsafe
for (i=0; i < remoteClients.Size(); i++)
{
closesocket(remoteClients[i]->socket);
#if defined(OPEN_SSL_CLIENT_SUPPORT)
remoteClients[i]->FreeSSL();
#endif
delete remoteClients[i];
}
remoteClients.Clear();
for (i=0; i < remoteClientsInsertionQueue.Size(); i++)
{
closesocket(remoteClientsInsertionQueue[i]->socket);
delete remoteClientsInsertionQueue[i];
}
remoteClientsInsertionQueue.Clear();
outgoingMessages.Clear();
incomingMessages.Clear();
newConnections.Clear();
newRemoteClients.Clear();
lostConnections.Clear();
requestedCloseConnections.Clear();
failedConnectionAttempts.Clear();
completedConnectionAttempts.Clear();
failedConnectionAttempts.Clear();
#if defined(OPEN_SSL_CLIENT_SUPPORT)
SSL_CTX_free (ctx);
startSSL.Clear();
activeSSLConnections.Clear();
#endif
}
