[thirdparty/lldpd.git] / src / lldpd-structs.h

/* -*- mode: c; c-file-style: "openbsd" -*- */
/*
 * Copyright (c) 2008 Vincent Bernat <bernat@luffy.cx>
 *
 * Permission to use, copy, modify, and/or distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */

#ifndef _LLDPD_STRUCTS_H
#define _LLDPD_STRUCTS_H

#if HAVE_CONFIG_H
#  include <config.h>
#endif

#include <sys/types.h>
#include <sys/socket.h>

/* This is not very convenient, but we need net/if.h for IFNAMSIZ and others but
 * we may also need linux/if.h in some modules. And they conflict each others.
 */
#ifdef HOST_OS_LINUX
# include <linux/if.h>
#else
# include <net/if.h>
#endif

#include <netinet/in.h>
#include <netinet/if_ether.h>
#include <sys/queue.h>

#include "compat/compat.h"
#include "marshal.h"
#include "lldp-const.h"

#ifdef ENABLE_DOT1
struct lldpd_ppvid {
	TAILQ_ENTRY(lldpd_ppvid) p_entries;
	u_int8_t		p_cap_status;
	u_int16_t		p_ppvid;
};
MARSHAL_BEGIN(lldpd_ppvid)
MARSHAL_TQE(lldpd_ppvid, p_entries)
MARSHAL_END(lldpd_ppvid);

struct lldpd_vlan {
	TAILQ_ENTRY(lldpd_vlan)  v_entries;
	char			*v_name;
	u_int16_t		 v_vid;
};
MARSHAL_BEGIN(lldpd_vlan)
MARSHAL_TQE(lldpd_vlan, v_entries)
MARSHAL_STR(lldpd_vlan, v_name)
MARSHAL_END(lldpd_vlan);

struct lldpd_pi {
	TAILQ_ENTRY(lldpd_pi)  p_entries;
	char			*p_pi;
	int			 p_pi_len;
};
MARSHAL_BEGIN(lldpd_pi)
MARSHAL_TQE(lldpd_pi, p_entries)
MARSHAL_FSTR(lldpd_pi, p_pi, p_pi_len)
MARSHAL_END(lldpd_pi);
#endif

#ifdef ENABLE_LLDPMED
struct lldpd_med_policy {
	u_int8_t		 index; /* Not used. */
	u_int8_t		 type;
	u_int8_t		 unknown;
	u_int8_t		 tagged;
	u_int16_t		 vid;
	u_int8_t		 priority;
	u_int8_t		 dscp;
};
MARSHAL(lldpd_med_policy);

struct lldpd_med_loc {
	u_int8_t		 index; /* Not used. */
	u_int8_t		 format;
	char			*data;
	int			 data_len;
};
MARSHAL_BEGIN(lldpd_med_loc)
MARSHAL_FSTR(lldpd_med_loc, data, data_len)
MARSHAL_END(lldpd_med_loc);

struct lldpd_med_power {
	u_int8_t		 devicetype; /* PD or PSE */
	u_int8_t		 source;
	u_int8_t		 priority;
	u_int16_t		 val;
};
MARSHAL(lldpd_med_power);
#endif

#ifdef ENABLE_DOT3
struct lldpd_dot3_macphy {
	u_int8_t		 autoneg_support;
	u_int8_t		 autoneg_enabled;
	u_int16_t		 autoneg_advertised;
	u_int16_t		 mau_type;
};

struct lldpd_dot3_power {
	u_int8_t		devicetype;
	u_int8_t		supported;
	u_int8_t		enabled;
	u_int8_t		paircontrol;
	u_int8_t		pairs;
	u_int8_t		class;
	u_int8_t		powertype; /* If set to LLDP_DOT3_POWER_8023AT_OFF,
					      following fields have no meaning */
	u_int8_t		source;
	u_int8_t		priority;
	u_int16_t		requested;
	u_int16_t		allocated;
};
MARSHAL(lldpd_dot3_power);
#endif

enum {
	LLDPD_AF_UNSPEC = 0,
	LLDPD_AF_IPV4,
	LLDPD_AF_IPV6,
	LLDPD_AF_LAST
};

inline static int
lldpd_af(int af)
{
	switch (af) {
	case LLDPD_AF_IPV4: return AF_INET;
	case LLDPD_AF_IPV6: return AF_INET6;
	case LLDPD_AF_LAST: return AF_MAX;
	default: return AF_UNSPEC;
	}
}

#define LLDPD_MGMT_MAXADDRSIZE	16 /* sizeof(struct in6_addr) */
struct lldpd_mgmt {
	TAILQ_ENTRY(lldpd_mgmt) m_entries;
	int				m_family;
	union {
		struct in_addr		inet;
		struct in6_addr		inet6;
		u_int8_t		octets[LLDPD_MGMT_MAXADDRSIZE]; /* network byte order! */
	} m_addr;
	size_t 			m_addrsize;
	u_int32_t		m_iface;
};
MARSHAL_BEGIN(lldpd_mgmt)
MARSHAL_TQE(lldpd_mgmt, m_entries)
MARSHAL_END(lldpd_mgmt);

struct lldpd_chassis {
	TAILQ_ENTRY(lldpd_chassis) c_entries;
	u_int16_t		 c_refcount; /* Reference count by ports */
	u_int16_t		 c_index;    /* Monotonic index */
	u_int8_t		 c_protocol; /* Protocol used to get this chassis */
	u_int8_t	 	 c_id_subtype;
	char			*c_id;
	int			 c_id_len;
	char			*c_name;
	char			*c_descr;

	u_int16_t		 c_cap_available;
	u_int16_t		 c_cap_enabled;

	u_int16_t		 c_ttl;

	TAILQ_HEAD(, lldpd_mgmt) c_mgmt;

#ifdef ENABLE_LLDPMED
	u_int16_t		 c_med_cap_available;
	u_int8_t		 c_med_type;
	char			*c_med_hw;
	char			*c_med_fw;
	char			*c_med_sw;
	char			*c_med_sn;
	char			*c_med_manuf;
	char			*c_med_model;
	char			*c_med_asset;
#endif

};
/* WARNING: any change to this structure should also be reflected into
   `lldpd_copy_chassis()` which is not using marshaling. */
MARSHAL_BEGIN(lldpd_chassis)
MARSHAL_IGNORE(lldpd_chassis, c_entries.tqe_next)
MARSHAL_IGNORE(lldpd_chassis, c_entries.tqe_prev)
MARSHAL_FSTR(lldpd_chassis, c_id, c_id_len)
MARSHAL_STR(lldpd_chassis, c_name)
MARSHAL_STR(lldpd_chassis, c_descr)
MARSHAL_SUBTQ(lldpd_chassis, lldpd_mgmt, c_mgmt)
#ifdef ENABLE_LLDPMED
MARSHAL_STR(lldpd_chassis, c_med_hw)
MARSHAL_STR(lldpd_chassis, c_med_fw)
MARSHAL_STR(lldpd_chassis, c_med_sw)
MARSHAL_STR(lldpd_chassis, c_med_sn)
MARSHAL_STR(lldpd_chassis, c_med_manuf)
MARSHAL_STR(lldpd_chassis, c_med_model)
MARSHAL_STR(lldpd_chassis, c_med_asset)
#endif
MARSHAL_END(lldpd_chassis);

