![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to in_bootp.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Apple Darwin 0.x] / kernel / bsd / netinet|
Return to in_bootp.c CVS log | Up to [Apple Darwin 0.x] / kernel / bsd / netinet |
1.1 root 1: /*
2: * Copyright (c) 1999 Apple Computer, Inc. All rights reserved.
3: *
4: * @APPLE_LICENSE_HEADER_START@
5: *
6: * Portions Copyright (c) 1999 Apple Computer, Inc. All Rights
7: * Reserved. This file contains Original Code and/or Modifications of
8: * Original Code as defined in and that are subject to the Apple Public
9: * Source License Version 1.1 (the "License"). You may not use this file
10: * except in compliance with the License. Please obtain a copy of the
11: * License at http://www.apple.com/publicsource and read it before using
12: * this file.
13: *
14: * The Original Code and all software distributed under the License are
15: * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER
16: * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
17: * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
18: * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the
19: * License for the specific language governing rights and limitations
20: * under the License.
21: *
22: * @APPLE_LICENSE_HEADER_END@
23: */
24:
25: #if NEXT
26: /*
27: * Copyright (c) 1988, by NeXT Inc.
28: *
29: **********************************************************************
30: * HISTORY
31: * Tue Mar 18 11:49:14 PST 1997 Dieter Siegmund (dieter) at NeXT
32: * Ported from 4.3 to 4.4Lite (Teflon)
33: *
34: * Mon Jan 10 15:13:33 PST 1994 Matt Watson (mwatson) at NeXT
35: * Allow "Sexy Net Init"(tm) while netbooting
36: * Function prototype cleanup
37: *
38: * 09-Apr-90 Bradley Taylor (btaylor) at NeXT
39: * Changes because of new network API (netbuf and netif)
40: *
41: * 25-May-89 Peter King (king) at NeXT
42: * Added support for "Sexy Net Init" -- NeXT vendor protocol 1.
43: *
44: * 15-Aug-88 Peter King (king) at NeXT, Inc.
45: * Created.
46: **********************************************************************
47: */
48:
49: #if m68k
50: #else
51:
52: #import <machine/spl.h>
53: #import <machine/label_t.h>
54: #import <sys/param.h>
55: #import <sys/types.h>
56: #import <mach/boolean.h>
57: #import <sys/kernel.h>
58: #import <sys/errno.h>
59: #import <sys/file.h>
60: #import <sys/uio.h>
61: #import <sys/ioctl.h>
62: #import <sys/time.h>
63: #import <sys/mbuf.h>
64: #import <sys/vnode.h>
65: #import <sys/socket.h>
66: #import <sys/socketvar.h>
67: #import <net/if.h>
68: #import <net/route.h>
69: #import <netinet/in.h>
70: #import <netinet/in_systm.h>
71: //#import <netinet/in_pcb.h>
72: #import <netinet/if_ether.h>
73: #import <netinet/ip.h>
74: #import <netinet/ip_var.h>
75: #import <netinet/udp.h>
76: #import <netinet/udp_var.h>
77: #import <netinet/ip_icmp.h>
78: #import <netinet/bootp.h>
79: #import <dev/kmreg_com.h>
80:
81: #define CONSOLE "/dev/console"
82:
83: #define BOOTP_DEBUG 0
84: #if BOOTP_DEBUG
85: #define dprintf(x) printf x;
86: #else BOOTP_DEBUG
87: #define dprintf(x)
88: #endif BOOTP_DEBUG
89:
90: static int in_bootp_initnet(volatile struct ifnet *ifp, struct ifreq *ifr,
91: struct socket **sop);
92:
93: static struct bootp_packet * in_bootp_buildpacket(volatile struct ifnet *ifp,
94: struct sockaddr_in *sin, u_char my_enaddr[6]);
95:
96: struct mbuf * in_bootp_bptombuf(struct bootp_packet *bp);
97:
98: static void in_bootp_timeout(struct socket **socketflag);
99:
100: static int in_bootp_promisctimeout(boolean_t *ignoreflag);
101:
102: static int in_bootp_getpacket(struct socket *so, caddr_t pp, int psize);
103:
104: static int in_bootp_sendrequest(volatile struct ifnet *ifp,
105: struct socket *so, struct bootp_packet *bp_s, struct bootp *bp_r,
106: u_char my_enaddr[6], struct vnode **console_vpp);
107:
108: static int in_bootp_openconsole(struct vnode **vpp);
109:
110: static void in_bootp_closeconsole(struct vnode *vp);
111:
112: static int in_bootp_processreply(struct vnode *vp, struct bootp_packet *bp_s,
113: struct bootp *bp_r);
114:
115: static int in_bootp_setaddress(volatile struct ifnet *ifp, struct ifreq *ifr,
116: struct socket *so, struct in_addr *addr);
117:
118: static struct ifreq in_bootp_makeifreq(volatile struct ifnet *ifp,
119: struct sockaddr_in *sin);
120:
121: static void kmgets(char *cp, char *lp, boolean_t silent);
122:
123: static boolean_t alertShowing = FALSE;
124:
125: /*
126: * Routine: in_bootp
127: * Function:
128: * Use the BOOTP protocol to resolve what our IP address should be
129: * on a particular interface.
130: * Note:
131: * The ifreq structure returns the newly configured address. If there
132: * is an error, it can be full of bogus information.
133: *
134: * This is called from driver level ioctl routines to assure that
135: * the interface is a 10Meg Ethernet.
136: */
137: int
138: in_bootp(
139: volatile struct ifnet *ifp,
140: struct sockaddr_in *sin,
141: u_char my_enaddr[6]
142: )
143: {
144: struct mbuf *m;
145: struct socket *so;
146: register int error;
147: struct bootp_packet *bp_s = NULL;
148: struct bootp *bp_r = NULL;
149: struct vnode *vp = NULL;
150: struct nextvend *nv_s;
151: struct nextvend *nv_r;
152: struct ifreq ifr;
153: struct proc * procp = current_proc(); /* XXX */
154:
155: dprintf(("in_bootp() entered\n"));
156:
157: ifr = in_bootp_makeifreq(ifp, sin);
158: if (error = in_bootp_initnet(ifp, &ifr, &so)) {
159: if (error == -1) {
160: /*
161: * This means the interface was already
162: * autoconfigured. Reset the address to make
163: * sure the netmask is right.
164: */
165: error = ifioctl(so, SIOCSIFADDR, (caddr_t)&ifr,
166: procp);
167: if (error == 0) {
168: bcopy(&ifr.ifr_addr, sin, sizeof(*sin));
169: }
170: soclose(so);
171: return (error);
172: }
173: dprintf(("in_bootp() in_bootp_initnet failed: %d\n", error));
174: goto errout;
175: }
176:
177: /* Build a packet */
178: bp_s = in_bootp_buildpacket(ifp,
179: sin,
180: my_enaddr);
181: nv_s = (struct nextvend *)&bp_s->bp_bootp.bp_vend;
182:
183: /* Set up place to receive BOOTP response */
184: bp_r = (struct bootp *)kalloc(sizeof (*bp_r));
185: nv_r = (struct nextvend *)&bp_r->bp_vend;
186:
187: while (TRUE) {
188: /* Send the request */
189: dprintf(("in_bootp() trying to send request\n"));
190: if (error = in_bootp_sendrequest(ifp, so, bp_s, bp_r,
191: my_enaddr, &vp)) {
192: goto errout;
193: }
194: if (nv_r->nv_opcode == BPOP_OK) {
195: break;
196: }
197: dprintf(("in_bootp() trying to open console\n"));
198: if (vp == NULL && (error = in_bootp_openconsole(&vp))) {
199: goto errout;
200: }
201: dprintf(("in_bootp() trying to process reply\n"));
202: if (error = in_bootp_processreply(vp, bp_s, bp_r)) {
203: goto errout;
204: }
205: }
206:
207: /* It's for us. */
208: dprintf(("in_bootp() got a response!\n"));
209: if (vp) {
210: (void) in_bootp_closeconsole(vp);
211: vp = NULL;
212: }
213:
214: error = in_bootp_setaddress(ifp, &ifr, so,
215: (struct in_addr *)&bp_r->bp_yiaddr);
216: if (error == 0) {
217: bcopy(&ifr.ifr_addr, sin, sizeof(*sin));
218: }
219:
220: errout:
221: if (error && so) {
222: /* Make sure the interface is shut down */
223: (void) ifioctl(so, SIOCDIFADDR, (caddr_t) &ifr, procp);
224: ifr.ifr_flags = ifp->if_flags & ~(IFF_UP);
225: (void) ifioctl(so, SIOCSIFFLAGS, (caddr_t) &ifr, procp);
226: }
227: ifp->if_eflags &= ~(IFEF_AUTOCONF);
228: if (so) {
229: soclose(so);
230: }
231: if (bp_s) {
232: kfree((caddr_t)bp_s, sizeof (*bp_s));
233: }
234: if (bp_r) {
235: kfree((caddr_t)bp_r, sizeof (*bp_r));
236: }
237: if (!error) {
238: (void) in_bootp_closeconsole(vp);
239: }
240: dprintf(("in_bootp() returning: %d\n", error));
241:
242: return (error);
243: }
244:
245: /*
246: * Routine: in_bootp_initnet
247: * Function:
248: * Set up the interface to handle BOOTP packets. Return the interface
249: * address in ifr.
250: * Returns:
251: * -1: interface previously autoconfigured
252: * 0: success
253: * >0: unix error
254: */
255: int
256: in_bootp_initnet(ifp, ifr, sop)
257: register volatile struct ifnet *ifp;
258: register struct ifreq *ifr;
259: struct socket **sop;
260: {
261: struct sockaddr_in lsin;
262: struct sockaddr_in *sin;
263: struct mbuf *m;
264: int error;
265: struct proc * procp = current_proc(); /* XXX */
266:
267: dprintf((" in_bootp_initnet() entered\n"));
268:
269: /*
270: * Get a socket (wouldn't it be nice to make system calls from
271: * within the kernel?)
272: */
273: dprintf((" in_bootp_initnet() socreate..."));
274: if (error = socreate(AF_INET, sop, SOCK_DGRAM, 0)) {
275: *sop = NULL;
276: dprintf(("failed: %d\n", error));
277: return (error);
278: }
279: dprintf(("ok\n"));
280:
281: /*
282: * Bring the interface up if neccessary.
283: */
284: if ((ifp->if_flags & IFF_UP) == 0) {
285: /* Turn off trailers here, otherwise the server ARP reply
286: will cause the booting client the issue its own ARP
287: reply enabling trailers.
288: */
289: ifr->ifr_flags = ifp->if_flags | IFF_UP | IFF_NOTRAILERS;
290: dprintf((" in_bootp_initnet() SIOCSIFFLAGS..."));
291: if (error = ifioctl(*sop, SIOCSIFFLAGS, (caddr_t)ifr, procp)) {
292: dprintf(("failed: %d\n", error));
293: return (error);
294: }
295: dprintf(("ok\n"));
296: }
297: else {
298: if (ifp->if_eflags & IFEF_AUTOCONF_DONE) {
299: /* If the interface was previously autoconfigured, return */
300: dprintf((" in_bootp_initnet() already done:"));
301: if ((error = ifioctl(*sop, SIOCGIFADDR,
302: (caddr_t)ifr, procp))) {
303: dprintf((" %d\n", error));
304: return (error);
305: }
306: ifp->if_eflags &= ~(IFEF_AUTOCONF);
307: dprintf((" -1\n"));
308: return(-1);
309: }
310: }
311:
312: /*
313: * Assign the all-zeroes address to the interface.
314: */
315: bzero((caddr_t)&lsin, sizeof(lsin));
316: lsin.sin_family = AF_INET;
317: ifr->ifr_addr = *(struct sockaddr *)&lsin;
318:
319: dprintf((" in_bootp_initnet() SIOCSIFADDR..."));
320: if (error = ifioctl(*sop, SIOCSIFADDR, (caddr_t)ifr, procp)) {
321: dprintf(("failed: %d\n",
322: error));
323: return (error);
324: }
325: dprintf(("ok\n"));
326:
327: /*
328: * Now set up the socket to receive the BOOTP response, i.e. bind
329: * a name to it.
330: */
331: dprintf((" in_bootp_initnet() m_get..."));
332: m = m_get(M_WAIT, MT_SONAME);
333: if (m == NULL) {
334: error = ENOBUFS;
335: dprintf(("failed: %d\n", error));
336: return (error);
337: }
338: dprintf(("ok\n"));
339:
340: m->m_len = sizeof (struct sockaddr_in);
341: sin = mtod(m, struct sockaddr_in *);
342: sin->sin_family = AF_INET;
343: sin->sin_port = htons(IPPORT_BOOTPC);
344: sin->sin_addr.s_addr = INADDR_ANY;
345:
346: dprintf((" in_bootp_initnet() sobind..."));
347: error = sobind(*sop, m);
348: m_freem(m);
349: if (error) {
350: dprintf(("failed: %d\n", error));
351: return (error);
352: }
353: dprintf(("ok\n"));
354:
355: /* We will be doing non-blocking IO on this socket */
356: (*sop)->so_state |= SS_NBIO;
357:
358: dprintf((" in_bootp_initnet() exiting normally\n"));
359: return (0);
360: }
361:
362: /*
363: * Routine: in_bootp_buildpacket
364: * Function:
365: * Put together a BOOTP request packet. RFC951.
366: */
367: struct bootp_packet *
368: in_bootp_buildpacket(
369: volatile struct ifnet *ifp, /* Interface */
370: struct sockaddr_in *sin, /* Local IP address */
371: u_char my_enaddr[6] /* Local EN address */
372: )
373: {
374: struct bootp_packet *bp_s;
375: struct nextvend *nv;
376:
377: dprintf((" in_bootp_buildpacket() entered\n"));
378:
379: bp_s = (struct bootp_packet *)kalloc(sizeof (*bp_s));
380: nv = (struct nextvend *)&bp_s->bp_bootp.bp_vend;
381:
382: bzero(bp_s, sizeof (*bp_s));
383: bp_s->bp_ip.ip_v = IPVERSION;
384: bp_s->bp_ip.ip_hl = sizeof (struct ip) >> 2;
385: bp_s->bp_ip.ip_id = htons(ip_id++);
386: bp_s->bp_ip.ip_ttl = MAXTTL;
387: bp_s->bp_ip.ip_p = IPPROTO_UDP;
388: bp_s->bp_ip.ip_src.s_addr = sin->sin_addr.s_addr;
389: bp_s->bp_ip.ip_dst.s_addr = INADDR_BROADCAST;
390: bp_s->bp_udp.uh_sport = htons(IPPORT_BOOTPC);
391: bp_s->bp_udp.uh_dport = htons(IPPORT_BOOTPS);
392: bp_s->bp_udp.uh_sum = 0;
393: bp_s->bp_bootp.bp_op = BOOTREQUEST;
394: bp_s->bp_bootp.bp_htype = ARPHRD_ETHER;
395: bp_s->bp_bootp.bp_hlen = 6;
396: bp_s->bp_bootp.bp_ciaddr.s_addr = 0;
397: bcopy((caddr_t)my_enaddr, bp_s->bp_bootp.bp_chaddr, 6);
398: bcopy(VM_NEXT, &nv->nv_magic, 4);
399:
400: nv->nv_version = 1;
401: nv->nv_opcode = BPOP_OK;
402: bp_s->bp_udp.uh_ulen = htons(sizeof (bp_s->bp_udp) +
403: sizeof (bp_s->bp_bootp));
404: bp_s->bp_ip.ip_len = htons(sizeof (struct ip) +
405: ntohs(bp_s->bp_udp.uh_ulen));
406: bp_s->bp_ip.ip_sum = 0;
407:
408: dprintf((" in_bootp_buildpacket() exiting\n"));
409:
410: return (bp_s);
411: }
412:
413: /*
414: * Routine: in_bootp_bptombuf
415: * Function:
416: * Put the outgoing BOOTP packet into an mbuf chain.
417: */
418: struct mbuf *
419: in_bootp_bptombuf(bp)
420: struct bootp_packet *bp;
421: {
422: register struct ip *ip;
423: struct mbuf *m;
424: int resid = sizeof (*bp);
425: caddr_t cp = (caddr_t) bp;
426:
427: m = (struct mbuf *)m_devget(bp, sizeof(*bp), 0, 0, 0);
428:
429: if (m == 0) {
430: printf("in_bootp_bptombuf: m_devget failed\n");
431: return 0;
432: }
433: m->m_flags |= M_BCAST;
434:
435: /* Compute the checksum */
436: ip = mtod(m, struct ip *);
437: ip->ip_sum = 0;
438: ip->ip_sum = in_cksum(m, sizeof (struct ip));
439: return (m);
440: }
441:
442: /*
443: * Routine: in_bootp_timeout
444: * Function:
445: * Wakeup the process waiting to receive something on a socket.
446: * Boy wouldn't it be nice if we could do system calls from the
447: * kernel. Then I could do a select!
448: */
449: void
450: in_bootp_timeout(socketflag)
451: struct socket **socketflag;
452: {
453: struct socket *so = *socketflag;
454:
455: dprintf(("\n---->in_bootp_timeout()\n"));
456:
457: *socketflag = NULL;
458: sowakeup(so, &so->so_rcv);
459: }
460:
461: /*
462: * Routine: in_bootp_promisctimeout
463: * Function:
464: * Flag that it is ok to accept a response from a promiscuous BOOTP
465: * server.
466: */
467: int
468: in_bootp_promisctimeout(ignoreflag)
469: boolean_t *ignoreflag;
470: {
471: dprintf(("\n---->in_bootp_promisctimeout()\n"));
472:
473: *ignoreflag = FALSE;
474: return 0;
475: }
476:
477: /*
478: * Routine: in_bootp_getpacket
479: * Function:
480: * Wait for an incoming packet on the socket.
481: */
482: int
483: in_bootp_getpacket(so, pp, psize)
484: struct socket *so;
485: caddr_t pp;
486: int psize;
487: {
488: struct iovec aiov;
489: struct uio auio;
490: int rcvflg;
491:
492: aiov.iov_base = pp;
493: aiov.iov_len = psize;
494: auio.uio_iov = &aiov;
495: auio.uio_iovcnt = 1;
496: auio.uio_segflg = UIO_SYSSPACE;
497: auio.uio_offset = 0;
498: auio.uio_resid = psize;
499: auio.uio_rw = UIO_READ;
500: rcvflg = MSG_WAITALL;
501:
502: return (soreceive(so, 0, &auio, 0, 0, &rcvflg));
503: }
504:
505: #define INITIAL_DEADLINE 5
506: /*
507: * Routine: in_bootp_sendrequest
508: * Function:
509: * Do the actual work of sending a BOOTP request and getting the
510: * response.
511: */
512: int
513: in_bootp_sendrequest(
514: volatile struct ifnet *ifp,
515: struct socket *so,
516: struct bootp_packet *bp_s,
517: struct bootp *bp_r,
518: u_char my_enaddr[6],
519: struct vnode **console_vpp
520: ) {
521: struct mbuf *m;
522: register int error;
523: int xid;
524: struct timeval tv;
525: int timeo;
526: int timecount;
527: unsigned long totaltime;
528: unsigned long deadline;
529: struct socket *timeflag;
530: label_t jmpbuf;
531: struct sockaddr_in lsin;
532: struct nextvend *nv_s =
533: (struct nextvend *) &bp_s->bp_bootp.bp_vend;
534: struct nextvend *nv_r = (struct nextvend *)&bp_r->bp_vend;
535: boolean_t promisc_rcvd = FALSE;
536: boolean_t promisc_ignore;
537:
538: dprintf((" in_bootp_sendrequest() entered\n"));
539:
540: /* Create a transaction ID */
541: microtime(&tv);
542: xid = my_enaddr[5] ^ tv.tv_sec;
543: bp_s->bp_bootp.bp_xid = xid;
544:
545: /* Address to send to */
546: lsin.sin_family = AF_INET;
547: lsin.sin_port = htons(IPPORT_BOOTPS);
548: lsin.sin_addr.s_addr = INADDR_BROADCAST;
549:
550: /*
551: * timeout/retry policy:
552: * Before a server has responded we retransmit at a random time
553: * in a binary window which is doubled each transmission. This
554: * avoids flooding the net after, say, a power failure when all
555: * machines are trying to reboot simultaneously.
556: */
557: timeo = 1;
558: timecount = 0;
559: totaltime = 0;
560: deadline = INITIAL_DEADLINE;
561:
562: while (TRUE) {
563: if (timecount == 0) {
564: /* Put the outgoing packet in an mbuf */
565: m = in_bootp_bptombuf(bp_s);
566: dprintf((" in_bootp_sendrequest() if_output "));
567: if (error = (*ifp->if_output)(ifp, m,
568: (struct sockaddr *)&lsin, 0)) {
569: dprintf(("failed: %d\n", error));
570: goto errout;
571: }
572: dprintf(("ok\n"));
573: }
574:
575: /*
576: * Sleep for a second and then check for the abort
577: * character again.
578: */
579: timeflag = so;
580: timeout(in_bootp_timeout, &timeflag, hz);
581: keepwaiting:
582: dprintf((" in_bootp_sendrequest(): in_bootp_getpacket..."));
583: while (((error = in_bootp_getpacket(so, (caddr_t)bp_r, sizeof (*bp_r)))
584: == EWOULDBLOCK) && (timeflag == so)) {
585: /* dprintf(("waiting (spl = 0x%x)...", curspl())); */
586: sbwait(&so->so_rcv);
587: }
588: if (error && (error != EWOULDBLOCK)) {
589: dprintf(("failed: %d\n", error));
590: untimeout(in_bootp_timeout, &timeflag);
591: goto errout;
592: }
593: if (timeflag == NULL) {
594: dprintf((" in_bootp_sendrequest(): "
595: "in_bootp_getpacket...timed out\n"));
596: if ((deadline > INITIAL_DEADLINE) && (timecount & 1))
597: printf(".");
598: timecount++;
599: totaltime++;
600: if (timecount == timeo) {
601: if (timeo < 64) {
602: timeo <<= 1;
603: }
604: timecount = 0;
605: }
606: if (totaltime == deadline) {
607: register c = 0;
608:
609: if (error=in_bootp_openconsole(console_vpp)) {
610: goto errout;
611: }
612: printf("\nServer %snot responding.\n"
613: "Continue without network? (y/n) ",
614: (deadline == INITIAL_DEADLINE) ? "is " : "still ");
615: while (1) {
616: c = kmgetc_silent(0) & 0177;
617: if (c == 'y' || c == 'Y') {
618: printf("%c\n", c);
619: psignal(current_proc(), SIGINT);
620: error = EINTR;
621: in_bootp_closeconsole(*console_vpp);
622: goto errout;
623: }
624: else if (c == 'n' || c == 'N') {
625: break;
626: }
627: }
628: printf("%c\nWaiting for response.", c);
629: deadline += 30;
630: }
631:
632: continue;
633: }
634:
635: dprintf(("received packet!\n"));
636:
637: /* We have a packet. Check it out. */
638: if (bp_r->bp_xid != xid ||
639: bp_r->bp_op != BOOTREPLY ||
640: bcmp(bp_r->bp_chaddr, my_enaddr, 6) != 0) {
641: dprintf((" in_bootp_sendrequest() not for us\n"));
642: goto keepwaiting;
643: }
644:
645: /*
646: * It's for us. If it is not an authoritative answer,
647: * wait for a while (10 secs) to see if there is an
648: * authoritative server out there.
649: */
650: if (nv_s->nv_opcode == BPOP_OK && nv_r->nv_opcode != BPOP_OK) {
651: if (!promisc_rcvd) {
652: promisc_rcvd = TRUE;
653: promisc_ignore = TRUE;
654: timeout(in_bootp_promisctimeout,
655: &promisc_ignore, 10 * hz);
656: dprintf((" in_bootp_sendrequest() "
657: "ignoring 1st promisc response\n"));
658: goto keepwaiting;
659: }
660: if (promisc_ignore == TRUE) {
661: dprintf((" in_bootp_sendrequest() "
662: "ignoring promisc response\n"));
663: goto keepwaiting;
664: }
665: }
666:
667:
668: /* OK, it's for us */
669: dprintf((" in_bootp_sendrequest() it's for us!\n"));
670:
671: untimeout(in_bootp_timeout, &timeflag);
672:
673: if (alertShowing) {
674: printf("Network responded!\n");
675: }
676: error = 0;
677: goto errout;
678: }
679:
680: /* We aborted. Return appropriate error */
681: error = ETIMEDOUT;
682:
683: errout:
684: dprintf((" in_bootp_sendrequest() returning %d\n", error));
685:
686: untimeout(in_bootp_promisctimeout, &promisc_ignore);
687: return (error);
688: }
689:
690: /*
691: * Routine: in_bootp_openconsole
692: * Function:
693: * Pop up a console window so that we can do some user I/O to
694: * answer the server's questions.
695: */
696: int
697: in_bootp_openconsole(vpp)
698: struct vnode **vpp;
699: {
700: int ret = 0;
701: struct proc * procp = current_proc(); /* XXX */
702:
703: if (alertShowing == FALSE) {
704: ret = alert(60, 8, "Configuring Network", "%L", 0, 0, 0, 0, 0, 0, 0);
705: alertShowing = TRUE;
706: }
707: dprintf(("in_bootp_openconsole() returning: %d\n", ret));
708: return(ret);
709: }
710:
711: /*
712: * Routine: in_bootp_closeconsole
713: * Function:
714: * Restore and close and the console window.
715: */
716: void
717: in_bootp_closeconsole(vp)
718: struct vnode *vp;
719: {
720: if (alertShowing)
721: alert_done();
722: alertShowing = FALSE;
723: }
724:
725: /*
726: * Routine: in_bootp_processreply
727: * Function:
728: * The heart of "Sexy Net Init". This routine handles requests from
729: * the BOOTP server to interact with the user.
730: */
731: int
732: in_bootp_processreply(vp, bp_s, bp_r)
733: struct vnode *vp;
734: struct bootp_packet *bp_s;
735: struct bootp *bp_r;
736: {
737: struct nextvend *nv_s =
738: (struct nextvend *) &bp_s->bp_bootp.bp_vend;
739: struct nextvend *nv_r = (struct nextvend *)&bp_r->bp_vend;
740: int resid;
741: int error;
742: int flush = FREAD;
743: boolean_t noecho = FALSE;
744: char *cp;
745:
746: /* Truncate text if needed */
747: if (strlen(nv_r->nv_text) > NVMAXTEXT) {
748: nv_r->nv_null = '\0';
749: }
750:
751: /* Write out the server message */
752: printf("%s", nv_r->nv_text);
753:
754: if (error = kmioctl(0, TIOCFLUSH, &flush, 0)) {
755: goto errout;
756: }
757: switch (nv_r->nv_opcode) {
758: case BPOP_QUERY_NE:
759: noecho = TRUE;
760: /* Fall through */
761:
762: case BPOP_QUERY:
763: error = 0;
764: /* Read in the user response */
765: kmgets(nv_s->nv_text, nv_s->nv_text, noecho);
766:
767: /* If we are not echoing, move the cursor to the next line */
768: if (noecho) {
769: printf("\n");
770: }
771:
772: /* Get rid of the CR or LF if either exists. */
773: for (cp = (char *)nv_s->nv_text; *cp; cp++) {
774: if (*cp == '\n' || *cp == '\r') {
775: *cp = '\0';
776: break;
777: }
778: }
779:
780: /* Set the destination, opcode and xid */
781: bp_s->bp_ip.ip_dst = *(struct in_addr *)&bp_r->bp_siaddr;
782: nv_s->nv_opcode = nv_r->nv_opcode;
783: nv_s->nv_xid = nv_r->nv_xid;
784: break;
785:
786: case BPOP_ERROR:
787: /* Reset the destination, opcode and xid */
788: bp_s->bp_ip.ip_dst.s_addr = INADDR_BROADCAST;
789: nv_s->nv_opcode = BPOP_OK;
790: nv_s->nv_xid = 0;
791: break;
792: }
793: errout:
794: return (error);
795: }
796:
797: /*
798: * Routine: in_bootp_setaddress
799: * Function:
800: * Set the address of the interface. Leave the new address in ifr
801: * to be returned to the user.
802: */
803: int
804: in_bootp_setaddress(ifp, ifr, so, addr)
805: register volatile struct ifnet *ifp;
806: register struct ifreq *ifr;
807: struct socket *so;
808: struct in_addr *addr;
809: {
810: struct sockaddr_in *sin;
811: int error;
812: struct proc * procp = current_proc(); /* XXX */
813:
814: dprintf((" in_bootp_setaddress() entered\n"));
815:
816: ifr->ifr_flags = ifp->if_flags & ~(IFF_UP);
817: if (error = ifioctl(so, SIOCSIFFLAGS, (caddr_t) ifr, procp)) {
818: dprintf((" in_bootp_setaddress() SIOCSIFFLAGS failed: %d\n",
819: error));
820: return (error);
821: }
822:
823: /* Clear the netmask first */
824: sin = (struct sockaddr_in *)&(ifr->ifr_addr);
825: bzero((caddr_t)sin, sizeof(struct sockaddr_in));
826: sin->sin_len = sizeof(*sin);
827: sin->sin_family = AF_INET;
828: if (error = ifioctl(so, SIOCSIFNETMASK, (caddr_t)ifr, procp)) {
829: dprintf((" in_bootp_setaddress() SIOCSIFNETMASK failed: %d\n",
830: error));
831: return (error);
832: }
833:
834: /* Now set the new address */
835: sin->sin_addr.s_addr = addr->s_addr;
836: if (error = ifioctl(so, SIOCSIFADDR, (caddr_t)ifr, procp)) {
837: dprintf((" in_bootp_setaddress() SIOCSIFADDR failed: %d\n",
838: error));
839: return (error);
840: }
841:
842: /* Flag that we have autoconfigured */
843: ifp->if_eflags |= IFEF_AUTOCONF_DONE;
844:
845: dprintf((" in_bootp_setaddress() exiting\n"));
846:
847: return (0);
848: }
849:
850: /*
851: * Routine: in_bootp_makeifreq
852: * Function:
853: * Make a valid ifreq struct from interface pointer and an address
854: */
855: struct ifreq
856: in_bootp_makeifreq(
857: volatile struct ifnet *ifp,
858: struct sockaddr_in *sin
859: )
860: {
861: struct ifreq ifr;
862: char *p;
863:
864: strcpy(ifr.ifr_name, ifp->if_name);
865: for (p = ifr.ifr_name; *p; p++) {
866: }
867: *p++ = ifp->if_unit + '0';
868: *p = 0;
869: bcopy(sin, &ifr.ifr_addr, sizeof(*sin));
870: return (ifr);
871: }
872:
873: /*
874: * Routine: kmgets (mostly stolen from swapgeneric.{c,m}
875: * Function:
876: * Allows printing echoed or non-echoed text.
877: */
878: void
879: kmgets(cp, lp, silent)
880: char *cp, *lp;
881: boolean_t silent;
882: {
883: register c = 0;
884:
885: for (;;) {
886: if (silent) {
887: c = kmgetc_silent(0) & 0177;
888: } else {
889: c = kmgetc(0) & 0177;
890: }
891: switch (c) {
892: case '\n':
893: case '\r':
894: *lp++ = '\0';
895: return;
896: case '\177':
897: if (lp == cp) {
898: cnputc('\b');
899: continue;
900: }
901: cnputc('\b');
902: cnputc('\b');
903: /* fall into ... */
904: case '\b':
905: if (lp == cp) {
906: cnputc('\b');
907: continue;
908: }
909: cnputc(' ');
910: cnputc('\b');
911: lp--;
912: continue;
913: case '@':
914: case 'u'&037:
915: lp = cp;
916: cnputc('\n');
917: continue;
918: default:
919: *lp++ = c;
920: }
921: }
922: }
923:
924: #endif
925: #endif NEXT
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.