#define _POSIX_C_SOURCE 200809L

#include <errno.h>
#include <poll.h>
#include <sched.h>
#include <signal.h>
#include <sys/ioctl.h>
#include <sys/socket.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

#include "test.h"

#undef waitpid

enum
{
	Childtimeout = 2000,
};

typedef struct Childres Childres;
struct Childres
{
	int rc;
	unsigned int want;
	unsigned int mod;
	unsigned int key;
};

static long long
nowms(void)
{
	struct timespec ts;

	if(clock_gettime(CLOCK_MONOTONIC, &ts) < 0)
		return -1;
	return (long long)ts.tv_sec * 1000 + ts.tv_nsec / 1000000;
}

static int
waitreadable(int fd, int timeout)
{
	struct pollfd pfd;
	long long end, now;
	int n, left;

	end = nowms() + timeout;
	pfd.fd = fd;
	pfd.events = POLLIN;
	for(;;){
		now = nowms();
		if(now < 0 || now >= end)
			return -1;
		left = end - now;
		n = poll(&pfd, 1, left);
		if(n > 0)
			return (pfd.revents & (POLLIN|POLLHUP)) != 0 ? 0 : -1;
		if(n == 0)
			return -1;
		if(errno != EINTR)
			return -1;
	}
}

static int
readdeadline(int fd, void *buf, size_t n, int timeout)
{
	unsigned char *p;
	long long end, now;
	ssize_t got;

	p = buf;
	end = nowms() + timeout;
	while(n > 0){
		now = nowms();
		if(now < 0 || now >= end || waitreadable(fd, end - now) < 0)
			return -1;
		got = read(fd, p, n);
		if(got < 0 && errno == EINTR)
			continue;
		if(got <= 0)
			return -1;
		p += got;
		n -= got;
	}
	return 0;
}

static int
waitqueueempty(int fd, int timeout)
{
	long long end;
	int n;

	end = nowms() + timeout;
	for(;;){
		if(ioctl(fd, FIONREAD, &n) < 0)
			return -1;
		if(n == 0)
			return 0;
		if(nowms() >= end)
			return -1;
		sched_yield();
	}
}

static int
reapchild(pid_t pid, int *status, int timeout)
{
	long long end;
	pid_t got;

	end = nowms() + timeout;
	for(;;){
		got = waitpid(pid, status, WNOHANG);
		if(got == pid)
			return 0;
		if(got < 0 && errno != EINTR)
			return -1;
		if(nowms() >= end)
			break;
		poll(nil, 0, 1);
	}
	if(kill(pid, SIGKILL) < 0 && errno != ESRCH)
		return -1;
	end = nowms() + timeout;
	for(;;){
		got = waitpid(pid, status, WNOHANG);
		if(got == pid)
			return 0;
		if(got < 0 && errno != EINTR)
			return -1;
		if(nowms() >= end)
			return -1;
		poll(nil, 0, 1);
	}
}

void
ipc_request_codec(struct ct *t)
{
	static const struct {
		int want;
		unsigned int mod, key;
		unsigned char bytes[Ipcreqsz];
	} cases[] = {
		{ 0, 0, 0, { 0, 0, 0, 0, 0, 0 } },
		{ 1, Mctrl|Mshift, 0x1234,
			{ 1, Mctrl|Mshift, 0x34, 0x12, 0, 0 } },
		{ 1, Malt, 0x1f600,
			{ 1, Malt, 0x00, 0xf6, 0x01, 0x00 } },
		{ 1, 0, 0xf008,
			{ 1, 0, 0x08, 0xf0, 0x00, 0x00 } },
		{ 1, 0, Kback,
			{ 1, 0, 0x08, 0x00, 0x11, 0x00 } },
		{ 1, Msuper, 0x89abcdefU,
			{ 1, Msuper, 0xef, 0xcd, 0xab, 0x89 } },
	};
	unsigned char got[Ipcreqsz];
	unsigned int mod, key;
	int i, want;

	for(i = 0; i < nelem(cases); i++){
		ipcpackreq(got, cases[i].want, cases[i].mod, cases[i].key);
		if(!CT_EQ_MEM(t, cases[i].bytes, got, sizeof got))
			continue;
		ipcunpackreq(got, &want, &mod, &key);
		CT_EQ_INT(t, cases[i].want != 0, want);
		CT_EQ_UINT(t, cases[i].mod, mod);
		CT_EQ_UINT(t, cases[i].key, key);
	}
}