#ifdef ENABLE_CUSTOM
/* Custom TLV struct as defined on page 35 of IEEE 802.1AB-2005 */
struct lldpd_custom {
	TAILQ_ENTRY(lldpd_custom)	next;	/* Pointer to next custom TLV */

	/* Organizationally Unique Identifier */
	u_int8_t		oui[LLDP_TLV_ORG_OUI_LEN];
	/* Organizationally Defined Subtype */
	u_int8_t		subtype;
	/* Organizationally Defined Information String */
	u_int8_t		*oui_info;
	/* Organizationally Defined Information String length */
	int			oui_info_len;
};
MARSHAL_BEGIN(lldpd_custom)
MARSHAL_TQE(lldpd_custom, next)
MARSHAL_FSTR(lldpd_custom, oui_info, oui_info_len)
MARSHAL_END(lldpd_custom);
#endif

struct lldpd_port {
	TAILQ_ENTRY(lldpd_port)	 p_entries;
	struct lldpd_chassis	*p_chassis;    /* Attached chassis */
	time_t			 p_lastchange; /* Time of last change of values */
	time_t			 p_lastupdate; /* Time of last update received */
	struct lldpd_frame	*p_lastframe;  /* Frame received during last update */
	u_int8_t		 p_protocol;   /* Protocol used to get this port */
	u_int8_t		 p_hidden_in:1; /* Considered as hidden for reception */
	u_int8_t		 p_hidden_out:2; /* Considered as hidden for emission */
	u_int8_t		 p_disable_rx:3; /* Should RX be disabled for this port? */
	u_int8_t		 p_disable_tx:4; /* Should TX be disabled for this port? */
	/* Important: all fields that should be ignored to check if a port has
	 * been changed should be before this mark. */
#define LLDPD_PORT_START_MARKER (offsetof(struct lldpd_port, p_id_subtype))
	int			 _p_hardware_flags; /* This is a copy of hardware flags. Do not use it! */
	u_int8_t		 p_id_subtype;
	char			*p_id;
	int			 p_id_len;
	char			*p_descr;
	u_int16_t		 p_mfs;

#ifdef ENABLE_DOT3
	/* Dot3 stuff */
	u_int32_t		 p_aggregid;
	struct lldpd_dot3_macphy p_macphy;
	struct lldpd_dot3_power	 p_power;
#endif

#ifdef ENABLE_LLDPMED
	u_int16_t		 p_med_cap_enabled;
	struct lldpd_med_policy	 p_med_policy[LLDP_MED_APPTYPE_LAST];
	struct lldpd_med_loc	 p_med_location[LLDP_MED_LOCFORMAT_LAST];
	struct lldpd_med_power	 p_med_power;
#endif

#ifdef ENABLE_DOT1
	u_int16_t		 p_pvid;
	TAILQ_HEAD(, lldpd_vlan) p_vlans;
	TAILQ_HEAD(, lldpd_ppvid) p_ppvids;
	TAILQ_HEAD(, lldpd_pi)	  p_pids;
#endif
#ifdef ENABLE_CUSTOM
	TAILQ_HEAD(, lldpd_custom) p_custom_list;
#endif
};
MARSHAL_BEGIN(lldpd_port)
MARSHAL_TQE(lldpd_port, p_entries)
MARSHAL_POINTER(lldpd_port, lldpd_chassis, p_chassis)
MARSHAL_IGNORE(lldpd_port, p_lastframe)
MARSHAL_FSTR(lldpd_port, p_id, p_id_len)
MARSHAL_STR(lldpd_port, p_descr)
#ifdef ENABLE_LLDPMED
MARSHAL_SUBSTRUCT(lldpd_port, lldpd_med_loc, p_med_location[0])
MARSHAL_SUBSTRUCT(lldpd_port, lldpd_med_loc, p_med_location[1])
MARSHAL_SUBSTRUCT(lldpd_port, lldpd_med_loc, p_med_location[2])
#endif
#ifdef ENABLE_DOT1
MARSHAL_SUBTQ(lldpd_port, lldpd_vlan, p_vlans)
MARSHAL_SUBTQ(lldpd_port, lldpd_ppvid, p_ppvids)
MARSHAL_SUBTQ(lldpd_port, lldpd_pi, p_pids)
#endif
#ifdef ENABLE_CUSTOM
MARSHAL_SUBTQ(lldpd_port, lldpd_custom, p_custom_list)
#endif
MARSHAL_END(lldpd_port);

/* Used to modify some port related settings */
#define LLDPD_RXTX_UNCHANGED 0
#define LLDPD_RXTX_TXONLY 1
#define LLDPD_RXTX_RXONLY 2
#define LLDPD_RXTX_DISABLED 3
#define LLDPD_RXTX_BOTH 4
#define LLDPD_RXTX_FROM_PORT(p) (((p)->p_disable_rx && (p)->p_disable_tx)?LLDPD_RXTX_DISABLED: \
	    ((p)->p_disable_rx && !(p)->p_disable_tx)?LLDPD_RXTX_TXONLY:	\
	    (!(p)->p_disable_rx && (p)->p_disable_tx)?LLDPD_RXTX_RXONLY:	\
	    LLDPD_RXTX_BOTH)
#define LLDPD_RXTX_RXENABLED(v) ((v) == LLDPD_RXTX_RXONLY || (v) == LLDPD_RXTX_BOTH)
#define LLDPD_RXTX_TXENABLED(v) ((v) == LLDPD_RXTX_TXONLY || (v) == LLDPD_RXTX_BOTH)
struct lldpd_port_set {
	char *ifname;
	char *local_id;
	char *local_descr;
	int rxtx;
#ifdef ENABLE_LLDPMED
	struct lldpd_med_policy *med_policy;
	struct lldpd_med_loc    *med_location;
	struct lldpd_med_power  *med_power;
#endif
#ifdef ENABLE_DOT3
	struct lldpd_dot3_power *dot3_power;
#endif
#ifdef ENABLE_CUSTOM
	struct lldpd_custom     *custom;
	int custom_list_clear;
#endif
};
MARSHAL_BEGIN(lldpd_port_set)
MARSHAL_STR(lldpd_port_set, ifname)
MARSHAL_STR(lldpd_port_set, local_id)
MARSHAL_STR(lldpd_port_set, local_descr)
#ifdef ENABLE_LLDPMED
MARSHAL_POINTER(lldpd_port_set, lldpd_med_policy, med_policy)
MARSHAL_POINTER(lldpd_port_set, lldpd_med_loc,    med_location)
MARSHAL_POINTER(lldpd_port_set, lldpd_med_power,  med_power)
#endif
#ifdef ENABLE_DOT3
MARSHAL_POINTER(lldpd_port_set, lldpd_dot3_power, dot3_power)
#endif
#ifdef ENABLE_CUSTOM
MARSHAL_POINTER(lldpd_port_set, lldpd_custom,     custom)
#endif
MARSHAL_END(lldpd_port_set);

