Subversion Repositories spk

Rev

Rev 56 | Rev 61 | Go to most recent revision | Show entire file | Ignore whitespace | Details | Blame | Last modification | View Log | RSS feed

Rev 56 Rev 58
Line 395... Line 395...
395
 
395
 
396
	return true;
396
	return true;
397
}
397
}
398
 
398
 
399
 
399
 
400
bool C_File::readFromFile(CFileIO &File, long lSize, bool bDoSize)
400
bool C_File::readFromFile(CFileIO &File)
401
{
401
{
402
	return this->readFromFile(File.stream(), lSize, bDoSize);
402
	return readFromFile(File, File.fileSize(), false);
403
}
403
}
-
 
404
 
404
bool C_File::readFromFile(std::fstream &stream, long lSize, bool bDoSize)
405
bool C_File::readFromFile(CFileIO &File, int iSize, bool bDoSize)
405
{
406
{
-
 
407
	if ( !File.isOpened() ) File.startRead();
-
 
408
	if ( !File.isOpened() ) return false;
-
 
409
 
406
	m_lDataSize = lSize;
410
	m_lDataSize = File.fileSize();
407
	try {
411
	try {
408
		m_sData = new unsigned char[m_lDataSize];
412
		m_sData = new unsigned char[m_lDataSize];
409
	}
413
	}
410
	catch(std::exception &e) {
-
 
411
		CLog::logf(CLog::Log_IO, 2, "C_File::readFromFile() unable to malloc, %d (%s)", lSize, e.what());
-
 
412
		return false;
-
 
413
	}
-
 
414
 
-
 
415
	if ( bDoSize ) {
-
 
416
		unsigned char s[4];
-
 
417
		stream.read((char *)s, 4);
-
 
418
	}
-
 
419
 
-
 
420
	try { 
-
 
421
		stream.read((char *)m_sData, m_lDataSize); 
-
 
422
	}
-
 
423
	catch(std::exception &e) {
414
	catch(std::exception &e) {
424
		CLog::logf(CLog::Log_IO, 2, "C_File::readFromFile() unable to read from file, %d (%s)", lSize, e.what());
415
		CLog::logf(CLog::Log_IO, 2, "C_File::readFromFile() unable to malloc, %d (%s)", File.fileSize(), e.what());
425
		DeleteData ();
-
 
426
		m_lDataSize = 0;
-
 
427
		return false;
416
		return false;
428
	}
-
 
429
	return true;
-
 
430
}
-
 
431
 
-
 
432
/*
-
 
433
	Func:	ReadFromFile
-
 
434
	Accept:	id		- File Pointer Stream of open file
-
 
435
			size	- amount of data to read from file
-
 
436
			dosize	- Read the 4 character size
-
 
437
	Func:	Reads a data stream from a currently open file
-
 
438
			Can be used to read directly from a SPK Package
-
 
439
			dosize will read the initial 4 character uncompressed size if needed
-
 
440
*/
-
 
441
bool C_File::ReadFromFile ( FILE *id, long size, bool dosize )
-
 
442
{
-
 
443
	// remove data
-
 
444
 
-
 
445
	m_lDataSize = size ;
-
 
446
	m_sData = new unsigned char[m_lDataSize];
-
 
447
	if ( dosize )
-
 
448
	{
-
 
449
		unsigned char s[4];
-
 
450
		fread ( s, sizeof(unsigned char), 4, id );
-
 
451
	}
417
	}
452
 
418
 
453
	fread ( m_sData, sizeof(unsigned char), m_lDataSize, id );
419
	if ( bDoSize ) File.readSize();
454
 
420
 
-
 
421
	try { 
455
	if ( ferror (id) )
422
		File.read(m_sData, m_lDataSize); 
456
	{
423
	}
-
 
424
	catch(std::exception &e) {
-
 
425
		CLog::logf(CLog::Log_IO, 2, "C_File::readFromFile() unable to read from file, %d (%s)", File.fileSize(), e.what());
457
		DeleteData ();
426
		DeleteData ();
458
		m_lDataSize = 0;
427
		m_lDataSize = 0;
459
		return false;
428
		return false;
460
	}
429
	}
461
 
-
 
462
	return true;
430
	return true;
463
}
431
}
464
 
