responses.h File Reference

#include <string.h>
#include "libgdbr.h"
#include "utils.h"

Go to the source code of this file.

Functions
int	handle_g (libgdbr_t *g)
int	handle_G (libgdbr_t *g)
int	handle_m (libgdbr_t *g)
int	handle_M (libgdbr_t *g)
int	handle_P (libgdbr_t *g)
int	handle_cont (libgdbr_t *g)
int	handle_qStatus (libgdbr_t *g)
int	handle_qC (libgdbr_t *g)
int	handle_execFileRead (libgdbr_t *g)
int	handle_qSupported (libgdbr_t *g)
int	handle_setbp (libgdbr_t *g)
int	handle_removebp (libgdbr_t *g)
int	handle_attach (libgdbr_t *g)
int	handle_vFile_open (libgdbr_t *g)
int	handle_vFile_pread (libgdbr_t *g, ut8 *buf)
int	handle_vFile_close (libgdbr_t *g)
int	handle_stop_reason (libgdbr_t *g)
int	handle_lldb_read_reg (libgdbr_t *g)

Function Documentation

handle_attach()

int handle_attach

(

libgdbr_t *

g

)

Definition at line 124 of file responses.c.

                                {
    if (g->data_len == 3 && g->data[0] == 'E') {
        send_ack(g);
        return -1;
    }
    return send_ack(g);
}

References g, and send_ack().

Referenced by gdbr_attach().

handle_cont()

int handle_cont

(

libgdbr_t *

g

)

Definition at line 383 of file responses.c.

                              {
    return handle_stop_reason(g);
}

References g, and handle_stop_reason().

Referenced by send_vcont().

handle_execFileRead()

int handle_execFileRead

(

libgdbr_t *

g

)

handle_g()

int handle_g

(

libgdbr_t *

g

)

For handling responses from gdbserver See Appendix E in the gdb manual (GDB Remote Serial Protocol) Packets look following: $ starts a command/packet, the end is indicated with # and a final checksum $<command>#<checksum>

Definition at line 11 of file responses.c.

                           {
    if (unpack_hex(g->data, g->data_len, g->data) < 0) {
        return -1;
    }
    g->data_len = g->data_len / 2;
    return send_ack(g);
}

References g, send_ack(), and unpack_hex().

Referenced by gdbr_read_registers().

handle_G()

int handle_G

(

libgdbr_t *

g

)

Definition at line 19 of file responses.c.

                           {
    return send_ack(g);
}

References g, and send_ack().

Referenced by gdbr_write_bin_registers(), and gdbr_write_registers().

handle_lldb_read_reg()

int handle_lldb_read_reg

(

libgdbr_t *

g

)

Definition at line 387 of file responses.c.

                                       {
    if (send_ack(g) < 0) {
        return -1;
    }
    char *ptr, *ptr2, *buf;
    size_t regnum, tot_regs, buflen = 0;
 
    // Get maximum register number
    for (regnum = 0; *g->registers[regnum].name; regnum++) {
        if (g->registers[regnum].offset + g->registers[regnum].size > buflen) {
            buflen = g->registers[regnum].offset + g->registers[regnum].size;
        }
    }
    tot_regs = regnum;
 
    // We're not using the receive buffer till next packet anyway. Better use it
    buf = g->read_buff;
    memset(buf, 0, buflen);
 
    if (!(ptr = strtok(g->data, ";"))) {
        return -1;
    }
    while (ptr) {
        if (!isxdigit(*ptr)) {
            // This is not a reg value. Skip
            ptr = strtok(NULL, ";");
            continue;
        }
        // Get register number
        regnum = (int)strtoul(ptr, NULL, 16);
        if (regnum >= tot_regs || !(ptr2 = strchr(ptr, ':'))) {
            ptr = strtok(NULL, ";");
            continue;
        }
        ptr2++;
        // Write to offset
        unpack_hex(ptr2, strlen(ptr2), buf + g->registers[regnum].offset);
        ptr = strtok(NULL, ";");
        continue;
    }
    memcpy(g->data, buf, buflen);
    g->data_len = buflen;
    return 0;
}

References buflen, g, int, isxdigit, memcpy(), memset(), NULL, send_ack(), and unpack_hex().

Referenced by gdbr_read_registers_lldb().

handle_m()

int handle_m

(

libgdbr_t *

g

)

Definition at line 36 of file responses.c.

                           {
    if (g->data_len == 3 && g->data[0] == 'E') {
        // TODO: figure out if this is a problem
        send_ack(g);
        return -1;
    }
    int len = strlen(g->data);
    g->data_len = len / 2;
    unpack_hex(g->data, len, g->data);
    return send_ack(g);
}

