source: branches/3.2/mindi-busybox/archival/lzop.c @ 3232

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