mirror of
https://github.com/xemu-project/xemu.git
synced 2024-12-12 22:16:19 +00:00
95b1ad7ad8
This option is described in RFC 1783. As this is only an optional field, we may ignore it in some situations and handle it in some others. However, MS Windows 2003 PXE boot client requests a block size of the MTU (most of the times 1472 bytes), and doesn't work if the option is not acknowledged (with whatever value). According to the RFC 1783, we cannot acknowledge the option with a bigger value than the requested one. As current implementation is using 512 bytes by block, accept the option with a value of 512 if the option was specified, and don't acknowledge it if it is not present or less than 512 bytes. Signed-off-by: Hervé Poussineau <hpoussin@reactos.org> Signed-off-by: Jan Kiszka <jan.kiszka@siemens.com>
443 lines
10 KiB
C
443 lines
10 KiB
C
/*
|
|
* tftp.c - a simple, read-only tftp server for qemu
|
|
*
|
|
* Copyright (c) 2004 Magnus Damm <damm@opensource.se>
|
|
*
|
|
* Permission is hereby granted, free of charge, to any person obtaining a copy
|
|
* of this software and associated documentation files (the "Software"), to deal
|
|
* in the Software without restriction, including without limitation the rights
|
|
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
|
|
* copies of the Software, and to permit persons to whom the Software is
|
|
* furnished to do so, subject to the following conditions:
|
|
*
|
|
* The above copyright notice and this permission notice shall be included in
|
|
* all copies or substantial portions of the Software.
|
|
*
|
|
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
|
|
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
|
|
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
|
|
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
|
|
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
|
|
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
|
|
* THE SOFTWARE.
|
|
*/
|
|
|
|
#include <slirp.h>
|
|
#include "qemu-common.h"
|
|
|
|
static inline int tftp_session_in_use(struct tftp_session *spt)
|
|
{
|
|
return (spt->slirp != NULL);
|
|
}
|
|
|
|
static inline void tftp_session_update(struct tftp_session *spt)
|
|
{
|
|
spt->timestamp = curtime;
|
|
}
|
|
|
|
static void tftp_session_terminate(struct tftp_session *spt)
|
|
{
|
|
if (spt->fd >= 0) {
|
|
close(spt->fd);
|
|
spt->fd = -1;
|
|
}
|
|
g_free(spt->filename);
|
|
spt->slirp = NULL;
|
|
}
|
|
|
|
static int tftp_session_allocate(Slirp *slirp, struct tftp_t *tp)
|
|
{
|
|
struct tftp_session *spt;
|
|
int k;
|
|
|
|
for (k = 0; k < TFTP_SESSIONS_MAX; k++) {
|
|
spt = &slirp->tftp_sessions[k];
|
|
|
|
if (!tftp_session_in_use(spt))
|
|
goto found;
|
|
|
|
/* sessions time out after 5 inactive seconds */
|
|
if ((int)(curtime - spt->timestamp) > 5000) {
|
|
tftp_session_terminate(spt);
|
|
goto found;
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
|
|
found:
|
|
memset(spt, 0, sizeof(*spt));
|
|
memcpy(&spt->client_ip, &tp->ip.ip_src, sizeof(spt->client_ip));
|
|
spt->fd = -1;
|
|
spt->client_port = tp->udp.uh_sport;
|
|
spt->slirp = slirp;
|
|
|
|
tftp_session_update(spt);
|
|
|
|
return k;
|
|
}
|
|
|
|
static int tftp_session_find(Slirp *slirp, struct tftp_t *tp)
|
|
{
|
|
struct tftp_session *spt;
|
|
int k;
|
|
|
|
for (k = 0; k < TFTP_SESSIONS_MAX; k++) {
|
|
spt = &slirp->tftp_sessions[k];
|
|
|
|
if (tftp_session_in_use(spt)) {
|
|
if (!memcmp(&spt->client_ip, &tp->ip.ip_src, sizeof(spt->client_ip))) {
|
|
if (spt->client_port == tp->udp.uh_sport) {
|
|
return k;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
return -1;
|
|
}
|
|
|
|
static int tftp_read_data(struct tftp_session *spt, uint32_t block_nr,
|
|
uint8_t *buf, int len)
|
|
{
|
|
int bytes_read = 0;
|
|
|
|
if (spt->fd < 0) {
|
|
spt->fd = open(spt->filename, O_RDONLY | O_BINARY);
|
|
}
|
|
|
|
if (spt->fd < 0) {
|
|
return -1;
|
|
}
|
|
|
|
if (len) {
|
|
lseek(spt->fd, block_nr * 512, SEEK_SET);
|
|
|
|
bytes_read = read(spt->fd, buf, len);
|
|
}
|
|
|
|
return bytes_read;
|
|
}
|
|
|
|
static int tftp_send_oack(struct tftp_session *spt,
|
|
const char *keys[], uint32_t values[], int nb,
|
|
struct tftp_t *recv_tp)
|
|
{
|
|
struct sockaddr_in saddr, daddr;
|
|
struct mbuf *m;
|
|
struct tftp_t *tp;
|
|
int i, n = 0;
|
|
|
|
m = m_get(spt->slirp);
|
|
|
|
if (!m)
|
|
return -1;
|
|
|
|
memset(m->m_data, 0, m->m_size);
|
|
|
|
m->m_data += IF_MAXLINKHDR;
|
|
tp = (void *)m->m_data;
|
|
m->m_data += sizeof(struct udpiphdr);
|
|
|
|
tp->tp_op = htons(TFTP_OACK);
|
|
for (i = 0; i < nb; i++) {
|
|
n += snprintf(tp->x.tp_buf + n, sizeof(tp->x.tp_buf) - n, "%s",
|
|
keys[i]) + 1;
|
|
n += snprintf(tp->x.tp_buf + n, sizeof(tp->x.tp_buf) - n, "%u",
|
|
values[i]) + 1;
|
|
}
|
|
|
|
saddr.sin_addr = recv_tp->ip.ip_dst;
|
|
saddr.sin_port = recv_tp->udp.uh_dport;
|
|
|
|
daddr.sin_addr = spt->client_ip;
|
|
daddr.sin_port = spt->client_port;
|
|
|
|
m->m_len = sizeof(struct tftp_t) - 514 + n -
|
|
sizeof(struct ip) - sizeof(struct udphdr);
|
|
udp_output2(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY);
|
|
|
|
return 0;
|
|
}
|
|
|
|
static void tftp_send_error(struct tftp_session *spt,
|
|
uint16_t errorcode, const char *msg,
|
|
struct tftp_t *recv_tp)
|
|
{
|
|
struct sockaddr_in saddr, daddr;
|
|
struct mbuf *m;
|
|
struct tftp_t *tp;
|
|
|
|
m = m_get(spt->slirp);
|
|
|
|
if (!m) {
|
|
goto out;
|
|
}
|
|
|
|
memset(m->m_data, 0, m->m_size);
|
|
|
|
m->m_data += IF_MAXLINKHDR;
|
|
tp = (void *)m->m_data;
|
|
m->m_data += sizeof(struct udpiphdr);
|
|
|
|
tp->tp_op = htons(TFTP_ERROR);
|
|
tp->x.tp_error.tp_error_code = htons(errorcode);
|
|
pstrcpy((char *)tp->x.tp_error.tp_msg, sizeof(tp->x.tp_error.tp_msg), msg);
|
|
|
|
saddr.sin_addr = recv_tp->ip.ip_dst;
|
|
saddr.sin_port = recv_tp->udp.uh_dport;
|
|
|
|
daddr.sin_addr = spt->client_ip;
|
|
daddr.sin_port = spt->client_port;
|
|
|
|
m->m_len = sizeof(struct tftp_t) - 514 + 3 + strlen(msg) -
|
|
sizeof(struct ip) - sizeof(struct udphdr);
|
|
|
|
udp_output2(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY);
|
|
|
|
out:
|
|
tftp_session_terminate(spt);
|
|
}
|
|
|
|
static void tftp_send_next_block(struct tftp_session *spt,
|
|
struct tftp_t *recv_tp)
|
|
{
|
|
struct sockaddr_in saddr, daddr;
|
|
struct mbuf *m;
|
|
struct tftp_t *tp;
|
|
int nobytes;
|
|
|
|
m = m_get(spt->slirp);
|
|
|
|
if (!m) {
|
|
return;
|
|
}
|
|
|
|
memset(m->m_data, 0, m->m_size);
|
|
|
|
m->m_data += IF_MAXLINKHDR;
|
|
tp = (void *)m->m_data;
|
|
m->m_data += sizeof(struct udpiphdr);
|
|
|
|
tp->tp_op = htons(TFTP_DATA);
|
|
tp->x.tp_data.tp_block_nr = htons((spt->block_nr + 1) & 0xffff);
|
|
|
|
saddr.sin_addr = recv_tp->ip.ip_dst;
|
|
saddr.sin_port = recv_tp->udp.uh_dport;
|
|
|
|
daddr.sin_addr = spt->client_ip;
|
|
daddr.sin_port = spt->client_port;
|
|
|
|
nobytes = tftp_read_data(spt, spt->block_nr, tp->x.tp_data.tp_buf, 512);
|
|
|
|
if (nobytes < 0) {
|
|
m_free(m);
|
|
|
|
/* send "file not found" error back */
|
|
|
|
tftp_send_error(spt, 1, "File not found", tp);
|
|
|
|
return;
|
|
}
|
|
|
|
m->m_len = sizeof(struct tftp_t) - (512 - nobytes) -
|
|
sizeof(struct ip) - sizeof(struct udphdr);
|
|
|
|
udp_output2(NULL, m, &saddr, &daddr, IPTOS_LOWDELAY);
|
|
|
|
if (nobytes == 512) {
|
|
tftp_session_update(spt);
|
|
}
|
|
else {
|
|
tftp_session_terminate(spt);
|
|
}
|
|
|
|
spt->block_nr++;
|
|
}
|
|
|
|
static void tftp_handle_rrq(Slirp *slirp, struct tftp_t *tp, int pktlen)
|
|
{
|
|
struct tftp_session *spt;
|
|
int s, k;
|
|
size_t prefix_len;
|
|
char *req_fname;
|
|
const char *option_name[2];
|
|
uint32_t option_value[2];
|
|
int nb_options = 0;
|
|
|
|
/* check if a session already exists and if so terminate it */
|
|
s = tftp_session_find(slirp, tp);
|
|
if (s >= 0) {
|
|
tftp_session_terminate(&slirp->tftp_sessions[s]);
|
|
}
|
|
|
|
s = tftp_session_allocate(slirp, tp);
|
|
|
|
if (s < 0) {
|
|
return;
|
|
}
|
|
|
|
spt = &slirp->tftp_sessions[s];
|
|
|
|
/* unspecifed prefix means service disabled */
|
|
if (!slirp->tftp_prefix) {
|
|
tftp_send_error(spt, 2, "Access violation", tp);
|
|
return;
|
|
}
|
|
|
|
/* skip header fields */
|
|
k = 0;
|
|
pktlen -= offsetof(struct tftp_t, x.tp_buf);
|
|
|
|
/* prepend tftp_prefix */
|
|
prefix_len = strlen(slirp->tftp_prefix);
|
|
spt->filename = g_malloc(prefix_len + TFTP_FILENAME_MAX + 2);
|
|
memcpy(spt->filename, slirp->tftp_prefix, prefix_len);
|
|
spt->filename[prefix_len] = '/';
|
|
|
|
/* get name */
|
|
req_fname = spt->filename + prefix_len + 1;
|
|
|
|
while (1) {
|
|
if (k >= TFTP_FILENAME_MAX || k >= pktlen) {
|
|
tftp_send_error(spt, 2, "Access violation", tp);
|
|
return;
|
|
}
|
|
req_fname[k] = tp->x.tp_buf[k];
|
|
if (req_fname[k++] == '\0') {
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* check mode */
|
|
if ((pktlen - k) < 6) {
|
|
tftp_send_error(spt, 2, "Access violation", tp);
|
|
return;
|
|
}
|
|
|
|
if (strcasecmp(&tp->x.tp_buf[k], "octet") != 0) {
|
|
tftp_send_error(spt, 4, "Unsupported transfer mode", tp);
|
|
return;
|
|
}
|
|
|
|
k += 6; /* skipping octet */
|
|
|
|
/* do sanity checks on the filename */
|
|
if (!strncmp(req_fname, "../", 3) ||
|
|
req_fname[strlen(req_fname) - 1] == '/' ||
|
|
strstr(req_fname, "/../")) {
|
|
tftp_send_error(spt, 2, "Access violation", tp);
|
|
return;
|
|
}
|
|
|
|
/* check if the file exists */
|
|
if (tftp_read_data(spt, 0, NULL, 0) < 0) {
|
|
tftp_send_error(spt, 1, "File not found", tp);
|
|
return;
|
|
}
|
|
|
|
if (tp->x.tp_buf[pktlen - 1] != 0) {
|
|
tftp_send_error(spt, 2, "Access violation", tp);
|
|
return;
|
|
}
|
|
|
|
while (k < pktlen && nb_options < ARRAY_SIZE(option_name)) {
|
|
const char *key, *value;
|
|
|
|
key = &tp->x.tp_buf[k];
|
|
k += strlen(key) + 1;
|
|
|
|
if (k >= pktlen) {
|
|
tftp_send_error(spt, 2, "Access violation", tp);
|
|
return;
|
|
}
|
|
|
|
value = &tp->x.tp_buf[k];
|
|
k += strlen(value) + 1;
|
|
|
|
if (strcasecmp(key, "tsize") == 0) {
|
|
int tsize = atoi(value);
|
|
struct stat stat_p;
|
|
|
|
if (tsize == 0) {
|
|
if (stat(spt->filename, &stat_p) == 0)
|
|
tsize = stat_p.st_size;
|
|
else {
|
|
tftp_send_error(spt, 1, "File not found", tp);
|
|
return;
|
|
}
|
|
}
|
|
|
|
option_name[nb_options] = "tsize";
|
|
option_value[nb_options] = tsize;
|
|
nb_options++;
|
|
} else if (strcasecmp(key, "blksize") == 0) {
|
|
int blksize = atoi(value);
|
|
|
|
/* If blksize option is bigger than what we will
|
|
* emit, accept the option with our packet size.
|
|
* Otherwise, simply do as we didn't see the option.
|
|
*/
|
|
if (blksize >= 512) {
|
|
option_name[nb_options] = "blksize";
|
|
option_value[nb_options] = 512;
|
|
nb_options++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (nb_options > 0) {
|
|
assert(nb_options <= ARRAY_SIZE(option_name));
|
|
tftp_send_oack(spt, option_name, option_value, nb_options, tp);
|
|
return;
|
|
}
|
|
|
|
spt->block_nr = 0;
|
|
tftp_send_next_block(spt, tp);
|
|
}
|
|
|
|
static void tftp_handle_ack(Slirp *slirp, struct tftp_t *tp, int pktlen)
|
|
{
|
|
int s;
|
|
|
|
s = tftp_session_find(slirp, tp);
|
|
|
|
if (s < 0) {
|
|
return;
|
|
}
|
|
|
|
tftp_send_next_block(&slirp->tftp_sessions[s], tp);
|
|
}
|
|
|
|
static void tftp_handle_error(Slirp *slirp, struct tftp_t *tp, int pktlen)
|
|
{
|
|
int s;
|
|
|
|
s = tftp_session_find(slirp, tp);
|
|
|
|
if (s < 0) {
|
|
return;
|
|
}
|
|
|
|
tftp_session_terminate(&slirp->tftp_sessions[s]);
|
|
}
|
|
|
|
void tftp_input(struct mbuf *m)
|
|
{
|
|
struct tftp_t *tp = (struct tftp_t *)m->m_data;
|
|
|
|
switch(ntohs(tp->tp_op)) {
|
|
case TFTP_RRQ:
|
|
tftp_handle_rrq(m->slirp, tp, m->m_len);
|
|
break;
|
|
|
|
case TFTP_ACK:
|
|
tftp_handle_ack(m->slirp, tp, m->m_len);
|
|
break;
|
|
|
|
case TFTP_ERROR:
|
|
tftp_handle_error(m->slirp, tp, m->m_len);
|
|
break;
|
|
}
|
|
}
|