References g, len, send_ack(), and unpack_hex().

Referenced by gdbr_read_memory_page().

handle_M()

int handle_M

(

libgdbr_t *

g

)

Definition at line 23 of file responses.c.

                           {
    return send_ack(g);
}

References g, and send_ack().

Referenced by gdbr_write_memory().

handle_P()

int handle_P

(

libgdbr_t *

g

)

Definition at line 27 of file responses.c.

                           {
    if (g->data_len == 0) {
        g->last_code = MSG_NOT_SUPPORTED;
    } else {
        g->last_code = MSG_OK;
    }
    return send_ack(g);
}

References g, MSG_NOT_SUPPORTED, MSG_OK, and send_ack().

Referenced by gdbr_write_register().

handle_qC()

int handle_qC

(

libgdbr_t *

g

)

Definition at line 77 of file responses.c.

                            {
    // We get process and thread ID
    if (strncmp(g->data, "QC", 2)) {
        send_ack(g);
        return -1;
    }
    g->data[g->data_len] = '\0';
    if (read_thread_id(g->data + 2, &g->pid, &g->tid, g->stub_features.multiprocess) < 0) {
        send_ack(g);
        return -1;
    }
    return send_ack(g);
}

References g, read_thread_id(), and send_ack().

Referenced by gdbr_connect().

handle_qStatus()

int handle_qStatus

(

libgdbr_t *

g

)

Definition at line 48 of file responses.c.

                                 {
    if (!g || !g->data || !*g->data) {
        return -1;
    }
    char *data = strdup(g->data);
    char *tok = strtok(data, ";");
    if (!tok) {
        free(data);
        return -1;
    }
    // TODO: We do not yet handle the case where a trace is already running
    if (strncmp(tok, "T0", 2)) {
        send_ack(g);
        free(data);
        return -1;
    }
    // Ensure that trace was never run
    while (tok != NULL) {
        if (!strncmp(tok, "tnotrun:0", 9)) {
            free(data);
            return send_ack(g);
        }
        tok = strtok(NULL, ";");
    }
    send_ack(g);
    free(data);
    return -1;
}

References free(), g, NULL, send_ack(), and strdup().

handle_qSupported()

int handle_qSupported

(

libgdbr_t *

g

)

