nold/hekate
1
0
Fork 0
mirror of https://github.com/CTCaer/hekate synced 2024-09-19 22:29:00 +00:00
Code Issues Packages Projects Releases Wiki Activity

bdk: blz: refactor style

Browse source
This commit is contained in:
CTCaer 2024-06-02 06:51:47 +03:00
parent 7a74761da9
commit 8c44969afb
2 changed files with 33 additions and 30 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

55
bdk/libs/compr/blz.c
View file

@ -20,33 +20,33 @@
#include "blz.h" #include "blz.h"
const blz_footer *blz_get_footer(const unsigned char *compData, unsigned int compDataLen, blz_footer *outFooter) const blz_footer *blz_get_footer(const u8 *comp_data, u32 comp_data_size, blz_footer *out_footer)
{ {
if (compDataLen < sizeof(blz_footer)) if (comp_data_size < sizeof(blz_footer))
return NULL; return NULL;
const blz_footer *srcFooter = (const blz_footer*)&compData[compDataLen - sizeof(blz_footer)]; const blz_footer *src_footer = (const blz_footer *)&comp_data[comp_data_size - sizeof(blz_footer)];
if (outFooter != NULL) if (out_footer)
memcpy(outFooter, srcFooter, sizeof(blz_footer)); // Must be a memcpy because no umaligned accesses on ARMv4. memcpy(out_footer, src_footer, sizeof(blz_footer)); // Must be a memcpy because no unaligned accesses on ARMv4.
return srcFooter; return src_footer;
} }
// From https://github.com/SciresM/hactool/blob/master/kip.c which is exactly how kernel does it, thanks SciresM! // From https://github.com/SciresM/hactool/blob/master/kip.c which is exactly how kernel does it, thanks SciresM!
int blz_uncompress_inplace(unsigned char *dataBuf, unsigned int compSize, const blz_footer *footer) int blz_uncompress_inplace(u8 *data, u32 comp_size, const blz_footer *footer)
{ {
u32 addl_size = footer->addl_size; u32 addl_size = footer->addl_size;
u32 header_size = footer->header_size; u32 header_size = footer->header_size;
u32 cmp_and_hdr_size = footer->cmp_and_hdr_size; u32 cmp_and_hdr_size = footer->cmp_and_hdr_size;
unsigned char* cmp_start = &dataBuf[compSize] - cmp_and_hdr_size; u8 *cmp_start = &data[comp_size] - cmp_and_hdr_size;
u32 cmp_ofs = cmp_and_hdr_size - header_size; u32 cmp_ofs = cmp_and_hdr_size - header_size;
u32 out_ofs = cmp_and_hdr_size + addl_size; u32 out_ofs = cmp_and_hdr_size + addl_size;
while (out_ofs) while (out_ofs)
{ {
unsigned char control = cmp_start[--cmp_ofs]; u8 control = cmp_start[--cmp_ofs];
for (unsigned int i=0; i<8; i++) for (u32 i = 0; i < 8; i++)
{ {
if (control & 0x80) if (control & 0x80)
{ {
@ -54,45 +54,48 @@ int blz_uncompress_inplace(unsigned char *dataBuf, unsigned int compSize, const
return 0; // Out of bounds. return 0; // Out of bounds.
cmp_ofs -= 2; cmp_ofs -= 2;
u16 seg_val = ((unsigned int)(cmp_start[cmp_ofs + 1]) << 8) | cmp_start[cmp_ofs]; u16 seg_val = ((u32)(cmp_start[cmp_ofs + 1]) << 8) | cmp_start[cmp_ofs];
u32 seg_size = ((seg_val >> 12) & 0xF) + 3; u32 seg_size = ((seg_val >> 12) & 0xF) + 3;
u32 seg_ofs = (seg_val & 0x0FFF) + 3; u32 seg_ofs = (seg_val & 0x0FFF) + 3;
if (out_ofs < seg_size) // Kernel restricts segment copy to stay in bounds.
// Kernel restricts segment copy to stay in bounds.
if (out_ofs < seg_size)
seg_size = out_ofs; seg_size = out_ofs;
out_ofs -= seg_size; out_ofs -= seg_size;
for (unsigned int j = 0; j < seg_size; j++) for (u32 j = 0; j < seg_size; j++)
cmp_start[out_ofs + j] = cmp_start[out_ofs + j + seg_ofs]; cmp_start[out_ofs + j] = cmp_start[out_ofs + j + seg_ofs];
} }
else else // Copy directly.
{ {
// Copy directly.
if (cmp_ofs < 1) if (cmp_ofs < 1)
return 0; //out of bounds return 0; // Out of bounds.
cmp_start[--out_ofs] = cmp_start[--cmp_ofs]; cmp_start[--out_ofs] = cmp_start[--cmp_ofs];
} }
control <<= 1; control <<= 1;
if (out_ofs == 0) // Blz works backwards, so if it reaches byte 0, it's done.
if (!out_ofs) // Blz works backwards, so if it reaches byte 0, it's done.
return 1; return 1;
}
} }
}
return 1; return 1;
} }
int blz_uncompress_srcdest(const unsigned char *compData, unsigned int compDataLen, unsigned char *dstData, unsigned int dstSize) int blz_uncompress_srcdest(const u8 *comp_data, u32 comp_data_size, u8 *dst_data, u32 dst_size)
{ {
blz_footer footer; blz_footer footer;
const blz_footer *compFooterPtr = blz_get_footer(compData, compDataLen, &footer); const blz_footer *comp_footer = blz_get_footer(comp_data, comp_data_size, &footer);
if (compFooterPtr == NULL) if (!comp_footer)
return 0; return 0;
// Decompression must be done in-place, so need to copy the relevant compressed data first. // Decompression happens in-place, so need to copy the relevant compressed data first.
unsigned int numCompBytes = (const unsigned char*)(compFooterPtr)-compData; u32 comp_bytes = (const u8 *)comp_footer - comp_data;
memcpy(dstData, compData, numCompBytes); memcpy(dst_data, comp_data, comp_bytes);
memset(&dstData[numCompBytes], 0, dstSize - numCompBytes); memset(&dst_data[comp_bytes], 0, dst_size - comp_bytes);
return blz_uncompress_inplace(dstData, compDataLen, &footer); return blz_uncompress_inplace(dst_data, comp_data_size, &footer);
} }

8
bdk/libs/compr/blz.h
View file

@ -26,11 +26,11 @@ typedef struct _blz_footer
u32 addl_size; u32 addl_size;
} blz_footer; } blz_footer;
// Returns pointer to footer in compData if present, additionally copies it to outFooter if not NULL. // Returns pointer to footer in comp_data if present, additionally copies it to out_footer if not NULL.
const blz_footer *blz_get_footer(const unsigned char *compData, unsigned int compDataLen, blz_footer *outFooter); const blz_footer *blz_get_footer(const u8 *comp_data, u32 comp_data_size, blz_footer *out_footer);
// Returns 0 on failure. // Returns 0 on failure.
int blz_uncompress_inplace(unsigned char *dataBuf, unsigned int compSize, const blz_footer *footer); int blz_uncompress_inplace(u8 *data, u32 comp_size, const blz_footer *footer);
// Returns 0 on failure. // Returns 0 on failure.
int blz_uncompress_srcdest(const unsigned char *compData, unsigned int compDataLen, unsigned char *dstData, unsigned int dstSize); int blz_uncompress_srcdest(const u8 *comp_data, u32 comp_data_size, u8 *dst_data, u32 dst_size);
#endif #endif