[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 <net/ethernet.h>
#include <netinet/in.h>

#include "compat.h"
#include "lldp.h"
#include "cdp.h"
#include "sonmp.h"
#include "edp.h"

#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

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

struct lldpd_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;
};
#define STRUCT_LLDPD_CHASSIS "bCsswwwll"

struct lldpd_port {
	u_int8_t		 p_id_subtype;
	char			*p_id;
	int			 p_id_len;
	char			*p_descr;

	/* 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;

	TAILQ_HEAD(, lldpd_vlan) p_vlans;
};
#define STRUCT_LLDPD_PORT "bCslbbwwPP"

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

struct lldpd_hardware {
	TAILQ_ENTRY(lldpd_hardware)	 h_entries;

#define INTERFACE_OPENED(x) ((x)->h_raw != -1)
	
	int			 h_raw;
	int			 h_raw_real; /* For bonding */
	int			 h_master;   /* For bonding */

#define LLDPD_MODE_ANY 0
#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
	int			 h_mode;

	int			 h_flags;
	int			 h_mtu;
	char			 h_ifname[IFNAMSIZ];
	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_int8_t		*h_proto_macs;
	time_t			 h_start_probe;

	struct lldpd_port	 h_lport;
	time_t			 h_llastchange;
	struct lldpd_frame	*h_llastframe;

	time_t			 h_rlastchange;
	time_t			 h_rlastupdate;
	int			 h_rid;
	struct lldpd_frame	*h_rlastframe;
	struct lldpd_port	*h_rport;
	struct lldpd_chassis	*h_rchassis;
};

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

struct lldpd_client {
	TAILQ_ENTRY(lldpd_client) next;
	int fd;
};

#define PROTO_SEND_SIG struct lldpd *, struct lldpd_chassis *, 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 lldpd;
struct protocol {
	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 */
};

struct lldpd {
	int			 g_sock;
	int			 g_delay;

	struct protocol		*g_protocols;
	int			 g_multi; /* Set to 1 if multiple protocols */
	int			 g_probe_time;

	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_client) g_clients;

	char			*g_mgmt_pattern;

	struct lldpd_chassis	 g_lchassis;

	TAILQ_HEAD(, lldpd_hardware) g_hardware;
};

enum hmsg_type {
	HMSG_NONE,
	HMSG_GET_INTERFACES,
	HMSG_GET_CHASSIS,
	HMSG_GET_PORT,
	HMSG_GET_VLANS,
	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 */
void	 lldpd_cleanup(struct lldpd *);
void	 lldpd_vlan_cleanup(struct lldpd_port *);
void	 lldpd_remote_cleanup(struct lldpd *, struct lldpd_hardware *, int);
void	 lldpd_port_cleanup(struct lldpd_port *);
void	 lldpd_chassis_cleanup(struct lldpd_chassis *);

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

/* cdp.c */
int	 cdpv1_send(PROTO_SEND_SIG);
int	 cdpv2_send(PROTO_SEND_SIG);
int	 cdp_decode(PROTO_DECODE_SIG);
int	 cdpv1_guess(PROTO_GUESS_SIG);
int	 cdpv2_guess(PROTO_GUESS_SIG);

/* sonmp.c */
int	 sonmp_send(PROTO_SEND_SIG);
int	 sonmp_decode(PROTO_DECODE_SIG);

/* edp.c */
int	 edp_send(PROTO_SEND_SIG);
int	 edp_decode(PROTO_DECODE_SIG);

/* ctl.c */
int	 ctl_create(struct lldpd *, char *);
int	 ctl_connect(char *);
void	 ctl_cleanup(int, char *);
int	 ctl_accept(struct lldpd *, int);
int	 ctl_close(struct lldpd *, int);
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 **);

/* features.c */
int	 iface_is_bridge(struct lldpd *, const char *);
int	 iface_is_bridged(struct lldpd *, const char *);
int	 iface_is_wireless(struct lldpd *, const char *);
int	 iface_is_vlan(struct lldpd *, const char *);
int	 iface_is_bond(struct lldpd *, const char *);
int	 iface_is_bond_slave(struct lldpd *,
	    const char *, const char *);
int	 iface_is_enslaved(struct lldpd *, const char *);

