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

/*
 * Copyright (c) 2008 Vincent Bernat <bernat@luffy.cx>
 *
 * Permission to use, copy, modify, and 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_H
#define _LLDPD_H

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

#define _GNU_SOURCE 1
#include <stdlib.h>
#include <string.h>
#include <sys/queue.h>
#ifndef INCLUDE_LINUX_IF_H
#include <net/if.h>
#else
#include <arpa/inet.h>
#include <linux/if.h>
#endif
#include <ifaddrs.h>
#include <net/ethernet.h>
#include <netinet/in.h>
#include <linux/ethtool.h>

#include "compat.h"
#include "lldp.h"
#if defined (ENABLE_CDP) || defined (ENABLE_FDP)
#include "cdp.h"
#endif
#ifdef ENABLE_SONMP
#include "sonmp.h"
#endif
#ifdef ENABLE_EDP
#include "edp.h"
#endif

#define SYSFS_CLASS_NET "/sys/class/net/"
#define SYSFS_CLASS_DMI "/sys/class/dmi/id/"
#define LLDPD_TTL		120
#define LLDPD_TX_DELAY		30
#define LLDPD_TX_MSGDELAY	1
#define LLDPD_CTL_SOCKET	"/var/run/lldpd.socket"
#define LLDPD_PID_FILE		"/var/run/lldpd.pid"

#define UNIX_PATH_MAX	108

#define USING_AGENTX_SUBAGENT_MODULE 1

#ifdef ENABLE_DOT1
struct lldpd_vlan {
	TAILQ_ENTRY(lldpd_vlan)  v_entries;
	char			*v_name;
	u_int16_t		 v_vid;
};
#define STRUCT_LLDPD_VLAN "(Lsw)"
#endif

#ifdef ENABLE_LLDPMED
#define STRUCT_LLDPD_MED_POLICY "(bbbwbb)"
struct lldpd_med_policy {
	u_int8_t		 type;
	u_int8_t		 unknown;
	u_int8_t		 tagged;
	u_int16_t		 vid;
	u_int8_t		 priority;
	u_int8_t		 dscp;
};

#define STRUCT_LLDPD_MED_LOC "(bC)"
struct lldpd_med_loc {
	u_int8_t		 format;
	char			*data;
	int			 data_len;
};
#endif

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;

	struct in_addr		 c_mgmt;
	u_int32_t		 c_mgmt_if;

#ifdef ENABLE_LLDPMED
#define STRUCT_LLDPD_CHASSIS_MED "wbsssssss"
	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;
#else
#define STRUCT_LLDPD_CHASSIS_MED ""
#endif

};
#define STRUCT_LLDPD_CHASSIS "(LwwbbCsswwwll" STRUCT_LLDPD_CHASSIS_MED ")"

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_id_subtype;
	char			*p_id;
	int			 p_id_len;
	char			*p_descr;
	u_int16_t		 p_mfs;

#ifdef ENABLE_DOT3
#define STRUCT_LLDPD_PORT_DOT3 "lbbww"
	/* Dot3 stuff */
	u_int32_t		 p_aggregid;
	u_int8_t		 p_autoneg_support;
	u_int8_t		 p_autoneg_enabled;
	u_int16_t		 p_autoneg_advertised;
	u_int16_t		 p_mau_type;
#else
#define STRUCT_LLDPD_PORT_DOT3 ""
#endif

#ifdef ENABLE_LLDPMED
#define STRUCT_LLDPD_PORT_MED "w"      \
	STRUCT_LLDPD_MED_POLICY	       \
	STRUCT_LLDPD_MED_POLICY	       \
	STRUCT_LLDPD_MED_POLICY	       \
	STRUCT_LLDPD_MED_POLICY	       \
	STRUCT_LLDPD_MED_POLICY	       \
	STRUCT_LLDPD_MED_POLICY	       \
	STRUCT_LLDPD_MED_POLICY	       \
	STRUCT_LLDPD_MED_POLICY	       \
	STRUCT_LLDPD_MED_LOC	       \
	STRUCT_LLDPD_MED_LOC	       \
	STRUCT_LLDPD_MED_LOC	       \
	"bbbw"
	u_int16_t		 p_med_cap_enabled;
	struct lldpd_med_policy	 p_med_policy[LLDPMED_APPTYPE_LAST];
	struct lldpd_med_loc	 p_med_location[LLDPMED_LOCFORMAT_LAST];
	u_int8_t		 p_med_pow_devicetype; /* PD or PSE */
	u_int8_t		 p_med_pow_source;
	u_int8_t		 p_med_pow_priority;
	u_int16_t		 p_med_pow_val;
#else
#define STRUCT_LLDPD_PORT_MED ""
#endif

