/*
   This file is part of the lzop file compressor.

   Copyright (C) 1996..2003 Markus Franz Xaver Johannes Oberhumer
   All Rights Reserved.

   Markus F.X.J. Oberhumer <markus@oberhumer.com>
   http://www.oberhumer.com/opensource/lzop/

   lzop and the LZO library are free software; you can redistribute them
   and/or modify them under the terms of the GNU General Public License as
   published by the Free Software Foundation; either version 2 of
   the License, or (at your option) any later version.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
   GNU General Public License for more details.

   You should have received a copy of the GNU General Public License
   along with this program; see the file COPYING.
   If not, write to the Free Software Foundation, Inc.,
   59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.

   "Minimalized" for busybox by Alain Knaff
*/
//config:config LZOP
//config:       bool "lzop (12 kb)"
//config:       default y
//config:       help
//config:       Lzop compression/decompresion.
//config:
//config:config UNLZOP
//config:       bool "unlzop (13 kb)"
//config:       default n  # INCOMPAT: upstream lzop does not provide such tool
//config:       help
//config:       Lzop decompresion.
//config:
//config:config LZOPCAT
//config:       bool "lzopcat (13 kb)"
//config:       default n  # INCOMPAT: upstream lzop does not provide such tool
//config:       help
//config:       Alias to "lzop -dc".
//config:
//config:config LZOP_COMPR_HIGH
//config:       bool "lzop compression levels 7,8,9 (not very useful)"
//config:       default n
//config:       depends on LZOP || UNLZOP || LZOPCAT
//config:       help
//config:       High levels (7,8,9) of lzop compression. These levels
//config:       are actually slower than gzip at equivalent compression ratios
//config:       and take up 3.2K of code.

//applet:IF_LZOP(APPLET(lzop, BB_DIR_BIN, BB_SUID_DROP))
//                  APPLET_ODDNAME:name     main  location        suid_type     help
//applet:IF_UNLZOP( APPLET_ODDNAME(unlzop,  lzop, BB_DIR_USR_BIN, BB_SUID_DROP, unlzop))
//applet:IF_LZOPCAT(APPLET_ODDNAME(lzopcat, lzop, BB_DIR_USR_BIN, BB_SUID_DROP, lzopcat))

//kbuild:lib-$(CONFIG_LZOP) += lzop.o
//kbuild:lib-$(CONFIG_UNLZOP) += lzop.o
//kbuild:lib-$(CONFIG_LZOPCAT) += lzop.o

//usage:#define lzop_trivial_usage
//usage:       "[-cfUvd123456789CF] [FILE]..."
//usage:#define lzop_full_usage "\n\n"
//usage:       "        -1..9   Compression level"
//usage:     "\n        -d      Decompress"
//usage:     "\n        -c      Write to stdout"
//usage:     "\n        -f      Force"
//usage:     "\n        -U      Delete input files"
///////:     "\n        -k      Keep input files" (default, so why bother documenting?)
//usage:     "\n        -v      Verbose"
//usage:     "\n        -F      Don't store or verify checksum"
//usage:     "\n        -C      Also write checksum of compressed block"
//usage:
//usage:#define lzopcat_trivial_usage
//usage:       "[-vF] [FILE]..."
//usage:#define lzopcat_full_usage "\n\n"
//usage:       "        -v      Verbose"
//usage:     "\n        -F      Don't verify checksum"
//usage:
//usage:#define unlzop_trivial_usage
//usage:       "[-cfUvF] [FILE]..."
//usage:#define unlzop_full_usage "\n\n"
//usage:       "        -c      Write to stdout"
//usage:     "\n        -f      Force"
//usage:     "\n        -U      Delete input files"
///////:     "\n        -k      Keep input files" (default, so why bother documenting?)
//usage:     "\n        -t      Test integrity"
//usage:     "\n        -v      Verbose"
//usage:     "\n        -F      Don't verify checksum"

#include "libbb.h"
#include "common_bufsiz.h"
#include "bb_archive.h"
#include "liblzo_interface.h"

/* lzo-2.03/src/lzo_ptr.h */
#define pd(a,b)  ((unsigned)((a)-(b)))

#define lzo_version()                   LZO_VERSION
#define lzo_sizeof_dict_t               (sizeof(uint8_t*))

/* lzo-2.03/include/lzo/lzo1x.h */
#define LZO1X_1_MEM_COMPRESS    (16384 * lzo_sizeof_dict_t)
#define LZO1X_1_15_MEM_COMPRESS (32768 * lzo_sizeof_dict_t)
#define LZO1X_999_MEM_COMPRESS  (14 * 16384 * sizeof(short))

/* lzo-2.03/src/lzo1x_oo.c */
#define NO_LIT UINT_MAX

/**********************************************************************/
static void copy2(uint8_t* ip, const uint8_t* m_pos, unsigned off)
{
        ip[0] = m_pos[0];
        if (off == 1)
                ip[1] = m_pos[0];
        else
                ip[1] = m_pos[1];
}

