// SPDX-FileCopyrightText: 2010-2020 pancake <pancake@nopcode.org>
// SPDX-License-Identifier: LGPL-3.0-only

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

#include "rz_io_plugins.h"

#define RZ_GDB_MAGIC rz_str_djb2_hash("gdb")

#define MIN_DOWNLOAD_CHUNK 64
#define MAX_DOWNLOAD_CHUNK 65536

static int __close(RzIODesc *fd);

static bool __plugin_open(RzIO *io, const char *file, bool many) {
	return (!strncmp(file, "gdb://", 6));
}

static int debug_gdb_read_at(RzIODesc *fd, ut8 *buf, int sz, ut64 addr) {
	if (sz < 1 || addr >= UT64_MAX || !fd || !fd->data) {
		return -1;
	}
	libgdbr_t *desc = fd->data;
	return gdbr_read_memory(desc, addr, buf, sz);
}

static int debug_gdb_write_at(RzIODesc *fd, const ut8 *buf, int sz, ut64 addr) {
	ut32 x, size_max;
	ut32 packets;
	ut32 last;
	if (sz < 1 || addr >= UT64_MAX || !fd || !fd->data) {
		return -1;
	}
	libgdbr_t *desc = fd->data;
	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;
}

static RzIODesc *__open(RzIO *io, const char *file, int rw, int mode) {
	RzIODesc *riogdb = NULL;
	libgdbr_t *desc = NULL;
	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);
	}

	desc = RZ_NEW(libgdbr_t);
	gdbr_init(desc, false);

	if (gdbr_connect(desc, host, i_port) == 0) {
		__close(NULL);
		// RZ_FREE (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, desc);
	}
	// Get name
	if (riogdb) {
		riogdb->name = gdbr_exec_file_read(desc, i_pid);
	} else {
		eprintf("gdb.io.open: Cannot connect to host.\n");
		gdbr_disconnect(desc);
		gdbr_cleanup(desc);
		RZ_FREE(desc);
	}
	return riogdb;
}

static int __write(RzIO *io, RzIODesc *fd, const ut8 *buf, size_t count) {
	ut64 addr = io->off;
	if (!fd || !fd->data) {
		return -1;
	}
	libgdbr_t *desc = fd->data;
	if (!desc->data) {
		return -1;
	}
	return debug_gdb_write_at(fd, buf, count, addr);
}

static ut64 __lseek(RzIO *io, RzIODesc *fd, ut64 offset, int whence) {
	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;
}

static int __read(RzIO *io, RzIODesc *fd, ut8 *buf, size_t count) {
	if (!io || !fd || !buf || count < 1) {
		return -1;
	}
	libgdbr_t *desc = fd->data;
	memset(buf, 0xff, count);
	ut64 addr = io->off;
	if (!desc || !desc->data) {
		return -1;
	}
	return debug_gdb_read_at(fd, buf, count, addr);
}

static int __close(RzIODesc *fd) {
	if (!fd) {
		return 0;
	}
	libgdbr_t *desc = fd->data;
	gdbr_disconnect(desc);
	gdbr_cleanup(desc);
	RZ_FREE(desc);
	RZ_FREE(fd->name);
	return -1;
}

static int __getpid(RzIODesc *fd) {
	// XXX don't use globals
	libgdbr_t *desc = fd->data;
	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
}

static int __gettid(RzIODesc *fd) {
	libgdbr_t *desc = fd->data;
	return desc ? desc->tid : -1;
}

extern int send_msg(libgdbr_t *g, const char *command);
extern int read_packet(libgdbr_t *instance, bool vcont);

static bool gdbr_download_file(libgdbr_t *g, const char *remote, const char *local) {
	rz_return_val_if_fail(g && remote && local, false);
	// empty the destination file by writing nothing in non-append mode
	if (!rz_file_dump(local, NULL, 0, false)) {
		return false;
	}
	// open the remote file on the stub side
	if (gdbr_open_file(g, remote, O_RDONLY, 0) < 0) {
		return false;
	}

	uint32_t off = 0;
	bool ok = true;
	// clamp the download size between a reasonable MIN floor and MAX ceiling
	ut32 chunk = RZ_MAX(MIN_DOWNLOAD_CHUNK, g->stub_features.pkt_sz / 2);
	chunk = RZ_MIN(chunk, MAX_DOWNLOAD_CHUNK);
	ut8 *buf = malloc(chunk);
	if (!buf) {
		gdbr_close_file(g);
		return false;
	}

	int ret;
	do {
		ret = gdbr_pread_file(g, buf, chunk, off);
		if (ret < 0) {
			ok = false;
			break;
		}
		if (ret == 0) {
			break;
		}
		if (!rz_file_dump(local, buf, ret, true)) {
			ok = false;
			break;
		}
		off += ret;
	} while ((ut32)ret == chunk);
	free(buf);
	gdbr_close_file(g);
	return ok;
}

static bool io_gdb_download_file(RzIO *io, RzIODesc *fd, const char *remote, const char *local) {
	if (!fd || !fd->data) {
		return false;
	}
	return gdbr_download_file(fd->data, remote, local);
}

static char *__system(RzIO *io, RzIODesc *fd, const char *cmd) {
	if (!fd || !fd->data) {
		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"
			" R! download_file remote local - download remote file to local path\n");
		return NULL;
	}
	libgdbr_t *desc = fd->data;
	if (rz_str_startswith(cmd, "download_file")) {
		int argc = 0;
		char **argv = rz_str_argv(cmd, &argc);
		if (!argv || argc != 3) {
			rz_str_argv_free(argv);
			return rz_str_dup("0");
		}
		bool ok = gdbr_download_file(desc, argv[1], argv[2]);
		rz_str_argv_free(argv);
		return rz_str_dup(ok ? "1" : "0");
	}
	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;
}

RzIOPlugin rz_io_plugin_gdb = {
	// void *plugin;
	.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,
	.download_file = io_gdb_download_file,
	.isdbg = true
};

#ifndef RZ_PLUGIN_INCORE
RZ_API RzLibStruct rizin_plugin = {
	.type = RZ_LIB_TYPE_IO,
	.data = &rz_io_plugin_gdb,
	.version = RZ_VERSION
};
#endif
