34437b4f9c
This reworks the sd-lldp substantially, simplifying things on one hand, and extending the logic a bit on the other. Specifically: - Besides the sd_lldp object only one other object is maintained now, sd_lldp_neighbor. It's used both as storage for literal LLDP packets, and for maintainging info about peers in the database. Separation between packet, TLV and chassis data is not maintained anymore. This should be a major simplification. - The sd-lldp API has been extended so that a couple of per-neighbor fields may be queried directly, without iterating through the object. Other fields that may appear multiple times, OTOH have to be iterated through. - The maximum number of entries in the neighbor database is now configurable during runtime. - The generation of callbacks from sd_lldp objects is more restricted: callbacks are only invoked when actual data changed. - The TTL information is now hooked with a timer event, so that removals from the neighbor database due to TTLs now result in a callback event. - Querying LLDP neighbor database will now return a strictly ordered array, to guarantee stability. - A "capabilities" mask may now be configured, that selects what type of LLDP neighbor data is collected. This may be used to restrict collection of LLDP info about routers instead of all neighbors. This is now exposed via networkd's LLDP= setting. - sd-lldp's API to serialize the collected data to text files has been removed. Instead, there's now an API to extract the raw binary data from LLDP neighbor objects, as well as one to convert this raw binary data back to an LLDP neighbor object. networkd will save this raw binary data to /run now, and the client side can simply parse the information. - support for parsing the more exotic TLVs has been removed, since we are not using that. Instead there are now APIs to extract the raw data from TLVs. Given how easy it is to parse the TLVs clients should do so now directly instead of relying on our APIs for that. - A lot of the APIs that parse out LLDP strings have been simplified so that they actually return strings, instead of char arrays with a length. To deal with possibly dangerous characters the strings are escaped if needed. - APIs to extract and format the chassis and port IDs as strings has been added. - lldp.h has been simplified a lot. The enums are anonymous now, since they were never used as enums, but simply as constants. Most definitions we don't actually use ourselves have eben removed.
107 lines
3.1 KiB
C
107 lines
3.1 KiB
C
#pragma once
|
|
|
|
/***
|
|
This file is part of systemd.
|
|
|
|
Copyright 2016 Lennart Poettering
|
|
|
|
systemd is free software; you can redistribute it and/or modify it
|
|
under the terms of the GNU Lesser General Public License as published by
|
|
the Free Software Foundation; either version 2.1 of the License, or
|
|
(at your option) any later version.
|
|
|
|
systemd is distributed in the hope that it will be useful, but
|
|
WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
Lesser General Public License for more details.
|
|
|
|
You should have received a copy of the GNU Lesser General Public License
|
|
along with systemd; If not, see <http://www.gnu.org/licenses/>.
|
|
***/
|
|
|
|
#include <inttypes.h>
|
|
#include <stdbool.h>
|
|
#include <sys/types.h>
|
|
|
|
#include "sd-lldp.h"
|
|
|
|
#include "hash-funcs.h"
|
|
#include "lldp-internal.h"
|
|
#include "time-util.h"
|
|
|
|
typedef struct LLDPNeighborID {
|
|
/* The spec calls this an "MSAP identifier" */
|
|
void *chassis_id;
|
|
size_t chassis_id_size;
|
|
|
|
void *port_id;
|
|
size_t port_id_size;
|
|
} LLDPNeighborID;
|
|
|
|
struct sd_lldp_neighbor {
|
|
/* Neighbor objects stay around as long as they are linked into an "sd_lldp" object or n_ref > 0. */
|
|
sd_lldp *lldp;
|
|
unsigned n_ref;
|
|
|
|
usec_t until;
|
|
unsigned prioq_idx;
|
|
|
|
struct ether_addr source_address;
|
|
struct ether_addr destination_address;
|
|
|
|
LLDPNeighborID id;
|
|
|
|
/* The raw packet size. The data is appended to the object, accessible via LLDP_NEIGHBOR_RAW() */
|
|
size_t raw_size;
|
|
|
|
/* The current read index for the iterative TLV interface */
|
|
size_t rindex;
|
|
|
|
/* And a couple of fields parsed out. */
|
|
bool has_ttl:1;
|
|
bool has_capabilities:1;
|
|
bool has_port_vlan_id:1;
|
|
|
|
uint16_t ttl;
|
|
|
|
uint16_t system_capabilities;
|
|
uint16_t enabled_capabilities;
|
|
|
|
char *port_description;
|
|
char *system_name;
|
|
char *system_description;
|
|
|
|
uint16_t port_vlan_id;
|
|
|
|
char *chassis_id_as_string;
|
|
char *port_id_as_string;
|
|
};
|
|
|
|
static inline void *LLDP_NEIGHBOR_RAW(const sd_lldp_neighbor *n) {
|
|
return (uint8_t*) n + ALIGN(sizeof(sd_lldp_neighbor));
|
|
}
|
|
|
|
static inline uint8_t LLDP_NEIGHBOR_TYPE(const sd_lldp_neighbor *n) {
|
|
return ((uint8_t*) LLDP_NEIGHBOR_RAW(n))[n->rindex] >> 1;
|
|
}
|
|
|
|
static inline size_t LLDP_NEIGHBOR_LENGTH(const sd_lldp_neighbor *n) {
|
|
uint8_t *p;
|
|
|
|
p = (uint8_t*) LLDP_NEIGHBOR_RAW(n) + n->rindex;
|
|
return p[1] + (((size_t) (p[0] & 1)) << 8);
|
|
}
|
|
|
|
static inline void* LLDP_NEIGHBOR_DATA(const sd_lldp_neighbor *n) {
|
|
return ((uint8_t*) LLDP_NEIGHBOR_RAW(n)) + n->rindex + 2;
|
|
}
|
|
|
|
extern const struct hash_ops lldp_neighbor_id_hash_ops;
|
|
int lldp_neighbor_prioq_compare_func(const void *a, const void *b);
|
|
|
|
sd_lldp_neighbor *lldp_neighbor_unlink(sd_lldp_neighbor *n);
|
|
sd_lldp_neighbor *lldp_neighbor_new(size_t raw_size);
|
|
int lldp_neighbor_parse(sd_lldp_neighbor *n);
|
|
void lldp_neighbor_start_ttl(sd_lldp_neighbor *n);
|
|
bool lldp_neighbor_equal(const sd_lldp_neighbor *a, const sd_lldp_neighbor *b);
|