src/journal/test-compress.c

   1 /* SPDX-License-Identifier: LGPL-2.1+ */
   2
   3 #include <sys/stat.h>
   4
   5 #if HAVE_LZ4
   6 #include <lz4.h>
   7 #endif
   8
   9 #include "alloc-util.h"
  10 #include "compress.h"
  11 #include "fd-util.h"
  12 #include "fs-util.h"
  13 #include "macro.h"
  14 #include "memory-util.h"
  15 #include "path-util.h"
  16 #include "random-util.h"
  17 #include "tests.h"
  18 #include "tmpfile-util.h"
  19
  20 #if HAVE_XZ
  21 # define XZ_OK 0
  22 #else
  23 # define XZ_OK -EPROTONOSUPPORT
  24 #endif
  25
  26 #if HAVE_LZ4
  27 # define LZ4_OK 0
  28 #else
  29 # define LZ4_OK -EPROTONOSUPPORT
  30 #endif
  31
  32 #define HUGE_SIZE (4096*1024)
  33
  34 typedef int (compress_blob_t)(const void *src, uint64_t src_size,
  35                               void *dst, size_t dst_alloc_size, size_t *dst_size);
  36 typedef int (decompress_blob_t)(const void *src, uint64_t src_size,
  37                                 void **dst, size_t *dst_alloc_size,
  38                                 size_t* dst_size, size_t dst_max);
  39 typedef int (decompress_sw_t)(const void *src, uint64_t src_size,
  40                               void **buffer, size_t *buffer_size,
  41                               const void *prefix, size_t prefix_len,
  42                               uint8_t extra);
  43
  44 typedef int (compress_stream_t)(int fdf, int fdt, uint64_t max_bytes);
  45 typedef int (decompress_stream_t)(int fdf, int fdt, uint64_t max_size);
  46
  47 #if HAVE_COMPRESSION
  48 _unused_ static void test_compress_decompress(const char *compression,
  49                                               compress_blob_t compress,
  50                                               decompress_blob_t decompress,
  51                                               const char *data,
  52                                               size_t data_len,
  53                                               bool may_fail) {
  54         char compressed[512];
  55         size_t csize, usize = 0;
  56         _cleanup_free_ char *decompressed = NULL;
  57         int r;
  58
  59         log_info("/* testing %s %s blob compression/decompression */",
  60                  compression, data);
  61
  62         r = compress(data, data_len, compressed, sizeof(compressed), &csize);
  63         if (r == -ENOBUFS) {
  64                 log_info_errno(r, "compression failed: %m");
  65                 assert_se(may_fail);
  66         } else {
  67                 assert_se(r == 0);
  68                 r = decompress(compressed, csize,
  69                                (void **) &decompressed, &usize, &csize, 0);
  70                 assert_se(r == 0);
  71                 assert_se(decompressed);
  72                 assert_se(memcmp(decompressed, data, data_len) == 0);
  73         }
  74
  75         r = decompress("garbage", 7,
  76                        (void **) &decompressed, &usize, &csize, 0);
  77         assert_se(r < 0);
  78
  79         /* make sure to have the minimal lz4 compressed size */
  80         r = decompress("00000000\1g", 9,
  81                        (void **) &decompressed, &usize, &csize, 0);
  82         assert_se(r < 0);
  83
  84         r = decompress("\100000000g", 9,
  85                        (void **) &decompressed, &usize, &csize, 0);
  86         assert_se(r < 0);
  87
  88         memzero(decompressed, usize);
  89 }
  90
  91 _unused_ static void test_decompress_startswith(const char *compression,
  92                                                 compress_blob_t compress,
  93                                                 decompress_sw_t decompress_sw,
  94                                                 const char *data,
  95                                                 size_t data_len,
  96                                                 bool may_fail) {
  97
  98         char *compressed;
  99         _cleanup_free_ char *compressed1 = NULL, *compressed2 = NULL, *decompressed = NULL;
 100         size_t csize, usize = 0, len;
 101         int r;
 102
 103         log_info("/* testing decompress_startswith with %s on %.20s text */",
 104                  compression, data);
 105
 106 #define BUFSIZE_1 512
 107 #define BUFSIZE_2 20000
 108
 109         compressed = compressed1 = malloc(BUFSIZE_1);
 110         assert_se(compressed1);
 111         r = compress(data, data_len, compressed, BUFSIZE_1, &csize);
 112         if (r == -ENOBUFS) {
 113                 log_info_errno(r, "compression failed: %m");
 114                 assert_se(may_fail);
 115
 116                 compressed = compressed2 = malloc(BUFSIZE_2);
 117                 assert_se(compressed2);
 118                 r = compress(data, data_len, compressed, BUFSIZE_2, &csize);
 119                 assert(r == 0);
 120         }
 121         assert_se(r == 0);
 122
 123         len = strlen(data);
 124
 125         r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, data, len, '\0');
 126         assert_se(r > 0);
 127         r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, data, len, 'w');
 128         assert_se(r == 0);
 129         r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, "barbarbar", 9, ' ');
 130         assert_se(r == 0);
 131         r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, data, len - 1, data[len-1]);
 132         assert_se(r > 0);
 133         r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, data, len - 1, 'w');
 134         assert_se(r == 0);
 135         r = decompress_sw(compressed, csize, (void **) &decompressed, &usize, data, len, '\0');
 136         assert_se(r > 0);
 137 }
 138
 139 _unused_ static void test_decompress_startswith_short(const char *compression,
 140                                                       compress_blob_t compress,
 141                                                       decompress_sw_t decompress_sw) {
 142
 143 #define TEXT "HUGE=xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 144
 145         char buf[1024];
 146         size_t i, csize;
 147         int r;
 148
 149         log_info("/* %s with %s */", __func__, compression);
 150
 151         r = compress(TEXT, sizeof TEXT, buf, sizeof buf, &csize);
 152         assert_se(r == 0);
 153
 154         for (i = 1; i < strlen(TEXT); i++) {
 155                 size_t alloc_size = i;
 156                 _cleanup_free_ void *buf2 = NULL;
 157
 158                 assert_se(buf2 = malloc(i));
 159
 160                 assert_se(decompress_sw(buf, csize, &buf2, &alloc_size, TEXT, i, TEXT[i]) == 1);
 161                 assert_se(decompress_sw(buf, csize, &buf2, &alloc_size, TEXT, i, 'y') == 0);
 162         }
 163 }
 164
 165 _unused_ static void test_compress_stream(const char *compression,
 166                                           const char *cat,
 167                                           compress_stream_t compress,
 168                                           decompress_stream_t decompress,
 169                                           const char *srcfile) {
 170
 171         _cleanup_close_ int src = -1, dst = -1, dst2 = -1;
 172         _cleanup_(unlink_tempfilep) char
 173                 pattern[] = "/tmp/systemd-test.compressed.XXXXXX",
 174                 pattern2[] = "/tmp/systemd-test.compressed.XXXXXX";
 175         int r;
 176         _cleanup_free_ char *cmd = NULL, *cmd2 = NULL;
 177         struct stat st = {};
 178
 179         r = find_binary(cat, NULL);
 180         if (r < 0) {
 181                 log_error_errno(r, "Skipping %s, could not find %s binary: %m", __func__, cat);
 182                 return;
 183         }
 184
 185         log_debug("/* testing %s compression */", compression);
 186
 187         log_debug("/* create source from %s */", srcfile);
 188
 189         assert_se((src = open(srcfile, O_RDONLY|O_CLOEXEC)) >= 0);
 190
 191         log_debug("/* test compression */");
 192
 193         assert_se((dst = mkostemp_safe(pattern)) >= 0);
 194
 195         assert_se(compress(src, dst, -1) == 0);
 196
 197         if (cat) {
 198                 assert_se(asprintf(&cmd, "%s %s | diff %s -", cat, pattern, srcfile) > 0);
 199                 assert_se(system(cmd) == 0);
 200         }
 201
 202         log_debug("/* test decompression */");
 203
 204         assert_se((dst2 = mkostemp_safe(pattern2)) >= 0);
 205
 206         assert_se(stat(srcfile, &st) == 0);
 207
 208         assert_se(lseek(dst, 0, SEEK_SET) == 0);
 209         r = decompress(dst, dst2, st.st_size);
 210         assert_se(r == 0);
 211
 212         assert_se(asprintf(&cmd2, "diff %s %s", srcfile, pattern2) > 0);
 213         assert_se(system(cmd2) == 0);
 214
 215         log_debug("/* test faulty decompression */");
 216
 217         assert_se(lseek(dst, 1, SEEK_SET) == 1);
 218         r = decompress(dst, dst2, st.st_size);
 219         assert_se(IN_SET(r, 0, -EBADMSG));
 220
 221         assert_se(lseek(dst, 0, SEEK_SET) == 0);
 222         assert_se(lseek(dst2, 0, SEEK_SET) == 0);
 223         r = decompress(dst, dst2, st.st_size - 1);
 224         assert_se(r == -EFBIG);
 225 }
 226 #endif
 227
 228 #if HAVE_LZ4
 229 static void test_lz4_decompress_partial(void) {
 230         char buf[20000], buf2[100];
 231         size_t buf_size = sizeof(buf), compressed;
 232         int r;
 233         _cleanup_free_ char *huge = NULL;
 234
 235         log_debug("/* %s */", __func__);
 236
 237         assert_se(huge = malloc(HUGE_SIZE));
 238         memcpy(huge, "HUGE=", STRLEN("HUGE="));
 239         memset(&huge[STRLEN("HUGE=")], 'x', HUGE_SIZE - STRLEN("HUGE=") - 1);
 240         huge[HUGE_SIZE - 1] = '\0';
 241
 242         r = LZ4_compress_default(huge, buf, HUGE_SIZE, buf_size);
 243         assert_se(r >= 0);
 244         compressed = r;
 245         log_info("Compressed %i → %zu", HUGE_SIZE, compressed);
 246
 247         r = LZ4_decompress_safe(buf, huge, r, HUGE_SIZE);
 248         assert_se(r >= 0);
 249         log_info("Decompressed → %i", r);
 250
 251         r = LZ4_decompress_safe_partial(buf, huge,
 252                                         compressed,
 253                                         12, HUGE_SIZE);
 254         assert_se(r >= 0);
 255         log_info("Decompressed partial %i/%i → %i", 12, HUGE_SIZE, r);
 256
 257         for (size_t size = 1; size < sizeof(buf2); size++) {
 258                 /* This failed in older lz4s but works in newer ones. */
 259                 r = LZ4_decompress_safe_partial(buf, buf2, compressed, size, size);
 260                 log_info("Decompressed partial %zu/%zu → %i (%s)", size, size, r,
 261                                                                    r < 0 ? "bad" : "good");
 262                 if (r >= 0 && LZ4_versionNumber() >= 10803)
 263                         /* lz4 <= 1.8.2 should fail that test, let's only check for newer ones */
 264                         assert_se(memcmp(buf2, huge, r) == 0);
 265         }
 266 }
 267 #endif
 268
 269 int main(int argc, char *argv[]) {
 270 #if HAVE_COMPRESSION
 271         _unused_ const char text[] =
 272                 "text\0foofoofoofoo AAAA aaaaaaaaa ghost busters barbarbar FFF"
 273                 "foofoofoofoo AAAA aaaaaaaaa ghost busters barbarbar FFF";
 274
 275         /* The file to test compression on can be specified as the first argument */
 276         const char *srcfile = argc > 1 ? argv[1] : argv[0];
 277
 278         char data[512] = "random\0";
 279
 280         _cleanup_free_ char *huge = NULL;
 281
 282         assert_se(huge = malloc(HUGE_SIZE));
 283         memcpy(huge, "HUGE=", STRLEN("HUGE="));
 284         memset(&huge[STRLEN("HUGE=")], 'x', HUGE_SIZE - STRLEN("HUGE=") - 1);
 285         huge[HUGE_SIZE - 1] = '\0';
 286
 287         test_setup_logging(LOG_DEBUG);
 288
 289         random_bytes(data + 7, sizeof(data) - 7);
 290
 291 #if HAVE_XZ
 292         test_compress_decompress("XZ", compress_blob_xz, decompress_blob_xz,
 293                                  text, sizeof(text), false);
 294         test_compress_decompress("XZ", compress_blob_xz, decompress_blob_xz,
 295                                  data, sizeof(data), true);
 296
 297         test_decompress_startswith("XZ",
 298                                    compress_blob_xz, decompress_startswith_xz,
 299                                    text, sizeof(text), false);
 300         test_decompress_startswith("XZ",
 301                                    compress_blob_xz, decompress_startswith_xz,
 302                                    data, sizeof(data), true);
 303         test_decompress_startswith("XZ",
 304                                    compress_blob_xz, decompress_startswith_xz,
 305                                    huge, HUGE_SIZE, true);
 306
 307         test_compress_stream("XZ", "xzcat",
 308                              compress_stream_xz, decompress_stream_xz, srcfile);
 309
 310         test_decompress_startswith_short("XZ", compress_blob_xz, decompress_startswith_xz);
 311
 312 #else
 313         log_info("/* XZ test skipped */");
 314 #endif
 315
 316 #if HAVE_LZ4
 317         test_compress_decompress("LZ4", compress_blob_lz4, decompress_blob_lz4,
 318                                  text, sizeof(text), false);
 319         test_compress_decompress("LZ4", compress_blob_lz4, decompress_blob_lz4,
 320                                  data, sizeof(data), true);
 321
 322         test_decompress_startswith("LZ4",
 323                                    compress_blob_lz4, decompress_startswith_lz4,
 324                                    text, sizeof(text), false);
 325         test_decompress_startswith("LZ4",
 326                                    compress_blob_lz4, decompress_startswith_lz4,
 327                                    data, sizeof(data), true);
 328         test_decompress_startswith("LZ4",
 329                                    compress_blob_lz4, decompress_startswith_lz4,
 330                                    huge, HUGE_SIZE, true);
 331
 332         test_compress_stream("LZ4", "lz4cat",
 333                              compress_stream_lz4, decompress_stream_lz4, srcfile);
 334
 335         test_lz4_decompress_partial();
 336
 337         test_decompress_startswith_short("LZ4", compress_blob_lz4, decompress_startswith_lz4);
 338
 339 #else
 340         log_info("/* LZ4 test skipped */");
 341 #endif
 342
 343 #if HAVE_ZSTD
 344         test_compress_decompress("ZSTD", compress_blob_zstd, decompress_blob_zstd,
 345                                  text, sizeof(text), false);
 346         test_compress_decompress("ZSTD", compress_blob_zstd, decompress_blob_zstd,
 347                                  data, sizeof(data), true);
 348
 349         test_decompress_startswith("ZSTD",
 350                                    compress_blob_zstd, decompress_startswith_zstd,
 351                                    text, sizeof(text), false);
 352         test_decompress_startswith("ZSTD",
 353                                    compress_blob_zstd, decompress_startswith_zstd,
 354                                    data, sizeof(data), true);
 355         test_decompress_startswith("ZSTD",
 356                                    compress_blob_zstd, decompress_startswith_zstd,
 357                                    huge, HUGE_SIZE, true);
 358
 359         test_compress_stream("ZSTD", "zstdcat",
 360                              compress_stream_zstd, decompress_stream_zstd, srcfile);
 361
 362         test_decompress_startswith_short("ZSTD", compress_blob_zstd, decompress_startswith_zstd);
 363 #else
 364         log_info("/* ZSTD test skipped */");
 365 #endif
 366
 367         return 0;
 368 #else
 369         log_info("/* XZ, LZ4 and ZSTD tests skipped */");
 370         return EXIT_TEST_SKIP;
 371 #endif
 372 }