[apple/xnu.git] / bsd / netinet / in_bootp.c

/*
 * Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
 *
 * @APPLE_LICENSE_HEADER_START@
 * 
 * Copyright (c) 1999-2003 Apple Computer, Inc.  All Rights Reserved.
 * 
 * This file contains Original Code and/or Modifications of Original Code
 * as defined in and that are subject to the Apple Public Source License
 * Version 2.0 (the 'License'). You may not use this file except in
 * compliance with the License. Please obtain a copy of the License at
 * http://www.opensource.apple.com/apsl/ and read it before using this
 * file.
 * 
 * The Original Code and all software distributed under the License are
 * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
 * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
 * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
 * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
 * Please see the License for the specific language governing rights and
 * limitations under the License.
 * 
 * @APPLE_LICENSE_HEADER_END@
 */
/*
 *  Copyright (c) 1988-1999 Apple Computer, Inc. All Rights Reserved 
 */

/*
 * bootp.c
 * - be a BOOTP client over a particular interface to retrieve
 *   the IP address, netmask, and router
 */

/* 
 * Modification History
 *
 * February 19, 1999	Dieter Siegmund	(dieter@apple.com)
 * - completely rewritten
 */

#include <sys/param.h>
#include <sys/types.h>
#include <mach/boolean.h>
#include <sys/kernel.h>
#include <sys/errno.h>
#include <sys/file.h>
#include <sys/uio.h>
#include <sys/ioctl.h>
#include <sys/time.h>
#include <sys/mbuf.h>
#include <sys/vnode.h>
#include <sys/socket.h>
#include <sys/socketvar.h>
#include <net/if.h>
#include <net/if_dl.h>
#include <net/if_types.h>
#include <net/route.h>
#include <netinet/in.h>
#include <netinet/in_systm.h>
#include <netinet/if_ether.h>
#include <netinet/ip.h>
#include <netinet/ip_var.h>
#include <netinet/udp.h>
#include <netinet/udp_var.h>
#include <netinet/ip_icmp.h>
#include <netinet/bootp.h>
#include <sys/systm.h>
#include <sys/malloc.h>
#include <netinet/dhcp_options.h>

#ifdef	BOOTP_DEBUG
#define	dprintf(x) printf x;
#else	BOOTP_DEBUG
#define	dprintf(x)
#endif	BOOTP_DEBUG

/* ip address formatting macros */
#define IP_FORMAT	"%d.%d.%d.%d"
#define IP_CH(ip)	((u_char *)ip)
#define IP_LIST(ip)	IP_CH(ip)[0],IP_CH(ip)[1],IP_CH(ip)[2],IP_CH(ip)[3]

static __inline__ struct sockaddr_in
blank_sin()
{
    struct sockaddr_in	blank = { sizeof(struct sockaddr_in), AF_INET };
    return (blank);
}

static __inline__ void
print_reply(struct bootp *bp, int bp_len)
{
	int i, j, len;

	printf("bp_op = ");
	if (bp->bp_op == BOOTREQUEST) printf("BOOTREQUEST\n");
	else if (bp->bp_op == BOOTREPLY) printf("BOOTREPLY\n");
	else
	{
		i = bp->bp_op;
		printf("%d\n", i);
	}

	i = bp->bp_htype;
	printf("bp_htype = %d\n", i);

	len = bp->bp_hlen;
	printf("bp_hlen = %d\n", len);

	i = bp->bp_hops;
	printf("bp_hops = %d\n", i);

	printf("bp_xid = %lu\n", bp->bp_xid);

	printf("bp_secs = %u\n", bp->bp_secs);

	printf("bp_ciaddr = " IP_FORMAT "\n", IP_LIST(&bp->bp_ciaddr));
	printf("bp_yiaddr = " IP_FORMAT "\n", IP_LIST(&bp->bp_yiaddr));
	printf("bp_siaddr = " IP_FORMAT "\n", IP_LIST(&bp->bp_siaddr));
	printf("bp_giaddr = " IP_FORMAT "\n", IP_LIST(&bp->bp_giaddr));

	printf("bp_chaddr = ");
	for (j = 0; j < len; j++)
	{
		i = bp->bp_chaddr[j];
		printf("%0x", i);
		if (j < (len - 1)) printf(":");
	}
	printf("\n");

	printf("bp_sname = %s\n", bp->bp_sname);
	printf("bp_file = %s\n", bp->bp_file);
}

static __inline__ void
print_reply_short(struct bootp *bp, int bp_len)
{
	printf("bp_yiaddr = " IP_FORMAT "\n", IP_LIST(&bp->bp_yiaddr));
	printf("bp_sname = %s\n", bp->bp_sname);
}


static __inline__ long
random_range(long bottom, long top)
{
    long number = top - bottom + 1;
    long range_size = LONG_MAX / number;
    return (((long)random()) / range_size + bottom);
}

/*
 * Function: make_bootp_request
 * Purpose:
 *   Create a "blank" bootp packet.
 */