#ifdef ENABLE_DOT1
#define STRUCT_LLDPD_PORT_DOT1 "wPP"
	u_int16_t		 p_pvid;
	TAILQ_HEAD(, lldpd_vlan) p_vlans;
#else
#define STRUCT_LLDPD_PORT_DOT1 ""
#endif
};

#define STRUCT_LLDPD_PORT "(LPttPbbCsw"				\
	STRUCT_LLDPD_PORT_DOT3					\
	STRUCT_LLDPD_PORT_MED					\
	STRUCT_LLDPD_PORT_DOT1 ")"

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

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;

	fd_set			 h_recvfds; /* FD for reception */
	int			 h_sendfd;  /* FD for sending, only used by h_ops */
	struct lldpd_ops	*h_ops;	    /* Hardware-dependent functions */
	void			*h_data;    /* Hardware-dependent data */

	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_ageout_cnt;
	u_int64_t		 h_rx_unrecognized_cnt;

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

struct lldpd_interface {
	TAILQ_ENTRY(lldpd_interface) next;
	char			*name;
};
#define STRUCT_LLDPD_INTERFACE "(Ls)"

#define PROTO_SEND_SIG struct lldpd *, struct lldpd_hardware *
#define PROTO_DECODE_SIG struct lldpd *, char *, int, struct lldpd_hardware *, struct lldpd_chassis **, struct lldpd_port **
#define PROTO_GUESS_SIG char *, int

struct protocol {
#define LLDPD_MODE_LLDP 1
#define LLDPD_MODE_CDPV1 2
#define LLDPD_MODE_CDPV2 3
#define LLDPD_MODE_SONMP 4
#define LLDPD_MODE_EDP 5
#define LLDPD_MODE_FDP 6
	int		 mode;		/* > 0 mode identifier (unique per protocol) */
	int		 enabled;	/* Is this protocol enabled? */
	char		*name;		/* Name of protocol */
	char		 arg;		/* Argument to enable this protocol */
	int(*send)(PROTO_SEND_SIG);	/* How to send a frame */
	int(*decode)(PROTO_DECODE_SIG); /* How to decode a frame */
	int(*guess)(PROTO_GUESS_SIG);   /* Can be NULL, use MAC address in this case */
	u_int8_t	 mac[ETH_ALEN];  /* Destination MAC address used by this protocol */
	struct sock_filter *filter;	/* BPF filter */
	size_t		 filterlen;	/* Size of BPF filter */
};

#define CALLBACK_SIG struct lldpd*, struct lldpd_callback*
struct lldpd_callback {
	TAILQ_ENTRY(lldpd_callback) next;
	int	 fd;	      /* FD that will trigger this callback */
	void(*function)(CALLBACK_SIG); /* Function called */
	void	*data;		/* Optional data for this callback*/
};

struct lldpd {
	int			 g_sock;
	int			 g_delay;

	struct protocol		*g_protocols;
#ifdef ENABLE_LISTENVLAN
	int			 g_listen_vlans;
#endif
#ifdef ENABLE_LLDPMED
	int			 g_noinventory;
#endif

	time_t			 g_lastsent;
	int			 g_lastrid;
#ifdef USE_SNMP
	int			 g_snmp;
#endif /* USE_SNMP */

	/* Unix socket handling */
	int			 g_ctl;

	TAILQ_HEAD(, lldpd_callback) g_callbacks;

	char			*g_mgmt_pattern;

#define LOCAL_CHASSIS(cfg) ((struct lldpd_chassis *)(TAILQ_FIRST(&cfg->g_chassis)))
	TAILQ_HEAD(, lldpd_chassis) g_chassis;
	TAILQ_HEAD(, lldpd_hardware) g_hardware;
};

typedef void(*lldpd_ifhandlers)(struct lldpd *, struct ifaddrs *);

enum hmsg_type {
	HMSG_NONE,
	HMSG_GET_INTERFACES,
	HMSG_GET_NB_PORTS,
	HMSG_GET_PORT,
	HMSG_GET_CHASSIS,
	HMSG_GET_VLANS,
	HMSG_SET_LOCATION,
	HMSG_SHUTDOWN
};

struct hmsg_hdr {
	enum hmsg_type	 type;
	int16_t		 len;
	pid_t		 pid;
} __attribute__ ((__packed__));

struct hmsg {
	struct hmsg_hdr	 hdr;
	void		*data;
} __attribute__ ((__packed__));

#define HMSG_HEADER_SIZE	sizeof(struct hmsg_hdr)
#define MAX_HMSGSIZE		8192

/* lldpd.c */
struct lldpd_hardware	*lldpd_get_hardware(struct lldpd *,
    char *, int, struct lldpd_ops *);
