libqnxr.h File Reference

#include <stdint.h>
#include <unistd.h>
#include "arch.h"
#include "rz_types_base.h"
#include "rz_socket.h"
#include "dsmsgs.h"

Go to the source code of this file.

Classes
struct	ptid_t
struct	libqnxr_t

Macros
#define	MSG_OK   0
#define	MSG_NOT_SUPPORTED   -1
#define	MSG_ERROR_1   -2
#define	X86_64   ARCH_X86_64
#define	X86_32   ARCH_X86_32
#define	ARM_32   ARCH_ARM_32
#define	ARM_64   ARCH_ARM_64

Typedefs
typedef struct libqnxr_t	libqnxr_t
typedef void()	pidlist_cb_t(void *ctx, pid_t pid, char *name)

Functions
int	qnxr_init (libqnxr_t *g)
int	qnxr_set_architecture (libqnxr_t *g, ut8 architecture)
int	qnxr_cleanup (libqnxr_t *g)
int	qnxr_connect (libqnxr_t *g, const char *server, int port)
int	qnxr_disconnect (libqnxr_t *g)
void	qnxr_pidlist (libqnxr_t *g, void *ctx, pidlist_cb_t *cb)
int	qnxr_select (libqnxr_t *g, pid_t pid, int tid)
ptid_t	qnxr_run (libqnxr_t *g, const char *file, char **args, char **env)
ptid_t	qnxr_attach (libqnxr_t *g, pid_t pid)
ptid_t	qnxr_wait (libqnxr_t *g, pid_t pid)
int	qnxr_stop (libqnxr_t *g)
int	qnxr_continue (libqnxr_t *g, int thread_id)
int	qnxr_step (libqnxr_t *g, int thread_id)
int	qnxr_read_registers (libqnxr_t *g)
int	qnxr_write_reg (libqnxr_t *g, const char *name, char *value, int len)
int	qnxr_write_register (libqnxr_t *g, int index, char *value, int len)
int	qnxr_read_memory (libqnxr_t *g, ut64 address, ut8 *data, ut64 len)
int	qnxr_write_memory (libqnxr_t *g, ut64 address, const ut8 *data, ut64 len)
int	qnxr_set_bp (libqnxr_t *g, ut64 address, const char *conditions)
int	qnxr_set_hwbp (libqnxr_t *g, ut64 address, const char *conditions)
int	qnxr_remove_bp (libqnxr_t *g, ut64 address)
int	qnxr_remove_hwbp (libqnxr_t *g, ut64 address)
int	ptid_equal (ptid_t ptid1, ptid_t ptid2)

Variables
ptid_t	null_ptid

Macro Definition Documentation

ARM_32

#define ARM_32   ARCH_ARM_32

Definition at line 26 of file libqnxr.h.

ARM_64

#define ARM_64   ARCH_ARM_64

Definition at line 27 of file libqnxr.h.

MSG_ERROR_1

#define MSG_ERROR_1   -2

Definition at line 22 of file libqnxr.h.

MSG_NOT_SUPPORTED

#define MSG_NOT_SUPPORTED   -1

Definition at line 21 of file libqnxr.h.

MSG_OK

#define MSG_OK   0

Definition at line 20 of file libqnxr.h.

X86_32

#define X86_32   ARCH_X86_32

Definition at line 25 of file libqnxr.h.

X86_64

#define X86_64   ARCH_X86_64

Definition at line 24 of file libqnxr.h.

Typedef Documentation

libqnxr_t

typedef struct libqnxr_t libqnxr_t

Core "object" that saves the instance of the lib

pidlist_cb_t

typedef void() pidlist_cb_t(void *ctx, pid_t pid, char *name)

Definition at line 69 of file libqnxr.h.

Function Documentation

ptid_equal()

int ptid_equal	(	ptid_t	ptid1,
		ptid_t	ptid2
	)

Definition at line 309 of file utils.c.

                                           {
    return ptid1.pid == ptid2.pid && ptid1.tid == ptid2.tid;
}

References ptid_t::pid, and ptid_t::tid.

Referenced by rz_debug_qnx_wait().

qnxr_attach()

ptid_t qnxr_attach	(	libqnxr_t *	g,
		pid_t	pid
	)

