2 This file is part of the lzop file compressor.
4 Copyright (C) 1996..2003 Markus Franz Xaver Johannes Oberhumer
7 Markus F.X.J. Oberhumer <markus@oberhumer.com>
8 http://www.oberhumer.com/opensource/lzop/
10 lzop and the LZO library are free software; you can redistribute them
11 and/or modify them under the terms of the GNU General Public License as
12 published by the Free Software Foundation; either version 2 of
13 the License, or (at your option) any later version.
15 This program is distributed in the hope that it will be useful,
16 but WITHOUT ANY WARRANTY; without even the implied warranty of
17 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
18 GNU General Public License for more details.
20 You should have received a copy of the GNU General Public License
21 along with this program; see the file COPYING.
22 If not, write to the Free Software Foundation, Inc.,
23 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
25 "Minimalized" for busybox by Alain Knaff
28 //config: bool "lzop (12 kb)"
31 //config: Lzop compression/decompresion.
33 //config:config UNLZOP
34 //config: bool "unlzop (13 kb)"
35 //config: default n # INCOMPAT: upstream lzop does not provide such tool
37 //config: Lzop decompresion.
39 //config:config LZOPCAT
40 //config: bool "lzopcat (13 kb)"
41 //config: default n # INCOMPAT: upstream lzop does not provide such tool
43 //config: Alias to "lzop -dc".
45 //config:config LZOP_COMPR_HIGH
46 //config: bool "lzop compression levels 7,8,9 (not very useful)"
48 //config: depends on LZOP || UNLZOP || LZOPCAT
50 //config: High levels (7,8,9) of lzop compression. These levels
51 //config: are actually slower than gzip at equivalent compression ratios
52 //config: and take up 3.2K of code.
54 //applet:IF_LZOP(APPLET(lzop, BB_DIR_BIN, BB_SUID_DROP))
55 // APPLET_ODDNAME:name main location suid_type help
56 //applet:IF_UNLZOP( APPLET_ODDNAME(unlzop, lzop, BB_DIR_USR_BIN, BB_SUID_DROP, unlzop))
57 //applet:IF_LZOPCAT(APPLET_ODDNAME(lzopcat, lzop, BB_DIR_USR_BIN, BB_SUID_DROP, lzopcat))
59 //kbuild:lib-$(CONFIG_LZOP) += lzop.o
60 //kbuild:lib-$(CONFIG_UNLZOP) += lzop.o
61 //kbuild:lib-$(CONFIG_LZOPCAT) += lzop.o
63 //usage:#define lzop_trivial_usage
64 //usage: "[-cfUvd123456789CF] [FILE]..."
65 //usage:#define lzop_full_usage "\n\n"
66 //usage: " -1..9 Compression level"
67 //usage: "\n -d Decompress"
68 //usage: "\n -c Write to stdout"
69 //usage: "\n -f Force"
70 //usage: "\n -U Delete input files"
71 ///////: "\n -k Keep input files" (default, so why bother documenting?)
72 //usage: "\n -v Verbose"
73 //usage: "\n -F Don't store or verify checksum"
74 //usage: "\n -C Also write checksum of compressed block"
76 //usage:#define lzopcat_trivial_usage
77 //usage: "[-vF] [FILE]..."
78 //usage:#define lzopcat_full_usage "\n\n"
79 //usage: " -v Verbose"
80 //usage: "\n -F Don't verify checksum"
82 //usage:#define unlzop_trivial_usage
83 //usage: "[-cfUvF] [FILE]..."
84 //usage:#define unlzop_full_usage "\n\n"
85 //usage: " -c Write to stdout"
86 //usage: "\n -f Force"
87 //usage: "\n -U Delete input files"
88 ///////: "\n -k Keep input files" (default, so why bother documenting?)
89 //usage: "\n -v Verbose"
90 //usage: "\n -F Don't verify checksum"
93 #include "common_bufsiz.h"
94 #include "bb_archive.h"
95 #include "liblzo_interface.h"
97 /* lzo-2.03/src/lzo_ptr.h */
98 #define pd(a,b) ((unsigned)((a)-(b)))
100 #define lzo_version() LZO_VERSION
101 #define lzo_sizeof_dict_t (sizeof(uint8_t*))
103 /* lzo-2.03/include/lzo/lzo1x.h */
104 #define LZO1X_1_MEM_COMPRESS (16384 * lzo_sizeof_dict_t)
105 #define LZO1X_1_15_MEM_COMPRESS (32768 * lzo_sizeof_dict_t)
106 #define LZO1X_999_MEM_COMPRESS (14 * 16384 * sizeof(short))
108 /* lzo-2.03/src/lzo1x_oo.c */
109 #define NO_LIT UINT_MAX
111 /**********************************************************************/
112 static void copy2(uint8_t* ip, const uint8_t* m_pos, unsigned off)
121 static void copy3(uint8_t* ip, const uint8_t* m_pos, unsigned off)
125 ip[2] = ip[1] = m_pos[0];
137 /**********************************************************************/
138 // optimize a block of data.
139 /**********************************************************************/
140 #define TEST_IP (ip < ip_end)
141 #define TEST_OP (op <= op_end)
143 static NOINLINE int lzo1x_optimize(uint8_t *in, unsigned in_len,
144 uint8_t *out, unsigned *out_len /*, void* wrkmem */)
150 uint8_t* const ip_end = in + in_len;
151 uint8_t* const op_end = out + *out_len;
152 uint8_t* litp = NULL;
154 unsigned next_lit = NO_LIT;
156 unsigned long o_m1_a = 0, o_m1_b = 0, o_m2 = 0, o_m3_a = 0, o_m3_b = 0;
158 // LZO_UNUSED(wrkmem);
169 goto first_literal_run;
172 while (TEST_IP && TEST_OP) {
191 do *op++ = *ip++; while (--t > 0);
198 m_pos = op - 1 - 0x800;
200 m_pos = op - 1 - 0x400;
213 if (t < 16) { /* a M1 match */
222 /* test if a match follows */
223 if (nl == 0 && lit == 1 && ip[0] >= 16) {
225 /* adjust length of previous short run */
227 *litp = (unsigned char)((*litp & ~3) | lit);
228 /* copy over the 2 literals that replace the match */
229 copy2(ip-2, m_pos, pd(op, m_pos));
232 /* test if a literal run follows */
237 && (lit + 2 + ip[0] < 16)
240 /* remove short run */
242 /* copy over the 2 literals that replace the match */
243 copy2(ip-3+1, m_pos, pd(op, m_pos));
244 /* move literals 1 byte ahead */
247 memmove(litp+1, litp, lit);
248 /* insert new length of long literal run */
250 *litp = (unsigned char)(lit - 3);
255 goto copy_literal_run;
262 if (t >= 64) { /* a M2 match */
265 m_pos -= (t >> 2) & 7;
269 m_pos -= (t >> 2) & 3;
277 /* test if in beetween two long literal runs */
278 if (t == 1 && lit > 3 && nl == 0
279 && ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16)
282 /* copy over the 3 literals that replace the match */
283 copy3(ip-1-2, m_pos, pd(op, m_pos));
284 /* set new length of previous literal run */
286 *litp = (unsigned char)(lit - 3);
291 goto copy_literal_run;
294 if (t >= 32) { /* a M3 match */
305 } else { /* a M4 match */
307 m_pos -= (t & 8) << 11;
325 /* test if in beetween two matches */
326 if (t == 1 && lit == 0 && nl == 0 && ip[0] >= 16) {
328 /* make a previous short run */
330 *litp = (unsigned char)((*litp & ~3) | lit);
331 /* copy over the 3 literals that replace the match */
332 copy3(ip-3, m_pos, pd(op, m_pos));
335 /* test if a literal run follows */
336 else if (t == 1 && lit <= 3 && nl == 0
337 && ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16)
340 /* remove short run */
342 /* copy over the 3 literals that replace the match */
343 copy3(ip-4+1, m_pos, pd(op, m_pos));
344 /* move literals 1 byte ahead */
347 memmove(litp+1,litp,lit);
348 /* insert new length of long literal run */
350 *litp = (unsigned char)(lit - 3);
356 goto copy_literal_run;
362 do *op++ = *m_pos++; while (--t > 0);
366 if (next_lit == NO_LIT) {
378 do *op++ = *ip++; while (--t > 0);
380 } while (TEST_IP && TEST_OP);
383 /* no EOF code was found */
384 *out_len = pd(op, out);
385 return LZO_E_EOF_NOT_FOUND;
388 // LZO_UNUSED(o_m1_a); LZO_UNUSED(o_m1_b); LZO_UNUSED(o_m2);
389 // LZO_UNUSED(o_m3_a); LZO_UNUSED(o_m3_b);
390 *out_len = pd(op, out);
391 return (ip == ip_end ? LZO_E_OK :
392 (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
395 /**********************************************************************/
396 #define F_OS F_OS_UNIX
397 #define F_CS F_CS_NATIVE
399 /**********************************************************************/
400 #define ADLER32_INIT_VALUE 1
401 #define CRC32_INIT_VALUE 0
403 /**********************************************************************/
410 /**********************************************************************/
412 #define F_ADLER32_D 0x00000001L
413 #define F_ADLER32_C 0x00000002L
414 #define F_H_EXTRA_FIELD 0x00000040L
415 #define F_H_GMTDIFF 0x00000080L
416 #define F_CRC32_D 0x00000100L
417 #define F_CRC32_C 0x00000200L
418 #define F_H_FILTER 0x00000800L
419 #define F_H_CRC32 0x00001000L
420 #define F_MASK 0x00003FFFL
422 /* operating system & file system that created the file [mostly unused] */
423 #define F_OS_UNIX 0x03000000L
424 #define F_OS_SHIFT 24
425 #define F_OS_MASK 0xff000000L
427 /* character set for file name encoding [mostly unused] */
428 #define F_CS_NATIVE 0x00000000L
429 #define F_CS_SHIFT 20
430 #define F_CS_MASK 0x00f00000L
432 /* these bits must be zero */
433 #define F_RESERVED ((F_MASK | F_OS_MASK | F_CS_MASK) ^ 0xffffffffL)
435 typedef struct chksum_t {
440 typedef struct header_t {
441 /* used to have auxiliary fields here */
443 /* Starting from here, the layout and endianness
444 * are exactly in on-disk format.
446 uint16_t version_be16;
447 uint16_t lib_version_be16;
448 uint16_t version_needed_to_extract_be16;
451 uint32_t flags32; /* be32 on disk, but we keep this field in native order */
454 uint32_t gmtdiff_be32;
455 char len_and_name[1+255+1];
459 /*const uint32_t *lzo_crc32_table;*/
462 #define G (*(struct globals*)bb_common_bufsiz1)
463 //#define G (*ptr_to_globals)
464 #define INIT_G() do { \
465 setup_common_bufsiz(); \
466 /*SET_PTR_TO_GLOBALS(xzalloc(sizeof(G)));*/ \
470 /**********************************************************************/
471 #define LZOP_VERSION 0x1010
472 //#define LZOP_VERSION_STRING "1.01"
473 //#define LZOP_VERSION_DATE "Apr 27th 2003"
475 // lzop wants to be weird:
476 // unlike all other compressosrs, its -k "keep" option is the default,
477 // and -U is used to delete the source. We will invert the bit after getopt().
478 #define OPTION_STRING "cfUvqdt123456789CFk"
480 /* Note: must be kept in sync with archival/bbunzip.c */
482 OPT_STDOUT = (1 << 0),
483 OPT_FORCE = (1 << 1),
485 OPT_VERBOSE = (1 << 3),
486 OPT_QUIET = (1 << 4),
487 OPT_DECOMPRESS = (1 << 5),
501 OPT_789 = OPT_7 | OPT_8 | OPT_9
504 /**********************************************************************/
506 // adapted from free code by Mark Adler <madler@alumni.caltech.edu>
507 // see http://www.zlib.org/
508 /**********************************************************************/
509 static FAST_FUNC uint32_t
510 lzo_adler32(uint32_t adler, const uint8_t* buf, unsigned len)
513 LZO_BASE = 65521, /* largest prime smaller than 65536 */
514 /* NMAX is the largest n such that
515 * 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
518 uint32_t s1 = adler & 0xffff;
519 uint32_t s2 = (adler >> 16) & 0xffff;
526 k = len < LZO_NMAX ? (unsigned) len : LZO_NMAX;
535 return (s2 << 16) | s1;
538 static FAST_FUNC uint32_t
539 lzo_crc32(uint32_t c, const uint8_t* buf, unsigned len)
541 //if (buf == NULL) - impossible
544 return ~crc32_block_endian0(~c, buf, len, global_crc32_table);
547 /**********************************************************************/
548 static void init_chksum(void)
550 G.chksum.f_adler32 = ADLER32_INIT_VALUE;
551 G.chksum.f_crc32 = CRC32_INIT_VALUE;
554 static void add_bytes_to_chksum(const void* buf, int cnt)
556 /* We need to handle the two checksums at once, because at the
557 * beginning of the header, we don't know yet which one we'll
559 G.chksum.f_adler32 = lzo_adler32(G.chksum.f_adler32, (const uint8_t*)buf, cnt);
560 G.chksum.f_crc32 = lzo_crc32(G.chksum.f_crc32, (const uint8_t*)buf, cnt);
563 static uint32_t chksum_getresult(uint32_t h_flags32)
565 return (h_flags32 & F_H_CRC32) ? G.chksum.f_crc32 : G.chksum.f_adler32;
568 /**********************************************************************/
569 static uint32_t read32(void)
575 static void f_read(void* buf, int cnt)
578 add_bytes_to_chksum(buf, cnt);
580 //static int f_read8(void)
586 //static unsigned f_read16(void)
592 static uint32_t f_read32(void)
599 static void write32(uint32_t v)
604 static void f_write(const void* buf, int cnt)
607 add_bytes_to_chksum(buf, cnt);
609 //static void f_write8(uint8_t v)
613 //static void f_write16(uint16_t v)
618 //static void f_write32(uint32_t v)
624 /**********************************************************************/
625 #define LZO_BLOCK_SIZE (256 * 1024l)
626 #define MAX_BLOCK_SIZE (64 * 1024l * 1024l) /* DO NOT CHANGE */
628 /* LZO may expand uncompressible data by a small amount */
629 #define MAX_COMPRESSED_SIZE(x) ((x) + (x) / 16 + 64 + 3)
631 /**********************************************************************/
633 /**********************************************************************/
634 static NOINLINE int lzo_compress(const header_t *h)
636 unsigned block_size = LZO_BLOCK_SIZE;
637 int r = 0; /* LZO_E_OK */
638 uint8_t *const b1 = xzalloc(block_size);
639 uint8_t *const b2 = xzalloc(MAX_COMPRESSED_SIZE(block_size));
640 uint32_t d_adler32 = ADLER32_INIT_VALUE;
641 uint32_t d_crc32 = CRC32_INIT_VALUE;
642 uint8_t *wrk_mem = NULL;
644 /* Only these methods are possible, see lzo_set_method():
647 * -7..9: M_LZO1X_999 if ENABLE_LZOP_COMPR_HIGH
649 if (h->method == M_LZO1X_1)
650 wrk_mem = xzalloc(LZO1X_1_MEM_COMPRESS);
651 else /* check only if it's not the only possibility */
652 IF_LZOP_COMPR_HIGH(if (h->method == M_LZO1X_1_15))
653 wrk_mem = xzalloc(LZO1X_1_15_MEM_COMPRESS);
654 #if ENABLE_LZOP_COMPR_HIGH
655 else /* must be h->method == M_LZO1X_999 */
656 wrk_mem = xzalloc(LZO1X_999_MEM_COMPRESS);
660 unsigned src_len, dst_len;
663 uint32_t *wordptr = wordbuf;
666 l = full_read(0, b1, block_size);
667 src_len = (l > 0 ? l : 0);
669 /* write uncompressed block size */
670 /* exit if last block */
675 *wordptr++ = htonl(src_len);
677 /* compute checksum of uncompressed block */
678 if (h->flags32 & F_ADLER32_D)
679 d_adler32 = lzo_adler32(ADLER32_INIT_VALUE, b1, src_len);
680 if (h->flags32 & F_CRC32_D)
681 d_crc32 = lzo_crc32(CRC32_INIT_VALUE, b1, src_len);
684 if (h->method == M_LZO1X_1)
685 r = lzo1x_1_compress(b1, src_len, b2, &dst_len, wrk_mem);
686 else IF_LZOP_COMPR_HIGH(if (h->method == M_LZO1X_1_15))
687 r = lzo1x_1_15_compress(b1, src_len, b2, &dst_len, wrk_mem);
688 #if ENABLE_LZOP_COMPR_HIGH
689 else /* must be h->method == M_LZO1X_999 */
690 r = lzo1x_999_compress_level(b1, src_len, b2, &dst_len,
693 if (r != 0) /* not LZO_E_OK */
694 bb_error_msg_and_die("%s: %s", "internal error", "compression");
696 /* write compressed block size */
697 if (dst_len < src_len) {
699 if (h->method == M_LZO1X_999) {
700 unsigned new_len = src_len;
701 r = lzo1x_optimize(b2, dst_len, b1, &new_len /*, NULL*/);
702 if (r != 0 /*LZO_E_OK*/ || new_len != src_len)
703 bb_error_msg_and_die("%s: %s", "internal error", "optimization");
705 *wordptr++ = htonl(dst_len);
707 /* data actually expanded => store data uncompressed */
708 *wordptr++ = htonl(src_len);
711 /* write checksum of uncompressed block */
712 if (h->flags32 & F_ADLER32_D)
713 *wordptr++ = htonl(d_adler32);
714 if (h->flags32 & F_CRC32_D)
715 *wordptr++ = htonl(d_crc32);
717 if (dst_len < src_len) {
718 /* write checksum of compressed block */
719 if (h->flags32 & F_ADLER32_C)
720 *wordptr++ = htonl(lzo_adler32(ADLER32_INIT_VALUE, b2, dst_len));
721 if (h->flags32 & F_CRC32_C)
722 *wordptr++ = htonl(lzo_crc32(CRC32_INIT_VALUE, b2, dst_len));
724 xwrite(1, wordbuf, ((char*)wordptr) - ((char*)wordbuf));
725 if (dst_len < src_len) {
726 /* write compressed block data */
727 xwrite(1, b2, dst_len);
729 /* write uncompressed block data */
730 xwrite(1, b1, src_len);
732 // /* if full_read() was nevertheless "short", it was EOF */
733 // if (src_len < block_size)
743 static FAST_FUNC void lzo_check(
745 uint8_t* buf, unsigned len,
746 uint32_t FAST_FUNC (*fn)(uint32_t, const uint8_t*, unsigned),
749 /* This function, by having the same order of parameters
750 * as fn, and by being marked FAST_FUNC (same as fn),
751 * saves a dozen bytes of code.
753 uint32_t c = fn(init, buf, len);
755 bb_error_msg_and_die("checksum error");
758 /**********************************************************************/
760 /**********************************************************************/
761 // used to have "const header_t *h" parameter, but since it uses
762 // only flags32 field, changed to receive only that.
763 static NOINLINE int lzo_decompress(uint32_t h_flags32)
765 unsigned block_size = LZO_BLOCK_SIZE;
767 uint32_t src_len, dst_len;
768 uint32_t c_adler32 = ADLER32_INIT_VALUE;
769 uint32_t d_adler32 = ADLER32_INIT_VALUE;
770 uint32_t c_crc32 = CRC32_INIT_VALUE, d_crc32 = CRC32_INIT_VALUE;
772 uint32_t mcs_block_size = MAX_COMPRESSED_SIZE(block_size);
778 /* read uncompressed block size */
781 /* exit if last block */
785 /* error if split file */
786 if (dst_len == 0xffffffffL)
787 /* should not happen - not yet implemented */
788 bb_error_msg_and_die("this file is a split lzop file");
790 if (dst_len > MAX_BLOCK_SIZE)
791 bb_error_msg_and_die("corrupted data");
793 /* read compressed block size */
795 if (src_len <= 0 || src_len > dst_len)
796 bb_error_msg_and_die("corrupted data");
798 if (dst_len > block_size) {
803 block_size = dst_len;
804 mcs_block_size = MAX_COMPRESSED_SIZE(block_size);
807 /* read checksum of uncompressed block */
808 if (h_flags32 & F_ADLER32_D)
809 d_adler32 = read32();
810 if (h_flags32 & F_CRC32_D)
813 /* read checksum of compressed block */
814 if (src_len < dst_len) {
815 if (h_flags32 & F_ADLER32_C)
816 c_adler32 = read32();
817 if (h_flags32 & F_CRC32_C)
822 b2 = xzalloc(mcs_block_size);
823 /* read the block into the end of our buffer */
824 b1 = b2 + mcs_block_size - src_len;
825 xread(0, b1, src_len);
827 if (src_len < dst_len) {
828 unsigned d = dst_len;
830 if (!(option_mask32 & OPT_F)) {
831 /* verify checksum of compressed block */
832 if (h_flags32 & F_ADLER32_C)
833 lzo_check(ADLER32_INIT_VALUE,
835 lzo_adler32, c_adler32);
836 if (h_flags32 & F_CRC32_C)
837 lzo_check(CRC32_INIT_VALUE,
843 // if (option_mask32 & OPT_F)
844 // r = lzo1x_decompress(b1, src_len, b2, &d /*, NULL*/);
846 r = lzo1x_decompress_safe(b1, src_len, b2, &d /*, NULL*/);
848 if (r != 0 /*LZO_E_OK*/ || dst_len != d) {
849 bb_error_msg_and_die("corrupted data");
853 /* "stored" block => no decompression */
857 if (!(option_mask32 & OPT_F)) {
858 /* verify checksum of uncompressed block */
859 if (h_flags32 & F_ADLER32_D)
860 lzo_check(ADLER32_INIT_VALUE,
862 lzo_adler32, d_adler32);
863 if (h_flags32 & F_CRC32_D)
864 lzo_check(CRC32_INIT_VALUE,
869 /* write uncompressed block data */
870 xwrite(1, dst, dst_len);
877 /**********************************************************************/
878 // lzop file signature (shamelessly borrowed from PNG)
879 /**********************************************************************/
881 * The first nine bytes of a lzop file always contain the following values:
884 * --- --- --- --- --- --- --- --- ---
885 * (hex) 89 4c 5a 4f 00 0d 0a 1a 0a
886 * (decimal) 137 76 90 79 0 13 10 26 10
887 * (C notation - ASCII) \211 L Z O \0 \r \n \032 \n
890 /* (vda) comparison with lzop v1.02rc1 ("lzop -1 <FILE" cmd):
891 * Only slight differences in header:
892 * -00000000 89 4c 5a 4f 00 0d 0a 1a 0a 10 20 20 20 09 40 02
893 * +00000000 89 4c 5a 4f 00 0d 0a 1a 0a 10 10 20 30 09 40 02
895 * version lib_version
896 * -00000010 01 03 00 00 0d 00 00 81 a4 49 f7 a6 3f 00 00 00
897 * +00000010 01 03 00 00 01 00 00 00 00 00 00 00 00 00 00 00
898 * ^^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^
900 * -00000020 00 00 2d 67 04 17 00 04 00 00 00 03 ed ec 9d 6d
901 * +00000020 00 00 10 5f 00 c1 00 04 00 00 00 03 ed ec 9d 6d
904 * The rest is identical.
906 static const unsigned char lzop_magic[9] ALIGN1 = {
907 0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a
910 /* This coding is derived from Alexander Lehmann's pngcheck code. */
911 static void check_magic(void)
913 unsigned char magic[sizeof(lzop_magic)];
914 xread(0, magic, sizeof(magic));
915 if (memcmp(magic, lzop_magic, sizeof(lzop_magic)) != 0)
916 bb_error_msg_and_die("bad magic number");
919 /**********************************************************************/
921 /**********************************************************************/
922 static void write_header(header_t *h)
926 xwrite(1, lzop_magic, sizeof(lzop_magic));
930 /* Our caller leaves name zero-filled, so len == 0 */
931 end = h->len_and_name+1 + 0; /* 0 is strlen(h->len_and_name+1) */
932 /* Store length byte */
933 /*h->len_and_name[0] = end - (h->len_and_name+1); - zero already */
935 f_write(&h->version_be16, end - (char*)&h->version_be16);
937 h->flags32 = htonl(h->flags32); /* native endianness for lzo_compress() */
939 write32(chksum_getresult(h->flags32));
942 static int read_header(header_t *h)
946 /* As it stands now, only h->flags32 is used by our caller.
947 * Therefore we don't store many fields in h->FIELD.
950 unsigned h_version_needed_to_extract;
954 /* We don't support versions < 0.94, since 0.94
955 * came only 2 months after 0.90:
956 * 0.90 (10 Aug 1997): First public release of lzop
957 * 0.94 (15 Oct 1997): Header format change
960 /* Read up to and including name length byte */
961 f_read(&h->version_be16, ((char*)&h->len_and_name[1]) - ((char*)&h->version_be16));
963 h_version = htons(h->version_be16);
964 if (h_version < 0x0940)
966 h_version_needed_to_extract = htons(h->version_needed_to_extract_be16);
967 if (h_version_needed_to_extract > LZOP_VERSION)
969 if (h_version_needed_to_extract < 0x0940)
975 /* former lzo_get_method(h): */
976 if (h->method == M_LZO1X_1) {
979 } else if (h->method == M_LZO1X_1_15) {
982 } else if (h->method == M_LZO1X_999) {
986 return -1; /* not a LZO method */
987 /* check compression level */
988 if (h->level < 1 || h->level > 9)
991 h->flags32 = ntohl(h->flags32);
992 if (h->flags32 & F_H_FILTER)
993 return 16; /* filter not supported */
994 /* check reserved flags */
995 if (h->flags32 & F_RESERVED)
998 l = h->len_and_name[0];
1000 /* UNUSED */ f_read(h->len_and_name+1, l);
1001 /* UNUSED h->len_and_name[1+l] = 0; */
1003 checksum = chksum_getresult(h->flags32);
1004 if (read32() != checksum)
1007 /* skip extra field [not used yet] */
1008 if (h->flags32 & F_H_EXTRA_FIELD) {
1009 uint32_t extra_field_len;
1010 uint32_t extra_field_checksum;
1014 /* note: the checksum also covers the length */
1016 extra_field_len = f_read32();
1017 for (k = 0; k < extra_field_len; k++)
1019 checksum = chksum_getresult(h->flags32);
1020 extra_field_checksum = read32();
1021 if (extra_field_checksum != checksum)
1028 /**********************************************************************/
1030 /**********************************************************************/
1031 static void lzo_set_method(header_t *h)
1035 /* levels 2..6 or none (defaults to level 3) */
1036 h->method = M_LZO1X_1;
1037 level = 5; /* levels 2-6 are actually the same */
1039 if (option_mask32 & OPT_1) {
1040 h->method = M_LZO1X_1_15;
1043 if (option_mask32 & OPT_789) {
1044 #if ENABLE_LZOP_COMPR_HIGH
1045 h->method = M_LZO1X_999;
1047 if (option_mask32 & OPT_7)
1049 else if (option_mask32 & OPT_8)
1052 bb_error_msg_and_die("high compression not compiled in");
1059 static int do_lzo_compress(void)
1064 memset(h, 0, sizeof(*h));
1068 h->version_be16 = htons(LZOP_VERSION & 0xffff);
1069 h->version_needed_to_extract_be16 = htons(0x0940);
1070 h->lib_version_be16 = htons(lzo_version() & 0xffff);
1072 h->flags32 = htonl((F_OS & F_OS_MASK) | (F_CS & F_CS_MASK));
1074 if (!(option_mask32 & OPT_F) || h->method == M_LZO1X_999) {
1075 h->flags32 |= htonl(F_ADLER32_D);
1076 if (option_mask32 & OPT_C)
1077 h->flags32 |= htonl(F_ADLER32_C);
1080 /* write_header() also converts h->flags32 to native endianness */
1083 return lzo_compress(h);
1087 /**********************************************************************/
1089 /**********************************************************************/
1090 static int do_lzo_decompress(void)
1096 r = read_header(&header);
1098 bb_error_msg_and_die("header_error %d", r);
1099 return lzo_decompress(header.flags32);
1102 static char* FAST_FUNC make_new_name_lzop(char *filename, const char *expected_ext UNUSED_PARAM)
1104 if (option_mask32 & OPT_DECOMPRESS) {
1105 char *extension = strrchr(filename, '.');
1106 if (!extension || strcmp(extension + 1, "lzo") != 0)
1107 return xasprintf("%s.out", filename);
1111 return xasprintf("%s.lzo", filename);
1114 static IF_DESKTOP(long long) int FAST_FUNC pack_lzop(transformer_state_t *xstate UNUSED_PARAM)
1116 if (option_mask32 & OPT_DECOMPRESS)
1117 return do_lzo_decompress();
1118 return do_lzo_compress();
1121 int lzop_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1122 int lzop_main(int argc UNUSED_PARAM, char **argv)
1126 getopt32(argv, OPTION_STRING);
1128 /* -U is "anti -k", invert bit for bbunpack(): */
1129 option_mask32 ^= OPT_KEEP;
1130 /* -k disables -U (if any): */
1131 /* opt_complementary "k-U"? - nope, only handles -Uk, not -kU */
1132 if (option_mask32 & OPT_k)
1133 option_mask32 |= OPT_KEEP;
1136 if (ENABLE_LZOPCAT && applet_name[4] == 'c')
1137 option_mask32 |= (OPT_STDOUT | OPT_DECOMPRESS);
1139 if (ENABLE_UNLZOP && applet_name[4] == 'o')
1140 option_mask32 |= OPT_DECOMPRESS;
1142 global_crc32_new_table_le();
1143 return bbunpack(argv, pack_lzop, make_new_name_lzop, /*unused:*/ NULL);