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

/*
 * Copyright (c) 2002-2016 Apple Inc. All rights reserved.
 *
 * @APPLE_OSREFERENCE_LICENSE_HEADER_START@
 * 
 * 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. The rights granted to you under the License
 * may not be used to create, or enable the creation or redistribution of,
 * unlawful or unlicensed copies of an Apple operating system, or to
 * circumvent, violate, or enable the circumvention or violation of, any
 * terms of an Apple operating system software license agreement.
 * 
 * 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_OSREFERENCE_LICENSE_HEADER_END@
 */
/*
 * dhcp_options.c
 * - routines to parse and access dhcp options
 *   and create new dhcp option areas
 * - handles overloaded areas as well as vendor-specific options
 *   that are encoded using the RFC 2132 encoding
 */

/* 
 * Modification History
 *
 * March 15, 2002	Dieter Siegmund (dieter@apple)
 * - imported from bootp project
 */

#include <string.h>
#include <sys/types.h>
#include <sys/param.h>
#include <netinet/in.h>
#include <sys/malloc.h>
#include <netinet/dhcp.h>
#include <netinet/dhcp_options.h>

#ifndef TEST_DHCP_OPTIONS
#include <libkern/libkern.h>

#ifdef	DHCP_DEBUG
#define	dprintf(x) printf x;
#else	/* !DHCP_DEBUG */
#define	dprintf(x)
#endif	/* DHCP_DEBUG */

static __inline__ void
my_free(void * ptr)
{
    _FREE(ptr, M_TEMP);
}

static __inline__ void *
my_malloc(int size)
{
    void * data;
    MALLOC(data, void *, size, M_TEMP, M_WAITOK);
    return (data);
}

static __inline__ void *
my_realloc(void * oldptr, int oldsize, int newsize)
{
    void * data;

    MALLOC(data, void *, newsize, M_TEMP, M_WAITOK);
    bcopy(oldptr, data, oldsize);
    my_free(oldptr);
    return (data);
}
#else
/*
 * To build:
 * xcrun -sdk macosx.internal cc -DTEST_DHCP_OPTIONS -o /tmp/dhcp_options dhcp_options.c -I .. 
 */
#include <stdlib.h>
#include <unistd.h>
#include <stdio.h>
#define my_free	free
#define my_malloc malloc
#define my_realloc(ptr, old_size, new_size) realloc(ptr, new_size)
#define	dprintf(x) printf x;
#endif

/*
 * Functions: ptrlist_*
 * Purpose:
 *   A dynamically growable array of pointers.
 */

#define PTRLIST_NUMBER		16

static void
ptrlist_init(ptrlist_t * list)
{
    bzero(list, sizeof(*list));
    return;
}

static void
ptrlist_free(ptrlist_t * list)
{
    if (list->array)
	my_free(list->array);
    ptrlist_init(list);
    return;
}

static int
ptrlist_count(ptrlist_t * list)
{
    if (list == NULL || list->array == NULL)
	return (0);

    return (list->count);
}

static const void *
ptrlist_element(ptrlist_t * list, int i)
{
    if (list->array == NULL)
	return (NULL);
    if (i < list->count)
	return (list->array[i]);
    return (NULL);
}


static boolean_t
ptrlist_grow(ptrlist_t * list)
{
    if (list->array == NULL) {
	if (list->size == 0)
	    list->size = PTRLIST_NUMBER;
	list->count = 0;
	list->array = my_malloc(sizeof(*list->array) * list->size);
    }
    else if (list->size == list->count) {
	dprintf(("doubling %d to %d\n", list->size, list->size * 2));
	list->array = my_realloc(list->array, 
				 sizeof(*list->array) * list->size,
				 sizeof(*list->array) * list->size * 2);
	list->size *= 2;
    }
    if (list->array == NULL)
	return (FALSE);
    return (TRUE);
}

static boolean_t
ptrlist_add(ptrlist_t * list, const void * element)
{
    if (ptrlist_grow(list) == FALSE)
	return (FALSE);

    list->array[list->count++] = element;
    return (TRUE);
}

