#include <arpa/inet.h>
#include <assert.h>
#include <errno.h>
#include <fcntl.h>
#include <sched.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <sys/mount.h>
#include <sys/param.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/types.h>
#include <sys/wait.h>
#include <time.h>
#include <unistd.h>

#include <libmnl/libmnl.h>
#include <libnetfilter_conntrack/libnetfilter_conntrack.h>
#include <libnetfilter_conntrack/libnetfilter_conntrack_tcp.h>
#include "config.h"
#include "nssocket.h"

int fdpair[2];
#define PARENT_FD (fdpair[0])
#define CHILD_FD (fdpair[1])

pid_t child_pid;

void add_child(pid_t pid)
{
	/* XXX: check excess MAX_CHILD */
	children[nchild++] = pid;
}

static int get_unaligned_int(const void *s)
{
	int x;
	memcpy(&x, s, sizeof(x));
	return x;
}

static void put_unaligned_int(void *d, int x)
{
	memcpy(d, &x, sizeof(x));
}

/*
 * message exchange via socketpair using send/recv msg()
 *
 * - use cdata:
 *   cdata represents a file descriptor
 *   cmd[0] means -errno
 *
 * - without cdata:
 *   cmd[0] means:
 *   > 0:  command
 *   == 0: sync, echo
 *   < 0:  -errno
 *
 * it's an given fact that tx() and rx() never fail.
 */
ssize_t tx(int fd, int *cmd, uint8_t cmdlen, int cdata)
{
	struct msghdr msg;
	struct iovec iov[cmdlen];
	size_t cmsglen = CMSG_SPACE(sizeof(int));
	char control[CMSG_SPACE(sizeof(int))];
	struct cmsghdr *cmsg;
	int i;

	memset(&msg, 0, sizeof(struct msghdr));
	memset(iov, 0, sizeof(struct iovec) * cmdlen);

	msg.msg_iov = iov;
	msg.msg_iovlen = cmdlen;
	for (i = 0; i < cmdlen; i++) {
		iov[i].iov_len = sizeof(int);
		iov[i].iov_base = &cmd[i];
	}
	if (cdata) {
		msg.msg_control = control;
		msg.msg_controllen = cmsglen;
		cmsg = CMSG_FIRSTHDR(&msg);
		cmsg->cmsg_len = CMSG_LEN(sizeof(int));
		cmsg->cmsg_level = SOL_SOCKET;
		cmsg->cmsg_type = SCM_RIGHTS;
		put_unaligned_int(CMSG_DATA(cmsg), cdata);
	}

	return sendmsg(fd, &msg, 0);
}

ssize_t rx(int fd, int *cmd, uint8_t cmdlen, int *cdata)
{
	struct msghdr msg;
	struct iovec iov[cmdlen];
	size_t cmsglen = CMSG_SPACE(sizeof(int));
	char control[CMSG_SPACE(sizeof(int))];
	struct cmsghdr *cmsg;
	ssize_t ret;
	int i;

	memset(&msg, 0, sizeof(struct msghdr));
	memset(iov, 0, sizeof(struct iovec));

	msg.msg_iov = iov;
	msg.msg_iovlen = cmdlen;
	for (i = 0; i < cmdlen; i++) {
		iov[i].iov_len = sizeof(int);
		iov[i].iov_base = &cmd[i];
	}
	if (cdata != NULL) {
		msg.msg_control = control;
		msg.msg_controllen = cmsglen;
	}

	ret = recvmsg(fd, &msg, 0);
	if (ret == -1) {
		perror("recvmsg");
		return ret;
	}

	if (cdata == NULL)
		return ret;

	cmsg = CMSG_FIRSTHDR(&msg);
	if (cmsg == NULL || cmsg->cmsg_len != CMSG_LEN(sizeof(int))
	    || cmsg->cmsg_level != SOL_SOCKET
	    || cmsg->cmsg_type != SCM_RIGHTS) {
		errno = EBADMSG;
		return -1;
	}
	*cdata = get_unaligned_int(CMSG_DATA(cmsg));

	return ret;
}

