?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge branch 'master' of git://github.com/illumos/illumos-gate
[unleashed.git] / usr / src / grub / grub-0.97 / netboot / nic.c
blob23b8d59fc805f8f53ab10105958c630252080022
1 /**************************************************************************
2 Etherboot - Network Bootstrap Program
3
4 Literature dealing with the network protocols:
5 ARP - RFC826
6 RARP - RFC903
7 IP - RFC791
8 UDP - RFC768
9 BOOTP - RFC951, RFC2132 (vendor extensions)
10 DHCP - RFC2131, RFC2132 (options)
11 TFTP - RFC1350, RFC2347 (options), RFC2348 (blocksize), RFC2349 (tsize)
12 RPC - RFC1831, RFC1832 (XDR), RFC1833 (rpcbind/portmapper)
13 NFS - RFC1094, RFC1813 (v3, useful for clarifications, not implemented)
14 IGMP - RFC1112, RFC2113, RFC2365, RFC2236, RFC3171
15
16 **************************************************************************/
17 #include "etherboot.h"
18 #include "grub.h"
19 #include "nic.h"
20 #include "elf.h" /* FOR EM_CURRENT */
21 #include "bootp.h"
22 #include "if_arp.h"
23 #include "tftp.h"
24 #include "timer.h"
25 #include "ip.h"
26 #include "udp.h"
27
28 /* Currently no other module uses rom, but it is available */
29 struct rom_info rom;
30 struct arptable_t arptable[MAX_ARP];
31 #ifdef MULTICAST_LEVEL2
32 unsigned long last_igmpv1 = 0;
33 struct igmptable_t igmptable[MAX_IGMP];
34 #endif
35 static unsigned long netmask;
36 /* Used by nfs.c */
37 char *hostname = "";
38 int hostnamelen = 0;
39 /* Used by fsys_tftp.c */
40 int use_bios_pxe = 0;
41 static uint32_t xid;
42 static unsigned char *end_of_rfc1533 = NULL;
43 static const unsigned char broadcast[] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF };
44 static const in_addr zeroIP = { 0L };
45 static char rfc1533_venddata[MAX_RFC1533_VENDLEN];
46 static unsigned char rfc1533_cookie[4] = { RFC1533_COOKIE };
47 static unsigned char rfc1533_cookie_bootp[5] = { RFC1533_COOKIE, RFC1533_END };
48 static unsigned char rfc1533_cookie_dhcp[] = { RFC1533_COOKIE };
49 static int dhcp_reply;
50 static in_addr dhcp_server = { 0L };
51 static in_addr dhcp_addr = { 0L };
52
53 static const unsigned char dhcpdiscover[] = {
54 RFC2132_MSG_TYPE, 1, DHCPDISCOVER,
55 RFC2132_MAX_SIZE, 2, /* request as much as we can */
56 ETH_MAX_MTU / 256, ETH_MAX_MTU % 256,
57 /* Vendor class identifier */
58 #ifdef SOLARIS_NETBOOT
59 RFC2132_VENDOR_CLASS_ID,32,'P','X','E','C','l','i','e','n','t',':',
60 'A','r','c','h',':','0','0','0','0','0',':','U','N','D','I',':',
61 '0','0','2','0','0','1',
62 #else
63 RFC2132_VENDOR_CLASS_ID, 10, 'G', 'R', 'U', 'B', 'C', 'l', 'i', 'e', 'n', 't',
64 #endif
65 RFC2132_PARAM_LIST, 4, RFC1533_NETMASK, RFC1533_GATEWAY,
66 RFC1533_HOSTNAME, RFC1533_EXTENSIONPATH, RFC1533_END
67 };
68 static const unsigned char dhcprequest [] = {
69 RFC2132_MSG_TYPE,1,DHCPREQUEST,
70 RFC2132_SRV_ID,4,0,0,0,0,
71 RFC2132_REQ_ADDR,4,0,0,0,0,
72 RFC2132_MAX_SIZE,2, /* request as much as we can */
73 ETH_MAX_MTU / 256, ETH_MAX_MTU % 256,
74 /* Vendor class identifier */
75 #ifdef SOLARIS_NETBOOT
76 RFC2132_VENDOR_CLASS_ID,32,'P','X','E','C','l','i','e','n','t',':',
77 'A','r','c','h',':','0','0','0','0','0',':','U','N','D','I',':',
78 '0','0','2','0','0','1',
79 #else
80 RFC2132_VENDOR_CLASS_ID, 10, 'G', 'R', 'U', 'B', 'C', 'l', 'i', 'e', 'n', 't',
81 #endif
82 RFC2132_PARAM_LIST,
83 /* 4 standard + 2 vendortags */
84 4 + 2,
85 /* Standard parameters */
86 RFC1533_NETMASK, RFC1533_GATEWAY,
87 RFC1533_HOSTNAME, RFC1533_EXTENSIONPATH,
88 /* Etherboot vendortags */
89 RFC1533_VENDOR_MAGIC,
90 RFC1533_VENDOR_CONFIGFILE,
91 RFC1533_END
92 };
93
94 /* See nic.h */
95 int user_abort = 0;
96 int network_ready = 0;
97
98 #ifdef REQUIRE_VCI_ETHERBOOT
99 int vci_etherboot;
100 #endif
101
102 char *bootfile = NULL;
103 configfile_origin_t configfile_origin = CFG_HARDCODED;
104 char *vendor_configfile = NULL;
105 char vendor_configfile_len;
106
107 static void update_network_configuration(void);
108
109 static int dummy(void *unused __unused)
110 {
111 return (0);
112 }
113
114 /* Careful. We need an aligned buffer to avoid problems on machines
115 * that care about alignment. To trivally align the ethernet data
116 * (the ip hdr and arp requests) we offset the packet by 2 bytes.
117 * leaving the ethernet data 16 byte aligned. Beyond this
118 * we use memmove but this makes the common cast simple and fast.
119 */
120 static char packet[ETH_FRAME_LEN + ETH_DATA_ALIGN] __aligned;
121
122 struct nic nic =
123 {
124 {
125 0, /* dev.disable */
126 {
127 0,
128 0,
129 PCI_BUS_TYPE,
130 }, /* dev.devid */
131 0, /* index */
132 0, /* type */
133 PROBE_FIRST, /* how_pobe */
134 PROBE_NONE, /* to_probe */
135 0, /* failsafe */
136 0, /* type_index */
137 {}, /* state */
138 },
139 (int (*)(struct nic *, int))dummy, /* poll */
140 (void (*)(struct nic *, const char *,
141 unsigned int, unsigned int,
142 const char *))dummy, /* transmit */
143 (void (*)(struct nic *, irq_action_t))dummy, /* irq */
144 0, /* flags */
145 &rom, /* rom_info */
146 arptable[ARP_CLIENT].node, /* node_addr */
147 packet + ETH_DATA_ALIGN, /* packet */
148 0, /* packetlen */
149 0, /* ioaddr */
150 0, /* irqno */
151 NULL, /* priv_data */
152 };
153
154
155
156 int grub_eth_probe(void)
157 {
158 static int probed = 0;
159 struct dev *dev;
160
161 EnterFunction("grub_eth_probe");
162
163 if (probed)
164 return 1;
165
166 network_ready = 0;
167 grub_memset((char *)arptable, 0, MAX_ARP * sizeof(struct arptable_t));
168 dev = &nic.dev;
169 dev->how_probe = -1;
170 dev->type = NIC_DRIVER;
171 dev->failsafe = 1;
172 rom = *((struct rom_info *)ROM_INFO_LOCATION);
173
174 probed = (eth_probe(dev) == PROBE_WORKED);
175
176 LeaveFunction("grub_eth_probe");
177 return probed;
178 }
179
180 int eth_probe(struct dev *dev)
181 {
182 return probe(dev);
183 }
184
185 int eth_poll(int retrieve)
186 {
187 return ((*nic.poll)(&nic, retrieve));
188 }
189
190 void eth_transmit(const char *d, unsigned int t, unsigned int s, const void *p)
191 {
192 (*nic.transmit)(&nic, d, t, s, p);
193 if (t == IP) twiddle();
194 }
195
196 void eth_disable(void)
197 {
198 #ifdef MULTICAST_LEVEL2
199 int i;
200 for(i = 0; i < MAX_IGMP; i++) {
201 leave_group(i);
202 }
203 #endif
204 disable(&nic.dev);
205 }
206
207 void eth_irq (irq_action_t action)
208 {
209 (*nic.irq)(&nic,action);
210 }
211
212 /**************************************************************************
213 IPCHKSUM - Checksum IP Header
214 **************************************************************************/
215 uint16_t ipchksum(const void *data, unsigned long length)
216 {
217 unsigned long sum;
218 unsigned long i;
219 const uint8_t *ptr;
220
221 /* In the most straight forward way possible,
222 * compute an ip style checksum.
223 */
224 sum = 0;
225 ptr = data;
226 for(i = 0; i < length; i++) {
227 unsigned long value;
228 value = ptr[i];
229 if (i & 1) {
230 value <<= 8;
231 }
232 /* Add the new value */
233 sum += value;
234 /* Wrap around the carry */
235 if (sum > 0xFFFF) {
236 sum = (sum + (sum >> 16)) & 0xFFFF;
237 }
238 }
239 return (~cpu_to_le16(sum)) & 0xFFFF;
240 }
241
242 uint16_t add_ipchksums(unsigned long offset, uint16_t sum, uint16_t new)
243 {
244 unsigned long checksum;
245 sum = ~sum & 0xFFFF;
246 new = ~new & 0xFFFF;
247 if (offset & 1) {
248 /* byte swap the sum if it came from an odd offset
249 * since the computation is endian independant this
250 * works.
251 */
252 new = bswap_16(new);
253 }
254 checksum = sum + new;
255 if (checksum > 0xFFFF) {
256 checksum -= 0xFFFF;
257 }
258 return (~checksum) & 0xFFFF;
259 }
260
261 /**************************************************************************
262 DEFAULT_NETMASK - Return default netmask for IP address
263 **************************************************************************/
264 static inline unsigned long default_netmask(void)
265 {
266 int net = ntohl(arptable[ARP_CLIENT].ipaddr.s_addr) >> 24;
267 if (net <= 127)
268 return(htonl(0xff000000));
269 else if (net < 192)
270 return(htonl(0xffff0000));
271 else
272 return(htonl(0xffffff00));
273 }
274
275 /**************************************************************************
276 IP_TRANSMIT - Send an IP datagram
277 **************************************************************************/
278 static int await_arp(int ival, void *ptr,
279 unsigned short ptype, struct iphdr *ip __unused, struct udphdr *udp __unused)
280 {
281 struct arprequest *arpreply;
282 if (ptype != ARP)
283 return 0;
284 if (nic.packetlen < ETH_HLEN + sizeof(struct arprequest))
285 return 0;
286 arpreply = (struct arprequest *)&nic.packet[ETH_HLEN];
287
288 if (arpreply->opcode != htons(ARP_REPLY))
289 return 0;
290 if (memcmp(arpreply->sipaddr, ptr, sizeof(in_addr)) != 0)
291 return 0;
292 memcpy(arptable[ival].node, arpreply->shwaddr, ETH_ALEN);
293 return 1;
294 }
295
296 int ip_transmit(int len, const void *buf)
297 {
298 unsigned long destip;
299 struct iphdr *ip;
300 struct arprequest arpreq;
301 int arpentry, i;
302 int retry;
303
304 ip = (struct iphdr *)buf;
305 destip = ip->dest.s_addr;
306 if (destip == IP_BROADCAST) {
307 eth_transmit(broadcast, IP, len, buf);
308 #ifdef MULTICAST_LEVEL1
309 } else if ((destip & htonl(MULTICAST_MASK)) == htonl(MULTICAST_NETWORK)) {
310 unsigned char multicast[6];
311 unsigned long hdestip;
312 hdestip = ntohl(destip);
313 multicast[0] = 0x01;
314 multicast[1] = 0x00;
315 multicast[2] = 0x5e;
316 multicast[3] = (hdestip >> 16) & 0x7;
317 multicast[4] = (hdestip >> 8) & 0xff;
318 multicast[5] = hdestip & 0xff;
319 eth_transmit(multicast, IP, len, buf);
320 #endif
321 } else {
322 if (((destip & netmask) !=
323 (arptable[ARP_CLIENT].ipaddr.s_addr & netmask)) &&
324 arptable[ARP_GATEWAY].ipaddr.s_addr)
325 destip = arptable[ARP_GATEWAY].ipaddr.s_addr;
326 for(arpentry = 0; arpentry<MAX_ARP; arpentry++)
327 if (arptable[arpentry].ipaddr.s_addr == destip) break;
328 if (arpentry == MAX_ARP) {
329 printf("%@ is not in my arp table!\n", destip);
330 return(0);
331 }
332 for (i = 0; i < ETH_ALEN; i++)
333 if (arptable[arpentry].node[i])
334 break;
335 if (i == ETH_ALEN) { /* Need to do arp request */
336 arpreq.hwtype = htons(1);
337 arpreq.protocol = htons(IP);
338 arpreq.hwlen = ETH_ALEN;
339 arpreq.protolen = 4;
340 arpreq.opcode = htons(ARP_REQUEST);
341 memcpy(arpreq.shwaddr, arptable[ARP_CLIENT].node, ETH_ALEN);
342 memcpy(arpreq.sipaddr, &arptable[ARP_CLIENT].ipaddr, sizeof(in_addr));
343 memset(arpreq.thwaddr, 0, ETH_ALEN);
344 memcpy(arpreq.tipaddr, &destip, sizeof(in_addr));
345 for (retry = 1; retry <= MAX_ARP_RETRIES; retry++) {
346 long timeout;
347 eth_transmit(broadcast, ARP, sizeof(arpreq),
348 &arpreq);
349 timeout = rfc2131_sleep_interval(TIMEOUT, retry);
350 if (await_reply(await_arp, arpentry,
351 arpreq.tipaddr, timeout)) goto xmit;
352 }
353 return(0);
354 }
355 xmit:
356 eth_transmit(arptable[arpentry].node, IP, len, buf);
357 }
358 return 1;
359 }
360
361 void build_ip_hdr(unsigned long destip, int ttl, int protocol, int option_len,
362 int len, const void *buf)
363 {
364 struct iphdr *ip;
365 ip = (struct iphdr *)buf;
366 ip->verhdrlen = 0x45;
367 ip->verhdrlen += (option_len/4);
368 ip->service = 0;
369 ip->len = htons(len);
370 ip->ident = 0;
371 ip->frags = 0; /* Should we set don't fragment? */
372 ip->ttl = ttl;
373 ip->protocol = protocol;
374 ip->chksum = 0;
375 ip->src.s_addr = arptable[ARP_CLIENT].ipaddr.s_addr;
376 ip->dest.s_addr = destip;
377 ip->chksum = ipchksum(buf, sizeof(struct iphdr) + option_len);
378 }
379
380 static uint16_t udpchksum(struct iphdr *ip, struct udphdr *udp)
381 {
382 struct udp_pseudo_hdr pseudo;
383 uint16_t checksum;
384
385 /* Compute the pseudo header */
386 pseudo.src.s_addr = ip->src.s_addr;
387 pseudo.dest.s_addr = ip->dest.s_addr;
388 pseudo.unused = 0;
389 pseudo.protocol = IP_UDP;
390 pseudo.len = udp->len;
391
392 /* Sum the pseudo header */
393 checksum = ipchksum(&pseudo, 12);
394
395 /* Sum the rest of the udp packet */
396 checksum = add_ipchksums(12, checksum, ipchksum(udp, ntohs(udp->len)));
397 return checksum;
398 }
399
400
401 void build_udp_hdr(unsigned long destip,
402 unsigned int srcsock, unsigned int destsock, int ttl,
403 int len, const void *buf)
404 {
405 struct iphdr *ip;
406 struct udphdr *udp;
407 ip = (struct iphdr *)buf;
408 build_ip_hdr(destip, ttl, IP_UDP, 0, len, buf);
409 udp = (struct udphdr *)((char *)buf + sizeof(struct iphdr));
410 udp->src = htons(srcsock);
411 udp->dest = htons(destsock);
412 udp->len = htons(len - sizeof(struct iphdr));
413 udp->chksum = 0;
414 if ((udp->chksum = udpchksum(ip, udp)) == 0)
415 udp->chksum = 0xffff;
416 }
417
418
419 /**************************************************************************
420 UDP_TRANSMIT - Send an UDP datagram
421 **************************************************************************/
422 int udp_transmit(unsigned long destip, unsigned int srcsock,
423 unsigned int destsock, int len, const void *buf)
424 {
425 build_udp_hdr(destip, srcsock, destsock, 60, len, buf);
426 return ip_transmit(len, buf);
427 }
428
429 /**************************************************************************
430 QDRAIN - clear the nic's receive queue
431 **************************************************************************/
432 static int await_qdrain(int ival __unused, void *ptr __unused,
433 unsigned short ptype __unused,
434 struct iphdr *ip __unused, struct udphdr *udp __unused)
435 {
436 return 0;
437 }
438
439 void rx_qdrain(void)
440 {
441 /* Clear out the Rx queue first. It contains nothing of interest,
442 * except possibly ARP requests from the DHCP/TFTP server. We use
443 * polling throughout Etherboot, so some time may have passed since we
444 * last polled the receive queue, which may now be filled with
445 * broadcast packets. This will cause the reply to the packets we are
446 * about to send to be lost immediately. Not very clever. */
447 await_reply(await_qdrain, 0, NULL, 0);
448 }
449
450 /**
451 * rarp
452 *
453 * Get IP address by rarp. Just copy from etherboot
454 **/
455 static int await_rarp(int ival, void *ptr, unsigned short ptype,
456 struct iphdr *ip, struct udphdr *udp)
457 {
458 struct arprequest *arpreply;
459 if (ptype != RARP)
460 return 0;
461 if (nic.packetlen < ETH_HLEN + sizeof(struct arprequest))
462 return 0;
463 arpreply = (struct arprequest *)&nic.packet[ETH_HLEN];
464 if (arpreply->opcode != htons(RARP_REPLY))
465 return 0;
466 if (memcmp(arpreply->thwaddr, ptr, ETH_ALEN) == 0){
467 memcpy(arptable[ARP_SERVER].node, arpreply->shwaddr, ETH_ALEN);
468 memcpy(&arptable[ARP_SERVER].ipaddr, arpreply->sipaddr, sizeof(in_addr));
469 memcpy(&arptable[ARP_CLIENT].ipaddr, arpreply->tipaddr, sizeof(in_addr));
470 memset(&arptable[ARP_GATEWAY].ipaddr, 0, sizeof(in_addr));
471 return 1;
472 }
473 return 0;
474 }
475
476 int rarp(void)
477 {
478 int retry;
479
480 /* arp and rarp requests share the same packet structure. */
481 struct arprequest rarpreq;
482
483 if(!grub_eth_probe())
484 return 0;
485 network_ready = 0;
486
487 memset(&rarpreq, 0, sizeof(rarpreq));
488
489 rarpreq.hwtype = htons(1);
490 rarpreq.protocol = htons(IP);
491 rarpreq.hwlen = ETH_ALEN;
492 rarpreq.protolen = 4;
493 rarpreq.opcode = htons(RARP_REQUEST);
494 memcpy(&rarpreq.shwaddr, arptable[ARP_CLIENT].node, ETH_ALEN);
495 /* sipaddr is already zeroed out */
496 memcpy(&rarpreq.thwaddr, arptable[ARP_CLIENT].node, ETH_ALEN);
497 /* tipaddr is already zeroed out */
498
499 for (retry = 0; retry < MAX_ARP_RETRIES; ++retry) {
500 long timeout;
501 eth_transmit(broadcast, RARP, sizeof(rarpreq), &rarpreq);
502
503 timeout = rfc2131_sleep_interval(TIMEOUT, retry);
504 if (await_reply(await_rarp, 0, rarpreq.shwaddr, timeout))
505 break;
506 if (user_abort)
507 return 0;
508 }
509
510 if (retry == MAX_ARP_RETRIES) {
511 return (0);
512 }
513
514 network_ready = 1;
515 update_network_configuration();
516 return (1);
517 }
518
519 /**
520 * bootp
521 *
522 * Get IP address by bootp, segregate from bootp in etherboot.
523 **/
524 static int await_bootp(int ival __unused, void *ptr __unused,
525 unsigned short ptype __unused, struct iphdr *ip __unused,
526 struct udphdr *udp)
527 {
528 struct bootp_t *bootpreply;
529 int len; /* Length of vendor */
530
531 if (!udp) {
532 return 0;
533 }
534 bootpreply = (struct bootp_t *)
535 &nic.packet[ETH_HLEN + sizeof(struct iphdr) + sizeof(struct udphdr)];
536 len = nic.packetlen - (ETH_HLEN + sizeof(struct iphdr) +
537 sizeof(struct udphdr) + sizeof(struct bootp_t) - BOOTP_VENDOR_LEN);
538 if (len < 0) {
539 return 0;
540 }
541 if (udp->dest != htons(BOOTP_CLIENT))
542 return 0;
543 if (bootpreply->bp_op != BOOTP_REPLY)
544 return 0;
545 if (bootpreply->bp_xid != xid)
546 return 0;
547 if (memcmp((char *)&bootpreply->bp_siaddr, (char *)&zeroIP, sizeof(in_addr)) == 0)
548 return 0;
549 if ((memcmp(broadcast, bootpreply->bp_hwaddr, ETH_ALEN) != 0) &&
550 (memcmp(arptable[ARP_CLIENT].node, bootpreply->bp_hwaddr, ETH_ALEN) != 0)) {
551 return 0;
552 }
553
554 #ifdef SOLARIS_NETBOOT
555 /* fill in netinfo */
556 dhcpack_length = len + sizeof (struct bootp_t) - BOOTP_VENDOR_LEN;
557 memcpy((char *)dhcpack_buf, (char *)bootpreply, dhcpack_length);
558 #endif
559
560 arptable[ARP_CLIENT].ipaddr.s_addr = bootpreply->bp_yiaddr.s_addr;
561 netmask = default_netmask();
562 arptable[ARP_SERVER].ipaddr.s_addr = bootpreply->bp_siaddr.s_addr;
563 memset(arptable[ARP_SERVER].node, 0, ETH_ALEN); /* Kill arp */
564 arptable[ARP_GATEWAY].ipaddr.s_addr = bootpreply->bp_giaddr.s_addr;
565 memset(arptable[ARP_GATEWAY].node, 0, ETH_ALEN); /* Kill arp */
566 bootfile = bootpreply->bp_file;
567 memcpy((char *)rfc1533_venddata, (char *)(bootpreply->bp_vend), len);
568 decode_rfc1533(rfc1533_venddata, 0, len, 1);
569 return(1);
570 }
571
572 int bootp(void)
573 {
574 int retry;
575 struct bootpip_t ip;
576 unsigned long starttime;
577
578 EnterFunction("bootp");
579
580 if(!grub_eth_probe())
581 return 0;
582 network_ready = 0;
583
584 memset(&ip, 0, sizeof(struct bootpip_t));
585 ip.bp.bp_op = BOOTP_REQUEST;
586 ip.bp.bp_htype = 1;
587 ip.bp.bp_hlen = ETH_ALEN;
588 starttime = currticks();
589 /* Use lower 32 bits of node address, more likely to be
590 distinct than the time since booting */
591 memcpy(&xid, &arptable[ARP_CLIENT].node[2], sizeof(xid));
592 ip.bp.bp_xid = xid += htonl(starttime);
593 /* bp_secs defaults to zero */
594 memcpy(ip.bp.bp_hwaddr, arptable[ARP_CLIENT].node, ETH_ALEN);
595 memcpy(ip.bp.bp_vend, rfc1533_cookie_bootp, sizeof(rfc1533_cookie_bootp)); /* request RFC-style options */
596
597 for (retry = 0; retry < MAX_BOOTP_RETRIES; ) {
598 long timeout;
599
600 rx_qdrain();
601
602 udp_transmit(IP_BROADCAST, BOOTP_CLIENT, BOOTP_SERVER,
603 sizeof(struct bootpip_t), &ip);
604 timeout = rfc2131_sleep_interval(TIMEOUT, retry++);
605 if (await_reply(await_bootp, 0, NULL, timeout)){
606 network_ready = 1;
607 return(1);
608 }
609 if (user_abort)
610 return 0;
611 ip.bp.bp_secs = htons((currticks()-starttime)/TICKS_PER_SEC);
612 }
613 return(0);
614 }
615
616 /**
617 * dhcp
618 *
619 * Get IP address by dhcp, segregate from bootp in etherboot.
620 **/
621 static int await_dhcp(int ival __unused, void *ptr __unused,
622 unsigned short ptype __unused, struct iphdr *ip __unused,
623 struct udphdr *udp)
624 {
625 struct dhcp_t *dhcpreply;
626 int len;
627
628 if (!udp) {
629 return 0;
630 }
631 dhcpreply = (struct dhcp_t *)
632 &nic.packet[ETH_HLEN + sizeof(struct iphdr) + sizeof(struct udphdr)];
633 len = nic.packetlen - (ETH_HLEN + sizeof(struct iphdr) +
634 sizeof(struct udphdr) + sizeof(struct dhcp_t) - DHCP_OPT_LEN);
635 if (len < 0){
636 return 0;
637 }
638 if (udp->dest != htons(BOOTP_CLIENT))
639 return 0;
640 if (dhcpreply->bp_op != BOOTP_REPLY)
641 return 0;
642 if (dhcpreply->bp_xid != xid)
643 return 0;
644 if (memcmp((char *)&dhcpreply->bp_siaddr, (char *)&zeroIP, sizeof(in_addr)) == 0)
645 return 0;
646 if ((memcmp(broadcast, dhcpreply->bp_hwaddr, ETH_ALEN) != 0) &&
647 (memcmp(arptable[ARP_CLIENT].node, dhcpreply->bp_hwaddr, ETH_ALEN) != 0)) {
648 return 0;
649 }
650
651 #ifdef SOLARIS_NETBOOT
652 /* fill in netinfo */
653 dhcpack_length = len + sizeof (struct dhcp_t) - DHCP_OPT_LEN;
654 memcpy((char *)dhcpack_buf, (char *)dhcpreply, dhcpack_length);
655 #endif
656 arptable[ARP_CLIENT].ipaddr.s_addr = dhcpreply->bp_yiaddr.s_addr;
657 dhcp_addr.s_addr = dhcpreply->bp_yiaddr.s_addr;
658 netmask = default_netmask();
659 arptable[ARP_SERVER].ipaddr.s_addr = dhcpreply->bp_siaddr.s_addr;
660 memset(arptable[ARP_SERVER].node, 0, ETH_ALEN); /* Kill arp */
661 arptable[ARP_GATEWAY].ipaddr.s_addr = dhcpreply->bp_giaddr.s_addr;
662 memset(arptable[ARP_GATEWAY].node, 0, ETH_ALEN); /* Kill arp */
663 bootfile = dhcpreply->bp_file;
664 memcpy((char *)rfc1533_venddata, (char *)(dhcpreply->bp_vend), len);
665 decode_rfc1533(rfc1533_venddata, 0, len, 1);
666 return(1);
667 }
668
669 int dhcp(void)
670 {
671 int retry;
672 int reqretry;
673 struct dhcpip_t ip;
674 unsigned long starttime;
675
676 /* try bios pxe stack first */
677 if (dhcp_undi())
678 return 1;
679
680 if(!grub_eth_probe())
681 return 0;
682
683 network_ready = 0;
684
685 memset(&ip, 0, sizeof(ip));
686 ip.bp.bp_op = BOOTP_REQUEST;
687 ip.bp.bp_htype = 1;
688 ip.bp.bp_hlen = ETH_ALEN;
689 starttime = currticks();
690 /* Use lower 32 bits of node address, more likely to be
691 distinct than the time since booting */
692 memcpy(&xid, &arptable[ARP_CLIENT].node[2], sizeof(xid));
693 ip.bp.bp_xid = xid += htonl(starttime);
694 memcpy(ip.bp.bp_hwaddr, arptable[ARP_CLIENT].node, ETH_ALEN);
695 memcpy(ip.bp.bp_vend, rfc1533_cookie_dhcp, sizeof rfc1533_cookie_dhcp); /* request RFC-style options */
696 memcpy(ip.bp.bp_vend + sizeof rfc1533_cookie_dhcp, dhcpdiscover, sizeof dhcpdiscover);
697
698 for (retry = 0; retry < MAX_BOOTP_RETRIES; ) {
699 long timeout;
700
701 rx_qdrain();
702
703 udp_transmit(IP_BROADCAST, BOOTP_CLIENT, BOOTP_SERVER,
704 sizeof(ip), &ip);
705 timeout = rfc2131_sleep_interval(TIMEOUT, retry++);
706 if (await_reply(await_dhcp, 0, NULL, timeout)) {
707 /* If not a DHCPOFFER then must be just a
708 BOOTP reply, be backward compatible with
709 BOOTP then. Jscott report a bug here, but I
710 don't know how it happened */
711 if (dhcp_reply != DHCPOFFER){
712 network_ready = 1;
713 return(1);
714 }
715 dhcp_reply = 0;
716 memcpy(ip.bp.bp_vend, rfc1533_cookie_dhcp, sizeof rfc1533_cookie_dhcp);
717 memcpy(ip.bp.bp_vend + sizeof rfc1533_cookie_dhcp, dhcprequest, sizeof dhcprequest);
718 /* Beware: the magic numbers 9 and 15 depend on
719 the layout of dhcprequest */
720 memcpy(&ip.bp.bp_vend[9], &dhcp_server, sizeof(in_addr));
721 memcpy(&ip.bp.bp_vend[15], &dhcp_addr, sizeof(in_addr));
722 for (reqretry = 0; reqretry < MAX_BOOTP_RETRIES; ) {
723 udp_transmit(IP_BROADCAST, BOOTP_CLIENT, BOOTP_SERVER,
724 sizeof(ip), &ip);
725 dhcp_reply=0;
726 timeout = rfc2131_sleep_interval(TIMEOUT, reqretry++);
727 if (await_reply(await_dhcp, 0, NULL, timeout))
728 if (dhcp_reply == DHCPACK){
729 network_ready = 1;
730 return(1);
731 }
732 if (user_abort)
733 return 0;
734 }
735 }
736 if (user_abort)
737 return 0;
738 ip.bp.bp_secs = htons((currticks()-starttime)/TICKS_PER_SEC);
739 }
740 return(0);
741 }
742
743 #ifdef MULTICAST_LEVEL2
744 static void send_igmp_reports(unsigned long now)
745 {
746 int i;
747 for(i = 0; i < MAX_IGMP; i++) {
748 if (igmptable[i].time && (now >= igmptable[i].time)) {
749 struct igmp_ip_t igmp;
750 igmp.router_alert[0] = 0x94;
751 igmp.router_alert[1] = 0x04;
752 igmp.router_alert[2] = 0;
753 igmp.router_alert[3] = 0;
754 build_ip_hdr(igmptable[i].group.s_addr,
755 1, IP_IGMP, sizeof(igmp.router_alert), sizeof(igmp), &igmp);
756 igmp.igmp.type = IGMPv2_REPORT;
757 if (last_igmpv1 &&
758 (now < last_igmpv1 + IGMPv1_ROUTER_PRESENT_TIMEOUT)) {
759 igmp.igmp.type = IGMPv1_REPORT;
760 }
761 igmp.igmp.response_time = 0;
762 igmp.igmp.chksum = 0;
763 igmp.igmp.group.s_addr = igmptable[i].group.s_addr;
764 igmp.igmp.chksum = ipchksum(&igmp.igmp, sizeof(igmp.igmp));
765 ip_transmit(sizeof(igmp), &igmp);
766 #ifdef MDEBUG
767 printf("Sent IGMP report to: %@\n", igmp.igmp.group.s_addr);
768 #endif
769 /* Don't send another igmp report until asked */
770 igmptable[i].time = 0;
771 }
772 }
773 }
774
775 static void process_igmp(struct iphdr *ip, unsigned long now)
776 {
777 struct igmp *igmp;
778 int i;
779 unsigned iplen = 0;
780 if (!ip || (ip->protocol == IP_IGMP) ||
781 (nic.packetlen < sizeof(struct iphdr) + sizeof(struct igmp))) {
782 return;
783 }
784 iplen = (ip->verhdrlen & 0xf)*4;
785 igmp = (struct igmp *)&nic.packet[sizeof(struct iphdr)];
786 if (ipchksum(igmp, ntohs(ip->len) - iplen) != 0)
787 return;
788 if ((igmp->type == IGMP_QUERY) &&
789 (ip->dest.s_addr == htonl(GROUP_ALL_HOSTS))) {
790 unsigned long interval = IGMP_INTERVAL;
791 if (igmp->response_time == 0) {
792 last_igmpv1 = now;
793 } else {
794 interval = (igmp->response_time * TICKS_PER_SEC)/10;
795 }
796
797 #ifdef MDEBUG
798 printf("Received IGMP query for: %@\n", igmp->group.s_addr);
799 #endif
800 for(i = 0; i < MAX_IGMP; i++) {
801 uint32_t group = igmptable[i].group.s_addr;
802 if ((group == 0) || (group == igmp->group.s_addr)) {
803 unsigned long time;
804 time = currticks() + rfc1112_sleep_interval(interval, 0);
805 if (time < igmptable[i].time) {
806 igmptable[i].time = time;
807 }
808 }
809 }
810 }
811 if (((igmp->type == IGMPv1_REPORT) || (igmp->type == IGMPv2_REPORT)) &&
812 (ip->dest.s_addr == igmp->group.s_addr)) {
813 #ifdef MDEBUG
814 printf("Received IGMP report for: %@\n", igmp->group.s_addr);
815 #endif
816 for(i = 0; i < MAX_IGMP; i++) {
817 if ((igmptable[i].group.s_addr == igmp->group.s_addr) &&
818 igmptable[i].time != 0) {
819 igmptable[i].time = 0;
820 }
821 }
822 }
823 }
824
825 void leave_group(int slot)
826 {
827 /* Be very stupid and always send a leave group message if
828 * I have subscribed. Imperfect but it is standards
829 * compliant, easy and reliable to implement.
830 *
831 * The optimal group leave method is to only send leave when,
832 * we were the last host to respond to a query on this group,
833 * and igmpv1 compatibility is not enabled.
834 */
835 if (igmptable[slot].group.s_addr) {
836 struct igmp_ip_t igmp;
837 igmp.router_alert[0] = 0x94;
838 igmp.router_alert[1] = 0x04;
839 igmp.router_alert[2] = 0;
840 igmp.router_alert[3] = 0;
841 build_ip_hdr(htonl(GROUP_ALL_HOSTS),
842 1, IP_IGMP, sizeof(igmp.router_alert), sizeof(igmp), &igmp);
843 igmp.igmp.type = IGMP_LEAVE;
844 igmp.igmp.response_time = 0;
845 igmp.igmp.chksum = 0;
846 igmp.igmp.group.s_addr = igmptable[slot].group.s_addr;
847 igmp.igmp.chksum = ipchksum(&igmp.igmp, sizeof(igmp));
848 ip_transmit(sizeof(igmp), &igmp);
849 #ifdef MDEBUG
850 printf("Sent IGMP leave for: %@\n", igmp.igmp.group.s_addr);
851 #endif
852 }
853 memset(&igmptable[slot], 0, sizeof(igmptable[0]));
854 }
855
856 void join_group(int slot, unsigned long group)
857 {
858 /* I have already joined */
859 if (igmptable[slot].group.s_addr == group)
860 return;
861 if (igmptable[slot].group.s_addr) {
862 leave_group(slot);
863 }
864 /* Only join a group if we are given a multicast ip, this way
865 * code can be given a non-multicast (broadcast or unicast ip)
866 * and still work...
867 */
868 if ((group & htonl(MULTICAST_MASK)) == htonl(MULTICAST_NETWORK)) {
869 igmptable[slot].group.s_addr = group;
870 igmptable[slot].time = currticks();
871 }
872 }
873 #else
874 #define send_igmp_reports(now);
875 #define process_igmp(ip, now)
876 #endif
877
878 /**************************************************************************
879 AWAIT_REPLY - Wait until we get a response for our request
880 ************f**************************************************************/
881 int await_reply(reply_t reply, int ival, void *ptr, long timeout)
882 {
883 unsigned long time, now;
884 struct iphdr *ip;
885 unsigned iplen = 0;
886 struct udphdr *udp;
887 unsigned short ptype;
888 int result;
889
890 user_abort = 0;
891
892 time = timeout + currticks();
893 /* The timeout check is done below. The timeout is only checked if
894 * there is no packet in the Rx queue. This assumes that eth_poll()
895 * needs a negligible amount of time.
896 */
897 for (;;) {
898 now = currticks();
899 send_igmp_reports(now);
900 result = eth_poll(1);
901 if (result == 0) {
902 /* We don't have anything */
903
904 /* Check for abort key only if the Rx queue is empty -
905 * as long as we have something to process, don't
906 * assume that something failed. It is unlikely that
907 * we have no processing time left between packets. */
908 poll_interruptions();
909 /* Do the timeout after at least a full queue walk. */
910 if ((timeout == 0) || (currticks() > time) || user_abort == 1) {
911 break;
912 }
913 continue;
914 }
915
916 /* We have something! */
917
918 /* Find the Ethernet packet type */
919 if (nic.packetlen >= ETH_HLEN) {
920 ptype = ((unsigned short) nic.packet[12]) << 8
921 | ((unsigned short) nic.packet[13]);
922 } else continue; /* what else could we do with it? */
923 /* Verify an IP header */
924 ip = 0;
925 if ((ptype == IP) && (nic.packetlen >= ETH_HLEN + sizeof(struct iphdr))) {
926 unsigned ipoptlen;
927 ip = (struct iphdr *)&nic.packet[ETH_HLEN];
928 if ((ip->verhdrlen < 0x45) || (ip->verhdrlen > 0x4F))
929 continue;
930 iplen = (ip->verhdrlen & 0xf) * 4;
931 if (ipchksum(ip, iplen) != 0)
932 continue;
933 if (ip->frags & htons(0x3FFF)) {
934 static int warned_fragmentation = 0;
935 if (!warned_fragmentation) {
936 printf("ALERT: got a fragmented packet - reconfigure your server\n");
937 warned_fragmentation = 1;
938 }
939 continue;
940 }
941 if (ntohs(ip->len) > ETH_MAX_MTU)
942 continue;
943
944 ipoptlen = iplen - sizeof(struct iphdr);
945 if (ipoptlen) {
946 /* Delete the ip options, to guarantee
947 * good alignment, and make etherboot simpler.
948 */
949 memmove(&nic.packet[ETH_HLEN + sizeof(struct iphdr)],
950 &nic.packet[ETH_HLEN + iplen],
951 nic.packetlen - ipoptlen);
952 nic.packetlen -= ipoptlen;
953 }
954 }
955 udp = 0;
956 if (ip && (ip->protocol == IP_UDP) &&
957 (nic.packetlen >= ETH_HLEN + sizeof(struct iphdr) + sizeof(struct udphdr))) {
958 udp = (struct udphdr *)&nic.packet[ETH_HLEN + sizeof(struct iphdr)];
959
960 /* Make certain we have a reasonable packet length */
961 if (ntohs(udp->len) > (ntohs(ip->len) - iplen))
962 continue;
963
964 if (udp->chksum && udpchksum(ip, udp)) {
965 printf("UDP checksum error\n");
966 continue;
967 }
968 }
969 result = reply(ival, ptr, ptype, ip, udp);
970 if (result > 0) {
971 return result;
972 }
973
974 /* If it isn't a packet the upper layer wants see if there is a default
975 * action. This allows us reply to arp and igmp queryies.
976 */
977 if ((ptype == ARP) &&
978 (nic.packetlen >= ETH_HLEN + sizeof(struct arprequest))) {
979 struct arprequest *arpreply;
980 unsigned long tmp;
981
982 arpreply = (struct arprequest *)&nic.packet[ETH_HLEN];
983 memcpy(&tmp, arpreply->tipaddr, sizeof(in_addr));
984 if ((arpreply->opcode == htons(ARP_REQUEST)) &&
985 (tmp == arptable[ARP_CLIENT].ipaddr.s_addr)) {
986 arpreply->opcode = htons(ARP_REPLY);
987 memcpy(arpreply->tipaddr, arpreply->sipaddr, sizeof(in_addr));
988 memcpy(arpreply->thwaddr, arpreply->shwaddr, ETH_ALEN);
989 memcpy(arpreply->sipaddr, &arptable[ARP_CLIENT].ipaddr, sizeof(in_addr));
990 memcpy(arpreply->shwaddr, arptable[ARP_CLIENT].node, ETH_ALEN);
991 eth_transmit(arpreply->thwaddr, ARP,
992 sizeof(struct arprequest),
993 arpreply);
994 #ifdef MDEBUG
995 memcpy(&tmp, arpreply->tipaddr, sizeof(in_addr));
996 printf("Sent ARP reply to: %@\n",tmp);
997 #endif /* MDEBUG */
998 }
999 }
1000 process_igmp(ip, now);
1001 }
1002 return(0);
1003 }
1004
1005 #ifdef REQUIRE_VCI_ETHERBOOT
1006 /**************************************************************************
1007 FIND_VCI_ETHERBOOT - Looks for "Etherboot" in Vendor Encapsulated Identifiers
1008 On entry p points to byte count of VCI options
1009 **************************************************************************/
1010 static int find_vci_etherboot(unsigned char *p)
1011 {
1012 unsigned char *end = p + 1 + *p;
1013
1014 for (p++; p < end; ) {
1015 if (*p == RFC2132_VENDOR_CLASS_ID) {
1016 if (strncmp("Etherboot", p + 2, sizeof("Etherboot") - 1) == 0)
1017 return (1);
1018 } else if (*p == RFC1533_END)
1019 return (0);
1020 p += TAG_LEN(p) + 2;
1021 }
1022 return (0);
1023 }
1024 #endif /* REQUIRE_VCI_ETHERBOOT */
1025
1026 /**
1027 * decode_rfc1533
1028 *
1029 * Decodes RFC1533 header
1030 **/
1031 int decode_rfc1533(unsigned char *p, unsigned int block, unsigned int len, int eof)
1032 {
1033 static unsigned char *extdata = NULL, *extend = NULL;
1034 unsigned char *extpath = NULL;
1035 unsigned char *endp;
1036
1037 if (block == 0) {
1038 end_of_rfc1533 = NULL;
1039 if (memcmp(p, rfc1533_cookie, sizeof(rfc1533_cookie)))
1040 return(0); /* no RFC 1533 header found */
1041 p += 4;
1042 endp = p + len;
1043 } else {
1044 if (block == 1) {
1045 if (memcmp(p, rfc1533_cookie, sizeof(rfc1533_cookie)))
1046 return(0); /* no RFC 1533 header found */
1047 p += 4;
1048 len -= 4; }
1049 if (extend + len <= (unsigned char *)
1050 rfc1533_venddata + sizeof(rfc1533_venddata)) {
1051 memcpy(extend, p, len);
1052 extend += len;
1053 } else {
1054 printf("Overflow in vendor data buffer! Aborting...\n");
1055 *extdata = RFC1533_END;
1056 return(0);
1057 }
1058 p = extdata; endp = extend;
1059 }
1060 if (!eof)
1061 return 1;
1062 while (p < endp) {
1063 unsigned char c = *p;
1064 if (c == RFC1533_PAD) {
1065 p++;
1066 continue;
1067 }
1068 else if (c == RFC1533_END) {
1069 end_of_rfc1533 = endp = p;
1070 continue;
1071 }
1072 else if (c == RFC1533_NETMASK)
1073 memcpy(&netmask, p+2, sizeof(in_addr));
1074 else if (c == RFC1533_GATEWAY) {
1075 /* This is a little simplistic, but it will
1076 usually be sufficient.
1077 Take only the first entry */
1078 if (TAG_LEN(p) >= sizeof(in_addr))
1079 memcpy(&arptable[ARP_GATEWAY].ipaddr, p+2, sizeof(in_addr));
1080 }
1081 else if (c == RFC1533_EXTENSIONPATH)
1082 extpath = p;
1083 else if (c == RFC2132_MSG_TYPE)
1084 dhcp_reply=*(p+2);
1085 else if (c == RFC2132_SRV_ID)
1086 memcpy(&dhcp_server, p+2, sizeof(in_addr));
1087 else if (c == RFC1533_HOSTNAME) {
1088 hostname = p + 2;
1089 hostnamelen = *(p + 1);
1090 }
1091 else if (c == RFC1533_VENDOR_CONFIGFILE){
1092 int l = TAG_LEN (p);
1093
1094 /* Eliminate the trailing NULs according to RFC 2132. */
1095 while (*(p + 2 + l - 1) == '\000' && l > 0)
1096 l--;
1097
1098 /* XXX: Should check if LEN is less than the maximum length
1099 of CONFIG_FILE. This kind of robustness will be a goal
1100 in GRUB 1.0. */
1101 memcpy (config_file, p + 2, l);
1102 config_file[l] = 0;
1103 vendor_configfile = p + 2;
1104 vendor_configfile_len = l;
1105 configfile_origin = CFG_150;
1106 }
1107 else {
1108 ;
1109 }
1110 p += TAG_LEN(p) + 2;
1111 }
1112 extdata = extend = endp;
1113 if (block <= 0 && extpath != NULL) {
1114 char fname[64];
1115 if (TAG_LEN(extpath) >= sizeof(fname)){
1116 printf("Overflow in vendor data buffer! Aborting...\n");
1117 *extdata = RFC1533_END;
1118 return(0);
1119 }
1120 memcpy(fname, extpath+2, TAG_LEN(extpath));
1121 fname[(int)TAG_LEN(extpath)] = '\0';
1122 printf("Loading BOOTP-extension file: %s\n",fname);
1123 tftp_file_read(fname, decode_rfc1533);
1124 }
1125 return 1; /* proceed with next block */
1126 }
1127
1128
1129 /* FIXME double check TWO_SECOND_DIVISOR */
1130 #define TWO_SECOND_DIVISOR (RAND_MAX/TICKS_PER_SEC)
1131 /**************************************************************************
1132 RFC2131_SLEEP_INTERVAL - sleep for expotentially longer times (base << exp) +- 1 sec)
1133 **************************************************************************/
1134 long rfc2131_sleep_interval(long base, int exp)
1135 {
1136 unsigned long tmo;
1137 #ifdef BACKOFF_LIMIT
1138 if (exp > BACKOFF_LIMIT)
1139 exp = BACKOFF_LIMIT;
1140 #endif
1141 tmo = (base << exp) + (TICKS_PER_SEC - (random()/TWO_SECOND_DIVISOR));
1142 return tmo;
1143 }
1144
1145 #ifdef MULTICAST_LEVEL2
1146 /**************************************************************************
1147 RFC1112_SLEEP_INTERVAL - sleep for expotentially longer times, up to (base << exp)
1148 **************************************************************************/
1149 long rfc1112_sleep_interval(long base, int exp)
1150 {
1151 unsigned long divisor, tmo;
1152 #ifdef BACKOFF_LIMIT
1153 if (exp > BACKOFF_LIMIT)
1154 exp = BACKOFF_LIMIT;
1155 #endif
1156 divisor = RAND_MAX/(base << exp);
1157 tmo = random()/divisor;
1158 return tmo;
1159 }
1160 #endif /* MULTICAST_LEVEL_2 */
1161 /* ifconfig - configure network interface. */
1162 int
1163 ifconfig (char *ip, char *sm, char *gw, char *svr)
1164 {
1165 in_addr tmp;
1166
1167 if (sm)
1168 {
1169 if (! inet_aton (sm, &tmp))
1170 return 0;
1171
1172 netmask = tmp.s_addr;
1173 }
1174
1175 if (ip)
1176 {
1177 if (! inet_aton (ip, &arptable[ARP_CLIENT].ipaddr))
1178 return 0;
1179
1180 if (! netmask && ! sm)
1181 netmask = default_netmask ();
1182 }
1183
1184 if (gw && ! inet_aton (gw, &arptable[ARP_GATEWAY].ipaddr))
1185 return 0;
1186
1187 /* Clear out the ARP entry. */
1188 grub_memset (arptable[ARP_GATEWAY].node, 0, ETH_ALEN);
1189
1190 if (svr && ! inet_aton (svr, &arptable[ARP_SERVER].ipaddr))
1191 return 0;
1192
1193 /* Likewise. */
1194 grub_memset (arptable[ARP_SERVER].node, 0, ETH_ALEN);
1195
1196 if (ip || sm)
1197 {
1198 if (IP_BROADCAST == (netmask | arptable[ARP_CLIENT].ipaddr.s_addr)
1199 || netmask == (netmask | arptable[ARP_CLIENT].ipaddr.s_addr)
1200 || ! netmask)
1201 network_ready = 0;
1202 else
1203 network_ready = 1;
1204 }
1205
1206 update_network_configuration();
1207 return 1;
1208 }
1209
1210 /*
1211 * print_network_configuration
1212 *
1213 * Output the network configuration. It may broke the graphic console now.:-(
1214 */
1215 void print_network_configuration (void)
1216 {
1217 EnterFunction("print_network_configuration");
1218 if (! network_ready)
1219 grub_printf ("Network interface not initialized yet.\n");
1220 else {
1221 if (hostnamelen == 0)
1222 etherboot_printf ("Hostname: not set\n");
1223 else
1224 etherboot_printf ("Hostname: %s\n", hostname);
1225
1226 etherboot_printf ("Address: %@\n", arptable[ARP_CLIENT].ipaddr.s_addr);
1227 etherboot_printf ("Netmask: %@\n", netmask);
1228 etherboot_printf ("Gateway: %@\n", arptable[ARP_GATEWAY].ipaddr.s_addr);
1229 etherboot_printf ("Server: %@\n", arptable[ARP_SERVER].ipaddr.s_addr);
1230 if (vendor_configfile == NULL) {
1231 etherboot_printf ("Site Option 150: not set\n");
1232 } else {
1233 /*
1234 * vendor_configfile points into the packet and
1235 * is not NULL terminated, so it needs to be
1236 * patched up before printing it out
1237 */
1238 char c = vendor_configfile[vendor_configfile_len];
1239 vendor_configfile[vendor_configfile_len] = '\0';
1240 etherboot_printf ("Site Option 150: %s\n",
1241 vendor_configfile);
1242 vendor_configfile[vendor_configfile_len] = c;
1243 }
1244
1245 if (bootfile == NULL)
1246 etherboot_printf ("BootFile: not set\n");
1247 else
1248 etherboot_printf ("BootFile: %s\n", bootfile);
1249
1250 etherboot_printf ("GRUB menu file: %s", config_file);
1251 switch (configfile_origin) {
1252 case CFG_HARDCODED:
1253 etherboot_printf (" from hardcoded default\n");
1254 break;
1255 case CFG_150:
1256 etherboot_printf (" from Site Option 150\n");
1257 break;
1258 case CFG_MAC:
1259 etherboot_printf (" inferred from system MAC\n");
1260 break;
1261 case CFG_BOOTFILE:
1262 etherboot_printf (" inferred from BootFile\n");
1263 break;
1264 default:
1265 etherboot_printf ("\n");
1266 }
1267 }
1268 LeaveFunction("print_network_configuration");
1269 }
1270
1271 /*
1272 * update_network_configuration
1273 *
1274 * Update network configuration for diskless clients (Solaris only)
1275 */
1276 static void update_network_configuration (void)
1277 {
1278 #ifdef SOLARIS_NETBOOT
1279 struct sol_netinfo {
1280 uint8_t sn_infotype;
1281 uint8_t sn_mactype;
1282 uint8_t sn_maclen;
1283 uint8_t sn_padding;
1284 unsigned long sn_ciaddr;
1285 unsigned long sn_siaddr;
1286 unsigned long sn_giaddr;
1287 unsigned long sn_netmask;
1288 uint8_t sn_macaddr[1];
1289 } *sip;
1290
1291 if (! network_ready)
1292 return;
1293
1294 sip = (struct sol_netinfo *)dhcpack_buf;
1295 sip->sn_infotype = 0xf0; /* something not BOOTP_REPLY */
1296 sip->sn_mactype = 4; /* DL_ETHER */
1297 sip->sn_maclen = ETH_ALEN;
1298 sip->sn_ciaddr = arptable[ARP_CLIENT].ipaddr.s_addr;
1299 sip->sn_siaddr = arptable[ARP_SERVER].ipaddr.s_addr;
1300 sip->sn_giaddr = arptable[ARP_GATEWAY].ipaddr.s_addr;
1301 sip->sn_netmask = netmask;
1302 memcpy(sip->sn_macaddr, arptable[ARP_CLIENT].node, ETH_ALEN);
1303 dhcpack_length = sizeof (*sip) + sip->sn_maclen - 1;
1304 #endif /* SOLARIS_NETBOOT */
1305 }
1306
1307 /**
1308 * cleanup_net
1309 *
1310 * Mark network unusable, and disable NICs
1311 */
1312 void cleanup_net (void)
1313 {
1314 if (network_ready){
1315 /* Stop receiving packets. */
1316 if (use_bios_pxe)
1317 undi_pxe_disable();
1318 else
1319 eth_disable ();
1320 network_ready = 0;
1321 }
1322 }
1323
1324 /*******************************************************************
1325 * dhcp implementation reusing the BIOS pxe stack
1326 */
1327 static void
1328 dhcp_copy(struct dhcp_t *dhcpreply)
1329 {
1330 unsigned long time;
1331 int ret, len = DHCP_OPT_LEN;
1332
1333 /* fill in netinfo */
1334 dhcpack_length = sizeof (struct dhcp_t);
1335 memcpy((char *)dhcpack_buf, (char *)dhcpreply, dhcpack_length);
1336
1337 memcpy(arptable[ARP_CLIENT].node, dhcpreply->bp_hwaddr, ETH_ALEN);
1338 arptable[ARP_CLIENT].ipaddr.s_addr = dhcpreply->bp_yiaddr.s_addr;
1339 dhcp_addr.s_addr = dhcpreply->bp_yiaddr.s_addr;
1340 netmask = default_netmask();
1341 arptable[ARP_SERVER].ipaddr.s_addr = dhcpreply->bp_siaddr.s_addr;
1342 memset(arptable[ARP_SERVER].node, 0, ETH_ALEN); /* Kill arp */
1343 arptable[ARP_GATEWAY].ipaddr.s_addr = dhcpreply->bp_giaddr.s_addr;
1344 memset(arptable[ARP_GATEWAY].node, 0, ETH_ALEN); /* Kill arp */
1345 bootfile = dhcpreply->bp_file;
1346 memcpy((char *)rfc1533_venddata, (char *)(dhcpreply->bp_vend), len);
1347 decode_rfc1533(rfc1533_venddata, 0, len, 1);
1348 }
1349
1350 int dhcp_undi(void)
1351 {
1352 struct dhcp_t *dhcpreply;
1353
1354 if (!undi_bios_pxe((void **)&dhcpreply))
1355 return 0;
1356
1357 dhcp_copy(dhcpreply);
1358 network_ready = 1;
1359 use_bios_pxe = 1;
1360 return (1);
1361 }
Unleashed OS