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;
if (!n)
return NULL;
- assert(n->n_ref > 0 || n->lldp);
+ assert(n->n_ref > 0 || n->lldp_rx);
n->n_ref++;
return 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;
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);
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;
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;
}
/* 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;
}
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 ||
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));
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;
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) */
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)
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)
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);
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;
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);
} 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) {
} 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;
#include "log-link.h"
#include "prioq.h"
-struct sd_lldp {
+struct sd_lldp_rx {
unsigned n_ref;
int ifindex;
uint64_t neighbors_max;
- sd_lldp_callback_t callback;
+ sd_lldp_rx_callback_t callback;
void *userdata;
uint16_t capability_mask;
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__)
#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. */
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)
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 */
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;
}
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);
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;
}
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;
}
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;
}
}
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);
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;
}
#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)
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;
0x00, 0x00 /* End Of LLDPDU */
};
- sd_lldp *lldp;
+ sd_lldp_rx *lldp_rx;
sd_lldp_neighbor **neighbors;
uint8_t type;
const void *data;
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);
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 */
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 */
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);
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) {
"2/19", "1/0",
};
- sd_lldp *lldp;
+ sd_lldp_rx *lldp_rx;
sd_lldp_neighbor **neighbors;
int i;
uint8_t type;
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);
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);
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[]) {
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);
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");
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");
}
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");
}
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");
}
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 */
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;
(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.");
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;
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) {
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);
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));
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);
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;
projects / thirdparty / systemd.git / commitdiff
