Subversion Repositories spk

Rev

Rev 52 | Rev 58 | Go to most recent revision | Details | Compare with Previous | Last modification | View Log | RSS feed

Rev Author Line No. Line
1 cycrow 1 
#include "CatFile.h"
2 
#include <time.h>
3 
#include "File.h"
4 
#include "DirIO.h"
51 cycrow 5 
#include "Logging/Log.h"
1 cycrow 6 
 
53 cycrow 7 
CCatFile::CCatFile () : m_bCatChanged(false)
1 cycrow 8 
{
9 
	m_iDataType = CATFILE_NONE;
10 
	m_sData = NULL;
11 
	m_lSize = 0;
12 
	m_bCreate = false;
13 
}
14 
 
15 
CCatFile::~CCatFile ()
16 
{
52 cycrow 17 
	m_fDatFile.close();
18 
	m_fCatFile.close();
53 cycrow 19 
 
20 
	if ( m_bCatChanged ) {
21 
		WriteCatFile ();
22 
		m_fCatFile.close();
23 
	}
24 
 
1 cycrow 25 
	for ( SInCatFile *c = m_lFiles.First(); c; c = m_lFiles.Next() )
26 
	{
27 
		if ( c->sData )
53 cycrow 28 
			delete []c->sData;
1 cycrow 29 
		delete c;
30 
	}
53 cycrow 31 
 
32 
	if ( m_sData ) delete []m_sData;
33 
 
1 cycrow 34 
	m_lFiles.clear();
35 
}
36 
 
37 
bool CCatFile::IsAddonDir(CyString dir)
38 
{
39 
	CyString d = dir;
40 
	d = d.FindReplace("\\", "/");
41 
	d = d.GetToken("/", 1, 1);
42 
 
43 
	if ( d.Compare("types") )
44 
		return true;
45 
	if ( d.Compare("t") )
46 
		return true;
47 
	if ( d.Compare("maps") )
48 
		return true;
49 
	if ( d.Compare("director") )
50 
		return true;
51 
	if ( d.Compare("cutscenes") )
52 
		return true;
53 
	return false;
54 
}
55 
 
56 
bool CCatFile::Opened(int error, bool allowCreate)
57 
{
58 
	if ( error == CATERR_NONE ) return true;
59 
	if ( allowCreate && error == CATERR_CREATED ) return true;
60 
	return false;
61 
}
51 cycrow 62 
int CCatFile::Open ( CyString sCatfile, CyString addon, int readtype, bool create )
1 cycrow 63 
{
51 cycrow 64 
	Utils::String catfile = sCatfile.ToString();
65 
 
1 cycrow 66 
	m_bCreate = false;
67 
 
51 cycrow 68 
	Utils::String datfile;
69 
	if ( !catfile.right(4).Compare(".cat") ) {
1 cycrow 70 
		datfile = catfile + ".dat";
71 
		catfile += ".cat";
72 
	}
51 cycrow 73 
	else datfile = catfile.left(-4) + ".dat";
1 cycrow 74 
 
51 cycrow 75 
	if ( readtype == CATREAD_JUSTCONTENTS ) create = false;
1 cycrow 76 
 
77 
	// first check if the dat file exists and opens
78 
	bool created = false;
51 cycrow 79 
	if ( readtype != CATREAD_JUSTCONTENTS ) {
80 
		std::ifstream file(datfile);
81 
		if ( !file.good() ) {
82 
			if ( create ) created = true;
83 
			else		  return CATERR_NODATFILE;
1 cycrow 84 
		}
85 
 
51 cycrow 86 
		if ( file.is_open() ) file.close();
1 cycrow 87 
	}
88 
 
89 
	// now open the cat file to read
51 cycrow 90 
	std::fstream File;
91 
	File.open(catfile.c_str(), std::ios::in | std::ios::binary);
92 
	if ( !File.is_open() ) {
93 
		if ( create ) created = true;
94 
		else		  return CATERR_NOCATFILE;
1 cycrow 95 
	}
96 
 
51 cycrow 97 
	if ( created ) {
98 
		m_fCatFile.Open(catfile);
99 
		m_fDatFile.Open(datfile);
1 cycrow 100 
		m_bCreate = true;
101 
		return CATERR_CREATED;
102 
	}
103 
 
104 
	// find the file size
51 cycrow 105 
	File.seekg(0, std::ios::end);
106 
	size_t lFileSize = File.tellg();
107 
	File.seekg(0, std::ios::beg);
1 cycrow 108 
 
51 cycrow 109 
	if ( !lFileSize ) {
110 
		File.close();
1 cycrow 111 
		return CATERR_FILEEMPTY;
112 
	}
113 
 
114 
	// size must be multiples of 5
115 
	size_t size = lFileSize + ((lFileSize % 5) ? 5 - (lFileSize % 5) : 0);
116 
 
117 
	// read cat to buffer
51 cycrow 118 
	try {
53 cycrow 119 
		if ( m_sData ) delete [] m_sData;
51 cycrow 120 
		m_sData = new unsigned char[size + 1];
121 
	}
122 
	catch (std::exception &e) {
123 
		CLog::logf(CLog::Log_IO, 2, "Memory Exception error, unable to alloc enough memory to store file data, %d (%s)", size + 1, e.what());
124 
		return CATERR_MALLOC;
125 
	}
126 
 
1 cycrow 127 
	m_lSize = size;
51 cycrow 128 
	try {
129 
		File.read((char *)m_sData, m_lSize);
130 
	} catch (std::exception &e) {
131 
		CLog::logf(CLog::Log_IO, 3, "CCatFile::Open() unable to read from cat file, %s", e.what());
1 cycrow 132 
		RemoveData ();
51 cycrow 133 
		File.close();
1 cycrow 134 
		return CATERR_READCAT;
135 
	}
136 
 
51 cycrow 137 
	m_sData[size] = 0;
1 cycrow 138 
	m_iDataType = CATFILE_READ;
51 cycrow 139 
	File.close();
1 cycrow 140 
 
51 cycrow 141 
	if ( readtype != CATREAD_CAT ) {
142 
		if ( !DecryptData () ) return CATERR_DECRYPT;
1 cycrow 143 
		m_sData[lFileSize] = 0;
144 
		ReadFiles ();
145 
	}
146 
 
147 
	m_sAddonDir = addon;
148 
 
149 
	m_fCatFile.Open ( catfile );
150 
 
51 cycrow 151 
	if ( readtype != CATREAD_JUSTCONTENTS ) {
1 cycrow 152 
		m_fDatFile.Open ( datfile );
153 
 
154 
		// check the file size matches
155 
		long compare = 0;
51 cycrow 156 
		std::fstream file(datfile, std::ios::in | std::ios::binary);
157 
		if ( file.is_open() ) {
158 
			file.seekg(0, std::ios::end);
159 
			compare = file.tellg();
160 
			file.close();
1 cycrow 161 
		}
162 
		SInCatFile *c = m_lFiles.Back ()->Data();
51 cycrow 163 
		//if ( (c->lSize + c->lOffset) != compare ) return CATERR_MISMATCH;
1 cycrow 164 
	}
165 
 
51 cycrow 166 
	if ( readtype >= CATREAD_DAT ) LoadDatFile ();
1 cycrow 167 
 
168 
	return CATERR_NONE;
169 
}
170 
 
