* Fixed tab formatting in fuzzers.
* Fixed function argument spacing.
* Fixed whitespace in comments and strings.
static void check_compress_level(uint8_t *compr, size_t comprLen,
uint8_t *uncompr, size_t uncomprLen,
int level) {
- PREFIX(compress2)(compr, &comprLen, data, dataLen, level);
- PREFIX(uncompress)(uncompr, &uncomprLen, compr, comprLen);
+ PREFIX(compress2)(compr, &comprLen, data, dataLen, level);
+ PREFIX(uncompress)(uncompr, &uncomprLen, compr, comprLen);
- /* Make sure compress + uncompress gives back the input data. */
- assert(dataLen == uncomprLen);
- assert(0 == memcmp(data, uncompr, dataLen));
+ /* Make sure compress + uncompress gives back the input data. */
+ assert(dataLen == uncomprLen);
+ assert(0 == memcmp(data, uncompr, dataLen));
}
#define put_byte(s, i, c) {s[i] = (unsigned char)(c);}
static void write_zlib_header(uint8_t *s) {
- unsigned level_flags = 0; /* compression level (0..3) */
- unsigned w_bits = 8; /* window size log2(w_size) (8..16) */
- unsigned int header = (Z_DEFLATED + ((w_bits-8)<<4)) << 8;
- header |= (level_flags << 6);
+ unsigned level_flags = 0; /* compression level (0..3) */
+ unsigned w_bits = 8; /* window size log2(w_size) (8..16) */
+ unsigned int header = (Z_DEFLATED + ((w_bits-8)<<4)) << 8;
+ header |= (level_flags << 6);
- header += 31 - (header % 31);
+ header += 31 - (header % 31);
- /* s is guaranteed to be longer than 2 bytes. */
- put_byte(s, 0, (unsigned char)(header >> 8));
- put_byte(s, 1, (unsigned char)(header & 0xff));
+ /* s is guaranteed to be longer than 2 bytes. */
+ put_byte(s, 0, (unsigned char)(header >> 8));
+ put_byte(s, 1, (unsigned char)(header & 0xff));
}
static void check_decompress(uint8_t *compr, size_t comprLen) {
- /* We need to write a valid zlib header of size two bytes. Copy the input data
- in a larger buffer. Do not modify the input data to avoid libFuzzer error:
- fuzz target overwrites its const input. */
- size_t copyLen = dataLen + 2;
- uint8_t *copy = (uint8_t *)malloc(copyLen);
- memcpy(copy + 2, data, dataLen);
- write_zlib_header(copy);
-
- PREFIX(uncompress)(compr, &comprLen, copy, copyLen);
- free(copy);
+ /* We need to write a valid zlib header of size two bytes. Copy the input data
+ in a larger buffer. Do not modify the input data to avoid libFuzzer error:
+ fuzz target overwrites its const input. */
+ size_t copyLen = dataLen + 2;
+ uint8_t *copy = (uint8_t *)malloc(copyLen);
+ memcpy(copy + 2, data, dataLen);
+ write_zlib_header(copy);
+
+ PREFIX(uncompress)(compr, &comprLen, copy, copyLen);
+ free(copy);
}
int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) {
- /* compressBound does not provide enough space for low compression levels. */
- size_t comprLen = 100 + 2 * PREFIX(compressBound)(size);
- size_t uncomprLen = size;
- uint8_t *compr, *uncompr;
+ /* compressBound does not provide enough space for low compression levels. */
+ size_t comprLen = 100 + 2 * PREFIX(compressBound)(size);
+ size_t uncomprLen = size;
+ uint8_t *compr, *uncompr;
- /* Discard inputs larger than 1Mb. */
- static size_t kMaxSize = 1024 * 1024;
+ /* Discard inputs larger than 1Mb. */
+ static size_t kMaxSize = 1024 * 1024;
- if (size < 1 || size > kMaxSize)
- return 0;
+ if (size < 1 || size > kMaxSize)
+ return 0;
- data = d;
- dataLen = size;
- compr = (uint8_t *)calloc(1, comprLen);
- uncompr = (uint8_t *)calloc(1, uncomprLen);
+ data = d;
+ dataLen = size;
+ compr = (uint8_t *)calloc(1, comprLen);
+ uncompr = (uint8_t *)calloc(1, uncomprLen);
- check_compress_level(compr, comprLen, uncompr, uncomprLen, 1);
- check_compress_level(compr, comprLen, uncompr, uncomprLen, 3);
- check_compress_level(compr, comprLen, uncompr, uncomprLen, 6);
- check_compress_level(compr, comprLen, uncompr, uncomprLen, 7);
+ check_compress_level(compr, comprLen, uncompr, uncomprLen, 1);
+ check_compress_level(compr, comprLen, uncompr, uncomprLen, 3);
+ check_compress_level(compr, comprLen, uncompr, uncomprLen, 6);
+ check_compress_level(compr, comprLen, uncompr, uncomprLen, 7);
- check_decompress(compr, comprLen);
+ check_decompress(compr, comprLen);
- free(compr);
- free(uncompr);
+ free(compr);
+ free(uncompr);
- /* This function must return 0. */
- return 0;
+ /* This function must return 0. */
+ return 0;
}
* Test inflate() with a preset dictionary
*/
void test_dict_inflate(unsigned char *compr, size_t comprLen) {
- int err;
- PREFIX3(stream) d_stream; /* decompression stream */
- unsigned char *uncompr;
-
- d_stream.zalloc = zalloc;
- d_stream.zfree = zfree;
- d_stream.opaque = (void *)0;
-
- d_stream.next_in = compr;
- d_stream.avail_in = (unsigned int)comprLen;
-
- err = PREFIX(inflateInit)(&d_stream);
- CHECK_ERR(err, "inflateInit");
-
- uncompr = (uint8_t *)calloc(1, dataLen);
- d_stream.next_out = uncompr;
- d_stream.avail_out = (unsigned int)dataLen;
-
- for (;;) {
- err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH);
- if (err == Z_STREAM_END)
- break;
- if (err == Z_NEED_DICT) {
- if (d_stream.adler != dictId) {
- fprintf(stderr, "unexpected dictionary");
- exit(1);
- }
- err = PREFIX(inflateSetDictionary)(
- &d_stream, (const unsigned char *)data, dictionaryLen);
+ int err;
+ PREFIX3(stream) d_stream; /* decompression stream */
+ unsigned char *uncompr;
+
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (void *)0;
+
+ d_stream.next_in = compr;
+ d_stream.avail_in = (unsigned int)comprLen;
+
+ err = PREFIX(inflateInit)(&d_stream);
+ CHECK_ERR(err, "inflateInit");
+
+ uncompr = (uint8_t *)calloc(1, dataLen);
+ d_stream.next_out = uncompr;
+ d_stream.avail_out = (unsigned int)dataLen;
+
+ for (;;) {
+ err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH);
+ if (err == Z_STREAM_END)
+ break;
+ if (err == Z_NEED_DICT) {
+ if (d_stream.adler != dictId) {
+ fprintf(stderr, "unexpected dictionary");
+ exit(1);
+ }
+ err = PREFIX(inflateSetDictionary)(
+ &d_stream, (const unsigned char *)data, dictionaryLen);
+ }
+ CHECK_ERR(err, "inflate with dict");
}
- CHECK_ERR(err, "inflate with dict");
- }
- err = PREFIX(inflateEnd)(&d_stream);
- CHECK_ERR(err, "inflateEnd");
+ err = PREFIX(inflateEnd)(&d_stream);
+ CHECK_ERR(err, "inflateEnd");
- if (memcmp(uncompr, data, dataLen)) {
- fprintf(stderr, "bad inflate with dict\n");
- exit(1);
- }
+ if (memcmp(uncompr, data, dataLen)) {
+ fprintf(stderr, "bad inflate with dict\n");
+ exit(1);
+ }
- free(uncompr);
+ free(uncompr);
}
int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) {
- size_t comprLen = 0;
- uint8_t *compr;
+ size_t comprLen = 0;
+ uint8_t *compr;
- /* Discard inputs larger than 100Kb. */
- static size_t kMaxSize = 100 * 1024;
+ /* Discard inputs larger than 100Kb. */
+ static size_t kMaxSize = 100 * 1024;
- if (size < 1 || size > kMaxSize)
- return 0;
+ if (size < 1 || size > kMaxSize)
+ return 0;
- data = d;
- dataLen = size;
+ data = d;
+ dataLen = size;
- /* Set up the contents of the dictionary. The size of the dictionary is
- intentionally selected to be of unusual size. To help cover more corner
- cases, the size of the dictionary is read from the input data. */
- dictionaryLen = data[0];
- if (dictionaryLen > dataLen)
- dictionaryLen = dataLen;
+ /* Set up the contents of the dictionary. The size of the dictionary is
+ intentionally selected to be of unusual size. To help cover more corner
+ cases, the size of the dictionary is read from the input data. */
+ dictionaryLen = data[0];
+ if (dictionaryLen > dataLen)
+ dictionaryLen = dataLen;
- test_dict_deflate(&compr, &comprLen);
- test_dict_inflate(compr, comprLen);
+ test_dict_deflate(&compr, &comprLen);
+ test_dict_inflate(compr, comprLen);
- free(compr);
+ free(compr);
- /* This function must return 0. */
- return 0;
+ /* This function must return 0. */
+ return 0;
}
* Test deflate() with full flush
*/
void test_flush(unsigned char *compr, z_size_t *comprLen) {
- PREFIX3(stream) c_stream; /* compression stream */
- int err;
- unsigned int len = dataLen;
-
- c_stream.zalloc = zalloc;
- c_stream.zfree = zfree;
- c_stream.opaque = (void *)0;
-
- err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION);
- CHECK_ERR(err, "deflateInit");
-
- c_stream.next_in = (const unsigned char *)data;
- c_stream.next_out = compr;
- c_stream.avail_in = 3;
- c_stream.avail_out = (unsigned int)*comprLen;
- err = PREFIX(deflate)(&c_stream, Z_FULL_FLUSH);
- CHECK_ERR(err, "deflate flush 1");
-
- compr[3]++; /* force an error in first compressed block */
- c_stream.avail_in = len - 3;
-
- err = PREFIX(deflate)(&c_stream, Z_FINISH);
- if (err != Z_STREAM_END) {
- CHECK_ERR(err, "deflate flush 2");
- }
- err = PREFIX(deflateEnd)(&c_stream);
- CHECK_ERR(err, "deflateEnd");
-
- *comprLen = (z_size_t)c_stream.total_out;
+ PREFIX3(stream) c_stream; /* compression stream */
+ int err;
+ unsigned int len = dataLen;
+
+ c_stream.zalloc = zalloc;
+ c_stream.zfree = zfree;
+ c_stream.opaque = (void *)0;
+
+ err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION);
+ CHECK_ERR(err, "deflateInit");
+
+ c_stream.next_in = (const unsigned char *)data;
+ c_stream.next_out = compr;
+ c_stream.avail_in = 3;
+ c_stream.avail_out = (unsigned int)*comprLen;
+ err = PREFIX(deflate)(&c_stream, Z_FULL_FLUSH);
+ CHECK_ERR(err, "deflate flush 1");
+
+ compr[3]++; /* force an error in first compressed block */
+ c_stream.avail_in = len - 3;
+
+ err = PREFIX(deflate)(&c_stream, Z_FINISH);
+ if (err != Z_STREAM_END) {
+ CHECK_ERR(err, "deflate flush 2");
+ }
+ err = PREFIX(deflateEnd)(&c_stream);
+ CHECK_ERR(err, "deflateEnd");
+
+ *comprLen = (z_size_t)c_stream.total_out;
}
/* ===========================================================================
* Test inflateSync()
*/
-void test_sync(unsigned char *compr, size_t comprLen, unsigned char *uncompr,
- size_t uncomprLen) {
- int err;
- PREFIX3(stream) d_stream; /* decompression stream */
-
- d_stream.zalloc = zalloc;
- d_stream.zfree = zfree;
- d_stream.opaque = (void *)0;
-
- d_stream.next_in = compr;
- d_stream.avail_in = 2; /* just read the zlib header */
-
- err = PREFIX(inflateInit)(&d_stream);
- CHECK_ERR(err, "inflateInit");
-
- d_stream.next_out = uncompr;
- d_stream.avail_out = (unsigned int)uncomprLen;
-
- err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH);
- CHECK_ERR(err, "inflate");
-
- d_stream.avail_in = (unsigned int)comprLen - 2; /* read all compressed data */
- err = PREFIX(inflateSync)(&d_stream); /* but skip the damaged part */
- CHECK_ERR(err, "inflateSync");
-
- err = PREFIX(inflate)(&d_stream, Z_FINISH);
- if (err != Z_DATA_ERROR) {
- fprintf(stderr, "inflate should report DATA_ERROR\n");
- /* Because of incorrect adler32 */
- exit(1);
- }
- err = PREFIX(inflateEnd)(&d_stream);
- CHECK_ERR(err, "inflateEnd");
+void test_sync(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) {
+ int err;
+ PREFIX3(stream) d_stream; /* decompression stream */
+
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (void *)0;
+
+ d_stream.next_in = compr;
+ d_stream.avail_in = 2; /* just read the zlib header */
+
+ err = PREFIX(inflateInit)(&d_stream);
+ CHECK_ERR(err, "inflateInit");
+
+ d_stream.next_out = uncompr;
+ d_stream.avail_out = (unsigned int)uncomprLen;
+
+ err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH);
+ CHECK_ERR(err, "inflate");
+
+ d_stream.avail_in = (unsigned int)comprLen - 2; /* read all compressed data */
+ err = PREFIX(inflateSync)(&d_stream); /* but skip the damaged part */
+ CHECK_ERR(err, "inflateSync");
+
+ err = PREFIX(inflate)(&d_stream, Z_FINISH);
+ if (err != Z_DATA_ERROR) {
+ fprintf(stderr, "inflate should report DATA_ERROR\n");
+ /* Because of incorrect adler32 */
+ exit(1);
+ }
+ err = PREFIX(inflateEnd)(&d_stream);
+ CHECK_ERR(err, "inflateEnd");
}
int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) {
- size_t comprLen = 100 + 2 * PREFIX(compressBound)(size);
- size_t uncomprLen = size;
- uint8_t *compr, *uncompr;
+ size_t comprLen = 100 + 2 * PREFIX(compressBound)(size);
+ size_t uncomprLen = size;
+ uint8_t *compr, *uncompr;
- /* Discard inputs larger than 1Mb. */
- static size_t kMaxSize = 1024 * 1024;
+ /* Discard inputs larger than 1Mb. */
+ static size_t kMaxSize = 1024 * 1024;
- // This test requires at least 3 bytes of input data.
- if (size <= 3 || size > kMaxSize)
- return 0;
+ // This test requires at least 3 bytes of input data.
+ if (size <= 3 || size > kMaxSize)
+ return 0;
- data = d;
- dataLen = size;
- compr = (uint8_t *)calloc(1, comprLen);
- uncompr = (uint8_t *)calloc(1, uncomprLen);
+ data = d;
+ dataLen = size;
+ compr = (uint8_t *)calloc(1, comprLen);
+ uncompr = (uint8_t *)calloc(1, uncomprLen);
- test_flush(compr, &comprLen);
- test_sync(compr, comprLen, uncompr, uncomprLen);
+ test_flush(compr, &comprLen);
+ test_sync(compr, comprLen, uncompr, uncomprLen);
- free(compr);
- free(uncompr);
+ free(compr);
+ free(uncompr);
- /* This function must return 0. */
- return 0;
+ /* This function must return 0. */
+ return 0;
}
/* ===========================================================================
* Test deflate() with large buffers and dynamic change of compression level
*/
-void test_large_deflate(unsigned char *compr, size_t comprLen,
- unsigned char *uncompr, size_t uncomprLen) {
- PREFIX3(stream) c_stream; /* compression stream */
- int err;
-
- c_stream.zalloc = zalloc;
- c_stream.zfree = zfree;
- c_stream.opaque = (void *)0;
-
- err = PREFIX(deflateInit)(&c_stream, Z_BEST_COMPRESSION);
- CHECK_ERR(err, "deflateInit");
-
- c_stream.next_out = compr;
- c_stream.avail_out = (unsigned int)comprLen;
-
- /* At this point, uncompr is still mostly zeroes, so it should compress
- * very well:
- */
- c_stream.next_in = uncompr;
- c_stream.avail_in = (unsigned int)uncomprLen;
- err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);
- CHECK_ERR(err, "deflate large 1");
- if (c_stream.avail_in != 0) {
- fprintf(stderr, "deflate not greedy\n");
- exit(1);
- }
-
- /* Feed in already compressed data and switch to no compression: */
- PREFIX(deflateParams)(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
- c_stream.next_in = compr;
- diff = (unsigned int)(c_stream.next_out - compr);
- c_stream.avail_in = diff;
- err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);
- CHECK_ERR(err, "deflate large 2");
-
- /* Switch back to compressing mode: */
- PREFIX(deflateParams)(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
- c_stream.next_in = uncompr;
- c_stream.avail_in = (unsigned int)uncomprLen;
- err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);
- CHECK_ERR(err, "deflate large 3");
-
- err = PREFIX(deflate)(&c_stream, Z_FINISH);
- if (err != Z_STREAM_END) {
- fprintf(stderr, "deflate large should report Z_STREAM_END\n");
- exit(1);
- }
- err = PREFIX(deflateEnd)(&c_stream);
- CHECK_ERR(err, "deflateEnd");
+void test_large_deflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) {
+ PREFIX3(stream) c_stream; /* compression stream */
+ int err;
+
+ c_stream.zalloc = zalloc;
+ c_stream.zfree = zfree;
+ c_stream.opaque = (void *)0;
+
+ err = PREFIX(deflateInit)(&c_stream, Z_BEST_COMPRESSION);
+ CHECK_ERR(err, "deflateInit");
+
+ c_stream.next_out = compr;
+ c_stream.avail_out = (unsigned int)comprLen;
+
+ /* At this point, uncompr is still mostly zeroes, so it should compress
+ * very well:
+ */
+ c_stream.next_in = uncompr;
+ c_stream.avail_in = (unsigned int)uncomprLen;
+ err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);
+ CHECK_ERR(err, "deflate large 1");
+ if (c_stream.avail_in != 0) {
+ fprintf(stderr, "deflate not greedy\n");
+ exit(1);
+ }
+
+ /* Feed in already compressed data and switch to no compression: */
+ PREFIX(deflateParams)(&c_stream, Z_NO_COMPRESSION, Z_DEFAULT_STRATEGY);
+ c_stream.next_in = compr;
+ diff = (unsigned int)(c_stream.next_out - compr);
+ c_stream.avail_in = diff;
+ err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);
+ CHECK_ERR(err, "deflate large 2");
+
+ /* Switch back to compressing mode: */
+ PREFIX(deflateParams)(&c_stream, Z_BEST_COMPRESSION, Z_FILTERED);
+ c_stream.next_in = uncompr;
+ c_stream.avail_in = (unsigned int)uncomprLen;
+ err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);
+ CHECK_ERR(err, "deflate large 3");
+
+ err = PREFIX(deflate)(&c_stream, Z_FINISH);
+ if (err != Z_STREAM_END) {
+ fprintf(stderr, "deflate large should report Z_STREAM_END\n");
+ exit(1);
+ }
+ err = PREFIX(deflateEnd)(&c_stream);
+ CHECK_ERR(err, "deflateEnd");
}
/* ===========================================================================
* Test inflate() with large buffers
*/
-void test_large_inflate(unsigned char *compr, size_t comprLen,
- unsigned char *uncompr, size_t uncomprLen) {
- int err;
- PREFIX3(stream) d_stream; /* decompression stream */
-
- d_stream.zalloc = zalloc;
- d_stream.zfree = zfree;
- d_stream.opaque = (void *)0;
-
- d_stream.next_in = compr;
- d_stream.avail_in = (unsigned int)comprLen;
-
- err = PREFIX(inflateInit)(&d_stream);
- CHECK_ERR(err, "inflateInit");
-
- for (;;) {
- d_stream.next_out = uncompr; /* discard the output */
- d_stream.avail_out = (unsigned int)uncomprLen;
- err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH);
- if (err == Z_STREAM_END)
- break;
- CHECK_ERR(err, "large inflate");
- }
-
- err = PREFIX(inflateEnd)(&d_stream);
- CHECK_ERR(err, "inflateEnd");
-
- if (d_stream.total_out != 2 * uncomprLen + diff) {
- fprintf(stderr, "bad large inflate: %zu\n", d_stream.total_out);
- exit(1);
- }
+void test_large_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) {
+ int err;
+ PREFIX3(stream) d_stream; /* decompression stream */
+
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (void *)0;
+
+ d_stream.next_in = compr;
+ d_stream.avail_in = (unsigned int)comprLen;
+
+ err = PREFIX(inflateInit)(&d_stream);
+ CHECK_ERR(err, "inflateInit");
+
+ for (;;) {
+ d_stream.next_out = uncompr; /* discard the output */
+ d_stream.avail_out = (unsigned int)uncomprLen;
+ err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH);
+ if (err == Z_STREAM_END)
+ break;
+ CHECK_ERR(err, "large inflate");
+ }
+
+ err = PREFIX(inflateEnd)(&d_stream);
+ CHECK_ERR(err, "inflateEnd");
+
+ if (d_stream.total_out != 2 * uncomprLen + diff) {
+ fprintf(stderr, "bad large inflate: %zu\n", d_stream.total_out);
+ exit(1);
+ }
}
int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) {
- size_t comprLen = 100 + 3 * size;
- size_t uncomprLen = comprLen;
- uint8_t *compr, *uncompr;
+ size_t comprLen = 100 + 3 * size;
+ size_t uncomprLen = comprLen;
+ uint8_t *compr, *uncompr;
- /* Discard inputs larger than 512Kb. */
- static size_t kMaxSize = 512 * 1024;
+ /* Discard inputs larger than 512Kb. */
+ static size_t kMaxSize = 512 * 1024;
- if (size < 1 || size > kMaxSize)
- return 0;
+ if (size < 1 || size > kMaxSize)
+ return 0;
- data = d;
- dataLen = size;
- compr = (uint8_t *)calloc(1, comprLen);
- uncompr = (uint8_t *)calloc(1, uncomprLen);
+ data = d;
+ dataLen = size;
+ compr = (uint8_t *)calloc(1, comprLen);
+ uncompr = (uint8_t *)calloc(1, uncomprLen);
- test_large_deflate(compr, comprLen, uncompr, uncomprLen);
- test_large_inflate(compr, comprLen, uncompr, uncomprLen);
+ test_large_deflate(compr, comprLen, uncompr, uncomprLen);
+ test_large_inflate(compr, comprLen, uncompr, uncomprLen);
- free(compr);
- free(uncompr);
+ free(compr);
+ free(uncompr);
- /* This function must return 0. */
- return 0;
+ /* This function must return 0. */
+ return 0;
}
* Test deflate() with small buffers
*/
void test_deflate(unsigned char *compr, size_t comprLen) {
- PREFIX3(stream) c_stream; /* compression stream */
- int err;
- unsigned long len = dataLen;
-
- c_stream.zalloc = zalloc;
- c_stream.zfree = zfree;
- c_stream.opaque = (void *)0;
-
- err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION);
- CHECK_ERR(err, "deflateInit");
-
- c_stream.next_in = (const unsigned char *)data;
- c_stream.next_out = compr;
-
- while (c_stream.total_in != len && c_stream.total_out < comprLen) {
- c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
- err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);
- CHECK_ERR(err, "deflate small 1");
- }
- /* Finish the stream, still forcing small buffers: */
- for (;;) {
- c_stream.avail_out = 1;
- err = PREFIX(deflate)(&c_stream, Z_FINISH);
- if (err == Z_STREAM_END)
- break;
- CHECK_ERR(err, "deflate small 2");
- }
-
- err = PREFIX(deflateEnd)(&c_stream);
- CHECK_ERR(err, "deflateEnd");
+ PREFIX3(stream) c_stream; /* compression stream */
+ int err;
+ unsigned long len = dataLen;
+
+ c_stream.zalloc = zalloc;
+ c_stream.zfree = zfree;
+ c_stream.opaque = (void *)0;
+
+ err = PREFIX(deflateInit)(&c_stream, Z_DEFAULT_COMPRESSION);
+ CHECK_ERR(err, "deflateInit");
+
+ c_stream.next_in = (const unsigned char *)data;
+ c_stream.next_out = compr;
+
+ while (c_stream.total_in != len && c_stream.total_out < comprLen) {
+ c_stream.avail_in = c_stream.avail_out = 1; /* force small buffers */
+ err = PREFIX(deflate)(&c_stream, Z_NO_FLUSH);
+ CHECK_ERR(err, "deflate small 1");
+ }
+ /* Finish the stream, still forcing small buffers: */
+ for (;;) {
+ c_stream.avail_out = 1;
+ err = PREFIX(deflate)(&c_stream, Z_FINISH);
+ if (err == Z_STREAM_END)
+ break;
+ CHECK_ERR(err, "deflate small 2");
+ }
+
+ err = PREFIX(deflateEnd)(&c_stream);
+ CHECK_ERR(err, "deflateEnd");
}
/* ===========================================================================
* Test inflate() with small buffers
*/
-void test_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr,
- size_t uncomprLen) {
- int err;
- PREFIX3(stream) d_stream; /* decompression stream */
-
- d_stream.zalloc = zalloc;
- d_stream.zfree = zfree;
- d_stream.opaque = (void *)0;
-
- d_stream.next_in = compr;
- d_stream.avail_in = 0;
- d_stream.next_out = uncompr;
-
- err = PREFIX(inflateInit)(&d_stream);
- CHECK_ERR(err, "inflateInit");
-
- while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {
- d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
- err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH);
- if (err == Z_STREAM_END)
- break;
- CHECK_ERR(err, "inflate");
- }
-
- err = PREFIX(inflateEnd)(&d_stream);
- CHECK_ERR(err, "inflateEnd");
-
- if (memcmp(uncompr, data, dataLen)) {
- fprintf(stderr, "bad inflate\n");
- exit(1);
- }
+void test_inflate(unsigned char *compr, size_t comprLen, unsigned char *uncompr, size_t uncomprLen) {
+ int err;
+ PREFIX3(stream) d_stream; /* decompression stream */
+
+ d_stream.zalloc = zalloc;
+ d_stream.zfree = zfree;
+ d_stream.opaque = (void *)0;
+
+ d_stream.next_in = compr;
+ d_stream.avail_in = 0;
+ d_stream.next_out = uncompr;
+
+ err = PREFIX(inflateInit)(&d_stream);
+ CHECK_ERR(err, "inflateInit");
+
+ while (d_stream.total_out < uncomprLen && d_stream.total_in < comprLen) {
+ d_stream.avail_in = d_stream.avail_out = 1; /* force small buffers */
+ err = PREFIX(inflate)(&d_stream, Z_NO_FLUSH);
+ if (err == Z_STREAM_END)
+ break;
+ CHECK_ERR(err, "inflate");
+ }
+
+ err = PREFIX(inflateEnd)(&d_stream);
+ CHECK_ERR(err, "inflateEnd");
+
+ if (memcmp(uncompr, data, dataLen)) {
+ fprintf(stderr, "bad inflate\n");
+ exit(1);
+ }
}
int LLVMFuzzerTestOneInput(const uint8_t *d, size_t size) {
- size_t comprLen = PREFIX(compressBound)(size);
- size_t uncomprLen = size;
- uint8_t *compr, *uncompr;
+ size_t comprLen = PREFIX(compressBound)(size);
+ size_t uncomprLen = size;
+ uint8_t *compr, *uncompr;
- /* Discard inputs larger than 1Mb. */
- static size_t kMaxSize = 1024 * 1024;
+ /* Discard inputs larger than 1Mb. */
+ static size_t kMaxSize = 1024 * 1024;
- if (size < 1 || size > kMaxSize)
- return 0;
+ if (size < 1 || size > kMaxSize)
+ return 0;
- data = d;
- dataLen = size;
- compr = (uint8_t *)calloc(1, comprLen);
- uncompr = (uint8_t *)calloc(1, uncomprLen);
+ data = d;
+ dataLen = size;
+ compr = (uint8_t *)calloc(1, comprLen);
+ uncompr = (uint8_t *)calloc(1, uncomprLen);
- test_deflate(compr, comprLen);
- test_inflate(compr, comprLen, uncompr, uncomprLen);
+ test_deflate(compr, comprLen);
+ test_inflate(compr, comprLen, uncompr, uncomprLen);
- free(compr);
- free(uncompr);
+ free(compr);
+ free(uncompr);
- /* This function must return 0. */
- return 0;
+ /* This function must return 0. */
+ return 0;
}
static const char *prog = "minigzip_fuzzer";
void error (const char *msg);
-void gz_compress (FILE *in, gzFile out);
+void gz_compress (FILE *in, gzFile out);
#ifdef USE_MMAP
-int gz_compress_mmap (FILE *in, gzFile out);
+int gz_compress_mmap (FILE *in, gzFile out);
#endif
-void gz_uncompress (gzFile in, FILE *out);
-void file_compress (char *file, char *mode);
-void file_uncompress (char *file);
+void gz_uncompress (gzFile in, FILE *out);
+void file_compress (char *file, char *mode);
+void file_uncompress (char *file);
int main (int argc, char *argv[]);
/* ===========================================================================
* Compress input to output then close both files.
*/
-void gz_compress(FILE *in, gzFile out)
+void gz_compress(FILE *in, gzFile out)
{
char buf[BUFLEN];
int len;
/* Try compressing the input file at once using mmap. Return Z_OK if
* if success, Z_ERRNO otherwise.
*/
-int gz_compress_mmap(FILE *in, gzFile out)
+int gz_compress_mmap(FILE *in, gzFile out)
{
int len;
int err;
/* ===========================================================================
* Uncompress input to output then close both files.
*/
-void gz_uncompress(gzFile in, FILE *out)
+void gz_uncompress(gzFile in, FILE *out)
{
char buf[BUFLENW];
int len;
* Compress the given file: create a corresponding .gz file and remove the
* original.
*/
-void file_compress(char *file, char *mode)
+void file_compress(char *file, char *mode)
{
char outfile[MAX_NAME_LEN];
FILE *in;
/* ===========================================================================
* Uncompress the given file and remove the original.
*/
-void file_uncompress(char *file)
+void file_uncompress(char *file)
{
char buf[MAX_NAME_LEN];
char *infile, *outfile;
}
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t dataLen) {
- char *inFileName = "minigzip_fuzzer.out";
- char *outFileName = "minigzip_fuzzer.out.gz";
- char outmode[20];
- FILE *in;
- char buf[BUFLEN];
- uint32_t offset = 0;
-
- /* Discard inputs larger than 1Mb. */
- static size_t kMaxSize = 1024 * 1024;
- if (dataLen < 1 || dataLen > kMaxSize)
- return 0;
+ char *inFileName = "minigzip_fuzzer.out";
+ char *outFileName = "minigzip_fuzzer.out.gz";
+ char outmode[20];
+ FILE *in;
+ char buf[BUFLEN];
+ uint32_t offset = 0;
+
+ /* Discard inputs larger than 1Mb. */
+ static size_t kMaxSize = 1024 * 1024;
+ if (dataLen < 1 || dataLen > kMaxSize)
+ return 0;
+
+ in = fopen(inFileName, "wb");
+ if (fwrite(data, 1, (unsigned)dataLen, in) != dataLen)
+ error("failed fwrite");
+ if (fclose(in))
+ error("failed fclose");
+
+ memset(outmode, 0, sizeof(outmode));
+ snprintf(outmode, sizeof(outmode), "%s", "wb");
+
+ /* Compression level: [0..9]. */
+ outmode[2] = data[0] % 10;
+
+ switch (data[0] % 4) {
+ default:
+ case 0:
+ outmode[3] = 0;
+ break;
+ case 1:
+ /* compress with Z_FILTERED */
+ outmode[3] = 'f';
+ break;
+ case 2:
+ /* compress with Z_HUFFMAN_ONLY */
+ outmode[3] = 'h';
+ break;
+ case 3:
+ /* compress with Z_RLE */
+ outmode[3] = 'R';
+ break;
+ }
- in = fopen(inFileName, "wb");
- if (fwrite(data, 1, (unsigned)dataLen, in) != dataLen)
- error("failed fwrite");
- if (fclose(in))
- error("failed fclose");
-
- memset(outmode, 0, sizeof(outmode));
- snprintf(outmode, sizeof(outmode), "%s", "wb");
-
- /* Compression level: [0..9]. */
- outmode[2] = data[0] % 10;
-
- switch (data[0] % 4) {
- default:
- case 0:
- outmode[3] = 0;
- break;
- case 1:
- /* compress with Z_FILTERED */
- outmode[3] = 'f';
- break;
- case 2:
- /* compress with Z_HUFFMAN_ONLY */
- outmode[3] = 'h';
- break;
- case 3:
- /* compress with Z_RLE */
- outmode[3] = 'R';
- break;
- }
-
- file_compress(inFileName, outmode);
- file_uncompress(outFileName);
-
- /* Check that the uncompressed file matches the input data. */
- in = fopen(inFileName, "rb");
- if (in == NULL) {
- perror(inFileName);
- exit(1);
- }
-
- memset(buf, 0, sizeof(buf));
- for (;;) {
- int len = (int)fread(buf, 1, sizeof(buf), in);
- if (ferror(in)) {
- perror("fread");
- exit(1);
+ file_compress(inFileName, outmode);
+ file_uncompress(outFileName);
+
+ /* Check that the uncompressed file matches the input data. */
+ in = fopen(inFileName, "rb");
+ if (in == NULL) {
+ perror(inFileName);
+ exit(1);
+ }
+
+ memset(buf, 0, sizeof(buf));
+ for (;;) {
+ int len = (int)fread(buf, 1, sizeof(buf), in);
+ if (ferror(in)) {
+ perror("fread");
+ exit(1);
+ }
+ if (len == 0)
+ break;
+ assert(0 == memcmp(data + offset, buf, len));
+ offset += len;
}
- if (len == 0)
- break;
- assert(0 == memcmp(data + offset, buf, len));
- offset += len;
- }
- if (fclose(in))
- error("failed fclose");
+ if (fclose(in))
+ error("failed fclose");
- /* This function must return 0. */
- return 0;
+ /* This function must return 0. */
+ return 0;
}
extern int LLVMFuzzerTestOneInput(const unsigned char *data, size_t size);
int main(int argc, char **argv) {
- int i;
- fprintf(stderr, "StandaloneFuzzTargetMain: running %d inputs\n", argc - 1);
+ int i;
+ fprintf(stderr, "StandaloneFuzzTargetMain: running %d inputs\n", argc - 1);
- for (i = 1; i < argc; i++) {
- size_t len, n_read, err;
- unsigned char *buf;
- FILE *f = fopen(argv[i], "rb+");
- if (!f) {
- /* Failed to open this file: it may be a directory. */
- fprintf(stderr, "Skipping: %s\n", argv[i]);
- continue;
+ for (i = 1; i < argc; i++) {
+ size_t len, n_read, err;
+ unsigned char *buf;
+ FILE *f = fopen(argv[i], "rb+");
+ if (!f) {
+ /* Failed to open this file: it may be a directory. */
+ fprintf(stderr, "Skipping: %s\n", argv[i]);
+ continue;
+ }
+ fprintf(stderr, "Running: %s %s\n", argv[0], argv[i]);
+ fseek(f, 0, SEEK_END);
+ len = ftell(f);
+ fseek(f, 0, SEEK_SET);
+ buf = (unsigned char *)malloc(len);
+ n_read = fread(buf, 1, len, f);
+ assert(n_read == len);
+ LLVMFuzzerTestOneInput(buf, len);
+ free(buf);
+ err = fclose(f);
+ assert(err == 0);
+ (void)err;
+ fprintf(stderr, "Done: %s: (%d bytes)\n", argv[i], (int)n_read);
}
- fprintf(stderr, "Running: %s %s\n", argv[0], argv[i]);
- fseek(f, 0, SEEK_END);
- len = ftell(f);
- fseek(f, 0, SEEK_SET);
- buf = (unsigned char *)malloc(len);
- n_read = fread(buf, 1, len, f);
- assert(n_read == len);
- LLVMFuzzerTestOneInput(buf, len);
- free(buf);
- err = fclose(f);
- assert(err == 0);
- (void)err;
- fprintf(stderr, "Done: %s: (%d bytes)\n", argv[i], (int)n_read);
- }
- return 0;
+ return 0;
}
projects / thirdparty / zlib-ng.git / commitdiff