static void copy3(uint8_t* ip, const uint8_t* m_pos, unsigned off)
{
        ip[0] = m_pos[0];
        if (off == 1) {
                ip[2] = ip[1] = m_pos[0];
        }
        else if (off == 2) {
                ip[1] = m_pos[1];
                ip[2] = m_pos[0];
        }
        else {
                ip[1] = m_pos[1];
                ip[2] = m_pos[2];
        }
}

/**********************************************************************/
// optimize a block of data.
/**********************************************************************/
#define TEST_IP         (ip < ip_end)
#define TEST_OP         (op <= op_end)

static NOINLINE int lzo1x_optimize(uint8_t *in, unsigned in_len,
                uint8_t *out, unsigned *out_len /*, void* wrkmem */)
{
        uint8_t* op;
        uint8_t* ip;
        unsigned t;
        uint8_t* m_pos;
        uint8_t* const ip_end = in + in_len;
        uint8_t* const op_end = out + *out_len;
        uint8_t* litp = NULL;
        unsigned lit = 0;
        unsigned next_lit = NO_LIT;
        unsigned nl;
        unsigned long o_m1_a = 0, o_m1_b = 0, o_m2 = 0, o_m3_a = 0, o_m3_b = 0;

//      LZO_UNUSED(wrkmem);

        *out_len = 0;

        op = out;
        ip = in;

        if (*ip > 17) {
                t = *ip++ - 17;
                if (t < 4)
                        goto match_next;
                goto first_literal_run;
        }

        while (TEST_IP && TEST_OP) {
                t = *ip++;
                if (t >= 16)
                        goto match;
                /* a literal run */
                litp = ip - 1;
                if (t == 0) {
                        t = 15;
                        while (*ip == 0)
                                t += 255, ip++;
                        t += *ip++;
                }
                lit = t + 3;
                /* copy literals */
 copy_literal_run:
                *op++ = *ip++;
                *op++ = *ip++;
                *op++ = *ip++;
 first_literal_run:
                do *op++ = *ip++; while (--t > 0);

                t = *ip++;

                if (t >= 16)
                        goto match;
#if defined(LZO1X)
                m_pos = op - 1 - 0x800;
#elif defined(LZO1Y)
                m_pos = op - 1 - 0x400;
#endif
                m_pos -= t >> 2;
                m_pos -= *ip++ << 2;
                *op++ = *m_pos++;
                *op++ = *m_pos++;
                *op++ = *m_pos++;
                lit = 0;
                goto match_done;


                /* handle matches */
                do {
                        if (t < 16) { /* a M1 match */
                                m_pos = op - 1;
                                m_pos -= t >> 2;
                                m_pos -= *ip++ << 2;

                                if (litp == NULL)
                                        goto copy_m1;

                                nl = ip[-2] & 3;
                                /* test if a match follows */
                                if (nl == 0 && lit == 1 && ip[0] >= 16) {
                                        next_lit = nl;
                                        /* adjust length of previous short run */
                                        lit += 2;
                                        *litp = (unsigned char)((*litp & ~3) | lit);
                                        /* copy over the 2 literals that replace the match */
                                        copy2(ip-2, m_pos, pd(op, m_pos));
                                        o_m1_a++;
                                }
                                /* test if a literal run follows */
                                else
                                if (nl == 0
                                 && ip[0] < 16
                                 && ip[0] != 0
                                 && (lit + 2 + ip[0] < 16)
                                ) {
                                        t = *ip++;
                                        /* remove short run */
                                        *litp &= ~3;
                                        /* copy over the 2 literals that replace the match */
                                        copy2(ip-3+1, m_pos, pd(op, m_pos));
                                        /* move literals 1 byte ahead */
                                        litp += 2;
                                        if (lit > 0)
                                                memmove(litp+1, litp, lit);
                                        /* insert new length of long literal run */
                                        lit += 2 + t + 3;
                                        *litp = (unsigned char)(lit - 3);

                                        o_m1_b++;
                                        *op++ = *m_pos++;
                                        *op++ = *m_pos++;
                                        goto copy_literal_run;
                                }
 copy_m1:
                                *op++ = *m_pos++;
                                *op++ = *m_pos++;
                        } else {
 match:
                                if (t >= 64) {                          /* a M2 match */
                                        m_pos = op - 1;
#if defined(LZO1X)
                                        m_pos -= (t >> 2) & 7;
                                        m_pos -= *ip++ << 3;
                                        t = (t >> 5) - 1;
#elif defined(LZO1Y)
                                        m_pos -= (t >> 2) & 3;
                                        m_pos -= *ip++ << 2;
                                        t = (t >> 4) - 3;
#endif
                                        if (litp == NULL)
                                                goto copy_m;

                                        nl = ip[-2] & 3;
                                        /* test if in beetween two long literal runs */
                                        if (t == 1 && lit > 3 && nl == 0
                                         && ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16)
                                        ) {
                                                t = *ip++;
                                                /* copy over the 3 literals that replace the match */
                                                copy3(ip-1-2, m_pos, pd(op, m_pos));
                                                /* set new length of previous literal run */
                                                lit += 3 + t + 3;
                                                *litp = (unsigned char)(lit - 3);
                                                o_m2++;
                                                *op++ = *m_pos++;
                                                *op++ = *m_pos++;
                                                *op++ = *m_pos++;
                                                goto copy_literal_run;
                                        }
                                } else {
                                        if (t >= 32) {                  /* a M3 match */
                                                t &= 31;
                                                if (t == 0) {
                                                        t = 31;
                                                        while (*ip == 0)
                                                                t += 255, ip++;
                                                        t += *ip++;
                                                }
                                                m_pos = op - 1;
                                                m_pos -= *ip++ >> 2;
                                                m_pos -= *ip++ << 6;
                                        } else {                                        /* a M4 match */
                                                m_pos = op;
                                                m_pos -= (t & 8) << 11;
                                                t &= 7;
                                                if (t == 0) {
                                                        t = 7;
                                                        while (*ip == 0)
                                                                t += 255, ip++;
                                                        t += *ip++;
                                                }
                                                m_pos -= *ip++ >> 2;
                                                m_pos -= *ip++ << 6;
                                                if (m_pos == op)
                                                        goto eof_found;
                                                m_pos -= 0x4000;
                                        }
                                        if (litp == NULL)
                                                goto copy_m;

                                        nl = ip[-2] & 3;
                                        /* test if in beetween two matches */
                                        if (t == 1 && lit == 0 && nl == 0 && ip[0] >= 16) {
                                                next_lit = nl;
                                                /* make a previous short run */
                                                lit += 3;
                                                *litp = (unsigned char)((*litp & ~3) | lit);
                                                /* copy over the 3 literals that replace the match */
                                                copy3(ip-3, m_pos, pd(op, m_pos));
                                                o_m3_a++;
                                        }
                                        /* test if a literal run follows */
                                        else if (t == 1 && lit <= 3 && nl == 0
                                         && ip[0] < 16 && ip[0] != 0 && (lit + 3 + ip[0] < 16)
                                        ) {
                                                t = *ip++;
                                                /* remove short run */
                                                *litp &= ~3;
                                                /* copy over the 3 literals that replace the match */
                                                copy3(ip-4+1, m_pos, pd(op, m_pos));
                                                /* move literals 1 byte ahead */
                                                litp += 2;
                                                if (lit > 0)
                                                        memmove(litp+1,litp,lit);
                                                /* insert new length of long literal run */
                                                lit += 3 + t + 3;
                                                *litp = (unsigned char)(lit - 3);

                                                o_m3_b++;
                                                *op++ = *m_pos++;
                                                *op++ = *m_pos++;
                                                *op++ = *m_pos++;
                                                goto copy_literal_run;
                                        }
                                }
 copy_m:
                                *op++ = *m_pos++;
                                *op++ = *m_pos++;
                                do *op++ = *m_pos++; while (--t > 0);
                        }

 match_done:
                        if (next_lit == NO_LIT) {
                                t = ip[-2] & 3;
                                lit = t;
                                litp = ip - 2;
                        }
                        else
                                t = next_lit;
                        next_lit = NO_LIT;
                        if (t == 0)
                                break;
                        /* copy literals */
 match_next:
                        do *op++ = *ip++; while (--t > 0);
                        t = *ip++;
                } while (TEST_IP && TEST_OP);
        }

        /* no EOF code was found */
        *out_len = pd(op, out);
        return LZO_E_EOF_NOT_FOUND;

 eof_found:
