io_gdb.c File Reference

#include <rz_io.h>
#include <rz_lib.h>
#include <rz_socket.h>
#include <rz_util.h>
#include <ctype.h>
#include <libgdbr.h>
#include <gdbclient/commands.h>
#include <gdbclient/responses.h>

Go to the source code of this file.

Classes
struct	RzIOGdb

Macros
#define	IRAPI   static inline
#define	RZ_GDB_MAGIC   rz_str_djb2_hash("gdb")

Functions
static int	__close (RzIODesc *fd)
static bool	__plugin_open (RzIO *io, const char *file, bool many)
static int	debug_gdb_read_at (ut8 *buf, int sz, ut64 addr)
static int	debug_gdb_write_at (const ut8 *buf, int sz, ut64 addr)
static RzIODesc *	__open (RzIO *io, const char *file, int rw, int mode)
static int	__write (RzIO *io, RzIODesc *fd, const ut8 *buf, int count)
static ut64	__lseek (RzIO *io, RzIODesc *fd, ut64 offset, int whence)
static int	__read (RzIO *io, RzIODesc *fd, ut8 *buf, int count)
static int	__getpid (RzIODesc *fd)
static int	__gettid (RzIODesc *fd)
int	send_msg (libgdbr_t *g, const char *command)
int	read_packet (libgdbr_t *instance, bool vcont)
static char *	__system (RzIO *io, RzIODesc *fd, const char *cmd)

Variables
static libgdbr_t *	desc = NULL
RzIOPlugin	rz_io_plugin_gdb
RZ_API RzLibStruct	rizin_plugin

Macro Definition Documentation

IRAPI

#define IRAPI   static inline

Definition at line 9 of file io_gdb.c.

RZ_GDB_MAGIC

#define RZ_GDB_MAGIC   rz_str_djb2_hash("gdb")

Definition at line 18 of file io_gdb.c.

Function Documentation

__close()

static int __close ( RzIODesc *  fd )

static

Definition at line 167 of file io_gdb.c.

                                 {
    if (fd) {
        RZ_FREE(fd->name);
    }
    gdbr_disconnect(desc);
    gdbr_cleanup(desc);
    RZ_FREE(desc);
    return -1;
}

References desc, fd, gdbr_cleanup(), gdbr_disconnect(), z80_opcode::name, and RZ_FREE.

Referenced by __open().

__getpid()

static int __getpid ( RzIODesc *  fd )

static

Definition at line 177 of file io_gdb.c.

                                  {
    // XXX don't use globals
    return desc ? desc->pid : -1;
#if 0
    // dupe for ? rz_io_desc_get_pid (desc);
    if (!desc || !desc->data) {
        return -1;
    }
    RzIODescData *iodd = desc->data;
    if (iodd) {
        if (iodd->magic != RZ_GDB_MAGIC) {
            return -1;
        }
        return iodd->pid;
    }
    return -1;
#endif
}

References libgdbr_t::data, desc, RzIODescData::magic, RzIODescData::pid, libgdbr_t::pid, and RZ_GDB_MAGIC.

__gettid()

static int __gettid ( RzIODesc *  fd )

static

Definition at line 196 of file io_gdb.c.

                                  {
    return desc ? desc->tid : -1;
}

References desc, and libgdbr_t::tid.

__lseek()

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

static

Definition at line 141 of file io_gdb.c.

                                                                     {
    switch (whence) {
    case RZ_IO_SEEK_SET:
        io->off = offset;
        break;
    case RZ_IO_SEEK_CUR:
        io->off += offset;
        break;
    case RZ_IO_SEEK_END:
        io->off = ST64_MAX;
    }
    return io->off;
}

References rz_io_t::off, RZ_IO_SEEK_CUR, RZ_IO_SEEK_END, RZ_IO_SEEK_SET, and ST64_MAX.

__open()

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

static

