src/libsystemd-network/sd-lldp.c

   1 /***
   2   This file is part of systemd.
   3
   4   Copyright (C) 2014 Tom Gundersen
   5   Copyright (C) 2014 Susant Sahani
   6
   7   systemd is free software; you can redistribute it and/or modify it
   8   under the terms of the GNU Lesser General Public License as published by
   9   the Free Software Foundation; either version 2.1 of the License, or
  10   (at your option) any later version.
  11
  12   systemd is distributed in the hope that it will be useful, but
  13   WITHOUT ANY WARRANTY; without even the implied warranty of
  14   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  15   Lesser General Public License for more details.
  16
  17   You should have received a copy of the GNU Lesser General Public License
  18   along with systemd; If not, see <http://www.gnu.org/licenses/>.
  19 ***/
  20
  21 #include <arpa/inet.h>
  22
  23 #include "sd-lldp.h"
  24
  25 #include "alloc-util.h"
  26 #include "fd-util.h"
  27 #include "lldp-internal.h"
  28 #include "lldp-neighbor.h"
  29 #include "lldp-network.h"
  30 #include "socket-util.h"
  31 #include "ether-addr-util.h"
  32
  33 #define LLDP_DEFAULT_NEIGHBORS_MAX 128U
  34
  35 static void lldp_flush_neighbors(sd_lldp *lldp) {
  36         sd_lldp_neighbor *n;
  37
  38         assert(lldp);
  39
  40         while ((n = hashmap_first(lldp->neighbor_by_id)))
  41                 lldp_neighbor_unlink(n);
  42 }
  43
  44 static void lldp_callback(sd_lldp *lldp, sd_lldp_event event, sd_lldp_neighbor *n) {
  45         assert(lldp);
  46
  47         log_lldp("Invoking callback for '%c'.", event);
  48
  49         if (!lldp->callback)
  50                 return;
  51
  52         lldp->callback(lldp, event, n, lldp->userdata);
  53 }
  54
  55 static int lldp_make_space(sd_lldp *lldp, size_t extra) {
  56         usec_t t = USEC_INFINITY;
  57         bool changed = false;
  58
  59         assert(lldp);
  60
  61         /* Remove all entries that are past their TTL, and more until at least the specified number of extra entries
  62          * are free. */
  63
  64         for (;;) {
  65                 _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
  66
  67                 n = prioq_peek(lldp->neighbor_by_expiry);
  68                 if (!n)
  69                         break;
  70
  71                 sd_lldp_neighbor_ref(n);
  72
  73                 if (hashmap_size(lldp->neighbor_by_id) > LESS_BY(lldp->neighbors_max, extra))
  74                         goto remove_one;
  75
  76                 if (t == USEC_INFINITY)
  77                         t = now(clock_boottime_or_monotonic());
  78
  79                 if (n->until > t)
  80                         break;
  81
  82         remove_one:
  83                 lldp_neighbor_unlink(n);
  84                 lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, n);
  85                 changed = true;
  86         }
  87
  88         return changed;
  89 }
  90
  91 static bool lldp_keep_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) {
  92         assert(lldp);
  93         assert(n);
  94
  95         /* Don't keep data with a zero TTL */
  96         if (n->ttl <= 0)
  97                 return false;
  98
  99         /* Filter out data from the filter address */
 100         if (!ether_addr_is_null(&lldp->filter_address) &&
 101             ether_addr_equal(&lldp->filter_address, &n->source_address))
 102                 return false;
 103
 104         /* Only add if the neighbor has a capability we are interested in. Note that we also store all neighbors with
 105          * no caps field set. */
 106         if (n->has_capabilities &&
 107             (n->enabled_capabilities & lldp->capability_mask) == 0)
 108                 return false;
 109
 110         /* Keep everything else */
 111         return true;
 112 }
 113
 114 static int lldp_start_timer(sd_lldp *lldp, sd_lldp_neighbor *neighbor);
 115
 116 static int lldp_add_neighbor(sd_lldp *lldp, sd_lldp_neighbor *n) {
 117         _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *old = NULL;
 118         bool keep;
 119         int r;
 120
 121         assert(lldp);
 122         assert(n);
 123         assert(!n->lldp);
 124
 125         keep = lldp_keep_neighbor(lldp, n);
 126
 127         /* First retrieve the old entry for this MSAP */
 128         old = hashmap_get(lldp->neighbor_by_id, &n->id);
 129         if (old) {
 130                 sd_lldp_neighbor_ref(old);
 131
 132                 if (!keep) {
 133                         lldp_neighbor_unlink(old);
 134                         lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, old);
 135                         return 0;
 136                 }
 137
 138                 if (lldp_neighbor_equal(n, old)) {
 139                         /* Is this equal, then restart the TTL counter, but don't do anyting else. */
 140                         old->timestamp = n->timestamp;
 141                         lldp_start_timer(lldp, old);
 142                         lldp_callback(lldp, SD_LLDP_EVENT_REFRESHED, old);
 143                         return 0;
 144                 }
 145
 146                 /* Data changed, remove the old entry, and add a new one */
 147                 lldp_neighbor_unlink(old);
 148
 149         } else if (!keep)
 150                 return 0;
 151
 152         /* Then, make room for at least one new neighbor */
 153         lldp_make_space(lldp, 1);
 154
 155         r = hashmap_put(lldp->neighbor_by_id, &n->id, n);
 156         if (r < 0)
 157                 goto finish;
 158
 159         r = prioq_put(lldp->neighbor_by_expiry, n, &n->prioq_idx);
 160         if (r < 0) {
 161                 assert_se(hashmap_remove(lldp->neighbor_by_id, &n->id) == n);
 162                 goto finish;
 163         }
 164
 165         n->lldp = lldp;
 166
 167         lldp_start_timer(lldp, n);
 168         lldp_callback(lldp, old ? SD_LLDP_EVENT_UPDATED : SD_LLDP_EVENT_ADDED, n);
 169
 170         return 1;
 171
 172 finish:
 173         if (old)
 174                 lldp_callback(lldp, SD_LLDP_EVENT_REMOVED, old);
 175
 176         return r;
 177 }
 178
 179 static int lldp_handle_datagram(sd_lldp *lldp, sd_lldp_neighbor *n) {
 180         int r;
 181
 182         assert(lldp);
 183         assert(n);
 184
 185         r = lldp_neighbor_parse(n);
 186         if (r == -EBADMSG) /* Ignore bad messages */
 187                 return 0;
 188         if (r < 0)
 189                 return r;
 190
 191         r = lldp_add_neighbor(lldp, n);
 192         if (r < 0) {
 193                 log_lldp_errno(r, "Failed to add datagram. Ignoring.");
 194                 return 0;
 195         }
 196
 197         log_lldp("Successfully processed LLDP datagram.");
 198         return 0;
 199 }
 200
 201 static int lldp_receive_datagram(sd_event_source *s, int fd, uint32_t revents, void *userdata) {
 202         _cleanup_(sd_lldp_neighbor_unrefp) sd_lldp_neighbor *n = NULL;
 203         ssize_t space, length;
 204         sd_lldp *lldp = userdata;
 205         struct timespec ts;
 206
 207         assert(fd >= 0);
 208         assert(lldp);
 209
 210         space = next_datagram_size_fd(fd);
 211         if (space < 0)
 212                 return log_lldp_errno(space, "Failed to determine datagram size to read: %m");
 213
 214         n = lldp_neighbor_new(space);
 215         if (!n)
 216                 return -ENOMEM;
 217
 218         length = recv(fd, LLDP_NEIGHBOR_RAW(n), n->raw_size, MSG_DONTWAIT);
 219         if (length < 0) {
 220                 if (errno == EAGAIN || errno == EINTR)
 221                         return 0;
 222
 223                 return log_lldp_errno(errno, "Failed to read LLDP datagram: %m");
 224         }
 225
 226         if ((size_t) length != n->raw_size) {
 227                 log_lldp("Packet size mismatch.");
 228                 return -EINVAL;
 229         }
 230
 231         /* Try to get the timestamp of this packet if it is known */
 232         if (ioctl(fd, SIOCGSTAMPNS, &ts) >= 0)
 233                 triple_timestamp_from_realtime(&n->timestamp, timespec_load(&ts));
 234         else
 235                 triple_timestamp_get(&n->timestamp);
 236
 237         return lldp_handle_datagram(lldp, n);
 238 }
 239
 240 static void lldp_reset(sd_lldp *lldp) {
 241         assert(lldp);
 242
 243         lldp->timer_event_source = sd_event_source_unref(lldp->timer_event_source);
 244         lldp->io_event_source = sd_event_source_unref(lldp->io_event_source);
 245         lldp->fd = safe_close(lldp->fd);
 246 }
 247
 248 _public_ int sd_lldp_start(sd_lldp *lldp) {
 249         int r;
 250
 251         assert_return(lldp, -EINVAL);
 252         assert_return(lldp->event, -EINVAL);
 253         assert_return(lldp->ifindex > 0, -EINVAL);
 254
 255         if (lldp->fd >= 0)
 256                 return 0;
 257
 258         assert(!lldp->io_event_source);
 259
 260         lldp->fd = lldp_network_bind_raw_socket(lldp->ifindex);
 261         if (lldp->fd < 0)
 262                 return lldp->fd;
 263
 264         r = sd_event_add_io(lldp->event, &lldp->io_event_source, lldp->fd, EPOLLIN, lldp_receive_datagram, lldp);
 265         if (r < 0)
 266                 goto fail;
 267
 268         r = sd_event_source_set_priority(lldp->io_event_source, lldp->event_priority);
 269         if (r < 0)
 270                 goto fail;
 271
 272         (void) sd_event_source_set_description(lldp->io_event_source, "lldp-io");
 273
 274         log_lldp("Started LLDP client");
 275         return 1;
 276
 277 fail:
 278         lldp_reset(lldp);
 279         return r;
 280 }
 281
 282 _public_ int sd_lldp_stop(sd_lldp *lldp) {
 283         assert_return(lldp, -EINVAL);
 284
 285         if (lldp->fd < 0)
 286                 return 0;
 287
 288         log_lldp("Stopping LLDP client");
 289
 290         lldp_reset(lldp);
 291         lldp_flush_neighbors(lldp);
 292
 293         return 1;
 294 }
 295
 296 _public_ int sd_lldp_attach_event(sd_lldp *lldp, sd_event *event, int64_t priority) {
 297         int r;
 298
 299         assert_return(lldp, -EINVAL);
 300         assert_return(lldp->fd < 0, -EBUSY);
 301         assert_return(!lldp->event, -EBUSY);
 302
 303         if (event)
 304                 lldp->event = sd_event_ref(event);
 305         else {
 306                 r = sd_event_default(&lldp->event);
 307                 if (r < 0)
 308                         return r;
 309         }
 310
 311         lldp->event_priority = priority;
 312
 313         return 0;
 314 }
 315
 316 _public_ int sd_lldp_detach_event(sd_lldp *lldp) {
 317
 318         assert_return(lldp, -EINVAL);
 319         assert_return(lldp->fd < 0, -EBUSY);
 320
 321         lldp->event = sd_event_unref(lldp->event);
 322         return 0;
 323 }
 324
 325 _public_ int sd_lldp_set_callback(sd_lldp *lldp, sd_lldp_callback_t cb, void *userdata) {
 326         assert_return(lldp, -EINVAL);
 327
 328         lldp->callback = cb;
 329         lldp->userdata = userdata;
 330
 331         return 0;
 332 }
 333
 334 _public_ int sd_lldp_set_ifindex(sd_lldp *lldp, int ifindex) {
 335         assert_return(lldp, -EINVAL);
 336         assert_return(ifindex > 0, -EINVAL);
 337         assert_return(lldp->fd < 0, -EBUSY);
 338
 339         lldp->ifindex = ifindex;
 340         return 0;
 341 }
 342
 343 _public_ sd_lldp* sd_lldp_ref(sd_lldp *lldp) {
 344
 345         if (!lldp)
 346                 return NULL;
 347
 348         assert(lldp->n_ref > 0);
 349         lldp->n_ref++;
 350
 351         return lldp;
 352 }
 353
 354 _public_ sd_lldp* sd_lldp_unref(sd_lldp *lldp) {
 355
 356         if (!lldp)
 357                 return NULL;
 358
 359         assert(lldp->n_ref > 0);
 360         lldp->n_ref --;
 361
 362         if (lldp->n_ref > 0)
 363                 return NULL;
 364
 365         lldp_reset(lldp);
 366         sd_lldp_detach_event(lldp);
 367         lldp_flush_neighbors(lldp);
 368
 369         hashmap_free(lldp->neighbor_by_id);
 370         prioq_free(lldp->neighbor_by_expiry);
 371         free(lldp);
 372
 373         return NULL;
 374 }
 375
 376 _public_ int sd_lldp_new(sd_lldp **ret) {
 377         _cleanup_(sd_lldp_unrefp) sd_lldp *lldp = NULL;
 378         int r;
 379
 380         assert_return(ret, -EINVAL);
 381
 382         lldp = new0(sd_lldp, 1);
 383         if (!lldp)
 384                 return -ENOMEM;
 385
 386         lldp->n_ref = 1;
 387         lldp->fd = -1;
 388         lldp->neighbors_max = LLDP_DEFAULT_NEIGHBORS_MAX;
 389         lldp->capability_mask = (uint16_t) -1;
 390
 391         lldp->neighbor_by_id = hashmap_new(&lldp_neighbor_id_hash_ops);
 392         if (!lldp->neighbor_by_id)
 393                 return -ENOMEM;
 394
 395         r = prioq_ensure_allocated(&lldp->neighbor_by_expiry, lldp_neighbor_prioq_compare_func);
 396         if (r < 0)
 397                 return r;
 398
 399         *ret = lldp;
 400         lldp = NULL;
 401
 402         return 0;
 403 }
 404
 405 static int neighbor_compare_func(const void *a, const void *b) {
 406         const sd_lldp_neighbor * const*x = a, * const *y = b;
 407
 408         return lldp_neighbor_id_hash_ops.compare(&(*x)->id, &(*y)->id);
 409 }
 410
 411 static int on_timer_event(sd_event_source *s, uint64_t usec, void *userdata) {
 412         sd_lldp *lldp = userdata;
 413         int r, q;
 414
 415         r = lldp_make_space(lldp, 0);
 416         if (r < 0)
 417                 return log_lldp_errno(r, "Failed to make space: %m");
 418
 419         q = lldp_start_timer(lldp, NULL);
 420         if (q < 0)
 421                 return log_lldp_errno(q, "Failed to restart timer: %m");
 422
 423         return 0;
 424 }
 425
 426 static int lldp_start_timer(sd_lldp *lldp, sd_lldp_neighbor *neighbor) {
 427         sd_lldp_neighbor *n;
 428         int r;
 429
 430         assert(lldp);
 431
 432         if (neighbor)
 433                 lldp_neighbor_start_ttl(neighbor);
 434
 435         n = prioq_peek(lldp->neighbor_by_expiry);
 436         if (!n) {
 437
 438                 if (lldp->timer_event_source)
 439                         return sd_event_source_set_enabled(lldp->timer_event_source, SD_EVENT_OFF);
 440
 441                 return 0;
 442         }
 443
 444         if (lldp->timer_event_source) {
 445                 r = sd_event_source_set_time(lldp->timer_event_source, n->until);
 446                 if (r < 0)
 447                         return r;
 448
 449                 return sd_event_source_set_enabled(lldp->timer_event_source, SD_EVENT_ONESHOT);
 450         }
 451
 452         if (!lldp->event)
 453                 return 0;
 454
 455         r = sd_event_add_time(lldp->event, &lldp->timer_event_source, clock_boottime_or_monotonic(), n->until, 0, on_timer_event, lldp);
 456         if (r < 0)
 457                 return r;
 458
 459         r = sd_event_source_set_priority(lldp->timer_event_source, lldp->event_priority);
 460         if (r < 0)
 461                 return r;
 462
 463         (void) sd_event_source_set_description(lldp->timer_event_source, "lldp-timer");
 464         return 0;
 465 }
 466
 467 _public_ int sd_lldp_get_neighbors(sd_lldp *lldp, sd_lldp_neighbor ***ret) {
 468         sd_lldp_neighbor **l = NULL, *n;
 469         Iterator i;
 470         int k = 0, r;
 471
 472         assert_return(lldp, -EINVAL);
 473         assert_return(ret, -EINVAL);
 474
 475         if (hashmap_isempty(lldp->neighbor_by_id)) { /* Special shortcut */
 476                 *ret = NULL;
 477                 return 0;
 478         }
 479
 480         l = new0(sd_lldp_neighbor*, hashmap_size(lldp->neighbor_by_id));
 481         if (!l)
 482                 return -ENOMEM;
 483
 484         r = lldp_start_timer(lldp, NULL);
 485         if (r < 0) {
 486                 free(l);
 487                 return r;
 488         }
 489
 490         HASHMAP_FOREACH(n, lldp->neighbor_by_id, i)
 491                 l[k++] = sd_lldp_neighbor_ref(n);
 492
 493         assert((size_t) k == hashmap_size(lldp->neighbor_by_id));
 494
 495         /* Return things in a stable order */
 496         qsort(l, k, sizeof(sd_lldp_neighbor*), neighbor_compare_func);
 497         *ret = l;
 498
 499         return k;
 500 }
 501
 502 _public_ int sd_lldp_set_neighbors_max(sd_lldp *lldp, uint64_t m) {
 503         assert_return(lldp, -EINVAL);
 504         assert_return(m <= 0, -EINVAL);
 505
 506         lldp->neighbors_max = m;
 507         lldp_make_space(lldp, 0);
 508
 509         return 0;
 510 }
 511
 512 _public_ int sd_lldp_match_capabilities(sd_lldp *lldp, uint16_t mask) {
 513         assert_return(lldp, -EINVAL);
 514         assert_return(mask != 0, -EINVAL);
 515
 516         lldp->capability_mask = mask;
 517
 518         return 0;
 519 }
 520
 521 _public_ int sd_lldp_set_filter_address(sd_lldp *lldp, const struct ether_addr *addr) {
 522         assert_return(lldp, -EINVAL);
 523
 524         /* In order to deal nicely with bridges that send back our own packets, allow one address to be filtered, so
 525          * that our own can be filtered out here. */
 526
 527         if (!addr) {
 528                 zero(lldp->filter_address);
 529                 return 0;
 530         }
 531
 532         lldp->filter_address = *addr;
 533         return 0;
 534 }