WebSVN – spk – Diff – //libspk/src/CatFile.cpp

 #include <time.h>
 #include "File.h"
 #include "DirIO.h"
 #include "Logging/Log.h"
-CCatFile::CCatFile ()
+CCatFile::CCatFile () : m_bCatChanged(false)
+{
 	m_iDataType = CATFILE_NONE;
 	m_sData = NULL;
 	m_lSize = 0;
 	m_bCreate = false;
 CCatFile::~CCatFile ()
+{
 	m_fDatFile.close();
 	m_fCatFile.close();
+	if ( m_bCatChanged ) {
+		WriteCatFile ();
+		m_fCatFile.close();
+	}
 	for ( SInCatFile *c = m_lFiles.First(); c; c = m_lFiles.Next() )
+	{
 		if ( c->sData )
-			delete c->sData;
+			delete []c->sData;
 		delete c;
+	}
+	if ( m_sData ) delete []m_sData;
 	m_lFiles.clear();
+}
 bool CCatFile::IsAddonDir(CyString dir)
+{
 	// size must be multiples of 5
 	size_t size = lFileSize + ((lFileSize % 5) ? 5 - (lFileSize % 5) : 0);
 	// read cat to buffer
 	try {
+		if ( m_sData ) delete [] m_sData;
 		m_sData = new unsigned char[size + 1];
+	}
 	catch (std::exception &e) {
 		CLog::logf(CLog::Log_IO, 2, "Memory Exception error, unable to alloc enough memory to store file data, %d (%s)", size + 1, e.what());
 		return CATERR_MALLOC;
 	size_t offset = 0;
 	unsigned char *data = m_sData;
 	int spacePos = -1;
-	while ( m_sData[num] != '\0' )
+	while ( m_sData[num] != '\0' ) {
-	{
-		if ( m_sData[num] == '\n' )
+		if ( m_sData[num] == '\n' ) {
-		{
 			m_sData[num] = 0;
 			if ( spacePos != -1 )
+			{
 				CyString file;
 				int size = 0;
 	return true;
+}
 void CCatFile::RemoveData ()
+{
-	if ( m_sData ) delete m_sData;
+	delete m_sData;
 	m_sData = NULL;
 	m_iDataType = CATFILE_NONE;
 	m_lSize = 0;
+}
 bool CCatFile::ReadFileToData ( SInCatFile *c )
+{
 	if ( !c ) return false;
 	size_t size = 0;
-	if ( !c->sData ) c->sData = ReadData ( c, &size );
+	if ( !c->sData ) c->sData = readData ( c, &size );
 	if ( c->sData )	return true;
 	return false;
+}
-unsigned char *CCatFile::ReadData ( SInCatFile *c, size_t *size )
+unsigned char *CCatFile::readData ( SInCatFile *c, size_t *size )
+{
 	*size = c->lSize;
-	std::fstream File(m_fDatFile.GetFullFilename().c_str(), std::ios::in | std::ios::binary);
-	if ( File.is_open() ) {
+	if ( !c->sData ) {
-		File.seekg(c->lOffset, std::ios::beg);
+		if ( m_fDatFile.startRead() ) {
-		unsigned char *data;
+			m_fDatFile.seek(c->lOffset);
-		try {
-			data = new unsigned char[c->lSize + 1];
+			c->sData = m_fDatFile.read(c->lSize);
-		}
-		catch(std::exception &e) {
-			CLog::logf(CLog::Log_IO, 2, "CCatFile::ReadData() unable to malloc data storage: %s, %d (%s)", c->sFile.c_str(), c->lSize, e.what());
-			File.close();
+			m_fDatFile.close();
-			return NULL;
-		}
-		try {
-			File.read((char *)data, c->lSize);
+			if ( !c->sData ) (*size) = 0;
-		}
+			else {
-		catch(std::exception &amp;e) {
+				c->sData[c->lSize] = &apos;\0';
-			CLog::logf(CLog::Log_IO, 2, "CCatFile::ReadData() unable to read file data: %s, %d (%s)", c->sFile.c_str(), c->lSize, e.what());
+				DecryptDAT(c->sData, c->lSize);
-			File.close();
+				c->bDecrypted = true;
-			return NULL;
+			}
+		}
-		File.close();
-		*size = c->lSize;
-		data[c->lSize] = '\0';
-		DecryptDAT(data, c->lSize);
-		c->bDecrypted = true;
-		return data;
+	}
-	return NULL;
+	return c->sData;
+}
 void CCatFile::DecryptDAT(SInCatFile *pFile)
+{
 	if ( pFile->bDecrypted ) return;
+}
 void CCatFile::DecryptDAT(unsigned char *buffer, size_t size)
+{
 	for(unsigned char *pos=buffer, *end=buffer + size; pos < end; pos++){
 		*pos^=0x33;
 	}
 }
-unsigned char *CCatFile::ReadData ( CyString filename, size_t *size )
+unsigned char *CCatFile::readData ( CyString filename, size_t *size )
 {
 	*size = 0;
-	if ( !m_fDatFile.NoFile() )
+	if ( !m_fDatFile.NoFile() ) {
-	{
 		SInCatFile *c = FindData ( filename );
-		if ( c )
-			return ReadData ( c, size );
+		if ( c ) return readData ( c, size );
+	}
 	return NULL;
+}
 	// plain file
 	if ( iFiletype == FILETYPE_PLAIN ) {
 		*size = c->lSize;
 		return c->sData;
 	}
 	//otherwise unpack it
 //	if ( IsDataPCK ( (const unsigned char *)c->sData, c->lSize ) || forcepck )
 	/*int iOffset = 0;
 	if ( iFiletype == FILETYPE_PCK ) {
 			iOffset = node->Data()->lOffset;
+		}
 		else if ( iOffset >= 0 ) {
 			node->Data()->lOffset = iOffset;
 			iOffset += node->Data()->lSize;
 		}
 	}
 	// now just write the new cat file
 	m_lFiles.remove ( f );
-	WriteCatFile ();
+	m_bCatChanged = true;
 	return true;
+}
 bool CCatFile::WriteCatFile ()
 {
-	if ( (m_bCreate) && (m_lFiles.empty()) )
+	if ( (m_bCreate) && (m_lFiles.empty()) ) return false;
+	Utils::String cat = m_fCatFile.filename() + "\n";
+	for ( CListNode<SInCatFile> *node = m_lFiles.Front(); node; node = node->next() ) {
+		if ( !node->Data() ) continue;
+		if ( node->Data()->sFile.Empty() ) continue;
+		Utils::String str = node->Data()->sFile.ToString();
+		cat += str.findReplace("/", "\\").findReplace("\\\\", "\\") + " " + (long)node->Data()->lSize + "\n";
+	}
-		return false;
+	if ( !cat.length() ) return false;
+	// make sure the len is in multiples of 5, otherwise decryptData could cause heap problems
+	size_t len = cat.length() + ((cat.length() % 5) ? 5 - (cat.length() % 5) : 0);
+	bool ret = false;
+	try {
-	CyString cat = m_fCatFile.GetFilename() + "\n";
+		unsigned char *data = new unsigned char[len + 1];
+		memcpy(data, cat.c_str(), cat.length() * sizeof(unsigned char));
+		for ( size_t i = len; i >= cat.length(); i-- ) data[i] = '\0';
+		this->DecryptData(data, len);
-	for ( SInCatFile *f = m_lFiles.First(); f; f = m_lFiles.Next() )
+		bool ret = m_fCatFile.write(data, cat.length());
-	{
-		if ( f->sFile.Empty() )
-			continue;
+		delete []data;
-		cat += f->sFile.findreplace("/", "\\") + " " + (long)f->lSize + "\n";
+	}
-	if ( !cat.Length() )
+	catch(std::exception &e) {
+		CLog::logf(CLog::Log_IO, 2, "CCatFile::WriteCatFile() unable to malloc, %d (%s)", len + 1, e.what());
 		return false;
-	size_t len = cat.Length();
-//	if ( len % 5)
-//		len += (5 - (len % 5));
+	}
-	unsigned char *data = new unsigned char[len + 1];
-	memcpy ( data, cat.c_str(), cat.Length() );
-	for ( size_t i = len; i > cat.Length(); i-- )
-		data[i] = '\0';
+	m_fCatFile.close();
-	DecryptData ( data, len );
+	m_bCatChanged = false;
-	m_fCatFile.WriteData ( (const char *)data, len );
-	return true;
+	return ret;
 }
 bool CCatFile::CheckExtensionPck ( CyString filename )
+{
 	CyString ext = filename.GetToken ( ".", filename.NumToken  ( "." ) ).lower();
 	if ( ext == "xml" )
 		return true;
 	else if ( ext == "txt" )
 		return true;
 	else if ( ext == "bob" )
 		return true;
 	else if ( ext == "bod" )
 		return true;
 bool CCatFile::AppendFile(const Utils::String &filename, const Utils::String &sTo, bool pck, bool bXor, Utils::String *sChangeTo)
+{
 	CLog::logf(CLog::Log_IO, 1, "CCatFile::AppendFile() Adding file, %s, into cat file, %s::%s [PCK:%s XOR:%s]", filename.c_str(), this->m_fCatFile.GetFilename().ToString().c_str(), sTo.c_str(), (pck) ? "Yes" : "No", (bXor) ? "Yes" : "No");
 	if ( filename.isin ( "::" ) ) return WriteFromCat ( filename.token("::", 1), filename.token("::", 2));
-	if ( (!m_bCreate) && (!m_fCatFile.exists ()) ) {
+	if ( (!m_bCreate) && (!m_fDatFile.exists ()) ) {
 		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() Cat File: %s, doesn't exist, quitting...", m_fCatFile.GetFullFilename().ToString().c_str());
 		return false;
+	}
 	CyString to = sTo;
 	if ( !m_sAddonDir.Empty() && CCatFile::IsAddonDir(to) ) {
 	bool dofile = true;
 	if ( !m_lFiles.size() )	{
 		CLog::logf(CLog::Log_IO, 3, "CCatFile::AppendFile() no existing files found, wipeing the existing dat file");
 		m_fDatFile.WipeFile();
 	}
 	CFileIO File(filename);
 	if ( !File.startRead() ) {
 		CLog::logf(CLog::Log_IO, 3, "CCatFile::AppendFile() unable to open file, %s, for reading", filename.c_str());
 		return false;
+	}
 	// check if we need to pack the file
 	int iFileType = this->_checkFiletype(data, 3);
 	CLog::logf(CLog::Log_IO, 3, "CCatFile::AppendFile() preparing to append file data, Type=%d", iFileType);
 	if ( iFileType == FILETYPE_PLAIN && CheckPackedExtension(to) ) {
 		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() plain text file needs to packed");
 		size_t newsize = 0;
 		unsigned char *newdata = PCKData(data, File.fileSize(), &newsize, bXor);
 		CLog::logf(CLog::Log_IO, 1, "CCatFile::AppendFile() file has been packed, %d => %d", File.fileSize(), newsize);
 		f->lSize = newsize;
 		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() Decrypting data");
 		append = m_fDatFile.AppendDataToPos ( (const char *)data, f->lSize, f->lOffset );
+	}
 	CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() cleaning up memory");
 	delete [] data;
+	m_fDatFile.close();
 	if ( append ) {
 		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() append complete, adding file into cat list");
-		m_fDatFile.close();
 		m_bCreate = false;
 		f->sFile = to;
 		m_lFiles.push_back ( f );
 		CLog::logf(CLog::Log_IO, 3, "CCatFile::AppendFile() writing the new cat file");
-		this->WriteCatFile ();
+		m_bCatChanged = true;
 	}
 	else {
 		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() appending failed, cleaning up file data");
 		delete f;
+	}
+	CLog::logf(CLog::Log_IO, 4, "CCatFile::AppendFile() function complete");
-	return true;
+	return append;
 }
 bool CCatFile::AddData ( CyString catfile, unsigned char *data, size_t size, CyString to, bool pck, bool create )
+{
 	int err = Open ( catfile, "", CATREAD_CATDECRYPT, create );
 	if ( (err != CATERR_NONE) && (err != CATERR_CREATED) )
 		return false;
 	return AppendData ( data, size, to, pck );
 }
 int CCatFile::GetEndOffset()
 {
 	if ( m_lFiles.empty() )
 		return 0;
 	else
 		return m_lFiles.Back()->Data()->lOffset + m_lFiles.Back()->Data()->lSize;
+}
 bool CCatFile::AppendData ( unsigned char *data, size_t size, CyString to, bool pck, bool bXor )
+{
 	if ( (!m_bCreate) && (!m_fCatFile.exists ()) )
 		return false;
 	if ( (size <= 0) || (!data) )
 		return false;
 	// then check if the file already exists
 	if ( !m_lFiles.empty() )
+	{
 		SInCatFile *f = FindData ( to );
 		if ( f )
+		{
 			if ( !RemoveFile ( f ) )
 				return false;
 		}
 	}
 	bool append = false;
 	if ( !m_lFiles.size() )
 		m_fDatFile.WipeFile();
 	SInCatFile *f = new SInCatFile;
 	f->sData = 0;
 	if ( m_lFiles.empty() )
 		f->lOffset = 0;
 	else
 		f->lOffset = m_fDatFile.GetFilesize();
 	// if file extension is packed but not the file, then pack it, "pck" forces it to be packed unless it already is
 	f->lSize = size;
 	if ( (((pck) && (CheckExtensionPck (to))) || ((CheckPackedExtension ( to )))) && (!IsDataPCK ( data, size )) )
 	{
 		to = PckChangeExtension ( to );
 		if ( !m_lFiles.empty() )
+		{
 			SInCatFile *f = FindData ( to );
+	{
 		m_fDatFile.close();
 		m_bCreate = false;
 		f->sFile = to;
 		m_lFiles.push_back ( f );
-		WriteCatFile ();
+		m_bCatChanged = true;
+	}
 	else
 		delete f;
 	return true;
 		zs.avail_out=(unsigned int)newsize - zs.total_out;
+	}
 	pos += zs.total_out;
 	deflateEnd(&zs);
 	unsigned long crc=crc32(0, NULL, 0);
 	crc=crc32(crc, buffer, (unsigned int)size);
 	int s = sizeof(crc) + sizeof(size);
 	if ( newsize < (size_t)(s + pos) )
+	{
 		newsize += (s + pos) - newsize;
 		data = (unsigned char *)realloc ( data, sizeof(unsigned char) * newsize );
+	}
 	memcpy(&data[pos], &crc, sizeof(crc));
 	pos += sizeof(crc);
 	memcpy(&data[pos], &size, sizeof(size));
 	pos += sizeof(size);
 	newsize = pos;
 	unsigned char *retdata = NULL;
 	if ( ret == Z_STREAM_END )
+	{
 		*retsize = newsize;
 		retdata = new unsigned char[newsize];
 bool CCatFile::WriteFromCat ( CCatFile *fcat, CyString file )
+{
 	// now find the file in the cat file
 	SInCatFile *getfile = fcat->FindData ( file );
 	if ( !getfile )
 		return false;
 	// read the dat from the cat file
 	size_t size = 0;
-	unsigned char *data = fcat->ReadData ( getfile, &size );
+	unsigned char *data = fcat->readData ( getfile, &size );
 	if ( !data )
 		return false;
 	// now check if it exists in this file
 	RemoveFile ( file );
 	// now write to the new file
-	if ( !m_fDatFile.AppendData ( (const char *)data, size ) )
+	if ( !m_fDatFile.AppendData ( (const char *)data, size ) ) return false;
-		return false;
 	// finally add to the list
 	SInCatFile *f = new SInCatFile;
 	f->sData = 0;
 	if ( m_lFiles.empty() )
 	else
 		f->lOffset = m_lFiles.Back()->Data()->lOffset + m_lFiles.Back()->Data()->lSize;
 	f->sFile = file;
 	f->lSize = size;
 	m_lFiles.push_back ( f );
-	WriteCatFile ();
+	m_bCatChanged = true;
 	return true;
+}
 bool CCatFile::WriteFromCat ( CyString catfile, CyString file )
 	CCatFile fcat;
 	if ( fcat.Open ( catfile, "", CATREAD_CATDECRYPT, false ) )
 		return false;
 	return this->WriteFromCat(&fcat, file);
 }
 SInCatFile *CCatFile::FindData ( CyString filename )
+{
 	if ( m_lFiles.empty() )
 		return NULL;
 		f = f.FindReplace ( "\\", "/" );
 		if ( f.Compare(check) )
 			return c;
+	}
 	return NULL;
 }
 bool CCatFile::MarkRemoveFile( CyString file )
+{
 	SInCatFile *f = FindData ( file );
 	if ( !f )
 	{
 		m_iError = CATERR_NOFILE;
 		return false;
 	}
 	return MarkRemoveFile ( f );
 }
 bool CCatFile::MarkRemoveFile ( SInCatFile *f )
 {
 	f->bDelete = true;
 	return true;
-}
-void CCatFile::WriteFiles()
-{
-	int count = 0;
-	CListNode<SInCatFile> *node;
-	for ( node = m_lFiles.Front(); node; node = node->next() )
-	{
-		if ( node->Data()->bDelete )
-			++count;
-	}
-	if ( !count )
-		return;
-	size_t *offset = new size_t[count * 2];
-	count = 0;
-	node = m_lFiles.Front();
-	while ( node )
-	{
-		CListNode<SInCatFile> *nextNode = node->next();
-		SInCatFile *f = node->Data();
-		if ( f->bDelete )
-		{
-			offset[count++] = f->lOffset;
-			offset[count++] = f->lSize;
-			m_lFiles.remove(node);
-			delete f;
-		}
-		node = nextNode;
-	}
-	if ( m_fDatFile.WritePartFile(offset, count) )
-		WriteCatFile();
+}
 CyStringList *CCatFile::GetTShipsEntries()
+{
 	if ( this->ExtractFile("types/tships.pck", "tships.txt") )

Subversion Repositories spk

(root)//libspk/src/CatFile.cpp – Rev 52 → 53