171 
bool CCatFile::RemoveFile ( CyString file )
172 
{
173 
	if ( !m_sAddonDir.Empty() ) {
174 
		SInCatFile *f = FindData ( m_sAddonDir + "\\" + file );
175 
		if ( f )
176 
			RemoveFile(f);
177 
	}
178 
	{
179 
		SInCatFile *f = FindData ( CyString("addon\\") + file );
180 
		if ( f )
181 
			RemoveFile(f);
182 
	}
183 
	SInCatFile *f = FindData ( file );
184 
	if ( !f )
185 
	{
186 
		m_iError = CATERR_NOFILE;
187 
		return false;
188 
	}
189 
 
190 
	return RemoveFile ( f );
191 
}
192 
 
193 
void CCatFile::LoadDatFile ()
194 
{
195 
	if ( m_fDatFile.NoFile() )
196 
		return;
197 
 
51 cycrow 198 
	std::fstream File(m_fDatFile.GetFullFilename().ToString().c_str(), std::ios::in | std::ios::binary);
199 
	if ( File.is_open() ) {
1 cycrow 200 
		for ( CListNode<SInCatFile> *node = m_lFiles.Front(); node; node = node->next() )
201 
		{
202 
			SInCatFile *c = node->Data();
51 cycrow 203 
			if ( c->sData )	delete c->sData;
1 cycrow 204 
 
51 cycrow 205 
			try {
206 
				c->sData = new unsigned char[c->lSize + 1];
207 
			}
208 
			catch (std::exception &e) {
209 
				CLog::logf(CLog::Log_IO, 2, "CCatFile::LoadDatFile() unable to malloc data storage: %s, %d (%s)", c->sFile.c_str(), c->lSize, e.what());
210 
				continue;
211 
			}
212 
 
213 
			try {
214 
				File.read((char *)c->sData, c->lSize);
215 
			}
216 
			catch(std::exception &e) {
217 
				CLog::logf(CLog::Log_IO, 2, "CCatFile::LoadDatFile() unable to read file data: %s, %d (%s)", c->sFile.c_str(), c->lSize, e.what());
218 
				continue;
219 
			}
220 
			this->DecryptDAT(c);
1 cycrow 221 
		}
51 cycrow 222 
		File.close();
1 cycrow 223 
	}
224 
}
225 
 
226 
bool CCatFile::ReadFiles ()
227 
{
228 
	int num = 0;
229 
 
230 
	size_t offset = 0;
231 
 
232 
	unsigned char *data = m_sData;
233 
	int spacePos = -1;
53 cycrow 234 
	while ( m_sData[num] != '\0' ) {
235 
		if ( m_sData[num] == '\n' ) {
1 cycrow 236 
			m_sData[num] = 0;
237 
			if ( spacePos != -1 )
238 
			{
239 
				CyString file;
240 
				int size = 0;
241 
 
242 
				m_sData[spacePos] = '\0';
243 
				file = (char *)data;
244 
				data = (m_sData + (spacePos + 1));
245 
				if ( !CyString((char *)data).IsNumber() )
246 
					size = 0;
247 
				else
248 
					size = atoi((const char *)data);
249 
 
250 
				if ( size )
251 
				{
252 
					SInCatFile *catfile = new SInCatFile;
253 
 
254 
					catfile->lSize = size;
255 
					catfile->sFile = file;
256 
					catfile->lOffset = offset;
257 
					catfile->sData = 0;
258 
 
259 
					offset += catfile->lSize;
260 
 
261 
					m_lFiles.push_back ( catfile );
262 
				}
263 
			}
264 
			data = (m_sData + (num + 1));
265 
			spacePos = -1;
266 
		}
267 
		else if ( m_sData[num] == ' ' )
268 
			spacePos = num;
269 
		++num;
270 
	}
271 
 
272 
	return true;
273 
}
274 
 
275 
bool CCatFile::DecryptData ( unsigned char *data, size_t size )
276 
{
277 
	unsigned char cl=0xDB, dh=0xDC, dl=0xDD, ah=0xDE, ch=0xDF, al;
278 
	unsigned char *ptr = data, *end = data + size;
279 
	for ( ptr = data; ptr < end; ptr += 5)
280 
	{
281 
		al=ch;
282 
		ch+=5;
283 
		*(ptr + 4) ^= al;
284 
		al=ah;
285 
		ah+=5;
286 
		*(ptr + 3) ^= al;
287 
		al=dl;
288 
		dl+=5;
289 
		*(ptr + 2) ^= al;
290 
		al=dh;
291 
		dh+=5;
292 
		*(ptr + 1) ^= al;
293 
		al=cl;
294 
		cl+=5;
295 
		*(ptr + 0) ^= al;
296 
	}
297 
 
298 
	return true;
299 
}
300 
 
301 
bool CCatFile::DecryptData ()
302 
{
51 cycrow 303 
	if ( !DecryptData ( m_sData, m_lSize ) ) return false;
1 cycrow 304 
 
305 
	m_iDataType = CATERR_DECRYPT;
306 
 
307 
	return true;
308 
}
309 
 