//      LZO_UNUSED(o_m1_a); LZO_UNUSED(o_m1_b); LZO_UNUSED(o_m2);
//      LZO_UNUSED(o_m3_a); LZO_UNUSED(o_m3_b);
        *out_len = pd(op, out);
        return (ip == ip_end ? LZO_E_OK :
                (ip < ip_end ? LZO_E_INPUT_NOT_CONSUMED : LZO_E_INPUT_OVERRUN));
}

/**********************************************************************/
#define F_OS F_OS_UNIX
#define F_CS F_CS_NATIVE

/**********************************************************************/
#define ADLER32_INIT_VALUE 1
#define CRC32_INIT_VALUE   0

/**********************************************************************/
enum {
        M_LZO1X_1    = 1,
        M_LZO1X_1_15 = 2,
        M_LZO1X_999  = 3,
};

/**********************************************************************/
/* header flags */
#define F_ADLER32_D     0x00000001L
#define F_ADLER32_C     0x00000002L
#define F_H_EXTRA_FIELD 0x00000040L
#define F_H_GMTDIFF     0x00000080L
#define F_CRC32_D       0x00000100L
#define F_CRC32_C       0x00000200L
#define F_H_FILTER      0x00000800L
#define F_H_CRC32       0x00001000L
#define F_MASK          0x00003FFFL

/* operating system & file system that created the file [mostly unused] */
#define F_OS_UNIX       0x03000000L
#define F_OS_SHIFT      24
#define F_OS_MASK       0xff000000L