/* concatenates extra onto list */
static boolean_t
ptrlist_concat(ptrlist_t * list, ptrlist_t * extra)
{
    if (extra->count == 0)
	return (TRUE);

    if ((extra->count + list->count) > list->size) {
	int old_size = list->size;

	list->size = extra->count + list->count;
	if (list->array == NULL)
	    list->array = my_malloc(sizeof(*list->array) * list->size);
	else
	    list->array = my_realloc(list->array, old_size,
				     sizeof(*list->array) * list->size);
    }
    if (list->array == NULL)
	return (FALSE);
    bcopy(extra->array, list->array + list->count, 
	  extra->count * sizeof(*list->array));
    list->count += extra->count;
    return (TRUE);
}


/*
 * Functions: dhcpol_* 
 *
 * Purpose:
 *   Routines to parse/access existing options buffers.
 */
boolean_t
dhcpol_add(dhcpol_t * list, const void * element)
{
    return (ptrlist_add((ptrlist_t *)list, element));
}

int
dhcpol_count(dhcpol_t * list)
{
    return (ptrlist_count((ptrlist_t *)list));
}

const void *
dhcpol_element(dhcpol_t * list, int i)
{
    return (ptrlist_element((ptrlist_t *)list, i));
}

void
dhcpol_init(dhcpol_t * list)
{
    ptrlist_init((ptrlist_t *)list);
}

void
dhcpol_free(dhcpol_t * list)
{
    ptrlist_free((ptrlist_t *)list);
}

boolean_t
dhcpol_concat(dhcpol_t * list, dhcpol_t * extra)
{
    return (ptrlist_concat((ptrlist_t *)list, (ptrlist_t *)extra));
}

/*
 * Function: dhcpol_parse_buffer
 *
 * Purpose:
 *   Parse the given buffer into DHCP options, returning the
 *   list of option pointers in the given dhcpol_t.
 *   Parsing continues until we hit the end of the buffer or
 *   the end tag.
 */
boolean_t
dhcpol_parse_buffer(dhcpol_t * list, const void * buffer, int length)
{
    int			len;
    const uint8_t *	scan;
    uint8_t		tag;

    dhcpol_init(list);

    len = length;
    tag = dhcptag_pad_e;
    for (scan = (const uint8_t *)buffer;
	 tag != dhcptag_end_e && len > DHCP_TAG_OFFSET; ) {

	tag = scan[DHCP_TAG_OFFSET];

	switch (tag) {
	  case dhcptag_end_e:
	      /* remember that it was terminated */
	      dhcpol_add(list, scan);
	      scan++;
	      len--;
	      break;
	  case dhcptag_pad_e: /* ignore pad */
	      scan++;
	      len--;
	      break;
	  default:
	      if (len > DHCP_LEN_OFFSET) {
		  uint8_t	option_len;

		  option_len = scan[DHCP_LEN_OFFSET];
		  dhcpol_add(list, scan);
		  len -= (option_len + DHCP_OPTION_OFFSET);
		  scan += (option_len + DHCP_OPTION_OFFSET);
	      }
	      else {
		  len = -1;
	      }
	      break;
	}
    }
    if (len < 0) {
	/* ran off the end */
	dprintf(("dhcp_options: parse failed near tag %d\n", tag));
	dhcpol_free(list);
	return (FALSE);
    }
    return (TRUE);
}

/*
 * Function: dhcpol_find
 *
 * Purpose:
 *   Finds the first occurence of the given option, and returns its
 *   length and the option data pointer.
 *
 *   The optional start parameter allows this function to 
 *   return the next start point so that successive
 *   calls will retrieve the next occurence of the option.
 *   Before the first call, *start should be set to 0.
 */