Definition at line 12 of file common.c.

                                    {
    char *tok = NULL;
    // Catch no data received
    if (!*g->data) {
        return -1;
    }
    // TODO handle the message correct and set all infos like packetsize, thread stuff and features
    tok = strtok(g->data, ";");
    while (tok) {
        if (rz_str_startswith(tok, "PacketSize=")) {
            // Largest packet size we support is 2048
            g->stub_features.pkt_sz = RZ_MIN(strtoul(tok + strlen("PacketSize="), NULL, 16), 2048);
            // Shouldn't be smaller than 64 (Erroneous 0 etc.)
            g->stub_features.pkt_sz = RZ_MAX(g->stub_features.pkt_sz, 64);
        } else if (rz_str_startswith(tok, "qXfer:")) {
            if (!tok[6]) {
                tok = strtok(NULL, ";");
                continue;
            }
            char *p = tok + 6;
            if (rz_str_startswith(p, "btrace:read")) {
                g->stub_features.qXfer_btrace_read = (p[strlen("btrace:read")] == '+');
            } else if (rz_str_startswith(p, "btrace-conf:read")) {
                g->stub_features.qXfer_btrace_conf_read = (p[strlen("btrace-conf:read")] == '+');
            } else if (rz_str_startswith(p, "spu:read")) {
                g->stub_features.qXfer_spu_read = (p[strlen("spu:read")] == '+');
            } else if (rz_str_startswith(p, "spu:write")) {
                g->stub_features.qXfer_spu_write = (p[strlen("spu:write")] == '+');
            } else if (rz_str_startswith(p, "libraries:read")) {
                g->stub_features.qXfer_libraries_read = (p[strlen("libraries:read")] == '+');
            } else if (rz_str_startswith(p, "libraries-svr4:read")) {
                g->stub_features.qXfer_libraries_svr4_read = (p[strlen("libraries-svr4:read")] == '+');
            } else if (rz_str_startswith(p, "memory-map:read")) {
                g->stub_features.qXfer_memory_map_read = (p[strlen("memory-map:read")] == '+');
            } else if (rz_str_startswith(p, "auxv:read")) {
                g->stub_features.qXfer_auxv_read = (p[strlen("auxv:read")] == '+');
            } else if (rz_str_startswith(p, "exec-file:read")) {
                g->stub_features.qXfer_exec_file_read = (p[strlen("exec-file:read")] == '+');
            } else if (rz_str_startswith(p, "features:read")) {
                g->stub_features.qXfer_features_read = (p[strlen("features:read")] == '+');
            } else if (rz_str_startswith(p, "sdata:read")) {
                g->stub_features.qXfer_sdata_read = (p[strlen("sdata:read")] == '+');
            } else if (rz_str_startswith(p, "siginfo:read")) {
                g->stub_features.qXfer_siginfo_read = (p[strlen("siginfo:read")] == '+');
            } else if (rz_str_startswith(p, "siginfo:write")) {
                g->stub_features.qXfer_siginfo_write = (p[strlen("siginfo:write")] == '+');
            } else if (rz_str_startswith(p, "threads:read")) {
                g->stub_features.qXfer_threads_read = (p[strlen("threads:read")] == '+');
            } else if (rz_str_startswith(p, "traceframe-info:read")) {
                g->stub_features.qXfer_traceframe_info_read = (p[strlen("traceframe-info:read")] == '+');
            } else if (rz_str_startswith(p, "uib:read")) {
                g->stub_features.qXfer_uib_read = (p[strlen("uib:read")] == '+');
            } else if (rz_str_startswith(p, "fdpic:read")) {
                g->stub_features.qXfer_fdpic_read = (p[strlen("fdpic:read")] == '+');
            } else if (rz_str_startswith(p, "osdata:read")) {
                g->stub_features.qXfer_osdata_read = (p[strlen("osdata:read")] == '+');
            }
        } else if (tok[0] == 'Q') {
            if (rz_str_startswith(tok, "Qbtrace")) {
                if (!tok[strlen("Qbtrace")]) {
                    tok = strtok(NULL, ";");
                    continue;
                }
                char *p = tok + 7;
                if (rz_str_startswith(p, ":off")) {
                    g->stub_features.Qbtrace_off = (p[4] == '+');
                } else if (rz_str_startswith(p, ":bts")) {
                    g->stub_features.Qbtrace_bts = (p[4] == '+');
                } else if (rz_str_startswith(p, ":pt")) {
                    g->stub_features.Qbtrace_pt = (p[3] == '+');
                } else if (rz_str_startswith(p, "-conf:bts:size")) {
                    g->stub_features.Qbtrace_conf_bts_size = (p[strlen("-conf:bts:size")] == '+');
                } else if (rz_str_startswith(p, ":-conf:pt:size")) {
                    g->stub_features.Qbtrace_conf_pt_size = (p[strlen("-conf:pt:size")] == '+');
                }
            } else if (rz_str_startswith(tok, "QNonStop")) {
                g->stub_features.QNonStop = (tok[strlen("QNonStop")] == '+');
            } else if (rz_str_startswith(tok, "QCatchSyscalls")) {
                g->stub_features.QCatchSyscalls = (tok[strlen("QCatchSyscalls")] == '+');
            } else if (rz_str_startswith(tok, "QPassSignals")) {
                g->stub_features.QPassSignals = (tok[strlen("QPassSignals")] == '+');
            } else if (rz_str_startswith(tok, "QStartNoAckMode")) {
                g->stub_features.QStartNoAckMode = (tok[strlen("QStartNoAckMode")] == '+');
            } else if (rz_str_startswith(tok, "QAgent")) {
                g->stub_features.QAgent = (tok[strlen("QAgent")] == '+');
            } else if (rz_str_startswith(tok, "QAllow")) {
                g->stub_features.QAllow = (tok[strlen("QAllow")] == '+');
            } else if (rz_str_startswith(tok, "QDisableRandomization")) {
                g->stub_features.QDisableRandomization = (tok[strlen("QDisableRandomization")] == '+');
            } else if (rz_str_startswith(tok, "QTBuffer:size")) {
                g->stub_features.QTBuffer_size = (tok[strlen("QTBuffer:size")] == '+');
            } else if (rz_str_startswith(tok, "QThreadEvents")) {
                g->stub_features.QThreadEvents = (tok[strlen("QThreadEvents")] == '+');
            } else if (rz_str_startswith(tok, "QThreadSuffixSupported")) {
                g->remote_type = GDB_REMOTE_TYPE_LLDB;
                g->stub_features.lldb.QThreadSuffixSupported = (tok[strlen("QThreadSuffixSupported")] == '+');
            } else if (rz_str_startswith(tok, "QListThreadsInStopReply")) {
                g->remote_type = GDB_REMOTE_TYPE_LLDB;
                g->stub_features.lldb.QListThreadsInStopReply = (tok[strlen("QListThreadsInStopReply")] == '+');
            }
        } else if (rz_str_startswith(tok, "multiprocess")) {
            g->stub_features.multiprocess = (tok[strlen("multiprocess")] == '+');
        } else if (rz_str_startswith(tok, "qEcho")) {
            g->remote_type = GDB_REMOTE_TYPE_LLDB;
            g->stub_features.lldb.qEcho = (tok[strlen("qEcho")] == '+');
        } else if (rz_str_startswith(tok, "ReverseStep")) {
            g->stub_features.ReverseStep = (tok[strlen("ReverseStep")] == '+');
        } else if (rz_str_startswith(tok, "ReverseContinue")) {
            g->stub_features.ReverseContinue = (tok[strlen("ReverseContinue")] == '+');
        }
        // TODO
        tok = strtok(NULL, ";");
    }
    return send_ack(g);
}

