/* vi: set sw=4 ts=4:
 *
 * nc: mini-netcat - Forward stdin/stdout to a file or network connection.
 *
 * Copyright 2007 Rob Landley <rob@landley.net>
 *
 * Not in SUSv3.

USE_NETCAT(OLDTOY(nc, netcat, USE_NETCAT_LISTEN("tl^L^")"w#p#s:q#f:", TOYFLAG_BIN))
USE_NETCAT(NEWTOY(netcat, USE_NETCAT_LISTEN("tl^L^")"w#p#s:q#f:", TOYFLAG_BIN))

config NETCAT
	bool "netcat"
	default y
	help
	  usage: netcat [-wpq #] [-s addr] {IPADDR PORTNUM|-f FILENAME|-let} [-e COMMAND]

	  -w	SECONDS timeout for connection
	  -p	local port number
	  -s	local ipv4 address
	  -q	SECONDS quit this many seconds after EOF on stdin.
	  -f	use FILENAME (ala /dev/ttyS0) instead of network

	  Use "stty 115200 -F /dev/ttyS0 && stty raw -echo -ctlecho" with
	  netcat -f to connect to a serial port.


config NETCAT_LISTEN
	bool "netcat sever options (-let)"
	default y
	depends on NETCAT
	help
	  -t    allocate tty (must come before -l or -L)
	  -l	listen for one incoming connection.
	  -L	listen for multiple incoming connections (server mode).

	  Any additional command line arguments after -l or -L are executed
	  to handle each incoming connection.  If none, the connection is
	  forwarded to stdin/stdout.

	  For a quick-and-dirty server, try something like:
		netcat -s 127.0.0.1 -p 1234 -tL /bin/bash -l
*/

#include "toys.h"
#include "toynet.h"

DEFINE_GLOBALS(
	char *filename;        // -f read from filename instead of network
	long quit_delay;       // -q Exit after EOF from stdin after # seconds.
	char *source_address;  // -s Bind to a specific source address.
	long port;             // -p Bind to a specific source port.
	long wait;             // -w Wait # seconds for a connection.
)

#define TT this.netcat

#define FLAG_f   1
#define FLAG_L  32
#define FLAG_l  64
#define FLAG_t 128

static void timeout(int signum)
{
	if (TT.wait) error_exit("Timeout");
	exit(0);
}

static void set_alarm(int seconds)
{
	signal(SIGALRM, seconds ? timeout : SIG_DFL);
	alarm(seconds);
}

// Translate x.x.x.x numeric IPv4 address, or else DNS lookup an IPv4 name.
static void lookup_name(char *name, uint32_t *result)
{
	struct hostent *hostbyname;

	hostbyname = gethostbyname(name);
	if (!hostbyname) error_exit("no host '%s'", name);
	*result = *(uint32_t *)*hostbyname->h_addr_list;
}

// Worry about a fancy lookup later.
static void lookup_port(char *str, uint16_t *port)
{
  *port = SWAP_BE16(atoi(str));
}