Definition at line 223 of file core.c.

                                            {
 
    if (g->inferior_ptid.pid != pid) {
        qnxr_disconnect(g);
        rz_sys_sleep(1);
        qnxr_connect(g, g->host, g->port);
    }
 
    nto_send_init(g, DStMsg_attach, 0, SET_CHANNEL_DEBUG);
    g->tran.pkt.attach.pid = pid;
    g->tran.pkt.attach.pid = EXTRACT_SIGNED_INTEGER(&g->tran.pkt.attach.pid, 4);
 
    nto_send(g, sizeof(g->tran.pkt.attach), 0);
    if (g->recv.pkt.hdr.cmd != DSrMsg_okdata) {
        eprintf("%s: failed to attach to %d\n", __func__, pid);
        return null_ptid;
    }
 
    g->inferior_ptid = ptid_build(
        EXTRACT_SIGNED_INTEGER(&g->recv.pkt.notify.pid, 4),
        EXTRACT_SIGNED_INTEGER(&g->recv.pkt.notify.tid, 4));
 
    return g->inferior_ptid;
}

References DSrMsg_okdata, DStMsg_attach, eprintf, EXTRACT_SIGNED_INTEGER, g, nto_send(), nto_send_init(), null_ptid, pid, ptid_build(), qnxr_connect(), qnxr_disconnect(), rz_sys_sleep(), and SET_CHANNEL_DEBUG.

Referenced by rz_debug_qnx_attach().

qnxr_cleanup()

int qnxr_cleanup

(

libqnxr_t *

g

)

Definition at line 138 of file core.c.

                               {
    if (!g)
        return -1;
    free(g->send_buff);
    g->send_len = 0;
    free(g->read_buff);
    return 0;
}

References free(), and g.

qnxr_connect()

int qnxr_connect	(	libqnxr_t *	g,
		const char *	server,
		int	port
	)

Definition at line 147 of file core.c.

                                                           {
    char tmp[255];
    int ret;
    if (!g || !host || g->connected)
        return -1;
 
    g->data_len = 0;
    g->read_len = 0;
    g->read_ptr = 0;
    g->sock = rz_socket_new(0);
    g->connected = 0;
    g->mid = 0;
 
    memmove(g->host, host, strlen(host) + 1);
    g->port = port;
 
    ret = snprintf(tmp, sizeof(tmp) - 1, "%d", port);
    if (!ret)
        return -1;
    ret = rz_socket_connect_tcp(g->sock, host, tmp, 200);
    if (!ret)
        return -1;
    g->connected = 1;
 
    qnxr_send_ch_reset(g);
    nto_send_init(g, DStMsg_connect, 0, SET_CHANNEL_DEBUG);
    g->tran.pkt.connect.major = HOST_QNX_PROTOVER_MAJOR;
    g->tran.pkt.connect.minor = HOST_QNX_PROTOVER_MINOR;
    nto_send(g, sizeof(g->tran.pkt.connect), 0);
 
    if (g->recv.pkt.hdr.cmd == DSrMsg_err) {
        eprintf("%s: connection failed: %lld\n", __func__,
            EXTRACT_SIGNED_INTEGER(&g->recv.pkt.err.err, 4));
        return -1;
    }
 
    /* Try to query pdebug for their version of the protocol */
    nto_send_init(g, DStMsg_protover, 0, SET_CHANNEL_DEBUG);
    g->tran.pkt.protover.major = HOST_QNX_PROTOVER_MAJOR;
    g->tran.pkt.protover.minor = HOST_QNX_PROTOVER_MINOR;
    nto_send(g, sizeof(g->tran.pkt.protover), 0);
 
    if ((g->recv.pkt.hdr.cmd == DSrMsg_err) && (EXTRACT_SIGNED_INTEGER(&g->recv.pkt.err.err, 4) == EINVAL)) {
        g->target_proto_major = 0;
        g->target_proto_minor = 0;
    } else if (g->recv.pkt.hdr.cmd == DSrMsg_okstatus) {
        g->target_proto_major = EXTRACT_SIGNED_INTEGER(&g->recv.pkt.okstatus.status, 4);
        g->target_proto_minor = EXTRACT_SIGNED_INTEGER(&g->recv.pkt.okstatus.status, 4);
        g->target_proto_major = (g->target_proto_major >> 8) & DSMSG_PROTOVER_MAJOR;
        g->target_proto_minor = g->target_proto_minor & DSMSG_PROTOVER_MINOR;
    } else {
        eprintf("Connection failed (Protocol Version Query): %lld\n",
            EXTRACT_SIGNED_INTEGER(&g->recv.pkt.err.err, 4));
        return -1;
    }
 
    return 0;
}

