int main () {
int ret;
RIODesc *fd;
char buf[1024];
struct r_io_t *io;
io = r_io_new();
r_io_plugin_list(io);
//fd = r_io_open(io, "/bin/ls", R_IO_READ, 0);
fd = r_io_open(io, "dbg:///bin/ls", R_IO_READ, 0);
r_io_set_fd(io, fd);
//r_io_map_add(io, fd, R_IO_READ, 0, 0xf00000, 0xffff);
r_io_map_add(io, fd->fd, R_IO_READ, 0x8048000, 0, 0xffff);
memset(buf, 0, 1024);
//ret = r_io_read_at(io, 0xf00000, buf, 1024);
// ret = r_io_seek(io, 0x8048000, R_IO_SEEK_SET);
// printf("seek = 0x%"PFMT64x"\n", ret);
ret = r_io_read_at (io, 0, (ut8*)buf, 64);
//ret = r_io_read_at(io, 0x8048000, buf, 64);
printf("%d = %02x %02x %02x %02x\n", ret, buf[0], buf[1], buf[2], buf[3]);
r_io_free(io);
return 0;
}
static ut8 *slurp(RCore **c, const char *file, int *sz) {
RIODesc *d;
RIO *io;
if (c && file && strstr (file, "://")) {
ut8 *data = NULL;
ut64 size;
if (!*c) {
*c = opencore (NULL);
}
io = (*c)->io;
d = r_io_open (io, file, 0, 0);
if (!d) {
return NULL;
}
size = r_io_size (io);
if (size > 0 || size < ST32_MAX) {
data = calloc (1, size);
if (r_io_read_at (io, 0, data, size) == size) {
if (sz) {
*sz = size;
}
} else {
eprintf ("slurp: read error\n");
R_FREE (data);
}
} else {
eprintf ("slurp: File is too big\n");
}
r_io_close (io, d);
return data;
}
return (ut8*)r_file_slurp (file, sz);
}
int main(int argc, char **argv) {
const char *algo = "md5,sha1"; /* default hashing algorithm */
int c, rad = 0, quit = 0, bsize = 0;
RIO *io;
while ((c = getopt (argc, argv, "rva:s:b:Bhf:t:")) != -1) {
switch (c) {
case 'r':
rad = 1;
break;
case 'a':
algo = optarg;
break;
case 'B':
incremental = 0;
break;
case 'b':
bsize = (int)r_num_math (NULL, optarg);
break;
case 's':
{
ut64 algobit = r_hash_name_to_bits (algo);
RHash *ctx = r_hash_new (R_TRUE, algobit);
from = 0;
to = strlen (optarg);
do_hash_internal (ctx, //0, strlen (optarg),
algobit, (const ut8*) optarg,
strlen (optarg), 0, 1);
r_hash_free (ctx);
quit = R_TRUE;
}
break;
case 'f':
from = r_num_math (NULL, optarg);
break;
case 't':
to = r_num_math (NULL, optarg);
break;
case 'v':
printf ("rahash2 v"R2_VERSION"\n");
return 0;
case 'h':
return do_help (0);
}
}
if (quit)
return 0;
if (optind>=argc)
return do_help (1);
io = r_io_new ();
if (!r_io_open (io, argv[optind], 0, 0)) {
eprintf ("Cannot open '%s'\n", argv[optind]);
return 1;
}
return do_hash (algo, io, bsize, rad);
}
R_API RIODesc *r_io_open_as(struct r_io_t *io, const char *urihandler, const char *file, int flags, int mode) {
RIODesc *ret;
char *uri;
int urilen, hlen = strlen (urihandler);
urilen = hlen + strlen (file)+5;
uri = malloc (urilen);
if (uri == NULL)
return NULL;
if (hlen>0) snprintf (uri, urilen, "%s://%s", urihandler, file);
else strncpy (uri, file, urilen);
ret = r_io_open (io, uri, flags, mode);
free (uri);
return ret;
}
static int perform_mapped_file_yank (RCore *core, ut64 offset, ut64 len, const char *filename) {
// grab the current file descriptor, so we can reset core and io state
// after our io op is done
RIODesc *yankfd = NULL;
ut64 fd = core->file ? core->file->desc->fd : -1, yank_file_sz = 0,
loadaddr = 0, addr = offset;
int res = R_FALSE;
if (filename && *filename) {
ut64 load_align = r_config_get_i (core->config,
"file.loadalign");
RIOMap * map = NULL;
yankfd = r_io_open (core->io, filename, R_IO_READ, 0644);
// map the file in for IO operations.
if (yankfd && load_align) {
yank_file_sz = r_io_size (core->io);
map = r_io_map_add_next_available (core->io,
yankfd->fd,
R_IO_READ, 0, 0,
yank_file_sz,
load_align);
loadaddr = map ? map->from : -1;
if (yankfd && map && loadaddr != -1) {
// ***NOTE*** this is important, we need to
// address the file at its physical address!
addr += loadaddr;
} else if (yankfd) {
eprintf ("Unable to map the opened file: %s", filename);
r_io_close (core->io, yankfd);
yankfd = NULL;
} else {
eprintf ("Unable to open the file: %s", filename);
}
}
}
// if len is -1 then we yank in everything
if (len == -1) len = yank_file_sz;
IFDBG eprintf ("yankfd: %p, yank->fd = %d, fd=%d\n", yankfd,
(int)(yankfd ? yankfd->fd : -1), (int)fd);
// this wont happen if the file failed to open or the file failed to
// map into the IO layer
if (yankfd) {
ut64 res = r_io_seek (core->io, addr, R_IO_SEEK_SET),
actual_len = len <= yank_file_sz ? len : 0;
ut8 *buf = NULL;
IFDBG eprintf (
"Addr (%"PFMT64d
") file_sz (%"PFMT64d
") actual_len (%"PFMT64d
") len (%"PFMT64d
") bytes from file: %s\n", addr, yank_file_sz,
actual_len, len, filename);
if (actual_len > 0 && res == addr) {
IFDBG eprintf (
"Creating buffer and reading %"PFMT64d
" bytes from file: %s\n", actual_len, filename);
buf = malloc (actual_len);
actual_len = r_io_read_at (core->io, addr, buf,
actual_len);
IFDBG eprintf (
"Reading %"PFMT64d " bytes from file: %s\n",
actual_len, filename);
/*IFDBG {
int i = 0;
eprintf ("Read these bytes from file: \n");
for (i = 0; i < actual_len; i++)
eprintf ("%02x", buf[i]);
eprintf ("\n");
}*/
r_core_yank_set (core, R_CORE_FOREIGN_ADDR, buf, len);
res = R_TRUE;
} else if (res != addr) {
eprintf (
"ERROR: Unable to yank data from file: (loadaddr (0x%"
PFMT64x ") (addr (0x%"
PFMT64x ") > file_sz (0x%"PFMT64x ")\n", res, addr,
yank_file_sz );
} else if (actual_len == 0) {
eprintf (
"ERROR: Unable to yank from file: addr+len (0x%"
PFMT64x ") > file_sz (0x%"PFMT64x ")\n", addr+len,
yank_file_sz );
}
r_io_close (core->io, yankfd);
free (buf);
}
if (fd != -1) {
r_io_raise (core->io, fd);
core->switch_file_view = 1;
r_core_block_read (core, 0);
}
return res;
}
