/* SPDX-License-Identifier: LGPL-2.1-or-later */ #include "sd-event.h" #include "sd-id128.h" #include "sd-lldp-tx.h" #include "alloc-util.h" #include "env-util.h" #include "ether-addr-util.h" #include "fd-util.h" #include "hostname-setup.h" #include "hostname-util.h" #include "json-util.h" #include "network-common.h" #include "random-util.h" #include "socket-util.h" #include "string-util.h" #include "time-util.h" #include "unaligned.h" #include "web-util.h" #define LLDP_APP_ID SD_ID128_MAKE(07,3a,43,bf,54,de,40,8d,8e,c4,96,ed,fd,94,72,dc) /* The LLDP spec calls this "txFastInit", see 9.2.5.19 */ #define LLDP_FAST_TX_INIT 4U /* The LLDP spec calls this "msgTxHold", see 9.2.5.6 */ #define LLDP_TX_HOLD 4U /* The jitter range to add, see 9.2.2. */ #define LLDP_TX_JITTER_USEC (400U * USEC_PER_MSEC) /* The LLDP spec calls this msgTxInterval, but we subtract half the jitter off it. */ #define LLDP_TX_INTERVAL_USEC (30U * USEC_PER_SEC - LLDP_TX_JITTER_USEC / 2) /* The LLDP spec calls this msgFastTx, but we subtract half the jitter off it. */ #define LLDP_FAST_TX_INTERVAL_USEC (1U * USEC_PER_SEC - LLDP_TX_JITTER_USEC / 2) #define LLDP_TX_TTL ((uint16_t) DIV_ROUND_UP(LLDP_TX_INTERVAL_USEC * LLDP_TX_HOLD + 1, USEC_PER_SEC)) static const struct ether_addr lldp_multicast_addr[_SD_LLDP_MULTICAST_MODE_MAX] = { [SD_LLDP_MULTICAST_MODE_NEAREST_BRIDGE] = {{ 0x01, 0x80, 0xc2, 0x00, 0x00, 0x0e }}, [SD_LLDP_MULTICAST_MODE_NON_TPMR_BRIDGE] = {{ 0x01, 0x80, 0xc2, 0x00, 0x00, 0x03 }}, [SD_LLDP_MULTICAST_MODE_CUSTOMER_BRIDGE] = {{ 0x01, 0x80, 0xc2, 0x00, 0x00, 0x00 }}, }; struct sd_lldp_tx { unsigned n_ref; int ifindex; char *ifname; sd_event *event; int64_t event_priority; sd_event_source *timer_event_source; unsigned fast_tx; sd_lldp_multicast_mode_t mode; struct ether_addr hwaddr; char *port_description; char *hostname; char *pretty_hostname; char *mud_url; uint16_t supported_capabilities; uint16_t enabled_capabilities; uint16_t vlan_id; }; #define log_lldp_tx_errno(lldp_tx, error, fmt, ...) \ log_interface_prefix_full_errno( \ "LLDP Tx: ", \ sd_lldp_tx, lldp_tx, \ error, fmt, ##__VA_ARGS__) #define log_lldp_tx(lldp_tx, fmt, ...) \ log_interface_prefix_full_errno_zerook( \ "LLDP Tx: ", \ sd_lldp_tx, lldp_tx, \ 0, fmt, ##__VA_ARGS__) static sd_lldp_tx *lldp_tx_free(sd_lldp_tx *lldp_tx) { if (!lldp_tx) return NULL; sd_lldp_tx_detach_event(lldp_tx); free(lldp_tx->port_description); free(lldp_tx->hostname); free(lldp_tx->pretty_hostname); free(lldp_tx->mud_url); free(lldp_tx->ifname); return mfree(lldp_tx); } DEFINE_PUBLIC_TRIVIAL_REF_UNREF_FUNC(sd_lldp_tx, sd_lldp_tx, lldp_tx_free); int sd_lldp_tx_new(sd_lldp_tx **ret) { _cleanup_(sd_lldp_tx_unrefp) sd_lldp_tx *lldp_tx = NULL; assert_return(ret, -EINVAL); lldp_tx = new(sd_lldp_tx, 1); if (!lldp_tx) return -ENOMEM; *lldp_tx = (sd_lldp_tx) { .n_ref = 1, .mode = _SD_LLDP_MULTICAST_MODE_INVALID, }; *ret = TAKE_PTR(lldp_tx); return 0; } int sd_lldp_tx_set_ifindex(sd_lldp_tx *lldp_tx, int ifindex) { assert_return(lldp_tx, -EINVAL); assert_return(ifindex > 0, -EINVAL); lldp_tx->ifindex = ifindex; return 0; } int sd_lldp_tx_set_ifname(sd_lldp_tx *lldp_tx, const char *ifname) { assert_return(lldp_tx, -EINVAL); assert_return(ifname, -EINVAL); if (!ifname_valid_full(ifname, IFNAME_VALID_ALTERNATIVE)) return -EINVAL; return free_and_strdup(&lldp_tx->ifname, ifname); } int sd_lldp_tx_get_ifname(sd_lldp_tx *lldp_tx, const char **ret) { int r; assert_return(lldp_tx, -EINVAL); r = get_ifname(lldp_tx->ifindex, &lldp_tx->ifname); if (r < 0) return r; if (ret) *ret = lldp_tx->ifname; return 0; } int sd_lldp_tx_set_multicast_mode(sd_lldp_tx *lldp_tx, sd_lldp_multicast_mode_t mode) { assert_return(lldp_tx, -EINVAL); assert_return(mode >= 0 && mode < _SD_LLDP_MULTICAST_MODE_MAX, -EINVAL); lldp_tx->mode = mode; return 0; } int sd_lldp_tx_set_hwaddr(sd_lldp_tx *lldp_tx, const struct ether_addr *hwaddr) { assert_return(lldp_tx, -EINVAL); assert_return(hwaddr, -EINVAL); assert_return(!ether_addr_is_null(hwaddr), -EINVAL); lldp_tx->hwaddr = *hwaddr; return 0; } int sd_lldp_tx_set_capabilities(sd_lldp_tx *lldp_tx, uint16_t supported, uint16_t enabled) { assert_return(lldp_tx, -EINVAL); assert_return((enabled & ~supported) == 0, -EINVAL); lldp_tx->supported_capabilities = supported; lldp_tx->enabled_capabilities = enabled; return 0; } int sd_lldp_tx_set_port_description(sd_lldp_tx *lldp_tx, const char *port_description) { assert_return(lldp_tx, -EINVAL); /* An empty string unset the previously set hostname. */ if (strlen_ptr(port_description) >= 512) return -EINVAL; return free_and_strdup(&lldp_tx->port_description, empty_to_null(port_description)); } int sd_lldp_tx_set_hostname(sd_lldp_tx *lldp_tx, const char *hostname) { assert_return(lldp_tx, -EINVAL); /* An empty string unset the previously set hostname. */ if (!isempty(hostname) && !hostname_is_valid(hostname, /* flags= */ 0)) return -EINVAL; return free_and_strdup(&lldp_tx->hostname, empty_to_null(hostname)); } int sd_lldp_tx_set_pretty_hostname(sd_lldp_tx *lldp_tx, const char *pretty_hostname) { assert_return(lldp_tx, -EINVAL); /* An empty string unset the previously set hostname. */ if (strlen_ptr(pretty_hostname) >= 512) return -EINVAL; return free_and_strdup(&lldp_tx->pretty_hostname, empty_to_null(pretty_hostname)); } int sd_lldp_tx_set_mud_url(sd_lldp_tx *lldp_tx, const char *mud_url) { assert_return(lldp_tx, -EINVAL); /* An empty string unset the previously set hostname. */ if (!isempty(mud_url)) { /* Unless the maximum length of each value is 511, the MUD url must be smaller than 256. * See RFC 8520. */ if (strlen(mud_url) >= 256) return -EINVAL; if (!http_url_is_valid(mud_url)) return -EINVAL; } return free_and_strdup(&lldp_tx->mud_url, empty_to_null(mud_url)); } int sd_lldp_tx_set_vlan_id(sd_lldp_tx *lldp_tx, uint16_t vlan_id) { assert_return(lldp_tx, -EINVAL); lldp_tx->vlan_id = vlan_id; return 0; } static size_t lldp_tx_calculate_maximum_packet_size(sd_lldp_tx *lldp_tx, const char *hostname, const char *pretty_hostname) { assert(lldp_tx); assert(lldp_tx->ifindex > 0); return sizeof(struct ether_header) + /* Chassis ID */ 2 + 1 + (SD_ID128_STRING_MAX - 1) + /* Port ID */ 2 + 1 + strlen_ptr(lldp_tx->ifname) + /* TTL */ 2 + 2 + /* Port description */ 2 + strlen_ptr(lldp_tx->port_description) + /* System name */ 2 + strlen_ptr(hostname) + /* System description */ 2 + strlen_ptr(pretty_hostname) + /* System Capabilities */ 2 + 4 + /* MUD URL */ 2 + sizeof(SD_LLDP_OUI_IANA_MUD) + strlen_ptr(lldp_tx->mud_url) + /* VLAN ID */ 2 + sizeof(SD_LLDP_OUI_802_1_VLAN_ID) + sizeof(uint16_t) + /* End */ 2; } static int packet_append_tlv_header(uint8_t *packet, size_t packet_size, size_t *offset, uint8_t type, size_t data_len) { assert(packet); assert(offset); /* * +--------+--------+-------------- * |TLV Type| len | value * |(7 bits)|(9 bits)|(0-511 octets) * +--------+--------+-------------- * where: * * len = indicates the length of value */ /* The type field is 7-bits. */ if (type >= 128) return -EINVAL; /* The data length field is 9-bits. */ if (data_len >= 512) return -EINVAL; if (packet_size < 2 + data_len) return -ENOBUFS; if (*offset > packet_size - 2 - data_len) return -ENOBUFS; packet[(*offset)++] = (type << 1) | !!(data_len >> 8); packet[(*offset)++] = data_len & (size_t) UINT8_MAX; return 0; } static int packet_append_prefixed_string( uint8_t *packet, size_t packet_size, size_t *offset, uint8_t type, size_t prefix_len, const void *prefix, const char *str) { size_t len; int r; assert(packet); assert(offset); assert(prefix_len == 0 || prefix); if (isempty(str)) return 0; len = strlen(str); /* Check for overflow */ if (len > SIZE_MAX - prefix_len) return -ENOBUFS; r = packet_append_tlv_header(packet, packet_size, offset, type, prefix_len + len); if (r < 0) return r; memcpy_safe(packet + *offset, prefix, prefix_len); *offset += prefix_len; memcpy(packet + *offset, str, len); *offset += len; return 0; } static int packet_append_string( uint8_t *packet, size_t packet_size, size_t *offset, uint8_t type, const char *str) { return packet_append_prefixed_string(packet, packet_size, offset, type, 0, NULL, str); } static int lldp_tx_get_machine_id(sd_id128_t *ret) { int r; assert(ret); /* Unfortunately we previously exposed machine ID. If the environment variable is set, then * use the machine ID as is. Otherwise, use application specific one. */ r = secure_getenv_bool("SYSTEMD_LLDP_SEND_MACHINE_ID"); if (r < 0 && r != -ENXIO) log_debug_errno(r, "Failed to parse $SYSTEMD_LLDP_SEND_MACHINE_ID, ignoring: %m"); if (r > 0) return sd_id128_get_machine(ret); return sd_id128_get_machine_app_specific(LLDP_APP_ID, ret); } static int lldp_tx_create_packet(sd_lldp_tx *lldp_tx, size_t *ret_packet_size, uint8_t **ret_packet) { _cleanup_free_ char *hostname = NULL, *pretty_hostname = NULL; _cleanup_free_ uint8_t *packet = NULL; struct ether_header *header; size_t packet_size, offset; sd_id128_t machine_id; int r; assert(lldp_tx); assert(lldp_tx->ifindex > 0); assert(ret_packet_size); assert(ret_packet); /* If ifname is not set yet, set ifname from ifindex. */ r = sd_lldp_tx_get_ifname(lldp_tx, /* ret= */ NULL); if (r < 0) return r; r = lldp_tx_get_machine_id(&machine_id); if (r < 0) return r; if (!lldp_tx->hostname) (void) gethostname_strict(&hostname); if (!lldp_tx->pretty_hostname) (void) get_pretty_hostname(&pretty_hostname); packet_size = lldp_tx_calculate_maximum_packet_size(lldp_tx, lldp_tx->hostname ?: hostname, lldp_tx->pretty_hostname ?: pretty_hostname); packet = new(uint8_t, packet_size); if (!packet) return -ENOMEM; header = (struct ether_header*) packet; header->ether_type = htobe16(ETH_P_LLDP); memcpy(header->ether_dhost, lldp_multicast_addr + lldp_tx->mode, ETH_ALEN); memcpy(header->ether_shost, &lldp_tx->hwaddr, ETH_ALEN); offset = sizeof(struct ether_header); /* The three mandatory TLVs must appear first, in this specific order: * 1. Chassis ID * 2. Port ID * 3. Time To Live */ r = packet_append_prefixed_string(packet, packet_size, &offset, SD_LLDP_TYPE_CHASSIS_ID, 1, (const uint8_t[]) { SD_LLDP_CHASSIS_SUBTYPE_LOCALLY_ASSIGNED }, SD_ID128_TO_STRING(machine_id)); if (r < 0) return r; r = packet_append_prefixed_string(packet, packet_size, &offset, SD_LLDP_TYPE_PORT_ID, 1, (const uint8_t[]) { SD_LLDP_PORT_SUBTYPE_INTERFACE_NAME }, lldp_tx->ifname); if (r < 0) return r; r = packet_append_tlv_header(packet, packet_size, &offset, SD_LLDP_TYPE_TTL, 2); if (r < 0) return r; unaligned_write_be16(packet + offset, LLDP_TX_TTL); offset += 2; /* Optional TLVs follow, in no specific order: */ r = packet_append_string(packet, packet_size, &offset, SD_LLDP_TYPE_PORT_DESCRIPTION, lldp_tx->port_description); if (r < 0) return r; r = packet_append_string(packet, packet_size, &offset, SD_LLDP_TYPE_SYSTEM_NAME, lldp_tx->hostname ?: hostname); if (r < 0) return r; r = packet_append_string(packet, packet_size, &offset, SD_LLDP_TYPE_SYSTEM_DESCRIPTION, lldp_tx->pretty_hostname ?: pretty_hostname); if (r < 0) return r; r = packet_append_tlv_header(packet, packet_size, &offset, SD_LLDP_TYPE_SYSTEM_CAPABILITIES, 4); if (r < 0) return r; unaligned_write_be16(packet + offset, lldp_tx->supported_capabilities); offset += 2; unaligned_write_be16(packet + offset, lldp_tx->enabled_capabilities); offset += 2; /* See section 12 of RFC 8520. * +--------+--------+----------+---------+-------------- * |TLV Type| len | OUI |subtype | MUDString * | =127 | |= 00 00 5E| = 1 | * |(7 bits)|(9 bits)|(3 octets)|(1 octet)|(1-255 octets) * +--------+--------+----------+---------+-------------- * where: * * o TLV Type = 127 indicates a vendor-specific TLV * o len = indicates the TLV string length * o OUI = 00 00 5E is the organizationally unique identifier of IANA * o subtype = 1 (as assigned by IANA for the MUDstring) * o MUDstring = the length MUST NOT exceed 255 octets */ r = packet_append_prefixed_string(packet, packet_size, &offset, SD_LLDP_TYPE_PRIVATE, sizeof(SD_LLDP_OUI_IANA_MUD), SD_LLDP_OUI_IANA_MUD, lldp_tx->mud_url); if (r < 0) return r; /* VLAN ID */ if (lldp_tx->vlan_id > 0) { r = packet_append_tlv_header(packet, packet_size, &offset, SD_LLDP_TYPE_PRIVATE, sizeof(SD_LLDP_OUI_802_1_VLAN_ID) + sizeof(uint16_t)); if (r < 0) return r; memcpy_safe(packet + offset, SD_LLDP_OUI_802_1_VLAN_ID, sizeof(SD_LLDP_OUI_802_1_VLAN_ID)); offset += sizeof(SD_LLDP_OUI_802_1_VLAN_ID); unaligned_write_be16(packet + offset, lldp_tx->vlan_id); offset += 2; } r = packet_append_tlv_header(packet, packet_size, &offset, SD_LLDP_TYPE_END, 0); if (r < 0) return r; *ret_packet_size = offset; *ret_packet = TAKE_PTR(packet); return 0; } static int lldp_tx_send_packet(sd_lldp_tx *lldp_tx, size_t packet_size, const uint8_t *packet) { _cleanup_close_ int fd = -EBADF; union sockaddr_union sa; ssize_t l; assert(lldp_tx); assert(lldp_tx->ifindex > 0); assert(packet_size > sizeof(struct ether_header)); assert(packet); sa = (union sockaddr_union) { .ll.sll_family = AF_PACKET, .ll.sll_protocol = htobe16(ETH_P_LLDP), .ll.sll_ifindex = lldp_tx->ifindex, .ll.sll_halen = ETH_ALEN, }; memcpy(sa.ll.sll_addr, lldp_multicast_addr + lldp_tx->mode, ETH_ALEN); fd = socket(AF_PACKET, SOCK_RAW | SOCK_CLOEXEC, IPPROTO_RAW); if (fd < 0) return -errno; l = sendto(fd, packet, packet_size, MSG_NOSIGNAL, &sa.sa, sizeof(sa.ll)); if (l < 0) return -errno; if ((size_t) l != packet_size) return -EIO; return 0; } static int lldp_tx_send(sd_lldp_tx *lldp_tx) { _cleanup_free_ uint8_t *packet = NULL; size_t packet_size = 0; /* avoid false maybe-uninitialized warning */ int r; assert(lldp_tx); r = lldp_tx_create_packet(lldp_tx, &packet_size, &packet); if (r < 0) return r; return lldp_tx_send_packet(lldp_tx, packet_size, packet); } int sd_lldp_tx_attach_event(sd_lldp_tx *lldp_tx, sd_event *event, int64_t priority) { int r; assert_return(lldp_tx, -EINVAL); assert_return(!lldp_tx->event, -EBUSY); if (event) lldp_tx->event = sd_event_ref(event); else { r = sd_event_default(&lldp_tx->event); if (r < 0) return r; } lldp_tx->event_priority = priority; return 0; } int sd_lldp_tx_detach_event(sd_lldp_tx *lldp_tx) { assert_return(lldp_tx, -EINVAL); lldp_tx->timer_event_source = sd_event_source_disable_unref(lldp_tx->timer_event_source); lldp_tx->event = sd_event_unref(lldp_tx->event); return 0; } static usec_t lldp_tx_get_delay(sd_lldp_tx *lldp_tx) { assert(lldp_tx); return usec_add(lldp_tx->fast_tx > 0 ? LLDP_FAST_TX_INTERVAL_USEC : LLDP_TX_INTERVAL_USEC, (usec_t) random_u64() % LLDP_TX_JITTER_USEC); } static int lldp_tx_reset_timer(sd_lldp_tx *lldp_tx) { usec_t delay; int r; assert(lldp_tx); assert(lldp_tx->timer_event_source); delay = lldp_tx_get_delay(lldp_tx); r = sd_event_source_set_time_relative(lldp_tx->timer_event_source, delay); if (r < 0) return r; return sd_event_source_set_enabled(lldp_tx->timer_event_source, SD_EVENT_ONESHOT); } static int on_timer_event(sd_event_source *s, uint64_t usec, void *userdata) { sd_lldp_tx *lldp_tx = ASSERT_PTR(userdata); int r; r = lldp_tx_send(lldp_tx); if (r < 0) log_lldp_tx_errno(lldp_tx, r, "Failed to send packet, ignoring: %m"); if (lldp_tx->fast_tx > 0) lldp_tx->fast_tx--; r = lldp_tx_reset_timer(lldp_tx); if (r < 0) log_lldp_tx_errno(lldp_tx, r, "Failed to reset timer: %m"); return 0; } int sd_lldp_tx_is_running(sd_lldp_tx *lldp_tx) { int enabled; if (!lldp_tx) return 0; if (!lldp_tx->timer_event_source) return 0; if (sd_event_source_get_enabled(lldp_tx->timer_event_source, &enabled) < 0) return 0; return enabled == SD_EVENT_ONESHOT; } int sd_lldp_tx_stop(sd_lldp_tx *lldp_tx) { if (!lldp_tx) return 0; if (!lldp_tx->timer_event_source) return 0; (void) sd_event_source_set_enabled(lldp_tx->timer_event_source, SD_EVENT_OFF); return 1; } int sd_lldp_tx_start(sd_lldp_tx *lldp_tx) { usec_t delay; int r; assert_return(lldp_tx, -EINVAL); assert_return(lldp_tx->event, -EINVAL); assert_return(lldp_tx->ifindex > 0, -EINVAL); assert_return(lldp_tx->mode >= 0 && lldp_tx->mode < _SD_LLDP_MULTICAST_MODE_MAX, -EINVAL); assert_return(!ether_addr_is_null(&lldp_tx->hwaddr), -EINVAL); if (sd_lldp_tx_is_running(lldp_tx)) return 0; lldp_tx->fast_tx = LLDP_FAST_TX_INIT; if (lldp_tx->timer_event_source) { r = lldp_tx_reset_timer(lldp_tx); if (r < 0) return log_lldp_tx_errno(lldp_tx, r, "Failed to re-enable timer: %m"); return 0; } delay = lldp_tx_get_delay(lldp_tx); r = sd_event_add_time_relative(lldp_tx->event, &lldp_tx->timer_event_source, CLOCK_BOOTTIME, delay, 0, on_timer_event, lldp_tx); if (r < 0) return r; (void) sd_event_source_set_description(lldp_tx->timer_event_source, "lldp-tx-timer"); (void) sd_event_source_set_priority(lldp_tx->timer_event_source, lldp_tx->event_priority); return 0; } int sd_lldp_tx_describe(sd_lldp_tx *lldp_tx, sd_json_variant **ret) { int r; assert(lldp_tx); assert(ret); /* If ifname is not set yet, set ifname from ifindex. */ const char *ifname; r = sd_lldp_tx_get_ifname(lldp_tx, &ifname); if (r < 0) return r; size_t port_id_len = strlen(ifname) + 1; /* +1 for subtype */ _cleanup_free_ uint8_t *port_id = new(uint8_t, port_id_len + 1); /* +1 for unused zero suffix for safety */ if (!port_id) return -ENOMEM; port_id[0] = SD_LLDP_PORT_SUBTYPE_INTERFACE_NAME; memcpy(port_id + 1, ifname, port_id_len); /* also copy the final NUL for safety */ assert(port_id[port_id_len] == 0); sd_id128_t machine_id; r = lldp_tx_get_machine_id(&machine_id); if (r < 0) return r; size_t chassis_id_len = (SD_ID128_STRING_MAX - 1) + 1; _cleanup_free_ uint8_t *chassis_id = new(uint8_t, chassis_id_len + 1); if (!chassis_id) return -ENOMEM; chassis_id[0] = SD_LLDP_CHASSIS_SUBTYPE_LOCALLY_ASSIGNED; memcpy(chassis_id + 1, SD_ID128_TO_STRING(machine_id), chassis_id_len); assert(chassis_id[chassis_id_len] == 0); _cleanup_free_ char *hostname = NULL; if (!lldp_tx->hostname) (void) gethostname_strict(&hostname); _cleanup_free_ char *pretty_hostname = NULL; if (!lldp_tx->pretty_hostname) (void) get_pretty_hostname(&pretty_hostname); return sd_json_buildo( ret, SD_JSON_BUILD_PAIR_ID128("ChassisID", machine_id), SD_JSON_BUILD_PAIR_BYTE_ARRAY("RawChassisID", chassis_id, chassis_id_len), SD_JSON_BUILD_PAIR_STRING("PortID", lldp_tx->ifname), SD_JSON_BUILD_PAIR_BYTE_ARRAY("RawPortID", port_id, port_id_len), JSON_BUILD_PAIR_STRING_NON_EMPTY("PortDescription", lldp_tx->port_description), JSON_BUILD_PAIR_STRING_NON_EMPTY("SystemName", lldp_tx->hostname ?: hostname), JSON_BUILD_PAIR_STRING_NON_EMPTY("SystemDescription", lldp_tx->pretty_hostname ?: pretty_hostname), SD_JSON_BUILD_PAIR_UNSIGNED("EnabledCapabilities", lldp_tx->enabled_capabilities), JSON_BUILD_PAIR_STRING_NON_EMPTY("MUDURL", lldp_tx->mud_url), JSON_BUILD_PAIR_UNSIGNED_NON_ZERO("VlanID", lldp_tx->vlan_id)); }