/* character set for file name encoding [mostly unused] */
#define F_CS_NATIVE     0x00000000L
#define F_CS_SHIFT      20
#define F_CS_MASK       0x00f00000L

/* these bits must be zero */
#define F_RESERVED      ((F_MASK | F_OS_MASK | F_CS_MASK) ^ 0xffffffffL)

typedef struct chksum_t {
        uint32_t f_adler32;
        uint32_t f_crc32;
} chksum_t;

typedef struct header_t {
        /* used to have auxiliary fields here */

        /* Starting from here, the layout and endianness
         * are exactly in on-disk format.
         */
        uint16_t version_be16;
        uint16_t lib_version_be16;
        uint16_t version_needed_to_extract_be16;
        uint8_t  method;
        uint8_t  level;
        uint32_t flags32; /* be32 on disk, but we keep this field in native order */
        uint32_t mode_be32;
        uint32_t mtime_be32;
        uint32_t gmtdiff_be32;
        char     len_and_name[1+255+1];
} header_t;

struct globals {
        /*const uint32_t *lzo_crc32_table;*/
        chksum_t chksum;
} FIX_ALIASING;
#define G (*(struct globals*)bb_common_bufsiz1)
//#define G (*ptr_to_globals)
#define INIT_G() do { \
        setup_common_bufsiz(); \
        /*SET_PTR_TO_GLOBALS(xzalloc(sizeof(G)));*/ \
} while (0)


/**********************************************************************/
#define LZOP_VERSION            0x1010
//#define LZOP_VERSION_STRING     "1.01"
//#define LZOP_VERSION_DATE       "Apr 27th 2003"

// lzop wants to be weird:
// unlike all other compressosrs, its -k "keep" option is the default,
// and -U is used to delete the source. We will invert the bit after getopt().
#define OPTION_STRING "cfUvqdt123456789CFk"

/* Note: must be kept in sync with archival/bbunzip.c */
enum {
        OPT_STDOUT      = (1 << 0),
        OPT_FORCE       = (1 << 1),
        OPT_KEEP        = (1 << 2),
        OPT_VERBOSE     = (1 << 3),
        OPT_QUIET       = (1 << 4),
        OPT_DECOMPRESS  = (1 << 5),
        OPT_TEST        = (1 << 6),
        OPT_1           = (1 << 7),
        OPT_2           = (1 << 8),
        OPT_3           = (1 << 9),
        OPT_4           = (1 << 10),
        OPT_5           = (1 << 11),
        OPT_6           = (1 << 12),
        OPT_7           = (1 << 13),
        OPT_8           = (1 << 14),
        OPT_9           = (1 << 15),
        OPT_C           = (1 << 16),
        OPT_F           = (1 << 17),
        OPT_k           = (1 << 18),
        OPT_789         = OPT_7 | OPT_8 | OPT_9
};

/**********************************************************************/
// adler32 checksum
// adapted from free code by Mark Adler <madler@alumni.caltech.edu>
// see http://www.zlib.org/
/**********************************************************************/
static FAST_FUNC uint32_t
lzo_adler32(uint32_t adler, const uint8_t* buf, unsigned len)
{
        enum {
                LZO_BASE = 65521, /* largest prime smaller than 65536 */
                /* NMAX is the largest n such that
                 * 255n(n+1)/2 + (n+1)(BASE-1) <= 2^32-1 */
                LZO_NMAX = 5552,
        };
        uint32_t s1 = adler & 0xffff;
        uint32_t s2 = (adler >> 16) & 0xffff;
        unsigned k;

        if (buf == NULL)
                return 1;

        while (len > 0) {
                k = len < LZO_NMAX ? (unsigned) len : LZO_NMAX;
                len -= k;
                if (k != 0) do {
                        s1 += *buf++;
                        s2 += s1;
                } while (--k > 0);
                s1 %= LZO_BASE;
                s2 %= LZO_BASE;
        }
        return (s2 << 16) | s1;
}

static FAST_FUNC uint32_t
lzo_crc32(uint32_t c, const uint8_t* buf, unsigned len)
{
        //if (buf == NULL) - impossible
        //      return 0;

        return ~crc32_block_endian0(~c, buf, len, global_crc32_table);
}

/**********************************************************************/
static void init_chksum(void)
{
        G.chksum.f_adler32 = ADLER32_INIT_VALUE;
        G.chksum.f_crc32 = CRC32_INIT_VALUE;
}

static void add_bytes_to_chksum(const void* buf, int cnt)
{
        /* We need to handle the two checksums at once, because at the
         * beginning of the header, we don't know yet which one we'll
         * eventually need */
        G.chksum.f_adler32 = lzo_adler32(G.chksum.f_adler32, (const uint8_t*)buf, cnt);
        G.chksum.f_crc32 = lzo_crc32(G.chksum.f_crc32, (const uint8_t*)buf, cnt);
}

static uint32_t chksum_getresult(uint32_t h_flags32)
{
        return (h_flags32 & F_H_CRC32) ? G.chksum.f_crc32 : G.chksum.f_adler32;
}

