nm-lldp-listener.c 24.2 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20
/* -*- Mode: C; tab-width: 4; indent-tabs-mode: t; c-basic-offset: 4 -*- */
/* NetworkManager -- Network link manager
 *
 * This program is free software; you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation; either version 2 of the License, or
 * (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program; if not, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Copyright (C) 2015 Red Hat, Inc.
 */

21
#include "nm-default.h"
22

23 24
#include "nm-lldp-listener.h"

25
#include <net/ethernet.h>
26
#include <errno.h>
27 28 29 30

#include "nm-platform.h"
#include "nm-utils.h"

31 32 33 34 35
#include "sd-lldp.h"

#include "nm-sd-adapt.h"
#include "lldp.h"

36 37 38
#define MAX_NEIGHBORS         4096
#define MIN_UPDATE_INTERVAL   2

39 40 41 42
#define LLDP_MAC_NEAREST_BRIDGE          ((const struct ether_addr *) ((uint8_t[ETH_ALEN]) { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x0e }))
#define LLDP_MAC_NEAREST_NON_TPMR_BRIDGE ((const struct ether_addr *) ((uint8_t[ETH_ALEN]) { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x03 }))
#define LLDP_MAC_NEAREST_CUSTOMER_BRIDGE ((const struct ether_addr *) ((uint8_t[ETH_ALEN]) { 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 }))

43 44 45 46 47 48 49 50 51 52
typedef struct {
	char         *iface;
	int           ifindex;
	sd_lldp      *lldp_handle;
	GHashTable   *lldp_neighbors;
	guint         timer;
	guint         num_pending_events;
	GVariant     *variant;
} NMLldpListenerPrivate;

53
NM_GOBJECT_PROPERTIES_DEFINE (NMLldpListener,
54
	PROP_NEIGHBORS,
55
);
56 57 58 59 60 61 62 63 64 65 66

G_DEFINE_TYPE (NMLldpListener, nm_lldp_listener, G_TYPE_OBJECT)

#define NM_LLDP_LISTENER_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_LLDP_LISTENER, NMLldpListenerPrivate))

typedef struct {
	guint8 chassis_id_type;
	guint8 port_id_type;
	char *chassis_id;
	char *port_id;

67
	struct ether_addr destination_address;
68

69 70
	bool valid:1;

71
	GHashTable *tlvs;
72 73

	GVariant *variant;
74
} LldpNeighbor;
75 76 77

static void process_lldp_neighbors (NMLldpListener *self);

78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101
/*****************************************************************************/

#define _NMLOG_PREFIX_NAME                "lldp"
#define _NMLOG_DOMAIN                     LOGD_DEVICE
#define _NMLOG(level, ...) \
    G_STMT_START { \
        const NMLogLevel _level = (level); \
        \
        if (nm_logging_enabled (_level, _NMLOG_DOMAIN)) { \
            char _sbuf[64]; \
            int _ifindex = (self) ? NM_LLDP_LISTENER_GET_PRIVATE (self)->ifindex : 0; \
            \
            _nm_log (_level, _NMLOG_DOMAIN, 0, \
                     "%s%s: " _NM_UTILS_MACRO_FIRST (__VA_ARGS__), \
                     _NMLOG_PREFIX_NAME, \
                     ((_ifindex > 0) \
                        ? nm_sprintf_buf (_sbuf, "[%p,%d]", (self), _ifindex) \
                        : ((self) \
                            ? nm_sprintf_buf (_sbuf, "[%p]", (self)) \
                            : "")) \
                     _NM_UTILS_MACRO_REST (__VA_ARGS__)); \
        } \
    } G_STMT_END \

Thomas Haller's avatar
Thomas Haller committed
102 103 104
#define LOG_NEIGH_FMT        "CHASSIS=%s%s%s PORT=%s%s%s"
#define LOG_NEIGH_ARG(neigh) NM_PRINT_FMT_QUOTE_STRING ((neigh)->chassis_id), NM_PRINT_FMT_QUOTE_STRING ((neigh)->port_id)

105 106
/*****************************************************************************/

107 108 109 110 111 112 113 114 115 116
static gboolean
ether_addr_equal (const struct ether_addr *a1, const struct ether_addr *a2)
{
	nm_assert (a1);
	nm_assert (a2);

	G_STATIC_ASSERT_EXPR (sizeof (*a1) == ETH_ALEN);
	return memcmp (a1, a2, ETH_ALEN) == 0;
}