int tx_cmd(int fd, int cmd)
{
	return tx(fd, &cmd, 1, 0);
}

int rx_cmd(int fd)
{
	int cmd;
	if (rx((fd), &cmd, 1, NULL) == -1)
		return -1;
	return cmd;
}

int tx_fd(int fd1, int fd2, int e)
{
	return tx(fd1, &e, 1, fd2);
}

int rx_fd(int fd1)
{
	int e, fd2;

	if (rx(fd1, &e, 1, &fd2) == -1)
		return -1;

	errno = -e;
	return fd2;
}

/*
 * copy from ip/ipnetns.c::iproute2
 */
#ifndef HAVE_SETNS
#include <sys/syscall.h>
static int setns(int fd, int nstype)
{
#ifdef __NR_setns
	return syscall(__NR_setns, fd, nstype);
#else
	errno = ENOSYS;
	return -1;
#endif
}
#endif /* HAVE_SETNS */

#define NETNS_RUN_DIR "/var/run/netns"
static int netns_setup(const char *name)
{
	/* Setup the proper environment for apps that are not netns
	 * aware, and execute a program in that environment.
	 */
	char net_path[MAXPATHLEN];
	int netns;

	snprintf(net_path, sizeof(net_path), "%s/%s", NETNS_RUN_DIR, name);
	netns = open(net_path, O_RDONLY | O_CLOEXEC);
	if (netns < 0) {
		fprintf(stderr, "Cannot open network namespace \"%s\": %s\n",
			name, strerror(errno));
		return -1;
	}

	if (setns(netns, CLONE_NEWNET) < 0) {
		fprintf(stderr, "setting the network namespace \"%s\" failed: %s\n",
			name, strerror(errno));
		return -1;
	}

	if (unshare(CLONE_NEWNS) < 0) {
		fprintf(stderr, "unshare failed: %s\n", strerror(errno));
		return -1;
	}
	/* Don't let any mounts propagate back to the parent */
	if (mount("", "/", "none", MS_SLAVE | MS_REC, NULL)) {
		fprintf(stderr, "\"mount --make-rslave /\" failed: %s\n",
			strerror(errno));
		return -1;
	}
	/* Mount a version of /sys that describes the network namespace */
	if (umount2("/sys", MNT_DETACH) < 0) {
		fprintf(stderr, "umount of /sys failed: %s\n", strerror(errno));
		return -1;
	}
	if (mount(name, "/sys", "sysfs", 0, NULL) < 0) {
		fprintf(stderr, "mount of /sys failed: %s\n",strerror(errno));
		return -1;
	}

	return 0;
}

static void child(const char *nsname)
{
	int cmd = CMD_SYNC;
	int params[3]; /* XXX: magic number, see enum CALL_ */
	int sockfd;

	if (netns_setup(nsname) == -1)
		child_exit("netns_setup", EXIT_FAILURE);

	/* sync with parent */
	if (tx_cmd(CHILD_FD, CMD_SYNC) == -1)
		child_exit("tx_cmd", EXIT_FAILURE);

	/* waiting cmd */
	while (1) {
		debug_ns("child waiting for cmd...\n");
		cmd = rx_cmd(CHILD_FD);
		switch (cmd) {
		case CMD_DONE:
			debug_ns("child received CMD_DONE - exiting\n");
			close(CHILD_FD);
			child_exit("receive CMD_DONE", EXIT_SUCCESS);
			break;
		case CMD_SOCKET:
			if (rx(CHILD_FD, params, 3, NULL) == -1)
				child_exit("rx", EXIT_FAILURE);
			debug_ns("child received CMD_SOCKET -"
				 " domain: %d, type: %d, protocol: %d\n",
				 params[0], params[1], params[2]);
			sockfd = socket(params[0], params[1], params[2]);
			if (tx_fd(CHILD_FD, sockfd, -errno) == -1)
				child_exit("tx_fd", EXIT_FAILURE);
			break;
		default:
			debug_ns("child received unknown cmd: %d\n", cmd);
			child_exit("receive unknown cmd", EXIT_FAILURE);
			break;
		}
	}
}