310 
void CCatFile::RemoveData ()
311 
{
53 cycrow 312 
	delete m_sData;
1 cycrow 313 
	m_sData = NULL;
314 
	m_iDataType = CATFILE_NONE;
315 
	m_lSize = 0;
316 
}
317 
 
318 
bool CCatFile::ReadFileToData ( CyString filename )
319 
{
320 
	SInCatFile *c = FindData ( filename );
321 
	return ReadFileToData ( c );
322 
}
323 
 
324 
bool CCatFile::ReadFileToData ( SInCatFile *c )
325 
{
41 cycrow 326 
	if ( !c ) return false;
1 cycrow 327 
	size_t size = 0;
53 cycrow 328 
	if ( !c->sData ) c->sData = readData ( c, &size );
41 cycrow 329 
	if ( c->sData )	return true;
1 cycrow 330 
	return false;
331 
}
332 
 
53 cycrow 333 
unsigned char *CCatFile::readData ( SInCatFile *c, size_t *size )
1 cycrow 334 
{
335 
	*size = c->lSize;
336 
 
53 cycrow 337 
	if ( !c->sData ) {
338 
		if ( m_fDatFile.startRead() ) {
339 
			m_fDatFile.seek(c->lOffset);
340 
			c->sData = m_fDatFile.read(c->lSize);
341 
			m_fDatFile.close();
51 cycrow 342 
 
53 cycrow 343 
			if ( !c->sData ) (*size) = 0;
344 
			else {
345 
				c->sData[c->lSize] = '\0';
346 
				DecryptDAT(c->sData, c->lSize);
347 
				c->bDecrypted = true;
348 
			}
51 cycrow 349 
		}
1 cycrow 350 
	}
351 
 
53 cycrow 352 
	return c->sData;
1 cycrow 353 
}
354 
 
41 cycrow 355 
void CCatFile::DecryptDAT(SInCatFile *pFile)
356 
{
357 
	if ( pFile->bDecrypted ) return;
358 
	pFile->bDecrypted = true;
359 
	this->DecryptDAT(pFile->sData, pFile->lSize);
360 
}
1 cycrow 361 
void CCatFile::DecryptDAT(unsigned char *buffer, size_t size)
362 
{
363 
	for(unsigned char *pos=buffer, *end=buffer + size; pos < end; pos++){
364 
		*pos^=0x33;
365 
	}
366 
}
53 cycrow 367 
unsigned char *CCatFile::readData ( CyString filename, size_t *size )
1 cycrow 368 
{
369 
	*size = 0;
370 
 
53 cycrow 371 
	if ( !m_fDatFile.NoFile() ) {
1 cycrow 372 
		SInCatFile *c = FindData ( filename );
53 cycrow 373 
		if ( c ) return readData ( c, size );
1 cycrow 374 
	}
375 
 
376 
	return NULL;
377 
}
378 
 
41 cycrow 379 
unsigned char *CCatFile::UnpackFile ( SInCatFile *c, size_t *size)
1 cycrow 380 
{
381 
	*size = 0;
382 
	if ( !c )
383 
		return NULL;
384 
 
41 cycrow 385 
	this->DecryptDAT(c);
1 cycrow 386 
 
41 cycrow 387 
	int iFiletype = this->_checkFiletype(c->sData, 3);
388 
 
389 
	// plain file
390 
	if ( iFiletype == FILETYPE_PLAIN ) {
391 
		*size = c->lSize;
392 
		return c->sData;
393 
	}
394 
 
395 
	//otherwise unpack it
396 
 
397 
//	if ( IsDataPCK ( (const unsigned char *)c->sData, c->lSize ) || forcepck )
398 
	/*int iOffset = 0;
399 
	if ( iFiletype == FILETYPE_PCK ) {
400 
		iOffset = 1;
401 
		for(size_t i=0; i < c->lSize; i++){
402 
			c->sData[i] ^= magic;
403 
		}
404 
	}
405 
 
406 
 
407 
	return UnPCKData ( c->sData + iOffset, c->lSize - iOffset, size );*/
408 
	return UnPCKData(c->sData, c->lSize, size, (iFiletype == FILETYPE_PCK) ? true : false);
1 cycrow 409 
}
410 
 
411 
bool CCatFile::RemoveFile ( SInCatFile *f )
412 
{
413 
	if ( (m_bCreate) || (m_lFiles.empty()) )
414 
		return false;
415 
 
416 
	if ( !f )
417 
		return false;
418 
 
419 
	int err = m_fDatFile.TruncateFile ( f->lOffset, f->lSize );
420 
	if ( err == FILEERR_TOSMALL )
421 
	{
422 
		if ( (int)m_fDatFile.GetFilesize() > this->GetEndOffset() )
423 
			m_fDatFile.TruncateFile( this->GetEndOffset(), m_fDatFile.GetFilesize() - this->GetEndOffset() );
424 
	}
425 
	else if ( err != FILEERR_NONE )
426 
		return false;
427 
 
16 cycrow 428 
	// adjust the file positions
40 cycrow 429 
	int iOffset = -1;
16 cycrow 430 
	for ( CListNode<SInCatFile> *node = m_lFiles.Front(); node; node = node->next() ) {
40 cycrow 431 
		if ( node->Data() == f ) {
432 
			iOffset = node->Data()->lOffset;
433 
		}
434 
		else if ( iOffset >= 0 ) {
16 cycrow 435 
			node->Data()->lOffset = iOffset;
40 cycrow 436 
			iOffset += node->Data()->lSize;
16 cycrow 437 
		}
438 
	}
439 
 
1 cycrow 440 
	// now just write the new cat file
441 
	m_lFiles.remove ( f );
53 cycrow 442 
	m_bCatChanged = true;
1 cycrow 443 
 
444 
	return true;
445 
}
446 
 