static void
make_bootp_request(struct bootp_packet * pkt, 
		   u_char * hwaddr, u_char hwtype, u_char hwlen)
{
    char		rfc_magic[4] = RFC_OPTIONS_MAGIC;

    bzero(pkt, sizeof (*pkt));
    pkt->bp_ip.ip_v = IPVERSION;
    pkt->bp_ip.ip_hl = sizeof (struct ip) >> 2;
#ifdef RANDOM_IP_ID
    pkt->bp_ip.ip_id = ip_randomid();
#else
    pkt->bp_ip.ip_id = htons(ip_id++);
#endif
    pkt->bp_ip.ip_ttl = MAXTTL;
    pkt->bp_ip.ip_p = IPPROTO_UDP;
    pkt->bp_ip.ip_src.s_addr = 0;
    pkt->bp_ip.ip_dst.s_addr = htonl(INADDR_BROADCAST);
    pkt->bp_udp.uh_sport = htons(IPPORT_BOOTPC);
    pkt->bp_udp.uh_dport = htons(IPPORT_BOOTPS);
    pkt->bp_udp.uh_sum = 0;
    pkt->bp_bootp.bp_op = BOOTREQUEST;
    pkt->bp_bootp.bp_htype = hwtype;
    pkt->bp_bootp.bp_hlen = hwlen;
    pkt->bp_bootp.bp_ciaddr.s_addr = 0;
    bcopy(hwaddr, pkt->bp_bootp.bp_chaddr, hwlen);
    bcopy(rfc_magic, pkt->bp_bootp.bp_vend, sizeof(rfc_magic));
    pkt->bp_bootp.bp_vend[4] = dhcptag_end_e;
    pkt->bp_udp.uh_ulen = htons(sizeof(pkt->bp_udp) + sizeof(pkt->bp_bootp));
    pkt->bp_ip.ip_len = htons(sizeof(struct ip) + ntohs(pkt->bp_udp.uh_ulen));
    pkt->bp_ip.ip_sum = 0;
    return;
}

/*
 * Function: ip_pkt_to_mbuf
 * Purpose:
 *   Put the given IP packet into an mbuf, calculate the
 *   IP checksum.
 */
struct mbuf *
ip_pkt_to_mbuf(caddr_t pkt, int pktsize)
{
    struct ip *		ip;
    struct mbuf	*	m;
    
    m = (struct mbuf *)m_devget(pkt, pktsize, 0, 0, 0);
    if (m == 0) {
	printf("bootp: ip_pkt_to_mbuf: m_devget failed\n");
	return 0;
    }
    m->m_flags |= M_BCAST;
    /* Compute the checksum */
    ip = mtod(m, struct ip *);
    ip->ip_sum = 0;
    ip->ip_sum = in_cksum(m, sizeof (struct ip));
    return (m);
}

static __inline__ u_char *
link_address(struct sockaddr_dl * dl_p)
{
    return (dl_p->sdl_data + dl_p->sdl_nlen);
}

static __inline__ void
link_print(struct sockaddr_dl * dl_p)
{
    int i;

#if 0
    printf("len %d index %d family %d type 0x%x nlen %d alen %d"
	   " slen %d addr ", dl_p->sdl_len, 
	   dl_p->sdl_index,  dl_p->sdl_family, dl_p->sdl_type,
	   dl_p->sdl_nlen, dl_p->sdl_alen, dl_p->sdl_slen);
#endif 0
    for (i = 0; i < dl_p->sdl_alen; i++) 
	printf("%s%x", i ? ":" : "", 
	       (link_address(dl_p))[i]);
    printf("\n");
    return;
}

static struct sockaddr_dl *
link_from_ifnet(struct ifnet * ifp)
{
    struct ifaddr * addr;

/*    for (addr = ifp->if_addrlist; addr; addr = addr->ifa_next) */

    TAILQ_FOREACH(addr, &ifp->if_addrhead, ifa_link) {
	if (addr->ifa_addr->sa_family == AF_LINK) {
	    struct sockaddr_dl * dl_p = (struct sockaddr_dl *)(addr->ifa_addr);
	    
	    return (dl_p);
	}
    }
    return (NULL);
}

/*
 * Function: send_bootp_request
 * Purpose:
 *     Send the request by calling the interface's output routine
 *     bypassing routing code.
 */
static int
send_bootp_request(struct ifnet * ifp, struct socket * so,
		   struct bootp_packet * pkt)
{
    struct mbuf	*	m;
    struct sockaddr_in	sin;
    
    /* Address to send to */
    sin = blank_sin();
    sin.sin_port = htons(IPPORT_BOOTPS);
    sin.sin_addr.s_addr = INADDR_BROADCAST;
    
    m = ip_pkt_to_mbuf((caddr_t)pkt, sizeof(*pkt));
    return (dlil_output(ifp->if_data.default_proto, m, 0, (struct sockaddr *)&sin, 0));
}

/*
 * Function: receive_packet
 * Purpose:
 *   Return a received packet or an error if none available.
 */
int
receive_packet(struct socket * so, caddr_t pp, int psize, int * actual_size)
{
    struct iovec	aiov;
    struct uio		auio;
    int			rcvflg;
    int			error;

    aiov.iov_base = pp;
    aiov.iov_len = psize;
    auio.uio_iov = &aiov;
    auio.uio_iovcnt = 1;
    auio.uio_segflg = UIO_SYSSPACE;
    auio.uio_offset = 0;
    auio.uio_resid = psize;
    auio.uio_rw = UIO_READ;
    rcvflg = MSG_WAITALL;
    
    error = soreceive(so, (struct sockaddr **) 0, &auio, 0, 0, &rcvflg);
    *actual_size = psize - auio.uio_resid;
    return (error);
}

/*
 * Function: bootp_timeout
 * Purpose:
 *   Wakeup the process waiting for something on a socket.
 */
static void
bootp_timeout(void * arg)
{
    struct socket * * socketflag = (struct socket * *)arg;
    struct socket * so = *socketflag;
    boolean_t 	funnel_state;
    
    dprintf(("bootp: timeout\n"));

    funnel_state = thread_funnel_set(network_flock,TRUE);
    *socketflag = NULL;
    sowakeup(so, &so->so_rcv);
    (void) thread_funnel_set(network_flock, FALSE);
    return;
}

