core.c

Go to the documentation of this file.

// SPDX-FileCopyrightText: 2017 Srimanta Barua <srimanta.barua1@gmail.com>
// SPDX-License-Identifier: LGPL-3.0-only
 
// Notes and useful links:
// This conversation (https://www.sourceware.org/ml/gdb/2009-02/msg00100.html) suggests GDB clients usually ignore error codes
// Useful, but not to be blindly trusted - http://www.embecosm.com/appnotes/ean4/embecosm-howto-rsp-server-ean4-issue-2.html
// https://github.com/llvm-mirror/lldb/blob/master/docs/lldb-gdb-remote.txt
// http://www.cygwin.com/ml/gdb/2008-05/msg00166.html
 
#include "gdbserver/core.h"
#include "gdbr_common.h"
#include "libgdbr.h"
#include "packet.h"
#include "utils.h"
#include "rz_util/rz_str.h"
 
static int _server_handle_qSupported(libgdbr_t *g) {
    int ret;
    char *buf;
    if (!(buf = malloc(128))) {
        return -1;
    }
    snprintf(buf, 127, "PacketSize=%x;QStartNoAckMode+;qXfer:exec-file:read+",
        (ut32)(g->read_max - 1));
    if (handle_qSupported(g) < 0) {
        free(buf);
        return -1;
    }
    ret = send_msg(g, buf);
    free(buf);
    return ret;
}
 
static int _server_handle_qTStatus(libgdbr_t *g) {
    // TODO Handle proper reporting of trace status
    const char *message = "";
    if (send_ack(g) < 0) {
        return -1;
    }
    return send_msg(g, message);
}
 
static int _server_handle_qOffsets(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    char buf[64], *ptr;
    ptr = buf + sprintf(buf, "TextSeg=");
    if (send_ack(g) < 0) {
        return -1;
    }
    if (cmd_cb(g, core_ptr, "dm", ptr, sizeof(buf) - (ptr - buf) - 1) < 0) {
        send_msg(g, "");
        return -1;
    }
    return send_msg(g, buf);
}
 
static int _server_handle_exec_file_read(libgdbr_t *g, gdbr_server_cmd_cb cb,
    void *core_ptr) {
    char *buf, *ptr, cmd[64] = { 0 };
    size_t buflen = 512;
    int ret;
    if (send_ack(g) < 0) {
        return -1;
    }
    ptr = g->data + strlen("qXfer:exec-file:read:");
    if (*ptr != ':') {
        int pid;
        if ((pid = (int)strtol(ptr, NULL, 16)) <= 0 || pid != g->pid) {
            return send_msg(g, "E00");
        }
    }
    if (!(ptr = strchr(ptr, ':'))) {
        return send_msg(g, "E00");
    }
    ptr++;
    snprintf(cmd, sizeof(cmd) - 1, "if%s", ptr);
    if (!(buf = malloc(buflen))) {
        send_msg(g, "E01");
        return -1;
    }
    if (cb(g, core_ptr, cmd, buf, buflen) < 0) {
        free(buf);
        return send_msg(g, "E01");
    }
    ret = send_msg(g, buf);
    free(buf);
    return ret;
}
 
static int _server_handle_M(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    if (send_ack(g) < 0) {
        return -1;
    }
    char *memstr, *buf;
    ut64 memlen, memlen2, addr;
    g->data[g->data_len] = '\0';
    if (sscanf(g->data + 1, "%" PFMT64x ",%" PFMT64x, &addr, &memlen) != 2) {
        return send_msg(g, "E01");
    }
    memlen2 = memlen * 2;
    if (!(memstr = strchr(g->data, ':')) || !*(++memstr)) {
        return send_msg(g, "E01");
    }
    if (memlen2 != strlen(memstr)) {
        return send_msg(g, "E01");
    }
    if (!(buf = malloc(memlen2 + 64))) {
        return send_msg(g, "E01");
    }
    snprintf(buf, memlen2 + 63, "wx 0x%s @ 0x%" PFMT64x, memstr, addr);
    buf[memlen2 + 63] = '\0';
    eprintf("buf: %s\n", buf);
    if (cmd_cb(g, core_ptr, buf, NULL, 0) < 0) {
        free(buf);
        return send_msg(g, "E01");
    }
    free(buf);
    return send_msg(g, "OK");
}
 