447 
bool CCatFile::WriteCatFile ()
448 
{
53 cycrow 449 
	if ( (m_bCreate) && (m_lFiles.empty()) ) return false;
1 cycrow 450 
 
53 cycrow 451 
	Utils::String cat = m_fCatFile.filename() + "\n";
452 
	for ( CListNode<SInCatFile> *node = m_lFiles.Front(); node; node = node->next() ) {
453 
		if ( !node->Data() ) continue;
454 
		if ( node->Data()->sFile.Empty() ) continue;
455 
		Utils::String str = node->Data()->sFile.ToString();
456 
		cat += str.findReplace("/", "\\").findReplace("\\\\", "\\") + " " + (long)node->Data()->lSize + "\n";
1 cycrow 457 
	}
458 
 
53 cycrow 459 
	if ( !cat.length() ) return false;
1 cycrow 460 
 
53 cycrow 461 
	// make sure the len is in multiples of 5, otherwise decryptData could cause heap problems
462 
	size_t len = cat.length() + ((cat.length() % 5) ? 5 - (cat.length() % 5) : 0);
1 cycrow 463 
 
53 cycrow 464 
	bool ret = false;
465 
	try {
466 
		unsigned char *data = new unsigned char[len + 1];
467 
		memcpy(data, cat.c_str(), cat.length() * sizeof(unsigned char));
468 
		for ( size_t i = len; i >= cat.length(); i-- ) data[i] = '\0';
469 
		this->DecryptData(data, len);
1 cycrow 470 
 
53 cycrow 471 
		bool ret = m_fCatFile.write(data, cat.length());
472 
		delete []data;
473 
	}
474 
	catch(std::exception &e) {
475 
		CLog::logf(CLog::Log_IO, 2, "CCatFile::WriteCatFile() unable to malloc, %d (%s)", len + 1, e.what());
476 
		return false;
477 
	}
1 cycrow 478 
 
53 cycrow 479 
	m_fCatFile.close();
480 
	m_bCatChanged = false;
481 
	return ret;
1 cycrow 482 
}
483 
 
484 
bool CCatFile::CheckExtensionPck ( CyString filename )
485 
{
486 
	CyString ext = filename.GetToken ( ".", filename.NumToken  ( "." ) ).lower();
487 
 
488 
	if ( ext == "xml" )
489 
		return true;
490 
	else if ( ext == "txt" )
491 
		return true;
492 
	else if ( ext == "bob" )
493 
		return true;
494 
	else if ( ext == "bod" )
495 
		return true;
496 
 
497 
	return false;
498 
}
499 
 
500 
bool CCatFile::CheckPackedExtension ( CyString filename )
501 
{
502 
	CyString ext = filename.GetToken ( ".", filename.NumToken  ( "." ) ).lower();
503 
 
504 
	if ( ext == "pck" )
505 
		return true;
506 
	else if ( ext == "pbb" )
507 
		return true;
508 
	else if ( ext == "pbd" )
509 
		return true;
510 
 
511 
	return false;
512 
}
513 
 
514 
CyString CCatFile::PckChangeExtension ( CyString f )
515 
{
516 
	CFileIO fo ( f );
517 
	CyString ext = fo.GetFileExtension ().lower();
518 
	if ( ext == "txt" )
519 
		return fo.ChangeFileExtension ( "pck" );
520 
	else if ( ext == "xml" )
521 
		return fo.ChangeFileExtension ( "pck" );
522 
	else if ( ext == "bob" )
523 
		return fo.ChangeFileExtension ( "pbb" );
524 
	else if ( ext == "bod" )
525 
		return fo.ChangeFileExtension ( "pbd" );
526 
 
527 
	return f;
528 
}
529 
 