/*
 * kill all the other registered child by SIGKILL
 *
 * SIGCHLD will not be raised if child has killed in SIGABRT handler
 */
static void sigchld_handler(int signum)
{
	pid_t pid;
	int status, i, fail = 0;

	while ((pid = waitpid(-1, &status, WNOHANG)) > 0) {
		debug_ns("receive SIGCHLD - pid: %d\n", pid);
		if (WIFEXITED(status))
			fail |= WEXITSTATUS(status);
		else if (WIFSIGNALED(status) || WCOREDUMP(status))
			fail |= status;
		if (pid == child_pid)
			child_pid = 0;
		for (i = 0; i < nchild; i++)
			if (children[i] == pid)
				children[i] = 0;
			else
				kill(children[i], SIGKILL);
	}
	if (pid == -1 && errno != ECHILD)
		fail |= errno;

	/* overdoing? kill myself
	 * if (fail) kill(0, SIGKILL);
	 */
}

/*
 * core public API
 */
int init_nssocket(const char *nsname)
{
	pid_t pid;
	struct sigaction sa;

	if (socketpair(AF_UNIX, SOCK_STREAM, 0, fdpair) == -1)
		return -1;

	sigemptyset(&sa.sa_mask);
	sa.sa_handler = sigchld_handler;
	sa.sa_flags = SA_NOCLDSTOP;
	if (sigaction(SIGCHLD, &sa, NULL) == -1)
		return -1;

	fflush(stdout);
	pid = fork();
	switch (pid) {
	case -1:
		return -1;
		break;
	case 0:
		child(nsname); /* not return */
		break;
	default:
		child_pid = pid;
		add_child(pid);
		if (rx_cmd(PARENT_FD) < 0) {
			parent_fail("rx_cmd");
			return -1;
		}
		break;
	}

	return 0;
}

int fini_nssocket(void)
{
	int status;
	sigset_t block_mask;
	pid_t pid;

	sigemptyset(&block_mask);
	sigaddset(&block_mask, SIGCHLD);
	if (sigprocmask(SIG_SETMASK, &block_mask, NULL) == -1)
		return -1;
	tx_cmd(PARENT_FD, CMD_DONE);
	close(PARENT_FD);
	pid = waitpid(child_pid, &status, 0);
	child_pid = 0;
	if (pid < 0)
		return -1;
	if (WIFEXITED(status) && WEXITSTATUS(status) == 0)
		return 0;

	return status;
}

int nssocket(int domain, int type, int protocol)
{
	int cmd[] = {CMD_SOCKET, domain, type, protocol};

	if (child_pid == 0 || kill(child_pid, 0) == -1) {
		errno = ECHILD;
		return -1;
	}
	tx(PARENT_FD, cmd, 4, 0);
	return rx_fd(PARENT_FD);
}

/*
 * utils API
 */
int debug_nfct_cb(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct;
	uint32_t type = NFCT_T_UNKNOWN;
	char buf[4096];

	switch(nlh->nlmsg_type & 0xFF) {
	case IPCTNL_MSG_CT_NEW:
		if (nlh->nlmsg_flags & (NLM_F_CREATE|NLM_F_EXCL))
			type = NFCT_T_NEW;
		else
			type = NFCT_T_UPDATE;
		break;
	case IPCTNL_MSG_CT_DELETE:
		type = NFCT_T_DESTROY;
		break;
	}

	ct = nfct_new();
	if (ct == NULL)
		return MNL_CB_OK;

	nfct_nlmsg_parse(nlh, ct);
	nfct_snprintf(buf, sizeof(buf), ct, type, NFCT_O_DEFAULT, 0);
	debug("%s\n", buf);
	nfct_destroy(ct);

	return MNL_CB_OK;
}