117 118 119 120 121 122 123 124 125 126
static void
gvalue_destroy (gpointer data)
{
	GValue *value = (GValue *) data;

	g_value_unset (value);
	g_slice_free (GValue, value);
}

static GValue *
127
gvalue_new_str (const char *str)
128 129 130 131 132
{
	GValue *value;

	value = g_slice_new0 (GValue);
	g_value_init (value, G_TYPE_STRING);
133
	g_value_set_string (value, str ?: "");
134 135 136
	return value;
}

137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162
static GValue *
gvalue_new_str_ptr (const void *str, gsize len)
{
	const char *s = str;
	const char *tmp;
	gsize len0 = len;
	gs_free char *str_free = NULL;
	gs_free char *str_escaped = NULL;

	/* truncate at first NUL, including removing trailing NULs*/
	tmp = memchr (s, '\0', len);
	if (tmp)
		len = tmp - s;

	if (!len)
		return gvalue_new_str ("");

	if (len0 <= len || s[len] != '\0') {
		/* hmpf, g_strescape needs a trailing NUL. Need to clone */
		s = str_free = g_strndup (s, len);
	}

	str_escaped = g_strescape (s, NULL);
	return gvalue_new_str (str_escaped);
}

163 164 165 166 167 168 169 170 171 172 173
static GValue *
gvalue_new_uint (guint val)
{
	GValue *value;

	value = g_slice_new0 (GValue);
	g_value_init (value, G_TYPE_UINT);
	g_value_set_uint (value, val);
	return value;
}

174 175 176 177 178 179 180 181 182 183 184 185 186 187 188
static GValue *
gvalue_new_uint_u8 (const void *data)
{
	return gvalue_new_uint (*((const guint8 *) data));
}

static GValue *
gvalue_new_uint_u16 (const void *data)
{
	guint16 v;

	memcpy (&v, data, sizeof (v));
	return gvalue_new_uint (ntohs (v));
}

189 190
/*****************************************************************************/

191 192 193
static guint
lldp_neighbor_id_hash (gconstpointer ptr)
{
194
	const LldpNeighbor *neigh = ptr;
195
	guint hash;
196

197 198 199 200 201
	hash =   23423423u  + ((guint) (neigh->chassis_id ? g_str_hash (neigh->chassis_id) : 12321u));
	hash = (hash * 33u) + ((guint) (neigh->port_id ? g_str_hash (neigh->port_id) : 34342343u));
	hash = (hash * 33u) + ((guint) neigh->chassis_id_type);
	hash = (hash * 33u) + ((guint) neigh->port_id_type);
	return hash;
202 203 204 205 206
}

static gboolean
lldp_neighbor_id_equal (gconstpointer a, gconstpointer b)
{
207
	const LldpNeighbor *x = a, *y = b;
208 209 210 211 212 213 214 215

	return x->chassis_id_type == y->chassis_id_type &&
	       x->port_id_type == y->port_id_type &&
	       !g_strcmp0 (x->chassis_id, y->chassis_id) &&
	       !g_strcmp0 (x->port_id, y->port_id);
}

static void
216
lldp_neighbor_free (LldpNeighbor *neighbor)
217 218 219 220 221
{
	if (neighbor) {
		g_free (neighbor->chassis_id);
		g_free (neighbor->port_id);
		g_hash_table_unref (neighbor->tlvs);
222
		g_clear_pointer (&neighbor->variant, g_variant_unref);
223
		g_slice_free (LldpNeighbor, neighbor);
224 225 226
	}
}

227
static void
228
lldp_neighbor_freep (LldpNeighbor **ptr)
229 230 231 232
{
	lldp_neighbor_free (*ptr);
}

