summaryrefslogtreecommitdiffstats
path: root/vendor/libz-sys/src/lib.rs
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/libz-sys/src/lib.rs')
-rw-r--r--vendor/libz-sys/src/lib.rs431
1 files changed, 431 insertions, 0 deletions
diff --git a/vendor/libz-sys/src/lib.rs b/vendor/libz-sys/src/lib.rs
new file mode 100644
index 0000000..ae00583
--- /dev/null
+++ b/vendor/libz-sys/src/lib.rs
@@ -0,0 +1,431 @@
+#![allow(non_camel_case_types)]
+#![allow(non_snake_case)]
+
+use std::os::raw::{c_char, c_int, c_long, c_uchar, c_uint, c_ulong, c_void};
+
+// Macro for variances between zlib-ng in native mode and either zlib or zlib-ng in zlib compat
+// mode. Note in particular that zlib-ng in compat mode does *not* use the zng case.
+#[cfg(not(zng))]
+macro_rules! if_zng {
+ ($_zng:tt, $not_zng:tt) => {
+ $not_zng
+ };
+}
+
+#[cfg(zng)]
+macro_rules! if_zng {
+ ($zng:tt, $_not_zng:tt) => {
+ $zng
+ };
+}
+
+// zlib uses unsigned long for various sizes; zlib-ng uses size_t.
+type z_size = if_zng!(usize, c_ulong);
+
+// zlib stores Adler-32 and CRC-32 checksums in unsigned long; zlib-ng uses uint32_t.
+type z_checksum = if_zng!(u32, c_ulong);
+
+pub type alloc_func = unsafe extern "C" fn(voidpf, uInt, uInt) -> voidpf;
+pub type Bytef = u8;
+pub type free_func = unsafe extern "C" fn(voidpf, voidpf);
+#[cfg(any(zng, feature = "libc"))]
+pub type gzFile = *mut gzFile_s;
+pub type in_func = unsafe extern "C" fn(*mut c_void, *mut *const c_uchar) -> c_uint;
+pub type out_func = unsafe extern "C" fn(*mut c_void, *mut c_uchar, c_uint) -> c_int;
+pub type uInt = c_uint;
+pub type uLong = c_ulong;
+pub type uLongf = c_ulong;
+pub type voidp = *mut c_void;
+pub type voidpc = *const c_void;
+pub type voidpf = *mut c_void;
+
+#[cfg(any(zng, feature = "libc"))]
+pub enum gzFile_s {}
+pub enum internal_state {}
+
+#[cfg(all(
+ not(zng),
+ feature = "libc",
+ not(all(target_family = "wasm", target_os = "unknown"))
+))]
+pub type z_off_t = libc::off_t;
+
+#[cfg(all(
+ not(zng),
+ feature = "libc",
+ all(target_family = "wasm", target_os = "unknown")
+))]
+pub type z_off_t = c_long;
+
+#[cfg(all(zng, windows, not(target_env = "gnu")))]
+pub type z_off_t = i64;
+
+#[cfg(all(zng, not(all(windows, not(target_env = "gnu")))))]
+pub type z_off_t = libc::off_t;
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct gz_header {
+ pub text: c_int,
+ pub time: uLong,
+ pub xflags: c_int,
+ pub os: c_int,
+ pub extra: *mut Bytef,
+ pub extra_len: uInt,
+ pub extra_max: uInt,
+ pub name: *mut Bytef,
+ pub name_max: uInt,
+ pub comment: *mut Bytef,
+ pub comm_max: uInt,
+ pub hcrc: c_int,
+ pub done: c_int,
+}
+pub type gz_headerp = *mut gz_header;
+
+#[repr(C)]
+#[derive(Copy, Clone)]
+pub struct z_stream {
+ pub next_in: *mut Bytef,
+ pub avail_in: uInt,
+ pub total_in: z_size,
+ pub next_out: *mut Bytef,
+ pub avail_out: uInt,
+ pub total_out: z_size,
+ pub msg: *mut c_char,
+ pub state: *mut internal_state,
+ pub zalloc: alloc_func,
+ pub zfree: free_func,
+ pub opaque: voidpf,
+ pub data_type: c_int,
+ pub adler: z_checksum,
+ pub reserved: uLong,
+}
+pub type z_streamp = *mut z_stream;
+
+// Ideally, this should instead use a macro that parses the whole block of externs, and generates
+// the appropriate link_name attributes, without duplicating the function names. However, ctest2
+// can't parse that.
+#[cfg(not(zng))]
+macro_rules! zng_prefix {
+ ($name:expr) => {
+ stringify!($name)
+ };
+}
+
+#[cfg(zng)]
+macro_rules! zng_prefix {
+ ($name:expr) => {
+ concat!("zng_", stringify!($name))
+ };
+}
+
+extern "C" {
+ #[link_name = zng_prefix!(adler32)]
+ pub fn adler32(adler: z_checksum, buf: *const Bytef, len: uInt) -> z_checksum;
+ #[link_name = zng_prefix!(crc32)]
+ pub fn crc32(crc: z_checksum, buf: *const Bytef, len: uInt) -> z_checksum;
+ #[link_name = zng_prefix!(deflate)]
+ pub fn deflate(strm: z_streamp, flush: c_int) -> c_int;
+ #[link_name = zng_prefix!(deflateBound)]
+ pub fn deflateBound(strm: z_streamp, sourceLen: uLong) -> uLong;
+ #[link_name = zng_prefix!(deflateCopy)]
+ pub fn deflateCopy(dest: z_streamp, source: z_streamp) -> c_int;
+ #[link_name = zng_prefix!(deflateEnd)]
+ pub fn deflateEnd(strm: z_streamp) -> c_int;
+ #[link_name = zng_prefix!(deflateParams)]
+ pub fn deflateParams(strm: z_streamp, level: c_int, strategy: c_int) -> c_int;
+ #[link_name = zng_prefix!(deflatePrime)]
+ pub fn deflatePrime(strm: z_streamp, bits: c_int, value: c_int) -> c_int;
+ #[link_name = zng_prefix!(deflateReset)]
+ pub fn deflateReset(strm: z_streamp) -> c_int;
+ #[link_name = zng_prefix!(deflateSetDictionary)]
+ pub fn deflateSetDictionary(
+ strm: z_streamp,
+ dictionary: *const Bytef,
+ dictLength: uInt,
+ ) -> c_int;
+ #[link_name = zng_prefix!(deflateSetHeader)]
+ pub fn deflateSetHeader(strm: z_streamp, head: gz_headerp) -> c_int;
+ #[link_name = zng_prefix!(deflateTune)]
+ pub fn deflateTune(
+ strm: z_streamp,
+ good_length: c_int,
+ max_lazy: c_int,
+ nice_length: c_int,
+ max_chain: c_int,
+ ) -> c_int;
+ #[link_name = zng_prefix!(inflate)]
+ pub fn inflate(strm: z_streamp, flush: c_int) -> c_int;
+ #[link_name = zng_prefix!(inflateBack)]
+ pub fn inflateBack(
+ strm: z_streamp,
+ _in: in_func,
+ in_desc: *mut c_void,
+ out: out_func,
+ out_desc: *mut c_void,
+ ) -> c_int;
+ #[link_name = zng_prefix!(inflateBackEnd)]
+ pub fn inflateBackEnd(strm: z_streamp) -> c_int;
+ #[link_name = zng_prefix!(inflateCopy)]
+ pub fn inflateCopy(dest: z_streamp, source: z_streamp) -> c_int;
+ #[link_name = zng_prefix!(inflateEnd)]
+ pub fn inflateEnd(strm: z_streamp) -> c_int;
+ #[link_name = zng_prefix!(inflateGetHeader)]
+ pub fn inflateGetHeader(strm: z_streamp, head: gz_headerp) -> c_int;
+ #[link_name = zng_prefix!(inflateMark)]
+ pub fn inflateMark(strm: z_streamp) -> c_long;
+ #[link_name = zng_prefix!(inflatePrime)]
+ pub fn inflatePrime(strm: z_streamp, bits: c_int, value: c_int) -> c_int;
+ #[link_name = zng_prefix!(inflateReset)]
+ pub fn inflateReset(strm: z_streamp) -> c_int;
+ #[link_name = zng_prefix!(inflateReset2)]
+ pub fn inflateReset2(strm: z_streamp, windowBits: c_int) -> c_int;
+ #[link_name = zng_prefix!(inflateSetDictionary)]
+ pub fn inflateSetDictionary(
+ strm: z_streamp,
+ dictionary: *const Bytef,
+ dictLength: uInt,
+ ) -> c_int;
+ #[link_name = zng_prefix!(inflateSync)]
+ pub fn inflateSync(strm: z_streamp) -> c_int;
+ #[link_name = zng_prefix!(zlibCompileFlags)]
+ pub fn zlibCompileFlags() -> uLong;
+
+ // The above set of functions currently target 1.2.3.4 (what's present on Ubuntu
+ // 12.04, but there's some other APIs that were added later. Should figure out
+ // how to expose them...
+ //
+ // Added in 1.2.5.1
+ //
+ // pub fn deflatePending(strm: z_streamp,
+ // pending: *mut c_uint,
+ // bits: *mut c_int) -> c_int;
+ //
+ // Addedin 1.2.7.1
+ // pub fn inflateGetDictionary(strm: z_streamp,
+ // dictionary: *mut Bytef,
+ // dictLength: *mut uInt) -> c_int;
+ //
+ // Added in 1.2.3.5
+ // pub fn gzbuffer(file: gzFile, size: c_uint) -> c_int;
+ // pub fn gzclose_r(file: gzFile) -> c_int;
+ // pub fn gzclose_w(file: gzFile) -> c_int;
+ // pub fn gzoffset(file: gzFile) -> z_off_t;
+}
+
+extern "C" {
+ #[link_name = if_zng!("zlibng_version", "zlibVersion")]
+ pub fn zlibVersion() -> *const c_char;
+}
+
+#[cfg(not(zng))]
+extern "C" {
+ pub fn deflateInit_(
+ strm: z_streamp,
+ level: c_int,
+ version: *const c_char,
+ stream_size: c_int,
+ ) -> c_int;
+ pub fn deflateInit2_(
+ strm: z_streamp,
+ level: c_int,
+ method: c_int,
+ windowBits: c_int,
+ memLevel: c_int,
+ strategy: c_int,
+ version: *const c_char,
+ stream_size: c_int,
+ ) -> c_int;
+ pub fn inflateBackInit_(
+ strm: z_streamp,
+ windowBits: c_int,
+ window: *mut c_uchar,
+ version: *const c_char,
+ stream_size: c_int,
+ ) -> c_int;
+ pub fn inflateInit_(strm: z_streamp, version: *const c_char, stream_size: c_int) -> c_int;
+ pub fn inflateInit2_(
+ strm: z_streamp,
+ windowBits: c_int,
+ version: *const c_char,
+ stream_size: c_int,
+ ) -> c_int;
+}
+
+#[cfg(zng)]
+extern "C" {
+ pub fn zng_deflateInit(strm: z_streamp, level: c_int) -> c_int;
+ pub fn zng_deflateInit2(
+ strm: z_streamp,
+ level: c_int,
+ method: c_int,
+ windowBits: c_int,
+ memLevel: c_int,
+ strategy: c_int,
+ ) -> c_int;
+ pub fn zng_inflateBackInit(strm: z_streamp, windowBits: c_int, window: *mut c_uchar) -> c_int;
+ pub fn zng_inflateInit(strm: z_streamp) -> c_int;
+ pub fn zng_inflateInit2(strm: z_streamp, windowBits: c_int) -> c_int;
+}
+
+// These methods are required to keep BC with original zlib API since zlib-ng 2.1 that changed API
+#[cfg(zng)]
+#[inline(always)]
+pub unsafe fn inflateInit2_(
+ strm: z_streamp,
+ windowBits: c_int,
+ _version: *const c_char,
+ _stream_size: c_int,
+) -> c_int {
+ zng_inflateInit2(strm, windowBits)
+}
+
+#[cfg(zng)]
+#[inline(always)]
+pub unsafe fn inflateInit_(strm: z_streamp, _version: *const c_char, _stream_size: c_int) -> c_int {
+ zng_inflateInit(strm)
+}
+
+#[cfg(zng)]
+#[inline(always)]
+pub unsafe fn inflateBackInit_(
+ strm: z_streamp,
+ windowBits: c_int,
+ window: *mut c_uchar,
+ _version: *const c_char,
+ _stream_size: c_int,
+) -> c_int {
+ zng_inflateBackInit(strm, windowBits, window)
+}
+
+#[cfg(zng)]
+#[inline(always)]
+pub unsafe fn deflateInit2_(
+ strm: z_streamp,
+ level: c_int,
+ method: c_int,
+ windowBits: c_int,
+ memLevel: c_int,
+ strategy: c_int,
+ _version: *const c_char,
+ _stream_size: c_int,
+) -> c_int {
+ zng_deflateInit2(strm, level, method, windowBits, memLevel, strategy)
+}
+
+#[cfg(zng)]
+#[inline]
+pub unsafe fn deflateInit_(
+ strm: z_streamp,
+ level: c_int,
+ _version: *const c_char,
+ _stream_size: c_int,
+) -> c_int {
+ zng_deflateInit(strm, level)
+}
+
+#[cfg(any(zng, feature = "libc"))]
+extern "C" {
+ #[link_name = zng_prefix!(adler32_combine)]
+ pub fn adler32_combine(adler1: z_checksum, adler2: z_checksum, len2: z_off_t) -> z_checksum;
+ #[link_name = zng_prefix!(compress)]
+ pub fn compress(
+ dest: *mut Bytef,
+ destLen: *mut z_size,
+ source: *const Bytef,
+ sourceLen: z_size,
+ ) -> c_int;
+ #[link_name = zng_prefix!(compress2)]
+ pub fn compress2(
+ dest: *mut Bytef,
+ destLen: *mut z_size,
+ source: *const Bytef,
+ sourceLen: z_size,
+ level: c_int,
+ ) -> c_int;
+ #[link_name = zng_prefix!(compressBound)]
+ pub fn compressBound(sourceLen: z_size) -> z_size;
+ #[link_name = zng_prefix!(crc32_combine)]
+ pub fn crc32_combine(crc1: z_checksum, crc2: z_checksum, len2: z_off_t) -> z_checksum;
+ #[link_name = zng_prefix!(gzdirect)]
+ pub fn gzdirect(file: gzFile) -> c_int;
+ #[link_name = zng_prefix!(gzdopen)]
+ pub fn gzdopen(fd: c_int, mode: *const c_char) -> gzFile;
+ #[link_name = zng_prefix!(gzclearerr)]
+ pub fn gzclearerr(file: gzFile);
+ #[link_name = zng_prefix!(gzclose)]
+ pub fn gzclose(file: gzFile) -> c_int;
+ #[link_name = zng_prefix!(gzeof)]
+ pub fn gzeof(file: gzFile) -> c_int;
+ #[link_name = zng_prefix!(gzerror)]
+ pub fn gzerror(file: gzFile, errnum: *mut c_int) -> *const c_char;
+ #[link_name = zng_prefix!(gzflush)]
+ pub fn gzflush(file: gzFile, flush: c_int) -> c_int;
+ #[link_name = zng_prefix!(gzgetc)]
+ pub fn gzgetc(file: gzFile) -> c_int;
+ #[link_name = zng_prefix!(gzgets)]
+ pub fn gzgets(file: gzFile, buf: *mut c_char, len: c_int) -> *mut c_char;
+ #[link_name = zng_prefix!(gzopen)]
+ pub fn gzopen(path: *const c_char, mode: *const c_char) -> gzFile;
+ #[link_name = zng_prefix!(gzputc)]
+ pub fn gzputc(file: gzFile, c: c_int) -> c_int;
+ #[link_name = zng_prefix!(gzputs)]
+ pub fn gzputs(file: gzFile, s: *const c_char) -> c_int;
+ #[link_name = zng_prefix!(gzread)]
+ pub fn gzread(file: gzFile, buf: voidp, len: c_uint) -> c_int;
+ #[link_name = zng_prefix!(gzrewind)]
+ pub fn gzrewind(file: gzFile) -> c_int;
+ #[link_name = zng_prefix!(gzseek)]
+ pub fn gzseek(file: gzFile, offset: z_off_t, whence: c_int) -> z_off_t;
+ #[link_name = zng_prefix!(gzsetparams)]
+ pub fn gzsetparams(file: gzFile, level: c_int, strategy: c_int) -> c_int;
+ #[link_name = zng_prefix!(gztell)]
+ pub fn gztell(file: gzFile) -> z_off_t;
+ #[link_name = zng_prefix!(gzungetc)]
+ pub fn gzungetc(c: c_int, file: gzFile) -> c_int;
+ #[link_name = zng_prefix!(gzwrite)]
+ pub fn gzwrite(file: gzFile, buf: voidpc, len: c_uint) -> c_int;
+ #[link_name = zng_prefix!(uncompress)]
+ pub fn uncompress(
+ dest: *mut Bytef,
+ destLen: *mut z_size,
+ source: *const Bytef,
+ sourceLen: z_size,
+ ) -> c_int;
+}
+
+pub const Z_NO_FLUSH: c_int = 0;
+pub const Z_PARTIAL_FLUSH: c_int = 1;
+pub const Z_SYNC_FLUSH: c_int = 2;
+pub const Z_FULL_FLUSH: c_int = 3;
+pub const Z_FINISH: c_int = 4;
+pub const Z_BLOCK: c_int = 5;
+pub const Z_TREES: c_int = 6;
+
+pub const Z_OK: c_int = 0;
+pub const Z_STREAM_END: c_int = 1;
+pub const Z_NEED_DICT: c_int = 2;
+pub const Z_ERRNO: c_int = -1;
+pub const Z_STREAM_ERROR: c_int = -2;
+pub const Z_DATA_ERROR: c_int = -3;
+pub const Z_MEM_ERROR: c_int = -4;
+pub const Z_BUF_ERROR: c_int = -5;
+pub const Z_VERSION_ERROR: c_int = -6;
+
+pub const Z_NO_COMPRESSION: c_int = 0;
+pub const Z_BEST_SPEED: c_int = 1;
+pub const Z_BEST_COMPRESSION: c_int = 9;
+pub const Z_DEFAULT_COMPRESSION: c_int = -1;
+
+pub const Z_FILTERED: c_int = 1;
+pub const Z_HUFFMAN_ONLY: c_int = 2;
+pub const Z_RLE: c_int = 3;
+pub const Z_FIXED: c_int = 4;
+pub const Z_DEFAULT_STRATEGY: c_int = 0;
+
+pub const Z_BINARY: c_int = 0;
+pub const Z_TEXT: c_int = 1;
+pub const Z_ASCII: c_int = Z_TEXT;
+pub const Z_UNKNOWN: c_int = 2;
+
+pub const Z_DEFLATED: c_int = 8;
generated by cgit v1.2.3 (git 2.39.1) at 2024-11-26 18:50:15 +0000