/* Smart mode / Hide mode */
#define SMART_INCOMING_FILTER		(1<<0) /* Incoming filtering enabled */
#define SMART_INCOMING_ONE_PROTO	(1<<1) /* On reception, keep only one proto */
#define SMART_INCOMING_ONE_NEIGH	(1<<2) /* On reception, keep only one neighbor */
#define SMART_OUTGOING_FILTER		(1<<3) /* Outgoing filtering enabled */
#define SMART_OUTGOING_ONE_PROTO	(1<<4) /* On emission, keep only one proto */
#define SMART_OUTGOING_ONE_NEIGH	(1<<5) /* On emission, consider only one neighbor */
#define SMART_INCOMING (SMART_INCOMING_FILTER |    \
			 SMART_INCOMING_ONE_PROTO | \
			 SMART_INCOMING_ONE_NEIGH)
#define SMART_OUTGOING (SMART_OUTGOING_FILTER |		\
			SMART_OUTGOING_ONE_PROTO |	\
			SMART_OUTGOING_ONE_NEIGH)

struct lldpd_config {
	int c_paused;	        /* lldpd is paused */
	int c_tx_interval;	/* Transmit interval */
	int c_smart;		/* Bitmask for smart configuration (see SMART_*) */
	int c_receiveonly;	/* Receive only mode */
	int c_max_neighbors;	/* Maximum number of neighbors (per protocol) */

	char *c_mgmt_pattern;	/* Pattern to match a management address */
	char *c_cid_pattern;	/* Pattern to match interfaces to use for chassis ID */
	char *c_iface_pattern;	/* Pattern to match interfaces to use */

	char *c_platform;	/* Override platform description (for CDP) */
	char *c_description;	/* Override chassis description */
	char *c_hostname;	/* Override system name */
	int c_advertise_version; /* Should the precise version be advertised? */
	int c_set_ifdescr;	 /* Set interface description */
	int c_promisc;		 /* Interfaces should be in promiscuous mode */
	int c_cap_advertise;	 /* Chassis capabilities advertisement */
	int c_mgmt_advertise;	 /* Management addresses advertisement */

#ifdef ENABLE_LLDPMED
	int c_noinventory;	/* Don't send inventory with LLDP-MED */
	int c_enable_fast_start; /* enable fast start */
	int c_tx_fast_init;	/* Num of lldpd lldppdu's for fast start */
	int c_tx_fast_interval;	/* Time intr between sends during fast start */
#endif
	int c_tx_hold;		/* Transmit hold */
	int c_bond_slave_src_mac_type; /* Src mac type in lldp frames over bond
					  slaves */
	int c_lldp_portid_type; /* The PortID type */
};
MARSHAL_BEGIN(lldpd_config)
MARSHAL_STR(lldpd_config, c_mgmt_pattern)
MARSHAL_STR(lldpd_config, c_cid_pattern)
MARSHAL_STR(lldpd_config, c_iface_pattern)
MARSHAL_STR(lldpd_config, c_hostname)
MARSHAL_STR(lldpd_config, c_platform)
MARSHAL_STR(lldpd_config, c_description)
MARSHAL_END(lldpd_config);

struct lldpd_frame {
	int size;
	unsigned char frame[1];
};

struct lldpd_hardware;
struct lldpd;
struct lldpd_ops {
	int(*send)(struct lldpd *,
		   struct lldpd_hardware*,
		   char *, size_t); /* Function to send a frame */
	int(*recv)(struct lldpd *,
		   struct lldpd_hardware*,
		   int, char *, size_t); /* Function to receive a frame */
	int(*cleanup)(struct lldpd *, struct lldpd_hardware *); /* Cleanup function. */
};

/* An interface is uniquely identified by h_ifindex, h_ifname and h_ops. This
 * means if an interface becomes enslaved, it will be considered as a new
 * interface. The same applies for renaming and we include the index in case of
 * renaming to an existing interface. */
struct lldpd_hardware {
	TAILQ_ENTRY(lldpd_hardware)	 h_entries;

	struct lldpd		*h_cfg;	    /* Pointer to main configuration */
	void			*h_recv;    /* FD for reception */
	int			 h_sendfd;  /* FD for sending, only used by h_ops */
	int			 h_mangle;  /* 1 if we have to mangle the MAC address */
	struct lldpd_ops	*h_ops;	    /* Hardware-dependent functions */
	void			*h_data;    /* Hardware-dependent data */
	void			*h_timer;   /* Timer for this port */

	int			 h_mtu;
	int			 h_flags; /* Packets will be sent only
					     if IFF_RUNNING. Will be
					     removed if this is left
					     to 0. */
	int			 h_ifindex; /* Interface index, used by SNMP */
	char			 h_ifname[IFNAMSIZ]; /* Should be unique */
	u_int8_t		 h_lladdr[ETHER_ADDR_LEN];

	u_int64_t		 h_tx_cnt;
	u_int64_t		 h_rx_cnt;
	u_int64_t		 h_rx_discarded_cnt;
	u_int64_t		 h_rx_unrecognized_cnt;
	u_int64_t		 h_ageout_cnt;
	u_int64_t		 h_insert_cnt;
	u_int64_t		 h_delete_cnt;
	u_int64_t		 h_drop_cnt;

	/* Previous values of different stuff. */
	/* Backup of the previous local port. Used to check if there was a
	 * change to send an immediate update. All those are not marshalled to
	 * the client. */
	void			*h_lport_previous;
	ssize_t			 h_lport_previous_len;
	/* Backup of the previous chassis ID. Used to check if there was a
	 * change and send an LLDP shutdown. */
	u_int8_t	 	 h_lchassis_previous_id_subtype;
	char			*h_lchassis_previous_id;
	int			 h_lchassis_previous_id_len;
	/* Backup of the previous port ID. Used to check if there was a change
	 * and send an LLDP shutdown. */
	u_int8_t		 h_lport_previous_id_subtype;
	char			*h_lport_previous_id;
	int			 h_lport_previous_id_len;