const void *
dhcpol_find(dhcpol_t * list, int tag, int * len_p, int * start)
{
    int 	i = 0;

    if (tag == dhcptag_end_e || tag == dhcptag_pad_e)
	return (NULL);

    if (start)
	i = *start;

    for (; i < dhcpol_count(list); i++) {
	const uint8_t * 	option = dhcpol_element(list, i);
	
	if (option[DHCP_TAG_OFFSET] == tag) {
	    if (len_p)
		*len_p = option[DHCP_LEN_OFFSET];
	    if (start)
		*start = i + 1;
	    return (option + DHCP_OPTION_OFFSET);
	}
    }
    return (NULL);
}

/*
 * Function: dhcpol_parse_packet
 *
 * Purpose:
 *    Parse the option areas in the DHCP packet.
 *    Verifies that the packet has the right magic number,
 *    then parses and accumulates the option areas.
 *    First the pkt->dp_options is parsed.  If that contains
 *    the overload option, it parses pkt->dp_file if specified,
 *    then parses pkt->dp_sname if specified.
 */
boolean_t
dhcpol_parse_packet(dhcpol_t * options, const struct dhcp * pkt, int len)
{
    char		rfc_magic[4] = RFC_OPTIONS_MAGIC;

    dhcpol_init(options);	/* make sure it's empty */

    if (len < (sizeof(*pkt) + RFC_MAGIC_SIZE)) {
	dprintf(("dhcp_options: packet is too short: %d < %d\n",
		 len, (int)sizeof(*pkt) + RFC_MAGIC_SIZE));
	return (FALSE);
    }
    if (bcmp(pkt->dp_options, rfc_magic, RFC_MAGIC_SIZE)) {
	dprintf(("dhcp_options: missing magic number\n"));
	return (FALSE);
    }
    if (dhcpol_parse_buffer(options, pkt->dp_options + RFC_MAGIC_SIZE,
			    len - sizeof(*pkt) - RFC_MAGIC_SIZE) == FALSE)
	return (FALSE);
    { /* get overloaded options */
	const uint8_t *	overload;
	int		overload_len;

	overload = dhcpol_find(options, dhcptag_option_overload_e, 
			       &overload_len, NULL);
	if (overload && overload_len == 1) { /* has overloaded options */
	    dhcpol_t	extra;
	    
	    dhcpol_init(&extra);
	    if (*overload == DHCP_OVERLOAD_FILE
		|| *overload == DHCP_OVERLOAD_BOTH) {
		if (dhcpol_parse_buffer(&extra, pkt->dp_file, 
					sizeof(pkt->dp_file))) {
		    dhcpol_concat(options, &extra);
		    dhcpol_free(&extra);
		}
	    }
	    if (*overload == DHCP_OVERLOAD_SNAME
		|| *overload == DHCP_OVERLOAD_BOTH) {
		if (dhcpol_parse_buffer(&extra, pkt->dp_sname, 
					sizeof(pkt->dp_sname))) {
		    dhcpol_concat(options, &extra);
		    dhcpol_free(&extra);
		}
	    }
	}
    }
    return (TRUE);
}

#ifdef TEST_DHCP_OPTIONS
char test_empty[] = {
    99, 130, 83, 99,
    255,
};

char test_short[] = {
    99, 130, 83, 99,
    1,
};

char test_simple[] = {
    99, 130, 83, 99,
    1, 4, 255, 255, 252, 0,
    3, 4, 17, 202, 40, 1,
    255,
};

char test_vendor[] = {
    99, 130, 83, 99,
    1, 4, 255, 255, 252, 0,
    3, 4, 17, 202, 40, 1,
    43, 6, 1, 4, 1, 2, 3, 4,
    43, 6, 1, 4, 1, 2, 3, 4,
    255,
};

char test_no_end[] = {
    0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x05, 0x36, 
    0x04, 0xc0, 0xa8, 0x01, 0x01, 0x33, 0x04, 0x80,
    0x00, 0x80, 0x00, 0x01, 0x04, 0xff, 0xff, 0xff,
    0x00, 0x03, 0x04, 0xc0, 0xa8, 0x01, 0x01, 0x06,
    0x0c, 0x18, 0x1a, 0xa3, 0x21, 0x18, 0x1a, 0xa3,
    0x20, 0x18, 0x5e, 0xa3, 0x21, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
    0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
};