struct lldpd_hardware	*lldpd_alloc_hardware(struct lldpd *, char *);
void	 lldpd_hardware_cleanup(struct lldpd*, struct lldpd_hardware *);
#ifdef ENABLE_DOT1
void	 lldpd_vlan_cleanup(struct lldpd_port *);
#endif
void	 lldpd_remote_cleanup(struct lldpd *, struct lldpd_hardware *, int);
void	 lldpd_port_cleanup(struct lldpd_port *, int);
void	 lldpd_chassis_cleanup(struct lldpd_chassis *, int);
int	 lldpd_callback_add(struct lldpd *, int, void(*fn)(CALLBACK_SIG), void *);
void	 lldpd_callback_del(struct lldpd *, int, void(*fn)(CALLBACK_SIG));

/* lldp.c */
int	 lldp_send(PROTO_SEND_SIG);
int	 lldp_decode(PROTO_DECODE_SIG);

/* cdp.c */
#ifdef ENABLE_CDP
int	 cdpv1_send(PROTO_SEND_SIG);
int	 cdpv2_send(PROTO_SEND_SIG);
int	 cdpv1_guess(PROTO_GUESS_SIG);
int	 cdpv2_guess(PROTO_GUESS_SIG);
#endif
#if defined (ENABLE_CDP) || defined (ENABLE_FDP)
int	 cdp_decode(PROTO_DECODE_SIG);
#endif
#ifdef ENABLE_FDP
int	 fdp_send(PROTO_SEND_SIG);
#endif

#ifdef ENABLE_SONMP
/* sonmp.c */
int	 sonmp_send(PROTO_SEND_SIG);
int	 sonmp_decode(PROTO_DECODE_SIG);
#endif

#ifdef ENABLE_EDP
/* edp.c */
int	 edp_send(PROTO_SEND_SIG);
int	 edp_decode(PROTO_DECODE_SIG);
#endif

/* ctl.c */
int	 ctl_create(char *);
int	 ctl_connect(char *);
void	 ctl_cleanup(char *);
#ifndef CLIENT_ONLY
void	 ctl_accept(struct lldpd *, struct lldpd_callback *);
#endif
void	 ctl_msg_init(struct hmsg *, enum hmsg_type);
int	 ctl_msg_send(int, struct hmsg *);
int	 ctl_msg_recv(int, struct hmsg *);
int	 ctl_msg_pack_list(char *, void *, unsigned int, struct hmsg *, void **);
int	 ctl_msg_unpack_list(char *, void *, unsigned int, struct hmsg *, void **);
int	 ctl_msg_pack_structure(char *, void *, unsigned int, struct hmsg *, void **);
int	 ctl_msg_unpack_structure(char *, void *, unsigned int, struct hmsg *, void **);

/* interfaces.c */
void	 lldpd_ifh_bond(struct lldpd *, struct ifaddrs *);
void	 lldpd_ifh_eth(struct lldpd *, struct ifaddrs *);
#ifdef ENABLE_DOT1
void	 lldpd_ifh_vlan(struct lldpd *, struct ifaddrs *);
#endif
void	 lldpd_ifh_mgmt(struct lldpd *, struct ifaddrs *);

/* dmi.c */
#ifdef ENABLE_LLDPMED
char	*dmi_hw();
char	*dmi_fw();
char	*dmi_sn();
char	*dmi_manuf();
char	*dmi_model();
char	*dmi_asset();
#endif

/* log.c */
void             log_init(int);
void             log_warn(const char *, ...);
#define LLOG_WARN(x,...) log_warn("%s: " x, __FUNCTION__, ##__VA_ARGS__)
void             log_warnx(const char *, ...);
#define LLOG_WARNX(x,...) log_warnx("%s: " x,  __FUNCTION__, ##__VA_ARGS__)
void             log_info(const char *, ...);
#define LLOG_INFO(x,...) log_info("%s: " x, __FUNCTION__, ##__VA_ARGS__)
void             log_debug(const char *, ...);
#define LLOG_DEBUG(x,...) log_debug("%s: " x, __FUNCTION__, ##__VA_ARGS__)
void             fatal(const char *);
void             fatalx(const char *);

/* agent.c */
void		 agent_shutdown();
void		 agent_init(struct lldpd *, int);

/* agent_priv.c */
void		 agent_priv_register_domain();

/* strlcpy.c */
size_t	strlcpy(char *, const char *, size_t);

/* client.c */
struct client_handle {
	enum hmsg_type type;
	void (*handle)(struct lldpd*, struct hmsg*, struct hmsg*);
};

void	 client_handle_client(struct lldpd *, struct lldpd_callback *,
    char *, int);
void	 client_handle_none(struct lldpd *, struct hmsg *,
	    struct hmsg *);
void	 client_handle_get_interfaces(struct lldpd *, struct hmsg *,
	    struct hmsg *);
