io_zip.c File Reference

#include <rz_io.h>
#include <rz_lib.h>
#include <rz_util.h>
#include <rz_cons.h>
#include <zip.h>

Go to the source code of this file.

Classes
struct	rz_io_zip_uri_const_t
struct	rz_io_zfo_t

Typedefs
typedef struct rz_io_zip_uri_const_t	RzIOZipConstURI
typedef struct rz_io_zfo_t	RzIOZipFileObj

Enumerations
enum	RZ_IO_ZIP_ARCHIVE_TYPE {   RZ_IO_PARENT_ZIP = 0x0001 , RZ_IO_CHILD_FILE = 0x0002 , RZ_IO_NEW_FILE = 0x0004 , RZ_IO_EXISTING_FILE = 0x0008 ,   RZ_IO_MODIFIED_FILE = 0x0010 , RZ_IO_DELETED_FILE = 0x0020 }

Functions
static int	rz_io_zip_has_uri_substr (const char *file)
static int	rz_io_zip_check_uri_many (const char *file)
static int	rz_io_zip_check_uri (const char *file)
static bool	rz_io_zip_plugin_open (RzIO *io, const char *file, bool many)
struct zip *	rz_io_zip_open_archive (const char *archivename, ut32 perm, int mode, int rw)
static int	rz_io_zip_slurp_file (RzIOZipFileObj *zfo)
RzList *	rz_io_zip_get_files (const char *archivename, ut32 perm, int mode, int rw)
int	rz_io_zip_flush_file (RzIOZipFileObj *zfo)
static void	rz_io_zip_free_zipfileobj (RzIOZipFileObj *zfo)
RzIOZipFileObj *	rz_io_zip_create_new_file (const char *archivename, const char *filename, struct zip_stat *sb, ut32 perm, int mode, int rw)
RzIOZipFileObj *	rz_io_zip_alloc_zipfileobj (const char *archivename, const char *filename, ut32 perm, int mode, int rw)
static RzList *	rz_io_zip_open_many (RzIO *io, const char *file, int rw, int mode)
char *	rz_io_zip_get_by_file_idx (const char *archivename, const char *idx, ut32 perm, int mode, int rw)
static char *	find_ipa_binary (const char *filename, int rw, int mode)
static char *	find_apk_binary (const char *filename, int rw, int mode, RzIO *io)
static RzIODesc *	rz_io_zip_open (RzIO *io, const char *file, int rw, int mode)
static ut64	rz_io_zip_lseek (RzIO *io, RzIODesc *fd, ut64 offset, int whence)
static int	rz_io_zip_read (RzIO *io, RzIODesc *fd, ut8 *buf, int count)
static int	rz_io_zip_realloc_buf (RzIOZipFileObj *zfo, int count)
static bool	rz_io_zip_truncate_buf (RzIOZipFileObj *zfo, int size)
static bool	rz_io_zip_resize (RzIO *io, RzIODesc *fd, ut64 size)
static int	rz_io_zip_write (RzIO *io, RzIODesc *fd, const ut8 *buf, int count)
static int	rz_io_zip_close (RzIODesc *fd)

Variables
static RzIOZipConstURI	ZIP_URIS []
static RzIOZipConstURI	ZIP_ALL_URIS []
RzIOPlugin	rz_io_plugin_zip
RZ_API RzLibStruct	rizin_plugin

Typedef Documentation

RzIOZipConstURI

typedef struct rz_io_zip_uri_const_t RzIOZipConstURI

RzIOZipFileObj

typedef struct rz_io_zfo_t RzIOZipFileObj

Enumeration Type Documentation

RZ_IO_ZIP_ARCHIVE_TYPE

enum RZ_IO_ZIP_ARCHIVE_TYPE

Enumerator
RZ_IO_PARENT_ZIP
RZ_IO_CHILD_FILE
RZ_IO_NEW_FILE
RZ_IO_EXISTING_FILE
RZ_IO_MODIFIED_FILE
RZ_IO_DELETED_FILE

Definition at line 11 of file io_zip.c.

             {
    RZ_IO_PARENT_ZIP = 0x0001,
    RZ_IO_CHILD_FILE = 0x0002,
    RZ_IO_NEW_FILE = 0x0004,
    RZ_IO_EXISTING_FILE = 0x0008,
    RZ_IO_MODIFIED_FILE = 0x0010,
    RZ_IO_DELETED_FILE = 0x0020,
} RZ_IO_ZIP_ARCHIVE_TYPE;

Function Documentation

find_apk_binary()

static char* find_apk_binary ( const char *  filename, int  rw, int  mode, RzIO *  io  )

static