char test_no_magic[] = {
    0x1 
};
struct test {
    char * 		name;
    char *		data;
    int			len;
    boolean_t		result;
};

struct test tests[] = {
    { "empty", test_empty, sizeof(test_empty), TRUE },
    { "simple", test_simple, sizeof(test_simple), TRUE },
    { "vendor", test_vendor, sizeof(test_vendor), TRUE },
    { "no_end", test_no_end, sizeof(test_no_end), TRUE },
    { "no magic", test_no_magic, sizeof(test_no_magic), FALSE },
    { "short", test_short, sizeof(test_short), FALSE },
    { NULL, NULL, 0, FALSE },
};


static char buf[2048];

int
main()
{
    int 	i;
    dhcpol_t 	options;
    struct dhcp * pkt = (struct dhcp *)buf;

    dhcpol_init(&options);

    for (i = 0; tests[i].name; i++) {
	printf("\nTest %d: ", i);
	bcopy(tests[i].data, pkt->dp_options, tests[i].len);
	if (dhcpol_parse_packet(&options, pkt, 
				sizeof(*pkt) + tests[i].len)
	    != tests[i].result) {
	    printf("test '%s' FAILED\n", tests[i].name);
	}
	else {
	    printf("test '%s' PASSED\n", tests[i].name);
	}
	dhcpol_free(&options);
    }
    exit(0);
}
#endif /* TEST_DHCP_OPTIONS */
Commit	Line	Data
2d21ac55	1	/*
ecc0ceb4	2	* Copyright (c) 2002-2016 Apple Inc. All rights reserved.
2d21ac55 A	3	*
	4	* @APPLE_OSREFERENCE_LICENSE_HEADER_START@
	5	*
	6	* This file contains Original Code and/or Modifications of Original Code
	7	* as defined in and that are subject to the Apple Public Source License
	8	* Version 2.0 (the 'License'). You may not use this file except in
	9	* compliance with the License. The rights granted to you under the License
	10	* may not be used to create, or enable the creation or redistribution of,
	11	* unlawful or unlicensed copies of an Apple operating system, or to
	12	* circumvent, violate, or enable the circumvention or violation of, any
	13	* terms of an Apple operating system software license agreement.
	14	*
	15	* Please obtain a copy of the License at
	16	* http://www.opensource.apple.com/apsl/ and read it before using this file.
	17	*
	18	* The Original Code and all software distributed under the License are
	19	* distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER
	20	* EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES,
	21	* INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY,
	22	* FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT.
	23	* Please see the License for the specific language governing rights and
	24	* limitations under the License.
	25	*
	26	* @APPLE_OSREFERENCE_LICENSE_HEADER_END@
	27	*/
9bccf70c A	28	/*
	29	* dhcp_options.c
	30	* - routines to parse and access dhcp options
	31	* and create new dhcp option areas
	32	* - handles overloaded areas as well as vendor-specific options
	33	* that are encoded using the RFC 2132 encoding
	34	*/
	35
	36	/*
	37	* Modification History
	38	*
	39	* March 15, 2002 Dieter Siegmund (dieter@apple)
	40	* - imported from bootp project
	41	*/
	42
2d21ac55	43	#include <string.h>
9bccf70c A	44	#include <sys/types.h>
	45	#include <sys/param.h>
	46	#include <netinet/in.h>
	47	#include <sys/malloc.h>
9bccf70c A	48	#include <netinet/dhcp.h>
	49	#include <netinet/dhcp_options.h>
	50
ecc0ceb4 A	51	#ifndef TEST_DHCP_OPTIONS
	52	#include <libkern/libkern.h>
	53
2d21ac55 A	54	#ifdef DHCP_DEBUG
	55	#define dprintf(x) printf x;
	56	#else /* !DHCP_DEBUG */
	57	#define dprintf(x)
	58	#endif /* DHCP_DEBUG */
	59
