/*

 * CDDL HEADER START

 *

 * The contents of this file are subject to the terms of the

 * Common Development and Distribution License, Version 1.0 only

 * (the "License").  You may not use this file except in compliance

 * with the License.

 *

 * You can obtain a copy of the license at usr/src/OPENSOLARIS.LICENSE

 * or http://www.opensolaris.org/os/licensing.

 * See the License for the specific language governing permissions

 * and limitations under the License.

 *

 * When distributing Covered Code, include this CDDL HEADER in each

 * file and include the License file at usr/src/OPENSOLARIS.LICENSE.

 * If applicable, add the following below this CDDL HEADER, with the

 * fields enclosed by brackets "[]" replaced with your own identifying

 * information: Portions Copyright [yyyy] [name of copyright owner]

 *

 * CDDL HEADER END

 *

 * Copyright 2004 Sun Microsystems, Inc.  All rights reserved.

 * Use is subject to license terms.

 */

/*

 * Copyright (c) 1983, 1984, 1985, 1986, 1987, 1988, 1989 AT&T

 * All Rights Reserved.

 */

/*

 * University Copyright- Copyright (c) 1982, 1986, 1988

 * The Regents of the University of California.

 * All Rights Reserved.

 *

 * University Acknowledgment- Portions of this document are derived from

 * software developed by the University of California, Berkeley, and its

 * contributors.

 */

#pragma ident	"%Z%%M%	%I%	%E% SMI"

/*

 * Trivial file transfer protocol server.  A top level process runs in

 * an infinite loop fielding new TFTP requests.  A child process,

 * communicating via a pipe with the top level process, sends delayed

 * NAKs for those that we can't handle.  A new child process is created

 * to service each request that we can handle.  The top level process

 * exits after a period of time during which no new requests are

 * received.

 */

#include <sys/types.h>

#include <sys/socket.h>

#include <sys/wait.h>

#include <sys/stat.h>

#include <sys/time.h>

#include <netinet/in.h>

#include <arpa/inet.h>

#include <dirent.h>

#include <signal.h>

#include <stdio.h>

#include <stdlib.h>

#include <unistd.h>

#include <errno.h>

#include <ctype.h>

#include <netdb.h>

#include <setjmp.h>

#include <syslog.h>

#include <sys/param.h>

#include <fcntl.h>

#include <pwd.h>

#include <string.h>

#include <priv_utils.h>

#include "tftpcommon.h"

#define	TIMEOUT		5

#define	DELAY_SECS	3

#define	DALLYSECS 60

#define	SYSLOG_MSG(message) \

	(syslog((((errno == ENETUNREACH) || (errno == EHOSTUNREACH) || \

		(errno == ECONNREFUSED)) ? LOG_WARNING : LOG_ERR), message))

static int			rexmtval = TIMEOUT;

static int			maxtimeout = 5*TIMEOUT;

static int			securetftp;

static int			debug;

static int			disable_pnp;

static int			standalone;

static uid_t			uid_nobody = UID_NOBODY;

static uid_t			gid_nobody = GID_NOBODY;

static int			reqsock = -1;

				/* file descriptor of request socket */

static socklen_t		fromlen;

static socklen_t		fromplen;

static struct sockaddr_storage	client;

static struct sockaddr_in6 	*sin6_ptr;

static struct sockaddr_in	*sin_ptr;

static struct sockaddr_in6	*from6_ptr;

static struct sockaddr_in	*from_ptr;

static int			addrfmly;

static int			peer;

static off_t			tsize;

static tftpbuf			ackbuf;

static struct sockaddr_storage	from;

static boolean_t		tsize_set;

static pid_t			child;

				/* pid of child handling delayed replys */

static int			delay_fd [2];

				/* pipe for communicating with child */

static FILE			*file;

static char			*filename;

static union {

	struct tftphdr	hdr;

	char		data[SEGSIZE + 4];

} buf;

static union {

	struct tftphdr	hdr;

	char		data[SEGSIZE];

} oackbuf;

struct	delay_info {

	long	timestamp;		/* time request received */

	int	ecode;			/* error code to return */

	struct	sockaddr_storage from;	/* address of client */

};

