electrobun 0.0.1 → 0.0.3

package/src/bsdiff/zstd/contrib/seekable_format/examples/seekable_decompression_mem.c

@@ -1,147 +0,0 @@
-/*
- * Copyright (c) Meta Platforms, Inc. and affiliates.
- * 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).
- */
-
-
-#include <stdlib.h>    // malloc, exit
-#include <stdio.h>     // fprintf, perror, feof
-#include <string.h>    // strerror
-#include <errno.h>     // errno
-#define ZSTD_STATIC_LINKING_ONLY
-#include <zstd.h>      // presumes zstd library is installed
-#include <zstd_errors.h>
-
-#include "zstd_seekable.h"
-
-#define MIN(a, b) ((a) < (b) ? (a) : (b))
-
-#define MAX_FILE_SIZE (8 * 1024 * 1024)
-
-static void* malloc_orDie(size_t size)
-{
-    void* const buff = malloc(size);
-    if (buff) return buff;
-    /* error */
-    perror("malloc");
-    exit(1);
-}
-
-static void* realloc_orDie(void* ptr, size_t size)
-{
-    ptr = realloc(ptr, size);
-    if (ptr) return ptr;
-    /* error */
-    perror("realloc");
-    exit(1);
-}
-
-static FILE* fopen_orDie(const char *filename, const char *instruction)
-{
-    FILE* const inFile = fopen(filename, instruction);
-    if (inFile) return inFile;
-    /* error */
-    perror(filename);
-    exit(3);
-}
-
-static size_t fread_orDie(void* buffer, size_t sizeToRead, FILE* file)
-{
-    size_t const readSize = fread(buffer, 1, sizeToRead, file);
-    if (readSize == sizeToRead) return readSize;   /* good */
-    if (feof(file)) return readSize;   /* good, reached end of file */
-    /* error */
-    perror("fread");
-    exit(4);
-}
-
-static size_t fwrite_orDie(const void* buffer, size_t sizeToWrite, FILE* file)
-{
-    size_t const writtenSize = fwrite(buffer, 1, sizeToWrite, file);
-    if (writtenSize == sizeToWrite) return sizeToWrite;   /* good */
-    /* error */
-    perror("fwrite");
-    exit(5);
-}
-
-static size_t fclose_orDie(FILE* file)
-{
-    if (!fclose(file)) return 0;
-    /* error */
-    perror("fclose");
-    exit(6);
-}
-
-static void fseek_orDie(FILE* file, long int offset, int origin) {
-    if (!fseek(file, offset, origin)) {
-        if (!fflush(file)) return;
-    }
-    /* error */
-    perror("fseek");
-    exit(7);
-}
-
-
-static void decompressFile_orDie(const char* fname, off_t startOffset, off_t endOffset)
-{
-    FILE* const fin  = fopen_orDie(fname, "rb");
-    FILE* const fout = stdout;
-    // Just for demo purposes, assume file is <= MAX_FILE_SIZE
-    void*  const buffIn = malloc_orDie(MAX_FILE_SIZE);
-    size_t const inSize = fread_orDie(buffIn, MAX_FILE_SIZE, fin);
-    size_t const buffOutSize = ZSTD_DStreamOutSize();  /* Guarantee to successfully flush at least one complete compressed block in all circumstances. */
-    void*  const buffOut = malloc_orDie(buffOutSize);
-
-    ZSTD_seekable* const seekable = ZSTD_seekable_create();
-    if (seekable==NULL) { fprintf(stderr, "ZSTD_seekable_create() error \n"); exit(10); }
-
-    size_t const initResult = ZSTD_seekable_initBuff(seekable, buffIn, inSize);
-    if (ZSTD_isError(initResult)) { fprintf(stderr, "ZSTD_seekable_init() error : %s \n", ZSTD_getErrorName(initResult)); exit(11); }
-
-    while (startOffset < endOffset) {
-        size_t const result = ZSTD_seekable_decompress(seekable, buffOut, MIN(endOffset - startOffset, buffOutSize), startOffset);
-        if (!result) {
-            break;
-        }
-
-        if (ZSTD_isError(result)) {
-            fprintf(stderr, "ZSTD_seekable_decompress() error : %s \n",
-                    ZSTD_getErrorName(result));
-            exit(12);
-        }
-        fwrite_orDie(buffOut, result, fout);
-        startOffset += result;
-    }
-
-    ZSTD_seekable_free(seekable);
-    fclose_orDie(fin);
-    fclose_orDie(fout);
-    free(buffIn);
-    free(buffOut);
-}
-
-
-int main(int argc, const char** argv)
-{
-    const char* const exeName = argv[0];
-
-    if (argc!=4) {
-        fprintf(stderr, "wrong arguments\n");
-        fprintf(stderr, "usage:\n");
-        fprintf(stderr, "%s FILE START END\n", exeName);
-        return 1;
-    }
-
-    {
-        const char* const inFilename = argv[1];
-        off_t const startOffset = atoll(argv[2]);
-        off_t const endOffset = atoll(argv[3]);
-        decompressFile_orDie(inFilename, startOffset, endOffset);
-    }
-
-    return 0;
-}