52 cycrow 530 
bool CCatFile::AppendFile(const Utils::String &filename, const Utils::String &sTo, bool pck, bool bXor, Utils::String *sChangeTo)
1 cycrow 531 
{
52 cycrow 532 
	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");
533 
 
534 
	if ( filename.isin ( "::" ) ) return WriteFromCat ( filename.token("::", 1), filename.token("::", 2));
53 cycrow 535 
	if ( (!m_bCreate) && (!m_fDatFile.exists ()) ) {
52 cycrow 536 
		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() Cat File: %s, doesn't exist, quitting...", m_fCatFile.GetFullFilename().ToString().c_str());
1 cycrow 537 
		return false;
52 cycrow 538 
	}
539 
	CyString to = sTo;
1 cycrow 540 
	if ( !m_sAddonDir.Empty() && CCatFile::IsAddonDir(to) ) {
52 cycrow 541 
		CLog::logf(CLog::Log_IO, 3, "CCatFile::AppendFile() changing destination to included addon fir, %s => %s", to, m_sAddonDir + "/" + to);
1 cycrow 542 
		to = m_sAddonDir + "\\" + to;
543 
	}
544 
 
42 cycrow 545 
	// change the file extension and remove the file again
546 
	if ( pck && CheckExtensionPck(filename) ) {
52 cycrow 547 
		CLog::logf(CLog::Log_IO, 3, "CCatFile::AppendFile() changing file extension for packed file, %s => %s", to.c_str(), PckChangeExtension(to).ToString().c_str());
548 
		to = PckChangeExtension(to);
1 cycrow 549 
	}
52 cycrow 550 
	if ( sChangeTo ) *sChangeTo = to.ToString();
1 cycrow 551 
 
42 cycrow 552 
	if ( !m_lFiles.empty() ) {
553 
		SInCatFile *checkf = FindData ( to );
554 
		if ( checkf ) {
52 cycrow 555 
			CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() removing existing filechanging file extension for packed file, %s => %s", to.c_str(), PckChangeExtension(to).ToString().c_str());
556 
			if ( !RemoveFile(checkf) ) {
557 
				CLog::logf(CLog::Log_IO, 1, "CCatFile::AppendFile() unable to remove existing file, quitting...");
558 
				return false;
559 
			}
42 cycrow 560 
		}
561 
	}
562 
 
1 cycrow 563 
	bool append = false;
564 
 
565 
	SInCatFile *f = new SInCatFile;
566 
	f->sData = 0;
567 
	f->lOffset = this->GetEndOffset();
568 
 
569 
	bool dofile = true;
570 
 
52 cycrow 571 
	if ( !m_lFiles.size() )	{
572 
		CLog::logf(CLog::Log_IO, 3, "CCatFile::AppendFile() no existing files found, wipeing the existing dat file");
1 cycrow 573 
		m_fDatFile.WipeFile();
52 cycrow 574 
	}
1 cycrow 575 
 
52 cycrow 576 
	CFileIO File(filename);
577 
	if ( !File.startRead() ) {
578 
		CLog::logf(CLog::Log_IO, 3, "CCatFile::AppendFile() unable to open file, %s, for reading", filename.c_str());
579 
		return false;
580 
	}
581 
 
582 
	CLog::logf(CLog::Log_IO, 3, "CCatFile::AppendFile() reading file data, %s:%d", filename.c_str(), File.fileSize());
583 
	unsigned char *data = File.readAll();
584 
	File.close();
1 cycrow 585 
 
52 cycrow 586 
	// check if we need to pack the file
587 
	int iFileType = this->_checkFiletype(data, 3);
588 
	CLog::logf(CLog::Log_IO, 3, "CCatFile::AppendFile() preparing to append file data, Type=%d", iFileType);
589 
	if ( iFileType == FILETYPE_PLAIN && CheckPackedExtension(to) ) {
590 
		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() plain text file needs to packed");
591 
		size_t newsize = 0;
592 
		unsigned char *newdata = PCKData(data, File.fileSize(), &newsize, bXor);
593 
		CLog::logf(CLog::Log_IO, 1, "CCatFile::AppendFile() file has been packed, %d => %d", File.fileSize(), newsize);
1 cycrow 594 
 
52 cycrow 595 
		f->lSize = newsize;
596 
		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() Decrypting data");
597 
		this->DecryptDAT(newdata, f->lSize);
598 
		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() appending data to Dat file, Offset:%d", f->lOffset);
599 
		append = m_fDatFile.AppendDataToPos ( (const char *)newdata, newsize, f->lOffset );
1 cycrow 600 
 
52 cycrow 601 
		delete [] newdata;
1 cycrow 602 
	}
52 cycrow 603 
	else  {
604 
		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() Decrypting data");
605 
		this->DecryptDAT(data, File.fileSize());
606 
		f->lSize = File.fileSize();
607 
		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() appending data to Dat file, Offset:%d", f->lOffset);
608 
		append = m_fDatFile.AppendDataToPos ( (const char *)data, f->lSize, f->lOffset );
609 
	}
1 cycrow 610 
 
52 cycrow 611 
	CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() cleaning up memory");
612 
	delete [] data;
613 
 
53 cycrow 614 
	m_fDatFile.close();
615 
 
52 cycrow 616 
	if ( append ) {
617 
		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() append complete, adding file into cat list");
1 cycrow 618 
		m_bCreate = false;
619 
		f->sFile = to;
620 
		m_lFiles.push_back ( f );
52 cycrow 621 
		CLog::logf(CLog::Log_IO, 3, "CCatFile::AppendFile() writing the new cat file");
53 cycrow 622 
		m_bCatChanged = true;
1 cycrow 623 
	}
52 cycrow 624 
	else {
625 
		CLog::logf(CLog::Log_IO, 2, "CCatFile::AppendFile() appending failed, cleaning up file data");
1 cycrow 626 
		delete f;
52 cycrow 627 
	}
1 cycrow 628 
 
53 cycrow 629 
	CLog::logf(CLog::Log_IO, 4, "CCatFile::AppendFile() function complete");
630 
 
631 
	return append;
1 cycrow 632 
}
633 
 
634 
bool CCatFile::AddData ( CyString catfile, unsigned char *data, size_t size, CyString to, bool pck, bool create )
635 
{
636 
	int err = Open ( catfile, "", CATREAD_CATDECRYPT, create );
637 
	if ( (err != CATERR_NONE) && (err != CATERR_CREATED) )
638 
		return false;
639 
 
640 
	return AppendData ( data, size, to, pck );
641 
}
642 
 
643 
int CCatFile::GetEndOffset()
644 
{
645 
	if ( m_lFiles.empty() )
646 
		return 0;
647 
	else
648 
		return m_lFiles.Back()->Data()->lOffset + m_lFiles.Back()->Data()->lSize;
649 
}
650 
 
651 
 
652 
bool CCatFile::AppendData ( unsigned char *data, size_t size, CyString to, bool pck, bool bXor )
653 
{
52 cycrow 654 
	if ( (!m_bCreate) && (!m_fCatFile.exists ()) )
1 cycrow 655 
		return false;
656 
 
657 
	if ( (size <= 0) || (!data) )
658 
		return false;
659 
 
660 
	// then check if the file already exists
661 
	if ( !m_lFiles.empty() )
662 
	{
663 
		SInCatFile *f = FindData ( to );
664 
		if ( f )
665 
		{
666 
			if ( !RemoveFile ( f ) )
667 
				return false;
668 
		}
669 
	}
670 
 
671 
	bool append = false;
672 
 
673 
	if ( !m_lFiles.size() )
674 
		m_fDatFile.WipeFile();
675 
 
676 
	SInCatFile *f = new SInCatFile;
677 
	f->sData = 0;
678 
	if ( m_lFiles.empty() )
679 
		f->lOffset = 0;
680 
	else
681 
		f->lOffset = m_fDatFile.GetFilesize();
682 
 
683 
	// if file extension is packed but not the file, then pack it, "pck" forces it to be packed unless it already is
684 
 
685 
	f->lSize = size;
686 
	if ( (((pck) && (CheckExtensionPck (to))) || ((CheckPackedExtension ( to )))) && (!IsDataPCK ( data, size )) )
687 
	{
688 
		to = PckChangeExtension ( to );
689 
 
690 
		if ( !m_lFiles.empty() )
691 
		{
692 
			SInCatFile *f = FindData ( to );
693 
			if ( f )
694 
			{
695 
				if ( !RemoveFile ( f ) )
696 
					return false;
697 
			}
698 
		}
699 
		size_t newsize = 0;
700 
		unsigned char *d = PCKData ( data, size, &newsize, bXor );
701 
 
702 
		f->lSize = newsize;
703 
		this->DecryptDAT(d, newsize);
704 
		append = m_fDatFile.AppendDataToPos ( (const char *)d, newsize, f->lOffset );
705 
 
706 
		delete [] d;
707 
	}
708 
	else {
709 
		this->DecryptDAT(data, size);
710 
		append = m_fDatFile.AppendDataToPos ( (const char *)data, size, f->lOffset );
711 
	}
712 
 
713 
	if ( append )
714 
	{
52 cycrow 715 
		m_fDatFile.close();
1 cycrow 716 
		m_bCreate = false;
717 
		f->sFile = to;
718 
		m_lFiles.push_back ( f );
53 cycrow 719 
		m_bCatChanged = true;
1 cycrow 720 
	}
721 
	else
722 
		delete f;
723 
 
724 
	return true;
725 
}
726 
 