-
 
465
 
432
 
466
void C_File::copyData(const unsigned char *data, size_t size)
433
void C_File::copyData(const unsigned char *data, size_t size)
467
{
434
{
468
	m_lDataSize = (long)size;
435
	m_lDataSize = (long)size;
469
	delete m_sData;
436
	delete m_sData;
Line 539... Line 506...
539
	Func:	ReadFileSize()
506
	Func:	ReadFileSize()
540
	Return:	Returns the file size read
507
	Return:	Returns the file size read
541
	Desc:	Opens the file and seeks to the end
508
	Desc:	Opens the file and seeks to the end
542
*/
509
*/
543
long C_File::ReadFileSize ()
510
long C_File::ReadFileSize ()
544
{
511
{
545
	CFileIO File(GetFilePointer());
512
	CFileIO File(GetFilePointer());
546
	if ( File.exists() ) m_lSize = File.fileSize();
513
	if ( File.exists() ) m_lSize = File.fileSize();
547
 
514
 
548
	m_lUncomprDataSize = m_lSize;
515
	m_lUncomprDataSize = m_lSize;
549
 
516
 
Line 572... Line 539...
572
}
539
}
573
 
540
 
574
bool C_File::CheckValidFilePointer ()
541
bool C_File::CheckValidFilePointer ()
575
{
542
{
576
	return CFileIO::Exists(GetFilePointer().ToString());
543
	return CFileIO::Exists(GetFilePointer().ToString());
577
}
544
}
578
 
545
 
579
bool C_File::ReadSignedFile()
546
bool C_File::ReadSignedFile()
580
{
547
{
581
	if ( (m_iFileType != FILETYPE_SCRIPT) && (m_iFileType != FILETYPE_UNINSTALL) )
548
	if ( (m_iFileType != FILETYPE_SCRIPT) && (m_iFileType != FILETYPE_UNINSTALL) )
582
		return false;
549
		return false;
Line 604... Line 571...
604
	else if ( (m_sData) && (m_iDataCompression == SPKCOMPRESS_NONE) )
571
	else if ( (m_sData) && (m_iDataCompression == SPKCOMPRESS_NONE) )
605
		return ::ReadSignedFromData ( m_sData, m_lDataSize );
572
		return ::ReadSignedFromData ( m_sData, m_lDataSize );
606
	else
573
	else
607
	{
574
	{
608
		unsigned char pData[5001];
575
		unsigned char pData[5001];
609
 
576
 
610
		CFileIO File(file);
577
		CFileIO File(file);
611
		int iAmount = (File.fileSize() > 5000) ? 5000 : File.fileSize();
578
		int iAmount = (File.fileSize() > 5000) ? 5000 : File.fileSize();
612
		if ( File.startRead() ) {
579
		if ( File.startRead() ) {
613
			File.seekStart(File.fileSize() - iAmount);
580
			File.seekStart(File.fileSize() - iAmount);
614
			if ( File.read(pData, iAmount, true) ) {
581
			if ( File.read(pData, iAmount, true) ) {
Line 621... Line 588...
621
}
588
}
622
 
589
 
623
int C_File::ReadScriptVersion ()
590
int C_File::ReadScriptVersion ()
624
{
591
{
625
	if ( (m_iFileType != FILETYPE_SCRIPT) && (m_iFileType != FILETYPE_UNINSTALL) ) return 0;
592
	if ( (m_iFileType != FILETYPE_SCRIPT) && (m_iFileType != FILETYPE_UNINSTALL) ) return 0;
626
 
593
 
627
	if ( (m_sData) && (m_iDataCompression == SPKCOMPRESS_NONE) )
594
	if ( (m_sData) && (m_iDataCompression == SPKCOMPRESS_NONE) )
628
		m_iVersion = ::ReadScriptVersionFromData ( m_sData, m_lDataSize );
595
		m_iVersion = ::ReadScriptVersionFromData ( m_sData, m_lDataSize );
629
	else {
596
	else {
630
		CFileIO File(GetFilePointer());
597
		CFileIO File(GetFilePointer());
631
		if ( File.startRead() ) {
598
		if ( File.startRead() ) {
Line 637... Line 604...
637
			}
604
			}
638
		}
605
		}
639
	}
606
	}
640
 
607
 
641
	return m_iVersion;
608
	return m_iVersion;
642
}
609
}
643
 
610
 
644
bool C_File::MatchFile ( C_File *file )
611
bool C_File::MatchFile ( C_File *file )
645
{
612
{
646
	if ( file->GetFileType() != m_iFileType )
613
	if ( file->GetFileType() != m_iFileType )
647
		return false;
614
		return false;
Line 670... Line 637...
670
			return false;
637
			return false;
671
		file = "tempuncompr.dat";
638
		file = "tempuncompr.dat";
672
	}
639
	}
673
 
640
 
674
	bool ret = false;
641
	bool ret = false;
675
 
642
 
676
	FILE *fIn = fopen(file.c_str(), "rb");
643
	FILE *fIn = fopen(file.c_str(), "rb");
677
	if ( fIn )
644
	if ( fIn )
678
	{
645
	{
679
		FILE *fOut = fopen("tempcompr.dat", "wb");
646
		FILE *fOut = fopen("tempcompr.dat", "wb");
680
		if ( fOut )
647
		if ( fOut )
Line 703... Line 670...
703
						m_iDataCompression = SPKCOMPRESS_ZLIB;
670
						m_iDataCompression = SPKCOMPRESS_ZLIB;
704
						ret = true;
671
						ret = true;
705
					}
672
					}
706
				}
673
				}
707
				File.close();
674
				File.close();
708
			}
675
			}
709
		}
676
		}
