diff --git a/src/libsystemd-network/fuzz-lldp-rx.c b/src/libsystemd-network/fuzz-lldp-rx.c index 6c4d3e2e56..6ee623fa11 100644 --- a/src/libsystemd-network/fuzz-lldp-rx.c +++ b/src/libsystemd-network/fuzz-lldp-rx.c @@ -21,22 +21,22 @@ int lldp_network_bind_raw_socket(int ifindex) { int LLVMFuzzerTestOneInput(const uint8_t *data, size_t size) { _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) return 0; assert_se(sd_event_new(&e) == 0); - assert_se(sd_lldp_new(&lldp) >= 0); - assert_se(sd_lldp_set_ifindex(lldp, 42) >= 0); - assert_se(sd_lldp_attach_event(lldp, e, 0) >= 0); - assert_se(sd_lldp_start(lldp) >= 0); + assert_se(sd_lldp_rx_new(&lldp_rx) >= 0); + assert_se(sd_lldp_rx_set_ifindex(lldp_rx, 42) >= 0); + assert_se(sd_lldp_rx_attach_event(lldp_rx, e, 0) >= 0); + assert_se(sd_lldp_rx_start(lldp_rx) >= 0); assert_se(write(test_fd[1], data, size) == (ssize_t) size); assert_se(sd_event_run(e, 0) >= 0); - assert_se(sd_lldp_stop(lldp) >= 0); - assert_se(sd_lldp_detach_event(lldp) >= 0); + assert_se(sd_lldp_rx_stop(lldp_rx) >= 0); + assert_se(sd_lldp_rx_detach_event(lldp_rx) >= 0); test_fd[1] = safe_close(test_fd[1]); return 0; diff --git a/src/libsystemd-network/lldp-neighbor.c b/src/libsystemd-network/lldp-neighbor.c index ba5f288aa5..7eae998a60 100644 --- a/src/libsystemd-network/lldp-neighbor.c +++ b/src/libsystemd-network/lldp-neighbor.c @@ -35,7 +35,7 @@ _public_ sd_lldp_neighbor *sd_lldp_neighbor_ref(sd_lldp_neighbor *n) { if (!n) return NULL; - assert(n->n_ref > 0 || n->lldp); + assert(n->n_ref > 0 || n->lldp_rx); n->n_ref++; return n; @@ -66,7 +66,7 @@ _public_ sd_lldp_neighbor *sd_lldp_neighbor_unref(sd_lldp_neighbor *n) { assert(n->n_ref > 0); n->n_ref--; - if (n->n_ref <= 0 && !n->lldp) + if (n->n_ref <= 0 && !n->lldp_rx) lldp_neighbor_free(n); return NULL; @@ -79,18 +79,18 @@ sd_lldp_neighbor *lldp_neighbor_unlink(sd_lldp_neighbor *n) { if (!n) return NULL; - if (!n->lldp) + if (!n->lldp_rx) 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); + (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) lldp_neighbor_free(n); @@ -111,7 +111,7 @@ sd_lldp_neighbor *lldp_neighbor_new(size_t raw_size) { 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; 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); if (*s) { - log_lldp(lldp, "Found duplicate string, ignoring field."); + log_lldp_rx(lldp_rx, "Found duplicate string, ignoring field."); 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 */ 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; } @@ -156,14 +156,14 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) { assert(n); if (n->raw_size < sizeof(struct ether_header)) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "Received truncated packet, ignoring."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "Received truncated packet, ignoring."); memcpy(&h, LLDP_NEIGHBOR_RAW(n), sizeof(h)); if (h.ether_type != htobe16(ETHERTYPE_LLDP)) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "Received packet with wrong type, ignoring."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "Received packet with wrong type, ignoring."); if (h.ether_dhost[0] != 0x01 || 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[4] != 0x00 || !IN_SET(h.ether_dhost[5], 0x00, 0x03, 0x0e)) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "Received packet with wrong destination address, ignoring."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "Received packet with wrong destination address, ignoring."); memcpy(&n->source_address, h.ether_shost, 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; 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."); type = p[0] >> 1; @@ -193,15 +193,15 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) { p += 2, left -= 2; if (left < length) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "TLV truncated, ignoring datagram."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "TLV truncated, ignoring datagram."); switch (type) { case SD_LLDP_TYPE_END: if (length != 0) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "End marker TLV not zero-sized, ignoring datagram."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "End marker TLV not zero-sized, ignoring datagram."); /* 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) */ @@ -211,12 +211,12 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) { case SD_LLDP_TYPE_CHASSIS_ID: if (length < 2 || length > 256) /* includes the chassis subtype, hence one extra byte */ - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "Chassis ID field size out of range, ignoring datagram."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "Chassis ID field size out of range, ignoring datagram."); if (n->id.chassis_id) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "Duplicate chassis ID field, ignoring datagram."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "Duplicate chassis ID field, ignoring datagram."); n->id.chassis_id = memdup(p, length); if (!n->id.chassis_id) @@ -228,12 +228,12 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) { case SD_LLDP_TYPE_PORT_ID: if (length < 2 || length > 256) /* includes the port subtype, hence one extra byte */ - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "Port ID field size out of range, ignoring datagram."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "Port ID field size out of range, ignoring datagram."); if (n->id.port_id) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "Duplicate port ID field, ignoring datagram."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "Duplicate port ID field, ignoring datagram."); n->id.port_id = memdup(p, length); if (!n->id.port_id) @@ -244,39 +244,39 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) { case SD_LLDP_TYPE_TTL: if (length != 2) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "TTL field has wrong size, ignoring datagram."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "TTL field has wrong size, ignoring datagram."); if (n->has_ttl) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "Duplicate TTL field, ignoring datagram."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "Duplicate TTL field, ignoring datagram."); n->ttl = unaligned_read_be16(p); n->has_ttl = true; break; 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) return r; break; 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) return r; break; 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) return r; break; case SD_LLDP_TYPE_SYSTEM_CAPABILITIES: if (length != 4) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "System capabilities field has wrong size."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "System capabilities field has wrong size."); n->system_capabilities = unaligned_read_be16(p); 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: if (length < 4) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "Found private TLV that is too short, ignoring."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "Found private TLV that is too short, ignoring."); /* RFC 8520: MUD URL */ 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) { - 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)); if (r < 0) return r; @@ -304,8 +304,8 @@ int lldp_neighbor_parse(sd_lldp_neighbor *n) { end_marker: if (!n->id.chassis_id || !n->id.port_id || !n->has_ttl) - return log_lldp_errno(n->lldp, SYNTHETIC_ERRNO(EBADMSG), - "One or more mandatory TLV missing in datagram. Ignoring."); + return log_lldp_rx_errno(n->lldp_rx, SYNTHETIC_ERRNO(EBADMSG), + "One or more mandatory TLV missing in datagram. Ignoring."); n->rindex = sizeof(struct ether_header); @@ -327,8 +327,8 @@ void lldp_neighbor_start_ttl(sd_lldp_neighbor *n) { } else n->until = 0; - if (n->lldp) - prioq_reshuffle(n->lldp->neighbor_by_expiry, n, &n->prioq_idx); + if (n->lldp_rx) + 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) { diff --git a/src/libsystemd-network/lldp-neighbor.h b/src/libsystemd-network/lldp-neighbor.h index 82735ee0c3..016286b17d 100644 --- a/src/libsystemd-network/lldp-neighbor.h +++ b/src/libsystemd-network/lldp-neighbor.h @@ -21,8 +21,8 @@ typedef struct LLDPNeighborID { } 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; + /* Neighbor objects stay around as long as they are linked into an "sd_lldp_rx" object or n_ref > 0. */ + sd_lldp_rx *lldp_rx; unsigned n_ref; triple_timestamp timestamp; diff --git a/src/libsystemd-network/lldp-rx-internal.h b/src/libsystemd-network/lldp-rx-internal.h index ad6ee5a7e2..6d3ce0e1bc 100644 --- a/src/libsystemd-network/lldp-rx-internal.h +++ b/src/libsystemd-network/lldp-rx-internal.h @@ -8,7 +8,7 @@ #include "log-link.h" #include "prioq.h" -struct sd_lldp { +struct sd_lldp_rx { unsigned n_ref; int ifindex; @@ -25,7 +25,7 @@ struct sd_lldp { uint64_t neighbors_max; - sd_lldp_callback_t callback; + sd_lldp_rx_callback_t callback; void *userdata; uint16_t capability_mask; @@ -33,16 +33,16 @@ struct sd_lldp { struct ether_addr filter_address; }; -const char* lldp_event_to_string(sd_lldp_event_t e) _const_; -sd_lldp_event_t lldp_event_from_string(const char *s) _pure_; +const char* lldp_rx_event_to_string(sd_lldp_rx_event_t e) _const_; +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( \ - "LLDP: ", \ - sd_lldp_get_ifname(lldp), \ + "LLDP Rx: ", \ + sd_lldp_rx_get_ifname(lldp_rx), \ error, fmt, ##__VA_ARGS__) -#define log_lldp(lldp, fmt, ...) \ +#define log_lldp_rx(lldp_rx, fmt, ...) \ log_interface_prefix_full_errno_zerook( \ - "LLDP: ", \ - sd_lldp_get_ifname(lldp), \ + "LLDP Rx: ", \ + sd_lldp_rx_get_ifname(lldp_rx), \ 0, fmt, ##__VA_ARGS__) diff --git a/src/libsystemd-network/sd-lldp-rx.c b/src/libsystemd-network/sd-lldp-rx.c index 06861c0d41..8d9b132722 100644 --- a/src/libsystemd-network/sd-lldp-rx.c +++ b/src/libsystemd-network/sd-lldp-rx.c @@ -21,37 +21,37 @@ #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", +static const char * const lldp_rx_event_table[_SD_LLDP_RX_EVENT_MAX] = { + [SD_LLDP_RX_EVENT_ADDED] = "added", + [SD_LLDP_RX_EVENT_REMOVED] = "removed", + [SD_LLDP_RX_EVENT_UPDATED] = "updated", + [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) { - assert(lldp); +static void lldp_rx_flush_neighbors(sd_lldp_rx *lldp_rx) { + 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) { - assert(lldp); - assert(event >= 0 && event < _SD_LLDP_EVENT_MAX); +static void lldp_rx_callback(sd_lldp_rx *lldp_rx, sd_lldp_rx_event_t event, sd_lldp_neighbor *n) { + assert(lldp_rx); + assert(event >= 0 && event < _SD_LLDP_RX_EVENT_MAX); - if (!lldp->callback) - return (void) log_lldp(lldp, "Received '%s' event.", lldp_event_to_string(event)); + if (!lldp_rx->callback) + 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)); - lldp->callback(lldp, event, n, lldp->userdata); + log_lldp_rx(lldp_rx, "Invoking callback for '%s' event.", lldp_rx_event_to_string(event)); + 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; 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 * are free. */ @@ -59,13 +59,13 @@ static int lldp_make_space(sd_lldp *lldp, size_t extra) { for (;;) { _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) break; 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; if (t == USEC_INFINITY) @@ -76,15 +76,15 @@ static int lldp_make_space(sd_lldp *lldp, size_t extra) { remove_one: 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; } return changed; } -static bool lldp_keep_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) { - assert(lldp); +static bool lldp_rx_keep_neighbor(sd_lldp_rx *lldp_rx, sd_lldp_neighbor *n) { + assert(lldp_rx); assert(n); /* 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; /* Filter out data from the filter address */ - if (!ether_addr_is_null(&lldp->filter_address) && - ether_addr_equal(&lldp->filter_address, &n->source_address)) + if (!ether_addr_is_null(&lldp_rx->filter_address) && + ether_addr_equal(&lldp_rx->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) + (n->enabled_capabilities & lldp_rx->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_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; bool keep; int r; - assert(lldp); + assert(lldp_rx); 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 */ - old = hashmap_get(lldp->neighbor_by_id, &n->id); + old = hashmap_get(lldp_rx->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); + lldp_rx_callback(lldp_rx, SD_LLDP_RX_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); + lldp_rx_start_timer(lldp_rx, old); + lldp_rx_callback(lldp_rx, SD_LLDP_RX_EVENT_REFRESHED, old); return 0; } @@ -145,36 +145,36 @@ static int lldp_add_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) { return 0; /* 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) 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) { - 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; } - n->lldp = lldp; + n->lldp_rx = lldp_rx; - lldp_start_timer(lldp, n); - lldp_callback(lldp, old ? SD_LLDP_EVENT_UPDATED : SD_LLDP_EVENT_ADDED, n); + lldp_rx_start_timer(lldp_rx, n); + lldp_rx_callback(lldp_rx, old ? SD_LLDP_RX_EVENT_UPDATED : SD_LLDP_RX_EVENT_ADDED, n); return 1; finish: if (old) - lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, old); + lldp_rx_callback(lldp_rx, SD_LLDP_RX_EVENT_REMOVED, old); 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; - assert(lldp); + assert(lldp_rx); assert(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) return r; - r = lldp_add_neighbor(lldp, n); + r = lldp_rx_add_neighbor(lldp_rx, n); 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; } - log_lldp(lldp, "Successfully processed LLDP datagram."); + log_lldp_rx(lldp_rx, "Successfully processed LLDP datagram."); 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; ssize_t space, length; - sd_lldp *lldp = userdata; + sd_lldp_rx *lldp_rx = userdata; struct timespec ts; assert(fd >= 0); - assert(lldp); + assert(lldp_rx); space = next_datagram_size_fd(fd); 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; } @@ -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)) 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; } 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; } @@ -232,180 +232,180 @@ static int lldp_receive_datagram(sd_event_source *s, int fd, uint32_t revents, v else 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) { - assert(lldp); +static void lldp_rx_reset(sd_lldp_rx *lldp_rx) { + assert(lldp_rx); - (void) event_source_disable(lldp->timer_event_source); - lldp->io_event_source = sd_event_source_disable_unref(lldp->io_event_source); - lldp->fd = safe_close(lldp->fd); + (void) event_source_disable(lldp_rx->timer_event_source); + lldp_rx->io_event_source = sd_event_source_disable_unref(lldp_rx->io_event_source); + 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; - assert_return(lldp, -EINVAL); - assert_return(lldp->event, -EINVAL); - assert_return(lldp->ifindex > 0, -EINVAL); + assert_return(lldp_rx, -EINVAL); + assert_return(lldp_rx->event, -EINVAL); + assert_return(lldp_rx->ifindex > 0, -EINVAL); - if (lldp->fd >= 0) + if (lldp_rx->fd >= 0) return 0; - assert(!lldp->io_event_source); + assert(!lldp_rx->io_event_source); - lldp->fd = lldp_network_bind_raw_socket(lldp->ifindex); - if (lldp->fd < 0) - return lldp->fd; + lldp_rx->fd = lldp_network_bind_raw_socket(lldp_rx->ifindex); + if (lldp_rx->fd < 0) + 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) 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) 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; fail: - lldp_reset(lldp); + lldp_rx_reset(lldp_rx); return r; } -_public_ int sd_lldp_stop(sd_lldp *lldp) { - if (!lldp) +_public_ int sd_lldp_rx_stop(sd_lldp_rx *lldp_rx) { + if (!lldp_rx) return 0; - if (lldp->fd < 0) + if (lldp_rx->fd < 0) return 0; - log_lldp(lldp, "Stopping LLDP client"); + log_lldp_rx(lldp_rx, "Stopping LLDP client"); - lldp_reset(lldp); - lldp_flush_neighbors(lldp); + lldp_rx_reset(lldp_rx); + lldp_rx_flush_neighbors(lldp_rx); 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; - assert_return(lldp, -EINVAL); - assert_return(lldp->fd < 0, -EBUSY); - assert_return(!lldp->event, -EBUSY); + assert_return(lldp_rx, -EINVAL); + assert_return(lldp_rx->fd < 0, -EBUSY); + assert_return(!lldp_rx->event, -EBUSY); if (event) - lldp->event = sd_event_ref(event); + lldp_rx->event = sd_event_ref(event); else { - r = sd_event_default(&lldp->event); + r = sd_event_default(&lldp_rx->event); if (r < 0) return r; } - lldp->event_priority = priority; + lldp_rx->event_priority = priority; 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->fd < 0, -EBUSY); + assert_return(lldp_rx, -EINVAL); + 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; } -_public_ sd_event* sd_lldp_get_event(sd_lldp *lldp) { - assert_return(lldp, NULL); +_public_ sd_event* sd_lldp_rx_get_event(sd_lldp_rx *lldp_rx) { + 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) { - assert_return(lldp, -EINVAL); +_public_ int sd_lldp_rx_set_callback(sd_lldp_rx *lldp_rx, sd_lldp_rx_callback_t cb, void *userdata) { + assert_return(lldp_rx, -EINVAL); - lldp->callback = cb; - lldp->userdata = userdata; + lldp_rx->callback = cb; + lldp_rx->userdata = userdata; return 0; } -_public_ int sd_lldp_set_ifindex(sd_lldp *lldp, int ifindex) { - assert_return(lldp, -EINVAL); +_public_ int sd_lldp_rx_set_ifindex(sd_lldp_rx *lldp_rx, int ifindex) { + assert_return(lldp_rx, -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; } -int sd_lldp_set_ifname(sd_lldp *lldp, const char *ifname) { - assert_return(lldp, -EINVAL); +int sd_lldp_rx_set_ifname(sd_lldp_rx *lldp_rx, const char *ifname) { + assert_return(lldp_rx, -EINVAL); assert_return(ifname, -EINVAL); if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE)) 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) { - if (!lldp) +const char *sd_lldp_rx_get_ifname(sd_lldp_rx *lldp_rx) { + if (!lldp_rx) 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) { - assert(lldp); +static sd_lldp_rx *lldp_rx_free(sd_lldp_rx *lldp_rx) { + assert(lldp_rx); - lldp_reset(lldp); + lldp_rx_reset(lldp_rx); - sd_event_source_unref(lldp->timer_event_source); - sd_lldp_detach_event(lldp); + sd_event_source_unref(lldp_rx->timer_event_source); + sd_lldp_rx_detach_event(lldp_rx); - lldp_flush_neighbors(lldp); + lldp_rx_flush_neighbors(lldp_rx); - hashmap_free(lldp->neighbor_by_id); - prioq_free(lldp->neighbor_by_expiry); - free(lldp->ifname); - return mfree(lldp); + hashmap_free(lldp_rx->neighbor_by_id); + prioq_free(lldp_rx->neighbor_by_expiry); + free(lldp_rx->ifname); + 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) { - _cleanup_(sd_lldp_unrefp) sd_lldp *lldp = NULL; +_public_ int sd_lldp_rx_new(sd_lldp_rx **ret) { + _cleanup_(sd_lldp_rx_unrefp) sd_lldp_rx *lldp_rx = NULL; int r; assert_return(ret, -EINVAL); - lldp = new(sd_lldp, 1); - if (!lldp) + lldp_rx = new(sd_lldp_rx, 1); + if (!lldp_rx) return -ENOMEM; - *lldp = (sd_lldp) { + *lldp_rx = (sd_lldp_rx) { .n_ref = 1, .fd = -1, .neighbors_max = LLDP_DEFAULT_NEIGHBORS_MAX, .capability_mask = UINT16_MAX, }; - lldp->neighbor_by_id = hashmap_new(&lldp_neighbor_hash_ops); - if (!lldp->neighbor_by_id) + lldp_rx->neighbor_by_id = hashmap_new(&lldp_neighbor_hash_ops); + if (!lldp_rx->neighbor_by_id) 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) return r; - *ret = TAKE_PTR(lldp); + *ret = TAKE_PTR(lldp_rx); 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) { - sd_lldp *lldp = userdata; + sd_lldp_rx *lldp_rx = userdata; int r; - r = lldp_make_space(lldp, 0); + r = lldp_rx_make_space(lldp_rx, 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; } - r = lldp_start_timer(lldp, NULL); + r = lldp_rx_start_timer(lldp_rx, NULL); 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; } -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; - assert(lldp); + assert(lldp_rx); if (neighbor) lldp_neighbor_start_ttl(neighbor); - n = prioq_peek(lldp->neighbor_by_expiry); + n = prioq_peek(lldp_rx->neighbor_by_expiry); 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 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(), n->until, 0, - on_timer_event, lldp, - lldp->event_priority, "lldp-timer", true); + on_timer_event, lldp_rx, + 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; int k = 0, r; - assert_return(lldp, -EINVAL); + assert_return(lldp_rx, -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; 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) return -ENOMEM; - r = lldp_start_timer(lldp, NULL); + r = lldp_rx_start_timer(lldp_rx, NULL); if (r < 0) { free(l); return r; } - HASHMAP_FOREACH(n, lldp->neighbor_by_id) + HASHMAP_FOREACH(n, lldp_rx->neighbor_by_id) 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 */ 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; } -_public_ int sd_lldp_set_neighbors_max(sd_lldp *lldp, uint64_t m) { - assert_return(lldp, -EINVAL); +_public_ int sd_lldp_rx_set_neighbors_max(sd_lldp_rx *lldp_rx, uint64_t m) { + assert_return(lldp_rx, -EINVAL); assert_return(m > 0, -EINVAL); - lldp->neighbors_max = m; - lldp_make_space(lldp, 0); + lldp_rx->neighbors_max = m; + lldp_rx_make_space(lldp_rx, 0); return 0; } -_public_ int sd_lldp_match_capabilities(sd_lldp *lldp, uint16_t mask) { - assert_return(lldp, -EINVAL); +_public_ int sd_lldp_rx_match_capabilities(sd_lldp_rx *lldp_rx, uint16_t mask) { + assert_return(lldp_rx, -EINVAL); assert_return(mask != 0, -EINVAL); - lldp->capability_mask = mask; + lldp_rx->capability_mask = mask; return 0; } -_public_ int sd_lldp_set_filter_address(sd_lldp *lldp, const struct ether_addr *addr) { - assert_return(lldp, -EINVAL); +_public_ int sd_lldp_rx_set_filter_address(sd_lldp_rx *lldp_rx, const struct ether_addr *addr) { + 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 * that our own can be filtered out here. */ if (addr) - lldp->filter_address = *addr; + lldp_rx->filter_address = *addr; else - zero(lldp->filter_address); + zero(lldp_rx->filter_address); return 0; } diff --git a/src/libsystemd-network/test-lldp-rx.c b/src/libsystemd-network/test-lldp-rx.c index 09aacfd9fb..11049a85b9 100644 --- a/src/libsystemd-network/test-lldp-rx.c +++ b/src/libsystemd-network/test-lldp-rx.c @@ -21,7 +21,7 @@ #define TEST_LLDP_TYPE_SYSTEM_DESC "systemd-lldp-desc" 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) { 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]; } -static void lldp_handler(sd_lldp *lldp, sd_lldp_event_t event, sd_lldp_neighbor *n, void *userdata) { - lldp_handler_calls++; +static void lldp_rx_handler(sd_lldp_rx *lldp_rx, sd_lldp_rx_event_t event, sd_lldp_neighbor *n, void *userdata) { + 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; - r = sd_lldp_new(lldp); + r = sd_lldp_rx_new(lldp_rx); if (r < 0) return r; - r = sd_lldp_set_ifindex(*lldp, 42); + r = sd_lldp_rx_set_ifindex(*lldp_rx, 42); if (r < 0) 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) return r; - r = sd_lldp_attach_event(*lldp, e, 0); + r = sd_lldp_rx_attach_event(*lldp_rx, e, 0); if (r < 0) return r; - r = sd_lldp_start(*lldp); + r = sd_lldp_rx_start(*lldp_rx); if (r < 0) return r; return 0; } -static int stop_lldp(sd_lldp *lldp) { +static int stop_lldp_rx(sd_lldp_rx *lldp_rx) { int r; - r = sd_lldp_stop(lldp); + r = sd_lldp_rx_stop(lldp_rx); if (r < 0) return r; - r = sd_lldp_detach_event(lldp); + r = sd_lldp_rx_detach_event(lldp_rx); if (r < 0) return r; - sd_lldp_unref(lldp); + sd_lldp_rx_unref(lldp_rx); safe_close(test_fd[1]); return 0; @@ -96,7 +96,7 @@ static void test_receive_basic_packet(sd_event *e) { 0x00, 0x00 /* End Of LLDPDU */ }; - sd_lldp *lldp; + sd_lldp_rx *lldp_rx; sd_lldp_neighbor **neighbors; uint8_t type; const void *data; @@ -104,13 +104,13 @@ static void test_receive_basic_packet(sd_event *e) { size_t length; const char *str; - lldp_handler_calls = 0; - assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0); + lldp_rx_handler_calls = 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)); sd_event_run(e, 0); - assert_se(lldp_handler_calls == 1); - assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 1); + assert_se(lldp_rx_handler_calls == 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(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]); 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) { - sd_lldp *lldp; + sd_lldp_rx *lldp_rx; sd_lldp_neighbor **neighbors; uint8_t frame[] = { /* Ethernet header */ @@ -156,19 +156,19 @@ static void test_receive_incomplete_packet(sd_event *e) { 0x00, 0x00 /* End Of LLDPDU */ }; - lldp_handler_calls = 0; - assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0); + lldp_rx_handler_calls = 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)); sd_event_run(e, 0); - assert_se(lldp_handler_calls == 0); - assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 0); + assert_se(lldp_rx_handler_calls == 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) { - sd_lldp *lldp; + sd_lldp_rx *lldp_rx; sd_lldp_neighbor **neighbors; uint8_t frame[] = { /* Ethernet header */ @@ -197,13 +197,13 @@ static void test_receive_oui_packet(sd_event *e) { 0x00, 0x00 /* End of LLDPDU */ }; - lldp_handler_calls = 0; - assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0); + lldp_rx_handler_calls = 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)); sd_event_run(e, 0); - assert_se(lldp_handler_calls == 1); - assert_se(sd_lldp_get_neighbors(lldp, &neighbors) == 1); + assert_se(lldp_rx_handler_calls == 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_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]); 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) { @@ -311,7 +311,7 @@ static void test_multiple_neighbors_sorted(sd_event *e) { "2/19", "1/0", }; - sd_lldp *lldp; + sd_lldp_rx *lldp_rx; sd_lldp_neighbor **neighbors; int i; uint8_t type; @@ -319,8 +319,8 @@ static void test_multiple_neighbors_sorted(sd_event *e) { size_t length, expected_length; uint16_t ttl; - lldp_handler_calls = 0; - assert_se(start_lldp(&lldp, e, lldp_handler, NULL) == 0); + lldp_rx_handler_calls = 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)); sd_event_run(e, 0); @@ -334,9 +334,9 @@ static void test_multiple_neighbors_sorted(sd_event *e) { 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(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++) { 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]); free(neighbors); - assert_se(stop_lldp(lldp) == 0); + assert_se(stop_lldp_rx(lldp_rx) == 0); } int main(int argc, char *argv[]) { diff --git a/src/network/networkd-link.c b/src/network/networkd-link.c index ad39f690f6..c819be55d0 100644 --- a/src/network/networkd-link.c +++ b/src/network/networkd-link.c @@ -209,7 +209,7 @@ static void link_free_engines(Link *link) { link->dhcp_client = sd_dhcp_client_unref(link->dhcp_client); 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); ndisc_flush(link); @@ -375,7 +375,7 @@ int link_stop_engines(Link *link, bool may_keep_dhcp) { if (k < 0) 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) 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) return log_link_warning_errno(link, r, "Failed to start LLDP transmission: %m"); - if (link->lldp) { - r = sd_lldp_start(link->lldp); + if (link->lldp_rx) { + r = sd_lldp_rx_start(link->lldp_rx); if (r < 0) 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"); } - if (link->lldp) { - r = sd_lldp_set_filter_address(link->lldp, &link->hw_addr.ether); + if (link->lldp_rx) { + r = sd_lldp_rx_set_filter_address(link->lldp_rx, &link->hw_addr.ether); if (r < 0) 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"); } - if (link->lldp) { - r = sd_lldp_set_ifname(link->lldp, link->ifname); + if (link->lldp_rx) { + r = sd_lldp_rx_set_ifname(link->lldp_rx, link->ifname); if (r < 0) return log_link_debug_errno(link, r, "Failed to update interface name in LLDP: %m"); } diff --git a/src/network/networkd-link.h b/src/network/networkd-link.h index 4946452e28..c0f8c1bed6 100644 --- a/src/network/networkd-link.h +++ b/src/network/networkd-link.h @@ -171,7 +171,7 @@ typedef struct Link { bool dhcp6_pd_prefixes_assigned:1; /* This is about LLDP reception */ - sd_lldp *lldp; + sd_lldp_rx *lldp_rx; char *lldp_file; /* This is about LLDP transmission */ diff --git a/src/network/networkd-lldp-rx.c b/src/network/networkd-lldp-rx.c index 57c8446ade..328e885fae 100644 --- a/src/network/networkd-lldp-rx.c +++ b/src/network/networkd-lldp-rx.c @@ -48,7 +48,7 @@ static bool link_lldp_rx_enabled(Link *link) { 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; 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); - 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 */ 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)) return 0; - if (link->lldp) + if (link->lldp_rx) return -EBUSY; - r = sd_lldp_new(&link->lldp); + r = sd_lldp_rx_new(&link->lldp_rx); if (r < 0) 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) 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) return r; - r = sd_lldp_match_capabilities(link->lldp, - link->network->lldp_mode == LLDP_MODE_ROUTERS_ONLY ? - SD_LLDP_SYSTEM_CAPABILITIES_ALL_ROUTERS : - SD_LLDP_SYSTEM_CAPABILITIES_ALL); + r = sd_lldp_rx_match_capabilities(link->lldp_rx, + link->network->lldp_mode == LLDP_MODE_ROUTERS_ONLY ? + SD_LLDP_SYSTEM_CAPABILITIES_ALL_ROUTERS : + SD_LLDP_SYSTEM_CAPABILITIES_ALL); if (r < 0) 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) 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) return r; @@ -115,12 +115,12 @@ int link_lldp_save(Link *link) { assert(link); assert(link->lldp_file); - if (!link->lldp) { + if (!link->lldp_rx) { (void) unlink(link->lldp_file); return 0; } - r = sd_lldp_get_neighbors(link->lldp, &l); + r = sd_lldp_rx_get_neighbors(link->lldp_rx, &l); if (r < 0) return r; if (r == 0) { diff --git a/src/network/test-network-tables.c b/src/network/test-network-tables.c index a13c8d7a7b..c1c26d21c5 100644 --- a/src/network/test-network-tables.c +++ b/src/network/test-network-tables.c @@ -35,7 +35,7 @@ int main(int argc, char **argv) { test_table(lldp_mode, LLDP_MODE); test_table(netdev_kind, NETDEV_KIND); 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(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(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_dhcp_lease_server_type_t) == sizeof(int64_t)); diff --git a/src/systemd/sd-lldp-rx.h b/src/systemd/sd-lldp-rx.h index ac4bb6018c..a7aab85ee2 100644 --- a/src/systemd/sd-lldp-rx.h +++ b/src/systemd/sd-lldp-rx.h @@ -119,43 +119,43 @@ enum { 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 enum sd_lldp_event_t { - SD_LLDP_EVENT_ADDED, - SD_LLDP_EVENT_REMOVED, - SD_LLDP_EVENT_UPDATED, - SD_LLDP_EVENT_REFRESHED, - _SD_LLDP_EVENT_MAX, - _SD_LLDP_EVENT_INVALID = -EINVAL, - _SD_ENUM_FORCE_S64(LLDP_EVENT), -} sd_lldp_event_t; +typedef enum sd_lldp_rx_event_t { + SD_LLDP_RX_EVENT_ADDED, + SD_LLDP_RX_EVENT_REMOVED, + SD_LLDP_RX_EVENT_UPDATED, + SD_LLDP_RX_EVENT_REFRESHED, + _SD_LLDP_RX_EVENT_MAX, + _SD_LLDP_RX_EVENT_INVALID = -EINVAL, + _SD_ENUM_FORCE_S64(LLDP_RX_EVENT), +} 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); -sd_lldp* sd_lldp_ref(sd_lldp *lldp); -sd_lldp* sd_lldp_unref(sd_lldp *lldp); +int sd_lldp_rx_new(sd_lldp_rx **ret); +sd_lldp_rx *sd_lldp_rx_ref(sd_lldp_rx *lldp_rx); +sd_lldp_rx *sd_lldp_rx_unref(sd_lldp_rx *lldp_rx); -int sd_lldp_start(sd_lldp *lldp); -int sd_lldp_stop(sd_lldp *lldp); +int sd_lldp_rx_start(sd_lldp_rx *lldp_rx); +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_detach_event(sd_lldp *lldp); -sd_event *sd_lldp_get_event(sd_lldp *lldp); +int sd_lldp_rx_attach_event(sd_lldp_rx *lldp_rx, sd_event *event, int64_t priority); +int sd_lldp_rx_detach_event(sd_lldp_rx *lldp_rx); +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_set_ifindex(sd_lldp *lldp, int ifindex); -int sd_lldp_set_ifname(sd_lldp *lldp, const char *ifname); -const char *sd_lldp_get_ifname(sd_lldp *lldp); +int sd_lldp_rx_set_callback(sd_lldp_rx *lldp_rx, sd_lldp_rx_callback_t cb, void *userdata); +int sd_lldp_rx_set_ifindex(sd_lldp_rx *lldp_rx, int ifindex); +int sd_lldp_rx_set_ifname(sd_lldp_rx *lldp_rx, const char *ifname); +const char *sd_lldp_rx_get_ifname(sd_lldp_rx *lldp_rx); /* 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_match_capabilities(sd_lldp *lldp, uint16_t mask); -int sd_lldp_set_filter_address(sd_lldp *lldp, const struct ether_addr *address); +int sd_lldp_rx_set_neighbors_max(sd_lldp_rx *lldp_rx, uint64_t n); +int sd_lldp_rx_match_capabilities(sd_lldp_rx *lldp_rx, uint16_t mask); +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); 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_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_END_DECLARATIONS;