void FileList::AddFile(const char *filename, const char *data, const unsigned dataLength, const unsigned fileLength, FileListNodeContext context, bool isAReference)
{
if (filename==0)
return;
if (strlen(filename)>MAX_FILENAME_LENGTH)
{
// Should be enough for anyone
RakAssert(0);
return;
}
// If adding a reference, do not send data
RakAssert(isAReference==false || data==0);
// Avoid duplicate insertions unless the data is different, in which case overwrite the old data
unsigned i;
for (i=0; i<fileList.Size();i++)
{
if (strcmp(fileList[i].filename, filename)==0)
{
if (fileList[i].fileLengthBytes==fileLength && fileList[i].dataLengthBytes==dataLength &&
(dataLength==0 || memcmp(fileList[i].data, data, dataLength)==0))
// Exact same file already here
return;
// File of the same name, but different contents, so overwrite
rakFree(fileList[i].data);
rakFree(fileList[i].filename);
fileList.RemoveAtIndex(i);
break;
}
}
FileListNode n;
n.filename=(char*) rakMalloc( strlen(filename)+1 );
if (dataLength && data)
{
n.data=(char*) rakMalloc( dataLength );
memcpy(n.data, data, dataLength);
}
else
n.data=0;
n.dataLengthBytes=dataLength;
n.fileLengthBytes=fileLength;
n.isAReference=isAReference;
n.context=context;
strcpy(n.filename, filename);
fileList.Insert(n);
}
void ThreadsafePacketLogger::AddToLog(const char *str)
{
char **msg = logMessages.WriteLock();
*msg = (char*) rakMalloc( strlen(str)+1 );
strcpy(*msg, str);
logMessages.WriteUnlock();
}
unsigned DataCompressor::DecompressAndAllocate( RakNet::BitStream * input, unsigned char **output )
{
HuffmanEncodingTree tree;
unsigned int bitsUsed, destinationSizeInBytes, decompressedBytes;
unsigned int frequencyTable[ 256 ];
unsigned i;
input->ReadCompressed(destinationSizeInBytes);
for (i=0; i < 256; i++)
input->ReadCompressed(frequencyTable[i]);
input->AlignReadToByteBoundary();
if (input->Read(bitsUsed)==false)
{
// Read error
#ifdef _DEBUG
assert(0);
#endif
return 0;
}
*output = (unsigned char*) rakMalloc(destinationSizeInBytes);
tree.GenerateFromFrequencyTable(frequencyTable);
decompressedBytes=tree.DecodeArray(input, bitsUsed, destinationSizeInBytes, *output );
assert(decompressedBytes==destinationSizeInBytes);
return destinationSizeInBytes;
}
RNS2_SendParameters_NativeClient* RNS2_NativeClient::CloneSP(RNS2_SendParameters *sp, RNS2_NativeClient *socket2, const char *file, unsigned int line)
{
RNS2_SendParameters_NativeClient *spNew = RakNet::OP_NEW<RNS2_SendParameters_NativeClient>(file, line);
spNew->data=(char*) rakMalloc(sp->length);
memcpy(spNew->data,sp->data,sp->length);
spNew->length = sp->length;
spNew->socket2=socket2;
spNew->systemAddress=sp->systemAddress;
spNew->ttl=0; // Unused
return spNew;
}
void TelnetTransport::SetSendPrefix(const char *prefix)
{
if (sendPrefix)
{
rakFree(sendPrefix);
sendPrefix=0;
}
if (prefix)
{
sendPrefix = (char*) rakMalloc(strlen(prefix)+1);
strcpy(sendPrefix, prefix);
}
}
void TelnetTransport::SetSendSuffix(const char *suffix)
{
if (sendSuffix)
{
rakFree(sendSuffix);
sendSuffix=0;
}
if (suffix)
{
sendSuffix = (char*) rakMalloc(strlen(suffix)+1);
strcpy(sendSuffix, suffix);
}
}
void MessageFilter::SetAllowRPC(bool allow, const char *functionName, int filterSetID)
{
(void) allow;
FilterSet *filterSet = GetFilterSetByID(filterSetID);
bool objectExists;
unsigned index = filterSet->allowedRPCs.GetIndexFromKey((char *const) functionName, &objectExists);
if (objectExists==false)
{
char *str = (char*) rakMalloc( strlen(functionName)+1 );
strcpy(str, functionName);
filterSet->allowedRPCs.InsertAtIndex(str, index);
}
}
void TCPInterface::Send( const char *data, unsigned length, SystemAddress systemAddress )
{
if (isStarted==false)
return;
if (remoteClients.Size()==0)
return;
if (data==0)
return;
Packet *p=outgoingMessages.WriteLock();
p->length=length;
p->data = (unsigned char*) rakMalloc( p->length );
memcpy(p->data, data, p->length);
p->systemAddress=systemAddress;
outgoingMessages.WriteUnlock();
}
void FileList::AddFile(const char *filepath, const char *filename, FileListNodeContext context)
{
if (filepath==0 || filename==0)
return;
char *data;
//std::fstream file;
//file.open(filename, std::ios::in | std::ios::binary);
FILE *fp = fopen(filepath, "rb");
if (fp==0)
return;
fseek(fp, 0, SEEK_END);
int length = ftell(fp);
fseek(fp, 0, SEEK_SET);
if (length > (int) ((unsigned int)-1 / 8))
{
// If this assert hits, split up your file. You could also change BitSize_t in RakNetTypes.h to unsigned long long but this is not recommended for performance reasons
RakAssert("Cannot add files over 536 MB" && 0);
fclose(fp);
return;
}
#if !defined(_XBOX) && !defined(_X360)
bool usedAlloca=false;
if (length < MAX_ALLOCA_STACK_ALLOCATION)
{
data = ( char* ) alloca( length );
usedAlloca=true;
}
else
#endif
{
data = (char*) rakMalloc( length );
}
fread(data, 1, length, fp);
AddFile(filename, data, length, length, context);
fclose(fp);
#if !defined(_XBOX) && !defined(_X360)
if (usedAlloca==false)
#endif
rakFree(data);
}
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;
}
void FileList::PopulateDataFromDisk(const char *applicationDirectory, bool writeFileData, bool writeFileHash, bool removeUnknownFiles)
{
FILE *fp;
char fullPath[512];
unsigned i;
// CSHA1 sha1;
i=0;
while (i < fileList.Size())
{
rakFree(fileList[i].data);
strcpy(fullPath, applicationDirectory);
FixEndingSlash(fullPath);
strcat(fullPath,fileList[i].filename);
fp=fopen(fullPath, "rb");
if (fp)
{
if (writeFileHash || writeFileData)
{
fseek(fp, 0, SEEK_END);
fileList[i].fileLengthBytes = ftell(fp);
fseek(fp, 0, SEEK_SET);
if (writeFileHash)
{
if (writeFileData)
{
// Hash + data so offset the data by HASH_LENGTH
fileList[i].data=(char*) rakMalloc( fileList[i].fileLengthBytes+HASH_LENGTH );
fread(fileList[i].data+HASH_LENGTH, fileList[i].fileLengthBytes, 1, fp);
// sha1.Reset();
// sha1.Update((unsigned char*)fileList[i].data+HASH_LENGTH, fileList[i].fileLength);
// sha1.Final();
unsigned int hash = SuperFastHash(fileList[i].data+HASH_LENGTH, fileList[i].fileLengthBytes);
if (RakNet::BitStream::DoEndianSwap())
RakNet::BitStream::ReverseBytesInPlace((unsigned char*) &hash, sizeof(hash));
// memcpy(fileList[i].data, sha1.GetHash(), HASH_LENGTH);
memcpy(fileList[i].data, &hash, HASH_LENGTH);
}
else
{
// Hash only
fileList[i].dataLengthBytes=HASH_LENGTH;
if (fileList[i].fileLengthBytes < HASH_LENGTH)
fileList[i].data=(char*) rakMalloc( HASH_LENGTH );
else
fileList[i].data=(char*) rakMalloc( fileList[i].fileLengthBytes );
fread(fileList[i].data, fileList[i].fileLengthBytes, 1, fp);
// sha1.Reset();
// sha1.Update((unsigned char*)fileList[i].data, fileList[i].fileLength);
// sha1.Final();
unsigned int hash = SuperFastHash(fileList[i].data, fileList[i].fileLengthBytes);
if (RakNet::BitStream::DoEndianSwap())
RakNet::BitStream::ReverseBytesInPlace((unsigned char*) &hash, sizeof(hash));
// memcpy(fileList[i].data, sha1.GetHash(), HASH_LENGTH);
memcpy(fileList[i].data, &hash, HASH_LENGTH);
}
}
else
{
// Data only
fileList[i].dataLengthBytes=fileList[i].fileLengthBytes;
fileList[i].data=(char*) rakMalloc( fileList[i].fileLengthBytes );
fread(fileList[i].data, fileList[i].fileLengthBytes, 1, fp);
}
fclose(fp);
i++;
}
else
{
fileList[i].data=0;
fileList[i].dataLengthBytes=0;
}
}
else
{
if (removeUnknownFiles)
{
rakFree(fileList[i].filename);
fileList.RemoveAtIndex(i);
}
else
i++;
}
}
}
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( (size_t) n.dataLengthBytes );
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=(char*) rakMalloc( strlen(filename)+1 );
strcpy(n.filename, filename);
fileList.Insert(n);
}
return true;
}
void FileList::AddFilesFromDirectory(const char *applicationDirectory, const char *subDirectory, bool writeHash, bool writeData, bool recursive, FileListNodeContext context)
{
DataStructures::Queue<char*> dirList;
char root[260];
char fullPath[520];
_finddata_t fileInfo;
intptr_t dir;
FILE *fp;
char *dirSoFar, *fileData;
dirSoFar=(char*) rakMalloc( 520 );
if (applicationDirectory)
strcpy(root, applicationDirectory);
else
root[0]=0;
int rootLen=(int)strlen(root);
if (rootLen)
{
strcpy(dirSoFar, root);
if (FixEndingSlash(dirSoFar))
rootLen++;
}
else
dirSoFar[0]=0;
if (subDirectory)
{
strcat(dirSoFar, subDirectory);
FixEndingSlash(dirSoFar);
}
if (callback)
callback->OnAddFilesFromDirectoryStarted(this, dirSoFar);
// RAKNET_DEBUG_PRINTF("Adding files from directory %s\n",dirSoFar);
dirList.Push(dirSoFar);
while (dirList.Size())
{
dirSoFar=dirList.Pop();
strcpy(fullPath, dirSoFar);
// Changed from *.* to * for Linux compatibility
strcat(fullPath, "*");
dir=_findfirst(fullPath, &fileInfo );
if (dir==-1)
{
_findclose(dir);
rakFree(dirSoFar);
unsigned i;
for (i=0; i < dirList.Size(); i++)
rakFree(dirList[i]);
return;
}
// RAKNET_DEBUG_PRINTF("Adding %s. %i remaining.\n", fullPath, dirList.Size());
if (callback)
callback->OnDirectory(this, fullPath, dirList.Size());
do
{
// no guarantee these entries are first...
if (strcmp("." , fileInfo.name) == 0 ||
strcmp("..", fileInfo.name) == 0)
{
continue;
}
if ((fileInfo.attrib & (_A_HIDDEN | _A_SUBDIR | _A_SYSTEM))==0)
{
strcpy(fullPath, dirSoFar);
strcat(fullPath, fileInfo.name);
fileData=0;
if (callback)
callback->OnFile(this, dirSoFar, fileInfo.name, fileInfo.size);
if (writeData && writeHash)
{
fileData= (char*) rakMalloc( fileInfo.size+HASH_LENGTH );
fp = fopen(fullPath, "rb");
fread(fileData+HASH_LENGTH, fileInfo.size, 1, fp);
fclose(fp);
unsigned int hash = SuperFastHash(fileData+HASH_LENGTH, fileInfo.size);
if (RakNet::BitStream::DoEndianSwap())
RakNet::BitStream::ReverseBytesInPlace((unsigned char*) &hash, sizeof(hash));
memcpy(fileData, &hash, HASH_LENGTH);
// sha1.Reset();
// sha1.Update( ( unsigned char* ) fileData+HASH_LENGTH, fileInfo.size );
// sha1.Final();
// memcpy(fileData, sha1.GetHash(), HASH_LENGTH);
// File data and hash
AddFile((const char*)fullPath+rootLen, fileData, fileInfo.size+HASH_LENGTH, fileInfo.size, context);
}
else if (writeHash)
{
// sha1.Reset();
// sha1.HashFile((char*)fullPath);
// sha1.Final();
unsigned int hash = SuperFastHashFile(fullPath);
if (RakNet::BitStream::DoEndianSwap())
RakNet::BitStream::ReverseBytesInPlace((unsigned char*) &hash, sizeof(hash));
// Hash only
// AddFile((const char*)fullPath+rootLen, (const char*)sha1.GetHash(), HASH_LENGTH, fileInfo.size, context);
AddFile((const char*)fullPath+rootLen, (const char*)&hash, HASH_LENGTH, fileInfo.size, context);
}
else if (writeData)
{
fileData= (char*) rakMalloc( fileInfo.size );
fp = fopen(fullPath, "rb");
fread(fileData, fileInfo.size, 1, fp);
fclose(fp);
// File data only
AddFile(fullPath+rootLen, fileData, fileInfo.size, fileInfo.size, context);
}
else
{
// Just the filename
AddFile(fullPath+rootLen, 0, 0, fileInfo.size, context);
}
if (fileData)
rakFree(fileData);
}
else if ((fileInfo.attrib & _A_SUBDIR) && (fileInfo.attrib & (_A_HIDDEN | _A_SYSTEM))==0 && recursive)
{
char *newDir=(char*) rakMalloc( 520 );
strcpy(newDir, dirSoFar);
strcat(newDir, fileInfo.name);
strcat(newDir, "/");
dirList.Push(newDir);
}
} while (_findnext(dir, &fileInfo ) != -1);
_findclose(dir);
rakFree(dirSoFar);
}
}
bool WriteFileWithDirectories( const char *path, char *data, unsigned dataLength )
{
int index;
FILE *fp;
char *pathCopy;
#ifndef _WIN32
char *systemCommand;
#endif
if ( path == 0 || path[ 0 ] == 0 )
return false;
#ifndef _WIN32
systemCommand = (char*) rakMalloc( strlen( path ) + 1 + 6 );
#endif
pathCopy = (char*) rakMalloc( strlen( path ) + 1 );
strcpy( pathCopy, path );
index = 0;
while ( pathCopy[ index ] )
{
if ( pathCopy[ index ] == '/' || pathCopy[ index ] == '\\')
{
pathCopy[ index ] = 0;
#ifdef _WIN32
#pragma warning( disable : 4966 ) // mkdir declared depreciated by Microsoft in order to make it harder to be cross platform. I don't agree it's depreciated.
mkdir( pathCopy );
#else
mkdir( pathCopy, 0744 );
#endif
pathCopy[ index ] = '/';
}
index++;
}
if (data)
{
fp = fopen( path, "wb" );
if ( fp == 0 )
{
rakFree(pathCopy);
#ifndef _WIN32
rakFree(systemCommand);
#endif
return false;
}
fwrite( data, 1, dataLength, fp );
fclose( fp );
}
else
{
#ifdef _WIN32
#pragma warning( disable : 4966 ) // mkdir declared depreciated by Microsoft in order to make it harder to be cross platform. I don't agree it's depreciated.
mkdir( pathCopy );
#else
mkdir( pathCopy, 0744 );
#endif
}
rakFree(pathCopy);
#ifndef _WIN32
rakFree(systemCommand);
#endif
return true;
}