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