Definition at line 54 of file io_gdb.c.

                                                                      {
    RzIODesc *riogdb = NULL;
    RzIOGdb *riog;
    char host[128], *port, *pid;
    int i_port = -1;
    bool isdev = false;
 
    if (!__plugin_open(io, file, 0)) {
        return NULL;
    }
    strncpy(host, file + 6, sizeof(host) - 1);
    host[sizeof(host) - 1] = '\0';
    if (host[0] == '/') {
        isdev = true;
    }
 
    if (isdev) {
        port = strchr(host, '@');
        if (port) {
            *port = '\0';
            port++;
            pid = strchr(port, ':');
        } else {
            pid = strchr(host, ':');
        }
    } else {
        port = strchr(host, ':');
        if (!port) {
            eprintf("Invalid debugger URI. Port missing?\nPlease use either\n"
                " - gdb://host:port[/pid] for a network gdbserver.\n"
                " - gdb:///dev/DEVICENAME[@speed][:pid] for a serial gdbserver.\n");
            return NULL;
        }
        *port = '\0';
        port++;
        pid = strchr(port, '/');
    }
 
    int i_pid = -1;
    if (pid) {
        *pid = 0;
        pid++;
        i_pid = atoi(pid);
    }
 
    if (port) {
        i_port = atoi(port);
    }
 
    if (!(riog = RZ_NEW0(RzIOGdb))) {
        return NULL;
    }
    gdbr_init(&riog->desc, false);
 
    if (gdbr_connect(&riog->desc, host, i_port) == 0) {
        __close(NULL);
        // RZ_FREE (desc);
        desc = &riog->desc;
        if (pid > 0) { // FIXME this is here for now because RzDebug's pid and libgdbr's aren't properly synced.
            desc->pid = i_pid;
            if (gdbr_attach(desc, i_pid) < 0) {
                eprintf("gdbr: Failed to attach to PID %i\n", i_pid);
                return NULL;
            }
        } else if ((i_pid = desc->pid) < 0) {
            i_pid = -1;
        }
        riogdb = rz_io_desc_new(io, &rz_io_plugin_gdb, file, RZ_PERM_RWX, mode, riog);
    }
    // Get name
    if (riogdb) {
        riogdb->name = gdbr_exec_file_read(desc, i_pid);
    } else {
        eprintf("gdb.io.open: Cannot connect to host.\n");
        free(riog);
    }
    return riogdb;
}

References __close(), __plugin_open(), RzIOGdb::desc, desc, eprintf, free(), gdbr_attach(), gdbr_connect(), gdbr_exec_file_read(), gdbr_init(), rz_io_desc_t::name, NULL, pid, libgdbr_t::pid, rz_io_desc_new(), rz_io_plugin_gdb, RZ_NEW0, and RZ_PERM_RWX.

__plugin_open()

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

static

Definition at line 23 of file io_gdb.c.

                                                                 {
    return (!strncmp(file, "gdb://", 6));
}

Referenced by __open().

__read()

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

static

Definition at line 155 of file io_gdb.c.

                                                               {
    if (!io || !fd || !buf || count < 1) {
        return -1;
    }
    memset(buf, 0xff, count);
    ut64 addr = io->off;
    if (!desc || !desc->data) {
        return -1;
    }
    return debug_gdb_read_at(buf, count, addr);
}

References addr, count, libgdbr_t::data, debug_gdb_read_at(), desc, fd, memset(), rz_io_t::off, and ut64().

__system()

static char* __system ( RzIO *  io, RzIODesc *  fd, const char *  cmd  )

static