	struct lldpd_port	 h_lport;  /* Port attached to this hardware port */
	TAILQ_HEAD(, lldpd_port) h_rports; /* Remote ports */

#ifdef ENABLE_LLDPMED
	int			h_tx_fast; /* current tx fast start count */
#endif
};
MARSHAL_BEGIN(lldpd_hardware)
MARSHAL_IGNORE(lldpd_hardware, h_entries.tqe_next)
MARSHAL_IGNORE(lldpd_hardware, h_entries.tqe_prev)
MARSHAL_IGNORE(lldpd_hardware, h_ops)
MARSHAL_IGNORE(lldpd_hardware, h_data)
MARSHAL_IGNORE(lldpd_hardware, h_cfg)
MARSHAL_IGNORE(lldpd_hardware, h_lport_previous)
MARSHAL_IGNORE(lldpd_hardware, h_lport_previous_len)
MARSHAL_IGNORE(lldpd_hardware, h_lchassis_previous_id_subtype)
MARSHAL_IGNORE(lldpd_hardware, h_lchassis_previous_id)
MARSHAL_IGNORE(lldpd_hardware, h_lchassis_previous_id_len)
MARSHAL_IGNORE(lldpd_hardware, h_lport_previous_id_subtype)
MARSHAL_IGNORE(lldpd_hardware, h_lport_previous_id)
MARSHAL_IGNORE(lldpd_hardware, h_lport_previous_id_len)
MARSHAL_SUBSTRUCT(lldpd_hardware, lldpd_port, h_lport)
MARSHAL_SUBTQ(lldpd_hardware, lldpd_port, h_rports)
MARSHAL_END(lldpd_hardware);

struct lldpd_interface {
	TAILQ_ENTRY(lldpd_interface) next;
	char			*name;
};
MARSHAL_BEGIN(lldpd_interface)
MARSHAL_TQE(lldpd_interface, next)
MARSHAL_STR(lldpd_interface, name)
MARSHAL_END(lldpd_interface);
TAILQ_HEAD(lldpd_interface_list, lldpd_interface);
MARSHAL_TQ(lldpd_interface_list, lldpd_interface);

struct lldpd_neighbor_change {
	char *ifname;
#define NEIGHBOR_CHANGE_DELETED -1
#define NEIGHBOR_CHANGE_ADDED    1
#define NEIGHBOR_CHANGE_UPDATED  0
	int state;
	struct lldpd_port *neighbor;
};
MARSHAL_BEGIN(lldpd_neighbor_change)
MARSHAL_STR(lldpd_neighbor_change, ifname)
MARSHAL_POINTER(lldpd_neighbor_change, lldpd_port, neighbor)
MARSHAL_END(lldpd_neighbor_change);

/* Cleanup functions */
void	 lldpd_chassis_mgmt_cleanup(struct lldpd_chassis *);
void	 lldpd_chassis_cleanup(struct lldpd_chassis *, int);
void	 lldpd_remote_cleanup(struct lldpd_hardware *,
    void(*expire)(struct lldpd_hardware *, struct lldpd_port *),
    int);
void	 lldpd_port_cleanup(struct lldpd_port *, int);
void	 lldpd_config_cleanup(struct lldpd_config *);
#ifdef ENABLE_DOT1
void	 lldpd_ppvid_cleanup(struct lldpd_port *);
void	 lldpd_vlan_cleanup(struct lldpd_port *);
void	 lldpd_pi_cleanup(struct lldpd_port *);
#endif
#ifdef ENABLE_CUSTOM
void     lldpd_custom_list_cleanup(struct lldpd_port *);
#endif

#endif
Commit	Line	Data
4b292b55	1	/* -- mode: c; c-file-style: "openbsd" -- */
43c02e7b VB	2	/*
	3	* Copyright (c) 2008 Vincent Bernat <bernat@luffy.cx>
	4	*
51434125	5	* Permission to use, copy, modify, and/or distribute this software for any
43c02e7b VB	6	* purpose with or without fee is hereby granted, provided that the above
	7	* copyright notice and this permission notice appear in all copies.
	8	*
	9	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	10	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	11	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	12	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	13	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	14	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	15	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	16	*/
	17
4b292b55 VB	18	#ifndef _LLDPD_STRUCTS_H
4b292b55 VB	19	#define _LLDPD_STRUCTS_H
43c02e7b VB	20
43c02e7b VB	21	#if HAVE_CONFIG_H
d38eae28	22	# include <config.h>
43c02e7b VB	23	#endif
43c02e7b VB	24
4b292b55 VB	25	#include <sys/types.h>
4b292b55 VB	26	#include <sys/socket.h>
e12c2365 VB	27
	28	/* This is not very convenient, but we need net/if.h for IFNAMSIZ and others but
	29	* we may also need linux/if.h in some modules. And they conflict each others.
	30	*/
	31	#ifdef HOST_OS_LINUX
	32	# include <linux/if.h>
43c02e7b	33	#else
e12c2365	34	# include <net/if.h>
43c02e7b	35	#endif
e12c2365	36
43c02e7b	37	#include <netinet/in.h>
21a48c64	38	#include <netinet/if_ether.h>
4b292b55	39	#include <sys/queue.h>
43c02e7b	40
4b292b55	41	#include "compat/compat.h"
db323555	42	#include "marshal.h"
4b292b55	43	#include "lldp-const.h"
43c02e7b	44
a1347cd8	45	#ifdef ENABLE_DOT1
9757bfbc SK	46	struct lldpd_ppvid {
	47	TAILQ_ENTRY(lldpd_ppvid) p_entries;
	48	u_int8_t p_cap_status;
	49	u_int16_t p_ppvid;
	50	};
f6d20631 VB	51	MARSHAL_BEGIN(lldpd_ppvid)
f6d20631 VB	52	MARSHAL_TQE(lldpd_ppvid, p_entries)
985a4cb5	53	MARSHAL_END(lldpd_ppvid);
9757bfbc	54
43c02e7b VB	55	struct lldpd_vlan {
	56	TAILQ_ENTRY(lldpd_vlan) v_entries;
	57	char *v_name;
	58	u_int16_t v_vid;
	59	};
f6d20631 VB	60	MARSHAL_BEGIN(lldpd_vlan)
	61	MARSHAL_TQE(lldpd_vlan, v_entries)
	62	MARSHAL_STR(lldpd_vlan, v_name)
985a4cb5	63	MARSHAL_END(lldpd_vlan);
9757bfbc SK	64
	65	struct lldpd_pi {
	66	TAILQ_ENTRY(lldpd_pi) p_entries;
	67	char *p_pi;
48acfcaf	68	int p_pi_len;
9757bfbc	69	};
f6d20631 VB	70	MARSHAL_BEGIN(lldpd_pi)
	71	MARSHAL_TQE(lldpd_pi, p_entries)
	72	MARSHAL_FSTR(lldpd_pi, p_pi, p_pi_len)