233
static gboolean
234
lldp_neighbor_equal (LldpNeighbor *a, LldpNeighbor *b)
235 236 237 238 239 240 241 242 243
{
	GHashTableIter iter;
	gpointer k, v;

	g_return_val_if_fail (a && a->tlvs, FALSE);
	g_return_val_if_fail (b && b->tlvs, FALSE);

	if (   a->chassis_id_type != b->chassis_id_type
	    || a->port_id_type != b->port_id_type
244
	    || ether_addr_equal (&a->destination_address, &b->destination_address)
245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276
	    || g_strcmp0 (a->chassis_id, b->chassis_id)
	    || g_strcmp0 (a->port_id, b->port_id))
		return FALSE;

	if (g_hash_table_size (a->tlvs) != g_hash_table_size (b->tlvs))
		return FALSE;

	g_hash_table_iter_init (&iter, a->tlvs);
	while (g_hash_table_iter_next (&iter, &k, &v)) {
		GValue *value_a, *value_b;

		value_a = v;
		value_b = g_hash_table_lookup (b->tlvs, k);

		if (!value_b)
			return FALSE;

		g_return_val_if_fail (G_VALUE_TYPE (value_a) == G_VALUE_TYPE (value_b), FALSE);

		if (G_VALUE_HOLDS_STRING (value_a)) {
			if (g_strcmp0 (g_value_get_string (value_a), g_value_get_string (value_b)))
				return FALSE;
		} else if (G_VALUE_HOLDS_UINT (value_a)) {
			if (g_value_get_uint (value_a) != g_value_get_uint (value_b))
				return FALSE;
		} else
			g_return_val_if_reached (FALSE);
	}

	return TRUE;
}

277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324
static LldpNeighbor *
lldp_neighbor_new (sd_lldp_neighbor *neighbor_sd, GError **error)
{
	nm_auto (lldp_neighbor_freep) LldpNeighbor *neigh = NULL;
	uint8_t chassis_id_type, port_id_type;
	uint16_t data16;
	uint8_t *data8;
	const void *chassis_id, *port_id;
	gsize chassis_id_len, port_id_len, len;
	GValue *value;
	const char *str;
	int r;

	r = sd_lldp_neighbor_get_chassis_id (neighbor_sd, &chassis_id_type,
	                                     &chassis_id, &chassis_id_len);
	if (r < 0) {
		g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
		             "failed reading chassis-id: %s", g_strerror (-r));
		return NULL;
	}
	if (chassis_id_len < 1) {
		g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
		             "empty chassis-id");
		return NULL;
	}

	r = sd_lldp_neighbor_get_port_id (neighbor_sd, &port_id_type,
	                                  &port_id, &port_id_len);
	if (r < 0) {
		g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
		             "failed reading port-id: %s", g_strerror (-r));
		return NULL;
	}
	if (port_id_len < 1) {
		g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
		             "empty port-id");
		return NULL;
	}

	neigh = g_slice_new0 (LldpNeighbor);
	neigh->tlvs = g_hash_table_new_full (g_str_hash, g_str_equal, NULL, gvalue_destroy);
	neigh->chassis_id_type = chassis_id_type;
	neigh->port_id_type = port_id_type;

	r = sd_lldp_neighbor_get_destination_address (neighbor_sd, &neigh->destination_address);
	if (r < 0) {
		g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
		             "failed getting destination address: %s", g_strerror (-r));
325
		goto out;
326 327 328 329 330 331 332 333 334 335 336 337 338 339 340
	}

	switch (chassis_id_type) {
	case LLDP_CHASSIS_SUBTYPE_INTERFACE_ALIAS:
	case LLDP_CHASSIS_SUBTYPE_INTERFACE_NAME:
	case LLDP_CHASSIS_SUBTYPE_LOCALLY_ASSIGNED:
	case LLDP_CHASSIS_SUBTYPE_CHASSIS_COMPONENT:
		neigh->chassis_id = g_strndup ((const char *) chassis_id, chassis_id_len);
		break;
	case LLDP_CHASSIS_SUBTYPE_MAC_ADDRESS:
		neigh->chassis_id = nm_utils_hwaddr_ntoa (chassis_id, chassis_id_len);
		break;
	default:
		g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
		             "unsupported chassis-id type %d", chassis_id_type);
341
		goto out;
342 343 344 345 346 347 348 349 350 351 352 353 354 355 356
	}

	switch (port_id_type) {
	case LLDP_PORT_SUBTYPE_INTERFACE_ALIAS:
	case LLDP_PORT_SUBTYPE_INTERFACE_NAME:
	case LLDP_PORT_SUBTYPE_LOCALLY_ASSIGNED:
	case LLDP_PORT_SUBTYPE_PORT_COMPONENT:
		neigh->port_id = strndup ((char *) port_id, port_id_len);
		break;
	case LLDP_PORT_SUBTYPE_MAC_ADDRESS:
		neigh->port_id = nm_utils_hwaddr_ntoa (port_id, port_id_len);
		break;
	default:
		g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
		             "unsupported port-id type %d", port_id_type);
