@appzung/react-native-code-push 9.0.2 → 10.0.0

package/ios/CodePush/SSZipArchive/minizip/mz_strm_mem.h

@@ -1,48 +0,0 @@
-/* mz_strm_mem.h -- Stream for memory access
-   part of the minizip-ng project
-
-   Copyright (C) Nathan Moinvaziri
-      https://github.com/zlib-ng/minizip-ng
-
-   This program is distributed under the terms of the same license as zlib.
-   See the accompanying LICENSE file for the full text of the license.
-*/
-
-#ifndef MZ_STREAM_MEM_H
-#define MZ_STREAM_MEM_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/***************************************************************************/
-
-int32_t mz_stream_mem_open(void *stream, const char *filename, int32_t mode);
-int32_t mz_stream_mem_is_open(void *stream);
-int32_t mz_stream_mem_read(void *stream, void *buf, int32_t size);
-int32_t mz_stream_mem_write(void *stream, const void *buf, int32_t size);
-int64_t mz_stream_mem_tell(void *stream);
-int32_t mz_stream_mem_seek(void *stream, int64_t offset, int32_t origin);
-int32_t mz_stream_mem_close(void *stream);
-int32_t mz_stream_mem_error(void *stream);
-
-void    mz_stream_mem_set_buffer(void *stream, void *buf, int32_t size);
-int32_t mz_stream_mem_get_buffer(void *stream, const void **buf);
-int32_t mz_stream_mem_get_buffer_at(void *stream, int64_t position, const void **buf);
-int32_t mz_stream_mem_get_buffer_at_current(void *stream, const void **buf);
-void    mz_stream_mem_get_buffer_length(void *stream, int32_t *length);
-void    mz_stream_mem_set_buffer_limit(void *stream, int32_t limit);
-void    mz_stream_mem_set_grow_size(void *stream, int32_t grow_size);
-
-void*   mz_stream_mem_create(void **stream);
-void    mz_stream_mem_delete(void **stream);
-
-void*   mz_stream_mem_get_interface(void);
-
-/***************************************************************************/
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

package/ios/CodePush/SSZipArchive/minizip/mz_strm_os.h

@@ -1,40 +0,0 @@
-/* mz_sstrm_os.h -- Stream for filesystem access
-   part of the minizip-ng project
-
-   Copyright (C) Nathan Moinvaziri
-     https://github.com/zlib-ng/minizip-ng
-
-   This program is distributed under the terms of the same license as zlib.
-   See the accompanying LICENSE file for the full text of the license.
-*/
-
-#ifndef MZ_STREAM_OS_H
-#define MZ_STREAM_OS_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/***************************************************************************/
-
-int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode);
-int32_t mz_stream_os_is_open(void *stream);
-int32_t mz_stream_os_read(void *stream, void *buf, int32_t size);
-int32_t mz_stream_os_write(void *stream, const void *buf, int32_t size);
-int64_t mz_stream_os_tell(void *stream);
-int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin);
-int32_t mz_stream_os_close(void *stream);
-int32_t mz_stream_os_error(void *stream);
-
-void*   mz_stream_os_create(void **stream);
-void    mz_stream_os_delete(void **stream);
-
-void*   mz_stream_os_get_interface(void);
-
-/***************************************************************************/
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif

package/ios/CodePush/SSZipArchive/minizip/mz_strm_os_posix.c