9bccf70c A	60	static __inline__ void
	61	my_free(void * ptr)
	62	{
	63	_FREE(ptr, M_TEMP);
	64	}
	65
	66	static __inline__ void *
	67	my_malloc(int size)
	68	{
	69	void * data;
	70	MALLOC(data, void *, size, M_TEMP, M_WAITOK);
	71	return (data);
	72	}
	73
	74	static __inline__ void *
	75	my_realloc(void * oldptr, int oldsize, int newsize)
	76	{
	77	void * data;
	78
	79	MALLOC(data, void *, newsize, M_TEMP, M_WAITOK);
	80	bcopy(oldptr, data, oldsize);
	81	my_free(oldptr);
	82	return (data);
	83	}
ecc0ceb4 A	84	#else
	85	/*
	86	* To build:
	87	* xcrun -sdk macosx.internal cc -DTEST_DHCP_OPTIONS -o /tmp/dhcp_options dhcp_options.c -I ..
	88	*/
	89	#include <stdlib.h>
	90	#include <unistd.h>
	91	#include <stdio.h>
	92	#define my_free free
	93	#define my_malloc malloc
	94	#define my_realloc(ptr, old_size, new_size) realloc(ptr, new_size)
	95	#define dprintf(x) printf x;
	96	#endif
9bccf70c A	97
	98	/*
	99	* Functions: ptrlist_*
	100	* Purpose:
	101	* A dynamically growable array of pointers.
	102	*/
	103
	104	#define PTRLIST_NUMBER 16
	105
	106	static void
	107	ptrlist_init(ptrlist_t * list)
	108	{
	109	bzero(list, sizeof(*list));
	110	return;
	111	}
	112
	113	static void
	114	ptrlist_free(ptrlist_t * list)
	115	{
	116	if (list->array)
	117	my_free(list->array);
	118	ptrlist_init(list);
	119	return;
	120	}
	121
	122	static int
	123	ptrlist_count(ptrlist_t * list)
	124	{
	125	if (list == NULL \|\| list->array == NULL)
	126	return (0);
	127
	128	return (list->count);
	129	}
	130
2d21ac55	131	static const void *
9bccf70c A	132	ptrlist_element(ptrlist_t * list, int i)
	133	{
	134	if (list->array == NULL)
	135	return (NULL);
	136	if (i < list->count)
	137	return (list->array[i]);
	138	return (NULL);
	139	}
	140
	141
	142	static boolean_t
	143	ptrlist_grow(ptrlist_t * list)
	144	{
	145	if (list->array == NULL) {
	146	if (list->size == 0)
	147	list->size = PTRLIST_NUMBER;
	148	list->count = 0;
	149	list->array = my_malloc(sizeof(list->array) list->size);
	150	}
	151	else if (list->size == list->count) {
2d21ac55	152	dprintf(("doubling %d to %d\n", list->size, list->size * 2));
9bccf70c A	153	list->array = my_realloc(list->array,
	154	sizeof(list->array) list->size,
	155	sizeof(list->array) list->size * 2);
	156	list->size *= 2;
	157	}
	158	if (list->array == NULL)
	159	return (FALSE);
	160	return (TRUE);
	161	}
	162
	163	static boolean_t
2d21ac55	164	ptrlist_add(ptrlist_t * list, const void * element)
9bccf70c A	165	{
	166	if (ptrlist_grow(list) == FALSE)
	167	return (FALSE);
	168
	169	list->array[list->count++] = element;
	170	return (TRUE);
	171	}
	172
	173	/* concatenates extra onto list */
	174	static boolean_t
	175	ptrlist_concat(ptrlist_t * list, ptrlist_t * extra)
	176	{
	177	if (extra->count == 0)
	178	return (TRUE);
	179
	180	if ((extra->count + list->count) > list->size) {
	181	int old_size = list->size;
	182
	183	list->size = extra->count + list->count;
	184	if (list->array == NULL)
	185	list->array = my_malloc(sizeof(list->array) list->size);
	186	else
	187	list->array = my_realloc(list->array, old_size,
	188	sizeof(list->array) list->size);
	189	}
	190	if (list->array == NULL)
	191	return (FALSE);
	192	bcopy(extra->array, list->array + list->count,
	193	extra->count * sizeof(*list->array));
	194	list->count += extra->count;
	195	return (TRUE);
	196	}
	197
	198
	199	/*
	200	* Functions: dhcpol_*
	201	*
	202	* Purpose:
	203	* Routines to parse/access existing options buffers.
	204	*/
	205	boolean_t
