diff --git a/.gitmodules b/.gitmodules
index b249b40..669c57f 100644
--- a/.gitmodules
+++ b/.gitmodules
@@ -13,3 +13,6 @@
 [submodule "submodules/velia"]
 	path = submodules/velia
 	url = ../velia/
+[submodule "submodules/lldp-systemd-networkd-sysrepo"]
+	path = submodules/lldp-systemd-networkd-sysrepo
+	url = ../lldp-systemd-networkd-sysrepo
diff --git a/.zuul.yaml b/.zuul.yaml
index d5c7540..a127ae3 100644
--- a/.zuul.yaml
+++ b/.zuul.yaml
@@ -13,6 +13,7 @@
       - CzechLight/gammarus
       - CzechLight/netconf-cli
       - CzechLight/velia
+      - CzechLight/lldp-systemd-networkd-sysrepo
       - github/CESNET/libyang
       - github/sysrepo/libredblack
       - github/sysrepo/sysrepo
diff --git a/board/czechlight/common/patches/systemd/sd_lldp.patch b/board/czechlight/common/patches/systemd/sd_lldp.patch
new file mode 100644
index 0000000..ca32358
--- /dev/null
+++ b/board/czechlight/common/patches/systemd/sd_lldp.patch
@@ -0,0 +1,4023 @@
+From 9b8b7ba40accbd303a3378d75022d6d92a2b7771 Mon Sep 17 00:00:00 2001
+From: Tomas Pecka <peckato1@fit.cvut.cz>
+Date: Mon, 7 Sep 2020 18:26:47 +0200
+Subject: [PATCH] Move sd_lldp to libsystemd
+
+Make sd_lldp public in libsystemd. Clients can therefore operate
+with LLDP structures and files (e.g. parse LLDP neighbours).
+---
+ meson.build                            |   1 +
+ src/fuzz/meson.build                   |   9 +-
+ src/libsystemd-network/lldp-internal.h |  39 --
+ src/libsystemd-network/lldp-neighbor.c | 769 -------------------------
+ src/libsystemd-network/lldp-neighbor.h |  91 ---
+ src/libsystemd-network/lldp-network.c  |  78 ---
+ src/libsystemd-network/lldp-network.h  |   6 -
+ src/libsystemd-network/meson.build     |   6 -
+ src/libsystemd-network/sd-lldp.c       | 498 ----------------
+ src/libsystemd-network/test-lldp.c     | 379 ------------
+ src/libsystemd/libsystemd.sym          |  41 ++
+ src/libsystemd/meson.build             |   6 +
+ src/libsystemd/sd-lldp/lldp-internal.h |  39 ++
+ src/libsystemd/sd-lldp/lldp-neighbor.c | 769 +++++++++++++++++++++++++
+ src/libsystemd/sd-lldp/lldp-neighbor.h |  91 +++
+ src/libsystemd/sd-lldp/lldp-network.c  |  78 +++
+ src/libsystemd/sd-lldp/lldp-network.h  |   6 +
+ src/libsystemd/sd-lldp/sd-lldp.c       | 498 ++++++++++++++++
+ src/libsystemd/sd-lldp/test-lldp.c     | 379 ++++++++++++
+ src/systemd/meson.build                |   2 +-
+ src/test/meson.build                   |  10 +-
+ 21 files changed, 1919 insertions(+), 1876 deletions(-)
+ delete mode 100644 src/libsystemd-network/lldp-internal.h
+ delete mode 100644 src/libsystemd-network/lldp-neighbor.c
+ delete mode 100644 src/libsystemd-network/lldp-neighbor.h
+ delete mode 100644 src/libsystemd-network/lldp-network.c
+ delete mode 100644 src/libsystemd-network/lldp-network.h
+ delete mode 100644 src/libsystemd-network/sd-lldp.c
+ delete mode 100644 src/libsystemd-network/test-lldp.c
+ create mode 100644 src/libsystemd/sd-lldp/lldp-internal.h
+ create mode 100644 src/libsystemd/sd-lldp/lldp-neighbor.c
+ create mode 100644 src/libsystemd/sd-lldp/lldp-neighbor.h
+ create mode 100644 src/libsystemd/sd-lldp/lldp-network.c
+ create mode 100644 src/libsystemd/sd-lldp/lldp-network.h
+ create mode 100644 src/libsystemd/sd-lldp/sd-lldp.c
+ create mode 100644 src/libsystemd/sd-lldp/test-lldp.c
+
+diff --git a/meson.build b/meson.build
+index 8ccc947e37..1c2099d093 100644
+--- a/meson.build
++++ b/meson.build
+@@ -1398,6 +1398,7 @@ includes = include_directories('src/basic',
+                                'src/libsystemd/sd-event',
+                                'src/libsystemd/sd-hwdb',
+                                'src/libsystemd/sd-id128',
++                               'src/libsystemd/sd-lldp',
+                                'src/libsystemd/sd-netlink',
+                                'src/libsystemd/sd-network',
+                                'src/libsystemd/sd-resolve',
+diff --git a/src/fuzz/meson.build b/src/fuzz/meson.build
+index c88812d1de..8171bf58c1 100644
+--- a/src/fuzz/meson.build
++++ b/src/fuzz/meson.build
+@@ -33,8 +33,8 @@ fuzzers += [
+          []],
+ 
+         [['src/fuzz/fuzz-lldp.c'],
+-         [libshared,
+-          libsystemd_network],
++         [libbasic,libshared_static,libsystemd_static
++          ],
+          []],
+ 
+         [['src/fuzz/fuzz-ndisc-rs.c',
+@@ -43,8 +43,9 @@ fuzzers += [
+           'src/libsystemd-network/icmp6-util.h',
+           'src/systemd/sd-dhcp6-client.h',
+           'src/systemd/sd-ndisc.h'],
+-         [libshared,
+-          libsystemd_network],
++         [libsystemd_network,
++          libshared
++          ],
+          []],
+ 
+         [['src/fuzz/fuzz-json.c'],
+diff --git a/src/libsystemd-network/lldp-internal.h b/src/libsystemd-network/lldp-internal.h
+deleted file mode 100644
+index 9598438dba..0000000000
+--- a/src/libsystemd-network/lldp-internal.h
++++ /dev/null
+@@ -1,39 +0,0 @@
+-/* SPDX-License-Identifier: LGPL-2.1+ */
+-#pragma once
+-
+-#include "sd-event.h"
+-#include "sd-lldp.h"
+-
+-#include "hashmap.h"
+-#include "log.h"
+-#include "prioq.h"
+-
+-struct sd_lldp {
+-        unsigned n_ref;
+-
+-        int ifindex;
+-        int fd;
+-
+-        sd_event *event;
+-        int64_t event_priority;
+-        sd_event_source *io_event_source;
+-        sd_event_source *timer_event_source;
+-
+-        Prioq *neighbor_by_expiry;
+-        Hashmap *neighbor_by_id;
+-
+-        uint64_t neighbors_max;
+-
+-        sd_lldp_callback_t callback;
+-        void *userdata;
+-
+-        uint16_t capability_mask;
+-
+-        struct ether_addr filter_address;
+-};
+-
+-#define log_lldp_errno(error, fmt, ...) log_internal(LOG_DEBUG, error, PROJECT_FILE, __LINE__, __func__, "LLDP: " fmt, ##__VA_ARGS__)
+-#define log_lldp(fmt, ...) log_lldp_errno(0, fmt, ##__VA_ARGS__)
+-
+-const char* lldp_event_to_string(sd_lldp_event e) _const_;
+-sd_lldp_event lldp_event_from_string(const char *s) _pure_;
+diff --git a/src/libsystemd-network/lldp-neighbor.c b/src/libsystemd-network/lldp-neighbor.c
+deleted file mode 100644
+index 9bae4a3c6e..0000000000
+--- a/src/libsystemd-network/lldp-neighbor.c
++++ /dev/null
+@@ -1,769 +0,0 @@
+-/* SPDX-License-Identifier: LGPL-2.1+ */
+-
+-#include "alloc-util.h"
+-#include "escape.h"
+-#include "ether-addr-util.h"
+-#include "hexdecoct.h"
+-#include "in-addr-util.h"
+-#include "lldp-internal.h"
+-#include "lldp-neighbor.h"
+-#include "memory-util.h"
+-#include "missing.h"
+-#include "unaligned.h"
+-
+-static void lldp_neighbor_id_hash_func(const LLDPNeighborID *id, struct siphash *state) {
+-        siphash24_compress(id->chassis_id, id->chassis_id_size, state);
+-        siphash24_compress(&id->chassis_id_size, sizeof(id->chassis_id_size), state);
+-        siphash24_compress(id->port_id, id->port_id_size, state);
+-        siphash24_compress(&id->port_id_size, sizeof(id->port_id_size), state);
+-}
+-
+-int lldp_neighbor_id_compare_func(const LLDPNeighborID *x, const LLDPNeighborID *y) {
+-        return memcmp_nn(x->chassis_id, x->chassis_id_size, y->chassis_id, y->chassis_id_size)
+-            ?: memcmp_nn(x->port_id, x->port_id_size, y->port_id, y->port_id_size);
+-}
+-
+-DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(lldp_neighbor_hash_ops, LLDPNeighborID, lldp_neighbor_id_hash_func, lldp_neighbor_id_compare_func,
+-                                      sd_lldp_neighbor, lldp_neighbor_unlink);
+-
+-int lldp_neighbor_prioq_compare_func(const void *a, const void *b) {
+-        const sd_lldp_neighbor *x = a, *y = b;
+-
+-        return CMP(x->until, y->until);
+-}
+-
+-_public_ sd_lldp_neighbor *sd_lldp_neighbor_ref(sd_lldp_neighbor *n) {
+-        if (!n)
+-                return NULL;
+-
+-        assert(n->n_ref > 0 || n->lldp);
+-        n->n_ref++;
+-
+-        return n;
+-}
+-
+-static void lldp_neighbor_free(sd_lldp_neighbor *n) {
+-        assert(n);
+-
+-        free(n->id.port_id);
+-        free(n->id.chassis_id);
+-        free(n->port_description);
+-        free(n->system_name);
+-        free(n->system_description);
+-        free(n->chassis_id_as_string);
+-        free(n->port_id_as_string);
+-        free(n);
+-}
+-
+-_public_ sd_lldp_neighbor *sd_lldp_neighbor_unref(sd_lldp_neighbor *n) {
+-
+-        /* Drops one reference from the neighbor. Note that the object is not freed unless it is already unlinked from
+-         * the sd_lldp object. */
+-
+-        if (!n)
+-                return NULL;
+-
+-        assert(n->n_ref > 0);
+-        n->n_ref--;
+-
+-        if (n->n_ref <= 0 && !n->lldp)
+-                lldp_neighbor_free(n);
+-
+-        return NULL;
+-}
+-
+-sd_lldp_neighbor *lldp_neighbor_unlink(sd_lldp_neighbor *n) {
+-
+-        /* Removes the neighbor object from the LLDP object, and frees it if it also has no other reference. */
+-
+-        if (!n)
+-                return NULL;
+-
+-        if (!n->lldp)
+-                return NULL;
+-
+-        /* Only remove the neighbor object from the hash table if it's in there, don't complain if it isn't. This is
+-         * because we are used as destructor call for hashmap_clear() and thus sometimes are called to de-register
+-         * ourselves from the hashtable and sometimes are called after we already are de-registered. */
+-
+-        (void) hashmap_remove_value(n->lldp->neighbor_by_id, &n->id, n);
+-
+-        assert_se(prioq_remove(n->lldp->neighbor_by_expiry, n, &n->prioq_idx) >= 0);
+-
+-        n->lldp = NULL;
+-
+-        if (n->n_ref <= 0)
+-                lldp_neighbor_free(n);
+-
+-        return NULL;
+-}
+-
+-sd_lldp_neighbor *lldp_neighbor_new(size_t raw_size) {
+-        sd_lldp_neighbor *n;
+-
+-        n = malloc0(ALIGN(sizeof(sd_lldp_neighbor)) + raw_size);
+-        if (!n)
+-                return NULL;
+-
+-        n->raw_size = raw_size;
+-        n->n_ref = 1;
+-
+-        return n;
+-}
+-
+-static int parse_string(char **s, const void *q, size_t n) {
+-        const char *p = q;
+-        char *k;
+-
+-        assert(s);
+-        assert(p || n == 0);
+-
+-        if (*s) {
+-                log_lldp("Found duplicate string, ignoring field.");
+-                return 0;
+-        }
+-
+-        /* Strip trailing NULs, just to be nice */
+-        while (n > 0 && p[n-1] == 0)
+-                n--;
+-
+-        if (n <= 0) /* Ignore empty strings */
+-                return 0;
+-
+-        /* Look for inner NULs */
+-        if (memchr(p, 0, n)) {
+-                log_lldp("Found inner NUL in string, ignoring field.");
+-                return 0;
+-        }
+-
+-        /* Let's escape weird chars, for security reasons */
+-        k = cescape_length(p, n);
+-        if (!k)
+-                return -ENOMEM;
+-
+-        free(*s);
+-        *s = k;
+-
+-        return 1;
+-}
+-
+-int lldp_neighbor_parse(sd_lldp_neighbor *n) {
+-        struct ether_header h;
+-        const uint8_t *p;
+-        size_t left;
+-        int r;
+-
+-        assert(n);
+-
+-        if (n->raw_size < sizeof(struct ether_header)) {
+-                log_lldp("Received truncated packet, ignoring.");
+-                return -EBADMSG;
+-        }
+-
+-        memcpy(&h, LLDP_NEIGHBOR_RAW(n), sizeof(h));
+-
+-        if (h.ether_type != htobe16(ETHERTYPE_LLDP)) {
+-                log_lldp("Received packet with wrong type, ignoring.");
+-                return -EBADMSG;
+-        }
+-
+-        if (h.ether_dhost[0] != 0x01 ||
+-            h.ether_dhost[1] != 0x80 ||
+-            h.ether_dhost[2] != 0xc2 ||
+-            h.ether_dhost[3] != 0x00 ||
+-            h.ether_dhost[4] != 0x00 ||
+-            !IN_SET(h.ether_dhost[5], 0x00, 0x03, 0x0e)) {
+-                log_lldp("Received packet with wrong destination address, ignoring.");
+-                return -EBADMSG;
+-        }
+-
+-        memcpy(&n->source_address, h.ether_shost, sizeof(struct ether_addr));
+-        memcpy(&n->destination_address, h.ether_dhost, sizeof(struct ether_addr));
+-
+-        p = (const uint8_t*) LLDP_NEIGHBOR_RAW(n) + sizeof(struct ether_header);
+-        left = n->raw_size - sizeof(struct ether_header);
+-
+-        for (;;) {
+-                uint8_t type;
+-                uint16_t length;
+-
+-                if (left < 2) {
+-                        log_lldp("TLV lacks header, ignoring.");
+-                        return -EBADMSG;
+-                }
+-
+-                type = p[0] >> 1;
+-                length = p[1] + (((uint16_t) (p[0] & 1)) << 8);
+-                p += 2, left -= 2;
+-
+-                if (left < length) {
+-                        log_lldp("TLV truncated, ignoring datagram.");
+-                        return -EBADMSG;
+-                }
+-
+-                switch (type) {
+-
+-                case SD_LLDP_TYPE_END:
+-                        if (length != 0) {
+-                                log_lldp("End marker TLV not zero-sized, ignoring datagram.");
+-                                return -EBADMSG;
+-                        }
+-
+-                        /* Note that after processing the SD_LLDP_TYPE_END left could still be > 0
+-                         * as the message may contain padding (see IEEE 802.1AB-2016, sec. 8.5.12) */
+-
+-                        goto end_marker;
+-
+-                case SD_LLDP_TYPE_CHASSIS_ID:
+-                        if (length < 2 || length > 256) { /* includes the chassis subtype, hence one extra byte */
+-                                log_lldp("Chassis ID field size out of range, ignoring datagram.");
+-                                return -EBADMSG;
+-                        }
+-                        if (n->id.chassis_id) {
+-                                log_lldp("Duplicate chassis ID field, ignoring datagram.");
+-                                return -EBADMSG;
+-                        }
+-
+-                        n->id.chassis_id = memdup(p, length);
+-                        if (!n->id.chassis_id)
+-                                return -ENOMEM;
+-
+-                        n->id.chassis_id_size = length;
+-                        break;
+-
+-                case SD_LLDP_TYPE_PORT_ID:
+-                        if (length < 2 || length > 256) { /* includes the port subtype, hence one extra byte */
+-                                log_lldp("Port ID field size out of range, ignoring datagram.");
+-                                return -EBADMSG;
+-                        }
+-                        if (n->id.port_id) {
+-                                log_lldp("Duplicate port ID field, ignoring datagram.");
+-                                return -EBADMSG;
+-                        }
+-
+-                        n->id.port_id = memdup(p, length);
+-                        if (!n->id.port_id)
+-                                return -ENOMEM;
+-
+-                        n->id.port_id_size = length;
+-                        break;
+-
+-                case SD_LLDP_TYPE_TTL:
+-                        if (length != 2) {
+-                                log_lldp("TTL field has wrong size, ignoring datagram.");
+-                                return -EBADMSG;
+-                        }
+-
+-                        if (n->has_ttl) {
+-                                log_lldp("Duplicate TTL field, ignoring datagram.");
+-                                return -EBADMSG;
+-                        }
+-
+-                        n->ttl = unaligned_read_be16(p);
+-                        n->has_ttl = true;
+-                        break;
+-
+-                case SD_LLDP_TYPE_PORT_DESCRIPTION:
+-                        r = parse_string(&n->port_description, p, length);
+-                        if (r < 0)
+-                                return r;
+-                        break;
+-
+-                case SD_LLDP_TYPE_SYSTEM_NAME:
+-                        r = parse_string(&n->system_name, p, length);
+-                        if (r < 0)
+-                                return r;
+-                        break;
+-
+-                case SD_LLDP_TYPE_SYSTEM_DESCRIPTION:
+-                        r = parse_string(&n->system_description, p, length);
+-                        if (r < 0)
+-                                return r;
+-                        break;
+-
+-                case SD_LLDP_TYPE_SYSTEM_CAPABILITIES:
+-                        if (length != 4)
+-                                log_lldp("System capabilities field has wrong size, ignoring.");
+-                        else {
+-                                n->system_capabilities = unaligned_read_be16(p);
+-                                n->enabled_capabilities = unaligned_read_be16(p + 2);
+-                                n->has_capabilities = true;
+-                        }
+-
+-                        break;
+-
+-                case SD_LLDP_TYPE_PRIVATE:
+-                        if (length < 4)
+-                                log_lldp("Found private TLV that is too short, ignoring.");
+-
+-                        break;
+-                }
+-
+-                p += length, left -= length;
+-        }
+-
+-end_marker:
+-        if (!n->id.chassis_id || !n->id.port_id || !n->has_ttl) {
+-                log_lldp("One or more mandatory TLV missing in datagram. Ignoring.");
+-                return -EBADMSG;
+-
+-        }
+-
+-        n->rindex = sizeof(struct ether_header);
+-
+-        return 0;
+-}
+-
+-void lldp_neighbor_start_ttl(sd_lldp_neighbor *n) {
+-        assert(n);
+-
+-        if (n->ttl > 0) {
+-                usec_t base;
+-
+-                /* Use the packet's timestamp if there is one known */
+-                base = triple_timestamp_by_clock(&n->timestamp, clock_boottime_or_monotonic());
+-                if (base <= 0 || base == USEC_INFINITY)
+-                        base = now(clock_boottime_or_monotonic()); /* Otherwise, take the current time */
+-
+-                n->until = usec_add(base, n->ttl * USEC_PER_SEC);
+-        } else
+-                n->until = 0;
+-
+-        if (n->lldp)
+-                prioq_reshuffle(n->lldp->neighbor_by_expiry, n, &n->prioq_idx);
+-}
+-
+-bool lldp_neighbor_equal(const sd_lldp_neighbor *a, const sd_lldp_neighbor *b) {
+-        if (a == b)
+-                return true;
+-
+-        if (!a || !b)
+-                return false;
+-
+-        if (a->raw_size != b->raw_size)
+-                return false;
+-
+-        return memcmp(LLDP_NEIGHBOR_RAW(a), LLDP_NEIGHBOR_RAW(b), a->raw_size) == 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_source_address(sd_lldp_neighbor *n, struct ether_addr* address) {
+-        assert_return(n, -EINVAL);
+-        assert_return(address, -EINVAL);
+-
+-        *address = n->source_address;
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_destination_address(sd_lldp_neighbor *n, struct ether_addr* address) {
+-        assert_return(n, -EINVAL);
+-        assert_return(address, -EINVAL);
+-
+-        *address = n->destination_address;
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size) {
+-        assert_return(n, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-        assert_return(size, -EINVAL);
+-
+-        *ret = LLDP_NEIGHBOR_RAW(n);
+-        *size = n->raw_size;
+-
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_chassis_id(sd_lldp_neighbor *n, uint8_t *type, const void **ret, size_t *size) {
+-        assert_return(n, -EINVAL);
+-        assert_return(type, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-        assert_return(size, -EINVAL);
+-
+-        assert(n->id.chassis_id_size > 0);
+-
+-        *type = *(uint8_t*) n->id.chassis_id;
+-        *ret = (uint8_t*) n->id.chassis_id + 1;
+-        *size = n->id.chassis_id_size - 1;
+-
+-        return 0;
+-}
+-
+-static int format_mac_address(const void *data, size_t sz, char **ret) {
+-        struct ether_addr a;
+-        char *k;
+-
+-        assert(data || sz <= 0);
+-
+-        if (sz != 7)
+-                return 0;
+-
+-        memcpy(&a, (uint8_t*) data + 1, sizeof(a));
+-
+-        k = new(char, ETHER_ADDR_TO_STRING_MAX);
+-        if (!k)
+-                return -ENOMEM;
+-
+-        *ret = ether_addr_to_string(&a, k);
+-        return 1;
+-}
+-
+-static int format_network_address(const void *data, size_t sz, char **ret) {
+-        union in_addr_union a;
+-        int family, r;
+-
+-        if (sz == 6 && ((uint8_t*) data)[1] == 1) {
+-                memcpy(&a.in, (uint8_t*) data + 2, sizeof(a.in));
+-                family = AF_INET;
+-        } else if (sz == 18 && ((uint8_t*) data)[1] == 2) {
+-                memcpy(&a.in6, (uint8_t*) data + 2, sizeof(a.in6));
+-                family = AF_INET6;
+-        } else
+-                return 0;
+-
+-        r = in_addr_to_string(family, &a, ret);
+-        if (r < 0)
+-                return r;
+-        return 1;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_chassis_id_as_string(sd_lldp_neighbor *n, const char **ret) {
+-        char *k;
+-        int r;
+-
+-        assert_return(n, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-
+-        if (n->chassis_id_as_string) {
+-                *ret = n->chassis_id_as_string;
+-                return 0;
+-        }
+-
+-        assert(n->id.chassis_id_size > 0);
+-
+-        switch (*(uint8_t*) n->id.chassis_id) {
+-
+-        case SD_LLDP_CHASSIS_SUBTYPE_CHASSIS_COMPONENT:
+-        case SD_LLDP_CHASSIS_SUBTYPE_INTERFACE_ALIAS:
+-        case SD_LLDP_CHASSIS_SUBTYPE_PORT_COMPONENT:
+-        case SD_LLDP_CHASSIS_SUBTYPE_INTERFACE_NAME:
+-        case SD_LLDP_CHASSIS_SUBTYPE_LOCALLY_ASSIGNED:
+-                k = cescape_length((char*) n->id.chassis_id + 1, n->id.chassis_id_size - 1);
+-                if (!k)
+-                        return -ENOMEM;
+-
+-                goto done;
+-
+-        case SD_LLDP_CHASSIS_SUBTYPE_MAC_ADDRESS:
+-                r = format_mac_address(n->id.chassis_id, n->id.chassis_id_size, &k);
+-                if (r < 0)
+-                        return r;
+-                if (r > 0)
+-                        goto done;
+-
+-                break;
+-
+-        case SD_LLDP_CHASSIS_SUBTYPE_NETWORK_ADDRESS:
+-                r = format_network_address(n->id.chassis_id, n->id.chassis_id_size, &k);
+-                if (r < 0)
+-                        return r;
+-                if (r > 0)
+-                        goto done;
+-
+-                break;
+-        }
+-
+-        /* Generic fallback */
+-        k = hexmem(n->id.chassis_id, n->id.chassis_id_size);
+-        if (!k)
+-                return -ENOMEM;
+-
+-done:
+-        *ret = n->chassis_id_as_string = k;
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_port_id(sd_lldp_neighbor *n, uint8_t *type, const void **ret, size_t *size) {
+-        assert_return(n, -EINVAL);
+-        assert_return(type, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-        assert_return(size, -EINVAL);
+-
+-        assert(n->id.port_id_size > 0);
+-
+-        *type = *(uint8_t*) n->id.port_id;
+-        *ret = (uint8_t*) n->id.port_id + 1;
+-        *size = n->id.port_id_size - 1;
+-
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_port_id_as_string(sd_lldp_neighbor *n, const char **ret) {
+-        char *k;
+-        int r;
+-
+-        assert_return(n, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-
+-        if (n->port_id_as_string) {
+-                *ret = n->port_id_as_string;
+-                return 0;
+-        }
+-
+-        assert(n->id.port_id_size > 0);
+-
+-        switch (*(uint8_t*) n->id.port_id) {
+-
+-        case SD_LLDP_PORT_SUBTYPE_INTERFACE_ALIAS:
+-        case SD_LLDP_PORT_SUBTYPE_PORT_COMPONENT:
+-        case SD_LLDP_PORT_SUBTYPE_INTERFACE_NAME:
+-        case SD_LLDP_PORT_SUBTYPE_LOCALLY_ASSIGNED:
+-                k = cescape_length((char*) n->id.port_id + 1, n->id.port_id_size - 1);
+-                if (!k)
+-                        return -ENOMEM;
+-
+-                goto done;
+-
+-        case SD_LLDP_PORT_SUBTYPE_MAC_ADDRESS:
+-                r = format_mac_address(n->id.port_id, n->id.port_id_size, &k);
+-                if (r < 0)
+-                        return r;
+-                if (r > 0)
+-                        goto done;
+-
+-                break;
+-
+-        case SD_LLDP_PORT_SUBTYPE_NETWORK_ADDRESS:
+-                r = format_network_address(n->id.port_id, n->id.port_id_size, &k);
+-                if (r < 0)
+-                        return r;
+-                if (r > 0)
+-                        goto done;
+-
+-                break;
+-        }
+-
+-        /* Generic fallback */
+-        k = hexmem(n->id.port_id, n->id.port_id_size);
+-        if (!k)
+-                return -ENOMEM;
+-
+-done:
+-        *ret = n->port_id_as_string = k;
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_ttl(sd_lldp_neighbor *n, uint16_t *ret_sec) {
+-        assert_return(n, -EINVAL);
+-        assert_return(ret_sec, -EINVAL);
+-
+-        *ret_sec = n->ttl;
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_system_name(sd_lldp_neighbor *n, const char **ret) {
+-        assert_return(n, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-
+-        if (!n->system_name)
+-                return -ENODATA;
+-
+-        *ret = n->system_name;
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_system_description(sd_lldp_neighbor *n, const char **ret) {
+-        assert_return(n, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-
+-        if (!n->system_description)
+-                return -ENODATA;
+-
+-        *ret = n->system_description;
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_port_description(sd_lldp_neighbor *n, const char **ret) {
+-        assert_return(n, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-
+-        if (!n->port_description)
+-                return -ENODATA;
+-
+-        *ret = n->port_description;
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_system_capabilities(sd_lldp_neighbor *n, uint16_t *ret) {
+-        assert_return(n, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-
+-        if (!n->has_capabilities)
+-                return -ENODATA;
+-
+-        *ret = n->system_capabilities;
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_enabled_capabilities(sd_lldp_neighbor *n, uint16_t *ret) {
+-        assert_return(n, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-
+-        if (!n->has_capabilities)
+-                return -ENODATA;
+-
+-        *ret = n->enabled_capabilities;
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_from_raw(sd_lldp_neighbor **ret, const void *raw, size_t raw_size) {
+-        _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
+-        int r;
+-
+-        assert_return(ret, -EINVAL);
+-        assert_return(raw || raw_size <= 0, -EINVAL);
+-
+-        n = lldp_neighbor_new(raw_size);
+-        if (!n)
+-                return -ENOMEM;
+-
+-        memcpy(LLDP_NEIGHBOR_RAW(n), raw, raw_size);
+-        r = lldp_neighbor_parse(n);
+-        if (r < 0)
+-                return r;
+-
+-        *ret = TAKE_PTR(n);
+-
+-        return r;
+-}
+-
+-_public_ int sd_lldp_neighbor_tlv_rewind(sd_lldp_neighbor *n) {
+-        assert_return(n, -EINVAL);
+-
+-        assert(n->raw_size >= sizeof(struct ether_header));
+-        n->rindex = sizeof(struct ether_header);
+-
+-        return n->rindex < n->raw_size;
+-}
+-
+-_public_ int sd_lldp_neighbor_tlv_next(sd_lldp_neighbor *n) {
+-        size_t length;
+-
+-        assert_return(n, -EINVAL);
+-
+-        if (n->rindex == n->raw_size) /* EOF */
+-                return -ESPIPE;
+-
+-        if (n->rindex + 2 > n->raw_size) /* Truncated message */
+-                return -EBADMSG;
+-
+-        length = LLDP_NEIGHBOR_TLV_LENGTH(n);
+-        if (n->rindex + 2 + length > n->raw_size)
+-                return -EBADMSG;
+-
+-        n->rindex += 2 + length;
+-        return n->rindex < n->raw_size;
+-}
+-
+-_public_ int sd_lldp_neighbor_tlv_get_type(sd_lldp_neighbor *n, uint8_t *type) {
+-        assert_return(n, -EINVAL);
+-        assert_return(type, -EINVAL);
+-
+-        if (n->rindex == n->raw_size) /* EOF */
+-                return -ESPIPE;
+-
+-        if (n->rindex + 2 > n->raw_size)
+-                return -EBADMSG;
+-
+-        *type = LLDP_NEIGHBOR_TLV_TYPE(n);
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_tlv_is_type(sd_lldp_neighbor *n, uint8_t type) {
+-        uint8_t k;
+-        int r;
+-
+-        assert_return(n, -EINVAL);
+-
+-        r = sd_lldp_neighbor_tlv_get_type(n, &k);
+-        if (r < 0)
+-                return r;
+-
+-        return type == k;
+-}
+-
+-_public_ int sd_lldp_neighbor_tlv_get_oui(sd_lldp_neighbor *n, uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t *subtype) {
+-        const uint8_t *d;
+-        size_t length;
+-        int r;
+-
+-        assert_return(n, -EINVAL);
+-        assert_return(oui, -EINVAL);
+-        assert_return(subtype, -EINVAL);
+-
+-        r = sd_lldp_neighbor_tlv_is_type(n, SD_LLDP_TYPE_PRIVATE);
+-        if (r < 0)
+-                return r;
+-        if (r == 0)
+-                return -ENXIO;
+-
+-        length = LLDP_NEIGHBOR_TLV_LENGTH(n);
+-        if (length < 4)
+-                return -EBADMSG;
+-
+-        if (n->rindex + 2 + length > n->raw_size)
+-                return -EBADMSG;
+-
+-        d = LLDP_NEIGHBOR_TLV_DATA(n);
+-        memcpy(oui, d, 3);
+-        *subtype = d[3];
+-
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_tlv_is_oui(sd_lldp_neighbor *n, const uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t subtype) {
+-        uint8_t k[3], st;
+-        int r;
+-
+-        r = sd_lldp_neighbor_tlv_get_oui(n, k, &st);
+-        if (r == -ENXIO)
+-                return 0;
+-        if (r < 0)
+-                return r;
+-
+-        return memcmp(k, oui, 3) == 0 && st == subtype;
+-}
+-
+-_public_ int sd_lldp_neighbor_tlv_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size) {
+-        size_t length;
+-
+-        assert_return(n, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-        assert_return(size, -EINVAL);
+-
+-        /* Note that this returns the full TLV, including the TLV header */
+-
+-        if (n->rindex + 2 > n->raw_size)
+-                return -EBADMSG;
+-
+-        length = LLDP_NEIGHBOR_TLV_LENGTH(n);
+-        if (n->rindex + 2 + length > n->raw_size)
+-                return -EBADMSG;
+-
+-        *ret = (uint8_t*) LLDP_NEIGHBOR_RAW(n) + n->rindex;
+-        *size = length + 2;
+-
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_neighbor_get_timestamp(sd_lldp_neighbor *n, clockid_t clock, uint64_t *ret) {
+-        assert_return(n, -EINVAL);
+-        assert_return(TRIPLE_TIMESTAMP_HAS_CLOCK(clock), -EOPNOTSUPP);
+-        assert_return(clock_supported(clock), -EOPNOTSUPP);
+-        assert_return(ret, -EINVAL);
+-
+-        if (!triple_timestamp_is_set(&n->timestamp))
+-                return -ENODATA;
+-
+-        *ret = triple_timestamp_by_clock(&n->timestamp, clock);
+-        return 0;
+-}
+diff --git a/src/libsystemd-network/lldp-neighbor.h b/src/libsystemd-network/lldp-neighbor.h
+deleted file mode 100644
+index 62dbff42ca..0000000000
+--- a/src/libsystemd-network/lldp-neighbor.h
++++ /dev/null
+@@ -1,91 +0,0 @@
+-/* SPDX-License-Identifier: LGPL-2.1+ */
+-#pragma once
+-
+-#include <inttypes.h>
+-#include <stdbool.h>
+-#include <sys/types.h>
+-
+-#include "sd-lldp.h"
+-
+-#include "hash-funcs.h"
+-#include "lldp-internal.h"
+-#include "time-util.h"
+-
+-typedef struct LLDPNeighborID {
+-        /* The spec calls this an "MSAP identifier" */
+-        void *chassis_id;
+-        size_t chassis_id_size;
+-
+-        void *port_id;
+-        size_t port_id_size;
+-} LLDPNeighborID;
+-
+-struct sd_lldp_neighbor {
+-        /* Neighbor objects stay around as long as they are linked into an "sd_lldp" object or n_ref > 0. */
+-        sd_lldp *lldp;
+-        unsigned n_ref;
+-
+-        triple_timestamp timestamp;
+-
+-        usec_t until;
+-        unsigned prioq_idx;
+-
+-        struct ether_addr source_address;
+-        struct ether_addr destination_address;
+-
+-        LLDPNeighborID id;
+-
+-        /* The raw packet size. The data is appended to the object, accessible via LLDP_NEIGHBOR_RAW() */
+-        size_t raw_size;
+-
+-        /* The current read index for the iterative TLV interface */
+-        size_t rindex;
+-
+-        /* And a couple of fields parsed out. */
+-        bool has_ttl:1;
+-        bool has_capabilities:1;
+-        bool has_port_vlan_id:1;
+-
+-        uint16_t ttl;
+-
+-        uint16_t system_capabilities;
+-        uint16_t enabled_capabilities;
+-
+-        char *port_description;
+-        char *system_name;
+-        char *system_description;
+-
+-        uint16_t port_vlan_id;
+-
+-        char *chassis_id_as_string;
+-        char *port_id_as_string;
+-};
+-
+-static inline void *LLDP_NEIGHBOR_RAW(const sd_lldp_neighbor *n) {
+-        return (uint8_t*) n + ALIGN(sizeof(sd_lldp_neighbor));
+-}
+-
+-static inline uint8_t LLDP_NEIGHBOR_TLV_TYPE(const sd_lldp_neighbor *n) {
+-        return ((uint8_t*) LLDP_NEIGHBOR_RAW(n))[n->rindex] >> 1;
+-}
+-
+-static inline size_t LLDP_NEIGHBOR_TLV_LENGTH(const sd_lldp_neighbor *n) {
+-        uint8_t *p;
+-
+-        p = (uint8_t*) LLDP_NEIGHBOR_RAW(n) + n->rindex;
+-        return p[1] + (((size_t) (p[0] & 1)) << 8);
+-}
+-
+-static inline void* LLDP_NEIGHBOR_TLV_DATA(const sd_lldp_neighbor *n) {
+-        return ((uint8_t*) LLDP_NEIGHBOR_RAW(n)) + n->rindex + 2;
+-}
+-
+-extern const struct hash_ops lldp_neighbor_hash_ops;
+-int lldp_neighbor_id_compare_func(const LLDPNeighborID *x, const LLDPNeighborID *y);
+-int lldp_neighbor_prioq_compare_func(const void *a, const void *b);
+-
+-sd_lldp_neighbor *lldp_neighbor_unlink(sd_lldp_neighbor *n);
+-sd_lldp_neighbor *lldp_neighbor_new(size_t raw_size);
+-int lldp_neighbor_parse(sd_lldp_neighbor *n);
+-void lldp_neighbor_start_ttl(sd_lldp_neighbor *n);
+-bool lldp_neighbor_equal(const sd_lldp_neighbor *a, const sd_lldp_neighbor *b);
+diff --git a/src/libsystemd-network/lldp-network.c b/src/libsystemd-network/lldp-network.c
+deleted file mode 100644
+index 870584c0db..0000000000
+--- a/src/libsystemd-network/lldp-network.c
++++ /dev/null
+@@ -1,78 +0,0 @@
+-/* SPDX-License-Identifier: LGPL-2.1+ */
+-
+-#include <linux/filter.h>
+-#include <netinet/if_ether.h>
+-
+-#include "fd-util.h"
+-#include "lldp-network.h"
+-#include "missing.h"
+-#include "socket-util.h"
+-
+-int lldp_network_bind_raw_socket(int ifindex) {
+-
+-        static const struct sock_filter filter[] = {
+-                BPF_STMT(BPF_LD + BPF_W + BPF_ABS, offsetof(struct ethhdr, h_dest)),      /* A <- 4 bytes of destination MAC */
+-                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x0180c200, 1, 0),                    /* A != 01:80:c2:00 */
+-                BPF_STMT(BPF_RET + BPF_K, 0),                                             /* drop packet */
+-                BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(struct ethhdr, h_dest) + 4),  /* A <- remaining 2 bytes of destination MAC */
+-                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x0000, 3, 0),                        /* A != 00:00 */
+-                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x0003, 2, 0),                        /* A != 00:03 */
+-                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x000e, 1, 0),                        /* A != 00:0e */
+-                BPF_STMT(BPF_RET + BPF_K, 0),                                             /* drop packet */
+-                BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(struct ethhdr, h_proto)),     /* A <- protocol */
+-                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ETHERTYPE_LLDP, 1, 0),                /* A != ETHERTYPE_LLDP */
+-                BPF_STMT(BPF_RET + BPF_K, 0),                                             /* drop packet */
+-                BPF_STMT(BPF_RET + BPF_K, (uint32_t) -1),                                 /* accept packet */
+-        };
+-
+-        static const struct sock_fprog fprog = {
+-                .len = ELEMENTSOF(filter),
+-                .filter = (struct sock_filter*) filter,
+-        };
+-
+-        struct packet_mreq mreq = {
+-                .mr_ifindex = ifindex,
+-                .mr_type = PACKET_MR_MULTICAST,
+-                .mr_alen = ETH_ALEN,
+-                .mr_address = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x00 }
+-        };
+-
+-        union sockaddr_union saddrll = {
+-                .ll.sll_family = AF_PACKET,
+-                .ll.sll_ifindex = ifindex,
+-        };
+-
+-        _cleanup_close_ int fd = -1;
+-        int r;
+-
+-        assert(ifindex > 0);
+-
+-        fd = socket(PF_PACKET, SOCK_RAW|SOCK_CLOEXEC|SOCK_NONBLOCK,
+-                    htobe16(ETHERTYPE_LLDP));
+-        if (fd < 0)
+-                return -errno;
+-
+-        r = setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &fprog, sizeof(fprog));
+-        if (r < 0)
+-                return -errno;
+-
+-        r = setsockopt(fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
+-        if (r < 0)
+-                return -errno;
+-
+-        mreq.mr_address[ETH_ALEN - 1] = 0x03;
+-        r = setsockopt(fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
+-        if (r < 0)
+-                return -errno;
+-
+-        mreq.mr_address[ETH_ALEN - 1] = 0x0E;
+-        r = setsockopt(fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
+-        if (r < 0)
+-                return -errno;
+-
+-        r = bind(fd, &saddrll.sa, sizeof(saddrll.ll));
+-        if (r < 0)
+-                return -errno;
+-
+-        return TAKE_FD(fd);
+-}
+diff --git a/src/libsystemd-network/lldp-network.h b/src/libsystemd-network/lldp-network.h
+deleted file mode 100644
+index e4ed2898a5..0000000000
+--- a/src/libsystemd-network/lldp-network.h
++++ /dev/null
+@@ -1,6 +0,0 @@
+-/* SPDX-License-Identifier: LGPL-2.1+ */
+-#pragma once
+-
+-#include "sd-event.h"
+-
+-int lldp_network_bind_raw_socket(int ifindex);
+diff --git a/src/libsystemd-network/meson.build b/src/libsystemd-network/meson.build
+index 56d470ff68..88a72aa900 100644
+--- a/src/libsystemd-network/meson.build
++++ b/src/libsystemd-network/meson.build
+@@ -33,12 +33,6 @@ sources = files('''
+         sd-dhcp6-lease.c
+         dhcp-identifier.h
+         dhcp-identifier.c
+-        lldp-internal.h
+-        lldp-network.h
+-        lldp-network.c
+-        lldp-neighbor.h
+-        lldp-neighbor.c
+-        sd-lldp.c
+ '''.split())
+ 
+ network_internal_h = files('network-internal.h')
+diff --git a/src/libsystemd-network/sd-lldp.c b/src/libsystemd-network/sd-lldp.c
+deleted file mode 100644
+index 1f28c5731f..0000000000
+--- a/src/libsystemd-network/sd-lldp.c
++++ /dev/null
+@@ -1,498 +0,0 @@
+-/* SPDX-License-Identifier: LGPL-2.1+ */
+-
+-#include <arpa/inet.h>
+-#include <linux/sockios.h>
+-#include <sys/ioctl.h>
+-
+-#include "sd-lldp.h"
+-
+-#include "alloc-util.h"
+-#include "ether-addr-util.h"
+-#include "event-util.h"
+-#include "fd-util.h"
+-#include "lldp-internal.h"
+-#include "lldp-neighbor.h"
+-#include "lldp-network.h"
+-#include "memory-util.h"
+-#include "socket-util.h"
+-#include "sort-util.h"
+-#include "string-table.h"
+-
+-#define LLDP_DEFAULT_NEIGHBORS_MAX 128U
+-
+-static const char * const lldp_event_table[_SD_LLDP_EVENT_MAX] = {
+-        [SD_LLDP_EVENT_ADDED]   = "added",
+-        [SD_LLDP_EVENT_REMOVED] = "removed",
+-        [SD_LLDP_EVENT_UPDATED]   = "updated",
+-        [SD_LLDP_EVENT_REFRESHED] = "refreshed",
+-};
+-
+-DEFINE_STRING_TABLE_LOOKUP(lldp_event, sd_lldp_event);
+-
+-static void lldp_flush_neighbors(sd_lldp *lldp) {
+-        assert(lldp);
+-
+-        hashmap_clear(lldp->neighbor_by_id);
+-}
+-
+-static void lldp_callback(sd_lldp *lldp, sd_lldp_event event, sd_lldp_neighbor *n) {
+-        assert(lldp);
+-        assert(event >= 0 && event < _SD_LLDP_EVENT_MAX);
+-
+-        if (!lldp->callback) {
+-                log_lldp("Received '%s' event.", lldp_event_to_string(event));
+-                return;
+-        }
+-
+-        log_lldp("Invoking callback for '%s' event.", lldp_event_to_string(event));
+-        lldp->callback(lldp, event, n, lldp->userdata);
+-}
+-
+-static int lldp_make_space(sd_lldp *lldp, size_t extra) {
+-        usec_t t = USEC_INFINITY;
+-        bool changed = false;
+-
+-        assert(lldp);
+-
+-        /* Remove all entries that are past their TTL, and more until at least the specified number of extra entries
+-         * are free. */
+-
+-        for (;;) {
+-                _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
+-
+-                n = prioq_peek(lldp->neighbor_by_expiry);
+-                if (!n)
+-                        break;
+-
+-                sd_lldp_neighbor_ref(n);
+-
+-                if (hashmap_size(lldp->neighbor_by_id) > LESS_BY(lldp->neighbors_max, extra))
+-                        goto remove_one;
+-
+-                if (t == USEC_INFINITY)
+-                        t = now(clock_boottime_or_monotonic());
+-
+-                if (n->until > t)
+-                        break;
+-
+-        remove_one:
+-                lldp_neighbor_unlink(n);
+-                lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, n);
+-                changed = true;
+-        }
+-
+-        return changed;
+-}
+-
+-static bool lldp_keep_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) {
+-        assert(lldp);
+-        assert(n);
+-
+-        /* Don't keep data with a zero TTL */
+-        if (n->ttl <= 0)
+-                return false;
+-
+-        /* Filter out data from the filter address */
+-        if (!ether_addr_is_null(&lldp->filter_address) &&
+-            ether_addr_equal(&lldp->filter_address, &n->source_address))
+-                return false;
+-
+-        /* Only add if the neighbor has a capability we are interested in. Note that we also store all neighbors with
+-         * no caps field set. */
+-        if (n->has_capabilities &&
+-            (n->enabled_capabilities & lldp->capability_mask) == 0)
+-                return false;
+-
+-        /* Keep everything else */
+-        return true;
+-}
+-
+-static int lldp_start_timer(sd_lldp *lldp, sd_lldp_neighbor *neighbor);
+-
+-static int lldp_add_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) {
+-        _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *old = NULL;
+-        bool keep;
+-        int r;
+-
+-        assert(lldp);
+-        assert(n);
+-        assert(!n->lldp);
+-
+-        keep = lldp_keep_neighbor(lldp, n);
+-
+-        /* First retrieve the old entry for this MSAP */
+-        old = hashmap_get(lldp->neighbor_by_id, &n->id);
+-        if (old) {
+-                sd_lldp_neighbor_ref(old);
+-
+-                if (!keep) {
+-                        lldp_neighbor_unlink(old);
+-                        lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, old);
+-                        return 0;
+-                }
+-
+-                if (lldp_neighbor_equal(n, old)) {
+-                        /* Is this equal, then restart the TTL counter, but don't do anything else. */
+-                        old->timestamp = n->timestamp;
+-                        lldp_start_timer(lldp, old);
+-                        lldp_callback(lldp, SD_LLDP_EVENT_REFRESHED, old);
+-                        return 0;
+-                }
+-
+-                /* Data changed, remove the old entry, and add a new one */
+-                lldp_neighbor_unlink(old);
+-
+-        } else if (!keep)
+-                return 0;
+-
+-        /* Then, make room for at least one new neighbor */
+-        lldp_make_space(lldp, 1);
+-
+-        r = hashmap_put(lldp->neighbor_by_id, &n->id, n);
+-        if (r < 0)
+-                goto finish;
+-
+-        r = prioq_put(lldp->neighbor_by_expiry, n, &n->prioq_idx);
+-        if (r < 0) {
+-                assert_se(hashmap_remove(lldp->neighbor_by_id, &n->id) == n);
+-                goto finish;
+-        }
+-
+-        n->lldp = lldp;
+-
+-        lldp_start_timer(lldp, n);
+-        lldp_callback(lldp, old ? SD_LLDP_EVENT_UPDATED : SD_LLDP_EVENT_ADDED, n);
+-
+-        return 1;
+-
+-finish:
+-        if (old)
+-                lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, old);
+-
+-        return r;
+-}
+-
+-static int lldp_handle_datagram(sd_lldp *lldp, sd_lldp_neighbor *n) {
+-        int r;
+-
+-        assert(lldp);
+-        assert(n);
+-
+-        r = lldp_neighbor_parse(n);
+-        if (r == -EBADMSG) /* Ignore bad messages */
+-                return 0;
+-        if (r < 0)
+-                return r;
+-
+-        r = lldp_add_neighbor(lldp, n);
+-        if (r < 0) {
+-                log_lldp_errno(r, "Failed to add datagram. Ignoring.");
+-                return 0;
+-        }
+-
+-        log_lldp("Successfully processed LLDP datagram.");
+-        return 0;
+-}
+-
+-static int lldp_receive_datagram(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
+-        _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
+-        ssize_t space, length;
+-        sd_lldp *lldp = userdata;
+-        struct timespec ts;
+-
+-        assert(fd >= 0);
+-        assert(lldp);
+-
+-        space = next_datagram_size_fd(fd);
+-        if (space < 0)
+-                return log_lldp_errno(space, "Failed to determine datagram size to read: %m");
+-
+-        n = lldp_neighbor_new(space);
+-        if (!n)
+-                return -ENOMEM;
+-
+-        length = recv(fd, LLDP_NEIGHBOR_RAW(n), n->raw_size, MSG_DONTWAIT);
+-        if (length < 0) {
+-                if (IN_SET(errno, EAGAIN, EINTR))
+-                        return 0;
+-
+-                return log_lldp_errno(errno, "Failed to read LLDP datagram: %m");
+-        }
+-
+-        if ((size_t) length != n->raw_size) {
+-                log_lldp("Packet size mismatch.");
+-                return -EINVAL;
+-        }
+-
+-        /* Try to get the timestamp of this packet if it is known */
+-        if (ioctl(fd, SIOCGSTAMPNS, &ts) >= 0)
+-                triple_timestamp_from_realtime(&n->timestamp, timespec_load(&ts));
+-        else
+-                triple_timestamp_get(&n->timestamp);
+-
+-        return lldp_handle_datagram(lldp, n);
+-}
+-
+-static void lldp_reset(sd_lldp *lldp) {
+-        assert(lldp);
+-
+-        (void) event_source_disable(lldp->timer_event_source);
+-        lldp->io_event_source = sd_event_source_unref(lldp->io_event_source);
+-        lldp->fd = safe_close(lldp->fd);
+-}
+-
+-_public_ int sd_lldp_start(sd_lldp *lldp) {
+-        int r;
+-
+-        assert_return(lldp, -EINVAL);
+-        assert_return(lldp->event, -EINVAL);
+-        assert_return(lldp->ifindex > 0, -EINVAL);
+-
+-        if (lldp->fd >= 0)
+-                return 0;
+-
+-        assert(!lldp->io_event_source);
+-
+-        lldp->fd = lldp_network_bind_raw_socket(lldp->ifindex);
+-        if (lldp->fd < 0)
+-                return lldp->fd;
+-
+-        r = sd_event_add_io(lldp->event, &lldp->io_event_source, lldp->fd, EPOLLIN, lldp_receive_datagram, lldp);
+-        if (r < 0)
+-                goto fail;
+-
+-        r = sd_event_source_set_priority(lldp->io_event_source, lldp->event_priority);
+-        if (r < 0)
+-                goto fail;
+-
+-        (void) sd_event_source_set_description(lldp->io_event_source, "lldp-io");
+-
+-        log_lldp("Started LLDP client");
+-        return 1;
+-
+-fail:
+-        lldp_reset(lldp);
+-        return r;
+-}
+-
+-_public_ int sd_lldp_stop(sd_lldp *lldp) {
+-        assert_return(lldp, -EINVAL);
+-
+-        if (lldp->fd < 0)
+-                return 0;
+-
+-        log_lldp("Stopping LLDP client");
+-
+-        lldp_reset(lldp);
+-        lldp_flush_neighbors(lldp);
+-
+-        return 1;
+-}
+-
+-_public_ int sd_lldp_attach_event(sd_lldp *lldp, sd_event *event, int64_t priority) {
+-        int r;
+-
+-        assert_return(lldp, -EINVAL);
+-        assert_return(lldp->fd < 0, -EBUSY);
+-        assert_return(!lldp->event, -EBUSY);
+-
+-        if (event)
+-                lldp->event = sd_event_ref(event);
+-        else {
+-                r = sd_event_default(&lldp->event);
+-                if (r < 0)
+-                        return r;
+-        }
+-
+-        lldp->event_priority = priority;
+-
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_detach_event(sd_lldp *lldp) {
+-
+-        assert_return(lldp, -EINVAL);
+-        assert_return(lldp->fd < 0, -EBUSY);
+-
+-        lldp->event = sd_event_unref(lldp->event);
+-        return 0;
+-}
+-
+-_public_ sd_event* sd_lldp_get_event(sd_lldp *lldp) {
+-        assert_return(lldp, NULL);
+-
+-        return lldp->event;
+-}
+-
+-_public_ int sd_lldp_set_callback(sd_lldp *lldp, sd_lldp_callback_t cb, void *userdata) {
+-        assert_return(lldp, -EINVAL);
+-
+-        lldp->callback = cb;
+-        lldp->userdata = userdata;
+-
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_set_ifindex(sd_lldp *lldp, int ifindex) {
+-        assert_return(lldp, -EINVAL);
+-        assert_return(ifindex > 0, -EINVAL);
+-        assert_return(lldp->fd < 0, -EBUSY);
+-
+-        lldp->ifindex = ifindex;
+-        return 0;
+-}
+-
+-static sd_lldp* lldp_free(sd_lldp *lldp) {
+-        assert(lldp);
+-
+-        lldp->timer_event_source = sd_event_source_unref(lldp->timer_event_source);
+-
+-        lldp_reset(lldp);
+-        sd_lldp_detach_event(lldp);
+-        lldp_flush_neighbors(lldp);
+-
+-        hashmap_free(lldp->neighbor_by_id);
+-        prioq_free(lldp->neighbor_by_expiry);
+-        return mfree(lldp);
+-}
+-
+-DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_lldp, sd_lldp, lldp_free);
+-
+-_public_ int sd_lldp_new(sd_lldp **ret) {
+-        _cleanup_(sd_lldp_unrefp) sd_lldp *lldp = NULL;
+-        int r;
+-
+-        assert_return(ret, -EINVAL);
+-
+-        lldp = new(sd_lldp, 1);
+-        if (!lldp)
+-                return -ENOMEM;
+-
+-        *lldp = (sd_lldp) {
+-                .n_ref = 1,
+-                .fd = -1,
+-                .neighbors_max = LLDP_DEFAULT_NEIGHBORS_MAX,
+-                .capability_mask = (uint16_t) -1,
+-        };
+-
+-        lldp->neighbor_by_id = hashmap_new(&lldp_neighbor_hash_ops);
+-        if (!lldp->neighbor_by_id)
+-                return -ENOMEM;
+-
+-        r = prioq_ensure_allocated(&lldp->neighbor_by_expiry, lldp_neighbor_prioq_compare_func);
+-        if (r < 0)
+-                return r;
+-
+-        *ret = TAKE_PTR(lldp);
+-
+-        return 0;
+-}
+-
+-static int neighbor_compare_func(sd_lldp_neighbor * const *a, sd_lldp_neighbor * const *b) {
+-        return lldp_neighbor_id_compare_func(&(*a)->id, &(*b)->id);
+-}
+-
+-static int on_timer_event(sd_event_source *s, uint64_t usec, void *userdata) {
+-        sd_lldp *lldp = userdata;
+-        int r;
+-
+-        r = lldp_make_space(lldp, 0);
+-        if (r < 0)
+-                return log_lldp_errno(r, "Failed to make space: %m");
+-
+-        r = lldp_start_timer(lldp, NULL);
+-        if (r < 0)
+-                return log_lldp_errno(r, "Failed to restart timer: %m");
+-
+-        return 0;
+-}
+-
+-static int lldp_start_timer(sd_lldp *lldp, sd_lldp_neighbor *neighbor) {
+-        sd_lldp_neighbor *n;
+-
+-        assert(lldp);
+-
+-        if (neighbor)
+-                lldp_neighbor_start_ttl(neighbor);
+-
+-        n = prioq_peek(lldp->neighbor_by_expiry);
+-        if (!n)
+-                return event_source_disable(lldp->timer_event_source);
+-
+-        if (!lldp->event)
+-                return 0;
+-
+-        return event_reset_time(lldp->event, &lldp->timer_event_source,
+-                                clock_boottime_or_monotonic(),
+-                                n->until, 0,
+-                                on_timer_event, lldp,
+-                                lldp->event_priority, "lldp-timer", true);
+-}
+-
+-_public_ int sd_lldp_get_neighbors(sd_lldp *lldp, sd_lldp_neighbor ***ret) {
+-        sd_lldp_neighbor **l = NULL, *n;
+-        Iterator i;
+-        int k = 0, r;
+-
+-        assert_return(lldp, -EINVAL);
+-        assert_return(ret, -EINVAL);
+-
+-        if (hashmap_isempty(lldp->neighbor_by_id)) { /* Special shortcut */
+-                *ret = NULL;
+-                return 0;
+-        }
+-
+-        l = new0(sd_lldp_neighbor*, hashmap_size(lldp->neighbor_by_id));
+-        if (!l)
+-                return -ENOMEM;
+-
+-        r = lldp_start_timer(lldp, NULL);
+-        if (r < 0) {
+-                free(l);
+-                return r;
+-        }
+-
+-        HASHMAP_FOREACH(n, lldp->neighbor_by_id, i)
+-                l[k++] = sd_lldp_neighbor_ref(n);
+-
+-        assert((size_t) k == hashmap_size(lldp->neighbor_by_id));
+-
+-        /* Return things in a stable order */
+-        typesafe_qsort(l, k, neighbor_compare_func);
+-        *ret = l;
+-
+-        return k;
+-}
+-
+-_public_ int sd_lldp_set_neighbors_max(sd_lldp *lldp, uint64_t m) {
+-        assert_return(lldp, -EINVAL);
+-        assert_return(m <= 0, -EINVAL);
+-
+-        lldp->neighbors_max = m;
+-        lldp_make_space(lldp, 0);
+-
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_match_capabilities(sd_lldp *lldp, uint16_t mask) {
+-        assert_return(lldp, -EINVAL);
+-        assert_return(mask != 0, -EINVAL);
+-
+-        lldp->capability_mask = mask;
+-
+-        return 0;
+-}
+-
+-_public_ int sd_lldp_set_filter_address(sd_lldp *lldp, const struct ether_addr *addr) {
+-        assert_return(lldp, -EINVAL);
+-
+-        /* In order to deal nicely with bridges that send back our own packets, allow one address to be filtered, so
+-         * that our own can be filtered out here. */
+-
+-        if (addr)
+-                lldp->filter_address = *addr;
+-        else
+-                zero(lldp->filter_address);
+-
+-        return 0;
+-}
+diff --git a/src/libsystemd-network/test-lldp.c b/src/libsystemd-network/test-lldp.c
+deleted file mode 100644
+index 7406f94ce0..0000000000
+--- a/src/libsystemd-network/test-lldp.c
++++ /dev/null
+@@ -1,379 +0,0 @@
+-/* SPDX-License-Identifier: LGPL-2.1+ */
+-
+-#include <arpa/inet.h>
+-#include <errno.h>
+-#include <net/ethernet.h>
+-#include <stdio.h>
+-#include <string.h>
+-#include <unistd.h>
+-
+-#include "sd-event.h"
+-#include "sd-lldp.h"
+-
+-#include "alloc-util.h"
+-#include "fd-util.h"
+-#include "lldp-network.h"
+-#include "macro.h"
+-#include "string-util.h"
+-#include "tests.h"
+-
+-#define TEST_LLDP_PORT "em1"
+-#define TEST_LLDP_TYPE_SYSTEM_NAME "systemd-lldp"
+-#define TEST_LLDP_TYPE_SYSTEM_DESC "systemd-lldp-desc"
+-
+-static int test_fd[2] = { -1, -1 };
+-static int lldp_handler_calls;
+-
+-int lldp_network_bind_raw_socket(int ifindex) {
+-        if (socketpair(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) < 0)
+-                return -errno;
+-
+-        return test_fd[0];
+-}
+-
+-static void lldp_handler(sd_lldp *lldp, sd_lldp_event event, sd_lldp_neighbor *n, void *userdata) {
+-        lldp_handler_calls++;
+-}
+-
+-static int start_lldp(sd_lldp **lldp, sd_event *e, sd_lldp_callback_t cb, void *cb_data) {
+-        int r;
+-
+-        r = sd_lldp_new(lldp);
+-        if (r < 0)
+-                return r;
+-
+-        r = sd_lldp_set_ifindex(*lldp, 42);
+-        if (r < 0)
+-                return r;
+-
+-        r = sd_lldp_set_callback(*lldp, cb, cb_data);
+-        if (r < 0)
+-                return r;
+-
+-        r = sd_lldp_attach_event(*lldp, e, 0);
+-        if (r < 0)
+-                return r;
+-
+-        r = sd_lldp_start(*lldp);
+-        if (r < 0)
+-                return r;
+-
+-        return 0;
+-}
+-
+-static int stop_lldp(sd_lldp *lldp) {
+-        int r;
+-
+-        r = sd_lldp_stop(lldp);
+-        if (r < 0)
+-                return r;
+-
+-        r = sd_lldp_detach_event(lldp);
+-        if (r < 0)
+-                return r;
+-
+-        sd_lldp_unref(lldp);
+-        safe_close(test_fd[1]);
+-
+-        return 0;
+-}
+-
+-static void test_receive_basic_packet(sd_event *e) {
+-
+-        static const uint8_t frame[] = {
+-                /* Ethernet header */
+-                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
+-                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
+-                0x88, 0xcc,                             /* Ethertype */
+-                /* LLDP mandatory TLVs */
+-                0x02, 0x07, 0x04, 0x00, 0x01, 0x02,     /* Chassis: MAC, 00:01:02:03:04:05 */
+-                0x03, 0x04, 0x05,
+-                0x04, 0x04, 0x05, 0x31, 0x2f, 0x33,     /* Port: interface name, "1/3" */
+-                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
+-                /* LLDP optional TLVs */
+-                0x08, 0x04, 0x50, 0x6f, 0x72, 0x74,     /* Port Description: "Port" */
+-                0x0a, 0x03, 0x53, 0x59, 0x53,           /* System Name: "SYS" */
+-                0x0c, 0x04, 0x66, 0x6f, 0x6f, 0x00,     /* System Description: "foo" (NULL-terminated) */
+-                0x00, 0x00                              /* End Of LLDPDU */
+-        };
+-
+-        sd_lldp *lldp;
+-        sd_lldp_neighbor **neighbors;
+-        uint8_t type;
+-        const void *data;
+-        uint16_t ttl;
+-        size_t length;
+-        const char *str;
+-
+-        lldp_handler_calls = 0;
+-        assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0);
+-
+-        assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
+-        sd_event_run(e, 0);
+-        assert_se(lldp_handler_calls == 1);
+-        assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 1);
+-
+-        assert_se(sd_lldp_neighbor_get_chassis_id(neighbors[0], &type, &data, &length) == 0);
+-        assert_se(type == SD_LLDP_CHASSIS_SUBTYPE_MAC_ADDRESS);
+-        assert_se(length == ETH_ALEN);
+-        assert_se(!memcmp(data, "\x00\x01\x02\x03\x04\x05", ETH_ALEN));
+-
+-        assert_se(sd_lldp_neighbor_get_port_id(neighbors[0], &type, &data, &length) == 0);
+-        assert_se(type == SD_LLDP_PORT_SUBTYPE_INTERFACE_NAME);
+-        assert_se(length == 3);
+-        assert_se(!memcmp(data, "1/3", 3));
+-
+-        assert_se(sd_lldp_neighbor_get_port_description(neighbors[0], &str) == 0);
+-        assert_se(streq(str, "Port"));
+-
+-        assert_se(sd_lldp_neighbor_get_system_name(neighbors[0], &str) == 0);
+-        assert_se(streq(str, "SYS"));
+-
+-        assert_se(sd_lldp_neighbor_get_system_description(neighbors[0], &str) == 0);
+-        assert_se(streq(str, "foo"));
+-
+-        assert_se(sd_lldp_neighbor_get_ttl(neighbors[0], &ttl) == 0);
+-        assert_se(ttl == 120);
+-
+-        sd_lldp_neighbor_unref(neighbors[0]);
+-        free(neighbors);
+-
+-        assert_se(stop_lldp(lldp) == 0);
+-}
+-
+-static void test_receive_incomplete_packet(sd_event *e) {
+-        sd_lldp *lldp;
+-        sd_lldp_neighbor **neighbors;
+-        uint8_t frame[] = {
+-                /* Ethernet header */
+-                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
+-                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
+-                0x88, 0xcc,                             /* Ethertype */
+-                /* LLDP mandatory TLVs */
+-                0x02, 0x07, 0x04, 0x00, 0x01, 0x02,     /* Chassis: MAC, 00:01:02:03:04:05 */
+-                0x03, 0x04, 0x05,
+-                0x04, 0x04, 0x05, 0x31, 0x2f, 0x33,     /* Port: interface name, "1/3" */
+-                                                        /* Missing TTL */
+-                0x00, 0x00                              /* End Of LLDPDU */
+-        };
+-
+-        lldp_handler_calls = 0;
+-        assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0);
+-
+-        assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
+-        sd_event_run(e, 0);
+-        assert_se(lldp_handler_calls == 0);
+-        assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 0);
+-
+-        assert_se(stop_lldp(lldp) == 0);
+-}
+-
+-static void test_receive_oui_packet(sd_event *e) {
+-        sd_lldp *lldp;
+-        sd_lldp_neighbor **neighbors;
+-        uint8_t frame[] = {
+-                /* Ethernet header */
+-                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
+-                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
+-                0x88, 0xcc,                             /* Ethertype */
+-                /* LLDP mandatory TLVs */
+-                0x02, 0x07, 0x04, 0x00, 0x01, 0x02,     /* Chassis: MAC, 00:01:02:03:04:05 */
+-                0x03, 0x04, 0x05,
+-                0x04, 0x04, 0x05, 0x31, 0x2f, 0x33,     /* Port TLV: interface name, "1/3" */
+-                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
+-                /* LLDP optional TLVs */
+-                0xfe, 0x06, 0x00, 0x80, 0xc2, 0x01,     /* Port VLAN ID: 0x1234 */
+-                0x12, 0x34,
+-                0xfe, 0x07, 0x00, 0x80, 0xc2, 0x02,     /* Port and protocol: flag 1, PPVID 0x7788 */
+-                0x01, 0x77, 0x88,
+-                0xfe, 0x0d, 0x00, 0x80, 0xc2, 0x03,     /* VLAN Name: ID 0x1234, name "Vlan51" */
+-                0x12, 0x34, 0x06, 0x56, 0x6c, 0x61,
+-                0x6e, 0x35, 0x31,
+-                0xfe, 0x06, 0x00, 0x80, 0xc2, 0x06,     /* Management VID: 0x0102 */
+-                0x01, 0x02,
+-                0xfe, 0x09, 0x00, 0x80, 0xc2, 0x07,     /* Link aggregation: status 1, ID 0x00140012 */
+-                0x01, 0x00, 0x14, 0x00, 0x12,
+-                0xfe, 0x07, 0x00, 0x12, 0x0f, 0x02,     /* 802.3 Power via MDI: PSE, MDI enabled */
+-                0x07, 0x01, 0x00,
+-                0x00, 0x00                              /* End of LLDPDU */
+-        };
+-
+-        lldp_handler_calls = 0;
+-        assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0);
+-
+-        assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
+-        sd_event_run(e, 0);
+-        assert_se(lldp_handler_calls == 1);
+-        assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 1);
+-
+-        assert_se(sd_lldp_neighbor_tlv_rewind(neighbors[0]) >= 0);
+-        assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_CHASSIS_ID) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_PORT_ID) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_TTL) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_PORT_VLAN_ID) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_PORT_PROTOCOL_VLAN_ID) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_VLAN_NAME) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_MANAGEMENT_VID) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_LINK_AGGREGATION) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_3, SD_LLDP_OUI_802_3_SUBTYPE_POWER_VIA_MDI) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_END) > 0);
+-        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) == 0);
+-
+-        sd_lldp_neighbor_unref(neighbors[0]);
+-        free(neighbors);
+-
+-        assert_se(stop_lldp(lldp) == 0);
+-}
+-
+-static void test_multiple_neighbors_sorted(sd_event *e) {
+-
+-        static const uint8_t frame1[] = {
+-                /* Ethernet header */
+-                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
+-                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
+-                0x88, 0xcc,                             /* Ethertype */
+-                /* LLDP mandatory TLVs */
+-                0x02, 0x04, 0x01, '1', '/', '2',        /* Chassis component: "1/2" */
+-                0x04, 0x04, 0x02, '2', '/', '3',        /* Port component: "2/3" */
+-                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
+-                0x00, 0x00                              /* End Of LLDPDU */
+-        };
+-        static const uint8_t frame2[] = {
+-                /* Ethernet header */
+-                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
+-                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
+-                0x88, 0xcc,                             /* Ethertype */
+-                /* LLDP mandatory TLVs */
+-                0x02, 0x04, 0x01, '2', '/', '1',        /* Chassis component: "2/1" */
+-                0x04, 0x04, 0x02, '1', '/', '3',        /* Port component: "1/3" */
+-                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
+-                0x00, 0x00                              /* End Of LLDPDU */
+-        };
+-        static const uint8_t frame3[] = {
+-                /* Ethernet header */
+-                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
+-                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
+-                0x88, 0xcc,                             /* Ethertype */
+-                /* LLDP mandatory TLVs */
+-                0x02, 0x05, 0x01, '2', '/', '1', '0',   /* Chassis component: "2/10" */
+-                0x04, 0x04, 0x02, '1', '/', '0',        /* Port component: "1/0" */
+-                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
+-                0x00, 0x00                              /* End Of LLDPDU */
+-        };
+-        static const uint8_t frame4[] = {
+-                /* Ethernet header */
+-                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
+-                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
+-                0x88, 0xcc,                             /* Ethertype */
+-                /* LLDP mandatory TLVs */
+-                0x02, 0x05, 0x01, '2', '/', '1', '9',   /* Chassis component: "2/19" */
+-                0x04, 0x04, 0x02, '1', '/', '0',        /* Port component: "1/0" */
+-                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
+-                0x00, 0x00                              /* End Of LLDPDU */
+-        };
+-        static const uint8_t frame5[] = {
+-                /* Ethernet header */
+-                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
+-                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
+-                0x88, 0xcc,                             /* Ethertype */
+-                /* LLDP mandatory TLVs */
+-                0x02, 0x04, 0x01, '1', '/', '2',        /* Chassis component: "1/2" */
+-                0x04, 0x05, 0x02, '2', '/', '1', '0',   /* Port component: "2/10" */
+-                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
+-                0x00, 0x00                              /* End Of LLDPDU */
+-        };
+-        static const uint8_t frame6[] = {
+-                /* Ethernet header */
+-                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
+-                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
+-                0x88, 0xcc,                             /* Ethertype */
+-                /* LLDP mandatory TLVs */
+-                0x02, 0x04, 0x01, '1', '/', '2',        /* Chassis component: "1/2" */
+-                0x04, 0x05, 0x02, '2', '/', '3', '9',   /* Port component: "2/10" */
+-                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
+-                0x00, 0x00                              /* End Of LLDPDU */
+-        };
+-        static const char* expected[] = {
+-                /* ordered pairs of Chassis+Port */
+-                "1/2", "2/10",
+-                "1/2", "2/3",
+-                "1/2", "2/39",
+-                "2/1", "1/3",
+-                "2/10", "1/0",
+-                "2/19", "1/0",
+-        };
+-
+-        sd_lldp *lldp;
+-        sd_lldp_neighbor **neighbors;
+-        int i;
+-        uint8_t type;
+-        const void *data;
+-        size_t length, expected_length;
+-        uint16_t ttl;
+-
+-        lldp_handler_calls = 0;
+-        assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0);
+-
+-        assert_se(write(test_fd[1], frame1, sizeof(frame1)) == sizeof(frame1));
+-        sd_event_run(e, 0);
+-        assert_se(write(test_fd[1], frame2, sizeof(frame2)) == sizeof(frame2));
+-        sd_event_run(e, 0);
+-        assert_se(write(test_fd[1], frame3, sizeof(frame3)) == sizeof(frame3));
+-        sd_event_run(e, 0);
+-        assert_se(write(test_fd[1], frame4, sizeof(frame4)) == sizeof(frame4));
+-        sd_event_run(e, 0);
+-        assert_se(write(test_fd[1], frame5, sizeof(frame5)) == sizeof(frame5));
+-        sd_event_run(e, 0);
+-        assert_se(write(test_fd[1], frame6, sizeof(frame6)) == sizeof(frame6));
+-        sd_event_run(e, 0);
+-        assert_se(lldp_handler_calls == 6);
+-
+-        assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 6);
+-
+-        for (i = 0; i < 6; i++) {
+-                assert_se(sd_lldp_neighbor_get_chassis_id(neighbors[i], &type, &data, &length) == 0);
+-                assert_se(type == SD_LLDP_CHASSIS_SUBTYPE_CHASSIS_COMPONENT);
+-                expected_length = strlen(expected[2 * i]);
+-                assert_se(length == expected_length);
+-                assert_se(memcmp(data, expected[2 * i], expected_length) == 0);
+-
+-                assert_se(sd_lldp_neighbor_get_port_id(neighbors[i], &type, &data, &length) == 0);
+-                assert_se(type == SD_LLDP_PORT_SUBTYPE_PORT_COMPONENT);
+-                expected_length = strlen(expected[2 * i + 1]);
+-                assert_se(length == expected_length);
+-                assert_se(memcmp(data, expected[2 * i + 1], expected_length) == 0);
+-
+-                assert_se(sd_lldp_neighbor_get_ttl(neighbors[i], &ttl) == 0);
+-                assert_se(ttl == 120);
+-        }
+-
+-        for (i = 0; i < 6; i++)
+-                sd_lldp_neighbor_unref(neighbors[i]);
+-        free(neighbors);
+-
+-        assert_se(stop_lldp(lldp) == 0);
+-}
+-
+-int main(int argc, char *argv[]) {
+-        _cleanup_(sd_event_unrefp) sd_event *e = NULL;
+-
+-        test_setup_logging(LOG_DEBUG);
+-
+-        /* LLDP reception tests */
+-        assert_se(sd_event_new(&e) == 0);
+-        test_receive_basic_packet(e);
+-        test_receive_incomplete_packet(e);
+-        test_receive_oui_packet(e);
+-        test_multiple_neighbors_sorted(e);
+-
+-        return 0;
+-}
+diff --git a/src/libsystemd/libsystemd.sym b/src/libsystemd/libsystemd.sym
+index 5ec42e0f1f..48021b86d3 100644
+--- a/src/libsystemd/libsystemd.sym
++++ b/src/libsystemd/libsystemd.sym
+@@ -681,4 +681,45 @@ LIBSYSTEMD_243 {
+ global:
+         sd_bus_object_vtable_format;
+         sd_event_source_disable_unref;
++
++        sd_lldp_new;
++        sd_lldp_ref;
++        sd_lldp_unref;
++        sd_lldp_start;
++        sd_lldp_stop;
++        sd_lldp_attach_event;
++        sd_lldp_detach_event;
++        sd_lldp_get_event;
++        sd_lldp_set_callback;
++        sd_lldp_set_ifindex;
++        sd_lldp_set_neighbors_max;
++        sd_lldp_match_capabilities;
++        sd_lldp_set_filter_address;
++        sd_lldp_get_neighbors;
++        sd_lldp_neighbor_from_raw;
++        sd_lldp_neighbor_ref;
++        sd_lldp_neighbor_unref;
++        sd_lldp_neighbor_get_source_address;
++        sd_lldp_neighbor_get_destination_address;
++        sd_lldp_neighbor_get_timestamp;
++        sd_lldp_neighbor_get_raw;
++        sd_lldp_neighbor_get_chassis_id;
++        sd_lldp_neighbor_get_chassis_id_as_string;
++        sd_lldp_neighbor_get_port_id;
++        sd_lldp_neighbor_get_port_id_as_string;
++        sd_lldp_neighbor_get_ttl;
++        sd_lldp_neighbor_get_system_name;
++        sd_lldp_neighbor_get_system_description;
++        sd_lldp_neighbor_get_port_description;
++        sd_lldp_neighbor_get_mud_url;
++        sd_lldp_neighbor_get_system_capabilities;
++        sd_lldp_neighbor_get_enabled_capabilities;
++        sd_lldp_neighbor_tlv_rewind;
++        sd_lldp_neighbor_tlv_next;
++        sd_lldp_neighbor_tlv_get_type;
++        sd_lldp_neighbor_tlv_is_type;
++        sd_lldp_neighbor_tlv_get_oui;
++        sd_lldp_neighbor_tlv_is_oui;
++        sd_lldp_neighbor_tlv_get_raw;
++
+ } LIBSYSTEMD_241;
+diff --git a/src/libsystemd/meson.build b/src/libsystemd/meson.build
+index 77fe6e780f..e60853959f 100644
+--- a/src/libsystemd/meson.build
++++ b/src/libsystemd/meson.build
+@@ -70,6 +70,12 @@ libsystemd_sources = files('''
+         sd-hwdb/hwdb-util.c
+         sd-hwdb/hwdb-util.h
+         sd-hwdb/sd-hwdb.c
++        sd-lldp/sd-lldp.c
++        sd-lldp/lldp-internal.h
++        sd-lldp/lldp-neighbor.c
++        sd-lldp/lldp-neighbor.h
++        sd-lldp/lldp-network.c
++        sd-lldp/lldp-network.h
+         sd-netlink/generic-netlink.c
+         sd-netlink/netlink-internal.h
+         sd-netlink/netlink-message.c
+diff --git a/src/libsystemd/sd-lldp/lldp-internal.h b/src/libsystemd/sd-lldp/lldp-internal.h
+new file mode 100644
+index 0000000000..9598438dba
+--- /dev/null
++++ b/src/libsystemd/sd-lldp/lldp-internal.h
+@@ -0,0 +1,39 @@
++/* SPDX-License-Identifier: LGPL-2.1+ */
++#pragma once
++
++#include "sd-event.h"
++#include "sd-lldp.h"
++
++#include "hashmap.h"
++#include "log.h"
++#include "prioq.h"
++
++struct sd_lldp {
++        unsigned n_ref;
++
++        int ifindex;
++        int fd;
++
++        sd_event *event;
++        int64_t event_priority;
++        sd_event_source *io_event_source;
++        sd_event_source *timer_event_source;
++
++        Prioq *neighbor_by_expiry;
++        Hashmap *neighbor_by_id;
++
++        uint64_t neighbors_max;
++
++        sd_lldp_callback_t callback;
++        void *userdata;
++
++        uint16_t capability_mask;
++
++        struct ether_addr filter_address;
++};
++
++#define log_lldp_errno(error, fmt, ...) log_internal(LOG_DEBUG, error, PROJECT_FILE, __LINE__, __func__, "LLDP: " fmt, ##__VA_ARGS__)
++#define log_lldp(fmt, ...) log_lldp_errno(0, fmt, ##__VA_ARGS__)
++
++const char* lldp_event_to_string(sd_lldp_event e) _const_;
++sd_lldp_event lldp_event_from_string(const char *s) _pure_;
+diff --git a/src/libsystemd/sd-lldp/lldp-neighbor.c b/src/libsystemd/sd-lldp/lldp-neighbor.c
+new file mode 100644
+index 0000000000..9bae4a3c6e
+--- /dev/null
++++ b/src/libsystemd/sd-lldp/lldp-neighbor.c
+@@ -0,0 +1,769 @@
++/* SPDX-License-Identifier: LGPL-2.1+ */
++
++#include "alloc-util.h"
++#include "escape.h"
++#include "ether-addr-util.h"
++#include "hexdecoct.h"
++#include "in-addr-util.h"
++#include "lldp-internal.h"
++#include "lldp-neighbor.h"
++#include "memory-util.h"
++#include "missing.h"
++#include "unaligned.h"
++
++static void lldp_neighbor_id_hash_func(const LLDPNeighborID *id, struct siphash *state) {
++        siphash24_compress(id->chassis_id, id->chassis_id_size, state);
++        siphash24_compress(&id->chassis_id_size, sizeof(id->chassis_id_size), state);
++        siphash24_compress(id->port_id, id->port_id_size, state);
++        siphash24_compress(&id->port_id_size, sizeof(id->port_id_size), state);
++}
++
++int lldp_neighbor_id_compare_func(const LLDPNeighborID *x, const LLDPNeighborID *y) {
++        return memcmp_nn(x->chassis_id, x->chassis_id_size, y->chassis_id, y->chassis_id_size)
++            ?: memcmp_nn(x->port_id, x->port_id_size, y->port_id, y->port_id_size);
++}
++
++DEFINE_HASH_OPS_WITH_VALUE_DESTRUCTOR(lldp_neighbor_hash_ops, LLDPNeighborID, lldp_neighbor_id_hash_func, lldp_neighbor_id_compare_func,
++                                      sd_lldp_neighbor, lldp_neighbor_unlink);
++
++int lldp_neighbor_prioq_compare_func(const void *a, const void *b) {
++        const sd_lldp_neighbor *x = a, *y = b;
++
++        return CMP(x->until, y->until);
++}
++
++_public_ sd_lldp_neighbor *sd_lldp_neighbor_ref(sd_lldp_neighbor *n) {
++        if (!n)
++                return NULL;
++
++        assert(n->n_ref > 0 || n->lldp);
++        n->n_ref++;
++
++        return n;
++}
++
++static void lldp_neighbor_free(sd_lldp_neighbor *n) {
++        assert(n);
++
++        free(n->id.port_id);
++        free(n->id.chassis_id);
++        free(n->port_description);
++        free(n->system_name);
++        free(n->system_description);
++        free(n->chassis_id_as_string);
++        free(n->port_id_as_string);
++        free(n);
++}
++
++_public_ sd_lldp_neighbor *sd_lldp_neighbor_unref(sd_lldp_neighbor *n) {
++
++        /* Drops one reference from the neighbor. Note that the object is not freed unless it is already unlinked from
++         * the sd_lldp object. */
++
++        if (!n)
++                return NULL;
++
++        assert(n->n_ref > 0);
++        n->n_ref--;
++
++        if (n->n_ref <= 0 && !n->lldp)
++                lldp_neighbor_free(n);
++
++        return NULL;
++}
++
++sd_lldp_neighbor *lldp_neighbor_unlink(sd_lldp_neighbor *n) {
++
++        /* Removes the neighbor object from the LLDP object, and frees it if it also has no other reference. */
++
++        if (!n)
++                return NULL;
++
++        if (!n->lldp)
++                return NULL;
++
++        /* Only remove the neighbor object from the hash table if it's in there, don't complain if it isn't. This is
++         * because we are used as destructor call for hashmap_clear() and thus sometimes are called to de-register
++         * ourselves from the hashtable and sometimes are called after we already are de-registered. */
++
++        (void) hashmap_remove_value(n->lldp->neighbor_by_id, &n->id, n);
++
++        assert_se(prioq_remove(n->lldp->neighbor_by_expiry, n, &n->prioq_idx) >= 0);
++
++        n->lldp = NULL;
++
++        if (n->n_ref <= 0)
++                lldp_neighbor_free(n);
++
++        return NULL;
++}
++
++sd_lldp_neighbor *lldp_neighbor_new(size_t raw_size) {
++        sd_lldp_neighbor *n;
++
++        n = malloc0(ALIGN(sizeof(sd_lldp_neighbor)) + raw_size);
++        if (!n)
++                return NULL;
++
++        n->raw_size = raw_size;
++        n->n_ref = 1;
++
++        return n;
++}
++
++static int parse_string(char **s, const void *q, size_t n) {
++        const char *p = q;
++        char *k;
++
++        assert(s);
++        assert(p || n == 0);
++
++        if (*s) {
++                log_lldp("Found duplicate string, ignoring field.");
++                return 0;
++        }
++
++        /* Strip trailing NULs, just to be nice */
++        while (n > 0 && p[n-1] == 0)
++                n--;
++
++        if (n <= 0) /* Ignore empty strings */
++                return 0;
++
++        /* Look for inner NULs */
++        if (memchr(p, 0, n)) {
++                log_lldp("Found inner NUL in string, ignoring field.");
++                return 0;
++        }
++
++        /* Let's escape weird chars, for security reasons */
++        k = cescape_length(p, n);
++        if (!k)
++                return -ENOMEM;
++
++        free(*s);
++        *s = k;
++
++        return 1;
++}
++
++int lldp_neighbor_parse(sd_lldp_neighbor *n) {
++        struct ether_header h;
++        const uint8_t *p;
++        size_t left;
++        int r;
++
++        assert(n);
++
++        if (n->raw_size < sizeof(struct ether_header)) {
++                log_lldp("Received truncated packet, ignoring.");
++                return -EBADMSG;
++        }
++
++        memcpy(&h, LLDP_NEIGHBOR_RAW(n), sizeof(h));
++
++        if (h.ether_type != htobe16(ETHERTYPE_LLDP)) {
++                log_lldp("Received packet with wrong type, ignoring.");
++                return -EBADMSG;
++        }
++
++        if (h.ether_dhost[0] != 0x01 ||
++            h.ether_dhost[1] != 0x80 ||
++            h.ether_dhost[2] != 0xc2 ||
++            h.ether_dhost[3] != 0x00 ||
++            h.ether_dhost[4] != 0x00 ||
++            !IN_SET(h.ether_dhost[5], 0x00, 0x03, 0x0e)) {
++                log_lldp("Received packet with wrong destination address, ignoring.");
++                return -EBADMSG;
++        }
++
++        memcpy(&n->source_address, h.ether_shost, sizeof(struct ether_addr));
++        memcpy(&n->destination_address, h.ether_dhost, sizeof(struct ether_addr));
++
++        p = (const uint8_t*) LLDP_NEIGHBOR_RAW(n) + sizeof(struct ether_header);
++        left = n->raw_size - sizeof(struct ether_header);
++
++        for (;;) {
++                uint8_t type;
++                uint16_t length;
++
++                if (left < 2) {
++                        log_lldp("TLV lacks header, ignoring.");
++                        return -EBADMSG;
++                }
++
++                type = p[0] >> 1;
++                length = p[1] + (((uint16_t) (p[0] & 1)) << 8);
++                p += 2, left -= 2;
++
++                if (left < length) {
++                        log_lldp("TLV truncated, ignoring datagram.");
++                        return -EBADMSG;
++                }
++
++                switch (type) {
++
++                case SD_LLDP_TYPE_END:
++                        if (length != 0) {
++                                log_lldp("End marker TLV not zero-sized, ignoring datagram.");
++                                return -EBADMSG;
++                        }
++
++                        /* Note that after processing the SD_LLDP_TYPE_END left could still be > 0
++                         * as the message may contain padding (see IEEE 802.1AB-2016, sec. 8.5.12) */
++
++                        goto end_marker;
++
++                case SD_LLDP_TYPE_CHASSIS_ID:
++                        if (length < 2 || length > 256) { /* includes the chassis subtype, hence one extra byte */
++                                log_lldp("Chassis ID field size out of range, ignoring datagram.");
++                                return -EBADMSG;
++                        }
++                        if (n->id.chassis_id) {
++                                log_lldp("Duplicate chassis ID field, ignoring datagram.");
++                                return -EBADMSG;
++                        }
++
++                        n->id.chassis_id = memdup(p, length);
++                        if (!n->id.chassis_id)
++                                return -ENOMEM;
++
++                        n->id.chassis_id_size = length;
++                        break;
++
++                case SD_LLDP_TYPE_PORT_ID:
++                        if (length < 2 || length > 256) { /* includes the port subtype, hence one extra byte */
++                                log_lldp("Port ID field size out of range, ignoring datagram.");
++                                return -EBADMSG;
++                        }
++                        if (n->id.port_id) {
++                                log_lldp("Duplicate port ID field, ignoring datagram.");
++                                return -EBADMSG;
++                        }
++
++                        n->id.port_id = memdup(p, length);
++                        if (!n->id.port_id)
++                                return -ENOMEM;
++
++                        n->id.port_id_size = length;
++                        break;
++
++                case SD_LLDP_TYPE_TTL:
++                        if (length != 2) {
++                                log_lldp("TTL field has wrong size, ignoring datagram.");
++                                return -EBADMSG;
++                        }
++
++                        if (n->has_ttl) {
++                                log_lldp("Duplicate TTL field, ignoring datagram.");
++                                return -EBADMSG;
++                        }
++
++                        n->ttl = unaligned_read_be16(p);
++                        n->has_ttl = true;
++                        break;
++
++                case SD_LLDP_TYPE_PORT_DESCRIPTION:
++                        r = parse_string(&n->port_description, p, length);
++                        if (r < 0)
++                                return r;
++                        break;
++
++                case SD_LLDP_TYPE_SYSTEM_NAME:
++                        r = parse_string(&n->system_name, p, length);
++                        if (r < 0)
++                                return r;
++                        break;
++
++                case SD_LLDP_TYPE_SYSTEM_DESCRIPTION:
++                        r = parse_string(&n->system_description, p, length);
++                        if (r < 0)
++                                return r;
++                        break;
++
++                case SD_LLDP_TYPE_SYSTEM_CAPABILITIES:
++                        if (length != 4)
++                                log_lldp("System capabilities field has wrong size, ignoring.");
++                        else {
++                                n->system_capabilities = unaligned_read_be16(p);
++                                n->enabled_capabilities = unaligned_read_be16(p + 2);
++                                n->has_capabilities = true;
++                        }
++
++                        break;
++
++                case SD_LLDP_TYPE_PRIVATE:
++                        if (length < 4)
++                                log_lldp("Found private TLV that is too short, ignoring.");
++
++                        break;
++                }
++
++                p += length, left -= length;
++        }
++
++end_marker:
++        if (!n->id.chassis_id || !n->id.port_id || !n->has_ttl) {
++                log_lldp("One or more mandatory TLV missing in datagram. Ignoring.");
++                return -EBADMSG;
++
++        }
++
++        n->rindex = sizeof(struct ether_header);
++
++        return 0;
++}
++
++void lldp_neighbor_start_ttl(sd_lldp_neighbor *n) {
++        assert(n);
++
++        if (n->ttl > 0) {
++                usec_t base;
++
++                /* Use the packet's timestamp if there is one known */
++                base = triple_timestamp_by_clock(&n->timestamp, clock_boottime_or_monotonic());
++                if (base <= 0 || base == USEC_INFINITY)
++                        base = now(clock_boottime_or_monotonic()); /* Otherwise, take the current time */
++
++                n->until = usec_add(base, n->ttl * USEC_PER_SEC);
++        } else
++                n->until = 0;
++
++        if (n->lldp)
++                prioq_reshuffle(n->lldp->neighbor_by_expiry, n, &n->prioq_idx);
++}
++
++bool lldp_neighbor_equal(const sd_lldp_neighbor *a, const sd_lldp_neighbor *b) {
++        if (a == b)
++                return true;
++
++        if (!a || !b)
++                return false;
++
++        if (a->raw_size != b->raw_size)
++                return false;
++
++        return memcmp(LLDP_NEIGHBOR_RAW(a), LLDP_NEIGHBOR_RAW(b), a->raw_size) == 0;
++}
++
++_public_ int sd_lldp_neighbor_get_source_address(sd_lldp_neighbor *n, struct ether_addr* address) {
++        assert_return(n, -EINVAL);
++        assert_return(address, -EINVAL);
++
++        *address = n->source_address;
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_destination_address(sd_lldp_neighbor *n, struct ether_addr* address) {
++        assert_return(n, -EINVAL);
++        assert_return(address, -EINVAL);
++
++        *address = n->destination_address;
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size) {
++        assert_return(n, -EINVAL);
++        assert_return(ret, -EINVAL);
++        assert_return(size, -EINVAL);
++
++        *ret = LLDP_NEIGHBOR_RAW(n);
++        *size = n->raw_size;
++
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_chassis_id(sd_lldp_neighbor *n, uint8_t *type, const void **ret, size_t *size) {
++        assert_return(n, -EINVAL);
++        assert_return(type, -EINVAL);
++        assert_return(ret, -EINVAL);
++        assert_return(size, -EINVAL);
++
++        assert(n->id.chassis_id_size > 0);
++
++        *type = *(uint8_t*) n->id.chassis_id;
++        *ret = (uint8_t*) n->id.chassis_id + 1;
++        *size = n->id.chassis_id_size - 1;
++
++        return 0;
++}
++
++static int format_mac_address(const void *data, size_t sz, char **ret) {
++        struct ether_addr a;
++        char *k;
++
++        assert(data || sz <= 0);
++
++        if (sz != 7)
++                return 0;
++
++        memcpy(&a, (uint8_t*) data + 1, sizeof(a));
++
++        k = new(char, ETHER_ADDR_TO_STRING_MAX);
++        if (!k)
++                return -ENOMEM;
++
++        *ret = ether_addr_to_string(&a, k);
++        return 1;
++}
++
++static int format_network_address(const void *data, size_t sz, char **ret) {
++        union in_addr_union a;
++        int family, r;
++
++        if (sz == 6 && ((uint8_t*) data)[1] == 1) {
++                memcpy(&a.in, (uint8_t*) data + 2, sizeof(a.in));
++                family = AF_INET;
++        } else if (sz == 18 && ((uint8_t*) data)[1] == 2) {
++                memcpy(&a.in6, (uint8_t*) data + 2, sizeof(a.in6));
++                family = AF_INET6;
++        } else
++                return 0;
++
++        r = in_addr_to_string(family, &a, ret);
++        if (r < 0)
++                return r;
++        return 1;
++}
++
++_public_ int sd_lldp_neighbor_get_chassis_id_as_string(sd_lldp_neighbor *n, const char **ret) {
++        char *k;
++        int r;
++
++        assert_return(n, -EINVAL);
++        assert_return(ret, -EINVAL);
++
++        if (n->chassis_id_as_string) {
++                *ret = n->chassis_id_as_string;
++                return 0;
++        }
++
++        assert(n->id.chassis_id_size > 0);
++
++        switch (*(uint8_t*) n->id.chassis_id) {
++
++        case SD_LLDP_CHASSIS_SUBTYPE_CHASSIS_COMPONENT:
++        case SD_LLDP_CHASSIS_SUBTYPE_INTERFACE_ALIAS:
++        case SD_LLDP_CHASSIS_SUBTYPE_PORT_COMPONENT:
++        case SD_LLDP_CHASSIS_SUBTYPE_INTERFACE_NAME:
++        case SD_LLDP_CHASSIS_SUBTYPE_LOCALLY_ASSIGNED:
++                k = cescape_length((char*) n->id.chassis_id + 1, n->id.chassis_id_size - 1);
++                if (!k)
++                        return -ENOMEM;
++
++                goto done;
++
++        case SD_LLDP_CHASSIS_SUBTYPE_MAC_ADDRESS:
++                r = format_mac_address(n->id.chassis_id, n->id.chassis_id_size, &k);
++                if (r < 0)
++                        return r;
++                if (r > 0)
++                        goto done;
++
++                break;
++
++        case SD_LLDP_CHASSIS_SUBTYPE_NETWORK_ADDRESS:
++                r = format_network_address(n->id.chassis_id, n->id.chassis_id_size, &k);
++                if (r < 0)
++                        return r;
++                if (r > 0)
++                        goto done;
++
++                break;
++        }
++
++        /* Generic fallback */
++        k = hexmem(n->id.chassis_id, n->id.chassis_id_size);
++        if (!k)
++                return -ENOMEM;
++
++done:
++        *ret = n->chassis_id_as_string = k;
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_port_id(sd_lldp_neighbor *n, uint8_t *type, const void **ret, size_t *size) {
++        assert_return(n, -EINVAL);
++        assert_return(type, -EINVAL);
++        assert_return(ret, -EINVAL);
++        assert_return(size, -EINVAL);
++
++        assert(n->id.port_id_size > 0);
++
++        *type = *(uint8_t*) n->id.port_id;
++        *ret = (uint8_t*) n->id.port_id + 1;
++        *size = n->id.port_id_size - 1;
++
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_port_id_as_string(sd_lldp_neighbor *n, const char **ret) {
++        char *k;
++        int r;
++
++        assert_return(n, -EINVAL);
++        assert_return(ret, -EINVAL);
++
++        if (n->port_id_as_string) {
++                *ret = n->port_id_as_string;
++                return 0;
++        }
++
++        assert(n->id.port_id_size > 0);
++
++        switch (*(uint8_t*) n->id.port_id) {
++
++        case SD_LLDP_PORT_SUBTYPE_INTERFACE_ALIAS:
++        case SD_LLDP_PORT_SUBTYPE_PORT_COMPONENT:
++        case SD_LLDP_PORT_SUBTYPE_INTERFACE_NAME:
++        case SD_LLDP_PORT_SUBTYPE_LOCALLY_ASSIGNED:
++                k = cescape_length((char*) n->id.port_id + 1, n->id.port_id_size - 1);
++                if (!k)
++                        return -ENOMEM;
++
++                goto done;
++
++        case SD_LLDP_PORT_SUBTYPE_MAC_ADDRESS:
++                r = format_mac_address(n->id.port_id, n->id.port_id_size, &k);
++                if (r < 0)
++                        return r;
++                if (r > 0)
++                        goto done;
++
++                break;
++
++        case SD_LLDP_PORT_SUBTYPE_NETWORK_ADDRESS:
++                r = format_network_address(n->id.port_id, n->id.port_id_size, &k);
++                if (r < 0)
++                        return r;
++                if (r > 0)
++                        goto done;
++
++                break;
++        }
++
++        /* Generic fallback */
++        k = hexmem(n->id.port_id, n->id.port_id_size);
++        if (!k)
++                return -ENOMEM;
++
++done:
++        *ret = n->port_id_as_string = k;
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_ttl(sd_lldp_neighbor *n, uint16_t *ret_sec) {
++        assert_return(n, -EINVAL);
++        assert_return(ret_sec, -EINVAL);
++
++        *ret_sec = n->ttl;
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_system_name(sd_lldp_neighbor *n, const char **ret) {
++        assert_return(n, -EINVAL);
++        assert_return(ret, -EINVAL);
++
++        if (!n->system_name)
++                return -ENODATA;
++
++        *ret = n->system_name;
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_system_description(sd_lldp_neighbor *n, const char **ret) {
++        assert_return(n, -EINVAL);
++        assert_return(ret, -EINVAL);
++
++        if (!n->system_description)
++                return -ENODATA;
++
++        *ret = n->system_description;
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_port_description(sd_lldp_neighbor *n, const char **ret) {
++        assert_return(n, -EINVAL);
++        assert_return(ret, -EINVAL);
++
++        if (!n->port_description)
++                return -ENODATA;
++
++        *ret = n->port_description;
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_system_capabilities(sd_lldp_neighbor *n, uint16_t *ret) {
++        assert_return(n, -EINVAL);
++        assert_return(ret, -EINVAL);
++
++        if (!n->has_capabilities)
++                return -ENODATA;
++
++        *ret = n->system_capabilities;
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_enabled_capabilities(sd_lldp_neighbor *n, uint16_t *ret) {
++        assert_return(n, -EINVAL);
++        assert_return(ret, -EINVAL);
++
++        if (!n->has_capabilities)
++                return -ENODATA;
++
++        *ret = n->enabled_capabilities;
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_from_raw(sd_lldp_neighbor **ret, const void *raw, size_t raw_size) {
++        _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
++        int r;
++
++        assert_return(ret, -EINVAL);
++        assert_return(raw || raw_size <= 0, -EINVAL);
++
++        n = lldp_neighbor_new(raw_size);
++        if (!n)
++                return -ENOMEM;
++
++        memcpy(LLDP_NEIGHBOR_RAW(n), raw, raw_size);
++        r = lldp_neighbor_parse(n);
++        if (r < 0)
++                return r;
++
++        *ret = TAKE_PTR(n);
++
++        return r;
++}
++
++_public_ int sd_lldp_neighbor_tlv_rewind(sd_lldp_neighbor *n) {
++        assert_return(n, -EINVAL);
++
++        assert(n->raw_size >= sizeof(struct ether_header));
++        n->rindex = sizeof(struct ether_header);
++
++        return n->rindex < n->raw_size;
++}
++
++_public_ int sd_lldp_neighbor_tlv_next(sd_lldp_neighbor *n) {
++        size_t length;
++
++        assert_return(n, -EINVAL);
++
++        if (n->rindex == n->raw_size) /* EOF */
++                return -ESPIPE;
++
++        if (n->rindex + 2 > n->raw_size) /* Truncated message */
++                return -EBADMSG;
++
++        length = LLDP_NEIGHBOR_TLV_LENGTH(n);
++        if (n->rindex + 2 + length > n->raw_size)
++                return -EBADMSG;
++
++        n->rindex += 2 + length;
++        return n->rindex < n->raw_size;
++}
++
++_public_ int sd_lldp_neighbor_tlv_get_type(sd_lldp_neighbor *n, uint8_t *type) {
++        assert_return(n, -EINVAL);
++        assert_return(type, -EINVAL);
++
++        if (n->rindex == n->raw_size) /* EOF */
++                return -ESPIPE;
++
++        if (n->rindex + 2 > n->raw_size)
++                return -EBADMSG;
++
++        *type = LLDP_NEIGHBOR_TLV_TYPE(n);
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_tlv_is_type(sd_lldp_neighbor *n, uint8_t type) {
++        uint8_t k;
++        int r;
++
++        assert_return(n, -EINVAL);
++
++        r = sd_lldp_neighbor_tlv_get_type(n, &k);
++        if (r < 0)
++                return r;
++
++        return type == k;
++}
++
++_public_ int sd_lldp_neighbor_tlv_get_oui(sd_lldp_neighbor *n, uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t *subtype) {
++        const uint8_t *d;
++        size_t length;
++        int r;
++
++        assert_return(n, -EINVAL);
++        assert_return(oui, -EINVAL);
++        assert_return(subtype, -EINVAL);
++
++        r = sd_lldp_neighbor_tlv_is_type(n, SD_LLDP_TYPE_PRIVATE);
++        if (r < 0)
++                return r;
++        if (r == 0)
++                return -ENXIO;
++
++        length = LLDP_NEIGHBOR_TLV_LENGTH(n);
++        if (length < 4)
++                return -EBADMSG;
++
++        if (n->rindex + 2 + length > n->raw_size)
++                return -EBADMSG;
++
++        d = LLDP_NEIGHBOR_TLV_DATA(n);
++        memcpy(oui, d, 3);
++        *subtype = d[3];
++
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_tlv_is_oui(sd_lldp_neighbor *n, const uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t subtype) {
++        uint8_t k[3], st;
++        int r;
++
++        r = sd_lldp_neighbor_tlv_get_oui(n, k, &st);
++        if (r == -ENXIO)
++                return 0;
++        if (r < 0)
++                return r;
++
++        return memcmp(k, oui, 3) == 0 && st == subtype;
++}
++
++_public_ int sd_lldp_neighbor_tlv_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size) {
++        size_t length;
++
++        assert_return(n, -EINVAL);
++        assert_return(ret, -EINVAL);
++        assert_return(size, -EINVAL);
++
++        /* Note that this returns the full TLV, including the TLV header */
++
++        if (n->rindex + 2 > n->raw_size)
++                return -EBADMSG;
++
++        length = LLDP_NEIGHBOR_TLV_LENGTH(n);
++        if (n->rindex + 2 + length > n->raw_size)
++                return -EBADMSG;
++
++        *ret = (uint8_t*) LLDP_NEIGHBOR_RAW(n) + n->rindex;
++        *size = length + 2;
++
++        return 0;
++}
++
++_public_ int sd_lldp_neighbor_get_timestamp(sd_lldp_neighbor *n, clockid_t clock, uint64_t *ret) {
++        assert_return(n, -EINVAL);
++        assert_return(TRIPLE_TIMESTAMP_HAS_CLOCK(clock), -EOPNOTSUPP);
++        assert_return(clock_supported(clock), -EOPNOTSUPP);
++        assert_return(ret, -EINVAL);
++
++        if (!triple_timestamp_is_set(&n->timestamp))
++                return -ENODATA;
++
++        *ret = triple_timestamp_by_clock(&n->timestamp, clock);
++        return 0;
++}
+diff --git a/src/libsystemd/sd-lldp/lldp-neighbor.h b/src/libsystemd/sd-lldp/lldp-neighbor.h
+new file mode 100644
+index 0000000000..62dbff42ca
+--- /dev/null
++++ b/src/libsystemd/sd-lldp/lldp-neighbor.h
+@@ -0,0 +1,91 @@
++/* SPDX-License-Identifier: LGPL-2.1+ */
++#pragma once
++
++#include <inttypes.h>
++#include <stdbool.h>
++#include <sys/types.h>
++
++#include "sd-lldp.h"
++
++#include "hash-funcs.h"
++#include "lldp-internal.h"
++#include "time-util.h"
++
++typedef struct LLDPNeighborID {
++        /* The spec calls this an "MSAP identifier" */
++        void *chassis_id;
++        size_t chassis_id_size;
++
++        void *port_id;
++        size_t port_id_size;
++} LLDPNeighborID;
++
++struct sd_lldp_neighbor {
++        /* Neighbor objects stay around as long as they are linked into an "sd_lldp" object or n_ref > 0. */
++        sd_lldp *lldp;
++        unsigned n_ref;
++
++        triple_timestamp timestamp;
++
++        usec_t until;
++        unsigned prioq_idx;
++
++        struct ether_addr source_address;
++        struct ether_addr destination_address;
++
++        LLDPNeighborID id;
++
++        /* The raw packet size. The data is appended to the object, accessible via LLDP_NEIGHBOR_RAW() */
++        size_t raw_size;
++
++        /* The current read index for the iterative TLV interface */
++        size_t rindex;
++
++        /* And a couple of fields parsed out. */
++        bool has_ttl:1;
++        bool has_capabilities:1;
++        bool has_port_vlan_id:1;
++
++        uint16_t ttl;
++
++        uint16_t system_capabilities;
++        uint16_t enabled_capabilities;
++
++        char *port_description;
++        char *system_name;
++        char *system_description;
++
++        uint16_t port_vlan_id;
++
++        char *chassis_id_as_string;
++        char *port_id_as_string;
++};
++
++static inline void *LLDP_NEIGHBOR_RAW(const sd_lldp_neighbor *n) {
++        return (uint8_t*) n + ALIGN(sizeof(sd_lldp_neighbor));
++}
++
++static inline uint8_t LLDP_NEIGHBOR_TLV_TYPE(const sd_lldp_neighbor *n) {
++        return ((uint8_t*) LLDP_NEIGHBOR_RAW(n))[n->rindex] >> 1;
++}
++
++static inline size_t LLDP_NEIGHBOR_TLV_LENGTH(const sd_lldp_neighbor *n) {
++        uint8_t *p;
++
++        p = (uint8_t*) LLDP_NEIGHBOR_RAW(n) + n->rindex;
++        return p[1] + (((size_t) (p[0] & 1)) << 8);
++}
++
++static inline void* LLDP_NEIGHBOR_TLV_DATA(const sd_lldp_neighbor *n) {
++        return ((uint8_t*) LLDP_NEIGHBOR_RAW(n)) + n->rindex + 2;
++}
++
++extern const struct hash_ops lldp_neighbor_hash_ops;
++int lldp_neighbor_id_compare_func(const LLDPNeighborID *x, const LLDPNeighborID *y);
++int lldp_neighbor_prioq_compare_func(const void *a, const void *b);
++
++sd_lldp_neighbor *lldp_neighbor_unlink(sd_lldp_neighbor *n);
++sd_lldp_neighbor *lldp_neighbor_new(size_t raw_size);
++int lldp_neighbor_parse(sd_lldp_neighbor *n);
++void lldp_neighbor_start_ttl(sd_lldp_neighbor *n);
++bool lldp_neighbor_equal(const sd_lldp_neighbor *a, const sd_lldp_neighbor *b);
+diff --git a/src/libsystemd/sd-lldp/lldp-network.c b/src/libsystemd/sd-lldp/lldp-network.c
+new file mode 100644
+index 0000000000..870584c0db
+--- /dev/null
++++ b/src/libsystemd/sd-lldp/lldp-network.c
+@@ -0,0 +1,78 @@
++/* SPDX-License-Identifier: LGPL-2.1+ */
++
++#include <linux/filter.h>
++#include <netinet/if_ether.h>
++
++#include "fd-util.h"
++#include "lldp-network.h"
++#include "missing.h"
++#include "socket-util.h"
++
++int lldp_network_bind_raw_socket(int ifindex) {
++
++        static const struct sock_filter filter[] = {
++                BPF_STMT(BPF_LD + BPF_W + BPF_ABS, offsetof(struct ethhdr, h_dest)),      /* A <- 4 bytes of destination MAC */
++                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x0180c200, 1, 0),                    /* A != 01:80:c2:00 */
++                BPF_STMT(BPF_RET + BPF_K, 0),                                             /* drop packet */
++                BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(struct ethhdr, h_dest) + 4),  /* A <- remaining 2 bytes of destination MAC */
++                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x0000, 3, 0),                        /* A != 00:00 */
++                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x0003, 2, 0),                        /* A != 00:03 */
++                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, 0x000e, 1, 0),                        /* A != 00:0e */
++                BPF_STMT(BPF_RET + BPF_K, 0),                                             /* drop packet */
++                BPF_STMT(BPF_LD + BPF_H + BPF_ABS, offsetof(struct ethhdr, h_proto)),     /* A <- protocol */
++                BPF_JUMP(BPF_JMP + BPF_JEQ + BPF_K, ETHERTYPE_LLDP, 1, 0),                /* A != ETHERTYPE_LLDP */
++                BPF_STMT(BPF_RET + BPF_K, 0),                                             /* drop packet */
++                BPF_STMT(BPF_RET + BPF_K, (uint32_t) -1),                                 /* accept packet */
++        };
++
++        static const struct sock_fprog fprog = {
++                .len = ELEMENTSOF(filter),
++                .filter = (struct sock_filter*) filter,
++        };
++
++        struct packet_mreq mreq = {
++                .mr_ifindex = ifindex,
++                .mr_type = PACKET_MR_MULTICAST,
++                .mr_alen = ETH_ALEN,
++                .mr_address = { 0x01, 0x80, 0xC2, 0x00, 0x00, 0x00 }
++        };
++
++        union sockaddr_union saddrll = {
++                .ll.sll_family = AF_PACKET,
++                .ll.sll_ifindex = ifindex,
++        };
++
++        _cleanup_close_ int fd = -1;
++        int r;
++
++        assert(ifindex > 0);
++
++        fd = socket(PF_PACKET, SOCK_RAW|SOCK_CLOEXEC|SOCK_NONBLOCK,
++                    htobe16(ETHERTYPE_LLDP));
++        if (fd < 0)
++                return -errno;
++
++        r = setsockopt(fd, SOL_SOCKET, SO_ATTACH_FILTER, &fprog, sizeof(fprog));
++        if (r < 0)
++                return -errno;
++
++        r = setsockopt(fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
++        if (r < 0)
++                return -errno;
++
++        mreq.mr_address[ETH_ALEN - 1] = 0x03;
++        r = setsockopt(fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
++        if (r < 0)
++                return -errno;
++
++        mreq.mr_address[ETH_ALEN - 1] = 0x0E;
++        r = setsockopt(fd, SOL_PACKET, PACKET_ADD_MEMBERSHIP, &mreq, sizeof(mreq));
++        if (r < 0)
++                return -errno;
++
++        r = bind(fd, &saddrll.sa, sizeof(saddrll.ll));
++        if (r < 0)
++                return -errno;
++
++        return TAKE_FD(fd);
++}
+diff --git a/src/libsystemd/sd-lldp/lldp-network.h b/src/libsystemd/sd-lldp/lldp-network.h
+new file mode 100644
+index 0000000000..e4ed2898a5
+--- /dev/null
++++ b/src/libsystemd/sd-lldp/lldp-network.h
+@@ -0,0 +1,6 @@
++/* SPDX-License-Identifier: LGPL-2.1+ */
++#pragma once
++
++#include "sd-event.h"
++
++int lldp_network_bind_raw_socket(int ifindex);
+diff --git a/src/libsystemd/sd-lldp/sd-lldp.c b/src/libsystemd/sd-lldp/sd-lldp.c
+new file mode 100644
+index 0000000000..1f28c5731f
+--- /dev/null
++++ b/src/libsystemd/sd-lldp/sd-lldp.c
+@@ -0,0 +1,498 @@
++/* SPDX-License-Identifier: LGPL-2.1+ */
++
++#include <arpa/inet.h>
++#include <linux/sockios.h>
++#include <sys/ioctl.h>
++
++#include "sd-lldp.h"
++
++#include "alloc-util.h"
++#include "ether-addr-util.h"
++#include "event-util.h"
++#include "fd-util.h"
++#include "lldp-internal.h"
++#include "lldp-neighbor.h"
++#include "lldp-network.h"
++#include "memory-util.h"
++#include "socket-util.h"
++#include "sort-util.h"
++#include "string-table.h"
++
++#define LLDP_DEFAULT_NEIGHBORS_MAX 128U
++
++static const char * const lldp_event_table[_SD_LLDP_EVENT_MAX] = {
++        [SD_LLDP_EVENT_ADDED]   = "added",
++        [SD_LLDP_EVENT_REMOVED] = "removed",
++        [SD_LLDP_EVENT_UPDATED]   = "updated",
++        [SD_LLDP_EVENT_REFRESHED] = "refreshed",
++};
++
++DEFINE_STRING_TABLE_LOOKUP(lldp_event, sd_lldp_event);
++
++static void lldp_flush_neighbors(sd_lldp *lldp) {
++        assert(lldp);
++
++        hashmap_clear(lldp->neighbor_by_id);
++}
++
++static void lldp_callback(sd_lldp *lldp, sd_lldp_event event, sd_lldp_neighbor *n) {
++        assert(lldp);
++        assert(event >= 0 && event < _SD_LLDP_EVENT_MAX);
++
++        if (!lldp->callback) {
++                log_lldp("Received '%s' event.", lldp_event_to_string(event));
++                return;
++        }
++
++        log_lldp("Invoking callback for '%s' event.", lldp_event_to_string(event));
++        lldp->callback(lldp, event, n, lldp->userdata);
++}
++
++static int lldp_make_space(sd_lldp *lldp, size_t extra) {
++        usec_t t = USEC_INFINITY;
++        bool changed = false;
++
++        assert(lldp);
++
++        /* Remove all entries that are past their TTL, and more until at least the specified number of extra entries
++         * are free. */
++
++        for (;;) {
++                _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
++
++                n = prioq_peek(lldp->neighbor_by_expiry);
++                if (!n)
++                        break;
++
++                sd_lldp_neighbor_ref(n);
++
++                if (hashmap_size(lldp->neighbor_by_id) > LESS_BY(lldp->neighbors_max, extra))
++                        goto remove_one;
++
++                if (t == USEC_INFINITY)
++                        t = now(clock_boottime_or_monotonic());
++
++                if (n->until > t)
++                        break;
++
++        remove_one:
++                lldp_neighbor_unlink(n);
++                lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, n);
++                changed = true;
++        }
++
++        return changed;
++}
++
++static bool lldp_keep_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) {
++        assert(lldp);
++        assert(n);
++
++        /* Don't keep data with a zero TTL */
++        if (n->ttl <= 0)
++                return false;
++
++        /* Filter out data from the filter address */
++        if (!ether_addr_is_null(&lldp->filter_address) &&
++            ether_addr_equal(&lldp->filter_address, &n->source_address))
++                return false;
++
++        /* Only add if the neighbor has a capability we are interested in. Note that we also store all neighbors with
++         * no caps field set. */
++        if (n->has_capabilities &&
++            (n->enabled_capabilities & lldp->capability_mask) == 0)
++                return false;
++
++        /* Keep everything else */
++        return true;
++}
++
++static int lldp_start_timer(sd_lldp *lldp, sd_lldp_neighbor *neighbor);
++
++static int lldp_add_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) {
++        _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *old = NULL;
++        bool keep;
++        int r;
++
++        assert(lldp);
++        assert(n);
++        assert(!n->lldp);
++
++        keep = lldp_keep_neighbor(lldp, n);
++
++        /* First retrieve the old entry for this MSAP */
++        old = hashmap_get(lldp->neighbor_by_id, &n->id);
++        if (old) {
++                sd_lldp_neighbor_ref(old);
++
++                if (!keep) {
++                        lldp_neighbor_unlink(old);
++                        lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, old);
++                        return 0;
++                }
++
++                if (lldp_neighbor_equal(n, old)) {
++                        /* Is this equal, then restart the TTL counter, but don't do anything else. */
++                        old->timestamp = n->timestamp;
++                        lldp_start_timer(lldp, old);
++                        lldp_callback(lldp, SD_LLDP_EVENT_REFRESHED, old);
++                        return 0;
++                }
++
++                /* Data changed, remove the old entry, and add a new one */
++                lldp_neighbor_unlink(old);
++
++        } else if (!keep)
++                return 0;
++
++        /* Then, make room for at least one new neighbor */
++        lldp_make_space(lldp, 1);
++
++        r = hashmap_put(lldp->neighbor_by_id, &n->id, n);
++        if (r < 0)
++                goto finish;
++
++        r = prioq_put(lldp->neighbor_by_expiry, n, &n->prioq_idx);
++        if (r < 0) {
++                assert_se(hashmap_remove(lldp->neighbor_by_id, &n->id) == n);
++                goto finish;
++        }
++
++        n->lldp = lldp;
++
++        lldp_start_timer(lldp, n);
++        lldp_callback(lldp, old ? SD_LLDP_EVENT_UPDATED : SD_LLDP_EVENT_ADDED, n);
++
++        return 1;
++
++finish:
++        if (old)
++                lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, old);
++
++        return r;
++}
++
++static int lldp_handle_datagram(sd_lldp *lldp, sd_lldp_neighbor *n) {
++        int r;
++
++        assert(lldp);
++        assert(n);
++
++        r = lldp_neighbor_parse(n);
++        if (r == -EBADMSG) /* Ignore bad messages */
++                return 0;
++        if (r < 0)
++                return r;
++
++        r = lldp_add_neighbor(lldp, n);
++        if (r < 0) {
++                log_lldp_errno(r, "Failed to add datagram. Ignoring.");
++                return 0;
++        }
++
++        log_lldp("Successfully processed LLDP datagram.");
++        return 0;
++}
++
++static int lldp_receive_datagram(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
++        _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
++        ssize_t space, length;
++        sd_lldp *lldp = userdata;
++        struct timespec ts;
++
++        assert(fd >= 0);
++        assert(lldp);
++
++        space = next_datagram_size_fd(fd);
++        if (space < 0)
++                return log_lldp_errno(space, "Failed to determine datagram size to read: %m");
++
++        n = lldp_neighbor_new(space);
++        if (!n)
++                return -ENOMEM;
++
++        length = recv(fd, LLDP_NEIGHBOR_RAW(n), n->raw_size, MSG_DONTWAIT);
++        if (length < 0) {
++                if (IN_SET(errno, EAGAIN, EINTR))
++                        return 0;
++
++                return log_lldp_errno(errno, "Failed to read LLDP datagram: %m");
++        }
++
++        if ((size_t) length != n->raw_size) {
++                log_lldp("Packet size mismatch.");
++                return -EINVAL;
++        }
++
++        /* Try to get the timestamp of this packet if it is known */
++        if (ioctl(fd, SIOCGSTAMPNS, &ts) >= 0)
++                triple_timestamp_from_realtime(&n->timestamp, timespec_load(&ts));
++        else
++                triple_timestamp_get(&n->timestamp);
++
++        return lldp_handle_datagram(lldp, n);
++}
++
++static void lldp_reset(sd_lldp *lldp) {
++        assert(lldp);
++
++        (void) event_source_disable(lldp->timer_event_source);
++        lldp->io_event_source = sd_event_source_unref(lldp->io_event_source);
++        lldp->fd = safe_close(lldp->fd);
++}
++
++_public_ int sd_lldp_start(sd_lldp *lldp) {
++        int r;
++
++        assert_return(lldp, -EINVAL);
++        assert_return(lldp->event, -EINVAL);
++        assert_return(lldp->ifindex > 0, -EINVAL);
++
++        if (lldp->fd >= 0)
++                return 0;
++
++        assert(!lldp->io_event_source);
++
++        lldp->fd = lldp_network_bind_raw_socket(lldp->ifindex);
++        if (lldp->fd < 0)
++                return lldp->fd;
++
++        r = sd_event_add_io(lldp->event, &lldp->io_event_source, lldp->fd, EPOLLIN, lldp_receive_datagram, lldp);
++        if (r < 0)
++                goto fail;
++
++        r = sd_event_source_set_priority(lldp->io_event_source, lldp->event_priority);
++        if (r < 0)
++                goto fail;
++
++        (void) sd_event_source_set_description(lldp->io_event_source, "lldp-io");
++
++        log_lldp("Started LLDP client");
++        return 1;
++
++fail:
++        lldp_reset(lldp);
++        return r;
++}
++
++_public_ int sd_lldp_stop(sd_lldp *lldp) {
++        assert_return(lldp, -EINVAL);
++
++        if (lldp->fd < 0)
++                return 0;
++
++        log_lldp("Stopping LLDP client");
++
++        lldp_reset(lldp);
++        lldp_flush_neighbors(lldp);
++
++        return 1;
++}
++
++_public_ int sd_lldp_attach_event(sd_lldp *lldp, sd_event *event, int64_t priority) {
++        int r;
++
++        assert_return(lldp, -EINVAL);
++        assert_return(lldp->fd < 0, -EBUSY);
++        assert_return(!lldp->event, -EBUSY);
++
++        if (event)
++                lldp->event = sd_event_ref(event);
++        else {
++                r = sd_event_default(&lldp->event);
++                if (r < 0)
++                        return r;
++        }
++
++        lldp->event_priority = priority;
++
++        return 0;
++}
++
++_public_ int sd_lldp_detach_event(sd_lldp *lldp) {
++
++        assert_return(lldp, -EINVAL);
++        assert_return(lldp->fd < 0, -EBUSY);
++
++        lldp->event = sd_event_unref(lldp->event);
++        return 0;
++}
++
++_public_ sd_event* sd_lldp_get_event(sd_lldp *lldp) {
++        assert_return(lldp, NULL);
++
++        return lldp->event;
++}
++
++_public_ int sd_lldp_set_callback(sd_lldp *lldp, sd_lldp_callback_t cb, void *userdata) {
++        assert_return(lldp, -EINVAL);
++
++        lldp->callback = cb;
++        lldp->userdata = userdata;
++
++        return 0;
++}
++
++_public_ int sd_lldp_set_ifindex(sd_lldp *lldp, int ifindex) {
++        assert_return(lldp, -EINVAL);
++        assert_return(ifindex > 0, -EINVAL);
++        assert_return(lldp->fd < 0, -EBUSY);
++
++        lldp->ifindex = ifindex;
++        return 0;
++}
++
++static sd_lldp* lldp_free(sd_lldp *lldp) {
++        assert(lldp);
++
++        lldp->timer_event_source = sd_event_source_unref(lldp->timer_event_source);
++
++        lldp_reset(lldp);
++        sd_lldp_detach_event(lldp);
++        lldp_flush_neighbors(lldp);
++
++        hashmap_free(lldp->neighbor_by_id);
++        prioq_free(lldp->neighbor_by_expiry);
++        return mfree(lldp);
++}
++
++DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_lldp, sd_lldp, lldp_free);
++
++_public_ int sd_lldp_new(sd_lldp **ret) {
++        _cleanup_(sd_lldp_unrefp) sd_lldp *lldp = NULL;
++        int r;
++
++        assert_return(ret, -EINVAL);
++
++        lldp = new(sd_lldp, 1);
++        if (!lldp)
++                return -ENOMEM;
++
++        *lldp = (sd_lldp) {
++                .n_ref = 1,
++                .fd = -1,
++                .neighbors_max = LLDP_DEFAULT_NEIGHBORS_MAX,
++                .capability_mask = (uint16_t) -1,
++        };
++
++        lldp->neighbor_by_id = hashmap_new(&lldp_neighbor_hash_ops);
++        if (!lldp->neighbor_by_id)
++                return -ENOMEM;
++
++        r = prioq_ensure_allocated(&lldp->neighbor_by_expiry, lldp_neighbor_prioq_compare_func);
++        if (r < 0)
++                return r;
++
++        *ret = TAKE_PTR(lldp);
++
++        return 0;
++}
++
++static int neighbor_compare_func(sd_lldp_neighbor * const *a, sd_lldp_neighbor * const *b) {
++        return lldp_neighbor_id_compare_func(&(*a)->id, &(*b)->id);
++}
++
++static int on_timer_event(sd_event_source *s, uint64_t usec, void *userdata) {
++        sd_lldp *lldp = userdata;
++        int r;
++
++        r = lldp_make_space(lldp, 0);
++        if (r < 0)
++                return log_lldp_errno(r, "Failed to make space: %m");
++
++        r = lldp_start_timer(lldp, NULL);
++        if (r < 0)
++                return log_lldp_errno(r, "Failed to restart timer: %m");
++
++        return 0;
++}
++
++static int lldp_start_timer(sd_lldp *lldp, sd_lldp_neighbor *neighbor) {
++        sd_lldp_neighbor *n;
++
++        assert(lldp);
++
++        if (neighbor)
++                lldp_neighbor_start_ttl(neighbor);
++
++        n = prioq_peek(lldp->neighbor_by_expiry);
++        if (!n)
++                return event_source_disable(lldp->timer_event_source);
++
++        if (!lldp->event)
++                return 0;
++
++        return event_reset_time(lldp->event, &lldp->timer_event_source,
++                                clock_boottime_or_monotonic(),
++                                n->until, 0,
++                                on_timer_event, lldp,
++                                lldp->event_priority, "lldp-timer", true);
++}
++
++_public_ int sd_lldp_get_neighbors(sd_lldp *lldp, sd_lldp_neighbor ***ret) {
++        sd_lldp_neighbor **l = NULL, *n;
++        Iterator i;
++        int k = 0, r;
++
++        assert_return(lldp, -EINVAL);
++        assert_return(ret, -EINVAL);
++
++        if (hashmap_isempty(lldp->neighbor_by_id)) { /* Special shortcut */
++                *ret = NULL;
++                return 0;
++        }
++
++        l = new0(sd_lldp_neighbor*, hashmap_size(lldp->neighbor_by_id));
++        if (!l)
++                return -ENOMEM;
++
++        r = lldp_start_timer(lldp, NULL);
++        if (r < 0) {
++                free(l);
++                return r;
++        }
++
++        HASHMAP_FOREACH(n, lldp->neighbor_by_id, i)
++                l[k++] = sd_lldp_neighbor_ref(n);
++
++        assert((size_t) k == hashmap_size(lldp->neighbor_by_id));
++
++        /* Return things in a stable order */
++        typesafe_qsort(l, k, neighbor_compare_func);
++        *ret = l;
++
++        return k;
++}
++
++_public_ int sd_lldp_set_neighbors_max(sd_lldp *lldp, uint64_t m) {
++        assert_return(lldp, -EINVAL);
++        assert_return(m <= 0, -EINVAL);
++
++        lldp->neighbors_max = m;
++        lldp_make_space(lldp, 0);
++
++        return 0;
++}
++
++_public_ int sd_lldp_match_capabilities(sd_lldp *lldp, uint16_t mask) {
++        assert_return(lldp, -EINVAL);
++        assert_return(mask != 0, -EINVAL);
++
++        lldp->capability_mask = mask;
++
++        return 0;
++}
++
++_public_ int sd_lldp_set_filter_address(sd_lldp *lldp, const struct ether_addr *addr) {
++        assert_return(lldp, -EINVAL);
++
++        /* In order to deal nicely with bridges that send back our own packets, allow one address to be filtered, so
++         * that our own can be filtered out here. */
++
++        if (addr)
++                lldp->filter_address = *addr;
++        else
++                zero(lldp->filter_address);
++
++        return 0;
++}
+diff --git a/src/libsystemd/sd-lldp/test-lldp.c b/src/libsystemd/sd-lldp/test-lldp.c
+new file mode 100644
+index 0000000000..7406f94ce0
+--- /dev/null
++++ b/src/libsystemd/sd-lldp/test-lldp.c
+@@ -0,0 +1,379 @@
++/* SPDX-License-Identifier: LGPL-2.1+ */
++
++#include <arpa/inet.h>
++#include <errno.h>
++#include <net/ethernet.h>
++#include <stdio.h>
++#include <string.h>
++#include <unistd.h>
++
++#include "sd-event.h"
++#include "sd-lldp.h"
++
++#include "alloc-util.h"
++#include "fd-util.h"
++#include "lldp-network.h"
++#include "macro.h"
++#include "string-util.h"
++#include "tests.h"
++
++#define TEST_LLDP_PORT "em1"
++#define TEST_LLDP_TYPE_SYSTEM_NAME "systemd-lldp"
++#define TEST_LLDP_TYPE_SYSTEM_DESC "systemd-lldp-desc"
++
++static int test_fd[2] = { -1, -1 };
++static int lldp_handler_calls;
++
++int lldp_network_bind_raw_socket(int ifindex) {
++        if (socketpair(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) < 0)
++                return -errno;
++
++        return test_fd[0];
++}
++
++static void lldp_handler(sd_lldp *lldp, sd_lldp_event event, sd_lldp_neighbor *n, void *userdata) {
++        lldp_handler_calls++;
++}
++
++static int start_lldp(sd_lldp **lldp, sd_event *e, sd_lldp_callback_t cb, void *cb_data) {
++        int r;
++
++        r = sd_lldp_new(lldp);
++        if (r < 0)
++                return r;
++
++        r = sd_lldp_set_ifindex(*lldp, 42);
++        if (r < 0)
++                return r;
++
++        r = sd_lldp_set_callback(*lldp, cb, cb_data);
++        if (r < 0)
++                return r;
++
++        r = sd_lldp_attach_event(*lldp, e, 0);
++        if (r < 0)
++                return r;
++
++        r = sd_lldp_start(*lldp);
++        if (r < 0)
++                return r;
++
++        return 0;
++}
++
++static int stop_lldp(sd_lldp *lldp) {
++        int r;
++
++        r = sd_lldp_stop(lldp);
++        if (r < 0)
++                return r;
++
++        r = sd_lldp_detach_event(lldp);
++        if (r < 0)
++                return r;
++
++        sd_lldp_unref(lldp);
++        safe_close(test_fd[1]);
++
++        return 0;
++}
++
++static void test_receive_basic_packet(sd_event *e) {
++
++        static const uint8_t frame[] = {
++                /* Ethernet header */
++                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
++                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
++                0x88, 0xcc,                             /* Ethertype */
++                /* LLDP mandatory TLVs */
++                0x02, 0x07, 0x04, 0x00, 0x01, 0x02,     /* Chassis: MAC, 00:01:02:03:04:05 */
++                0x03, 0x04, 0x05,
++                0x04, 0x04, 0x05, 0x31, 0x2f, 0x33,     /* Port: interface name, "1/3" */
++                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
++                /* LLDP optional TLVs */
++                0x08, 0x04, 0x50, 0x6f, 0x72, 0x74,     /* Port Description: "Port" */
++                0x0a, 0x03, 0x53, 0x59, 0x53,           /* System Name: "SYS" */
++                0x0c, 0x04, 0x66, 0x6f, 0x6f, 0x00,     /* System Description: "foo" (NULL-terminated) */
++                0x00, 0x00                              /* End Of LLDPDU */
++        };
++
++        sd_lldp *lldp;
++        sd_lldp_neighbor **neighbors;
++        uint8_t type;
++        const void *data;
++        uint16_t ttl;
++        size_t length;
++        const char *str;
++
++        lldp_handler_calls = 0;
++        assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0);
++
++        assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
++        sd_event_run(e, 0);
++        assert_se(lldp_handler_calls == 1);
++        assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 1);
++
++        assert_se(sd_lldp_neighbor_get_chassis_id(neighbors[0], &type, &data, &length) == 0);
++        assert_se(type == SD_LLDP_CHASSIS_SUBTYPE_MAC_ADDRESS);
++        assert_se(length == ETH_ALEN);
++        assert_se(!memcmp(data, "\x00\x01\x02\x03\x04\x05", ETH_ALEN));
++
++        assert_se(sd_lldp_neighbor_get_port_id(neighbors[0], &type, &data, &length) == 0);
++        assert_se(type == SD_LLDP_PORT_SUBTYPE_INTERFACE_NAME);
++        assert_se(length == 3);
++        assert_se(!memcmp(data, "1/3", 3));
++
++        assert_se(sd_lldp_neighbor_get_port_description(neighbors[0], &str) == 0);
++        assert_se(streq(str, "Port"));
++
++        assert_se(sd_lldp_neighbor_get_system_name(neighbors[0], &str) == 0);
++        assert_se(streq(str, "SYS"));
++
++        assert_se(sd_lldp_neighbor_get_system_description(neighbors[0], &str) == 0);
++        assert_se(streq(str, "foo"));
++
++        assert_se(sd_lldp_neighbor_get_ttl(neighbors[0], &ttl) == 0);
++        assert_se(ttl == 120);
++
++        sd_lldp_neighbor_unref(neighbors[0]);
++        free(neighbors);
++
++        assert_se(stop_lldp(lldp) == 0);
++}
++
++static void test_receive_incomplete_packet(sd_event *e) {
++        sd_lldp *lldp;
++        sd_lldp_neighbor **neighbors;
++        uint8_t frame[] = {
++                /* Ethernet header */
++                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
++                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
++                0x88, 0xcc,                             /* Ethertype */
++                /* LLDP mandatory TLVs */
++                0x02, 0x07, 0x04, 0x00, 0x01, 0x02,     /* Chassis: MAC, 00:01:02:03:04:05 */
++                0x03, 0x04, 0x05,
++                0x04, 0x04, 0x05, 0x31, 0x2f, 0x33,     /* Port: interface name, "1/3" */
++                                                        /* Missing TTL */
++                0x00, 0x00                              /* End Of LLDPDU */
++        };
++
++        lldp_handler_calls = 0;
++        assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0);
++
++        assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
++        sd_event_run(e, 0);
++        assert_se(lldp_handler_calls == 0);
++        assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 0);
++
++        assert_se(stop_lldp(lldp) == 0);
++}
++
++static void test_receive_oui_packet(sd_event *e) {
++        sd_lldp *lldp;
++        sd_lldp_neighbor **neighbors;
++        uint8_t frame[] = {
++                /* Ethernet header */
++                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
++                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
++                0x88, 0xcc,                             /* Ethertype */
++                /* LLDP mandatory TLVs */
++                0x02, 0x07, 0x04, 0x00, 0x01, 0x02,     /* Chassis: MAC, 00:01:02:03:04:05 */
++                0x03, 0x04, 0x05,
++                0x04, 0x04, 0x05, 0x31, 0x2f, 0x33,     /* Port TLV: interface name, "1/3" */
++                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
++                /* LLDP optional TLVs */
++                0xfe, 0x06, 0x00, 0x80, 0xc2, 0x01,     /* Port VLAN ID: 0x1234 */
++                0x12, 0x34,
++                0xfe, 0x07, 0x00, 0x80, 0xc2, 0x02,     /* Port and protocol: flag 1, PPVID 0x7788 */
++                0x01, 0x77, 0x88,
++                0xfe, 0x0d, 0x00, 0x80, 0xc2, 0x03,     /* VLAN Name: ID 0x1234, name "Vlan51" */
++                0x12, 0x34, 0x06, 0x56, 0x6c, 0x61,
++                0x6e, 0x35, 0x31,
++                0xfe, 0x06, 0x00, 0x80, 0xc2, 0x06,     /* Management VID: 0x0102 */
++                0x01, 0x02,
++                0xfe, 0x09, 0x00, 0x80, 0xc2, 0x07,     /* Link aggregation: status 1, ID 0x00140012 */
++                0x01, 0x00, 0x14, 0x00, 0x12,
++                0xfe, 0x07, 0x00, 0x12, 0x0f, 0x02,     /* 802.3 Power via MDI: PSE, MDI enabled */
++                0x07, 0x01, 0x00,
++                0x00, 0x00                              /* End of LLDPDU */
++        };
++
++        lldp_handler_calls = 0;
++        assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0);
++
++        assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
++        sd_event_run(e, 0);
++        assert_se(lldp_handler_calls == 1);
++        assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 1);
++
++        assert_se(sd_lldp_neighbor_tlv_rewind(neighbors[0]) >= 0);
++        assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_CHASSIS_ID) > 0);
++        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
++        assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_PORT_ID) > 0);
++        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
++        assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_TTL) > 0);
++        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
++        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_PORT_VLAN_ID) > 0);
++        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
++        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_PORT_PROTOCOL_VLAN_ID) > 0);
++        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
++        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_VLAN_NAME) > 0);
++        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
++        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_MANAGEMENT_VID) > 0);
++        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
++        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_1, SD_LLDP_OUI_802_1_SUBTYPE_LINK_AGGREGATION) > 0);
++        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
++        assert_se(sd_lldp_neighbor_tlv_is_oui(neighbors[0], SD_LLDP_OUI_802_3, SD_LLDP_OUI_802_3_SUBTYPE_POWER_VIA_MDI) > 0);
++        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) > 0);
++        assert_se(sd_lldp_neighbor_tlv_is_type(neighbors[0], SD_LLDP_TYPE_END) > 0);
++        assert_se(sd_lldp_neighbor_tlv_next(neighbors[0]) == 0);
++
++        sd_lldp_neighbor_unref(neighbors[0]);
++        free(neighbors);
++
++        assert_se(stop_lldp(lldp) == 0);
++}
++
++static void test_multiple_neighbors_sorted(sd_event *e) {
++
++        static const uint8_t frame1[] = {
++                /* Ethernet header */
++                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
++                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
++                0x88, 0xcc,                             /* Ethertype */
++                /* LLDP mandatory TLVs */
++                0x02, 0x04, 0x01, '1', '/', '2',        /* Chassis component: "1/2" */
++                0x04, 0x04, 0x02, '2', '/', '3',        /* Port component: "2/3" */
++                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
++                0x00, 0x00                              /* End Of LLDPDU */
++        };
++        static const uint8_t frame2[] = {
++                /* Ethernet header */
++                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
++                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
++                0x88, 0xcc,                             /* Ethertype */
++                /* LLDP mandatory TLVs */
++                0x02, 0x04, 0x01, '2', '/', '1',        /* Chassis component: "2/1" */
++                0x04, 0x04, 0x02, '1', '/', '3',        /* Port component: "1/3" */
++                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
++                0x00, 0x00                              /* End Of LLDPDU */
++        };
++        static const uint8_t frame3[] = {
++                /* Ethernet header */
++                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
++                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
++                0x88, 0xcc,                             /* Ethertype */
++                /* LLDP mandatory TLVs */
++                0x02, 0x05, 0x01, '2', '/', '1', '0',   /* Chassis component: "2/10" */
++                0x04, 0x04, 0x02, '1', '/', '0',        /* Port component: "1/0" */
++                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
++                0x00, 0x00                              /* End Of LLDPDU */
++        };
++        static const uint8_t frame4[] = {
++                /* Ethernet header */
++                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
++                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
++                0x88, 0xcc,                             /* Ethertype */
++                /* LLDP mandatory TLVs */
++                0x02, 0x05, 0x01, '2', '/', '1', '9',   /* Chassis component: "2/19" */
++                0x04, 0x04, 0x02, '1', '/', '0',        /* Port component: "1/0" */
++                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
++                0x00, 0x00                              /* End Of LLDPDU */
++        };
++        static const uint8_t frame5[] = {
++                /* Ethernet header */
++                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
++                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
++                0x88, 0xcc,                             /* Ethertype */
++                /* LLDP mandatory TLVs */
++                0x02, 0x04, 0x01, '1', '/', '2',        /* Chassis component: "1/2" */
++                0x04, 0x05, 0x02, '2', '/', '1', '0',   /* Port component: "2/10" */
++                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
++                0x00, 0x00                              /* End Of LLDPDU */
++        };
++        static const uint8_t frame6[] = {
++                /* Ethernet header */
++                0x01, 0x80, 0xc2, 0x00, 0x00, 0x03,     /* Destination MAC */
++                0x01, 0x02, 0x03, 0x04, 0x05, 0x06,     /* Source MAC */
++                0x88, 0xcc,                             /* Ethertype */
++                /* LLDP mandatory TLVs */
++                0x02, 0x04, 0x01, '1', '/', '2',        /* Chassis component: "1/2" */
++                0x04, 0x05, 0x02, '2', '/', '3', '9',   /* Port component: "2/10" */
++                0x06, 0x02, 0x00, 0x78,                 /* TTL: 120 seconds */
++                0x00, 0x00                              /* End Of LLDPDU */
++        };
++        static const char* expected[] = {
++                /* ordered pairs of Chassis+Port */
++                "1/2", "2/10",
++                "1/2", "2/3",
++                "1/2", "2/39",
++                "2/1", "1/3",
++                "2/10", "1/0",
++                "2/19", "1/0",
++        };
++
++        sd_lldp *lldp;
++        sd_lldp_neighbor **neighbors;
++        int i;
++        uint8_t type;
++        const void *data;
++        size_t length, expected_length;
++        uint16_t ttl;
++
++        lldp_handler_calls = 0;
++        assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0);
++
++        assert_se(write(test_fd[1], frame1, sizeof(frame1)) == sizeof(frame1));
++        sd_event_run(e, 0);
++        assert_se(write(test_fd[1], frame2, sizeof(frame2)) == sizeof(frame2));
++        sd_event_run(e, 0);
++        assert_se(write(test_fd[1], frame3, sizeof(frame3)) == sizeof(frame3));
++        sd_event_run(e, 0);
++        assert_se(write(test_fd[1], frame4, sizeof(frame4)) == sizeof(frame4));
++        sd_event_run(e, 0);
++        assert_se(write(test_fd[1], frame5, sizeof(frame5)) == sizeof(frame5));
++        sd_event_run(e, 0);
++        assert_se(write(test_fd[1], frame6, sizeof(frame6)) == sizeof(frame6));
++        sd_event_run(e, 0);
++        assert_se(lldp_handler_calls == 6);
++
++        assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 6);
++
++        for (i = 0; i < 6; i++) {
++                assert_se(sd_lldp_neighbor_get_chassis_id(neighbors[i], &type, &data, &length) == 0);
++                assert_se(type == SD_LLDP_CHASSIS_SUBTYPE_CHASSIS_COMPONENT);
++                expected_length = strlen(expected[2 * i]);
++                assert_se(length == expected_length);
++                assert_se(memcmp(data, expected[2 * i], expected_length) == 0);
++
++                assert_se(sd_lldp_neighbor_get_port_id(neighbors[i], &type, &data, &length) == 0);
++                assert_se(type == SD_LLDP_PORT_SUBTYPE_PORT_COMPONENT);
++                expected_length = strlen(expected[2 * i + 1]);
++                assert_se(length == expected_length);
++                assert_se(memcmp(data, expected[2 * i + 1], expected_length) == 0);
++
++                assert_se(sd_lldp_neighbor_get_ttl(neighbors[i], &ttl) == 0);
++                assert_se(ttl == 120);
++        }
++
++        for (i = 0; i < 6; i++)
++                sd_lldp_neighbor_unref(neighbors[i]);
++        free(neighbors);
++
++        assert_se(stop_lldp(lldp) == 0);
++}
++
++int main(int argc, char *argv[]) {
++        _cleanup_(sd_event_unrefp) sd_event *e = NULL;
++
++        test_setup_logging(LOG_DEBUG);
++
++        /* LLDP reception tests */
++        assert_se(sd_event_new(&e) == 0);
++        test_receive_basic_packet(e);
++        test_receive_incomplete_packet(e);
++        test_receive_oui_packet(e);
++        test_multiple_neighbors_sorted(e);
++
++        return 0;
++}
+diff --git a/src/systemd/meson.build b/src/systemd/meson.build
+index 75c48b07a5..887421bee0 100644
+--- a/src/systemd/meson.build
++++ b/src/systemd/meson.build
+@@ -12,6 +12,7 @@ _systemd_headers = '''
+         sd-journal.h
+         sd-login.h
+         sd-messages.h
++        sd-lldp.h
+ '''.split()
+ 
+ # https://github.com/mesonbuild/meson/issues/1633
+@@ -25,7 +26,6 @@ _not_installed_headers = '''
+         sd-dhcp-server.h
+         sd-ipv4acd.h
+         sd-ipv4ll.h
+-        sd-lldp.h
+         sd-ndisc.h
+         sd-netlink.h
+         sd-network.h
+diff --git a/src/test/meson.build b/src/test/meson.build
+index de31e977bc..680d1dec6b 100644
+--- a/src/test/meson.build
++++ b/src/test/meson.build
+@@ -1010,6 +1010,11 @@ tests += [
+          [],
+          []],
+ 
++        [['src/libsystemd/sd-lldp/test-lldp.c'],
++         [libbasic,libshared_static,libsystemd_static
++          ],
++         []],
++
+ ]
+ 
+ # test-bus-vtable-cc.cc is a symlink and symlinks get lost in containers on FuzzBuzz.
+@@ -1098,11 +1103,6 @@ tests += [
+          [libshared,
+           libsystemd_network],
+          []],
+-
+-        [['src/libsystemd-network/test-lldp.c'],
+-         [libshared,
+-          libsystemd_network],
+-         []],
+ ]
+ 
+ ############################################################
+-- 
+2.28.0
+
diff --git a/ci/build.sh b/ci/build.sh
index 1158727..4fced8e 100755
--- a/ci/build.sh
+++ b/ci/build.sh
@@ -61,7 +61,7 @@
     # We don't use gating, so there's a risk that there's no prebuilt artifact, so don't die if we cannot download that file
     curl ${ARTIFACT_URL} | unzstd --stdout | tar -xf - || echo "No Buildroot prebuilt tarball found, will build from scratch"
 