/*
 * Function: rate_packet
 * Purpose:
 *   Return an integer point rating value for the given bootp packet.
 *   If yiaddr non-zero, the packet gets a rating of 1.
 *   Another point is given if the packet contains the subnet mask,
 *   and another if the router is present.
 */
#define GOOD_RATING	3
static __inline__ int 
rate_packet(struct bootp * pkt, int pkt_size, dhcpol_t * options_p)
{
    int		len;
    int 	rating = 1;

    if (dhcpol_find(options_p, dhcptag_subnet_mask_e, &len, NULL) != NULL) {
	rating++;
    }
    if (dhcpol_find(options_p, dhcptag_router_e, &len, NULL) != NULL) {
	rating++;
    }
    return (rating);
}

#define INITIAL_WAIT_SECS		4
#define MAX_WAIT_SECS			64
#define GATHER_TIME_SECS		2
#define RAND_TICKS			(hz)	/* one second */

/*
 * Function: bootp_loop
 * Purpose:
 *   Do the actual BOOTP protocol.
 *   The algorithm sends out a packet, waits for a response.
 *   We try max_try times, waiting in an exponentially increasing
 *   amount of time.  Once we receive a good response, we start
 *   a new time period called the "gather time", during which we
 *   either find the perfect packet (one that has ip, mask and router)
 *   or we continue to gather responses.  At the end of the gather period,
 *   we use the best response gathered.
 */
static int
bootp_loop(struct socket * so, struct ifnet * ifp, int max_try,
	   struct in_addr * iaddr_p, struct in_addr * netmask_p,
	   struct in_addr * router_p)
{
    struct timeval		current_time;
    struct sockaddr_dl *	dl_p;
    int				error = 0;
    char *			hwaddr;
    int				hwlen;
    char			hwtype = 0;
    struct bootp_packet * 	request = NULL;
    struct bootp *		reply = NULL;
    int				reply_size = DHCP_PACKET_MIN;
    struct timeval		start_time;
    u_long			xid;
    int				retry;
    struct socket *		timeflag;
    int				wait_ticks = INITIAL_WAIT_SECS * hz;

    /* get the hardware address from the interface */
    dl_p = link_from_ifnet(ifp);
    if (dl_p == NULL) {
	printf("bootp: can't get link address\n");
	return (ENXIO);
    }

    printf("bootp: h/w addr ");
    link_print(dl_p);

    hwaddr = link_address(dl_p);
    hwlen = dl_p->sdl_alen;
    switch (dl_p->sdl_type) {
        case IFT_ETHER:
	    hwtype = ARPHRD_ETHER;
	    break;
        default:
	    printf("bootp: hardware type %d not supported\n",
		   dl_p->sdl_type);
	    panic("bootp: hardware type not supported");
	    break;
    }

    /* set transaction id and remember the start time */
    microtime(&start_time);
    current_time = start_time;
    xid = random();
    
    /* make a request/reply packet */
    request = (struct bootp_packet *)kalloc(sizeof(*request));
    make_bootp_request(request, hwaddr, hwtype, hwlen);
    reply = (struct bootp *)kalloc(reply_size);
    iaddr_p->s_addr = 0;
    printf("bootp: sending request");
    for (retry = 0; retry < max_try; retry++) {
	int	 	gather_count = 0;
	int		last_rating = 0;

	/* Send the request */
	printf(".");
	request->bp_bootp.bp_secs = htons((u_short)(current_time.tv_sec 
						    - start_time.tv_sec));
	request->bp_bootp.bp_xid = htonl(xid);
	error = send_bootp_request(ifp, so, request);
	if (error)
	    goto cleanup;

	timeflag = so;
	wait_ticks += random_range(-RAND_TICKS, RAND_TICKS);
	dprintf(("bootp: waiting %d ticks\n", wait_ticks));
	timeout((timeout_fcn_t)bootp_timeout, &timeflag, wait_ticks);

	while (TRUE) {
	    int 	n = 0;

	    error = receive_packet(so, (caddr_t)reply, reply_size, &n);
	    if (error == 0) {
		dprintf(("\nbootp: received packet\n"));
		if (ntohl(reply->bp_xid) == xid
		    && reply->bp_yiaddr.s_addr
		    && bcmp(reply->bp_chaddr, hwaddr, hwlen) == 0) {
		    int 		rating;
		    dhcpol_t		options;

#ifdef	BOOTP_DEBUG
		    print_reply_short(reply, n);
#endif BOOTP_DEBUG
		    (void)dhcpol_parse_packet(&options, (struct dhcp *)reply, 
					      n, NULL);
		    rating = rate_packet(reply, n, &options);
		    if (rating > last_rating) {
			struct in_addr * 	ip;
			int			len;

			*iaddr_p = reply->bp_yiaddr;
			ip = (struct in_addr *)
			    dhcpol_find(&options, 
					dhcptag_subnet_mask_e, &len, NULL);
			if (ip) {
			    *netmask_p = *ip;
			}
			ip = (struct in_addr *)
			    dhcpol_find(&options, dhcptag_router_e, &len, NULL);
			if (ip) {
			    *router_p = *ip;
			}
			printf("%sbootp: got "
			       "response from %s (" IP_FORMAT ")\n",
			       last_rating == 0 ? "\n" : "",
			       reply->bp_sname, 
			       IP_LIST(&reply->bp_siaddr));
		    }
		    dhcpol_free(&options);
		    if (rating >= GOOD_RATING) {
			untimeout((timeout_fcn_t)bootp_timeout, &timeflag);
			goto done;
		    }
		    if (gather_count == 0) {
			untimeout((timeout_fcn_t)bootp_timeout, &timeflag);
			timeflag = so;
			timeout((timeout_fcn_t)bootp_timeout, &timeflag, 
				hz * GATHER_TIME_SECS);
		    }
		    gather_count++;
		}
		else {
		    dprintf(("bootp: packet ignored\n"));
		}
	    }
	    else if ((error != EWOULDBLOCK)) {
		break;
	    }
	    else if (timeflag == NULL) { /* timed out */
		if (gather_count) {
		    dprintf(("bootp: gathering time has expired"));
		    goto done; /* we have a packet */
		}
		break; /* retry */
	    }
	    else
		sbwait(&so->so_rcv);
	}
	if (error && (error != EWOULDBLOCK)) {
	    dprintf(("bootp: failed to receive packets: %d\n", error));
	    untimeout((timeout_fcn_t)bootp_timeout, &timeflag);
	    goto cleanup;
	}
	wait_ticks *= 2;
	if (wait_ticks > (MAX_WAIT_SECS * hz))
	    wait_ticks = MAX_WAIT_SECS * hz;
	xid++;
	microtime(&current_time);
    }
    error = ETIMEDOUT;
    goto cleanup;

