[u-boot.git] / net / cdp.c

// SPDX-License-Identifier: GPL-2.0
/*
 *	Copied from Linux Monitor (LiMon) - Networking.
 *
 *	Copyright 1994 - 2000 Neil Russell.
 *	(See License)
 *	Copyright 2000 Roland Borde
 *	Copyright 2000 Paolo Scaffardi
 *	Copyright 2000-2002 Wolfgang Denk, [email protected]
 */

#include <common.h>
#include <net.h>
#if defined(CONFIG_CDP_VERSION)
#include <timestamp.h>
#endif

#include "cdp.h"

/* Ethernet bcast address */
const u8 net_cdp_ethaddr[6] = { 0x01, 0x00, 0x0c, 0xcc, 0xcc, 0xcc };

#define CDP_DEVICE_ID_TLV		0x0001
#define CDP_ADDRESS_TLV			0x0002
#define CDP_PORT_ID_TLV			0x0003
#define CDP_CAPABILITIES_TLV		0x0004
#define CDP_VERSION_TLV			0x0005
#define CDP_PLATFORM_TLV		0x0006
#define CDP_NATIVE_VLAN_TLV		0x000a
#define CDP_APPLIANCE_VLAN_TLV		0x000e
#define CDP_TRIGGER_TLV			0x000f
#define CDP_POWER_CONSUMPTION_TLV	0x0010
#define CDP_SYSNAME_TLV			0x0014
#define CDP_SYSOBJECT_TLV		0x0015
#define CDP_MANAGEMENT_ADDRESS_TLV	0x0016

#define CDP_TIMEOUT			250UL	/* one packet every 250ms */

static int cdp_seq;
static int cdp_ok;

ushort cdp_native_vlan;
ushort cdp_appliance_vlan;

static const uchar cdp_snap_hdr[8] = {
	0xAA, 0xAA, 0x03, 0x00, 0x00, 0x0C, 0x20, 0x00 };

static ushort cdp_compute_csum(const uchar *buff, ushort len)
{
	ushort csum;
	int     odd;
	ulong   result = 0;
	ushort  leftover;
	ushort *p;

	if (len > 0) {
		odd = 1 & (ulong)buff;
		if (odd) {
			result = *buff << 8;
			len--;
			buff++;
		}
		while (len > 1) {
			p = (ushort *)buff;
			result += *p++;
			buff = (uchar *)p;
			if (result & 0x80000000)
				result = (result & 0xFFFF) + (result >> 16);
			len -= 2;
		}
		if (len) {
			leftover = (signed short)(*(const signed char *)buff);
			/*
			 * CISCO SUCKS big time! (and blows too):
			 * CDP uses the IP checksum algorithm with a twist;
			 * for the last byte it *sign* extends and sums.
			 */
			result = (result & 0xffff0000) |
				 ((result + leftover) & 0x0000ffff);
		}
		while (result >> 16)
			result = (result & 0xFFFF) + (result >> 16);

		if (odd)
			result = ((result >> 8) & 0xff) |
				 ((result & 0xff) << 8);
	}

	/* add up 16-bit and 17-bit words for 17+c bits */
	result = (result & 0xffff) + (result >> 16);
	/* add up 16-bit and 2-bit for 16+c bit */
	result = (result & 0xffff) + (result >> 16);
	/* add up carry.. */
	result = (result & 0xffff) + (result >> 16);

	/* negate */
	csum = ~(ushort)result;

	/* run time endian detection */
	if (csum != htons(csum))	/* little endian */
		csum = htons(csum);

	return csum;
}

