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/decompress/unlzo.h>
  37 #endif
  38
  39 #include <linux/types.h>
  40 #include <linux/lzo.h>
  41 #include <linux/decompress/mm.h>
  42
  43 #include <linux/compiler.h>
  44 #include <asm/unaligned.h>
  45
  46 static const unsigned char lzop_magic[] = {
  47         0x89, 0x4c, 0x5a, 0x4f, 0x00, 0x0d, 0x0a, 0x1a, 0x0a };
  48
  49 #define LZO_BLOCK_SIZE        (256*1024l)
  50 #define HEADER_HAS_FILTER      0x00000800L
  51 #define HEADER_SIZE_MIN       (9 + 7     + 4 + 8     + 1       + 4)
  52 #define HEADER_SIZE_MAX       (9 + 7 + 1 + 8 + 8 + 4 + 1 + 255 + 4)
  53
  54 STATIC inline int INIT parse_header(u8 *input, int *skip, int in_len)
  55 {
  56         int l;
  57         u8 *parse = input;
  58         u8 *end = input + in_len;
  59         u8 level = 0;
  60         u16 version;
  61
  62         /*
  63          * Check that there's enough input to possibly have a valid header.
  64          * Then it is possible to parse several fields until the minimum
  65          * size may have been used.
  66          */
  67         if (in_len < HEADER_SIZE_MIN)
  68                 return 0;
  69
  70         /* read magic: 9 first bits */
  71         for (l = 0; l < 9; l++) {
  72                 if (*parse++ != lzop_magic[l])
  73                         return 0;
  74         }
  75         /* get version (2bytes), skip library version (2),
  76          * 'need to be extracted' version (2) and
  77          * method (1) */
  78         version = get_unaligned_be16(parse);
  79         parse += 7;
  80         if (version >= 0x0940)
  81                 level = *parse++;
  82         if (get_unaligned_be32(parse) & HEADER_HAS_FILTER)
  83                 parse += 8; /* flags + filter info */
  84         else
  85                 parse += 4; /* flags */
  86
  87         /*
  88          * At least mode, mtime_low, filename length, and checksum must
  89          * be left to be parsed. If also mtime_high is present, it's OK
  90          * because the next input buffer check is after reading the
  91          * filename length.
  92          */
  93         if (end - parse < 8 + 1 + 4)
  94                 return 0;
  95
  96         /* skip mode and mtime_low */
  97         parse += 8;
  98         if (version >= 0x0940)
  99                 parse += 4;     /* skip mtime_high */
 100
 101         l = *parse++;
 102         /* don't care about the file name, and skip checksum */
 103         if (end - parse < l + 4)
 104                 return 0;
 105         parse += l + 4;
 106
 107         *skip = parse - input;
 108         return 1;
 109 }
 110
 111 STATIC inline int INIT unlzo(u8 *input, int in_len,
 112                                 int (*fill) (void *, unsigned int),
 113                                 int (*flush) (void *, unsigned int),
 114                                 u8 *output, int *posp,
 115                                 void (*error) (char *x))
 116 {
 117         u8 r = 0;
 118         int skip = 0;
 119         u32 src_len, dst_len;
 120         size_t tmp;
 121         u8 *in_buf, *in_buf_save, *out_buf;
 122         int ret = -1;
 123
 124         if (output) {
 125                 out_buf = output;
 126         } else if (!flush) {
 127                 error("NULL output pointer and no flush function provided");
 128                 goto exit;
 129         } else {
 130                 out_buf = malloc(LZO_BLOCK_SIZE);
 131                 if (!out_buf) {
 132                         error("Could not allocate output buffer");
 133                         goto exit;
 134                 }
 135         }
 136
 137         if (input && fill) {
 138                 error("Both input pointer and fill function provided, don't know what to do");
 139                 goto exit_1;
 140         } else if (input) {
 141                 in_buf = input;
 142         } else if (!fill) {
 143                 error("NULL input pointer and missing fill function");
 144                 goto exit_1;
 145         } else {
 146                 in_buf = malloc(lzo1x_worst_compress(LZO_BLOCK_SIZE));
 147                 if (!in_buf) {
 148                         error("Could not allocate input buffer");
 149                         goto exit_1;
 150                 }
 151         }
 152         in_buf_save = in_buf;
 153
 154         if (posp)
 155                 *posp = 0;
 156
 157         if (fill) {
 158                 /*
 159                  * Start from in_buf + HEADER_SIZE_MAX to make it possible
 160                  * to use memcpy() to copy the unused data to the beginning
 161                  * of the buffer. This way memmove() isn't needed which
 162                  * is missing from pre-boot environments of most archs.
 163                  */
 164                 in_buf += HEADER_SIZE_MAX;
 165                 in_len = fill(in_buf, HEADER_SIZE_MAX);
 166         }
 167
 168         if (!parse_header(in_buf, &skip, in_len)) {
 169                 error("invalid header");
 170                 goto exit_2;
 171         }
 172         in_buf += skip;
 173         in_len -= skip;
 174
 175         if (fill) {
 176                 /* Move the unused data to the beginning of the buffer. */
 177                 memcpy(in_buf_save, in_buf, in_len);
 178                 in_buf = in_buf_save;
 179         }
 180
 181         if (posp)
 182                 *posp = skip;
 183
 184         for (;;) {
 185                 /* read uncompressed block size */
 186                 if (fill && in_len < 4) {
 187                         skip = fill(in_buf + in_len, 4 - in_len);
 188                         if (skip > 0)
 189                                 in_len += skip;
 190                 }
 191                 if (in_len < 4) {
 192                         error("file corrupted");
 193                         goto exit_2;
 194                 }
 195                 dst_len = get_unaligned_be32(in_buf);
 196                 in_buf += 4;
 197                 in_len -= 4;
 198
 199                 /* exit if last block */
 200                 if (dst_len == 0) {
 201                         if (posp)
 202                                 *posp += 4;
 203                         break;
 204                 }
 205
 206                 if (dst_len > LZO_BLOCK_SIZE) {
 207                         error("dest len longer than block size");
 208                         goto exit_2;
 209                 }
 210
 211                 /* read compressed block size, and skip block checksum info */
 212                 if (fill && in_len < 8) {
 213                         skip = fill(in_buf + in_len, 8 - in_len);
 214                         if (skip > 0)
 215                                 in_len += skip;
 216                 }
 217                 if (in_len < 8) {
 218                         error("file corrupted");
 219                         goto exit_2;
 220                 }
 221                 src_len = get_unaligned_be32(in_buf);
 222                 in_buf += 8;
 223                 in_len -= 8;
 224
 225                 if (src_len <= 0 || src_len > dst_len) {
 226                         error("file corrupted");
 227                         goto exit_2;
 228                 }
 229
 230                 /* decompress */
 231                 if (fill && in_len < src_len) {
 232                         skip = fill(in_buf + in_len, src_len - in_len);
 233                         if (skip > 0)
 234                                 in_len += skip;
 235                 }
 236                 if (in_len < src_len) {
 237                         error("file corrupted");
 238                         goto exit_2;
 239                 }
 240                 tmp = dst_len;
 241
 242                 /* When the input data is not compressed at all,
 243                  * lzo1x_decompress_safe will fail, so call memcpy()
 244                  * instead */
 245                 if (unlikely(dst_len == src_len))
 246                         memcpy(out_buf, in_buf, src_len);
 247                 else {
 248                         r = lzo1x_decompress_safe((u8 *) in_buf, src_len,
 249                                                 out_buf, &tmp);
 250
 251                         if (r != LZO_E_OK || dst_len != tmp) {
 252                                 error("Compressed data violation");
 253                                 goto exit_2;
 254                         }
 255                 }
 256
 257                 if (flush && flush(out_buf, dst_len) != dst_len)
 258                         goto exit_2;
 259                 if (output)
 260                         out_buf += dst_len;
 261                 if (posp)
 262                         *posp += src_len + 12;
 263
 264                 in_buf += src_len;
 265                 in_len -= src_len;
 266                 if (fill) {
 267                         /*
 268                          * If there happens to still be unused data left in
 269                          * in_buf, move it to the beginning of the buffer.
 270                          * Use a loop to avoid memmove() dependency.
 271                          */
 272                         if (in_len > 0)
 273                                 for (skip = 0; skip < in_len; ++skip)
 274                                         in_buf_save[skip] = in_buf[skip];
 275                         in_buf = in_buf_save;
 276                 }
 277         }
 278
 279         ret = 0;
 280 exit_2:
 281         if (!input)
 282                 free(in_buf_save);
 283 exit_1:
 284         if (!output)
 285                 free(out_buf);
 286 exit:
 287         return ret;
 288 }
 289
 290 #define decompress unlzo