 done:
    error = 0;

 cleanup:
    if (request)
	kfree((caddr_t)request, sizeof (*request));
    if (reply)
	kfree((caddr_t)reply, reply_size);
    return (error);
}

/*
 * Routine: bootp
 * Function:
 *	Use the BOOTP protocol to resolve what our IP address should be
 *	on a particular interface.
 */
int bootp(struct ifnet * ifp, struct in_addr * iaddr_p, int max_try,
	  struct in_addr * netmask_p, struct in_addr * router_p,
	  struct proc * procp)
{
    boolean_t			addr_set = FALSE;
    struct ifreq 		ifr;
    int				error;
    struct socket *		so = NULL;

    /* get a socket */
    error = socreate(AF_INET, &so, SOCK_DGRAM, 0);
    if (error) {
	dprintf(("bootp: socreate failed %d\n", error));
	return (error);
    }

    /* assign the all-zeroes address */
    bzero(&ifr, sizeof(ifr));
    sprintf(ifr.ifr_name, "%s%d", ifp->if_name, ifp->if_unit);
    *((struct sockaddr_in *)&ifr.ifr_addr) = blank_sin();
    error = ifioctl(so, SIOCSIFADDR, (caddr_t)&ifr, procp);
    if (error) {
	dprintf(("bootp: SIOCSIFADDR all-zeroes IP failed: %d\n",
		 error));
	goto cleanup;
    }
    dprintf(("bootp: all-zeroes IP address assigned\n"));
    addr_set = TRUE;
    
    { /* bind the socket */
	struct sockaddr_in * sin;

	sin = _MALLOC(sizeof(struct sockaddr_in), M_IFADDR, M_WAIT);
	if (sin == NULL) {
	  	error = ENOMEM;
		goto cleanup;
	}
	sin->sin_len = sizeof(struct sockaddr_in);
	sin->sin_family = AF_INET;
	sin->sin_port = htons(IPPORT_BOOTPC);
	sin->sin_addr.s_addr = INADDR_ANY;
	error = sobind(so, (struct sockaddr *) sin);

	FREE(sin, M_IFADDR);
	if (error) {
	    dprintf(("bootp: sobind failed, %d\n", error));
	    goto cleanup;
	}
	so->so_state |= SS_NBIO;
    }
    /* do the protocol */
    error = bootp_loop(so, ifp, max_try, iaddr_p, netmask_p, router_p);
    
 cleanup:
    if (so) {
	if (addr_set) {
	    (void) ifioctl(so, SIOCDIFADDR, (caddr_t) &ifr, procp);
	}
	soclose(so);
    }
    return (error);
}
Commit	Line	Data
1c79356b A	1	/*
	2	* Copyright (c) 2000 Apple Computer, Inc. All rights reserved.
	3	*
	4	* @APPLE_LICENSE_HEADER_START@
	5	*
d7e50217	6	* Copyright (c) 1999-2003 Apple Computer, Inc. All Rights Reserved.
1c79356b	7	*
d7e50217 A	8	* This file contains Original Code and/or Modifications of Original Code
	9	* as defined in and that are subject to the Apple Public Source License
	10	* Version 2.0 (the 'License'). You may not use this file except in
	11	* compliance with the License. Please obtain a copy of the License at
	12	* http://www.opensource.apple.com/apsl/ and read it before using this
	13	* file.
	14	*
	15	* The Original Code and all software distributed under the License are
	16	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
1c79356b A	17	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
1c79356b A	18	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
d7e50217 A	19	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	20	* Please see the License for the specific language governing rights and
	21	* limitations under the License.
1c79356b A	22	*
	23	* @APPLE_LICENSE_HEADER_END@
	24	*/
	25	/*
	26	* Copyright (c) 1988-1999 Apple Computer, Inc. All Rights Reserved
	27	*/
	28
	29	/*
	30	* bootp.c
	31	* - be a BOOTP client over a particular interface to retrieve
	32	* the IP address, netmask, and router
	33	*/
	34
	35	/*
	36	* Modification History
	37	*
	38	* February 19, 1999 Dieter Siegmund (dieter@apple.com)
	39	* - completely rewritten
	40	*/
	41
	42	#include <sys/param.h>
	43	#include <sys/types.h>
	44	#include <mach/boolean.h>
	45	#include <sys/kernel.h>
	46	#include <sys/errno.h>
	47	#include <sys/file.h>
	48	#include <sys/uio.h>
	49	#include <sys/ioctl.h>
	50	#include <sys/time.h>
	51	#include <sys/mbuf.h>
	52	#include <sys/vnode.h>
	53	#include <sys/socket.h>
	54	#include <sys/socketvar.h>
	55	#include <net/if.h>
	56	#include <net/if_dl.h>
	57	#include <net/if_types.h>
	58	#include <net/route.h>
	59	#include <netinet/in.h>
	60	#include <netinet/in_systm.h>
	61	#include <netinet/if_ether.h>
	62	#include <netinet/ip.h>
	63	#include <netinet/ip_var.h>
	64	#include <netinet/udp.h>
	65	#include <netinet/udp_var.h>
	66	#include <netinet/ip_icmp.h>
	67	#include <netinet/bootp.h>
	68	#include <sys/systm.h>
	69	#include <sys/malloc.h>