static int _server_handle_s(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    char message[64];
    if (send_ack(g) < 0) {
        return -1;
    }
    if (g->data_len > 1) {
        // We don't handle s[addr] packet
        return send_msg(g, "E01");
    }
    if (cmd_cb(g, core_ptr, "ds", NULL, 0) < 0) {
        send_msg(g, "E01");
        return -1;
    }
    if (cmd_cb(g, core_ptr, "?", message, sizeof(message)) < 0) {
        send_msg(g, "");
        return -1;
    }
    return send_msg(g, message);
}
 
static int _server_handle_c(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    char message[64];
    if (send_ack(g) < 0) {
        return -1;
    }
    if (g->data_len > 1) {
        // We don't handle s[addr] packet
        return send_msg(g, "E01");
    }
    if (cmd_cb(g, core_ptr, "dc", NULL, 0) < 0) {
        send_msg(g, "E01");
        return -1;
    }
    if (cmd_cb(g, core_ptr, "?", message, sizeof(message)) < 0) {
        send_msg(g, "");
        return -1;
    }
    return send_msg(g, message);
}
 
static int _server_handle_ques(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    char message[64] = { 0 };
    if (send_ack(g) < 0) {
        return -1;
    }
    if (cmd_cb(g, core_ptr, "?", message, sizeof(message)) < 0) {
        send_msg(g, "");
        return -1;
    }
    return send_msg(g, message);
}
 
static int _server_handle_qC(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    char *buf;
    int ret;
    size_t buf_len = 80;
    if (send_ack(g) < 0) {
        return -1;
    }
    if (!(buf = malloc(buf_len))) {
        return -1;
    }
    if (cmd_cb(g, core_ptr, "dp", buf, buf_len) < 0) {
        free(buf);
        return -1;
    }
    ret = send_msg(g, buf);
    free(buf);
    return ret;
}
 
static int _server_handle_k(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    send_ack(g);
    return -1;
}
 
static int _server_handle_vKill(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    if (send_ack(g) < 0) {
        return -1;
    }
    // TODO handle killing of pid
    send_msg(g, "OK");
    return -1;
}
 
static int _server_handle_z(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    if (send_ack(g) < 0) {
        return -1;
    }
    char set; // Z = set, z = remove
    int type;
    ut64 addr;
    char cmd[64];
    sscanf(g->data, "%c%d,%" PFMT64x, &set, &type, &addr);
    if (type != 0) {
        // TODO handle hw breakpoints and watchpoints
        return send_msg(g, "E01");
    }
    switch (set) {
    case 'Z':
        // Set
        snprintf(cmd, sizeof(cmd) - 1, "db @ 0x%" PFMT64x, addr);
        break;
    case 'z':
        // Remove
        snprintf(cmd, sizeof(cmd) - 1, "db- @ 0x%" PFMT64x, addr);
        break;
    default:
        return send_msg(g, "E01");
    }
    if (cmd_cb(g, core_ptr, cmd, NULL, 0) < 0) {
        send_msg(g, "E01");
        return -1;
    }
    return send_msg(g, "OK");
}
 
static int _server_handle_vCont(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    char *action = NULL;
    if (send_ack(g) < 0) {
        return -1;
    }
    g->data[g->data_len] = '\0';
    if (g->data[5] == '?') {
        // Query about everything we support
        return send_msg(g, "vCont;c;s");
    }
    if (!strtok(g->data, ";")) {
        return send_msg(g, "E01");
    }
    while ((action = strtok(NULL, ";"))) {
        eprintf("action: %s\n", action);
        switch (action[0]) {
        case 's':
            // TODO handle thread selections
            if (cmd_cb(g, core_ptr, "ds", NULL, 0) < 0) {
                send_msg(g, "E01");
                return -1;
            }
            return send_msg(g, "OK");
        case 'c':
            // TODO handle thread selections
            if (cmd_cb(g, core_ptr, "dc", NULL, 0) < 0) {
                send_msg(g, "E01");
                return -1;
            }
            return send_msg(g, "OK");
        default:
            // TODO support others
            return send_msg(g, "E01");
        }
    }
    return -1;
}
 
static int _server_handle_qAttached(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    if (send_ack(g) < 0) {
        return -1;
    }
    // TODO check if process was attached or created
    // Right now, says that process was created
    return send_msg(g, "0");
}
 
// TODO, proper handling of Hg and Hc (right now handled identically)
 