985a4cb5	73	MARSHAL_END(lldpd_pi);
a1347cd8	74	#endif
43c02e7b	75
e3a44efb	76	#ifdef ENABLE_LLDPMED
e3a44efb	77	struct lldpd_med_policy {
4b292b55	78	u_int8_t index; /* Not used. */
e3a44efb VB	79	u_int8_t type;
	80	u_int8_t unknown;
	81	u_int8_t tagged;
	82	u_int16_t vid;
	83	u_int8_t priority;
	84	u_int8_t dscp;
e3a44efb	85	};
f6d20631	86	MARSHAL(lldpd_med_policy);
e3a44efb	87
e3a44efb	88	struct lldpd_med_loc {
4b292b55	89	u_int8_t index; /* Not used. */
e3a44efb VB	90	u_int8_t format;
	91	char *data;
	92	int data_len;
e3a44efb	93	};
f6d20631 VB	94	MARSHAL_BEGIN(lldpd_med_loc)
f6d20631 VB	95	MARSHAL_FSTR(lldpd_med_loc, data, data_len)
985a4cb5	96	MARSHAL_END(lldpd_med_loc);
6d08df0e	97
6d08df0e VB	98	struct lldpd_med_power {
	99	u_int8_t devicetype; /* PD or PSE */
	100	u_int8_t source;
	101	u_int8_t priority;
	102	u_int16_t val;
	103	};
f6d20631	104	MARSHAL(lldpd_med_power);
e3a44efb VB	105	#endif
e3a44efb VB	106
3fd015c0	107	#ifdef ENABLE_DOT3
3fd015c0 VB	108	struct lldpd_dot3_macphy {
	109	u_int8_t autoneg_support;
	110	u_int8_t autoneg_enabled;
	111	u_int16_t autoneg_advertised;
	112	u_int16_t mau_type;
	113	};
befbdf89	114
befbdf89 VB	115	struct lldpd_dot3_power {
	116	u_int8_t devicetype;
	117	u_int8_t supported;
	118	u_int8_t enabled;
	119	u_int8_t paircontrol;
	120	u_int8_t pairs;
	121	u_int8_t class;
608cb51c VB	122	u_int8_t powertype; /* If set to LLDP_DOT3_POWER_8023AT_OFF,
	123	following fields have no meaning */
	124	u_int8_t source;
	125	u_int8_t priority;
	126	u_int16_t requested;
	127	u_int16_t allocated;
befbdf89	128	};
f6d20631	129	MARSHAL(lldpd_dot3_power);
3fd015c0 VB	130	#endif
3fd015c0 VB	131
f15d3950 VB	132	enum {
	133	LLDPD_AF_UNSPEC = 0,
	134	LLDPD_AF_IPV4,
	135	LLDPD_AF_IPV6,
	136	LLDPD_AF_LAST
	137	};
	138
	139	inline static int
	140	lldpd_af(int af)
	141	{
	142	switch (af) {
4b292b55 VB	143	case LLDPD_AF_IPV4: return AF_INET;
	144	case LLDPD_AF_IPV6: return AF_INET6;
	145	case LLDPD_AF_LAST: return AF_MAX;
	146	default: return AF_UNSPEC;
f15d3950 VB	147	}
	148	}
	149
e6b36c87 JV	150	#define LLDPD_MGMT_MAXADDRSIZE 16 /* sizeof(struct in6_addr) */
	151	struct lldpd_mgmt {
	152	TAILQ_ENTRY(lldpd_mgmt) m_entries;
	153	int m_family;
	154	union {
	155	struct in_addr inet;
	156	struct in6_addr inet6;
6d3c1ce0	157	u_int8_t octets[LLDPD_MGMT_MAXADDRSIZE]; /* network byte order! */
e6b36c87 JV	158	} m_addr;
	159	size_t m_addrsize;
	160	u_int32_t m_iface;
	161	};
	162	MARSHAL_BEGIN(lldpd_mgmt)
	163	MARSHAL_TQE(lldpd_mgmt, m_entries)
985a4cb5	164	MARSHAL_END(lldpd_mgmt);
e6b36c87	165
43c02e7b	166	struct lldpd_chassis {
75068724 VB	167	TAILQ_ENTRY(lldpd_chassis) c_entries;
	168	u_int16_t c_refcount; /* Reference count by ports */
	169	u_int16_t c_index; /* Monotonic index */
	170	u_int8_t c_protocol; /* Protocol used to get this chassis */
43c02e7b VB	171	u_int8_t c_id_subtype;
	172	char *c_id;
	173	int c_id_len;
	174	char *c_name;
	175	char *c_descr;
	176
	177	u_int16_t c_cap_available;
	178	u_int16_t c_cap_enabled;
	179
	180	u_int16_t c_ttl;
	181
e6b36c87	182	TAILQ_HEAD(, lldpd_mgmt) c_mgmt;
89840df0 VB	183
89840df0 VB	184	#ifdef ENABLE_LLDPMED
40ecae87	185	u_int16_t c_med_cap_available;
89840df0 VB	186	u_int8_t c_med_type;
	187	char *c_med_hw;
	188	char *c_med_fw;
	189	char *c_med_sw;
	190	char *c_med_sn;
	191	char *c_med_manuf;
	192	char *c_med_model;
	193	char *c_med_asset;
89840df0	194	#endif
1531f7f3 VB	195
1531f7f3 VB	196	};
d938c51f VB	197	/* WARNING: any change to this structure should also be reflected into
d938c51f VB	198	`lldpd_copy_chassis()` which is not using marshaling. */
f6d20631	199	MARSHAL_BEGIN(lldpd_chassis)
74e0080e VB	200	MARSHAL_IGNORE(lldpd_chassis, c_entries.tqe_next)
74e0080e VB	201	MARSHAL_IGNORE(lldpd_chassis, c_entries.tqe_prev)
f6d20631 VB	202	MARSHAL_FSTR(lldpd_chassis, c_id, c_id_len)
	203	MARSHAL_STR(lldpd_chassis, c_name)
	204	MARSHAL_STR(lldpd_chassis, c_descr)
e6b36c87	205	MARSHAL_SUBTQ(lldpd_chassis, lldpd_mgmt, c_mgmt)
f6d20631 VB	206	#ifdef ENABLE_LLDPMED
	207	MARSHAL_STR(lldpd_chassis, c_med_hw)
	208	MARSHAL_STR(lldpd_chassis, c_med_fw)
	209	MARSHAL_STR(lldpd_chassis, c_med_sw)
	210	MARSHAL_STR(lldpd_chassis, c_med_sn)
	211	MARSHAL_STR(lldpd_chassis, c_med_manuf)
	212	MARSHAL_STR(lldpd_chassis, c_med_model)
	213	MARSHAL_STR(lldpd_chassis, c_med_asset)
	214	#endif