void
ipc_response_pack_boundaries(struct ct *t)
{
	static const unsigned char want[] = { 1, 1, 0, 'A', 2, 0, 'x', 'y' };
	static const unsigned char want0[] = { 1, 1, 0, 'A' };
	unsigned char out[Ipcmaxresp+1], field[Ipcfieldmax];
	int n;

	n = ipcpackresp(out, sizeof out, 7, "A", 1, "xy", 2, 1);
	CT_EQ_INT(t, sizeof want, n);
	CT_EQ_MEM(t, want, out, sizeof want);
	n = ipcpackresp(out, sizeof out, 1, "A", 1, "xy", 2, 0);
	CT_EQ_INT(t, sizeof want0, n);
	CT_EQ_MEM(t, want0, out, sizeof want0);

	memset(field, 'x', sizeof field);
	memset(out, 0xa5, sizeof out);
	n = ipcpackresp(out, Ipcmaxresp, 1,
		(char*)field, sizeof field, (char*)field, sizeof field, 1);
	CT_EQ_INT(t, Ipcmaxresp, n);
	CT_EQ_INT(t, 0, out[1]);
	CT_EQ_INT(t, 1, out[2]);
	CT_EQ_INT(t, 0, out[3+Ipcfieldmax]);
	CT_EQ_INT(t, 1, out[4+Ipcfieldmax]);
	CT_EQ_INT(t, 0xa5, out[Ipcmaxresp]);
	CT_EQ_INT(t, 'x', out[Ipcmaxresp-1]);

	memset(out, 0xa5, sizeof out);
	CT_EQ_INT(t, -1, ipcpackresp(out, Ipcmaxresp-1, 1,
		(char*)field, sizeof field, (char*)field, sizeof field, 1));
	CT_EQ_INT(t, 0xa5, out[0]);
	CT_EQ_INT(t, -1, ipcpackresp(out, sizeof out, 0,
		nil, 1, nil, 0, 0));
	CT_EQ_INT(t, -1, ipcpackresp(out, sizeof out, 0,
		nil, 0, nil, 1, 1));
	CT_EQ_INT(t, -1, ipcpackresp(out, sizeof out, 0,
		(char*)field, Ipcfieldmax+1, nil, 0, 0));
}

void
ipc_response_codec_and_drain(struct ct *t)
{
	unsigned char first[Ipcmaxresp];
	static const unsigned char second[] = { 0, 2, 0, 'o', 'k' };
	unsigned char field[Ipcfieldmax];
	char commit[8], preedit[8];
	Ipcresp resp;
	int fd[2], n;

	memset(field, 'x', sizeof field);
	n = ipcpackresp(first, sizeof first, 1,
		(char*)field, sizeof field, (char*)field, sizeof field, 1);
	if(!CT_EQ_INT(t, Ipcmaxresp, n))
		return;
	if(socketpair(AF_UNIX, SOCK_STREAM, 0, fd) < 0){
		CT_ERRORF(t, "socketpair failed");
		return;
	}
	if(!CT_EQ_INT(t, 0, ipcsend(fd[0], first, n)))
		goto cleanup;
	if(!CT_EQ_INT(t, 0, ipcsend(fd[0], second, sizeof second)))
		goto cleanup;
	if(!CT_EQ_INT(t, 0, shutdown(fd[0], SHUT_WR)))
		goto cleanup;
	if(!CT_EQ_INT(t, 0,
		ipcreadresp(fd[1], 1, commit, sizeof commit,
			preedit, sizeof preedit, &resp)))
		goto cleanup;
	CT_EQ_INT(t, 1, resp.eaten);
	CT_EQ_SIZE(t, Ipcfieldmax, resp.ncommit);
	CT_EQ_SIZE(t, Ipcfieldmax, resp.npreedit);
	CT_EQ_STR(t, "xxxxxxx", commit);
	CT_EQ_STR(t, "xxxxxxx", preedit);
	if(!CT_EQ_INT(t, 0,
		ipcreadresp(fd[1], 0, commit, sizeof commit,
			preedit, sizeof preedit, &resp)))
		goto cleanup;
	CT_EQ_INT(t, 0, resp.eaten);
	CT_EQ_STR(t, "ok", commit);
	CT_EQ_STR(t, "", preedit);
cleanup:
	close(fd[0]);
	close(fd[1]);
}

void
ipc_truncated_frame(struct ct *t)
{
	unsigned char b = 1, req[Ipcreqsz];
	int fd[2];

	if(pipe(fd) < 0){
		CT_ERRORF(t, "pipe failed");
		return;
	}
	if(!CT_EQ_INT(t, 1, write(fd[1], &b, 1))){
		close(fd[0]);
		close(fd[1]);
		return;
	}
	close(fd[1]);
	CT_EQ_INT(t, -1, ipcreadn(fd[0], req, sizeof req));
	close(fd[0]);
}