References g, GDB_REMOTE_TYPE_LLDB, NULL, p, RZ_MAX, RZ_MIN, rz_str_startswith(), and send_ack().

Referenced by _server_handle_qSupported(), and gdbr_connect().

handle_removebp()

int handle_removebp

(

libgdbr_t *

g

)

Definition at line 120 of file responses.c.

                                  {
    return send_ack(g);
}

References g, and send_ack().

Referenced by remove_bp().

handle_setbp()

int handle_setbp

(

libgdbr_t *

g

)

Definition at line 116 of file responses.c.

                               {
    return send_ack(g);
}

References g, and send_ack().

Referenced by set_bp().

handle_stop_reason()

int handle_stop_reason

(

libgdbr_t *

g

)

Definition at line 244 of file responses.c.

                                     {
    send_ack(g);
    if (g->data_len < 3) {
        return -1;
    }
    switch (g->data[0]) {
    case 'O':
        unpack_hex(g->data + 1, g->data_len - 1, g->data + 1);
        // g->data[g->data_len - 1] = '\0';
        eprintf("%s", g->data + 1);
        if (send_ack(g) < 0) {
            return -1;
        }
        memset(&g->stop_reason, 0, sizeof(libgdbr_stop_reason_t));
        g->stop_reason.signum = -1;
        g->stop_reason.reason = RZ_DEBUG_REASON_NONE;
        return 0;
    case 'W':
        return stop_reason_exit(g);
    case 'X':
        return stop_reason_terminated(g);
    }
    if (g->data[0] != 'T') {
        return -1;
    }
    char *ptr1, *ptr2;
    g->data[g->data_len] = '\0';
    free(g->stop_reason.exec.path);
    memset(&g->stop_reason, 0, sizeof(libgdbr_stop_reason_t));
    g->stop_reason.core = -1;
    if (sscanf(g->data + 1, "%02x", &g->stop_reason.signum) != 1) {
        return -1;
    }
    g->stop_reason.is_valid = true;
    g->stop_reason.reason = RZ_DEBUG_REASON_SIGNAL;
    for (ptr1 = strtok(g->data + 3, ";"); ptr1; ptr1 = strtok(NULL, ";")) {
        if (rz_str_startswith(ptr1, "thread") && !g->stop_reason.thread.present) {
            if (!(ptr2 = strchr(ptr1, ':'))) {
                continue;
            }
            ptr2++;
            if (read_thread_id(ptr2, &g->stop_reason.thread.pid,
                    &g->stop_reason.thread.tid,
                    g->stub_features.multiprocess) < 0) {
                continue;
            }
            g->stop_reason.thread.present = true;
            continue;
        }
        if (rz_str_startswith(ptr1, "core")) {
            if (!(ptr2 = strchr(ptr1, ':'))) {
                continue;
            }
            ptr2++;
            if (!isxdigit(*ptr2)) {
                continue;
            }
            g->stop_reason.core = (int)strtol(ptr2, NULL, 16);
            continue;
        }
        if (g->stop_reason.signum == 5) {
            if (rz_str_startswith(ptr1, "watch") || rz_str_startswith(ptr1, "rwatch") || rz_str_startswith(ptr1, "awatch")) {
                if (!(ptr2 = strchr(ptr1, ':'))) {
                    continue;
                }
                ptr2++;
                if (!isxdigit(*ptr2)) {
                    continue;
                }
                g->stop_reason.watchpoint.addr = strtoll(ptr2, NULL, 16);
                g->stop_reason.watchpoint.present = true;
                continue;
            }
            if (rz_str_startswith(ptr1, "exec") && !g->stop_reason.exec.present) {
                if (!(ptr2 = strchr(ptr1, ':'))) {
                    continue;
                }
                ptr2++;
                if (!(g->stop_reason.exec.path = calloc(strlen(ptr1) / 2, 1))) {
                    continue;
                }
                unpack_hex(ptr2, strlen(ptr2), g->stop_reason.exec.path);
                g->stop_reason.exec.present = true;
                continue;
            }
            if (rz_str_startswith(ptr1, "fork") && !g->stop_reason.fork.present) {
                if (!(ptr2 = strchr(ptr1, ':'))) {
                    continue;
                }
                ptr2++;
                if (read_thread_id(ptr2, &g->stop_reason.fork.pid,
                        &g->stop_reason.fork.tid,
                        g->stub_features.multiprocess) < 0) {
                    continue;
                }
                g->stop_reason.fork.present = true;
                continue;
            }
            if (rz_str_startswith(ptr1, "vfork") && !g->stop_reason.vfork.present) {
                if (!(ptr2 = strchr(ptr1, ':'))) {
                    continue;
                }
                ptr2++;
                if (read_thread_id(ptr2, &g->stop_reason.vfork.pid,
                        &g->stop_reason.vfork.tid,
                        g->stub_features.multiprocess) < 0) {
                    continue;
                }
                g->stop_reason.vfork.present = true;
                continue;
            }
            if (rz_str_startswith(ptr1, "vforkdone")) {
                g->stop_reason.vforkdone = true;
                continue;
            }
            if (rz_str_startswith(ptr1, "library")) {
                g->stop_reason.library = true;
                continue;
            }
            if (rz_str_startswith(ptr1, "swbreak")) {
                g->stop_reason.swbreak = true;
                continue;
            }
            if (rz_str_startswith(ptr1, "hwbreak")) {
                g->stop_reason.hwbreak = true;
                continue;
            }
            if (rz_str_startswith(ptr1, "create")) {
                g->stop_reason.create = true;
                continue;
            }
        }
    }
    if (g->stop_reason.signum == 5) {
        g->stop_reason.reason = RZ_DEBUG_REASON_BREAKPOINT;
    }
    return 0;
}