@@ -1,203 +0,0 @@
-/* mz_strm_posix.c -- Stream for filesystem access for posix/linux
-   part of the minizip-ng project
-
-   Copyright (C) Nathan Moinvaziri
-     https://github.com/zlib-ng/minizip-ng
-   Modifications for Zip64 support
-     Copyright (C) 2009-2010 Mathias Svensson
-     http://result42.com
-   Copyright (C) 1998-2010 Gilles Vollant
-     https://www.winimage.com/zLibDll/minizip.html
-
-   This program is distributed under the terms of the same license as zlib.
-   See the accompanying LICENSE file for the full text of the license.
-*/
-
-#include "mz.h"
-#include "mz_strm.h"
-#include "mz_strm_os.h"
-
-#include <stdio.h> /* fopen, fread.. */
-#include <errno.h>
-
-/***************************************************************************/
-
-#define fopen64 fopen
-#ifndef MZ_FILE32_API
-#  ifndef NO_FSEEKO
-#    define ftello64 ftello
-#    define fseeko64 fseeko
-#  elif defined(_MSC_VER) && (_MSC_VER >= 1400)
-#    define ftello64 _ftelli64
-#    define fseeko64 _fseeki64
-#  endif
-#endif
-#ifndef ftello64
-#  define ftello64 ftell
-#endif
-#ifndef fseeko64
-#  define fseeko64 fseek
-#endif
-
-/***************************************************************************/
-
-static mz_stream_vtbl mz_stream_os_vtbl = {
-    mz_stream_os_open,
-    mz_stream_os_is_open,
-    mz_stream_os_read,
-    mz_stream_os_write,
-    mz_stream_os_tell,
-    mz_stream_os_seek,
-    mz_stream_os_close,
-    mz_stream_os_error,
-    mz_stream_os_create,
-    mz_stream_os_delete,
-    NULL,
-    NULL
-};
-
-/***************************************************************************/
-
-typedef struct mz_stream_posix_s {
-    mz_stream   stream;
-    int32_t     error;
-    FILE        *handle;
-} mz_stream_posix;
-
-/***************************************************************************/
-
-int32_t mz_stream_os_open(void *stream, const char *path, int32_t mode) {
-    mz_stream_posix *posix = (mz_stream_posix *)stream;
-    const char *mode_fopen = NULL;
-
-    if (!path)
-        return MZ_PARAM_ERROR;
-
-    if ((mode & MZ_OPEN_MODE_READWRITE) == MZ_OPEN_MODE_READ)
-        mode_fopen = "rb";
-    else if (mode & MZ_OPEN_MODE_APPEND)
-        mode_fopen = "r+b";
-    else if (mode & MZ_OPEN_MODE_CREATE)
-        mode_fopen = "wb";
-    else
-        return MZ_OPEN_ERROR;
-
-    posix->handle = fopen64(path, mode_fopen);
-    if (!posix->handle) {
-        posix->error = errno;
-        return MZ_OPEN_ERROR;
-    }
-
-    if (mode & MZ_OPEN_MODE_APPEND)
-        return mz_stream_os_seek(stream, 0, MZ_SEEK_END);
-
-    return MZ_OK;
-}
-
-int32_t mz_stream_os_is_open(void *stream) {
-    mz_stream_posix *posix = (mz_stream_posix *)stream;
-    if (!posix->handle)
-        return MZ_OPEN_ERROR;
-    return MZ_OK;
-}
-
-int32_t mz_stream_os_read(void *stream, void *buf, int32_t size) {
-    mz_stream_posix *posix = (mz_stream_posix *)stream;
-    int32_t read = (int32_t)fread(buf, 1, (size_t)size, posix->handle);
-    if (read < size && ferror(posix->handle)) {
-        posix->error = errno;
-        return MZ_READ_ERROR;
-    }
-    return read;
-}
-
-int32_t mz_stream_os_write(void *stream, const void *buf, int32_t size) {
-    mz_stream_posix *posix = (mz_stream_posix *)stream;
-    int32_t written = (int32_t)fwrite(buf, 1, (size_t)size, posix->handle);
-    if (written < size && ferror(posix->handle)) {
-        posix->error = errno;
-        return MZ_WRITE_ERROR;
-    }
-    return written;
-}
-
-int64_t mz_stream_os_tell(void *stream) {
-    mz_stream_posix *posix = (mz_stream_posix *)stream;
-    int64_t position = ftello64(posix->handle);
-    if (position == -1) {
-        posix->error = errno;
-        return MZ_TELL_ERROR;
-    }
-    return position;
-}
-
-int32_t mz_stream_os_seek(void *stream, int64_t offset, int32_t origin) {
-    mz_stream_posix *posix = (mz_stream_posix *)stream;
-    int32_t fseek_origin = 0;
-
-    switch (origin) {
-    case MZ_SEEK_CUR:
-        fseek_origin = SEEK_CUR;
-        break;
-    case MZ_SEEK_END:
-        fseek_origin = SEEK_END;
-        break;
-    case MZ_SEEK_SET:
-        fseek_origin = SEEK_SET;
-        break;
-    default:
-        return MZ_SEEK_ERROR;
-    }
-
-    if (fseeko64(posix->handle, offset, fseek_origin) != 0) {
-        posix->error = errno;
-        return MZ_SEEK_ERROR;
-    }
-
-    return MZ_OK;
-}
-
-int32_t mz_stream_os_close(void *stream) {
-    mz_stream_posix *posix = (mz_stream_posix *)stream;
-    int32_t closed = 0;
-    if (posix->handle) {
-        closed = fclose(posix->handle);
-        posix->handle = NULL;
-    }
-    if (closed != 0) {
-        posix->error = errno;
-        return MZ_CLOSE_ERROR;
-    }
-    return MZ_OK;
-}
-
-int32_t mz_stream_os_error(void *stream) {
-    mz_stream_posix *posix = (mz_stream_posix *)stream;
-    return posix->error;
-}
-
-void *mz_stream_os_create(void **stream) {
-    mz_stream_posix *posix = NULL;
-
-    posix = (mz_stream_posix *)calloc(1, sizeof(mz_stream_posix));
-    if (posix)
-        posix->stream.vtbl = &mz_stream_os_vtbl;
-    if (stream)
-        *stream = posix;
-
-    return posix;
-}
-
-void mz_stream_os_delete(void **stream) {
-    mz_stream_posix *posix = NULL;
-    if (!stream)
-        return;
-    posix = (mz_stream_posix *)*stream;
-    if (posix)
-        free(posix);
-    *stream = NULL;
-}
-
-void *mz_stream_os_get_interface(void) {
-    return (void *)&mz_stream_os_vtbl;
-}