985a4cb5	215	MARSHAL_END(lldpd_chassis);
f6d20631	216
fb1b78bb	217	#ifdef ENABLE_CUSTOM
cd5de7a2 AA	218	/* Custom TLV struct as defined on page 35 of IEEE 802.1AB-2005 */
	219	struct lldpd_custom {
	220	TAILQ_ENTRY(lldpd_custom) next; /* Pointer to next custom TLV */
	221
	222	/* Organizationally Unique Identifier */
	223	u_int8_t oui[LLDP_TLV_ORG_OUI_LEN];
	224	/* Organizationally Defined Subtype */
	225	u_int8_t subtype;
5427983b	226	/* Organizationally Defined Information String */
8caf4341	227	u_int8_t *oui_info;
cd5de7a2 AA	228	/* Organizationally Defined Information String length */
	229	int oui_info_len;
	230	};
	231	MARSHAL_BEGIN(lldpd_custom)
	232	MARSHAL_TQE(lldpd_custom, next)
8caf4341	233	MARSHAL_FSTR(lldpd_custom, oui_info, oui_info_len)
cd5de7a2	234	MARSHAL_END(lldpd_custom);
fb1b78bb	235	#endif
43c02e7b VB	236
43c02e7b VB	237	struct lldpd_port {
75068724 VB	238	TAILQ_ENTRY(lldpd_port) p_entries;
	239	struct lldpd_chassis p_chassis; / Attached chassis */
	240	time_t p_lastchange; /* Time of last change of values */
	241	time_t p_lastupdate; /* Time of last update received */
	242	struct lldpd_frame p_lastframe; / Frame received during last update */
	243	u_int8_t p_protocol; /* Protocol used to get this port */
579bedd5 VB	244	u_int8_t p_hidden_in:1; /* Considered as hidden for reception */
579bedd5 VB	245	u_int8_t p_hidden_out:2; /* Considered as hidden for emission */
e7331ce9 VB	246	u_int8_t p_disable_rx:3; /* Should RX be disabled for this port? */
e7331ce9 VB	247	u_int8_t p_disable_tx:4; /* Should TX be disabled for this port? */
579bedd5	248	/* Important: all fields that should be ignored to check if a port has
28414fbd VB	249	* been changed should be before this mark. */
28414fbd VB	250	#define LLDPD_PORT_START_MARKER (offsetof(struct lldpd_port, p_id_subtype))
196757ce	251	int _p_hardware_flags; /* This is a copy of hardware flags. Do not use it! */
43c02e7b VB	252	u_int8_t p_id_subtype;
	253	char *p_id;
	254	int p_id_len;
	255	char *p_descr;
548109b2	256	u_int16_t p_mfs;
43c02e7b	257
a1347cd8	258	#ifdef ENABLE_DOT3
43c02e7b VB	259	/* Dot3 stuff */
43c02e7b VB	260	u_int32_t p_aggregid;
3fd015c0	261	struct lldpd_dot3_macphy p_macphy;
befbdf89	262	struct lldpd_dot3_power p_power;
a1347cd8	263	#endif
1531f7f3	264
740593ff	265	#ifdef ENABLE_LLDPMED
740593ff	266	u_int16_t p_med_cap_enabled;
4b292b55 VB	267	struct lldpd_med_policy p_med_policy[LLDP_MED_APPTYPE_LAST];
4b292b55 VB	268	struct lldpd_med_loc p_med_location[LLDP_MED_LOCFORMAT_LAST];
6d08df0e	269	struct lldpd_med_power p_med_power;
740593ff VB	270	#endif
740593ff VB	271
a1347cd8	272	#ifdef ENABLE_DOT1
75b3469d	273	u_int16_t p_pvid;
1531f7f3	274	TAILQ_HEAD(, lldpd_vlan) p_vlans;
9757bfbc SK	275	TAILQ_HEAD(, lldpd_ppvid) p_ppvids;
9757bfbc SK	276	TAILQ_HEAD(, lldpd_pi) p_pids;
a1347cd8	277	#endif
fb1b78bb	278	#ifdef ENABLE_CUSTOM
cd5de7a2	279	TAILQ_HEAD(, lldpd_custom) p_custom_list;
fb1b78bb	280	#endif
1531f7f3	281	};
f6d20631 VB	282	MARSHAL_BEGIN(lldpd_port)
	283	MARSHAL_TQE(lldpd_port, p_entries)
	284	MARSHAL_POINTER(lldpd_port, lldpd_chassis, p_chassis)
	285	MARSHAL_IGNORE(lldpd_port, p_lastframe)
	286	MARSHAL_FSTR(lldpd_port, p_id, p_id_len)
	287	MARSHAL_STR(lldpd_port, p_descr)
	288	#ifdef ENABLE_LLDPMED
	289	MARSHAL_SUBSTRUCT(lldpd_port, lldpd_med_loc, p_med_location[0])
	290	MARSHAL_SUBSTRUCT(lldpd_port, lldpd_med_loc, p_med_location[1])
	291	MARSHAL_SUBSTRUCT(lldpd_port, lldpd_med_loc, p_med_location[2])
	292	#endif
	293	#ifdef ENABLE_DOT1
	294	MARSHAL_SUBTQ(lldpd_port, lldpd_vlan, p_vlans)
	295	MARSHAL_SUBTQ(lldpd_port, lldpd_ppvid, p_ppvids)
	296	MARSHAL_SUBTQ(lldpd_port, lldpd_pi, p_pids)
	297	#endif
fb1b78bb	298	#ifdef ENABLE_CUSTOM
cd5de7a2	299	MARSHAL_SUBTQ(lldpd_port, lldpd_custom, p_custom_list)
fb1b78bb	300	#endif
985a4cb5	301	MARSHAL_END(lldpd_port);
1531f7f3	302
f6d20631	303	/* Used to modify some port related settings */
e7331ce9 VB	304	#define LLDPD_RXTX_UNCHANGED 0
	305	#define LLDPD_RXTX_TXONLY 1
	306	#define LLDPD_RXTX_RXONLY 2
	307	#define LLDPD_RXTX_DISABLED 3
	308	#define LLDPD_RXTX_BOTH 4
	309	#define LLDPD_RXTX_FROM_PORT(p) (((p)->p_disable_rx && (p)->p_disable_tx)?LLDPD_RXTX_DISABLED: \
	310	((p)->p_disable_rx && !(p)->p_disable_tx)?LLDPD_RXTX_TXONLY: \
	311	(!(p)->p_disable_rx && (p)->p_disable_tx)?LLDPD_RXTX_RXONLY: \
	312	LLDPD_RXTX_BOTH)
	313	#define LLDPD_RXTX_RXENABLED(v) ((v) == LLDPD_RXTX_RXONLY \|\| (v) == LLDPD_RXTX_BOTH)
	314	#define LLDPD_RXTX_TXENABLED(v) ((v) == LLDPD_RXTX_TXONLY \|\| (v) == LLDPD_RXTX_BOTH)