void	 client_handle_port_related(struct lldpd *, struct hmsg *,
	    struct hmsg *);
void	 client_handle_shutdown(struct lldpd *, struct hmsg *,
	    struct hmsg *);

/* priv.c */
void	 priv_init(char*);
int 	 priv_ctl_create();
void	 priv_ctl_cleanup();
char   	*priv_gethostbyname();
int    	 priv_open(char*);
int    	 priv_ethtool(char*, struct ethtool_cmd*);
int    	 priv_iface_init(const char *);
int	 priv_iface_multicast(const char *, u_int8_t *, int);
int	 priv_snmp_socket(struct sockaddr_un *);

/* privsep_fdpass.c */
int	 receive_fd(int);
void	 send_fd(int, int);

#endif /* _LLDPD_H */
Commit	Line	Data
43c02e7b VB	1	/*
	2	* Copyright (c) 2008 Vincent Bernat <bernat@luffy.cx>
	3	*
	4	* Permission to use, copy, modify, and distribute this software for any
	5	* purpose with or without fee is hereby granted, provided that the above
	6	* copyright notice and this permission notice appear in all copies.
	7	*
	8	* THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
	9	* WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
	10	* MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
	11	* ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
	12	* WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
	13	* ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
	14	* OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
	15	*/
	16
	17	#ifndef _LLDPD_H
	18	#define _LLDPD_H
	19
	20	#if HAVE_CONFIG_H
	21	#include <config.h>
	22	#endif
	23
	24	#define _GNU_SOURCE 1
	25	#include <stdlib.h>
	26	#include <string.h>
	27	#include <sys/queue.h>
	28	#ifndef INCLUDE_LINUX_IF_H
	29	#include <net/if.h>
	30	#else
	31	#include <arpa/inet.h>
	32	#include <linux/if.h>
	33	#endif
6e75df87	34	#include <ifaddrs.h>
43c02e7b VB	35	#include <net/ethernet.h>
43c02e7b VB	36	#include <netinet/in.h>
4afe659e	37	#include <linux/ethtool.h>
43c02e7b VB	38
	39	#include "compat.h"
	40	#include "lldp.h"
4bad1937	41	#if defined (ENABLE_CDP) \|\| defined (ENABLE_FDP)
43c02e7b	42	#include "cdp.h"
4bad1937 VB	43	#endif
4bad1937 VB	44	#ifdef ENABLE_SONMP
43c02e7b	45	#include "sonmp.h"
4bad1937 VB	46	#endif
4bad1937 VB	47	#ifdef ENABLE_EDP
43c02e7b	48	#include "edp.h"
4bad1937	49	#endif
43c02e7b	50
89840df0 VB	51	#define SYSFS_CLASS_NET "/sys/class/net/"
89840df0 VB	52	#define SYSFS_CLASS_DMI "/sys/class/dmi/id/"
43c02e7b VB	53	#define LLDPD_TTL 120
	54	#define LLDPD_TX_DELAY 30
	55	#define LLDPD_TX_MSGDELAY 1
	56	#define LLDPD_CTL_SOCKET "/var/run/lldpd.socket"
	57	#define LLDPD_PID_FILE "/var/run/lldpd.pid"
	58
	59	#define UNIX_PATH_MAX 108
	60
	61	#define USING_AGENTX_SUBAGENT_MODULE 1
	62
a1347cd8	63	#ifdef ENABLE_DOT1
43c02e7b VB	64	struct lldpd_vlan {
	65	TAILQ_ENTRY(lldpd_vlan) v_entries;
	66	char *v_name;
	67	u_int16_t v_vid;
	68	};
0c8f36f3	69	#define STRUCT_LLDPD_VLAN "(Lsw)"
a1347cd8	70	#endif
43c02e7b	71
e3a44efb	72	#ifdef ENABLE_LLDPMED
0c8f36f3	73	#define STRUCT_LLDPD_MED_POLICY "(bbbwbb)"
e3a44efb VB	74	struct lldpd_med_policy {
	75	u_int8_t type;
	76	u_int8_t unknown;
	77	u_int8_t tagged;
	78	u_int16_t vid;
	79	u_int8_t priority;
	80	u_int8_t dscp;
e3a44efb VB	81	};
e3a44efb VB	82
0c8f36f3	83	#define STRUCT_LLDPD_MED_LOC "(bC)"
e3a44efb VB	84	struct lldpd_med_loc {
	85	u_int8_t format;
	86	char *data;
	87	int data_len;
e3a44efb VB	88	};
	89	#endif
	90