2d21ac55	206	dhcpol_add(dhcpol_t * list, const void * element)
9bccf70c A	207	{
	208	return (ptrlist_add((ptrlist_t *)list, element));
	209	}
	210
	211	int
	212	dhcpol_count(dhcpol_t * list)
	213	{
	214	return (ptrlist_count((ptrlist_t *)list));
	215	}
	216
2d21ac55	217	const void *
9bccf70c A	218	dhcpol_element(dhcpol_t * list, int i)
	219	{
	220	return (ptrlist_element((ptrlist_t *)list, i));
	221	}
	222
	223	void
	224	dhcpol_init(dhcpol_t * list)
	225	{
	226	ptrlist_init((ptrlist_t *)list);
	227	}
	228
	229	void
	230	dhcpol_free(dhcpol_t * list)
	231	{
	232	ptrlist_free((ptrlist_t *)list);
	233	}
	234
	235	boolean_t
	236	dhcpol_concat(dhcpol_t * list, dhcpol_t * extra)
	237	{
	238	return (ptrlist_concat((ptrlist_t )list, (ptrlist_t )extra));
	239	}
	240
	241	/*
	242	* Function: dhcpol_parse_buffer
	243	*
	244	* Purpose:
	245	* Parse the given buffer into DHCP options, returning the
	246	* list of option pointers in the given dhcpol_t.
	247	* Parsing continues until we hit the end of the buffer or
	248	* the end tag.
	249	*/
	250	boolean_t
2d21ac55	251	dhcpol_parse_buffer(dhcpol_t * list, const void * buffer, int length)
9bccf70c A	252	{
9bccf70c A	253	int len;
2d21ac55 A	254	const uint8_t * scan;
2d21ac55 A	255	uint8_t tag;
9bccf70c A	256
	257	dhcpol_init(list);
	258
	259	len = length;
	260	tag = dhcptag_pad_e;
ecc0ceb4 A	261	for (scan = (const uint8_t *)buffer;
ecc0ceb4 A	262	tag != dhcptag_end_e && len > DHCP_TAG_OFFSET; ) {
9bccf70c A	263
	264	tag = scan[DHCP_TAG_OFFSET];
	265
	266	switch (tag) {
	267	case dhcptag_end_e:
2d21ac55 A	268	/* remember that it was terminated */
2d21ac55 A	269	dhcpol_add(list, scan);
9bccf70c A	270	scan++;
	271	len--;
	272	break;
	273	case dhcptag_pad_e: /* ignore pad */
	274	scan++;
	275	len--;
	276	break;
ecc0ceb4 A	277	default:
	278	if (len > DHCP_LEN_OFFSET) {
	279	uint8_t option_len;
	280
	281	option_len = scan[DHCP_LEN_OFFSET];
	282	dhcpol_add(list, scan);
	283	len -= (option_len + DHCP_OPTION_OFFSET);
	284	scan += (option_len + DHCP_OPTION_OFFSET);
	285	}
	286	else {
	287	len = -1;
	288	}
9bccf70c	289	break;
9bccf70c A	290	}
	291	}
	292	if (len < 0) {
	293	/* ran off the end */
ecc0ceb4	294	dprintf(("dhcp_options: parse failed near tag %d\n", tag));
9bccf70c A	295	dhcpol_free(list);
	296	return (FALSE);
	297	}
	298	return (TRUE);
	299	}
	300
	301	/*
	302	* Function: dhcpol_find
	303	*
	304	* Purpose:
	305	* Finds the first occurence of the given option, and returns its
	306	* length and the option data pointer.
	307	*
	308	* The optional start parameter allows this function to
	309	* return the next start point so that successive
	310	* calls will retrieve the next occurence of the option.
	311	* Before the first call, *start should be set to 0.
	312	*/