// Set thread for all operations other than "step" and "continue"
static int _server_handle_Hg(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    // We don't yet support multiprocess. Client is not supposed to send Hgp. If we receive it anyway,
    // send error
    char cmd[32];
    int tid;
    if (send_ack(g) < 0) {
        return -1;
    }
    if (g->data_len <= 2 || isalpha(g->data[2])) {
        return send_msg(g, "E01");
    }
    // Hg-1 = "all threads", Hg0 = "pick any thread"
    if (g->data[2] == '0' || !strncmp(g->data + 2, "-1", 2)) {
        return send_msg(g, "OK");
    }
    sscanf(g->data + 2, "%x", &tid);
    snprintf(cmd, sizeof(cmd) - 1, "dpt=%d", tid);
    // Set thread for future operations
    if (cmd_cb(g, core_ptr, cmd, NULL, 0) < 0) {
        send_msg(g, "E01");
        return -1;
    }
    return send_msg(g, "OK");
}
 
// Set thread for "step" and "continue"
static int _server_handle_Hc(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    // Usually this is only sent with Hc-1. Still. Set the threads for next operations
    char cmd[32];
    int tid;
    if (send_ack(g) < 0) {
        return -1;
    }
    if (g->data_len <= 2 || isalpha(g->data[2])) {
        return send_msg(g, "E01");
    }
    // Hc-1 = "all threads", Hc0 = "pick any thread"
    if (g->data[2] == '0' || !strncmp(g->data + 2, "-1", 2)) {
        return send_msg(g, "OK");
    }
    sscanf(g->data + 2, "%x", &tid);
    snprintf(cmd, sizeof(cmd) - 1, "dpt=%d", tid);
    // Set thread for future operations
    if (cmd_cb(g, core_ptr, cmd, NULL, 0) < 0) {
        send_msg(g, "E01");
        return -1;
    }
    return send_msg(g, "OK");
}
 
static int _server_handle_qfThreadInfo(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    char *buf;
    int ret;
    size_t buf_len = g->stub_features.pkt_sz;
    if (send_ack(g) < 0) {
        return -1;
    }
    if (!(buf = malloc(buf_len))) {
        return -1;
    }
    if (cmd_cb(g, core_ptr, "dpt", buf, buf_len) < 0) {
        free(buf);
        return -1;
    }
    ret = send_msg(g, buf);
    free(buf);
    return ret;
}
 
static int _server_handle_qsThreadInfo(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    // TODO handle overflow from qfThreadInfo. Otherwise this won't work with programs with many threads
    if (send_ack(g) < 0 || send_msg(g, "l") < 0) {
        return -1;
    }
    return 0;
}
 
static int _server_handle_g(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    char *buf;
    // To be very safe
    int buf_len = 4096;
    int ret;
    if (send_ack(g) < 0) {
        return -1;
    }
    if (!(buf = malloc(buf_len))) {
        send_msg(g, "E01");
        return -1;
    }
    memset(buf, 0, buf_len);
    if (cmd_cb(g, core_ptr, "dr", buf, buf_len) < 0) {
        free(buf);
        send_msg(g, "E01");
        return -1;
    }
    ret = send_msg(g, buf);
    free(buf);
    return ret;
}
 
static int _server_handle_m(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    ut64 addr;
    int length;
    char *cmd, *buf;
    if (send_ack(g) < 0) {
        return -1;
    }
    g->data[g->data_len] = 0;
    sscanf(g->data, "m%" PFMT64x, &addr);
    if (!(cmd = strdup(g->data))) {
        send_msg(g, "E01");
        return -1;
    }
    if (!(buf = malloc(g->data_max / 2))) {
        free(cmd);
        send_msg(g, "E01");
        return -1;
    }
    if ((length = cmd_cb(g, core_ptr, cmd, buf, (g->data_max / 2) - 1)) < 0 || length >= g->data_max / 2) {
        free(cmd);
        free(buf);
        return send_msg(g, "E01");
    }
    pack_hex(buf, length, g->data);
    free(cmd);
    free(buf);
    g->data[length * 2] = '\0';
    return send_msg(g, g->data);
}
 
// Read register number
static int _server_handle_p(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    char message[128] = { 0 }, cmd[128] = { 0 };
    int regnum, i;
    if (send_ack(g) < 0) {
        return -1;
    }
    if (!isxdigit(g->data[1])) {
        return send_msg(g, "E01");
    }
    regnum = strtol(g->data + 1, NULL, 16);
    // We need to do this because length of register set is not known
    for (i = 0; i < regnum; i++) {
        if (!*g->registers[i].name) {
            return send_msg(g, "E01");
        }
    }
    if (snprintf(cmd, sizeof(cmd) - 1, "dr %s", g->registers[regnum].name) < 0) {
        send_msg(g, "E01");
        return -1;
    }
    if (cmd_cb(g, core_ptr, cmd, message, sizeof(message)) < 0) {
        send_msg(g, "E01");
        return -1;
    }
    return send_msg(g, message);
}
 