int	blocksize = SEGSIZE;	/* Number of data bytes in a DATA packet */

/*

 * Default directory for unqualified names

 * Used by TFTP boot procedures

 */

static char	*homedir = "/tftpboot";

struct formats {

	char	*f_mode;

	int	(*f_validate)(int);

	void	(*f_send)(struct formats *, int);

	void	(*f_recv)(struct formats *, int);

	int	f_convert;

};

static void	delayed_responder(void);

static void	tftp(struct tftphdr *, int);

static int	validate_filename(int);

static void	tftpd_sendfile(struct formats *, int);

static void	tftpd_recvfile(struct formats *, int);

static void	nak(int);

static char	*blksize_handler(int, char *, int *);

static char	*timeout_handler(int, char *, int *);

static char	*tsize_handler(int, char *, int *);

static struct formats formats[] = {

	{ "netascii",	validate_filename, tftpd_sendfile, tftpd_recvfile, 1 },

	{ "octet",	validate_filename, tftpd_sendfile, tftpd_recvfile, 0 },

	{ NULL }

};

struct options {

	char	*opt_name;

	char	*(*opt_handler)(int, char *, int *);

};

static struct options options[] = {

	{ "blksize",	blksize_handler },

	{ "timeout",	timeout_handler },

	{ "tsize",	tsize_handler },

	{ NULL }

};

static char		optbuf[MAX_OPTVAL_LEN];

static int		timeout;

static sigjmp_buf	timeoutbuf;

int

main(int argc, char **argv)

