@algocare/react-native-code-push 12.6.4 → 13.0.0-rc.0

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

@@ -0,0 +1,48 @@
+/* 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

@@ -0,0 +1,40 @@
+/* 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

@@ -0,0 +1,203 @@
+/* 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

@@ -0,0 +1,334 @@
+/* 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

@@ -0,0 +1,46 @@
+/* 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