References DSMSG_PROTOVER_MAJOR, DSMSG_PROTOVER_MINOR, DSrMsg_err, DSrMsg_okstatus, DStMsg_connect, DStMsg_protover, EINVAL, eprintf, EXTRACT_SIGNED_INTEGER, g, HOST_QNX_PROTOVER_MAJOR, HOST_QNX_PROTOVER_MINOR, nto_send(), nto_send_init(), qnxr_send_ch_reset(), rz_socket_connect_tcp, rz_socket_new(), SET_CHANNEL_DEBUG, snprintf, and autogen_x86imm::tmp.

Referenced by __open(), and qnxr_attach().

qnxr_continue()

int qnxr_continue	(	libqnxr_t *	g,
		int	thread_id
	)

Definition at line 470 of file core.c.

                                               {
    return qnxr_send_vcont(g, 0, thread_id);
}

References g, and qnxr_send_vcont().

Referenced by rz_debug_qnx_continue().

qnxr_disconnect()

int qnxr_disconnect

(

libqnxr_t *

g

)

Definition at line 206 of file core.c.

                                  {
    if (!g)
        return -1;
 
    if (g->connected) {
        nto_send_init(g, DStMsg_disconnect, 0, SET_CHANNEL_DEBUG);
        nto_send(g, sizeof(g->tran.pkt.disconnect), 0);
        g->connected = 0;
        g->inferior_ptid = null_ptid;
 
        if (!rz_socket_close(g->sock))
            return -1;
    }
 
    return 0;
}

References DStMsg_disconnect, g, nto_send(), nto_send_init(), null_ptid, rz_socket_close(), and SET_CHANNEL_DEBUG.

Referenced by qnxr_attach(), and rz_debug_qnx_detach().

qnxr_init()

int qnxr_init

(

libqnxr_t *

g

)

Definition at line 104 of file core.c.

                            {
    if (!g)
        return -1;
    memset(g, 0, sizeof(libqnxr_t));
    g->send_len = 0;
    g->send_buff = (char *)calloc(DS_DATA_MAX_SIZE * 2, 1);
    if (!g->send_buff)
        return -1;
    g->read_buff = (char *)calloc(DS_DATA_MAX_SIZE * 2, 1);
    if (!g->read_buff) {
        RZ_FREE(g->send_buff);
        return -1;
    }
    g->registers = x86_32;
    return 0;
}

References calloc(), DS_DATA_MAX_SIZE, g, memset(), RZ_FREE, and x86_32.

Referenced by __open().

qnxr_pidlist()

void qnxr_pidlist	(	libqnxr_t *	g,
		void *	ctx,
		pidlist_cb_t *	cb
	)

Definition at line 417 of file core.c.

                                                             {
    struct dspidlist *pidlist = (void *)g->recv.pkt.okdata.data;
    pid_t pid, start_tid;
    char subcmd;
 
    if (!g)
        return;
 
    start_tid = 1;
    pid = 1;
    subcmd = DSMSG_PIDLIST_BEGIN;
 
    while (1) {
        nto_send_init(g, DStMsg_pidlist, subcmd, SET_CHANNEL_DEBUG);
        g->tran.pkt.pidlist.pid = EXTRACT_SIGNED_INTEGER(&pid, 4);
        g->tran.pkt.pidlist.tid = EXTRACT_SIGNED_INTEGER(&start_tid, 4);
        nto_send(g, sizeof(g->tran.pkt.pidlist), 0);
 
        if (g->recv.pkt.hdr.cmd == DSrMsg_err || g->recv.pkt.hdr.cmd != DSrMsg_okdata)
            return;
 
        pid = EXTRACT_SIGNED_INTEGER(&pidlist->pid, 4);
        if (cb != NULL)
            cb(ctx, pid, pidlist->name);
        subcmd = DSMSG_PIDLIST_NEXT;
    }
}

References cb, DSMSG_PIDLIST_BEGIN, DSMSG_PIDLIST_NEXT, DSrMsg_err, DSrMsg_okdata, DStMsg_pidlist, EXTRACT_SIGNED_INTEGER, g, if(), dspidlist::name, nto_send(), nto_send_init(), NULL, pid, dspidlist::pid, and SET_CHANNEL_DEBUG.

