#include <errno.h>
#include <stdio.h>
#include <stdlib.h>
#include <stddef.h>
#include <string.h>
#include <sys/ptrace.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <unistd.h>
#include <limits.h>

#ifdef __GLIBC__
/* glibc */
#include <sys/user.h>
#else
/* bionic/android */
#include <asm/user.h>
#endif

#define PID_INVALID ((pid_t)-1)

#define TRY(e) do { if((e)==-1) { fprintf(stderr, "Error:%s:%s\n", #e, strerror(errno)); exit(EXIT_FAILURE); } } while(0)

#if defined(__x86_64__)
typedef struct user_regs_struct pt_regs_t;
static void print_regs(FILE *out, const pt_regs_t *regs, const char *prefix_str) {
	const struct {
		const char *n;
		ptrdiff_t o;
	} r[] = {
		{ "rax", offsetof(pt_regs_t, rax), },
		{ "rbx", offsetof(pt_regs_t, rbx), },
		{ "rcx", offsetof(pt_regs_t, rcx), },
		{ "rdx", offsetof(pt_regs_t, rdx), },
		{ "rsi", offsetof(pt_regs_t, rsi), },
		{ "rdi", offsetof(pt_regs_t, rdi), },
		{ "rbp", offsetof(pt_regs_t, rbp), },
		{ "rsp", offsetof(pt_regs_t, rsp), },
		{ "r8", offsetof(pt_regs_t, r8), },
		{ "r9", offsetof(pt_regs_t, r9), },
		{ "r10", offsetof(pt_regs_t, r10), },
		{ "r11", offsetof(pt_regs_t, r11), },
		{ "r12", offsetof(pt_regs_t, r12), },
		{ "r13", offsetof(pt_regs_t, r13), },
		{ "r14", offsetof(pt_regs_t, r14), },
		{ "r15", offsetof(pt_regs_t, r15), },
		{ "rip", offsetof(pt_regs_t, rip), },
		{ "eflags", offsetof(pt_regs_t, eflags), },
		{ "cs", offsetof(pt_regs_t, cs), },
		{ "ss", offsetof(pt_regs_t, ss), },
		{ "ds", offsetof(pt_regs_t, ds), },
		{ "es", offsetof(pt_regs_t, es), },
		{ "fs", offsetof(pt_regs_t, fs), },
		{ "gs", offsetof(pt_regs_t, gs), },
	};
	unsigned i;

	if(!prefix_str) prefix_str="";

	for(i=0;i<sizeof r/sizeof *r;i++) {
		if(i%2==0) fputs(prefix_str, out);
		fprintf(out, "%6s: 0x%016lx", r[i].n, *(unsigned long*)((char*)regs+r[i].o));
		if(i%2!=0) fputc('\n', out); else fputc('\t', out);
	}
	if(i%2!=0) fputc('\n', out);
}
#elif defined(__i386__)
typedef struct user_regs_struct pt_regs_t;
static void print_regs(FILE *out, const pt_regs_t *regs, const char *prefix_str) {
	const struct {
		const char *n;
		ptrdiff_t o;
	} r[] = {
		{ "ebx", offsetof(pt_regs_t, ebx), },
		{ "ecx", offsetof(pt_regs_t, ecx), },
		{ "edx", offsetof(pt_regs_t, edx), },
		{ "esi", offsetof(pt_regs_t, esi), },
		{ "edi", offsetof(pt_regs_t, edi), },
		{ "ebp", offsetof(pt_regs_t, ebp), },
		{ "eax", offsetof(pt_regs_t, eax), },
		{ "xds", offsetof(pt_regs_t, xds), },
		{ "xes", offsetof(pt_regs_t, xes), },
		{ "xfs", offsetof(pt_regs_t, xfs), },
		{ "xgs", offsetof(pt_regs_t, xgs), },
		{ "orig_eax", offsetof(pt_regs_t, orig_eax), },
		{ "eip", offsetof(pt_regs_t, eip), },
		{ "xcs", offsetof(pt_regs_t, xcs), },
		{ "eflags", offsetof(pt_regs_t, eflags), },
		{ "esp", offsetof(pt_regs_t, esp), },
		{ "xss", offsetof(pt_regs_t, xss), },
	};
	unsigned i;

	if(!prefix_str) prefix_str="";

	for(i=0;i<sizeof r/sizeof *r;i++) {
		if(i%2==0) fputs(prefix_str, out);
		fprintf(out, "%8s: 0x%08x", r[i].n, *(unsigned*)((char*)regs+r[i].o));
		if(i%2!=0) fputc('\n', out); else fputc('\t', out);
	}
	if(i%2!=0) fputc('\n', out);
}
#elif defined(__arm__)
typedef struct pt_regs pt_regs_t;
static void print_regs(FILE *out, const pt_regs_t *regs, const char *prefix_str) {
	const struct {
		const char *n;
		ptrdiff_t o;
	} r[] = {
		{ "cpsr", offsetof(pt_regs_t, ARM_cpsr), },
		{ "pc", offsetof(pt_regs_t, ARM_pc), },
		{ "lr", offsetof(pt_regs_t, ARM_lr), },
		{ "sp", offsetof(pt_regs_t, ARM_sp), },
		{ "ip", offsetof(pt_regs_t, ARM_ip), },
		{ "fp", offsetof(pt_regs_t, ARM_fp), },
		{ "r10", offsetof(pt_regs_t, ARM_r10), },
		{ "r9", offsetof(pt_regs_t, ARM_r9), },
		{ "r8", offsetof(pt_regs_t, ARM_r8), },
		{ "r7", offsetof(pt_regs_t, ARM_r7), },
		{ "r6", offsetof(pt_regs_t, ARM_r6), },
		{ "r5", offsetof(pt_regs_t, ARM_r5), },
		{ "r4", offsetof(pt_regs_t, ARM_r4), },
		{ "r3", offsetof(pt_regs_t, ARM_r3), },
		{ "r2", offsetof(pt_regs_t, ARM_r2), },
		{ "r1", offsetof(pt_regs_t, ARM_r1), },
		{ "r0", offsetof(pt_regs_t, ARM_r0), },
		{ "ORIG_r0", offsetof(pt_regs_t, ARM_ORIG_r0), },
	};
	unsigned i;

	if(!prefix_str) prefix_str="";

	for(i=0;i<sizeof r/sizeof *r;i++) {
		if(i%2==0) fputs(prefix_str, out);
		fprintf(out, "%8s: 0x%08x", r[i].n, *(unsigned*)((char*)regs+r[i].o));
		if(i%2!=0) fputc('\n', out); else fputc('\t', out);
	}
	if(i%2!=0) fputc('\n', out);
}
#else
#error Unknown architecture.
#endif

