/* Copy a zero terminated string to the clipboard. Clamp to maxlen or blocksize. */
R_API int r_core_yank_string(RCore *core, ut64 addr, int maxlen) {
ut64 curseek = core->offset;
ut8 *buf = NULL;
if (maxlen < 0) {
eprintf ("r_core_yank_string: cannot yank negative bytes\n");
return false;
}
if (addr != core->offset) {
r_core_seek (core, addr, 1);
}
/* Ensure space and safe termination for largest possible string allowed */
buf = calloc (1, core->blocksize + 1);
if (!buf) {
return false;
}
buf[core->blocksize] = 0;
r_io_read_at (core->io, addr, buf, core->blocksize);
if (maxlen == 0) {
// Don't use strnlen, see: http://sourceforge.net/p/mingw/bugs/1912/
maxlen = r_str_nlen ((const char *) buf, core->blocksize);
} else if (maxlen > core->blocksize) {
maxlen = core->blocksize;
}
r_core_yank_set (core, addr, buf, maxlen);
if (curseek != addr) {
r_core_seek (core, curseek, 1);
}
free (buf);
return true;
}
/* Copy a zero terminated string to the clipboard. Clamp to maxlen or blocksize. */
R_API int r_core_yank_string(RCore *core, ut64 addr, int maxlen) {
ut64 curseek = core->offset;
ut8 *buf = NULL;
if (maxlen<0) {
eprintf ("r_core_yank_string: cannot yank negative bytes\n");
return R_FALSE;
}
if (addr != core->offset)
r_core_seek (core, addr, 1);
/* Ensure space and safe termination for largest possible string allowed */
buf = malloc (core->blocksize + 1);
if (!buf)
return R_FALSE;
buf[core->blocksize] = 0;
r_core_read_at (core, addr, buf, core->blocksize);
if (maxlen == 0) {
maxlen = strnlen ((const char*)buf, core->blocksize);
} else if (maxlen > core->blocksize) {
maxlen = core->blocksize;
}
r_core_yank_set (core, addr, buf, maxlen);
if (curseek != addr)
r_core_seek (core, curseek, 1);
free (buf);
return R_TRUE;
}
R_API int r_core_yank(struct r_core_t *core, ut64 addr, int len) {
ut64 curseek = core->offset;
ut8 *buf = NULL;
if (len < 0) {
eprintf ("r_core_yank: cannot yank negative bytes\n");
return false;
}
if (len == 0) {
len = core->blocksize;
}
buf = malloc (len);
if (!buf) {
return false;
}
if (addr != core->offset) {
r_core_seek (core, addr, 1);
}
r_io_read_at (core->io, addr, buf, len);
r_core_yank_set (core, addr, buf, len);
if (curseek != addr) {
r_core_seek (core, curseek, 1);
}
free (buf);
return true;
}
// Call set and then null terminate the bytes.
R_API int r_core_yank_set_str (RCore *core, ut64 addr, const char *str,
ut32 len) {
//free (core->yank_buf);
int res = r_core_yank_set (core, addr, (ut8*)str, len);
if (res == R_TRUE)
core->yank_buf->buf[len-1] = 0;
return res;
}
R_API bool r_core_yank_hexpair(RCore *core, const char *input) {
if (!input || !*input) {
return false;
}
char *out = strdup (input);
int len = r_hex_str2bin (input, (ut8 *)out);
if (len > 0) {
r_core_yank_set (core, 0, (ut8 *)out, len);
}
free (out);
return true;
}
R_API int r_core_yank(struct r_core_t *core, ut64 addr, int len) {
ut64 curseek = core->offset;
ut8 *buf = NULL;
if (len<0) {
eprintf ("r_core_yank: cannot yank negative bytes\n");
return R_FALSE;
}
if (len == 0) len = core->blocksize;
//free (core->yank_buf);
buf = malloc (len);
//core->yank_buf = (ut8 *)malloc (len);
if (addr != core->offset)
r_core_seek (core, addr, 1);
r_core_read_at (core, addr, buf, len);
r_core_yank_set (core, addr, buf, len);
if (curseek != addr)
r_core_seek (core, curseek, 1);
free (buf);
return R_TRUE;
}
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;
}
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 *yankdesc = NULL;
ut64 fd = core->file? core->file->fd: -1, yank_file_sz = 0,
loadaddr = 0, addr = offset;
int res = false;
if (filename && *filename) {
ut64 load_align = r_config_get_i (core->config, "file.loadalign");
RIOMap *map = NULL;
yankdesc = r_io_open_nomap (core->io, filename, R_PERM_R, 0644);
// map the file in for IO operations.
if (yankdesc && load_align) {
yank_file_sz = r_io_size (core->io);
map = r_io_map_add_next_available (core->io, yankdesc->fd, R_PERM_R, 0, 0, yank_file_sz, load_align);
loadaddr = map? map->itv.addr: -1;
if (yankdesc && map && loadaddr != -1) {
// ***NOTE*** this is important, we need to
// address the file at its physical address!
addr += loadaddr;
} else if (yankdesc) {
eprintf ("Unable to map the opened file: %s", filename);
r_io_desc_close (yankdesc);
yankdesc = 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;
}
// this wont happen if the file failed to open or the file failed to
// map into the IO layer
if (yankdesc) {
ut64 res = r_io_seek (core->io, addr, R_IO_SEEK_SET);
ut64 actual_len = len <= yank_file_sz? len: 0;
ut8 *buf = NULL;
if (actual_len > 0 && res == addr) {
buf = malloc (actual_len);
if (!r_io_read_at (core->io, addr, buf, actual_len)) {
actual_len = 0;
}
r_core_yank_set (core, R_CORE_FOREIGN_ADDR, buf, len);
res = 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_desc_close (yankdesc);
free (buf);
}
if (fd != -1) {
r_io_use_fd (core->io, fd);
core->switch_file_view = 1;
r_core_block_read (core);
}
return res;
}
