xref: /freebsd/libexec/tftpd/tftp-options.c (revision a6fe717c2a876105123214c05176cd74106fb94b)

/*-
 * SPDX-License-Identifier: BSD-2-Clause
 *
 * Copyright (C) 2008 Edwin Groothuis. All rights reserved.
 *
 * Redistribution and use in source and binary forms, with or without
 * modification, are permitted provided that the following conditions
 * are met:
 * 1. Redistributions of source code must retain the above copyright
 *    notice, this list of conditions and the following disclaimer.
 * 2. Redistributions in binary form must reproduce the above copyright
 *    notice, this list of conditions and the following disclaimer in the
 *    documentation and/or other materials provided with the distribution.
 *
 * THIS SOFTWARE IS PROVIDED BY AUTHOR AND CONTRIBUTORS ``AS IS'' AND
 * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
 * ARE DISCLAIMED.  IN NO EVENT SHALL AUTHOR OR CONTRIBUTORS BE LIABLE
 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
 * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
 * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
 * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
 * SUCH DAMAGE.
 */

#include <sys/types.h>
#include <sys/socket.h>
#include <sys/stat.h>
#include <sys/sysctl.h>

#include <netinet/in.h>
#include <arpa/tftp.h>

#include <ctype.h>
#include <stdarg.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <syslog.h>

#include "tftp-utils.h"
#include "tftp-io.h"
#include "tftp-options.h"

/*
 * Option handlers
 */

struct options options[] = {
	{ "tsize",	NULL, NULL, NULL /* option_tsize */, 1 },
	{ "timeout",	NULL, NULL, option_timeout, 1 },
	{ "blksize",	NULL, NULL, option_blksize, 1 },
	{ "blksize2",	NULL, NULL, option_blksize2, 0 },
	{ "rollover",	NULL, NULL, option_rollover, 0 },
	{ "windowsize",	NULL, NULL, option_windowsize, 1 },
	{ NULL,		NULL, NULL, NULL, 0 }
};

/* By default allow them */
int options_rfc_enabled = 1;
int options_extra_enabled = 1;

int
options_set_request(enum opt_enum opt, const char *fmt, ...)
{
	va_list ap;
	char *str;
	int ret;

	if (fmt == NULL) {
		str = NULL;
	} else {
		va_start(ap, fmt);
		ret = vasprintf(&str, fmt, ap);
		va_end(ap);
		if (ret < 0)
			return (ret);
	}
	if (options[opt].o_request != NULL &&
	    options[opt].o_request != options[opt].o_reply)
		free(options[opt].o_request);
	options[opt].o_request = str;
	return (0);
}

int
options_set_reply(enum opt_enum opt, const char *fmt, ...)
{
	va_list ap;
	char *str;
	int ret;

	if (fmt == NULL) {
		str = NULL;
	} else {
		va_start(ap, fmt);
		ret = vasprintf(&str, fmt, ap);
		va_end(ap);
		if (ret < 0)
			return (ret);
	}
	if (options[opt].o_reply != NULL &&
	    options[opt].o_reply != options[opt].o_request)
		free(options[opt].o_reply);
	options[opt].o_reply = str;
	return (0);
}

static void
options_set_reply_equal_request(enum opt_enum opt)
{

	if (options[opt].o_reply != NULL &&
	    options[opt].o_reply != options[opt].o_request)
		free(options[opt].o_reply);
	options[opt].o_reply = options[opt].o_request;
}

/*
 * Rules for the option handlers:
 * - If there is no o_request, there will be no processing.
 *
 * For servers
 * - Logging is done as warnings.
 * - The handler exit()s if there is a serious problem with the
 *   values submitted in the option.
 *
 * For clients
 * - Logging is done as errors. After all, the server shouldn't
 *   return rubbish.
 * - The handler returns if there is a serious problem with the
 *   values submitted in the option.
 * - Sending the EBADOP packets is done by the handler.
 */

int
option_tsize(int peer __unused, struct tftphdr *tp __unused, int mode,
    struct stat *stbuf)
{

	if (options[OPT_TSIZE].o_request == NULL)
		return (0);

	if (mode == RRQ)
		options_set_reply(OPT_TSIZE, "%ju", (uintmax_t)stbuf->st_size);
	else
		/* XXX Allows writes of all sizes. */
		options_set_reply_equal_request(OPT_TSIZE);
	return (0);
}