package/src/bsdiff/zstd/contrib/seekable_format/tests/Makefile

@@ -1,38 +0,0 @@
-# ################################################################
-# Copyright (c) Meta Platforms, Inc. and affiliates.
-# 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).
-# ################################################################
-
-# This Makefile presumes libzstd is built, using `make` in / or /lib/
-
-ZSTDLIB_PATH = ../../../lib
-ZSTDLIB_NAME = libzstd.a
-ZSTDLIB = $(ZSTDLIB_PATH)/$(ZSTDLIB_NAME)
-
-CPPFLAGS += -DXXH_NAMESPACE=ZSTD_ -I../ -I$(ZSTDLIB_PATH) -I$(ZSTDLIB_PATH)/common
-
-CFLAGS ?= -O3
-CFLAGS += -g -Wall -Wextra -Wcast-qual -Wcast-align -Wconversion \
-          -Wformat=2 -Wstrict-aliasing=1
-
-SEEKABLE_OBJS = ../zstdseek_compress.c ../zstdseek_decompress.c $(ZSTDLIB)
-
-.PHONY: default clean test
-default: test
-
-test: seekable_tests
-	./seekable_tests
-
-$(ZSTDLIB):
-	$(MAKE) -C $(ZSTDLIB_PATH) $(ZSTDLIB_NAME)
-
-seekable_tests : $(SEEKABLE_OBJS)
-
-clean:
-	@$(RM) core *.o tmp* result* *.zst \
-		seekable_tests
-	@echo Cleaning completed

package/src/bsdiff/zstd/contrib/seekable_format/tests/seekable_tests.c