void netcat_main(void)
{
	int sockfd=-1, pollcount=2;
	struct pollfd pollfds[2];

	memset(pollfds, 0, 2*sizeof(struct pollfd));
	pollfds[0].events = pollfds[1].events = POLLIN;
	set_alarm(TT.wait);

	// The argument parsing logic can't make "<2" conditional on other
	// arguments like -f and -l, so we do it by hand here.
	if (toys.optflags&FLAG_f) {
		if (toys.optc) toys.exithelp++;
	} else if (!(toys.optflags&(FLAG_l|FLAG_L)) && toys.optc!=2) toys.exithelp++;

	if (toys.exithelp) error_exit("Argument count wrong");

	if (TT.filename) pollfds[0].fd = xopen(TT.filename, O_RDWR);
	else {
		int temp;
		struct sockaddr_in address;

		// Setup socket
		sockfd = socket(AF_INET, SOCK_STREAM, 0);
		if (-1 == sockfd) perror_exit("socket");
		fcntl(sockfd, F_SETFD, FD_CLOEXEC);
		temp = 1;
		setsockopt(sockfd, SOL_SOCKET, SO_REUSEADDR, &temp, sizeof(temp));
		memset(&address, 0, sizeof(address));
		address.sin_family = AF_INET;
		if (TT.source_address || TT.port) {
			address.sin_port = SWAP_BE16(TT.port);
			if (TT.source_address) 
				lookup_name(TT.source_address, (uint32_t *)&address.sin_addr);
			if (bind(sockfd, (struct sockaddr *)&address, sizeof(address)))
				perror_exit("bind");
		}

		// Dial out

		if (!CFG_NETCAT_LISTEN || !(toys.optflags&(FLAG_L|FLAG_l))) {
			// Figure out where to dial out to.
			lookup_name(*toys.optargs, (uint32_t *)&address.sin_addr);
			lookup_port(toys.optargs[1], &address.sin_port);
			temp = connect(sockfd, (struct sockaddr *)&address, sizeof(address));
			if (temp<0) perror_exit("connect");
			pollfds[0].fd = sockfd;

		// Listen for incoming connections

		} else {
			socklen_t len = sizeof(address);

			if (listen(sockfd, 5)) error_exit("listen");
			if (!TT.port) {
				getsockname(sockfd, (struct sockaddr *)&address, &len);
				printf("%d\n", SWAP_BE16(address.sin_port));
				fflush(stdout);
			}
			// Do we need to return immediately because -l has arguments?

			if ((toys.optflags&FLAG_l) && toys.optc) {
				if (fork()) goto cleanup;
				close(0);
				close(1);
				close(2);
			}

			for (;;) {
				pid_t child = 0;

				// For -l, call accept from the _new_ thread.

				pollfds[0].fd = accept(sockfd, (struct sockaddr *)&address,
					&len);
				if (pollfds[0].fd<0) perror_exit("accept");

				// Do we need a tty?

				if (toys.optflags&FLAG_t)
					child = forkpty(&(pollfds[1].fd), NULL, NULL, NULL);

				// Do we need to fork and/or redirect for exec?

				else {
					if (toys.optflags&FLAG_L) child = fork();
					if (!child && toys.optc) {
						int fd = pollfds[0].fd;

						if (!temp) close(sockfd);
						dup2(fd, 0);
						dup2(fd, 1);
						dup2(fd, 2);
						if (fd>2) close(fd);
					}
				}

				if (child<0) error_msg("Fork failed\n");
				if (child<1) break;
				close(pollfds[0].fd);
			}
		}
	}

	// We have a connection.  Disarm timeout.
	// (Does not play well with -L, but what _should_ that do?)
	set_alarm(0);

	if (CFG_NETCAT_LISTEN && (toys.optflags&(FLAG_L|FLAG_l) && toys.optc)) {
		execvp(*toys.optargs, toys.optargs);
		error_exit("Exec failed");
	}

	// Poll loop copying stdin->socket and socket->stdout.
	for (;;) {
		int i;

		if (0>poll(pollfds, pollcount, -1)) perror_exit("poll");

		for (i=0; i<pollcount; i++) {
			if (pollfds[i].revents & POLLIN) {
				int len = read(pollfds[i].fd, toybuf, sizeof(toybuf));
				if (len<1) goto dohupnow;
				xwrite(i ? pollfds[0].fd : 1, toybuf, len);
			} else if (pollfds[i].revents & POLLHUP) {
dohupnow:
				// Close half-connection.  This is needed for things like
				// "echo GET / | netcat landley.net 80"
				if (i) {
					shutdown(pollfds[0].fd, SHUT_WR);
					pollcount--;
					set_alarm(TT.quit_delay);
				} else goto cleanup;
			}
		}
	}
cleanup:
	if (CFG_TOYBOX_FREE) {
		close(pollfds[0].fd);
		close(sockfd);
	}
}