io_gzip.c File Reference

#include "rz_io.h"
#include "rz_lib.h"
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>

Go to the source code of this file.

Classes
struct	RzIOGzip

Functions
static ut32	_io_malloc_sz (RzIODesc *desc)
static void	_io_malloc_set_sz (RzIODesc *desc, ut32 sz)
static ut8 *	_io_malloc_buf (RzIODesc *desc)
static ut8 *	_io_malloc_set_buf (RzIODesc *desc, ut8 *buf)
static ut64	_io_malloc_off (RzIODesc *desc)
static void	_io_malloc_set_off (RzIODesc *desc, ut64 off)
static int	__write (RzIO *io, RzIODesc *fd, const ut8 *buf, int count)
static bool	__resize (RzIO *io, RzIODesc *fd, ut64 count)
static int	__read (RzIO *io, RzIODesc *fd, ut8 *buf, int count)
static int	__close (RzIODesc *fd)
static ut64	__lseek (RzIO *io, RzIODesc *fd, ut64 offset, int whence)
static bool	__plugin_open (RzIO *io, const char *pathname, bool many)
static RzIODesc *	__open (RzIO *io, const char *pathname, int rw, int mode)

Variables
RzIOPlugin	rz_io_plugin_gzip
RZ_API RzLibStruct	rizin_plugin

Function Documentation

__close()

static int __close ( RzIODesc *  fd )

static

Definition at line 123 of file io_gzip.c.

                                 {
    RzIOGzip *riom;
    if (!fd || !fd->data) {
        return -1;
    }
    riom = fd->data;
    RZ_FREE(riom->buf);
    RZ_FREE(fd->data);
    eprintf("TODO: Writing changes into gzipped files is not yet supported\n");
    return 0;
}

References RzIOGzip::buf, eprintf, fd, and RZ_FREE.

__lseek()

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

static

Definition at line 135 of file io_gzip.c.

                                                                     {
    ut64 rz_offset = offset;
    if (!fd || !fd->data) {
        return offset;
    }
    ut32 mallocsz = _io_malloc_sz(fd);
    switch (whence) {
    case SEEK_SET:
        rz_offset = (offset <= mallocsz) ? offset : mallocsz;
        break;
    case SEEK_CUR:
        rz_offset = (_io_malloc_off(fd) + offset <= mallocsz) ? _io_malloc_off(fd) + offset : mallocsz;
        break;
    case SEEK_END:
        rz_offset = _io_malloc_sz(fd);
        break;
    }
    _io_malloc_set_off(fd, rz_offset);
    return rz_offset;
}

References _io_malloc_off(), _io_malloc_set_off(), _io_malloc_sz(), fd, SEEK_CUR, SEEK_END, SEEK_SET, and ut64().

__open()

static RzIODesc* __open ( RzIO *  io, const char *  pathname, int  rw, int  mode  )

static

Definition at line 160 of file io_gzip.c.

                                                                          {
    if (__plugin_open(io, pathname, 0)) {
        RzIOGzip *mal = RZ_NEW0(RzIOGzip);
        if (!mal) {
            return NULL;
        }
        size_t len;
        ut8 *data = (ut8 *)rz_file_slurp(pathname + 7, &len);
        int *size = (int *)&mal->size;
        mal->buf = rz_inflate(data, (int)len, NULL, size);
        if (mal->buf) {
            free(data);
            return rz_io_desc_new(io, &rz_io_plugin_gzip, pathname, rw, mode, mal);
        }
        free(data);
        eprintf("Cannot allocate (%s) %d byte(s)\n", pathname + 9, mal->size);
        free(mal);
    }
    return NULL;
}

References __plugin_open(), eprintf, free(), len, mal, NULL, pathname, rz_file_slurp(), rz_inflate(), rz_io_desc_new(), rz_io_plugin_gzip, and RZ_NEW0.

__plugin_open()

static bool __plugin_open ( RzIO *  io, const char *  pathname, bool  many  )

static

Definition at line 156 of file io_gzip.c.

                                                                     {
    return (!strncmp(pathname, "gzip://", 7));
}

References pathname.

Referenced by __open().

__read()

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

static

Definition at line 107 of file io_gzip.c.

                                                               {
    memset(buf, 0xff, count);
    if (!fd || !fd->data) {
        return -1;
    }
    ut32 mallocsz = _io_malloc_sz(fd);
    if (_io_malloc_off(fd) > mallocsz) {
        return -1;
    }
    if (_io_malloc_off(fd) + count >= mallocsz) {
        count = mallocsz - _io_malloc_off(fd);
    }
    memcpy(buf, _io_malloc_buf(fd) + _io_malloc_off(fd), count);
    return count;
}

References _io_malloc_buf(), _io_malloc_off(), _io_malloc_sz(), count, fd, memcpy(), and memset().

__resize()

static bool __resize ( RzIO *  io, RzIODesc *  fd, ut64  count  )