Definition at line 409 of file io_zip.c.

                                                                               {
    RzList *files = NULL;
    RzListIter *iter = NULL;
    char *name = NULL;
    RzIOZipFileObj *zfo = NULL;
    char *zip_filename = rz_str_newf("//%s//classes.dex", filename);
    files = rz_io_zip_get_files(filename, 0, mode, rw);
 
    if (files) {
        rz_list_foreach (files, iter, name) {
            /* Find matching file */
            if (!strcmp(name, "classes.dex")) {
                continue;
            } else if (rz_str_endswith(name, ".dex")) {
                RZ_LOG_INFO("Adding extra IO descriptor to file %s\n", name);
                zfo = rz_io_zip_alloc_zipfileobj(filename, name, ZIP_CREATE, mode, rw);
                if (!zfo) {
                    eprintf("Error: cannot allocate zip file object.\n");
                    continue;
                }
                if (zfo->entry == -1) {
                    if (!rw) {
                        eprintf("Warning: File %s does not exist.\n", name);
                        rz_io_zip_free_zipfileobj(zfo);
                        continue;
                    }
                    eprintf("Warning: File %s does not exist, creating a new one.\n", name);
                }
                zfo->io_backref = io;
                RzIODesc *desc = rz_io_desc_new(io, &rz_io_plugin_zip, zfo->name, rw, mode, zfo);
                desc->name = strdup(name);
                rz_io_desc_add(io, desc);
            }
        }
        rz_list_free(files);
    }
 
    return zip_filename;
}

References desc, rz_io_zfo_t::entry, eprintf, files, rz_io_zfo_t::io_backref, rz_io_zfo_t::name, NULL, rz_io_desc_add(), rz_io_desc_new(), rz_io_plugin_zip, rz_io_zip_alloc_zipfileobj(), rz_io_zip_free_zipfileobj(), rz_io_zip_get_files(), rz_list_free(), RZ_LOG_INFO, rz_str_endswith(), rz_str_newf(), strdup(), and ZIP_CREATE.

Referenced by rz_io_zip_open().

find_ipa_binary()

static char* find_ipa_binary ( const char *  filename, int  rw, int  mode  )

static

Definition at line 376 of file io_zip.c.

                                                                     {
    RzList *files = NULL;
    RzListIter *iter;
    char *name;
    int app_size = 0;
    const char *app_name;
    const char *last_slash;
 
    char *zip_filename = NULL;
    files = rz_io_zip_get_files(filename, 0, mode, rw);
 
    rz_list_foreach (files, iter, name) {
        /* Find matching file */
        app_name = strstr(name, ".app/");
        if (!app_name) {
            continue;
        }
        last_slash = rz_str_rchr(name, app_name, '/');
        if (!last_slash) {
            continue;
        }
        app_size = (app_name - last_slash) - 1;
        zip_filename = rz_str_newf("//Payload/%.*s.app/%.*s", app_size, last_slash + 1, app_size, last_slash + 1);
        if (zip_filename && !strcmp(name, zip_filename + 2)) {
            break;
        }
        RZ_FREE(zip_filename);
    }
    rz_list_free(files);
 
    return zip_filename;
}

References files, name, NULL, RZ_FREE, rz_io_zip_get_files(), rz_list_free(), rz_str_newf(), and rz_str_rchr().

Referenced by rz_io_zip_open().

rz_io_zip_alloc_zipfileobj()

RzIOZipFileObj* rz_io_zip_alloc_zipfileobj	(	const char *	archivename,
		const char *	filename,
		ut32	perm,
		int	mode,
		int	rw
	)

Definition at line 252 of file io_zip.c.

                                                                                                                       {
    RzIOZipFileObj *zfo = NULL;
    ut64 i, num_entries;
    struct zip_stat sb;
    struct zip *zipArch = rz_io_zip_open_archive(archivename, perm, mode, rw);
    if (!zipArch) {
        return NULL;
    }
    num_entries = zip_get_num_files(zipArch);
 
    for (i = 0; i < num_entries; i++) {
        zip_stat_init(&sb);
        zip_stat_index(zipArch, i, 0, &sb);
        if (sb.name != NULL) {
            if (strcmp(sb.name, filename) == 0) {
                zfo = rz_io_zip_create_new_file(
                    archivename, filename, &sb,
                    perm, mode, rw);
                rz_io_zip_slurp_file(zfo);
                break;
            }
        }
    }
    if (!zfo) {
        zfo = rz_io_zip_create_new_file(archivename,
            filename, NULL, perm, mode, rw);
    }
    zip_close(zipArch);
    return zfo;
}

References i, NULL, rz_io_zip_create_new_file(), rz_io_zip_open_archive(), rz_io_zip_slurp_file(), sb, ut64(), zip_close(), zip_get_num_files(), zip_stat_index(), and zip_stat_init().