@@ -1,363 +0,0 @@
-#include <stddef.h>
-#include <stdint.h>
-#include <stdlib.h>  // malloc
-#include <stdio.h>
-#include <assert.h>
-#include <string.h>
-
-#include "../zstd_seekable.h"
-
-
-/* ZSTD_seekable_customFile implementation that reads/seeks a buffer while keeping track of total bytes read */
-typedef struct {
-    const void *ptr;
-    size_t size;
-    size_t pos;
-    size_t totalRead;
-} buffWrapperWithTotal_t;
-
-static int readBuffWithTotal(void* opaque, void* buffer, size_t n)
-{
-    buffWrapperWithTotal_t* const buff = (buffWrapperWithTotal_t*)opaque;
-    assert(buff != NULL);
-    if (buff->pos + n > buff->size) return -1;
-    memcpy(buffer, (const char*)buff->ptr + buff->pos, n);
-    buff->pos += n;
-    buff->totalRead += n;
-    return 0;
-}
-
-static int seekBuffWithTotal(void* opaque, long long offset, int origin)
-{
-    buffWrapperWithTotal_t* const buff = (buffWrapperWithTotal_t*) opaque;
-    unsigned long long newOffset;
-    assert(buff != NULL);
-    switch (origin) {
-    case SEEK_SET:
-        assert(offset >= 0);
-        newOffset = (unsigned long long)offset;
-        break;
-    case SEEK_CUR:
-        newOffset = (unsigned long long)((long long)buff->pos + offset);
-        break;
-    case SEEK_END:
-        newOffset = (unsigned long long)((long long)buff->size + offset);
-        break;
-    default:
-        assert(0);  /* not possible */
-    }
-    if (newOffset > buff->size) {
-        return -1;
-    }
-    buff->pos = newOffset;
-    return 0;
-}
-
-/* Basic unit tests for zstd seekable format */
-int main(int argc, const char** argv)
-{
-    unsigned testNb = 1;
-    (void)argc; (void)argv;
-    printf("Beginning zstd seekable format tests...\n");
-
-    printf("Test %u - simple round trip: ", testNb++);
-    {   size_t const inSize = 4000;
-        void* const inBuffer = malloc(inSize);
-        assert(inBuffer != NULL);
-
-        size_t const seekCapacity = 5000;
-        void* const seekBuffer = malloc(seekCapacity);
-        assert(seekBuffer != NULL);
-        size_t seekSize;
-
-        size_t const outCapacity = inSize;
-        void* const outBuffer = malloc(outCapacity);
-        assert(outBuffer != NULL);
-
-        ZSTD_seekable_CStream* const zscs = ZSTD_seekable_createCStream();
-        assert(zscs != NULL);
-
-        { size_t const initStatus = ZSTD_seekable_initCStream(zscs, 9, 0 /* checksumFlag */, (unsigned)inSize /* maxFrameSize */);
-          assert(!ZSTD_isError(initStatus));
-        }
-
-        {   ZSTD_outBuffer outb = { .dst=seekBuffer, .pos=0, .size=seekCapacity };
-            ZSTD_inBuffer inb = { .src=inBuffer, .pos=0, .size=inSize };
-
-            size_t const cStatus = ZSTD_seekable_compressStream(zscs, &outb, &inb);
-            assert(!ZSTD_isError(cStatus));
-            assert(inb.pos == inb.size);
-
-            size_t const endStatus = ZSTD_seekable_endStream(zscs, &outb);
-            assert(!ZSTD_isError(endStatus));
-            seekSize = outb.pos;
-        }
-
-        ZSTD_seekable* const stream = ZSTD_seekable_create();
-        assert(stream != NULL);
-        { size_t const initStatus = ZSTD_seekable_initBuff(stream, seekBuffer, seekSize);
-          assert(!ZSTD_isError(initStatus)); }
-
-        { size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, outCapacity, 0);
-          assert(decStatus == inSize); }
-
-        /* unit test ZSTD_seekTable functions */
-        ZSTD_seekTable* const zst = ZSTD_seekTable_create_fromSeekable(stream);
-        assert(zst != NULL);
-
-        unsigned const nbFrames = ZSTD_seekTable_getNumFrames(zst);
-        assert(nbFrames > 0);
-
-        unsigned long long const frame0Offset = ZSTD_seekTable_getFrameCompressedOffset(zst, 0);
-        assert(frame0Offset == 0);
-
-        unsigned long long const content0Offset = ZSTD_seekTable_getFrameDecompressedOffset(zst, 0);
-        assert(content0Offset == 0);
-
-        size_t const cSize = ZSTD_seekTable_getFrameCompressedSize(zst, 0);
-        assert(!ZSTD_isError(cSize));
-        assert(cSize <= seekCapacity);
-
-        size_t const origSize = ZSTD_seekTable_getFrameDecompressedSize(zst, 0);
-        assert(origSize == inSize);
-
-        unsigned const fo1idx = ZSTD_seekTable_offsetToFrameIndex(zst, 1);
-        assert(fo1idx == 0);
-
-        free(inBuffer);
-        free(seekBuffer);
-        free(outBuffer);
-        ZSTD_seekable_freeCStream(zscs);
-        ZSTD_seekTable_free(zst);
-        ZSTD_seekable_free(stream);
-    }
-    printf("Success!\n");
-
-
-    printf("Test %u - check that seekable decompress does not hang: ", testNb++);
-    {   /* Github issue #2335 */
-        const size_t compressed_size = 17;
-        const uint8_t compressed_data[17] = {
-            '^',
-            '*',
-            'M',
-            '\x18',
-            '\t',
-            '\x00',
-            '\x00',
-            '\x00',
-            '\x00',
-            '\x00',
-            '\x00',
-            '\x00',
-            (uint8_t)('\x03'),
-            (uint8_t)('\xb1'),
-            (uint8_t)('\xea'),
-            (uint8_t)('\x92'),
-            (uint8_t)('\x8f'),
-        };
-        const size_t uncompressed_size = 32;
-        uint8_t uncompressed_data[32];
-
-        ZSTD_seekable* const stream = ZSTD_seekable_create();
-        assert(stream != NULL);
-        {   size_t const status = ZSTD_seekable_initBuff(stream, compressed_data, compressed_size);
-            if (ZSTD_isError(status)) {
-                ZSTD_seekable_free(stream);
-                goto _test_error;
-        }   }
-
-        /* Should return an error, but not hang */
-        {   const size_t offset = 2;
-            size_t const status = ZSTD_seekable_decompress(stream, uncompressed_data, uncompressed_size, offset);
-            if (!ZSTD_isError(status)) {
-                ZSTD_seekable_free(stream);
-                goto _test_error;
-        }   }
-
-        ZSTD_seekable_free(stream);
-    }
-    printf("Success!\n");
-
-    printf("Test %u - check #2 that seekable decompress does not hang: ", testNb++);
-    {   /* Github issue #FIXME */
-        const size_t compressed_size = 27;
-        const uint8_t compressed_data[27] = {
-            (uint8_t)'\x28',
-            (uint8_t)'\xb5',
-            (uint8_t)'\x2f',
-            (uint8_t)'\xfd',
-            (uint8_t)'\x00',
-            (uint8_t)'\x32',
-            (uint8_t)'\x91',
-            (uint8_t)'\x00',
-            (uint8_t)'\x00',
-            (uint8_t)'\x00',
-            (uint8_t)'\x5e',
-            (uint8_t)'\x2a',
-            (uint8_t)'\x4d',
-            (uint8_t)'\x18',
-            (uint8_t)'\x09',
-            (uint8_t)'\x00',
-            (uint8_t)'\x00',
-            (uint8_t)'\x00',
-            (uint8_t)'\x00',
-            (uint8_t)'\x00',
-            (uint8_t)'\x00',
-            (uint8_t)'\x00',
-            (uint8_t)'\x00',
-            (uint8_t)'\xb1',
-            (uint8_t)'\xea',
-            (uint8_t)'\x92',
-            (uint8_t)'\x8f',
-        };
-        const size_t uncompressed_size = 400;
-        uint8_t uncompressed_data[400];
-
-        ZSTD_seekable* stream = ZSTD_seekable_create();
-        size_t status = ZSTD_seekable_initBuff(stream, compressed_data, compressed_size);
-        if (ZSTD_isError(status)) {
-            ZSTD_seekable_free(stream);
-            goto _test_error;
-        }
-
-        const size_t offset = 2;
-        /* Should return an error, but not hang */
-        status = ZSTD_seekable_decompress(stream, uncompressed_data, uncompressed_size, offset);
-        if (!ZSTD_isError(status)) {
-            ZSTD_seekable_free(stream);
-            goto _test_error;
-        }
-
-        ZSTD_seekable_free(stream);
-    }
-    printf("Success!\n");
-
-
-    printf("Test %u - check ZSTD magic in compressing empty string: ", testNb++);
-    { // compressing empty string should return a zstd header
-        size_t const capacity = 255;
-        char* inBuffer = malloc(capacity);
-        assert(inBuffer != NULL);
-        inBuffer[0] = '\0';
-        void* const outBuffer = malloc(capacity);
-        assert(outBuffer != NULL);
-
-        ZSTD_seekable_CStream *s = ZSTD_seekable_createCStream();
-        ZSTD_seekable_initCStream(s, 1, 1, 255);
-
-        ZSTD_inBuffer input = { .src=inBuffer, .pos=0, .size=0 };
-        ZSTD_outBuffer output = { .dst=outBuffer, .pos=0, .size=capacity };
-
-        ZSTD_seekable_compressStream(s, &output, &input);
-        ZSTD_seekable_endStream(s, &output);
-
-        if((((char*)output.dst)[0] != '\x28') | (((char*)output.dst)[1] != '\xb5') | (((char*)output.dst)[2] != '\x2f') | (((char*)output.dst)[3] != '\xfd')) {
-            printf("%#02x %#02x %#02x %#02x\n", ((char*)output.dst)[0], ((char*)output.dst)[1] , ((char*)output.dst)[2] , ((char*)output.dst)[3] );
-
-            free(inBuffer);
-            free(outBuffer);
-            ZSTD_seekable_freeCStream(s);
-            goto _test_error;
-        }
-
-        free(inBuffer);
-        free(outBuffer);
-        ZSTD_seekable_freeCStream(s);
-    }
-    printf("Success!\n");
-
-
-    printf("Test %u - multiple decompress calls: ", testNb++);
-    {   char const inBuffer[] = "Lorem ipsum dolor sit amet, consectetur adipiscing elit, sed do eiusmod tempor incididunt";
-        size_t const inSize = sizeof(inBuffer);
-
-        size_t const seekCapacity = 5000;
-        void* const seekBuffer = malloc(seekCapacity);
-        assert(seekBuffer != NULL);
-        size_t seekSize;
-
-        size_t const outCapacity = inSize;
-        char* const outBuffer = malloc(outCapacity);
-        assert(outBuffer != NULL);
-
-        ZSTD_seekable_CStream* const zscs = ZSTD_seekable_createCStream();
-        assert(zscs != NULL);
-
-        /* compress test data with a small frame size to ensure multiple frames in the output */
-        unsigned const maxFrameSize = 40;
-        { size_t const initStatus = ZSTD_seekable_initCStream(zscs, 9, 0 /* checksumFlag */, maxFrameSize);
-          assert(!ZSTD_isError(initStatus));
-        }
-
-        {   ZSTD_outBuffer outb = { .dst=seekBuffer, .pos=0, .size=seekCapacity };
-            ZSTD_inBuffer inb = { .src=inBuffer, .pos=0, .size=inSize };
-
-            while (inb.pos < inb.size) {
-                size_t const cStatus = ZSTD_seekable_compressStream(zscs, &outb, &inb);
-                assert(!ZSTD_isError(cStatus));
-            }
-
-            size_t const endStatus = ZSTD_seekable_endStream(zscs, &outb);
-            assert(!ZSTD_isError(endStatus));
-            seekSize = outb.pos;
-        }
-
-        ZSTD_seekable* const stream = ZSTD_seekable_create();
-        assert(stream != NULL);
-        buffWrapperWithTotal_t buffWrapper = {seekBuffer, seekSize, 0, 0};
-        { ZSTD_seekable_customFile srcFile = {&buffWrapper, &readBuffWithTotal, &seekBuffWithTotal};
-          size_t const initStatus = ZSTD_seekable_initAdvanced(stream, srcFile);
-          assert(!ZSTD_isError(initStatus)); }
-
-        /* Perform a series of small reads and seeks (repeatedly read 1 byte and skip 1 byte)
-           and check that we didn't reread input data unnecessarily */
-        size_t pos;
-        for (pos = 0; pos < inSize; pos += 2) {
-            size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, 1, pos);
-            if (decStatus != 1 || outBuffer[0] != inBuffer[pos]) {
-                goto _test_error;
-            }
-        }
-        if (buffWrapper.totalRead > seekSize) {
-            /* We read more than the compressed size, meaning there were some rereads.
-               This is unneeded because we only seeked forward. */
-            printf("Too much data read: %zu read, with compressed size %zu\n", buffWrapper.totalRead, seekSize);
-            goto _test_error;
-        }
-
-        /* Perform some reads and seeks to ensure correctness */
-        struct {
-            size_t offset;
-            size_t size;
-        } const tests[] = {  /* Assume the frame size is 40 */
-            {20, 40}, /* read partial data from two frames */
-            {60, 10}, /* continue reading from the same offset */
-            {50, 20}, /* seek backward within the same frame */
-            {10, 10}, /* seek backward to a different frame */
-            {25, 10}, /* seek forward within the same frame */
-            {60, 10}, /* seek forward to a different frame */
-        };
-        size_t idx;
-        for (idx = 0; idx < sizeof(tests) / sizeof(tests[0]); idx++) {
-            size_t const decStatus = ZSTD_seekable_decompress(stream, outBuffer, tests[idx].size, tests[idx].offset);
-            if (decStatus != tests[idx].size || memcmp(outBuffer, inBuffer + tests[idx].offset, tests[idx].size) != 0) {
-                goto _test_error;
-            }
-        }
-
-        free(seekBuffer);
-        free(outBuffer);
-        ZSTD_seekable_freeCStream(zscs);
-        ZSTD_seekable_free(stream);
-    }
-    printf("Success!\n");
-
-    /* TODO: Add more tests */
-    printf("Finished tests\n");
-    return 0;
-
-_test_error:
-    printf("test failed! Exiting..\n");
-    return 1;
-}