package/ios/CodePush/SSZipArchive/minizip/mz_strm_pkcrypt.c

@@ -1,334 +0,0 @@
-/* mz_strm_pkcrypt.c -- Code for traditional PKWARE encryption
-   part of the minizip-ng project
-
-   Copyright (C) Nathan Moinvaziri
-      https://github.com/zlib-ng/minizip-ng
-   Copyright (C) 1998-2005 Gilles Vollant
-      Modifications for Info-ZIP crypting
-      https://www.winimage.com/zLibDll/minizip.html
-   Copyright (C) 2003 Terry Thorsen
-
-   This code is a modified version of crypting code in Info-ZIP distribution
-
-   Copyright (C) 1990-2000 Info-ZIP.  All rights reserved.
-
-   This program is distributed under the terms of the same license as zlib.
-   See the accompanying LICENSE file for the full text of the license.
-
-   This encryption code is a direct transcription of the algorithm from
-   Roger Schlafly, described by Phil Katz in the file appnote.txt. This
-   file (appnote.txt) is distributed with the PKZIP program (even in the
-   version without encryption capabilities).
-*/
-
-#include "mz.h"
-#include "mz_crypt.h"
-#include "mz_strm.h"
-#include "mz_strm_pkcrypt.h"
-
-/***************************************************************************/
-
-static mz_stream_vtbl mz_stream_pkcrypt_vtbl = {
-    mz_stream_pkcrypt_open,
-    mz_stream_pkcrypt_is_open,
-    mz_stream_pkcrypt_read,
-    mz_stream_pkcrypt_write,
-    mz_stream_pkcrypt_tell,
-    mz_stream_pkcrypt_seek,
-    mz_stream_pkcrypt_close,
-    mz_stream_pkcrypt_error,
-    mz_stream_pkcrypt_create,
-    mz_stream_pkcrypt_delete,
-    mz_stream_pkcrypt_get_prop_int64,
-    mz_stream_pkcrypt_set_prop_int64
-};
-
-/***************************************************************************/
-
-typedef struct mz_stream_pkcrypt_s {
-    mz_stream       stream;
-    int32_t         error;
-    int16_t         initialized;
-    uint8_t         buffer[UINT16_MAX];
-    int64_t         total_in;
-    int64_t         max_total_in;
-    int64_t         total_out;
-    uint32_t        keys[3];          /* keys defining the pseudo-random sequence */
-    uint8_t         verify1;
-    uint8_t         verify2;
-    const char      *password;
-} mz_stream_pkcrypt;
-
-/***************************************************************************/
-
-#define mz_stream_pkcrypt_decode(strm, c)                                   \
-    (mz_stream_pkcrypt_update_keys(strm,                                    \
-        c ^= mz_stream_pkcrypt_decrypt_byte(strm)))
-
-#define mz_stream_pkcrypt_encode(strm, c, t)                                \
-    (t = mz_stream_pkcrypt_decrypt_byte(strm),                              \
-        mz_stream_pkcrypt_update_keys(strm, (uint8_t)c), (uint8_t)(t^(c)))
-
-/***************************************************************************/
-
-static uint8_t mz_stream_pkcrypt_decrypt_byte(void *stream) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-
-    unsigned temp; /* POTENTIAL BUG:  temp*(temp^1) may overflow in an */
-                   /* unpredictable manner on 16-bit systems; not a problem */
-                   /* with any known compiler so far, though. */
-
-    temp = pkcrypt->keys[2] | 2;
-    return (uint8_t)(((temp * (temp ^ 1)) >> 8) & 0xff);
-}
-
-static uint8_t mz_stream_pkcrypt_update_keys(void *stream, uint8_t c) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    uint8_t buf = c;
-
-    pkcrypt->keys[0] = (uint32_t)~mz_crypt_crc32_update(~pkcrypt->keys[0], &buf, 1);
-
-    pkcrypt->keys[1] += pkcrypt->keys[0] & 0xff;
-    pkcrypt->keys[1] *= 134775813L;
-    pkcrypt->keys[1] += 1;
-
-    buf = (uint8_t)(pkcrypt->keys[1] >> 24);
-    pkcrypt->keys[2] = (uint32_t)~mz_crypt_crc32_update(~pkcrypt->keys[2], &buf, 1);
-
-    return (uint8_t)c;
-}
-
-static void mz_stream_pkcrypt_init_keys(void *stream, const char *password) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-
-    pkcrypt->keys[0] = 305419896L;
-    pkcrypt->keys[1] = 591751049L;
-    pkcrypt->keys[2] = 878082192L;
-
-    while (*password != 0) {
-        mz_stream_pkcrypt_update_keys(stream, (uint8_t)*password);
-        password += 1;
-    }
-}
-
-/***************************************************************************/
-
-int32_t mz_stream_pkcrypt_open(void *stream, const char *path, int32_t mode) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    uint16_t t = 0;
-    int16_t i = 0;
-    uint8_t verify1 = 0;
-    uint8_t verify2 = 0;
-    uint8_t header[MZ_PKCRYPT_HEADER_SIZE];
-    const char *password = path;
-
-    pkcrypt->total_in = 0;
-    pkcrypt->total_out = 0;
-    pkcrypt->initialized = 0;
-
-    if (mz_stream_is_open(pkcrypt->stream.base) != MZ_OK)
-        return MZ_OPEN_ERROR;
-
-    if (!password)
-        password = pkcrypt->password;
-    if (!password)
-        return MZ_PARAM_ERROR;
-
-    mz_stream_pkcrypt_init_keys(stream, password);
-
-    if (mode & MZ_OPEN_MODE_WRITE) {
-        /* First generate RAND_HEAD_LEN - 2 random bytes. */
-        mz_crypt_rand(header, MZ_PKCRYPT_HEADER_SIZE - 2);
-
-        /* Encrypt random header (last two bytes is high word of crc) */
-        for (i = 0; i < MZ_PKCRYPT_HEADER_SIZE - 2; i++)
-            header[i] = mz_stream_pkcrypt_encode(stream, header[i], t);
-
-        header[i++] = mz_stream_pkcrypt_encode(stream, pkcrypt->verify1, t);
-        header[i++] = mz_stream_pkcrypt_encode(stream, pkcrypt->verify2, t);
-
-        if (mz_stream_write(pkcrypt->stream.base, header, sizeof(header)) != sizeof(header))
-            return MZ_WRITE_ERROR;
-
-        pkcrypt->total_out += MZ_PKCRYPT_HEADER_SIZE;
-    } else if (mode & MZ_OPEN_MODE_READ) {
-        if (mz_stream_read(pkcrypt->stream.base, header, sizeof(header)) != sizeof(header))
-            return MZ_READ_ERROR;
-
-        for (i = 0; i < MZ_PKCRYPT_HEADER_SIZE - 2; i++)
-            header[i] = mz_stream_pkcrypt_decode(stream, header[i]);
-
-        verify1 = mz_stream_pkcrypt_decode(stream, header[i++]);
-        verify2 = mz_stream_pkcrypt_decode(stream, header[i++]);
-
-        /* Older versions used 2 byte check, newer versions use 1 byte check. */
-        MZ_UNUSED(verify1);
-        if ((verify2 != 0) && (verify2 != pkcrypt->verify2))
-            return MZ_PASSWORD_ERROR;
-
-        pkcrypt->total_in += MZ_PKCRYPT_HEADER_SIZE;
-    }
-
-    pkcrypt->initialized = 1;
-    return MZ_OK;
-}
-
-int32_t mz_stream_pkcrypt_is_open(void *stream) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    if (!pkcrypt->initialized)
-        return MZ_OPEN_ERROR;
-    return MZ_OK;
-}
-
-int32_t mz_stream_pkcrypt_read(void *stream, void *buf, int32_t size) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    uint8_t *buf_ptr = (uint8_t *)buf;
-    int32_t bytes_to_read = size;
-    int32_t read = 0;
-    int32_t i = 0;
-
-    if ((int64_t)bytes_to_read > (pkcrypt->max_total_in - pkcrypt->total_in))
-        bytes_to_read = (int32_t)(pkcrypt->max_total_in - pkcrypt->total_in);
-
-    read = mz_stream_read(pkcrypt->stream.base, buf, bytes_to_read);
-
-    for (i = 0; i < read; i++)
-        buf_ptr[i] = mz_stream_pkcrypt_decode(stream, buf_ptr[i]);
-
-    if (read > 0)
-        pkcrypt->total_in += read;
-
-    return read;
-}
-
-int32_t mz_stream_pkcrypt_write(void *stream, const void *buf, int32_t size) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    const uint8_t *buf_ptr = (const uint8_t *)buf;
-    int32_t bytes_to_write = sizeof(pkcrypt->buffer);
-    int32_t total_written = 0;
-    int32_t written = 0;
-    int32_t i = 0;
-    uint16_t t = 0;
-
-    if (size < 0)
-        return MZ_PARAM_ERROR;
-
-    do {
-        if (bytes_to_write > (size - total_written))
-            bytes_to_write = (size - total_written);
-
-        for (i = 0; i < bytes_to_write; i += 1) {
-            pkcrypt->buffer[i] = mz_stream_pkcrypt_encode(stream, *buf_ptr, t);
-            buf_ptr += 1;
-        }
-
-        written = mz_stream_write(pkcrypt->stream.base, pkcrypt->buffer, bytes_to_write);
-        if (written < 0)
-            return written;
-
-        total_written += written;
-    } while (total_written < size && written > 0);
-
-    pkcrypt->total_out += total_written;
-    return total_written;
-}
-
-int64_t mz_stream_pkcrypt_tell(void *stream) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    return mz_stream_tell(pkcrypt->stream.base);
-}
-
-int32_t mz_stream_pkcrypt_seek(void *stream, int64_t offset, int32_t origin) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    return mz_stream_seek(pkcrypt->stream.base, offset, origin);
-}
-
-int32_t mz_stream_pkcrypt_close(void *stream) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    pkcrypt->initialized = 0;
-    return MZ_OK;
-}
-
-int32_t mz_stream_pkcrypt_error(void *stream) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    return pkcrypt->error;
-}
-
-void mz_stream_pkcrypt_set_password(void *stream, const char *password) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    pkcrypt->password = password;
-}
-
-void mz_stream_pkcrypt_set_verify(void *stream, uint8_t verify1, uint8_t verify2) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    pkcrypt->verify1 = verify1;
-    pkcrypt->verify2 = verify2;
-}
-
-void mz_stream_pkcrypt_get_verify(void *stream, uint8_t *verify1, uint8_t *verify2) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    *verify1 = pkcrypt->verify1;
-    *verify2 = pkcrypt->verify2;
-}
-
-int32_t mz_stream_pkcrypt_get_prop_int64(void *stream, int32_t prop, int64_t *value) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    switch (prop) {
-    case MZ_STREAM_PROP_TOTAL_IN:
-        *value = pkcrypt->total_in;
-        break;
-    case MZ_STREAM_PROP_TOTAL_OUT:
-        *value = pkcrypt->total_out;
-        break;
-    case MZ_STREAM_PROP_TOTAL_IN_MAX:
-        *value = pkcrypt->max_total_in;
-        break;
-    case MZ_STREAM_PROP_HEADER_SIZE:
-        *value = MZ_PKCRYPT_HEADER_SIZE;
-        break;
-    case MZ_STREAM_PROP_FOOTER_SIZE:
-        *value = 0;
-        break;
-    default:
-        return MZ_EXIST_ERROR;
-    }
-    return MZ_OK;
-}
-
-int32_t mz_stream_pkcrypt_set_prop_int64(void *stream, int32_t prop, int64_t value) {
-    mz_stream_pkcrypt *pkcrypt = (mz_stream_pkcrypt *)stream;
-    switch (prop) {
-    case MZ_STREAM_PROP_TOTAL_IN_MAX:
-        pkcrypt->max_total_in = value;
-        break;
-    default:
-        return MZ_EXIST_ERROR;
-    }
-    return MZ_OK;
-}
-
-void *mz_stream_pkcrypt_create(void **stream) {
-    mz_stream_pkcrypt *pkcrypt = NULL;
-
-    pkcrypt = (mz_stream_pkcrypt *)calloc(1, sizeof(mz_stream_pkcrypt));
-    if (pkcrypt)
-        pkcrypt->stream.vtbl = &mz_stream_pkcrypt_vtbl;
-    if (stream)
-        *stream = pkcrypt;
-
-    return pkcrypt;
-}
-
-void mz_stream_pkcrypt_delete(void **stream) {
-    mz_stream_pkcrypt *pkcrypt = NULL;
-    if (!stream)
-        return;
-    pkcrypt = (mz_stream_pkcrypt *)*stream;
-    if (pkcrypt)
-        free(pkcrypt);
-    *stream = NULL;
-}
-
-void *mz_stream_pkcrypt_get_interface(void) {
-    return (void *)&mz_stream_pkcrypt_vtbl;
-}