-    for PROJECT in cla-sysrepo netconf-cli gammarus velia; do
+    for PROJECT in cla-sysrepo netconf-cli gammarus velia lldp-systemd-networkd-sysrepo; do
         # If there's a change for ${PROJECT} queued ahead, ensure it gets used.
         # This means that if our submodules still pin, say, `cla-sysrepo` to some ancient version and we're testing a `netconf-cli` change,
         # then we will keep using that ancient `cla-sysrepo`. Hopefully this reduces the number of false alerts.
diff --git a/configs/czechlight_clearfog_defconfig b/configs/czechlight_clearfog_defconfig
index 97f6117..69acd06 100644
--- a/configs/czechlight_clearfog_defconfig
+++ b/configs/czechlight_clearfog_defconfig
@@ -4,7 +4,7 @@
 BR2_ARM_ENABLE_VFP=y
 BR2_ARM_FPU_NEON=y
 BR2_ENABLE_DEBUG=y
-BR2_STRIP_EXCLUDE_FILES="cla-* netopeer2* sysrepo* libsysrepo* libSysrepo* libnetconf2* libyang* sysrepo-cli veliad"
+BR2_STRIP_EXCLUDE_FILES="cla-* netopeer2* sysrepo* libsysrepo* libSysrepo* libnetconf2* libyang* sysrepo-cli veliad lldp-systemd-networkd-sysrepod"
 BR2_STRIP_EXCLUDE_DIRS="/usr/lib/libyang /usr/lib/sysrepo"
 BR2_GLOBAL_PATCH_DIR="$(BR2_EXTERNAL_CZECHLIGHT_PATH)/board/czechlight/common/patches"
 BR2_PER_PACKAGE_DIRECTORIES=y
