/*

 * Copyright (c) 2015 Sunil Nimmagadda <sunil@openbsd.org>

 *

 * 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 <sys/cdefs.h>

#include <sys/types.h>

#include <sys/queue.h>

#include <sys/stat.h>

#include <sys/socket.h>

#include <sys/wait.h>

#include <err.h>

#include <errno.h>

#include <fcntl.h>

#include <imsg.h>

#include <libgen.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <string.h>

#include <unistd.h>

#include "ftp.h"

#include "xmalloc.h"

#define	IMSG_OPEN	 1

static int		 auto_fetch(int, char **);

static void		 child(int, int, char **);

static int		 parent(int, pid_t);

static struct url	*proxy_parse(const char *);

static int		 stdout_copy(const char *);

static int		 append(const char *);

static int		 save(const char *);

static int		 slurp(struct url *, FILE *, off_t *, off_t);

static char		*output_fname(struct url *, const char *);

static void		 re_exec(int, int, char **);

static __dead void	 usage(void);

static int		 read_message(struct imsgbuf *, struct imsg *);

static void		 send_message(struct imsgbuf *, int, uint32_t, void *,

			     size_t, int);

struct url		*ftp_proxy, *http_proxy;

const char		*useragent = "OpenBSD ftp";

char			*oarg;

int			 activemode, family = AF_UNSPEC, io_debug;

int			 progressmeter, verbose = 1;

volatile sig_atomic_t	 interrupted = 0;

static struct imsgbuf	 child_ibuf;

static const char	*title;

static char		*tls_options;

static int		 connect_timeout, resume;

int

main(int argc, char **argv)

{

	const char	 *e;

	char		**save_argv, *term;

	int		  ch, csock, dumb_terminal, rexec, save_argc;

	if (isatty(fileno(stdin)) != 1)

		verbose = 0;

	io_debug = getenv("IO_DEBUG") != NULL;

	term = getenv("TERM");

	dumb_terminal = (term == NULL || *term == '\0' ||

	    !strcmp(term, "dumb") || !strcmp(term, "emacs") ||

	    !strcmp(term, "su"));

	if (isatty(STDOUT_FILENO) && isatty(STDERR_FILENO) && !dumb_terminal)

		progressmeter = 1;

	csock = rexec = 0;

	save_argc = argc;

	save_argv = argv;

	while ((ch = getopt(argc, argv,

	    "46AaCc:dD:Eegik:MmN:no:pP:r:S:s:tU:vVw:xz:")) != -1) {

		switch (ch) {

		case '4':

			family = AF_INET;

			break;

		case '6':

			family = AF_INET6;

			break;

		case 'A':

			activemode = 1;

			break;

		case 'C':

			resume = 1;

			break;

		case 'D':

			title = optarg;

			break;

		case 'o':

			oarg = optarg;

			if (!strlen(oarg))

				oarg = NULL;

			break;

		case 'M':

			progressmeter = 0;

			break;

		case 'm':

			progressmeter = 1;

			break;

		case 'N':

			setprogname(optarg);

			break;

		case 'S':

			tls_options = optarg;

			break;

		case 'U':

			useragent = optarg;

			break;

		case 'V':

			verbose = 0;

			break;

		case 'v':

			verbose = 1;

			break;

		case 'w':

			connect_timeout = strtonum(optarg, 0, 200, &e);

			if (e)

				errx(1, "-w: %s", e);

			break;

		/* options for internal use only */

		case 'x':

			rexec = 1;

			break;

		case 'z':

			csock = strtonum(optarg, 3, getdtablesize() - 1, &e);

			if (e)

				errx(1, "-z: %s", e);

			break;

		/* Ignoring all remaining options */

		case 'a':

		case 'c':

		case 'd':

		case 'E':

		case 'e':

		case 'g':

		case 'i':

		case 'k':

		case 'n':

		case 'P':

		case 'p':

		case 'r':

		case 's':

		case 't':

			warnx("Ignoring getopt: %c", ch);

			break;

		default:

			usage();

		}

	}

	argc -= optind;

	argv += optind;

	if (rexec)

		child(csock, argc, argv);

#ifndef SMALL

	struct url	*url;

	switch (argc) {

	case 0:

		cmd(NULL, NULL, NULL);

		return 0;

	case 1:

	case 2:

		switch (url_scheme_lookup(argv[0])) {

		case -1:

			cmd(argv[0], argv[1], NULL);

			return 0;

		case S_FTP:

			url = xurl_parse(argv[0]);

			if (url->path &&

			    url->path[strlen(url->path) - 1] != '/')

				break; /* auto fetch */

			cmd(url->host, url->port, url->path);

			return 0;

		}

		break;

	}