Referenced by find_apk_binary(), rz_io_zip_open(), and rz_io_zip_open_many().

rz_io_zip_check_uri()

static int rz_io_zip_check_uri ( const char *  file )

static

Definition at line 73 of file io_zip.c.

                                                 {
    int i;
    if (rz_io_zip_has_uri_substr(file)) {
        for (i = 0; ZIP_URIS[i].name != NULL; i++) {
            if (!strncmp(file, ZIP_URIS[i].name, ZIP_URIS[i].len) && file[ZIP_URIS[i].len]) {
                return true;
            }
        }
    }
    return false;
}

References i, len, rz_io_zip_uri_const_t::name, NULL, rz_io_zip_has_uri_substr(), and ZIP_URIS.

Referenced by rz_io_zip_plugin_open().

rz_io_zip_check_uri_many()

static int rz_io_zip_check_uri_many ( const char *  file )

static

Definition at line 61 of file io_zip.c.

                                                      {
    int i;
    if (rz_io_zip_has_uri_substr(file)) {
        for (i = 0; ZIP_ALL_URIS[i].name != NULL; i++) {
            if (!strncmp(file, ZIP_ALL_URIS[i].name, ZIP_ALL_URIS[i].len) && file[ZIP_ALL_URIS[i].len]) {
                return true;
            }
        }
    }
    return false;
}

References i, len, rz_io_zip_uri_const_t::name, NULL, rz_io_zip_has_uri_substr(), and ZIP_ALL_URIS.

Referenced by rz_io_zip_plugin_open().

rz_io_zip_close()

static int rz_io_zip_close ( RzIODesc *  fd )

static

Definition at line 664 of file io_zip.c.

                                         {
    RzIOZipFileObj *zfo;
    if (!fd || !fd->data) {
        return -1;
    }
    zfo = fd->data;
    rz_io_zip_free_zipfileobj(zfo);
    zfo = fd->data = NULL;
    return 0;
}

References fd, NULL, and rz_io_zip_free_zipfileobj().

rz_io_zip_create_new_file()

RzIOZipFileObj* rz_io_zip_create_new_file	(	const char *	archivename,
		const char *	filename,
		struct zip_stat *	sb,
		ut32	perm,
		int	mode,
		int	rw
	)

Definition at line 236 of file io_zip.c.

                                                                                                                                           {
    RzIOZipFileObj *zfo = RZ_NEW0(RzIOZipFileObj);
    if (zfo) {
        zfo->b = rz_buf_new_with_bytes(NULL, 0);
        zfo->archivename = strdup(archivename);
        zfo->name = strdup(sb ? sb->name : filename);
        zfo->entry = !sb ? -1 : sb->index;
        zfo->fd = rz_num_rand(0xFFFF); // XXX: Use rz_io_fd api
        zfo->perm = perm;
        zfo->mode = mode;
        zfo->rw = rw;
    }
    return zfo;
}

References rz_io_zfo_t::archivename, rz_io_zfo_t::b, rz_io_zfo_t::entry, rz_io_zfo_t::fd, rz_io_zfo_t::mode, rz_io_zfo_t::name, NULL, rz_io_zfo_t::perm, rz_io_zfo_t::rw, rz_buf_new_with_bytes(), RZ_NEW0, rz_num_rand(), sb, and strdup().

Referenced by rz_io_zip_alloc_zipfileobj().

rz_io_zip_flush_file()

int rz_io_zip_flush_file

(

RzIOZipFileObj *

zfo

)

Definition at line 188 of file io_zip.c.

                                              {
    int res = false;
    struct zip *zipArch;
 
    if (!zfo) {
        return res;
    }
 
    zipArch = rz_io_zip_open_archive(
        zfo->archivename, zfo->perm, zfo->mode, zfo->rw);
    if (!zipArch) {
        return res;
    }
 
    ut64 tmpsz;
    const ut8 *tmp = rz_buf_data(zfo->b, &tmpsz);
    struct zip_source *s = zip_source_buffer(zipArch, tmp, tmpsz, 0);
    if (s && zfo->entry != -1) {
        if (zip_replace(zipArch, zfo->entry, s) == 0) {
            res = true;
        }
    } else if (s && zfo->name) {
        if (zip_add(zipArch, zfo->name, s) == 0) {
            zfo->entry = zip_name_locate(zipArch, zfo->name, 0);
            res = true;
        }
    }
    // s (zip_source) is freed when the archive is closed, i think - dso
    zip_close(zipArch);
    if (s) {
        zip_source_free(s);
    }
    return res;
}