/* 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);

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

/* iov.c */
void		 iov_dump(struct lldpd_frame **, struct iovec *, int);
u_int16_t	 iov_checksum(struct iovec *, 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
	34	#include <net/ethernet.h>
	35	#include <netinet/in.h>
	36
	37	#include "compat.h"
	38	#include "lldp.h"
	39	#include "cdp.h"
	40	#include "sonmp.h"
	41	#include "edp.h"
	42
	43	#define LLDPD_TTL 120
	44	#define LLDPD_TX_DELAY 30
	45	#define LLDPD_TX_MSGDELAY 1
	46	#define LLDPD_CTL_SOCKET "/var/run/lldpd.socket"
	47	#define LLDPD_PID_FILE "/var/run/lldpd.pid"
	48
	49	#define UNIX_PATH_MAX 108
	50
	51	#define USING_AGENTX_SUBAGENT_MODULE 1
	52
	53	struct lldpd_vlan {
	54	TAILQ_ENTRY(lldpd_vlan) v_entries;
	55	char *v_name;
	56	u_int16_t v_vid;
	57	};
	58	#define STRUCT_LLDPD_VLAN "Lsw"
	59
	60	struct lldpd_chassis {
	61	u_int8_t c_id_subtype;
	62	char *c_id;
	63	int c_id_len;
	64	char *c_name;
65	char *c_descr;
66
67	u_int16_t c_cap_available;
68	u_int16_t c_cap_enabled;
69
70	u_int16_t c_ttl;
71
72	struct in_addr c_mgmt;
73	u_int32_t c_mgmt_if;
74	};
75	#define STRUCT_LLDPD_CHASSIS "bCsswwwll"
76
77	struct lldpd_port {
78	u_int8_t p_id_subtype;
79	char *p_id;
80	int p_id_len;
81	char *p_descr;
82
83	/* Dot3 stuff */
84	u_int32_t p_aggregid;
85	u_int8_t p_autoneg_support;
86	u_int8_t p_autoneg_enabled;
87	u_int16_t p_autoneg_advertised;
88	u_int16_t p_mau_type;
89
90	TAILQ_HEAD(, lldpd_vlan) p_vlans;
91	};
92	#define STRUCT_LLDPD_PORT "bCslbbwwPP"
93
94	struct lldpd_frame {
95	int size;
96	unsigned char frame[];
97	};
98
99	struct lldpd_hardware {
100	TAILQ_ENTRY(lldpd_hardware) h_entries;
101
102	#define INTERFACE_OPENED(x) ((x)->h_raw != -1)
103
104	int h_raw;
105	int h_raw_real; /* For bonding */
106	int h_master; /* For bonding */
107
108	#define LLDPD_MODE_ANY 0
109	#define LLDPD_MODE_LLDP 1
110	#define LLDPD_MODE_CDPV1 2
111	#define LLDPD_MODE_CDPV2 3
112	#define LLDPD_MODE_SONMP 4
113	#define LLDPD_MODE_EDP 5
114	int h_mode;
115
116	int h_flags;
117	int h_mtu;
118	char h_ifname[IFNAMSIZ];
119	u_int8_t h_lladdr[ETHER_ADDR_LEN];
120
121	u_int64_t h_tx_cnt;
122	u_int64_t h_rx_cnt;
123	u_int64_t h_rx_discarded_cnt;
124	u_int64_t h_rx_ageout_cnt;
125
126	u_int8_t *h_proto_macs;
127	time_t h_start_probe;
128
129	struct lldpd_port h_lport;
130	time_t h_llastchange;
131	struct lldpd_frame *h_llastframe;
132
133	time_t h_rlastchange;
134	time_t h_rlastupdate;
135	int h_rid;
136	struct lldpd_frame *h_rlastframe;
137	struct lldpd_port *h_rport;
138	struct lldpd_chassis *h_rchassis;
139	};
140
141	struct lldpd_interface {
142	TAILQ_ENTRY(lldpd_interface) next;
143	char *name;
144	};
145	#define STRUCT_LLDPD_INTERFACE "Ls"
146
147	struct lldpd_client {
148	TAILQ_ENTRY(lldpd_client) next;
149	int fd;
150	};
151
152	#define PROTO_SEND_SIG struct lldpd , struct lldpd_chassis , struct lldpd_hardware *
153	#define PROTO_DECODE_SIG struct lldpd , char , int, struct lldpd_hardware , struct lldpd_chassis , struct lldpd_port *
154	#define PROTO_GUESS_SIG char *, int
155
156	struct lldpd;
157	struct protocol {
158	int mode; /* > 0 mode identifier (unique per protocol) */
159	int enabled; /* Is this protocol enabled? */
160	char name; / Name of protocol */
161	char arg; /* Argument to enable this protocol */
162	int(send)(PROTO_SEND_SIG); / How to send a frame */
163	int(decode)(PROTO_DECODE_SIG); / How to decode a frame */
164	int(guess)(PROTO_GUESS_SIG); / Can be NULL, use MAC address in this case */
165	u_int8_t mac[ETH_ALEN]; /* Destination MAC address used by this protocol */
166	struct sock_filter filter; / BPF filter */
167	size_t filterlen; /* Size of BPF filter */
168	};
169
170	struct lldpd {
171	int g_sock;
172	int g_delay;
173
174	struct protocol *g_protocols;
175	int g_multi; /* Set to 1 if multiple protocols */
176	int g_probe_time;
177
178	time_t g_lastsent;
179	int g_lastrid;
180	#ifdef USE_SNMP
181	int g_snmp;
182	#endif /* USE_SNMP */
183
184	/* Unix socket handling */
185	int g_ctl;
186	TAILQ_HEAD(, lldpd_client) g_clients;
187
188	char *g_mgmt_pattern;
189
190	struct lldpd_chassis g_lchassis;
191
192	TAILQ_HEAD(, lldpd_hardware) g_hardware;
193	};
194
195	enum hmsg_type {
196	HMSG_NONE,
197	HMSG_GET_INTERFACES,
198	HMSG_GET_CHASSIS,
199	HMSG_GET_PORT,
200	HMSG_GET_VLANS,
201	HMSG_SHUTDOWN
202	};
203
204	struct hmsg_hdr {
205	enum hmsg_type type;
206	int16_t len;
207	pid_t pid;
208	} __attribute__ ((__packed__));
209
210	struct hmsg {
211	struct hmsg_hdr hdr;
212	void *data;
213	} __attribute__ ((__packed__));
214
215	#define HMSG_HEADER_SIZE sizeof(struct hmsg_hdr)
216	#define MAX_HMSGSIZE 8192
217
218	/* lldpd.c */
219	void lldpd_cleanup(struct lldpd *);
220	void lldpd_vlan_cleanup(struct lldpd_port *);
221	void lldpd_remote_cleanup(struct lldpd , struct lldpd_hardware , int);
222	void lldpd_port_cleanup(struct lldpd_port *);
223	void lldpd_chassis_cleanup(struct lldpd_chassis *);
224
225	/* lldp.c */
226	int lldp_send(PROTO_SEND_SIG);
227	int lldp_decode(PROTO_DECODE_SIG);
228
229	/* cdp.c */
230	int cdpv1_send(PROTO_SEND_SIG);
231	int cdpv2_send(PROTO_SEND_SIG);
232	int cdp_decode(PROTO_DECODE_SIG);
233	int cdpv1_guess(PROTO_GUESS_SIG);
234	int cdpv2_guess(PROTO_GUESS_SIG);
235
236	/* sonmp.c */
237	int sonmp_send(PROTO_SEND_SIG);
238	int sonmp_decode(PROTO_DECODE_SIG);
239
240	/* edp.c */
241	int edp_send(PROTO_SEND_SIG);
242	int edp_decode(PROTO_DECODE_SIG);
243
244	/* ctl.c */
245	int ctl_create(struct lldpd , char );
246	int ctl_connect(char *);
247	void ctl_cleanup(int, char *);
248	int ctl_accept(struct lldpd *, int);
249	int ctl_close(struct lldpd *, int);
250	void ctl_msg_init(struct hmsg *, enum hmsg_type);
251	int ctl_msg_send(int, struct hmsg *);
252	int ctl_msg_recv(int, struct hmsg *);
253	int ctl_msg_pack_list(char , void , unsigned int, struct hmsg , void *);
254	int ctl_msg_unpack_list(char , void , unsigned int, struct hmsg , void *);
255	int ctl_msg_pack_structure(char , void , unsigned int, struct hmsg , void *);
256	int ctl_msg_unpack_structure(char , void , unsigned int, struct hmsg , void *);
257
258	/* features.c */
259	int iface_is_bridge(struct lldpd , const char );
260	int iface_is_bridged(struct lldpd , const char );
261	int iface_is_wireless(struct lldpd , const char );
262	int iface_is_vlan(struct lldpd , const char );
263	int iface_is_bond(struct lldpd , const char );
264	int iface_is_bond_slave(struct lldpd *,
265	const char , const char );
266	int iface_is_enslaved(struct lldpd , const char );
267
268	/* log.c */
269	void log_init(int);
270	void log_warn(const char *, ...);
271	#define LLOG_WARN(x,...) log_warn("%s: " x, __FUNCTION__, ##__VA_ARGS__)
272	void log_warnx(const char *, ...);
273	#define LLOG_WARNX(x,...) log_warnx("%s: " x, __FUNCTION__, ##__VA_ARGS__)
274	void log_info(const char *, ...);
275	#define LLOG_INFO(x,...) log_info("%s: " x, __FUNCTION__, ##__VA_ARGS__)
276	void log_debug(const char *, ...);
277	#define LLOG_DEBUG(x,...) log_debug("%s: " x, __FUNCTION__, ##__VA_ARGS__)
278	void fatal(const char *);
279	void fatalx(const char *);
280
281	/* agent.c */
282	void agent_shutdown();
283	void agent_init(struct lldpd *, int);
284
285	/* strlcpy.c */
286	size_t strlcpy(char , const char , size_t);
287
288	/* iov.c */
289	void iov_dump(struct lldpd_frame *, struct iovec , int);
290	u_int16_t iov_checksum(struct iovec *, int, int);
291
292	#endif /* _LLDPD_H */