/*
* GRUB -- GRand Unified Bootloader
* Copyright (C) 2000,2001,2002 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-5.0.5. */
/**************************************************************************
ETHERBOOT - BOOTP/TFTP Bootstrap Program
Author: Martin Renters
Date: Dec/93
Literature dealing with the network protocols:
ARP - RFC826
RARP - RFC903
UDP - RFC768
BOOTP - RFC951, RFC2132 (vendor extensions)
DHCP - RFC2131, RFC2132 (options)
TFTP - RFC1350, RFC2347 (options), RFC2348 (blocksize), RFC2349 (tsize)
RPC - RFC1831, RFC1832 (XDR), RFC1833 (rpcbind/portmapper)
NFS - RFC1094, RFC1813 (v3, useful for clarifications, not implemented)
**************************************************************************/
#define GRUB 1
#include <etherboot.h>
#include <nic.h>
/* #define DEBUG 1 */
struct arptable_t arptable[MAX_ARP];
/* Set if the user pushes Control-C. */
int ip_abort = 0;
/* Set if an ethernet card is probed and IP addresses are set. */
int network_ready = 0;
struct rom_info rom;
static int vendorext_isvalid;
static unsigned long netmask;
static struct bootpd_t bootp_data;
static unsigned long xid;
static unsigned char *end_of_rfc1533 = NULL;
#ifndef NO_DHCP_SUPPORT
#endif /* NO_DHCP_SUPPORT */
/* äEth */
static unsigned char vendorext_magic[] = {0xE4, 0x45, 0x74, 0x68};
static const unsigned char broadcast[] = {0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
#ifdef NO_DHCP_SUPPORT
static unsigned char rfc1533_cookie[5] = {RFC1533_COOKIE, RFC1533_END};
#else /* ! NO_DHCP_SUPPORT */
static int dhcp_reply;
static in_addr dhcp_server = {0L};
static in_addr dhcp_addr = {0L};
static unsigned char rfc1533_cookie[] = {RFC1533_COOKIE};
static unsigned char rfc1533_end[] = {RFC1533_END};
static const unsigned char dhcpdiscover[] =
{
RFC2132_MSG_TYPE, 1, DHCPDISCOVER,
RFC2132_MAX_SIZE,2, /* request as much as we can */
ETH_MAX_MTU / 256, ETH_MAX_MTU % 256,
RFC2132_PARAM_LIST, 4, RFC1533_NETMASK, RFC1533_GATEWAY,
RFC1533_HOSTNAME, RFC1533_EXTENSIONPATH
};
static const unsigned char dhcprequest[] =
{
RFC2132_MSG_TYPE, 1, DHCPREQUEST,
RFC2132_SRV_ID, 4, 0, 0, 0, 0,
RFC2132_REQ_ADDR, 4, 0, 0, 0, 0,
RFC2132_MAX_SIZE, 2, /* request as much as we can */
ETH_MAX_MTU / 256, ETH_MAX_MTU % 256,
/* request parameters */
RFC2132_PARAM_LIST,
/* 4 standard + 2 vendortags */
4 + 2,
/* Standard parameters */
RFC1533_NETMASK, RFC1533_GATEWAY,
RFC1533_HOSTNAME, RFC1533_EXTENSIONPATH,
/* Etherboot vendortags */
RFC1533_VENDOR_MAGIC,
RFC1533_VENDOR_CONFIGFILE,
};
#endif /* ! NO_DHCP_SUPPORT */
static unsigned short ipchksum (unsigned short *ip, int len);
static unsigned short udpchksum (struct iphdr *packet);
void
print_network_configuration (void)
{
if (! eth_probe ())
grub_printf ("No ethernet card found.\n");
else if (! network_ready)
grub_printf ("Not initialized yet.\n");
else
{
etherboot_printf ("Address: %@\n", arptable[ARP_CLIENT].ipaddr.s_addr);
etherboot_printf ("Netmask: %@\n", netmask);
etherboot_printf ("Server: %@\n", arptable[ARP_SERVER].ipaddr.s_addr);
etherboot_printf ("Gateway: %@\n", arptable[ARP_GATEWAY].ipaddr.s_addr);
}
}
/**************************************************************************
DEFAULT_NETMASK - Return default netmask for IP address
**************************************************************************/
static inline unsigned long
default_netmask (void)
{
int net = ntohl (arptable[ARP_CLIENT].ipaddr.s_addr) >> 24;
if (net <= 127)
return (htonl (0xff000000));
else if (net < 192)
return (htonl (0xffff0000));
else
return (htonl (0xffffff00));
}
/* ifconfig - configure network interface. */
int
ifconfig (char *ip, char *sm, char *gw, char *svr)
{
in_addr tmp;
if (sm)
{
if (! inet_aton (sm, &tmp))
return 0;
netmask = tmp.s_addr;
}
if (ip)
{
if (! inet_aton (ip, &arptable[ARP_CLIENT].ipaddr))
return 0;
if (! netmask && ! sm)
netmask = default_netmask ();
}
if (gw && ! inet_aton (gw, &arptable[ARP_GATEWAY].ipaddr))
return 0;
/* Clear out the ARP entry. */
grub_memset (arptable[ARP_GATEWAY].node, 0, ETH_ALEN);
if (svr && ! inet_aton (svr, &arptable[ARP_SERVER].ipaddr))
return 0;
/* Likewise. */
grub_memset (arptable[ARP_SERVER].node, 0, ETH_ALEN);
if (ip || sm)
{
if (IP_BROADCAST == (netmask | arptable[ARP_CLIENT].ipaddr.s_addr)
|| netmask == (netmask | arptable[ARP_CLIENT].ipaddr.s_addr)
|| ! netmask)
network_ready = 0;
else
network_ready = 1;
}
return 1;
}
/**************************************************************************
UDP_TRANSMIT - Send a UDP datagram
**************************************************************************/
int
udp_transmit (unsigned long destip, unsigned int srcsock,
unsigned int destsock, int len, const void *buf)
{
struct iphdr *ip;
struct udphdr *udp;
struct arprequest arpreq;
int arpentry, i;
int retry;
ip = (struct iphdr *) buf;
udp = (struct udphdr *) ((unsigned long) buf + sizeof (struct iphdr));
ip->verhdrlen = 0x45;
ip->service = 0;
ip->len = htons (len);
ip->ident = 0;
ip->frags = 0;
ip->ttl = 60;
ip->protocol = IP_UDP;
ip->chksum = 0;
ip->src.s_addr = arptable[ARP_CLIENT].ipaddr.s_addr;
ip->dest.s_addr = destip;
ip->chksum = ipchksum ((unsigned short *) buf, sizeof (struct iphdr));
udp->src = htons (srcsock);
udp->dest = htons (destsock);
udp->len = htons (len - sizeof (struct iphdr));
udp->chksum = 0;
udp->chksum = htons (udpchksum (ip));
if (udp->chksum == 0)
udp->chksum = 0xffff;
if (destip == IP_BROADCAST)
{
eth_transmit (broadcast, IP, len, buf);
}
else
{
if (((destip & netmask)
!= (arptable[ARP_CLIENT].ipaddr.s_addr & netmask))
&& arptable[ARP_GATEWAY].ipaddr.s_addr)
destip = arptable[ARP_GATEWAY].ipaddr.s_addr;
for (arpentry = 0; arpentry < MAX_ARP; arpentry++)
if (arptable[arpentry].ipaddr.s_addr == destip)
break;
if (arpentry == MAX_ARP)
{
etherboot_printf ("%@ is not in my arp table!\n", destip);
return 0;
}
for (i = 0; i < ETH_ALEN; i++)
if (arptable[arpentry].node[i])
break;
if (i == ETH_ALEN)
{
/* Need to do arp request. */
#ifdef DEBUG
grub_printf ("arp request.\n");
#endif
arpreq.hwtype = htons (1);
arpreq.protocol = htons (IP);
arpreq.hwlen = ETH_ALEN;
arpreq.protolen = 4;
arpreq.opcode = htons (ARP_REQUEST);
grub_memmove (arpreq.shwaddr, arptable[ARP_CLIENT].node,
ETH_ALEN);
grub_memmove (arpreq.sipaddr, (char *) &arptable[ARP_CLIENT].ipaddr,
sizeof (in_addr));
grub_memset (arpreq.thwaddr, 0, ETH_ALEN);
grub_memmove (arpreq.tipaddr, (char *) &destip, sizeof (in_addr));
for (retry = 1; retry <= MAX_ARP_RETRIES; retry++)
{
long timeout;
eth_transmit (broadcast, ARP, sizeof (arpreq), &arpreq);
timeout = rfc2131_sleep_interval (TIMEOUT, retry);
if (await_reply (AWAIT_ARP, arpentry, arpreq.tipaddr, timeout))
goto xmit;
if (ip_abort)
return 0;
}
return 0;
}
xmit:
eth_transmit (arptable[arpentry].node, IP, len, buf);
}
return 1;
}
/**************************************************************************
TFTP - Download extended BOOTP data, or kernel image
**************************************************************************/
static int
tftp (const char *name, int (*fnc) (unsigned char *, int, int, int))
{
int retry = 0;
static unsigned short iport = 2000;
unsigned short oport = 0;
unsigned short len, block = 0, prevblock = 0;
int bcounter = 0;
struct tftp_t *tr;
struct tftpreq_t tp;
int rc;
int packetsize = TFTP_DEFAULTSIZE_PACKET;
/* Clear out the Rx queue first. It contains nothing of interest,
* except possibly ARP requests from the DHCP/TFTP server. We use
* polling throughout Etherboot, so some time may have passed since we
* last polled the receive queue, which may now be filled with
* broadcast packets. This will cause the reply to the packets we are
* about to send to be lost immediately. Not very clever. */
await_reply (AWAIT_QDRAIN, 0, NULL, 0);
tp.opcode = htons (TFTP_RRQ);
len = (grub_sprintf ((char *) tp.u.rrq, "%s%coctet%cblksize%c%d",
name, 0, 0, 0, TFTP_MAX_PACKET)
+ sizeof (tp.ip) + sizeof (tp.udp) + sizeof (tp.opcode) + 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
grub_printf ("<REXMT>\n");
#endif
udp_transmit (arptable[ARP_SERVER].ipaddr.s_addr,
iport, oport,
TFTP_MIN_PACKET, &tp);
continue;
}
#endif
/* Timeout. */
break;
}
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);
break;
}
if (tr->opcode == ntohs (TFTP_OACK))
{
char *p = tr->u.oack.data, *e;
/* Shouldn't happen. */
if (prevblock)
/* Ignore it. */
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;
while (p < e && *p)
p++;
if (p < e)
p++;
}
else
{
noak:
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;
}
}
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))
{
len = ntohs (tr->udp.len) - sizeof (struct udphdr) - 4;
/* Shouldn't happen. */
if (len > packetsize)
/* Ignore it. */
continue;
block = ntohs (tp.u.ack.block = tr->u.data.block);
}
else
/* Neither TFTP_OACK nor TFTP_DATA. */
break;
if ((block || bcounter) && (block != prevblock + 1))
/* Block order should be continuous */
tp.u.ack.block = htons (block = prevblock);
/* Should be continuous. */
tp.opcode = htons (TFTP_ACK);
oport = ntohs (tr->udp.src);
/* Ack. */
udp_transmit (arptable[ARP_SERVER].ipaddr.s_addr, iport,
oport, TFTP_MIN_PACKET, &tp);
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;
/* Is it the right place to zero the timer? */
retry = 0;
if ((rc = fnc (tr->u.data.download,
++bcounter, len, len < packetsize)) >= 0)
return rc;
/* End of data. */
if (len < packetsize)
return 1;
}
return 0;
}
/**************************************************************************
RARP - Get my IP address and load information
**************************************************************************/
int
rarp (void)
{
int retry;
/* arp and rarp requests share the same packet structure. */
struct arprequest rarpreq;
/* Make sure that an ethernet is probed. */
if (! eth_probe ())
return 0;
/* Clear the ready flag. */
network_ready = 0;
grub_memset (&rarpreq, 0, sizeof (rarpreq));
rarpreq.hwtype = htons (1);
rarpreq.protocol = htons (IP);
rarpreq.hwlen = ETH_ALEN;
rarpreq.protolen = 4;
rarpreq.opcode = htons (RARP_REQUEST);
grub_memmove ((char *) &rarpreq.shwaddr, arptable[ARP_CLIENT].node,
ETH_ALEN);
/* sipaddr is already zeroed out */
grub_memmove ((char *) &rarpreq.thwaddr, arptable[ARP_CLIENT].node,
ETH_ALEN);
/* tipaddr is already zeroed out */
for (retry = 0; retry < MAX_ARP_RETRIES; ++retry)
{
long timeout;
eth_transmit (broadcast, RARP, sizeof (rarpreq), &rarpreq);
timeout = rfc2131_sleep_interval (TIMEOUT, retry);
if (await_reply (AWAIT_RARP, 0, rarpreq.shwaddr, timeout))
break;
if (ip_abort)
return 0;
}
if (retry < MAX_ARP_RETRIES)
{
network_ready = 1;
return 1;
}
return 0;
}
/**************************************************************************
BOOTP - Get my IP address and load information
**************************************************************************/
int
bootp (void)
{
int retry;
#ifndef NO_DHCP_SUPPORT
int reqretry;
#endif /* ! NO_DHCP_SUPPORT */
struct bootpip_t ip;
unsigned long starttime;
/* Make sure that an ethernet is probed. */
if (! eth_probe ())
return 0;
/* Clear the ready flag. */
network_ready = 0;
#ifdef DEBUG
grub_printf ("network is ready.\n");
#endif
grub_memset (&ip, 0, sizeof (struct bootpip_t));
ip.bp.bp_op = BOOTP_REQUEST;
ip.bp.bp_htype = 1;
ip.bp.bp_hlen = ETH_ALEN;
starttime = currticks ();
/* Use lower 32 bits of node address, more likely to be
distinct than the time since booting */
grub_memmove (&xid, &arptable[ARP_CLIENT].node[2], sizeof(xid));
ip.bp.bp_xid = xid += htonl (starttime);
grub_memmove (ip.bp.bp_hwaddr, arptable[ARP_CLIENT].node, ETH_ALEN);
#ifdef DEBUG
etherboot_printf ("bp_op = %d\n", ip.bp.bp_op);
etherboot_printf ("bp_htype = %d\n", ip.bp.bp_htype);
etherboot_printf ("bp_hlen = %d\n", ip.bp.bp_hlen);
etherboot_printf ("bp_xid = %d\n", ip.bp.bp_xid);
etherboot_printf ("bp_hwaddr = %!\n", ip.bp.bp_hwaddr);
etherboot_printf ("bp_hops = %d\n", (int) ip.bp.bp_hops);
etherboot_printf ("bp_secs = %d\n", (int) ip.bp.bp_hwaddr);
#endif
#ifdef NO_DHCP_SUPPORT
/* Request RFC-style options. */
grub_memmove (ip.bp.bp_vend, rfc1533_cookie, 5);
#else
/* Request RFC-style options. */
grub_memmove (ip.bp.bp_vend, rfc1533_cookie, sizeof rfc1533_cookie);
grub_memmove (ip.bp.bp_vend + sizeof rfc1533_cookie, dhcpdiscover,
sizeof dhcpdiscover);
grub_memmove (ip.bp.bp_vend + sizeof rfc1533_cookie + sizeof dhcpdiscover,
rfc1533_end, sizeof rfc1533_end);
#endif /* ! NO_DHCP_SUPPORT */
for (retry = 0; retry < MAX_BOOTP_RETRIES;)
{
long timeout;
#ifdef DEBUG
grub_printf ("retry = %d\n", retry);
#endif
/* Clear out the Rx queue first. It contains nothing of
* interest, except possibly ARP requests from the DHCP/TFTP
* server. We use polling throughout Etherboot, so some time
* may have passed since we last polled the receive queue,
* which may now be filled with broadcast packets. This will
* cause the reply to the packets we are about to send to be
* lost immediately. Not very clever. */
await_reply (AWAIT_QDRAIN, 0, NULL, 0);
udp_transmit (IP_BROADCAST, BOOTP_CLIENT, BOOTP_SERVER,
sizeof (struct bootpip_t), &ip);
timeout = rfc2131_sleep_interval (TIMEOUT, retry++);
#ifdef NO_DHCP_SUPPORT
if (await_reply (AWAIT_BOOTP, 0, NULL, timeout))
{
network_ready = 1;
return 1;
}
#else /* ! NO_DHCP_SUPPORT */
if (await_reply (AWAIT_BOOTP, 0, NULL, timeout))
{
if (dhcp_reply != DHCPOFFER)
{
network_ready = 1;
return 1;
}
dhcp_reply = 0;
#ifdef DEBUG
etherboot_printf ("bp_op = %d\n", (int) ip.bp.bp_op);
etherboot_printf ("bp_htype = %d\n", (int) ip.bp.bp_htype);
etherboot_printf ("bp_hlen = %d\n", (int) ip.bp.bp_hlen);
etherboot_printf ("bp_xid = %d\n", (int) ip.bp.bp_xid);
etherboot_printf ("bp_hwaddr = %!\n", ip.bp.bp_hwaddr);
etherboot_printf ("bp_hops = %d\n", (int) ip.bp.bp_hops);
etherboot_printf ("bp_secs = %d\n", (int) ip.bp.bp_hwaddr);
#endif
grub_memmove (ip.bp.bp_vend, rfc1533_cookie, sizeof rfc1533_cookie);
grub_memmove (ip.bp.bp_vend + sizeof rfc1533_cookie,
dhcprequest, sizeof dhcprequest);
grub_memmove (ip.bp.bp_vend + sizeof rfc1533_cookie
+ sizeof dhcprequest,
rfc1533_end, sizeof rfc1533_end);
grub_memmove (ip.bp.bp_vend + 9, (char *) &dhcp_server,
sizeof (in_addr));
grub_memmove (ip.bp.bp_vend + 15, (char *) &dhcp_addr,
sizeof (in_addr));
#ifdef DEBUG
grub_printf ("errnum = %d\n", errnum);
#endif
for (reqretry = 0; reqretry < MAX_BOOTP_RETRIES;)
{
int ret;
#ifdef DEBUG
grub_printf ("reqretry = %d\n", reqretry);
#endif
ret = udp_transmit (IP_BROADCAST, BOOTP_CLIENT, BOOTP_SERVER,
sizeof (struct bootpip_t), &ip);
if (! ret)
grub_printf ("udp_transmit failed.\n");
dhcp_reply = 0;
timeout = rfc2131_sleep_interval (TIMEOUT, reqretry++);
if (await_reply (AWAIT_BOOTP, 0, NULL, timeout))
if (dhcp_reply == DHCPACK)
{
network_ready = 1;
return 1;
}
#ifdef DEBUG
grub_printf ("dhcp_reply = %d\n", dhcp_reply);
#endif
if (ip_abort)
return 0;
}
}
#endif /* ! NO_DHCP_SUPPORT */
if (ip_abort)
return 0;
ip.bp.bp_secs = htons ((currticks () - starttime) / TICKS_PER_SEC);
}
/* Timeout. */
return 0;
}
/**************************************************************************
UDPCHKSUM - Checksum UDP Packet (one of the rare cases when assembly is
actually simpler...)
RETURNS: checksum, 0 on checksum error. This
allows for using the same routine for RX and TX summing:
RX if (packet->udp.chksum && udpchksum(packet))
error("checksum error");
TX packet->udp.chksum=0;
if (0==(packet->udp.chksum=udpchksum(packet)))
packet->upd.chksum=0xffff;
**************************************************************************/
static inline void
dosum (unsigned short *start, unsigned int len, unsigned short *sum)
{
__asm__ __volatile__
("clc\n"
"1:\tlodsw\n\t"
"xchg %%al,%%ah\n\t" /* convert to host byte order */
"adcw %%ax,%0\n\t" /* add carry of previous iteration */
"loop 1b\n\t"
"adcw $0,%0" /* add carry of last iteration */
: "=b" (*sum), "=S"(start), "=c"(len)
: "0"(*sum), "1"(start), "2"(len)
: "ax", "cc"
);
}
/* UDP sum:
* proto, src_ip, dst_ip, udp_dport, udp_sport, 2*udp_len, payload
*/
static unsigned short
udpchksum (struct iphdr *packet)
{
int len = ntohs (packet->len);
unsigned short rval;
/* add udplength + protocol number */
rval = (len - sizeof (struct iphdr)) + IP_UDP;
/* pad to an even number of bytes */
if (len % 2) {
((char *) packet)[len++] = 0;
}
/* sum over src/dst ipaddr + udp packet */
len -= (char *) &packet->src - (char *) packet;
dosum ((unsigned short *) &packet->src, len >> 1, &rval);
/* take one's complement */
return ~rval;
}
/**************************************************************************
AWAIT_REPLY - Wait until we get a response for our request
**************************************************************************/
int
await_reply (int type, int ival, void *ptr, int timeout)
{
unsigned long time;
struct iphdr *ip;
struct udphdr *udp;
struct arprequest *arpreply;
struct bootp_t *bootpreply;
unsigned short ptype;
unsigned int protohdrlen = (ETH_HLEN + sizeof (struct iphdr)
+ sizeof (struct udphdr));
/* Clear the abort flag. */
ip_abort = 0;
time = timeout + currticks ();
/* The timeout check is done below. The timeout is only checked if
* there is no packet in the Rx queue. This assumes that eth_poll()
* needs a negligible amount of time. */
for (;;)
{
if (eth_poll ())
{
/* We have something! */
/* Check for ARP - No IP hdr. */
if (nic.packetlen >= ETH_HLEN)
{
ptype = (((unsigned short) nic.packet[12]) << 8
| ((unsigned short) nic.packet[13]));
}
else
/* What else could we do with it? */
continue;
if (nic.packetlen >= ETH_HLEN + sizeof (struct arprequest)
&& ptype == ARP)
{
unsigned long tmp;
arpreply = (struct arprequest *) &nic.packet[ETH_HLEN];
if (arpreply->opcode == htons (ARP_REPLY)
&& ! grub_memcmp (arpreply->sipaddr, ptr, sizeof (in_addr))
&& type == AWAIT_ARP)
{
grub_memmove ((char *) arptable[ival].node,
arpreply->shwaddr,
ETH_ALEN);
return 1;
}
grub_memmove ((char *) &tmp, arpreply->tipaddr,
sizeof (in_addr));
if (arpreply->opcode == htons (ARP_REQUEST)
&& tmp == arptable[ARP_CLIENT].ipaddr.s_addr)
{
arpreply->opcode = htons (ARP_REPLY);
grub_memmove (arpreply->tipaddr, arpreply->sipaddr,
sizeof (in_addr));
grub_memmove (arpreply->thwaddr, (char *) arpreply->shwaddr,
ETH_ALEN);
grub_memmove (arpreply->sipaddr,
(char *) &arptable[ARP_CLIENT].ipaddr,
sizeof (in_addr));
grub_memmove (arpreply->shwaddr,
arptable[ARP_CLIENT].node,
ETH_ALEN);
eth_transmit (arpreply->thwaddr, ARP,
sizeof (struct arprequest),
arpreply);
#ifdef MDEBUG
grub_memmove (&tmp, arpreply->tipaddr, sizeof (in_addr));
etherboot_printf ("Sent ARP reply to: %@\n", tmp);
#endif /* MDEBUG */
}
continue;
}
if (type == AWAIT_QDRAIN)
continue;
/* Check for RARP - No IP hdr. */
if (type == AWAIT_RARP
&& nic.packetlen >= ETH_HLEN + sizeof (struct arprequest)
&& ptype == RARP)
{
arpreply = (struct arprequest *) &nic.packet[ETH_HLEN];
if (arpreply->opcode == htons (RARP_REPLY)
&& ! grub_memcmp (arpreply->thwaddr, ptr, ETH_ALEN))
{
grub_memmove ((char *) arptable[ARP_SERVER].node,
arpreply->shwaddr, ETH_ALEN);
grub_memmove ((char *) &arptable[ARP_SERVER].ipaddr,
arpreply->sipaddr, sizeof (in_addr));
grub_memmove ((char *) &arptable[ARP_CLIENT].ipaddr,
arpreply->tipaddr, sizeof (in_addr));
return 1;
}
continue;
}
/* Anything else has IP header. */
if (nic.packetlen < protohdrlen || ptype != IP)
continue;
ip = (struct iphdr *) &nic.packet[ETH_HLEN];
if (ip->verhdrlen != 0x45
|| ipchksum ((unsigned short *) ip, sizeof (struct iphdr))
|| ip->protocol != IP_UDP)
continue;
/*
- Till Straumann <Till.Straumann@TU-Berlin.de>
added udp checksum (safer on a wireless link)
added fragmentation check: I had a corrupted image
in memory due to fragmented TFTP packets - took me
3 days to find the cause for this :-(
*/
/* If More Fragments bit and Fragment Offset field
are non-zero then packet is fragmented */
if (ip->frags & htons(0x3FFF))
{
grub_printf ("ALERT: got a fragmented packet - reconfigure your server\n");
continue;
}
udp = (struct udphdr *) &nic.packet[(ETH_HLEN
+ sizeof (struct iphdr))];
if (udp->chksum && udpchksum (ip))
{
grub_printf ("UDP checksum error\n");
continue;
}
/* BOOTP ? */
bootpreply = (struct bootp_t *)
&nic.packet[(ETH_HLEN + sizeof (struct iphdr)
+ sizeof (struct udphdr))];
if (type == AWAIT_BOOTP
#ifdef NO_DHCP_SUPPORT
&& (nic.packetlen
>= (ETH_HLEN + sizeof (struct bootp_t) - BOOTP_VENDOR_LEN))
#else
&& (nic.packetlen
>= (ETH_HLEN + sizeof (struct bootp_t) - DHCP_OPT_LEN))
#endif /* ! NO_DHCP_SUPPORT */
&& udp->dest == htons (BOOTP_CLIENT)
&& bootpreply->bp_op == BOOTP_REPLY
&& bootpreply->bp_xid == xid
&& (! grub_memcmp (broadcast, bootpreply->bp_hwaddr, ETH_ALEN)
|| ! grub_memcmp (arptable[ARP_CLIENT].node,
bootpreply->bp_hwaddr, ETH_ALEN)))
{
#ifdef DEBUG
grub_printf ("BOOTP packet was received.\n");
#endif
arptable[ARP_CLIENT].ipaddr.s_addr
= bootpreply->bp_yiaddr.s_addr;
#ifndef NO_DHCP_SUPPORT
dhcp_addr.s_addr = bootpreply->bp_yiaddr.s_addr;
#ifdef DEBUG
etherboot_printf ("dhcp_addr = %@\n", dhcp_addr.s_addr);
#endif
#endif /* ! NO_DHCP_SUPPORT */
netmask = default_netmask ();
arptable[ARP_SERVER].ipaddr.s_addr
= bootpreply->bp_siaddr.s_addr;
/* Kill arp. */
grub_memset (arptable[ARP_SERVER].node, 0, ETH_ALEN);
arptable[ARP_GATEWAY].ipaddr.s_addr
= bootpreply->bp_giaddr.s_addr;
/* Kill arp. */
grub_memset (arptable[ARP_GATEWAY].node, 0, ETH_ALEN);
grub_memmove ((char *) BOOTP_DATA_ADDR, (char *) bootpreply,
sizeof (struct bootpd_t));
#ifdef NO_DHCP_SUPPORT
decode_rfc1533 (BOOTP_DATA_ADDR->bootp_reply.bp_vend,
0, BOOTP_VENDOR_LEN + MAX_BOOTP_EXTLEN, 1);
#else
decode_rfc1533 (BOOTP_DATA_ADDR->bootp_reply.bp_vend,
0, DHCP_OPT_LEN + MAX_BOOTP_EXTLEN, 1);
#endif /* ! NO_DHCP_SUPPORT */
return 1;
}
/* TFTP ? */
if (type == AWAIT_TFTP && ntohs (udp->dest) == ival)
return 1;
}
else
{
/* Check for abort key only if the Rx queue is empty -
* as long as we have something to process, don't
* assume that something failed. It is unlikely that
* we have no processing time left between packets. */
if (checkkey () != -1 && ASCII_CHAR (getkey ()) == CTRL_C)
{
ip_abort = 1;
return 0;
}
/* Do the timeout after at least a full queue walk. */
if ((timeout == 0) || (currticks() > time))
{
break;
}
}
}
return 0;
}
/**************************************************************************
DECODE_RFC1533 - Decodes RFC1533 header
**************************************************************************/
int
decode_rfc1533 (unsigned char *p, int block, int len, int eof)
{
static unsigned char *extdata = NULL, *extend = NULL;
unsigned char *extpath = NULL;
unsigned char *endp;
if (block == 0)
{
end_of_rfc1533 = NULL;
vendorext_isvalid = 0;
if (grub_memcmp (p, rfc1533_cookie, 4))
/* no RFC 1533 header found */
return 0;
p += 4;
endp = p + len;
}
else
{
if (block == 1)
{
if (grub_memcmp (p, rfc1533_cookie, 4))
/* no RFC 1533 header found */
return 0;
p += 4;
len -= 4;
}
if (extend + len
<= ((unsigned char *)
&(BOOTP_DATA_ADDR->bootp_extension[MAX_BOOTP_EXTLEN])))
{
grub_memmove (extend, p, len);
extend += len;
}
else
{
grub_printf ("Overflow in vendor data buffer! Aborting...\n");
*extdata = RFC1533_END;
return 0;
}
p = extdata;
endp = extend;
}
if (! eof)
return -1;
while (p < endp)
{
unsigned char c = *p;
if (c == RFC1533_PAD)
{
p++;
continue;
}
else if (c == RFC1533_END)
{
end_of_rfc1533 = endp = p;
continue;
}
else if (c == RFC1533_NETMASK)
{
grub_memmove ((char *) &netmask, p + 2, sizeof (in_addr));
}
else if (c == RFC1533_GATEWAY)
{
/* This is a little simplistic, but it will
usually be sufficient.
Take only the first entry. */
if (TAG_LEN (p) >= sizeof (in_addr))
grub_memmove ((char *) &arptable[ARP_GATEWAY].ipaddr, p + 2,
sizeof (in_addr));
}
else if (c == RFC1533_EXTENSIONPATH)
extpath = p;
#ifndef NO_DHCP_SUPPORT
else if (c == RFC2132_MSG_TYPE)
{
dhcp_reply = *(p + 2);
}
else if (c == RFC2132_SRV_ID)
{
grub_memmove ((char *) &dhcp_server, p + 2, sizeof (in_addr));
#ifdef DEBUG
etherboot_printf ("dhcp_server = %@\n", dhcp_server.s_addr);
#endif
}
#endif /* ! NO_DHCP_SUPPORT */
else if (c == RFC1533_VENDOR_MAGIC
&& TAG_LEN(p) >= 6
&& ! grub_memcmp (p + 2, vendorext_magic, 4)
&& p[6] == RFC1533_VENDOR_MAJOR)
vendorext_isvalid++;
/* GRUB now handles its own tag. Get the name of a configuration
file from the network. Cool... */
else if (c == RFC1533_VENDOR_CONFIGFILE)
{
int l = TAG_LEN (p);
/* Eliminate the trailing NULs according to RFC 2132. */
while (*(p + 2 + l - 1) == '\000' && l > 0)
l--;
/* XXX: Should check if LEN is less than the maximum length
of CONFIG_FILE. This kind of robustness will be a goal
in GRUB 1.0. */
grub_memmove (config_file, p + 2, l);
config_file[l] = 0;
}
p += TAG_LEN (p) + 2;
}
extdata = extend = endp;
/* Perhaps we can eliminate this because we doesn't require so
much information, but I leave this alone. */
if (block == 0 && extpath != NULL)
{
char fname[64];
int fnamelen = TAG_LEN (extpath);
while (*(extpath + 2 + fnamelen - 1) == '\000' && fnamelen > 0)
fnamelen--;
if (fnamelen + 1 > sizeof (fname))
{
grub_printf ("Too long file name for Extensions Path\n");
return 0;
}
else if (! fnamelen)
{
grub_printf ("Empty file name for Extensions Path\n");
return 0;
}
grub_memmove (fname, extpath + 2, fnamelen);
fname[fnamelen] = '\000';
grub_printf ("Loading BOOTP-extension file: %s\n", fname);
tftp (fname, decode_rfc1533);
}
/* Proceed with next block. */
return -1;
}
/**************************************************************************
IPCHKSUM - Checksum IP Header
**************************************************************************/
static unsigned short
ipchksum (unsigned short *ip, int len)
{
unsigned long sum = 0;
len >>= 1;
while (len--)
{
sum += *(ip++);
if (sum > 0xFFFF)
sum -= 0xFFFF;
}
return (~sum) & 0x0000FFFF;
}
#define TWO_SECOND_DIVISOR (2147483647l/TICKS_PER_SEC)
/**************************************************************************
RFC2131_SLEEP_INTERVAL - sleep for expotentially longer times
**************************************************************************/
long
rfc2131_sleep_interval (int base, int exp)
{
static long seed = 0;
long q;
unsigned long tmo;
#ifdef BACKOFF_LIMIT
if (exp > BACKOFF_LIMIT)
exp = BACKOFF_LIMIT;
#endif
if (!seed)
/* Initialize linear congruential generator */
seed = (currticks () + *((long *) &arptable[ARP_CLIENT].node)
+ ((short *) arptable[ARP_CLIENT].node)[2]);
/* simplified version of the LCG given in Bruce Schneier's
"Applied Cryptography" */
q = seed / 53668;
if ((seed = 40014 * (seed - 53668 * q) - 12211 *q ) < 0)
seed += 2147483563L;
tmo = (base << exp) + (TICKS_PER_SEC - (seed / TWO_SECOND_DIVISOR));
return tmo;
}
/**************************************************************************
CLEANUP - shut down networking
**************************************************************************/
void
cleanup_net (void)
{
if (network_ready)
{
/* Stop receiving packets. */
eth_disable ();
network_ready = 0;
}
}
syntax highlighted by Code2HTML, v. 0.9.1