/*
 * Copyright (c) 2016 Vincent Gross <vincent.gross@kilob.yt>
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#include <err.h>
#include <errno.h>
#include <getopt.h>
#include <netdb.h>
#include <signal.h>
#include <stdlib.h>
#include <string.h>
#include <stdio.h>
#include <unistd.h>

#include <sys/socket.h>
#include <sys/types.h>
#include <sys/wait.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#define PORTNUM "23000"

int
main(int argc, char *argv[])
{
	struct addrinfo		  hints;
	struct addrinfo		 *in6ai;

	struct sockaddr_in6	 *null_sin6 = NULL;
	struct sockaddr_in6	**next_sin6_p = NULL;
	struct sockaddr_in6	**first_sin6p = &null_sin6;
	struct sockaddr_in6	**bind_sin6p = &null_sin6;
	struct sockaddr_in6	**sendmsg_sin6p = &null_sin6;
	struct sockaddr_in6	**setsockopt_sin6p = &null_sin6;
	struct sockaddr_in6	**dst_sin6p = &null_sin6;

	int			  ch, rc, wstat, expected = -1;
	int			  first_sock;
	int			  reuse_addr = 0;
	pid_t			  pid;

	const char		 *numerr;
	char			  adrbuf[40];
	const char		 *adrp;


	bzero(&hints, sizeof(hints));
	hints.ai_family = AF_INET6;
	hints.ai_socktype = SOCK_DGRAM;

	do {
		if (next_sin6_p == NULL)
			next_sin6_p = malloc(sizeof(*next_sin6_p));
		if (next_sin6_p == NULL)
			err(2, "malloc()");
		*next_sin6_p = NULL;
		while ((ch = getopt(argc, argv, "dfbmoe:")) != -1) {
			switch(ch) {
			case 'd':
				dst_sin6p = next_sin6_p;
				break;
			case 'f':
				first_sin6p = next_sin6_p;
				break;
			case 'b':
				bind_sin6p = next_sin6_p;
				break;
			case 'm':
				sendmsg_sin6p = next_sin6_p;
				break;
			case 'o':
				setsockopt_sin6p = next_sin6_p;
				break;
			case 'e':
				expected = strtonum(optarg, 0, 255, &numerr);
				if (numerr != NULL)
					errx(2, "strtonum(%s): %s", optarg, numerr);
				break;
			}
		}
		if (optind < argc) {
			rc = getaddrinfo(argv[optind], PORTNUM, &hints, &in6ai);
			if (rc)
				errx(2, "getaddrinfo(%s) = %d: %s",
				    argv[0], rc, gai_strerror(rc));
			*next_sin6_p = (struct sockaddr_in6 *)in6ai->ai_addr;
			next_sin6_p = NULL;
		}
		optreset = 1; optind++;
	} while (optind < argc);

	if (*bind_sin6p == NULL)
		errx(2, "bind_sin6p == NULL");

	if (*dst_sin6p == NULL)
		errx(2, "dst_sin6p == NULL");

	if (expected < 0)
		errx(2, "need expected");

	if (*first_sin6p) {
		first_sock = udp6_first(*first_sin6p);
		reuse_addr = 1;
	}

	pid = fork();
	if (pid == 0) {
		return udp6_override(*dst_sin6p, *bind_sin6p,
		    *setsockopt_sin6p, *sendmsg_sin6p, reuse_addr);
	}
	(void)wait(&wstat);

	if (*first_sin6p)
		close(first_sock);

	if (! WIFEXITED(wstat))
		errx(2, "error setting up override");

	if (WEXITSTATUS(wstat) != expected)
		errx(2, "expected %d, got %d", expected, WEXITSTATUS(wstat));

	return EXIT_SUCCESS;
}


int
udp6_first(struct sockaddr_in6 *src)
{
	int s_con;

	s_con = socket(AF_INET6, SOCK_DGRAM, 0);
	if (s_con == -1)
		err(2, "udp6_bind: socket()");

	if (bind(s_con, (struct sockaddr *)src, src->sin6_len))
		err(2, "udp6_bind: bind()");

	return s_con;
}


int
udp6_override(struct sockaddr_in6 *dst, struct sockaddr_in6 *src_bind,
    struct sockaddr_in6 *src_setsockopt, struct sockaddr_in6 *src_sendmsg,
    int reuse_addr)
{
	int			 s, optval, error, saved_errno;
	ssize_t			 send_rc;
	struct msghdr		 msg;
	struct iovec		 iov;
	struct cmsghdr		*cmsg;
	struct in6_pktinfo	*pi_sendmsg;
	struct in6_pktinfo	 pi_setsockopt;
	union {
		struct cmsghdr	hdr;
		unsigned char	buf[CMSG_SPACE(sizeof(struct in6_pktinfo))];
	} cmsgbuf;

	bzero(&msg, sizeof(msg));
	bzero(&cmsgbuf, sizeof(cmsgbuf));
	bzero(&pi_setsockopt, sizeof(pi_setsockopt));

	s = socket(AF_INET6, SOCK_DGRAM, 0);
	if (s == -1) {
		warn("udp6_override: socket()");
		kill(getpid(), SIGTERM);
	}

	if (reuse_addr) {
		optval = 1;
		if (setsockopt(s, SOL_SOCKET, SO_REUSEADDR, &optval, sizeof(int))) {
			warn("udp6_override: setsockopt(SO_REUSEADDR)");
			kill(getpid(), SIGTERM);
		}
	}

	if (bind(s, (struct sockaddr *)src_bind, src_bind->sin6_len)) {
		warn("udp6_override: bind()");
		kill(getpid(), SIGTERM);
	}

	if (src_setsockopt != NULL) {
		memcpy(&pi_setsockopt.ipi6_addr, &src_setsockopt->sin6_addr, sizeof(struct in6_addr));
		if (setsockopt(s, IPPROTO_IPV6, IPV6_PKTINFO, &pi_setsockopt, sizeof(pi_setsockopt))) {
			warn("udp6_override: setsockopt(IPV6_PKTINFO)");
			kill(getpid(), SIGTERM);
		}
	}

	iov.iov_base = "payload";
	iov.iov_len = 8;
	msg.msg_name = dst;
	msg.msg_namelen = dst->sin6_len;
	msg.msg_iov = &iov;
	msg.msg_iovlen = 1;

	if (src_sendmsg) {
		msg.msg_control = &cmsgbuf.buf;
		msg.msg_controllen = sizeof(cmsgbuf.buf);
		cmsg = CMSG_FIRSTHDR(&msg);
		cmsg->cmsg_len = CMSG_LEN(sizeof(struct in6_pktinfo));
		cmsg->cmsg_level = IPPROTO_IPV6;
		cmsg->cmsg_type = IPV6_PKTINFO;
		pi_sendmsg = (struct in6_pktinfo *)CMSG_DATA(cmsg);
		memcpy(&pi_sendmsg->ipi6_addr, &src_sendmsg->sin6_addr, sizeof(struct in6_addr));
	}

	send_rc = sendmsg(s, &msg, 0);
	saved_errno = errno;

	close(s);

	if (send_rc == iov.iov_len)
		return 0;
	return saved_errno;
}