{

	struct tftphdr *tp;

	int n;

	int c;

	struct	passwd *pwd;		/* for "nobody" entry */

	struct in_addr ipv4addr;

	char abuf[INET6_ADDRSTRLEN];

	socklen_t addrlen;

	openlog("tftpd", LOG_PID, LOG_DAEMON);

	pwd = getpwnam("nobody");

	if (pwd != NULL) {

		uid_nobody = pwd->pw_uid;

		gid_nobody = pwd->pw_gid;

	}

	(void) __init_daemon_priv(

		PU_LIMITPRIVS,

		uid_nobody, gid_nobody,

		PRIV_PROC_FORK, PRIV_PROC_CHROOT, NULL);

	/*

	 *  Limit set is still "all."  Trim it down to just what we need:

	 *  fork and chroot.

	 */

	(void) priv_set(PRIV_SET,

	    PRIV_ALLSETS, PRIV_PROC_FORK, PRIV_PROC_CHROOT, NULL);

	(void) priv_set(PRIV_SET, PRIV_EFFECTIVE, NULL);

	(void) priv_set(PRIV_SET, PRIV_INHERITABLE, NULL);

	while ((c = getopt(argc, argv, "dspS")) != EOF)

		switch (c) {

		case 'd':		/* enable debug */

			debug++;

			continue;

		case 's':		/* secure daemon */

			securetftp = 1;

			continue;

		case 'p':		/* disable name pnp mapping */

			disable_pnp = 1;

			continue;

		case 'S':

			standalone = 1;

			continue;

		case '?':

		default:

usage:

			(void) fprintf(stderr,

			    "usage:  %s [-spd] [home-directory]\n", argv[0]);

			for (; optind < argc; optind++)

				syslog(LOG_ERR, "bad argument %s",

				    argv[optind]);

			exit(1);

		}

	if (optind < argc)

		if (optind == argc - 1 && *argv [optind] == '/')

			homedir = argv [optind];

		else

			goto usage;

	if (pipe(delay_fd) < 0) {

		syslog(LOG_ERR, "pipe (main): %m");

		exit(1);

	}

	(void) sigset(SIGCHLD, SIG_IGN); /* no zombies please */

	if (standalone) {

		socklen_t clientlen;

		sin6_ptr = (struct sockaddr_in6 *)&client;

		clientlen = sizeof (struct sockaddr_in6);

		reqsock = socket(AF_INET6, SOCK_DGRAM, 0);

		if (reqsock == -1) {

			perror("socket");

			exit(1);

		}

		(void) memset(&client, 0, clientlen);

		sin6_ptr->sin6_family = AF_INET6;

		sin6_ptr->sin6_port = htons(IPPORT_TFTP);

		if (bind(reqsock, (struct sockaddr *)&client,

		    clientlen) == -1) {

			perror("bind");

			exit(1);

		}

		if (debug)

			(void) puts("running in standalone mode...");

	} else {

		/* request socket passed on fd 0 by inetd */

		reqsock = 0;

	}

	if (debug) {

		int on = 1;

		(void) setsockopt(reqsock, SOL_SOCKET, SO_DEBUG,

		    (char *)&on, sizeof (on));

	}

	(void) chdir(homedir);

	(void) priv_set(PRIV_SET, PRIV_EFFECTIVE, PRIV_PROC_FORK, NULL);

	if ((child = fork()) < 0) {

		syslog(LOG_ERR, "fork (main): %m");

		exit(1);

	}

	(void) priv_set(PRIV_SET, PRIV_EFFECTIVE, NULL);

	if (child == 0) {

		(void) priv_set(PRIV_SET, PRIV_ALLSETS, NULL);

		delayed_responder();

	} /* child */

	/* close read side of pipe */

	(void) close(delay_fd[0]);

	/*

	 * Top level handling of incomming tftp requests.  Read a request

	 * and pass it off to be handled.  If request is valid, handling

	 * forks off and parent returns to this loop.  If no new requests

	 * are received for DALLYSECS, exit and return to inetd.

	 */

	for (;;) {

		fd_set readfds;

		struct timeval dally;

		FD_ZERO(&readfds);

		FD_SET(reqsock, &readfds);

		dally.tv_sec = DALLYSECS;

		dally.tv_usec = 0;

		n = select(reqsock + 1, &readfds, NULL, NULL, &dally);

		if (n < 0) {

			if (errno == EINTR)

				continue;

			syslog(LOG_ERR, "select: %m");

			(void) kill(child, SIGKILL);

			exit(1);

		}

		if (n == 0) {

			/* Select timed out.  Its time to die. */

			if (standalone)

				continue;

			else {

				(void) kill(child, SIGKILL);

				exit(0);

			}

		}

		addrlen = sizeof (from);

		if (getsockname(reqsock, (struct sockaddr  *)&from,

		    &addrlen) < 0) {

			syslog(LOG_ERR, "getsockname: %m");

			exit(1);

		}

		switch (from.ss_family) {

		case AF_INET:

			fromlen = (socklen_t)sizeof (struct sockaddr_in);

			break;

		case AF_INET6:

			fromlen = (socklen_t)sizeof (struct sockaddr_in6);

			break;

		default:

			syslog(LOG_ERR,

			    "Unknown address Family on peer connection %d",

			    from.ss_family);

			exit(1);

		}

		n = recvfrom(reqsock, &buf, sizeof (buf), 0,

			(struct sockaddr *)&from, &fromlen);

		if (n < 0) {

			if (errno == EINTR)

				continue;

			if (standalone)

				perror("recvfrom");

			else

				syslog(LOG_ERR, "recvfrom: %m");

			(void) kill(child, SIGKILL);

			exit(1);

		}

		(void) alarm(0);

		switch (from.ss_family) {

		case AF_INET:

			addrfmly = AF_INET;

			fromplen = sizeof (struct sockaddr_in);

			sin_ptr = (struct sockaddr_in *)&client;

			(void) memset(&client, 0, fromplen);

			sin_ptr->sin_family = AF_INET;

			break;

		case AF_INET6:

			addrfmly = AF_INET6;

			fromplen = sizeof (struct sockaddr_in6);

			sin6_ptr = (struct sockaddr_in6 *)&client;

			(void) memset(&client, 0, fromplen);

			sin6_ptr->sin6_family = AF_INET6;

			break;

		default:

			syslog(LOG_ERR,

			    "Unknown address Family on peer connection");

			exit(1);

		}

		peer = socket(addrfmly, SOCK_DGRAM, 0);

		if (peer < 0) {

			if (standalone)

				perror("socket (main)");

			else

				syslog(LOG_ERR, "socket (main): %m");

			(void) kill(child, SIGKILL);

			exit(1);

		}

		if (debug) {

			int on = 1;

			(void) setsockopt(peer, SOL_SOCKET, SO_DEBUG,

			    (char *)&on, sizeof (on));

		}

		if (bind(peer, (struct sockaddr *)&client, fromplen) < 0) {

			if (standalone)

				perror("bind (main)");

			else

				syslog(LOG_ERR, "bind (main): %m");

			(void) kill(child, SIGKILL);

			exit(1);

		}

		if (standalone && debug) {

			sin6_ptr = (struct sockaddr_in6 *)&client;

			from6_ptr = (struct sockaddr_in6 *)&from;

			if (IN6_IS_ADDR_V4MAPPED(&from6_ptr->sin6_addr)) {

				IN6_V4MAPPED_TO_INADDR(&from6_ptr->sin6_addr,

				    &ipv4addr);

				(void) inet_ntop(AF_INET, &ipv4addr, abuf,

				    sizeof (abuf));

			} else {

				(void) inet_ntop(AF_INET6,

				    &from6_ptr->sin6_addr, abuf,

				    sizeof (abuf));

			}

			/* get local port */

			if (getsockname(peer, (struct sockaddr *)&client,

			    &fromplen) < 0)

				perror("getsockname (main)");

			(void) fprintf(stderr,

			    "request from %s port %d; local port %d\n",

			    abuf, from6_ptr->sin6_port, sin6_ptr->sin6_port);

		}

		tp = &buf.hdr;

		tp->th_opcode = ntohs((ushort_t)tp->th_opcode);

		if (tp->th_opcode == RRQ || tp->th_opcode == WRQ)

			tftp(tp, n);

		(void) close(peer);

		(void) fclose(file);

	}

	/*NOTREACHED*/

	return (0);

}