References rz_io_zfo_t::archivename, rz_io_zfo_t::b, rz_io_zfo_t::entry, rz_io_zfo_t::mode, rz_io_zfo_t::name, rz_io_zfo_t::perm, rz_io_zfo_t::rw, rz_buf_data(), rz_io_zip_open_archive(), s, autogen_x86imm::tmp, ut64(), zip_add(), zip_close(), zip_name_locate(), zip_replace(), zip_source_buffer(), and zip_source_free().

Referenced by rz_io_zip_free_zipfileobj(), rz_io_zip_resize(), and rz_io_zip_write().

rz_io_zip_free_zipfileobj()

static void rz_io_zip_free_zipfileobj ( RzIOZipFileObj *  zfo )

static

Definition at line 223 of file io_zip.c.

                                                           {
    if (!zfo) {
        return;
    }
    if (zfo->modified) {
        rz_io_zip_flush_file(zfo);
    }
    free(zfo->name);
    free(zfo->password);
    rz_buf_free(zfo->b);
    free(zfo);
}

References rz_io_zfo_t::b, free(), rz_io_zfo_t::modified, rz_io_zfo_t::name, rz_io_zfo_t::password, rz_buf_free(), and rz_io_zip_flush_file().

Referenced by find_apk_binary(), and rz_io_zip_close().

rz_io_zip_get_by_file_idx()

char* rz_io_zip_get_by_file_idx	(	const char *	archivename,
		const char *	idx,
		ut32	perm,
		int	mode,
		int	rw
	)

Definition at line 348 of file io_zip.c.

                                                                                                       {
    char *filename = NULL;
    ut64 i, num_entries;
    ut32 file_idx = -1;
    struct zip_stat sb;
    struct zip *zipArch = rz_io_zip_open_archive(archivename, perm, mode, rw);
    if (!idx || !zipArch) {
        zip_close(zipArch);
        return filename;
    }
    num_entries = zip_get_num_files(zipArch);
    file_idx = atoi(idx);
    if ((file_idx == 0 && idx[0] != '0') || (file_idx >= num_entries)) {
        zip_close(zipArch);
        return filename;
    }
    for (i = 0; i < num_entries; i++) {
        zip_stat_init(&sb);
        zip_stat_index(zipArch, i, 0, &sb);
        if (file_idx == i) {
            filename = strdup(sb.name);
            break;
        }
    }
    zip_close(zipArch);
    return filename;
}

References i, setup::idx, NULL, rz_io_zip_open_archive(), sb, strdup(), ut64(), zip_close(), zip_get_num_files(), zip_stat_index(), and zip_stat_init().

Referenced by rz_io_zip_open().

rz_io_zip_get_files()

RzList* rz_io_zip_get_files	(	const char *	archivename,
		ut32	perm,
		int	mode,
		int	rw
	)

Definition at line 160 of file io_zip.c.

                                                                                  {
    struct zip *zipArch = rz_io_zip_open_archive(archivename, perm, mode, rw);
    ut64 num_entries = 0, i = 0;
    struct zip_stat sb;
    char *name = NULL;
    RzList *files = NULL;
    if (!zipArch) {
        return NULL;
    }
 
    files = rz_list_newf(free);
    if (!files) {
        zip_close(zipArch);
        return NULL;
    }
 
    num_entries = zip_get_num_files(zipArch);
    for (i = 0; i < num_entries; i++) {
        zip_stat_init(&sb);
        zip_stat_index(zipArch, i, 0, &sb);
        if ((name = strdup(sb.name))) {
            rz_list_append(files, name);
        }
    }
    zip_close(zipArch);
    return files;
}

References files, free(), i, NULL, rz_io_zip_open_archive(), rz_list_append(), rz_list_newf(), sb, strdup(), ut64(), zip_close(), zip_get_num_files(), zip_stat_index(), and zip_stat_init().

Referenced by find_apk_binary(), find_ipa_binary(), rz_io_zip_open(), and rz_io_zip_open_many().

rz_io_zip_has_uri_substr()

static int rz_io_zip_has_uri_substr ( const char *  file )

static

Definition at line 57 of file io_zip.c.

                                                      {
    return (file && strstr(file, "://"));
}

Referenced by rz_io_zip_check_uri(), and rz_io_zip_check_uri_many().

rz_io_zip_lseek()

static ut64 rz_io_zip_lseek ( RzIO *  io, RzIODesc *  fd, ut64  offset, int  whence  )

static