357
		goto out;
358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383
	}

	if (sd_lldp_neighbor_get_port_description (neighbor_sd, &str) == 0) {
		value = gvalue_new_str (str);
		g_hash_table_insert (neigh->tlvs, NM_LLDP_ATTR_PORT_DESCRIPTION, value);
	}

	if (sd_lldp_neighbor_get_system_name (neighbor_sd, &str) == 0) {
		value = gvalue_new_str (str);
		g_hash_table_insert (neigh->tlvs, NM_LLDP_ATTR_SYSTEM_NAME, value);
	}

	if (sd_lldp_neighbor_get_system_description (neighbor_sd, &str) == 0) {
		value = gvalue_new_str (str);
		g_hash_table_insert (neigh->tlvs, NM_LLDP_ATTR_SYSTEM_DESCRIPTION, value);
	}

	if (sd_lldp_neighbor_get_system_capabilities (neighbor_sd, &data16) == 0) {
		value = gvalue_new_uint (data16);
		g_hash_table_insert (neigh->tlvs, NM_LLDP_ATTR_SYSTEM_CAPABILITIES, value);
	}

	r = sd_lldp_neighbor_tlv_rewind (neighbor_sd);
	if (r < 0) {
		g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
		             "failed reading tlv (rewind): %s", g_strerror (-r));
384
		goto out;
385 386 387 388 389 390 391 392 393 394 395
	}
	do {
		guint8 oui[3];
		guint8 subtype;

		r = sd_lldp_neighbor_tlv_get_oui (neighbor_sd, oui, &subtype);
		if (r < 0) {
			if (r == -ENXIO)
				continue;
			g_set_error (error, NM_UTILS_ERROR, NM_UTILS_ERROR_UNKNOWN,
			             "failed reading tlv: %s", g_strerror (-r));
396
			goto out;
397 398 399 400 401 402 403 404 405 406 407 408 409 410 411 412 413 414 415 416 417 418 419 420 421 422 423 424 425 426 427 428 429 430 431 432 433 434 435 436 437 438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465
		}

		if (!(   memcmp (oui, LLDP_OUI_802_1, sizeof (oui)) == 0
		      && NM_IN_SET (subtype,
		                    LLDP_OUI_802_1_SUBTYPE_PORT_PROTOCOL_VLAN_ID,
		                    LLDP_OUI_802_1_SUBTYPE_PORT_VLAN_ID,
		                    LLDP_OUI_802_1_SUBTYPE_VLAN_NAME)))
			continue;

		if (sd_lldp_neighbor_tlv_get_raw (neighbor_sd, (void *) &data8, &len) < 0)
			continue;

		/* skip over leading TLV, OUI and subtype */
#ifdef WITH_MORE_ASSERTS
		{
			guint8 check_hdr[] = {
				0xfe | (((len - 2) >> 8) & 0x01), ((len - 2) & 0xFF),
				oui[0], oui[1], oui[2],
				subtype
			};

			nm_assert (len > 2 + 3 +1);
			nm_assert (memcmp (data8, check_hdr, sizeof check_hdr) == 0);
		}
#endif
		if (len <= 6)
			continue;
		data8 += 6;
		len -= 6;

		/*if (memcmp (oui, LLDP_OUI_802_1, sizeof (oui)) == 0)*/
		{
			switch (subtype) {
			case LLDP_OUI_802_1_SUBTYPE_PORT_VLAN_ID:
				if (len != 2)
					continue;
				g_hash_table_insert (neigh->tlvs, NM_LLDP_ATTR_IEEE_802_1_PVID,
				                     gvalue_new_uint_u16 (data8));
				break;
			case LLDP_OUI_802_1_SUBTYPE_PORT_PROTOCOL_VLAN_ID:
				if (len != 3)
					continue;
				g_hash_table_insert (neigh->tlvs, NM_LLDP_ATTR_IEEE_802_1_PPVID_FLAGS,
				                     gvalue_new_uint_u8 (&data8[0]));
				g_hash_table_insert (neigh->tlvs, NM_LLDP_ATTR_IEEE_802_1_PPVID,
				                     gvalue_new_uint_u16 (&data8[1]));
				break;
			case LLDP_OUI_802_1_SUBTYPE_VLAN_NAME: {
				int l;

				if (len <= 3)
					continue;

				l = data8[2];
				if (len != 3 + l)
					continue;

				g_hash_table_insert (neigh->tlvs, NM_LLDP_ATTR_IEEE_802_1_VID,
				                     gvalue_new_uint_u16 (&data8[0]));
				g_hash_table_insert (neigh->tlvs, NM_LLDP_ATTR_IEEE_802_1_VLAN_NAME,
				                     gvalue_new_str_ptr (&data8[3], len));
				break;
			}
			default:
				g_assert_not_reached ();
			}
		}
	} while (sd_lldp_neighbor_tlv_next (neighbor_sd) > 0);