package/ios/CodePush/SSZipArchive/minizip/mz_strm_pkcrypt.h

@@ -1,46 +0,0 @@
-/* mz_strm_pkcrypt.h -- Code for traditional PKWARE encryption
-   part of the minizip-ng project
-
-   Copyright (C) Nathan Moinvaziri
-     https://github.com/zlib-ng/minizip-ng
-
-   This program is distributed under the terms of the same license as zlib.
-   See the accompanying LICENSE file for the full text of the license.
-*/
-
-#ifndef MZ_STREAM_PKCRYPT_H
-#define MZ_STREAM_PKCRYPT_H
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/***************************************************************************/
-
-int32_t mz_stream_pkcrypt_open(void *stream, const char *filename, int32_t mode);
-int32_t mz_stream_pkcrypt_is_open(void *stream);
-int32_t mz_stream_pkcrypt_read(void *stream, void *buf, int32_t size);
-int32_t mz_stream_pkcrypt_write(void *stream, const void *buf, int32_t size);
-int64_t mz_stream_pkcrypt_tell(void *stream);
-int32_t mz_stream_pkcrypt_seek(void *stream, int64_t offset, int32_t origin);
-int32_t mz_stream_pkcrypt_close(void *stream);
-int32_t mz_stream_pkcrypt_error(void *stream);
-
-void    mz_stream_pkcrypt_set_password(void *stream, const char *password);
-void    mz_stream_pkcrypt_set_verify(void *stream, uint8_t verify1, uint8_t verify2);
-void    mz_stream_pkcrypt_get_verify(void *stream, uint8_t *verify1, uint8_t *verify2);
-int32_t mz_stream_pkcrypt_get_prop_int64(void *stream, int32_t prop, int64_t *value);
-int32_t mz_stream_pkcrypt_set_prop_int64(void *stream, int32_t prop, int64_t value);
-
-void*   mz_stream_pkcrypt_create(void **stream);
-void    mz_stream_pkcrypt_delete(void **stream);
-
-void*   mz_stream_pkcrypt_get_interface(void);
-
-/***************************************************************************/
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif