ldpd/neighbor.c

   1 /*      $OpenBSD$ */
   2
   3 /*
   4  * Copyright (c) 2013, 2016 Renato Westphal <renato@openbsd.org>
   5  * Copyright (c) 2009 Michele Marchetto <michele@openbsd.org>
   6  * Copyright (c) 2005 Claudio Jeker <claudio@openbsd.org>
   7  * Copyright (c) 2004, 2005, 2008 Esben Norby <norby@openbsd.org>
   8  *
   9  * Permission to use, copy, modify, and distribute this software for any
  10  * purpose with or without fee is hereby granted, provided that the above
  11  * copyright notice and this permission notice appear in all copies.
  12  *
  13  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
  14  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
  15  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
  16  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
  17  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
  18  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
  19  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
  20  */
  21
  22 #include <zebra.h>
  23
  24 #include "ldpd.h"
  25 #include "ldpe.h"
  26 #include "lde.h"
  27 #include "log.h"
  28
  29 static __inline int      nbr_id_compare(struct nbr *, struct nbr *);
  30 static __inline int      nbr_addr_compare(struct nbr *, struct nbr *);
  31 static __inline int      nbr_pid_compare(struct nbr *, struct nbr *);
  32 static void              nbr_update_peerid(struct nbr *);
  33 static int               nbr_ktimer(struct thread *);
  34 static void              nbr_start_ktimer(struct nbr *);
  35 static int               nbr_ktimeout(struct thread *);
  36 static void              nbr_start_ktimeout(struct nbr *);
  37 static int               nbr_itimeout(struct thread *);
  38 static void              nbr_start_itimeout(struct nbr *);
  39 static int               nbr_idtimer(struct thread *);
  40 static int               nbr_act_session_operational(struct nbr *);
  41 static void              nbr_send_labelmappings(struct nbr *);
  42 static __inline int      nbr_params_compare(struct nbr_params *,
  43                             struct nbr_params *);
  44
  45 RB_GENERATE(nbr_id_head, nbr, id_tree, nbr_id_compare)
  46 RB_GENERATE(nbr_addr_head, nbr, addr_tree, nbr_addr_compare)
  47 RB_GENERATE(nbr_pid_head, nbr, pid_tree, nbr_pid_compare)
  48 RB_GENERATE(nbrp_head, nbr_params, entry, nbr_params_compare)
  49
  50 struct {
  51         int             state;
  52         enum nbr_event  event;
  53         enum nbr_action action;
  54         int             new_state;
  55 } nbr_fsm_tbl[] = {
  56     /* current state    event that happened     action to take          resulting state */
  57 /* Passive Role */
  58     {NBR_STA_PRESENT,   NBR_EVT_MATCH_ADJ,      NBR_ACT_NOTHING,        NBR_STA_INITIAL},
  59     {NBR_STA_INITIAL,   NBR_EVT_INIT_RCVD,      NBR_ACT_PASSIVE_INIT,   NBR_STA_OPENREC},
  60     {NBR_STA_OPENREC,   NBR_EVT_KEEPALIVE_RCVD, NBR_ACT_SESSION_EST,    NBR_STA_OPER},
  61 /* Active Role */
  62     {NBR_STA_PRESENT,   NBR_EVT_CONNECT_UP,     NBR_ACT_CONNECT_SETUP,  NBR_STA_INITIAL},
  63     {NBR_STA_INITIAL,   NBR_EVT_INIT_SENT,      NBR_ACT_NOTHING,        NBR_STA_OPENSENT},
  64     {NBR_STA_OPENSENT,  NBR_EVT_INIT_RCVD,      NBR_ACT_KEEPALIVE_SEND, NBR_STA_OPENREC},
  65 /* Session Maintenance */
  66     {NBR_STA_OPER,      NBR_EVT_PDU_RCVD,       NBR_ACT_RST_KTIMEOUT,   0},
  67     {NBR_STA_SESSION,   NBR_EVT_PDU_RCVD,       NBR_ACT_NOTHING,        0},
  68     {NBR_STA_OPER,      NBR_EVT_PDU_SENT,       NBR_ACT_RST_KTIMER,     0},
  69     {NBR_STA_SESSION,   NBR_EVT_PDU_SENT,       NBR_ACT_NOTHING,        0},
  70 /* Session Close */
  71     {NBR_STA_PRESENT,   NBR_EVT_CLOSE_SESSION,  NBR_ACT_NOTHING,        0},
  72     {NBR_STA_SESSION,   NBR_EVT_CLOSE_SESSION,  NBR_ACT_CLOSE_SESSION,  NBR_STA_PRESENT},
  73     {-1,                NBR_EVT_NOTHING,        NBR_ACT_NOTHING,        0},
  74 };
  75
  76 const char * const nbr_event_names[] = {
  77         "NOTHING",
  78         "ADJACENCY MATCHED",
  79         "CONNECTION UP",
  80         "SESSION CLOSE",
  81         "INIT RECEIVED",
  82         "KEEPALIVE RECEIVED",
  83         "PDU RECEIVED",
  84         "PDU SENT",
  85         "INIT SENT"
  86 };
  87
  88 const char * const nbr_action_names[] = {
  89         "NOTHING",
  90         "RESET KEEPALIVE TIMEOUT",
  91         "START NEIGHBOR SESSION",
  92         "RESET KEEPALIVE TIMER",
  93         "SETUP NEIGHBOR CONNECTION",
  94         "SEND INIT AND KEEPALIVE",
  95         "SEND KEEPALIVE",
  96         "CLOSE SESSION"
  97 };
  98
  99 struct nbr_id_head nbrs_by_id = RB_INITIALIZER(&nbrs_by_id);
 100 struct nbr_addr_head nbrs_by_addr = RB_INITIALIZER(&nbrs_by_addr);
 101 struct nbr_pid_head nbrs_by_pid = RB_INITIALIZER(&nbrs_by_pid);
 102
 103 static __inline int
 104 nbr_id_compare(struct nbr *a, struct nbr *b)
 105 {
 106         return (ntohl(a->id.s_addr) - ntohl(b->id.s_addr));
 107 }
 108
 109 static __inline int
 110 nbr_addr_compare(struct nbr *a, struct nbr *b)
 111 {
 112         if (a->af < b->af)
 113                 return (-1);
 114         if (a->af > b->af)
 115                 return (1);
 116
 117         return (ldp_addrcmp(a->af, &a->raddr, &b->raddr));
 118 }
 119
 120 static __inline int
 121 nbr_pid_compare(struct nbr *a, struct nbr *b)
 122 {
 123         return (a->peerid - b->peerid);
 124 }
 125
 126 int
 127 nbr_fsm(struct nbr *nbr, enum nbr_event event)
 128 {
 129         struct timeval  now;
 130         int             old_state;
 131         int             new_state = 0;
 132         int             i;
 133
 134         old_state = nbr->state;
 135         for (i = 0; nbr_fsm_tbl[i].state != -1; i++)
 136                 if ((nbr_fsm_tbl[i].state & old_state) &&
 137                     (nbr_fsm_tbl[i].event == event)) {
 138                         new_state = nbr_fsm_tbl[i].new_state;
 139                         break;
 140                 }
 141
 142         if (nbr_fsm_tbl[i].state == -1) {
 143                 /* event outside of the defined fsm, ignore it. */
 144                 log_warnx("%s: lsr-id %s, event %s not expected in "
 145                     "state %s", __func__, inet_ntoa(nbr->id),
 146                     nbr_event_names[event], nbr_state_name(old_state));
 147                 return (0);
 148         }
 149
 150         if (new_state != 0)
 151                 nbr->state = new_state;
 152
 153         if (old_state != nbr->state) {
 154                 log_debug("%s: event %s resulted in action %s and "
 155                     "changing state for lsr-id %s from %s to %s",
 156                     __func__, nbr_event_names[event],
 157                     nbr_action_names[nbr_fsm_tbl[i].action],
 158                     inet_ntoa(nbr->id), nbr_state_name(old_state),
 159                     nbr_state_name(nbr->state));
 160
 161                 if (nbr->state == NBR_STA_OPER) {
 162                         gettimeofday(&now, NULL);
 163                         nbr->uptime = now.tv_sec;
 164                 }
 165         }
 166
 167         if (nbr->state == NBR_STA_OPER || nbr->state == NBR_STA_PRESENT)
 168                 nbr_stop_itimeout(nbr);
 169         else
 170                 nbr_start_itimeout(nbr);
 171
 172         switch (nbr_fsm_tbl[i].action) {
 173         case NBR_ACT_RST_KTIMEOUT:
 174                 nbr_start_ktimeout(nbr);
 175                 break;
 176         case NBR_ACT_RST_KTIMER:
 177                 nbr_start_ktimer(nbr);
 178                 break;
 179         case NBR_ACT_SESSION_EST:
 180                 nbr_act_session_operational(nbr);
 181                 nbr_start_ktimer(nbr);
 182                 nbr_start_ktimeout(nbr);
 183                 if (nbr->v4_enabled)
 184                         send_address_all(nbr, AF_INET);
 185                 if (nbr->v6_enabled)
 186                         send_address_all(nbr, AF_INET6);
 187                 nbr_send_labelmappings(nbr);
 188                 break;
 189         case NBR_ACT_CONNECT_SETUP:
 190                 nbr->tcp = tcp_new(nbr->fd, nbr);
 191
 192                 /* trigger next state */
 193                 send_init(nbr);
 194                 nbr_fsm(nbr, NBR_EVT_INIT_SENT);
 195                 break;
 196         case NBR_ACT_PASSIVE_INIT:
 197                 send_init(nbr);
 198                 send_keepalive(nbr);
 199                 break;
 200         case NBR_ACT_KEEPALIVE_SEND:
 201                 nbr_start_ktimeout(nbr);
 202                 send_keepalive(nbr);
 203                 break;
 204         case NBR_ACT_CLOSE_SESSION:
 205                 ldpe_imsg_compose_lde(IMSG_NEIGHBOR_DOWN, nbr->peerid, 0,
 206                     NULL, 0);
 207                 session_close(nbr);
 208                 break;
 209         case NBR_ACT_NOTHING:
 210                 /* do nothing */
 211                 break;
 212         }
 213
 214         return (0);
 215 }
 216
 217 struct nbr *
 218 nbr_new(struct in_addr id, int af, int ds_tlv, union ldpd_addr *addr,
 219     uint32_t scope_id)
 220 {
 221         struct nbr              *nbr;
 222         struct nbr_params       *nbrp;
 223         struct adj              *adj;
 224         struct pending_conn     *pconn;
 225
 226         log_debug("%s: lsr-id %s transport-address %s", __func__,
 227             inet_ntoa(id), log_addr(af, addr));
 228
 229         if ((nbr = calloc(1, sizeof(*nbr))) == NULL)
 230                 fatal(__func__);
 231
 232         RB_INIT(&nbr->adj_tree);
 233         nbr->state = NBR_STA_PRESENT;
 234         nbr->peerid = 0;
 235         nbr->af = af;
 236         nbr->ds_tlv = ds_tlv;
 237         if (af == AF_INET || ds_tlv)
 238                 nbr->v4_enabled = 1;
 239         if (af == AF_INET6 || ds_tlv)
 240                 nbr->v6_enabled = 1;
 241         nbr->id = id;
 242         nbr->laddr = (ldp_af_conf_get(leconf, af))->trans_addr;
 243         nbr->raddr = *addr;
 244         nbr->raddr_scope = scope_id;
 245         nbr->conf_seqnum = 0;
 246
 247         RB_FOREACH(adj, global_adj_head, &global.adj_tree) {
 248                 if (adj->lsr_id.s_addr == nbr->id.s_addr) {
 249                         adj->nbr = nbr;
 250                         RB_INSERT(nbr_adj_head, &nbr->adj_tree, adj);
 251                 }
 252         }
 253
 254         if (RB_INSERT(nbr_id_head, &nbrs_by_id, nbr) != NULL)
 255                 fatalx("nbr_new: RB_INSERT(nbrs_by_id) failed");
 256         if (RB_INSERT(nbr_addr_head, &nbrs_by_addr, nbr) != NULL)
 257                 fatalx("nbr_new: RB_INSERT(nbrs_by_addr) failed");
 258
 259         TAILQ_INIT(&nbr->mapping_list);
 260         TAILQ_INIT(&nbr->withdraw_list);
 261         TAILQ_INIT(&nbr->request_list);
 262         TAILQ_INIT(&nbr->release_list);
 263         TAILQ_INIT(&nbr->abortreq_list);
 264
 265         nbrp = nbr_params_find(leconf, nbr->id);
 266         if (nbrp) {
 267                 nbr->auth.method = nbrp->auth.method;
 268 #ifdef __OpenBSD__
 269                 if (pfkey_establish(nbr, nbrp) == -1)
 270                         fatalx("pfkey setup failed");
 271 #else
 272                 sock_set_md5sig(
 273                     (ldp_af_global_get(&global, nbr->af))->ldp_session_socket,
 274                     nbr->af, &nbr->raddr, nbrp->auth.md5key);
 275 #endif
 276         }
 277
 278         pconn = pending_conn_find(nbr->af, &nbr->raddr);
 279         if (pconn) {
 280                 session_accept_nbr(nbr, pconn->fd);
 281                 pending_conn_del(pconn);
 282         }
 283
 284         return (nbr);
 285 }
 286
 287 void
 288 nbr_del(struct nbr *nbr)
 289 {
 290         log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));
 291
 292         nbr_fsm(nbr, NBR_EVT_CLOSE_SESSION);
 293 #ifdef __OpenBSD__
 294         pfkey_remove(nbr);
 295 #else
 296         sock_set_md5sig(
 297             (ldp_af_global_get(&global, nbr->af))->ldp_session_socket,
 298             nbr->af, &nbr->raddr, NULL);
 299 #endif
 300         nbr->auth.method = AUTH_NONE;
 301
 302         if (nbr_pending_connect(nbr))
 303                 THREAD_WRITE_OFF(nbr->ev_connect);
 304         nbr_stop_ktimer(nbr);
 305         nbr_stop_ktimeout(nbr);
 306         nbr_stop_itimeout(nbr);
 307         nbr_stop_idtimer(nbr);
 308
 309         mapping_list_clr(&nbr->mapping_list);
 310         mapping_list_clr(&nbr->withdraw_list);
 311         mapping_list_clr(&nbr->request_list);
 312         mapping_list_clr(&nbr->release_list);
 313         mapping_list_clr(&nbr->abortreq_list);
 314
 315         if (nbr->peerid)
 316                 RB_REMOVE(nbr_pid_head, &nbrs_by_pid, nbr);
 317         RB_REMOVE(nbr_id_head, &nbrs_by_id, nbr);
 318         RB_REMOVE(nbr_addr_head, &nbrs_by_addr, nbr);
 319
 320         free(nbr);
 321 }
 322
 323 static void
 324 nbr_update_peerid(struct nbr *nbr)
 325 {
 326         static uint32_t  peercnt = 1;
 327
 328         if (nbr->peerid)
 329                 RB_REMOVE(nbr_pid_head, &nbrs_by_pid, nbr);
 330
 331         /* get next unused peerid */
 332         while (nbr_find_peerid(++peercnt))
 333                 ;
 334         nbr->peerid = peercnt;
 335
 336         if (RB_INSERT(nbr_pid_head, &nbrs_by_pid, nbr) != NULL)
 337                 fatalx("nbr_update_peerid: RB_INSERT(nbrs_by_pid) failed");
 338 }
 339
 340 struct nbr *
 341 nbr_find_ldpid(uint32_t lsr_id)
 342 {
 343         struct nbr      n;
 344         n.id.s_addr = lsr_id;
 345         return (RB_FIND(nbr_id_head, &nbrs_by_id, &n));
 346 }
 347
 348 struct nbr *
 349 nbr_find_addr(int af, union ldpd_addr *addr)
 350 {
 351         struct nbr      n;
 352         n.af = af;
 353         n.raddr = *addr;
 354         return (RB_FIND(nbr_addr_head, &nbrs_by_addr, &n));
 355 }
 356
 357 struct nbr *
 358 nbr_find_peerid(uint32_t peerid)
 359 {
 360         struct nbr      n;
 361         n.peerid = peerid;
 362         return (RB_FIND(nbr_pid_head, &nbrs_by_pid, &n));
 363 }
 364
 365 int
 366 nbr_adj_count(struct nbr *nbr, int af)
 367 {
 368         struct adj      *adj;
 369         int              total = 0;
 370
 371         RB_FOREACH(adj, nbr_adj_head, &nbr->adj_tree)
 372                 if (adj_get_af(adj) == af)
 373                         total++;
 374
 375         return (total);
 376 }
 377
 378 int
 379 nbr_session_active_role(struct nbr *nbr)
 380 {
 381         if (ldp_addrcmp(nbr->af, &nbr->laddr, &nbr->raddr) > 0)
 382                 return (1);
 383
 384         return (0);
 385 }
 386
 387 /* timers */
 388
 389 /* Keepalive timer: timer to send keepalive message to neighbors */
 390
 391 static int
 392 nbr_ktimer(struct thread *thread)
 393 {
 394         struct nbr      *nbr = THREAD_ARG(thread);
 395
 396         nbr->keepalive_timer = NULL;
 397         send_keepalive(nbr);
 398         nbr_start_ktimer(nbr);
 399
 400         return (0);
 401 }
 402
 403 static void
 404 nbr_start_ktimer(struct nbr *nbr)
 405 {
 406         int              secs;
 407
 408         /* send three keepalives per period */
 409         secs = nbr->keepalive / KEEPALIVE_PER_PERIOD;
 410         THREAD_TIMER_OFF(nbr->keepalive_timer);
 411         nbr->keepalive_timer = NULL;
 412         thread_add_timer(master, nbr_ktimer, nbr, secs, &nbr->keepalive_timer);
 413 }
 414
 415 void
 416 nbr_stop_ktimer(struct nbr *nbr)
 417 {
 418         THREAD_TIMER_OFF(nbr->keepalive_timer);
 419 }
 420
 421 /* Keepalive timeout: if the nbr hasn't sent keepalive */
 422
 423 static int
 424 nbr_ktimeout(struct thread *thread)
 425 {
 426         struct nbr *nbr = THREAD_ARG(thread);
 427
 428         nbr->keepalive_timeout = NULL;
 429
 430         log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));
 431
 432         session_shutdown(nbr, S_KEEPALIVE_TMR, 0, 0);
 433
 434         return (0);
 435 }
 436
 437 static void
 438 nbr_start_ktimeout(struct nbr *nbr)
 439 {
 440         THREAD_TIMER_OFF(nbr->keepalive_timeout);
 441         nbr->keepalive_timeout = NULL;
 442         thread_add_timer(master, nbr_ktimeout, nbr, nbr->keepalive,
 443                          &nbr->keepalive_timeout);
 444 }
 445
 446 void
 447 nbr_stop_ktimeout(struct nbr *nbr)
 448 {
 449         THREAD_TIMER_OFF(nbr->keepalive_timeout);
 450 }
 451
 452 /* Session initialization timeout: if nbr got stuck in the initialization FSM */
 453
 454 static int
 455 nbr_itimeout(struct thread *thread)
 456 {
 457         struct nbr      *nbr = THREAD_ARG(thread);
 458
 459         log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));
 460
 461         nbr_fsm(nbr, NBR_EVT_CLOSE_SESSION);
 462
 463         return (0);
 464 }
 465
 466 static void
 467 nbr_start_itimeout(struct nbr *nbr)
 468 {
 469         int              secs;
 470
 471         secs = INIT_FSM_TIMEOUT;
 472         THREAD_TIMER_OFF(nbr->init_timeout);
 473         nbr->init_timeout = NULL;
 474         thread_add_timer(master, nbr_itimeout, nbr, secs, &nbr->init_timeout);
 475 }
 476
 477 void
 478 nbr_stop_itimeout(struct nbr *nbr)
 479 {
 480         THREAD_TIMER_OFF(nbr->init_timeout);
 481 }
 482
 483 /* Init delay timer: timer to retry to iniziatize session */
 484
 485 static int
 486 nbr_idtimer(struct thread *thread)
 487 {
 488         struct nbr *nbr = THREAD_ARG(thread);
 489
 490         nbr->initdelay_timer = NULL;
 491
 492         log_debug("%s: lsr-id %s", __func__, inet_ntoa(nbr->id));
 493
 494         nbr_establish_connection(nbr);
 495
 496         return (0);
 497 }
 498
 499 void
 500 nbr_start_idtimer(struct nbr *nbr)
 501 {
 502         int     secs;
 503
 504         secs = INIT_DELAY_TMR;
 505         switch(nbr->idtimer_cnt) {
 506         default:
 507                 /* do not further increase the counter */
 508                 secs = MAX_DELAY_TMR;
 509                 break;
 510         case 2:
 511                 secs *= 2;
 512                 /* FALLTHROUGH */
 513         case 1:
 514                 secs *= 2;
 515                 /* FALLTHROUGH */
 516         case 0:
 517                 nbr->idtimer_cnt++;
 518                 break;
 519         }
 520
 521         THREAD_TIMER_OFF(nbr->initdelay_timer);
 522         nbr->initdelay_timer = NULL;
 523         thread_add_timer(master, nbr_idtimer, nbr, secs,
 524                          &nbr->initdelay_timer);
 525 }
 526
 527 void
 528 nbr_stop_idtimer(struct nbr *nbr)
 529 {
 530         THREAD_TIMER_OFF(nbr->initdelay_timer);
 531 }
 532
 533 int
 534 nbr_pending_idtimer(struct nbr *nbr)
 535 {
 536         return (nbr->initdelay_timer != NULL);
 537 }
 538
 539 int
 540 nbr_pending_connect(struct nbr *nbr)
 541 {
 542         return (nbr->ev_connect != NULL);
 543 }
 544
 545 static int
 546 nbr_connect_cb(struct thread *thread)
 547 {
 548         struct nbr      *nbr = THREAD_ARG(thread);
 549         int              error;
 550         socklen_t        len;
 551
 552         nbr->ev_connect = NULL;
 553
 554         len = sizeof(error);
 555         if (getsockopt(nbr->fd, SOL_SOCKET, SO_ERROR, &error, &len) < 0) {
 556                 log_warn("%s: getsockopt SOL_SOCKET SO_ERROR", __func__);
 557                 return (0);
 558         }
 559
 560         if (error) {
 561                 close(nbr->fd);
 562                 errno = error;
 563                 log_debug("%s: error while connecting to %s: %s", __func__,
 564                     log_addr(nbr->af, &nbr->raddr), strerror(errno));
 565                 return (0);
 566         }
 567
 568         nbr_fsm(nbr, NBR_EVT_CONNECT_UP);
 569
 570         return (0);
 571 }
 572
 573 int
 574 nbr_establish_connection(struct nbr *nbr)
 575 {
 576         struct sockaddr_storage  local_sa;
 577         struct sockaddr_storage  remote_sa;
 578         struct adj              *adj;
 579         struct nbr_params       *nbrp;
 580 #ifdef __OpenBSD__
 581         int                      opt = 1;
 582 #endif
 583
 584         nbr->fd = socket(nbr->af, SOCK_STREAM, 0);
 585         if (nbr->fd == -1) {
 586                 log_warn("%s: error while creating socket", __func__);
 587                 return (-1);
 588         }
 589         sock_set_nonblock(nbr->fd);
 590
 591         nbrp = nbr_params_find(leconf, nbr->id);
 592         if (nbrp && nbrp->auth.method == AUTH_MD5SIG) {
 593 #ifdef __OpenBSD__
 594                 if (sysdep.no_pfkey || sysdep.no_md5sig) {
 595                         log_warnx("md5sig configured but not available");
 596                         close(nbr->fd);
 597                         return (-1);
 598                 }
 599                 if (setsockopt(nbr->fd, IPPROTO_TCP, TCP_MD5SIG,
 600                     &opt, sizeof(opt)) == -1) {
 601                         log_warn("setsockopt md5sig");
 602                         close(nbr->fd);
 603                         return (-1);
 604                 }
 605 #else
 606                 sock_set_md5sig(nbr->fd, nbr->af, &nbr->raddr,
 607                     nbrp->auth.md5key);
 608 #endif
 609         }
 610
 611         memcpy(&local_sa, addr2sa(nbr->af, &nbr->laddr, 0), sizeof(local_sa));
 612         memcpy(&remote_sa, addr2sa(nbr->af, &nbr->raddr, LDP_PORT),
 613             sizeof(local_sa));
 614         if (nbr->af == AF_INET6 && nbr->raddr_scope)
 615                 addscope((struct sockaddr_in6 *)&remote_sa, nbr->raddr_scope);
 616
 617         if (bind(nbr->fd, (struct sockaddr *)&local_sa,
 618             sockaddr_len((struct sockaddr *)&local_sa)) == -1) {
 619                 log_warn("%s: error while binding socket to %s", __func__,
 620                     log_sockaddr((struct sockaddr *)&local_sa));
 621                 close(nbr->fd);
 622                 return (-1);
 623         }
 624
 625         if (nbr_gtsm_check(nbr->fd, nbr, nbrp)) {
 626                 close(nbr->fd);
 627                 return (-1);
 628         }
 629
 630         /*
 631          * Send an extra hello to guarantee that the remote peer has formed
 632          * an adjacency as well.
 633          */
 634         RB_FOREACH(adj, nbr_adj_head, &nbr->adj_tree)
 635                 send_hello(adj->source.type, adj->source.link.ia,
 636                     adj->source.target);
 637
 638         if (connect(nbr->fd, (struct sockaddr *)&remote_sa,
 639             sockaddr_len((struct sockaddr *)&remote_sa)) == -1) {
 640                 if (errno == EINPROGRESS) {
 641                         thread_add_write(master, nbr_connect_cb, nbr, nbr->fd,
 642                                          &nbr->ev_connect);
 643                         return (0);
 644                 }
 645                 log_warn("%s: error while connecting to %s", __func__,
 646                     log_sockaddr((struct sockaddr *)&remote_sa));
 647                 close(nbr->fd);
 648                 return (-1);
 649         }
 650
 651         /* connection completed immediately */
 652         nbr_fsm(nbr, NBR_EVT_CONNECT_UP);
 653
 654         return (0);
 655 }
 656
 657 int
 658 nbr_gtsm_enabled(struct nbr *nbr, struct nbr_params *nbrp)
 659 {
 660         /*
 661          * RFC 6720 - Section 3:
 662          * "This document allows for the implementation to provide an option to
 663          * statically (e.g., via configuration) and/or dynamically override the
 664          * default behavior and enable/disable GTSM on a per-peer basis".
 665          */
 666         if (nbrp && (nbrp->flags & F_NBRP_GTSM))
 667                 return (nbrp->gtsm_enabled);
 668
 669         if ((ldp_af_conf_get(leconf, nbr->af))->flags & F_LDPD_AF_NO_GTSM)
 670                 return (0);
 671
 672         /* By default, GTSM support has to be negotiated for LDPv4 */
 673         if (nbr->af == AF_INET && !(nbr->flags & F_NBR_GTSM_NEGOTIATED))
 674                 return (0);
 675
 676         return (1);
 677 }
 678
 679 int
 680 nbr_gtsm_setup(int fd, int af, struct nbr_params *nbrp)
 681 {
 682         int      ttl = 255;
 683
 684         if (nbrp && (nbrp->flags & F_NBRP_GTSM_HOPS))
 685                 ttl = 256 - nbrp->gtsm_hops;
 686
 687         switch (af) {
 688         case AF_INET:
 689                 if (sock_set_ipv4_minttl(fd, ttl) == -1)
 690                         return (-1);
 691                 ttl = 255;
 692                 if (sock_set_ipv4_ucast_ttl(fd, ttl) == -1)
 693                         return (-1);
 694                 break;
 695         case AF_INET6:
 696                 /* ignore any possible error */
 697                 sock_set_ipv6_minhopcount(fd, ttl);
 698                 ttl = 255;
 699                 if (sock_set_ipv6_ucast_hops(fd, ttl) == -1)
 700                         return (-1);
 701                 break;
 702         default:
 703                 fatalx("nbr_gtsm_setup: unknown af");
 704         }
 705
 706         return (0);
 707 }
 708
 709 int
 710 nbr_gtsm_check(int fd, struct nbr *nbr, struct nbr_params *nbrp)
 711 {
 712         if (!nbr_gtsm_enabled(nbr, nbrp)) {
 713                 switch (nbr->af) {
 714                 case AF_INET:
 715                         sock_set_ipv4_ucast_ttl(fd, -1);
 716                         break;
 717                 case AF_INET6:
 718                         /*
 719                          * Send packets with a Hop Limit of 255 even when GSTM
 720                          * is disabled to guarantee interoperability.
 721                          */
 722                         sock_set_ipv6_ucast_hops(fd, 255);
 723                         break;
 724                 default:
 725                         fatalx("nbr_gtsm_check: unknown af");
 726                         break;
 727                 }
 728                 return (0);
 729         }
 730
 731         if (nbr_gtsm_setup(fd, nbr->af, nbrp) == -1) {
 732                 log_warnx("%s: error enabling GTSM for lsr-id %s", __func__,
 733                     inet_ntoa(nbr->id));
 734                 return (-1);
 735         }
 736
 737         return (0);
 738 }
 739
 740 static int
 741 nbr_act_session_operational(struct nbr *nbr)
 742 {
 743         struct lde_nbr   lde_nbr;
 744
 745         nbr->idtimer_cnt = 0;
 746
 747         /* this is necessary to avoid ipc synchronization issues */
 748         nbr_update_peerid(nbr);
 749
 750         memset(&lde_nbr, 0, sizeof(lde_nbr));
 751         lde_nbr.id = nbr->id;
 752         lde_nbr.v4_enabled = nbr->v4_enabled;
 753         lde_nbr.v6_enabled = nbr->v6_enabled;
 754         lde_nbr.flags = nbr->flags;
 755         return (ldpe_imsg_compose_lde(IMSG_NEIGHBOR_UP, nbr->peerid, 0,
 756             &lde_nbr, sizeof(lde_nbr)));
 757 }
 758
 759 static void
 760 nbr_send_labelmappings(struct nbr *nbr)
 761 {
 762         ldpe_imsg_compose_lde(IMSG_LABEL_MAPPING_FULL, nbr->peerid, 0,
 763             NULL, 0);
 764 }
 765
 766 static __inline int
 767 nbr_params_compare(struct nbr_params *a, struct nbr_params *b)
 768 {
 769         return (ntohl(a->lsr_id.s_addr) - ntohl(b->lsr_id.s_addr));
 770 }
 771
 772 struct nbr_params *
 773 nbr_params_new(struct in_addr lsr_id)
 774 {
 775         struct nbr_params       *nbrp;
 776
 777         if ((nbrp = calloc(1, sizeof(*nbrp))) == NULL)
 778                 fatal(__func__);
 779
 780         nbrp->lsr_id = lsr_id;
 781         nbrp->auth.method = AUTH_NONE;
 782
 783         return (nbrp);
 784 }
 785
 786 struct nbr_params *
 787 nbr_params_find(struct ldpd_conf *xconf, struct in_addr lsr_id)
 788 {
 789         struct nbr_params        nbrp;
 790         nbrp.lsr_id = lsr_id;
 791         return (RB_FIND(nbrp_head, &xconf->nbrp_tree, &nbrp));
 792 }
 793
 794 uint16_t
 795 nbr_get_keepalive(int af, struct in_addr lsr_id)
 796 {
 797         struct nbr_params       *nbrp;
 798
 799         nbrp = nbr_params_find(leconf, lsr_id);
 800         if (nbrp && (nbrp->flags & F_NBRP_KEEPALIVE))
 801                 return (nbrp->keepalive);
 802
 803         return ((ldp_af_conf_get(leconf, af))->keepalive);
 804 }
 805
 806 struct ctl_nbr *
 807 nbr_to_ctl(struct nbr *nbr)
 808 {
 809         static struct ctl_nbr    nctl;
 810         struct timeval           now;
 811
 812         nctl.af = nbr->af;
 813         nctl.id = nbr->id;
 814         nctl.laddr = nbr->laddr;
 815         nctl.lport = nbr->tcp->lport;
 816         nctl.raddr = nbr->raddr;
 817         nctl.rport = nbr->tcp->rport;
 818         nctl.auth_method = nbr->auth.method;
 819         nctl.holdtime = nbr->keepalive;
 820         nctl.nbr_state = nbr->state;
 821         nctl.stats = nbr->stats;
 822         nctl.flags = nbr->flags;
 823
 824         gettimeofday(&now, NULL);
 825         if (nbr->state == NBR_STA_OPER) {
 826                 nctl.uptime = now.tv_sec - nbr->uptime;
 827         } else
 828                 nctl.uptime = 0;
 829
 830         return (&nctl);
 831 }
 832
 833 void
 834 nbr_clear_ctl(struct ctl_nbr *nctl)
 835 {
 836         struct nbr              *nbr;
 837
 838         RB_FOREACH(nbr, nbr_addr_head, &nbrs_by_addr) {
 839                 if (ldp_addrisset(nctl->af, &nctl->raddr) &&
 840                     ldp_addrcmp(nctl->af, &nctl->raddr, &nbr->raddr))
 841                         continue;
 842
 843                 log_debug("%s: neighbor %s manually cleared", __func__,
 844                     log_addr(nbr->af, &nbr->raddr));
 845                 session_shutdown(nbr, S_SHUTDOWN, 0, 0);
 846         }
 847 }