466 467 468 469
	neigh->valid = TRUE;

out:
	return nm_unauto (&neigh);
470 471
}

472 473 474 475 476 477 478 479
static GVariant *
lldp_neighbor_to_variant (LldpNeighbor *neigh)
{
	GVariantBuilder builder;
	GHashTableIter val_iter;
	gpointer key, val;
	const char *dest_str;

480 481 482
	if (neigh->variant)
		return neigh->variant;

483 484 485 486 487 488 489 490 491 492 493 494 495 496 497 498 499 500 501 502 503 504 505 506 507 508 509 510 511 512 513 514 515 516 517 518 519 520 521 522 523 524 525 526
	g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));

	g_variant_builder_add (&builder, "{sv}",
	                       NM_LLDP_ATTR_CHASSIS_ID_TYPE,
	                       g_variant_new_uint32 (neigh->chassis_id_type));
	g_variant_builder_add (&builder, "{sv}",
	                       NM_LLDP_ATTR_CHASSIS_ID,
	                       g_variant_new_string (neigh->chassis_id));
	g_variant_builder_add (&builder, "{sv}",
	                       NM_LLDP_ATTR_PORT_ID_TYPE,
	                       g_variant_new_uint32 (neigh->port_id_type));
	g_variant_builder_add (&builder, "{sv}",
	                       NM_LLDP_ATTR_PORT_ID,
	                       g_variant_new_string (neigh->port_id));

	if (ether_addr_equal (&neigh->destination_address, LLDP_MAC_NEAREST_BRIDGE))
		dest_str = NM_LLDP_DEST_NEAREST_BRIDGE;
	else if (ether_addr_equal (&neigh->destination_address, LLDP_MAC_NEAREST_NON_TPMR_BRIDGE))
		dest_str = NM_LLDP_DEST_NEAREST_NON_TPMR_BRIDGE;
	else if (ether_addr_equal (&neigh->destination_address, LLDP_MAC_NEAREST_CUSTOMER_BRIDGE))
		dest_str = NM_LLDP_DEST_NEAREST_CUSTOMER_BRIDGE;
	else
		dest_str = NULL;
	if (dest_str) {
		g_variant_builder_add (&builder, "{sv}",
		                       NM_LLDP_ATTR_DESTINATION,
		                       g_variant_new_string (dest_str));
	}

	g_hash_table_iter_init (&val_iter, neigh->tlvs);
	while (g_hash_table_iter_next (&val_iter, &key, &val)) {
		GValue *item = val;

		if (G_VALUE_HOLDS_STRING (item)) {
			g_variant_builder_add (&builder, "{sv}",
			                       key,
			                       g_variant_new_string (g_value_get_string (item)));
		} else if (G_VALUE_HOLDS_UINT (item)) {
			g_variant_builder_add (&builder, "{sv}",
			                       key,
			                       g_variant_new_uint32 (g_value_get_uint (item)));
		}
	}

527
	return (neigh->variant = g_variant_ref_sink (g_variant_builder_end (&builder)));
528 529
}

530 531
/*****************************************************************************/

532 533 534
static gboolean
lldp_timeout (gpointer user_data)
{
535 536 537 538 539 540
	NMLldpListener *self = user_data;
	NMLldpListenerPrivate *priv;

	g_return_val_if_fail (NM_IS_LLDP_LISTENER (self), G_SOURCE_REMOVE);

	priv = NM_LLDP_LISTENER_GET_PRIVATE (self);
541 542 543 544 545 546 547 548 549 550 551 552 553

	priv->timer = 0;

	if (priv->num_pending_events)
		process_lldp_neighbors (self);

	return G_SOURCE_REMOVE;
}

