bool TableSerializer::DeserializeFilterQuery(RakNet::BitStream *out, DataStructures::Table::FilterQuery *query)
{
bool b;
RakAssert(query->cellValue);
stringCompressor->DecodeString(query->columnName,_TABLE_MAX_COLUMN_NAME_LENGTH,out,0);
out->ReadCompressed(query->columnIndex);
unsigned char op;
out->Read(op);
query->operation=(DataStructures::Table::FilterQueryType) op;
query->cellValue->Clear();
b=out->Read(query->cellValue->isEmpty);
if (query->cellValue->isEmpty==false)
{
// HACK - cellValue->i is used for integer, character, and binary data. However, for character and binary c will be 0. So use that to determine if the data was integer or not.
out->Read(query->cellValue->i);
unsigned int inputLength;
out->ReadAlignedBytesSafeAlloc(&query->cellValue->c,inputLength,10000000); // Sanity check to max binary cell of 10 megabytes
if (query->cellValue->c)
query->cellValue->i=inputLength;
b=out->Read(query->cellValue->ptr);
}
return b;
}
void ConsoleServer::AddCommandParser(CommandParserInterface *commandParserInterface)
{
if (commandParserInterface==0)
return;
// Non-duplicate insertion
unsigned i;
for (i=0; i < commandParserList.Size(); i++)
{
if (commandParserList[i]==commandParserInterface)
return;
if (_stricmp(commandParserList[i]->GetName(), commandParserInterface->GetName())==0)
{
// Naming conflict between two command parsers
RakAssert(0);
return;
}
}
commandParserList.Insert(commandParserInterface, __FILE__, __LINE__);
if (transport)
commandParserInterface->OnTransportChange(transport);
}
bool ServerClient::connect()
{
if(m_server == NULL) {
return false;
}
if(connected() && !connecting())
{
m_needsToConnect = true;
return false;
}
if(connected() || connecting())
return false;
m_connecting = true;
// Record the first client that connects to us so we can pass it to the ping function
RakNet::SystemAddress clientID=RakNet::UNASSIGNED_SYSTEM_ADDRESS;
RakNet::ConnectionAttemptResult car = m_server->Connect(m_address.c_str(), m_port, NULL, 0);
RakAssert(car==RakNet::CONNECTION_ATTEMPT_STARTED);
return true;
}
State *FSM::GetState(int index) const
{
RakAssert(index>=0 && index < (int) stateHistory.Size());
return stateHistory[(unsigned) index];
}
int main(void)
{
RakNet::RakNetStatistics *rss;
// Pointers to the interfaces of our server and client.
// Note we can easily have both in the same program
RakNet::RakPeerInterface *client=RakNet::RakPeerInterface::GetInstance();
// client->InitializeSecurity(0,0,0,0);
//RakNet::PacketLogger packetLogger;
//client->AttachPlugin(&packetLogger);
// Holds packets
RakNet::Packet* p;
// GetPacketIdentifier returns this
unsigned char packetIdentifier;
// Just so we can remember where the packet came from
bool isServer;
// Record the first client that connects to us so we can pass it to the ping function
RakNet::SystemAddress clientID=RakNet::UNASSIGNED_SYSTEM_ADDRESS;
// Crude interface
// Holds user data
char ip[64], serverPort[30];
// A client
isServer=false;
printf("This is a sample implementation of a text based chat client.\n");
printf("Connect to the project 'Chat Example Server'.\n");
printf("Difficulty: Beginner\n\n");
// Get our input
//#if 0
char clientPort[30];
puts("Enter the client port to listen on");
Gets(clientPort,sizeof(clientPort));
if (clientPort[0]==0)
strcpy(clientPort, "0");
//#endif
puts("Enter IP to connect to");
Gets(ip, sizeof(ip));
client->AllowConnectionResponseIPMigration(false);
if (ip[0]==0)
strcpy(ip, "127.0.0.1");
// strcpy(ip, "natpunch.jenkinssoftware.com");
puts("Enter the port to connect to");
Gets(serverPort,sizeof(serverPort));
if (serverPort[0]==0)
strcpy(serverPort, "1234");
//#if 0
// Connecting the client is very simple. 0 means we don't care about
// a connectionValidationInteger, and false for low priority threads
RakNet::SocketDescriptor socketDescriptor(atoi(clientPort),0);
socketDescriptor.socketFamily=AF_INET;
client->Startup(8,&socketDescriptor, 1);
client->SetOccasionalPing(true);
//#endif
#if LIBCAT_SECURITY==1
char public_key[cat::EasyHandshake::PUBLIC_KEY_BYTES];
FILE *fp = fopen("publicKey.dat","rb");
fread(public_key,sizeof(public_key),1,fp);
fclose(fp);
#endif
#if LIBCAT_SECURITY==1
RakNet::PublicKey pk;
pk.remoteServerPublicKey=public_key;
pk.publicKeyMode=RakNet::PKM_USE_KNOWN_PUBLIC_KEY;
bool b = client->Connect(ip, atoi(serverPort), "Rumpelstiltskin", (int) strlen("Rumpelstiltskin"), &pk)==RakNet::CONNECTION_ATTEMPT_STARTED;
#else
RakNet::ConnectionAttemptResult car = client->Connect(ip, atoi(serverPort), "Rumpelstiltskin", (int) strlen("Rumpelstiltskin"), 0, 0, 20, 2000);
RakAssert(car==RakNet::CONNECTION_ATTEMPT_STARTED);
#endif
printf("\nMy IP addresses:\n");
unsigned int i;
for (i=0; i < client->GetNumberOfAddresses(); i++)
{
printf("%i. %s\n", i+1, client->GetLocalIP(i));
}
printf("My GUID is %s\n", client->GetGuidFromSystemAddress(RakNet::UNASSIGNED_SYSTEM_ADDRESS).ToString());
puts("'quit' to quit. 'stat' to show stats. 'ping' to ping.\n'disconnect' to disconnect. 'connect' to reconnnect. Type to talk.");
char message[2048];
// Loop for input
while (1)
{
// This sleep keeps RakNet responsive
#ifdef _WIN32
Sleep(30);
#else
usleep(30 * 1000);
#endif
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,sizeof(message));
if (strcmp(message, "quit")==0)
{
puts("Quitting.");
break;
}
if (strcmp(message, "stat")==0)
{
rss=client->GetStatistics(client->GetSystemAddressFromIndex(0));
StatisticsToString(rss, message, 2);
printf("%s", message);
printf("Ping=%i\n", client->GetAveragePing(client->GetSystemAddressFromIndex(0)));
continue;
}
if (strcmp(message, "disconnect")==0)
{
printf("Enter index to disconnect: ");
char str[32];
Gets(str, sizeof(str));
if (str[0]==0)
strcpy(str,"0");
int index = atoi(str);
client->CloseConnection(client->GetSystemAddressFromIndex(index),false);
printf("Disconnecting.\n");
continue;
}
if (strcmp(message, "shutdown")==0)
{
client->Shutdown(100);
printf("Shutdown.\n");
continue;
}
#if 0
if (strcmp(message, "startup")==0)
{
bool b = client->Startup(8,&socketDescriptor, 1)==RakNet::RAKNET_STARTED;
if (b)
printf("Started.\n");
else
printf("Startup failed.\n");
continue;
}
#endif
if (strcmp(message, "connect")==0)
{
printf("Enter server ip: ");
Gets(ip, sizeof(ip));
if (ip[0]==0)
strcpy(ip, "127.0.0.1");
printf("Enter server port: ");
Gets(serverPort,sizeof(serverPort));
if (serverPort[0]==0)
strcpy(serverPort, "1234");
#if LIBCAT_SECURITY==1
bool b = client->Connect(ip, atoi(serverPort), "Rumpelstiltskin", (int) strlen("Rumpelstiltskin"), &pk)==RakNet::CONNECTION_ATTEMPT_STARTED;
#else
bool b = client->Connect(ip, atoi(serverPort), "Rumpelstiltskin", (int) strlen("Rumpelstiltskin"))==RakNet::CONNECTION_ATTEMPT_STARTED;
#endif
if (b)
puts("Attempting connection");
else
{
puts("Bad connection attempt. Terminating.");
exit(1);
}
continue;
}
if (strcmp(message, "ping")==0)
{
if (client->GetSystemAddressFromIndex(0)!=RakNet::UNASSIGNED_SYSTEM_ADDRESS)
client->Ping(client->GetSystemAddressFromIndex(0));
continue;
}
if (strcmp(message, "getlastping")==0)
{
if (client->GetSystemAddressFromIndex(0)!=RakNet::UNASSIGNED_SYSTEM_ADDRESS)
printf("Last ping is %i\n", client->GetLastPing(client->GetSystemAddressFromIndex(0)));
continue;
}
// message is the data to send
// strlen(message)+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
client->Send(message, (int) strlen(message)+1, HIGH_PRIORITY, RELIABLE_ORDERED, 0, RakNet::UNASSIGNED_SYSTEM_ADDRESS, true);
}
// Get a packet from either the server or the client
for (p=client->Receive(); p; client->DeallocatePacket(p), p=client->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\n");
break;
case ID_ALREADY_CONNECTED:
// Connection lost normally
printf("ID_ALREADY_CONNECTED with guid %" PRINTF_64_BIT_MODIFIER "u\n", p->guid);
break;
case ID_INCOMPATIBLE_PROTOCOL_VERSION:
printf("ID_INCOMPATIBLE_PROTOCOL_VERSION\n");
break;
case ID_REMOTE_DISCONNECTION_NOTIFICATION: // Server telling the clients of another client disconnecting gracefully. You can manually broadcast this in a peer to peer enviroment if you want.
printf("ID_REMOTE_DISCONNECTION_NOTIFICATION\n");
break;
case ID_REMOTE_CONNECTION_LOST: // Server telling the clients of another client disconnecting forcefully. You can manually broadcast this in a peer to peer enviroment if you want.
printf("ID_REMOTE_CONNECTION_LOST\n");
break;
case ID_REMOTE_NEW_INCOMING_CONNECTION: // Server telling the clients of another client connecting. You can manually broadcast this in a peer to peer enviroment if you want.
printf("ID_REMOTE_NEW_INCOMING_CONNECTION\n");
break;
case ID_CONNECTION_BANNED: // Banned from this server
printf("We are banned from this server.\n");
break;
case ID_CONNECTION_ATTEMPT_FAILED:
printf("Connection attempt failed\n");
break;
case ID_NO_FREE_INCOMING_CONNECTIONS:
// Sorry, the server is full. I don't do anything here but
// A real app should tell the user
printf("ID_NO_FREE_INCOMING_CONNECTIONS\n");
break;
case ID_INVALID_PASSWORD:
printf("ID_INVALID_PASSWORD\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;
case ID_CONNECTION_REQUEST_ACCEPTED:
// This tells the client they have connected
printf("ID_CONNECTION_REQUEST_ACCEPTED to %s with GUID %s\n", p->systemAddress.ToString(true), p->guid.ToString());
printf("My external address is %s\n", client->GetExternalID(p->systemAddress).ToString(true));
break;
case ID_CONNECTED_PING:
case ID_UNCONNECTED_PING:
printf("Ping from %s\n", p->systemAddress.ToString(true));
break;
default:
// It's a client, so just show the message
printf("====== %s\n", p->data);
break;
}
}
}
// Be nice and let the server know we quit.
client->Shutdown(300);
// We're done with the network
RakNet::RakPeerInterface::DestroyInstance(client);
return 0;
}
Packet* TelnetTransport::Receive( void )
{
if (tcpInterface==0) return 0;
Packet *p = tcpInterface->Receive();
if (p==0)
return 0;
/*
if (p->data[0]==255)
{
unsigned i;
for (i=0; i < p->length; i++)
{
RAKNET_DEBUG_PRINTF("%i ", p->data[i]);
}
RAKNET_DEBUG_PRINTF("\n");
tcpInterface->DeallocatePacket(p);
return 0;
}
*/
// 127 is delete - ignore that
// 9 is tab
// 27 is escape
if (p->data[0]>=127 || p->data[0]==9 || p->data[0]==27)
{
tcpInterface->DeallocatePacket(p);
return 0;
}
// Hack - I don't know what the hell this is about but cursor keys send 3 characters at a time. I can block these
//Up=27,91,65
//Down=27,91,66
//Right=27,91,67
//Left=27,91,68
if (p->length==3 && p->data[0]==27 && p->data[1]==91 && p->data[2]>=65 && p->data[2]<=68)
{
tcpInterface->DeallocatePacket(p);
return 0;
}
// Get this guy's cursor buffer. This is real bullcrap that I have to do this.
unsigned i;
TelnetClient *remoteClient=0;
for (i=0; i < remoteClients.Size(); i++)
{
if (remoteClients[i]->systemAddress==p->systemAddress)
remoteClient=remoteClients[i];
}
RakAssert(remoteClient);
if (remoteClient==0)
{
tcpInterface->DeallocatePacket(p);
return 0;
}
// Echo
#ifdef ECHO_INPUT
tcpInterface->Send((const char *)p->data, p->length, p->systemAddress);
#endif
bool gotLine;
// Process each character in turn
for (i=0; i < p->length; i++)
{
#ifdef ECHO_INPUT
if (p->data[i]==8)
{
char spaceThenBack[2];
spaceThenBack[0]=' ';
spaceThenBack[1]=8;
tcpInterface->Send((const char *)spaceThenBack, 2, p->systemAddress);
}
#endif
gotLine=ReassembleLine(remoteClient, p->data[i]);
if (gotLine && remoteClient->textInput[0])
{
Packet *reassembledLine = (Packet*) rakMalloc(sizeof(Packet));
reassembledLine->length=(unsigned int) strlen(remoteClient->textInput);
RakAssert(reassembledLine->length < REMOTE_MAX_TEXT_INPUT);
reassembledLine->data= (unsigned char*) rakMalloc( reassembledLine->length+1 );
memcpy(reassembledLine->data, remoteClient->textInput, reassembledLine->length);
#ifdef _PRINTF_DEBUG
memset(remoteClient->textInput, 0, REMOTE_MAX_TEXT_INPUT);
#endif
reassembledLine->data[reassembledLine->length]=0;
reassembledLine->systemAddress=p->systemAddress;
tcpInterface->DeallocatePacket(p);
return reassembledLine;
}
}
tcpInterface->DeallocatePacket(p);
return 0;
}
int main(void)
{
FMOD_RESULT result;
unsigned int version;
/*
Create a System object and initialize.
*/
result = FMOD::System_Create(&fmodSystem);
RakAssert(result>=0);
result = fmodSystem->getVersion(&version);
RakAssert(result>=0);
if (version < FMOD_VERSION)
{
printf("Error! You are using an old version of FMOD %08x. This program requires %08x\n", version, FMOD_VERSION);
return -1;
}
// result = fmodSystem->init(100, FMOD_INIT_NORMAL, (void *)&extradriverdata);
result = fmodSystem->init(100, FMOD_INIT_NORMAL, 0);
RakAssert(result>=0);
// ERRCHECK(result);
printf("A sample on how to use RakVoice. 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.1.12 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");
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 FMOD
if (!FMODVoiceAdapter::Instance()->SetupAdapter(fmodSystem, &rakVoice)){
printf("An error occurred while initializing FMOD sounds.\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;
FMODVoiceAdapter::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->guid);
}
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();
}
fmodSystem->update();
// Update or connection with FMOD
FMODVoiceAdapter::Instance()->Update();
LogStats();
RakSleep(20);
}
// Release any FMOD resources we used, and shutdown FMOD itself
FMODVoiceAdapter::Instance()->Release();
fmodSystem->release();
rakPeer->Shutdown(300);
RakNetworkFactory::DestroyRakPeerInterface(rakPeer);
return 0;
}
void RNS2_NativeClient::GetMyIP( SystemAddress addresses[MAXIMUM_NUMBER_OF_INTERNAL_IDS] ) {addresses[0]=UNASSIGNED_SYSTEM_ADDRESS; RakAssert("GetMyIP Unsupported?" && 0);}
void RakVoice::OpenChannel(Packet *packet)
{
RakNet::BitStream in(packet->data, packet->length, false);
in.IgnoreBits(8);
FreeChannelMemory(packet->guid);
VoiceChannel *channel=RakNet::OP_NEW<VoiceChannel>( __FILE__, __LINE__ );
channel->guid=packet->guid;
channel->isSendingVoiceData=false;
int sampleRate;
in.Read(sampleRate);
channel->remoteSampleRate=sampleRate;
if (channel->remoteSampleRate!=8000 && channel->remoteSampleRate!=16000 && channel->remoteSampleRate!=32000)
{
#ifdef _DEBUG
RakAssert(0);
#endif
RakNet::OP_DELETE(channel, __FILE__, __LINE__);
return;
}
if (sampleRate==8000)
channel->enc_state=speex_encoder_init(&speex_nb_mode);
else if (sampleRate==16000)
channel->enc_state=speex_encoder_init(&speex_wb_mode);
else // 32000
channel->enc_state=speex_encoder_init(&speex_uwb_mode);
if (channel->remoteSampleRate==8000)
channel->dec_state=speex_decoder_init(&speex_nb_mode);
else if (channel->remoteSampleRate==16000)
channel->dec_state=speex_decoder_init(&speex_wb_mode);
else // 32000
channel->dec_state=speex_decoder_init(&speex_uwb_mode);
// make sure encoder and decoder are created
RakAssert((channel->enc_state)&&(channel->dec_state));
int ret;
ret=speex_encoder_ctl(channel->enc_state, SPEEX_GET_FRAME_SIZE, &channel->speexOutgoingFrameSampleCount);
RakAssert(ret==0);
channel->outgoingBuffer = (char*) rakMalloc_Ex(bufferSizeBytes * FRAME_OUTGOING_BUFFER_COUNT, __FILE__, __LINE__);
channel->outgoingReadIndex=0;
channel->outgoingWriteIndex=0;
channel->bufferOutput=true;
channel->outgoingMessageNumber=0;
channel->copiedOutgoingBufferToBufferedOutput=false;
ret=speex_decoder_ctl(channel->dec_state, SPEEX_GET_FRAME_SIZE, &channel->speexIncomingFrameSampleCount);
RakAssert(ret==0);
channel->incomingBuffer = (char*) rakMalloc_Ex(bufferSizeBytes * FRAME_INCOMING_BUFFER_COUNT, __FILE__, __LINE__);
channel->incomingReadIndex=0;
channel->incomingWriteIndex=0;
channel->lastSend=0;
channel->incomingMessageNumber=0;
// Initialize preprocessor
channel->pre_state = speex_preprocess_state_init(channel->speexOutgoingFrameSampleCount, sampleRate);
RakAssert(channel->pre_state);
// Set encoder default parameters
SetEncoderParameter(channel->enc_state, SPEEX_SET_VBR, (defaultVBRState) ? 1 : 0 );
SetEncoderParameter(channel->enc_state, SPEEX_SET_COMPLEXITY, defaultEncoderComplexity);
// Set preprocessor default parameters
SetPreprocessorParameter(channel->pre_state, SPEEX_PREPROCESS_SET_DENOISE, (defaultDENOISEState) ? 1 : 2);
SetPreprocessorParameter(channel->pre_state, SPEEX_PREPROCESS_SET_VAD, (defaultVADState) ? 1 : 2);
voiceChannels.Insert(packet->guid, channel, true, __FILE__, __LINE__);
}
void State::FSMRemoveRef(const FSM *caller)
{
RakAssert(fsmRefCount!=0);
--fsmRefCount;
}
void AutopatcherServer::SetAutopatcherRepositoryInterface(AutopatcherRepositoryInterface *ari)
{
RakAssert(ari);
repository=ari;
}
PluginReceiveResult Router::OnReceive(Packet *packet)
{
if (packet->data[0]==ID_ROUTE_AND_MULTICAST ||
(packet->length>5 && packet->data[0]==ID_TIMESTAMP && packet->data[5]==ID_ROUTE_AND_MULTICAST))
{
#ifdef _DO_PRINTF
RAKNET_DEBUG_PRINTF("%i got routed message from %i\n", peer->GetExternalID(packet->systemAddress).port, packet->systemAddress.port);
#endif
RakNetTime timestamp;
PacketPriority priority;
PacketReliability reliability;
unsigned char orderingChannel;
SystemAddress originalSender;
RakNet::BitStream out;
BitSize_t outStartingOffset;
unsigned int payloadBitLength;
unsigned payloadWriteByteOffset;
RakNet::BitStream incomingBitstream(packet->data, packet->length, false);
incomingBitstream.IgnoreBits(8);
if (packet->data[0]==ID_TIMESTAMP)
{
incomingBitstream.Read(timestamp);
out.Write((MessageID)ID_TIMESTAMP);
out.Write(timestamp);
incomingBitstream.IgnoreBits(8);
}
// Read the send parameters
unsigned char c;
incomingBitstream.ReadCompressed(c);
priority=(PacketPriority)c;
incomingBitstream.ReadCompressed(c);
reliability=(PacketReliability)c;
incomingBitstream.ReadCompressed(orderingChannel);
incomingBitstream.Read(payloadBitLength);
out.Write((MessageID)ID_ROUTE_AND_MULTICAST);
out.WriteCompressed((unsigned char)priority);
out.WriteCompressed((unsigned char)reliability);
out.WriteCompressed((unsigned char)orderingChannel);
out.Write(payloadBitLength);
out.AlignWriteToByteBoundary();
incomingBitstream.AlignReadToByteBoundary();
payloadWriteByteOffset=(unsigned int) BITS_TO_BYTES(out.GetWriteOffset());
out.Write(&incomingBitstream, payloadBitLength); // This write also does a read on incomingBitStream
if (restrictByType)
{
RakNet::BitStream t(out.GetData()+payloadWriteByteOffset, sizeof(unsigned char), false);
MessageID messageID;
t.Read(messageID);
if (allowedTypes.HasData(messageID)==false)
return RR_STOP_PROCESSING_AND_DEALLOCATE; // Don't route restricted types
}
incomingBitstream.Read(originalSender);
out.Write(originalSender);
outStartingOffset=out.GetWriteOffset();
// Deserialize the root
bool hasData=false;
SystemAddress recipient;
unsigned short numberOfChildren;
incomingBitstream.Read(hasData);
incomingBitstream.Read(recipient); // This should be our own address
if (incomingBitstream.ReadCompressed(numberOfChildren)==false)
{
#ifdef _DEBUG
RakAssert(0);
#endif
return RR_STOP_PROCESSING_AND_DEALLOCATE;
}
unsigned childIndex;
bool childHasData=false;
SystemAddress childRecipient;
unsigned short childNumberOfChildren;
SystemAddress immediateRecipient;
immediateRecipient=UNASSIGNED_SYSTEM_ADDRESS;
int pendingNodeCount=0;
for (childIndex=0; childIndex < numberOfChildren; childIndex++)
{
while (pendingNodeCount!=-1)
{
// Copy out the serialized subtree for this child
incomingBitstream.Read(childHasData);
incomingBitstream.Read(childRecipient);
if (!incomingBitstream.ReadCompressed(childNumberOfChildren))
return RR_STOP_PROCESSING_AND_DEALLOCATE;
if (immediateRecipient==UNASSIGNED_SYSTEM_ADDRESS)
{
immediateRecipient=childRecipient;
}
pendingNodeCount+=childNumberOfChildren-1;
out.Write(childHasData);
out.Write(childRecipient);
out.WriteCompressed(childNumberOfChildren);
}
#ifdef _DO_PRINTF
RAKNET_DEBUG_PRINTF("%i routing to %i\n", peer->GetExternalID(packet->systemAddress).port, immediateRecipient.port);
#endif
// Send what we got so far
SendUnified(&out, priority, reliability, orderingChannel, immediateRecipient, false);
// Restart writing the per recipient data
out.SetWriteOffset(outStartingOffset);
// Reread the top level node
immediateRecipient=UNASSIGNED_SYSTEM_ADDRESS;
pendingNodeCount=0;
}
// Write the user payload to the packet struct if this is a destination and change the sender and return true
if (hasData)
{
#ifdef _DO_PRINTF
RAKNET_DEBUG_PRINTF("%i returning payload to user\n", peer->GetExternalID(packet->systemAddress).port);
#endif
if (packet->data[0]==ID_TIMESTAMP )
{
memcpy( packet->data + sizeof(RakNetTime)+sizeof(unsigned char), out.GetData()+payloadWriteByteOffset, BITS_TO_BYTES(payloadBitLength) );
packet->bitSize=BYTES_TO_BITS(sizeof(RakNetTime)+sizeof(unsigned char))+payloadBitLength;
}
else
{
memcpy( packet->data, out.GetData()+payloadWriteByteOffset, BITS_TO_BYTES(payloadBitLength) );
packet->bitSize=payloadBitLength;
}
packet->length=(unsigned int) BITS_TO_BYTES(packet->bitSize);
packet->systemAddress.systemIndex=(SystemIndex)-1;
packet->systemAddress=originalSender;
return RR_CONTINUE_PROCESSING;
}
// Absorb
return RR_STOP_PROCESSING_AND_DEALLOCATE;
}
return RR_CONTINUE_PROCESSING;
}
void SendToThread::ProcessBlock(SendToThread::SendToThreadBlock* threadedSend)
{
RakAssert(threadedSend->dataWriteOffset>0 && threadedSend->dataWriteOffset<=MAXIMUM_MTU_SIZE-UDP_HEADER_SIZE);
threadPool.AddInput(SendToWorkerThread,threadedSend);
}
int SocketLayer::SendTo( SOCKET s, const char *data, int length, unsigned int binaryAddress, unsigned short port, unsigned short remotePortRakNetWasStartedOn_PS3 )
{
RakAssert(length<=MAXIMUM_MTU_SIZE-UDP_HEADER_SIZE);
if (slo)
{
SystemAddress sa(binaryAddress,port);
return slo->RakNetSendTo(s,data,length,sa);
}
if ( s == (SOCKET) -1 )
{
return -1;
}
int len=0;
if (remotePortRakNetWasStartedOn_PS3!=0)
{
len = SendTo_PS3Lobby(s,data,length,binaryAddress,port, remotePortRakNetWasStartedOn_PS3);
}
else
{
#if (defined(_XBOX) || defined(_X360)) && defined(RAKNET_USE_VDP)
len = SendTo_360(s,data,length,0,0,binaryAddress,port);
#else
len = SendTo_PC(s,data,length,binaryAddress,port);
#endif
}
if ( len != -1 )
return 0;
#if defined(_WIN32) && !defined(_WIN32_WCE)
DWORD dwIOError = WSAGetLastError();
if ( dwIOError == WSAECONNRESET )
{
#if defined(_DEBUG)
RAKNET_DEBUG_PRINTF( "A previous send operation resulted in an ICMP Port Unreachable message.\n" );
#endif
}
else if ( dwIOError != WSAEWOULDBLOCK )
{
#if defined(_WIN32) && !defined(_XBOX) && !defined(X360) && defined(_DEBUG)
LPVOID messageBuffer;
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, dwIOError, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), // Default language
( LPTSTR ) & messageBuffer, 0, NULL );
// something has gone wrong here...
RAKNET_DEBUG_PRINTF( "sendto failed:Error code - %d\n%s", dwIOError, messageBuffer );
//Free the buffer.
LocalFree( messageBuffer );
#endif
}
return dwIOError;
#endif
return 1; // error
}
int SocketLayer::RecvFrom( const SOCKET s, RakPeer *rakPeer, int *errorCode, RakNetSmartPtr<RakNetSocket> rakNetSocket, unsigned short remotePortRakNetWasStartedOn_PS3 )
{
int len=0;
#if (defined(_XBOX) || defined(_X360)) && defined(RAKNET_USE_VDP)
char dataAndVoice[ MAXIMUM_MTU_SIZE*2 ];
char *data=&dataAndVoice[sizeof(unsigned short)]; // 2 bytes in
#else
char data[ MAXIMUM_MTU_SIZE ];
#endif
if (slo)
{
SystemAddress sender;
len = slo->RakNetRecvFrom(s,rakPeer,data,&sender,true);
if (len>0)
{
ProcessNetworkPacket( sender, data, len, rakPeer, rakNetSocket, RakNet::GetTimeUS() );
return 1;
}
}
if ( s == (SOCKET) -1 )
{
*errorCode = -1;
return -1;
}
#if defined (_WIN32) || !defined(MSG_DONTWAIT)
const int flag=0;
#else
const int flag=MSG_DONTWAIT;
#endif
sockaddr_in sa;
socklen_t len2;
unsigned short portnum=0;
if (remotePortRakNetWasStartedOn_PS3!=0)
{
#if defined(_PS3) || defined(__PS3__) || defined(SN_TARGET_PS3)
#endif
}
else
{
len2 = sizeof( sa );
sa.sin_family = AF_INET;
sa.sin_port=0;
#if (defined(_XBOX) || defined(_X360)) && defined(RAKNET_USE_VDP)
/*
DWORD zero=0;
WSABUF wsaBuf;
DWORD lenDword=0;
wsaBuf.buf=dataAndVoice;
wsaBuf.len=sizeof(dataAndVoice);
int result = WSARecvFrom( s,
&wsaBuf,
1,
&lenDword,
&zero,
( sockaddr* ) & sa, ( socklen_t* ) & len2,
0,0 );
len=lenDword;
*/
len = recvfrom( s, dataAndVoice, sizeof(dataAndVoice), flag, ( sockaddr* ) & sa, ( socklen_t* ) & len2 );
if (len>2)
{
// Skip first two bytes
len-=2;
}
#else
len = recvfrom( s, data, MAXIMUM_MTU_SIZE, flag, ( sockaddr* ) & sa, ( socklen_t* ) & len2 );
#endif
portnum = ntohs( sa.sin_port );
}
if ( len == 0 )
{
#ifdef _DEBUG
RAKNET_DEBUG_PRINTF( "Error: recvfrom returned 0 on a connectionless blocking call\non port %i. This is a bug with Zone Alarm. Please turn off Zone Alarm.\n", portnum );
RakAssert( 0 );
#endif
// 4/13/09 Changed from returning -1 to 0, to prevent attackers from sending 0 byte messages to shutdown the server
*errorCode = 0;
return 0;
}
if ( len > 0 )
{
ProcessNetworkPacket( SystemAddress(sa.sin_addr.s_addr, portnum), data, len, rakPeer, rakNetSocket, RakNet::GetTimeUS() );
return 1;
}
else
{
*errorCode = 0;
#if defined(_WIN32) && defined(_DEBUG)
DWORD dwIOError = WSAGetLastError();
if ( dwIOError == WSAEWOULDBLOCK )
{
return SOCKET_ERROR;
}
if ( dwIOError == WSAECONNRESET )
{
#if defined(_DEBUG)
// RAKNET_DEBUG_PRINTF( "A previous send operation resulted in an ICMP Port Unreachable message.\n" );
#endif
unsigned short portnum=0;
ProcessPortUnreachable(sa.sin_addr.s_addr, portnum, rakPeer);
// *errorCode = dwIOError;
return -1;
}
else
{
#if defined(_DEBUG) && !defined(_XBOX) && !defined(X360)
if ( dwIOError != WSAEINTR && dwIOError != WSAETIMEDOUT)
{
LPVOID messageBuffer;
FormatMessage( FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS,
NULL, dwIOError, MAKELANGID( LANG_NEUTRAL, SUBLANG_DEFAULT ), // Default language
( LPTSTR ) & messageBuffer, 0, NULL );
// something has gone wrong here...
RAKNET_DEBUG_PRINTF( "recvfrom failed:Error code - %d\n%s", dwIOError, messageBuffer );
//Free the buffer.
LocalFree( messageBuffer );
}
#endif
}
#endif
}
return 0; // no data
}
void LightweightDatabaseServer::OnUpdateRow(RakPeerInterface *peer, Packet *packet)
{
RakNet::BitStream inBitstream(packet->data, packet->length, false);
LightweightDatabaseServer::DatabaseTable *databaseTable = DeserializeClientHeader(&inBitstream, peer, packet, 1);
if (databaseTable==0)
return;
if (databaseTable->allowRemoteUpdate==false)
return;
unsigned char updateMode;
bool hasRowId;
unsigned rowId;
unsigned i;
DataStructures::Table::Row *row;
inBitstream.Read(updateMode);
inBitstream.Read(hasRowId);
if (hasRowId)
inBitstream.Read(rowId);
else
rowId=(unsigned) -1; // Not used here but remove the debugging check
unsigned char numCellUpdates;
if (inBitstream.Read(numCellUpdates)==false)
return;
// Read the updates for the row
DatabaseCellUpdate cellUpdates[256];
for (i=0; i < numCellUpdates; i++)
{
if (cellUpdates[i].Deserialize(&inBitstream)==false)
return;
}
if ((RowUpdateMode)updateMode==RUM_UPDATE_EXISTING_ROW)
{
if (hasRowId==false)
return;
row = databaseTable->table.GetRowByID(rowId);
if (row==0 || databaseTable->onlyUpdateOwnRows && RowHasIP(row, packet->playerId, databaseTable->systemIdColumnIndex)==false)
return; // You can't update some other system's row
}
else if ((RowUpdateMode)updateMode==RUM_UPDATE_OR_ADD_ROW)
{
if (hasRowId)
row = databaseTable->table.GetRowByID(rowId);
else
row=0;
if (row==0)
{
row=AddRow(databaseTable, packet->playerId, hasRowId, rowId);
if (row==0)
return;
}
else
{
// Existing row
if (databaseTable->onlyUpdateOwnRows && RowHasIP(row, packet->playerId, databaseTable->systemIdColumnIndex)==false)
return; // You can't update some other system's row
}
}
else
{
RakAssert((RowUpdateMode)updateMode==RUM_ADD_NEW_ROW);
row=AddRow(databaseTable, packet->playerId, hasRowId, rowId);
if (row==0)
return;
}
unsigned columnIndex;
for (i=0; i < numCellUpdates; i++)
{
columnIndex=databaseTable->table.ColumnIndex(cellUpdates[i].columnName);
if (columnIndex!=(unsigned)-1 && columnIndex!=databaseTable->lastPingResponseColumnIndex && columnIndex!=databaseTable->nextPingSendColumnIndex && columnIndex!=databaseTable->systemIdColumnIndex)
{
if (cellUpdates[i].cellValue.isEmpty)
row->cells[columnIndex]->Clear();
else if (cellUpdates[i].columnType==databaseTable->table.GetColumnType(columnIndex))
{
if (cellUpdates[i].columnType==DataStructures::Table::NUMERIC)
{
row->UpdateCell(columnIndex, cellUpdates[i].cellValue.i);
}
else if (cellUpdates[i].columnType==DataStructures::Table::BINARY)
{
row->UpdateCell(columnIndex, cellUpdates[i].cellValue.i, cellUpdates[i].cellValue.c);
}
else
{
RakAssert(cellUpdates[i].columnType==DataStructures::Table::STRING);
row->UpdateCell(columnIndex, cellUpdates[i].cellValue.c);
}
}
}
}
}
AutopatcherServer::ResultTypeAndBitstream* GetChangelistSinceDateCB(AutopatcherServer::ThreadData threadData, bool *returnOutput, void* perThreadData)
{
AutopatcherRepositoryInterface *repository = (AutopatcherRepositoryInterface*)perThreadData;
FileList addedFiles, deletedFiles;
AutopatcherServer *server = threadData.server;
//AutopatcherServer::ResultTypeAndBitstream *rtab = RakNet::OP_NEW<AutopatcherServer::ResultTypeAndBitstream>( _FILE_AND_LINE_ );
AutopatcherServer::ResultTypeAndBitstream rtab;
rtab.systemAddress=threadData.systemAddress;
// rtab.deletedFiles=RakNet::OP_NEW<FileList>( _FILE_AND_LINE_ );
// rtab.addedFiles=RakNet::OP_NEW<FileList>( _FILE_AND_LINE_ );
rtab.deletedFiles=&deletedFiles;
rtab.addedFiles=&addedFiles;
// Query the database for a changelist since this date
RakAssert(server);
//if (server->repository->GetChangelistSinceDate(threadData.applicationName.C_String(), rtab.addedFiles, rtab.deletedFiles, threadData.lastUpdateDate.C_String(), currentDate))
if (repository->GetChangelistSinceDate(threadData.applicationName.C_String(), rtab.addedFiles, rtab.deletedFiles, threadData.lastUpdateDate))
{
rtab.fatalError=false;
}
else
{
rtab.fatalError=true;
}
rtab.operation=AutopatcherServer::ResultTypeAndBitstream::GET_CHANGELIST_SINCE_DATE;
rtab.currentDate=(double) time(NULL);
// *returnOutput=true;
// return rtab;
if (rtab.fatalError==false)
{
if (rtab.deletedFiles->fileList.Size())
{
rtab.bitStream1.Write((unsigned char) ID_AUTOPATCHER_DELETION_LIST);
rtab.deletedFiles->Serialize(&rtab.bitStream1);
}
if (rtab.addedFiles->fileList.Size())
{
rtab.bitStream2.Write((unsigned char) ID_AUTOPATCHER_CREATION_LIST);
rtab.addedFiles->Serialize(&rtab.bitStream2);
rtab.bitStream2.Write(rtab.currentDate);
rtab.bitStream2.WriteCasted<double>(0);
rtab.addedFiles->Clear();
}
else
{
rtab.bitStream2.Write((unsigned char) ID_AUTOPATCHER_FINISHED);
rtab.bitStream2.Write(rtab.currentDate);
}
}
else
{
rtab.bitStream2.Write((unsigned char) ID_AUTOPATCHER_REPOSITORY_FATAL_ERROR);
StringCompressor::Instance()->EncodeString(repository->GetLastError(), 256, &rtab.bitStream2);
}
// RakNet::OP_DELETE(rtab.deletedFiles, _FILE_AND_LINE_);
// RakNet::OP_DELETE(rtab.addedFiles, _FILE_AND_LINE_);
*returnOutput=false;
if (rtab.bitStream1.GetNumberOfBitsUsed()>0)
server->SendUnified(&(rtab.bitStream1), server->priority, RELIABLE_ORDERED, server->orderingChannel, rtab.systemAddress, false);
if (rtab.bitStream2.GetNumberOfBitsUsed()>0)
server->SendUnified(&(rtab.bitStream2), server->priority, RELIABLE_ORDERED, server->orderingChannel, rtab.systemAddress, false);
server->DecrementPatchingUserCount();
if (server->loadNotifier)
{
AutopatcherServerLoadNotifier::AutopatcherState autopatcherState;
autopatcherState.requestsQueued=server->userRequestWaitingQueue.Size();
autopatcherState.requestsWorking=server->patchingUserCount;
AutopatcherServerLoadNotifier::GetChangelistResult getChangelistResult;
if (rtab.fatalError==true)
getChangelistResult=AutopatcherServerLoadNotifier::GCR_REPOSITORY_ERROR;
else if (rtab.deletedFiles->fileList.Size()==0 && rtab.addedFiles->fileList.Size()==0)
getChangelistResult=AutopatcherServerLoadNotifier::GCR_NOTHING_TO_DO;
else if (rtab.deletedFiles->fileList.Size()==0)
getChangelistResult=AutopatcherServerLoadNotifier::GCR_ADD_FILES;
else if (rtab.addedFiles->fileList.Size()==0)
getChangelistResult=AutopatcherServerLoadNotifier::GCR_DELETE_FILES;
else
getChangelistResult=AutopatcherServerLoadNotifier::GCR_ADD_AND_DELETE_FILES;
server->loadNotifier->OnGetChangelistCompleted(rtab.systemAddress, getChangelistResult, &autopatcherState);
}
return 0;
}
bool FileList::Deserialize(RakNet::BitStream *inBitStream)
{
bool b, dataLenNonZero=false, fileLenMatchesDataLen=false;
char filename[512];
unsigned int fileListSize;
FileListNode n;
b=inBitStream->ReadCompressed(fileListSize);
#ifdef _DEBUG
RakAssert(b);
RakAssert(fileListSize < 10000);
#endif
if (b==false || fileListSize > 10000)
return false; // Sanity check
Clear();
unsigned i;
for (i=0; i < fileListSize; i++)
{
inBitStream->ReadCompressed(n.context.op);
inBitStream->ReadCompressed(n.context.fileId);
stringCompressor->DecodeString((char*)filename, MAX_FILENAME_LENGTH, inBitStream);
inBitStream->Read(dataLenNonZero);
if (dataLenNonZero)
{
inBitStream->ReadCompressed(n.dataLengthBytes);
// sanity check
if (n.dataLengthBytes>2000000000)
{
#ifdef _DEBUG
RakAssert(n.dataLengthBytes<=2000000000);
#endif
return false;
}
n.data=(char*) rakMalloc_Ex( (size_t) n.dataLengthBytes, __FILE__, __LINE__ );
inBitStream->Read(n.data, n.dataLengthBytes);
}
else
{
n.dataLengthBytes=0;
n.data=0;
}
b=inBitStream->Read(fileLenMatchesDataLen);
if (fileLenMatchesDataLen)
n.fileLengthBytes=(unsigned) n.dataLengthBytes;
else
b=inBitStream->ReadCompressed(n.fileLengthBytes);
#ifdef _DEBUG
RakAssert(b);
#endif
if (b==0)
{
Clear();
return false;
}
n.filename=filename;
n.fullPathToFile=filename;
fileList.Insert(n, __FILE__, __LINE__);
}
return true;
}
AutopatcherServer::ResultTypeAndBitstream* GetPatchCB(AutopatcherServer::ThreadData threadData, bool *returnOutput, void* perThreadData)
{
AutopatcherServer *server = threadData.server;
AutopatcherRepositoryInterface *repository = (AutopatcherRepositoryInterface*)perThreadData;
// AutopatcherServer::ResultTypeAndBitstream *rtab = RakNet::OP_NEW<AutopatcherServer::ResultTypeAndBitstream>( _FILE_AND_LINE_ );
AutopatcherServer::ResultTypeAndBitstream rtab;
rtab.systemAddress=threadData.systemAddress;
FileList fileList;
// rtab.patchList=RakNet::OP_NEW<FileList>( _FILE_AND_LINE_ );
rtab.patchList=&fileList;
RakAssert(server);
// RakAssert(server->repository);
// if (server->repository->GetPatches(threadData.applicationName.C_String(), threadData.clientList, rtab.patchList, currentDate))
if (repository->GetPatches(threadData.applicationName.C_String(), threadData.clientList, rtab.patchList))
rtab.fatalError=false;
else
rtab.fatalError=true;
rtab.operation=AutopatcherServer::ResultTypeAndBitstream::GET_PATCH;
rtab.setId=threadData.setId;
rtab.currentDate=(double) time(NULL);
RakNet::OP_DELETE(threadData.clientList, _FILE_AND_LINE_);
if (rtab.fatalError==false)
{
if (rtab.patchList->fileList.Size())
{
//server->fileListTransfer->Send(rtab.patchList, 0, rtab.systemAddress, rtab.setId, server->priority, server->orderingChannel, false, server->repository);
server->fileListTransfer->Send(rtab.patchList, 0, rtab.systemAddress, rtab.setId, server->priority, server->orderingChannel, repository, repository->GetIncrementalReadChunkSize());
}
else
{
server->DecrementPatchingUserCount(); // No files needed to send
server->CallPatchCompleteCallback(rtab.systemAddress, AutopatcherServerLoadNotifier::PR_NO_FILES_NEEDED_PATCHING);
}
rtab.bitStream1.Write((unsigned char) ID_AUTOPATCHER_FINISHED_INTERNAL);
rtab.bitStream1.Write(rtab.currentDate);
}
else
{
rtab.bitStream1.Write((unsigned char) ID_AUTOPATCHER_REPOSITORY_FATAL_ERROR);
// StringCompressor::Instance()->EncodeString(server->repository->GetLastError(), 256, &rtab.bitStream1);
StringCompressor::Instance()->EncodeString(repository->GetLastError(), 256, &rtab.bitStream1);
server->DecrementPatchingUserCount(); // Repository error
server->CallPatchCompleteCallback(rtab.systemAddress, AutopatcherServerLoadNotifier::PR_REPOSITORY_ERROR);
}
*returnOutput=false;
if (rtab.bitStream1.GetNumberOfBitsUsed()>0)
server->SendUnified(&(rtab.bitStream1), server->priority, RELIABLE_ORDERED, server->orderingChannel, rtab.systemAddress, false);
if (rtab.bitStream2.GetNumberOfBitsUsed()>0)
server->SendUnified(&(rtab.bitStream2), server->priority, RELIABLE_ORDERED, server->orderingChannel, rtab.systemAddress, false);
// 12/1/2010 This doesn't scale well. Changing to allocating a connection object per request
/*
// Wait for repository to finish
// This is so that the same sql connection is not used between two different plugins, which causes thrashing and bad performance
// Plus if fileListTransfer uses multiple threads, this will keep this thread and the fileListTransfer thread from using the same connection at the same time
// PostgreSQL possibly MySQL are not threadsafe for multiple threads on the same connection
int pendingFiles = server->fileListTransfer->GetPendingFilesToAddress(rtab.systemAddress);
while (pendingFiles>0)
{
RakSleep(pendingFiles*10);
pendingFiles = server->fileListTransfer->GetPendingFilesToAddress(rtab.systemAddress);
}
*/
// *returnOutput=true;
// return rtab;
return 0;
}
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 ManagedState::FSMRemoveRef(const FSM *caller)
{
RakAssert(fsmRefCount!=0);
if (--fsmRefCount)
delete this;
}
/// In a real application these parameters would be filled out from application data
/// Here I've just hardcoded everything for fast testing
void ExecuteCommand(RakNet::Lobby2MessageID command, RakNet::RakString userName, int instanceNumber)
{
RakNet::Lobby2Message *m = messageFactory.Alloc(command);
RakAssert(m);
printf("Executing %s (message %i)\n", m->GetName(), command+1);
// If additional requires are needed to test the command, stick them here
switch (m->GetID())
{
case RakNet::L2MID_System_CreateTitle:
{
RakNet::System_CreateTitle *arg = (RakNet::System_CreateTitle *) m;
arg->requiredAge=22;
arg->titleName="Test Title Name";
arg->titleSecretKey="Test secret key";
}
break;
case RakNet::L2MID_System_DestroyTitle:
{
RakNet::System_DestroyTitle *arg = (RakNet::System_DestroyTitle *) m;
arg->titleName="Test Title Name";
}
break;
case RakNet::L2MID_System_GetTitleRequiredAge:
{
RakNet::System_GetTitleRequiredAge *arg = (RakNet::System_GetTitleRequiredAge *) m;
arg->titleName="Test Title Name";
}
break;
case RakNet::L2MID_System_GetTitleBinaryData:
{
RakNet::System_GetTitleBinaryData *arg = (RakNet::System_GetTitleBinaryData *) m;
arg->titleName="Test Title Name";
}
break;
case RakNet::L2MID_System_RegisterProfanity:
{
RakNet::System_RegisterProfanity *arg = (RakNet::System_RegisterProfanity *) m;
arg->profanityWords.Insert("Bodily Functions", _FILE_AND_LINE_ );
arg->profanityWords.Insert("Racial Epithet", _FILE_AND_LINE_ );
arg->profanityWords.Insert("Euphemism treadmill", _FILE_AND_LINE_ );
}
break;
case RakNet::L2MID_System_BanUser:
{
RakNet::System_BanUser *arg = (RakNet::System_BanUser *) m;
arg->durationHours=12;
arg->banReason="Ban Reason";
arg->userName=userName;
}
break;
case RakNet::L2MID_System_UnbanUser:
{
RakNet::System_UnbanUser *arg = (RakNet::System_UnbanUser *) m;
arg->reason="Unban Reason";
arg->userName=userName;
}
break;
case RakNet::L2MID_CDKey_Add:
{
RakNet::CDKey_Add *arg = (RakNet::CDKey_Add *) m;
arg->cdKeys.Insert("Test CD Key", _FILE_AND_LINE_ );
arg->cdKeys.Insert("Test CD Key 2", _FILE_AND_LINE_ );
arg->titleName="Test Title Name";
}
break;
case RakNet::L2MID_CDKey_GetStatus:
{
RakNet::CDKey_GetStatus *arg = (RakNet::CDKey_GetStatus *) m;
arg->cdKey="Test CD Key";
arg->titleName="Test Title Name";
}
break;
case RakNet::L2MID_CDKey_Use:
{
RakNet::CDKey_Use *arg = (RakNet::CDKey_Use *) m;
arg->cdKey="Test CD Key";
arg->titleName="Test Title Name";
arg->userName=userName;
}
break;
case RakNet::L2MID_CDKey_FlagStolen:
{
RakNet::CDKey_FlagStolen *arg = (RakNet::CDKey_FlagStolen *) m;
arg->cdKey="Test CD Key";
arg->titleName="Test Title Name";
arg->wasStolen=true;
}
break;
case RakNet::L2MID_Client_Login:
{
RakNet::Client_Login *arg = (RakNet::Client_Login *) m;
arg->titleName="Test Title Name";
arg->titleSecretKey="Test secret key";
arg->userPassword="******";
arg->userName=userName;
}
break;
case RakNet::L2MID_Client_SetPresence:
{
RakNet::Client_SetPresence *arg = (RakNet::Client_SetPresence *) m;
arg->presence.isVisible=true;
arg->presence.status=RakNet::Lobby2Presence::IN_LOBBY;
// arg->presence.titleName="Test Title Name";
}
break;
case RakNet::L2MID_Client_RegisterAccount:
{
RakNet::Client_RegisterAccount *arg = (RakNet::Client_RegisterAccount *) m;
arg->createAccountParameters.ageInDays=9999;
arg->createAccountParameters.firstName="Firstname";
arg->createAccountParameters.lastName="Lastname";
arg->createAccountParameters.password="******";
arg->createAccountParameters.passwordRecoveryQuestion="1+2=?";
arg->createAccountParameters.passwordRecoveryAnswer="3";
arg->createAccountParameters.emailAddress="*****@*****.**";
arg->createAccountParameters.homeCountry="United States";
arg->createAccountParameters.homeState="california";
arg->createAccountParameters.sex_male=true;
arg->userName=userName;
arg->cdKey="Test CD Key";
arg->titleName="Test Title Name";
}
break;
case RakNet::L2MID_System_SetEmailAddressValidated:
{
RakNet::System_SetEmailAddressValidated *arg = (RakNet::System_SetEmailAddressValidated *) m;
arg->validated=true;
arg->userName=userName;
}
break;
case RakNet::L2MID_Client_ValidateHandle:
{
RakNet::Client_ValidateHandle *arg = (RakNet::Client_ValidateHandle *) m;
arg->userName=userName;
}
break;
case RakNet::L2MID_System_DeleteAccount:
{
RakNet::System_DeleteAccount *arg = (RakNet::System_DeleteAccount *) m;
arg->userName=userName;
arg->password="******";
}
break;
case RakNet::L2MID_System_PruneAccounts:
{
RakNet::System_PruneAccounts *arg = (RakNet::System_PruneAccounts *) m;
arg->deleteAccountsNotLoggedInDays=1;
}
break;
case RakNet::L2MID_Client_GetEmailAddress:
{
RakNet::Client_GetEmailAddress *arg = (RakNet::Client_GetEmailAddress *) m;
arg->userName=userName;
}
break;
case RakNet::L2MID_Client_GetPasswordRecoveryQuestionByHandle:
{
RakNet::Client_GetPasswordRecoveryQuestionByHandle *arg = (RakNet::Client_GetPasswordRecoveryQuestionByHandle *) m;
arg->userName=userName;
}
break;
case RakNet::L2MID_Client_GetPasswordByPasswordRecoveryAnswer:
{
RakNet::Client_GetPasswordByPasswordRecoveryAnswer *arg = (RakNet::Client_GetPasswordByPasswordRecoveryAnswer *) m;
arg->userName=userName;
arg->passwordRecoveryAnswer="3";
}
break;
case RakNet::L2MID_Client_ChangeHandle:
{
RakNet::Client_ChangeHandle *arg = (RakNet::Client_ChangeHandle *) m;
arg->userName=userName;
arg->newHandle="New user handle";
}
break;
case RakNet::L2MID_Client_UpdateAccount:
{
RakNet::Client_UpdateAccount *arg = (RakNet::Client_UpdateAccount *) m;
}
break;
case RakNet::L2MID_Client_GetAccountDetails:
{
RakNet::Client_GetAccountDetails *arg = (RakNet::Client_GetAccountDetails *) m;
}
break;
case RakNet::L2MID_Client_StartIgnore:
{
RakNet::Client_StartIgnore *arg = (RakNet::Client_StartIgnore *) m;
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
}
break;
case RakNet::L2MID_Client_StopIgnore:
{
RakNet::Client_StopIgnore *arg = (RakNet::Client_StopIgnore *) m;
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
}
break;
case RakNet::L2MID_Client_GetIgnoreList:
{
RakNet::Client_GetIgnoreList *arg = (RakNet::Client_GetIgnoreList *) m;
}
break;
case RakNet::L2MID_Client_PerTitleIntegerStorage:
{
RakNet::Client_PerTitleIntegerStorage *arg = (RakNet::Client_PerTitleIntegerStorage *) m;
arg->titleName="Test Title Name";
arg->slotIndex=0;
arg->conditionValue=1.0;
arg->addConditionForOperation=RakNet::Client_PerTitleIntegerStorage::PTISC_GREATER_THAN;
arg->inputValue=0.0;
static int runCount=0;
if (runCount++%2==0)
arg->operationToPerform=RakNet::Client_PerTitleIntegerStorage::PTISO_WRITE;
else
arg->operationToPerform=RakNet::Client_PerTitleIntegerStorage::PTISO_READ;
}
break;
case RakNet::L2MID_Friends_SendInvite:
{
RakNet::Friends_SendInvite *arg = (RakNet::Friends_SendInvite *) m;
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
arg->subject="Friends_SendInvite subject";
arg->body="Friends_SendInvite body";
}
break;
case RakNet::L2MID_Friends_AcceptInvite:
{
RakNet::Friends_AcceptInvite *arg = (RakNet::Friends_AcceptInvite *) m;
arg->targetHandle=RakNet::RakString("user%i", 0);
arg->subject="Friends_AcceptInvite subject";
arg->body="Friends_AcceptInvite body";
arg->emailStatus=0;
}
break;
case RakNet::L2MID_Friends_RejectInvite:
{
RakNet::Friends_RejectInvite *arg = (RakNet::Friends_RejectInvite *) m;
arg->targetHandle=RakNet::RakString("user%i", 0);
arg->subject="L2MID_Friends_RejectInvite subject";
arg->body="L2MID_Friends_RejectInvite body";
arg->emailStatus=0;
}
break;
case RakNet::L2MID_Friends_GetInvites:
{
RakNet::Friends_GetInvites *arg = (RakNet::Friends_GetInvites *) m;
}
break;
case RakNet::L2MID_Friends_GetFriends:
{
RakNet::Friends_GetFriends *arg = (RakNet::Friends_GetFriends *) m;
}
break;
case RakNet::L2MID_Friends_Remove:
{
RakNet::Friends_Remove *arg = (RakNet::Friends_Remove *) m;
arg->targetHandle=RakNet::RakString("user%i", 0);
arg->subject="L2MID_Friends_Remove subject";
arg->body="L2MID_Friends_Remove body";
arg->emailStatus=0;
}
break;
case RakNet::L2MID_BookmarkedUsers_Add:
{
RakNet::BookmarkedUsers_Add *arg = (RakNet::BookmarkedUsers_Add *) m;
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
arg->type=0;
arg->description="L2MID_BookmarkedUsers_Add description";
}
break;
case RakNet::L2MID_BookmarkedUsers_Remove:
{
RakNet::BookmarkedUsers_Remove *arg = (RakNet::BookmarkedUsers_Remove *) m;
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
arg->type=0;
}
break;
case RakNet::L2MID_BookmarkedUsers_Get:
{
RakNet::BookmarkedUsers_Get *arg = (RakNet::BookmarkedUsers_Get *) m;
}
break;
case RakNet::L2MID_Emails_Send:
{
RakNet::Emails_Send *arg = (RakNet::Emails_Send *) m;
arg->recipients.Insert(RakNet::RakString("user%i", instanceNumber+1), _FILE_AND_LINE_ );
arg->recipients.Insert(RakNet::RakString("user%i", instanceNumber+2), _FILE_AND_LINE_ );
arg->subject="L2MID_Emails_Send subject";
arg->body="L2MID_Emails_Send body";
arg->status=0;
}
break;
case RakNet::L2MID_Emails_Get:
{
RakNet::Emails_Get *arg = (RakNet::Emails_Get *) m;
arg->unreadEmailsOnly=true;
arg->emailIdsOnly=true;
}
break;
case RakNet::L2MID_Emails_Delete:
{
RakNet::Emails_Delete *arg = (RakNet::Emails_Delete *) m;
arg->emailId=1;
}
break;
case RakNet::L2MID_Emails_SetStatus:
{
RakNet::Emails_SetStatus *arg = (RakNet::Emails_SetStatus *) m;
arg->emailId=2;
arg->updateStatusFlag=true;
arg->updateMarkedRead=true;
arg->newStatusFlag=1234;
arg->isNowMarkedRead=true;
}
break;
case RakNet::L2MID_Ranking_SubmitMatch:
{
RakNet::Ranking_SubmitMatch *arg = (RakNet::Ranking_SubmitMatch *) m;
arg->gameType="Match game type";
arg->titleName="Test Title Name";
arg->submittedMatch.matchNote="Ranking match note";
arg->submittedMatch.matchParticipants.Insert(RakNet::MatchParticipant("user0", 5.0f), _FILE_AND_LINE_ );
arg->submittedMatch.matchParticipants.Insert(RakNet::MatchParticipant("user1", 10.0f), _FILE_AND_LINE_ );
}
break;
case RakNet::L2MID_Ranking_GetMatches:
{
RakNet::Ranking_GetMatches *arg = (RakNet::Ranking_GetMatches *) m;
arg->gameType="Match game type";
arg->titleName="Test Title Name";
}
break;
case RakNet::L2MID_Ranking_GetMatchBinaryData:
{
RakNet::Ranking_GetMatchBinaryData *arg = (RakNet::Ranking_GetMatchBinaryData *) m;
arg->matchID=1;
}
break;
case RakNet::L2MID_Ranking_GetTotalScore:
{
RakNet::Ranking_GetTotalScore *arg = (RakNet::Ranking_GetTotalScore *) m;
arg->targetHandle=RakNet::RakString("user%i", instanceNumber);
arg->gameType="Match game type";
arg->titleName="Test Title Name";
}
break;
case RakNet::L2MID_Ranking_WipeScoresForPlayer:
{
RakNet::Ranking_WipeScoresForPlayer *arg = (RakNet::Ranking_WipeScoresForPlayer *) m;
arg->targetHandle=RakNet::RakString("user%i", instanceNumber);
arg->gameType="Match game type";
arg->titleName="Test Title Name";
}
break;
case RakNet::L2MID_Ranking_WipeMatches:
{
RakNet::Ranking_WipeMatches *arg = (RakNet::Ranking_WipeMatches *) m;
arg->gameType="Match game type";
arg->titleName="Test Title Name";
}
break;
case RakNet::L2MID_Ranking_PruneMatches:
{
RakNet::Ranking_PruneMatches *arg = (RakNet::Ranking_PruneMatches *) m;
arg->pruneTimeDays=1;
}
break;
case RakNet::L2MID_Ranking_UpdateRating:
{
RakNet::Ranking_UpdateRating *arg = (RakNet::Ranking_UpdateRating *) m;
arg->targetHandle=RakNet::RakString("user%i", instanceNumber);
arg->gameType="Match game type";
arg->titleName="Test Title Name";
arg->targetRating=1234.0f;
}
break;
case RakNet::L2MID_Ranking_WipeRatings:
{
RakNet::Ranking_WipeRatings *arg = (RakNet::Ranking_WipeRatings *) m;
arg->gameType="Match game type";
arg->titleName="Test Title Name";
}
break;
case RakNet::L2MID_Ranking_GetRating:
{
RakNet::Ranking_GetRating *arg = (RakNet::Ranking_GetRating *) m;
arg->targetHandle=RakNet::RakString("user%i", instanceNumber);
arg->gameType="Match game type";
arg->titleName="Test Title Name";
arg->targetHandle=RakNet::RakString("user%i", instanceNumber);
}
break;
case RakNet::L2MID_Clans_Create:
{
RakNet::Clans_Create *arg = (RakNet::Clans_Create *) m;
static int idx=0;
arg->clanHandle=RakNet::RakString("Clan handle %i", idx++);
arg->failIfAlreadyInClan=false;
arg->requiresInvitationsToJoin=true;
arg->description="Clan Description";
arg->binaryData->binaryData=new char[10];
strcpy(arg->binaryData->binaryData,"Hello");
arg->binaryData->binaryDataLength=10;
}
break;
case RakNet::L2MID_Clans_SetProperties:
{
RakNet::Clans_SetProperties *arg = (RakNet::Clans_SetProperties *) m;
arg->clanHandle="Clan handle";
arg->description="Updated description";
}
break;
case RakNet::L2MID_Clans_GetProperties:
{
RakNet::Clans_GetProperties *arg = (RakNet::Clans_GetProperties *) m;
arg->clanHandle="Clan handle";
}
break;
case RakNet::L2MID_Clans_SetMyMemberProperties:
{
RakNet::Clans_SetMyMemberProperties *arg = (RakNet::Clans_SetMyMemberProperties *) m;
arg->clanHandle="Clan handle";
arg->description="Updated description";
}
break;
case RakNet::L2MID_Clans_GrantLeader:
{
RakNet::Clans_GrantLeader *arg = (RakNet::Clans_GrantLeader *) m;
arg->clanHandle="Clan handle";
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
}
break;
case RakNet::L2MID_Clans_SetSubleaderStatus:
{
RakNet::Clans_SetSubleaderStatus *arg = (RakNet::Clans_SetSubleaderStatus *) m;
arg->clanHandle="Clan handle";
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
arg->setToSubleader=true;
}
break;
case RakNet::L2MID_Clans_SetMemberRank:
{
RakNet::Clans_SetMemberRank *arg = (RakNet::Clans_SetMemberRank *) m;
arg->clanHandle="Clan handle";
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
arg->newRank=666;
}
break;
case RakNet::L2MID_Clans_GetMemberProperties:
{
RakNet::Clans_GetMemberProperties *arg = (RakNet::Clans_GetMemberProperties *) m;
arg->clanHandle="Clan handle";
arg->targetHandle=RakNet::RakString("user%i", instanceNumber);
}
break;
case RakNet::L2MID_Clans_ChangeHandle:
{
RakNet::Clans_ChangeHandle *arg = (RakNet::Clans_ChangeHandle *) m;
arg->oldClanHandle="Clan handle";
arg->newClanHandle="New Clan handle";
}
break;
case RakNet::L2MID_Clans_Leave:
{
RakNet::Clans_Leave *arg = (RakNet::Clans_Leave *) m;
arg->clanHandle="Clan handle";
arg->dissolveIfClanLeader=false;
arg->subject="L2MID_Clans_Leave";
arg->emailStatus=0;
}
break;
case RakNet::L2MID_Clans_Get:
{
RakNet::Clans_Get *arg = (RakNet::Clans_Get *) m;
}
break;
case RakNet::L2MID_Clans_SendJoinInvitation:
{
RakNet::Clans_SendJoinInvitation *arg = (RakNet::Clans_SendJoinInvitation *) m;
static int idx=0;
arg->clanHandle=RakNet::RakString("Clan handle %i", idx++);
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
arg->subject="L2MID_Clans_SendJoinInvitation";
}
break;
case RakNet::L2MID_Clans_WithdrawJoinInvitation:
{
RakNet::Clans_WithdrawJoinInvitation *arg = (RakNet::Clans_WithdrawJoinInvitation *) m;
arg->clanHandle="Clan handle";
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
arg->subject="L2MID_Clans_WithdrawJoinInvitation";
}
break;
case RakNet::L2MID_Clans_AcceptJoinInvitation:
{
RakNet::Clans_AcceptJoinInvitation *arg = (RakNet::Clans_AcceptJoinInvitation *) m;
static int idx=0;
arg->clanHandle=RakNet::RakString("Clan handle %i", idx++);
arg->subject="L2MID_Clans_AcceptJoinInvitation";
arg->failIfAlreadyInClan=false;
}
break;
case RakNet::L2MID_Clans_RejectJoinInvitation:
{
RakNet::Clans_RejectJoinInvitation *arg = (RakNet::Clans_RejectJoinInvitation *) m;
static int idx=0;
arg->clanHandle=RakNet::RakString("Clan handle %i", idx++);
arg->subject="L2MID_Clans_WithdrawJoinInvitation";
}
break;
case RakNet::L2MID_Clans_DownloadInvitationList:
{
RakNet::Clans_DownloadInvitationList *arg = (RakNet::Clans_DownloadInvitationList *) m;
}
break;
case RakNet::L2MID_Clans_SendJoinRequest:
{
RakNet::Clans_SendJoinRequest *arg = (RakNet::Clans_SendJoinRequest *) m;
arg->clanHandle="Clan handle";
arg->subject="L2MID_Clans_SendJoinRequest";
}
break;
case RakNet::L2MID_Clans_WithdrawJoinRequest:
{
RakNet::Clans_WithdrawJoinRequest *arg = (RakNet::Clans_WithdrawJoinRequest *) m;
arg->clanHandle="Clan handle";
arg->subject="L2MID_Clans_WithdrawJoinRequest";
}
break;
case RakNet::L2MID_Clans_AcceptJoinRequest:
{
RakNet::Clans_AcceptJoinRequest *arg = (RakNet::Clans_AcceptJoinRequest *) m;
arg->clanHandle="Clan handle";
arg->requestingUserHandle=RakNet::RakString("user%i", instanceNumber+1);
arg->subject="L2MID_Clans_AcceptJoinRequest";
}
break;
case RakNet::L2MID_Clans_RejectJoinRequest:
{
RakNet::Clans_RejectJoinRequest *arg = (RakNet::Clans_RejectJoinRequest *) m;
arg->clanHandle="Clan handle";
arg->requestingUserHandle=RakNet::RakString("user%i", instanceNumber+1);
}
break;
case RakNet::L2MID_Clans_DownloadRequestList:
{
RakNet::Clans_DownloadRequestList *arg = (RakNet::Clans_DownloadRequestList *) m;
}
break;
case RakNet::L2MID_Clans_KickAndBlacklistUser:
{
RakNet::Clans_KickAndBlacklistUser *arg = (RakNet::Clans_KickAndBlacklistUser *) m;
arg->clanHandle="Clan handle";
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
arg->kick=true;
arg->blacklist=true;
}
break;
case RakNet::L2MID_Clans_UnblacklistUser:
{
RakNet::Clans_UnblacklistUser *arg = (RakNet::Clans_UnblacklistUser *) m;
arg->clanHandle="Clan handle";
arg->targetHandle=RakNet::RakString("user%i", instanceNumber+1);
}
break;
case RakNet::L2MID_Clans_GetBlacklist:
{
RakNet::Clans_GetBlacklist *arg = (RakNet::Clans_GetBlacklist *) m;
arg->clanHandle="Clan handle";
}
break;
case RakNet::L2MID_Clans_GetMembers:
{
RakNet::Clans_GetMembers *arg = (RakNet::Clans_GetMembers *) m;
arg->clanHandle="Clan handle";
}
break;
case RakNet::L2MID_Clans_CreateBoard:
{
RakNet::Clans_CreateBoard *arg = (RakNet::Clans_CreateBoard *) m;
}
break;
case RakNet::L2MID_Clans_DestroyBoard:
{
RakNet::Clans_DestroyBoard *arg = (RakNet::Clans_DestroyBoard *) m;
}
break;
case RakNet::L2MID_Clans_CreateNewTopic:
{
RakNet::Clans_CreateNewTopic *arg = (RakNet::Clans_CreateNewTopic *) m;
}
break;
case RakNet::L2MID_Clans_ReplyToTopic:
{
RakNet::Clans_ReplyToTopic *arg = (RakNet::Clans_ReplyToTopic *) m;
}
break;
case RakNet::L2MID_Clans_RemovePost:
{
RakNet::Clans_RemovePost *arg = (RakNet::Clans_RemovePost *) m;
}
break;
case RakNet::L2MID_Clans_GetBoards:
{
RakNet::Clans_GetBoards *arg = (RakNet::Clans_GetBoards *) m;
}
break;
case RakNet::L2MID_Clans_GetTopics:
{
RakNet::Clans_GetTopics *arg = (RakNet::Clans_GetTopics *) m;
}
break;
case RakNet::L2MID_Clans_GetPosts:
{
RakNet::Clans_GetPosts *arg = (RakNet::Clans_GetPosts *) m;
}
break;
}
lobby2Client[instanceNumber].SendMsg(m);
messageFactory.Dealloc(m);
}
bool AutopatcherMySQLRepository::UpdateApplicationFiles(const char *applicationName, const char *applicationDirectory, const char *userName, FileListProgress *cb)
{
MYSQL_STMT *stmt;
MYSQL_BIND bind[3];
char query[512];
FileList filesOnHarddrive;
filesOnHarddrive.SetCallback(cb);
int prepareResult;
my_bool falseVar=false;
RakNet::RakString escapedApplicationName = GetEscapedString(applicationName);
filesOnHarddrive.AddFilesFromDirectory(applicationDirectory,"", true, true, true, FileListNodeContext(0,0));
if (filesOnHarddrive.fileList.Size()==0)
{
sprintf(lastError,"ERROR: Can't find files at %s in UpdateApplicationFiles\n",applicationDirectory);
return false;
}
sprintf(query, "SELECT applicationID FROM Applications WHERE applicationName='%s';", escapedApplicationName.C_String());
int applicationID;
if (!ExecuteQueryReadInt(query, &applicationID))
{
sprintf(lastError,"ERROR: %s not found in UpdateApplicationFiles\n",escapedApplicationName.C_String());
return false;
}
if (!ExecuteBlockingCommand("BEGIN;"))
{
return false;
}
sprintf(query, "UPDATE Applications SET changeSetId = changeSetId + 1 where applicationID=%i;", applicationID);
if (!ExecuteBlockingCommand(query))
{
Rollback ();
return false;
}
int changeSetId = 0;
sprintf(query, "SELECT changeSetId FROM Applications WHERE applicationID=%i;", applicationID);
if (!ExecuteQueryReadInt(query, &changeSetId))
{
Rollback ();
return false;
}
// +1 was added in the update
changeSetId--;
// Gets all newest files
sprintf(query, "SELECT filename, contentHash, createFile FROM FileVersionHistory "
"JOIN (SELECT max(fileId) maxId FROM FileVersionHistory WHERE applicationId=%i GROUP BY fileName) MaxId "
"ON FileVersionHistory.fileId = MaxId.maxId "
"ORDER BY filename DESC;", applicationID);
MYSQL_RES *result = 0;
if (!ExecuteBlockingCommand(query, &result))
{
Rollback();
return false;
}
DataStructures::List <FileInfo> newestFiles;
MYSQL_ROW row;
while ((row = mysql_fetch_row (result)) != 0)
{
FileInfo fi;
fi.filename = row [0];
fi.createFile = (atoi (row [2]) != 0);
if (fi.createFile)
{
RakAssert(mysql_fetch_lengths (result) [1] == HASH_LENGTH); // check the data is sensible
memcpy (fi.contentHash, row [1], HASH_LENGTH);
}
newestFiles.Insert (fi);
}
mysql_free_result(result);
FileList newFiles;
// Loop through files on filesOnHarddrive
// If the file in filesOnHarddrive does not exist in the query result, or if it does but the hash is different or non-existent, add this file to the create list
for (unsigned fileListIndex=0; fileListIndex < filesOnHarddrive.fileList.Size(); fileListIndex++)
{
bool addFile=true;
if (fileListIndex%10==0)
printf("Hashing files %i/%i\n", fileListIndex+1, filesOnHarddrive.fileList.Size());
const char * hardDriveFilename=filesOnHarddrive.fileList[fileListIndex].filename;
const char * hardDriveHash=filesOnHarddrive.fileList[fileListIndex].data;
for (unsigned i = 0; i != newestFiles.Size (); ++i)
{
const FileInfo & fi = newestFiles [i];
if (_stricmp(hardDriveFilename, fi.filename)==0)
{
if (fi.createFile && memcmp(fi.contentHash, hardDriveHash, HASH_LENGTH)==0)
{
// File exists in database and is the same
addFile=false;
}
break;
}
}
// Unless set to false, file does not exist in query result or is different.
if (addFile)
{
newFiles.AddFile(hardDriveFilename,hardDriveFilename, filesOnHarddrive.fileList[fileListIndex].data, filesOnHarddrive.fileList[fileListIndex].dataLengthBytes, filesOnHarddrive.fileList[fileListIndex].fileLengthBytes, FileListNodeContext(0,0), false);
}
}
// Go through query results that are marked as create
// If a file that is currently in the database is not on the harddrive, add it to the delete list
FileList deletedFiles;
for (unsigned i = 0; i != newestFiles.Size (); ++i)
{
const FileInfo & fi = newestFiles [i];
if (!fi.createFile)
continue; // If already false don't mark false again.
bool fileOnHarddrive=false;
for (unsigned fileListIndex=0; fileListIndex < filesOnHarddrive.fileList.Size(); fileListIndex++)
{
const char * hardDriveFilename=filesOnHarddrive.fileList[fileListIndex].filename;
//hardDriveHash=filesOnHarddrive.fileList[fileListIndex].data;
if (_stricmp(hardDriveFilename, fi.filename)==0)
{
fileOnHarddrive=true;
break;
}
}
if (!fileOnHarddrive)
deletedFiles.AddFile(fi.filename,fi.filename,0,0,0,FileListNodeContext(0,0), false);
}
// files on harddrive no longer needed. Free this memory since generating all the patches is memory intensive.
filesOnHarddrive.Clear();
// For each file in the delete list add a row indicating file deletion
for (unsigned fileListIndex=0; fileListIndex < deletedFiles.fileList.Size(); fileListIndex++)
{
if (fileListIndex%10==0)
printf("Tagging deleted files %i/%i\n", fileListIndex+1, deletedFiles.fileList.Size());
sprintf(query, "INSERT INTO FileVersionHistory(applicationID, filename, createFile, changeSetID, userName) VALUES (%i, '%s', FALSE,%i,'%s');",
applicationID, GetEscapedString(deletedFiles.fileList[fileListIndex].filename).C_String(), changeSetId, GetEscapedString(userName).C_String());
if (!ExecuteBlockingCommand (query))
{
Rollback();
deletedFiles.Clear();
newFiles.Clear();
return false;
}
}
// Clear the delete list as it is no longer needed.
deletedFiles.Clear();
// For each file in the create list
for (unsigned fileListIndex=0; fileListIndex < newFiles.fileList.Size(); fileListIndex++)
{
if (fileListIndex%10==0)
printf("Adding file %i/%i\n", fileListIndex+1, newFiles.fileList.Size());
const char * hardDriveFilename=newFiles.fileList[fileListIndex].filename;
const char * hardDriveData=newFiles.fileList[fileListIndex].data+HASH_LENGTH;
const char * hardDriveHash=newFiles.fileList[fileListIndex].data;
unsigned hardDriveDataLength=newFiles.fileList[fileListIndex].fileLengthBytes;
sprintf( query, "SELECT fileID from FileVersionHistory WHERE applicationID=%i AND filename='%s' AND createFile=TRUE;", applicationID, GetEscapedString(hardDriveFilename).C_String() );
MYSQL_RES * res = 0;
if (!ExecuteBlockingCommand (query, &res))
{
Rollback();
newFiles.Clear();
return false;
}
// Create new patches for every create version
MYSQL_ROW row;
while ((row = mysql_fetch_row (res)) != 0)
{
const char * fileID = row [0];
// The last query handled all the relevant comparisons
sprintf(query, "SELECT content from FileVersionHistory WHERE fileID=%s", fileID );
MYSQL_RES * queryResult = 0;
if (!ExecuteBlockingCommand (query, &queryResult))
{
Rollback();
newFiles.Clear();
mysql_free_result(res);
return false;
}
MYSQL_ROW queryRow = mysql_fetch_row (queryResult);
const unsigned contentLength=mysql_fetch_lengths (queryResult) [0];
const char * content=queryRow [0];
char *patch;
unsigned patchLength;
if (!CreatePatch(content, contentLength, (char *) hardDriveData, hardDriveDataLength, &patch, &patchLength))
{
strcpy(lastError,"CreatePatch failed.");
Rollback();
newFiles.Clear();
mysql_free_result(res);
mysql_free_result(queryResult);
return false;
}
char buf[512];
stmt = mysql_stmt_init(mySqlConnection);
sprintf (buf, "UPDATE FileVersionHistory SET patch=? where fileID=%s;", fileID);
if ((prepareResult=mysql_stmt_prepare(stmt, buf, (unsigned long) strlen(buf)))!=0)
{
strcpy (lastError, mysql_stmt_error (stmt));
mysql_stmt_close(stmt);
Rollback();
return false;
}
memset(bind, 0, sizeof(bind));
unsigned long l1;
l1=patchLength;
bind[0].buffer_type= MYSQL_TYPE_LONG_BLOB;
bind[0].buffer= patch;
bind[0].buffer_length= patchLength;
bind[0].is_null= &falseVar;
bind[0].length=&l1;
if (mysql_stmt_bind_param(stmt, bind))
{
strcpy (lastError, mysql_stmt_error (stmt));
mysql_stmt_close(stmt);
Rollback();
return false;
}
if (mysql_stmt_execute(stmt))
{
strcpy (lastError, mysql_stmt_error (stmt));
mysql_stmt_close(stmt);
Rollback();
newFiles.Clear();
mysql_free_result(res);
mysql_free_result(queryResult);
delete [] patch;
return false;
}
mysql_stmt_close(stmt);
delete [] patch;
mysql_free_result(queryResult);
}
mysql_free_result(res);
stmt = mysql_stmt_init(mySqlConnection);
sprintf(query, "INSERT INTO FileVersionHistory (applicationID, filename, fileLength, content, contentHash, createFile, changeSetID, userName) "
"VALUES (%i, ?, %i,?,?, TRUE, %i, '%s' );",
applicationID, hardDriveDataLength, changeSetId, GetEscapedString(userName).C_String());
if ((prepareResult=mysql_stmt_prepare(stmt, query, (unsigned long) strlen(query)))!=0)
{
strcpy (lastError, mysql_stmt_error (stmt));
mysql_stmt_close(stmt);
Rollback();
return false;
}
memset(bind, 0, sizeof(bind));
unsigned long l2,l3,l4;
l2=(unsigned long) strlen(hardDriveFilename);
l3=hardDriveDataLength;
l4=HASH_LENGTH;
bind[0].buffer_type= MYSQL_TYPE_STRING;
bind[0].buffer= (void*) hardDriveFilename;
bind[0].buffer_length= (unsigned long) strlen(hardDriveFilename);
bind[0].is_null= &falseVar;
bind[0].length=&l2;
bind[1].buffer_type= MYSQL_TYPE_LONG_BLOB;
bind[1].buffer= (void*) hardDriveData;
bind[1].buffer_length= hardDriveDataLength;
bind[1].is_null= &falseVar;
bind[1].length=&l3;
bind[2].buffer_type= MYSQL_TYPE_TINY_BLOB;
bind[2].buffer= (void*) hardDriveHash;
bind[2].buffer_length= HASH_LENGTH;
bind[2].is_null= &falseVar;
bind[2].length=&l4;
if (mysql_stmt_bind_param(stmt, bind))
{
strcpy (lastError, mysql_stmt_error (stmt));
mysql_stmt_close(stmt);
Rollback();
return false;
}
if (mysql_stmt_execute(stmt))
{
strcpy (lastError, mysql_stmt_error (stmt));
mysql_stmt_close(stmt);
Rollback();
return false;
}
mysql_stmt_close(stmt);
}
if (!ExecuteBlockingCommand("COMMIT;"))
{
Rollback ();
return false;
}
return true;
}
bool FileListTransfer::DecodeSetHeader(Packet *packet)
{
bool anythingToWrite=false;
unsigned short setID;
RakNet::BitStream inBitStream(packet->data, packet->length, false);
inBitStream.IgnoreBits(8);
inBitStream.Read(setID);
FileListReceiver *fileListReceiver;
if (fileListReceivers.Has(setID)==false)
{
#ifdef _DEBUG
RakAssert(0);
#endif
return false;
}
fileListReceiver=fileListReceivers.Get(setID);
if (fileListReceiver->allowedSender!=packet->systemAddress)
{
#ifdef _DEBUG
RakAssert(0);
#endif
return false;
}
#ifdef _DEBUG
RakAssert(fileListReceiver->gotSetHeader==false);
#endif
inBitStream.Read(anythingToWrite);
if (anythingToWrite)
{
inBitStream.ReadCompressed(fileListReceiver->setCount);
if (inBitStream.ReadCompressed(fileListReceiver->setTotalFinalLength))
{
fileListReceiver->setTotalCompressedTransmissionLength=fileListReceiver->setTotalFinalLength;
fileListReceiver->gotSetHeader=true;
return true;
}
}
else
{
FileListTransferCBInterface::OnFileStruct s;
memset(&s,0,sizeof(FileListTransferCBInterface::OnFileStruct));
s.setID=setID;
if (fileListReceiver->downloadHandler->OnDownloadComplete()==false)
{
fileListReceiver->downloadHandler->OnDereference();
fileListReceivers.Delete(setID);
if (fileListReceiver->deleteDownloadHandler)
RakNet::OP_DELETE(fileListReceiver->downloadHandler, __FILE__, __LINE__);
RakNet::OP_DELETE(fileListReceiver, __FILE__, __LINE__);
}
return true;
}
return false;
}
void RakVoice::Update(void)
{
unsigned i,j, bytesAvailable, speexFramesAvailable, speexBlockSize;
unsigned bytesWaitingToReturn;
int bytesWritten;
VoiceChannel *channel;
char *inputBuffer;
char tempOutput[2048];
// 1 byte for ID, and 2 bytes(short) for Message number
static const int headerSize=sizeof(unsigned char) + sizeof(unsigned short);
// First byte is ID for RakNet
tempOutput[0]=ID_RAKVOICE_DATA;
RakNetTime currentTime = RakNet::GetTime();
// Size of VoiceChannel::incomingBuffer and VoiceChannel::outgoingBuffer arrays
unsigned totalBufferSize=bufferSizeBytes * FRAME_OUTGOING_BUFFER_COUNT;
// Allow all channels to write, and set the output to zero in preparation
if (zeroBufferedOutput)
{
for (i=0; i < bufferedOutputCount; i++)
bufferedOutput[i]=0.0f;
for (i=0; i < voiceChannels.Size(); i++)
voiceChannels[i]->copiedOutgoingBufferToBufferedOutput=false;
zeroBufferedOutput=false;
}
// For each channel
for (i=0; i < voiceChannels.Size(); i++)
{
channel=voiceChannels[i];
if (currentTime - channel->lastSend > 50) // Throttle to 20 sends a second
{
channel->isSendingVoiceData=false;
// Circular buffer so I have to do this to count how many bytes are available
if (channel->outgoingWriteIndex>=channel->outgoingReadIndex)
bytesAvailable=channel->outgoingWriteIndex-channel->outgoingReadIndex;
else
bytesAvailable=channel->outgoingWriteIndex + (totalBufferSize-channel->outgoingReadIndex);
// Speex returns how many frames it encodes per block. Each frame is of byte length sampleSize.
speexBlockSize = channel->speexOutgoingFrameSampleCount * SAMPLESIZE;
#ifdef PRINT_DEBUG_INFO
static int lastPrint=0;
if (i==0 && currentTime-lastPrint > 2000)
{
lastPrint=currentTime;
unsigned bytesWaitingToReturn;
if (channel->incomingReadIndex <= channel->incomingWriteIndex)
bytesWaitingToReturn=channel->incomingWriteIndex-channel->incomingReadIndex;
else
bytesWaitingToReturn=totalBufferSize-channel->incomingReadIndex+channel->incomingWriteIndex;
printf("%i bytes to send. incomingMessageNumber=%i. bytesWaitingToReturn=%i.\n", bytesAvailable, channel->incomingMessageNumber, bytesWaitingToReturn );
}
#endif
#ifdef _TEST_LOOPBACK
/*
if (bufferSizeBytes<bytesAvailable)
{
printf("Update: bytesAvailable=%i writeIndex=%i readIndex=%i\n",bytesAvailable, channel->outgoingWriteIndex, channel->outgoingReadIndex);
memcpy(channel->incomingBuffer + channel->incomingWriteIndex, channel->outgoingBuffer+channel->outgoingReadIndex, bufferSizeBytes);
channel->incomingWriteIndex=(channel->incomingWriteIndex+bufferSizeBytes) % totalBufferSize;
channel->outgoingReadIndex=(channel->outgoingReadIndex+bufferSizeBytes) % totalBufferSize;
}
return;
*/
#endif
// Find out how many frames we can read out of the buffer for speex to encode and send these out.
speexFramesAvailable = bytesAvailable / speexBlockSize;
// Encode all available frames and send them unreliable sequenced
if (speexFramesAvailable > 0)
{
SpeexBits speexBits;
speex_bits_init(&speexBits);
while (speexFramesAvailable-- > 0)
{
speex_bits_reset(&speexBits);
// If the input data would wrap around the buffer, copy it to another buffer first
if (channel->outgoingReadIndex + speexBlockSize >= totalBufferSize)
{
#ifdef _DEBUG
RakAssert(speexBlockSize < 2048-1);
#endif
unsigned t;
for (t=0; t < speexBlockSize; t++)
tempOutput[t+headerSize]=channel->outgoingBuffer[t%totalBufferSize];
inputBuffer=tempOutput+headerSize;
}
else
inputBuffer=channel->outgoingBuffer+channel->outgoingReadIndex;
#ifdef _DEBUG
/*
printf("In: ");
if (shortSampleType)
{
short *blah = (short*) inputBuffer;
for (int p=0; p < 5; p++)
{
printf("%.i ", blah[p]);
}
}
else
{
float *blah = (float*) inputBuffer;
for (int p=0; p < 5; p++)
{
printf("%.3f ", blah[p]);
}
}
printf("\n");
*/
#endif
int is_speech=1;
// Run preprocessor if required
if (defaultDENOISEState||defaultVADState){
is_speech=speex_preprocess((SpeexPreprocessState*)channel->pre_state,(spx_int16_t*) inputBuffer, NULL );
}
if ((is_speech)||(!defaultVADState)){
is_speech = speex_encode_int(channel->enc_state, (spx_int16_t*) inputBuffer, &speexBits);
}
channel->outgoingReadIndex=(channel->outgoingReadIndex+speexBlockSize)%totalBufferSize;
// If no speech detected, don't send this frame
if ((!is_speech)&&(defaultVADState)){
continue;
}
channel->isSendingVoiceData=true;
#ifdef _DEBUG
// printf("Update: bytesAvailable=%i writeIndex=%i readIndex=%i\n",bytesAvailable, channel->outgoingWriteIndex, channel->outgoingReadIndex);
#endif
bytesWritten = speex_bits_write(&speexBits, tempOutput+headerSize, 2048-headerSize);
#ifdef _DEBUG
// If this assert hits then you need to increase the size of the temp buffer, but this is really a bug because
// voice packets should never be bigger than a few hundred bytes.
RakAssert(bytesWritten!=2048-headerSize);
#endif
// static int bytesSent=0;
// bytesSent+= bytesWritten+headerSize;
// printf("bytesSent=%i\n", bytesSent);
#ifdef PRINT_DEBUG_INFO
static int voicePacketsSent=0;
printf("%i ", voicePacketsSent++);
#endif
// at +1, because the first byte in the buffer has the ID for RakNet.
memcpy(tempOutput+1, &channel->outgoingMessageNumber, sizeof(unsigned short));
channel->outgoingMessageNumber++;
RakNet::BitStream tempOutputBs((unsigned char*) tempOutput,bytesWritten+headerSize,false);
SendUnified(&tempOutputBs, HIGH_PRIORITY, UNRELIABLE,0,channel->guid,false);
if (loopbackMode)
{
Packet p;
p.length=bytesWritten+1;
p.data=(unsigned char*)tempOutput;
p.guid=channel->guid;
p.systemAddress=rakPeerInterface->GetSystemAddressFromGuid(p.guid);
OnVoiceData(&p);
}
}
speex_bits_destroy(&speexBits);
channel->lastSend=currentTime;
}
}
// As sound buffer blocks fill up, I add their values to RakVoice::bufferedOutput . Then when the user calls ReceiveFrame they get that value, already
// processed. This is necessary because that function needs to run as fast as possible so I remove all processing there that I can. Otherwise the sound
// plays back distorted and popping
if (channel->copiedOutgoingBufferToBufferedOutput==false)
{
if (channel->incomingReadIndex <= channel->incomingWriteIndex)
bytesWaitingToReturn=channel->incomingWriteIndex-channel->incomingReadIndex;
else
bytesWaitingToReturn=totalBufferSize-channel->incomingReadIndex+channel->incomingWriteIndex;
if (bytesWaitingToReturn==0)
{
channel->bufferOutput=true;
}
else if (channel->bufferOutput==false || bytesWaitingToReturn > bufferSizeBytes*2)
{
// Block running this again until the user calls ReceiveFrame since every call to ReceiveFrame only gets zero or one output blocks from
// each channel
channel->copiedOutgoingBufferToBufferedOutput=true;
// Stop buffering output. We won't start buffering again until there isn't enough data to read.
channel->bufferOutput=false;
// Cap to the size of the output buffer. But we do write less if less is available, with the rest silence
if (bytesWaitingToReturn > bufferSizeBytes)
{
bytesWaitingToReturn=bufferSizeBytes;
}
else
{
// Align the write index so when we increment the partial block read (which is always aligned) it computes out to 0 bytes waiting
channel->incomingWriteIndex=channel->incomingReadIndex+bufferSizeBytes;
if (channel->incomingWriteIndex==totalBufferSize)
channel->incomingWriteIndex=0;
}
short *in = (short *) (channel->incomingBuffer+channel->incomingReadIndex);
for (j=0; j < bytesWaitingToReturn / SAMPLESIZE; j++)
{
// Write short to float so if the range goes over the range of a float we can still add and subtract the correct final value.
// It will be clamped at the end
bufferedOutput[j]+=in[j%(totalBufferSize/SAMPLESIZE)];
}
// Update the read index. Always update by bufferSizeBytes, not bytesWaitingToReturn.
// if bytesWaitingToReturn < bufferSizeBytes then the rest is silence since this means the buffer ran out or we stopped sending.
channel->incomingReadIndex+=bufferSizeBytes;
if (channel->incomingReadIndex==totalBufferSize)
channel->incomingReadIndex=0;
// printf("%f %f\n", channel->incomingReadIndex/(float)bufferSizeBytes, channel->incomingWriteIndex/(float)bufferSizeBytes);
}
}
}
}
bool FileListTransfer::DecodeFile(Packet *packet, bool fullFile)
{
FileListTransferCBInterface::OnFileStruct onFileStruct;
RakNet::BitStream inBitStream(packet->data, packet->length, false);
inBitStream.IgnoreBits(8);
unsigned int partCount=0;
unsigned int partTotal=0;
unsigned int partLength=0;
onFileStruct.fileData=0;
if (fullFile==false)
{
// Disable endian swapping on reading this, as it's generated locally in ReliabilityLayer.cpp
inBitStream.ReadBits( (unsigned char* ) &partCount, BYTES_TO_BITS(sizeof(partCount)), true );
inBitStream.ReadBits( (unsigned char* ) &partTotal, BYTES_TO_BITS(sizeof(partTotal)), true );
inBitStream.ReadBits( (unsigned char* ) &partLength, BYTES_TO_BITS(sizeof(partLength)), true );
inBitStream.IgnoreBits(8);
// The header is appended to every chunk, which we continue to read after this statement block
}
inBitStream.Read(onFileStruct.context);
inBitStream.Read(onFileStruct.setID);
FileListReceiver *fileListReceiver;
if (fileListReceivers.Has(onFileStruct.setID)==false)
{
return false;
}
fileListReceiver=fileListReceivers.Get(onFileStruct.setID);
if (fileListReceiver->allowedSender!=packet->systemAddress)
{
#ifdef _DEBUG
RakAssert(0);
#endif
return false;
}
#ifdef _DEBUG
RakAssert(fileListReceiver->gotSetHeader==true);
#endif
if (stringCompressor->DecodeString(onFileStruct.fileName, 512, &inBitStream)==false)
{
#ifdef _DEBUG
RakAssert(0);
#endif
return false;
}
inBitStream.ReadCompressed(onFileStruct.fileIndex);
inBitStream.ReadCompressed(onFileStruct.finalDataLength);
// Read header uncompressed so the data is byte aligned, for speed
onFileStruct.compressedTransmissionLength=(unsigned int) onFileStruct.finalDataLength;
if (fullFile)
{
// Support SendLists
inBitStream.AlignReadToByteBoundary();
onFileStruct.fileData = (char*) rakMalloc_Ex( (size_t) onFileStruct.finalDataLength, __FILE__, __LINE__ );
inBitStream.Read((char*)onFileStruct.fileData, onFileStruct.finalDataLength);
}
onFileStruct.setCount=fileListReceiver->setCount;
onFileStruct.setTotalCompressedTransmissionLength=fileListReceiver->setTotalCompressedTransmissionLength;
onFileStruct.setTotalFinalLength=fileListReceiver->setTotalFinalLength;
// User callback for this file.
if (fullFile)
{
if (fileListReceiver->downloadHandler->OnFile(&onFileStruct))
rakFree_Ex(onFileStruct.fileData, __FILE__, __LINE__ );
fileListReceiver->filesReceived++;
// If this set is done, free the memory for it.
if ((int) fileListReceiver->setCount==fileListReceiver->filesReceived)
{
if (fileListReceiver->downloadHandler->OnDownloadComplete()==false)
{
fileListReceiver->downloadHandler->OnDereference();
if (fileListReceiver->deleteDownloadHandler)
RakNet::OP_DELETE(fileListReceiver->downloadHandler, __FILE__, __LINE__);
fileListReceivers.Delete(onFileStruct.setID);
RakNet::OP_DELETE(fileListReceiver, __FILE__, __LINE__);
}
}
}
else
{
inBitStream.AlignReadToByteBoundary();
bool usedAlloca=false;
char *firstDataChunk;
unsigned int unreadBits = inBitStream.GetNumberOfUnreadBits();
unsigned int unreadBytes = BITS_TO_BYTES(unreadBits);
if (unreadBytes>0)
{
#if !defined(_XBOX) && !defined(_X360)
if (unreadBits < MAX_ALLOCA_STACK_ALLOCATION)
{
firstDataChunk = ( char* ) alloca( unreadBytes );
usedAlloca=true;
}
else
#endif
firstDataChunk = (char*) rakMalloc_Ex( unreadBytes, __FILE__, __LINE__ );
// Read partLength bytes, reported to OnFileProgress
inBitStream.Read((char*)firstDataChunk, unreadBytes );
}
else
firstDataChunk=0;
fileListReceiver->downloadHandler->OnFileProgress(&onFileStruct, partCount, partTotal, unreadBytes, firstDataChunk);
if (usedAlloca==false)
RakNet::OP_DELETE_ARRAY(firstDataChunk, __FILE__, __LINE__);
}
return true;
}
void RakVoice::SetEncoderComplexity(int complexity)
{
RakAssert((complexity>=0)&&(complexity<=10));
SetEncoderParameter(NULL, SPEEX_SET_COMPLEXITY, complexity);
defaultEncoderComplexity = complexity;
}
void FileListTransfer::OnReferencePush(Packet *packet, bool fullFile)
{
// fullFile is always true for TCP, since TCP does not return SPLIT_PACKET_NOTIFICATION
RakNet::BitStream refPushAck;
refPushAck.Write((MessageID)ID_FILE_LIST_REFERENCE_PUSH_ACK);
SendUnified(&refPushAck,HIGH_PRIORITY, RELIABLE, 0, packet->systemAddress, false);
FileListTransferCBInterface::OnFileStruct onFileStruct;
RakNet::BitStream inBitStream(packet->data, packet->length, false);
inBitStream.IgnoreBits(8);
unsigned int partCount=0;
unsigned int partTotal=1;
unsigned int partLength=0;
onFileStruct.fileData=0;
if (fullFile==false)
{
// Disable endian swapping on reading this, as it's generated locally in ReliabilityLayer.cpp
inBitStream.ReadBits( (unsigned char* ) &partCount, BYTES_TO_BITS(sizeof(partCount)), true );
inBitStream.ReadBits( (unsigned char* ) &partTotal, BYTES_TO_BITS(sizeof(partTotal)), true );
inBitStream.ReadBits( (unsigned char* ) &partLength, BYTES_TO_BITS(sizeof(partLength)), true );
inBitStream.IgnoreBits(8);
// The header is appended to every chunk, which we continue to read after this statement block
}
inBitStream.Read(onFileStruct.context);
inBitStream.Read(onFileStruct.setID);
FileListReceiver *fileListReceiver;
if (fileListReceivers.Has(onFileStruct.setID)==false)
{
return;
}
fileListReceiver=fileListReceivers.Get(onFileStruct.setID);
if (fileListReceiver->allowedSender!=packet->systemAddress)
{
#ifdef _DEBUG
RakAssert(0);
#endif
return;
}
#ifdef _DEBUG
RakAssert(fileListReceiver->gotSetHeader==true);
#endif
if (stringCompressor->DecodeString(onFileStruct.fileName, 512, &inBitStream)==false)
{
#ifdef _DEBUG
RakAssert(0);
#endif
return;
}
inBitStream.ReadCompressed(onFileStruct.fileIndex);
inBitStream.ReadCompressed(onFileStruct.finalDataLength);
unsigned int offset;
unsigned int chunkLength;
inBitStream.ReadCompressed(offset);
inBitStream.ReadCompressed(chunkLength);
// if (chunkLength==0)
// return;
bool lastChunk;
inBitStream.Read(lastChunk);
bool finished = lastChunk && fullFile;
if (fullFile==false)
fileListReceiver->partLength=partLength;
FLR_MemoryBlock mb;
if (fileListReceiver->pushedFiles.Has(onFileStruct.fileIndex)==false)
{
if (chunkLength > 1000000000 || onFileStruct.finalDataLength > 1000000000)
{
RakAssert("FileListTransfer::OnReferencePush: file too large" && 0);
return;
}
mb.allocatedLength=onFileStruct.finalDataLength;
mb.block = (char*) rakMalloc_Ex(onFileStruct.finalDataLength, __FILE__, __LINE__);
if (mb.block==0)
{
notifyOutOfMemory(__FILE__, __LINE__);
return;
}
fileListReceiver->pushedFiles.SetNew(onFileStruct.fileIndex, mb);
}
else
mb=fileListReceiver->pushedFiles.Get(onFileStruct.fileIndex);
if (offset+chunkLength > mb.allocatedLength)
{
// Overrun
RakAssert("FileListTransfer::OnReferencePush: Write would overrun allocated block" && 0);
return;
}
// Read header uncompressed so the data is byte aligned, for speed
onFileStruct.compressedTransmissionLength=(unsigned int) onFileStruct.finalDataLength;
unsigned int unreadBits = inBitStream.GetNumberOfUnreadBits();
unsigned int unreadBytes = BITS_TO_BYTES(unreadBits);
unsigned int amountToRead;
if (fullFile)
amountToRead=chunkLength;
else
amountToRead=unreadBytes;
inBitStream.AlignReadToByteBoundary();
if (fullFile || (rakPeerInterface->GetSplitMessageProgressInterval() != 0 && (int)partCount==rakPeerInterface->GetSplitMessageProgressInterval()))
{
inBitStream.Read(mb.block+offset, amountToRead);
}
onFileStruct.setCount=fileListReceiver->setCount;
onFileStruct.setTotalCompressedTransmissionLength=fileListReceiver->setTotalCompressedTransmissionLength;
onFileStruct.setTotalFinalLength=fileListReceiver->setTotalFinalLength;
onFileStruct.fileData=mb.block;
if (finished)
{
if (fileListReceiver->downloadHandler->OnFile(&onFileStruct))
rakFree_Ex(onFileStruct.fileData, __FILE__, __LINE__ );
fileListReceiver->pushedFiles.Delete(onFileStruct.fileIndex);
fileListReceiver->filesReceived++;
// If this set is done, free the memory for it.
if ((int) fileListReceiver->setCount==fileListReceiver->filesReceived)
{
if (fileListReceiver->downloadHandler->OnDownloadComplete()==false)
{
fileListReceiver->downloadHandler->OnDereference();
fileListReceivers.Delete(onFileStruct.setID);
if (fileListReceiver->deleteDownloadHandler)
RakNet::OP_DELETE(fileListReceiver->downloadHandler, __FILE__, __LINE__);
RakNet::OP_DELETE(fileListReceiver, __FILE__, __LINE__);
}
}
}
else
{
unsigned int totalNotifications;
unsigned int currentNotificationIndex;
unsigned int unreadBytes;
if (rakPeerInterface==0 || rakPeerInterface->GetSplitMessageProgressInterval()==0)
{
totalNotifications = onFileStruct.finalDataLength / chunkLength + 1;
currentNotificationIndex = offset / chunkLength;
unreadBytes = mb.allocatedLength - ((offset+1)*chunkLength);
}
else
{
totalNotifications = onFileStruct.finalDataLength / fileListReceiver->partLength + 1;
if (fullFile==false)
currentNotificationIndex = (offset+partCount*fileListReceiver->partLength) / fileListReceiver->partLength ;
else
currentNotificationIndex = (offset+chunkLength) / fileListReceiver->partLength ;
unreadBytes = onFileStruct.finalDataLength - ((currentNotificationIndex+1) * fileListReceiver->partLength);
}
fileListReceiver->downloadHandler->OnFileProgress(&onFileStruct, currentNotificationIndex, totalNotifications, unreadBytes, mb.block);
}
return;
}
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;
}
PGresult * PostgreSQLInterface::QueryVariadic( const char * input, ... )
{
RakNet::RakString query;
PGresult *result;
DataStructures::List<VariadicSQLParser::IndexAndType> indices;
if ( input==0 || input[0]==0 )
return 0;
// Lookup this query in the stored query table. If it doesn't exist, prepare it.
RakNet::RakString inputStr;
inputStr=input;
unsigned int preparedQueryIndex;
for (preparedQueryIndex=0; preparedQueryIndex < preparedQueries.Size(); preparedQueryIndex++)
{
if (preparedQueries[preparedQueryIndex].StrICmp(inputStr)==0)
break;
}
// Find out how many params there are
// Find out the type of each param (%f, %s)
indices.Clear(false, _FILE_AND_LINE_);
GetTypeMappingIndices( input, indices );
if (preparedQueryIndex==preparedQueries.Size())
{
// if (indices.Size()>0)
// query += " (";
RakNet::RakString formatCopy;
RakNet::RakString insertion;
formatCopy=input;
unsigned int i;
unsigned int indexOffset=0;
for (i=0; i < indices.Size(); i++)
{
// if (i!=0)
// query += ",";
// query+=typeMappings[indices[i].typeMappingIndex].type;
formatCopy.SetChar(indices[i].strIndex+indexOffset, '$');
// if (i < 9)
// formatCopy.SetChar(indices[i].strIndex+1, i+1+'0');
// else
insertion=RakNet::RakString("%i::%s", i+1, VariadicSQLParser::GetTypeMappingAtIndex(indices[i].typeMappingIndex));
formatCopy.SetChar(indices[i].strIndex+1+indexOffset, insertion);
indexOffset+=(unsigned int) insertion.GetLength()-1;
}
// if (indices.Size()>0)
// query += ")";
// query += " AS ";
query += formatCopy;
// query += ";\n";
formatCopy+= ";\n";
result = PQprepare(pgConn, RakNet::RakString("PGSQL_ExecuteVariadic_%i", preparedQueries.Size()), formatCopy.C_String(), indices.Size(), NULL);
if (IsResultSuccessful(result, false))
{
PQclear(result);
preparedQueries.Insert(inputStr, _FILE_AND_LINE_);
}
else
{
printf(formatCopy.C_String());
printf("\n");
printf(lastError);
RakAssert(0);
PQclear(result);
return 0;
}
}
// char *paramData[512];
// int paramLength[512];
// int paramFormat[512];
va_list argptr;
va_start(argptr, input);
char **paramData;
int *paramLength;
int *paramFormat;
ExtractArguments(argptr, indices, ¶mData, ¶mLength);
paramFormat=RakNet::OP_NEW_ARRAY<int>(indices.Size(),_FILE_AND_LINE_);
for (unsigned int i=0; i < indices.Size(); i++)
paramFormat[i]=PQEXECPARAM_FORMAT_BINARY;
result = PQexecPrepared(pgConn, RakNet::RakString("PGSQL_ExecuteVariadic_%i", preparedQueryIndex), indices.Size(), paramData, paramLength, paramFormat, PQEXECPARAM_FORMAT_BINARY );
VariadicSQLParser::FreeArguments(indices, paramData, paramLength);
RakNet::OP_DELETE_ARRAY(paramFormat,_FILE_AND_LINE_);
va_end(argptr);
if (IsResultSuccessful(result, false)==false)
{
printf(lastError);
PQclear(result);
return 0;
}
return result;
}