int
option_timeout(int peer)
{
	int to;

	if (options[OPT_TIMEOUT].o_request == NULL)
		return (0);

	to = atoi(options[OPT_TIMEOUT].o_request);
	if (to < TIMEOUT_MIN || to > TIMEOUT_MAX) {
		tftp_log(acting_as_client ? LOG_ERR : LOG_WARNING,
		    "Received bad value for timeout. "
		    "Should be between %d and %d, received %d",
		    TIMEOUT_MIN, TIMEOUT_MAX, to);
		send_error(peer, EBADOP);
		if (acting_as_client)
			return (1);
		exit(1);
	} else {
		timeoutpacket = to;
		options_set_reply_equal_request(OPT_TIMEOUT);
	}
	settimeouts(timeoutpacket, timeoutnetwork, maxtimeouts);

	if (debug & DEBUG_OPTIONS)
		tftp_log(LOG_DEBUG, "Setting timeout to '%s'",
			options[OPT_TIMEOUT].o_reply);

	return (0);
}

int
option_rollover(int peer)
{

	if (options[OPT_ROLLOVER].o_request == NULL)
		return (0);

	if (strcmp(options[OPT_ROLLOVER].o_request, "0") != 0
	 && strcmp(options[OPT_ROLLOVER].o_request, "1") != 0) {
		tftp_log(acting_as_client ? LOG_ERR : LOG_WARNING,
		    "Bad value for rollover, "
		    "should be either 0 or 1, received '%s', "
		    "ignoring request",
		    options[OPT_ROLLOVER].o_request);
		if (acting_as_client) {
			send_error(peer, EBADOP);
			return (1);
		}
		return (0);
	}
	options_set_reply_equal_request(OPT_ROLLOVER);

	if (debug & DEBUG_OPTIONS)
		tftp_log(LOG_DEBUG, "Setting rollover to '%s'",
			options[OPT_ROLLOVER].o_reply);

	return (0);
}

int
option_blksize(int peer)
{
	u_long maxdgram;
	size_t len;

	if (options[OPT_BLKSIZE].o_request == NULL)
		return (0);

	/* maximum size of an UDP packet according to the system */
	len = sizeof(maxdgram);
	if (sysctlbyname("net.inet.udp.maxdgram",
	    &maxdgram, &len, NULL, 0) < 0) {
		tftp_log(LOG_ERR, "sysctl: net.inet.udp.maxdgram");
		return (acting_as_client ? 1 : 0);
	}
	maxdgram -= 4; /* leave room for header */

	int size = atoi(options[OPT_BLKSIZE].o_request);
	if (size < BLKSIZE_MIN || size > BLKSIZE_MAX) {
		if (acting_as_client) {
			tftp_log(LOG_ERR,
			    "Invalid blocksize (%d bytes), aborting",
			    size);
			send_error(peer, EBADOP);
			return (1);
		} else {
			tftp_log(LOG_WARNING,
			    "Invalid blocksize (%d bytes), ignoring request",
			    size);
			return (0);
		}
	}

	if (size > (int)maxdgram) {
		if (acting_as_client) {
			tftp_log(LOG_ERR,
			    "Invalid blocksize (%d bytes), "
			    "net.inet.udp.maxdgram sysctl limits it to "
			    "%ld bytes.\n", size, maxdgram);
			send_error(peer, EBADOP);
			return (1);
		} else {
			tftp_log(LOG_WARNING,
			    "Invalid blocksize (%d bytes), "
			    "net.inet.udp.maxdgram sysctl limits it to "
			    "%ld bytes.\n", size, maxdgram);
			size = maxdgram;
			/* No reason to return */
		}
	}

	options_set_reply(OPT_BLKSIZE, "%d", size);
	segsize = size;
	pktsize = size + 4;
	if (debug & DEBUG_OPTIONS)
		tftp_log(LOG_DEBUG, "Setting blksize to '%s'",
		    options[OPT_BLKSIZE].o_reply);

	return (0);
}

int
option_blksize2(int peer __unused)
{
	u_long	maxdgram;
	int	size, i;
	size_t	len;

	int sizes[] = {
		8, 16, 32, 64, 128, 256, 512, 1024,
		2048, 4096, 8192, 16384, 32768, 0
	};

	if (options[OPT_BLKSIZE2].o_request == NULL)
		return (0);

	/* maximum size of an UDP packet according to the system */
	len = sizeof(maxdgram);
	if (sysctlbyname("net.inet.udp.maxdgram",
	    &maxdgram, &len, NULL, 0) < 0) {
		tftp_log(LOG_ERR, "sysctl: net.inet.udp.maxdgram");
		return (acting_as_client ? 1 : 0);
	}

	size = atoi(options[OPT_BLKSIZE2].o_request);
	for (i = 0; sizes[i] != 0; i++) {
		if (size == sizes[i]) break;
	}
	if (sizes[i] == 0) {
		tftp_log(LOG_INFO,
		    "Invalid blocksize2 (%d bytes), ignoring request", size);
		return (acting_as_client ? 1 : 0);
	}

	if (size > (int)maxdgram) {
		for (i = 0; sizes[i+1] != 0; i++) {
			if ((int)maxdgram < sizes[i+1]) break;
		}
		tftp_log(LOG_INFO,
		    "Invalid blocksize2 (%d bytes), net.inet.udp.maxdgram "
		    "sysctl limits it to %ld bytes.\n", size, maxdgram);
		size = sizes[i];
		/* No need to return */
	}

	options_set_reply(OPT_BLKSIZE2, "%d", size);
	segsize = size;
	pktsize = size + 4;
	if (debug & DEBUG_OPTIONS)
		tftp_log(LOG_DEBUG, "Setting blksize2 to '%s'",
		    options[OPT_BLKSIZE2].o_reply);

	return (0);
}