Definition at line 203 of file io_gdb.c.

                                                               {
    if (!desc) {
        return NULL;
    }
    if (!*cmd) {
        return NULL;
    }
    if (cmd[0] == '?' || !strcmp(cmd, "help")) {
        eprintf("Usage: R!cmd args\n"
            " R!pid             - show targeted pid\n"
            " R!pkt s           - send packet 's'\n"
            " R!rd              - show reverse debugging availability\n"
            " R!dsb             - step backwards\n"
            " R!dcb             - continue backwards\n"
            " R!monitor cmd     - hex-encode monitor command and pass"
            " to target interpreter\n"
            " R!detach [pid]    - detach from remote/detach specific pid\n"
            " R!inv.reg         - invalidate reg cache\n"
            " R!pktsz           - get max packet size used\n"
            " R!pktsz bytes     - set max. packet size as 'bytes' bytes\n"
            " R!exec_file [pid] - get file which was executed for"
            " current/specified pid\n");
        return NULL;
    }
    if (rz_str_startswith(cmd, "pktsz")) {
        const char *ptr = rz_str_trim_head_ro(cmd + 5);
        if (!isdigit((ut8)*ptr)) {
            io->cb_printf("packet size: %u bytes\n",
                desc->stub_features.pkt_sz);
            return NULL;
        }
        ut32 pktsz;
        if (!(pktsz = (ut32)strtoul(ptr, NULL, 10))) {
            // pktsz = 0 doesn't make sense
            return NULL;
        }
        desc->stub_features.pkt_sz = RZ_MAX(pktsz, 8); // min = 64
        return NULL;
    }
    if (rz_str_startswith(cmd, "detach")) {
        int res;
        if (!isspace((ut8)cmd[6]) || !desc->stub_features.multiprocess) {
            res = gdbr_detach(desc) >= 0;
        } else {
            int pid = 0;
            cmd = rz_str_trim_head_ro(cmd + 6);
            if (!*cmd || !(pid = strtoul(cmd, NULL, 10))) {
                res = gdbr_detach(desc) >= 0;
            } else {
                res = gdbr_detach_pid(desc, pid) >= 0;
            }
        }
        eprintf("%d\n", res);
        return NULL;
    }
    if (rz_str_startswith(cmd, "pkt ")) {
        if (!gdbr_lock_enter(desc)) {
            goto gdb_lock_leave;
        }
        if (send_msg(desc, cmd + 4) >= 0) {
            (void)read_packet(desc, false);
            desc->data[desc->data_len] = '\0';
            io->cb_printf("reply:\n%s\n", desc->data);
            if (!desc->no_ack) {
                eprintf("[waiting for ack]\n");
            }
        }
        goto gdb_lock_leave;
    }
    if (rz_str_startswith(cmd, "rd")) {
        PJ *pj = pj_new();
        pj_o(pj);
        pj_kb(pj, "reverse-continue", desc->stub_features.ReverseStep);
        pj_kb(pj, "reverse-step", desc->stub_features.ReverseContinue);
        pj_end(pj);
        io->cb_printf("%s\n", pj_string(pj));
        pj_free(pj);
        return NULL;
    }
    if (rz_str_startswith(cmd, "dsb")) {
        if (!desc->stub_features.ReverseStep) {
            eprintf("Stepping backwards is not supported in this gdbserver implementation\n");
            return NULL;
        }
        if (!gdbr_lock_enter(desc)) {
            goto gdb_lock_leave;
        }
        if (send_msg(desc, "bs") >= 0) {
            (void)read_packet(desc, false);
            desc->data[desc->data_len] = '\0';
            if (!desc->no_ack) {
                eprintf("[waiting for ack]\n");
            } else {
                handle_stop_reason(desc);
                if (desc->stop_reason.is_valid == false) {
                    eprintf("Thread (%d) stopped for an invalid reason: %d\n",
                        desc->stop_reason.thread.tid, desc->stop_reason.reason);
                }
            }
            gdbr_invalidate_reg_cache();
        }
        goto gdb_lock_leave;
    }
    if (rz_str_startswith(cmd, "dcb")) {
        if (!desc->stub_features.ReverseContinue) {
            eprintf("Continue backwards is not supported in this gdbserver implementation\n");
            return NULL;
        }
        if (!gdbr_lock_enter(desc)) {
            goto gdb_lock_leave;
        }
        if (send_msg(desc, "bc") >= 0) {
            (void)read_packet(desc, false);
            desc->data[desc->data_len] = '\0';
            if (!desc->no_ack) {
                eprintf("[waiting for ack]\n");
            } else {
                handle_stop_reason(desc);
                if (desc->stop_reason.is_valid == false) {
                    eprintf("Thread (%d) stopped for an invalid reason: %d\n",
                        desc->stop_reason.thread.tid, desc->stop_reason.reason);
                }
            }
            gdbr_invalidate_reg_cache();
        }
        goto gdb_lock_leave;
    }
    if (rz_str_startswith(cmd, "pid")) {
        int pid = desc ? desc->pid : -1;
        if (!cmd[3]) {
            io->cb_printf("%d\n", pid);
        }
        return rz_str_newf("%d", pid);
    }
    if (rz_str_startswith(cmd, "monitor")) {
        const char *qrcmd = cmd + 8;
        if (!isspace((ut8)cmd[7])) {
            qrcmd = "help";
        }
        if (gdbr_send_qRcmd(desc, qrcmd, io->cb_printf) < 0) {
            eprintf("remote error\n");
            return NULL;
        }
        return NULL;
    }
    if (rz_str_startswith(cmd, "inv.reg")) {
        gdbr_invalidate_reg_cache();
        return NULL;
    }
    if (rz_str_startswith(cmd, "exec_file")) {
        const char *ptr = cmd + strlen("exec_file");
        char *file;
        if (!isspace((ut8)*ptr)) {
            file = gdbr_exec_file_read(desc, 0);
        } else {
            while (isspace((ut8)*ptr)) {
                ptr++;
            }
            if (isdigit((ut8)*ptr)) {
                int pid = atoi(ptr);
                file = gdbr_exec_file_read(desc, pid);
            } else {
                file = gdbr_exec_file_read(desc, 0);
            }
        }
        if (!file) {
            return NULL;
        }
        io->cb_printf("%s\n", file);
        return file;
    }
    // These are internal, not available to user directly
    if (rz_str_startswith(cmd, "retries")) {
        int num_retries;
        if (isspace((ut8)cmd[7]) && isdigit((ut8)cmd[8])) {
            if ((num_retries = atoi(cmd + 8)) >= 1) {
                desc->num_retries = num_retries;
            }
            return NULL;
        }
        io->cb_printf("num_retries: %d byte(s)\n", desc->page_size);
        return NULL;
    }
    if (rz_str_startswith(cmd, "page_size")) {
        int page_size;
        if (isspace((ut8)cmd[9]) && isdigit((ut8)cmd[10])) {
            if ((page_size = atoi(cmd + 10)) >= 64) {
                desc->page_size = page_size;
            }
            return NULL;
        }
        io->cb_printf("page size: %d byte(s)\n", desc->page_size);
        return NULL;
    }
    // Sets a flag that next call to get memmap will be for getting baddr
    if (!strcmp(cmd, "baddr")) {
        desc->get_baddr = true;
        return NULL;
    }
    eprintf("Try: 'R!?'\n");
    return NULL;
 
gdb_lock_leave:
    gdbr_lock_leave(desc);
    return NULL;
}

