bool npk_entity_read_partial( NPK_ENTITY entity, void* buf, NPK_SIZE offset, NPK_SIZE size )
{
NPK_ENTITYBODY* eb = entity;
NPK_PACKAGEBODY* pb = NULL;
NPK_RESULT res;
if( !entity )
{
npk_error( NPK_ERROR_EntityIsNull );
return false;
}
if( eb->info_.flag_ & ( NPK_ENTITY_COMPRESS_ZLIB | NPK_ENTITY_COMPRESS_BZIP2 ) )
{
npk_error( NPK_ERROR_CantReadCompressedEntityByPartial );
return false;
}
if( eb->info_.flag_ & ( NPK_ENTITY_ENCRYPT_TEA | NPK_ENTITY_ENCRYPT_XXTEA ) )
{
if( ( offset % 8 != 0 ) || ( ( size % 8 != 0 ) && ( offset + size != eb->info_.size_ ) ) )
{
npk_error( NPK_ERROR_ReadingEncryptedEntityByPartialShouldBeAligned );
return false;
}
}
pb = eb->owner_;
#ifdef NPK_PLATFORM_WINDOWS
if( g_useCriticalSection )
EnterCriticalSection( &pb->cs_ );
#endif
npk_seek( pb->handle_, (long)(eb->info_.offset_ + offset)+pb->offsetJump_, SEEK_SET );
res = npk_read( pb->handle_,
buf,
size,
g_callbackfp,
NPK_PROCESSTYPE_ENTITY,
g_callbackSize,
eb->name_ );
if( eb->info_.flag_ & NPK_ENTITY_ENCRYPT_TEA )
tea_decode_buffer(buf, size, pb->teakey_, (pb->info_.version_ >= NPK_VERSION_ENCRYPTREMAINS));
if( eb->info_.flag_ & NPK_ENTITY_ENCRYPT_XXTEA )
xxtea_decode_buffer(buf, size, pb->teakey_, (pb->info_.version_ >= NPK_VERSION_ENCRYPTREMAINS));
#ifdef NPK_PLATFORM_WINDOWS
if( g_useCriticalSection )
LeaveCriticalSection( &pb->cs_ );
#endif
if( res != NPK_SUCCESS )
return false;
return true;
}
NPK_RESULT __npk_package_open( NPK_PACKAGEBODY* pb, const NPK_CHAR* filename, long filesize, NPK_TEAKEY teakey[4] )
{
NPK_CHAR buf[512];
NPK_ENTITYBODY* eb = NULL;
NPK_ENTITYINFO_V21 oldinfo;
NPK_SIZE entityCount = 0;
NPK_CHAR* entityheaderbuf;
NPK_CHAR* pos;
long entityheadersize = 0;
NPK_RESULT res;
if( filesize == 0 )
{
filesize = npk_seek( pb->handle_, 0, SEEK_END );
npk_seek( pb->handle_, 0, SEEK_SET );
}
if( filesize < sizeof(NPK_PACKAGEINFO) )
return( npk_error( NPK_ERROR_PackageIsNotReady ) );
// Read common header
res = npk_read( pb->handle_,
(void*)&pb->info_,
sizeof(NPK_PACKAGEINFO),
g_callbackfp,
NPK_PROCESSTYPE_PACKAGEHEADER,
g_callbackSize,
filename );
if( res != NPK_SUCCESS ) return res;
if( strncmp( pb->info_.signature_, NPK_SIGNATURE, 4 ) != 0 )
if( strncmp( pb->info_.signature_, NPK_OLD_SIGNATURE, 4 ) != 0 )
return( npk_error( NPK_ERROR_NotValidPackage ) );
// version 18 / read own tea key
if( pb->info_.version_ < NPK_VERSION_REFACTORING )
{
return ( npk_error( NPK_ERROR_NotSupportedVersion ) );
}
else
{
if( teakey == NULL )
{
return ( npk_error( NPK_ERROR_NeedSpecifiedTeaKey ) );
}
memcpy( pb->teakey_, teakey, sizeof(NPK_TEAKEY) * 4 );
}
// version 23 / package timestamp
if( pb->info_.version_ >= NPK_VERSION_PACKAGETIMESTAMP )
{
res = npk_read( pb->handle_,
(void*)&pb->modified_,
sizeof(NPK_TIME),
g_callbackfp,
NPK_PROCESSTYPE_PACKAGEHEADER,
g_callbackSize,
filename );
if( res != NPK_SUCCESS ) return res;
}
entityCount = pb->info_.entityCount_;
pb->info_.entityCount_ = 0;
if( pb->info_.version_ >= NPK_VERSION_SINGLEPACKHEADER )
{
if( pb->info_.version_ >= NPK_VERSION_STREAMABLE )
{
if( filesize < (long)pb->info_.entityDataOffset_ )
return( npk_error( NPK_ERROR_PackageIsNotReady ) );
entityheadersize = (long)pb->info_.entityDataOffset_ - (long)pb->info_.entityInfoOffset_;
}
else
{
entityheadersize = filesize - (long)pb->info_.entityInfoOffset_;
npk_seek( pb->handle_, (long)pb->info_.entityInfoOffset_+pb->offsetJump_, SEEK_SET );
}
entityheaderbuf = malloc( entityheadersize );
if( !entityheaderbuf )
return( npk_error( NPK_ERROR_NotEnoughMemory ) );
res = npk_read_encrypt( teakey,
pb->handle_,
(void*)entityheaderbuf,
entityheadersize,
g_callbackfp,
NPK_PROCESSTYPE_ENTITYHEADER,
g_callbackSize,
filename,
pb->info_.version_ >= NPK_VERSION_ENCRYPTREMAINS,
pb->info_.version_ >= NPK_VERSION_USEXXTEAONHEADER
);
if( res != NPK_SUCCESS ) return res;
pos = entityheaderbuf;
while( entityCount > 0 )
{
--entityCount;
res = npk_entity_alloc( (NPK_ENTITY*)&eb );
if( res != NPK_SUCCESS )
goto __npk_package_open_return_res_with_free;
eb->owner_ = pb;
memcpy( &eb->info_, pos, sizeof(NPK_ENTITYINFO) );
pos += sizeof(NPK_ENTITYINFO);
if( pb->info_.version_ < NPK_VERSION_STREAMABLE )
if( eb->info_.offset_ >= pb->info_.entityInfoOffset_ )
{
res = npk_error( NPK_ERROR_InvalidTeaKey );
goto __npk_package_open_return_res_with_free;
}
eb->newflag_ = eb->info_.flag_;
eb->name_ = malloc( sizeof(NPK_CHAR)*(eb->info_.nameLength_+1) );
if( !eb->name_ )
{
res = npk_error( NPK_ERROR_NotEnoughMemory );
goto __npk_package_open_return_res_with_free;
}
eb->name_[eb->info_.nameLength_] = '\0';
memcpy( eb->name_, pos, eb->info_.nameLength_ );
pos += eb->info_.nameLength_;
__npk_package_add_entity( pb, eb, false );
}
NPK_SAFE_FREE( entityheaderbuf );
}
else // old style entity header
{
npk_seek( pb->handle_, (long)pb->info_.entityInfoOffset_+pb->offsetJump_, SEEK_SET );
while( entityCount > 0 )
{
--entityCount;
res = npk_entity_alloc( (NPK_ENTITY*)&eb );
if( res != NPK_SUCCESS )
goto __npk_package_open_return_res_with_free;
eb->owner_ = pb;
// read entity info
if( pb->info_.version_ < NPK_VERSION_UNIXTIMESUPPORT )
{
res = npk_read_encrypt( teakey,
pb->handle_,
(void*)&oldinfo,
sizeof(NPK_ENTITYINFO),
g_callbackfp,
NPK_PROCESSTYPE_ENTITYHEADER,
g_callbackSize,
filename,
false,
false );
if( res != NPK_SUCCESS )
goto __npk_package_open_return_res_with_free;
eb->info_.offset_ = oldinfo.offset_;
eb->info_.size_ = oldinfo.size_;
eb->info_.originalSize_ = oldinfo.originalSize_;
eb->info_.flag_ = oldinfo.flag_;
npk_filetime_to_unixtime( &oldinfo.modified_, &eb->info_.modified_ );
eb->info_.nameLength_ = oldinfo.nameLength_;
}
else
{
res = npk_read_encrypt( teakey,
pb->handle_,
(void*)&eb->info_,
sizeof(NPK_ENTITYINFO),
g_callbackfp,
NPK_PROCESSTYPE_ENTITYHEADER,
g_callbackSize,
filename,
false,
false );
if( res != NPK_SUCCESS )
goto __npk_package_open_return_res_with_free;
}
if( eb->info_.offset_ >= pb->info_.entityInfoOffset_ )
{
res = npk_error( NPK_ERROR_InvalidTeaKey );
goto __npk_package_open_return_res_with_free;
}
res = npk_read_encrypt( teakey,
pb->handle_,
(void*)buf,
sizeof(char) * eb->info_.nameLength_,
g_callbackfp,
NPK_PROCESSTYPE_ENTITYHEADER,
g_callbackSize,
filename,
false,
false );
if( res != NPK_SUCCESS )
goto __npk_package_open_return_res_with_free;
eb->newflag_ = eb->info_.flag_;
// copy name into entity body
buf[eb->info_.nameLength_] = '\0';
res = npk_alloc_copy_string( &eb->name_, buf );
if( res != NPK_SUCCESS )
goto __npk_package_open_return_res_with_free;
__npk_package_add_entity( pb, eb, false );
}
}
return NPK_SUCCESS;
__npk_package_open_return_res_with_free:
NPK_SAFE_FREE( eb );
return res;
}
bool npk_entity_read( NPK_ENTITY entity, void* buf )
{
NPK_ENTITYBODY* eb = entity;
NPK_PACKAGEBODY* pb = NULL;
void** lplpTarget = &buf;
void* lpDecompressBuffer = NULL;
//NPK_SIZE uncompLen = 0;
unsigned long uncompLen = 0;
NPK_RESULT res;
if( !entity )
{
npk_error( NPK_ERROR_EntityIsNull );
return false;
}
if( eb->info_.flag_ & ( NPK_ENTITY_COMPRESS_ZLIB | NPK_ENTITY_COMPRESS_BZIP2 ) )
{
lpDecompressBuffer = malloc( sizeof(char) * eb->info_.size_ );
lplpTarget = &lpDecompressBuffer;
}
pb = eb->owner_;
#ifdef NPK_PLATFORM_WINDOWS
if( g_useCriticalSection )
EnterCriticalSection( &pb->cs_ );
#endif
npk_seek( pb->handle_, (long)eb->info_.offset_+pb->offsetJump_, SEEK_SET );
res = npk_read( pb->handle_,
(*lplpTarget),
eb->info_.size_,
g_callbackfp,
NPK_PROCESSTYPE_ENTITY,
g_callbackSize,
eb->name_ );
#ifdef NPK_PLATFORM_WINDOWS
if( g_useCriticalSection )
LeaveCriticalSection( &pb->cs_ );
#endif
if( res != NPK_SUCCESS )
goto npk_entity_read_return_null_with_free;
// Decode before uncompress, after v21
if( ( eb->info_.flag_ & NPK_ENTITY_ENCRYPT_TEA ) && ( eb->info_.flag_ & NPK_ENTITY_REVERSE ) )
tea_decode_buffer((char*)(*lplpTarget), eb->info_.size_, pb->teakey_, (pb->info_.version_ >= NPK_VERSION_ENCRYPTREMAINS));
if( eb->info_.flag_ & NPK_ENTITY_ENCRYPT_XXTEA )
xxtea_decode_buffer((char*)(*lplpTarget), eb->info_.size_, pb->teakey_, (pb->info_.version_ >= NPK_VERSION_ENCRYPTREMAINS));
if( eb->info_.flag_ & NPK_ENTITY_COMPRESS_ZLIB )
{
uncompLen = eb->info_.originalSize_;
if( uncompLen >= NPK_MIN_SIZE_ZIPABLE )
{
#ifdef Z_PREFIX
if( Z_OK != z_uncompress((Bytef*)(buf), (z_uLong*)&uncompLen, (const Bytef*)lpDecompressBuffer, (z_uLong)eb->info_.size_ ) )
#else
if( Z_OK != uncompress((Bytef*)(buf), (uLong*)&uncompLen, (const Bytef*)lpDecompressBuffer, (uLong)eb->info_.size_ ) )
#endif
{
npk_error( NPK_ERROR_FailToDecompress );
goto npk_entity_read_return_null_with_free;
}
if( eb->info_.originalSize_ != uncompLen )
{
npk_error( NPK_ERROR_FailToDecompress );
goto npk_entity_read_return_null_with_free;
}
}
else
memcpy( buf, lpDecompressBuffer, eb->info_.size_ );
NPK_SAFE_FREE( lpDecompressBuffer );
lplpTarget = &buf;
}
// Decode after uncompress, before v21
if( ( eb->info_.flag_ & NPK_ENTITY_ENCRYPT_TEA ) && !( eb->info_.flag_ & NPK_ENTITY_REVERSE ) )
tea_decode_buffer((char*)(*lplpTarget), eb->info_.originalSize_, pb->teakey_, false);
return true;
npk_entity_read_return_null_with_free:
NPK_SAFE_FREE( lpDecompressBuffer );
return false;
}
NPK_RESULT npk_entity_write( NPK_ENTITY entity, NPK_HANDLE handle )
{
NPK_PACKAGEBODY* pb;
NPK_ENTITYBODY* eb = entity;
NPK_RESULT res;
bool skipProcessing;
void* buf = NULL;
void* buf_for_zlib = NULL;
NPK_SIZE size, endpos, startpos;
int filehandle;
int z_res;
if( !eb )
return npk_error( NPK_ERROR_EntityIsNull );
pb = eb->owner_;
skipProcessing = false;
if( eb->localname_ != NULL )
{ // read native file and write
if( ( res = npk_open( &filehandle, eb->localname_, false, false ) ) != NPK_SUCCESS )
return res;
endpos = npk_seek( filehandle, 0, SEEK_END );
startpos = npk_seek( filehandle, 0, SEEK_SET );
size = endpos - startpos;
if( size == 0 )
return npk_error( NPK_ERROR_ZeroFileSize );
eb->info_.originalSize_ = size;
buf = malloc( size );
if( ( res = npk_read( filehandle,
buf,
size,
g_callbackfp,
NPK_PROCESSTYPE_ENTITY,
g_callbackSize,
eb->name_ ) ) != NPK_SUCCESS )
goto npk_entity_write_return_with_free;
npk_close( filehandle );
npk_get_filetime( eb->localname_, &eb->info_.modified_ );
NPK_SAFE_FREE( eb->localname_ );
}
else
{
if( eb->newflag_ != eb->info_.flag_ )
{ // read entity and write
size = eb->info_.originalSize_;
buf = malloc( size );
npk_entity_read( eb, buf );
}
else
{ // just copy
size = eb->info_.size_;
buf = malloc( size );
npk_seek( pb->handle_, (long)eb->info_.offset_+pb->offsetJump_, SEEK_SET );
if( ( res = npk_read( pb->handle_,
buf,
size,
g_callbackfp,
NPK_PROCESSTYPE_ENTITY,
g_callbackSize,
eb->name_ ) ) != NPK_SUCCESS )
goto npk_entity_write_return_with_free;
skipProcessing = true;
}
}
if( !skipProcessing )
{
// Encode before compress, before v21
if( ( eb->newflag_ & NPK_ENTITY_ENCRYPT ) && !( eb->newflag_ & NPK_ENTITY_REVERSE ) )
tea_encode_buffer((char*)buf, (int)size, pb->teakey_ );
if( eb->newflag_ & NPK_ENTITY_COMPRESS )
{
if( size >= NPK_MIN_SIZE_ZIPABLE )
{
unsigned long compressedSize = (unsigned long)(sizeof(char) * size * 1.1 + 12); // margin rules from zlib/compress.c
buf_for_zlib = malloc( compressedSize );
#ifdef Z_PREFIX
z_res = z_compress( (Bytef*)buf_for_zlib, (z_uLong*)&compressedSize, (const Bytef*)buf, (z_uLong)size );
#else
z_res = compress( (Bytef*)buf_for_zlib, (uLong*)&compressedSize, (const Bytef*)buf, (uLong)size );
#endif
if( ( z_res == Z_OK ) && ( compressedSize < size ) )
{
free( buf );
buf = buf_for_zlib;
buf_for_zlib = NULL;
size = compressedSize;
}
else // not suitable to compress
{
free( buf_for_zlib );
eb->newflag_ &= !NPK_ENTITY_COMPRESS;
}
}
}
// Encode after compress, after v21
if( ( eb->newflag_ & NPK_ENTITY_ENCRYPT ) && ( eb->newflag_ & NPK_ENTITY_REVERSE ) )
tea_encode_buffer((char*)buf, (int)size, pb->teakey_ );
}
eb->info_.size_ = size;
eb->info_.offset_ = npk_tell( handle );
if( ( res = npk_write( handle,
buf,
size,
g_callbackfp,
NPK_PROCESSTYPE_ENTITY,
g_callbackSize,
eb->name_ ) ) != NPK_SUCCESS )
goto npk_entity_write_return_with_free;
free( buf );
eb->info_.flag_ = eb->newflag_;
return NPK_SUCCESS;
npk_entity_write_return_with_free:
NPK_SAFE_FREE( buf );
NPK_SAFE_FREE( buf_for_zlib );
return res;
}