727 
CyString CCatFile::RenameFileExtension(SInCatFile *f)
728 
{
729 
	CFileIO fo ( f->sFile );
730 
	CyString ext = fo.GetFileExtension ().lower();
731 
	if ( ext == "pck" )
732 
	{
733 
		CyString firstDir = f->sFile.FindReplace("/", "\\").GetToken("\\", 1, 1).lower();
734 
 
735 
		if ( firstDir == "t" )
736 
			return fo.ChangeFileExtension ( "xml" );
737 
		else if ( firstDir == "director" )
738 
			return fo.ChangeFileExtension ( "xml" );
739 
		return fo.ChangeFileExtension ( "txt" );
740 
	}
741 
	else if ( ext == "pbb" )
742 
		return fo.ChangeFileExtension ( "bob" );
743 
	else if ( ext == "pbd" )
744 
		return fo.ChangeFileExtension ( "bod" );
745 
	return f->sFile;
746 
}
747 
 
748 
void CCatFile::FindFiles(CyStringList *files, CyString filemask)
749 
{
750 
	if ( m_lFiles.empty() )
751 
		return;
752 
 
753 
	for ( SInCatFile *f = m_lFiles.First(); f; f = m_lFiles.Next() )
754 
	{
755 
		if ( filemask.WildMatch(f->sFile) )
756 
			files->PushBack(f->sFile);
757 
	}
758 
}
759 
 
760 
bool CCatFile::ExtractAll(CyString dir)
761 
{
762 
	if ( m_lFiles.empty() )
763 
		return false;
764 
 
765 
	for ( CListNode<SInCatFile> *node = m_lFiles.Front(); node; node = node->next() )
766 
	{
767 
		if ( !ExtractFile(node->Data(), dir, true) )
768 
			return false;
769 
	}
770 
 
771 
	return true;
772 
}
773 
bool CCatFile::ExtractFile ( CyString filename, CyString to, bool preserve )
774 
{
775 
	if ( m_lFiles.empty() )
776 
		return false;
777 
 
778 
	// check if file exists
779 
	if ( !m_sAddonDir.Empty() ) {
780 
		SInCatFile *f = FindData ( m_sAddonDir + "\\" + filename );
781 
		if ( f )
782 
			return ExtractFile ( f, to, preserve );
783 
	}
784 
	{
785 
		SInCatFile *f = FindData ( CyString("addon\\") + filename );
786 
		if ( f )
787 
			return ExtractFile ( f, to, preserve );
788 
	}
789 
 
790 
	SInCatFile *f = FindData ( filename );
791 
	if ( !f )
792 
	{
793 
		m_iError = CATERR_NOFILE;
794 
		return false;
795 
	}
796 
 
797 
	return ExtractFile ( f, to, preserve );
798 
}
799 
 
41 cycrow 800 
int CCatFile::_checkFiletype(const unsigned char *pBuffer, int iSize)
801 
{
802 
	if(iSize >= 3) {
803 
		unsigned char magic = pBuffer[0] ^ 0xC8;
804 
		if( (pBuffer[1] ^ magic) == 0x1F && (pBuffer[2] ^ magic) == 0x8B) {
805 
			return FILETYPE_PCK;
806 
		}
807 
	}
808 
 
809 
	if ( iSize >= 2 && (pBuffer[0] == 0x1F && pBuffer[1] == 0x8B) ) {
810 
		return FILETYPE_DEFLATE;
811 
	}
812 
 
813 
	return FILETYPE_PLAIN;
814 
}
815 
 
1 cycrow 816 
bool CCatFile::ExtractFile ( SInCatFile *f, CyString to, bool preserve )
817 
{
818 
	unsigned char *data = 0;
819 
	size_t size = 0;
820 
 
821 
	// load the data from file
822 
	ReadFileToData ( f );
823 
 
41 cycrow 824 
	data = this->UnpackFile(f, &size);
52 cycrow 825 
	if ( !data ) {
1 cycrow 826 
		m_iError = CATERR_CANTREAD;
827 
		return false;
828 
	}
829 
 
830 
	CFileIO fo(CCatFile::RenameFileExtension(f));
831 
	// check for a file name
832 
	CyString checkFile = to;
833 
	CyString todir, tofile = to;
834 
	if ( checkFile.IsAnyIn("\\/") )
835 
	{
836 
		checkFile = checkFile.FindReplace ( "\\", "/" );
837 
		checkFile = checkFile.FindReplace ( "//", "/" );
838 
		tofile = checkFile.GetToken("/", checkFile.NumToken('/'));
839 
 
840 
		if ( !checkFile.IsIn(".") || preserve )
841 
		{
842 
			tofile = fo.GetFilename();
843 
			todir = checkFile;
844 
		}
845 
		else
846 
		{
847 
			todir = CFileIO(checkFile).GetDir();
848 
			tofile = CFileIO(checkFile).GetFilename();
849 
		}
850 
	}
851 
 
852 
	if ( tofile.Empty() )
853 
	{
854 
		if ( !tofile.Empty() )
855 
			tofile += "/";
856 
		tofile += fo.GetFilename();
857 
		todir = CFileIO(tofile).GetDir();
858 
		tofile = CFileIO(tofile).GetFilename();
859 
	}
860 
 
861 
	if ( preserve )
862 
	{
863 
		if ( !fo.GetDir().Compare(todir.Right(- (int)fo.GetDir().Length())) )
864 
		{
865 
			if ( !todir.Empty() && todir.Right(1) != "/" )
866 
				todir += "/";
867 
			todir += fo.GetDir();
868 
		}
869 
	}
870 
 
871 
	if ( tofile.Empty() )
872 
		tofile = fo.GetFilename();
873 
 
52 cycrow 874 
	bool bWritten = false;
875 
 
1 cycrow 876 
	// create the directory to extract to
877 
	if ( !todir.Empty() && !CDirIO(todir).Create() )
878 
		m_iError = CATERR_CANTCREATEDIR;
879 
	else
880 
	{
881 
		CyString file = todir;
882 
		if ( !file.Empty() )
883 
			file += "/";
884 
		file += tofile;
885 
		file = file.FindReplace("/", "\\");
886 
		file = file.FindReplace("\\\\", "\\");
887 
 
52 cycrow 888 
		CFileIO File(file.c_str());
889 
		if ( !File.startWrite() ) m_iError = CATERR_INVALIDDEST;
890 
		else bWritten = File.write(data, size);
1 cycrow 891 
	}
892 
 
893 
	delete data;
894 
	f->sData = 0;
895 
 
52 cycrow 896 
	if ( bWritten ) this->ClearError();
897 
 
898 
	return bWritten;
1 cycrow 899 
}
900 
 