710
		fclose(fIn);
677
		fclose(fIn);
711
	}
678
	}
712
 
679
 
713
	CFileIO::Remove("tempuncompr.dat");
680
	CFileIO::Remove("tempuncompr.dat");
714
 
681
 
Line 1095... Line 1062...
1095
		filen = filen.findReplace ( "\\\\", "\\" );
1062
		filen = filen.findReplace ( "\\\\", "\\" );
1096
 
1063
 
1097
		if ( len && data ) {
1064
		if ( len && data ) {
1098
			CFileIO File(filen);
1065
			CFileIO File(filen);
1099
			if ( File.startWrite() ) ret = File.write(data, len);
1066
			if ( File.startWrite() ) ret = File.write(data, len);
1100
		}
1067
		}
1101
	}
1068
	}
1102
 
1069
 
1103
	return ret;
1070
	return ret;
1104
}
1071
}
1105
 
1072
 
1106
CyString C_File::GetFullFileToDir ( CyString dir, bool includedir, CBaseFile *file )
1073
CyString C_File::GetFullFileToDir ( CyString dir, bool includedir, CBaseFile *file )
1107
{
1074
{
1108
	CyString fullfile = dir;
1075
	CyString fullfile = dir;
1109
	if ( includedir )
1076
	if ( includedir )
1110
	{
1077
	{
Line 1115... Line 1082...
1115
				fullfile += "/";
1082
				fullfile += "/";
1116
			fullfile += d;
1083
			fullfile += d;
1117
		}
1084
		}
1118
	}
1085
	}
1119
	if ( !m_sName.Empty() )
1086
	if ( !m_sName.Empty() )
1120
	{
1087
	{
1121
		if ( !fullfile.Empty() )
1088
		if ( !fullfile.Empty() )
1122
			fullfile += "/";
1089
			fullfile += "/";
1123
		fullfile += m_sName;
1090
		fullfile += m_sName;
1124
	}
1091
	}
1125
 
1092
 
1126
	fullfile = fullfile.FindReplace ( "\\", "/" );
1093
	fullfile = fullfile.FindReplace ( "\\", "/" );
1127
	return fullfile;
1094
	return fullfile;
Line 1149... Line 1116...
1149
}
1116
}
1150
 
1117
 