43c02e7b	91	struct lldpd_chassis {
75068724 VB	92	TAILQ_ENTRY(lldpd_chassis) c_entries;
	93	u_int16_t c_refcount; /* Reference count by ports */
	94	u_int16_t c_index; /* Monotonic index */
	95	u_int8_t c_protocol; /* Protocol used to get this chassis */
43c02e7b VB	96	u_int8_t c_id_subtype;
	97	char *c_id;
	98	int c_id_len;
	99	char *c_name;
	100	char *c_descr;
	101
	102	u_int16_t c_cap_available;
	103	u_int16_t c_cap_enabled;
	104
	105	u_int16_t c_ttl;
	106
	107	struct in_addr c_mgmt;
	108	u_int32_t c_mgmt_if;
89840df0 VB	109
89840df0 VB	110	#ifdef ENABLE_LLDPMED
34602f3b	111	#define STRUCT_LLDPD_CHASSIS_MED "wbsssssss"
40ecae87	112	u_int16_t c_med_cap_available;
89840df0 VB	113	u_int8_t c_med_type;
	114	char *c_med_hw;
	115	char *c_med_fw;
	116	char *c_med_sw;
	117	char *c_med_sn;
	118	char *c_med_manuf;
	119	char *c_med_model;
	120	char *c_med_asset;
89840df0	121	#else
a1347cd8	122	#define STRUCT_LLDPD_CHASSIS_MED ""
89840df0	123	#endif
1531f7f3 VB	124
1531f7f3 VB	125	};
75068724	126	#define STRUCT_LLDPD_CHASSIS "(LwwbbCsswwwll" STRUCT_LLDPD_CHASSIS_MED ")"
43c02e7b VB	127
43c02e7b VB	128	struct lldpd_port {
75068724 VB	129	TAILQ_ENTRY(lldpd_port) p_entries;
	130	struct lldpd_chassis p_chassis; / Attached chassis */
	131	time_t p_lastchange; /* Time of last change of values */
	132	time_t p_lastupdate; /* Time of last update received */
	133	struct lldpd_frame p_lastframe; / Frame received during last update */
	134	u_int8_t p_protocol; /* Protocol used to get this port */
43c02e7b VB	135	u_int8_t p_id_subtype;
	136	char *p_id;
	137	int p_id_len;
	138	char *p_descr;
548109b2	139	u_int16_t p_mfs;
43c02e7b	140
a1347cd8	141	#ifdef ENABLE_DOT3
1531f7f3	142	#define STRUCT_LLDPD_PORT_DOT3 "lbbww"
43c02e7b VB	143	/* Dot3 stuff */
	144	u_int32_t p_aggregid;
	145	u_int8_t p_autoneg_support;
	146	u_int8_t p_autoneg_enabled;
	147	u_int16_t p_autoneg_advertised;
	148	u_int16_t p_mau_type;
a1347cd8 VB	149	#else
	150	#define STRUCT_LLDPD_PORT_DOT3 ""
	151	#endif
1531f7f3	152
740593ff VB	153	#ifdef ENABLE_LLDPMED
	154	#define STRUCT_LLDPD_PORT_MED "w" \
	155	STRUCT_LLDPD_MED_POLICY \
	156	STRUCT_LLDPD_MED_POLICY \
	157	STRUCT_LLDPD_MED_POLICY \
	158	STRUCT_LLDPD_MED_POLICY \
	159	STRUCT_LLDPD_MED_POLICY \
	160	STRUCT_LLDPD_MED_POLICY \
	161	STRUCT_LLDPD_MED_POLICY \
	162	STRUCT_LLDPD_MED_POLICY \
	163	STRUCT_LLDPD_MED_LOC \
	164	STRUCT_LLDPD_MED_LOC \
	165	STRUCT_LLDPD_MED_LOC \
	166	"bbbw"
	167	u_int16_t p_med_cap_enabled;
	168	struct lldpd_med_policy p_med_policy[LLDPMED_APPTYPE_LAST];
	169	struct lldpd_med_loc p_med_location[LLDPMED_LOCFORMAT_LAST];
	170	u_int8_t p_med_pow_devicetype; /* PD or PSE */
	171	u_int8_t p_med_pow_source;
	172	u_int8_t p_med_pow_priority;
	173	u_int16_t p_med_pow_val;
	174	#else
	175	#define STRUCT_LLDPD_PORT_MED ""
	176	#endif
	177
a1347cd8	178	#ifdef ENABLE_DOT1
75b3469d VB	179	#define STRUCT_LLDPD_PORT_DOT1 "wPP"
75b3469d VB	180	u_int16_t p_pvid;
1531f7f3	181	TAILQ_HEAD(, lldpd_vlan) p_vlans;
a1347cd8 VB	182	#else
	183	#define STRUCT_LLDPD_PORT_DOT1 ""
	184	#endif
1531f7f3 VB	185	};
1531f7f3 VB	186
84853b92	187	#define STRUCT_LLDPD_PORT "(LPttPbbCsw" \
740593ff VB	188	STRUCT_LLDPD_PORT_DOT3 \
	189	STRUCT_LLDPD_PORT_MED \
	190	STRUCT_LLDPD_PORT_DOT1 ")"
