ldp/ldp_state_funcs.c

   1
   2 /*
   3  *  Copyright (C) James R. Leu 2000
   4  *  jleu@mindspring.com
   5  *
   6  *  This software is covered under the LGPL, for more
   7  *  info check out http://www.gnu.org/copyleft/lgpl.html
   8  */
   9
  10 #include <sys/socket.h>
  11 #include "ldp_struct.h"
  12 #include "ldp_global.h"
  13 #include "ldp_session.h"
  14 #include "ldp_entity.h"
  15 #include "ldp_fec.h"
  16 #include "ldp_adj.h"
  17 #include "ldp_attr.h"
  18 #include "ldp_mesg.h"
  19 #include "ldp_hello.h"
  20 #include "ldp_init.h"
  21 #include "ldp_label_rel_with.h"
  22 #include "ldp_label_mapping.h"
  23 #include "ldp_label_request.h"
  24 #include "ldp_addr.h"
  25 #include "ldp_keepalive.h"
  26 #include "ldp_label_request.h"
  27 #include "ldp_label_mapping.h"
  28 #include "ldp_notif.h"
  29 #include "ldp_label_abort.h"
  30 #include "ldp_inet_addr.h"
  31
  32 #include "mpls_assert.h"
  33 #include "mpls_tree_impl.h"
  34 #include "mpls_trace_impl.h"
  35 #include "mpls_socket_impl.h"
  36
  37 mpls_return_enum ldp_state_new_adjacency(ldp_global * g, ldp_session * s,
  38   ldp_adj * a, ldp_entity * e, uint32_t event, ldp_mesg * msg, mpls_dest * from)
  39 {
  40   mpls_inet_addr traddr, lsraddr, *addr;
  41   ldp_adj *local_a = NULL;
  42   int labelspace;
  43   int hellotime;
  44   int request = 0;
  45   int target = 0;
  46   uint32_t csn = 0;
  47   mpls_return_enum retval = MPLS_FAILURE;
  48
  49   MPLS_ASSERT(msg && e);
  50
  51   LDP_ENTER(g->user_data, "ldp_state_new_adjacency");
  52
  53   ldp_mesg_hdr_get_labelspace(msg, &labelspace);
  54   ldp_mesg_hdr_get_lsraddr(msg, &lsraddr);
  55   ldp_mesg_hello_get_hellotime(msg, &hellotime);
  56   ldp_mesg_hello_get_request(msg, &request);
  57   ldp_mesg_hello_get_targeted(msg, &target);
  58   ldp_mesg_hello_get_csn(msg, &csn);
  59
  60   if (ldp_mesg_hello_get_traddr(msg, &traddr) == MPLS_FAILURE) {
  61     addr = NULL;
  62   } else {
  63     addr = &traddr;
  64   }
  65
  66   e->mesg_rx++;
  67
  68   if ((local_a = ldp_adj_create(&from->addr, &lsraddr, labelspace,
  69     hellotime, addr, csn)) == NULL) {
  70     goto ldp_state_new_adjacency_end;
  71   }
  72   ldp_entity_add_adj(e, local_a);
  73   _ldp_global_add_adj(g, local_a);
  74   if (ldp_hello_process(g, local_a, e, hellotime, csn, addr, target,
  75     request) != MPLS_SUCCESS) {
  76     /* this can fail if we could not create an active session, or
  77      * we're getting errored hellos,
  78      * if this fails then undo the e<->a linking (which will delete a) */
  79     ldp_entity_del_adj(e, local_a);
  80     _ldp_global_del_adj(g, local_a);
  81   } else if (ldp_adj_startup(g, local_a, request) != MPLS_SUCCESS) {
  82     /* the only way this fail is if a timer could not be created
  83      * if this fails then undo the e<->a linking (which will delete a) */
  84     ldp_entity_del_adj(e, local_a);
  85     _ldp_global_del_adj(g, local_a);
  86   } else {
  87     /* by this time, we will have a e<->a binding, and some timers,
  88      * if we're active, there will also be an active session */
  89     retval = MPLS_SUCCESS;
  90   }
  91
  92 ldp_state_new_adjacency_end:
  93
  94   LDP_EXIT(g->user_data, "ldp_state_new_adjacency");
  95   return retval;
  96 }
  97
  98 mpls_return_enum ldp_state_maintainance(ldp_global * g, ldp_session * s,
  99   ldp_adj * a, ldp_entity * e, uint32_t event, ldp_mesg * msg, mpls_dest * from)
 100 {
 101   mpls_inet_addr traddr, *addr;
 102   int hellotime;
 103   int request = 0;
 104   int target = 0;
 105   uint32_t csn = 0;
 106   mpls_return_enum retval = MPLS_SUCCESS;
 107
 108   MPLS_ASSERT(msg && e);
 109
 110   LDP_ENTER(g->user_data, "ldp_state_maintainance");
 111
 112   if (ldp_mesg_hello_get_hellotime(msg, &hellotime) != MPLS_SUCCESS) {
 113     retval = MPLS_FAILURE;
 114     goto ldp_state_maintainance_end;
 115   }
 116
 117   ldp_mesg_hello_get_request(msg, &request);
 118   ldp_mesg_hello_get_targeted(msg, &target);
 119   /* if there isn't a csn in the msg, then csn stays 0 */
 120   ldp_mesg_hello_get_csn(msg, &csn);
 121   if (ldp_mesg_hello_get_traddr(msg, &traddr) != MPLS_SUCCESS) {
 122     addr = NULL;
 123   } else {
 124     addr = &traddr;
 125   }
 126
 127   if (ldp_hello_process(g, a, e, hellotime, csn, addr, target,
 128       request) != MPLS_SUCCESS) {
 129     retval = MPLS_FAILURE;
 130     goto ldp_state_maintainance_end;
 131   }
 132   retval = ldp_adj_maintain_timer(g, a);
 133   e->mesg_rx++;
 134
 135 ldp_state_maintainance_end:
 136
 137   LDP_EXIT(g->user_data, "ldp_state_maintainance");
 138
 139   return retval;
 140 }
 141
 142 mpls_return_enum ldp_state_recv_init(ldp_global * g, ldp_session * s,
 143   ldp_adj * a, ldp_entity * e, uint32_t event, ldp_mesg * msg, mpls_dest * from)
 144 {
 145   mpls_inet_addr lsraddr;
 146   ldp_adj* ap;
 147   int labelspace = 0;
 148   mpls_bool match = MPLS_BOOL_FALSE;
 149
 150   MPLS_ASSERT(msg && s);
 151
 152   LDP_ENTER(g->user_data, "ldp_state_recv_init");
 153
 154   /* we haven't tied this session to an adj yet, at a minimum we can
 155    * now stop the backoff timer we started while waiting for this
 156    * init to arrive */
 157   ldp_session_backoff_stop(g, s);
 158
 159   ldp_mesg_hdr_get_lsraddr(msg, &lsraddr);
 160   ldp_mesg_hdr_get_labelspace(msg, &labelspace);
 161
 162   if (s->oper_role != LDP_ACTIVE) {
 163     /* sessions being created from the ACTIVE side of an ADJ have already
 164      * bound to the session */
 165     /* there may be multiple ADJ that are matched! */
 166     ap = MPLS_LIST_HEAD(&g->adj);
 167     while (ap != NULL) {
 168       if ((!mpls_inet_addr_compare(&lsraddr, &ap->remote_lsr_address)) &&
 169         labelspace == ap->remote_label_space && !ap->session) {
 170         ldp_adj_add_session(ap, s);
 171         match = MPLS_BOOL_TRUE;
 172       }
 173       ap = MPLS_LIST_NEXT(&g->adj, ap, _global);
 174     }
 175
 176     if (match == MPLS_BOOL_FALSE) {
 177       LDP_PRINT(g->user_data, "ldp_state_recv_init: cannot find adj\n");
 178       s->shutdown_notif = LDP_NOTIF_SESSION_REJECTED_NO_HELLO;
 179       s->shutdown_fatal = MPLS_BOOL_FALSE;
 180       goto ldp_state_recv_init_shutdown;
 181     }
 182   }
 183
 184   if (ldp_init_process(g, s, msg) == MPLS_FAILURE) {
 185     LDP_PRINT(g->user_data, "ldp_state_recv_init: invalid INIT parameters\n");
 186     /* session shutdown notif info set inside init_process */
 187     goto ldp_state_recv_init_shutdown;
 188   }
 189
 190   s->state = LDP_STATE_OPENREC;
 191   LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_DEBUG,
 192     "ldp_state_recv_init: (%d) changed to OPENREC\n", s->index);
 193
 194   if (s->oper_role == LDP_PASSIVE) {
 195     if (ldp_init_send(g, s) == MPLS_FAILURE) {
 196       LDP_PRINT(g->user_data, "ldp_state_recv_init: unable to send INIT\n");
 197       s->shutdown_notif = LDP_NOTIF_INTERNAL_ERROR;
 198       s->shutdown_fatal = MPLS_BOOL_TRUE;
 199       goto ldp_state_recv_init_shutdown;
 200     }
 201   }
 202   ldp_keepalive_send(g, s);
 203
 204   LDP_EXIT(g->user_data, "ldp_state_recv_init");
 205   return MPLS_SUCCESS;
 206
 207 ldp_state_recv_init_shutdown:
 208
 209   LDP_EXIT(g->user_data, "ldp_state_recv_init-error");
 210   return MPLS_FAILURE;
 211 }
 212
 213 mpls_return_enum ldp_state_connect(ldp_global * g, ldp_session * s, ldp_adj * a,
 214   ldp_entity * e, uint32_t event, ldp_mesg * msg, mpls_dest * from)
 215 {
 216   mpls_return_enum retval = MPLS_SUCCESS;
 217
 218   LDP_ENTER(g->user_data, "ldp_state_connect");
 219
 220   mpls_socket_readlist_add(g->socket_handle, s->socket, (void *)s,
 221     MPLS_SOCKET_TCP_DATA);
 222   s->state = LDP_STATE_INITIALIZED;
 223   LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_DEBUG,
 224     "ldp_state_connect: (%d) changed to INITIALIZED\n", s->index);
 225
 226   /* even though as part of creating an active session, the remote_dest
 227    * was filled in, it had port 646 specified. 'from' now contains the
 228    * real port info that our TCP session is connected to */
 229   if (from) {
 230     memcpy(&s->remote_dest, from, sizeof(mpls_dest));
 231   }
 232
 233   if (s->oper_role == LDP_ACTIVE) {
 234     if (ldp_init_send(g, s) == MPLS_SUCCESS) {
 235       s->state = LDP_STATE_OPENSENT;
 236       LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_DEBUG,
 237         "ldp_state_connect: (%d) changed to OPENSENT\n", s->index);
 238     } else {
 239       s->shutdown_notif = LDP_NOTIF_INTERNAL_ERROR;
 240       s->shutdown_fatal = MPLS_BOOL_TRUE;
 241       retval = MPLS_FAILURE;
 242     }
 243   } else {
 244     /* if this session is passive, we still are not associated with an
 245      * adj.  That will happen when we receive an init. There are no timers
 246      * running yet, so we need to create a timer, to clean this socket
 247      * up, if we do not receive a Init mesg, we'll overload the backoff
 248      * timer for this purpose */
 249     retval = ldp_session_backoff_start(g, s);
 250   }
 251
 252   LDP_EXIT(g->user_data, "ldp_state_connect");
 253
 254   return retval;
 255 }
 256
 257 mpls_return_enum ldp_state_finish_init(ldp_global * g, ldp_session * s,
 258   ldp_adj * a, ldp_entity * e, uint32_t event, ldp_mesg * msg, mpls_dest * from)
 259 {
 260   mpls_return_enum retval;
 261   MPLS_ASSERT(s);
 262
 263   LDP_ENTER(g->user_data, "ldp_state_finish_init");
 264
 265   retval = ldp_session_startup(g, s);
 266
 267   LDP_EXIT(g->user_data, "ldp_state_finish_init");
 268
 269   return MPLS_SUCCESS;
 270 }
 271
 272 mpls_return_enum ldp_state_process(ldp_global * g, ldp_session * s, ldp_adj * a,
 273   ldp_entity * e, uint32_t event, ldp_mesg * msg, mpls_dest * from)
 274 {
 275   mpls_return_enum retval = MPLS_SUCCESS;
 276   ldp_attr *r_attr;
 277   mpls_fec fec;
 278   int i;
 279
 280   MPLS_ASSERT(s && msg);
 281
 282   LDP_ENTER(g->user_data, "ldp_state_process");
 283
 284   switch (msg->u.generic.flags.flags.msgType) {
 285     case MPLS_LBLWITH_MSGTYPE:
 286       {
 287         mplsLdpLbl_W_R_Msg_t *rw = &msg->u.release;
 288         ldp_fec *f;
 289
 290         for (i = 0; i < rw->fecTlv.numberFecElements; i++) {
 291           fec_tlv2mpls_fec(&rw->fecTlv, i, &fec);
 292           if (!(r_attr = ldp_attr_create(g, &fec))) {
 293             goto ldp_state_process_error;
 294           }
 295
 296           MPLS_REFCNT_HOLD(r_attr);
 297
 298           rel_with2attr(rw, r_attr);
 299           f = ldp_fec_find2(g, &fec);
 300           MPLS_REFCNT_HOLD(f);
 301
 302           retval = ldp_label_withdraw_process(g, s, a, e, r_attr, f);
 303
 304           MPLS_REFCNT_RELEASE2(g, f, ldp_fec_delete);
 305           MPLS_REFCNT_RELEASE2(g, r_attr, ldp_attr_delete);
 306           if (retval != MPLS_SUCCESS)
 307             break;
 308         }
 309         break;
 310       }
 311     case MPLS_LBLREL_MSGTYPE:
 312       {
 313         mplsLdpLbl_W_R_Msg_t *rw = &msg->u.release;
 314         ldp_fec *f;
 315
 316         for (i = 0; i < rw->fecTlv.numberFecElements; i++) {
 317           fec_tlv2mpls_fec(&rw->fecTlv, i, &fec);
 318           if (!(r_attr = ldp_attr_create(g, &fec))) {
 319             goto ldp_state_process_error;
 320           }
 321
 322           MPLS_REFCNT_HOLD(r_attr);
 323
 324           rel_with2attr(rw, r_attr);
 325           f = ldp_fec_find2(g, &fec);
 326           MPLS_REFCNT_HOLD(f);
 327
 328           retval = ldp_label_release_process(g, s, a, e, r_attr, f);
 329
 330           MPLS_REFCNT_RELEASE2(g, f, ldp_fec_delete);
 331           MPLS_REFCNT_RELEASE2(g, r_attr, ldp_attr_delete);
 332           if (retval != MPLS_SUCCESS)
 333             break;
 334         }
 335         break;
 336       }
 337     case MPLS_LBLREQ_MSGTYPE:
 338       {
 339         mplsLdpLblReqMsg_t *req = &msg->u.request;
 340         ldp_fec *f;
 341
 342         MPLS_ASSERT(req->fecTlv.numberFecElements == 1);
 343
 344         for (i = 0; i < req->fecTlv.numberFecElements; i++) {
 345           fec_tlv2mpls_fec(&req->fecTlv, i, &fec);
 346           if (!(r_attr = ldp_attr_create(g, &fec))) {
 347             goto ldp_state_process_error;
 348           }
 349
 350           MPLS_REFCNT_HOLD(r_attr);
 351
 352           req2attr(req, r_attr, LDP_ATTR_ALL & ~LDP_ATTR_FEC);
 353           f = ldp_fec_find2(g, &fec);
 354           MPLS_REFCNT_HOLD(f);
 355
 356           retval = ldp_label_request_process(g, s, a, e, r_attr, f);
 357
 358           MPLS_REFCNT_RELEASE2(g, f, ldp_fec_delete);
 359           MPLS_REFCNT_RELEASE2(g, r_attr, ldp_attr_delete);
 360           if (retval != MPLS_SUCCESS)
 361             break;
 362         }
 363         break;
 364       }
 365     case MPLS_LBLMAP_MSGTYPE:
 366       {
 367         mplsLdpLblMapMsg_t *map = &msg->u.map;
 368         ldp_fec *f;
 369
 370         for (i = 0; i < map->fecTlv.numberFecElements; i++) {
 371           fec_tlv2mpls_fec(&map->fecTlv, i, &fec);
 372           if (!(r_attr = ldp_attr_create(g, &fec))) {
 373             goto ldp_state_process_error;
 374           }
 375
 376           MPLS_REFCNT_HOLD(r_attr);
 377
 378           map2attr(map, r_attr, LDP_ATTR_ALL & ~LDP_ATTR_FEC);
 379           f = ldp_fec_find2(g, &fec);
 380           MPLS_REFCNT_HOLD(f);
 381
 382           retval = ldp_label_mapping_process(g, s, a, e, r_attr, f);
 383
 384           MPLS_REFCNT_RELEASE2(g, f, ldp_fec_delete);
 385           MPLS_REFCNT_RELEASE2(g, r_attr, ldp_attr_delete);
 386           if (retval != MPLS_SUCCESS)
 387             break;
 388         }
 389         break;
 390       }
 391     case MPLS_LBLABORT_MSGTYPE:
 392       {
 393         mplsLdpLblAbortMsg_t *abrt = &msg->u.abort;
 394         ldp_fec *f;
 395
 396         for (i = 0; i < abrt->fecTlv.numberFecElements; i++) {
 397           fec_tlv2mpls_fec(&abrt->fecTlv, i, &fec);
 398           if (!(r_attr = ldp_attr_create(g, &fec))) {
 399             goto ldp_state_process_error;
 400           }
 401
 402           MPLS_REFCNT_HOLD(r_attr);
 403
 404           abort2attr(abrt, r_attr, LDP_ATTR_ALL & ~LDP_ATTR_FEC);
 405           f = ldp_fec_find2(g, &fec);
 406           MPLS_REFCNT_HOLD(f);
 407
 408           retval = ldp_label_abort_process(g, s, a, e, r_attr, f);
 409
 410           MPLS_REFCNT_RELEASE2(g, f, ldp_fec_delete);
 411           MPLS_REFCNT_RELEASE2(g, r_attr, ldp_attr_delete);
 412           if (retval != MPLS_SUCCESS)
 413             break;
 414         }
 415         break;
 416       }
 417     case MPLS_ADDRWITH_MSGTYPE:
 418     case MPLS_ADDR_MSGTYPE:
 419       {
 420         retval = ldp_addr_process(g, s, e, msg);
 421         break;
 422       }
 423     default:
 424       {
 425         MPLS_ASSERT(0);
 426         break;
 427       }
 428   }
 429
 430   LDP_EXIT(g->user_data, "ldp_state_process");
 431
 432   return retval;
 433
 434 ldp_state_process_error:
 435
 436   LDP_EXIT(g->user_data, "ldp_state_process");
 437
 438   s->shutdown_notif = LDP_NOTIF_INTERNAL_ERROR;
 439   s->shutdown_fatal = MPLS_BOOL_TRUE;
 440   return MPLS_FAILURE;
 441 }
 442
 443 mpls_return_enum ldp_state_ignore(ldp_global * g, ldp_session * session,
 444   ldp_adj * adj, ldp_entity * entity, uint32_t event, ldp_mesg * msg,
 445   mpls_dest * from)
 446 {
 447   return MPLS_SUCCESS;
 448 }
 449
 450 mpls_return_enum ldp_state_close(ldp_global * g, ldp_session * s, ldp_adj * a,
 451   ldp_entity * e, uint32_t event, ldp_mesg * msg, mpls_dest * from)
 452 {
 453
 454   LDP_ENTER(g->user_data, "ldp_state_close: a = %p, e = %p s = %p",a,e,s);
 455
 456   /* JLEU: this need more work */
 457   if (s) {
 458     /* not sure why we got here but we should tear it completely down */
 459     if (s->shutdown_fatal != MPLS_BOOL_TRUE) {
 460       ldp_notif_send(g,s,NULL,s->shutdown_notif);
 461     }
 462     ldp_session_shutdown(g, s, MPLS_BOOL_TRUE);
 463   }
 464
 465   LDP_EXIT(g->user_data, "ldp_state_close");
 466   return MPLS_SUCCESS;
 467 }
 468
 469 mpls_return_enum ldp_state_keepalive_maintainance(ldp_global * g,
 470   ldp_session * s, ldp_adj * a, ldp_entity * e, uint32_t event, ldp_mesg * msg,
 471   mpls_dest * from)
 472 {
 473   mpls_return_enum result;
 474
 475   MPLS_ASSERT(s);
 476
 477   LDP_ENTER(g->user_data, "ldp_state_keepalive_maintainance");
 478   result = ldp_session_maintain_timer(g, s, LDP_KEEPALIVE_RECV);
 479
 480   LDP_EXIT(g->user_data, "ldp_state_keepalive_maintainance");
 481
 482   return result;
 483 }
 484
 485 mpls_return_enum ldp_state_notif(ldp_global * g, ldp_session * s, ldp_adj * adj,
 486   ldp_entity * entity, uint32_t event, ldp_mesg * msg, mpls_dest * from)
 487 {
 488
 489   mpls_return_enum retval = MPLS_SUCCESS;
 490   ldp_attr *r_attr = NULL;
 491   mplsLdpNotifMsg_t *not = &msg->u.notif;
 492
 493   MPLS_ASSERT(s && msg);
 494
 495   LDP_ENTER(g->user_data, "ldp_state_notif");
 496
 497   if (!(r_attr = ldp_attr_create(g, NULL))) {
 498     retval = MPLS_FAILURE;
 499     goto ldp_state_notif_end;
 500   }
 501
 502   MPLS_REFCNT_HOLD(r_attr);
 503
 504   not2attr(not, r_attr, LDP_ATTR_ALL);
 505   retval = ldp_notif_process(g, s, adj, entity, r_attr);
 506
 507   MPLS_REFCNT_RELEASE2(g, r_attr, ldp_attr_delete);
 508
 509 ldp_state_notif_end:
 510
 511   LDP_EXIT(g->user_data, "ldp_state_notif");
 512
 513   return retval;
 514 }