Definition at line 568 of file io_zip.c.

                                                                             {
    RzIOZipFileObj *zfo;
    ut64 seek_val = 0;
 
    if (!fd || !fd->data) {
        return -1;
    }
 
    zfo = fd->data;
    seek_val = rz_buf_tell(zfo->b);
 
    switch (whence) {
    case SEEK_SET:
        seek_val = (rz_buf_size(zfo->b) < offset) ? rz_buf_size(zfo->b) : offset;
        io->off = seek_val;
        rz_buf_seek(zfo->b, seek_val, RZ_BUF_SET);
        return seek_val;
    case SEEK_CUR:
        seek_val = (rz_buf_size(zfo->b) < (offset + rz_buf_tell(zfo->b))) ? rz_buf_size(zfo->b) : offset + rz_buf_tell(zfo->b);
        io->off = seek_val;
        rz_buf_seek(zfo->b, seek_val, RZ_BUF_SET);
        return seek_val;
    case SEEK_END:
        seek_val = rz_buf_size(zfo->b);
        io->off = seek_val;
        rz_buf_seek(zfo->b, seek_val, RZ_BUF_SET);
        return seek_val;
    }
    return seek_val;
}

References rz_io_zfo_t::b, fd, rz_io_t::off, rz_buf_seek(), RZ_BUF_SET, rz_buf_size(), rz_buf_tell(), SEEK_CUR, SEEK_END, SEEK_SET, and ut64().

rz_io_zip_open()

static RzIODesc* rz_io_zip_open ( RzIO *  io, const char *  file, int  rw, int  mode  )

static

Definition at line 449 of file io_zip.c.

                                                                              {
    RzIODesc *res = NULL;
    char *uri_path, *tmp;
    RzIOZipFileObj *zfo = NULL;
    char *zip_uri = NULL, *zip_filename = NULL, *filename_in_zipfile = NULL;
 
    if (!rz_io_zip_plugin_open(io, file, false)) {
        return NULL;
    }
    zip_uri = strdup(file);
    if (!zip_uri) {
        return NULL;
    }
    uri_path = strstr(zip_uri, "://");
    if (uri_path) {
        tmp = strstr(uri_path + 3, "//");
        zip_filename = tmp ? strdup(tmp) : NULL;
        // 1) Tokenize to the '//' and find the base file directory ('/')
        if (!zip_filename) {
            if (!strncmp(zip_uri, "apk://", 6)) {
                zip_filename = find_apk_binary(uri_path + 3, rw, mode, io);
            } else if (!strncmp(zip_uri, "ipa://", 6)) {
                zip_filename = find_ipa_binary(uri_path + 3, rw, mode);
            } else {
                zip_filename = strdup(uri_path + 1);
            }
        } else {
            free(zip_filename);
            zip_filename = strdup(uri_path + 1);
        }
    }
    tmp = zip_filename;
    if (zip_filename && zip_filename[1] && zip_filename[2]) {
        if (zip_filename[0] && zip_filename[0] == '/' &&
            zip_filename[1] && zip_filename[1] == '/') {
            *zip_filename++ = 0;
        }
        *zip_filename++ = 0;
 
        // check for // for file in the archive
        if ((filename_in_zipfile = strstr(zip_filename, "//")) && filename_in_zipfile[2]) {
            // null terminating uri to filename here.
            *filename_in_zipfile++ = 0;
            *filename_in_zipfile++ = 0;
            filename_in_zipfile = strdup(filename_in_zipfile);
            // check for :: index
        } else if ((filename_in_zipfile = strstr(zip_filename, "::")) &&
            filename_in_zipfile[2]) {
            // null terminating uri to filename here.
            *filename_in_zipfile++ = 0;
            *filename_in_zipfile++ = 0;
            filename_in_zipfile = rz_io_zip_get_by_file_idx(
                zip_filename, filename_in_zipfile,
                ZIP_CREATE, mode, rw);
        } else {
            filename_in_zipfile = rz_str_newf("%s", zip_filename);
            RZ_FREE(tmp);
            zip_filename = strdup(uri_path + 3);
            if (!strcmp(zip_filename, filename_in_zipfile)) {
                // RZ_FREE (zip_filename);
                RZ_FREE(filename_in_zipfile);
            }
        }
    }
 
    if (!zip_filename) { // && !filename_in_zipfile) {
        // free (zip_uri);
        eprintf("usage: zip:///path/to/archive//filepath\n"
            "usage: zip:///path/to/archive::[number]\n"
            "Archive was not found.\n");
        // return res;
    }
 
    // Failed to find the file name the archive.
    if (!filename_in_zipfile) {
        RzList *files = NULL;
        RzListIter *iter;
        char *name;
        // eprintf("usage: zip:///path/to/archive//filepath\n");
        files = rz_io_zip_get_files(zip_filename, 0, mode, rw);
        if (files) {
            ut32 i = 0;
            rz_list_foreach (files, iter, name) {
                io->cb_printf("%d %s\n", i, name);
                i++;
            }
            rz_list_free(files);
        }
        goto done;
    }
    // eprintf("After parsing the given uri: %s\n", file);
    // eprintf("Zip filename the given uri: %s\n", zip_filename);
    // eprintf("File in the zip: %s\n", filename_in_zipfile);
    zfo = rz_io_zip_alloc_zipfileobj(zip_filename,
        filename_in_zipfile, ZIP_CREATE, mode, rw);
 
    if (zfo) {
        if (zfo->entry == -1) {
            eprintf("Warning: File %s does not exist, creating a new one.\n", filename_in_zipfile);
        }
        zfo->io_backref = io;
        res = rz_io_desc_new(io, &rz_io_plugin_zip,
            zfo->name, rw, mode, zfo);
    }
 
    if (!res) {
        eprintf("Failed to open the archive %s and file %s\n",
            zip_filename, filename_in_zipfile);
        // free (zfo); zfo is already freed by rz_io_desc_new
        rz_io_desc_free(res);
        res = NULL;
    }
done:
    free(filename_in_zipfile);
    free(zip_uri);
    free(tmp);
    return res;
}