2d21ac55	313	const void *
9bccf70c A	314	dhcpol_find(dhcpol_t * list, int tag, int * len_p, int * start)
	315	{
	316	int i = 0;
	317
	318	if (tag == dhcptag_end_e \|\| tag == dhcptag_pad_e)
	319	return (NULL);
	320
	321	if (start)
	322	i = *start;
	323
	324	for (; i < dhcpol_count(list); i++) {
2d21ac55	325	const uint8_t * option = dhcpol_element(list, i);
9bccf70c A	326
	327	if (option[DHCP_TAG_OFFSET] == tag) {
	328	if (len_p)
	329	*len_p = option[DHCP_LEN_OFFSET];
	330	if (start)
	331	*start = i + 1;
	332	return (option + DHCP_OPTION_OFFSET);
	333	}
	334	}
	335	return (NULL);
	336	}
	337
9bccf70c A	338	/*
	339	* Function: dhcpol_parse_packet
	340	*
	341	* Purpose:
	342	* Parse the option areas in the DHCP packet.
	343	* Verifies that the packet has the right magic number,
	344	* then parses and accumulates the option areas.
	345	* First the pkt->dp_options is parsed. If that contains
	346	* the overload option, it parses pkt->dp_file if specified,
	347	* then parses pkt->dp_sname if specified.
	348	*/
	349	boolean_t
2d21ac55	350	dhcpol_parse_packet(dhcpol_t * options, const struct dhcp * pkt, int len)
9bccf70c A	351	{
	352	char rfc_magic[4] = RFC_OPTIONS_MAGIC;
	353
	354	dhcpol_init(options); /* make sure it's empty */
	355
9bccf70c	356	if (len < (sizeof(*pkt) + RFC_MAGIC_SIZE)) {
2d21ac55 A	357	dprintf(("dhcp_options: packet is too short: %d < %d\n",
2d21ac55 A	358	len, (int)sizeof(*pkt) + RFC_MAGIC_SIZE));
9bccf70c A	359	return (FALSE);
	360	}
	361	if (bcmp(pkt->dp_options, rfc_magic, RFC_MAGIC_SIZE)) {
2d21ac55	362	dprintf(("dhcp_options: missing magic number\n"));
9bccf70c A	363	return (FALSE);
	364	}
	365	if (dhcpol_parse_buffer(options, pkt->dp_options + RFC_MAGIC_SIZE,
2d21ac55	366	len - sizeof(*pkt) - RFC_MAGIC_SIZE) == FALSE)
9bccf70c A	367	return (FALSE);
9bccf70c A	368	{ /* get overloaded options */
2d21ac55	369	const uint8_t * overload;
9bccf70c A	370	int overload_len;
9bccf70c A	371
2d21ac55 A	372	overload = dhcpol_find(options, dhcptag_option_overload_e,
2d21ac55 A	373	&overload_len, NULL);
9bccf70c A	374	if (overload && overload_len == 1) { /* has overloaded options */
9bccf70c A	375	dhcpol_t extra;
2d21ac55	376
9bccf70c A	377	dhcpol_init(&extra);
	378	if (*overload == DHCP_OVERLOAD_FILE
	379	\|\| *overload == DHCP_OVERLOAD_BOTH) {
	380	if (dhcpol_parse_buffer(&extra, pkt->dp_file,
2d21ac55	381	sizeof(pkt->dp_file))) {
9bccf70c A	382	dhcpol_concat(options, &extra);
	383	dhcpol_free(&extra);
	384	}
	385	}
	386	if (*overload == DHCP_OVERLOAD_SNAME
	387	\|\| *overload == DHCP_OVERLOAD_BOTH) {
	388	if (dhcpol_parse_buffer(&extra, pkt->dp_sname,
2d21ac55	389	sizeof(pkt->dp_sname))) {
9bccf70c A	390	dhcpol_concat(options, &extra);
	391	dhcpol_free(&extra);
	392	}
	393	}
	394	}
	395	}
	396	return (TRUE);
	397	}
	398