/**********************************************************************/
static uint32_t read32(void)
{
        uint32_t v;
        xread(0, &v, 4);
        return ntohl(v);
}
static void f_read(void* buf, int cnt)
{
        xread(0, buf, cnt);
        add_bytes_to_chksum(buf, cnt);
}
//static int f_read8(void)
//{
//      uint8_t v;
//      f_read(&v, 1);
//      return v;
//}
//static unsigned f_read16(void)
//{
//      uint16_t v;
//      f_read(&v, 2);
//      return ntohs(v);
//}
static uint32_t f_read32(void)
{
        uint32_t v;
        f_read(&v, 4);
        return ntohl(v);
}

static void write32(uint32_t v)
{
        v = htonl(v);
        xwrite(1, &v, 4);
}
static void f_write(const void* buf, int cnt)
{
        xwrite(1, buf, cnt);
        add_bytes_to_chksum(buf, cnt);
}
//static void f_write8(uint8_t v)
//{
//      f_write(&v, 1);
//}
//static void f_write16(uint16_t v)
//{
//      v = htons(v);
//      f_write(&v, 2);
//}
//static void f_write32(uint32_t v)
//{
//      v = htonl(v);
//      f_write(&v, 4);
//}

/**********************************************************************/
#define LZO_BLOCK_SIZE  (256 * 1024l)
#define MAX_BLOCK_SIZE  (64 * 1024l * 1024l)    /* DO NOT CHANGE */

/* LZO may expand uncompressible data by a small amount */
#define MAX_COMPRESSED_SIZE(x)  ((x) + (x) / 16 + 64 + 3)

/**********************************************************************/
// compress a file
/**********************************************************************/
static NOINLINE int lzo_compress(const header_t *h)
{
        unsigned block_size = LZO_BLOCK_SIZE;
        int r = 0; /* LZO_E_OK */
        uint8_t *const b1 = xzalloc(block_size);
        uint8_t *const b2 = xzalloc(MAX_COMPRESSED_SIZE(block_size));
        uint32_t d_adler32 = ADLER32_INIT_VALUE;
        uint32_t d_crc32 = CRC32_INIT_VALUE;
        uint8_t *wrk_mem = NULL;

        /* Only these methods are possible, see lzo_set_method():
         * -1:    M_LZO1X_1_15
         * -2..6: M_LZO1X_1
         * -7..9: M_LZO1X_999 if ENABLE_LZOP_COMPR_HIGH
         */
        if (h->method == M_LZO1X_1)
                wrk_mem = xzalloc(LZO1X_1_MEM_COMPRESS);
        else /* check only if it's not the only possibility */
                IF_LZOP_COMPR_HIGH(if (h->method == M_LZO1X_1_15))
                        wrk_mem = xzalloc(LZO1X_1_15_MEM_COMPRESS);
#if ENABLE_LZOP_COMPR_HIGH
        else /* must be h->method == M_LZO1X_999 */
                wrk_mem = xzalloc(LZO1X_999_MEM_COMPRESS);
#endif

        for (;;) {
                unsigned src_len, dst_len;
                int l;
                uint32_t wordbuf[6];
                uint32_t *wordptr = wordbuf;

                /* read a block */
                l = full_read(0, b1, block_size);
                src_len = (l > 0 ? l : 0);

                /* write uncompressed block size */
                /* exit if last block */
                if (src_len == 0) {
                        write32(0);
                        break;
                }
                *wordptr++ = htonl(src_len);

                /* compute checksum of uncompressed block */
                if (h->flags32 & F_ADLER32_D)
                        d_adler32 = lzo_adler32(ADLER32_INIT_VALUE, b1, src_len);
                if (h->flags32 & F_CRC32_D)
                        d_crc32 = lzo_crc32(CRC32_INIT_VALUE, b1, src_len);

                /* compress */
                if (h->method == M_LZO1X_1)
                        r = lzo1x_1_compress(b1, src_len, b2, &dst_len, wrk_mem);
                else IF_LZOP_COMPR_HIGH(if (h->method == M_LZO1X_1_15))
                        r = lzo1x_1_15_compress(b1, src_len, b2, &dst_len, wrk_mem);
#if ENABLE_LZOP_COMPR_HIGH
                else /* must be h->method == M_LZO1X_999 */
                        r = lzo1x_999_compress_level(b1, src_len, b2, &dst_len,
                                                wrk_mem, h->level);
#endif
                if (r != 0) /* not LZO_E_OK */
                        bb_error_msg_and_die("%s: %s", "internal error", "compression");

                /* write compressed block size */
                if (dst_len < src_len) {
                        /* optimize */
                        if (h->method == M_LZO1X_999) {
                                unsigned new_len = src_len;
                                r = lzo1x_optimize(b2, dst_len, b1, &new_len /*, NULL*/);
                                if (r != 0 /*LZO_E_OK*/ || new_len != src_len)
                                        bb_error_msg_and_die("%s: %s", "internal error", "optimization");
                        }
                        *wordptr++ = htonl(dst_len);
                } else {
                        /* data actually expanded => store data uncompressed */
                        *wordptr++ = htonl(src_len);
                }

                /* write checksum of uncompressed block */
                if (h->flags32 & F_ADLER32_D)
                        *wordptr++ = htonl(d_adler32);
                if (h->flags32 & F_CRC32_D)
                        *wordptr++ = htonl(d_crc32);

                if (dst_len < src_len) {
                        /* write checksum of compressed block */
                        if (h->flags32 & F_ADLER32_C)
                                *wordptr++ = htonl(lzo_adler32(ADLER32_INIT_VALUE, b2, dst_len));
                        if (h->flags32 & F_CRC32_C)
                                *wordptr++ = htonl(lzo_crc32(CRC32_INIT_VALUE, b2, dst_len));
                }
                xwrite(1, wordbuf, ((char*)wordptr) - ((char*)wordbuf));
                if (dst_len < src_len) {
                        /* write compressed block data */
                        xwrite(1, b2, dst_len);
                } else {
                        /* write uncompressed block data */
                        xwrite(1, b1, src_len);
                }
                // /* if full_read() was nevertheless "short", it was EOF */
                // if (src_len < block_size)
                //      break;
        }

        free(wrk_mem);
        free(b1);
        free(b2);
        return 1;
}