static void
process_lldp_neighbors (NMLldpListener *self)
{
	NMLldpListenerPrivate *priv = NM_LLDP_LISTENER_GET_PRIVATE (self);
554
	nm_auto_free sd_lldp_neighbor **neighbors = NULL;
555 556
	GHashTable *prune_list = NULL;
	GHashTableIter iter;
557 558
	int num, i;
	GError *parse_error = NULL, **p_parse_error;
559
	gboolean changed = FALSE;
560
	LldpNeighbor *neigh_old;
561

562 563
	g_return_if_fail (priv->lldp_handle);

564
	num = sd_lldp_get_neighbors (priv->lldp_handle, &neighbors);
565
	if (num < 0) {
566 567
		_LOGD ("process: error %d retrieving neighbor packets for %s",
		        num, priv->iface);
568 569 570
		return;
	}

571 572 573 574 575 576 577
	if (g_hash_table_size (priv->lldp_neighbors) > 0) {
		prune_list = g_hash_table_new (NULL, NULL);
		g_hash_table_iter_init (&iter, priv->lldp_neighbors);
		while (g_hash_table_iter_next (&iter, (gpointer *) &neigh_old, NULL)) {
			g_hash_table_add (prune_list, neigh_old);
		}
	}
578

579 580
	p_parse_error = _LOGT_ENABLED () ? &parse_error : NULL;

581
	for (i = 0; neighbors && i < num; i++) {
582 583
		nm_auto (lldp_neighbor_freep) LldpNeighbor *neigh = NULL;

584
		neigh = lldp_neighbor_new (neighbors[i], p_parse_error);
585
		if (!neigh || !neigh->valid) {
586
			if (p_parse_error) {
Thomas Haller's avatar
Thomas Haller committed
587 588 589 590 591 592
				if (neigh)
					_LOGT ("process: failed to parse neighbor: %s", parse_error->message);
				else {
					_LOGT ("process: failed to parse neighbor "LOG_NEIGH_FMT": %s",
					       LOG_NEIGH_ARG (neigh), parse_error->message);
				}
593
				g_clear_error (&parse_error);
594
			}
595 596
			continue;
		}
597

598 599
		neigh_old = g_hash_table_lookup (priv->lldp_neighbors, neigh);
		if (neigh_old) {
600
			if (lldp_neighbor_equal (neigh_old, neigh))
601 602 603 604 605 606 607 608 609 610 611 612 613 614 615 616 617
				continue;
			if (prune_list) {
				if (g_hash_table_remove (prune_list, neigh_old))
					changed = TRUE;
				if (g_hash_table_size (prune_list) == 0)
					g_clear_pointer (&prune_list, g_hash_table_unref);
			}
		}

		/* ensure that we have at most MAX_NEIGHBORS entires */
		if (   !neigh_old /* only matters in the "add" case. */
		    && i >= MAX_NEIGHBORS
		    && (g_hash_table_size (priv->lldp_neighbors) - (prune_list ? g_hash_table_size (prune_list) : 0)) > MAX_NEIGHBORS) {
			_LOGT ("process: skip remaining neighbors due to overall limit of %d", MAX_NEIGHBORS);
			break;
		}

Thomas Haller's avatar
Thomas Haller committed
618
		_LOGD ("process: %s neigh: "LOG_NEIGH_FMT,
619
		        neigh_old ? "update" : "new",
Thomas Haller's avatar
Thomas Haller committed
620
		        LOG_NEIGH_ARG (neigh));
621 622

		changed = TRUE;
623
		g_hash_table_add (priv->lldp_neighbors, nm_unauto (&neigh));
624 625
	}

626 627 628
	for (i = 0; neighbors && i < num; i++)
		sd_lldp_neighbor_unref (neighbors[i]);

629 630 631
	if (prune_list) {
		g_hash_table_iter_init (&iter, prune_list);
		while (g_hash_table_iter_next (&iter, (gpointer *) &neigh_old, NULL)) {
Thomas Haller's avatar
Thomas Haller committed
632
			_LOGD ("process: %s neigh: "LOG_NEIGH_FMT,
633
			        "remove",
Thomas Haller's avatar
Thomas Haller committed
634
			        LOG_NEIGH_ARG (neigh_old));
635 636 637 638 639 640 641 642
			if (!g_hash_table_remove (priv->lldp_neighbors, neigh_old))
				g_warn_if_reached ();
			changed = TRUE;
		}
		g_hash_table_unref (prune_list);
	}

	if (changed) {
643
		nm_clear_g_variant (&priv->variant);
644
		_notify (self, PROP_NEIGHBORS);
645 646 647 648 649 650 651 652 653 654 655
	}

	/* Since the processing of the neighbor list is potentially
	 * expensive when there are many neighbors, coalesce multiple
	 * events arriving in short time.
	 */
	priv->timer = g_timeout_add_seconds (MIN_UPDATE_INTERVAL, lldp_timeout, self);
	priv->num_pending_events = 0;
}