43c02e7b VB	191
	192	struct lldpd_frame {
	193	int size;
	194	unsigned char frame[];
	195	};
	196
6e75df87 VB	197	struct lldpd_hardware;
	198	struct lldpd;
	199	struct lldpd_ops {
	200	int(send)(struct lldpd ,
	201	struct lldpd_hardware*,
	202	char , size_t); / Function to send a frame */
	203	int(recv)(struct lldpd ,
	204	struct lldpd_hardware*,
	205	int, char , size_t); / Function to receive a frame */
	206	int(cleanup)(struct lldpd , struct lldpd_hardware ); / Cleanup function. */
	207	};
	208
44002d66 VB	209	/* An interface is uniquely identified by h_ifindex, h_ifname and h_ops. This
	210	* means if an interface becomes enslaved, it will be considered as a new
	211	* interface. The same applies for renaming and we include the index in case of
	212	* renaming to an existing interface. */
43c02e7b VB	213	struct lldpd_hardware {
	214	TAILQ_ENTRY(lldpd_hardware) h_entries;
	215
6e75df87 VB	216	fd_set h_recvfds; /* FD for reception */
	217	int h_sendfd; /* FD for sending, only used by h_ops */
	218	struct lldpd_ops h_ops; / Hardware-dependent functions */
	219	void h_data; / Hardware-dependent data */
43c02e7b	220
43c02e7b	221	int h_mtu;
6e75df87 VB	222	int h_flags; /* Packets will be sent only
	223	if IFF_RUNNING. Will be
	224	removed if this is left
	225	to 0. */
	226	int h_ifindex; /* Interface index, used by SNMP */
	227	char h_ifname[IFNAMSIZ]; /* Should be unique */
43c02e7b VB	228	u_int8_t h_lladdr[ETHER_ADDR_LEN];
	229
	230	u_int64_t h_tx_cnt;
	231	u_int64_t h_rx_cnt;
	232	u_int64_t h_rx_discarded_cnt;
	233	u_int64_t h_rx_ageout_cnt;
37387046	234	u_int64_t h_rx_unrecognized_cnt;
43c02e7b	235
75068724 VB	236	struct lldpd_port h_lport; /* Port attached to this hardware port */
75068724 VB	237	TAILQ_HEAD(, lldpd_port) h_rports; /* Remote ports */
43c02e7b VB	238	};
	239
	240	struct lldpd_interface {
	241	TAILQ_ENTRY(lldpd_interface) next;
	242	char *name;
	243	};
0c8f36f3	244	#define STRUCT_LLDPD_INTERFACE "(Ls)"
43c02e7b	245
77507b69	246	#define PROTO_SEND_SIG struct lldpd , struct lldpd_hardware
43c02e7b VB	247	#define PROTO_DECODE_SIG struct lldpd , char , int, struct lldpd_hardware , struct lldpd_chassis , struct lldpd_port *
	248	#define PROTO_GUESS_SIG char *, int
	249
43c02e7b	250	struct protocol {
f2dcb180 VB	251	#define LLDPD_MODE_LLDP 1
	252	#define LLDPD_MODE_CDPV1 2
	253	#define LLDPD_MODE_CDPV2 3
	254	#define LLDPD_MODE_SONMP 4
	255	#define LLDPD_MODE_EDP 5
	256	#define LLDPD_MODE_FDP 6
43c02e7b VB	257	int mode; /* > 0 mode identifier (unique per protocol) */
	258	int enabled; /* Is this protocol enabled? */
	259	char name; / Name of protocol */
	260	char arg; /* Argument to enable this protocol */
	261	int(send)(PROTO_SEND_SIG); / How to send a frame */
	262	int(decode)(PROTO_DECODE_SIG); / How to decode a frame */
	263	int(guess)(PROTO_GUESS_SIG); / Can be NULL, use MAC address in this case */
	264	u_int8_t mac[ETH_ALEN]; /* Destination MAC address used by this protocol */
	265	struct sock_filter filter; / BPF filter */
	266	size_t filterlen; /* Size of BPF filter */
	267	};
	268
77d7090e VB	269	#define CALLBACK_SIG struct lldpd, struct lldpd_callback
	270	struct lldpd_callback {
	271	TAILQ_ENTRY(lldpd_callback) next;
	272	int fd; /* FD that will trigger this callback */
	273	void(function)(CALLBACK_SIG); / Function called */
	274	void data; / Optional data for this callback*/
	275	};
	276