9bccf70c	70	#include <netinet/dhcp_options.h>
1c79356b A	71
	72	#ifdef BOOTP_DEBUG
	73	#define dprintf(x) printf x;
	74	#else BOOTP_DEBUG
	75	#define dprintf(x)
	76	#endif BOOTP_DEBUG
	77
	78	/* ip address formatting macros */
	79	#define IP_FORMAT "%d.%d.%d.%d"
	80	#define IP_CH(ip) ((u_char *)ip)
	81	#define IP_LIST(ip) IP_CH(ip)[0],IP_CH(ip)[1],IP_CH(ip)[2],IP_CH(ip)[3]
	82
9bccf70c A	83	static __inline__ struct sockaddr_in
	84	blank_sin()
	85	{
	86	struct sockaddr_in blank = { sizeof(struct sockaddr_in), AF_INET };
	87	return (blank);
	88	}
1c79356b A	89
	90	static __inline__ void
	91	print_reply(struct bootp *bp, int bp_len)
	92	{
	93	int i, j, len;
	94
	95	printf("bp_op = ");
	96	if (bp->bp_op == BOOTREQUEST) printf("BOOTREQUEST\n");
	97	else if (bp->bp_op == BOOTREPLY) printf("BOOTREPLY\n");
	98	else
	99	{
	100	i = bp->bp_op;
	101	printf("%d\n", i);
	102	}
	103
	104	i = bp->bp_htype;
	105	printf("bp_htype = %d\n", i);
	106
	107	len = bp->bp_hlen;
	108	printf("bp_hlen = %d\n", len);
	109
	110	i = bp->bp_hops;
	111	printf("bp_hops = %d\n", i);
	112
	113	printf("bp_xid = %lu\n", bp->bp_xid);
	114
	115	printf("bp_secs = %u\n", bp->bp_secs);
	116
	117	printf("bp_ciaddr = " IP_FORMAT "\n", IP_LIST(&bp->bp_ciaddr));
	118	printf("bp_yiaddr = " IP_FORMAT "\n", IP_LIST(&bp->bp_yiaddr));
	119	printf("bp_siaddr = " IP_FORMAT "\n", IP_LIST(&bp->bp_siaddr));
	120	printf("bp_giaddr = " IP_FORMAT "\n", IP_LIST(&bp->bp_giaddr));
	121
	122	printf("bp_chaddr = ");
	123	for (j = 0; j < len; j++)
	124	{
	125	i = bp->bp_chaddr[j];
	126	printf("%0x", i);
	127	if (j < (len - 1)) printf(":");
	128	}
	129	printf("\n");
	130
	131	printf("bp_sname = %s\n", bp->bp_sname);
	132	printf("bp_file = %s\n", bp->bp_file);
	133	}
	134
	135	static __inline__ void
	136	print_reply_short(struct bootp *bp, int bp_len)
	137	{
	138	printf("bp_yiaddr = " IP_FORMAT "\n", IP_LIST(&bp->bp_yiaddr));
	139	printf("bp_sname = %s\n", bp->bp_sname);
	140	}
	141
	142
	143	static __inline__ long
	144	random_range(long bottom, long top)
	145	{
	146	long number = top - bottom + 1;
	147	long range_size = LONG_MAX / number;
	148	return (((long)random()) / range_size + bottom);
	149	}
	150
	151	/*
	152	* Function: make_bootp_request
153	* Purpose:
154	* Create a "blank" bootp packet.
155	*/
156	static void
157	make_bootp_request(struct bootp_packet * pkt,
158	u_char * hwaddr, u_char hwtype, u_char hwlen)
159	{
9bccf70c A	160	char rfc_magic[4] = RFC_OPTIONS_MAGIC;
9bccf70c A	161
1c79356b A	162	bzero(pkt, sizeof (*pkt));
	163	pkt->bp_ip.ip_v = IPVERSION;
	164	pkt->bp_ip.ip_hl = sizeof (struct ip) >> 2;
9bccf70c A	165	#ifdef RANDOM_IP_ID
	166	pkt->bp_ip.ip_id = ip_randomid();
	167	#else
1c79356b	168	pkt->bp_ip.ip_id = htons(ip_id++);
9bccf70c	169	#endif
1c79356b A	170	pkt->bp_ip.ip_ttl = MAXTTL;
	171	pkt->bp_ip.ip_p = IPPROTO_UDP;
	172	pkt->bp_ip.ip_src.s_addr = 0;
	173	pkt->bp_ip.ip_dst.s_addr = htonl(INADDR_BROADCAST);
	174	pkt->bp_udp.uh_sport = htons(IPPORT_BOOTPC);
	175	pkt->bp_udp.uh_dport = htons(IPPORT_BOOTPS);
	176	pkt->bp_udp.uh_sum = 0;
	177	pkt->bp_bootp.bp_op = BOOTREQUEST;
	178	pkt->bp_bootp.bp_htype = hwtype;
	179	pkt->bp_bootp.bp_hlen = hwlen;
	180	pkt->bp_bootp.bp_ciaddr.s_addr = 0;
	181	bcopy(hwaddr, pkt->bp_bootp.bp_chaddr, hwlen);
	182	bcopy(rfc_magic, pkt->bp_bootp.bp_vend, sizeof(rfc_magic));
9bccf70c	183	pkt->bp_bootp.bp_vend[4] = dhcptag_end_e;
1c79356b A	184	pkt->bp_udp.uh_ulen = htons(sizeof(pkt->bp_udp) + sizeof(pkt->bp_bootp));
	185	pkt->bp_ip.ip_len = htons(sizeof(struct ip) + ntohs(pkt->bp_udp.uh_ulen));
	186	pkt->bp_ip.ip_sum = 0;
	187	return;
	188	}
	189
	190	/*
	191	* Function: ip_pkt_to_mbuf
	192	* Purpose:
	193	* Put the given IP packet into an mbuf, calculate the
	194	* IP checksum.
	195	*/
	196	struct mbuf *
	197	ip_pkt_to_mbuf(caddr_t pkt, int pktsize)
	198	{
	199	struct ip * ip;
	200	struct mbuf * m;
	201
	202	m = (struct mbuf *)m_devget(pkt, pktsize, 0, 0, 0);
	203	if (m == 0) {
	204	printf("bootp: ip_pkt_to_mbuf: m_devget failed\n");
	205	return 0;
	206	}
	207	m->m_flags \|= M_BCAST;
	208	/* Compute the checksum */
	209	ip = mtod(m, struct ip *);
	210	ip->ip_sum = 0;
	211	ip->ip_sum = in_cksum(m, sizeof (struct ip));
	212	return (m);
	213	}
	214
	215	static __inline__ u_char *
	216	link_address(struct sockaddr_dl * dl_p)
	217	{
	218	return (dl_p->sdl_data + dl_p->sdl_nlen);
	219	}
	220
	221	static __inline__ void
	222	link_print(struct sockaddr_dl * dl_p)
	223	{
	224	int i;
	225
	226	#if 0
	227	printf("len %d index %d family %d type 0x%x nlen %d alen %d"
	228	" slen %d addr ", dl_p->sdl_len,
	229	dl_p->sdl_index, dl_p->sdl_family, dl_p->sdl_type,
	230	dl_p->sdl_nlen, dl_p->sdl_alen, dl_p->sdl_slen);
	231	#endif 0
	232	for (i = 0; i < dl_p->sdl_alen; i++)
	233	printf("%s%x", i ? ":" : "",
	234	(link_address(dl_p))[i]);
	235	printf("\n");
	236	return;
	237	}
	238
	239	static struct sockaddr_dl *
	240	link_from_ifnet(struct ifnet * ifp)
	241	{
	242	struct ifaddr * addr;
	243
	244	/* for (addr = ifp->if_addrlist; addr; addr = addr->ifa_next) */
	245
	246	TAILQ_FOREACH(addr, &ifp->if_addrhead, ifa_link) {
	247	if (addr->ifa_addr->sa_family == AF_LINK) {
248	struct sockaddr_dl * dl_p = (struct sockaddr_dl *)(addr->ifa_addr);
249
250	return (dl_p);
251	}
252	}
253	return (NULL);
254	}
255
256	/*
257	* Function: send_bootp_request
258	* Purpose:
259	* Send the request by calling the interface's output routine
260	* bypassing routing code.
261	*/
262	static int
263	send_bootp_request(struct ifnet * ifp, struct socket * so,
264	struct bootp_packet * pkt)
265	{
266	struct mbuf * m;
267	struct sockaddr_in sin;
268
269	/* Address to send to */
9bccf70c	270	sin = blank_sin();
1c79356b A	271	sin.sin_port = htons(IPPORT_BOOTPS);
	272	sin.sin_addr.s_addr = INADDR_BROADCAST;
	273
	274	m = ip_pkt_to_mbuf((caddr_t)pkt, sizeof(*pkt));
9bccf70c	275	return (dlil_output(ifp->if_data.default_proto, m, 0, (struct sockaddr *)&sin, 0));
1c79356b A	276	}
	277
	278	/*
	279	* Function: receive_packet
	280	* Purpose:
	281	* Return a received packet or an error if none available.
	282	*/
	283	int
