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_ sd_event* sd_lldp_get_event(sd_lldp *lldp) {
 326         assert_return(lldp, NULL);
 327
 328         return lldp->event;
 329 }
 330
 331 _public_ int sd_lldp_set_callback(sd_lldp *lldp, sd_lldp_callback_t cb, void *userdata) {
 332         assert_return(lldp, -EINVAL);
 333
 334         lldp->callback = cb;
 335         lldp->userdata = userdata;
 336
 337         return 0;
 338 }
 339
 340 _public_ int sd_lldp_set_ifindex(sd_lldp *lldp, int ifindex) {
 341         assert_return(lldp, -EINVAL);
 342         assert_return(ifindex > 0, -EINVAL);
 343         assert_return(lldp->fd < 0, -EBUSY);
 344
 345         lldp->ifindex = ifindex;
 346         return 0;
 347 }
 348
 349 _public_ sd_lldp* sd_lldp_ref(sd_lldp *lldp) {
 350
 351         if (!lldp)
 352                 return NULL;
 353
 354         assert(lldp->n_ref > 0);
 355         lldp->n_ref++;
 356
 357         return lldp;
 358 }
 359
 360 _public_ sd_lldp* sd_lldp_unref(sd_lldp *lldp) {
 361
 362         if (!lldp)
 363                 return NULL;
 364
 365         assert(lldp->n_ref > 0);
 366         lldp->n_ref --;
 367
 368         if (lldp->n_ref > 0)
 369                 return NULL;
 370
 371         lldp_reset(lldp);
 372         sd_lldp_detach_event(lldp);
 373         lldp_flush_neighbors(lldp);
 374
 375         hashmap_free(lldp->neighbor_by_id);
 376         prioq_free(lldp->neighbor_by_expiry);
 377         free(lldp);
 378
 379         return NULL;
 380 }
 381
 382 _public_ int sd_lldp_new(sd_lldp **ret) {
 383         _cleanup_(sd_lldp_unrefp) sd_lldp *lldp = NULL;
 384         int r;
 385
 386         assert_return(ret, -EINVAL);
 387
 388         lldp = new0(sd_lldp, 1);
 389         if (!lldp)
 390                 return -ENOMEM;
 391
 392         lldp->n_ref = 1;
 393         lldp->fd = -1;
 394         lldp->neighbors_max = LLDP_DEFAULT_NEIGHBORS_MAX;
 395         lldp->capability_mask = (uint16_t) -1;
 396
 397         lldp->neighbor_by_id = hashmap_new(&lldp_neighbor_id_hash_ops);
 398         if (!lldp->neighbor_by_id)
 399                 return -ENOMEM;
 400
 401         r = prioq_ensure_allocated(&lldp->neighbor_by_expiry, lldp_neighbor_prioq_compare_func);
 402         if (r < 0)
 403                 return r;
 404
 405         *ret = lldp;
 406         lldp = NULL;
 407
 408         return 0;
 409 }
 410
 411 static int neighbor_compare_func(const void *a, const void *b) {
 412         const sd_lldp_neighbor * const*x = a, * const *y = b;
 413
 414         return lldp_neighbor_id_hash_ops.compare(&(*x)->id, &(*y)->id);
 415 }
 416
 417 static int on_timer_event(sd_event_source *s, uint64_t usec, void *userdata) {
 418         sd_lldp *lldp = userdata;
 419         int r, q;
 420
 421         r = lldp_make_space(lldp, 0);
 422         if (r < 0)
 423                 return log_lldp_errno(r, "Failed to make space: %m");
 424
 425         q = lldp_start_timer(lldp, NULL);
 426         if (q < 0)
 427                 return log_lldp_errno(q, "Failed to restart timer: %m");
 428
 429         return 0;
 430 }
 431
 432 static int lldp_start_timer(sd_lldp *lldp, sd_lldp_neighbor *neighbor) {
 433         sd_lldp_neighbor *n;
 434         int r;
 435
 436         assert(lldp);
 437
 438         if (neighbor)
 439                 lldp_neighbor_start_ttl(neighbor);
 440
 441         n = prioq_peek(lldp->neighbor_by_expiry);
 442         if (!n) {
 443
 444                 if (lldp->timer_event_source)
 445                         return sd_event_source_set_enabled(lldp->timer_event_source, SD_EVENT_OFF);
 446
 447                 return 0;
 448         }
 449
 450         if (lldp->timer_event_source) {
 451                 r = sd_event_source_set_time(lldp->timer_event_source, n->until);
 452                 if (r < 0)
 453                         return r;
 454
 455                 return sd_event_source_set_enabled(lldp->timer_event_source, SD_EVENT_ONESHOT);
 456         }
 457
 458         if (!lldp->event)
 459                 return 0;
 460
 461         r = sd_event_add_time(lldp->event, &lldp->timer_event_source, clock_boottime_or_monotonic(), n->until, 0, on_timer_event, lldp);
 462         if (r < 0)
 463                 return r;
 464
 465         r = sd_event_source_set_priority(lldp->timer_event_source, lldp->event_priority);
 466         if (r < 0)
 467                 return r;
 468
 469         (void) sd_event_source_set_description(lldp->timer_event_source, "lldp-timer");
 470         return 0;
 471 }
 472
 473 _public_ int sd_lldp_get_neighbors(sd_lldp *lldp, sd_lldp_neighbor ***ret) {
 474         sd_lldp_neighbor **l = NULL, *n;
 475         Iterator i;
 476         int k = 0, r;
 477
 478         assert_return(lldp, -EINVAL);
 479         assert_return(ret, -EINVAL);
 480
 481         if (hashmap_isempty(lldp->neighbor_by_id)) { /* Special shortcut */
 482                 *ret = NULL;
 483                 return 0;
 484         }
 485
 486         l = new0(sd_lldp_neighbor*, hashmap_size(lldp->neighbor_by_id));
 487         if (!l)
 488                 return -ENOMEM;
 489
 490         r = lldp_start_timer(lldp, NULL);
 491         if (r < 0) {
 492                 free(l);
 493                 return r;
 494         }
 495
 496         HASHMAP_FOREACH(n, lldp->neighbor_by_id, i)
 497                 l[k++] = sd_lldp_neighbor_ref(n);
 498
 499         assert((size_t) k == hashmap_size(lldp->neighbor_by_id));
 500
 501         /* Return things in a stable order */
 502         qsort(l, k, sizeof(sd_lldp_neighbor*), neighbor_compare_func);
 503         *ret = l;
 504
 505         return k;
 506 }
 507
 508 _public_ int sd_lldp_set_neighbors_max(sd_lldp *lldp, uint64_t m) {
 509         assert_return(lldp, -EINVAL);
 510         assert_return(m <= 0, -EINVAL);
 511
 512         lldp->neighbors_max = m;
 513         lldp_make_space(lldp, 0);
 514
 515         return 0;
 516 }
 517
 518 _public_ int sd_lldp_match_capabilities(sd_lldp *lldp, uint16_t mask) {
 519         assert_return(lldp, -EINVAL);
 520         assert_return(mask != 0, -EINVAL);
 521
 522         lldp->capability_mask = mask;
 523
 524         return 0;
 525 }
 526
 527 _public_ int sd_lldp_set_filter_address(sd_lldp *lldp, const struct ether_addr *addr) {
 528         assert_return(lldp, -EINVAL);
 529
 530         /* In order to deal nicely with bridges that send back our own packets, allow one address to be filtered, so
 531          * that our own can be filtered out here. */
 532
 533         if (addr)
 534                 lldp->filter_address = *addr;
 535         else
 536                 zero(lldp->filter_address);
 537
 538         return 0;
 539 }