summaryrefslogtreecommitdiff
path: root/archival/lzop.c (plain)
blob: 5062d9300c45f2f5975ddde9ec348e780b070b43
1/*
2 This file is part of the lzop file compressor.
3
4 Copyright (C) 1996..2003 Markus Franz Xaver Johannes Oberhumer
5 All Rights Reserved.
6
7 Markus F.X.J. Oberhumer <markus@oberhumer.com>
8 http://www.oberhumer.com/opensource/lzop/
9
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.
14
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.
19
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.
24
25 "Minimalized" for busybox by Alain Knaff
26*/
27
28//config:config LZOP
29//config: bool "lzop"
30//config: default y
31//config: help
32//config: Lzop compression/decompresion.
33//config:
34//config:config LZOP_COMPR_HIGH
35//config: bool "lzop compression levels 7,8,9 (not very useful)"
36//config: default n
37//config: depends on LZOP
38//config: help
39//config: High levels (7,8,9) of lzop compression. These levels
40//config: are actually slower than gzip at equivalent compression ratios
41//config: and take up 3.2K of code.
42
43//applet:IF_LZOP(APPLET(lzop, BB_DIR_BIN, BB_SUID_DROP))
44//applet:IF_LZOP(APPLET_ODDNAME(lzopcat, lzop, BB_DIR_USR_BIN, BB_SUID_DROP, lzopcat))
45//applet:IF_LZOP(APPLET_ODDNAME(unlzop, lzop, BB_DIR_USR_BIN, BB_SUID_DROP, unlzop))
46//kbuild:lib-$(CONFIG_LZOP) += lzop.o
47
48//usage:#define lzop_trivial_usage
49//usage: "[-cfvd123456789CF] [FILE]..."
50//usage:#define lzop_full_usage "\n\n"
51//usage: " -1..9 Compression level"
52//usage: "\n -d Decompress"
53//usage: "\n -c Write to stdout"
54//usage: "\n -f Force"
55//usage: "\n -v Verbose"
56//usage: "\n -F Don't store or verify checksum"
57//usage: "\n -C Also write checksum of compressed block"
58//usage:
59//usage:#define lzopcat_trivial_usage
60//usage: "[-vCF] [FILE]..."
61//usage:#define lzopcat_full_usage "\n\n"
62//usage: " -v Verbose"
63//usage: "\n -F Don't store or verify checksum"
64//usage:
65//usage:#define unlzop_trivial_usage
66//usage: "[-cfvCF] [FILE]..."
67//usage:#define unlzop_full_usage "\n\n"
68//usage: " -c Write to stdout"
69//usage: "\n -f Force"
70//usage: "\n -v Verbose"
71//usage: "\n -F Don't store or verify checksum"
72
73#include "libbb.h"
74#include "bb_archive.h"
75#include "liblzo_interface.h"
76
77/* lzo-2.03/src/lzo_ptr.h */
78#define pd(a,b) ((unsigned)((a)-(b)))
79
80#define lzo_version() LZO_VERSION
81#define lzo_sizeof_dict_t (sizeof(uint8_t*))
82
83/* lzo-2.03/include/lzo/lzo1x.h */
84#define LZO1X_1_MEM_COMPRESS (16384 * lzo_sizeof_dict_t)
85#define LZO1X_1_15_MEM_COMPRESS (32768 * lzo_sizeof_dict_t)
86#define LZO1X_999_MEM_COMPRESS (14 * 16384 * sizeof(short))
87
88/* lzo-2.03/src/lzo1x_oo.c */
89#define NO_LIT UINT_MAX
90
91/**********************************************************************/
92static void copy2(uint8_t* ip, const uint8_t* m_pos, unsigned off)
93{
94 ip[0] = m_pos[0];
95 if (off == 1)
96 ip[1] = m_pos[0];
97 else
98 ip[1] = m_pos[1];
99}
100
101static void copy3(uint8_t* ip, const uint8_t* m_pos, unsigned off)
102{
103 ip[0] = m_pos[0];
104 if (off == 1) {
105 ip[2] = ip[1] = m_pos[0];
106 }
107 else if (off == 2) {
108 ip[1] = m_pos[1];
109 ip[2] = m_pos[0];
110 }
111 else {
112 ip[1] = m_pos[1];
113 ip[2] = m_pos[2];
114 }
115}
116
117/**********************************************************************/
118// optimize a block of data.
119/**********************************************************************/
120#define TEST_IP (ip < ip_end)
121#define TEST_OP (op <= op_end)
122
123static NOINLINE int lzo1x_optimize(uint8_t *in, unsigned in_len,
124 uint8_t *out, unsigned *out_len,
125 void* wrkmem UNUSED_PARAM)
126{
127 uint8_t* op;
128 uint8_t* ip;
129 unsigned t;
130 uint8_t* m_pos;
131 uint8_t* const ip_end = in + in_len;
132 uint8_t* const op_end = out + *out_len;
133 uint8_t* litp = NULL;
134 unsigned lit = 0;
135 unsigned next_lit = NO_LIT;
136 unsigned nl;
137 unsigned long o_m1_a = 0, o_m1_b = 0, o_m2 = 0, o_m3_a = 0, o_m3_b = 0;
138
139// LZO_UNUSED(wrkmem);
140
141 *out_len = 0;
142
143 op = out;
144 ip = in;
145
146 if (*ip > 17) {
147 t = *ip++ - 17;
148 if (t < 4)
149 goto match_next;
150 goto first_literal_run;
151 }
152
153 while (TEST_IP && TEST_OP) {
154 t = *ip++;
155 if (t >= 16)
156 goto match;
157 /* a literal run */
158 litp = ip - 1;
159 if (t == 0) {
160 t = 15;
161 while (*ip == 0)
162 t += 255, ip++;
163 t += *ip++;
164 }
165 lit = t + 3;
166 /* copy literals */
167 copy_literal_run:
168 *op++ = *ip++;
169 *op++ = *ip++;
170 *op++ = *ip++;
171 first_literal_run:
172 do *op++ = *ip++; while (--t > 0);
173
174 t = *ip++;
175
176 if (t >= 16)
177 goto match;
178#if defined(LZO1X)
179 m_pos = op - 1 - 0x800;
180#elif defined(LZO1Y)
181 m_pos = op - 1 - 0x400;
182#endif
183 m_pos -= t >> 2;
184 m_pos -= *ip++ << 2;
185 *op++ = *m_pos++;
186 *op++ = *m_pos++;
187 *op++ = *m_pos++;
188 lit = 0;
189 goto match_done;
190
191
192 /* handle matches */
193 do {
194 if (t < 16) { /* a M1 match */
195 m_pos = op - 1;
196 m_pos -= t >> 2;
197 m_pos -= *ip++ << 2;
198
199 if (litp == NULL)
200 goto copy_m1;
201
202 nl = ip[-2] & 3;
203 /* test if a match follows */
204 if (nl == 0 && lit == 1 && ip[0] >= 16) {
205 next_lit = nl;
206 /* adjust length of previous short run */
207 lit += 2;
208 *litp = (unsigned char)((*litp & ~3) | lit);
209 /* copy over the 2 literals that replace the match */
210 copy2(ip-2, m_pos, pd(op, m_pos));
211 o_m1_a++;
212 }
213 /* test if a literal run follows */
214 else
215 if (nl == 0
216 && ip[0] < 16
217 && ip[0] != 0
218 && (lit + 2 + ip[0] < 16)
219 ) {
220 t = *ip++;
221 /* remove short run */
222 *litp &= ~3;
223 /* copy over the 2 literals that replace the match */
224 copy2(ip-3+1, m_pos, pd(op, m_pos));
225 /* move literals 1 byte ahead */
226 litp += 2;
227 if (lit > 0)
228 memmove(litp+1, litp, lit);
229 /* insert new length of long literal run */
230 lit += 2 + t + 3;
231 *litp = (unsigned char)(lit - 3);
232
233 o_m1_b++;
234 *op++ = *m_pos++;
235 *op++ = *m_pos++;
236 goto copy_literal_run;
237 }
238 copy_m1:
239 *op++ = *m_pos++;
240 *op++ = *m_pos++;
241 } else {
242 match:
243 if (t >= 64) { /* a M2 match */
244 m_pos = op - 1;
245#if defined(LZO1X)
246 m_pos -= (t >> 2) & 7;
247 m_pos -= *ip++ << 3;
248 t = (t >> 5) - 1;
249#elif defined(LZO1Y)
250 m_pos -= (t >> 2) & 3;
251 m_pos -= *ip++ << 2;
252 t = (t >> 4) - 3;
253#endif
254 if (litp == NULL)
255 goto copy_m;
256
257 nl = ip[-2] & 3;
258 /* test if in beetween two long literal runs */
259 if (t == 1 && lit > 3 && nl == 0
260 && ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16)
261 ) {
262 t = *ip++;
263 /* copy over the 3 literals that replace the match */
264 copy3(ip-1-2, m_pos, pd(op, m_pos));
265 /* set new length of previous literal run */
266 lit += 3 + t + 3;
267 *litp = (unsigned char)(lit - 3);
268 o_m2++;
269 *op++ = *m_pos++;
270 *op++ = *m_pos++;
271 *op++ = *m_pos++;
272 goto copy_literal_run;
273 }
274 } else {
275 if (t >= 32) { /* a M3 match */
276 t &= 31;
277 if (t == 0) {
278 t = 31;
279 while (*ip == 0)
280 t += 255, ip++;
281 t += *ip++;
282 }
283 m_pos = op - 1;
284 m_pos -= *ip++ >> 2;
285 m_pos -= *ip++ << 6;
286 } else { /* a M4 match */
287 m_pos = op;
288 m_pos -= (t & 8) << 11;
289 t &= 7;
290 if (t == 0) {
291 t = 7;
292 while (*ip == 0)
293 t += 255, ip++;
294 t += *ip++;
295 }
296 m_pos -= *ip++ >> 2;
297 m_pos -= *ip++ << 6;
298 if (m_pos == op)
299 goto eof_found;
300 m_pos -= 0x4000;
301 }
302 if (litp == NULL)
303 goto copy_m;
304
305 nl = ip[-2] & 3;
306 /* test if in beetween two matches */
307 if (t == 1 && lit == 0 && nl == 0 && ip[0] >= 16) {
308 next_lit = nl;
309 /* make a previous short run */
310 lit += 3;
311 *litp = (unsigned char)((*litp & ~3) | lit);
312 /* copy over the 3 literals that replace the match */
313 copy3(ip-3, m_pos, pd(op, m_pos));
314 o_m3_a++;
315 }
316 /* test if a literal run follows */
317 else if (t == 1 && lit <= 3 && nl == 0
318 && ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16)
319 ) {
320 t = *ip++;
321 /* remove short run */
322 *litp &= ~3;
323 /* copy over the 3 literals that replace the match */
324 copy3(ip-4+1, m_pos, pd(op, m_pos));
325 /* move literals 1 byte ahead */
326 litp += 2;
327 if (lit > 0)
328 memmove(litp+1,litp,lit);
329 /* insert new length of long literal run */
330 lit += 3 + t + 3;
331 *litp = (unsigned char)(lit - 3);
332
333 o_m3_b++;
334 *op++ = *m_pos++;
335 *op++ = *m_pos++;
336 *op++ = *m_pos++;
337 goto copy_literal_run;
338 }
339 }
340 copy_m:
341 *op++ = *m_pos++;
342 *op++ = *m_pos++;
343 do *op++ = *m_pos++; while (--t > 0);
344 }
345
346 match_done:
347 if (next_lit == NO_LIT) {
348 t = ip[-2] & 3;
349 lit = t;
350 litp = ip - 2;
351 }
352 else
353 t = next_lit;
354 next_lit = NO_LIT;
355 if (t == 0)
356 break;
357 /* copy literals */
358 match_next:
359 do *op++ = *ip++; while (--t > 0);
360 t = *ip++;
361 } while (TEST_IP && TEST_OP);
362 }
363
364 /* no EOF code was found */
365 *out_len = pd(op, out);
366 return LZO_E_EOF_NOT_FOUND;
367
368 eof_found:
369// LZO_UNUSED(o_m1_a); LZO_UNUSED(o_m1_b); LZO_UNUSED(o_m2);
370// LZO_UNUSED(o_m3_a); LZO_UNUSED(o_m3_b);
371 *out_len = pd(op, out);
372 return (ip == ip_end ? LZO_E_OK :
373 (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
374}
375
376/**********************************************************************/
377#define F_OS F_OS_UNIX
378#define F_CS F_CS_NATIVE
379
380/**********************************************************************/
381#define ADLER32_INIT_VALUE 1
382#define CRC32_INIT_VALUE 0
383
384/**********************************************************************/
385enum {
386 M_LZO1X_1 = 1,
387 M_LZO1X_1_15 = 2,
388 M_LZO1X_999 = 3,
389};
390
391/**********************************************************************/
392/* header flags */
393#define F_ADLER32_D 0x00000001L
394#define F_ADLER32_C 0x00000002L
395#define F_H_EXTRA_FIELD 0x00000040L
396#define F_H_GMTDIFF 0x00000080L
397#define F_CRC32_D 0x00000100L
398#define F_CRC32_C 0x00000200L
399#define F_H_FILTER 0x00000800L
400#define F_H_CRC32 0x00001000L
401#define F_MASK 0x00003FFFL
402
403/* operating system & file system that created the file [mostly unused] */
404#define F_OS_UNIX 0x03000000L
405#define F_OS_SHIFT 24
406#define F_OS_MASK 0xff000000L
407
408/* character set for file name encoding [mostly unused] */
409#define F_CS_NATIVE 0x00000000L
410#define F_CS_SHIFT 20
411#define F_CS_MASK 0x00f00000L
412
413/* these bits must be zero */
414#define F_RESERVED ((F_MASK | F_OS_MASK | F_CS_MASK) ^ 0xffffffffL)
415
416typedef struct chksum_t {
417 uint32_t f_adler32;
418 uint32_t f_crc32;
419} chksum_t;
420
421typedef struct header_t {
422 unsigned version;
423 unsigned lib_version;
424 unsigned version_needed_to_extract;
425 uint32_t flags;
426 uint32_t mode;
427 uint32_t mtime;
428 uint32_t gmtdiff;
429 uint32_t header_checksum;
430
431 uint32_t extra_field_len;
432 uint32_t extra_field_checksum;
433
434 unsigned char method;
435 unsigned char level;
436
437 /* info */
438 char name[255+1];
439} header_t;
440
441struct globals {
442 /*const uint32_t *lzo_crc32_table;*/
443 chksum_t chksum_in;
444 chksum_t chksum_out;
445} FIX_ALIASING;
446#define G (*(struct globals*)&bb_common_bufsiz1)
447#define INIT_G() do { } while (0)
448//#define G (*ptr_to_globals)
449//#define INIT_G() do {
450// SET_PTR_TO_GLOBALS(xzalloc(sizeof(G)));
451//} while (0)
452
453
454/**********************************************************************/
455#define LZOP_VERSION 0x1010
456//#define LZOP_VERSION_STRING "1.01"
457//#define LZOP_VERSION_DATE "Apr 27th 2003"
458
459#define OPTION_STRING "cfvqdt123456789CF"
460
461/* Note: must be kept in sync with archival/bbunzip.c */
462enum {
463 OPT_STDOUT = (1 << 0),
464 OPT_FORCE = (1 << 1),
465 OPT_VERBOSE = (1 << 2),
466 OPT_QUIET = (1 << 3),
467 OPT_DECOMPRESS = (1 << 4),
468 OPT_TEST = (1 << 5),
469 OPT_1 = (1 << 6),
470 OPT_2 = (1 << 7),
471 OPT_3 = (1 << 8),
472 OPT_4 = (1 << 9),
473 OPT_5 = (1 << 10),
474 OPT_6 = (1 << 11),
475 OPT_789 = (7 << 12),
476 OPT_7 = (1 << 13),
477 OPT_8 = (1 << 14),
478 OPT_C = (1 << 15),
479 OPT_F = (1 << 16),
480};
481
482/**********************************************************************/
483// adler32 checksum
484// adapted from free code by Mark Adler <madler@alumni.caltech.edu>
485// see http://www.zlib.org/
486/**********************************************************************/
487static FAST_FUNC uint32_t
488lzo_adler32(uint32_t adler, const uint8_t* buf, unsigned len)
489{
490 enum {
491 LZO_BASE = 65521, /* largest prime smaller than 65536 */
492 /* NMAX is the largest n such that
493 * 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
494 LZO_NMAX = 5552,
495 };
496 uint32_t s1 = adler & 0xffff;
497 uint32_t s2 = (adler >> 16) & 0xffff;
498 unsigned k;
499
500 if (buf == NULL)
501 return 1;
502
503 while (len > 0) {
504 k = len < LZO_NMAX ? (unsigned) len : LZO_NMAX;
505 len -= k;
506 if (k != 0) do {
507 s1 += *buf++;
508 s2 += s1;
509 } while (--k > 0);
510 s1 %= LZO_BASE;
511 s2 %= LZO_BASE;
512 }
513 return (s2 << 16) | s1;
514}
515
516static FAST_FUNC uint32_t
517lzo_crc32(uint32_t c, const uint8_t* buf, unsigned len)
518{
519 //if (buf == NULL) - impossible
520 // return 0;
521
522 return ~crc32_block_endian0(~c, buf, len, global_crc32_table);
523}
524
525/**********************************************************************/
526static void init_chksum(chksum_t *ct)
527{
528 ct->f_adler32 = ADLER32_INIT_VALUE;
529 ct->f_crc32 = CRC32_INIT_VALUE;
530}
531
532static void add_bytes_to_chksum(chksum_t *ct, const void* buf, int cnt)
533{
534 /* We need to handle the two checksums at once, because at the
535 * beginning of the header, we don't know yet which one we'll
536 * eventually need */
537 ct->f_adler32 = lzo_adler32(ct->f_adler32, (const uint8_t*)buf, cnt);
538 ct->f_crc32 = lzo_crc32(ct->f_crc32, (const uint8_t*)buf, cnt);
539}
540
541static uint32_t chksum_getresult(chksum_t *ct, const header_t *h)
542{
543 return (h->flags & F_H_CRC32) ? ct->f_crc32 : ct->f_adler32;
544}
545
546/**********************************************************************/
547static uint32_t read32(void)
548{
549 uint32_t v;
550 xread(0, &v, 4);
551 return ntohl(v);
552}
553
554static void write32(uint32_t v)
555{
556 v = htonl(v);
557 xwrite(1, &v, 4);
558}
559
560static void f_write(const void* buf, int cnt)
561{
562 xwrite(1, buf, cnt);
563 add_bytes_to_chksum(&G.chksum_out, buf, cnt);
564}
565
566static void f_read(void* buf, int cnt)
567{
568 xread(0, buf, cnt);
569 add_bytes_to_chksum(&G.chksum_in, buf, cnt);
570}
571
572static int f_read8(void)
573{
574 uint8_t v;
575 f_read(&v, 1);
576 return v;
577}
578
579static void f_write8(uint8_t v)
580{
581 f_write(&v, 1);
582}
583
584static unsigned f_read16(void)
585{
586 uint16_t v;
587 f_read(&v, 2);
588 return ntohs(v);
589}
590
591static void f_write16(uint16_t v)
592{
593 v = htons(v);
594 f_write(&v, 2);
595}
596
597static uint32_t f_read32(void)
598{
599 uint32_t v;
600 f_read(&v, 4);
601 return ntohl(v);
602}
603
604static void f_write32(uint32_t v)
605{
606 v = htonl(v);
607 f_write(&v, 4);
608}
609
610/**********************************************************************/
611static int lzo_get_method(header_t *h)
612{
613 /* check method */
614 if (h->method == M_LZO1X_1) {
615 if (h->level == 0)
616 h->level = 3;
617 } else if (h->method == M_LZO1X_1_15) {
618 if (h->level == 0)
619 h->level = 1;
620 } else if (h->method == M_LZO1X_999) {
621 if (h->level == 0)
622 h->level = 9;
623 } else
624 return -1; /* not a LZO method */
625
626 /* check compression level */
627 if (h->level < 1 || h->level > 9)
628 return 15;
629
630 return 0;
631}
632
633/**********************************************************************/
634#define LZO_BLOCK_SIZE (256 * 1024l)
635#define MAX_BLOCK_SIZE (64 * 1024l * 1024l) /* DO NOT CHANGE */
636
637/* LZO may expand uncompressible data by a small amount */
638#define MAX_COMPRESSED_SIZE(x) ((x) + (x) / 16 + 64 + 3)
639
640/**********************************************************************/
641// compress a file
642/**********************************************************************/
643static NOINLINE smallint lzo_compress(const header_t *h)
644{
645 unsigned block_size = LZO_BLOCK_SIZE;
646 int r = 0; /* LZO_E_OK */
647 uint8_t *const b1 = xzalloc(block_size);
648 uint8_t *const b2 = xzalloc(MAX_COMPRESSED_SIZE(block_size));
649 unsigned src_len = 0, dst_len = 0;
650 uint32_t d_adler32 = ADLER32_INIT_VALUE;
651 uint32_t d_crc32 = CRC32_INIT_VALUE;
652 int l;
653 smallint ok = 1;
654 uint8_t *wrk_mem = NULL;
655
656 if (h->method == M_LZO1X_1)
657 wrk_mem = xzalloc(LZO1X_1_MEM_COMPRESS);
658 else if (h->method == M_LZO1X_1_15)
659 wrk_mem = xzalloc(LZO1X_1_15_MEM_COMPRESS);
660 else if (h->method == M_LZO1X_999)
661 wrk_mem = xzalloc(LZO1X_999_MEM_COMPRESS);
662
663 for (;;) {
664 /* read a block */
665 l = full_read(0, b1, block_size);
666 src_len = (l > 0 ? l : 0);
667
668 /* write uncompressed block size */
669 write32(src_len);
670
671 /* exit if last block */
672 if (src_len == 0)
673 break;
674
675 /* compute checksum of uncompressed block */
676 if (h->flags & F_ADLER32_D)
677 d_adler32 = lzo_adler32(ADLER32_INIT_VALUE, b1, src_len);
678 if (h->flags & F_CRC32_D)
679 d_crc32 = lzo_crc32(CRC32_INIT_VALUE, b1, src_len);
680
681 /* compress */
682 if (h->method == M_LZO1X_1)
683 r = lzo1x_1_compress(b1, src_len, b2, &dst_len, wrk_mem);
684 else if (h->method == M_LZO1X_1_15)
685 r = lzo1x_1_15_compress(b1, src_len, b2, &dst_len, wrk_mem);
686#if ENABLE_LZOP_COMPR_HIGH
687 else if (h->method == M_LZO1X_999)
688 r = lzo1x_999_compress_level(b1, src_len, b2, &dst_len,
689 wrk_mem, h->level);
690#endif
691 else
692 bb_error_msg_and_die("internal error");
693
694 if (r != 0) /* not LZO_E_OK */
695 bb_error_msg_and_die("internal error - compression failed");
696
697 /* write compressed block size */
698 if (dst_len < src_len) {
699 /* optimize */
700 if (h->method == M_LZO1X_999) {
701 unsigned new_len = src_len;
702 r = lzo1x_optimize(b2, dst_len, b1, &new_len, NULL);
703 if (r != 0 /*LZO_E_OK*/ || new_len != src_len)
704 bb_error_msg_and_die("internal error - optimization failed");
705 }
706 write32(dst_len);
707 } else {
708 /* data actually expanded => store data uncompressed */
709 write32(src_len);
710 }
711
712 /* write checksum of uncompressed block */
713 if (h->flags & F_ADLER32_D)
714 write32(d_adler32);
715 if (h->flags & F_CRC32_D)
716 write32(d_crc32);
717
718 if (dst_len < src_len) {
719 /* write checksum of compressed block */
720 if (h->flags & F_ADLER32_C)
721 write32(lzo_adler32(ADLER32_INIT_VALUE, b2, dst_len));
722 if (h->flags & F_CRC32_C)
723 write32(lzo_crc32(CRC32_INIT_VALUE, b2, dst_len));
724 /* write compressed block data */
725 xwrite(1, b2, dst_len);
726 } else {
727 /* write uncompressed block data */
728 xwrite(1, b1, src_len);
729 }
730 }
731
732 free(wrk_mem);
733 free(b1);
734 free(b2);
735 return ok;
736}
737
738static FAST_FUNC void lzo_check(
739 uint32_t init,
740 uint8_t* buf, unsigned len,
741 uint32_t FAST_FUNC (*fn)(uint32_t, const uint8_t*, unsigned),
742 uint32_t ref)
743{
744 /* This function, by having the same order of parameters
745 * as fn, and by being marked FAST_FUNC (same as fn),
746 * saves a dozen bytes of code.
747 */
748 uint32_t c = fn(init, buf, len);
749 if (c != ref)
750 bb_error_msg_and_die("checksum error");
751}
752
753/**********************************************************************/
754// decompress a file
755/**********************************************************************/
756static NOINLINE smallint lzo_decompress(const header_t *h)
757{
758 unsigned block_size = LZO_BLOCK_SIZE;
759 int r;
760 uint32_t src_len, dst_len;
761 uint32_t c_adler32 = ADLER32_INIT_VALUE;
762 uint32_t d_adler32 = ADLER32_INIT_VALUE;
763 uint32_t c_crc32 = CRC32_INIT_VALUE, d_crc32 = CRC32_INIT_VALUE;
764 smallint ok = 1;
765 uint8_t *b1;
766 uint32_t mcs_block_size = MAX_COMPRESSED_SIZE(block_size);
767 uint8_t *b2 = NULL;
768
769 for (;;) {
770 uint8_t *dst;
771
772 /* read uncompressed block size */
773 dst_len = read32();
774
775 /* exit if last block */
776 if (dst_len == 0)
777 break;
778
779 /* error if split file */
780 if (dst_len == 0xffffffffL)
781 /* should not happen - not yet implemented */
782 bb_error_msg_and_die("this file is a split lzop file");
783
784 if (dst_len > MAX_BLOCK_SIZE)
785 bb_error_msg_and_die("corrupted data");
786
787 /* read compressed block size */
788 src_len = read32();
789 if (src_len <= 0 || src_len > dst_len)
790 bb_error_msg_and_die("corrupted data");
791
792 if (dst_len > block_size) {
793 if (b2) {
794 free(b2);
795 b2 = NULL;
796 }
797 block_size = dst_len;
798 mcs_block_size = MAX_COMPRESSED_SIZE(block_size);
799 }
800
801 /* read checksum of uncompressed block */
802 if (h->flags & F_ADLER32_D)
803 d_adler32 = read32();
804 if (h->flags & F_CRC32_D)
805 d_crc32 = read32();
806
807 /* read checksum of compressed block */
808 if (src_len < dst_len) {
809 if (h->flags & F_ADLER32_C)
810 c_adler32 = read32();
811 if (h->flags & F_CRC32_C)
812 c_crc32 = read32();
813 }
814
815 if (b2 == NULL)
816 b2 = xzalloc(mcs_block_size);
817 /* read the block into the end of our buffer */
818 b1 = b2 + mcs_block_size - src_len;
819 xread(0, b1, src_len);
820
821 if (src_len < dst_len) {
822 unsigned d = dst_len;
823
824 if (!(option_mask32 & OPT_F)) {
825 /* verify checksum of compressed block */
826 if (h->flags & F_ADLER32_C)
827 lzo_check(ADLER32_INIT_VALUE,
828 b1, src_len,
829 lzo_adler32, c_adler32);
830 if (h->flags & F_CRC32_C)
831 lzo_check(CRC32_INIT_VALUE,
832 b1, src_len,
833 lzo_crc32, c_crc32);
834 }
835
836 /* decompress */
837// if (option_mask32 & OPT_F)
838// r = lzo1x_decompress(b1, src_len, b2, &d, NULL);
839// else
840 r = lzo1x_decompress_safe(b1, src_len, b2, &d, NULL);
841
842 if (r != 0 /*LZO_E_OK*/ || dst_len != d) {
843 bb_error_msg_and_die("corrupted data");
844 }
845 dst = b2;
846 } else {
847 /* "stored" block => no decompression */
848 dst = b1;
849 }
850
851 if (!(option_mask32 & OPT_F)) {
852 /* verify checksum of uncompressed block */
853 if (h->flags & F_ADLER32_D)
854 lzo_check(ADLER32_INIT_VALUE,
855 dst, dst_len,
856 lzo_adler32, d_adler32);
857 if (h->flags & F_CRC32_D)
858 lzo_check(CRC32_INIT_VALUE,
859 dst, dst_len,
860 lzo_crc32, d_crc32);
861 }
862
863 /* write uncompressed block data */
864 xwrite(1, dst, dst_len);
865 }
866
867 free(b2);
868 return ok;
869}
870
871/**********************************************************************/
872// lzop file signature (shamelessly borrowed from PNG)
873/**********************************************************************/
874/*
875 * The first nine bytes of a lzop file always contain the following values:
876 *
877 * 0 1 2 3 4 5 6 7 8
878 * --- --- --- --- --- --- --- --- ---
879 * (hex) 89 4c 5a 4f 00 0d 0a 1a 0a
880 * (decimal) 137 76 90 79 0 13 10 26 10
881 * (C notation - ASCII) \211 L Z O \0 \r \n \032 \n
882 */
883
884/* (vda) comparison with lzop v1.02rc1 ("lzop -1 <FILE" cmd):
885 * Only slight differences in header:
886 * -00000000 89 4c 5a 4f 00 0d 0a 1a 0a 10 20 20 20 09 40 02
887 * +00000000 89 4c 5a 4f 00 0d 0a 1a 0a 10 10 20 30 09 40 02
888 * ^^^^^ ^^^^^
889 * version lib_version
890 * -00000010 01 03 00 00 0d 00 00 81 a4 49 f7 a6 3f 00 00 00
891 * +00000010 01 03 00 00 01 00 00 00 00 00 00 00 00 00 00 00
892 * ^^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^
893 * flags mode mtime
894 * -00000020 00 00 2d 67 04 17 00 04 00 00 00 03 ed ec 9d 6d
895 * +00000020 00 00 10 5f 00 c1 00 04 00 00 00 03 ed ec 9d 6d
896 * ^^^^^^^^^^^
897 * chksum_out
898 * The rest is identical.
899*/
900static const unsigned char lzop_magic[9] = {
901 0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a
902};
903
904/* This coding is derived from Alexander Lehmann's pngcheck code. */
905static void check_magic(void)
906{
907 unsigned char magic[sizeof(lzop_magic)];
908 xread(0, magic, sizeof(magic));
909 if (memcmp(magic, lzop_magic, sizeof(lzop_magic)) != 0)
910 bb_error_msg_and_die("bad magic number");
911}
912
913/**********************************************************************/
914// lzop file header
915/**********************************************************************/
916static void write_header(const header_t *h)
917{
918 int l;
919
920 xwrite(1, lzop_magic, sizeof(lzop_magic));
921
922 init_chksum(&G.chksum_out);
923
924 f_write16(h->version);
925 f_write16(h->lib_version);
926 f_write16(h->version_needed_to_extract);
927 f_write8(h->method);
928 f_write8(h->level);
929 f_write32(h->flags);
930 f_write32(h->mode);
931 f_write32(h->mtime);
932 f_write32(h->gmtdiff);
933
934 l = (int) strlen(h->name);
935 f_write8(l);
936 if (l)
937 f_write(h->name, l);
938
939 f_write32(chksum_getresult(&G.chksum_out, h));
940}
941
942static int read_header(header_t *h)
943{
944 int r;
945 int l;
946 uint32_t checksum;
947
948 memset(h, 0, sizeof(*h));
949 h->version_needed_to_extract = 0x0900; /* first lzop version */
950 h->level = 0;
951
952 init_chksum(&G.chksum_in);
953
954 h->version = f_read16();
955 if (h->version < 0x0900)
956 return 3;
957 h->lib_version = f_read16();
958 if (h->version >= 0x0940) {
959 h->version_needed_to_extract = f_read16();
960 if (h->version_needed_to_extract > LZOP_VERSION)
961 return 16;
962 if (h->version_needed_to_extract < 0x0900)
963 return 3;
964 }
965 h->method = f_read8();
966 if (h->version >= 0x0940)
967 h->level = f_read8();
968 h->flags = f_read32();
969 if (h->flags & F_H_FILTER)
970 return 16; /* filter not supported */
971 h->mode = f_read32();
972 h->mtime = f_read32();
973 if (h->version >= 0x0940)
974 h->gmtdiff = f_read32();
975
976 l = f_read8();
977 if (l > 0)
978 f_read(h->name, l);
979 h->name[l] = 0;
980
981 checksum = chksum_getresult(&G.chksum_in, h);
982 h->header_checksum = f_read32();
983 if (h->header_checksum != checksum)
984 return 2;
985
986 if (h->method <= 0)
987 return 14;
988 r = lzo_get_method(h);
989 if (r != 0)
990 return r;
991
992 /* check reserved flags */
993 if (h->flags & F_RESERVED)
994 return -13;
995
996 /* skip extra field [not used yet] */
997 if (h->flags & F_H_EXTRA_FIELD) {
998 uint32_t k;
999
1000 /* note: the checksum also covers the length */
1001 init_chksum(&G.chksum_in);
1002 h->extra_field_len = f_read32();
1003 for (k = 0; k < h->extra_field_len; k++)
1004 f_read8();
1005 checksum = chksum_getresult(&G.chksum_in, h);
1006 h->extra_field_checksum = f_read32();
1007 if (h->extra_field_checksum != checksum)
1008 return 3;
1009 }
1010
1011 return 0;
1012}
1013
1014static void p_header(header_t *h)
1015{
1016 int r;
1017
1018 r = read_header(h);
1019 if (r == 0)
1020 return;
1021 bb_error_msg_and_die("header_error %d", r);
1022}
1023
1024/**********************************************************************/
1025// compress
1026/**********************************************************************/
1027static void lzo_set_method(header_t *h)
1028{
1029 int level = 1;
1030
1031 if (option_mask32 & OPT_1) {
1032 h->method = M_LZO1X_1_15;
1033 } else if (option_mask32 & OPT_789) {
1034#if ENABLE_LZOP_COMPR_HIGH
1035 h->method = M_LZO1X_999;
1036 if (option_mask32 & OPT_7)
1037 level = 7;
1038 else if (option_mask32 & OPT_8)
1039 level = 8;
1040 else
1041 level = 9;
1042#else
1043 bb_error_msg_and_die("high compression not compiled in");
1044#endif
1045 } else { /* levels 2..6 or none (defaults to level 3) */
1046 h->method = M_LZO1X_1;
1047 level = 5; /* levels 2-6 are actually the same */
1048 }
1049
1050 h->level = level;
1051}
1052
1053static smallint do_lzo_compress(void)
1054{
1055 header_t header;
1056
1057#define h (&header)
1058 memset(h, 0, sizeof(*h));
1059
1060 lzo_set_method(h);
1061
1062 h->version = (LZOP_VERSION & 0xffff);
1063 h->version_needed_to_extract = 0x0940;
1064 h->lib_version = lzo_version() & 0xffff;
1065
1066 h->flags = (F_OS & F_OS_MASK) | (F_CS & F_CS_MASK);
1067
1068 if (!(option_mask32 & OPT_F) || h->method == M_LZO1X_999) {
1069 h->flags |= F_ADLER32_D;
1070 if (option_mask32 & OPT_C)
1071 h->flags |= F_ADLER32_C;
1072 }
1073 write_header(h);
1074 return lzo_compress(h);
1075#undef h
1076}
1077
1078/**********************************************************************/
1079// decompress
1080/**********************************************************************/
1081static smallint do_lzo_decompress(void)
1082{
1083 header_t header;
1084
1085 check_magic();
1086 p_header(&header);
1087 return lzo_decompress(&header);
1088}
1089
1090static char* FAST_FUNC make_new_name_lzop(char *filename, const char *expected_ext UNUSED_PARAM)
1091{
1092 if (option_mask32 & OPT_DECOMPRESS) {
1093 char *extension = strrchr(filename, '.');
1094 if (!extension || strcmp(extension + 1, "lzo") != 0)
1095 return xasprintf("%s.out", filename);
1096 *extension = '\0';
1097 return filename;
1098 }
1099 return xasprintf("%s.lzo", filename);
1100}
1101
1102static IF_DESKTOP(long long) int FAST_FUNC pack_lzop(transformer_aux_data_t *aux UNUSED_PARAM)
1103{
1104 if (option_mask32 & OPT_DECOMPRESS)
1105 return do_lzo_decompress();
1106 return do_lzo_compress();
1107}
1108
1109int lzop_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
1110int lzop_main(int argc UNUSED_PARAM, char **argv)
1111{
1112 getopt32(argv, OPTION_STRING);
1113 argv += optind;
1114 /* lzopcat? */
1115 if (applet_name[4] == 'c')
1116 option_mask32 |= (OPT_STDOUT | OPT_DECOMPRESS);
1117 /* unlzop? */
1118 if (applet_name[4] == 'o')
1119 option_mask32 |= OPT_DECOMPRESS;
1120
1121 global_crc32_table = crc32_filltable(NULL, 0);
1122 return bbunpack(argv, pack_lzop, make_new_name_lzop, /*unused:*/ NULL);
1123}
1124
generated by cgit at 2024-05-15 03:10:32 (GMT)