static FAST_FUNC void lzo_check(
                uint32_t init,
                uint8_t* buf, unsigned len,
                uint32_t FAST_FUNC (*fn)(uint32_t, const uint8_t*, unsigned),
                uint32_t ref)
{
        /* This function, by having the same order of parameters
         * as fn, and by being marked FAST_FUNC (same as fn),
         * saves a dozen bytes of code.
         */
        uint32_t c = fn(init, buf, len);
        if (c != ref)
                bb_simple_error_msg_and_die("checksum error");
}

/**********************************************************************/
// decompress a file
/**********************************************************************/
// used to have "const header_t *h" parameter, but since it uses
// only flags32 field, changed to receive only that.
static NOINLINE int lzo_decompress(uint32_t h_flags32)
{
        unsigned block_size = LZO_BLOCK_SIZE;
        int r;
        uint32_t src_len, dst_len;
        uint32_t c_adler32 = ADLER32_INIT_VALUE;
        uint32_t d_adler32 = ADLER32_INIT_VALUE;
        uint32_t c_crc32 = CRC32_INIT_VALUE, d_crc32 = CRC32_INIT_VALUE;
        uint8_t *b1;
        uint32_t mcs_block_size = MAX_COMPRESSED_SIZE(block_size);
        uint8_t *b2 = NULL;

        for (;;) {
                uint8_t *dst;

                /* read uncompressed block size */
                dst_len = read32();

                /* exit if last block */
                if (dst_len == 0)
                        break;

                /* error if split file */
                if (dst_len == 0xffffffffL)
                        /* should not happen - not yet implemented */
                        bb_simple_error_msg_and_die("this file is a split lzop file");

                if (dst_len > MAX_BLOCK_SIZE)
                        bb_simple_error_msg_and_die("corrupted data");

                /* read compressed block size */
                src_len = read32();
                if (src_len <= 0 || src_len > dst_len)
                        bb_simple_error_msg_and_die("corrupted data");

                if (dst_len > block_size) {
                        if (b2) {
                                free(b2);
                                b2 = NULL;
                        }
                        block_size = dst_len;
                        mcs_block_size = MAX_COMPRESSED_SIZE(block_size);
                }

                /* read checksum of uncompressed block */
                if (h_flags32 & F_ADLER32_D)
                        d_adler32 = read32();
                if (h_flags32 & F_CRC32_D)
                        d_crc32 = read32();

                /* read checksum of compressed block */
                if (src_len < dst_len) {
                        if (h_flags32 & F_ADLER32_C)
                                c_adler32 = read32();
                        if (h_flags32 & F_CRC32_C)
                                c_crc32 = read32();
                }

                if (b2 == NULL)
                        b2 = xzalloc(mcs_block_size);
                /* read the block into the end of our buffer */
                b1 = b2 + mcs_block_size - src_len;
                xread(0, b1, src_len);

                if (src_len < dst_len) {
                        unsigned d = dst_len;

                        if (!(option_mask32 & OPT_F)) {
                                /* verify checksum of compressed block */
                                if (h_flags32 & F_ADLER32_C)
                                        lzo_check(ADLER32_INIT_VALUE,
                                                        b1, src_len,
                                                        lzo_adler32, c_adler32);
                                if (h_flags32 & F_CRC32_C)
                                        lzo_check(CRC32_INIT_VALUE,
                                                        b1, src_len,
                                                        lzo_crc32, c_crc32);
                        }

                        /* decompress */
//                      if (option_mask32 & OPT_F)
//                              r = lzo1x_decompress(b1, src_len, b2, &d /*, NULL*/);
//                      else
                                r = lzo1x_decompress_safe(b1, src_len, b2, &d /*, NULL*/);

                        if (r != 0 /*LZO_E_OK*/ || dst_len != d) {
                                bb_simple_error_msg_and_die("corrupted data");
                        }
                        dst = b2;
                } else {
                        /* "stored" block => no decompression */
                        dst = b1;
                }

                if (!(option_mask32 & OPT_F)) {
                        /* verify checksum of uncompressed block */
                        if (h_flags32 & F_ADLER32_D)
                                lzo_check(ADLER32_INIT_VALUE,
                                        dst, dst_len,
                                        lzo_adler32, d_adler32);
                        if (h_flags32 & F_CRC32_D)
                                lzo_check(CRC32_INIT_VALUE,
                                        dst, dst_len,
                                        lzo_crc32, d_crc32);
                }

                /* write uncompressed block data */
                xwrite(1, dst, dst_len);
        }

        free(b2);
        return 1;
}