References rz_io_t::cb_printf, cmd, libgdbr_t::data, libgdbr_t::data_len, desc, eprintf, file, gdbr_detach(), gdbr_detach_pid(), gdbr_exec_file_read(), gdbr_invalidate_reg_cache(), gdbr_lock_enter(), gdbr_lock_leave(), gdbr_send_qRcmd(), libgdbr_t::get_baddr, handle_stop_reason(), libgdbr_stop_reason::is_valid, isdigit, isspace, libgdbr_stub_features_t::multiprocess, libgdbr_t::no_ack, NULL, libgdbr_t::num_retries, libgdbr_t::page_size, pid, libgdbr_t::pid, pj_end(), pj_free(), pj_kb(), pj_new(), pj_o(), pj_string(), libgdbr_stub_features_t::pkt_sz, read_packet(), libgdbr_stop_reason::reason, libgdbr_stub_features_t::ReverseContinue, libgdbr_stub_features_t::ReverseStep, RZ_MAX, rz_str_newf(), rz_str_startswith(), rz_str_trim_head_ro(), send_msg(), libgdbr_t::stop_reason, libgdbr_t::stub_features, libgdbr_stop_reason::thread, and libgdbr_stop_reason::tid.

__write()

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

static

Definition at line 133 of file io_gdb.c.

                                                                      {
    ut64 addr = io->off;
    if (!desc || !desc->data) {
        return -1;
    }
    return debug_gdb_write_at(buf, count, addr);
}