static int cdp_send_trigger(void)
{
	uchar *pkt;
	ushort *s;
	ushort *cp;
	struct ethernet_hdr *et;
	int len;
	ushort chksum;
#if	defined(CONFIG_CDP_DEVICE_ID) || defined(CONFIG_CDP_PORT_ID)   || \
	defined(CONFIG_CDP_VERSION)   || defined(CONFIG_CDP_PLATFORM)
	char buf[32];
#endif

	pkt = net_tx_packet;
	et = (struct ethernet_hdr *)pkt;

	/* NOTE: trigger sent not on any VLAN */

	/* form ethernet header */
	memcpy(et->et_dest, net_cdp_ethaddr, 6);
	memcpy(et->et_src, net_ethaddr, 6);

	pkt += ETHER_HDR_SIZE;

	/* SNAP header */
	memcpy((uchar *)pkt, cdp_snap_hdr, sizeof(cdp_snap_hdr));
	pkt += sizeof(cdp_snap_hdr);

	/* CDP header */
	*pkt++ = 0x02;				/* CDP version 2 */
	*pkt++ = 180;				/* TTL */
	s = (ushort *)pkt;
	cp = s;
	/* checksum (0 for later calculation) */
	*s++ = htons(0);

	/* CDP fields */
#ifdef CONFIG_CDP_DEVICE_ID
	*s++ = htons(CDP_DEVICE_ID_TLV);
	*s++ = htons(CONFIG_CDP_DEVICE_ID);
	sprintf(buf, CONFIG_CDP_DEVICE_ID_PREFIX "%pm", net_ethaddr);
	memcpy((uchar *)s, buf, 16);
	s += 16 / 2;
#endif

#ifdef CONFIG_CDP_PORT_ID
	*s++ = htons(CDP_PORT_ID_TLV);
	memset(buf, 0, sizeof(buf));
	sprintf(buf, CONFIG_CDP_PORT_ID, eth_get_dev_index());
	len = strlen(buf);
	if (len & 1)	/* make it even */
		len++;
	*s++ = htons(len + 4);
	memcpy((uchar *)s, buf, len);
	s += len / 2;
#endif

#ifdef CONFIG_CDP_CAPABILITIES
	*s++ = htons(CDP_CAPABILITIES_TLV);
	*s++ = htons(8);
	*(ulong *)s = htonl(CONFIG_CDP_CAPABILITIES);
	s += 2;
#endif

#ifdef CONFIG_CDP_VERSION
	*s++ = htons(CDP_VERSION_TLV);
	memset(buf, 0, sizeof(buf));
	strcpy(buf, CONFIG_CDP_VERSION);
	len = strlen(buf);
	if (len & 1)	/* make it even */
		len++;
	*s++ = htons(len + 4);
	memcpy((uchar *)s, buf, len);
	s += len / 2;
#endif

#ifdef CONFIG_CDP_PLATFORM
	*s++ = htons(CDP_PLATFORM_TLV);
	memset(buf, 0, sizeof(buf));
	strcpy(buf, CONFIG_CDP_PLATFORM);
	len = strlen(buf);
	if (len & 1)	/* make it even */
		len++;
	*s++ = htons(len + 4);
	memcpy((uchar *)s, buf, len);
	s += len / 2;
#endif

#ifdef CONFIG_CDP_TRIGGER
	*s++ = htons(CDP_TRIGGER_TLV);
	*s++ = htons(8);
	*(ulong *)s = htonl(CONFIG_CDP_TRIGGER);
	s += 2;
#endif

#ifdef CONFIG_CDP_POWER_CONSUMPTION
	*s++ = htons(CDP_POWER_CONSUMPTION_TLV);
	*s++ = htons(6);
	*s++ = htons(CONFIG_CDP_POWER_CONSUMPTION);
#endif

	/* length of ethernet packet */
	len = (uchar *)s - ((uchar *)net_tx_packet + ETHER_HDR_SIZE);
	et->et_protlen = htons(len);

	len = ETHER_HDR_SIZE + sizeof(cdp_snap_hdr);
	chksum = cdp_compute_csum((uchar *)net_tx_packet + len,
				  (uchar *)s - (net_tx_packet + len));
	if (chksum == 0)
		chksum = 0xFFFF;
	*cp = htons(chksum);

	net_send_packet(net_tx_packet, (uchar *)s - net_tx_packet);
	return 0;
}