1151
CyString C_File::GetDataSizeString ()
1118
CyString C_File::GetDataSizeString ()
1152
{
1119
{
1153
	return SPK::GetSizeString ( m_lDataSize );
1120
	return SPK::GetSizeString ( m_lDataSize );
1154
}
1121
}
1155
CyString C_File::GetUncompressedSizeString ()
1122
CyString C_File::GetUncompressedSizeString ()
1156
{
1123
{
1157
	return SPK::GetSizeString ( GetUncompressedDataSize() );
1124
	return SPK::GetSizeString ( GetUncompressedDataSize() );
1158
}
1125
}
1159
 
1126
 
1160
CyString C_File::GetCreationTimeString ()
1127
CyString C_File::GetCreationTimeString ()
1161
{
1128
{
1162
	if ( !m_tTime )
1129
	if ( !m_tTime )
1163
		return NullString;
1130
		return NullString;
1164
 
1131
 
1165
	struct tm   *currDate;
1132
	struct tm   *currDate;
1166
	char    dateString[100];
1133
	char    dateString[100];
1167
 
1134
 
1168
	time_t n = m_tTime;
1135
	time_t n = m_tTime;
1169
 
1136
 
1170
	currDate = localtime(&n);
1137
	currDate = localtime(&n);
1171
 
1138
 
1172
	strftime(dateString, sizeof dateString, "(%d/%m/%Y) %H:%M", currDate);
1139
	strftime(dateString, sizeof dateString, "(%d/%m/%Y) %H:%M", currDate);
1173
 
1140
 
1174
 
1141
 
1175
	return CyString(dateString);
1142
	return CyString(dateString);
1176
}
1143
}
1177
 
1144
 
1178
bool C_File::CompareNew ( C_File *file )
1145
bool C_File::CompareNew ( C_File *file )
1179
{
1146
{
Line 1182... Line 1149...
1182
 
1149
 
1183
	// if version, check if its later version
1150
	// if version, check if its later version
1184
	if ( (m_iVersion) && (file->GetVersion()) )
1151
	if ( (m_iVersion) && (file->GetVersion()) )
1185
	{
1152
	{
1186
		if ( m_iVersion > file->GetVersion() )
1153
		if ( m_iVersion > file->GetVersion() )
1187
			return false;
1154
			return false;
1188
	}
1155
	}
1189
 
1156
 
1190
	// now check for last modified time
1157
	// now check for last modified time
1191
	if ( (m_tTime) && (file->GetLastModified()) )
1158
	if ( (m_tTime) && (file->GetLastModified()) )
1192
	{
1159
	{
1193
		if ( m_tTime > file->GetLastModified() )
1160
		if ( m_tTime > file->GetLastModified() )
Line 1232... Line 1199...
1232
			return "ShipModel";
1199
			return "ShipModel";
1233
		case FILETYPE_SHIPSCENE:
1200
		case FILETYPE_SHIPSCENE:
1234
			return "ShipScene";
1201
			return "ShipScene";
1235
		case FILETYPE_COCKPITSCENE:
1202
		case FILETYPE_COCKPITSCENE:
1236
			return "CockpitScene";
1203
			return "CockpitScene";
1237
	}
1204
	}
1238
 
1205
 
1239
	return NullString;
1206
	return NullString;
1240
}
1207
}
1241
 
1208
 
1242
int GetFileTypeFromString ( CyString type )
1209
int GetFileTypeFromString ( CyString type )
Line 1495... Line 1462...
1495
			m_bUsedMalloc = false;
1462
			m_bUsedMalloc = false;
1496
			m_sData = new unsigned char[size];
1463
			m_sData = new unsigned char[size];
1497
			memcpy(m_sData, data, size);
1464
			memcpy(m_sData, data, size);
1498
			m_lDataSize = (long)size;
1465
			m_lDataSize = (long)size;
1499
			delete []data;
1466
			delete []data;
-
 
1467
			return true;
1500
		}
1468
		}
1501
 
-
 
1502
		return true;
-
 
1503
	}
1469
	}
1504
 
1470
 
1505
	return false;
1471
	return false;
1506
}
1472
}
1507
 
1473