43c02e7b VB	277	struct lldpd {
	278	int g_sock;
	279	int g_delay;
	280
	281	struct protocol *g_protocols;
993a6e50	282	#ifdef ENABLE_LISTENVLAN
6a2fa591	283	int g_listen_vlans;
993a6e50	284	#endif
740593ff VB	285	#ifdef ENABLE_LLDPMED
	286	int g_noinventory;
	287	#endif
43c02e7b VB	288
	289	time_t g_lastsent;
	290	int g_lastrid;
	291	#ifdef USE_SNMP
	292	int g_snmp;
	293	#endif /* USE_SNMP */
	294
	295	/* Unix socket handling */
	296	int g_ctl;
77d7090e VB	297
77d7090e VB	298	TAILQ_HEAD(, lldpd_callback) g_callbacks;
43c02e7b VB	299
	300	char *g_mgmt_pattern;
	301
77507b69	302	#define LOCAL_CHASSIS(cfg) ((struct lldpd_chassis *)(TAILQ_FIRST(&cfg->g_chassis)))
75068724	303	TAILQ_HEAD(, lldpd_chassis) g_chassis;
43c02e7b VB	304	TAILQ_HEAD(, lldpd_hardware) g_hardware;
	305	};
	306
6e75df87 VB	307	typedef void(lldpd_ifhandlers)(struct lldpd , struct ifaddrs *);
6e75df87 VB	308
43c02e7b VB	309	enum hmsg_type {
	310	HMSG_NONE,
	311	HMSG_GET_INTERFACES,
84853b92	312	HMSG_GET_NB_PORTS,
43c02e7b	313	HMSG_GET_PORT,
84853b92	314	HMSG_GET_CHASSIS,
43c02e7b	315	HMSG_GET_VLANS,
740593ff	316	HMSG_SET_LOCATION,
43c02e7b VB	317	HMSG_SHUTDOWN
	318	};
	319
	320	struct hmsg_hdr {
	321	enum hmsg_type type;
	322	int16_t len;
	323	pid_t pid;
	324	} __attribute__ ((__packed__));
	325
	326	struct hmsg {
	327	struct hmsg_hdr hdr;
	328	void *data;
	329	} __attribute__ ((__packed__));
	330
	331	#define HMSG_HEADER_SIZE sizeof(struct hmsg_hdr)
	332	#define MAX_HMSGSIZE 8192
	333
	334	/* lldpd.c */
44002d66 VB	335	struct lldpd_hardware lldpd_get_hardware(struct lldpd ,
44002d66 VB	336	char , int, struct lldpd_ops );
6e75df87 VB	337	struct lldpd_hardware lldpd_alloc_hardware(struct lldpd , char *);
6e75df87 VB	338	void lldpd_hardware_cleanup(struct lldpd, struct lldpd_hardware );
a1347cd8	339	#ifdef ENABLE_DOT1
43c02e7b	340	void lldpd_vlan_cleanup(struct lldpd_port *);
a1347cd8	341	#endif
43c02e7b	342	void lldpd_remote_cleanup(struct lldpd , struct lldpd_hardware , int);
a0edeaf8	343	void lldpd_port_cleanup(struct lldpd_port *, int);
77507b69	344	void lldpd_chassis_cleanup(struct lldpd_chassis *, int);
77d7090e VB	345	int lldpd_callback_add(struct lldpd , int, void(fn)(CALLBACK_SIG), void *);
77d7090e VB	346	void lldpd_callback_del(struct lldpd , int, void(fn)(CALLBACK_SIG));
43c02e7b VB	347
	348	/* lldp.c */
	349	int lldp_send(PROTO_SEND_SIG);
	350	int lldp_decode(PROTO_DECODE_SIG);
	351
	352	/* cdp.c */
4bad1937	353	#ifdef ENABLE_CDP
43c02e7b VB	354	int cdpv1_send(PROTO_SEND_SIG);
43c02e7b VB	355	int cdpv2_send(PROTO_SEND_SIG);
43c02e7b VB	356	int cdpv1_guess(PROTO_GUESS_SIG);
43c02e7b VB	357	int cdpv2_guess(PROTO_GUESS_SIG);
4bad1937 VB	358	#endif
	359	#if defined (ENABLE_CDP) \|\| defined (ENABLE_FDP)
	360	int cdp_decode(PROTO_DECODE_SIG);
	361	#endif
	362	#ifdef ENABLE_FDP
	363	int fdp_send(PROTO_SEND_SIG);
	364	#endif
43c02e7b	365
4bad1937	366	#ifdef ENABLE_SONMP
43c02e7b VB	367	/* sonmp.c */
	368	int sonmp_send(PROTO_SEND_SIG);
	369	int sonmp_decode(PROTO_DECODE_SIG);
4bad1937	370	#endif
43c02e7b	371
4bad1937	372	#ifdef ENABLE_EDP
43c02e7b VB	373	/* edp.c */
	374	int edp_send(PROTO_SEND_SIG);
	375	int edp_decode(PROTO_DECODE_SIG);
