shaba/systemd-stable
1
1
Fork 0
mirror of https://github.com/systemd/systemd-stable.git synced 2025-01-03 01:17:45 +03:00
Code

sd-lldp-rx: rename sd_lldp -> sd_lldp_rx

Browse Source
This commit is contained in:
Yu Watanabe 2021-09-26 12:39:36 +09:00
parent 94832e6e55
commit 35778343ab
11 changed files with 312 additions and 312 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

14
src/libsystemd-network/fuzz-lldp-rx.c
View File

@ -21,22 +21,22 @@ int lldp_network_bind_raw_socket(int ifindex) {
int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) {
_cleanup_(sd_event_unrefp) sd_event *e = NULL; _cleanup_(sd_event_unrefp) sd_event *e = NULL;
_cleanup_(sd_lldp_unrefp) sd_lldp *lldp = NULL; _cleanup_(sd_lldp_rx_unrefp) sd_lldp_rx *lldp_rx = NULL;
if (size > 2048) if (size > 2048)
return 0; return 0;
assert_se(sd_event_new(&e) == 0); assert_se(sd_event_new(&e) == 0);
assert_se(sd_lldp_new(&lldp) >= 0); assert_se(sd_lldp_rx_new(&lldp_rx) >= 0);
assert_se(sd_lldp_set_ifindex(lldp, 42) >= 0); assert_se(sd_lldp_rx_set_ifindex(lldp_rx, 42) >= 0);
assert_se(sd_lldp_attach_event(lldp, e, 0) >= 0); assert_se(sd_lldp_rx_attach_event(lldp_rx, e, 0) >= 0);
assert_se(sd_lldp_start(lldp) >= 0); assert_se(sd_lldp_rx_start(lldp_rx) >= 0);
assert_se(write(test_fd[1], data, size) == (ssize_t) size); assert_se(write(test_fd[1], data, size) == (ssize_t) size);
assert_se(sd_event_run(e, 0) >= 0); assert_se(sd_event_run(e, 0) >= 0);
assert_se(sd_lldp_stop(lldp) >= 0); assert_se(sd_lldp_rx_stop(lldp_rx) >= 0);
assert_se(sd_lldp_detach_event(lldp) >= 0); assert_se(sd_lldp_rx_detach_event(lldp_rx) >= 0);
test_fd[1] = safe_close(test_fd[1]); test_fd[1] = safe_close(test_fd[1]);
return 0; return 0;

88
src/libsystemd-network/lldp-neighbor.c
View File

@ -35,7 +35,7 @@ _public_ sd_lldp_neighbor *sd_lldp_neighbor_ref(sd_lldp_neighbor *n) {
if (!n) if (!n)
return NULL; return NULL;
assert(n->n_ref > 0 || n->lldp); assert(n->n_ref > 0 || n->lldp_rx);
n->n_ref++; n->n_ref++;
return n; return n;
@ -66,7 +66,7 @@ _public_ sd_lldp_neighbor *sd_lldp_neighbor_unref(sd_lldp_neighbor *n) {
assert(n->n_ref > 0); assert(n->n_ref > 0);
n->n_ref--; n->n_ref--;
if (n->n_ref <= 0 && !n->lldp) if (n->n_ref <= 0 && !n->lldp_rx)
lldp_neighbor_free(n); lldp_neighbor_free(n);
return NULL; return NULL;
@ -79,18 +79,18 @@ sd_lldp_neighbor *lldp_neighbor_unlink(sd_lldp_neighbor *n) {
if (!n) if (!n)
return NULL; return NULL;
if (!n->lldp) if (!n->lldp_rx)
return NULL; 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 /* 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 * 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. */ * 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); (void) hashmap_remove_value(n->lldp_rx->neighbor_by_id, &n->id, n);
assert_se(prioq_remove(n->lldp->neighbor_by_expiry, n, &n->prioq_idx) >= 0); assert_se(prioq_remove(n->lldp_rx->neighbor_by_expiry, n, &n->prioq_idx) >= 0);
n->lldp = NULL; n->lldp_rx = NULL;
if (n->n_ref <= 0) if (n->n_ref <= 0)
lldp_neighbor_free(n); lldp_neighbor_free(n);
@ -111,7 +111,7 @@ sd_lldp_neighbor *lldp_neighbor_new(size_t raw_size) {
return n; return n;
} }
static int parse_string(sd_lldp *lldp, char **s, const void *q, size_t n) { static int parse_string(sd_lldp_rx *lldp_rx, char **s, const void *q, size_t n) {
const char *p = q; const char *p = q;
char *k; char *k;
@ -119,7 +119,7 @@ static int parse_string(sd_lldp *lldp, char **s, const void *q, size_t n) {
assert(p || n == 0); assert(p || n == 0);
if (*s) { if (*s) {
log_lldp(lldp, "Found duplicate string, ignoring field."); log_lldp_rx(lldp_rx, "Found duplicate string, ignoring field.");
return 0; return 0;
} }
@ -132,7 +132,7 @@ static int parse_string(sd_lldp *lldp, char **s, const void *q, size_t n) {
/* Look for inner NULs */ /* Look for inner NULs */
if (memchr(p, 0, n)) { if (memchr(p, 0, n)) {
log_lldp(lldp, "Found inner NUL in string, ignoring field."); log_lldp_rx(lldp_rx, "Found inner NUL in string, ignoring field.");
return 0; return 0;
} }
@ -156,14 +156,14 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) {
assert(n); assert(n);
if (n->raw_size < sizeof(struct ether_header)) if (n->raw_size < sizeof(struct ether_header))
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Received truncated packet, ignoring."); "Received truncated packet, ignoring.");
memcpy(&h, LLDP_NEIGHBOR_RAW(n), sizeof(h)); memcpy(&h, LLDP_NEIGHBOR_RAW(n), sizeof(h));
if (h.ether_type != htobe16(ETHERTYPE_LLDP)) if (h.ether_type != htobe16(ETHERTYPE_LLDP))
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Received packet with wrong type, ignoring."); "Received packet with wrong type, ignoring.");
if (h.ether_dhost[0] != 0x01 || if (h.ether_dhost[0] != 0x01 ||
h.ether_dhost[1] != 0x80 || h.ether_dhost[1] != 0x80 ||
@ -171,8 +171,8 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) {
h.ether_dhost[3] != 0x00 || h.ether_dhost[3] != 0x00 ||
h.ether_dhost[4] != 0x00 || h.ether_dhost[4] != 0x00 ||
!IN_SET(h.ether_dhost[5], 0x00, 0x03, 0x0e)) !IN_SET(h.ether_dhost[5], 0x00, 0x03, 0x0e))
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Received packet with wrong destination address, ignoring."); "Received packet with wrong destination address, ignoring.");
memcpy(&n->source_address, h.ether_shost, sizeof(struct ether_addr)); memcpy(&n->source_address, h.ether_shost, sizeof(struct ether_addr));
memcpy(&n->destination_address, h.ether_dhost, sizeof(struct ether_addr)); memcpy(&n->destination_address, h.ether_dhost, sizeof(struct ether_addr));
@ -185,7 +185,7 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) {
uint16_t length; uint16_t length;
if (left < 2) if (left < 2)
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"TLV lacks header, ignoring."); "TLV lacks header, ignoring.");
type = p[0] >> 1; type = p[0] >> 1;
@ -193,15 +193,15 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) {
p += 2, left -= 2; p += 2, left -= 2;
if (left < length) if (left < length)
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"TLV truncated, ignoring datagram."); "TLV truncated, ignoring datagram.");
switch (type) { switch (type) {
case SD_LLDP_TYPE_END: case SD_LLDP_TYPE_END:
if (length != 0) if (length != 0)
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"End marker TLV not zero-sized, ignoring datagram."); "End marker TLV not zero-sized, ignoring datagram.");
/* Note that after processing the SD_LLDP_TYPE_END left could still be > 0 /* 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) */ * as the message may contain padding (see IEEE 802.1AB-2016, sec. 8.5.12) */
@ -211,12 +211,12 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) {
case SD_LLDP_TYPE_CHASSIS_ID: case SD_LLDP_TYPE_CHASSIS_ID:
if (length < 2 || length > 256) if (length < 2 || length > 256)
/* includes the chassis subtype, hence one extra byte */ /* includes the chassis subtype, hence one extra byte */
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Chassis ID field size out of range, ignoring datagram."); "Chassis ID field size out of range, ignoring datagram.");
if (n->id.chassis_id) if (n->id.chassis_id)
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Duplicate chassis ID field, ignoring datagram."); "Duplicate chassis ID field, ignoring datagram.");
n->id.chassis_id = memdup(p, length); n->id.chassis_id = memdup(p, length);
if (!n->id.chassis_id) if (!n->id.chassis_id)
@ -228,12 +228,12 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) {
case SD_LLDP_TYPE_PORT_ID: case SD_LLDP_TYPE_PORT_ID:
if (length < 2 || length > 256) if (length < 2 || length > 256)
/* includes the port subtype, hence one extra byte */ /* includes the port subtype, hence one extra byte */
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Port ID field size out of range, ignoring datagram."); "Port ID field size out of range, ignoring datagram.");
if (n->id.port_id) if (n->id.port_id)
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Duplicate port ID field, ignoring datagram."); "Duplicate port ID field, ignoring datagram.");
n->id.port_id = memdup(p, length); n->id.port_id = memdup(p, length);
if (!n->id.port_id) if (!n->id.port_id)
@ -244,39 +244,39 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) {
case SD_LLDP_TYPE_TTL: case SD_LLDP_TYPE_TTL:
if (length != 2) if (length != 2)
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"TTL field has wrong size, ignoring datagram."); "TTL field has wrong size, ignoring datagram.");
if (n->has_ttl) if (n->has_ttl)
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Duplicate TTL field, ignoring datagram."); "Duplicate TTL field, ignoring datagram.");
n->ttl = unaligned_read_be16(p); n->ttl = unaligned_read_be16(p);
n->has_ttl = true; n->has_ttl = true;
break; break;
case SD_LLDP_TYPE_PORT_DESCRIPTION: case SD_LLDP_TYPE_PORT_DESCRIPTION:
r = parse_string(n->lldp, &n->port_description, p, length); r = parse_string(n->lldp_rx, &n->port_description, p, length);
if (r < 0) if (r < 0)
return r; return r;
break; break;
case SD_LLDP_TYPE_SYSTEM_NAME: case SD_LLDP_TYPE_SYSTEM_NAME:
r = parse_string(n->lldp, &n->system_name, p, length); r = parse_string(n->lldp_rx, &n->system_name, p, length);
if (r < 0) if (r < 0)
return r; return r;
break; break;
case SD_LLDP_TYPE_SYSTEM_DESCRIPTION: case SD_LLDP_TYPE_SYSTEM_DESCRIPTION:
r = parse_string(n->lldp, &n->system_description, p, length); r = parse_string(n->lldp_rx, &n->system_description, p, length);
if (r < 0) if (r < 0)
return r; return r;
break; break;
case SD_LLDP_TYPE_SYSTEM_CAPABILITIES: case SD_LLDP_TYPE_SYSTEM_CAPABILITIES:
if (length != 4) if (length != 4)
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"System capabilities field has wrong size."); "System capabilities field has wrong size.");
n->system_capabilities = unaligned_read_be16(p); n->system_capabilities = unaligned_read_be16(p);
n->enabled_capabilities = unaligned_read_be16(p + 2); n->enabled_capabilities = unaligned_read_be16(p + 2);
@ -285,13 +285,13 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) {
case SD_LLDP_TYPE_PRIVATE: case SD_LLDP_TYPE_PRIVATE:
if (length < 4) if (length < 4)
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"Found private TLV that is too short, ignoring."); "Found private TLV that is too short, ignoring.");
/* RFC 8520: MUD URL */ /* RFC 8520: MUD URL */
if (memcmp(p, SD_LLDP_OUI_MUD, sizeof(SD_LLDP_OUI_MUD)) == 0 && if (memcmp(p, SD_LLDP_OUI_MUD, sizeof(SD_LLDP_OUI_MUD)) == 0 &&
p[sizeof(SD_LLDP_OUI_MUD)] == SD_LLDP_OUI_SUBTYPE_MUD_USAGE_DESCRIPTION) { p[sizeof(SD_LLDP_OUI_MUD)] == SD_LLDP_OUI_SUBTYPE_MUD_USAGE_DESCRIPTION) {
r = parse_string(n->lldp, &n->mud_url, p + sizeof(SD_LLDP_OUI_MUD) + 1, r = parse_string(n->lldp_rx, &n->mud_url, p + sizeof(SD_LLDP_OUI_MUD) + 1,
length - 1 - sizeof(SD_LLDP_OUI_MUD)); length - 1 - sizeof(SD_LLDP_OUI_MUD));
if (r < 0) if (r < 0)
return r; return r;
@ -304,8 +304,8 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) {
end_marker: end_marker:
if (!n->id.chassis_id || !n->id.port_id || !n->has_ttl) if (!n->id.chassis_id || !n->id.port_id || !n->has_ttl)
return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG),
"One or more mandatory TLV missing in datagram. Ignoring."); "One or more mandatory TLV missing in datagram. Ignoring.");
n->rindex = sizeof(struct ether_header); n->rindex = sizeof(struct ether_header);
@ -327,8 +327,8 @@ void lldp_neighbor_start_ttl(sd_lldp_neighbor *n) {
} else } else
n->until = 0; n->until = 0;
if (n->lldp) if (n->lldp_rx)
prioq_reshuffle(n->lldp->neighbor_by_expiry, n, &n->prioq_idx); prioq_reshuffle(n->lldp_rx->neighbor_by_expiry, n, &n->prioq_idx);
} }
bool lldp_neighbor_equal(const sd_lldp_neighbor *a, const sd_lldp_neighbor *b) { bool lldp_neighbor_equal(const sd_lldp_neighbor *a, const sd_lldp_neighbor *b) {

4
src/libsystemd-network/lldp-neighbor.h
View File

@ -21,8 +21,8 @@ typedef struct LLDPNeighborID {
} LLDPNeighborID; } LLDPNeighborID;
struct sd_lldp_neighbor { struct sd_lldp_neighbor {
/* Neighbor objects stay around as long as they are linked into an "sd_lldp" object or n_ref > 0. */ /* Neighbor objects stay around as long as they are linked into an "sd_lldp_rx" object or n_ref > 0. */
sd_lldp *lldp; sd_lldp_rx *lldp_rx;
unsigned n_ref; unsigned n_ref;
triple_timestamp timestamp; triple_timestamp timestamp;

20
src/libsystemd-network/lldp-rx-internal.h
View File

@ -8,7 +8,7 @@
#include "log-link.h" #include "log-link.h"
#include "prioq.h" #include "prioq.h"
struct sd_lldp { struct sd_lldp_rx {
unsigned n_ref; unsigned n_ref;
int ifindex; int ifindex;
@ -25,7 +25,7 @@ struct sd_lldp {
uint64_t neighbors_max; uint64_t neighbors_max;
sd_lldp_callback_t callback; sd_lldp_rx_callback_t callback;
void *userdata; void *userdata;
uint16_t capability_mask; uint16_t capability_mask;
@ -33,16 +33,16 @@ struct sd_lldp {
struct ether_addr filter_address; struct ether_addr filter_address;
}; };
const char* lldp_event_to_string(sd_lldp_event_t e) _const_; const char* lldp_rx_event_to_string(sd_lldp_rx_event_t e) _const_;
sd_lldp_event_t lldp_event_from_string(const char *s) _pure_; sd_lldp_rx_event_t lldp_rx_event_from_string(const char *s) _pure_;
#define log_lldp_errno(lldp, error, fmt, ...) \ #define log_lldp_rx_errno(lldp_rx, error, fmt, ...) \
log_interface_prefix_full_errno( \ log_interface_prefix_full_errno( \
"LLDP: ", \ "LLDP Rx: ", \
sd_lldp_get_ifname(lldp), \ sd_lldp_rx_get_ifname(lldp_rx), \
error, fmt, ##__VA_ARGS__) error, fmt, ##__VA_ARGS__)
#define log_lldp(lldp, fmt, ...) \ #define log_lldp_rx(lldp_rx, fmt, ...) \
log_interface_prefix_full_errno_zerook( \ log_interface_prefix_full_errno_zerook( \
"LLDP: ", \ "LLDP Rx: ", \
sd_lldp_get_ifname(lldp), \ sd_lldp_rx_get_ifname(lldp_rx), \
0, fmt, ##__VA_ARGS__) 0, fmt, ##__VA_ARGS__)

318
src/libsystemd-network/sd-lldp-rx.c
View File

@ -21,37 +21,37 @@
#define LLDP_DEFAULT_NEIGHBORS_MAX 128U #define LLDP_DEFAULT_NEIGHBORS_MAX 128U
static const char * const lldp_event_table[_SD_LLDP_EVENT_MAX] = { static const char * const lldp_rx_event_table[_SD_LLDP_RX_EVENT_MAX] = {
[SD_LLDP_EVENT_ADDED] = "added", [SD_LLDP_RX_EVENT_ADDED] = "added",
[SD_LLDP_EVENT_REMOVED] = "removed", [SD_LLDP_RX_EVENT_REMOVED] = "removed",
[SD_LLDP_EVENT_UPDATED] = "updated", [SD_LLDP_RX_EVENT_UPDATED] = "updated",
[SD_LLDP_EVENT_REFRESHED] = "refreshed", [SD_LLDP_RX_EVENT_REFRESHED] = "refreshed",
}; };
DEFINE_STRING_TABLE_LOOKUP(lldp_event, sd_lldp_event_t); DEFINE_STRING_TABLE_LOOKUP(lldp_rx_event, sd_lldp_rx_event_t);
static void lldp_flush_neighbors(sd_lldp *lldp) { static void lldp_rx_flush_neighbors(sd_lldp_rx *lldp_rx) {
assert(lldp); assert(lldp_rx);
hashmap_clear(lldp->neighbor_by_id); hashmap_clear(lldp_rx->neighbor_by_id);
} }
static void lldp_callback(sd_lldp *lldp, sd_lldp_event_t event, sd_lldp_neighbor *n) { static void lldp_rx_callback(sd_lldp_rx *lldp_rx, sd_lldp_rx_event_t event, sd_lldp_neighbor *n) {
assert(lldp); assert(lldp_rx);
assert(event >= 0 && event < _SD_LLDP_EVENT_MAX); assert(event >= 0 && event < _SD_LLDP_RX_EVENT_MAX);
if (!lldp->callback) if (!lldp_rx->callback)
return (void) log_lldp(lldp, "Received '%s' event.", lldp_event_to_string(event)); return (void) log_lldp_rx(lldp_rx, "Received '%s' event.", lldp_rx_event_to_string(event));
log_lldp(lldp, "Invoking callback for '%s' event.", lldp_event_to_string(event)); log_lldp_rx(lldp_rx, "Invoking callback for '%s' event.", lldp_rx_event_to_string(event));
lldp->callback(lldp, event, n, lldp->userdata); lldp_rx->callback(lldp_rx, event, n, lldp_rx->userdata);
} }
static int lldp_make_space(sd_lldp *lldp, size_t extra) { static int lldp_rx_make_space(sd_lldp_rx *lldp_rx, size_t extra) {
usec_t t = USEC_INFINITY; usec_t t = USEC_INFINITY;
bool changed = false; bool changed = false;
assert(lldp); assert(lldp_rx);
/* Remove all entries that are past their TTL, and more until at least the specified number of extra entries /* Remove all entries that are past their TTL, and more until at least the specified number of extra entries
* are free. */ * are free. */
@ -59,13 +59,13 @@ static int lldp_make_space(sd_lldp *lldp, size_t extra) {
for (;;) { for (;;) {
_cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL; _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
n = prioq_peek(lldp->neighbor_by_expiry); n = prioq_peek(lldp_rx->neighbor_by_expiry);
if (!n) if (!n)
break; break;
sd_lldp_neighbor_ref(n); sd_lldp_neighbor_ref(n);
if (hashmap_size(lldp->neighbor_by_id) > LESS_BY(lldp->neighbors_max, extra)) if (hashmap_size(lldp_rx->neighbor_by_id) > LESS_BY(lldp_rx->neighbors_max, extra))
goto remove_one; goto remove_one;
if (t == USEC_INFINITY) if (t == USEC_INFINITY)
@ -76,15 +76,15 @@ static int lldp_make_space(sd_lldp *lldp, size_t extra) {
remove_one: remove_one:
lldp_neighbor_unlink(n); lldp_neighbor_unlink(n);
lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, n); lldp_rx_callback(lldp_rx, SD_LLDP_RX_EVENT_REMOVED, n);
changed = true; changed = true;
} }
return changed; return changed;
} }
static bool lldp_keep_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) { static bool lldp_rx_keep_neighbor(sd_lldp_rx *lldp_rx, sd_lldp_neighbor *n) {
assert(lldp); assert(lldp_rx);
assert(n); assert(n);
/* Don't keep data with a zero TTL */ /* Don't keep data with a zero TTL */
@ -92,49 +92,49 @@ static bool lldp_keep_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) {
return false; return false;
/* Filter out data from the filter address */ /* Filter out data from the filter address */
if (!ether_addr_is_null(&lldp->filter_address) && if (!ether_addr_is_null(&lldp_rx->filter_address) &&
ether_addr_equal(&lldp->filter_address, &n->source_address)) ether_addr_equal(&lldp_rx->filter_address, &n->source_address))
return false; return false;
/* Only add if the neighbor has a capability we are interested in. Note that we also store all neighbors with /* Only add if the neighbor has a capability we are interested in. Note that we also store all neighbors with
* no caps field set. */ * no caps field set. */
if (n->has_capabilities && if (n->has_capabilities &&
(n->enabled_capabilities & lldp->capability_mask) == 0) (n->enabled_capabilities & lldp_rx->capability_mask) == 0)
return false; return false;
/* Keep everything else */ /* Keep everything else */
return true; return true;
} }
static int lldp_start_timer(sd_lldp *lldp, sd_lldp_neighbor *neighbor); static int lldp_rx_start_timer(sd_lldp_rx *lldp_rx, sd_lldp_neighbor *neighbor);
static int lldp_add_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) { static int lldp_rx_add_neighbor(sd_lldp_rx *lldp_rx, sd_lldp_neighbor *n) {
_cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *old = NULL; _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *old = NULL;
bool keep; bool keep;
int r; int r;
assert(lldp); assert(lldp_rx);
assert(n); assert(n);
assert(!n->lldp); assert(!n->lldp_rx);
keep = lldp_keep_neighbor(lldp, n); keep = lldp_rx_keep_neighbor(lldp_rx, n);
/* First retrieve the old entry for this MSAP */ /* First retrieve the old entry for this MSAP */
old = hashmap_get(lldp->neighbor_by_id, &n->id); old = hashmap_get(lldp_rx->neighbor_by_id, &n->id);
if (old) { if (old) {
sd_lldp_neighbor_ref(old); sd_lldp_neighbor_ref(old);
if (!keep) { if (!keep) {
lldp_neighbor_unlink(old); lldp_neighbor_unlink(old);
lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, old); lldp_rx_callback(lldp_rx, SD_LLDP_RX_EVENT_REMOVED, old);
return 0; return 0;
} }
if (lldp_neighbor_equal(n, old)) { if (lldp_neighbor_equal(n, old)) {
/* Is this equal, then restart the TTL counter, but don't do anything else. */ /* Is this equal, then restart the TTL counter, but don't do anything else. */
old->timestamp = n->timestamp; old->timestamp = n->timestamp;
lldp_start_timer(lldp, old); lldp_rx_start_timer(lldp_rx, old);
lldp_callback(lldp, SD_LLDP_EVENT_REFRESHED, old); lldp_rx_callback(lldp_rx, SD_LLDP_RX_EVENT_REFRESHED, old);
return 0; return 0;
} }
@ -145,36 +145,36 @@ static int lldp_add_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) {
return 0; return 0;
/* Then, make room for at least one new neighbor */ /* Then, make room for at least one new neighbor */
lldp_make_space(lldp, 1); lldp_rx_make_space(lldp_rx, 1);
r = hashmap_put(lldp->neighbor_by_id, &n->id, n); r = hashmap_put(lldp_rx->neighbor_by_id, &n->id, n);
if (r < 0) if (r < 0)
goto finish; goto finish;
r = prioq_put(lldp->neighbor_by_expiry, n, &n->prioq_idx); r = prioq_put(lldp_rx->neighbor_by_expiry, n, &n->prioq_idx);
if (r < 0) { if (r < 0) {
assert_se(hashmap_remove(lldp->neighbor_by_id, &n->id) == n); assert_se(hashmap_remove(lldp_rx->neighbor_by_id, &n->id) == n);
goto finish; goto finish;
} }
n->lldp = lldp; n->lldp_rx = lldp_rx;
lldp_start_timer(lldp, n); lldp_rx_start_timer(lldp_rx, n);
lldp_callback(lldp, old ? SD_LLDP_EVENT_UPDATED : SD_LLDP_EVENT_ADDED, n); lldp_rx_callback(lldp_rx, old ? SD_LLDP_RX_EVENT_UPDATED : SD_LLDP_RX_EVENT_ADDED, n);
return 1; return 1;
finish: finish:
if (old) if (old)
lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, old); lldp_rx_callback(lldp_rx, SD_LLDP_RX_EVENT_REMOVED, old);
return r; return r;
} }
static int lldp_handle_datagram(sd_lldp *lldp, sd_lldp_neighbor *n) { static int lldp_rx_handle_datagram(sd_lldp_rx *lldp_rx, sd_lldp_neighbor *n) {
int r; int r;
assert(lldp); assert(lldp_rx);
assert(n); assert(n);
r = lldp_neighbor_parse(n); r = lldp_neighbor_parse(n);
@ -183,28 +183,28 @@ static int lldp_handle_datagram(sd_lldp *lldp, sd_lldp_neighbor *n) {
if (r < 0) if (r < 0)
return r; return r;
r = lldp_add_neighbor(lldp, n); r = lldp_rx_add_neighbor(lldp_rx, n);
if (r < 0) { if (r < 0) {
log_lldp_errno(lldp, r, "Failed to add datagram. Ignoring."); log_lldp_rx_errno(lldp_rx, r, "Failed to add datagram. Ignoring.");
return 0; return 0;
} }
log_lldp(lldp, "Successfully processed LLDP datagram."); log_lldp_rx(lldp_rx, "Successfully processed LLDP datagram.");
return 0; return 0;
} }
static int lldp_receive_datagram(sd_event_source *s, int fd, uint32_t revents, void *userdata) { static int lldp_rx_receive_datagram(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
_cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL; _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
ssize_t space, length; ssize_t space, length;
sd_lldp *lldp = userdata; sd_lldp_rx *lldp_rx = userdata;
struct timespec ts; struct timespec ts;
assert(fd >= 0); assert(fd >= 0);
assert(lldp); assert(lldp_rx);
space = next_datagram_size_fd(fd); space = next_datagram_size_fd(fd);
if (space < 0) { if (space < 0) {
log_lldp_errno(lldp, space, "Failed to determine datagram size to read, ignoring: %m"); log_lldp_rx_errno(lldp_rx, space, "Failed to determine datagram size to read, ignoring: %m");
return 0; return 0;
} }
@ -217,12 +217,12 @@ static int lldp_receive_datagram(sd_event_source *s, int fd, uint32_t revents, v
if (IN_SET(errno, EAGAIN, EINTR)) if (IN_SET(errno, EAGAIN, EINTR))
return 0; return 0;
log_lldp_errno(lldp, errno, "Failed to read LLDP datagram, ignoring: %m"); log_lldp_rx_errno(lldp_rx, errno, "Failed to read LLDP datagram, ignoring: %m");
return 0; return 0;
} }
if ((size_t) length != n->raw_size) { if ((size_t) length != n->raw_size) {
log_lldp(lldp, "Packet size mismatch, ignoring"); log_lldp_rx(lldp_rx, "Packet size mismatch, ignoring");
return 0; return 0;
} }
@ -232,180 +232,180 @@ static int lldp_receive_datagram(sd_event_source *s, int fd, uint32_t revents, v
else else
triple_timestamp_get(&n->timestamp); triple_timestamp_get(&n->timestamp);
return lldp_handle_datagram(lldp, n); return lldp_rx_handle_datagram(lldp_rx, n);
} }
static void lldp_reset(sd_lldp *lldp) { static void lldp_rx_reset(sd_lldp_rx *lldp_rx) {
assert(lldp); assert(lldp_rx);
(void) event_source_disable(lldp->timer_event_source); (void) event_source_disable(lldp_rx->timer_event_source);
lldp->io_event_source = sd_event_source_disable_unref(lldp->io_event_source); lldp_rx->io_event_source = sd_event_source_disable_unref(lldp_rx->io_event_source);
lldp->fd = safe_close(lldp->fd); lldp_rx->fd = safe_close(lldp_rx->fd);
} }
_public_ int sd_lldp_start(sd_lldp *lldp) { _public_ int sd_lldp_rx_start(sd_lldp_rx *lldp_rx) {
int r; int r;
assert_return(lldp, -EINVAL); assert_return(lldp_rx, -EINVAL);
assert_return(lldp->event, -EINVAL); assert_return(lldp_rx->event, -EINVAL);
assert_return(lldp->ifindex > 0, -EINVAL); assert_return(lldp_rx->ifindex > 0, -EINVAL);
if (lldp->fd >= 0) if (lldp_rx->fd >= 0)
return 0; return 0;
assert(!lldp->io_event_source); assert(!lldp_rx->io_event_source);
lldp->fd = lldp_network_bind_raw_socket(lldp->ifindex); lldp_rx->fd = lldp_network_bind_raw_socket(lldp_rx->ifindex);
if (lldp->fd < 0) if (lldp_rx->fd < 0)
return lldp->fd; return lldp_rx->fd;
r = sd_event_add_io(lldp->event, &lldp->io_event_source, lldp->fd, EPOLLIN, lldp_receive_datagram, lldp); r = sd_event_add_io(lldp_rx->event, &lldp_rx->io_event_source, lldp_rx->fd, EPOLLIN, lldp_rx_receive_datagram, lldp_rx);
if (r < 0) if (r < 0)
goto fail; goto fail;
r = sd_event_source_set_priority(lldp->io_event_source, lldp->event_priority); r = sd_event_source_set_priority(lldp_rx->io_event_source, lldp_rx->event_priority);
if (r < 0) if (r < 0)
goto fail; goto fail;
(void) sd_event_source_set_description(lldp->io_event_source, "lldp-io"); (void) sd_event_source_set_description(lldp_rx->io_event_source, "lldp-rx-io");
log_lldp(lldp, "Started LLDP client"); log_lldp_rx(lldp_rx, "Started LLDP client");
return 1; return 1;
fail: fail:
lldp_reset(lldp); lldp_rx_reset(lldp_rx);
return r; return r;
} }
_public_ int sd_lldp_stop(sd_lldp *lldp) { _public_ int sd_lldp_rx_stop(sd_lldp_rx *lldp_rx) {
if (!lldp) if (!lldp_rx)
return 0; return 0;
if (lldp->fd < 0) if (lldp_rx->fd < 0)
return 0; return 0;
log_lldp(lldp, "Stopping LLDP client"); log_lldp_rx(lldp_rx, "Stopping LLDP client");
lldp_reset(lldp); lldp_rx_reset(lldp_rx);
lldp_flush_neighbors(lldp); lldp_rx_flush_neighbors(lldp_rx);
return 1; return 1;
} }
_public_ int sd_lldp_attach_event(sd_lldp *lldp, sd_event *event, int64_t priority) { _public_ int sd_lldp_rx_attach_event(sd_lldp_rx *lldp_rx, sd_event *event, int64_t priority) {
int r; int r;
assert_return(lldp, -EINVAL); assert_return(lldp_rx, -EINVAL);
assert_return(lldp->fd < 0, -EBUSY); assert_return(lldp_rx->fd < 0, -EBUSY);
assert_return(!lldp->event, -EBUSY); assert_return(!lldp_rx->event, -EBUSY);
if (event) if (event)
lldp->event = sd_event_ref(event); lldp_rx->event = sd_event_ref(event);
else { else {
r = sd_event_default(&lldp->event); r = sd_event_default(&lldp_rx->event);
if (r < 0) if (r < 0)
return r; return r;
} }
lldp->event_priority = priority; lldp_rx->event_priority = priority;
return 0; return 0;
} }
_public_ int sd_lldp_detach_event(sd_lldp *lldp) { _public_ int sd_lldp_rx_detach_event(sd_lldp_rx *lldp_rx) {
assert_return(lldp, -EINVAL); assert_return(lldp_rx, -EINVAL);
assert_return(lldp->fd < 0, -EBUSY); assert_return(lldp_rx->fd < 0, -EBUSY);
lldp->event = sd_event_unref(lldp->event); lldp_rx->event = sd_event_unref(lldp_rx->event);
return 0; return 0;
} }
_public_ sd_event* sd_lldp_get_event(sd_lldp *lldp) { _public_ sd_event* sd_lldp_rx_get_event(sd_lldp_rx *lldp_rx) {
assert_return(lldp, NULL); assert_return(lldp_rx, NULL);
return lldp->event; return lldp_rx->event;
} }
_public_ int sd_lldp_set_callback(sd_lldp *lldp, sd_lldp_callback_t cb, void *userdata) { _public_ int sd_lldp_rx_set_callback(sd_lldp_rx *lldp_rx, sd_lldp_rx_callback_t cb, void *userdata) {
assert_return(lldp, -EINVAL); assert_return(lldp_rx, -EINVAL);
lldp->callback = cb; lldp_rx->callback = cb;
lldp->userdata = userdata; lldp_rx->userdata = userdata;
return 0; return 0;
} }
_public_ int sd_lldp_set_ifindex(sd_lldp *lldp, int ifindex) { _public_ int sd_lldp_rx_set_ifindex(sd_lldp_rx *lldp_rx, int ifindex) {
assert_return(lldp, -EINVAL); assert_return(lldp_rx, -EINVAL);
assert_return(ifindex > 0, -EINVAL); assert_return(ifindex > 0, -EINVAL);
assert_return(lldp->fd < 0, -EBUSY); assert_return(lldp_rx->fd < 0, -EBUSY);
lldp->ifindex = ifindex; lldp_rx->ifindex = ifindex;
return 0; return 0;
} }
int sd_lldp_set_ifname(sd_lldp *lldp, const char *ifname) { int sd_lldp_rx_set_ifname(sd_lldp_rx *lldp_rx, const char *ifname) {
assert_return(lldp, -EINVAL); assert_return(lldp_rx, -EINVAL);
assert_return(ifname, -EINVAL); assert_return(ifname, -EINVAL);
if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE)) if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE))
return -EINVAL; return -EINVAL;
return free_and_strdup(&lldp->ifname, ifname); return free_and_strdup(&lldp_rx->ifname, ifname);
} }
const char *sd_lldp_get_ifname(sd_lldp *lldp) { const char *sd_lldp_rx_get_ifname(sd_lldp_rx *lldp_rx) {
if (!lldp) if (!lldp_rx)
return NULL; return NULL;
return get_ifname(lldp->ifindex, &lldp->ifname); return get_ifname(lldp_rx->ifindex, &lldp_rx->ifname);
} }
static sd_lldp* lldp_free(sd_lldp *lldp) { static sd_lldp_rx *lldp_rx_free(sd_lldp_rx *lldp_rx) {
assert(lldp); assert(lldp_rx);
lldp_reset(lldp); lldp_rx_reset(lldp_rx);
sd_event_source_unref(lldp->timer_event_source); sd_event_source_unref(lldp_rx->timer_event_source);
sd_lldp_detach_event(lldp); sd_lldp_rx_detach_event(lldp_rx);
lldp_flush_neighbors(lldp); lldp_rx_flush_neighbors(lldp_rx);
hashmap_free(lldp->neighbor_by_id); hashmap_free(lldp_rx->neighbor_by_id);
prioq_free(lldp->neighbor_by_expiry); prioq_free(lldp_rx->neighbor_by_expiry);
free(lldp->ifname); free(lldp_rx->ifname);
return mfree(lldp); return mfree(lldp_rx);
} }
DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_lldp, sd_lldp, lldp_free); DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_lldp_rx, sd_lldp_rx, lldp_rx_free);
_public_ int sd_lldp_new(sd_lldp **ret) { _public_ int sd_lldp_rx_new(sd_lldp_rx **ret) {
_cleanup_(sd_lldp_unrefp) sd_lldp *lldp = NULL; _cleanup_(sd_lldp_rx_unrefp) sd_lldp_rx *lldp_rx = NULL;
int r; int r;
assert_return(ret, -EINVAL); assert_return(ret, -EINVAL);
lldp = new(sd_lldp, 1); lldp_rx = new(sd_lldp_rx, 1);
if (!lldp) if (!lldp_rx)
return -ENOMEM; return -ENOMEM;
*lldp = (sd_lldp) { *lldp_rx = (sd_lldp_rx) {
.n_ref = 1, .n_ref = 1,
.fd = -1, .fd = -1,
.neighbors_max = LLDP_DEFAULT_NEIGHBORS_MAX, .neighbors_max = LLDP_DEFAULT_NEIGHBORS_MAX,
.capability_mask = UINT16_MAX, .capability_mask = UINT16_MAX,
}; };
lldp->neighbor_by_id = hashmap_new(&lldp_neighbor_hash_ops); lldp_rx->neighbor_by_id = hashmap_new(&lldp_neighbor_hash_ops);
if (!lldp->neighbor_by_id) if (!lldp_rx->neighbor_by_id)
return -ENOMEM; return -ENOMEM;
r = prioq_ensure_allocated(&lldp->neighbor_by_expiry, lldp_neighbor_prioq_compare_func); r = prioq_ensure_allocated(&lldp_rx->neighbor_by_expiry, lldp_neighbor_prioq_compare_func);
if (r < 0) if (r < 0)
return r; return r;
*ret = TAKE_PTR(lldp); *ret = TAKE_PTR(lldp_rx);
return 0; return 0;
} }
@ -415,72 +415,72 @@ static int neighbor_compare_func(sd_lldp_neighbor * const *a, sd_lldp_neighbor *
} }
static int on_timer_event(sd_event_source *s, uint64_t usec, void *userdata) { static int on_timer_event(sd_event_source *s, uint64_t usec, void *userdata) {
sd_lldp *lldp = userdata; sd_lldp_rx *lldp_rx = userdata;
int r; int r;
r = lldp_make_space(lldp, 0); r = lldp_rx_make_space(lldp_rx, 0);
if (r < 0) { if (r < 0) {
log_lldp_errno(lldp, r, "Failed to make space, ignoring: %m"); log_lldp_rx_errno(lldp_rx, r, "Failed to make space, ignoring: %m");
return 0; return 0;
} }
r = lldp_start_timer(lldp, NULL); r = lldp_rx_start_timer(lldp_rx, NULL);
if (r < 0) { if (r < 0) {
log_lldp_errno(lldp, r, "Failed to restart timer, ignoring: %m"); log_lldp_rx_errno(lldp_rx, r, "Failed to restart timer, ignoring: %m");
return 0; return 0;
} }
return 0; return 0;
} }
static int lldp_start_timer(sd_lldp *lldp, sd_lldp_neighbor *neighbor) { static int lldp_rx_start_timer(sd_lldp_rx *lldp_rx, sd_lldp_neighbor *neighbor) {
sd_lldp_neighbor *n; sd_lldp_neighbor *n;
assert(lldp); assert(lldp_rx);
if (neighbor) if (neighbor)
lldp_neighbor_start_ttl(neighbor); lldp_neighbor_start_ttl(neighbor);
n = prioq_peek(lldp->neighbor_by_expiry); n = prioq_peek(lldp_rx->neighbor_by_expiry);
if (!n) if (!n)
return event_source_disable(lldp->timer_event_source); return event_source_disable(lldp_rx->timer_event_source);
if (!lldp->event) if (!lldp_rx->event)
return 0; return 0;
return event_reset_time(lldp->event, &lldp->timer_event_source, return event_reset_time(lldp_rx->event, &lldp_rx->timer_event_source,
clock_boottime_or_monotonic(), clock_boottime_or_monotonic(),
n->until, 0, n->until, 0,
on_timer_event, lldp, on_timer_event, lldp_rx,
lldp->event_priority, "lldp-timer", true); lldp_rx->event_priority, "lldp-rx-timer", true);
} }
_public_ int sd_lldp_get_neighbors(sd_lldp *lldp, sd_lldp_neighbor ***ret) { _public_ int sd_lldp_rx_get_neighbors(sd_lldp_rx *lldp_rx, sd_lldp_neighbor ***ret) {
sd_lldp_neighbor **l = NULL, *n; sd_lldp_neighbor **l = NULL, *n;
int k = 0, r; int k = 0, r;
assert_return(lldp, -EINVAL); assert_return(lldp_rx, -EINVAL);
assert_return(ret, -EINVAL); assert_return(ret, -EINVAL);
if (hashmap_isempty(lldp->neighbor_by_id)) { /* Special shortcut */ if (hashmap_isempty(lldp_rx->neighbor_by_id)) { /* Special shortcut */
*ret = NULL; *ret = NULL;
return 0; return 0;
} }
l = new0(sd_lldp_neighbor*, hashmap_size(lldp->neighbor_by_id)); l = new0(sd_lldp_neighbor*, hashmap_size(lldp_rx->neighbor_by_id));
if (!l) if (!l)
return -ENOMEM; return -ENOMEM;
r = lldp_start_timer(lldp, NULL); r = lldp_rx_start_timer(lldp_rx, NULL);
if (r < 0) { if (r < 0) {
free(l); free(l);
return r; return r;
} }
HASHMAP_FOREACH(n, lldp->neighbor_by_id) HASHMAP_FOREACH(n, lldp_rx->neighbor_by_id)
l[k++] = sd_lldp_neighbor_ref(n); l[k++] = sd_lldp_neighbor_ref(n);
assert((size_t) k == hashmap_size(lldp->neighbor_by_id)); assert((size_t) k == hashmap_size(lldp_rx->neighbor_by_id));
/* Return things in a stable order */ /* Return things in a stable order */
typesafe_qsort(l, k, neighbor_compare_func); typesafe_qsort(l, k, neighbor_compare_func);
@ -489,35 +489,35 @@ _public_ int sd_lldp_get_neighbors(sd_lldp *lldp, sd_lldp_neighbor ***ret) {
return k; return k;
} }
_public_ int sd_lldp_set_neighbors_max(sd_lldp *lldp, uint64_t m) { _public_ int sd_lldp_rx_set_neighbors_max(sd_lldp_rx *lldp_rx, uint64_t m) {
assert_return(lldp, -EINVAL); assert_return(lldp_rx, -EINVAL);
assert_return(m > 0, -EINVAL); assert_return(m > 0, -EINVAL);
lldp->neighbors_max = m; lldp_rx->neighbors_max = m;
lldp_make_space(lldp, 0); lldp_rx_make_space(lldp_rx, 0);
return 0; return 0;
} }
_public_ int sd_lldp_match_capabilities(sd_lldp *lldp, uint16_t mask) { _public_ int sd_lldp_rx_match_capabilities(sd_lldp_rx *lldp_rx, uint16_t mask) {
assert_return(lldp, -EINVAL); assert_return(lldp_rx, -EINVAL);
assert_return(mask != 0, -EINVAL); assert_return(mask != 0, -EINVAL);
lldp->capability_mask = mask; lldp_rx->capability_mask = mask;
return 0; return 0;
} }
_public_ int sd_lldp_set_filter_address(sd_lldp *lldp, const struct ether_addr *addr) { _public_ int sd_lldp_rx_set_filter_address(sd_lldp_rx *lldp_rx, const struct ether_addr *addr) {
assert_return(lldp, -EINVAL); assert_return(lldp_rx, -EINVAL);
/* In order to deal nicely with bridges that send back our own packets, allow one address to be filtered, so /* 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. */ * that our own can be filtered out here. */
if (addr) if (addr)
lldp->filter_address = *addr; lldp_rx->filter_address = *addr;
else else
zero(lldp->filter_address); zero(lldp_rx->filter_address);
return 0; return 0;
} }

74
src/libsystemd-network/test-lldp-rx.c
View File

@ -21,7 +21,7 @@
#define TEST_LLDP_TYPE_SYSTEM_DESC "systemd-lldp-desc" #define TEST_LLDP_TYPE_SYSTEM_DESC "systemd-lldp-desc"
static int test_fd[2] = { -1, -1 }; static int test_fd[2] = { -1, -1 };
static int lldp_handler_calls; static int lldp_rx_handler_calls;
int lldp_network_bind_raw_socket(int ifindex) { int lldp_network_bind_raw_socket(int ifindex) {
if (socketpair(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) < 0) if (socketpair(AF_UNIX, SOCK_DGRAM | SOCK_CLOEXEC | SOCK_NONBLOCK, 0, test_fd) < 0)
@ -30,48 +30,48 @@ int lldp_network_bind_raw_socket(int ifindex) {
return test_fd[0]; return test_fd[0];
} }
static void lldp_handler(sd_lldp *lldp, sd_lldp_event_t event, sd_lldp_neighbor *n, void *userdata) { static void lldp_rx_handler(sd_lldp_rx *lldp_rx, sd_lldp_rx_event_t event, sd_lldp_neighbor *n, void *userdata) {
lldp_handler_calls++; lldp_rx_handler_calls++;
} }
static int start_lldp(sd_lldp **lldp, sd_event *e, sd_lldp_callback_t cb, void *cb_data) { static int start_lldp_rx(sd_lldp_rx **lldp_rx, sd_event *e, sd_lldp_rx_callback_t cb, void *cb_data) {
int r; int r;
r = sd_lldp_new(lldp); r = sd_lldp_rx_new(lldp_rx);
if (r < 0) if (r < 0)
return r; return r;
r = sd_lldp_set_ifindex(*lldp, 42); r = sd_lldp_rx_set_ifindex(*lldp_rx, 42);
if (r < 0) if (r < 0)
return r; return r;
r = sd_lldp_set_callback(*lldp, cb, cb_data); r = sd_lldp_rx_set_callback(*lldp_rx, cb, cb_data);
if (r < 0) if (r < 0)
return r; return r;
r = sd_lldp_attach_event(*lldp, e, 0); r = sd_lldp_rx_attach_event(*lldp_rx, e, 0);
if (r < 0) if (r < 0)
return r; return r;
r = sd_lldp_start(*lldp); r = sd_lldp_rx_start(*lldp_rx);
if (r < 0) if (r < 0)
return r; return r;
return 0; return 0;
} }
static int stop_lldp(sd_lldp *lldp) { static int stop_lldp_rx(sd_lldp_rx *lldp_rx) {
int r; int r;
r = sd_lldp_stop(lldp); r = sd_lldp_rx_stop(lldp_rx);
if (r < 0) if (r < 0)
return r; return r;
r = sd_lldp_detach_event(lldp); r = sd_lldp_rx_detach_event(lldp_rx);
if (r < 0) if (r < 0)
return r; return r;
sd_lldp_unref(lldp); sd_lldp_rx_unref(lldp_rx);
safe_close(test_fd[1]); safe_close(test_fd[1]);
return 0; return 0;
@ -96,7 +96,7 @@ static void test_receive_basic_packet(sd_event *e) {
0x00, 0x00 /* End Of LLDPDU */ 0x00, 0x00 /* End Of LLDPDU */
}; };
sd_lldp *lldp; sd_lldp_rx *lldp_rx;
sd_lldp_neighbor **neighbors; sd_lldp_neighbor **neighbors;
uint8_t type; uint8_t type;
const void *data; const void *data;
@ -104,13 +104,13 @@ static void test_receive_basic_packet(sd_event *e) {
size_t length; size_t length;
const char *str; const char *str;
lldp_handler_calls = 0; lldp_rx_handler_calls = 0;
assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0); assert_se(start_lldp_rx(&lldp_rx, e, lldp_rx_handler, NULL) == 0);
assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame)); assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
sd_event_run(e, 0); sd_event_run(e, 0);
assert_se(lldp_handler_calls == 1); assert_se(lldp_rx_handler_calls == 1);
assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 1); assert_se(sd_lldp_rx_get_neighbors(lldp_rx, &neighbors) == 1);
assert_se(sd_lldp_neighbor_get_chassis_id(neighbors[0], &type, &data, &length) == 0); 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(type == SD_LLDP_CHASSIS_SUBTYPE_MAC_ADDRESS);
@ -137,11 +137,11 @@ static void test_receive_basic_packet(sd_event *e) {
sd_lldp_neighbor_unref(neighbors[0]); sd_lldp_neighbor_unref(neighbors[0]);
free(neighbors); free(neighbors);
assert_se(stop_lldp(lldp) == 0); assert_se(stop_lldp_rx(lldp_rx) == 0);
} }
static void test_receive_incomplete_packet(sd_event *e) { static void test_receive_incomplete_packet(sd_event *e) {
sd_lldp *lldp; sd_lldp_rx *lldp_rx;
sd_lldp_neighbor **neighbors; sd_lldp_neighbor **neighbors;
uint8_t frame[] = { uint8_t frame[] = {
/* Ethernet header */ /* Ethernet header */
@ -156,19 +156,19 @@ static void test_receive_incomplete_packet(sd_event *e) {
0x00, 0x00 /* End Of LLDPDU */ 0x00, 0x00 /* End Of LLDPDU */
}; };
lldp_handler_calls = 0; lldp_rx_handler_calls = 0;
assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0); assert_se(start_lldp_rx(&lldp_rx, e, lldp_rx_handler, NULL) == 0);
assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame)); assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
sd_event_run(e, 0); sd_event_run(e, 0);
assert_se(lldp_handler_calls == 0); assert_se(lldp_rx_handler_calls == 0);
assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 0); assert_se(sd_lldp_rx_get_neighbors(lldp_rx, &neighbors) == 0);
assert_se(stop_lldp(lldp) == 0); assert_se(stop_lldp_rx(lldp_rx) == 0);
} }
static void test_receive_oui_packet(sd_event *e) { static void test_receive_oui_packet(sd_event *e) {
sd_lldp *lldp; sd_lldp_rx *lldp_rx;
sd_lldp_neighbor **neighbors; sd_lldp_neighbor **neighbors;
uint8_t frame[] = { uint8_t frame[] = {
/* Ethernet header */ /* Ethernet header */
@ -197,13 +197,13 @@ static void test_receive_oui_packet(sd_event *e) {
0x00, 0x00 /* End of LLDPDU */ 0x00, 0x00 /* End of LLDPDU */
}; };
lldp_handler_calls = 0; lldp_rx_handler_calls = 0;
assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0); assert_se(start_lldp_rx(&lldp_rx, e, lldp_rx_handler, NULL) == 0);
assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame)); assert_se(write(test_fd[1], frame, sizeof(frame)) == sizeof(frame));
sd_event_run(e, 0); sd_event_run(e, 0);
assert_se(lldp_handler_calls == 1); assert_se(lldp_rx_handler_calls == 1);
assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 1); assert_se(sd_lldp_rx_get_neighbors(lldp_rx, &neighbors) == 1);
assert_se(sd_lldp_neighbor_tlv_rewind(neighbors[0]) >= 0); 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_is_type(neighbors[0], SD_LLDP_TYPE_CHASSIS_ID) > 0);
@ -230,7 +230,7 @@ static void test_receive_oui_packet(sd_event *e) {
sd_lldp_neighbor_unref(neighbors[0]); sd_lldp_neighbor_unref(neighbors[0]);
free(neighbors); free(neighbors);
assert_se(stop_lldp(lldp) == 0); assert_se(stop_lldp_rx(lldp_rx) == 0);
} }
static void test_multiple_neighbors_sorted(sd_event *e) { static void test_multiple_neighbors_sorted(sd_event *e) {
@ -311,7 +311,7 @@ static void test_multiple_neighbors_sorted(sd_event *e) {
"2/19", "1/0", "2/19", "1/0",
}; };
sd_lldp *lldp; sd_lldp_rx *lldp_rx;
sd_lldp_neighbor **neighbors; sd_lldp_neighbor **neighbors;
int i; int i;
uint8_t type; uint8_t type;
@ -319,8 +319,8 @@ static void test_multiple_neighbors_sorted(sd_event *e) {
size_t length, expected_length; size_t length, expected_length;
uint16_t ttl; uint16_t ttl;
lldp_handler_calls = 0; lldp_rx_handler_calls = 0;
assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0); assert_se(start_lldp_rx(&lldp_rx, e, lldp_rx_handler, NULL) == 0);
assert_se(write(test_fd[1], frame1, sizeof(frame1)) == sizeof(frame1)); assert_se(write(test_fd[1], frame1, sizeof(frame1)) == sizeof(frame1));
sd_event_run(e, 0); sd_event_run(e, 0);
@ -334,9 +334,9 @@ static void test_multiple_neighbors_sorted(sd_event *e) {
sd_event_run(e, 0); sd_event_run(e, 0);
assert_se(write(test_fd[1], frame6, sizeof(frame6)) == sizeof(frame6)); assert_se(write(test_fd[1], frame6, sizeof(frame6)) == sizeof(frame6));
sd_event_run(e, 0); sd_event_run(e, 0);
assert_se(lldp_handler_calls == 6); assert_se(lldp_rx_handler_calls == 6);
assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 6); assert_se(sd_lldp_rx_get_neighbors(lldp_rx, &neighbors) == 6);
for (i = 0; i < 6; i++) { for (i = 0; i < 6; i++) {
assert_se(sd_lldp_neighbor_get_chassis_id(neighbors[i], &type, &data, &length) == 0); assert_se(sd_lldp_neighbor_get_chassis_id(neighbors[i], &type, &data, &length) == 0);
@ -359,7 +359,7 @@ static void test_multiple_neighbors_sorted(sd_event *e) {
sd_lldp_neighbor_unref(neighbors[i]); sd_lldp_neighbor_unref(neighbors[i]);
free(neighbors); free(neighbors);
assert_se(stop_lldp(lldp) == 0); assert_se(stop_lldp_rx(lldp_rx) == 0);
} }
int main(int argc, char *argv[]) { int main(int argc, char *argv[]) {

16
src/network/networkd-link.c
View File

@ -209,7 +209,7 @@ static void link_free_engines(Link *link) {
link->dhcp_client = sd_dhcp_client_unref(link->dhcp_client); link->dhcp_client = sd_dhcp_client_unref(link->dhcp_client);
link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease); link->dhcp_lease = sd_dhcp_lease_unref(link->dhcp_lease);
link->lldp = sd_lldp_unref(link->lldp); link->lldp_rx = sd_lldp_rx_unref(link->lldp_rx);
link_lldp_emit_stop(link); link_lldp_emit_stop(link);
ndisc_flush(link); ndisc_flush(link);
@ -375,7 +375,7 @@ int link_stop_engines(Link *link, bool may_keep_dhcp) {
if (k < 0) if (k < 0)
r = log_link_warning_errno(link, k, "Could not stop DHCPv4 server: %m"); r = log_link_warning_errno(link, k, "Could not stop DHCPv4 server: %m");
k = sd_lldp_stop(link->lldp); k = sd_lldp_rx_stop(link->lldp_rx);
if (k < 0) if (k < 0)
r = log_link_warning_errno(link, k, "Could not stop LLDP: %m"); r = log_link_warning_errno(link, k, "Could not stop LLDP: %m");
@ -690,8 +690,8 @@ static int link_acquire_dynamic_conf(Link *link) {
if (r < 0) if (r < 0)
return log_link_warning_errno(link, r, "Failed to start LLDP transmission: %m"); return log_link_warning_errno(link, r, "Failed to start LLDP transmission: %m");
if (link->lldp) { if (link->lldp_rx) {
r = sd_lldp_start(link->lldp); r = sd_lldp_rx_start(link->lldp_rx);
if (r < 0) if (r < 0)
return log_link_warning_errno(link, r, "Failed to start LLDP client: %m"); return log_link_warning_errno(link, r, "Failed to start LLDP client: %m");
} }
@ -2102,8 +2102,8 @@ static int link_update_hardware_address(Link *link, sd_netlink_message *message)
return log_link_debug_errno(link, r, "Could not update MAC for NDisc: %m"); return log_link_debug_errno(link, r, "Could not update MAC for NDisc: %m");
} }
if (link->lldp) { if (link->lldp_rx) {
r = sd_lldp_set_filter_address(link->lldp, &link->hw_addr.ether); r = sd_lldp_rx_set_filter_address(link->lldp_rx, &link->hw_addr.ether);
if (r < 0) if (r < 0)
return log_link_debug_errno(link, r, "Could not update MAC address for LLDP: %m"); return log_link_debug_errno(link, r, "Could not update MAC address for LLDP: %m");
} }
@ -2266,8 +2266,8 @@ static int link_update_name(Link *link, sd_netlink_message *message) {
return log_link_debug_errno(link, r, "Failed to update interface name in Router Advertisement: %m"); return log_link_debug_errno(link, r, "Failed to update interface name in Router Advertisement: %m");
} }
if (link->lldp) { if (link->lldp_rx) {
r = sd_lldp_set_ifname(link->lldp, link->ifname); r = sd_lldp_rx_set_ifname(link->lldp_rx, link->ifname);
if (r < 0) if (r < 0)
return log_link_debug_errno(link, r, "Failed to update interface name in LLDP: %m"); return log_link_debug_errno(link, r, "Failed to update interface name in LLDP: %m");
} }

2
src/network/networkd-link.h
View File

@ -171,7 +171,7 @@ typedef struct Link {
bool dhcp6_pd_prefixes_assigned:1; bool dhcp6_pd_prefixes_assigned:1;
/* This is about LLDP reception */ /* This is about LLDP reception */
sd_lldp *lldp; sd_lldp_rx *lldp_rx;
char *lldp_file; char *lldp_file;
/* This is about LLDP transmission */ /* This is about LLDP transmission */

28
src/network/networkd-lldp-rx.c
View File

@ -48,7 +48,7 @@ static bool link_lldp_rx_enabled(Link *link) {
return link->network->lldp_mode != LLDP_MODE_NO; return link->network->lldp_mode != LLDP_MODE_NO;
} }
static void lldp_handler(sd_lldp *lldp, sd_lldp_event_t event, sd_lldp_neighbor *n, void *userdata) { static void lldp_rx_handler(sd_lldp_rx *lldp_rx, sd_lldp_rx_event_t event, sd_lldp_neighbor *n, void *userdata) {
Link *link = userdata; Link *link = userdata;
int r; int r;
@ -56,7 +56,7 @@ static void lldp_handler(sd_lldp *lldp, sd_lldp_event_t event, sd_lldp_neighbor
(void) link_lldp_save(link); (void) link_lldp_save(link);
if (link_lldp_emit_enabled(link) && event == SD_LLDP_EVENT_ADDED) { if (link_lldp_emit_enabled(link) && event == SD_LLDP_RX_EVENT_ADDED) {
/* If we received information about a new neighbor, restart the LLDP "fast" logic */ /* If we received information about a new neighbor, restart the LLDP "fast" logic */
log_link_debug(link, "Received LLDP datagram from previously unknown neighbor, restarting 'fast' LLDP transmission."); log_link_debug(link, "Received LLDP datagram from previously unknown neighbor, restarting 'fast' LLDP transmission.");
@ -73,33 +73,33 @@ int link_lldp_rx_configure(Link *link) {
if (!link_lldp_rx_enabled(link)) if (!link_lldp_rx_enabled(link))
return 0; return 0;
if (link->lldp) if (link->lldp_rx)
return -EBUSY; return -EBUSY;
r = sd_lldp_new(&link->lldp); r = sd_lldp_rx_new(&link->lldp_rx);
if (r < 0) if (r < 0)
return r; return r;
r = sd_lldp_attach_event(link->lldp, link->manager->event, 0); r = sd_lldp_rx_attach_event(link->lldp_rx, link->manager->event, 0);
if (r < 0) if (r < 0)
return r; return r;
r = sd_lldp_set_ifindex(link->lldp, link->ifindex); r = sd_lldp_rx_set_ifindex(link->lldp_rx, link->ifindex);
if (r < 0) if (r < 0)
return r; return r;
r = sd_lldp_match_capabilities(link->lldp, r = sd_lldp_rx_match_capabilities(link->lldp_rx,
link->network->lldp_mode == LLDP_MODE_ROUTERS_ONLY ? link->network->lldp_mode == LLDP_MODE_ROUTERS_ONLY ?
SD_LLDP_SYSTEM_CAPABILITIES_ALL_ROUTERS : SD_LLDP_SYSTEM_CAPABILITIES_ALL_ROUTERS :
SD_LLDP_SYSTEM_CAPABILITIES_ALL); SD_LLDP_SYSTEM_CAPABILITIES_ALL);
if (r < 0) if (r < 0)
return r; return r;
r = sd_lldp_set_filter_address(link->lldp, &link->hw_addr.ether); r = sd_lldp_rx_set_filter_address(link->lldp_rx, &link->hw_addr.ether);
if (r < 0) if (r < 0)
return r; return r;
r = sd_lldp_set_callback(link->lldp, lldp_handler, link); r = sd_lldp_rx_set_callback(link->lldp_rx, lldp_rx_handler, link);
if (r < 0) if (r < 0)
return r; return r;
@ -115,12 +115,12 @@ int link_lldp_save(Link *link) {
assert(link); assert(link);
assert(link->lldp_file); assert(link->lldp_file);
if (!link->lldp) { if (!link->lldp_rx) {
(void) unlink(link->lldp_file); (void) unlink(link->lldp_file);
return 0; return 0;
} }
r = sd_lldp_get_neighbors(link->lldp, &l); r = sd_lldp_rx_get_neighbors(link->lldp_rx, &l);
if (r < 0) if (r < 0)
return r; return r;
if (r == 0) { if (r == 0) {

4
src/network/test-network-tables.c
View File

@ -35,7 +35,7 @@ int main(int argc, char **argv) {
test_table(lldp_mode, LLDP_MODE); test_table(lldp_mode, LLDP_MODE);
test_table(netdev_kind, NETDEV_KIND); test_table(netdev_kind, NETDEV_KIND);
test_table(radv_prefix_delegation, RADV_PREFIX_DELEGATION); test_table(radv_prefix_delegation, RADV_PREFIX_DELEGATION);
test_table(lldp_event, SD_LLDP_EVENT); test_table(lldp_rx_event, SD_LLDP_RX_EVENT);
test_table(ndisc_event, SD_NDISC_EVENT); test_table(ndisc_event, SD_NDISC_EVENT);
test_table(dhcp_lease_server_type, SD_DHCP_LEASE_SERVER_TYPE); test_table(dhcp_lease_server_type, SD_DHCP_LEASE_SERVER_TYPE);
@ -43,7 +43,7 @@ int main(int argc, char **argv) {
test_table_sparse(macvlan_mode, NETDEV_MACVLAN_MODE); test_table_sparse(macvlan_mode, NETDEV_MACVLAN_MODE);
test_table_sparse(address_family, ADDRESS_FAMILY); test_table_sparse(address_family, ADDRESS_FAMILY);
assert_cc(sizeof(sd_lldp_event_t) == sizeof(int64_t)); assert_cc(sizeof(sd_lldp_rx_event_t) == sizeof(int64_t));
assert_cc(sizeof(sd_ndisc_event_t) == sizeof(int64_t)); assert_cc(sizeof(sd_ndisc_event_t) == sizeof(int64_t));
assert_cc(sizeof(sd_dhcp_lease_server_type_t) == sizeof(int64_t)); assert_cc(sizeof(sd_dhcp_lease_server_type_t) == sizeof(int64_t));

56
src/systemd/sd-lldp-rx.h
View File

@ -119,43 +119,43 @@ enum {
SD_LLDP_OUI_802_3_SUBTYPE_MAXIMUM_FRAME_SIZE = 4, SD_LLDP_OUI_802_3_SUBTYPE_MAXIMUM_FRAME_SIZE = 4,
}; };
typedef struct sd_lldp sd_lldp; typedef struct sd_lldp_rx sd_lldp_rx;
typedef struct sd_lldp_neighbor sd_lldp_neighbor; typedef struct sd_lldp_neighbor sd_lldp_neighbor;
typedef enum sd_lldp_event_t { typedef enum sd_lldp_rx_event_t {
SD_LLDP_EVENT_ADDED, SD_LLDP_RX_EVENT_ADDED,
SD_LLDP_EVENT_REMOVED, SD_LLDP_RX_EVENT_REMOVED,
SD_LLDP_EVENT_UPDATED, SD_LLDP_RX_EVENT_UPDATED,
SD_LLDP_EVENT_REFRESHED, SD_LLDP_RX_EVENT_REFRESHED,
_SD_LLDP_EVENT_MAX, _SD_LLDP_RX_EVENT_MAX,
_SD_LLDP_EVENT_INVALID = -EINVAL, _SD_LLDP_RX_EVENT_INVALID = -EINVAL,
_SD_ENUM_FORCE_S64(LLDP_EVENT), _SD_ENUM_FORCE_S64(LLDP_RX_EVENT),
} sd_lldp_event_t; } sd_lldp_rx_event_t;
typedef void (*sd_lldp_callback_t)(sd_lldp *lldp, sd_lldp_event_t event, sd_lldp_neighbor *n, void *userdata); typedef void (*sd_lldp_rx_callback_t)(sd_lldp_rx *lldp_rx, sd_lldp_rx_event_t event, sd_lldp_neighbor *n, void *userdata);
int sd_lldp_new(sd_lldp **ret); int sd_lldp_rx_new(sd_lldp_rx **ret);
sd_lldp* sd_lldp_ref(sd_lldp *lldp); sd_lldp_rx *sd_lldp_rx_ref(sd_lldp_rx *lldp_rx);
sd_lldp* sd_lldp_unref(sd_lldp *lldp); sd_lldp_rx *sd_lldp_rx_unref(sd_lldp_rx *lldp_rx);
int sd_lldp_start(sd_lldp *lldp); int sd_lldp_rx_start(sd_lldp_rx *lldp_rx);
int sd_lldp_stop(sd_lldp *lldp); int sd_lldp_rx_stop(sd_lldp_rx *lldp_rx);
int sd_lldp_attach_event(sd_lldp *lldp, sd_event *event, int64_t priority); int sd_lldp_rx_attach_event(sd_lldp_rx *lldp_rx, sd_event *event, int64_t priority);
int sd_lldp_detach_event(sd_lldp *lldp); int sd_lldp_rx_detach_event(sd_lldp_rx *lldp_rx);
sd_event *sd_lldp_get_event(sd_lldp *lldp); sd_event *sd_lldp_rx_get_event(sd_lldp_rx *lldp_rx);
int sd_lldp_set_callback(sd_lldp *lldp, sd_lldp_callback_t cb, void *userdata); int sd_lldp_rx_set_callback(sd_lldp_rx *lldp_rx, sd_lldp_rx_callback_t cb, void *userdata);
int sd_lldp_set_ifindex(sd_lldp *lldp, int ifindex); int sd_lldp_rx_set_ifindex(sd_lldp_rx *lldp_rx, int ifindex);
int sd_lldp_set_ifname(sd_lldp *lldp, const char *ifname); int sd_lldp_rx_set_ifname(sd_lldp_rx *lldp_rx, const char *ifname);
const char *sd_lldp_get_ifname(sd_lldp *lldp); const char *sd_lldp_rx_get_ifname(sd_lldp_rx *lldp_rx);
/* Controls how much and what to store in the neighbors database */ /* Controls how much and what to store in the neighbors database */
int sd_lldp_set_neighbors_max(sd_lldp *lldp, uint64_t n); int sd_lldp_rx_set_neighbors_max(sd_lldp_rx *lldp_rx, uint64_t n);
int sd_lldp_match_capabilities(sd_lldp *lldp, uint16_t mask); int sd_lldp_rx_match_capabilities(sd_lldp_rx *lldp_rx, uint16_t mask);
int sd_lldp_set_filter_address(sd_lldp *lldp, const struct ether_addr *address); int sd_lldp_rx_set_filter_address(sd_lldp_rx *lldp_rx, const struct ether_addr *address);
int sd_lldp_get_neighbors(sd_lldp *lldp, sd_lldp_neighbor ***neighbors); int sd_lldp_rx_get_neighbors(sd_lldp_rx *lldp_rx, sd_lldp_neighbor ***neighbors);
int sd_lldp_neighbor_from_raw(sd_lldp_neighbor **ret, const void *raw, size_t raw_size); int sd_lldp_neighbor_from_raw(sd_lldp_neighbor **ret, const void *raw, size_t raw_size);
sd_lldp_neighbor *sd_lldp_neighbor_ref(sd_lldp_neighbor *n); sd_lldp_neighbor *sd_lldp_neighbor_ref(sd_lldp_neighbor *n);
@ -190,7 +190,7 @@ int sd_lldp_neighbor_tlv_get_oui(sd_lldp_neighbor *n, uint8_t oui[_SD_ARRAY_STAT
int sd_lldp_neighbor_tlv_is_oui(sd_lldp_neighbor *n, const uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t subtype); int sd_lldp_neighbor_tlv_is_oui(sd_lldp_neighbor *n, const uint8_t oui[_SD_ARRAY_STATIC 3], uint8_t subtype);
int sd_lldp_neighbor_tlv_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size); int sd_lldp_neighbor_tlv_get_raw(sd_lldp_neighbor *n, const void **ret, size_t *size);
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_lldp, sd_lldp_unref); _SD_DEFINE_POINTER_CLEANUP_FUNC(sd_lldp_rx, sd_lldp_rx_unref);
_SD_DEFINE_POINTER_CLEANUP_FUNC(sd_lldp_neighbor, sd_lldp_neighbor_unref); _SD_DEFINE_POINTER_CLEANUP_FUNC(sd_lldp_neighbor, sd_lldp_neighbor_unref);
_SD_END_DECLARATIONS; _SD_END_DECLARATIONS;