Subversion Repositories spk

Rev

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