// Write register number
static int _server_handle_P(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    char *ptr, *cmd;
    int regnum, len, i;
    if (send_ack(g) < 0) {
        return -1;
    }
    if (!isxdigit(g->data[1]) || !(ptr = strchr(g->data, '='))) {
        return send_msg(g, "E01");
    }
    ptr++;
    if (!isxdigit(*ptr)) {
        return send_msg(g, "E01");
    }
    regnum = strtol(g->data + 1, NULL, 16);
    // We need to do this because length of register set is not known
    for (i = 0; i < regnum; i++) {
        if (!*g->registers[i].name) {
            return send_msg(g, "E01");
        }
    }
    len = strlen(g->registers[regnum].name) + strlen(ptr) + 10;
    if (!(cmd = calloc(len, sizeof(char)))) {
        return send_msg(g, "E01");
    }
    snprintf(cmd, len - 1, "dr %s=0x%s", g->registers[regnum].name, ptr);
    if (cmd_cb(g, core_ptr, cmd, NULL, 0) < 0) {
        free(cmd);
        send_msg(g, "E01");
        return -1;
    }
    free(cmd);
    return send_msg(g, "OK");
}
 
static int _server_handle_vMustReplyEmpty(libgdbr_t *g) {
    if (send_ack(g) < 0) {
        return -1;
    }
    return send_msg(g, "");
}
 
static int _server_handle_qTfV(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    // TODO
    if (send_ack(g) < 0) {
        return -1;
    }
    return send_msg(g, "");
}
 
int gdbr_server_serve(libgdbr_t *g, gdbr_server_cmd_cb cmd_cb, void *core_ptr) {
    int ret;
    if (!g) {
        return -1;
    }
    while (1) {
        if (read_packet(g, false) < 0) {
            continue;
        }
        if (g->data_len == 0) {
            continue;
        }
        if (rz_str_startswith(g->data, "k")) {
            return _server_handle_k(g, cmd_cb, core_ptr);
        }
        if (rz_str_startswith(g->data, "vKill")) {
            return _server_handle_vKill(g, cmd_cb, core_ptr);
        }
        if (rz_str_startswith(g->data, "qSupported")) {
            if ((ret = _server_handle_qSupported(g)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "qTStatus")) {
            if ((ret = _server_handle_qTStatus(g)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "qC") && g->data_len == 2) {
            if ((ret = _server_handle_qC(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "qAttached")) {
            if ((ret = _server_handle_qAttached(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "vMustReplyEmpty")) {
            if ((ret = _server_handle_vMustReplyEmpty(g)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "qTfV")) {
            if ((ret = _server_handle_qTfV(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "qfThreadInfo")) {
            if ((ret = _server_handle_qfThreadInfo(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "qsThreadInfo")) {
            if ((ret = _server_handle_qsThreadInfo(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "Hg")) {
            if ((ret = _server_handle_Hg(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "Hc")) {
            if ((ret = _server_handle_Hc(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "?")) {
            if ((ret = _server_handle_ques(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "g") && g->data_len == 1) {
            if ((ret = _server_handle_g(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "vCont")) {
            if ((ret = _server_handle_vCont(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "qOffsets")) {
            if ((ret = _server_handle_qOffsets(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (g->data[0] == 'z' || g->data[0] == 'Z') {
            if ((ret = _server_handle_z(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (g->data[0] == 's') {
            if ((ret = _server_handle_s(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (g->data[0] == 'c') {
            if ((ret = _server_handle_c(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "m")) {
            if ((ret = _server_handle_m(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "M")) {
            if ((ret = _server_handle_M(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "P")) {
            if ((ret = _server_handle_P(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "p")) {
            if ((ret = _server_handle_p(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "qXfer:exec-file:read:")) {
            if ((ret = _server_handle_exec_file_read(g, cmd_cb, core_ptr)) < 0) {
                return ret;
            }
            continue;
        }
        if (rz_str_startswith(g->data, "QStartNoAckMode")) {
            if (send_ack(g) < 0) {
                return -1;
            }
            g->no_ack = true;
            if (g->server_debug) {
                eprintf("[noack mode enabled]\n");
            }
            if (send_msg(g, "OK") < 0) {
                return -1;
            }
            continue;
        }
        // Unrecognized packet
        if (send_ack(g) < 0 || send_msg(g, "") < 0) {
            g->data[g->data_len] = '\0';
            eprintf("Unknown packet: %s\n", g->data);
            return -1;
        }
    };
    return ret;
}