static void cdp_timeout_handler(void)
{
	cdp_seq++;

	if (cdp_seq < 3) {
		net_set_timeout_handler(CDP_TIMEOUT, cdp_timeout_handler);
		cdp_send_trigger();
		return;
	}

	/* if not OK try again */
	if (!cdp_ok)
		net_start_again();
	else
		net_set_state(NETLOOP_SUCCESS);
}

void cdp_receive(const uchar *pkt, unsigned len)
{
	const uchar *t;
	const ushort *ss;
	ushort type, tlen;
	ushort vlan, nvlan;

	/* minimum size? */
	if (len < sizeof(cdp_snap_hdr) + 4)
		goto pkt_short;

	/* check for valid CDP SNAP header */
	if (memcmp(pkt, cdp_snap_hdr, sizeof(cdp_snap_hdr)) != 0)
		return;

	pkt += sizeof(cdp_snap_hdr);
	len -= sizeof(cdp_snap_hdr);

	/* Version of CDP protocol must be >= 2 and TTL != 0 */
	if (pkt[0] < 0x02 || pkt[1] == 0)
		return;

	/*
	 * if version is greater than 0x02 maybe we'll have a problem;
	 * output a warning
	 */
	if (pkt[0] != 0x02)
		printf("**WARNING: CDP packet received with a protocol version "
				"%d > 2\n", pkt[0] & 0xff);

	if (cdp_compute_csum(pkt, len) != 0)
		return;

	pkt += 4;
	len -= 4;

	vlan = htons(-1);
	nvlan = htons(-1);
	while (len > 0) {
		if (len < 4)
			goto pkt_short;

		ss = (const ushort *)pkt;
		type = ntohs(ss[0]);
		tlen = ntohs(ss[1]);
		if (tlen > len)
			goto pkt_short;

		pkt += tlen;
		len -= tlen;

		ss += 2;	/* point ss to the data of the TLV */
		tlen -= 4;

		switch (type) {
		case CDP_DEVICE_ID_TLV:
			break;
		case CDP_ADDRESS_TLV:
			break;
		case CDP_PORT_ID_TLV:
			break;
		case CDP_CAPABILITIES_TLV:
			break;
		case CDP_VERSION_TLV:
			break;
		case CDP_PLATFORM_TLV:
			break;
		case CDP_NATIVE_VLAN_TLV:
			nvlan = *ss;
			break;
		case CDP_APPLIANCE_VLAN_TLV:
			t = (const uchar *)ss;
			while (tlen > 0) {
				if (tlen < 3)
					goto pkt_short;

				ss = (const ushort *)(t + 1);

#ifdef CONFIG_CDP_APPLIANCE_VLAN_TYPE
				if (t[0] == CONFIG_CDP_APPLIANCE_VLAN_TYPE)
					vlan = *ss;
#else
				/* XXX will this work; dunno */
				vlan = ntohs(*ss);
#endif
				t += 3; tlen -= 3;
			}
			break;
		case CDP_TRIGGER_TLV:
			break;
		case CDP_POWER_CONSUMPTION_TLV:
			break;
		case CDP_SYSNAME_TLV:
			break;
		case CDP_SYSOBJECT_TLV:
			break;
		case CDP_MANAGEMENT_ADDRESS_TLV:
			break;
		}
	}

	cdp_appliance_vlan = vlan;
	cdp_native_vlan = nvlan;

	cdp_ok = 1;
	return;

pkt_short:
	printf("** CDP packet is too short\n");
	return;
}