f6d20631 VB	315	struct lldpd_port_set {
f6d20631 VB	316	char *ifname;
8e46010c	317	char *local_id;
c267d0f2	318	char *local_descr;
e7331ce9	319	int rxtx;
f6d20631 VB	320	#ifdef ENABLE_LLDPMED
	321	struct lldpd_med_policy *med_policy;
	322	struct lldpd_med_loc *med_location;
	323	struct lldpd_med_power *med_power;
	324	#endif
	325	#ifdef ENABLE_DOT3
	326	struct lldpd_dot3_power *dot3_power;
	327	#endif
fb1b78bb	328	#ifdef ENABLE_CUSTOM
41cb7781 AA	329	struct lldpd_custom *custom;
41cb7781 AA	330	int custom_list_clear;
fb1b78bb	331	#endif
f6d20631 VB	332	};
	333	MARSHAL_BEGIN(lldpd_port_set)
	334	MARSHAL_STR(lldpd_port_set, ifname)
8e46010c	335	MARSHAL_STR(lldpd_port_set, local_id)
c267d0f2	336	MARSHAL_STR(lldpd_port_set, local_descr)
f6d20631 VB	337	#ifdef ENABLE_LLDPMED
	338	MARSHAL_POINTER(lldpd_port_set, lldpd_med_policy, med_policy)
	339	MARSHAL_POINTER(lldpd_port_set, lldpd_med_loc, med_location)
	340	MARSHAL_POINTER(lldpd_port_set, lldpd_med_power, med_power)
	341	#endif
	342	#ifdef ENABLE_DOT3
	343	MARSHAL_POINTER(lldpd_port_set, lldpd_dot3_power, dot3_power)
	344	#endif
fb1b78bb	345	#ifdef ENABLE_CUSTOM
41cb7781	346	MARSHAL_POINTER(lldpd_port_set, lldpd_custom, custom)
fb1b78bb	347	#endif
985a4cb5	348	MARSHAL_END(lldpd_port_set);
43c02e7b	349
8ec333bd VB	350	/* Smart mode / Hide mode */
	351	#define SMART_INCOMING_FILTER (1<<0) /* Incoming filtering enabled */
	352	#define SMART_INCOMING_ONE_PROTO (1<<1) /* On reception, keep only one proto */
	353	#define SMART_INCOMING_ONE_NEIGH (1<<2) /* On reception, keep only one neighbor */
	354	#define SMART_OUTGOING_FILTER (1<<3) /* Outgoing filtering enabled */
	355	#define SMART_OUTGOING_ONE_PROTO (1<<4) /* On emission, keep only one proto */
	356	#define SMART_OUTGOING_ONE_NEIGH (1<<5) /* On emission, consider only one neighbor */
	357	#define SMART_INCOMING (SMART_INCOMING_FILTER \| \
	358	SMART_INCOMING_ONE_PROTO \| \
	359	SMART_INCOMING_ONE_NEIGH)
	360	#define SMART_OUTGOING (SMART_OUTGOING_FILTER \| \
	361	SMART_OUTGOING_ONE_PROTO \| \
	362	SMART_OUTGOING_ONE_NEIGH)
	363
	364	struct lldpd_config {
e4ff3ed5	365	int c_paused; /* lldpd is paused */
8843f168	366	int c_tx_interval; /* Transmit interval */
8ec333bd VB	367	int c_smart; /* Bitmask for smart configuration (see SMART_) /
8ec333bd VB	368	int c_receiveonly; /* Receive only mode */
42589660	369	int c_max_neighbors; /* Maximum number of neighbors (per protocol) */
8ec333bd VB	370
	371	char c_mgmt_pattern; / Pattern to match a management address */
	372	char c_cid_pattern; / Pattern to match interfaces to use for chassis ID */
	373	char c_iface_pattern; / Pattern to match interfaces to use */
	374
	375	char c_platform; / Override platform description (for CDP) */
	376	char c_description; / Override chassis description */
ce347d29	377	char c_hostname; / Override system name */
8ec333bd	378	int c_advertise_version; /* Should the precise version be advertised? */
bb37268d	379	int c_set_ifdescr; /* Set interface description */
f84199dd	380	int c_promisc; /* Interfaces should be in promiscuous mode */
ca838758	381	int c_cap_advertise; /* Chassis capabilities advertisement */
1c2217aa	382	int c_mgmt_advertise; /* Management addresses advertisement */
8ec333bd VB	383
	384	#ifdef ENABLE_LLDPMED
	385	int c_noinventory; /* Don't send inventory with LLDP-MED */
b9de0ca6	386	int c_enable_fast_start; /* enable fast start */
	387	int c_tx_fast_init; /* Num of lldpd lldppdu's for fast start */
	388	int c_tx_fast_interval; /* Time intr between sends during fast start */
be511d00	389	#endif
c10302a3	390	int c_tx_hold; /* Transmit hold */
dfbd7185 RP	391	int c_bond_slave_src_mac_type; /* Src mac type in lldp frames over bond
dfbd7185 RP	392	slaves */
8fbd3195	393	int c_lldp_portid_type; /* The PortID type */
8ec333bd VB	394	};
	395	MARSHAL_BEGIN(lldpd_config)
	396	MARSHAL_STR(lldpd_config, c_mgmt_pattern)
	397	MARSHAL_STR(lldpd_config, c_cid_pattern)
	398	MARSHAL_STR(lldpd_config, c_iface_pattern)
ce347d29	399	MARSHAL_STR(lldpd_config, c_hostname)
8ec333bd VB	400	MARSHAL_STR(lldpd_config, c_platform)
8ec333bd VB	401	MARSHAL_STR(lldpd_config, c_description)
985a4cb5	402	MARSHAL_END(lldpd_config);
8ec333bd	403
43c02e7b VB	404	struct lldpd_frame {
43c02e7b VB	405	int size;
b5c7ce8d	406	unsigned char frame[1];
43c02e7b VB	407	};
43c02e7b VB	408
6e75df87 VB	409	struct lldpd_hardware;
	410	struct lldpd;
	411	struct lldpd_ops {
	412	int(send)(struct lldpd ,
	413	struct lldpd_hardware*,
	414	char , size_t); / Function to send a frame */
	415	int(recv)(struct lldpd ,
	416	struct lldpd_hardware*,
	417	int, char , size_t); / Function to receive a frame */
	418	int(cleanup)(struct lldpd , struct lldpd_hardware ); / Cleanup function. */
	419	};
	420
44002d66 VB	421	/* An interface is uniquely identified by h_ifindex, h_ifname and h_ops. This
	422	* means if an interface becomes enslaved, it will be considered as a new
	423	* interface. The same applies for renaming and we include the index in case of
	424	* renaming to an existing interface. */