901 
CyString CCatFile::GetErrorString ()
902 
{
903 
	switch ( m_iError )
904 
	{
905 
		case CATERR_NONE:
906 
			return NullString;
907 
		case CATERR_NODATFILE:
908 
			return "Unable to open Dat file";
909 
		case CATERR_NOCATFILE:
910 
			return "Unable to open Cat file";
911 
		case CATERR_FILEEMPTY:
912 
			return "Cat file is empty";
913 
		case CATERR_READCAT:
914 
			return "Unable to read from cat file";
915 
		case CATERR_DECRYPT:
916 
			return "Unable to decrypt cat file";
917 
		case CATERR_MISMATCH:
918 
			return "File size mismatch with Dat file";
919 
		case CATERR_NOFILE:
920 
			return "Unable to find file in archive";
921 
		case CATERR_CANTREAD:
922 
			return "Unable to read file in archive";
923 
		case CATERR_CANTCREATEDIR:
924 
			return "Unable to create destiantion directory";
925 
		case CATERR_INVALIDDEST:
926 
			return "Unable to write to destiantion file";
927 
	}
928 
 
929 
	return "Invalid";
930 
}
931 
 
932 
 
933 
unsigned char *CompressPCKData ( unsigned char *buffer, size_t size, size_t *retsize, time_t mtime )
934 
{
935 
	size_t newsize = (size * 2) + 20;
936 
	unsigned char *data = (unsigned char *)malloc ( sizeof(unsigned char) * newsize );
937 
 
938 
	z_stream zs;
939 
	char flags=0;
940 
 
941 
//	error(0);
942 
 
943 
	unsigned char *d = data;
944 
//	if(m_pszComment && strlen(m_pszComment) > 0) flags|=GZ_F_COMMENT;
945 
//	if(m_pszFileName && strlen(m_pszFileName) > 0) flags|=GZ_F_FILENAME;
946 
 
947 
	int pos = PCKHEADERSIZE;
948 
	*d = 0x1F; 		d++;
949 
	*d = 0x8B; 		d++;
950 
	*d = 8;			d++;
951 
	*d = flags; 	d++;
952 
	memcpy(d, &mtime, sizeof(mtime));
953 
	d += 4;
954 
	*d = 0; 		d++;
955 
	*d = 11; 		d++;
956 
//	if(flags & GZ_F_FILENAME) put((const char *)m_pszFileName);
957 
//	if(flags & GZ_F_COMMENT) put((const char *)m_pszComment);
958 
 
959 
	memset(&zs, 0, sizeof(zs));
960 
	zs.next_in=buffer;
961 
	zs.avail_in=(long)size;
962 
 
963 
	int ret;
964 
	unsigned long ubound;
965 
	ret=deflateInit2(&zs, 9, Z_DEFLATED, -15, 9, Z_DEFAULT_STRATEGY);
966 
	if(ret!=Z_OK)
967 
		return false;
968 
 
969 
	ubound=deflateBound(&zs, (unsigned long)size);
970 
	if ( newsize < ubound)
971 
	{
972 
		newsize += ubound;
973 
		data = (unsigned char *)realloc ( data, sizeof(unsigned char) * newsize );
974 
	}
975 
 
976 
 
977 
	zs.next_out=d;
978 
	zs.avail_out=(unsigned int)newsize - pos;
979 
 
980 
	while((ret=deflate(&zs, Z_FINISH))==Z_OK)
981 
	{
982 
		newsize += 1024;
983 
		data = (unsigned char *)realloc ( data, sizeof(unsigned char) * newsize );
984 
		zs.next_out=data + zs.total_out;
985 
		zs.avail_out=(unsigned int)newsize - zs.total_out;
986 
	}
987 
	pos += zs.total_out;
988 
 
989 
	deflateEnd(&zs);
990 
 
991 
	unsigned long crc=crc32(0, NULL, 0);
992 
	crc=crc32(crc, buffer, (unsigned int)size);
993 
 
994 
	int s = sizeof(crc) + sizeof(size);
995 
	if ( newsize < (size_t)(s + pos) )
996 
	{
997 
		newsize += (s + pos) - newsize;
998 
		data = (unsigned char *)realloc ( data, sizeof(unsigned char) * newsize );
999 
	}
1000 
 
1001 
	memcpy(&data[pos], &crc, sizeof(crc));
1002 
	pos += sizeof(crc);
1003 
	memcpy(&data[pos], &size, sizeof(size));
1004 
	pos += sizeof(size);
1005 
 
1006 
	newsize = pos;
1007 
 
1008 
	unsigned char *retdata = NULL;
1009 
	if ( ret == Z_STREAM_END )
1010 
	{
1011 
		*retsize = newsize;
1012 
		retdata = new unsigned char[newsize];
1013 
		memcpy ( retdata, data, newsize );
1014 
	}
1015 
	free ( data );
1016 
 
1017 
	return retdata;
1018 
}
1019 
 