References rz_io_t::cb_printf, done, rz_io_zfo_t::entry, eprintf, files, find_apk_binary(), find_ipa_binary(), free(), i, rz_io_zfo_t::io_backref, name, rz_io_zfo_t::name, NULL, RZ_FREE, rz_io_desc_free(), rz_io_desc_new(), rz_io_plugin_zip, rz_io_zip_alloc_zipfileobj(), rz_io_zip_get_by_file_idx(), rz_io_zip_get_files(), rz_io_zip_plugin_open(), rz_list_free(), rz_str_newf(), strdup(), autogen_x86imm::tmp, and ZIP_CREATE.

rz_io_zip_open_archive()

struct zip* rz_io_zip_open_archive	(	const char *	archivename,
		ut32	perm,
		int	mode,
		int	rw
	)

Definition at line 95 of file io_zip.c.

                                                                                         {
    struct zip *zipArch = NULL;
    int zip_errorp;
    if (!archivename) {
        return NULL;
    }
    if ((zipArch = zip_open(archivename, perm, &zip_errorp))) {
        return zipArch;
    }
    if (zip_errorp == ZIP_ER_INVAL) {
        eprintf("ZIP File Error: Invalid file name (NULL).\n");
    } else if (zip_errorp == ZIP_ER_OPEN) {
        eprintf("ZIP File Error: File could not be opened file name.\n");
    } else if (zip_errorp == ZIP_ER_NOENT) {
        eprintf("ZIP File Error: File does not exist.\n");
    } else if (zip_errorp == ZIP_ER_READ) {
        eprintf("ZIP File Error: Read error occurred.\n");
    } else if (zip_errorp == ZIP_ER_NOZIP) {
        eprintf("ZIP File Error: File is not a valid ZIP archive.\n");
    } else if (zip_errorp == ZIP_ER_INCONS) {
        eprintf("ZIP File Error: ZIP file had some inconsistencies archive.\n");
    } else {
        eprintf("ZIP File Error: Something bad happened, get your debug on.\n");
    }
    return NULL;
}

References eprintf, NULL, ZIP_ER_INCONS, ZIP_ER_INVAL, ZIP_ER_NOENT, ZIP_ER_NOZIP, ZIP_ER_OPEN, ZIP_ER_READ, and zip_open().

Referenced by rz_io_zip_alloc_zipfileobj(), rz_io_zip_flush_file(), rz_io_zip_get_by_file_idx(), rz_io_zip_get_files(), and rz_io_zip_slurp_file().

rz_io_zip_open_many()

static RzList* rz_io_zip_open_many ( RzIO *  io, const char *  file, int  rw, int  mode  )

static

Definition at line 284 of file io_zip.c.

                                                                                 {
    RzList *list_fds = NULL;
    RzListIter *iter;
    RzList *filenames = NULL;
    RzIODesc *res = NULL;
    RzIOZipFileObj *zfo = NULL;
    char *filename_in_zipfile, *zip_filename = NULL, *zip_uri;
 
    if (!rz_io_zip_plugin_open(io, file, true)) {
        return NULL;
    }
 
    zip_uri = strdup(file);
    if (!zip_uri) {
        return NULL;
    }
    // 1) Tokenize to the '//' and find the base file directory ('/')
    zip_filename = strstr(zip_uri, "//");
    if (zip_filename && zip_filename[2]) {
        if (zip_filename[0] && zip_filename[0] == '/' &&
            zip_filename[1] && zip_filename[1] == '/') {
            *zip_filename++ = 0;
        }
        *zip_filename++ = 0;
    } else {
        free(zip_uri);
        return NULL;
    }
 
    filenames = rz_io_zip_get_files(zip_filename, 0, mode, rw);
 
    if (!filenames) {
        free(zip_uri);
        return NULL;
    }
 
    list_fds = rz_list_new();
    rz_list_foreach (filenames, iter, filename_in_zipfile) {
        size_t v = strlen(filename_in_zipfile);
 
        if (filename_in_zipfile[v - 1] == '/') {
            continue;
        }
 
        zfo = rz_io_zip_alloc_zipfileobj(zip_filename,
            filename_in_zipfile, ZIP_CREATE, mode, rw);
 
        if (zfo && zfo->entry == -1) {
            eprintf("Warning: File did not exist, creating a new one.\n");
        }
 
        if (zfo) {
            zfo->io_backref = io;
            res = rz_io_desc_new(io, &rz_io_plugin_zip,
                zfo->name, rw, mode, zfo);
        }
        rz_list_append(list_fds, res);
    }
 
    free(zip_uri);
    rz_list_free(filenames);
    return list_fds;
}

