fdf929ff91
The windowsize option permits multiple blocks to be transmitted before the receiver sends an ACK improving throughput for larger files. Reviewed by: asomers MFC after: 2 weeks Sponsored by: DARPA Differential Revision: https://reviews.freebsd.org/D23836
427 lines
10 KiB
C
427 lines
10 KiB
C
/*-
|
|
* SPDX-License-Identifier: BSD-2-Clause-FreeBSD
|
|
*
|
|
* 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/cdefs.h>
|
|
__FBSDID("$FreeBSD$");
|
|
|
|
#include <sys/socket.h>
|
|
#include <sys/types.h>
|
|
#include <sys/sysctl.h>
|
|
#include <sys/stat.h>
|
|
|
|
#include <netinet/in.h>
|
|
#include <arpa/tftp.h>
|
|
|
|
#include <ctype.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;
|
|
|
|
/*
|
|
* 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)
|
|
asprintf(&options[OPT_TSIZE].o_reply,
|
|
"%ju", stbuf->st_size);
|
|
else
|
|
/* XXX Allows writes of all sizes. */
|
|
options[OPT_TSIZE].o_reply =
|
|
strdup(options[OPT_TSIZE].o_request);
|
|
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[OPT_TIMEOUT].o_reply =
|
|
strdup(options[OPT_TIMEOUT].o_request);
|
|
}
|
|
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[OPT_ROLLOVER].o_reply =
|
|
strdup(options[OPT_ROLLOVER].o_request);
|
|
|
|
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);
|
|
}
|
|
|
|
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 */
|
|
}
|
|
}
|
|
|
|
asprintf(&options[OPT_BLKSIZE].o_reply, "%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 */
|
|
}
|
|
|
|
asprintf(&options[OPT_BLKSIZE2].o_reply, "%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. */
|
|
asprintf(&options[OPT_WINDOWSIZE].o_reply, "%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[i].o_request = 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[OPT_ROLLOVER].o_request = strdup("0");
|
|
}
|