/**************************************************************************
NFS_READ - Read File on NFS Server
**************************************************************************/
static int nfs_read(int server, int port, char *fh, int offset, int len,
int sport)
{
struct rpc_t buf, *rpc;
unsigned long id;
int retries;
long *p;
static int tokens=0;
/*
* Try to implement something similar to a window protocol in
* terms of response to losses. On successful receive, increment
* the number of tokens by 1 (cap at 256). On failure, halve it.
* When the number of tokens is >= 2, use a very short timeout.
*/
id = rpc_id++;
buf.u.call.id = htonl(id);
buf.u.call.type = htonl(MSG_CALL);
buf.u.call.rpcvers = htonl(2); /* use RPC version 2 */
buf.u.call.prog = htonl(PROG_NFS);
buf.u.call.vers = htonl(2); /* nfsd is version 2 */
buf.u.call.proc = htonl(NFS_READ);
p = rpc_add_credentials((long *)buf.u.call.data);
memcpy(p, fh, NFS_FHSIZE);
p += NFS_FHSIZE / 4;
*p++ = htonl(offset);
*p++ = htonl(len);
*p++ = 0; /* unused parameter */
for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
if (tokens >= 2)
timeout = TICKS_PER_SEC/2;
udp_transmit(arptable[server].ipaddr.s_addr, sport, port,
(char *)p - (char *)&buf, &buf);
if (await_reply(await_rpc, sport, &id, timeout)) {
if (tokens < 256)
tokens++;
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus || rpc->u.reply.data[0]) {
rpc_printerror(rpc);
if (rpc->u.reply.rstatus) {
/* RPC failed, no verifier, data[0] */
return -9999;
}
if (rpc->u.reply.astatus) {
/* RPC couldn't decode parameters */
return -9998;
}
return -ntohl(rpc->u.reply.data[0]);
} else {
return 0;
}
} else
tokens >>= 1;
}
return -1;
}
/**************************************************************************
NFS_LOOKUP - Lookup Pathname
**************************************************************************/
static int nfs_lookup(int server, int port, char *fh, char *path, char *nfh,
int sport)
{
struct rpc_t buf, *rpc;
unsigned long id;
long *p;
int retries;
int pathlen = strlen(path);
id = rpc_id++;
buf.u.call.id = htonl(id);
buf.u.call.type = htonl(MSG_CALL);
buf.u.call.rpcvers = htonl(2); /* use RPC version 2 */
buf.u.call.prog = htonl(PROG_NFS);
buf.u.call.vers = htonl(2); /* nfsd is version 2 */
buf.u.call.proc = htonl(NFS_LOOKUP);
p = rpc_add_credentials((long *)buf.u.call.data);
memcpy(p, fh, NFS_FHSIZE);
p += (NFS_FHSIZE / 4);
*p++ = htonl(pathlen);
if (pathlen & 3) {
*(p + pathlen / 4) = 0; /* add zero padding */
}
memcpy(p, path, pathlen);
p += (pathlen + 3) / 4;
for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
udp_transmit(arptable[server].ipaddr.s_addr, sport, port,
(char *)p - (char *)&buf, &buf);
if (await_reply(await_rpc, sport, &id, timeout)) {
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus || rpc->u.reply.data[0]) {
rpc_printerror(rpc);
if (rpc->u.reply.rstatus) {
/* RPC failed, no verifier, data[0] */
return -9999;
}
if (rpc->u.reply.astatus) {
/* RPC couldn't decode parameters */
return -9998;
}
return -ntohl(rpc->u.reply.data[0]);
} else {
memcpy(nfh, rpc->u.reply.data + 1, NFS_FHSIZE);
return 0;
}
}
}
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;
/* 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);
#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);
}
/**************************************************************************
RPC_LOOKUP - Lookup RPC Port numbers
**************************************************************************/
static int rpc_lookup(int addr, int prog, int ver, int sport)
{
struct rpc_t buf, *rpc;
unsigned long id;
int retries;
long *p;
id = rpc_id++;
buf.u.call.id = htonl(id);
buf.u.call.type = htonl(MSG_CALL);
buf.u.call.rpcvers = htonl(2); /* use RPC version 2 */
buf.u.call.prog = htonl(PROG_PORTMAP);
buf.u.call.vers = htonl(2); /* portmapper is version 2 */
buf.u.call.proc = htonl(PORTMAP_GETPORT);
p = (long *)buf.u.call.data;
*p++ = 0; *p++ = 0; /* auth credential */
*p++ = 0; *p++ = 0; /* auth verifier */
*p++ = htonl(prog);
*p++ = htonl(ver);
*p++ = htonl(IP_UDP);
*p++ = 0;
for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
long timeout;
udp_transmit(arptable[addr].ipaddr.s_addr, sport, SUNRPC_PORT,
(char *)p - (char *)&buf, &buf);
timeout = rfc2131_sleep_interval(TIMEOUT, retries);
if (await_reply(await_rpc, sport, &id, timeout)) {
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus) {
rpc_printerror(rpc);
return -1;
} else {
return ntohl(rpc->u.reply.data[0]);
}
}
}
return -1;
}
/**************************************************************************
NFS_UMOUNTALL - Unmount all our NFS Filesystems on the Server
**************************************************************************/
void nfs_umountall(int server)
{
struct rpc_t buf, *rpc;
unsigned long id;
int retries;
long *p;
if (!arptable[server].ipaddr.s_addr) {
/* Haven't sent a single UDP packet to this server */
return;
}
if ((mount_port == -1) || (!fs_mounted)) {
/* Nothing mounted, nothing to umount */
return;
}
id = rpc_id++;
buf.u.call.id = htonl(id);
buf.u.call.type = htonl(MSG_CALL);
buf.u.call.rpcvers = htonl(2); /* use RPC version 2 */
buf.u.call.prog = htonl(PROG_MOUNT);
buf.u.call.vers = htonl(1); /* mountd is version 1 */
buf.u.call.proc = htonl(MOUNT_UMOUNTALL);
p = rpc_add_credentials((long *)buf.u.call.data);
for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
udp_transmit(arptable[server].ipaddr.s_addr, oport, mount_port,
(char *)p - (char *)&buf, &buf);
if (await_reply(await_rpc, oport, &id, timeout)) {
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus) {
rpc_printerror(rpc);
}
fs_mounted = 0;
return;
}
}
}
/*
* transmit() flags:
* MSG_DONTROUTE (not supported)
* MSG_EOR Close sending side after data sent
* MSG_TRUNC (not supported)
* MSG_CTRUNC (not supported)
* MSG_OOB (not supported)
* MSG_WAITALL Wait till room in tx-buffer (not supported)
*/
static int transmit (const char *func, int s, const void *buf, int len,
int flags, const struct sockaddr *to, int tolen)
{
Socket *socket = _socklist_find (s);
int rc;
SOCK_DEBUGF ((socket, "\n%s:%d, len=%d", func, s, len));
if (!socket)
{
if (_sock_dos_fd(s))
{
SOCK_DEBUGF ((NULL, ", ENOTSOCK"));
SOCK_ERR (ENOTSOCK);
return (-1);
}
SOCK_DEBUGF ((NULL, ", EBADF"));
SOCK_ERR (EBADF);
return (-1);
}
if (socket->so_type == SOCK_STREAM || /* TCP-socket or */
(socket->so_state & SS_ISCONNECTED)) /* "connected" udp/raw */
{
/* Note: SOCK_RAW doesn't really need a local address/port, but
* makes the code more similar for all socket-types.
* Disadvantage is that SOCK_RAW ties up a local port and a bit
* more memory.
*/
if (!socket->local_addr)
{
SOCK_DEBUGF ((socket, ", no local_addr"));
SOCK_ERR (ENOTCONN);
return (-1);
}
if (!socket->remote_addr)
{
SOCK_DEBUGF ((socket, ", no remote_addr"));
SOCK_ERR (ENOTCONN);
return (-1);
}
if (socket->so_state & SS_CONN_REFUSED)
{
if (socket->so_error == ECONNRESET) /* set in tcp_sockreset() */
{
SOCK_DEBUGF ((socket, ", ECONNRESET"));
SOCK_ERR (ECONNRESET);
}
else
{
SOCK_DEBUGF ((socket, ", ECONNREFUSED"));
SOCK_ERR (ECONNREFUSED);
}
return (-1);
}
}
/* connectionless protocol setup
*/
if (socket->so_type == SOCK_DGRAM || socket->so_type == SOCK_RAW)
{
if (!to || tolen < sizeof(*to))
{
SOCK_DEBUGF ((socket, ", no to-addr"));
SOCK_ERR (EINVAL);
return (-1);
}
if (setup_udp_raw(socket,to,tolen) < 0)
return (-1);
}
VERIFY_RW (buf, len);
/* Setup SIGINT handler now.
*/
if (_sock_sig_setup() < 0)
{
SOCK_ERR (EINTR);
return (-1);
}
switch (socket->so_type)
{
case SOCK_DGRAM:
rc = udp_transmit (socket, buf, len);
break;
case SOCK_STREAM:
rc = tcp_transmit (socket, buf, len, flags);
break;
case SOCK_RAW:
rc = ip_transmit (socket, buf, len);
break;
default:
SOCK_DEBUGF ((socket, ", EPROTONOSUPPORT"));
SOCK_ERR (EPROTONOSUPPORT);
rc = -1;
}
_sock_sig_restore();
if (rc >= 0 && (flags & MSG_EOR))
msg_eor_close (socket);
return (rc);
}
int
bootp (void)
{
int retry;
#ifndef NO_DHCP_SUPPORT
int reqretry;
#endif
struct bootpip_t ip;
unsigned long starttime;
if (! eth_probe ())
return 0;
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 ();
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
grub_memmove (ip.bp.bp_vend, rfc1533_cookie, 5);
#else
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
for (retry = 0; retry < MAX_BOOTP_RETRIES;)
{
long timeout;
#ifdef DEBUG
grub_printf ("retry = %d\n", retry);
#endif
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
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
if (ip_abort)
return 0;
ip.bp.bp_secs = htons ((currticks () - starttime) / TICKS_PER_SEC);
}
return 0;
}
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;
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)
{
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))
{
#ifdef MDEBUG
grub_printf ("<REXMT>\n");
#endif
udp_transmit (arptable[ARP_SERVER].ipaddr.s_addr,
iport, oport,
TFTP_MIN_PACKET, &tp);
continue;
}
#endif
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;
if (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;
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;
block = tp.u.ack.block = 0;
}
else if (tr->opcode == ntohs (TFTP_DATA))
{
len = ntohs (tr->udp.len) - sizeof (struct udphdr) - 4;
if (len > packetsize)
continue;
block = ntohs (tp.u.ack.block = tr->u.data.block);
}
else
break;
if ((block || bcounter) && (block != prevblock + 1))
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);
if ((unsigned short) (block - prevblock) != 1)
continue;
prevblock = block;
retry = 0;
if ((rc = fnc (tr->u.data.download,
++bcounter, len, len < packetsize)) >= 0)
return rc;
if (len < packetsize)
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
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 (ip_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 != prevblock + (unsigned short) 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;
}
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;
}
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;
}
/***************************************************************************
* NFS_READLINK (AH 2003-07-14)
* This procedure is called when read of the first block fails -
* this probably happens when it's a directory or a symlink
* In case of successful readlink(), the dirname is manipulated,
* so that inside the nfs() function a recursion can be done.
**************************************************************************/
static int nfs_readlink(int server, int port, char *fh, char *path, char *nfh,
int sport)
{
struct rpc_t buf, *rpc;
unsigned long id;
long *p;
int retries;
int pathlen = strlen(path);
id = rpc_id++;
buf.u.call.id = htonl(id);
buf.u.call.type = htonl(MSG_CALL);
buf.u.call.rpcvers = htonl(2); /* use RPC version 2 */
buf.u.call.prog = htonl(PROG_NFS);
buf.u.call.vers = htonl(2); /* nfsd is version 2 */
buf.u.call.proc = htonl(NFS_READLINK);
p = rpc_add_credentials((long *)buf.u.call.data);
memcpy(p, nfh, NFS_FHSIZE);
p += (NFS_FHSIZE / 4);
for (retries = 0; retries < MAX_RPC_RETRIES; retries++) {
long timeout = rfc2131_sleep_interval(TIMEOUT, retries);
udp_transmit(arptable[server].ipaddr.s_addr, sport, port,
(char *)p - (char *)&buf, &buf);
if (await_reply(await_rpc, sport, &id, timeout)) {
rpc = (struct rpc_t *)&nic.packet[ETH_HLEN];
if (rpc->u.reply.rstatus || rpc->u.reply.verifier ||
rpc->u.reply.astatus || rpc->u.reply.data[0]) {
rpc_printerror(rpc);
if (rpc->u.reply.rstatus) {
/* RPC failed, no verifier, data[0] */
return -9999;
}
if (rpc->u.reply.astatus) {
/* RPC couldn't decode parameters */
return -9998;
}
return -ntohl(rpc->u.reply.data[0]);
} else {
// It *is* a link.
// If it's a relative link, append everything to dirname, filename TOO!
retries = strlen ( (char *)(&(rpc->u.reply.data[2]) ));
if ( *((char *)(&(rpc->u.reply.data[2]))) != '/' ) {
path[pathlen++] = '/';
while ( ( retries + pathlen ) > 298 ) {
retries--;
}
if ( retries > 0 ) {
memcpy(path + pathlen, &(rpc->u.reply.data[2]), retries + 1);
} else { retries = 0; }
path[pathlen + retries] = 0;
} else {
// Else make it the only path.
if ( retries > 298 ) { retries = 298; }
memcpy ( path, &(rpc->u.reply.data[2]), retries + 1 );
path[retries] = 0;
}
return 0;
}
}
}
return -1;
}