References rz_io_zfo_t::entry, eprintf, free(), rz_io_zfo_t::io_backref, rz_io_zfo_t::name, NULL, rz_io_desc_new(), rz_io_plugin_zip, rz_io_zip_alloc_zipfileobj(), rz_io_zip_get_files(), rz_io_zip_plugin_open(), rz_list_append(), rz_list_free(), rz_list_new(), strdup(), v, and ZIP_CREATE.

rz_io_zip_plugin_open()

static bool rz_io_zip_plugin_open ( RzIO *  io, const char *  file, bool  many  )

static

Definition at line 85 of file io_zip.c.

                                                                         {
    if (io && file) {
        if (many) {
            return rz_io_zip_check_uri_many(file);
        }
        return rz_io_zip_check_uri(file);
    }
    return false;
}

References rz_io_zip_check_uri(), and rz_io_zip_check_uri_many().

Referenced by rz_io_zip_open(), and rz_io_zip_open_many().

rz_io_zip_read()

static int rz_io_zip_read ( RzIO *  io, RzIODesc *  fd, ut8 *  buf, int  count  )

static

Definition at line 599 of file io_zip.c.

                                                                       {
    RzIOZipFileObj *zfo = NULL;
    if (!fd || !fd->data || !buf) {
        return -1;
    }
    zfo = fd->data;
    if (rz_buf_size(zfo->b) < io->off) {
        io->off = rz_buf_size(zfo->b);
    }
    int r = rz_buf_read_at(zfo->b, io->off, buf, count);
    if (r >= 0) {
        rz_buf_seek(zfo->b, r, RZ_BUF_CUR);
    }
    return r;
}

References rz_io_zfo_t::b, count, fd, NULL, rz_io_t::off, r, RZ_BUF_CUR, rz_buf_read_at(), rz_buf_seek(), and rz_buf_size().

rz_io_zip_realloc_buf()

static int rz_io_zip_realloc_buf ( RzIOZipFileObj *  zfo, int  count  )

static

Definition at line 615 of file io_zip.c.

                                                                 {
    return rz_buf_resize(zfo->b, rz_buf_tell(zfo->b) + count);
}

References rz_io_zfo_t::b, count, rz_buf_resize(), and rz_buf_tell().

Referenced by rz_io_zip_write().

rz_io_zip_resize()

static bool rz_io_zip_resize ( RzIO *  io, RzIODesc *  fd, ut64  size  )

static

Definition at line 623 of file io_zip.c.

                                                                {
    RzIOZipFileObj *zfo;
    if (!fd || !fd->data) {
        return false;
    }
    zfo = fd->data;
    if (rz_io_zip_truncate_buf(zfo, size)) {
        zfo->modified = 1;
        rz_io_zip_flush_file(zfo);
        return true;
    }
    return false;
}

References fd, rz_io_zfo_t::modified, rz_io_zip_flush_file(), and rz_io_zip_truncate_buf().

rz_io_zip_slurp_file()

static int rz_io_zip_slurp_file ( RzIOZipFileObj *  zfo )

static

Definition at line 122 of file io_zip.c.

                                                     {
    struct zip_file *zFile = NULL;
    struct zip *zipArch;
    struct zip_stat sb;
    bool res = false;
    if (!zfo) {
        return res;
    }
    zipArch = rz_io_zip_open_archive(
        zfo->archivename, zfo->perm,
        zfo->mode, zfo->rw);
 
    if (zipArch && zfo && zfo->entry != -1) {
        zFile = zip_fopen_index(zipArch, zfo->entry, 0);
        if (!zFile) {
            zip_close(zipArch);
            return false;
        }
        if (!zfo->b) {
            zfo->b = rz_buf_new_with_bytes(NULL, 0);
        }
        zip_stat_init(&sb);
        if (zfo->b && !zip_stat_index(zipArch, zfo->entry, 0, &sb)) {
            ut8 *buf = calloc(1, sb.size);
            if (buf) {
                zip_fread(zFile, buf, sb.size);
                rz_buf_set_bytes(zfo->b, buf, sb.size);
                res = true;
                zfo->opened = true;
                free(buf);
            }
        }
        zip_fclose(zFile);
    }
    zip_close(zipArch);
    return res;
}

