diff options
Diffstat (limited to 'contrib/baremetal/main.c')
| -rw-r--r-- | contrib/baremetal/main.c | 1119 |
1 files changed, 0 insertions, 1119 deletions
diff --git a/contrib/baremetal/main.c b/contrib/baremetal/main.c deleted file mode 100644 index 7b0de44c1..000000000 --- a/contrib/baremetal/main.c +++ /dev/null @@ -1,1119 +0,0 @@ -/************************************************************************** -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 MDEBUG */ - -#include "etherboot.h" -#include "nic.h" - -int jmp_bootmenu[10]; - -struct arptable_t arptable[MAX_ARP]; - -const char *kernel; -char kernel_buf[128]; -struct rom_info rom; - -#ifdef IMAGE_MENU -static char *imagelist[RFC1533_VENDOR_NUMOFIMG]; -static int useimagemenu; -int menutmo,menudefault; -unsigned char *defparams = NULL; -int defparams_max = 0; -#endif -#ifdef MOTD -char *motd[RFC1533_VENDOR_NUMOFMOTD]; -#endif -#ifdef IMAGE_FREEBSD -int freebsd_howto = 0; -#endif -int vendorext_isvalid; -char config_buffer[TFTP_MAX_PACKET+1]; /* +1 for null byte */ -unsigned long netmask; -char *hostname = ""; -int hostnamelen = 0; -#if defined(ETHERBOOT16) || defined(INTERNAL_BOOTP_DATA) -struct bootpd_t bootp_data; -#endif -unsigned long xid; -unsigned char *end_of_rfc1533 = NULL; -#ifndef NO_DHCP_SUPPORT -int dhcp_reply; -in_addr dhcp_server = { 0L }; -in_addr dhcp_addr = { 0L }; -#endif /* NO_DHCP_SUPPORT */ - -unsigned char vendorext_magic[] = {0xE4,0x45,0x74,0x68}; /* äEth */ -#ifdef NO_DHCP_SUPPORT -char rfc1533_cookie[5] = { RFC1533_COOKIE, RFC1533_END }; -#else -char rfc1533_cookie[] = { RFC1533_COOKIE}; -char rfc1533_end[]={RFC1533_END }; -static const char dhcpdiscover[]={ - RFC2132_MSG_TYPE,1,DHCPDISCOVER, - RFC2132_MAX_SIZE,2, /* request as much as we can */ - sizeof(struct bootpd_t) / 256, sizeof(struct bootpd_t) % 256, - RFC2132_PARAM_LIST,4,RFC1533_NETMASK,RFC1533_GATEWAY, - RFC1533_HOSTNAME - }; -static const 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 */ - sizeof(struct bootpd_t) / 256, sizeof(struct bootpd_t) % 256, - /* request parameters */ - RFC2132_PARAM_LIST, -#ifdef IMAGE_FREEBSD - /* 4 standard + 6 vendortags + 8 motd + 16 menu items */ - 4 + 6 + 8 + 16, -#else - /* 4 standard + 5 vendortags + 8 motd + 16 menu items */ - 4 + 5 + 8 + 16, -#endif - /* Standard parameters */ - RFC1533_NETMASK, RFC1533_GATEWAY, - RFC1533_HOSTNAME, - RFC1533_ROOTPATH, /* only passed to the booted image */ - /* Etherboot vendortags */ - RFC1533_VENDOR_MAGIC, - RFC1533_VENDOR_ADDPARM, - RFC1533_VENDOR_ETHDEV, -#ifdef IMAGE_FREEBSD - RFC1533_VENDOR_HOWTO, -#endif - RFC1533_VENDOR_MNUOPTS, RFC1533_VENDOR_SELECTION, - /* 8 MOTD entries */ - RFC1533_VENDOR_MOTD, - RFC1533_VENDOR_MOTD+1, - RFC1533_VENDOR_MOTD+2, - RFC1533_VENDOR_MOTD+3, - RFC1533_VENDOR_MOTD+4, - RFC1533_VENDOR_MOTD+5, - RFC1533_VENDOR_MOTD+6, - RFC1533_VENDOR_MOTD+7, - /* 16 image entries */ - RFC1533_VENDOR_IMG, - RFC1533_VENDOR_IMG+1, - RFC1533_VENDOR_IMG+2, - RFC1533_VENDOR_IMG+3, - RFC1533_VENDOR_IMG+4, - RFC1533_VENDOR_IMG+5, - RFC1533_VENDOR_IMG+6, - RFC1533_VENDOR_IMG+7, - RFC1533_VENDOR_IMG+8, - RFC1533_VENDOR_IMG+9, - RFC1533_VENDOR_IMG+10, - RFC1533_VENDOR_IMG+11, - RFC1533_VENDOR_IMG+12, - RFC1533_VENDOR_IMG+13, - RFC1533_VENDOR_IMG+14, - RFC1533_VENDOR_IMG+15, - }; - -#endif /* NO_DHCP_SUPPORT */ -static const char broadcast[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF }; - -/************************************************************************** -MAIN - Kick off routine -**************************************************************************/ -int main(void) -{ - char *p; - static int card_retries = 0; - int i; - - for (p=_edata; p<_end; p++) - *p = 0; /* Zero BSS */ - -#ifdef CONSOLE_SERIAL - (void)serial_init(); -#endif - -#ifdef DELIMITERLINES - for (i=0; i<80; i++) putchar('='); -#endif - -#ifdef ETHERBOOT32 - rom = *(struct rom_info *)ROM_INFO_LOCATION; - printf("ROM segment %#x length %#x reloc %#x\n", rom.rom_segment, - rom.rom_length << 1, ((unsigned long)_start) >> 4); -#endif -#ifdef ETHERBOOT16 - fmemcpy(&rom, (Address)ROM_INFO_LOCATION, sizeof(rom)); - printf("ROM segment %#x length %#x\n", rom.rom_segment, - rom.rom_length << 1); -#endif -#ifdef ASK_BOOT - while (1) { - int c; - unsigned long time; - printf(ASK_PROMPT); -#if ASK_BOOT > 0 - for (time = currticks() + ASK_BOOT*TICKS_PER_SEC; !iskey(); ) - if (currticks() > time) { - c = ANS_DEFAULT; - goto done; - } -#endif - c = getchar(); - if ((c >= 'a') && (c <= 'z')) c &= 0x5F; - if (c == '\n') c = ANS_DEFAULT; -done: - if ((c >= ' ') && (c <= '~')) putchar(c); - putchar('\n'); - if (c == ANS_LOCAL) - exit(0); - if (c == ANS_NETWORK) - break; - } -#endif -#if (TRY_FLOPPY_FIRST > 0) && defined(FLOPPY) - disk_init(); - printf("Trying floppy"); - for (i = TRY_FLOPPY_FIRST; i-- > 0; ) { - putchar('.'); - if (disk_read(0, 0, 0, 0, ((char *) FLOPPY_BOOT_LOCATION)) != 0x8000) { - printf("using floppy\n"); - exit(0); - } - } - printf("no floppy\n"); -#endif /* TRY_FLOPPY_FIRST && FLOPPY */ - print_config(); - gateA20_set(); -#ifdef EMERGENCYDISKBOOT - if (!eth_probe()) { - printf("No adapter found\n"); - exit(0); - } -#else - while (!eth_probe()) { - printf("No adapter found"); - if (!setjmp(jmp_bootmenu)) - rfc951_sleep(++card_retries); - } -#endif - kernel = DEFAULT_BOOTFILE; - while (1) { - if ((i = setjmp(jmp_bootmenu)) != 0) { -#if defined(ANSIESC) && defined(CONSOLE_CRT) - ansi_reset(); -#endif - bootmenu(--i); - } else { - load(); - } -#if defined(ANSIESC) && defined(CONSOLE_CRT) - ansi_reset(); -#endif - } -} - -/************************************************************************** -LOADKERNEL - Try to load kernel image -**************************************************************************/ -#ifndef FLOPPY -#define loadkernel(s) download((s),downloadkernel) -#else -static int loadkernel(const char *fname) -{ - if (!memcmp(fname,"/dev/",5) && fname[6] == 'd') { - int dev, part = 0; - if (fname[5] == 'f') { - if ((dev = fname[7] - '0') < 0 || dev > 3) - goto nodisk; } - else if (fname[5] == 'h' || fname[5] == 's') { - if ((dev = 0x80 + fname[7] - 'a') < 0x80 || dev > 0x83) - goto nodisk; - if (fname[8]) { - part = fname[8] - '0'; - if (fname[9]) - part = 10*part + fname[9] - '0'; } - /* bootdisk cannot cope with more than eight partitions */ - if (part < 0 || part > 8) - goto nodisk; } - else - goto nodisk; - return(bootdisk(dev,part)); } -nodisk: - return download(fname, downloadkernel); -} -#endif - -/************************************************************************** -LOAD - Try to get booted -**************************************************************************/ -void load() -{ - static int bootp_completed = 0; - - /* Find a server to get BOOTP reply from */ - if (!bootp_completed || - !arptable[ARP_CLIENT].ipaddr.s_addr || !arptable[ARP_SERVER].ipaddr.s_addr) { -retry: - bootp_completed = 0; -#ifdef RARP_NOT_BOOTP - printf("Searching for server (RARP)...\n"); -#else -#ifndef NO_DHCP_SUPPORT - printf("Searching for server (DHCP)...\n"); -#else - printf("Searching for server (BOOTP)...\n"); -#endif -#endif - -#ifdef RARP_NOT_BOOTP - if (!rarp()) { -#else - if (!bootp()) { -#endif - printf("No Server found\n"); -#ifdef EMERGENCYDISKBOOT - exit(0); -#else - goto retry; -#endif - } - bootp_completed++; - } - printf("Me: %I, Server: %I", - arptable[ARP_CLIENT].ipaddr.s_addr, - arptable[ARP_SERVER].ipaddr.s_addr); - if (BOOTP_DATA_ADDR->bootp_reply.bp_giaddr.s_addr) - printf(", Relay: %I", - BOOTP_DATA_ADDR->bootp_reply.bp_giaddr.s_addr); - if (arptable[ARP_GATEWAY].ipaddr.s_addr) - printf(", Gateway %I", arptable[ARP_GATEWAY].ipaddr.s_addr); - putchar('\n'); - -#ifdef MDEBUG - printf("\n=>>"); getchar(); -#endif - -#ifdef MOTD - if (vendorext_isvalid) - show_motd(); -#endif - /* Now use TFTP to load file */ -#ifdef IMAGE_MENU - if (vendorext_isvalid && useimagemenu) { - selectImage(imagelist); - bootp_completed = 0; - } -#endif -#ifdef DOWNLOAD_PROTO_NFS - rpc_init(); -#endif - for (;;) { - printf("Loading %s ",kernel); - while (!loadkernel(kernel)) { - printf("Unable to load file.\n"); - sleep(2); /* lay off server for a while */ - } - } -} - -/************************************************************************** -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)); -} - -/************************************************************************** -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 *)((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; - 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) { - printf("%I is not in my arp table!\n", destip); - return(0); - } - for (i = 0; i<ETHER_ADDR_SIZE; i++) - if (arptable[arpentry].node[i]) break; - if (i == ETHER_ADDR_SIZE) { /* Need to do arp request */ - arpreq.hwtype = htons(1); - arpreq.protocol = htons(IP); - arpreq.hwlen = ETHER_ADDR_SIZE; - arpreq.protolen = 4; - arpreq.opcode = htons(ARP_REQUEST); - memcpy(arpreq.shwaddr, arptable[ARP_CLIENT].node, ETHER_ADDR_SIZE); - memcpy(arpreq.sipaddr, &arptable[ARP_CLIENT].ipaddr, sizeof(in_addr)); - memset(arpreq.thwaddr, 0, ETHER_ADDR_SIZE); - memcpy(arpreq.tipaddr, &destip, sizeof(in_addr)); - for (retry = 1; retry <= MAX_ARP_RETRIES; retry++) { - eth_transmit(broadcast, ARP, sizeof(arpreq), - &arpreq); - if (await_reply(AWAIT_ARP, arpentry, - arpreq.tipaddr, TIMEOUT)) goto xmit; - rfc951_sleep(retry); - /* We have slept for a while - the packet may - * have arrived by now. If not, we have at - * least some room in the Rx buffer for the - * next reply. */ - if (await_reply(AWAIT_ARP, arpentry, - arpreq.tipaddr, 0)) goto xmit; - } - return(0); - } -xmit: - eth_transmit(arptable[arpentry].node, IP, len, buf); - } - return(1); -} - -/************************************************************************** -DOWNLOADKERNEL - Try to load file -**************************************************************************/ -int downloadkernel(data, block, len, eof) - unsigned char *data; - int block, len, eof; -{ -#ifdef SIZEINDICATOR - static int rlen = 0; - - if (!(block % 4) || eof) { - int size; - size = ((block-1) * rlen + len) / 1024; - - putchar('\b'); - putchar('\b'); - putchar('\b'); - putchar('\b'); - - putchar('0' + (size/1000)%10); - putchar('0' + (size/100)%10); - putchar('0' + (size/10)%10); - putchar('0' + (size/1)%10); - } -#endif - if (block == 1) - { -#ifdef SIZEINDICATOR - rlen=len; -#endif - if (!eof && ( -#ifdef TAGGED_IMAGE - *((unsigned long *)data) == 0x1B031336L || -#endif -#ifdef ELF_IMAGE - *((unsigned long *)data) == 0x464C457FL || -#endif -#ifdef AOUT_IMAGE - *((unsigned short *)data) == 0x010BL || -#endif - ((unsigned short *)data)[255] == 0xAA55)) - { - ; - } - else if (eof) - { - memcpy(config_buffer, data, len); - config_buffer[len] = 0; - return (1); /* done */ - } - else - { - printf("error: not a tagged image\n"); - return(0); /* error */ - } - } - if (len != 0) { - if (!os_download(block, data, len)) - return(0); /* error */ - } - if (eof) { - os_download(block+1, data, 0); /* does not return */ - return(0); /* error */ - } - return(-1); /* there is more data */ -} - -#ifdef DOWNLOAD_PROTO_TFTP -/************************************************************************** -TFTP - Download extended BOOTP data, or kernel image -**************************************************************************/ -int tftp(const char *name, int (*fnc)(unsigned char *, int, int, int)) -{ - int retry = 0; - static unsigned short iport = 2000; - unsigned short oport; - unsigned short len, block = 0, prevblock = 0; - int bcounter = 0; - struct tftp_t *tr; - struct tftp_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 = (sprintf((char *)tp.u.rrq, "%s%coctet%cblksize%c%d", - name, 0, 0, 0, TFTP_MAX_PACKET) - ((char *)&tp)) + 1; - if (!udp_transmit(arptable[ARP_SERVER].ipaddr.s_addr, ++iport, - TFTP_PORT, len, &tp)) - return (0); - for (;;) - { -#ifdef CONGESTED - if (!await_reply(AWAIT_TFTP, iport, NULL, (block ? TFTP_REXMT : TIMEOUT))) -#else - if (!await_reply(AWAIT_TFTP, iport, NULL, TIMEOUT)) -#endif - { - if (!block && retry++ < MAX_TFTP_RETRIES) - { /* maybe initial request was lost */ - rfc951_sleep(retry); - 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[ETHER_HDR_SIZE]; - 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 != '\000' && p < e) { - if (!strcasecmp("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 = (sprintf((char *)tp.u.err.errmsg, - "RFC1782 error") - - ((char *)&tp)) + 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 == ntohs(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 != 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 */ - return (1); - } - return (0); -} -#endif /* DOWNLOAD_PROTO_TFTP */ - -#ifdef RARP_NOT_BOOTP -/************************************************************************** -RARP - Get my IP address and load information -**************************************************************************/ -int rarp() -{ - int retry; - - /* arp and rarp requests share the same packet structure. */ - struct arprequest rarpreq; - - memset(&rarpreq, 0, sizeof(rarpreq)); - - rarpreq.hwtype = htons(1); - rarpreq.protocol = htons(IP); - rarpreq.hwlen = ETHER_ADDR_SIZE; - rarpreq.protolen = 4; - rarpreq.opcode = htons(RARP_REQUEST); - memcpy(&rarpreq.shwaddr, arptable[ARP_CLIENT].node, ETHER_ADDR_SIZE); - /* sipaddr is already zeroed out */ - memcpy(&rarpreq.thwaddr, arptable[ARP_CLIENT].node, ETHER_ADDR_SIZE); - /* tipaddr is already zeroed out */ - - for (retry = 0; retry < MAX_ARP_RETRIES; rfc951_sleep(++retry)) { - eth_transmit(broadcast, RARP, sizeof(rarpreq), &rarpreq); - - if (await_reply(AWAIT_RARP, 0, rarpreq.shwaddr, TIMEOUT)) - break; - } - - if (retry < MAX_ARP_RETRIES) { - sprintf(kernel = kernel_buf, "/tftpboot/kernel.%I", arptable[ARP_CLIENT].ipaddr); - - return (1); - } - return (0); -} - -#else - -/************************************************************************** -BOOTP - Get my IP address and load information -**************************************************************************/ -int bootp() -{ - int retry; -#ifndef NO_DHCP_SUPPORT - int retry1; -#endif /* NO_DHCP_SUPPORT */ - struct bootp_t bp; - unsigned long starttime; -#ifdef T509HACK - int flag; - - flag = 1; -#endif - memset(&bp, 0, sizeof(struct bootp_t)); - bp.bp_op = BOOTP_REQUEST; - bp.bp_htype = 1; - bp.bp_hlen = ETHER_ADDR_SIZE; - bp.bp_xid = xid = starttime = currticks(); - memcpy(bp.bp_hwaddr, arptable[ARP_CLIENT].node, ETHER_ADDR_SIZE); -#ifdef NO_DHCP_SUPPORT - memcpy(bp.bp_vend, rfc1533_cookie, 5); /* request RFC-style options */ -#else - memcpy(bp.bp_vend, rfc1533_cookie, sizeof rfc1533_cookie); /* request RFC-style options */ - memcpy(bp.bp_vend+sizeof rfc1533_cookie, dhcpdiscover, sizeof dhcpdiscover); - memcpy(bp.bp_vend+sizeof rfc1533_cookie +sizeof dhcpdiscover, rfc1533_end, sizeof rfc1533_end); -#endif /* NO_DHCP_SUPPORT */ - - for (retry = 0; retry < MAX_BOOTP_RETRIES; ) { - - /* 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 bootp_t), &bp); -#ifdef T509HACK - if (flag) { - flag--; - } else { - if (await_reply(AWAIT_BOOTP, 0, NULL, TIMEOUT)) - return(1); - rfc951_sleep(++retry); - - } -#else -#ifdef NO_DHCP_SUPPORT - if (await_reply(AWAIT_BOOTP, 0, NULL, TIMEOUT)) -#else - if (await_reply(AWAIT_BOOTP, 0, NULL, TIMEOUT)){ - if (dhcp_reply==DHCPOFFER){ - dhcp_reply=0; - memcpy(bp.bp_vend, rfc1533_cookie, sizeof rfc1533_cookie); - memcpy(bp.bp_vend+sizeof rfc1533_cookie, dhcprequest, sizeof dhcprequest); - memcpy(bp.bp_vend+sizeof rfc1533_cookie +sizeof dhcprequest, rfc1533_end, sizeof rfc1533_end); - memcpy(bp.bp_vend+9, &dhcp_server, sizeof(in_addr)); - memcpy(bp.bp_vend+15, &dhcp_addr, sizeof(in_addr)); - for (retry1 = 0; retry1 < MAX_BOOTP_RETRIES;) { - udp_transmit(IP_BROADCAST, BOOTP_CLIENT, BOOTP_SERVER, - sizeof(struct bootp_t), &bp); - dhcp_reply=0; - if (await_reply(AWAIT_BOOTP, 0, NULL, TIMEOUT)) - if (dhcp_reply==DHCPACK) - return(1); - rfc951_sleep(++retry1); - } - } else -#endif /* NO_DHCP_SUPPORT */ - return(1); -#ifndef NO_DHCP_SUPPORT - } - rfc951_sleep(++retry); - -#endif /* NO_DHCP_SUPPORT */ -#endif - bp.bp_secs = htons((currticks()-starttime)/20); - } - return(0); -} -#endif /* RARP_NOT_BOOTP */ - -/************************************************************************** -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; - struct rpc_t *rpc; - unsigned short ptype; - - unsigned int protohdrlen = ETHER_HDR_SIZE + sizeof(struct iphdr) + - sizeof(struct udphdr); - 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 >= ETHER_HDR_SIZE) { - ptype = ((unsigned short) nic.packet[12]) << 8 - | ((unsigned short) nic.packet[13]); - } else continue; /* what else could we do with it? */ - if ((nic.packetlen >= ETHER_HDR_SIZE + - sizeof(struct arprequest)) && - (ptype == ARP) ) { - unsigned long tmp; - - arpreply = (struct arprequest *) - &nic.packet[ETHER_HDR_SIZE]; - if ((arpreply->opcode == ntohs(ARP_REPLY)) && - !memcmp(arpreply->sipaddr, ptr, sizeof(in_addr)) && - (type == AWAIT_ARP)) { - memcpy(arptable[ival].node, arpreply->shwaddr, ETHER_ADDR_SIZE); - return(1); - } - memcpy(&tmp, arpreply->tipaddr, sizeof(in_addr)); - if ((arpreply->opcode == ntohs(ARP_REQUEST)) && - (tmp == arptable[ARP_CLIENT].ipaddr.s_addr)) { - arpreply->opcode = htons(ARP_REPLY); - memcpy(arpreply->tipaddr, arpreply->sipaddr, sizeof(in_addr)); - memcpy(arpreply->thwaddr, arpreply->shwaddr, ETHER_ADDR_SIZE); - memcpy(arpreply->sipaddr, &arptable[ARP_CLIENT].ipaddr, sizeof(in_addr)); - memcpy(arpreply->shwaddr, arptable[ARP_CLIENT].node, ETHER_ADDR_SIZE); - eth_transmit(arpreply->thwaddr, ARP, - sizeof(struct arprequest), - arpreply); -#ifdef MDEBUG - memcpy(&tmp, arpreply->tipaddr, sizeof(in_addr)); - printf("Sent ARP reply to: %I\n",tmp); -#endif MDEBUG - } - continue; - } - - if (type == AWAIT_QDRAIN) { - continue; - } - - /* Check for RARP - No IP hdr */ - if ((type == AWAIT_RARP) && - (nic.packetlen >= ETHER_HDR_SIZE + - sizeof(struct arprequest)) && - (ptype == RARP)) { - arpreply = (struct arprequest *) - &nic.packet[ETHER_HDR_SIZE]; - if ((arpreply->opcode == ntohs(RARP_REPLY)) && - !memcmp(arpreply->thwaddr, ptr, ETHER_ADDR_SIZE)) { - memcpy(arptable[ARP_SERVER].node, arpreply->shwaddr, ETHER_ADDR_SIZE); - memcpy(& arptable[ARP_SERVER].ipaddr, arpreply->sipaddr, sizeof(in_addr)); - memcpy(& 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[ETHER_HDR_SIZE]; - if ((ip->verhdrlen != 0x45) || - ipchksum((unsigned short *)ip, sizeof(struct iphdr)) || - (ip->protocol != IP_UDP)) continue; - udp = (struct udphdr *)&nic.packet[ETHER_HDR_SIZE + - sizeof(struct iphdr)]; - - /* BOOTP ? */ - bootpreply = (struct bootp_t *)&nic.packet[ETHER_HDR_SIZE]; - if ((type == AWAIT_BOOTP) && - (nic.packetlen >= (ETHER_HDR_SIZE + -#ifdef NO_DHCP_SUPPORT - sizeof(struct bootp_t))) && -#else - sizeof(struct bootp_t))-DHCP_OPT_LEN) && -#endif /* NO_DHCP_SUPPORT */ - (ntohs(udp->dest) == BOOTP_CLIENT) && - (bootpreply->bp_op == BOOTP_REPLY) && - (bootpreply->bp_xid == xid)) { - arptable[ARP_CLIENT].ipaddr.s_addr = - bootpreply->bp_yiaddr.s_addr; -#ifndef NO_DHCP_SUPPORT - dhcp_addr.s_addr = bootpreply->bp_yiaddr.s_addr; -#endif /* NO_DHCP_SUPPORT */ - netmask = default_netmask(); - arptable[ARP_SERVER].ipaddr.s_addr = - bootpreply->bp_siaddr.s_addr; - memset(arptable[ARP_SERVER].node, 0, ETHER_ADDR_SIZE); /* Kill arp */ - arptable[ARP_GATEWAY].ipaddr.s_addr = - bootpreply->bp_giaddr.s_addr; - memset(arptable[ARP_GATEWAY].node, 0, ETHER_ADDR_SIZE); /* Kill arp */ - if (bootpreply->bp_file[0]) { - memcpy(kernel_buf, bootpreply->bp_file, 128); - kernel = kernel_buf; - } - memcpy((char *)BOOTP_DATA_ADDR, (char *)bootpreply, sizeof(struct bootpd_t)); - decode_rfc1533(BOOTP_DATA_ADDR->bootp_reply.bp_vend, -#ifdef NO_DHCP_SUPPORT - 0, BOOTP_VENDOR_LEN + MAX_BOOTP_EXTLEN, 1); -#else - 0, DHCP_OPT_LEN + MAX_BOOTP_EXTLEN, 1); -#endif /* NO_DHCP_SUPPORT */ - return(1); - } - -#ifdef DOWNLOAD_PROTO_TFTP - /* TFTP ? */ - if ((type == AWAIT_TFTP) && - (ntohs(udp->dest) == ival)) return(1); -#endif /* DOWNLOAD_PROTO_TFTP */ - -#ifdef DOWNLOAD_PROTO_NFS - /* RPC ? */ - rpc = (struct rpc_t *)&nic.packet[ETHER_HDR_SIZE]; - if ((type == AWAIT_RPC) && - (ntohs(udp->dest) == ival) && - (*(unsigned long *)ptr == ntohl(rpc->u.reply.id)) && - (ntohl(rpc->u.reply.type) == MSG_REPLY)) { - return (1); - } -#endif /* DOWNLOAD_PROTO_NFS */ - - } 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 (iskey() && (getchar() == ESC)) -#ifdef EMERGENCYDISKBOOT - exit(0); -#else - longjmp(jmp_bootmenu,1); -#endif - /* 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(p, block, len, eof) - register unsigned char *p; - int block, len, eof; -{ - static unsigned char *extdata = NULL, *extend = NULL; - unsigned char *extpath = NULL; - unsigned char *endp; - - if (block == 0) { -#ifdef IMAGE_MENU - memset(imagelist, 0, sizeof(imagelist)); - menudefault = useimagemenu = 0; - menutmo = -1; -#endif -#ifdef MOTD - memset(motd, 0, sizeof(motd)); -#endif - end_of_rfc1533 = NULL; - vendorext_isvalid = 0; - if (memcmp(p, rfc1533_cookie, 4)) - return(0); /* no RFC 1533 header found */ - p += 4; - endp = p + len; } - else { - if (block == 1) { - if (memcmp(p, rfc1533_cookie, 4)) - return(0); /* no RFC 1533 header found */ - p += 4; - len -= 4; } - if (extend + len <= (unsigned char *)&(BOOTP_DATA_ADDR->bootp_extension[MAX_BOOTP_EXTLEN])) { - memcpy(extend, p, len); - extend += len; - } else { - printf("Overflow in vendor data buffer! Aborting...\n"); - *extdata = RFC1533_END; - return(0); - } - p = extdata; endp = extend; - } - if (eof) { - 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) {memcpy(&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)) - memcpy(&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) - { - memcpy(&dhcp_server, p+2, sizeof(in_addr)); - } -#endif /* NO_DHCP_SUPPORT */ - else if (c == RFC1533_HOSTNAME) - { - hostname = p + 2; - hostnamelen = *(p + 1); - } - else if (c == RFC1533_VENDOR_MAGIC -#ifndef IMAGE_FREEBSD /* since FreeBSD uses tag 128 for swap definition */ - && TAG_LEN(p) >= 6 && - !memcmp(p+2,vendorext_magic,4) && - p[6] == RFC1533_VENDOR_MAJOR -#endif - ) - vendorext_isvalid++; -#ifdef IMAGE_FREEBSD - else if (c == RFC1533_VENDOR_HOWTO) { - freebsd_howto = ((p[2]*256+p[3])*256+p[4])*256+p[5]; - } -#endif -#ifdef IMAGE_MENU - else if (c == RFC1533_VENDOR_MNUOPTS) { - parse_menuopts(p+2, TAG_LEN(p)); - } - else if (c >= RFC1533_VENDOR_IMG && - c<RFC1533_VENDOR_IMG+RFC1533_VENDOR_NUMOFIMG){ - imagelist[c - RFC1533_VENDOR_IMG] = p; - useimagemenu++; - } -#endif -#ifdef MOTD - else if (c >= RFC1533_VENDOR_MOTD && - c < RFC1533_VENDOR_MOTD + - RFC1533_VENDOR_NUMOFMOTD) - motd[c - RFC1533_VENDOR_MOTD] = p; -#endif - else { -#if 0 - unsigned char *q; - printf("Unknown RFC1533-tag "); - for(q=p;q<p+2+TAG_LEN(p);q++) - printf("%x ",*q); - putchar('\n'); -#endif - } - p += TAG_LEN(p) + 2; - } - extdata = extend = endp; - if (block == 0 && extpath != NULL) { - char fname[64]; - memcpy(fname, extpath+2, TAG_LEN(extpath)); - fname[(int)TAG_LEN(extpath)] = '\000'; - printf("Loading BOOTP-extension file: %s\n",fname); - download(fname,decode_rfc1533); - } - } - return(-1); /* proceed with next block */ -} - -/************************************************************************** -IPCHKSUM - Checksum IP Header -**************************************************************************/ -unsigned short ipchksum(ip, len) - register unsigned short *ip; - register int len; -{ - unsigned long sum = 0; - len >>= 1; - while (len--) { - sum += *(ip++); - if (sum > 0xFFFF) - sum -= 0xFFFF; - } - return((~sum) & 0x0000FFFF); -} - -/************************************************************************** -RFC951_SLEEP - sleep for expotentially longer times -**************************************************************************/ -void rfc951_sleep(exp) - 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 Scheier's - "Applied Cryptography" */ - q = seed/53668; - if ((seed = 40014*(seed-53668*q) - 12211*q) < 0) seed += 2147483563l; - /* compute mask */ - for (tmo = 63; tmo <= 60*TICKS_PER_SEC && --exp > 0; tmo = 2*tmo+1); - /* sleep */ - printf("<sleep>\n"); - - for (tmo = (tmo&seed)+currticks(); currticks() < tmo; ) - if (iskey() && (getchar() == ESC)) longjmp(jmp_bootmenu,1); - return; -} - -/************************************************************************** -CLEANUP_NET - shut down networking -**************************************************************************/ -void cleanup_net(void) -{ -#ifdef DOWNLOAD_PROTO_NFS - nfs_umountall(ARP_SERVER); -#endif - eth_disable(); - eth_reset(); -} - -/************************************************************************** -CLEANUP - shut down etherboot so that the OS may be called right away -**************************************************************************/ -void cleanup(void) -{ -#if defined(ANSIESC) && defined(CONSOLE_CRT) - ansi_reset(); -#endif -} - -/* - * Local variables: - * c-basic-offset: 8 - * End: - */ |