void
ipc_fragmented_request(struct ct *t)
{
	unsigned char req[Ipcreqsz];
	Childres res;
	Keyreq got;
	pid_t pid;
	int data[2], result[2], status;

	pid = -1;
	data[0] = data[1] = result[0] = result[1] = -1;
	ipcpackreq(req, 1, Mctrl|Mshift, 0x1f600);
	if(socketpair(AF_UNIX, SOCK_STREAM, 0, data) < 0){
		CT_ERRORF(t, "data socketpair failed");
		return;
	}
	if(socketpair(AF_UNIX, SOCK_STREAM, 0, result) < 0){
		CT_ERRORF(t, "result socketpair failed");
		goto cleanup;
	}
	pid = fork();
	if(pid < 0){
		CT_ERRORF(t, "fork failed");
		goto cleanup;
	}
	if(pid == 0){
		close(data[0]);
		close(result[0]);
		memset(&res, 0, sizeof res);
		res.rc = srvreadkey(data[1], &got);
		if(res.rc == 0){
			res.want = got.want;
			res.mod = got.mod;
			res.key = got.ks;
		}
		_exit(ipcsend(result[1], &res, sizeof res) < 0 ? 1 : 0);
	}
	close(result[1]);
	result[1] = -1;
	if(ipcsend(data[0], req, Ipcreqsz/2) < 0){
		CT_ERRORF(t, "first request fragment failed");
		goto cleanup;
	}
	if(waitqueueempty(data[1], Childtimeout) < 0){
		CT_ERRORF(t, "child did not consume first request fragment");
		goto cleanup;
	}
	if(ipcsend(data[0], req+Ipcreqsz/2, Ipcreqsz-Ipcreqsz/2) < 0){
		CT_ERRORF(t, "second request fragment failed");
		goto cleanup;
	}
	if(readdeadline(result[0], &res, sizeof res, Childtimeout) < 0){
		CT_ERRORF(t, "timed out waiting for decoded request");
		goto cleanup;
	}
	CT_EQ_INT(t, 0, res.rc);
	CT_EQ_INT(t, 1, res.want);
	CT_EQ_UINT(t, Mctrl|Mshift, res.mod);
	CT_EQ_UINT(t, 0x1f600, res.key);
cleanup:
	if(data[0] >= 0)
		close(data[0]);
	if(data[1] >= 0)
		close(data[1]);
	if(result[0] >= 0)
		close(result[0]);
	if(result[1] >= 0)
		close(result[1]);
	if(pid > 0){
		if(reapchild(pid, &status, Childtimeout) < 0)
			CT_ERRORF(t, "could not reap request reader");
		else if(!WIFEXITED(status) || WEXITSTATUS(status) != 0)
			CT_ERRORF(t, "request reader failed");
	}
}

void
ipc_closed_peer(struct ct *t)
{
	unsigned char b;
	pid_t pid;
	int data[2], syncfd[2], status;

	pid = -1;
	data[0] = data[1] = syncfd[0] = syncfd[1] = -1;
	if(socketpair(AF_UNIX, SOCK_STREAM, 0, data) < 0){
		CT_ERRORF(t, "data socketpair failed");
		return;
	}
	if(socketpair(AF_UNIX, SOCK_STREAM, 0, syncfd) < 0){
		CT_ERRORF(t, "synchronization socketpair failed");
		goto cleanup;
	}
	pid = fork();
	if(pid < 0){
		CT_ERRORF(t, "fork failed");
		goto cleanup;
	}
	if(pid == 0){
		signal(SIGPIPE, SIG_DFL);
		close(data[1]);
		close(syncfd[0]);
		if(ipcsend(syncfd[1], "r", 1) < 0 ||
		   readdeadline(syncfd[1], &b, 1, Childtimeout) < 0)
			_exit(2);
		_exit(ipcsend(data[0], "x", 1) < 0 ? 0 : 1);
	}
	close(data[0]);
	data[0] = -1;
	close(data[1]);
	data[1] = -1;
	close(syncfd[1]);
	syncfd[1] = -1;
	if(readdeadline(syncfd[0], &b, 1, Childtimeout) < 0 ||
	   ipcsend(syncfd[0], "g", 1) < 0)
		CT_ERRORF(t, "child synchronization failed");
cleanup:
	if(data[0] >= 0)
		close(data[0]);
	if(data[1] >= 0)
		close(data[1]);
	if(syncfd[0] >= 0)
		close(syncfd[0]);
	if(syncfd[1] >= 0)
		close(syncfd[1]);
	if(pid > 0){
		if(reapchild(pid, &status, Childtimeout) < 0)
			CT_ERRORF(t, "could not reap closed-peer writer");
		else if(!WIFEXITED(status) || WEXITSTATUS(status) != 0)
			CT_ERRORF(t, "write to closed peer did not return -1");
	}
}