9bccf70c	284	receive_packet(struct socket * so, caddr_t pp, int psize, int * actual_size)
1c79356b A	285	{
	286	struct iovec aiov;
	287	struct uio auio;
	288	int rcvflg;
	289	int error;
	290
	291	aiov.iov_base = pp;
	292	aiov.iov_len = psize;
	293	auio.uio_iov = &aiov;
	294	auio.uio_iovcnt = 1;
	295	auio.uio_segflg = UIO_SYSSPACE;
	296	auio.uio_offset = 0;
	297	auio.uio_resid = psize;
	298	auio.uio_rw = UIO_READ;
	299	rcvflg = MSG_WAITALL;
	300
	301	error = soreceive(so, (struct sockaddr **) 0, &auio, 0, 0, &rcvflg);
9bccf70c	302	*actual_size = psize - auio.uio_resid;
1c79356b A	303	return (error);
	304	}
	305
	306	/*
	307	* Function: bootp_timeout
	308	* Purpose:
	309	* Wakeup the process waiting for something on a socket.
	310	*/
	311	static void
9bccf70c	312	bootp_timeout(void * arg)
1c79356b	313	{
9bccf70c	314	struct socket * * socketflag = (struct socket * *)arg;
1c79356b A	315	struct socket * so = *socketflag;
	316	boolean_t funnel_state;
	317
	318	dprintf(("bootp: timeout\n"));
	319
	320	funnel_state = thread_funnel_set(network_flock,TRUE);
	321	*socketflag = NULL;
	322	sowakeup(so, &so->so_rcv);
	323	(void) thread_funnel_set(network_flock, FALSE);
	324	return;
	325	}
	326