void cdp_start(void)
{
	printf("Using %s device\n", eth_get_name());
	cdp_seq = 0;
	cdp_ok = 0;

	cdp_native_vlan = htons(-1);
	cdp_appliance_vlan = htons(-1);

	net_set_timeout_handler(CDP_TIMEOUT, cdp_timeout_handler);

	cdp_send_trigger();
}
Commit	Line	Data
f739fcd8	1	// SPDX-License-Identifier: GPL-2.0
f575ae1f JH	2	/*
	3	* Copied from Linux Monitor (LiMon) - Networking.
	4	*
	5	* Copyright 1994 - 2000 Neil Russell.
	6	* (See License)
	7	* Copyright 2000 Roland Borde
	8	* Copyright 2000 Paolo Scaffardi
	9	* Copyright 2000-2002 Wolfgang Denk, [email protected]
	10	*/
	11
	12	#include <common.h>
	13	#include <net.h>
	14	#if defined(CONFIG_CDP_VERSION)
	15	#include <timestamp.h>
	16	#endif
	17
	18	#include "cdp.h"
	19
	20	/* Ethernet bcast address */
0adb5b76	21	const u8 net_cdp_ethaddr[6] = { 0x01, 0x00, 0x0c, 0xcc, 0xcc, 0xcc };
f575ae1f JH	22
	23	#define CDP_DEVICE_ID_TLV 0x0001
	24	#define CDP_ADDRESS_TLV 0x0002
	25	#define CDP_PORT_ID_TLV 0x0003
	26	#define CDP_CAPABILITIES_TLV 0x0004
	27	#define CDP_VERSION_TLV 0x0005
	28	#define CDP_PLATFORM_TLV 0x0006
	29	#define CDP_NATIVE_VLAN_TLV 0x000a
	30	#define CDP_APPLIANCE_VLAN_TLV 0x000e
	31	#define CDP_TRIGGER_TLV 0x000f
	32	#define CDP_POWER_CONSUMPTION_TLV 0x0010
	33	#define CDP_SYSNAME_TLV 0x0014
	34	#define CDP_SYSOBJECT_TLV 0x0015
	35	#define CDP_MANAGEMENT_ADDRESS_TLV 0x0016
	36
	37	#define CDP_TIMEOUT 250UL /* one packet every 250ms */
	38
6aede5b7 JH	39	static int cdp_seq;
6aede5b7 JH	40	static int cdp_ok;
f575ae1f	41
6aede5b7 JH	42	ushort cdp_native_vlan;
6aede5b7 JH	43	ushort cdp_appliance_vlan;
f575ae1f	44
6aede5b7	45	static const uchar cdp_snap_hdr[8] = {
f575ae1f JH	46	0xAA, 0xAA, 0x03, 0x00, 0x00, 0x0C, 0x20, 0x00 };
f575ae1f JH	47
6aede5b7	48	static ushort cdp_compute_csum(const uchar *buff, ushort len)
f575ae1f JH	49	{
	50	ushort csum;
	51	int odd;
	52	ulong result = 0;
	53	ushort leftover;
	54	ushort *p;
	55
	56	if (len > 0) {
	57	odd = 1 & (ulong)buff;
	58	if (odd) {
	59	result = *buff << 8;
	60	len--;
	61	buff++;
	62	}
	63	while (len > 1) {
	64	p = (ushort *)buff;
	65	result += *p++;
	66	buff = (uchar *)p;
	67	if (result & 0x80000000)
	68	result = (result & 0xFFFF) + (result >> 16);
	69	len -= 2;
	70	}
	71	if (len) {
	72	leftover = (signed short)((const signed char )buff);
	73	/*
	74	* CISCO SUCKS big time! (and blows too):
	75	* CDP uses the IP checksum algorithm with a twist;
	76	* for the last byte it sign extends and sums.
	77	*/
	78	result = (result & 0xffff0000) \|
	79	((result + leftover) & 0x0000ffff);
	80	}
	81	while (result >> 16)
	82	result = (result & 0xFFFF) + (result >> 16);
	83
	84	if (odd)
	85	result = ((result >> 8) & 0xff) \|
	86	((result & 0xff) << 8);
	87	}
	88
	89	/* add up 16-bit and 17-bit words for 17+c bits */
	90	result = (result & 0xffff) + (result >> 16);
	91	/* add up 16-bit and 2-bit for 16+c bit */
	92	result = (result & 0xffff) + (result >> 16);
	93	/* add up carry.. */
	94	result = (result & 0xffff) + (result >> 16);
	95
	96	/* negate */
	97	csum = ~(ushort)result;
	98
	99	/* run time endian detection */
	100	if (csum != htons(csum)) /* little endian */
	101	csum = htons(csum);
	102
	103	return csum;
	104	}
	105
