lib/decompress_unlzo.c

   1 /*
   2  * LZO decompressor for the Linux kernel. Code borrowed from the lzo
   3  * implementation by Markus Franz Xaver Johannes Oberhumer.
   4  *
   5  * Linux kernel adaptation:
   6  * Copyright (C) 2009
   7  * Albin Tonnerre, Free Electrons <albin.tonnerre@free-electrons.com>
   8  *
   9  * Original code:
  10  * Copyright (C) 1996-2005 Markus Franz Xaver Johannes Oberhumer
  11  * All Rights Reserved.
  12  *
  13  * lzop and the LZO library are free software; you can redistribute them
  14  * and/or modify them under the terms of the GNU General Public License as
  15  * published by the Free Software Foundation; either version 2 of
  16  * the License, or (at your option) any later version.
  17  *
  18  * This program is distributed in the hope that it will be useful,
  19  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  21  * GNU General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License
  24  * along with this program; see the file COPYING.
  25  * If not, write to the Free Software Foundation, Inc.,
  26  * 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
  27  *
  28  * Markus F.X.J. Oberhumer
  29  * <markus@oberhumer.com>
  30  * http://www.oberhumer.com/opensource/lzop/
  31  */
  32
  33 #ifdef STATIC
  34 #include "lzo/lzo1x_decompress.c"
  35 #else
  36 #include <linux/slab.h>
  37 #include <linux/decompress/unlzo.h>
  38 #endif
  39
  40 #include <linux/types.h>
  41 #include <linux/lzo.h>
  42 #include <linux/decompress/mm.h>
  43
  44 #include <linux/compiler.h>
  45 #include <asm/unaligned.h>
  46
  47 static const unsigned char lzop_magic[] = {
  48         0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a };
  49
  50 #define LZO_BLOCK_SIZE        (256*1024l)
  51 #define HEADER_HAS_FILTER      0x00000800L
  52
  53 STATIC inline int INIT parse_header(u8 *input, u8 *skip)
  54 {
  55         int l;
  56         u8 *parse = input;
  57         u8 level = 0;
  58         u16 version;
  59
  60         /* read magic: 9 first bits */
  61         for (l = 0; l < 9; l++) {
  62                 if (*parse++ != lzop_magic[l])
  63                         return 0;
  64         }
  65         /* get version (2bytes), skip library version (2),
  66          * 'need to be extracted' version (2) and
  67          * method (1) */
  68         version = get_unaligned_be16(parse);
  69         parse += 7;
  70         if (version >= 0x0940)
  71                 level = *parse++;
  72         if (get_unaligned_be32(parse) & HEADER_HAS_FILTER)
  73                 parse += 8; /* flags + filter info */
  74         else
  75                 parse += 4; /* flags */
  76
  77         /* skip mode and mtime_low */
  78         parse += 8;
  79         if (version >= 0x0940)
  80                 parse += 4;     /* skip mtime_high */
  81
  82         l = *parse++;
  83         /* don't care about the file name, and skip checksum */
  84         parse += l + 4;
  85
  86         *skip = parse - input;
  87         return 1;
  88 }
  89
  90 STATIC inline int INIT unlzo(u8 *input, int in_len,
  91                                 int (*fill) (void *, unsigned int),
  92                                 int (*flush) (void *, unsigned int),
  93                                 u8 *output, int *posp,
  94                                 void (*error_fn) (char *x))
  95 {
  96         u8 skip = 0, r = 0;
  97         u32 src_len, dst_len;
  98         size_t tmp;
  99         u8 *in_buf, *in_buf_save, *out_buf;
 100         int ret = -1;
 101
 102         set_error_fn(error_fn);
 103
 104         if (output) {
 105                 out_buf = output;
 106         } else if (!flush) {
 107                 error("NULL output pointer and no flush function provided");
 108                 goto exit;
 109         } else {
 110                 out_buf = malloc(LZO_BLOCK_SIZE);
 111                 if (!out_buf) {
 112                         error("Could not allocate output buffer");
 113                         goto exit;
 114                 }
 115         }
 116
 117         if (input && fill) {
 118                 error("Both input pointer and fill function provided, don't know what to do");
 119                 goto exit_1;
 120         } else if (input) {
 121                 in_buf = input;
 122         } else if (!fill || !posp) {
 123                 error("NULL input pointer and missing position pointer or fill function");
 124                 goto exit_1;
 125         } else {
 126                 in_buf = malloc(lzo1x_worst_compress(LZO_BLOCK_SIZE));
 127                 if (!in_buf) {
 128                         error("Could not allocate input buffer");
 129                         goto exit_1;
 130                 }
 131         }
 132         in_buf_save = in_buf;
 133
 134         if (posp)
 135                 *posp = 0;
 136
 137         if (fill)
 138                 fill(in_buf, lzo1x_worst_compress(LZO_BLOCK_SIZE));
 139
 140         if (!parse_header(input, &skip)) {
 141                 error("invalid header");
 142                 goto exit_2;
 143         }
 144         in_buf += skip;
 145
 146         if (posp)
 147                 *posp = skip;
 148
 149         for (;;) {
 150                 /* read uncompressed block size */
 151                 dst_len = get_unaligned_be32(in_buf);
 152                 in_buf += 4;
 153
 154                 /* exit if last block */
 155                 if (dst_len == 0) {
 156                         if (posp)
 157                                 *posp += 4;
 158                         break;
 159                 }
 160
 161                 if (dst_len > LZO_BLOCK_SIZE) {
 162                         error("dest len longer than block size");
 163                         goto exit_2;
 164                 }
 165
 166                 /* read compressed block size, and skip block checksum info */
 167                 src_len = get_unaligned_be32(in_buf);
 168                 in_buf += 8;
 169
 170                 if (src_len <= 0 || src_len > dst_len) {
 171                         error("file corrupted");
 172                         goto exit_2;
 173                 }
 174
 175                 /* decompress */
 176                 tmp = dst_len;
 177
 178                 /* When the input data is not compressed at all,
 179                  * lzo1x_decompress_safe will fail, so call memcpy()
 180                  * instead */
 181                 if (unlikely(dst_len == src_len))
 182                         memcpy(out_buf, in_buf, src_len);
 183                 else {
 184                         r = lzo1x_decompress_safe((u8 *) in_buf, src_len,
 185                                                 out_buf, &tmp);
 186
 187                         if (r != LZO_E_OK || dst_len != tmp) {
 188                                 error("Compressed data violation");
 189                                 goto exit_2;
 190                         }
 191                 }
 192
 193                 if (flush)
 194                         flush(out_buf, dst_len);
 195                 if (output)
 196                         out_buf += dst_len;
 197                 if (posp)
 198                         *posp += src_len + 12;
 199                 if (fill) {
 200                         in_buf = in_buf_save;
 201                         fill(in_buf, lzo1x_worst_compress(LZO_BLOCK_SIZE));
 202                 } else
 203                         in_buf += src_len;
 204         }
 205
 206         ret = 0;
 207 exit_2:
 208         if (!input)
 209                 free(in_buf);
 210 exit_1:
 211         if (!output)
 212                 free(out_buf);
 213 exit:
 214         return ret;
 215 }
 216
 217 #define decompress unlzo