Referenced by rz_debug_qnx_pids().

qnxr_read_memory()

int qnxr_read_memory	(	libqnxr_t *	g,
		ut64	address,
		ut8 *	data,
		ut64	len
	)

Definition at line 365 of file core.c.

                                                                      {
    int rcv_len, tot_len, ask_len;
    ut64 addr;
 
    if (!g || !data)
        return -1;
 
    tot_len = ask_len = 0;
 
    do {
        nto_send_init(g, DStMsg_memrd, 0, SET_CHANNEL_DEBUG);
        addr = address + tot_len;
        g->tran.pkt.memrd.addr = EXTRACT_UNSIGNED_INTEGER(&addr, 8);
        ask_len = ((len - tot_len) > DS_DATA_MAX_SIZE) ? DS_DATA_MAX_SIZE : (len - tot_len);
 
        g->tran.pkt.memrd.size = EXTRACT_SIGNED_INTEGER(&ask_len, 2);
        rcv_len = nto_send(g, sizeof(g->tran.pkt.memrd), 0) -
            sizeof(g->recv.pkt.hdr);
        if (rcv_len <= 0)
            break;
        if (g->recv.pkt.hdr.cmd == DSrMsg_okdata) {
            memcpy(data + tot_len, g->recv.pkt.okdata.data, rcv_len);
            tot_len += rcv_len;
        } else
            break;
    } while (tot_len != len);
 
    return tot_len;
}

References addr, DS_DATA_MAX_SIZE, DSrMsg_okdata, DStMsg_memrd, EXTRACT_SIGNED_INTEGER, EXTRACT_UNSIGNED_INTEGER, g, len, memcpy(), nto_send(), nto_send_init(), SET_CHANNEL_DEBUG, and ut64().

Referenced by debug_qnx_read_at().

qnxr_read_registers()

int qnxr_read_registers

(

libqnxr_t *

g

)

Definition at line 323 of file core.c.

                                      {
    int i = 0;
    int len, rlen, regset;
    int n = 0;
    ut32 off;
    char buf[DS_DATA_MAX_SIZE];
 
    if (!g)
        return -1;
 
    while (g->registers[i].size > 0) {
        regset = i386nto_regset_id(i);
        len = i386nto_register_area(i, regset, &off);
        if (len < 1) {
            eprintf("%s: unknown register %d\n", __func__, i);
            len = g->registers[i].size;
        }
        nto_send_init(g, DStMsg_regrd, regset, SET_CHANNEL_DEBUG);
        g->tran.pkt.regrd.offset = EXTRACT_SIGNED_INTEGER(&off, 2);
        g->tran.pkt.regrd.size = EXTRACT_SIGNED_INTEGER(&len, 2);
        rlen = nto_send(g, sizeof(g->tran.pkt.regrd), 1);
 
        if (rlen > 0) {
            if (g->recv.pkt.hdr.cmd == DSrMsg_okdata) {
                memcpy(buf + g->registers[i].offset,
                    g->recv.pkt.okdata.data, len);
                n += len;
            } else {
                memset(buf + g->registers[i].offset,
                    0, len);
            }
        } else {
            eprintf("%s: couldn't read register %d\n", __func__, i);
            return -1;
        }
        i++;
    }
 
    memcpy(g->recv.data, buf, n);
    return n;
}

References DS_DATA_MAX_SIZE, DSrMsg_okdata, DStMsg_regrd, eprintf, EXTRACT_SIGNED_INTEGER, g, i, i386nto_register_area(), i386nto_regset_id(), len, memcpy(), memset(), n, nto_send(), nto_send_init(), off, and SET_CHANNEL_DEBUG.

Referenced by rz_debug_qnx_reg_read().

qnxr_remove_bp()

int qnxr_remove_bp	(	libqnxr_t *	g,
		ut64	address
	)

Definition at line 607 of file core.c.

                                               {
    return _qnxr_remove_bp(g, address, BREAKPOINT);
}

References _qnxr_remove_bp(), BREAKPOINT, and g.

Referenced by rz_debug_qnx_breakpoint().

qnxr_remove_hwbp()

int qnxr_remove_hwbp	(	libqnxr_t *	g,
		ut64	address
	)

Definition at line 611 of file core.c.

                                                 {
    return _qnxr_remove_bp(g, address, HARDWARE_BREAKPOINT);
}