static

Definition at line 84 of file io_gzip.c.

                                                         {
    ut8 *new_buf = NULL;
    if (!fd || !fd->data || count == 0) {
        return false;
    }
    ut32 mallocsz = _io_malloc_sz(fd);
    if (_io_malloc_off(fd) > mallocsz) {
        return false;
    }
    new_buf = malloc(count);
    if (!new_buf) {
        return false;
    }
    memcpy(new_buf, _io_malloc_buf(fd), RZ_MIN(count, mallocsz));
    if (count > mallocsz) {
        memset(new_buf + mallocsz, 0, count - mallocsz);
    }
    free(_io_malloc_buf(fd));
    _io_malloc_set_buf(fd, new_buf);
    _io_malloc_set_sz(fd, count);
    return true;
}

References _io_malloc_buf(), _io_malloc_off(), _io_malloc_set_buf(), _io_malloc_set_sz(), _io_malloc_sz(), count, fd, free(), malloc(), memcpy(), memset(), NULL, and RZ_MIN.

__write()

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

static

Definition at line 66 of file io_gzip.c.

                                                                      {
    if (!fd || !buf || count < 0 || !fd->data) {
        return -1;
    }
    if (_io_malloc_off(fd) > _io_malloc_sz(fd)) {
        return -1;
    }
    if (_io_malloc_off(fd) + count > _io_malloc_sz(fd)) {
        count -= (_io_malloc_off(fd) + count - _io_malloc_sz(fd));
    }
    if (count > 0) {
        memcpy(_io_malloc_buf(fd) + _io_malloc_off(fd), buf, count);
        _io_malloc_set_off(fd, _io_malloc_off(fd) + count);
        return count;
    }
    return -1;
}

References _io_malloc_buf(), _io_malloc_off(), _io_malloc_set_off(), _io_malloc_sz(), count, fd, and memcpy().

_io_malloc_buf()

static ut8* _io_malloc_buf ( RzIODesc *  desc )

inlinestatic

Definition at line 34 of file io_gzip.c.

                                                  {
    if (!desc) {
        return NULL;
    }
    RzIOGzip *mal = (RzIOGzip *)desc->data;
    return mal->buf;
}

References desc, mal, and NULL.

Referenced by __read(), __resize(), and __write().

_io_malloc_off()

static ut64 _io_malloc_off ( RzIODesc *  desc )

inlinestatic

Definition at line 50 of file io_gzip.c.

                                                  {
    if (!desc) {
        return 0;
    }
    RzIOGzip *mal = (RzIOGzip *)desc->data;
    return mal->offset;
}

References desc, and mal.

Referenced by __lseek(), __read(), __resize(), and __write().

_io_malloc_set_buf()

static ut8* _io_malloc_set_buf ( RzIODesc *  desc, ut8 *  buf  )

inlinestatic

Definition at line 42 of file io_gzip.c.

                                                                {
    if (!desc) {
        return NULL;
    }
    RzIOGzip *mal = (RzIOGzip *)desc->data;
    return mal->buf = buf;
}

References desc, mal, and NULL.

Referenced by __resize().

_io_malloc_set_off()

static void _io_malloc_set_off ( RzIODesc *  desc, ut64  off  )

inlinestatic

Definition at line 58 of file io_gzip.c.

                                                                {
    if (!desc) {
        return;
    }
    RzIOGzip *mal = (RzIOGzip *)desc->data;
    mal->offset = off;
}

References desc, mal, and off.

Referenced by __lseek(), and __write().

_io_malloc_set_sz()

static void _io_malloc_set_sz ( RzIODesc *  desc, ut32  sz  )

inlinestatic

Definition at line 24 of file io_gzip.c.

                                                              {
    if (!desc) {
        return;
    }
    RzIOGzip *mal = (RzIOGzip *)desc->data;
    if (mal) {
        mal->size = sz;
    }
}

References desc, if(), and mal.

Referenced by __resize().

_io_malloc_sz()

static ut32 _io_malloc_sz ( RzIODesc *  desc )

inlinestatic

Definition at line 16 of file io_gzip.c.

                                                 {
    if (!desc) {
        return 0;
    }
    RzIOGzip *mal = (RzIOGzip *)desc->data;
    return mal ? mal->size : 0;
}

References desc, and mal.

Referenced by __lseek(), __read(), __resize(), and __write().

Variable Documentation

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

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

Definition at line 196 of file io_gzip.c.

rz_io_plugin_gzip

RzIOPlugin rz_io_plugin_gzip

Initial value:

= {
    .name = "gzip",
    .desc = "Read/write gzipped files",
    .license = "LGPL3",
    .uris = "gzip://",
    .open = __open,
    .close = __close,
    .read = __read,
    .check = __plugin_open,
    .lseek = __lseek,
    .write = __write,
    .resize = __resize,
}

Definition at line 181 of file io_gzip.c.

Referenced by __open().