OpenSolaris_b135/grub/grub-0.97/netboot/fsys_tftp.c
/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2000,2001,2002,2004 Free Software Foundation, Inc.
*
* This program is free software; you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation; either version 2 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program; if not, write to the Free Software
* Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
*/
/* Based on "src/main.c" in etherboot-4.5.8. */
/**************************************************************************
ETHERBOOT - BOOTP/TFTP Bootstrap Program
Author: Martin Renters
Date: Dec/93
**************************************************************************/
/* #define TFTP_DEBUG 1 */
#include <filesys.h>
#include <shared.h>
#include "grub.h"
#include "tftp.h"
#include "nic.h"
static int tftp_file_read_undi(const char *name,
int (*fnc)(unsigned char *, unsigned int, unsigned int, int));
static int tftp_read_undi(char *addr, int size);
static int tftp_dir_undi(char *dirname);
static void tftp_close_undi(void);
static int buf_fill_undi(int abort);
extern int use_bios_pxe;
static int retry;
static unsigned short iport = 2000;
static unsigned short oport = 0;
static unsigned short block, prevblock;
static int bcounter;
static struct tftp_t tp, saved_tp;
static int packetsize;
static int buf_eof, buf_read;
static int saved_filepos;
static unsigned short len, saved_len;
static char *buf, *saved_name;
/**
* tftp_read
*
* Read file with _name_, data handled by _fnc_. In fact, grub never
* use it, we just use it to read dhcp config file.
*/
static int await_tftp(int ival, void *ptr __unused,
unsigned short ptype __unused, struct iphdr *ip,
struct udphdr *udp)
{
static int tftp_count = 0;
if (!udp) {
return 0;
}
if (arptable[ARP_CLIENT].ipaddr.s_addr != ip->dest.s_addr)
return 0;
if (ntohs(udp->dest) != ival)
return 0;
tftp_count++; /* show progress */
if ((tftp_count % 1000) == 0)
printf(".");
return 1;
}
int tftp_file_read(const char *name, int (*fnc)(unsigned char *, unsigned int, unsigned int, int))
{
struct tftpreq_t tp;
struct tftp_t *tr;
int rc;
if (use_bios_pxe)
return (tftp_file_read_undi(name, fnc));
retry = 0;
block = 0;
prevblock = 0;
bcounter = 0;
rx_qdrain();
tp.opcode = htons(TFTP_RRQ);
/* Warning: the following assumes the layout of bootp_t.
But that's fixed by the IP, UDP and BOOTP specs. */
len = sizeof(tp.ip) + sizeof(tp.udp) + sizeof(tp.opcode) +
sprintf((char *)tp.u.rrq, "%s%coctet%cblksize%c%d",
name, 0, 0, 0, TFTP_MAX_PACKET) + 1;
if (!udp_transmit(arptable[ARP_SERVER].ipaddr.s_addr, ++iport,
TFTP_PORT, len, &tp))
return (0);
for (;;)
{
long timeout;
#ifdef CONGESTED
timeout = rfc2131_sleep_interval(block?TFTP_REXMT: TIMEOUT, retry);
#else
timeout = rfc2131_sleep_interval(TIMEOUT, retry);
#endif
if (!await_reply(await_tftp, iport, NULL, timeout))
{
if (!block && retry++ < MAX_TFTP_RETRIES)
{ /* maybe initial request was lost */
if (!udp_transmit(arptable[ARP_SERVER].ipaddr.s_addr,
++iport, TFTP_PORT, len, &tp))
return (0);
continue;
}
#ifdef CONGESTED
if (block && ((retry += TFTP_REXMT) < TFTP_TIMEOUT))
{ /* we resend our last ack */
#ifdef MDEBUG
printf("<REXMT>\n");
#endif
udp_transmit(arptable[ARP_SERVER].ipaddr.s_addr,
iport, oport,
TFTP_MIN_PACKET, &tp);
continue;
}
#endif
break; /* timeout */
}
tr = (struct tftp_t *)&nic.packet[ETH_HLEN];
if (tr->opcode == ntohs(TFTP_ERROR))
{
printf("TFTP error %d (%s)\n",
ntohs(tr->u.err.errcode),
tr->u.err.errmsg);
break;
}
if (tr->opcode == ntohs(TFTP_OACK)) {
char *p = tr->u.oack.data, *e;
if (prevblock) /* shouldn't happen */
continue; /* ignore it */
len = ntohs(tr->udp.len) - sizeof(struct udphdr) - 2;
if (len > TFTP_MAX_PACKET)
goto noak;
e = p + len;
while (*p != '\0' && p < e) {
/* if (!strcasecmp("blksize", p)) { */
if (!grub_strcmp("blksize", p)) {
p += 8;
/* if ((packetsize = strtoul(p, &p, 10)) < */
if ((packetsize = getdec(&p)) < TFTP_DEFAULTSIZE_PACKET)
goto noak;
while (p < e && *p) p++;
if (p < e)
p++;
}
else {
noak:
tp.opcode = htons(TFTP_ERROR);
tp.u.err.errcode = 8;
/*
* Warning: the following assumes the layout of bootp_t.
* But that's fixed by the IP, UDP and BOOTP specs.
*/
len = sizeof(tp.ip) + sizeof(tp.udp) + sizeof(tp.opcode) + sizeof(tp.u.err.errcode) +
/*
* Normally bad form to omit the format string, but in this case
* the string we are copying from is fixed. sprintf is just being
* used as a strcpy and strlen.
*/
sprintf((char *)tp.u.err.errmsg,
"RFC1782 error") + 1;
udp_transmit(arptable[ARP_SERVER].ipaddr.s_addr,
iport, ntohs(tr->udp.src),
len, &tp);
return (0);
}
}
if (p > e)
goto noak;
block = tp.u.ack.block = 0; /* this ensures, that */
/* the packet does not get */
/* processed as data! */
}
else if (tr->opcode == htons(TFTP_DATA)) {
len = ntohs(tr->udp.len) - sizeof(struct udphdr) - 4;
if (len > packetsize) /* shouldn't happen */
continue; /* ignore it */
block = ntohs(tp.u.ack.block = tr->u.data.block); }
else {/* neither TFTP_OACK nor TFTP_DATA */
break;
}
if ((block || bcounter) && (block != (unsigned short)(prevblock+1))) {
/* Block order should be continuous */
tp.u.ack.block = htons(block = prevblock);
}
tp.opcode = htons(TFTP_ACK);
oport = ntohs(tr->udp.src);
udp_transmit(arptable[ARP_SERVER].ipaddr.s_addr, iport,
oport, TFTP_MIN_PACKET, &tp); /* ack */
if ((unsigned short)(block-prevblock) != 1) {
/* Retransmission or OACK, don't process via callback
* and don't change the value of prevblock. */
continue;
}
prevblock = block;
retry = 0; /* It's the right place to zero the timer? */
if ((rc = fnc(tr->u.data.download,
++bcounter, len, len < packetsize)) <= 0)
return(rc);
if (len < packetsize) { /* End of data --- fnc should not have returned */
printf("tftp download complete, but\n");
return (1);
}
}
return (0);
}
/* Fill the buffer by receiving the data via the TFTP protocol. */
static int
buf_fill (int abort)
{
#ifdef TFTP_DEBUG
grub_printf ("buf_fill (%d)\n", abort);
#endif
if (use_bios_pxe)
return (buf_fill_undi(abort));
while (! buf_eof && (buf_read + packetsize <= FSYS_BUFLEN))
{
struct tftp_t *tr;
long timeout;
#ifdef CONGESTED
timeout = rfc2131_sleep_interval (block ? TFTP_REXMT : TIMEOUT, retry);
#else
timeout = rfc2131_sleep_interval (TIMEOUT, retry);
#endif
if (! await_reply (await_tftp, iport, NULL, timeout))
{
if (user_abort)
return 0;
if (! block && retry++ < MAX_TFTP_RETRIES)
{
/* Maybe initial request was lost. */
#ifdef TFTP_DEBUG
grub_printf ("Maybe initial request was lost.\n");
#endif
if (! udp_transmit (arptable[ARP_SERVER].ipaddr.s_addr,
++iport, TFTP_PORT, len, &tp))
return 0;
continue;
}
#ifdef CONGESTED
if (block && ((retry += TFTP_REXMT) < TFTP_TIMEOUT))
{
/* We resend our last ack. */
# ifdef TFTP_DEBUG
grub_printf ("<REXMT>\n");
# endif
udp_transmit (arptable[ARP_SERVER].ipaddr.s_addr,
iport, oport,
TFTP_MIN_PACKET, &tp);
continue;
}
#endif
/* Timeout. */
return 0;
}
tr = (struct tftp_t *) &nic.packet[ETH_HLEN];
if (tr->opcode == ntohs (TFTP_ERROR))
{
grub_printf ("TFTP error %d (%s)\n",
ntohs (tr->u.err.errcode),
tr->u.err.errmsg);
return 0;
}
if (tr->opcode == ntohs (TFTP_OACK))
{
char *p = tr->u.oack.data, *e;
#ifdef TFTP_DEBUG
grub_printf ("OACK ");
#endif
/* Shouldn't happen. */
if (prevblock)
{
/* Ignore it. */
grub_printf ("%s:%d: warning: PREVBLOCK != 0 (0x%x)\n",
__FILE__, __LINE__, prevblock);
continue;
}
len = ntohs (tr->udp.len) - sizeof (struct udphdr) - 2;
if (len > TFTP_MAX_PACKET)
goto noak;
e = p + len;
while (*p != '\000' && p < e)
{
if (! grub_strcmp ("blksize", p))
{
p += 8;
if ((packetsize = getdec (&p)) < TFTP_DEFAULTSIZE_PACKET)
goto noak;
#ifdef TFTP_DEBUG
grub_printf ("blksize = %d\n", packetsize);
#endif
}
else if (! grub_strcmp ("tsize", p))
{
p += 6;
if ((filemax = getdec (&p)) < 0)
{
filemax = -1;
goto noak;
}
#ifdef TFTP_DEBUG
grub_printf ("tsize = %d\n", filemax);
#endif
}
else
{
noak:
#ifdef TFTP_DEBUG
grub_printf ("NOAK\n");
#endif
tp.opcode = htons (TFTP_ERROR);
tp.u.err.errcode = 8;
len = (grub_sprintf ((char *) tp.u.err.errmsg,
"RFC1782 error")
+ sizeof (tp.ip) + sizeof (tp.udp)
+ sizeof (tp.opcode) + sizeof (tp.u.err.errcode)
+ 1);
udp_transmit (arptable[ARP_SERVER].ipaddr.s_addr,
iport, ntohs (tr->udp.src),
len, &tp);
return 0;
}
while (p < e && *p)
p++;
if (p < e)
p++;
}
if (p > e)
goto noak;
/* This ensures that the packet does not get processed as
data! */
block = tp.u.ack.block = 0;
}
else if (tr->opcode == ntohs (TFTP_DATA))
{
#ifdef TFTP_DEBUG
grub_printf ("DATA ");
#endif
len = ntohs (tr->udp.len) - sizeof (struct udphdr) - 4;
/* Shouldn't happen. */
if (len > packetsize)
{
/* Ignore it. */
grub_printf ("%s:%d: warning: LEN > PACKETSIZE (0x%x > 0x%x)\n",
__FILE__, __LINE__, len, packetsize);
continue;
}
block = ntohs (tp.u.ack.block = tr->u.data.block);
}
else
/* Neither TFTP_OACK nor TFTP_DATA. */
break;
if ((block || bcounter) && (block != (unsigned short) (prevblock + 1)))
/* Block order should be continuous */
tp.u.ack.block = htons (block = prevblock);
/* Should be continuous. */
tp.opcode = abort ? htons (TFTP_ERROR) : htons (TFTP_ACK);
oport = ntohs (tr->udp.src);
#ifdef TFTP_DEBUG
grub_printf ("ACK\n");
#endif
/* Ack. */
udp_transmit (arptable[ARP_SERVER].ipaddr.s_addr, iport,
oport, TFTP_MIN_PACKET, &tp);
if (abort)
{
buf_eof = 1;
break;
}
/* Retransmission or OACK. */
if ((unsigned short) (block - prevblock) != 1)
/* Don't process. */
continue;
prevblock = block;
/* Is it the right place to zero the timer? */
retry = 0;
/* In GRUB, this variable doesn't play any important role at all,
but use it for consistency with Etherboot. */
bcounter++;
/* Copy the downloaded data to the buffer. */
grub_memmove (buf + buf_read, tr->u.data.download, len);
buf_read += len;
/* End of data. */
if (len < packetsize)
buf_eof = 1;
}
return 1;
}
/* Send the RRQ whose length is LEN. */
static int
send_rrq (void)
{
/* Initialize some variables. */
retry = 0;
block = 0;
prevblock = 0;
packetsize = TFTP_DEFAULTSIZE_PACKET;
bcounter = 0;
buf = (char *) FSYS_BUF;
buf_eof = 0;
buf_read = 0;
saved_filepos = 0;
rx_qdrain();
#ifdef TFTP_DEBUG
grub_printf ("send_rrq ()\n");
{
int i;
char *p;
for (i = 0, p = (char *) &tp; i < len; i++)
if (p[i] >= ' ' && p[i] <= '~')
grub_putchar (p[i]);
else
grub_printf ("\\%x", (unsigned) p[i]);
grub_putchar ('\n');
}
#endif
/* Send the packet. */
return udp_transmit (arptable[ARP_SERVER].ipaddr.s_addr, ++iport,
TFTP_PORT, len, &tp);
}
/* Mount the network drive. If the drive is ready, return one, otherwise
return zero. */
int
tftp_mount (void)
{
/* Check if the current drive is the network drive. */
if (current_drive != NETWORK_DRIVE)
return 0;
/* If the drive is not initialized yet, abort. */
if (! network_ready)
return 0;
return 1;
}
/* Read up to SIZE bytes, returned in ADDR. */
int
tftp_read (char *addr, int size)
{
/* How many bytes is read? */
int ret = 0;
#ifdef TFTP_DEBUG
grub_printf ("tftp_read (0x%x, %d)\n", (int) addr, size);
#endif
if (use_bios_pxe)
return (tftp_read_undi(addr, size));
if (filepos < saved_filepos)
{
/* Uggh.. FILEPOS has been moved backwards. So reopen the file. */
buf_read = 0;
buf_fill (1);
grub_memmove ((char *) &tp, (char *) &saved_tp, saved_len);
len = saved_len;
#ifdef TFTP_DEBUG
{
int i;
grub_printf ("opcode = 0x%x, rrq = ", (unsigned long) tp.opcode);
for (i = 0; i < TFTP_DEFAULTSIZE_PACKET; i++)
{
if (tp.u.rrq[i] >= ' ' && tp.u.rrq[i] <= '~')
grub_putchar (tp.u.rrq[i]);
else
grub_putchar ('*');
}
grub_putchar ('\n');
}
#endif
if (! send_rrq ())
{
errnum = ERR_WRITE;
return 0;
}
}
while (size > 0)
{
int amt = buf_read + saved_filepos - filepos;
/* If the length that can be copied from the buffer is over the
requested size, cut it down. */
if (amt > size)
amt = size;
if (amt > 0)
{
/* Copy the buffer to the supplied memory space. */
grub_memmove (addr, buf + filepos - saved_filepos, amt);
size -= amt;
addr += amt;
filepos += amt;
ret += amt;
/* If the size of the empty space becomes small, move the unused
data forwards. */
if (filepos - saved_filepos > FSYS_BUFLEN / 2)
{
grub_memmove (buf, buf + FSYS_BUFLEN / 2, FSYS_BUFLEN / 2);
buf_read -= FSYS_BUFLEN / 2;
saved_filepos += FSYS_BUFLEN / 2;
}
}
else
{
/* Skip the whole buffer. */
saved_filepos += buf_read;
buf_read = 0;
}
/* Read the data. */
if (size > 0 && ! buf_fill (0))
{
errnum = ERR_READ;
return 0;
}
/* Sanity check. */
if (size > 0 && buf_read == 0)
{
errnum = ERR_READ;
return 0;
}
}
return ret;
}
/* Check if the file DIRNAME really exists. Get the size and save it in
FILEMAX. */
int
tftp_dir (char *dirname)
{
int ch;
#ifdef TFTP_DEBUG
grub_printf ("tftp_dir (%s)\n", dirname);
#endif
if (use_bios_pxe)
return (tftp_dir_undi(dirname));
/* In TFTP, there is no way to know what files exist. */
if (print_possibilities)
return 1;
/* Don't know the size yet. */
filemax = -1;
reopen:
/* Construct the TFTP request packet. */
tp.opcode = htons (TFTP_RRQ);
/* Terminate the filename. */
ch = nul_terminate (dirname);
/* Make the request string (octet, blksize and tsize). */
len = (grub_sprintf ((char *) tp.u.rrq,
"%s%coctet%cblksize%c%d%ctsize%c0",
dirname, 0, 0, 0, TFTP_MAX_PACKET, 0, 0)
+ sizeof (tp.ip) + sizeof (tp.udp) + sizeof (tp.opcode) + 1);
/* Restore the original DIRNAME. */
dirname[grub_strlen (dirname)] = ch;
/* Save the TFTP packet so that we can reopen the file later. */
grub_memmove ((char *) &saved_tp, (char *) &tp, len);
saved_len = len;
if (! send_rrq ())
{
errnum = ERR_WRITE;
return 0;
}
/* Read the data. */
if (! buf_fill (0))
{
errnum = ERR_FILE_NOT_FOUND;
return 0;
}
if (filemax == -1)
{
/* The server doesn't support the "tsize" option, so we must read
the file twice... */
/* Zero the size of the file. */
filemax = 0;
do
{
/* Add the length of the downloaded data. */
filemax += buf_read;
/* Reset the offset. Just discard the contents of the buffer. */
buf_read = 0;
/* Read the data. */
if (! buf_fill (0))
{
errnum = ERR_READ;
return 0;
}
}
while (! buf_eof);
/* Maybe a few amounts of data remains. */
filemax += buf_read;
/* Retry the open instruction. */
goto reopen;
}
return 1;
}
/* Close the file. */
void
tftp_close (void)
{
#ifdef TFTP_DEBUG
grub_printf ("tftp_close ()\n");
#endif
if (use_bios_pxe) {
tftp_close_undi();
return;
}
buf_read = 0;
buf_fill (1);
}
/* tftp implementation using BIOS established PXE stack */
static int tftp_file_read_undi(const char *name,
int (*fnc)(unsigned char *, unsigned int, unsigned int, int))
{
int rc;
uint16_t len;
buf = (char *)&nic.packet;
/* open tftp session */
if (eb_pxenv_tftp_open(name, arptable[ARP_SERVER].ipaddr,
arptable[ARP_GATEWAY].ipaddr, &packetsize) == 0)
return (0);
/* read blocks and invoke fnc for each block */
for (;;) {
rc = eb_pxenv_tftp_read(buf, &len);
if (rc == 0)
break;
rc = fnc(buf, ++block, len, len < packetsize);
if (rc <= 0 || len < packetsize)
break;
}
(void) eb_pxenv_tftp_close();
return (rc > 0 ? 1 : 0);
}
/* Fill the buffer by reading the data via the TFTP protocol. */
static int
buf_fill_undi(int abort)
{
int rc;
uint8_t *tmpbuf;
while (! buf_eof && (buf_read + packetsize <= FSYS_BUFLEN)) {
poll_interruptions();
if (user_abort)
return 0;
if (abort) {
buf_eof = 1;
break;
}
if (eb_pxenv_tftp_read(buf + buf_read, &len) == 0)
return (0);
buf_read += len;
/* End of data. */
if (len < packetsize)
buf_eof = 1;
}
return 1;
}
static void
tftp_reopen_undi(void)
{
tftp_close();
(void) eb_pxenv_tftp_open(saved_name, arptable[ARP_SERVER].ipaddr,
arptable[ARP_GATEWAY].ipaddr, &packetsize);
buf_eof = 0;
buf_read = 0;
saved_filepos = 0;
}
/* Read up to SIZE bytes, returned in ADDR. */
static int
tftp_read_undi(char *addr, int size)
{
int ret = 0;
if (filepos < saved_filepos) {
/* Uggh.. FILEPOS has been moved backwards. reopen the file. */
tftp_reopen_undi();
}
while (size > 0) {
int amt = buf_read + saved_filepos - filepos;
/* If the length that can be copied from the buffer is over
the requested size, cut it down. */
if (amt > size)
amt = size;
if (amt > 0) {
/* Copy the buffer to the supplied memory space. */
grub_memmove (addr, buf + filepos - saved_filepos, amt);
size -= amt;
addr += amt;
filepos += amt;
ret += amt;
/* If the size of the empty space becomes small,
* move the unused data forwards.
*/
if (filepos - saved_filepos > FSYS_BUFLEN / 2) {
grub_memmove (buf, buf + FSYS_BUFLEN / 2,
FSYS_BUFLEN / 2);
buf_read -= FSYS_BUFLEN / 2;
saved_filepos += FSYS_BUFLEN / 2;
}
} else {
/* Skip the whole buffer. */
saved_filepos += buf_read;
buf_read = 0;
}
/* Read the data. */
if (size > 0 && ! buf_fill (0)) {
errnum = ERR_READ;
return 0;
}
/* Sanity check. */
if (size > 0 && buf_read == 0) {
errnum = ERR_READ;
return 0;
}
}
return ret;
}
static int
tftp_dir_undi(char *dirname)
{
int rc, ch;
uint16_t len;
/* In TFTP, there is no way to know what files exist. */
if (print_possibilities)
return 1;
/* name may be space terminated */
ch = nul_terminate(dirname);
saved_name = (char *)&saved_tp;
sprintf(saved_name, "%s", dirname);
/* Restore the original dirname */
dirname[grub_strlen (dirname)] = ch;
/* get the file size; must call before tftp_open */
rc = eb_pxenv_tftp_get_fsize(saved_name, arptable[ARP_SERVER].ipaddr,
arptable[ARP_GATEWAY].ipaddr, &filemax);
/* open tftp session */
if (eb_pxenv_tftp_open(saved_name, arptable[ARP_SERVER].ipaddr,
arptable[ARP_GATEWAY].ipaddr, &packetsize) == 0)
return (0);
buf = (char *) FSYS_BUF;
buf_eof = 0;
buf_read = 0;
saved_filepos = 0;
if (rc == 0) {
/* Read the entire file to get filemax */
filemax = 0;
do {
/* Add the length of the downloaded data. */
filemax += buf_read;
buf_read = 0;
if (! buf_fill (0)) {
errnum = ERR_READ;
return 0;
}
} while (! buf_eof);
/* Maybe a few amounts of data remains. */
filemax += buf_read;
tftp_reopen_undi(); /* reopen file to read from beginning */
}
return (1);
}
static void
tftp_close_undi(void)
{
buf_read = 0;
buf_fill (1);
(void) eb_pxenv_tftp_close();
}