@@ -105,4 +105,5 @@
 CZECHLIGHT_RAUC_SLOT_B_CFG_DEV="/dev/mmcblk0p4"
 BR2_PACKAGE_GAMMARUS=y
 BR2_PACKAGE_VELIA=y
+BR2_PACKAGE_LLDP_SYSTEMD_NETWORKD_SYSREPO=y
 CZECHLIGHT_NETCONF=y
diff --git a/dev-setup-git.sh b/dev-setup-git.sh
index 447d48b..1f9aedc 100755
--- a/dev-setup-git.sh
+++ b/dev-setup-git.sh
@@ -24,6 +24,7 @@
 PYBIND11_OVERRIDE_SRCDIR = ${CZECHLIGHT_BR2_EXT_LOC}/submodules/pybind11
 SDBUS_CPP_OVERRIDE_SRCDIR = ${CZECHLIGHT_BR2_EXT_LOC}/submodules/cla-sysrepo/submodules/dependencies/sdbus-cpp
 VELIA_OVERRIDE_SRCDIR = ${CZECHLIGHT_BR2_EXT_LOC}/submodules/velia
+LLDP_SYSTEMD_NETWORKD_SYSREPO_OVERRIDE_SRCDIR = ${CZECHLIGHT_BR2_EXT_LOC}/submodules/lldp-systemd-networkd-sysrepo
 
 define CZECHLIGHT_GIT_FIX_GITDIR
 	echo "gitdir: \$\$(git rev-parse --resolve-git-dir \$(SRCDIR)/.git)" > \$(@D)/.git
@@ -32,6 +33,7 @@
 NETCONF_CLI_POST_RSYNC_HOOKS += CZECHLIGHT_GIT_FIX_GITDIR
 GAMMARUS_POST_RSYNC_HOOKS += CZECHLIGHT_GIT_FIX_GITDIR
 VELIA_POST_RSYNC_HOOKS += CZECHLIGHT_GIT_FIX_GITDIR
+LLDP_SYSTEMD_NETWORKD_SYSREPO_POST_RSYNC_HOOKS += CZECHLIGHT_GIT_FIX_GITDIR
 
 EOF
 
diff --git a/package/Config.in b/package/Config.in
index 13a2666..d09116f 100644
--- a/package/Config.in
+++ b/package/Config.in
@@ -4,5 +4,6 @@
 source "$BR2_EXTERNAL_CZECHLIGHT_PATH/package/czechlight-rauc/Config.in"
 source "$BR2_EXTERNAL_CZECHLIGHT_PATH/package/czechlight-separate-boot/Config.in"
 source "$BR2_EXTERNAL_CZECHLIGHT_PATH/package/gammarus/Config.in"
+source "$BR2_EXTERNAL_CZECHLIGHT_PATH/package/lldp-systemd-networkd-sysrepo/Config.in"
 source "$BR2_EXTERNAL_CZECHLIGHT_PATH/package/velia/Config.in"
 source "$BR2_EXTERNAL_CZECHLIGHT_PATH/package/grub2-tools/Config.in"
diff --git a/package/lldp-systemd-networkd-sysrepo/Config.in b/package/lldp-systemd-networkd-sysrepo/Config.in
new file mode 100644
index 0000000..4b9e418
--- /dev/null
+++ b/package/lldp-systemd-networkd-sysrepo/Config.in
@@ -0,0 +1,12 @@
+config BR2_PACKAGE_LLDP_SYSTEMD_NETWORKD_SYSREPO
+	bool "lldp-systemd-networkd-sysrepo"
+	select BR2_PACKAGE_SPDLOG
+	select BR2_PACKAGE_SDBUS_CPP
+	select BR2_PACKAGE_SYSTEMD
+	select BR2_PACKAGE_DOCOPT_CPP
+	select BR2_PACKAGE_SYSREPO
+	select BR2_PACKAGE_SYSREPO_CPP
+	help
+	  lldp-systemd-networkd-sysrepo is a sysrepo application announcing LLDP neighbours from systemd-networkd.
+
+	  https://gerrit.cesnet.cz/q/project:CzechLight/lldp-systemd-networkd-sysrepo
diff --git a/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo-install-yang.service b/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo-install-yang.service
new file mode 100644
index 0000000..003f7e2
--- /dev/null
+++ b/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo-install-yang.service
@@ -0,0 +1,14 @@
+[Unit]
+Description=Install YANG and initial data for lldp-systemd-networkd-sysrepo
+Requires=sysrepod.service
+Before=sysrepod.service
+
+[Service]
+Type=oneshot
+ExecStart=/usr/bin/sysrepoctl --install --yang /usr/share/lldp-systemd-networkd-sysrepo/yang/czechlight-lldp.yang
+ExecStart=/usr/bin/sysrepoctl --install --yang /usr/share/lldp-systemd-networkd-sysrepo/yang/iana-afn-safi@2013-07-04.yang
+ExecStart=/usr/bin/sysrepoctl --install --yang /usr/share/lldp-systemd-networkd-sysrepo/yang/ietf-inet-types@2013-07-15.yang
+ExecStart=/bin/cp -a /etc/sysrepo /cfg/etc/
+
+[Install]
+WantedBy=multi-user.target
diff --git a/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo.hash b/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo.hash
new file mode 100644
index 0000000..075e53a
--- /dev/null
+++ b/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo.hash
@@ -0,0 +1 @@
+none xxx
diff --git a/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo.mk b/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo.mk
new file mode 100644
index 0000000..84f6252
--- /dev/null
+++ b/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo.mk
@@ -0,0 +1,20 @@
+LLDP_SYSTEMD_NETWORKD_SYSREPO_VERSION = master
+LLDP_SYSTEMD_NETWORKD_SYSREPO_SITE = https://gerrit.cesnet.cz/CzechLight/lldp-systemd-networkd-sysrepo
+LLDP_SYSTEMD_NETWORKD_SYSREPO_SITE_METHOD = git
+LLDP_SYSTEMD_NETWORKD_SYSREPO_INSTALL_STAGING = NO
+LLDP_SYSTEMD_NETWORKD_SYSREPO_DEPENDENCIES = spdlog sdbus-cpp systemd docopt-cpp sysrepo
+LLDP_SYSTEMD_NETWORKD_SYSREPO_CONF_OPTS = -DTHREADS_PTHREAD_ARG:STRING=-pthread
+LLDP_SYSTEMD_NETWORKD_SYSREPO_LICENSE = Apache-2.0
+LLDP_SYSTEMD_NETWORKD_SYSREPO_LICENSE_FILES = LICENSE.md
+
+define LLDP_SYSTEMD_NETWORKD_SYSREPO_INSTALL_INIT_SYSTEMD
+        mkdir -p $(TARGET_DIR)/usr/lib/systemd/system/multi-user.target.wants/
+        $(INSTALL) -D -m 0644 \
+                $(BR2_EXTERNAL_CZECHLIGHT_PATH)/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo.service \
+                $(BR2_EXTERNAL_CZECHLIGHT_PATH)/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo-install-yang.service \
+                $(TARGET_DIR)/usr/lib/systemd/system/
+        ln -sf ../lldp-systemd-networkd-sysrepo.service $(TARGET_DIR)/usr/lib/systemd/system/multi-user.target.wants/
+        ln -sf ../lldp-systemd-networkd-sysrepo-install-yang.service $(TARGET_DIR)/usr/lib/systemd/system/multi-user.target.wants/
+endef
+
+$(eval $(cmake-package))
diff --git a/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo.service b/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo.service
new file mode 100644
index 0000000..94c7f62
--- /dev/null
+++ b/package/lldp-systemd-networkd-sysrepo/lldp-systemd-networkd-sysrepo.service
@@ -0,0 +1,19 @@
+[Unit]
+Description=lldp-systemd-networkd-sysrepo is a sysrepo application announcing LLDP neighbours from systemd-networkd.
+After=syslog.target network.target sysrepod.service
+Requires=sysrepod.service
+
+[Service]
+Type=simple
+ExecStart=/usr/bin/lldp-systemd-networkd-sysrepod
+PrivateTmp=yes
+PrivateDevices=no
+ProtectSystem=yes
+ProtectHome=yes
+Restart=always
+LogRateLimitIntervalSec=10
+LogRateLimitBurst=30000
+SyslogLevel=alert
+
+[Install]
+WantedBy=multi-user.target
diff --git a/submodules/lldp-systemd-networkd-sysrepo b/submodules/lldp-systemd-networkd-sysrepo
new file mode 160000
index 0000000..3b669e6
--- /dev/null
+++ b/submodules/lldp-systemd-networkd-sysrepo
@@ -0,0 +1 @@
+Subproject commit 3b669e6108501de411039b4972f8a6a34b882e6d