bool npk_package_close( NPK_PACKAGE package )
{
NPK_PACKAGEBODY* pb = (NPK_PACKAGEBODY*)package;
NPK_RESULT res;
int i;
if( !package )
{
npk_error( NPK_ERROR_PackageIsNull );
return false;
}
res = npk_package_remove_all_entity( pb );
if( NPK_SUCCESS != res )
return res;
#ifdef NPK_PLATFORM_WINDOWS
DeleteCriticalSection( &pb->cs_ );
#endif
if( false == pb->usingFdopen_ )
npk_close( pb->handle_ );
for( i = 0; i < NPK_HASH_BUCKETS; ++i )
NPK_SAFE_FREE( pb->bucket_[i] );
NPK_SAFE_FREE( pb );
return true;
}
NPK_RESULT npk_package_remove_entity( NPK_PACKAGE package, NPK_ENTITY entity )
{
NPK_ENTITYBODY* eb = entity;
NPK_PACKAGEBODY* pb = package;
if( !entity )
return npk_error( NPK_ERROR_EntityIsNull );
if( !package )
return npk_error( NPK_ERROR_PackageIsNull );
if( eb->owner_ != package )
return npk_error( NPK_ERROR_EntityIsNotInThePackage );
if( eb->prev_ )
eb->prev_->next_ = eb->next_;
if( eb->next_ )
eb->next_->prev_ = eb->prev_;
if( eb == pb->pEntityHead_ )
pb->pEntityHead_ = eb->next_;
if( eb == pb->pEntityTail_ )
pb->pEntityTail_ = eb->prev_;
pb->pEntityLatest_ = eb->next_;
--pb->info_.entityCount_;
NPK_SAFE_FREE( eb->name_ );
NPK_SAFE_FREE( eb->localname_ );
NPK_SAFE_FREE( eb );
return NPK_SUCCESS;
}
NPK_RESULT npk_package_add_file( NPK_PACKAGE package, NPK_CSTR filename, NPK_CSTR entityname, NPK_ENTITY* lpEntity )
{
NPK_ENTITYBODY* eb;
NPK_CSTR __entityname;
NPK_RESULT res;
NPK_CHAR namebuf[512];
if( ( res = npk_entity_alloc( (NPK_ENTITY*)&eb ) ) != NPK_SUCCESS )
return res;
if( entityname == NULL )
{
__entityname = NULL;
if( ( entityname = strrchr( filename, '\\' ) ) == NULL )
if( ( entityname = strrchr( filename, '/' ) ) == NULL )
__entityname = filename;
if( __entityname == NULL )
__entityname = entityname + sizeof(NPK_CHAR);
}
else
__entityname = entityname;
if( ( res = npk_prepare_entityname( __entityname, namebuf, 512) ) != NPK_SUCCESS )
goto npk_package_add_file_return_with_error;
if( ( res = npk_get_filetime( filename, &eb->info_.modified_ ) ) != NPK_SUCCESS )
goto npk_package_add_file_return_with_error;
if( ( res = npk_alloc_copy_string( &eb->localname_, filename ) ) != NPK_SUCCESS )
goto npk_package_add_file_return_with_error;
if( ( res = npk_alloc_copy_string( &eb->name_, namebuf ) ) != NPK_SUCCESS )
goto npk_package_add_file_return_with_error;
eb->info_.nameLength_ = (NPK_SIZE)strlen( eb->name_ );
if( ( res = npk_package_add_entity( package, eb ) ) != NPK_SUCCESS )
goto npk_package_add_file_return_with_error;
if( lpEntity )
*lpEntity = eb;
return NPK_SUCCESS;
npk_package_add_file_return_with_error:
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_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;
}
NPK_RESULT npk_package_save( NPK_PACKAGE package, NPK_CSTR filename, bool forceoverwrite )
{
NPK_PACKAGEBODY* pb = package;
NPK_ENTITYBODY* eb = NULL;
NPK_RESULT res;
bool bUseTemporaryFile = false;
NPK_SIZE len;
int savecount = 0;
NPK_STR savefilename = NULL;
int savefilehandle;
NPK_CHAR* buf;
NPK_CHAR* buf_pos;
NPK_PACKAGEINFO_V23 header_v23;
if( !package )
return npk_error( NPK_ERROR_PackageIsNull );
if( !filename )
return npk_error( NPK_ERROR_PackageHasNoName );
if( ( res = npk_open( &savefilehandle, filename, true, true ) ) == NPK_SUCCESS )
{
npk_alloc_copy_string( &savefilename, filename );
}
else
{
if( res != NPK_ERROR_FileAlreadyExists )
return res;
if( !forceoverwrite )
return res;
len = (NPK_SIZE)strlen( filename );
savefilename = malloc( sizeof(NPK_CHAR)*(len+2) );
if( savefilename == NULL )
return( npk_error( NPK_ERROR_NotEnoughMemory ) );
strncpy( savefilename, filename, len );
savefilename[len+0] = '_';
savefilename[len+1] = '\0';
bUseTemporaryFile = true;
if( ( res = npk_open( &savefilehandle, savefilename, true, false ) ) != NPK_SUCCESS )
return res;
}
strncpy( pb->info_.signature_, NPK_SIGNATURE, sizeof(NPK_CHAR)*4 );
pb->info_.version_ = NPK_VERSION_CURRENT;
pb->info_.entityDataOffset_ = sizeof(NPK_PACKAGEINFO)
+ sizeof(NPK_PACKAGEINFO_V23);
npk_seek( savefilehandle, (long)pb->info_.entityDataOffset_, SEEK_SET );
eb = pb->pEntityHead_;
while( eb != NULL )
{
if( g_callbackfp )
if( (g_callbackfp)( NPK_ACCESSTYPE_WRITE, NPK_PROCESSTYPE_PACKAGE, filename, savecount, pb->info_.entityCount_ ) == false )
return( npk_error( NPK_ERROR_CancelByCallback ) );
npk_entity_write( eb, savefilehandle );
++savecount;
eb = eb->next_;
}
pb->info_.entityInfoOffset_ = npk_tell( savefilehandle );
pb->info_.entityCount_ = savecount;
eb = pb->pEntityHead_;
// version 24, Take single encryption to whole entity headers
buf = malloc( (sizeof(NPK_ENTITYINFO)+260)*savecount ); // 260 = MAX_PATH on windows, isn't it enough?
if( !buf )
return( npk_error( NPK_ERROR_NotEnoughMemory ) );
buf_pos = buf;
while( eb != NULL )
{
memcpy( buf_pos, &eb->info_, sizeof(NPK_ENTITYINFO) );
buf_pos += sizeof(NPK_ENTITYINFO);
memcpy( buf_pos, eb->name_, sizeof(NPK_CHAR)*eb->info_.nameLength_ );
buf_pos += sizeof(NPK_CHAR)*eb->info_.nameLength_;
eb = eb->next_;
}
if( ( res = npk_write_encrypt( pb->teakey_,
savefilehandle,
buf,
buf_pos - buf,
g_callbackfp,
NPK_PROCESSTYPE_ENTITYHEADER,
g_callbackSize,
savefilename ) ) != NPK_SUCCESS )
return res;
NPK_SAFE_FREE( buf );
npk_seek( savefilehandle, 0, SEEK_SET );
if( ( res = npk_write( savefilehandle,
&pb->info_,
sizeof(NPK_PACKAGEINFO),
g_callbackfp,
NPK_PROCESSTYPE_PACKAGEHEADER,
g_callbackSize,
savefilename ) ) != NPK_SUCCESS )
return res;
// version 23, Write the package timestamp for other applications
// TODO:reveal the return type of 'time' function on 64bit mac os
time( (time_t*)&header_v23.modified_ );
if( ( res = npk_write( savefilehandle,
&header_v23,
sizeof(NPK_PACKAGEINFO_V23),
g_callbackfp,
NPK_PROCESSTYPE_PACKAGEHEADER,
g_callbackSize,
savefilename ) ) != NPK_SUCCESS )
return res;
npk_flush( savefilehandle );
npk_close( pb->handle_ );
if( bUseTemporaryFile )
{
npk_close( savefilehandle );
remove( filename );
rename( savefilename, filename );
if( (res = npk_open( &pb->handle_, filename, false, false ) ) != NPK_SUCCESS )
return res;
}
else
{
pb->handle_ = savefilehandle;
}
NPK_SAFE_FREE( savefilename );
return NPK_SUCCESS;
}
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;
}