References calloc(), eprintf, free(), g, int, isxdigit, memset(), NULL, read_thread_id(), RZ_DEBUG_REASON_BREAKPOINT, RZ_DEBUG_REASON_NONE, RZ_DEBUG_REASON_SIGNAL, rz_str_startswith(), send_ack(), stop_reason_exit(), stop_reason_terminated(), and unpack_hex().

Referenced by __system(), gdbr_stop_reason(), and handle_cont().

handle_vFile_close()

int handle_vFile_close

(

libgdbr_t *

g

)

Definition at line 177 of file responses.c.

                                     {
    if (g->data_len < 2 || g->data[0] != 'F' || g->data[1] == '-' || !isxdigit(g->data[1])) {
        send_ack(g);
        return -1;
    }
    return send_ack(g);
}

References g, isxdigit, and send_ack().

Referenced by gdbr_close_file().

handle_vFile_open()

int handle_vFile_open

(

libgdbr_t *

g

)

Definition at line 132 of file responses.c.

                                    {
    if (g->data_len < 2 || g->data[0] != 'F' || g->data[1] == '-' || !isxdigit(g->data[1])) {
        send_ack(g);
        return -1;
    }
    g->data[g->data_len] = '\0';
    if ((g->remote_file_fd = strtol(g->data + 1, NULL, 16)) <= 0) {
        send_ack(g);
        return -1;
    }
    return send_ack(g);
}

References g, isxdigit, NULL, and send_ack().

Referenced by gdbr_open_file().

handle_vFile_pread()

int handle_vFile_pread	(	libgdbr_t *	g,
		ut8 *	buf
	)

Definition at line 145 of file responses.c.

                                               {
    send_ack(g);
    char *ptr;
    int len;
    if (g->data_len < 3 || g->data[0] != 'F') {
        return -1;
    }
    // F-1 is an error, yes, but it probably should not be fatal, since it might
    // mean we're reading beyond file end. So this is handled in gdbr_read_file
    if (g->data[1] == '-') {
        return 0;
    }
    if (!isxdigit(g->data[1])) {
        return -1;
    }
    if (sscanf(g->data, "F%x;", &len) != 1) {
        return -1;
    }
    // Again, this is probably the end of file
    if (len == 0) {
        return 0;
    }
    if (!(ptr = strchr(g->data, ';')) || ptr >= g->data + g->data_len) {
        return -1;
    }
    ptr++;
    if (len > 0) {
        memcpy(buf, ptr, len);
    }
    return len;
}

References g, isxdigit, len, memcpy(), and send_ack().

Referenced by gdbr_read_file().