References _qnxr_remove_bp(), g, and HARDWARE_BREAKPOINT.

Referenced by rz_debug_qnx_breakpoint().

qnxr_run()

ptid_t qnxr_run	(	libqnxr_t *	g,
		const char *	file,
		char **	args,
		char **	env
	)

Definition at line 248 of file core.c.

                                                                         {
    ut32 argc = 0;
    ut32 envc = 0;
 
    char **argv, *p;
    int errors = 0;
 
    if (!g)
        return null_ptid;
 
    nto_send_init(g, DStMsg_env, DSMSG_ENV_CLEARENV, SET_CHANNEL_DEBUG);
    nto_send(g, sizeof(DStMsg_env_t), 1);
 
    for (envc = 0; *env; env++, envc++)
        errors += !nto_send_env(g, *env);
 
    if (errors) {
        eprintf("%s: error(s) occurred while sending environment\n", __func__);
    }
 
    nto_send_init(g, DStMsg_env, DSMSG_ENV_CLEARARGV, SET_CHANNEL_DEBUG);
    nto_send(g, sizeof(DStMsg_env_t), 1);
 
    if (file != NULL) {
        errors = !nto_send_arg(g, file);
        if (!errors)
            errors = !nto_send_arg(g, file);
 
        if (errors) {
            eprintf("%s: failed to send executable file name\n", __func__);
            return null_ptid;
        }
 
        errors = 0;
        for (argv = args; *argv && **argv; argv++, argc++)
            errors |= !nto_send_arg(g, *argv);
 
        if (errors) {
            eprintf("%s: error(s) occurred while sending args\n", __func__);
        }
    }
 
    if (errors) {
        return null_ptid;
    }
 
    nto_send_init(g, DStMsg_load, DSMSG_LOAD_DEBUG, SET_CHANNEL_DEBUG);
    p = g->tran.pkt.load.cmdline;
 
    g->tran.pkt.load.envc = 0;
    g->tran.pkt.load.argc = 0;
 
    if (file) {
        strncpy(p, file, sizeof(g->tran.pkt.load.cmdline) - 8);
        p += strlen(p);
    }
    *p++ = '\0';
 
    *p++ = '\0'; // stdin
    *p++ = '\0'; // stdout
    *p++ = '\0'; // stderr
 
    nto_send(g, offsetof(DStMsg_load_t, cmdline) + p - g->tran.pkt.load.cmdline + 1, 1);
 
    if (g->recv.pkt.hdr.cmd == DSrMsg_okdata) {
        ptid_t ptid = nto_parse_notify(g);
        eprintf("%s: inferior pid: %d\n", __func__, ptid.pid);
        g->inferior_ptid = ptid;
 
        return ptid;
    }
 
    return null_ptid;
}

References args, argv, DSMSG_ENV_CLEARARGV, DSMSG_ENV_CLEARENV, DSMSG_LOAD_DEBUG, DSrMsg_okdata, DStMsg_env, DStMsg_load, env, eprintf, g, nto_parse_notify(), nto_send(), nto_send_arg(), nto_send_env(), nto_send_init(), NULL, null_ptid, offsetof, p, ptid_t::pid, and SET_CHANNEL_DEBUG.

qnxr_select()

int qnxr_select	(	libqnxr_t *	g,
		pid_t	pid,
		int	tid
	)

Definition at line 445 of file core.c.

                                                  {
    if (!g)
        return 0;
 
    /* TODO */
    tid = 1;
 
    nto_send_init(g, DStMsg_select, DSMSG_SELECT_SET, SET_CHANNEL_DEBUG);
    g->tran.pkt.select.pid = pid;
    g->tran.pkt.select.pid = EXTRACT_SIGNED_INTEGER(&g->tran.pkt.select.pid, 4);
    g->tran.pkt.select.tid = EXTRACT_SIGNED_INTEGER(&tid, 4);
    nto_send(g, sizeof(g->tran.pkt.select), 1);
 
    if (g->recv.pkt.hdr.cmd == DSrMsg_err) {
        eprintf("%s: failed to select %d\n", __func__, pid);
        return 0;
    }
 
    return 1;
}

References DSMSG_SELECT_SET, DSrMsg_err, DStMsg_select, eprintf, EXTRACT_SIGNED_INTEGER, g, nto_send(), nto_send_init(), pid, and SET_CHANNEL_DEBUG.

