mirror of
https://github.com/sheumann/hush.git
synced 2024-08-19 13:28:57 +00:00
1079 lines
26 KiB
C
1079 lines
26 KiB
C
/*
|
|
This file is part of the lzop file compressor.
|
|
|
|
Copyright (C) 1996..2003 Markus Franz Xaver Johannes Oberhumer
|
|
All Rights Reserved.
|
|
|
|
Markus F.X.J. Oberhumer <markus@oberhumer.com>
|
|
http://www.oberhumer.com/opensource/lzop/
|
|
|
|
lzop and the LZO library are free software; you can redistribute them
|
|
and/or modify them under the terms of the GNU General Public License as
|
|
published by the Free Software Foundation; either version 2 of
|
|
the License, or (at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program; see the file COPYING.
|
|
If not, write to the Free Software Foundation, Inc.,
|
|
59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
|
|
|
|
"Minimalized" for busybox by Alain Knaff
|
|
*/
|
|
|
|
#include "libbb.h"
|
|
#include "unarchive.h"
|
|
#include "liblzo_interface.h"
|
|
|
|
/* lzo-2.03/src/lzo_ptr.h */
|
|
#define pd(a,b) ((unsigned)((a)-(b)))
|
|
|
|
#define lzo_version() LZO_VERSION
|
|
#define lzo_sizeof_dict_t (sizeof(uint8_t*))
|
|
|
|
/* lzo-2.03/include/lzo/lzo1x.h */
|
|
#define LZO1X_1_MEM_COMPRESS (16384 * lzo_sizeof_dict_t)
|
|
#define LZO1X_1_15_MEM_COMPRESS (32768 * lzo_sizeof_dict_t)
|
|
#define LZO1X_999_MEM_COMPRESS (14 * 16384 * sizeof(short))
|
|
|
|
/* lzo-2.03/src/lzo1x_oo.c */
|
|
#define NO_LIT UINT_MAX
|
|
|
|
/**********************************************************************/
|
|
static void copy2(uint8_t* ip, const uint8_t* m_pos, unsigned off)
|
|
{
|
|
ip[0] = m_pos[0];
|
|
if (off == 1)
|
|
ip[1] = m_pos[0];
|
|
else
|
|
ip[1] = m_pos[1];
|
|
}
|
|
|
|
static void copy3(uint8_t* ip, const uint8_t* m_pos, unsigned off)
|
|
{
|
|
ip[0] = m_pos[0];
|
|
if (off == 1) {
|
|
ip[2] = ip[1] = m_pos[0];
|
|
}
|
|
else if (off == 2) {
|
|
ip[1] = m_pos[1];
|
|
ip[2] = m_pos[0];
|
|
}
|
|
else {
|
|
ip[1] = m_pos[1];
|
|
ip[2] = m_pos[2];
|
|
}
|
|
}
|
|
|
|
/**********************************************************************/
|
|
// optimize a block of data.
|
|
/**********************************************************************/
|
|
#define TEST_IP (ip < ip_end)
|
|
#define TEST_OP (op <= op_end)
|
|
|
|
static NOINLINE int lzo1x_optimize(uint8_t *in, unsigned in_len,
|
|
uint8_t *out, unsigned *out_len,
|
|
void* wrkmem UNUSED_PARAM)
|
|
{
|
|
uint8_t* op;
|
|
uint8_t* ip;
|
|
unsigned t;
|
|
uint8_t* m_pos;
|
|
uint8_t* const ip_end = in + in_len;
|
|
uint8_t* const op_end = out + *out_len;
|
|
uint8_t* litp = NULL;
|
|
unsigned lit = 0;
|
|
unsigned next_lit = NO_LIT;
|
|
unsigned nl;
|
|
unsigned long o_m1_a = 0, o_m1_b = 0, o_m2 = 0, o_m3_a = 0, o_m3_b = 0;
|
|
|
|
// LZO_UNUSED(wrkmem);
|
|
|
|
*out_len = 0;
|
|
|
|
op = out;
|
|
ip = in;
|
|
|
|
if (*ip > 17) {
|
|
t = *ip++ - 17;
|
|
if (t < 4)
|
|
goto match_next;
|
|
goto first_literal_run;
|
|
}
|
|
|
|
while (TEST_IP && TEST_OP) {
|
|
t = *ip++;
|
|
if (t >= 16)
|
|
goto match;
|
|
/* a literal run */
|
|
litp = ip - 1;
|
|
if (t == 0) {
|
|
t = 15;
|
|
while (*ip == 0)
|
|
t += 255, ip++;
|
|
t += *ip++;
|
|
}
|
|
lit = t + 3;
|
|
/* copy literals */
|
|
copy_literal_run:
|
|
*op++ = *ip++;
|
|
*op++ = *ip++;
|
|
*op++ = *ip++;
|
|
first_literal_run:
|
|
do *op++ = *ip++; while (--t > 0);
|
|
|
|
t = *ip++;
|
|
|
|
if (t >= 16)
|
|
goto match;
|
|
#if defined(LZO1X)
|
|
m_pos = op - 1 - 0x800;
|
|
#elif defined(LZO1Y)
|
|
m_pos = op - 1 - 0x400;
|
|
#endif
|
|
m_pos -= t >> 2;
|
|
m_pos -= *ip++ << 2;
|
|
*op++ = *m_pos++;
|
|
*op++ = *m_pos++;
|
|
*op++ = *m_pos++;
|
|
lit = 0;
|
|
goto match_done;
|
|
|
|
|
|
/* handle matches */
|
|
do {
|
|
if (t < 16) { /* a M1 match */
|
|
m_pos = op - 1;
|
|
m_pos -= t >> 2;
|
|
m_pos -= *ip++ << 2;
|
|
|
|
if (litp == NULL)
|
|
goto copy_m1;
|
|
|
|
nl = ip[-2] & 3;
|
|
/* test if a match follows */
|
|
if (nl == 0 && lit == 1 && ip[0] >= 16) {
|
|
next_lit = nl;
|
|
/* adjust length of previous short run */
|
|
lit += 2;
|
|
*litp = (unsigned char)((*litp & ~3) | lit);
|
|
/* copy over the 2 literals that replace the match */
|
|
copy2(ip-2, m_pos, pd(op, m_pos));
|
|
o_m1_a++;
|
|
}
|
|
/* test if a literal run follows */
|
|
else
|
|
if (nl == 0
|
|
&& ip[0] < 16
|
|
&& ip[0] != 0
|
|
&& (lit + 2 + ip[0] < 16)
|
|
) {
|
|
t = *ip++;
|
|
/* remove short run */
|
|
*litp &= ~3;
|
|
/* copy over the 2 literals that replace the match */
|
|
copy2(ip-3+1,m_pos,pd(op,m_pos));
|
|
/* move literals 1 byte ahead */
|
|
litp += 2;
|
|
if (lit > 0)
|
|
memmove(litp+1, litp, lit);
|
|
/* insert new length of long literal run */
|
|
lit += 2 + t + 3;
|
|
*litp = (unsigned char)(lit - 3);
|
|
|
|
o_m1_b++;
|
|
*op++ = *m_pos++; *op++ = *m_pos++;
|
|
goto copy_literal_run;
|
|
}
|
|
copy_m1:
|
|
*op++ = *m_pos++;
|
|
*op++ = *m_pos++;
|
|
} else {
|
|
match:
|
|
if (t >= 64) { /* a M2 match */
|
|
m_pos = op - 1;
|
|
#if defined(LZO1X)
|
|
m_pos -= (t >> 2) & 7;
|
|
m_pos -= *ip++ << 3;
|
|
t = (t >> 5) - 1;
|
|
#elif defined(LZO1Y)
|
|
m_pos -= (t >> 2) & 3;
|
|
m_pos -= *ip++ << 2;
|
|
t = (t >> 4) - 3;
|
|
#endif
|
|
if (litp == NULL)
|
|
goto copy_m;
|
|
|
|
nl = ip[-2] & 3;
|
|
/* test if in beetween two long literal runs */
|
|
if (t == 1 && lit > 3 && nl == 0
|
|
&& ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16)
|
|
) {
|
|
t = *ip++;
|
|
/* copy over the 3 literals that replace the match */
|
|
copy3(ip-1-2,m_pos,pd(op,m_pos));
|
|
/* set new length of previous literal run */
|
|
lit += 3 + t + 3;
|
|
*litp = (unsigned char)(lit - 3);
|
|
o_m2++;
|
|
*op++ = *m_pos++;
|
|
*op++ = *m_pos++;
|
|
*op++ = *m_pos++;
|
|
goto copy_literal_run;
|
|
}
|
|
} else {
|
|
if (t >= 32) { /* a M3 match */
|
|
t &= 31;
|
|
if (t == 0) {
|
|
t = 31;
|
|
while (*ip == 0)
|
|
t += 255, ip++;
|
|
t += *ip++;
|
|
}
|
|
m_pos = op - 1;
|
|
m_pos -= *ip++ >> 2;
|
|
m_pos -= *ip++ << 6;
|
|
} else { /* a M4 match */
|
|
m_pos = op;
|
|
m_pos -= (t & 8) << 11;
|
|
t &= 7;
|
|
if (t == 0) {
|
|
t = 7;
|
|
while (*ip == 0)
|
|
t += 255, ip++;
|
|
t += *ip++;
|
|
}
|
|
m_pos -= *ip++ >> 2;
|
|
m_pos -= *ip++ << 6;
|
|
if (m_pos == op)
|
|
goto eof_found;
|
|
m_pos -= 0x4000;
|
|
}
|
|
if (litp == NULL)
|
|
goto copy_m;
|
|
|
|
nl = ip[-2] & 3;
|
|
/* test if in beetween two matches */
|
|
if (t == 1 && lit == 0 && nl == 0 && ip[0] >= 16) {
|
|
next_lit = nl;
|
|
/* make a previous short run */
|
|
lit += 3;
|
|
*litp = (unsigned char)((*litp & ~3) | lit);
|
|
/* copy over the 3 literals that replace the match */
|
|
copy3(ip-3,m_pos,pd(op,m_pos));
|
|
o_m3_a++;
|
|
}
|
|
/* test if a literal run follows */
|
|
else if (t == 1 && lit <= 3 && nl == 0
|
|
&& ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16)
|
|
) {
|
|
t = *ip++;
|
|
/* remove short run */
|
|
*litp &= ~3;
|
|
/* copy over the 3 literals that replace the match */
|
|
copy3(ip-4+1,m_pos,pd(op,m_pos));
|
|
/* move literals 1 byte ahead */
|
|
litp += 2;
|
|
if (lit > 0)
|
|
memmove(litp+1,litp,lit);
|
|
/* insert new length of long literal run */
|
|
lit += 3 + t + 3;
|
|
*litp = (unsigned char)(lit - 3);
|
|
|
|
o_m3_b++;
|
|
*op++ = *m_pos++;
|
|
*op++ = *m_pos++;
|
|
*op++ = *m_pos++;
|
|
goto copy_literal_run;
|
|
}
|
|
}
|
|
copy_m:
|
|
*op++ = *m_pos++;
|
|
*op++ = *m_pos++;
|
|
do *op++ = *m_pos++; while (--t > 0);
|
|
}
|
|
|
|
match_done:
|
|
if (next_lit == NO_LIT) {
|
|
t = ip[-2] & 3;
|
|
lit = t;
|
|
litp = ip - 2;
|
|
}
|
|
else
|
|
t = next_lit;
|
|
next_lit = NO_LIT;
|
|
if (t == 0)
|
|
break;
|
|
/* copy literals */
|
|
match_next:
|
|
do *op++ = *ip++; while (--t > 0);
|
|
t = *ip++;
|
|
} while (TEST_IP && TEST_OP);
|
|
}
|
|
|
|
/* no EOF code was found */
|
|
*out_len = pd(op, out);
|
|
return LZO_E_EOF_NOT_FOUND;
|
|
|
|
eof_found:
|
|
// LZO_UNUSED(o_m1_a); LZO_UNUSED(o_m1_b); LZO_UNUSED(o_m2);
|
|
// LZO_UNUSED(o_m3_a); LZO_UNUSED(o_m3_b);
|
|
*out_len = pd(op, out);
|
|
return (ip == ip_end ? LZO_E_OK :
|
|
(ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
|
|
}
|
|
|
|
/**********************************************************************/
|
|
#define F_OS F_OS_UNIX
|
|
#define F_CS F_CS_NATIVE
|
|
|
|
/**********************************************************************/
|
|
#define ADLER32_INIT_VALUE 1
|
|
#define CRC32_INIT_VALUE 0
|
|
|
|
/**********************************************************************/
|
|
enum {
|
|
M_LZO1X_1 = 1,
|
|
M_LZO1X_1_15 = 2,
|
|
M_LZO1X_999 = 3,
|
|
};
|
|
|
|
/**********************************************************************/
|
|
/* header flags */
|
|
#define F_ADLER32_D 0x00000001L
|
|
#define F_ADLER32_C 0x00000002L
|
|
#define F_H_EXTRA_FIELD 0x00000040L
|
|
#define F_H_GMTDIFF 0x00000080L
|
|
#define F_CRC32_D 0x00000100L
|
|
#define F_CRC32_C 0x00000200L
|
|
#define F_H_FILTER 0x00000800L
|
|
#define F_H_CRC32 0x00001000L
|
|
#define F_MASK 0x00003FFFL
|
|
|
|
/* operating system & file system that created the file [mostly unused] */
|
|
#define F_OS_UNIX 0x03000000L
|
|
#define F_OS_SHIFT 24
|
|
#define F_OS_MASK 0xff000000L
|
|
|
|
/* character set for file name encoding [mostly unused] */
|
|
#define F_CS_NATIVE 0x00000000L
|
|
#define F_CS_SHIFT 20
|
|
#define F_CS_MASK 0x00f00000L
|
|
|
|
/* these bits must be zero */
|
|
#define F_RESERVED ((F_MASK | F_OS_MASK | F_CS_MASK) ^ 0xffffffffL)
|
|
|
|
typedef struct chksum_t {
|
|
uint32_t f_adler32;
|
|
uint32_t f_crc32;
|
|
} chksum_t;
|
|
|
|
typedef struct header_t {
|
|
unsigned version;
|
|
unsigned lib_version;
|
|
unsigned version_needed_to_extract;
|
|
uint32_t flags;
|
|
uint32_t mode;
|
|
uint32_t mtime;
|
|
uint32_t gmtdiff;
|
|
uint32_t header_checksum;
|
|
|
|
uint32_t extra_field_len;
|
|
uint32_t extra_field_checksum;
|
|
|
|
unsigned char method;
|
|
unsigned char level;
|
|
|
|
/* info */
|
|
char name[255+1];
|
|
} header_t;
|
|
|
|
struct globals {
|
|
const uint32_t *lzo_crc32_table;
|
|
chksum_t chksum_in;
|
|
chksum_t chksum_out;
|
|
} FIX_ALIASING;
|
|
#define G (*(struct globals*)&bb_common_bufsiz1)
|
|
#define INIT_G() do { } while (0)
|
|
//#define G (*ptr_to_globals)
|
|
//#define INIT_G() do {
|
|
// SET_PTR_TO_GLOBALS(xzalloc(sizeof(G)));
|
|
//} while (0)
|
|
|
|
|
|
/**********************************************************************/
|
|
#define LZOP_VERSION 0x1010
|
|
//#define LZOP_VERSION_STRING "1.01"
|
|
//#define LZOP_VERSION_DATE "Apr 27th 2003"
|
|
|
|
#define OPTION_STRING "cfvdt123456789CF"
|
|
|
|
enum {
|
|
OPT_STDOUT = (1 << 0),
|
|
OPT_FORCE = (1 << 1),
|
|
OPT_VERBOSE = (1 << 2),
|
|
OPT_DECOMPRESS = (1 << 3),
|
|
OPT_TEST = (1 << 4),
|
|
OPT_1 = (1 << 5),
|
|
OPT_2 = (1 << 6),
|
|
OPT_3 = (1 << 7),
|
|
OPT_4 = (1 << 8),
|
|
OPT_5 = (1 << 9),
|
|
OPT_6 = (1 << 10),
|
|
OPT_789 = (7 << 11),
|
|
OPT_7 = (1 << 11),
|
|
OPT_8 = (1 << 12),
|
|
OPT_C = (1 << 14),
|
|
OPT_F = (1 << 15),
|
|
};
|
|
|
|
/**********************************************************************/
|
|
// adler32 checksum
|
|
// adapted from free code by Mark Adler <madler@alumni.caltech.edu>
|
|
// see http://www.zlib.org/
|
|
/**********************************************************************/
|
|
static FAST_FUNC uint32_t
|
|
lzo_adler32(uint32_t adler, const uint8_t* buf, unsigned len)
|
|
{
|
|
enum {
|
|
LZO_BASE = 65521, /* largest prime smaller than 65536 */
|
|
/* NMAX is the largest n such that
|
|
* 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
|
|
LZO_NMAX = 5552,
|
|
};
|
|
uint32_t s1 = adler & 0xffff;
|
|
uint32_t s2 = (adler >> 16) & 0xffff;
|
|
unsigned k;
|
|
|
|
if (buf == NULL)
|
|
return 1;
|
|
|
|
while (len > 0) {
|
|
k = len < LZO_NMAX ? (unsigned) len : LZO_NMAX;
|
|
len -= k;
|
|
if (k != 0) do {
|
|
s1 += *buf++;
|
|
s2 += s1;
|
|
} while (--k > 0);
|
|
s1 %= LZO_BASE;
|
|
s2 %= LZO_BASE;
|
|
}
|
|
return (s2 << 16) | s1;
|
|
}
|
|
|
|
static FAST_FUNC uint32_t
|
|
lzo_crc32(uint32_t c, const uint8_t* buf, unsigned len)
|
|
{
|
|
uint32_t crc;
|
|
|
|
if (buf == NULL)
|
|
return 0;
|
|
|
|
crc = ~c;
|
|
if (len != 0) do {
|
|
crc = G.lzo_crc32_table[((int)crc ^ *buf) & 0xff] ^ (crc >> 8);
|
|
buf += 1;
|
|
len -= 1;
|
|
} while (len > 0);
|
|
|
|
return ~crc;
|
|
}
|
|
|
|
/**********************************************************************/
|
|
static void init_chksum(chksum_t *ct)
|
|
{
|
|
ct->f_adler32 = ADLER32_INIT_VALUE;
|
|
ct->f_crc32 = CRC32_INIT_VALUE;
|
|
}
|
|
|
|
static void add_bytes_to_chksum(chksum_t *ct, const void* buf, int cnt)
|
|
{
|
|
/* We need to handle the two checksums at once, because at the
|
|
* beginning of the header, we don't know yet which one we'll
|
|
* eventually need */
|
|
ct->f_adler32 = lzo_adler32(ct->f_adler32, (const uint8_t*)buf, cnt);
|
|
ct->f_crc32 = lzo_crc32(ct->f_crc32, (const uint8_t*)buf, cnt);
|
|
}
|
|
|
|
static uint32_t chksum_getresult(chksum_t *ct, const header_t *h)
|
|
{
|
|
return (h->flags & F_H_CRC32) ? ct->f_crc32 : ct->f_adler32;
|
|
}
|
|
|
|
/**********************************************************************/
|
|
static uint32_t read32(void)
|
|
{
|
|
uint32_t v;
|
|
xread(0, &v, 4);
|
|
return ntohl(v);
|
|
}
|
|
|
|
static void write32(uint32_t v)
|
|
{
|
|
v = htonl(v);
|
|
xwrite(1, &v, 4);
|
|
}
|
|
|
|
static void f_write(const void* buf, int cnt)
|
|
{
|
|
xwrite(1, buf, cnt);
|
|
add_bytes_to_chksum(&G.chksum_out, buf, cnt);
|
|
}
|
|
|
|
static void f_read(void* buf, int cnt)
|
|
{
|
|
xread(0, buf, cnt);
|
|
add_bytes_to_chksum(&G.chksum_in, buf, cnt);
|
|
}
|
|
|
|
static int f_read8(void)
|
|
{
|
|
uint8_t v;
|
|
f_read(&v, 1);
|
|
return v;
|
|
}
|
|
|
|
static void f_write8(uint8_t v)
|
|
{
|
|
f_write(&v, 1);
|
|
}
|
|
|
|
static unsigned f_read16(void)
|
|
{
|
|
uint16_t v;
|
|
f_read(&v, 2);
|
|
return ntohs(v);
|
|
}
|
|
|
|
static void f_write16(uint16_t v)
|
|
{
|
|
v = htons(v);
|
|
f_write(&v, 2);
|
|
}
|
|
|
|
static uint32_t f_read32(void)
|
|
{
|
|
uint32_t v;
|
|
f_read(&v, 4);
|
|
return ntohl(v);
|
|
}
|
|
|
|
static void f_write32(uint32_t v)
|
|
{
|
|
v = htonl(v);
|
|
f_write(&v, 4);
|
|
}
|
|
|
|
/**********************************************************************/
|
|
static int lzo_get_method(header_t *h)
|
|
{
|
|
/* check method */
|
|
if (h->method == M_LZO1X_1) {
|
|
if (h->level == 0)
|
|
h->level = 3;
|
|
} else if (h->method == M_LZO1X_1_15) {
|
|
if (h->level == 0)
|
|
h->level = 1;
|
|
} else if (h->method == M_LZO1X_999) {
|
|
if (h->level == 0)
|
|
h->level = 9;
|
|
} else
|
|
return -1; /* not a LZO method */
|
|
|
|
/* check compression level */
|
|
if (h->level < 1 || h->level > 9)
|
|
return 15;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**********************************************************************/
|
|
#define LZO_BLOCK_SIZE (256 * 1024l)
|
|
#define MAX_BLOCK_SIZE (64 * 1024l * 1024l) /* DO NOT CHANGE */
|
|
|
|
/* LZO may expand uncompressible data by a small amount */
|
|
#define MAX_COMPRESSED_SIZE(x) ((x) + (x) / 16 + 64 + 3)
|
|
|
|
/**********************************************************************/
|
|
// compress a file
|
|
/**********************************************************************/
|
|
static NOINLINE smallint lzo_compress(const header_t *h)
|
|
{
|
|
unsigned block_size = LZO_BLOCK_SIZE;
|
|
int r = 0; /* LZO_E_OK */
|
|
uint8_t *const b1 = xzalloc(block_size);
|
|
uint8_t *const b2 = xzalloc(MAX_COMPRESSED_SIZE(block_size));
|
|
unsigned src_len = 0, dst_len = 0;
|
|
uint32_t d_adler32 = ADLER32_INIT_VALUE;
|
|
uint32_t d_crc32 = CRC32_INIT_VALUE;
|
|
int l;
|
|
smallint ok = 1;
|
|
uint8_t *wrk_mem = NULL;
|
|
|
|
if (h->method == M_LZO1X_1)
|
|
wrk_mem = xzalloc(LZO1X_1_MEM_COMPRESS);
|
|
else if (h->method == M_LZO1X_1_15)
|
|
wrk_mem = xzalloc(LZO1X_1_15_MEM_COMPRESS);
|
|
else if (h->method == M_LZO1X_999)
|
|
wrk_mem = xzalloc(LZO1X_999_MEM_COMPRESS);
|
|
|
|
for (;;) {
|
|
/* read a block */
|
|
l = full_read(0, b1, block_size);
|
|
src_len = (l > 0 ? l : 0);
|
|
|
|
/* write uncompressed block size */
|
|
write32(src_len);
|
|
|
|
/* exit if last block */
|
|
if (src_len == 0)
|
|
break;
|
|
|
|
/* compute checksum of uncompressed block */
|
|
if (h->flags & F_ADLER32_D)
|
|
d_adler32 = lzo_adler32(ADLER32_INIT_VALUE, b1, src_len);
|
|
if (h->flags & F_CRC32_D)
|
|
d_crc32 = lzo_crc32(CRC32_INIT_VALUE, b1, src_len);
|
|
|
|
/* compress */
|
|
if (h->method == M_LZO1X_1)
|
|
r = lzo1x_1_compress(b1, src_len, b2, &dst_len, wrk_mem);
|
|
else if (h->method == M_LZO1X_1_15)
|
|
r = lzo1x_1_15_compress(b1, src_len, b2, &dst_len, wrk_mem);
|
|
#if ENABLE_LZOP_COMPR_HIGH
|
|
else if (h->method == M_LZO1X_999)
|
|
r = lzo1x_999_compress_level(b1, src_len, b2, &dst_len,
|
|
wrk_mem, h->level);
|
|
#endif
|
|
else
|
|
bb_error_msg_and_die("internal error");
|
|
|
|
if (r != 0) /* not LZO_E_OK */
|
|
bb_error_msg_and_die("internal error - compression failed");
|
|
|
|
/* write compressed block size */
|
|
if (dst_len < src_len) {
|
|
/* optimize */
|
|
if (h->method == M_LZO1X_999) {
|
|
unsigned new_len = src_len;
|
|
r = lzo1x_optimize(b2, dst_len, b1, &new_len, NULL);
|
|
if (r != 0 /*LZO_E_OK*/ || new_len != src_len)
|
|
bb_error_msg_and_die("internal error - optimization failed");
|
|
}
|
|
write32(dst_len);
|
|
} else {
|
|
/* data actually expanded => store data uncompressed */
|
|
write32(src_len);
|
|
}
|
|
|
|
/* write checksum of uncompressed block */
|
|
if (h->flags & F_ADLER32_D)
|
|
write32(d_adler32);
|
|
if (h->flags & F_CRC32_D)
|
|
write32(d_crc32);
|
|
|
|
if (dst_len < src_len) {
|
|
/* write checksum of compressed block */
|
|
if (h->flags & F_ADLER32_C)
|
|
write32(lzo_adler32(ADLER32_INIT_VALUE, b2,
|
|
dst_len));
|
|
if (h->flags & F_CRC32_C)
|
|
write32(lzo_crc32(CRC32_INIT_VALUE, b2, dst_len));
|
|
/* write compressed block data */
|
|
xwrite(1, b2, dst_len);
|
|
} else {
|
|
/* write uncompressed block data */
|
|
xwrite(1, b1, src_len);
|
|
}
|
|
}
|
|
|
|
free(wrk_mem);
|
|
free(b1);
|
|
free(b2);
|
|
return ok;
|
|
}
|
|
|
|
static void lzo_check(uint32_t FAST_FUNC (*fn)(uint32_t, const uint8_t*, unsigned),
|
|
uint32_t ref, uint32_t init,
|
|
uint8_t* buf, unsigned len)
|
|
{
|
|
uint32_t c = fn(init, buf, len);
|
|
if (c != ref)
|
|
bb_error_msg_and_die("checksum error");
|
|
}
|
|
|
|
/**********************************************************************/
|
|
// decompress a file
|
|
/**********************************************************************/
|
|
static NOINLINE smallint lzo_decompress(const header_t *h)
|
|
{
|
|
unsigned block_size = LZO_BLOCK_SIZE;
|
|
int r;
|
|
uint32_t src_len, dst_len;
|
|
uint32_t c_adler32 = ADLER32_INIT_VALUE;
|
|
uint32_t d_adler32 = ADLER32_INIT_VALUE;
|
|
uint32_t c_crc32 = CRC32_INIT_VALUE, d_crc32 = CRC32_INIT_VALUE;
|
|
smallint ok = 1;
|
|
uint8_t *b1;
|
|
uint32_t mcs_block_size = MAX_COMPRESSED_SIZE(block_size);
|
|
uint8_t *b2 = NULL;
|
|
|
|
for (;;) {
|
|
uint8_t *dst;
|
|
|
|
/* read uncompressed block size */
|
|
dst_len = read32();
|
|
|
|
/* exit if last block */
|
|
if (dst_len == 0)
|
|
break;
|
|
|
|
/* error if split file */
|
|
if (dst_len == 0xffffffffL)
|
|
/* should not happen - not yet implemented */
|
|
bb_error_msg_and_die("this file is a split lzop file");
|
|
|
|
if (dst_len > MAX_BLOCK_SIZE)
|
|
bb_error_msg_and_die("lzop file corrupted");
|
|
|
|
/* read compressed block size */
|
|
src_len = read32();
|
|
if (src_len <= 0 || src_len > dst_len)
|
|
bb_error_msg_and_die("lzop file corrupted");
|
|
|
|
if (dst_len > block_size) {
|
|
if (b2) {
|
|
//FIXME!
|
|
b2 = NULL;
|
|
free(b2);
|
|
}
|
|
block_size = dst_len;
|
|
mcs_block_size = MAX_COMPRESSED_SIZE(block_size);
|
|
}
|
|
|
|
/* read checksum of uncompressed block */
|
|
if (h->flags & F_ADLER32_D)
|
|
d_adler32 = read32();
|
|
if (h->flags & F_CRC32_D)
|
|
d_crc32 = read32();
|
|
|
|
/* read checksum of compressed block */
|
|
if (src_len < dst_len) {
|
|
if (h->flags & F_ADLER32_C)
|
|
c_adler32 = read32();
|
|
if (h->flags & F_CRC32_C)
|
|
c_crc32 = read32();
|
|
}
|
|
|
|
if (b2 == NULL)
|
|
b2 = xzalloc(mcs_block_size);
|
|
/* read the block into the end of our buffer */
|
|
b1 = b2 + mcs_block_size - src_len;
|
|
xread(0, b1, src_len);
|
|
|
|
if (src_len < dst_len) {
|
|
unsigned d = dst_len;
|
|
|
|
if (!(option_mask32 & OPT_F)) {
|
|
/* verify checksum of compressed block */
|
|
if (h->flags & F_ADLER32_C)
|
|
lzo_check(lzo_adler32, c_adler32,
|
|
ADLER32_INIT_VALUE,
|
|
b1, src_len);
|
|
if (h->flags & F_CRC32_C)
|
|
lzo_check(lzo_crc32, c_crc32,
|
|
CRC32_INIT_VALUE,
|
|
b1, src_len);
|
|
}
|
|
|
|
/* decompress */
|
|
// if (option_mask32 & OPT_F)
|
|
// r = lzo1x_decompress(b1, src_len, b2, &d, NULL);
|
|
// else
|
|
r = lzo1x_decompress_safe(b1, src_len, b2, &d, NULL);
|
|
|
|
if (r != 0 /*LZO_E_OK*/ || dst_len != d) {
|
|
bb_error_msg_and_die("corrupted compressed data");
|
|
}
|
|
dst = b2;
|
|
} else {
|
|
/* "stored" block => no decompression */
|
|
dst = b1;
|
|
}
|
|
|
|
if (!(option_mask32 & OPT_F)) {
|
|
/* verify checksum of uncompressed block */
|
|
if (h->flags & F_ADLER32_D)
|
|
lzo_check(lzo_adler32, d_adler32, ADLER32_INIT_VALUE,
|
|
dst, dst_len);
|
|
if (h->flags & F_CRC32_D)
|
|
lzo_check(lzo_crc32, d_crc32, CRC32_INIT_VALUE,
|
|
dst, dst_len);
|
|
}
|
|
|
|
/* write uncompressed block data */
|
|
xwrite(1, dst, dst_len);
|
|
}
|
|
|
|
free(b2);
|
|
return ok;
|
|
}
|
|
|
|
/**********************************************************************/
|
|
// lzop file signature (shamelessly borrowed from PNG)
|
|
/**********************************************************************/
|
|
/*
|
|
* The first nine bytes of a lzop file always contain the following values:
|
|
*
|
|
* 0 1 2 3 4 5 6 7 8
|
|
* --- --- --- --- --- --- --- --- ---
|
|
* (hex) 89 4c 5a 4f 00 0d 0a 1a 0a
|
|
* (decimal) 137 76 90 79 0 13 10 26 10
|
|
* (C notation - ASCII) \211 L Z O \0 \r \n \032 \n
|
|
*/
|
|
|
|
/* (vda) comparison with lzop v1.02rc1 ("lzop -1 <FILE" cmd):
|
|
* Only slight differences in header:
|
|
* -00000000 89 4c 5a 4f 00 0d 0a 1a 0a 10 20 20 20 09 40 02
|
|
* +00000000 89 4c 5a 4f 00 0d 0a 1a 0a 10 10 20 30 09 40 02
|
|
* ^^^^^ ^^^^^
|
|
* version lib_version
|
|
* -00000010 01 03 00 00 0d 00 00 81 a4 49 f7 a6 3f 00 00 00
|
|
* +00000010 01 03 00 00 01 00 00 00 00 00 00 00 00 00 00 00
|
|
* ^^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^
|
|
* flags mode mtime
|
|
* -00000020 00 00 2d 67 04 17 00 04 00 00 00 03 ed ec 9d 6d
|
|
* +00000020 00 00 10 5f 00 c1 00 04 00 00 00 03 ed ec 9d 6d
|
|
* ^^^^^^^^^^^
|
|
* chksum_out
|
|
* The rest is identical.
|
|
*/
|
|
static const unsigned char lzop_magic[9] = {
|
|
0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a
|
|
};
|
|
|
|
/* This coding is derived from Alexander Lehmann's pngcheck code. */
|
|
static void check_magic(void)
|
|
{
|
|
unsigned char magic[sizeof(lzop_magic)];
|
|
xread(0, magic, sizeof(magic));
|
|
if (memcmp(magic, lzop_magic, sizeof(lzop_magic)) != 0)
|
|
bb_error_msg_and_die("bad magic number");
|
|
}
|
|
|
|
/**********************************************************************/
|
|
// lzop file header
|
|
/**********************************************************************/
|
|
static void write_header(const header_t *h)
|
|
{
|
|
int l;
|
|
|
|
xwrite(1, lzop_magic, sizeof(lzop_magic));
|
|
|
|
init_chksum(&G.chksum_out);
|
|
|
|
f_write16(h->version);
|
|
f_write16(h->lib_version);
|
|
f_write16(h->version_needed_to_extract);
|
|
f_write8(h->method);
|
|
f_write8(h->level);
|
|
f_write32(h->flags);
|
|
f_write32(h->mode);
|
|
f_write32(h->mtime);
|
|
f_write32(h->gmtdiff);
|
|
|
|
l = (int) strlen(h->name);
|
|
f_write8(l);
|
|
if (l)
|
|
f_write(h->name, l);
|
|
|
|
f_write32(chksum_getresult(&G.chksum_out, h));
|
|
}
|
|
|
|
static int read_header(header_t *h)
|
|
{
|
|
int r;
|
|
int l;
|
|
uint32_t checksum;
|
|
|
|
memset(h, 0, sizeof(*h));
|
|
h->version_needed_to_extract = 0x0900; /* first lzop version */
|
|
h->level = 0;
|
|
|
|
init_chksum(&G.chksum_in);
|
|
|
|
h->version = f_read16();
|
|
if (h->version < 0x0900)
|
|
return 3;
|
|
h->lib_version = f_read16();
|
|
if (h->version >= 0x0940) {
|
|
h->version_needed_to_extract = f_read16();
|
|
if (h->version_needed_to_extract > LZOP_VERSION)
|
|
return 16;
|
|
if (h->version_needed_to_extract < 0x0900)
|
|
return 3;
|
|
}
|
|
h->method = f_read8();
|
|
if (h->version >= 0x0940)
|
|
h->level = f_read8();
|
|
h->flags = f_read32();
|
|
if (h->flags & F_H_FILTER)
|
|
return 16; /* filter not supported */
|
|
h->mode = f_read32();
|
|
h->mtime = f_read32();
|
|
if (h->version >= 0x0940)
|
|
h->gmtdiff = f_read32();
|
|
|
|
l = f_read8();
|
|
if (l > 0)
|
|
f_read(h->name, l);
|
|
h->name[l] = 0;
|
|
|
|
checksum = chksum_getresult(&G.chksum_in, h);
|
|
h->header_checksum = f_read32();
|
|
if (h->header_checksum != checksum)
|
|
return 2;
|
|
|
|
if (h->method <= 0)
|
|
return 14;
|
|
r = lzo_get_method(h);
|
|
if (r != 0)
|
|
return r;
|
|
|
|
/* check reserved flags */
|
|
if (h->flags & F_RESERVED)
|
|
return -13;
|
|
|
|
/* skip extra field [not used yet] */
|
|
if (h->flags & F_H_EXTRA_FIELD) {
|
|
uint32_t k;
|
|
|
|
/* note: the checksum also covers the length */
|
|
init_chksum(&G.chksum_in);
|
|
h->extra_field_len = f_read32();
|
|
for (k = 0; k < h->extra_field_len; k++)
|
|
f_read8();
|
|
checksum = chksum_getresult(&G.chksum_in, h);
|
|
h->extra_field_checksum = f_read32();
|
|
if (h->extra_field_checksum != checksum)
|
|
return 3;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void p_header(header_t *h)
|
|
{
|
|
int r;
|
|
|
|
r = read_header(h);
|
|
if (r == 0)
|
|
return;
|
|
bb_error_msg_and_die("header_error %d", r);
|
|
}
|
|
|
|
/**********************************************************************/
|
|
// compress
|
|
/**********************************************************************/
|
|
static void lzo_set_method(header_t *h)
|
|
{
|
|
int level = 1;
|
|
|
|
if (option_mask32 & OPT_1) {
|
|
h->method = M_LZO1X_1_15;
|
|
} else if (option_mask32 & OPT_789) {
|
|
#if ENABLE_LZOP_COMPR_HIGH
|
|
h->method = M_LZO1X_999;
|
|
if (option_mask32 & OPT_7)
|
|
level = 7;
|
|
else if (option_mask32 & OPT_8)
|
|
level = 8;
|
|
else
|
|
level = 9;
|
|
#else
|
|
bb_error_msg_and_die("high compression not compiled in");
|
|
#endif
|
|
} else { /* levels 2..6 or none (defaults to level 3) */
|
|
h->method = M_LZO1X_1;
|
|
level = 5; /* levels 2-6 are actually the same */
|
|
}
|
|
|
|
h->level = level;
|
|
}
|
|
|
|
static smallint do_lzo_compress(void)
|
|
{
|
|
header_t header;
|
|
|
|
#define h (&header)
|
|
memset(h, 0, sizeof(*h));
|
|
|
|
lzo_set_method(h);
|
|
|
|
h->version = (LZOP_VERSION & 0xffff);
|
|
h->version_needed_to_extract = 0x0940;
|
|
h->lib_version = lzo_version() & 0xffff;
|
|
|
|
h->flags = (F_OS & F_OS_MASK) | (F_CS & F_CS_MASK);
|
|
|
|
if (!(option_mask32 & OPT_F) || h->method == M_LZO1X_999) {
|
|
h->flags |= F_ADLER32_D;
|
|
if (option_mask32 & OPT_C)
|
|
h->flags |= F_ADLER32_C;
|
|
}
|
|
write_header(h);
|
|
return lzo_compress(h);
|
|
#undef h
|
|
}
|
|
|
|
/**********************************************************************/
|
|
// decompress
|
|
/**********************************************************************/
|
|
static smallint do_lzo_decompress(void)
|
|
{
|
|
header_t header;
|
|
|
|
check_magic();
|
|
p_header(&header);
|
|
return lzo_decompress(&header);
|
|
}
|
|
|
|
static char* make_new_name_lzop(char *filename)
|
|
{
|
|
if (option_mask32 & OPT_DECOMPRESS) {
|
|
char *extension = strrchr(filename, '.');
|
|
if (!extension || strcmp(extension + 1, "lzo") != 0)
|
|
return xasprintf("%s.out", filename);
|
|
*extension = '\0';
|
|
return filename;
|
|
}
|
|
return xasprintf("%s.lzo", filename);
|
|
}
|
|
|
|
static IF_DESKTOP(long long) int pack_lzop(unpack_info_t *info UNUSED_PARAM)
|
|
{
|
|
if (option_mask32 & OPT_DECOMPRESS)
|
|
return do_lzo_decompress();
|
|
return do_lzo_compress();
|
|
}
|
|
|
|
int lzop_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
|
|
int lzop_main(int argc UNUSED_PARAM, char **argv)
|
|
{
|
|
getopt32(argv, OPTION_STRING);
|
|
argv += optind;
|
|
/* lzopcat? */
|
|
if (applet_name[4] == 'c')
|
|
option_mask32 |= (OPT_STDOUT | OPT_DECOMPRESS);
|
|
/* unlzop? */
|
|
if (applet_name[0] == 'u')
|
|
option_mask32 |= OPT_DECOMPRESS;
|
|
|
|
G.lzo_crc32_table = crc32_filltable(NULL, 0);
|
|
return bbunpack(argv, make_new_name_lzop, pack_lzop);
|
|
}
|