6aede5b7	106	static int cdp_send_trigger(void)
f575ae1f JH	107	{
	108	uchar *pkt;
	109	ushort *s;
	110	ushort *cp;
cb487f56	111	struct ethernet_hdr *et;
f575ae1f JH	112	int len;
	113	ushort chksum;
	114	#if defined(CONFIG_CDP_DEVICE_ID) \|\| defined(CONFIG_CDP_PORT_ID) \|\| \
	115	defined(CONFIG_CDP_VERSION) \|\| defined(CONFIG_CDP_PLATFORM)
	116	char buf[32];
	117	#endif
	118
1203fcce	119	pkt = net_tx_packet;
cb487f56	120	et = (struct ethernet_hdr *)pkt;
f575ae1f JH	121
	122	/* NOTE: trigger sent not on any VLAN */
	123
	124	/* form ethernet header */
0adb5b76 JH	125	memcpy(et->et_dest, net_cdp_ethaddr, 6);
0adb5b76 JH	126	memcpy(et->et_src, net_ethaddr, 6);
f575ae1f JH	127
	128	pkt += ETHER_HDR_SIZE;
	129
	130	/* SNAP header */
6aede5b7 JH	131	memcpy((uchar *)pkt, cdp_snap_hdr, sizeof(cdp_snap_hdr));
6aede5b7 JH	132	pkt += sizeof(cdp_snap_hdr);
f575ae1f JH	133
	134	/* CDP header */
	135	pkt++ = 0x02; / CDP version 2 */
	136	pkt++ = 180; / TTL */
	137	s = (ushort *)pkt;
	138	cp = s;
	139	/* checksum (0 for later calculation) */
	140	*s++ = htons(0);
	141
	142	/* CDP fields */
	143	#ifdef CONFIG_CDP_DEVICE_ID
	144	*s++ = htons(CDP_DEVICE_ID_TLV);
	145	*s++ = htons(CONFIG_CDP_DEVICE_ID);
0adb5b76	146	sprintf(buf, CONFIG_CDP_DEVICE_ID_PREFIX "%pm", net_ethaddr);
f575ae1f JH	147	memcpy((uchar *)s, buf, 16);
	148	s += 16 / 2;
	149	#endif
	150
	151	#ifdef CONFIG_CDP_PORT_ID
	152	*s++ = htons(CDP_PORT_ID_TLV);
	153	memset(buf, 0, sizeof(buf));
	154	sprintf(buf, CONFIG_CDP_PORT_ID, eth_get_dev_index());
	155	len = strlen(buf);
	156	if (len & 1) /* make it even */
	157	len++;
	158	*s++ = htons(len + 4);
	159	memcpy((uchar *)s, buf, len);
	160	s += len / 2;
	161	#endif
	162
	163	#ifdef CONFIG_CDP_CAPABILITIES
	164	*s++ = htons(CDP_CAPABILITIES_TLV);
	165	*s++ = htons(8);
	166	(ulong )s = htonl(CONFIG_CDP_CAPABILITIES);
	167	s += 2;
	168	#endif
	169
	170	#ifdef CONFIG_CDP_VERSION
	171	*s++ = htons(CDP_VERSION_TLV);
	172	memset(buf, 0, sizeof(buf));
	173	strcpy(buf, CONFIG_CDP_VERSION);
	174	len = strlen(buf);
	175	if (len & 1) /* make it even */
	176	len++;
	177	*s++ = htons(len + 4);
	178	memcpy((uchar *)s, buf, len);
	179	s += len / 2;
	180	#endif
	181
	182	#ifdef CONFIG_CDP_PLATFORM
	183	*s++ = htons(CDP_PLATFORM_TLV);
	184	memset(buf, 0, sizeof(buf));
	185	strcpy(buf, CONFIG_CDP_PLATFORM);
	186	len = strlen(buf);
	187	if (len & 1) /* make it even */
	188	len++;
	189	*s++ = htons(len + 4);
	190	memcpy((uchar *)s, buf, len);
	191	s += len / 2;
	192	#endif
	193
	194	#ifdef CONFIG_CDP_TRIGGER
	195	*s++ = htons(CDP_TRIGGER_TLV);
	196	*s++ = htons(8);
	197	(ulong )s = htonl(CONFIG_CDP_TRIGGER);
	198	s += 2;
	199	#endif
	200
	201	#ifdef CONFIG_CDP_POWER_CONSUMPTION
	202	*s++ = htons(CDP_POWER_CONSUMPTION_TLV);
	203	*s++ = htons(6);
	204	*s++ = htons(CONFIG_CDP_POWER_CONSUMPTION);
	205	#endif
	206
	207	/* length of ethernet packet */
1203fcce	208	len = (uchar )s - ((uchar )net_tx_packet + ETHER_HDR_SIZE);
f575ae1f JH	209	et->et_protlen = htons(len);
f575ae1f JH	210
6aede5b7 JH	211	len = ETHER_HDR_SIZE + sizeof(cdp_snap_hdr);
6aede5b7 JH	212	chksum = cdp_compute_csum((uchar *)net_tx_packet + len,
1203fcce	213	(uchar *)s - (net_tx_packet + len));
f575ae1f JH	214	if (chksum == 0)
	215	chksum = 0xFFFF;
	216	*cp = htons(chksum);
	217
1203fcce	218	net_send_packet(net_tx_packet, (uchar *)s - net_tx_packet);
f575ae1f JH	219	return 0;
	220	}
	221