Referenced by rz_debug_qnx_select().

qnxr_set_architecture()

int qnxr_set_architecture	(	libqnxr_t *	g,
		ut8	architecture
	)

Definition at line 121 of file core.c.

                                                          {
    if (!g)
        return -1;
    g->architecture = architecture;
    switch (architecture) {
    case ARCH_X86_32:
        g->registers = x86_32;
        break;
    case ARCH_ARM_32:
        g->registers = arm32;
        break;
    default:
        eprintf("Error unknown architecture set\n");
    }
    return 0;
}

References ARCH_ARM_32, ARCH_X86_32, arm32, eprintf, g, and x86_32.

Referenced by rz_debug_qnx_attach().

qnxr_set_bp()

int qnxr_set_bp	(	libqnxr_t *	g,
		ut64	address,
		const char *	conditions
	)

Definition at line 599 of file core.c.

                                                                    {
    return _qnxr_set_bp(g, address, conditions, BREAKPOINT);
}

References _qnxr_set_bp(), BREAKPOINT, conditions, and g.

Referenced by rz_debug_qnx_breakpoint().

qnxr_set_hwbp()

int qnxr_set_hwbp	(	libqnxr_t *	g,
		ut64	address,
		const char *	conditions
	)

Definition at line 603 of file core.c.

                                                                      {
    return _qnxr_set_bp(g, address, conditions, HARDWARE_BREAKPOINT);
}

References _qnxr_set_bp(), conditions, g, and HARDWARE_BREAKPOINT.

Referenced by rz_debug_qnx_breakpoint().

qnxr_step()

int qnxr_step	(	libqnxr_t *	g,
		int	thread_id
	)

Definition at line 466 of file core.c.

                                           {
    return qnxr_send_vcont(g, 1, thread_id);
}

References g, and qnxr_send_vcont().

Referenced by rz_debug_qnx_step().

qnxr_stop()

int qnxr_stop

(

libqnxr_t *

g

)

Definition at line 528 of file core.c.

                            {
    if (!g)
        return 0;
 
    eprintf("%s: waiting for stop\n", __func__);
    g->waiting_for_stop = 1;
    nto_send_init(g, DStMsg_stop, DSMSG_STOP_PIDS, SET_CHANNEL_DEBUG);
 
    g->send_len = sizeof(g->tran.pkt.stop);
    qnxr_send_packet(g);
 
    return 1;
}

References DSMSG_STOP_PIDS, DStMsg_stop, eprintf, g, nto_send_init(), qnxr_send_packet(), and SET_CHANNEL_DEBUG.

Referenced by rz_debug_qnx_stop().

qnxr_wait()

ptid_t qnxr_wait	(	libqnxr_t *	g,
		pid_t	pid
	)

Definition at line 542 of file core.c.

                                          {
    if (!g || pid < 0) {
        return null_ptid;
    }
    ptid_t returned_ptid = g->inferior_ptid;
    if (g->inferior_ptid.pid != pid) {
        return null_ptid;
    }
    if (g->recv.pkt.hdr.cmd != DShMsg_notify) {
        int rlen;
        char waiting_for_notify = 1;
 
        eprintf("%s: waiting for inferior\n", __func__);
 
        while (1) {
            rlen = qnxr_read_packet(g);
            if (rlen == -1) {
                if (g->waiting_for_stop) {
                    eprintf("%s: read eror while waiting for stop\n",
                        __func__);
                    continue;
                } else {
                    eprintf("%s: read packet error or NAK\n", __func__);
                    return null_ptid;
                }
            }
            if (g->channelrd == SET_CHANNEL_TEXT) {
                // TODO nto_incoming_text
            } else {
                g->recv.pkt.hdr.cmd &= ~DSHDR_MSG_BIG_ENDIAN;
                if (g->waiting_for_stop && g->recv.pkt.hdr.cmd == DSrMsg_ok) {
                    g->waiting_for_stop = 0;
                    eprintf("%s: got stop response\n", __func__);
                    if (!waiting_for_notify)
                        break;
                } else if (g->recv.pkt.hdr.cmd == DShMsg_notify) {
                    // acknowledge the notify
                    g->tran.pkt.hdr.cmd = DSrMsg_ok;
                    g->tran.pkt.hdr.channel = SET_CHANNEL_DEBUG;
                    g->tran.pkt.hdr.mid = g->recv.pkt.hdr.mid;
                    qnxr_send_ch_debug(g);
 
                    g->send_len = sizeof(g->tran.pkt.ok);
                    qnxr_send_packet(g);
 
                    returned_ptid = nto_parse_notify(g);
                    break;
                }
            }
        }
    }
 
    /* to make us wait the next time */
    g->recv.pkt.hdr.cmd = DSrMsg_ok;
    return returned_ptid;
}