static void
656
lldp_event_handler (sd_lldp *lldp, sd_lldp_event event, sd_lldp_neighbor *n, void *userdata)
657 658 659 660 661
{
	NMLldpListener *self = userdata;
	NMLldpListenerPrivate *priv;

	g_return_if_fail (NM_IS_LLDP_LISTENER (self));
662

663 664 665 666 667 668 669 670 671 672 673
	priv = NM_LLDP_LISTENER_GET_PRIVATE (self);

	if (priv->timer > 0) {
		priv->num_pending_events++;
		return;
	}

	process_lldp_neighbors (self);
}

gboolean
674
nm_lldp_listener_start (NMLldpListener *self, int ifindex, GError **error)
675 676 677 678 679 680 681 682 683 684 685 686 687 688 689 690
{
	NMLldpListenerPrivate *priv;
	int ret;

	g_return_val_if_fail (NM_IS_LLDP_LISTENER (self), FALSE);
	g_return_val_if_fail (ifindex > 0, FALSE);
	g_return_val_if_fail (!error || !*error, FALSE);

	priv = NM_LLDP_LISTENER_GET_PRIVATE (self);

	if (priv->lldp_handle) {
		g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED,
		                     "already running");
		return FALSE;
	}

691 692
	ret = sd_lldp_new (&priv->lldp_handle, ifindex);
	if (ret < 0) {
693 694 695 696 697 698
		g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED,
		                     "initialization failed");
		return FALSE;
	}

	ret = sd_lldp_attach_event (priv->lldp_handle, NULL, 0);
699
	if (ret < 0) {
700 701 702 703 704 705
		g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED,
		                     "attach event failed");
		goto err_free;
	}

	ret = sd_lldp_set_callback (priv->lldp_handle, lldp_event_handler, self);
706
	if (ret < 0) {
707 708 709 710 711 712
		g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED,
		                     "set callback failed");
		goto err;
	}

	ret = sd_lldp_start (priv->lldp_handle);
713
	if (ret < 0) {
714 715 716 717 718 719
		g_set_error_literal (error, NM_DEVICE_ERROR, NM_DEVICE_ERROR_FAILED,
		                     "start failed");
		goto err;
	}

	priv->ifindex = ifindex;
720
	_LOGD ("start");
721 722 723 724 725
	return TRUE;

err:
	sd_lldp_detach_event (priv->lldp_handle);
err_free:
726
	sd_lldp_unref (priv->lldp_handle);
727 728 729 730 731 732 733 734 735 736 737 738 739 740
	priv->lldp_handle = NULL;
	return FALSE;
}

void
nm_lldp_listener_stop (NMLldpListener *self)
{
	NMLldpListenerPrivate *priv;
	guint size;

	g_return_if_fail (NM_IS_LLDP_LISTENER (self));
	priv = NM_LLDP_LISTENER_GET_PRIVATE (self);

	if (priv->lldp_handle) {
741
		_LOGD ("stop");
742 743
		sd_lldp_stop (priv->lldp_handle);
		sd_lldp_detach_event (priv->lldp_handle);
744
		sd_lldp_unref (priv->lldp_handle);
745 746 747 748 749 750
		priv->lldp_handle = NULL;

		size = g_hash_table_size (priv->lldp_neighbors);
		g_hash_table_remove_all (priv->lldp_neighbors);
		if (size) {
			nm_clear_g_variant (&priv->variant);
751
			_notify (self, PROP_NEIGHBORS);
752 753 754 755
		}
	}

	nm_clear_g_source (&priv->timer);
756
	priv->ifindex = 0;
757 758 759 760 761 762 763 764 765 766 767 768 769 770 771 772
}

