lib/lz4_wrapper.c

   1 // SPDX-License-Identifier: GPL 2.0+ OR BSD-3-Clause
   2 /*
   3  * Copyright 2015 Google Inc.
   4  */
   5
   6 #include <common.h>
   7 #include <compiler.h>
   8 #include <image.h>
   9 #include <linux/kernel.h>
  10 #include <linux/types.h>
  11 #include <asm/unaligned.h>
  12 #include <u-boot/lz4.h>
  13
  14 /* lz4.c is unaltered (except removing unrelated code) from github.com/Cyan4973/lz4. */
  15 #include "lz4.c"        /* #include for inlining, do not link! */
  16
  17 #define LZ4F_BLOCKUNCOMPRESSED_FLAG 0x80000000U
  18
  19 int ulz4fn(const void *src, size_t srcn, void *dst, size_t *dstn)
  20 {
  21         const void *end = dst + *dstn;
  22         const void *in = src;
  23         void *out = dst;
  24         int has_block_checksum;
  25         int ret;
  26         *dstn = 0;
  27
  28         { /* With in-place decompression the header may become invalid later. */
  29                 u32 magic;
  30                 u8 flags, version, independent_blocks, has_content_size;
  31                 u8 block_desc;
  32
  33                 if (srcn < sizeof(u32) + 3*sizeof(u8))
  34                         return -EINVAL; /* input overrun */
  35
  36                 magic = get_unaligned_le32(in);
  37                 in += sizeof(u32);
  38                 flags = *(u8 *)in;
  39                 in += sizeof(u8);
  40                 block_desc = *(u8 *)in;
  41                 in += sizeof(u8);
  42
  43                 version = (flags >> 6) & 0x3;
  44                 independent_blocks = (flags >> 5) & 0x1;
  45                 has_block_checksum = (flags >> 4) & 0x1;
  46                 has_content_size = (flags >> 3) & 0x1;
  47
  48                 /* We assume there's always only a single, standard frame. */
  49                 if (magic != LZ4F_MAGIC || version != 1)
  50                         return -EPROTONOSUPPORT;        /* unknown format */
  51                 if ((flags & 0x03) || (block_desc & 0x8f))
  52                         return -EINVAL; /* reserved bits must be zero */
  53                 if (!independent_blocks)
  54                         return -EPROTONOSUPPORT; /* we can't support this yet */
  55
  56                 if (has_content_size) {
  57                         if (srcn < sizeof(u32) + 3*sizeof(u8) + sizeof(u64))
  58                                 return -EINVAL; /* input overrun */
  59                         in += sizeof(u64);
  60                 }
  61                 /* Header checksum byte */
  62                 in += sizeof(u8);
  63         }
  64
  65         while (1) {
  66                 u32 block_header, block_size;
  67
  68                 block_header = get_unaligned_le32(in);
  69                 in += sizeof(u32);
  70                 block_size = block_header & ~LZ4F_BLOCKUNCOMPRESSED_FLAG;
  71
  72                 if (in - src + block_size > srcn) {
  73                         ret = -EINVAL;          /* input overrun */
  74                         break;
  75                 }
  76
  77                 if (!block_size) {
  78                         ret = 0;        /* decompression successful */
  79                         break;
  80                 }
  81
  82                 if (block_header & LZ4F_BLOCKUNCOMPRESSED_FLAG) {
  83                         size_t size = min((ptrdiff_t)block_size, end - out);
  84                         memcpy(out, in, size);
  85                         out += size;
  86                         if (size < block_size) {
  87                                 ret = -ENOBUFS; /* output overrun */
  88                                 break;
  89                         }
  90                 } else {
  91                         /* constant folding essential, do not touch params! */
  92                         ret = LZ4_decompress_generic(in, out, block_size,
  93                                         end - out, endOnInputSize,
  94                                         decode_full_block, noDict, out, NULL, 0);
  95                         if (ret < 0) {
  96                                 ret = -EPROTO;  /* decompression error */
  97                                 break;
  98                         }
  99                         out += ret;
 100                 }
 101
 102                 in += block_size;
 103                 if (has_block_checksum)
 104                         in += sizeof(u32);
 105         }
 106
 107         *dstn = out - dst;
 108         return ret;
 109 }