References DSHDR_MSG_BIG_ENDIAN, DShMsg_notify, DSrMsg_ok, eprintf, g, nto_parse_notify(), null_ptid, pid, qnxr_read_packet(), qnxr_send_ch_debug(), qnxr_send_packet(), SET_CHANNEL_DEBUG, and SET_CHANNEL_TEXT.

Referenced by rz_debug_qnx_wait().

qnxr_write_memory()

int qnxr_write_memory	(	libqnxr_t *	g,
		ut64	address,
		const ut8 *	data,
		ut64	len
	)

Definition at line 395 of file core.c.

                                                                             {
    ut64 addr;
 
    if (!g || !data)
        return -1;
 
    nto_send_init(g, DStMsg_memwr, 0, SET_CHANNEL_DEBUG);
    addr = address;
    g->tran.pkt.memwr.addr = EXTRACT_UNSIGNED_INTEGER(&addr, 8);
    memcpy(g->tran.pkt.memwr.data, data, len);
    nto_send(g, offsetof(DStMsg_memwr_t, data) + len, 0);
 
    switch (g->recv.pkt.hdr.cmd) {
    case DSrMsg_ok:
        return len;
    case DSrMsg_okstatus:
        return EXTRACT_SIGNED_INTEGER(&g->recv.pkt.okstatus.status, 4);
    }
 
    return 0;
}

References addr, DSrMsg_ok, DSrMsg_okstatus, DStMsg_memwr, EXTRACT_SIGNED_INTEGER, EXTRACT_UNSIGNED_INTEGER, g, len, memcpy(), nto_send(), nto_send_init(), offsetof, SET_CHANNEL_DEBUG, and ut64().

Referenced by debug_qnx_write_at().

qnxr_write_reg()

int qnxr_write_reg	(	libqnxr_t *	g,
		const char *	name,
		char *	value,
		int	len
	)

Definition at line 496 of file core.c.

                                                                         {
    int i = 0;
 
    if (!g)
        return -1;
 
    while (g->registers[i].size > 0) {
        if (!strcmp(g->registers[i].name, name)) {
            break;
        }
        i++;
    }
    if (g->registers[i].size == 0) {
        eprintf("Error registername <%s> not found in profile\n", name);
        return -1;
    }
    qnxr_write_register(g, i, value, len);
 
    return 0;
}

References eprintf, g, i, len, qnxr_write_register(), and value.

Referenced by rz_debug_qnx_reg_write().

qnxr_write_register()

int qnxr_write_register	(	libqnxr_t *	g,
		int	index,
		char *	value,
		int	len
	)

Definition at line 474 of file core.c.

                                                                       {
    int tdep_len, regset;
    ut32 off;
 
    if (!g)
        return -1;
 
    regset = i386nto_regset_id(index);
    tdep_len = i386nto_register_area(index, regset, &off);
    if (len < 0 || tdep_len != len) {
        eprintf("%s: invalid length\n", __func__);
        return -1;
    }
 
    nto_send_init(g, DStMsg_regwr, regset, SET_CHANNEL_DEBUG);
    g->tran.pkt.regwr.offset = EXTRACT_SIGNED_INTEGER(&off, 2);
    memcpy(g->tran.pkt.regwr.data, value, len);
    nto_send(g, offsetof(DStMsg_regwr_t, data) + len, 1);
 
    return 0;
}

References DStMsg_regwr, eprintf, EXTRACT_SIGNED_INTEGER, g, i386nto_register_area(), i386nto_regset_id(), len, memcpy(), nto_send(), nto_send_init(), off, offsetof, SET_CHANNEL_DEBUG, and value.

Referenced by qnxr_write_reg().

Variable Documentation

null_ptid

ptid_t null_ptid

extern

Definition at line 18 of file core.c.

Referenced by qnxr_attach(), qnxr_disconnect(), qnxr_run(), qnxr_wait(), and rz_debug_qnx_wait().