Files
wuffs/test/c/mimiclib/flate.c
T
Nigel Tao d4372cb5b8 Change license to Apache 2.
Also remove explicit PATENTS file. The new LICENSE file already
discusses patents.

Note that the Puffs project has not yet been publicly released.
2017-10-12 11:17:41 +11:00

157 lines
4.1 KiB
C

// Copyright 2017 The Puffs Authors.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// https://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
#include "zlib.h"
uint32_t global_mimiclib_flate_unused_u32;
const char* mimic_adler32(puffs_base_buf1* dst, puffs_base_buf1* src) {
uint8_t* ptr = src->ptr + src->ri;
size_t len = src->wi - src->ri;
if (len > 0x7FFFFFFF) {
return "src length is too large";
}
global_mimiclib_flate_unused_u32 = adler32(0L, ptr, len);
src->ri = src->wi;
return NULL;
}
const char* mimic_crc32(puffs_base_buf1* dst, puffs_base_buf1* src) {
uint8_t* ptr = src->ptr + src->ri;
size_t len = src->wi - src->ri;
if (len > 0x7FFFFFFF) {
return "src length is too large";
}
global_mimiclib_flate_unused_u32 = crc32(0L, ptr, len);
src->ri = src->wi;
return NULL;
}
unsigned int mimic_flate_read_func(void* ctx, unsigned char** buf) {
puffs_base_buf1* src = (puffs_base_buf1*)(ctx);
*buf = src->ptr + src->ri;
return src->wi - src->ri;
}
int mimic_flate_write_func(void* ctx, unsigned char* ptr, unsigned int len) {
puffs_base_buf1* dst = (puffs_base_buf1*)(ctx);
size_t n = len;
if (n > dst->len - dst->wi) {
return 1;
}
memmove(dst->ptr + dst->wi, ptr, n);
dst->wi += n;
return 0;
}
const char* mimic_flate_decode(puffs_base_buf1* dst, puffs_base_buf1* src) {
const char* ret = NULL;
uint8_t window[32 * 1024];
z_stream z = {0};
const int window_bits = 15;
int ibi_err = inflateBackInit(&z, window_bits, window);
if (ibi_err != Z_OK) {
ret = "inflateBackInit failed";
goto cleanup0;
}
int ib_err =
inflateBack(&z, mimic_flate_read_func, src, mimic_flate_write_func, dst);
if (ib_err != Z_STREAM_END) {
ret = "inflateBack failed";
goto cleanup1;
}
size_t readable = src->wi - src->ri;
size_t r_remaining = z.avail_in;
if (readable < r_remaining) {
ret = "inconsistent avail_in";
goto cleanup1;
}
src->ri += readable - r_remaining;
cleanup1:;
int ibe_err = inflateBackEnd(&z);
if ((ibe_err != Z_OK) && !ret) {
ret = "inflateBackEnd failed";
}
cleanup0:;
return ret;
}
const char* mimic_gzip_zlib_decode(puffs_base_buf1* dst,
puffs_base_buf1* src,
bool gzip_instead_of_zlib) {
const char* ret = NULL;
z_stream z = {0};
int window_bits = 15;
if (gzip_instead_of_zlib) {
// See inflateInit2 in the zlib manual, or in zlib.h, for details about
// this magic constant.
window_bits |= 16;
}
int ii2_err = inflateInit2(&z, window_bits);
if (ii2_err != Z_OK) {
ret = "inflateInit2 failed";
goto cleanup0;
}
z.avail_in = src->wi - src->ri;
z.next_in = src->ptr + src->ri;
z.avail_out = dst->len - dst->wi;
z.next_out = dst->ptr + dst->wi;
int i_err = inflate(&z, Z_NO_FLUSH);
if (i_err != Z_STREAM_END) {
ret = "inflate failed";
goto cleanup1;
}
size_t readable = src->wi - src->ri;
size_t r_remaining = z.avail_in;
if (readable < r_remaining) {
ret = "inconsistent avail_in";
goto cleanup1;
}
src->ri += readable - r_remaining;
size_t writable = dst->len - dst->wi;
size_t w_remaining = z.avail_out;
if (writable < w_remaining) {
ret = "inconsistent avail_out";
goto cleanup1;
}
dst->wi += writable - w_remaining;
cleanup1:;
int ie_err = inflateEnd(&z);
if ((ie_err != Z_OK) && !ret) {
ret = "inflateEnd failed";
}
cleanup0:;
return ret;
}
const char* mimic_gzip_decode(puffs_base_buf1* dst, puffs_base_buf1* src) {
return mimic_gzip_zlib_decode(dst, src, true);
}
const char* mimic_zlib_decode(puffs_base_buf1* dst, puffs_base_buf1* src) {
return mimic_gzip_zlib_decode(dst, src, false);
}