struct mnl_socket *mnl_nssocket_open(int bus)
{
	int fd;
	struct mnl_socket *nl;

	fd = nssocket(AF_NETLINK, SOCK_RAW, bus);
	if (fd == -1)
		return NULL;

	nl = mnl_socket_fdopen(fd);
	if (nl == NULL) {
		close(fd);
		return NULL;
	}
	return nl;
}

/*
 * assert utilities
 */
struct nf_conntrack *author_new(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct;

	assert((nlh->nlmsg_type & 0xFF) == IPCTNL_MSG_CT_NEW);
	assert(nlh->nlmsg_flags == (NLM_F_CREATE | NLM_F_EXCL));
	ct = nfct_new();
	assert(ct != NULL);
	assert(nfct_nlmsg_parse((nlh), ct) == 0);
	assert_proto(ct, AF_INET, *(uint8_t *) data);
	assert_inaddr(ct, VETH_PARENT_ADDR, VETH_CHILD_ADDR);
	assert((nfct_get_attr_u32(ct, ATTR_STATUS) & IPS_SEEN_REPLY) == 0);
	timeout.tv_sec = nfct_get_attr_u32(ct, ATTR_TIMEOUT) + 1;

	return ct;
}

struct nf_conntrack *author_update(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct;

	assert((nlh->nlmsg_type & 0xFF) == IPCTNL_MSG_CT_NEW);
	assert(nlh->nlmsg_flags == 0);
	ct = nfct_new();
	assert(ct != NULL);
	assert(nfct_nlmsg_parse((nlh), ct) == 0);
	assert_proto(ct, AF_INET, *(uint8_t *) data);
	assert_inaddr(ct, VETH_PARENT_ADDR, VETH_CHILD_ADDR);
	assert((nfct_get_attr_u32(ct, ATTR_STATUS) & IPS_SEEN_REPLY));
	timeout.tv_sec = nfct_get_attr_u32(ct, ATTR_TIMEOUT) + 1;

	return ct;
}

struct nf_conntrack *author_destroy(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct;

	assert((nlh->nlmsg_type & 0xFF) == IPCTNL_MSG_CT_DELETE);
	assert(nlh->nlmsg_flags == 0);
	ct = nfct_new();
	assert(ct != NULL);
	assert(nfct_nlmsg_parse((nlh), ct) == 0);
	assert_proto(ct, AF_INET, *(uint8_t *) data);
	assert_inaddr(ct, VETH_PARENT_ADDR, VETH_CHILD_ADDR);
	assert((nfct_get_attr_u32(ct, ATTR_STATUS) & IPS_SEEN_REPLY));

	return ct;
}

void assert_proto(const struct nf_conntrack *ct,
		  uint8_t l3proto, uint8_t l4proto)
{
	assert(nfct_get_attr_u8(ct, ATTR_ORIG_L3PROTO) == l3proto);
	assert(nfct_get_attr_u8(ct, ATTR_REPL_L3PROTO) == l3proto);
	assert(nfct_get_attr_u8(ct, ATTR_ORIG_L4PROTO) == l4proto);
	assert(nfct_get_attr_u8(ct, ATTR_REPL_L4PROTO) == l4proto);
}

void assert_inaddr(const struct nf_conntrack *ct,
		   const char *src, const char *dst)
{
	struct in_addr addr;
	assert(inet_aton((src), &addr) != 0);
	assert(nfct_get_attr_u32((ct), ATTR_ORIG_IPV4_SRC) == addr.s_addr);
	assert(nfct_get_attr_u32((ct), ATTR_REPL_IPV4_DST) == addr.s_addr);
	assert(inet_aton((dst), &addr) != 0);
	assert(nfct_get_attr_u32((ct), ATTR_ORIG_IPV4_DST) == addr.s_addr);
	assert(nfct_get_attr_u32((ct), ATTR_REPL_IPV4_SRC) == addr.s_addr);
}