6aede5b7	222	static void cdp_timeout_handler(void)
f575ae1f	223	{
6aede5b7	224	cdp_seq++;
f575ae1f	225
6aede5b7	226	if (cdp_seq < 3) {
bc0571fc	227	net_set_timeout_handler(CDP_TIMEOUT, cdp_timeout_handler);
6aede5b7	228	cdp_send_trigger();
f575ae1f JH	229	return;
	230	}
	231
	232	/* if not OK try again */
6aede5b7	233	if (!cdp_ok)
bc0571fc	234	net_start_again();
f575ae1f	235	else
22f6e99d	236	net_set_state(NETLOOP_SUCCESS);
f575ae1f JH	237	}
f575ae1f JH	238
0b4c5ff4	239	void cdp_receive(const uchar *pkt, unsigned len)
f575ae1f JH	240	{
	241	const uchar *t;
	242	const ushort *ss;
	243	ushort type, tlen;
	244	ushort vlan, nvlan;
	245
	246	/* minimum size? */
6aede5b7	247	if (len < sizeof(cdp_snap_hdr) + 4)
f575ae1f JH	248	goto pkt_short;
	249
	250	/* check for valid CDP SNAP header */
6aede5b7	251	if (memcmp(pkt, cdp_snap_hdr, sizeof(cdp_snap_hdr)) != 0)
f575ae1f JH	252	return;
f575ae1f JH	253
6aede5b7 JH	254	pkt += sizeof(cdp_snap_hdr);
6aede5b7 JH	255	len -= sizeof(cdp_snap_hdr);
f575ae1f JH	256
	257	/* Version of CDP protocol must be >= 2 and TTL != 0 */
	258	if (pkt[0] < 0x02 \|\| pkt[1] == 0)
	259	return;
	260
	261	/*
	262	* if version is greater than 0x02 maybe we'll have a problem;
	263	* output a warning
	264	*/
	265	if (pkt[0] != 0x02)
	266	printf("**WARNING: CDP packet received with a protocol version "
	267	"%d > 2\n", pkt[0] & 0xff);
	268
6aede5b7	269	if (cdp_compute_csum(pkt, len) != 0)
f575ae1f JH	270	return;
	271
	272	pkt += 4;
	273	len -= 4;
	274
	275	vlan = htons(-1);
	276	nvlan = htons(-1);
	277	while (len > 0) {
	278	if (len < 4)
	279	goto pkt_short;
	280
	281	ss = (const ushort *)pkt;
	282	type = ntohs(ss[0]);
	283	tlen = ntohs(ss[1]);
	284	if (tlen > len)
	285	goto pkt_short;
	286
	287	pkt += tlen;
	288	len -= tlen;
	289
	290	ss += 2; /* point ss to the data of the TLV */
	291	tlen -= 4;
	292
	293	switch (type) {
	294	case CDP_DEVICE_ID_TLV:
	295	break;
	296	case CDP_ADDRESS_TLV:
	297	break;
	298	case CDP_PORT_ID_TLV:
	299	break;
	300	case CDP_CAPABILITIES_TLV:
	301	break;
	302	case CDP_VERSION_TLV:
	303	break;
	304	case CDP_PLATFORM_TLV:
	305	break;
	306	case CDP_NATIVE_VLAN_TLV:
	307	nvlan = *ss;
	308	break;
	309	case CDP_APPLIANCE_VLAN_TLV:
	310	t = (const uchar *)ss;
	311	while (tlen > 0) {
	312	if (tlen < 3)
	313	goto pkt_short;
	314
	315	ss = (const ushort *)(t + 1);
	316
	317	#ifdef CONFIG_CDP_APPLIANCE_VLAN_TYPE
	318	if (t[0] == CONFIG_CDP_APPLIANCE_VLAN_TYPE)
	319	vlan = *ss;
	320	#else
	321	/* XXX will this work; dunno */
	322	vlan = ntohs(*ss);
	323	#endif
	324	t += 3; tlen -= 3;
	325	}
	326	break;
	327	case CDP_TRIGGER_TLV:
	328	break;
	329	case CDP_POWER_CONSUMPTION_TLV:
	330	break;
	331	case CDP_SYSNAME_TLV:
	332	break;
	333	case CDP_SYSOBJECT_TLV:
334	break;
335	case CDP_MANAGEMENT_ADDRESS_TLV:
336	break;
337	}
338	}
339
6aede5b7 JH	340	cdp_appliance_vlan = vlan;
6aede5b7 JH	341	cdp_native_vlan = nvlan;
f575ae1f	342
6aede5b7	343	cdp_ok = 1;
f575ae1f JH	344	return;
f575ae1f JH	345
6aede5b7	346	pkt_short:
f575ae1f JH	347	printf("** CDP packet is too short\n");
	348	return;
	349	}
	350
6aede5b7	351	void cdp_start(void)
f575ae1f JH	352	{
f575ae1f JH	353	printf("Using %s device\n", eth_get_name());
6aede5b7 JH	354	cdp_seq = 0;
6aede5b7 JH	355	cdp_ok = 0;
f575ae1f	356
6aede5b7 JH	357	cdp_native_vlan = htons(-1);
6aede5b7 JH	358	cdp_appliance_vlan = htons(-1);
f575ae1f	359
bc0571fc	360	net_set_timeout_handler(CDP_TIMEOUT, cdp_timeout_handler);
f575ae1f	361
6aede5b7	362	cdp_send_trigger();
f575ae1f	363	}