References addr, count, libgdbr_t::data, debug_gdb_write_at(), desc, rz_io_t::off, and ut64().

debug_gdb_read_at()

static int debug_gdb_read_at ( ut8 *  buf, int  sz, ut64  addr  )

static

Definition at line 27 of file io_gdb.c.

                                                          {
    if (sz < 1 || addr >= UT64_MAX || !desc) {
        return -1;
    }
    return gdbr_read_memory(desc, addr, buf, sz);
}

References addr, desc, gdbr_read_memory(), and UT64_MAX.

Referenced by __read().

debug_gdb_write_at()

static int debug_gdb_write_at ( const ut8 *  buf, int  sz, ut64  addr  )

static

Definition at line 34 of file io_gdb.c.

                                                                 {
    ut32 x, size_max;
    ut32 packets;
    ut32 last;
    if (sz < 1 || addr >= UT64_MAX || !desc) {
        return -1;
    }
    size_max = desc->read_max;
    packets = sz / size_max;
    last = sz % size_max;
    ut64 offset = 0;
    for (x = 0; x < packets; x++, offset += size_max) {
        gdbr_write_memory(desc, addr + offset, buf + offset, size_max);
    }
    if (last) {
        gdbr_write_memory(desc, addr + offset, buf + offset, last);
    }
    return sz;
}

References addr, desc, gdbr_write_memory(), libgdbr_t::read_max, ut64(), UT64_MAX, and x.

Referenced by __write().

read_packet()

int read_packet	(	libgdbr_t *	instance,
		bool	vcont
	)

Definition at line 143 of file packet.c.

                                          {
    struct parse_ctx ctx = { 0 };
    int ret, i;
    if (!g) {
        eprintf("Initialize libgdbr_t first\n");
        return -1;
    }
    g->data_len = 0;
    if (g->read_len > 0) {
        if (unpack(g, &ctx, g->read_len) == 0) {
            // TODO: Evaluate if partial packets are clubbed
            g->data[g->data_len] = '\0';
            if (g->server_debug) {
                eprintf("getpkt (\"%s\");  %s\n", g->data,
                    g->no_ack ? "[no ack sent]" : "[sending ack]");
            }
            return 0;
        }
    }
    g->data_len = 0;
    for (i = 0; i < g->num_retries && !g->isbreaked; vcont ? 0 : i++) {
        ret = rz_socket_ready(g->sock, 0, READ_TIMEOUT);
        if (ret == 0 && !vcont) {
            continue;
        }
        if (ret <= 0) {
            return -1;
        }
        int sz = rz_socket_read(g->sock, (void *)g->read_buff, g->read_max - 1);
        if (sz <= 0) {
            eprintf("%s: read failed\n", __func__);
            return -1;
        }
        ret = unpack(g, &ctx, sz);
        if (ret < 0) {
            eprintf("%s: unpack failed\n", __func__);
            return -1;
        }
        if (!ret) {
            g->data[g->data_len] = '\0';
            if (g->server_debug) {
                eprintf("getpkt (\"%s\");  %s\n", g->data,
                    g->no_ack ? "[no ack sent]" : "[sending ack]");
            }
            return 0;
        }
    }
    return -1;
}

References eprintf, g, i, READ_TIMEOUT, rz_socket_read(), rz_socket_ready(), and unpack().