43c02e7b VB	425	struct lldpd_hardware {
	426	TAILQ_ENTRY(lldpd_hardware) h_entries;
	427
d6e889b6 VB	428	struct lldpd h_cfg; / Pointer to main configuration */
d6e889b6 VB	429	void h_recv; / FD for reception */
6e75df87	430	int h_sendfd; /* FD for sending, only used by h_ops */
5347914e	431	int h_mangle; /* 1 if we have to mangle the MAC address */
6e75df87 VB	432	struct lldpd_ops h_ops; / Hardware-dependent functions */
6e75df87 VB	433	void h_data; / Hardware-dependent data */
579bedd5	434	void h_timer; / Timer for this port */
43c02e7b	435
43c02e7b	436	int h_mtu;
6e75df87 VB	437	int h_flags; /* Packets will be sent only
	438	if IFF_RUNNING. Will be
	439	removed if this is left
	440	to 0. */
	441	int h_ifindex; /* Interface index, used by SNMP */
	442	char h_ifname[IFNAMSIZ]; /* Should be unique */
43c02e7b VB	443	u_int8_t h_lladdr[ETHER_ADDR_LEN];
	444
	445	u_int64_t h_tx_cnt;
	446	u_int64_t h_rx_cnt;
	447	u_int64_t h_rx_discarded_cnt;
37387046	448	u_int64_t h_rx_unrecognized_cnt;
14052b61 VB	449	u_int64_t h_ageout_cnt;
	450	u_int64_t h_insert_cnt;
	451	u_int64_t h_delete_cnt;
42589660	452	u_int64_t h_drop_cnt;
43c02e7b	453
acb5f65b VB	454	/* Previous values of different stuff. */
	455	/* Backup of the previous local port. Used to check if there was a
	456	* change to send an immediate update. All those are not marshalled to
	457	* the client. */
	458	void *h_lport_previous;
17d34115	459	ssize_t h_lport_previous_len;
acb5f65b VB	460	/* Backup of the previous chassis ID. Used to check if there was a
	461	* change and send an LLDP shutdown. */
	462	u_int8_t h_lchassis_previous_id_subtype;
	463	char *h_lchassis_previous_id;
	464	int h_lchassis_previous_id_len;
	465	/* Backup of the previous port ID. Used to check if there was a change
	466	* and send an LLDP shutdown. */
	467	u_int8_t h_lport_previous_id_subtype;
	468	char *h_lport_previous_id;
	469	int h_lport_previous_id_len;
	470
75068724 VB	471	struct lldpd_port h_lport; /* Port attached to this hardware port */
75068724 VB	472	TAILQ_HEAD(, lldpd_port) h_rports; /* Remote ports */
b9de0ca6	473
be511d00	474	#ifdef ENABLE_LLDPMED
b9de0ca6	475	int h_tx_fast; /* current tx fast start count */
be511d00	476	#endif
43c02e7b	477	};
f6d20631 VB	478	MARSHAL_BEGIN(lldpd_hardware)
	479	MARSHAL_IGNORE(lldpd_hardware, h_entries.tqe_next)
	480	MARSHAL_IGNORE(lldpd_hardware, h_entries.tqe_prev)
	481	MARSHAL_IGNORE(lldpd_hardware, h_ops)
	482	MARSHAL_IGNORE(lldpd_hardware, h_data)
d6e889b6	483	MARSHAL_IGNORE(lldpd_hardware, h_cfg)
b1785ed5 VB	484	MARSHAL_IGNORE(lldpd_hardware, h_lport_previous)
b1785ed5 VB	485	MARSHAL_IGNORE(lldpd_hardware, h_lport_previous_len)
acb5f65b VB	486	MARSHAL_IGNORE(lldpd_hardware, h_lchassis_previous_id_subtype)
	487	MARSHAL_IGNORE(lldpd_hardware, h_lchassis_previous_id)
	488	MARSHAL_IGNORE(lldpd_hardware, h_lchassis_previous_id_len)
	489	MARSHAL_IGNORE(lldpd_hardware, h_lport_previous_id_subtype)
	490	MARSHAL_IGNORE(lldpd_hardware, h_lport_previous_id)
	491	MARSHAL_IGNORE(lldpd_hardware, h_lport_previous_id_len)
f6d20631 VB	492	MARSHAL_SUBSTRUCT(lldpd_hardware, lldpd_port, h_lport)
f6d20631 VB	493	MARSHAL_SUBTQ(lldpd_hardware, lldpd_port, h_rports)
985a4cb5	494	MARSHAL_END(lldpd_hardware);
43c02e7b VB	495
	496	struct lldpd_interface {
	497	TAILQ_ENTRY(lldpd_interface) next;
	498	char *name;
	499	};
f6d20631 VB	500	MARSHAL_BEGIN(lldpd_interface)
	501	MARSHAL_TQE(lldpd_interface, next)
	502	MARSHAL_STR(lldpd_interface, name)
985a4cb5	503	MARSHAL_END(lldpd_interface);
f6d20631 VB	504	TAILQ_HEAD(lldpd_interface_list, lldpd_interface);
f6d20631 VB	505	MARSHAL_TQ(lldpd_interface_list, lldpd_interface);
43c02e7b	506
4e90a9e0 VB	507	struct lldpd_neighbor_change {
	508	char *ifname;
	509	#define NEIGHBOR_CHANGE_DELETED -1
	510	#define NEIGHBOR_CHANGE_ADDED 1
	511	#define NEIGHBOR_CHANGE_UPDATED 0
	512	int state;
	513	struct lldpd_port *neighbor;
	514	};
	515	MARSHAL_BEGIN(lldpd_neighbor_change)
	516	MARSHAL_STR(lldpd_neighbor_change, ifname)
	517	MARSHAL_POINTER(lldpd_neighbor_change, lldpd_port, neighbor)
985a4cb5	518	MARSHAL_END(lldpd_neighbor_change);
4e90a9e0	519
4b292b55 VB	520	/* Cleanup functions */
	521	void lldpd_chassis_mgmt_cleanup(struct lldpd_chassis *);
	522	void lldpd_chassis_cleanup(struct lldpd_chassis *, int);
4e90a9e0	523	void lldpd_remote_cleanup(struct lldpd_hardware *,
ef3707da VB	524	void(expire)(struct lldpd_hardware , struct lldpd_port *),
ef3707da VB	525	int);
4b292b55	526	void lldpd_port_cleanup(struct lldpd_port *, int);
8ec333bd	527	void lldpd_config_cleanup(struct lldpd_config *);
a1347cd8	528	#ifdef ENABLE_DOT1
9757bfbc	529	void lldpd_ppvid_cleanup(struct lldpd_port *);
43c02e7b	530	void lldpd_vlan_cleanup(struct lldpd_port *);
9757bfbc	531	void lldpd_pi_cleanup(struct lldpd_port *);
a1347cd8	532	#endif
fb1b78bb	533	#ifdef ENABLE_CUSTOM
cd5de7a2	534	void lldpd_custom_list_cleanup(struct lldpd_port *);
fb1b78bb	535	#endif
6e75df87	536
0265b1e5	537	#endif