void assert_port(const struct nf_conntrack *ct,
		 uint16_t src, uint16_t dst)
{
	if ((src)) {
		assert(nfct_get_attr_u16((ct), ATTR_ORIG_PORT_SRC) == htons((src)));
		assert(nfct_get_attr_u16((ct), ATTR_REPL_PORT_DST) == htons((src)));
	}
	if ((dst)) {
		assert(nfct_get_attr_u16((ct), ATTR_ORIG_PORT_DST) == htons((dst)));
		assert(nfct_get_attr_u16((ct), ATTR_REPL_PORT_SRC) == htons((dst)));
	}
}

void assert_typecode(const struct nf_conntrack *ct,
		     uint8_t type, uint8_t code)
{
	assert(nfct_get_attr_u8((ct), ATTR_ICMP_TYPE) == type);
	assert(nfct_get_attr_u8((ct), ATTR_ICMP_CODE) == code);
}

int cb_icmp_new(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_new(nlh, data);
	assert_typecode(ct, ICMP_TYPE, ICMP_CODE);
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_icmp_update(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_update(nlh, data);
	assert_typecode(ct, ICMP_TYPE, ICMP_CODE);
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_icmp_destroy(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_destroy(nlh, data);
	assert_typecode(ct, ICMP_TYPE, ICMP_CODE);
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_udp_new(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_new(nlh, data);
	assert_port(ct, 0, DSTPORT);
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_udp_update(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_update(nlh, data);
	assert_port(ct, 0, DSTPORT);
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_udp_destroy(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_destroy(nlh, data);
	assert_port(ct, 0, DSTPORT);
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_tcp_new(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_new(nlh, data);
	assert_port(ct, 0, DSTPORT);
	assert(nfct_get_attr_u8(ct, ATTR_TCP_STATE) == TCP_CONNTRACK_SYN_SENT);
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_tcp_syn_recv(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_update(nlh, data);
	assert_port(ct, 0, DSTPORT);
	assert(nfct_get_attr_u8(ct, ATTR_TCP_STATE) == TCP_CONNTRACK_SYN_RECV);
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_tcp_established(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_update(nlh, data);
	assert_port(ct, 0, DSTPORT);
	assert(nfct_get_attr_u8(ct, ATTR_TCP_STATE) == TCP_CONNTRACK_ESTABLISHED);
	assert((nfct_get_attr_u32(ct, ATTR_STATUS) & IPS_ASSURED));
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_tcp_fin_wait(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_update(nlh, data);
	assert_port(ct, 0, DSTPORT);
	assert(nfct_get_attr_u8(ct, ATTR_TCP_STATE) == TCP_CONNTRACK_FIN_WAIT);
	assert((nfct_get_attr_u32(ct, ATTR_STATUS) & IPS_ASSURED));
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_tcp_close_wait(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_update(nlh, data);
	assert_port(ct, 0, DSTPORT);
	assert(nfct_get_attr_u8(ct, ATTR_TCP_STATE) == TCP_CONNTRACK_CLOSE_WAIT);
	assert((nfct_get_attr_u32(ct, ATTR_STATUS) & IPS_ASSURED));
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_tcp_close(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_update(nlh, data);
	assert_port(ct, 0, DSTPORT);
	assert(nfct_get_attr_u8(ct, ATTR_TCP_STATE) == TCP_CONNTRACK_CLOSE);
	assert((nfct_get_attr_u32(ct, ATTR_STATUS) & IPS_ASSURED));
	nfct_destroy(ct);
	return MNL_CB_OK;
}

int cb_tcp_destroy(const struct nlmsghdr *nlh, void *data)
{
	struct nf_conntrack *ct = author_destroy(nlh, data);
	assert_port(ct, 0, DSTPORT);
	assert(nfct_attr_is_set(ct, ATTR_TCP_STATE) == 0);
	assert((nfct_get_attr_u32(ct, ATTR_STATUS) & IPS_ASSURED));
	nfct_destroy(ct);
	return MNL_CB_OK;
}

void tcp_echo(const struct mnl_socket *nl,
	      const char *pre, const char *post)
{
	uint8_t proto = IPPROTO_TCP;

	sync_fifo(pre);
	timeout.tv_sec = INIT_TIMEOUT;
	handle_qacb(nl, true, cb_tcp_new, &proto);
	handle_qacb(nl, true, cb_tcp_syn_recv, &proto);
	handle_qacb(nl, true, cb_tcp_established, &proto);
	handle_qacb(nl, true, cb_tcp_fin_wait, &proto);
	handle_qacb(nl, true, cb_tcp_close_wait, &proto);
	handle_qacb(nl, true, cb_tcp_close, &proto);
	handle_qacb(nl, true, cb_tcp_destroy, &proto);
	handle_qacb(nl, false, NULL, NULL);
	sync_fifo(post);
}

int handle_qacb(const struct mnl_socket *nl, bool should_receive,
		int(*cb)(const struct nlmsghdr *nlh, void *data), void *data)
{
	char buf[MNL_SOCKET_BUFFER_SIZE];
	fd_set rfds;
	int ret, fd = mnl_socket_get_fd(nl);
	bool receive_nfnl;

	FD_ZERO(&rfds);
	FD_SET(fd, &rfds);
	if (select(fd + 1, &rfds, NULL, NULL, &timeout) < 0)
		child_exit("select", EXIT_FAILURE);
	receive_nfnl = FD_ISSET(fd, &rfds);
	if (should_receive) {
		assert(receive_nfnl == true);
	} else {
		assert(receive_nfnl == false);
		return MNL_CB_ERROR;
	}

	ret = mnl_socket_recvfrom(nl, buf, sizeof(buf));
	if (ret == -1)
		child_exit("mnl_socket_recvfrom", EXIT_FAILURE);
	mnl_cb_run(buf, ret, 0, 0, debug_nfct_cb, NULL);
	if (cb != NULL) {
		ret = mnl_cb_run(buf, ret, 0, 0, cb, data);
		if (ret == -1)
			child_exit("mnl_cb_run", EXIT_FAILURE);
		return ret;
	}

	return MNL_CB_OK;
}

static void sigabrt_handler(int signum)
{
	fini_nssocket();
}

struct mnl_socket *mnl_event_nssocket(const char *nsname)
{
	struct mnl_socket *nl;
	struct sigaction sa;

	sigemptyset(&sa.sa_mask);
	sa.sa_flags = 0;
	sa.sa_handler = sigabrt_handler;
	if (sigaction(SIGABRT, &sa, NULL) == -1)
		return NULL;

	if (init_nssocket(nsname) == -1)
		return NULL;

	nl = mnl_nssocket_open(NETLINK_NETFILTER);
	if (nl == NULL)
		return NULL;
	if (mnl_socket_bind(nl, NF_NETLINK_CONNTRACK_NEW |
			    NF_NETLINK_CONNTRACK_UPDATE |
			    NF_NETLINK_CONNTRACK_DESTROY,
			    MNL_SOCKET_AUTOPID) < 0) {
		parent_fail("mnl_socket_bind");
		mnl_socket_close(nl);
		return NULL;
	}

	return nl;
}

void sync_fifo(const char *name)
{
	struct stat statbuf;
	int fd = open(name, O_WRONLY);
	if (fd == -1) {
		parent_fail("open fifo");
		exit(EXIT_FAILURE);
	}
	if (fstat(fd, &statbuf) == -1) {
		parent_fail("fstat fifo");
		exit(EXIT_FAILURE);
	}
	if (!S_ISFIFO(statbuf.st_mode)) {
		parent_fail("S_ISFIFO");
		exit(EXIT_FAILURE);
	}
	close(fd);
}