9bccf70c A	399	#ifdef TEST_DHCP_OPTIONS
	400	char test_empty[] = {
	401	99, 130, 83, 99,
	402	255,
	403	};
	404
ecc0ceb4 A	405	char test_short[] = {
	406	99, 130, 83, 99,
	407	1,
	408	};
	409
9bccf70c A	410	char test_simple[] = {
	411	99, 130, 83, 99,
	412	1, 4, 255, 255, 252, 0,
	413	3, 4, 17, 202, 40, 1,
	414	255,
	415	};
	416
	417	char test_vendor[] = {
	418	99, 130, 83, 99,
	419	1, 4, 255, 255, 252, 0,
	420	3, 4, 17, 202, 40, 1,
	421	43, 6, 1, 4, 1, 2, 3, 4,
	422	43, 6, 1, 4, 1, 2, 3, 4,
	423	255,
	424	};
	425
	426	char test_no_end[] = {
	427	0x63, 0x82, 0x53, 0x63, 0x35, 0x01, 0x05, 0x36,
	428	0x04, 0xc0, 0xa8, 0x01, 0x01, 0x33, 0x04, 0x80,
	429	0x00, 0x80, 0x00, 0x01, 0x04, 0xff, 0xff, 0xff,
	430	0x00, 0x03, 0x04, 0xc0, 0xa8, 0x01, 0x01, 0x06,
	431	0x0c, 0x18, 0x1a, 0xa3, 0x21, 0x18, 0x1a, 0xa3,
	432	0x20, 0x18, 0x5e, 0xa3, 0x21, 0x00, 0x00, 0x00,
	433	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
	434	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00
	435	};
	436
ecc0ceb4	437	char test_no_magic[] = {
9bccf70c A	438	0x1
	439	};
	440	struct test {
	441	char * name;
	442	char * data;
	443	int len;
	444	boolean_t result;
	445	};
	446
	447	struct test tests[] = {
	448	{ "empty", test_empty, sizeof(test_empty), TRUE },
	449	{ "simple", test_simple, sizeof(test_simple), TRUE },
	450	{ "vendor", test_vendor, sizeof(test_vendor), TRUE },
	451	{ "no_end", test_no_end, sizeof(test_no_end), TRUE },
ecc0ceb4 A	452	{ "no magic", test_no_magic, sizeof(test_no_magic), FALSE },
ecc0ceb4 A	453	{ "short", test_short, sizeof(test_short), FALSE },
9bccf70c A	454	{ NULL, NULL, 0, FALSE },
	455	};
	456
	457
	458	static char buf[2048];
	459
	460	int
	461	main()
	462	{
	463	int i;
	464	dhcpol_t options;
9bccf70c A	465	struct dhcp * pkt = (struct dhcp *)buf;
	466
	467	dhcpol_init(&options);
	468
	469	for (i = 0; tests[i].name; i++) {
	470	printf("\nTest %d: ", i);
	471	bcopy(tests[i].data, pkt->dp_options, tests[i].len);
	472	if (dhcpol_parse_packet(&options, pkt,
2d21ac55 A	473	sizeof(*pkt) + tests[i].len)
2d21ac55 A	474	!= tests[i].result) {
9bccf70c	475	printf("test '%s' FAILED\n", tests[i].name);
9bccf70c A	476	}
	477	else {
	478	printf("test '%s' PASSED\n", tests[i].name);
9bccf70c A	479	}
	480	dhcpol_free(&options);
	481	}
	482	exit(0);
	483	}
55e303ae	484	#endif /* TEST_DHCP_OPTIONS */