/**********************************************************************/
// lzop file signature (shamelessly borrowed from PNG)
/**********************************************************************/
/*
 * The first nine bytes of a lzop file always contain the following values:
 *
 *                                 0   1   2   3   4   5   6   7   8
 *                               --- --- --- --- --- --- --- --- ---
 * (hex)                          89  4c  5a  4f  00  0d  0a  1a  0a
 * (decimal)                     137  76  90  79   0  13  10  26  10
 * (C notation - ASCII)         \211   L   Z   O  \0  \r  \n \032 \n
 */

/* (vda) comparison with lzop v1.02rc1 ("lzop -1 <FILE" cmd):
 * Only slight differences in header:
 * -00000000  89 4c 5a 4f 00 0d 0a 1a 0a 10 20 20 20 09 40 02
 * +00000000  89 4c 5a 4f 00 0d 0a 1a 0a 10 10 20 30 09 40 02
 *                                       ^^^^^ ^^^^^
 *                                     version lib_version
 * -00000010  01 03 00 00 0d 00 00 81 a4 49 f7 a6 3f 00 00 00
 * +00000010  01 03 00 00 01 00 00 00 00 00 00 00 00 00 00 00
 *               ^^^^^^^^^^^ ^^^^^^^^^^^ ^^^^^^^^^^^
 *               flags       mode        mtime
 * -00000020  00 00 2d 67 04 17 00 04 00 00 00 03 ed ec 9d 6d
 * +00000020  00 00 10 5f 00 c1 00 04 00 00 00 03 ed ec 9d 6d
 *                  ^^^^^^^^^^^
 *                  chksum
 * The rest is identical.
*/
static const unsigned char lzop_magic[9] ALIGN1 = {
        0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a
};

/* This coding is derived from Alexander Lehmann's pngcheck code. */
static void check_magic(void)
{
        unsigned char magic[sizeof(lzop_magic)];
        xread(0, magic, sizeof(magic));
        if (memcmp(magic, lzop_magic, sizeof(lzop_magic)) != 0)
                bb_simple_error_msg_and_die("bad magic number");
}

/**********************************************************************/
// lzop file header
/**********************************************************************/
static void write_header(header_t *h)
{
        char *end;

        xwrite(1, lzop_magic, sizeof(lzop_magic));

        init_chksum();

        /* Our caller leaves name zero-filled, so len == 0 */
        end = h->len_and_name+1 + 0; /* 0 is strlen(h->len_and_name+1) */
        /* Store length byte */
        /*h->len_and_name[0] = end - (h->len_and_name+1); - zero already */

        f_write(&h->version_be16, end - (char*)&h->version_be16);

        h->flags32 = htonl(h->flags32); /* native endianness for lzo_compress() */

        write32(chksum_getresult(h->flags32));
}

static int read_header(header_t *h)
{
        int l;
        uint32_t checksum;
        /* As it stands now, only h->flags32 is used by our caller.
         * Therefore we don't store many fields in h->FIELD.
         */
        unsigned h_version;
        unsigned h_version_needed_to_extract;

        init_chksum();

        /* We don't support versions < 0.94, since 0.94
         * came only 2 months after 0.90:
         * 0.90 (10 Aug 1997): First public release of lzop
         * 0.94 (15 Oct 1997): Header format change
         */

        /* Read up to and including name length byte */
        f_read(&h->version_be16, ((char*)&h->len_and_name[1]) - ((char*)&h->version_be16));

        h_version = htons(h->version_be16);
        if (h_version < 0x0940)
                return 3;
        h_version_needed_to_extract = htons(h->version_needed_to_extract_be16);
        if (h_version_needed_to_extract > LZOP_VERSION)
                return 16;
        if (h_version_needed_to_extract < 0x0940)
                return 3;

        if (h->method <= 0)
                return 14;

        /* former lzo_get_method(h): */
        if (h->method == M_LZO1X_1) {
                if (h->level == 0)
                        h->level = 3;
        } else if (h->method == M_LZO1X_1_15) {
                if (h->level == 0)
                        h->level = 1;
        } else if (h->method == M_LZO1X_999) {
                if (h->level == 0)
                        h->level = 9;
        } else
                return -1; /* not a LZO method */
        /* check compression level */
        if (h->level < 1 || h->level > 9)
                return 15;

        h->flags32 = ntohl(h->flags32);
        if (h->flags32 & F_H_FILTER)
                return 16; /* filter not supported */
        /* check reserved flags */
        if (h->flags32 & F_RESERVED)
                return -13;

        l = h->len_and_name[0];
        if (l > 0)

                /* UNUSED */ f_read(h->len_and_name+1, l);
        /* UNUSED h->len_and_name[1+l] = 0; */

        checksum = chksum_getresult(h->flags32);
        if (read32() != checksum)
                return 2;

        /* skip extra field [not used yet] */
        if (h->flags32 & F_H_EXTRA_FIELD) {
                uint32_t extra_field_len;
                uint32_t extra_field_checksum;
                uint32_t k;
                char dummy;

                /* note: the checksum also covers the length */
                init_chksum();
                extra_field_len = f_read32();
                for (k = 0; k < extra_field_len; k++)
                        f_read(&dummy, 1);
                checksum = chksum_getresult(h->flags32);
                extra_field_checksum = read32();
                if (extra_field_checksum != checksum)
                        return 3;
        }

        return 0;
}