static void dumpprogname(FILE *out, pid_t progpid) {
	char procpath[PATH_MAX], linkpath[PATH_MAX];
	char cmdline[80];
	FILE *f;
	size_t len;

	snprintf(procpath, sizeof procpath, "/proc/%lu/exe", (long)progpid);
	if((len=readlink(procpath, linkpath, sizeof linkpath-1))>0) {
		linkpath[len]=0;
		fprintf(out, "exe: \"%s\"\n", linkpath);
	}

	snprintf(procpath, sizeof procpath, "/proc/%lu/cmdline", (long)progpid);
	f=fopen(procpath, "rb");
	len=fread(cmdline, 1, sizeof cmdline-1, f);
	if(ferror(f)) {
		perror(procpath);
		fclose(f);
		exit(EXIT_FAILURE);
	}
	fclose(f);
	cmdline[len]=0;
	fprintf(out, "argv[0]: \"%s\"\n", cmdline);
}

static void dumpregs(FILE *out, pid_t progpid) {
	int status;
	pt_regs_t regs;

	if(progpid==getpid()) {
		fprintf(stderr, "Error:Cannot dump myself!\n");
		exit(EXIT_FAILURE);
	}

	TRY(ptrace(PTRACE_ATTACH, progpid, NULL, NULL));

	TRY(waitpid(progpid, &status, 0));

	TRY(ptrace(PTRACE_GETREGS, progpid, NULL, &regs));
	print_regs(out, &regs, "\t");

	TRY(ptrace(PTRACE_DETACH, progpid, NULL, NULL));
}

int main(int argc, char **argv) {
	pid_t progpid=PID_INVALID;
	int dumpprogname_fl=1;
	int c;
	FILE *out=stdout;

	while((c=getopt(argc, argv, "hp:r"))>0) switch(c) {
		case 'r': /* dump regs only */
			dumpprogname_fl=0;
			break;
		case 'p': progpid=strtol(optarg, 0, 10); break;
		default:
		usage: case 'h': {
			const char *progname;
			progname=strrchr(argv[0], '/');
			if(!progname) progname=argv[0];
			fprintf(stderr, "usage: %s [-h] [-p <pid>]\n", progname);
			fprintf(stderr, "  -h        Help.\n");
			fprintf(stderr, "  -p <p>    Process to dump.\n");
			fprintf(stderr, "  -r        Print only register dump.\n");
			return EXIT_FAILURE;
		}
	}

	if(progpid==PID_INVALID) goto usage;
	fprintf(out, "pid: %ld\n", (long)progpid);
	if(dumpprogname_fl) dumpprogname(out, progpid);
	dumpregs(out, progpid);

	return 0;
}