#else

	if (argc == 0)

		usage();

#endif /* SMALL */

	return auto_fetch(save_argc, save_argv);

}

static int

auto_fetch(int sargc, char **sargv)

{

	pid_t	pid;

	int	sp[2];

	if (socketpair(AF_UNIX, SOCK_STREAM, PF_UNSPEC, sp) != 0)

		err(1, "socketpair");

	switch (pid = fork()) {

	case -1:

		err(1, "fork");

	case 0:

		close(sp[0]);

		re_exec(sp[1], sargc, sargv);

	}

	close(sp[1]);

	return parent(sp[0], pid);

}

static void

re_exec(int sock, int argc, char **argv)

{

	char	**nargv, *sock_str;

	int	  i, j, nargc;

	nargc = argc + 4;

	nargv = xcalloc(nargc, sizeof(*nargv));

	xasprintf(&sock_str, "%d", sock);

	i = 0;

	nargv[i++] = argv[0];

	nargv[i++] = "-z";

	nargv[i++] = sock_str;

	nargv[i++] = "-x";

	for (j = 1; j < argc; j++)

		nargv[i++] = argv[j];

	execvp(nargv[0], nargv);

	err(1, "execvp");

}

static int

parent(int sock, pid_t child_pid)

{

	struct imsgbuf	ibuf;

	struct imsg	imsg;

	struct stat	sb;

	off_t		offset;

	int		fd, save_errno, sig, status;

	setproctitle("%s", "parent");

	if (pledge("stdio cpath rpath wpath sendfd", NULL) == -1)

		err(1, "pledge");

	imsg_init(&ibuf, sock);

	for (;;) {

		if (read_message(&ibuf, &imsg) == 0)

			break;

		if (imsg.hdr.type != IMSG_OPEN)

			errx(1, "%s: IMSG_OPEN expected", __func__);

		offset = 0;

		fd = open(imsg.data, imsg.hdr.peerid, 0666);

		save_errno = errno;

		if (fd != -1 && fstat(fd, &sb) == 0) {

			if (sb.st_mode & S_IFDIR) {

				close(fd);

				fd = -1;

				save_errno = EISDIR;

			} else

				offset = sb.st_size;

		}

		send_message(&ibuf, IMSG_OPEN, save_errno,

		    &offset, sizeof offset, fd);

		imsg_free(&imsg);

	}

	close(sock);

	if (waitpid(child_pid, &status, 0) == -1 && errno != ECHILD)

		err(1, "wait");

	sig = WTERMSIG(status);

	if (WIFSIGNALED(status) && sig != SIGPIPE)

		errx(1, "child terminated: signal %d", sig);

	return WEXITSTATUS(status);

}

static void

child(int sock, int argc, char **argv)

{

	int	i, to_stdout = 0, r = 0;

	setproctitle("%s", "child");

#ifndef NOSSL

	/*

	 * TLS can't be init-ed on first use as filesystem(ca file) isn't

	 * available after pledge(2).

	 */

	https_init(tls_options);

#endif /* NOSSL */

	if (pledge("stdio inet dns recvfd tty unveil", NULL) == -1)

		err(1, "pledge");

	if (!progressmeter &&

	    pledge("stdio inet dns recvfd unveil", NULL) == -1)

		err(1, "pledge");

	imsg_init(&child_ibuf, sock);

	ftp_proxy = proxy_parse("ftp_proxy");

	http_proxy = proxy_parse("http_proxy");

	if (oarg) {

		if (strcmp(oarg, "-") == 0) {

			to_stdout = 1;

			if (resume)

				errx(1, "can't append to stdout");

		} else if (unveil(oarg, "w") == -1)

			err(1, "unveil");

		if (unveil(NULL, NULL) == -1)

			err(1, "unveil");

	}

	for (i = 0; i < argc; i++) {

		if (to_stdout)

			r = stdout_copy(argv[i]);

		else if (resume)

			r = append(argv[i]);

		else

			r = save(argv[i]);

	}

	exit(r);

}

static int

stdout_copy(const char *arg)

{

	struct url	*url;

	off_t		 offset = 0, sz = 0;

	url = xurl_parse(arg);

	url_connect(url, connect_timeout);

	url = url_request(url, &offset, &sz);

	return slurp(url, stdout, &offset, sz);

}

static int

append(const char *arg)

{

	struct url	*url;

	FILE		*fp;

	char		*fname;

	off_t		 offset = 0, sz = 0;

	int		 fd;

	url = xurl_parse(arg);

	url_connect(url, connect_timeout);

	fname = output_fname(url, arg);