1c79356b A	327	/*
	328	* Function: rate_packet
	329	* Purpose:
	330	* Return an integer point rating value for the given bootp packet.
	331	* If yiaddr non-zero, the packet gets a rating of 1.
	332	* Another point is given if the packet contains the subnet mask,
	333	* and another if the router is present.
	334	*/
	335	#define GOOD_RATING 3
	336	static __inline__ int
9bccf70c	337	rate_packet(struct bootp * pkt, int pkt_size, dhcpol_t * options_p)
1c79356b	338	{
9bccf70c A	339	int len;
9bccf70c A	340	int rating = 1;
1c79356b	341
9bccf70c A	342	if (dhcpol_find(options_p, dhcptag_subnet_mask_e, &len, NULL) != NULL) {
	343	rating++;
	344	}
	345	if (dhcpol_find(options_p, dhcptag_router_e, &len, NULL) != NULL) {
1c79356b	346	rating++;
1c79356b A	347	}
	348	return (rating);
	349	}
	350
	351	#define INITIAL_WAIT_SECS 4
	352	#define MAX_WAIT_SECS 64
	353	#define GATHER_TIME_SECS 2
	354	#define RAND_TICKS (hz) /* one second */
	355
	356	/*
	357	* Function: bootp_loop
	358	* Purpose:
	359	* Do the actual BOOTP protocol.
	360	* The algorithm sends out a packet, waits for a response.
	361	* We try max_try times, waiting in an exponentially increasing
	362	* amount of time. Once we receive a good response, we start
	363	* a new time period called the "gather time", during which we
	364	* either find the perfect packet (one that has ip, mask and router)
	365	* or we continue to gather responses. At the end of the gather period,
	366	* we use the best response gathered.
	367	*/
	368	static int
	369	bootp_loop(struct socket * so, struct ifnet * ifp, int max_try,
	370	struct in_addr * iaddr_p, struct in_addr * netmask_p,
	371	struct in_addr * router_p)
	372	{
	373	struct timeval current_time;
	374	struct sockaddr_dl * dl_p;
	375	int error = 0;
	376	char * hwaddr;
	377	int hwlen;
	378	char hwtype = 0;
	379	struct bootp_packet * request = NULL;
	380	struct bootp * reply = NULL;
9bccf70c	381	int reply_size = DHCP_PACKET_MIN;
1c79356b A	382	struct timeval start_time;
	383	u_long xid;
	384	int retry;
	385	struct socket * timeflag;
	386	int wait_ticks = INITIAL_WAIT_SECS * hz;
	387
	388	/* get the hardware address from the interface */
	389	dl_p = link_from_ifnet(ifp);
	390	if (dl_p == NULL) {
	391	printf("bootp: can't get link address\n");
	392	return (ENXIO);
	393	}
	394
	395	printf("bootp: h/w addr ");
	396	link_print(dl_p);
	397
	398	hwaddr = link_address(dl_p);
	399	hwlen = dl_p->sdl_alen;
	400	switch (dl_p->sdl_type) {
	401	case IFT_ETHER:
	402	hwtype = ARPHRD_ETHER;
	403	break;
	404	default:
	405	printf("bootp: hardware type %d not supported\n",
	406	dl_p->sdl_type);
	407	panic("bootp: hardware type not supported");
	408	break;
	409	}
	410
	411	/* set transaction id and remember the start time */
	412	microtime(&start_time);
	413	current_time = start_time;
	414	xid = random();
	415
	416	/* make a request/reply packet */
	417	request = (struct bootp_packet )kalloc(sizeof(request));
	418	make_bootp_request(request, hwaddr, hwtype, hwlen);
9bccf70c	419	reply = (struct bootp *)kalloc(reply_size);
1c79356b A	420	iaddr_p->s_addr = 0;
	421	printf("bootp: sending request");
	422	for (retry = 0; retry < max_try; retry++) {
	423	int gather_count = 0;
	424	int last_rating = 0;
	425
	426	/* Send the request */
	427	printf(".");
	428	request->bp_bootp.bp_secs = htons((u_short)(current_time.tv_sec
	429	- start_time.tv_sec));
	430	request->bp_bootp.bp_xid = htonl(xid);
	431	error = send_bootp_request(ifp, so, request);
	432	if (error)
	433	goto cleanup;
	434
	435	timeflag = so;
	436	wait_ticks += random_range(-RAND_TICKS, RAND_TICKS);
	437	dprintf(("bootp: waiting %d ticks\n", wait_ticks));
9bccf70c	438	timeout((timeout_fcn_t)bootp_timeout, &timeflag, wait_ticks);
1c79356b A	439
1c79356b A	440	while (TRUE) {
9bccf70c A	441	int n = 0;
	442
	443	error = receive_packet(so, (caddr_t)reply, reply_size, &n);
1c79356b A	444	if (error == 0) {
	445	dprintf(("\nbootp: received packet\n"));
	446	if (ntohl(reply->bp_xid) == xid
	447	&& reply->bp_yiaddr.s_addr
	448	&& bcmp(reply->bp_chaddr, hwaddr, hwlen) == 0) {
9bccf70c A	449	int rating;
	450	dhcpol_t options;
	451
1c79356b	452	#ifdef BOOTP_DEBUG
9bccf70c	453	print_reply_short(reply, n);
1c79356b	454	#endif BOOTP_DEBUG
9bccf70c A	455	(void)dhcpol_parse_packet(&options, (struct dhcp *)reply,
	456	n, NULL);
	457	rating = rate_packet(reply, n, &options);
	458	if (rating > last_rating) {
	459	struct in_addr * ip;
	460	int len;
	461
	462	*iaddr_p = reply->bp_yiaddr;
	463	ip = (struct in_addr *)
	464	dhcpol_find(&options,
	465	dhcptag_subnet_mask_e, &len, NULL);
	466	if (ip) {
	467	netmask_p = ip;
	468	}
	469	ip = (struct in_addr *)
	470	dhcpol_find(&options, dhcptag_router_e, &len, NULL);
	471	if (ip) {
	472	router_p = ip;
	473	}
	474	printf("%sbootp: got "
	475	"response from %s (" IP_FORMAT ")\n",
	476	last_rating == 0 ? "\n" : "",
	477	reply->bp_sname,
	478	IP_LIST(&reply->bp_siaddr));
	479	}
	480	dhcpol_free(&options);
1c79356b	481	if (rating >= GOOD_RATING) {
9bccf70c A	482	untimeout((timeout_fcn_t)bootp_timeout, &timeflag);
9bccf70c A	483	goto done;
1c79356b A	484	}
1c79356b A	485	if (gather_count == 0) {
9bccf70c	486	untimeout((timeout_fcn_t)bootp_timeout, &timeflag);
1c79356b	487	timeflag = so;
9bccf70c	488	timeout((timeout_fcn_t)bootp_timeout, &timeflag,
1c79356b A	489	hz * GATHER_TIME_SECS);
	490	}
	491	gather_count++;
	492	}
	493	else {
	494	dprintf(("bootp: packet ignored\n"));
	495	}
	496	}
	497	else if ((error != EWOULDBLOCK)) {
	498	break;
	499	}
	500	else if (timeflag == NULL) { /* timed out */
	501	if (gather_count) {
	502	dprintf(("bootp: gathering time has expired"));
9bccf70c	503	goto done; /* we have a packet */
1c79356b A	504	}
	505	break; /* retry */
	506	}
	507	else
	508	sbwait(&so->so_rcv);
	509	}
	510	if (error && (error != EWOULDBLOCK)) {
	511	dprintf(("bootp: failed to receive packets: %d\n", error));
9bccf70c	512	untimeout((timeout_fcn_t)bootp_timeout, &timeflag);
1c79356b A	513	goto cleanup;
	514	}
	515	wait_ticks *= 2;
	516	if (wait_ticks > (MAX_WAIT_SECS * hz))
	517	wait_ticks = MAX_WAIT_SECS * hz;
	518	xid++;
	519	microtime(&current_time);
	520	}
	521	error = ETIMEDOUT;
	522	goto cleanup;
	523
9bccf70c	524	done:
1c79356b	525	error = 0;
1c79356b A	526
	527	cleanup:
	528	if (request)
	529	kfree((caddr_t)request, sizeof (*request));
	530	if (reply)
9bccf70c	531	kfree((caddr_t)reply, reply_size);
1c79356b A	532	return (error);
	533	}
	534
	535	/*
	536	* Routine: bootp
	537	* Function:
	538	* Use the BOOTP protocol to resolve what our IP address should be
	539	* on a particular interface.
	540	*/
	541	int bootp(struct ifnet * ifp, struct in_addr * iaddr_p, int max_try,
	542	struct in_addr * netmask_p, struct in_addr * router_p,
	543	struct proc * procp)
	544	{
	545	boolean_t addr_set = FALSE;
	546	struct ifreq ifr;
	547	int error;
	548	struct socket * so = NULL;
	549
	550	/* get a socket */
	551	error = socreate(AF_INET, &so, SOCK_DGRAM, 0);
	552	if (error) {
	553	dprintf(("bootp: socreate failed %d\n", error));
	554	return (error);
	555	}
	556
	557	/* assign the all-zeroes address */
	558	bzero(&ifr, sizeof(ifr));
	559	sprintf(ifr.ifr_name, "%s%d", ifp->if_name, ifp->if_unit);
9bccf70c	560	((struct sockaddr_in )&ifr.ifr_addr) = blank_sin();
1c79356b A	561	error = ifioctl(so, SIOCSIFADDR, (caddr_t)&ifr, procp);
	562	if (error) {
	563	dprintf(("bootp: SIOCSIFADDR all-zeroes IP failed: %d\n",
	564	error));
	565	goto cleanup;
	566	}
	567	dprintf(("bootp: all-zeroes IP address assigned\n"));
	568	addr_set = TRUE;
	569
	570	{ /* bind the socket */
	571	struct sockaddr_in * sin;
	572
0b4e3aa0 A	573	sin = _MALLOC(sizeof(struct sockaddr_in), M_IFADDR, M_WAIT);
	574	if (sin == NULL) {
	575	error = ENOMEM;
	576	goto cleanup;
	577	}
1c79356b A	578	sin->sin_len = sizeof(struct sockaddr_in);
	579	sin->sin_family = AF_INET;
	580	sin->sin_port = htons(IPPORT_BOOTPC);
	581	sin->sin_addr.s_addr = INADDR_ANY;
	582	error = sobind(so, (struct sockaddr *) sin);
	583
	584	FREE(sin, M_IFADDR);
	585	if (error) {
	586	dprintf(("bootp: sobind failed, %d\n", error));
	587	goto cleanup;
	588	}
	589	so->so_state \|= SS_NBIO;
	590	}
	591	/* do the protocol */
	592	error = bootp_loop(so, ifp, max_try, iaddr_p, netmask_p, router_p);
	593
	594	cleanup:
	595	if (so) {
	596	if (addr_set) {
	597	(void) ifioctl(so, SIOCDIFADDR, (caddr_t) &ifr, procp);
	598	}
	599	soclose(so);
	600	}
	601	return (error);
	602	}