src/journal/compress.c

   1 /*-*- Mode: C; c-basic-offset: 8; indent-tabs-mode: nil -*-*/
   2
   3 /***
   4   This file is part of systemd.
   5
   6   Copyright 2011 Lennart Poettering
   7
   8   systemd is free software; you can redistribute it and/or modify it
   9   under the terms of the GNU Lesser General Public License as published by
  10   the Free Software Foundation; either version 2.1 of the License, or
  11   (at your option) any later version.
  12
  13   systemd is distributed in the hope that it will be useful, but
  14   WITHOUT ANY WARRANTY; without even the implied warranty of
  15   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  16   Lesser General Public License for more details.
  17
  18   You should have received a copy of the GNU Lesser General Public License
  19   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  20 ***/
  21
  22 #include <assert.h>
  23 #include <stdlib.h>
  24 #include <string.h>
  25 #include <lzma.h>
  26
  27 #include "macro.h"
  28 #include "compress.h"
  29
  30 bool compress_blob(const void *src, uint64_t src_size, void *dst, uint64_t *dst_size) {
  31         lzma_stream s = LZMA_STREAM_INIT;
  32         lzma_ret ret;
  33         bool b = false;
  34
  35         assert(src);
  36         assert(src_size > 0);
  37         assert(dst);
  38         assert(dst_size);
  39
  40         /* Returns false if we couldn't compress the data or the
  41          * compressed result is longer than the original */
  42
  43         ret = lzma_easy_encoder(&s, LZMA_PRESET_DEFAULT, LZMA_CHECK_NONE);
  44         if (ret != LZMA_OK)
  45                 return false;
  46
  47         s.next_in = src;
  48         s.avail_in = src_size;
  49         s.next_out = dst;
  50         s.avail_out = src_size;
  51
  52         /* Does it fit? */
  53         if (lzma_code(&s, LZMA_FINISH) != LZMA_STREAM_END)
  54                 goto fail;
  55
  56         /* Is it actually shorter? */
  57         if (s.avail_out == 0)
  58                 goto fail;
  59
  60         *dst_size = src_size - s.avail_out;
  61         b = true;
  62
  63 fail:
  64         lzma_end(&s);
  65
  66         return b;
  67 }
  68
  69 bool uncompress_blob(const void *src, uint64_t src_size,
  70                      void **dst, uint64_t *dst_alloc_size, uint64_t* dst_size, uint64_t dst_max) {
  71
  72         lzma_stream s = LZMA_STREAM_INIT;
  73         lzma_ret ret;
  74         uint64_t space;
  75         bool b = false;
  76
  77         assert(src);
  78         assert(src_size > 0);
  79         assert(dst);
  80         assert(dst_alloc_size);
  81         assert(dst_size);
  82         assert(*dst_alloc_size == 0 || *dst);
  83
  84         ret = lzma_stream_decoder(&s, UINT64_MAX, 0);
  85         if (ret != LZMA_OK)
  86                 return false;
  87
  88         if (*dst_alloc_size <= src_size) {
  89                 void *p;
  90
  91                 p = realloc(*dst, src_size*2);
  92                 if (!p)
  93                         return false;
  94
  95                 *dst = p;
  96                 *dst_alloc_size = src_size*2;
  97         }
  98
  99         s.next_in = src;
 100         s.avail_in = src_size;
 101
 102         s.next_out = *dst;
 103         space = dst_max > 0 ? MIN(*dst_alloc_size, dst_max) : *dst_alloc_size;
 104         s.avail_out = space;
 105
 106         for (;;) {
 107                 void *p;
 108
 109                 ret = lzma_code(&s, LZMA_FINISH);
 110
 111                 if (ret == LZMA_STREAM_END)
 112                         break;
 113
 114                 if (ret != LZMA_OK)
 115                         goto fail;
 116
 117                 if (dst_max > 0 && (space - s.avail_out) >= dst_max)
 118                         break;
 119
 120                 p = realloc(*dst, space*2);
 121                 if (!p)
 122                         goto fail;
 123
 124                 s.next_out = (uint8_t*) p + ((uint8_t*) s.next_out - (uint8_t*) *dst);
 125                 s.avail_out += space;
 126
 127                 space *= 2;
 128
 129                 *dst = p;
 130                 *dst_alloc_size = space;
 131         }
 132
 133         *dst_size = space - s.avail_out;
 134         b = true;
 135
 136 fail:
 137         lzma_end(&s);
 138
 139         return b;
 140 }
 141
 142 bool uncompress_startswith(const void *src, uint64_t src_size,
 143                            void **buffer, uint64_t *buffer_size,
 144                            const void *prefix, uint64_t prefix_len,
 145                            uint8_t extra) {
 146
 147         lzma_stream s = LZMA_STREAM_INIT;
 148         lzma_ret ret;
 149         bool b = false;
 150
 151         /* Checks whether the uncompressed blob starts with the
 152          * mentioned prefix. The byte extra needs to follow the
 153          * prefix */
 154
 155         assert(src);
 156         assert(src_size > 0);
 157         assert(buffer);
 158         assert(buffer_size);
 159         assert(prefix);
 160         assert(*buffer_size == 0 || *buffer);
 161
 162         ret = lzma_stream_decoder(&s, UINT64_MAX, 0);
 163         if (ret != LZMA_OK)
 164                 return false;
 165
 166         if (*buffer_size <= prefix_len) {
 167                 void *p;
 168
 169                 p = realloc(*buffer, prefix_len*2);
 170                 if (!p)
 171                         return false;
 172
 173                 *buffer = p;
 174                 *buffer_size = prefix_len*2;
 175         }
 176
 177         s.next_in = src;
 178         s.avail_in = src_size;
 179
 180         s.next_out = *buffer;
 181         s.avail_out = *buffer_size;
 182
 183         for (;;) {
 184                 void *p;
 185
 186                 ret = lzma_code(&s, LZMA_FINISH);
 187
 188                 if (ret != LZMA_STREAM_END && ret != LZMA_OK)
 189                         goto fail;
 190
 191                 if ((*buffer_size - s.avail_out > prefix_len) &&
 192                     memcmp(*buffer, prefix, prefix_len) == 0 &&
 193                     ((const uint8_t*) *buffer)[prefix_len] == extra)
 194                         break;
 195
 196                 if (ret == LZMA_STREAM_END)
 197                         goto fail;
 198
 199                 p = realloc(*buffer, *buffer_size*2);
 200                 if (!p)
 201                         goto fail;
 202
 203                 s.next_out = (uint8_t*) p + ((uint8_t*) s.next_out - (uint8_t*) *buffer);
 204                 s.avail_out += *buffer_size;
 205
 206                 *buffer = p;
 207                 *buffer_size *= 2;
 208         }
 209
 210         b = true;
 211
 212 fail:
 213         lzma_end(&s);
 214
 215         return b;
 216 }