4bad1937	376	#endif
43c02e7b VB	377
43c02e7b VB	378	/* ctl.c */
b5562b23	379	int ctl_create(char *);
43c02e7b	380	int ctl_connect(char *);
b5562b23	381	void ctl_cleanup(char *);
77d7090e VB	382	#ifndef CLIENT_ONLY
	383	void ctl_accept(struct lldpd , struct lldpd_callback );
	384	#endif
43c02e7b VB	385	void ctl_msg_init(struct hmsg *, enum hmsg_type);
	386	int ctl_msg_send(int, struct hmsg *);
	387	int ctl_msg_recv(int, struct hmsg *);
	388	int ctl_msg_pack_list(char , void , unsigned int, struct hmsg , void *);
	389	int ctl_msg_unpack_list(char , void , unsigned int, struct hmsg , void *);
	390	int ctl_msg_pack_structure(char , void , unsigned int, struct hmsg , void *);
	391	int ctl_msg_unpack_structure(char , void , unsigned int, struct hmsg , void *);
	392
6e75df87	393	/* interfaces.c */
849954d7	394	void lldpd_ifh_bond(struct lldpd , struct ifaddrs );
6e75df87	395	void lldpd_ifh_eth(struct lldpd , struct ifaddrs );
5994b27d	396	#ifdef ENABLE_DOT1
6e75df87	397	void lldpd_ifh_vlan(struct lldpd , struct ifaddrs );
5994b27d	398	#endif
6e75df87 VB	399	void lldpd_ifh_mgmt(struct lldpd , struct ifaddrs );
	400
	401	/* dmi.c */
89840df0 VB	402	#ifdef ENABLE_LLDPMED
	403	char *dmi_hw();
	404	char *dmi_fw();
	405	char *dmi_sn();
	406	char *dmi_manuf();
	407	char *dmi_model();
	408	char *dmi_asset();
	409	#endif
43c02e7b VB	410
	411	/* log.c */
	412	void log_init(int);
	413	void log_warn(const char *, ...);
	414	#define LLOG_WARN(x,...) log_warn("%s: " x, __FUNCTION__, ##__VA_ARGS__)
	415	void log_warnx(const char *, ...);
	416	#define LLOG_WARNX(x,...) log_warnx("%s: " x, __FUNCTION__, ##__VA_ARGS__)
	417	void log_info(const char *, ...);
	418	#define LLOG_INFO(x,...) log_info("%s: " x, __FUNCTION__, ##__VA_ARGS__)
	419	void log_debug(const char *, ...);
	420	#define LLOG_DEBUG(x,...) log_debug("%s: " x, __FUNCTION__, ##__VA_ARGS__)
	421	void fatal(const char *);
	422	void fatalx(const char *);
	423
	424	/* agent.c */
	425	void agent_shutdown();
	426	void agent_init(struct lldpd *, int);
	427
d72a05d4 VB	428	/* agent_priv.c */
	429	void agent_priv_register_domain();
	430
43c02e7b VB	431	/* strlcpy.c */
	432	size_t strlcpy(char , const char , size_t);
	433
a552a72e VB	434	/* client.c */
	435	struct client_handle {
	436	enum hmsg_type type;
	437	void (handle)(struct lldpd, struct hmsg, struct hmsg);
	438	};
	439
77d7090e VB	440	void client_handle_client(struct lldpd , struct lldpd_callback ,
77d7090e VB	441	char *, int);
a552a72e VB	442	void client_handle_none(struct lldpd , struct hmsg ,
	443	struct hmsg *);
	444	void client_handle_get_interfaces(struct lldpd , struct hmsg ,
	445	struct hmsg *);
740593ff	446	void client_handle_port_related(struct lldpd , struct hmsg ,
a552a72e VB	447	struct hmsg *);
	448	void client_handle_shutdown(struct lldpd , struct hmsg ,
	449	struct hmsg *);
	450
b5562b23	451	/* priv.c */
a2993d83	452	void priv_init(char*);
a7502371 VB	453	int priv_ctl_create();
	454	void priv_ctl_cleanup();
	455	char *priv_gethostbyname();
	456	int priv_open(char*);
	457	int priv_ethtool(char, struct ethtool_cmd);
849954d7	458	int priv_iface_init(const char *);
ef76f920	459	int priv_iface_multicast(const char , u_int8_t , int);
d72a05d4	460	int priv_snmp_socket(struct sockaddr_un *);
4afe659e VB	461
	462	/* privsep_fdpass.c */
	463	int receive_fd(int);
	464	void send_fd(int, int);
b5562b23	465
43c02e7b	466	#endif /* _LLDPD_H */