/**********************************************************************/
// compress
/**********************************************************************/
static void lzo_set_method(header_t *h)
{
        smallint level;

        /* levels 2..6 or none (defaults to level 3) */
        h->method = M_LZO1X_1;
        level = 5; /* levels 2-6 are actually the same */

        if (option_mask32 & OPT_1) {
                h->method = M_LZO1X_1_15;
                level = 1;
        }
        if (option_mask32 & OPT_789) {
#if ENABLE_LZOP_COMPR_HIGH
                h->method = M_LZO1X_999;
                level = 9;
                if (option_mask32 & OPT_7)
                        level = 7;
                else if (option_mask32 & OPT_8)
                        level = 8;
#else
                bb_simple_error_msg_and_die("high compression not compiled in");
#endif
        }

        h->level = level;
}

static int do_lzo_compress(void)
{
        header_t header;

#define h (&header)
        memset(h, 0, sizeof(*h));

        lzo_set_method(h);

        h->version_be16 = htons(LZOP_VERSION & 0xffff);
        h->version_needed_to_extract_be16 = htons(0x0940);
        h->lib_version_be16 = htons(lzo_version() & 0xffff);

        h->flags32 = htonl((F_OS & F_OS_MASK) | (F_CS & F_CS_MASK));

        if (!(option_mask32 & OPT_F) || h->method == M_LZO1X_999) {
                h->flags32 |= htonl(F_ADLER32_D);
                if (option_mask32 & OPT_C)
                        h->flags32 |= htonl(F_ADLER32_C);
        }

        /* write_header() also converts h->flags32 to native endianness */
        write_header(h);

        return lzo_compress(h);
#undef h
}

/**********************************************************************/
// decompress
/**********************************************************************/
static int do_lzo_decompress(void)
{
        int r;
        header_t header;

        check_magic();
        r = read_header(&header);
        if (r != 0)
                bb_error_msg_and_die("header_error %d", r);
        return lzo_decompress(header.flags32);
}

static char* FAST_FUNC make_new_name_lzop(char *filename, const char *expected_ext UNUSED_PARAM)
{
        if (option_mask32 & OPT_DECOMPRESS) {
                char *extension = strrchr(filename, '.');
                if (!extension || strcmp(extension + 1, "lzo") != 0)
                        return xasprintf("%s.out", filename);
                *extension = '\0';
                return filename;
        }
        return xasprintf("%s.lzo", filename);
}

static IF_DESKTOP(long long) int FAST_FUNC pack_lzop(transformer_state_t *xstate UNUSED_PARAM)
{
        if (option_mask32 & OPT_DECOMPRESS)
                return do_lzo_decompress();
        return do_lzo_compress();
}

int lzop_main(int argc, char **argv) MAIN_EXTERNALLY_VISIBLE;
int lzop_main(int argc UNUSED_PARAM, char **argv)
{
        INIT_G();

        getopt32(argv, OPTION_STRING);
        argv += optind;
        /* -U is "anti -k", invert bit for bbunpack(): */
        option_mask32 ^= OPT_KEEP;
        /* -k disables -U (if any): */
        /* opt_complementary "k-U"? - nope, only handles -Uk, not -kU */
        if (option_mask32 & OPT_k)
                option_mask32 |= OPT_KEEP;

        /* lzopcat? */
        if (ENABLE_LZOPCAT && applet_name[4] == 'c')
                option_mask32 |= (OPT_STDOUT | OPT_DECOMPRESS);
        /* unlzop? */
        if (ENABLE_UNLZOP && applet_name[4] == 'o')
                option_mask32 |= OPT_DECOMPRESS;

        global_crc32_new_table_le();
        return bbunpack(argv, pack_lzop, make_new_name_lzop, /*unused:*/ NULL);
}