static void

delayed_responder(void)

{

	struct delay_info dinfo;

	long now;

	/* we don't use the descriptors passed in to the parent */

	(void) close(0);

	(void) close(1);

	if (standalone)

		(void) close(reqsock);

	/* close write side of pipe */

	(void) close(delay_fd[1]);

	for (;;) {

		int n;

		if ((n = read(delay_fd[0], &dinfo,

		    sizeof (dinfo))) != sizeof (dinfo)) {

			if (n < 0) {

				if (errno == EINTR)

					continue;

				if (standalone)

					perror("read from pipe "

					    "(delayed responder)");

				else

					syslog(LOG_ERR, "read from pipe: %m");

			}

			exit(1);

		}

		switch (dinfo.from.ss_family) {

		case AF_INET:

			addrfmly = AF_INET;

			fromplen = sizeof (struct sockaddr_in);

			sin_ptr = (struct sockaddr_in *)&client;

			(void) memset(&client, 0, fromplen);

			sin_ptr->sin_family = AF_INET;

			break;

		case AF_INET6:

			addrfmly = AF_INET6;

			fromplen = sizeof (struct sockaddr_in6);

			sin6_ptr = (struct sockaddr_in6 *)&client;

			(void) memset(&client, 0, fromplen);

			sin6_ptr->sin6_family = AF_INET6;

			break;

		}

		peer = socket(addrfmly, SOCK_DGRAM, 0);

		if (peer == -1) {

			if (standalone)

				perror("socket (delayed responder)");

			else

				syslog(LOG_ERR, "socket (delay): %m");

			exit(1);

		}

		if (debug) {

			int on = 1;

			(void) setsockopt(peer, SOL_SOCKET, SO_DEBUG,

			    (char *)&on, sizeof (on));

		}

		if (bind(peer, (struct sockaddr *)&client, fromplen) < 0) {

			if (standalone)

				perror("bind (delayed responder)");

			else

				syslog(LOG_ERR, "bind (delay): %m");

			exit(1);

		}

		if (client.ss_family == AF_INET) {

			from_ptr = (struct sockaddr_in *)&dinfo.from;

			from_ptr->sin_family = AF_INET;

		} else {

			from6_ptr = (struct sockaddr_in6 *)&dinfo.from;

			from6_ptr->sin6_family = AF_INET6;

		}

		/*

		 * Since a request hasn't been received from the client

		 * before the delayed responder process is forked, the

		 * from variable is uninitialized.  So set it to contain

		 * the client address.

		 */