int
option_windowsize(int peer)
{
	int size;

	if (options[OPT_WINDOWSIZE].o_request == NULL)
		return (0);

	size = atoi(options[OPT_WINDOWSIZE].o_request);
	if (size < WINDOWSIZE_MIN || size > WINDOWSIZE_MAX) {
		if (acting_as_client) {
			tftp_log(LOG_ERR,
			    "Invalid windowsize (%d blocks), aborting",
			    size);
			send_error(peer, EBADOP);
			return (1);
		} else {
			tftp_log(LOG_WARNING,
			    "Invalid windowsize (%d blocks), ignoring request",
			    size);
			return (0);
		}
	}

	/* XXX: Should force a windowsize of 1 for non-seekable files. */
	options_set_reply(OPT_WINDOWSIZE, "%d", size);
	windowsize = size;

	if (debug & DEBUG_OPTIONS)
		tftp_log(LOG_DEBUG, "Setting windowsize to '%s'",
		    options[OPT_WINDOWSIZE].o_reply);

	return (0);
}

/*
 * Append the available options to the header
 */
uint16_t
make_options(int peer __unused, char *buffer, uint16_t size) {
	int	i;
	char	*value;
	const char *option;
	uint16_t length;
	uint16_t returnsize = 0;

	if (!options_rfc_enabled) return (0);

	for (i = 0; options[i].o_type != NULL; i++) {
		if (options[i].rfc == 0 && !options_extra_enabled)
			continue;

		option = options[i].o_type;
		if (acting_as_client)
			value = options[i].o_request;
		else
			value = options[i].o_reply;
		if (value == NULL)
			continue;

		length = strlen(value) + strlen(option) + 2;
		if (size <= length) {
			tftp_log(LOG_ERR,
			    "Running out of option space for "
			    "option '%s' with value '%s': "
			    "needed %d bytes, got %d bytes",
			    option, value, size, length);
			continue;
		}

		sprintf(buffer, "%s%c%s%c", option, '\000', value, '\000');
		size -= length;
		buffer += length;
		returnsize += length;
	}

	return (returnsize);
}

/*
 * Parse the received options in the header
 */
int
parse_options(int peer, char *buffer, uint16_t size)
{
	int	i, options_failed;
	char	*c, *cp, *option, *value;

	if (!options_rfc_enabled) return (0);

	/* Parse the options */
	cp = buffer;
	options_failed = 0;
	while (size > 0) {
		option = cp;
		i = get_field(peer, cp, size);
		cp += i;

		value = cp;
		i = get_field(peer, cp, size);
		cp += i;

		/* We are at the end */
		if (*option == '\0') break;

		if (debug & DEBUG_OPTIONS)
			tftp_log(LOG_DEBUG,
			    "option: '%s' value: '%s'", option, value);

		for (c = option; *c; c++)
			if (isupper(*c))
				*c = tolower(*c);
		for (i = 0; options[i].o_type != NULL; i++) {
			if (strcmp(option, options[i].o_type) == 0) {
				if (!acting_as_client)
					options_set_request(i, "%s", value);
				if (!options_extra_enabled && !options[i].rfc) {
					tftp_log(LOG_INFO,
					    "Option '%s' with value '%s' found "
					    "but it is not an RFC option",
					    option, value);
					continue;
				}
				if (options[i].o_handler)
					options_failed +=
					    (options[i].o_handler)(peer);
				break;
			}
		}
		if (options[i].o_type == NULL)
			tftp_log(LOG_WARNING,
			    "Unknown option: '%s'", option);

		size -= strlen(option) + strlen(value) + 2;
	}

	return (options_failed);
}

/*
 * Set some default values in the options
 */
void
init_options(void)
{

	options_set_request(OPT_ROLLOVER, "0");
}