update source to Ceph Pacific 16.2.2

[ceph.git] / ceph / src / zstd / doc / educational_decoder / harness.c

diff --git a/ceph/src/zstd/doc/educational_decoder/harness.c b/ceph/src/zstd/doc/educational_decoder/harness.c
index 47882b1689537253cf685deb91a8ffd795ccf916..1403a6ed655b49e365f5a00ae115b27a670726fa 100644 (file)
--- a/ceph/src/zstd/doc/educational_decoder/harness.c
+++ b/ceph/src/zstd/doc/educational_decoder/harness.c
@@ -1,10 +1,11 @@
 /*
- * Copyright (c) 2017-present, Facebook, Inc.
+ * Copyright (c) 2017-2020, Facebook, Inc.
  * All rights reserved.
  *
  * This source code is licensed under both the BSD-style license (found in the
  * LICENSE file in the root directory of this source tree) and the GPLv2 (found
  * in the COPYING file in the root directory of this source tree).
+ * You may select, at your option, one of the above-listed licenses.
  */
 
 #include <stdio.h>
@@ -21,105 +22,98 @@ typedef unsigned char u8;
 // Protect against allocating too much memory for output
 #define MAX_OUTPUT_SIZE ((size_t)1024 * 1024 * 1024)
 
-u8 *input;
-u8 *output;
-u8 *dict;
+// Error message then exit
+#define ERR_OUT(...) { fprintf(stderr, __VA_ARGS__); exit(1); }
 
-size_t read_file(const char *path, u8 **ptr) {
-    FILE *f = fopen(path, "rb");
-    if (!f) {
-        fprintf(stderr, "failed to open file %s\n", path);
-        exit(1);
-    }
+
+typedef struct {
+    u8* address;
+    size_t size;
+} buffer_s;
+
+static void freeBuffer(buffer_s b) { free(b.address); }
+
+static buffer_s read_file(const char *path)
+{
+    FILE* const f = fopen(path, "rb");
+    if (!f) ERR_OUT("failed to open file %s \n", path);
 
     fseek(f, 0L, SEEK_END);
-    size_t size = ftell(f);
+    size_t const size = (size_t)ftell(f);
     rewind(f);
 
-    *ptr = malloc(size);
-    if (!ptr) {
-        fprintf(stderr, "failed to allocate memory to hold %s\n", path);
-        exit(1);
-    }
+    void* const ptr = malloc(size);
+    if (!ptr) ERR_OUT("failed to allocate memory to hold %s \n", path);
 
-    size_t pos = 0;
-    while (!feof(f)) {
-        size_t read = fread(&(*ptr)[pos], 1, size, f);
-        if (ferror(f)) {
-            fprintf(stderr, "error while reading file %s\n", path);
-            exit(1);
-        }
-        pos += read;
-    }
+    size_t const read = fread(ptr, 1, size, f);
+    if (read != size) ERR_OUT("error while reading file %s \n", path);
 
     fclose(f);
-
-    return pos;
+    buffer_s const b = { ptr, size };
+    return b;
 }
 
-void write_file(const char *path, const u8 *ptr, size_t size) {
-    FILE *f = fopen(path, "wb");
+static void write_file(const char* path, const u8* ptr, size_t size)
+{
+    FILE* const f = fopen(path, "wb");
+    if (!f) ERR_OUT("failed to open file %s \n", path);
 
     size_t written = 0;
     while (written < size) {
-        written += fwrite(&ptr[written], 1, size, f);
-        if (ferror(f)) {
-            fprintf(stderr, "error while writing file %s\n", path);
-            exit(1);
-        }
+        written += fwrite(ptr+written, 1, size, f);
+        if (ferror(f)) ERR_OUT("error while writing file %s\n", path);
     }
 
     fclose(f);
 }
 
-int main(int argc, char **argv) {
-    if (argc < 3) {
-        fprintf(stderr, "usage: %s <file.zst> <out_path> [dictionary]\n",
-                argv[0]);
+int main(int argc, char **argv)
+{
+    if (argc < 3)
+        ERR_OUT("usage: %s <file.zst> <out_path> [dictionary] \n", argv[0]);
 
-        return 1;
-    }
+    buffer_s const input = read_file(argv[1]);
 
-    size_t input_size = read_file(argv[1], &input);
-    size_t dict_size = 0;
+    buffer_s dict = { NULL, 0 };
     if (argc >= 4) {
-        dict_size = read_file(argv[3], &dict);
+        dict = read_file(argv[3]);
     }
 
-    size_t decompressed_size = ZSTD_get_decompressed_size(input, input_size);
-    if (decompressed_size == (size_t)-1) {
-        decompressed_size = MAX_COMPRESSION_RATIO * input_size;
+    size_t out_capacity = ZSTD_get_decompressed_size(input.address, input.size);
+    if (out_capacity == (size_t)-1) {
+        out_capacity = MAX_COMPRESSION_RATIO * input.size;
         fprintf(stderr, "WARNING: Compressed data does not contain "
                         "decompressed size, going to assume the compression "
                         "ratio is at most %d (decompressed size of at most "
-                        "%zu)\n",
-                MAX_COMPRESSION_RATIO, decompressed_size);
-    }
-    if (decompressed_size > MAX_OUTPUT_SIZE) {
-        fprintf(stderr,
-                "Required output size too large for this implementation\n");
-        return 1;
-    }
-    output = malloc(decompressed_size);
-    if (!output) {
-        fprintf(stderr, "failed to allocate memory\n");
-        return 1;
+                        "%u) \n",
+                MAX_COMPRESSION_RATIO, (unsigned)out_capacity);
     }
+    if (out_capacity > MAX_OUTPUT_SIZE)
+        ERR_OUT("Required output size too large for this implementation \n");
+
+    u8* const output = malloc(out_capacity);
+    if (!output) ERR_OUT("failed to allocate memory \n");
 
     dictionary_t* const parsed_dict = create_dictionary();
-    if (dict) {
-        parse_dictionary(parsed_dict, dict, dict_size);
+    if (dict.size) {
+#if defined (ZDEC_NO_DICTIONARY)
+        printf("dict.size = %zu \n", dict.size);
+        ERR_OUT("no dictionary support \n");
+#else
+        parse_dictionary(parsed_dict, dict.address, dict.size);
+#endif
     }
-    size_t decompressed =
-        ZSTD_decompress_with_dict(output, decompressed_size,
-                                  input, input_size, parsed_dict);
+    size_t const decompressed_size =
+        ZSTD_decompress_with_dict(output, out_capacity,
+                                  input.address, input.size,
+                                  parsed_dict);
 
     free_dictionary(parsed_dict);
 
-    write_file(argv[2], output, decompressed);
+    write_file(argv[2], output, decompressed_size);
 
-    free(input);
+    freeBuffer(input);
+    freeBuffer(dict);
     free(output);
-    free(dict);
-    input = output = dict = NULL;
+    return 0;
 }