References rz_io_zfo_t::archivename, rz_io_zfo_t::b, calloc(), rz_io_zfo_t::entry, free(), rz_io_zfo_t::mode, NULL, rz_io_zfo_t::opened, rz_io_zfo_t::perm, rz_io_zfo_t::rw, rz_buf_new_with_bytes(), rz_buf_set_bytes(), rz_io_zip_open_archive(), sb, zip_close(), zip_fclose(), zip_fopen_index(), zip_fread(), zip_stat_index(), and zip_stat_init().

Referenced by rz_io_zip_alloc_zipfileobj().

rz_io_zip_truncate_buf()

static bool rz_io_zip_truncate_buf ( RzIOZipFileObj *  zfo, int  size  )

static

Definition at line 619 of file io_zip.c.

                                                                  {
    return rz_buf_resize(zfo->b, size > 0 ? size : 0);
}

References rz_io_zfo_t::b, and rz_buf_resize().

Referenced by rz_io_zip_resize().

rz_io_zip_write()

static int rz_io_zip_write ( RzIO *  io, RzIODesc *  fd, const ut8 *  buf, int  count  )

static

Definition at line 637 of file io_zip.c.

                                                                              {
    RzIOZipFileObj *zfo;
    int ret = 0;
    if (!fd || !fd->data || !buf) {
        return -1;
    }
    zfo = fd->data;
    if (!(zfo->perm & RZ_PERM_W)) {
        return -1;
    }
    if (rz_buf_tell(zfo->b) + count >= rz_buf_size(zfo->b)) {
        rz_io_zip_realloc_buf(zfo, count);
    }
    if (rz_buf_size(zfo->b) < io->off) {
        io->off = rz_buf_size(zfo->b);
    }
    zfo->modified = 1;
    ret = rz_buf_write_at(zfo->b, io->off, buf, count);
    if (ret >= 0) {
        rz_buf_seek(zfo->b, ret, RZ_BUF_CUR);
    }
    // XXX - Implement a flush of some sort, but until then, lets
    // just write through
    rz_io_zip_flush_file(zfo);
    return ret;
}

References rz_io_zfo_t::b, count, fd, rz_io_zfo_t::modified, rz_io_t::off, rz_io_zfo_t::perm, RZ_BUF_CUR, rz_buf_seek(), rz_buf_size(), rz_buf_tell(), rz_buf_write_at(), rz_io_zip_flush_file(), rz_io_zip_realloc_buf(), and RZ_PERM_W.

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

= {
    .type = RZ_LIB_TYPE_IO,
    .data = &rz_io_plugin_zip,
    .version = RZ_VERSION
}

Definition at line 691 of file io_zip.c.

rz_io_plugin_zip

RzIOPlugin rz_io_plugin_zip

Initial value:

= {
    .name = "zip",
    .desc = "Open zip files",
    .uris = "zip://,apk://,ipa://,jar://,zipall://,apkall://,ipaall://,jarall://",
    .license = "BSD",
    .open = rz_io_zip_open,
    .open_many = rz_io_zip_open_many,
    .write = rz_io_zip_write,
    .read = rz_io_zip_read,
    .close = rz_io_zip_close,
    .lseek = rz_io_zip_lseek,
    .check = rz_io_zip_plugin_open,
    .resize = rz_io_zip_resize,
}

Definition at line 675 of file io_zip.c.

Referenced by find_apk_binary(), rz_io_zip_open(), and rz_io_zip_open_many().

ZIP_ALL_URIS

RzIOZipConstURI ZIP_ALL_URIS[]

static

Initial value:

= {
    { "zipall://", 9 },
    { "apkall://", 9 },
    { "ipaall://", 9 },
    { "jarall://", 9 },
    { NULL, 0 }
}

Definition at line 33 of file io_zip.c.

Referenced by rz_io_zip_check_uri_many().

ZIP_URIS

RzIOZipConstURI ZIP_URIS[]

static

Initial value:

= {
    { "zip://", 6 },
    { "apk://", 6 },
    { "ipa://", 6 },
    { "jar://", 6 },
    { NULL, 0 }
}

Definition at line 25 of file io_zip.c.

Referenced by rz_io_zip_check_uri().