Referenced by __system(), gdbr_attach(), gdbr_check_extended_mode(), gdbr_check_vcont(), gdbr_close_file(), gdbr_connect(), gdbr_connect_lldb(), gdbr_detach_pid(), gdbr_exec_file_read(), gdbr_get_baddr(), gdbr_is_thread_dead(), gdbr_kill_pid(), gdbr_open_file(), gdbr_pids_list(), gdbr_read_feature(), gdbr_read_file(), gdbr_read_memory_page(), gdbr_read_osdata(), gdbr_read_registers(), gdbr_read_registers_lldb(), gdbr_select(), gdbr_send_qRcmd(), gdbr_server_serve(), gdbr_stop_reason(), gdbr_threads_list(), gdbr_write_bin_registers(), gdbr_write_memory(), gdbr_write_register(), gdbr_write_registers(), remove_bp(), send_vcont(), set_bp(), and test_command().

send_msg()

int send_msg	(	libgdbr_t *	g,
		const char *	command
	)

Definition at line 146 of file common.c.

                                            {
    int ret;
    if (!g || !msg) {
        return -1;
    }
    ret = pack(g, msg);
    if (ret < 0) {
        return -1;
    }
    ret = send_packet(g);
    g->send_len = ret;
    return ret;
}

References g, msg, pack(), and send_packet().

Referenced by __system(), _server_handle_c(), _server_handle_exec_file_read(), _server_handle_g(), _server_handle_Hc(), _server_handle_Hg(), _server_handle_M(), _server_handle_m(), _server_handle_p(), _server_handle_P(), _server_handle_qAttached(), _server_handle_qC(), _server_handle_qfThreadInfo(), _server_handle_qOffsets(), _server_handle_qsThreadInfo(), _server_handle_qSupported(), _server_handle_qTfV(), _server_handle_qTStatus(), _server_handle_ques(), _server_handle_s(), _server_handle_vCont(), _server_handle_vKill(), _server_handle_vMustReplyEmpty(), _server_handle_z(), gdbr_attach(), gdbr_check_extended_mode(), gdbr_check_vcont(), gdbr_close_file(), gdbr_connect(), gdbr_connect_lldb(), gdbr_detach(), gdbr_detach_pid(), gdbr_exec_file_read(), gdbr_get_baddr(), gdbr_is_thread_dead(), gdbr_kill(), gdbr_kill_pid(), gdbr_open_file(), gdbr_pids_list(), gdbr_read_feature(), gdbr_read_file(), gdbr_read_memory_page(), gdbr_read_osdata(), gdbr_read_registers(), gdbr_read_registers_lldb(), gdbr_select(), gdbr_send_qRcmd(), gdbr_server_serve(), gdbr_stop_reason(), gdbr_threads_list(), gdbr_write_bin_registers(), gdbr_write_memory(), gdbr_write_register(), gdbr_write_registers(), remove_bp(), send_vcont(), set_bp(), and test_command().

Variable Documentation

desc

libgdbr_t* desc = NULL

static

Definition at line 21 of file io_gdb.c.

Referenced by __close(), __getpid(), __gettid(), __open(), __read(), __system(), __write(), debug_gdb_read_at(), and debug_gdb_write_at().

rizin_plugin

RZ_API RzLibStruct rizin_plugin

Initial value:

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

Definition at line 429 of file io_gdb.c.

rz_io_plugin_gdb

RzIOPlugin rz_io_plugin_gdb

Initial value:

= {
    
    .name = "gdb",
    .license = "LGPL3",
    .desc = "Attach to gdbserver instance",
    .uris = "gdb://",
    .open = __open,
    .close = __close,
    .read = __read,
    .write = __write,
    .check = __plugin_open,
    .lseek = __lseek,
    .system = __system,
    .getpid = __getpid,
    .gettid = __gettid,
    .isdbg = true
}

Definition at line 410 of file io_gdb.c.

Referenced by __open().