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