radare2/libr/util/buf_sparse.c
pancake 961d5007a9
Do not use r_buf_data in DEX results in 1.5x faster parsing (22s vs 33s) ##bin
* Fix some memory leaks
* Mark r_buf_data as deprecated
* Remove some spaguetti (-42LOC)
* Fix buf license header authorship
* Make parser functions return void for simplicity
2020-04-05 19:24:36 +02:00

222 lines
5.0 KiB
C

/* radare - LGPL - Copyright 2009-2020 - ret2libc */
#include <r_util.h>
struct buf_sparse_priv {
RList *sparse;
ut64 offset;
};
static void buffer_sparse_free(void *a) {
RBufferSparse *s = (RBufferSparse *)a;
free (s->data);
free (s);
}
static bool sparse_limits(RList *l, ut64 *max) {
bool set = false;
RBufferSparse *s;
RListIter *iter;
r_list_foreach (l, iter, s) {
if (set) {
if (max && s->to > *max) {
*max = s->to;
}
} else {
set = true;
if (max) {
*max = s->to;
}
}
}
return set;
}
static RBufferSparse *sparse_append(RList *l, ut64 addr, const ut8 *data, ut64 len) {
if (l && data) {
RBufferSparse *s = R_NEW0 (RBufferSparse);
if (s) {
s->data = calloc (1, len);
if (s->data) {
s->from = addr;
s->to = addr + len;
s->size = len;
memcpy (s->data, data, len);
return r_list_append (l, s)? s: NULL;
}
free (s);
}
}
return NULL;
}
//ret -1 if failed; # of bytes copied if success
static st64 sparse_write(RList *l, ut64 addr, const ut8 *data, ut64 len) {
RBufferSparse *s;
RListIter *iter;
ut64 olen = len;
r_list_foreach (l, iter, s) {
if (addr >= s->from && addr < s->to) {
ut64 delta = addr - s->from;
ut64 reallen = s->size - delta >= len? len: s->size - delta;
memcpy (s->data + delta, data, reallen);
data += reallen;
len -= reallen;
addr += reallen;
}
if (len == 0) {
return olen;
}
}
if (len > 0 && !sparse_append (l, addr, data, len)) {
return -1;
}
return olen;
}
static inline struct buf_sparse_priv *get_priv_sparse(RBuffer *b) {
struct buf_sparse_priv *priv = (struct buf_sparse_priv *)b->priv;
r_warn_if_fail (priv);
return priv;
}
static bool buf_sparse_init(RBuffer *b, const void *user) {
struct buf_sparse_priv *priv = R_NEW0 (struct buf_sparse_priv);
if (!priv) {
return false;
}
priv->sparse = r_list_newf (buffer_sparse_free);
priv->offset = 0;
b->priv = priv;
return true;
}
static bool buf_sparse_fini(RBuffer *b) {
struct buf_sparse_priv *priv = get_priv_sparse (b);
r_list_free (priv->sparse);
R_FREE (b->priv);
return true;
}
static bool buf_sparse_resize(RBuffer *b, ut64 newsize) {
struct buf_sparse_priv *priv = get_priv_sparse (b);
RListIter *iter, *tmp;
RBufferSparse *s;
r_list_foreach_safe (priv->sparse, iter, tmp, s) {
if (s->from >= newsize) {
r_list_delete (priv->sparse, iter);
} else if (s->to >= newsize) {
RBufferSparse *ns = R_NEW (RBufferSparse);
ns->from = s->from;
ns->to = newsize;
ns->size = ns->to - ns->from;
ut8 *tmp = realloc (s->data, s->size);
if (!tmp) {
free (ns);
return false;
}
// otherwise it will be double-freed by r_list_delete
s->data = NULL;
ns->data = tmp;
ns->written = s->written;
r_list_append (priv->sparse, ns);
r_list_delete (priv->sparse, iter);
}
}
ut64 max;
max = sparse_limits (priv->sparse, &max)? max: 0;
if (max < newsize) {
return !!sparse_write (priv->sparse, newsize - 1, (ut8 *)&b->Oxff_priv, 1);
}
return true;
}
static ut64 buf_sparse_size(RBuffer *b) {
struct buf_sparse_priv *priv = get_priv_sparse (b);
ut64 max;
return sparse_limits (priv->sparse, &max)? max: 0;
}
static st64 buf_sparse_read(RBuffer *b, ut8 *buf, ut64 len) {
struct buf_sparse_priv *priv = get_priv_sparse (b);
RBufferSparse *c;
RListIter *iter;
ut64 max = 0;
memset (buf, b->Oxff_priv, len);
r_list_foreach (priv->sparse, iter, c) {
if (max < c->to) {
max = c->to;
}
if (priv->offset < c->to && c->from < priv->offset + len) {
if (priv->offset < c->from) {
ut64 l = R_MIN (priv->offset + len - c->from, c->size);
memcpy (buf + c->from - priv->offset, c->data, l);
} else {
ut64 l = R_MIN (c->to - priv->offset, len);
memcpy (buf, c->data + priv->offset - c->from, l);
}
}
}
if (priv->offset > max) {
return -1;
}
ut64 r = R_MIN (max - priv->offset, len);
priv->offset += r;
return r;
}
static st64 buf_sparse_write(RBuffer *b, const ut8 *buf, ut64 len) {
struct buf_sparse_priv *priv = get_priv_sparse (b);
st64 r = sparse_write (priv->sparse, priv->offset, buf, len);
priv->offset += r;
return r;
}
static st64 buf_sparse_seek(RBuffer *b, st64 addr, int whence) {
struct buf_sparse_priv *priv = get_priv_sparse (b);
ut64 max;
if (addr < 0 && (-addr) > (st64)priv->offset) {
return -1;
}
switch (whence) {
case R_BUF_CUR:
priv->offset += addr;
break;
case R_BUF_SET:
priv->offset = addr;
break;
case R_BUF_END:
if (!sparse_limits (priv->sparse, &max)) {
max = 0;
}
priv->offset = max + addr;
break;
default:
r_warn_if_reached ();
return -1;
}
return priv->offset;
}
static RList *buf_sparse_nonempty_list(RBuffer *b) {
struct buf_sparse_priv *priv = get_priv_sparse (b);
return r_list_clone (priv->sparse);
}
static const RBufferMethods buffer_sparse_methods = {
.init = buf_sparse_init,
.fini = buf_sparse_fini,
.read = buf_sparse_read,
.write = buf_sparse_write,
.get_size = buf_sparse_size,
.resize = buf_sparse_resize,
.seek = buf_sparse_seek,
.nonempty_list = buf_sparse_nonempty_list,
};