gboolean
nm_lldp_listener_is_running (NMLldpListener *self)
{
	NMLldpListenerPrivate *priv;

	g_return_val_if_fail (NM_IS_LLDP_LISTENER (self), FALSE);

	priv = NM_LLDP_LISTENER_GET_PRIVATE (self);
	return !!priv->lldp_handle;
}

GVariant *
nm_lldp_listener_get_neighbors (NMLldpListener *self)
{
773
	GVariantBuilder array_builder;
774 775
	GHashTableIter iter;
	NMLldpListenerPrivate *priv;
776
	LldpNeighbor *neigh;
777

778 779
	g_return_val_if_fail (NM_IS_LLDP_LISTENER (self), FALSE);

780 781
	priv = NM_LLDP_LISTENER_GET_PRIVATE (self);

782 783 784
	if (!priv->variant) {
		g_variant_builder_init (&array_builder, G_VARIANT_TYPE ("aa{sv}"));
		g_hash_table_iter_init (&iter, priv->lldp_neighbors);
785

786 787
		while (g_hash_table_iter_next (&iter, NULL, (gpointer *) &neigh))
			g_variant_builder_add_value (&array_builder, lldp_neighbor_to_variant (neigh));
788

789 790
		priv->variant = g_variant_ref_sink (g_variant_builder_end (&array_builder));
	}
791 792 793 794 795 796 797 798 799 800 801 802 803 804 805 806 807 808 809 810 811 812 813 814 815 816
	return priv->variant;
}

static void
get_property (GObject *object, guint prop_id,
              GValue *value, GParamSpec *pspec)
{
	NMLldpListener *self = NM_LLDP_LISTENER (object);

	switch (prop_id) {
	case PROP_NEIGHBORS:
		g_value_set_variant (value, nm_lldp_listener_get_neighbors (self));
		break;
	default:
		G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
		break;
	}
}

static void
nm_lldp_listener_init (NMLldpListener *self)
{
	NMLldpListenerPrivate *priv = NM_LLDP_LISTENER_GET_PRIVATE (self);

	priv->lldp_neighbors = g_hash_table_new_full (lldp_neighbor_id_hash,
	                                              lldp_neighbor_id_equal,
817
	                                              (GDestroyNotify) lldp_neighbor_free, NULL);
818 819

	_LOGT ("lldp listener created");
820 821 822 823 824 825 826 827 828 829 830 831 832 833 834 835 836 837 838 839 840 841 842 843 844 845 846
}

NMLldpListener *
nm_lldp_listener_new (void)
{
	return (NMLldpListener *) g_object_new (NM_TYPE_LLDP_LISTENER, NULL);
}

static void
dispose (GObject *object)
{
	nm_lldp_listener_stop (NM_LLDP_LISTENER (object));

	G_OBJECT_CLASS (nm_lldp_listener_parent_class)->dispose (object);
}

static void
finalize (GObject *object)
{
	NMLldpListener *self = NM_LLDP_LISTENER (object);
	NMLldpListenerPrivate *priv = NM_LLDP_LISTENER_GET_PRIVATE (self);

	nm_lldp_listener_stop (self);
	g_hash_table_unref (priv->lldp_neighbors);

	nm_clear_g_variant (&priv->variant);

847 848
	_LOGT ("lldp listener destroyed");

849 850 851 852 853 854 855 856 857 858 859 860 861 862
	G_OBJECT_CLASS (nm_lldp_listener_parent_class)->finalize (object);
}

static void
nm_lldp_listener_class_init (NMLldpListenerClass *klass)
{
	GObjectClass *object_class = G_OBJECT_CLASS (klass);

	g_type_class_add_private (klass, sizeof (NMLldpListenerPrivate));

	object_class->dispose = dispose;
	object_class->finalize = finalize;
	object_class->get_property = get_property;

863 864 865 866 867 868 869 870
	obj_properties[PROP_NEIGHBORS] =
	    g_param_spec_variant (NM_LLDP_LISTENER_NEIGHBORS, "", "",
	                          G_VARIANT_TYPE ("aa{sv}"),
	                          NULL,
	                          G_PARAM_READABLE |
	                          G_PARAM_STATIC_STRINGS);

	g_object_class_install_properties (object_class, _PROPERTY_ENUMS_LAST, obj_properties);
871 872
}