1020 
unsigned char *PCKData ( unsigned char *data, size_t oldsize, size_t *newsize, bool bXor )
1021 
{
1022 
	unsigned char *newdata = CompressPCKData ( data, oldsize, newsize, time(NULL) );
1023 
	if ( !bXor )
1024 
		return newdata;
1025 
 
1026 
	if ( newdata )
1027 
	{
1028 
		char magic = (char)clock(), m;
1029 
		m=magic ^ 0xC8;
1030 
 
1031 
		unsigned char *ptr = newdata, *end = newdata + *newsize;
1032 
		// XOR encryption
1033 
		if ( bXor )
1034 
		{
1035 
			for ( ; ptr < end; ptr++ )
1036 
				(*ptr)^=magic;
1037 
		}
1038 
 
1039 
		unsigned char *finalData = new unsigned char[*newsize + 1];
1040 
		finalData[0] = m;
1041 
		memcpy ( finalData + 1, newdata, *newsize );
1042 
		delete [] newdata;
1043 
		(*newsize)++;
1044 
		return finalData;
1045 
	}
1046 
 
1047 
	return NULL;
1048 
}
1049 
 
1050 
bool CCatFile::WriteFromCat ( CCatFile *fcat, CyString file )
1051 
{
1052 
	// now find the file in the cat file
1053 
	SInCatFile *getfile = fcat->FindData ( file );
1054 
	if ( !getfile )
1055 
		return false;
1056 
 
1057 
	// read the dat from the cat file
1058 
	size_t size = 0;
53 cycrow 1059 
	unsigned char *data = fcat->readData ( getfile, &size );
1 cycrow 1060 
	if ( !data )
1061 
		return false;
1062 
 
1063 
	// now check if it exists in this file
1064 
	RemoveFile ( file );
1065 
 
1066 
	// now write to the new file
53 cycrow 1067 
	if ( !m_fDatFile.AppendData ( (const char *)data, size ) ) return false;
1 cycrow 1068 
 
1069 
	// finally add to the list
1070 
	SInCatFile *f = new SInCatFile;
1071 
	f->sData = 0;
1072 
	if ( m_lFiles.empty() )
1073 
		f->lOffset = 0;
1074 
	else
1075 
		f->lOffset = m_lFiles.Back()->Data()->lOffset + m_lFiles.Back()->Data()->lSize;
1076 
	f->sFile = file;
1077 
	f->lSize = size;
1078 
	m_lFiles.push_back ( f );
53 cycrow 1079 
	m_bCatChanged = true;
1 cycrow 1080 
 
1081 
	return true;
1082 
}
1083 
 
1084 
bool CCatFile::WriteFromCat ( CyString catfile, CyString file )
1085 
{
1086 
	CCatFile fcat;
1087 
	if ( fcat.Open ( catfile, "", CATREAD_CATDECRYPT, false ) )
1088 
		return false;
1089 
 
1090 
	return this->WriteFromCat(&fcat, file);
1091 
}
1092 
 
1093 
SInCatFile *CCatFile::FindData ( CyString filename )
1094 
{
1095 
	if ( m_lFiles.empty() )
1096 
		return NULL;
1097 
 
1098 
	CyString check = filename;
1099 
	check = check.FindReplace ( "\\", "/" );
1100 
	for ( SInCatFile *c = m_lFiles.First(); c; c = m_lFiles.Next() )
1101 
	{
1102 
		CyString f = c->sFile;
1103 
		f = f.FindReplace ( "\\", "/" );
1104 
		if ( f.Compare(check) )
1105 
			return c;
1106 
	}
1107 
	return NULL;
1108 
}
1109 
 
1110 
bool CCatFile::MarkRemoveFile( CyString file )
1111 
{
1112 
	SInCatFile *f = FindData ( file );
1113 
	if ( !f )
1114 
	{
1115 
		m_iError = CATERR_NOFILE;
1116 
		return false;
1117 
	}
1118 
 
1119 
	return MarkRemoveFile ( f );
1120 
}
1121 
bool CCatFile::MarkRemoveFile ( SInCatFile *f )
1122 
{
1123 
	f->bDelete = true;
1124 
	return true;
1125 
}
1126 
 
1127 
CyStringList *CCatFile::GetTShipsEntries()
1128 
{
1129 
	if ( this->ExtractFile("types/tships.pck", "tships.txt") )
1130 
	{
1131 
		CFileIO TShips("tships.txt");
52 cycrow 1132 
		if ( TShips.exists() )
1 cycrow 1133 
		{
1134 
			CyStringList *lines = TShips.ReadLinesStr();
1135 
			if ( lines )
1136 
			{
1137 
				// remove any commands, blank lines, and start
1138 
				// and put the id as the data
1139 
				int entries = -1;
1140 
				for ( SStringList *str = lines->Head(); str; str = str->next )
1141 
				{
1142 
					str->str.RemoveFirstSpace();
1143 
					str->str.RemoveChar(9);
1144 
					str->str.RemoveChar('\r');
1145 
					str->str.RemoveChar('\n');
1146 
					if ( str->str.Empty() )
1147 
					{
1148 
						str->remove = true;
1149 
						continue;
1150 
					}
1151 
 
1152 
					if ( str->str[0] == '/' )
1153 
					{
1154 
						str->remove = true;
1155 
						continue;
1156 
					}
1157 
 
1158 
					if ( entries == -1 )
1159 
					{
1160 
						entries = str->str.GetToken(";", 2, 2).ToInt();
1161 
						str->remove = true;
1162 
						continue;
1163 
					}
1164 
 
1165 
					// hopefully we now have a valid tships line
1166 
					int num = -1;
1167 
					while ( str->data.Empty() )
1168 
						str->data = str->str.GetToken(";", num--, (num + 2));
1169 
				}
1170 
			}
1171 
			// remove the tmp file
52 cycrow 1172 
			TShips.remove();
1 cycrow 1173 
 
1174 
			if ( lines )
1175 
				lines->RemoveMarked();
1176 
			return lines;
1177 
		}
1178 
	}
1179 
 
1180 
	return NULL;
1181 
}
1182 
 
1183 
CyString CCatFile::GetTShipsEntry(CyString id)
1184 
{
1185 
	CyStringList *ships = this->GetTShipsEntries();
1186 
	if ( ships )
1187 
	{
1188 
		SStringList *node = ships->FindData(id.upper());
1189 
		if ( node )
1190 
			return node->str;
1191 
	}
1192 
	return NullString;
1193 
}
1194