ldp/ldp_label_mapping.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 "ldp_struct.h"
  11 #include "ldp_session.h"
  12 #include "ldp_attr.h"
  13 #include "ldp_fec.h"
  14 #include "ldp_mesg.h"
  15 #include "ldp_notif.h"
  16 #include "ldp_entity.h"
  17 #include "ldp_inlabel.h"
  18 #include "ldp_outlabel.h"
  19 #include "ldp_nexthop.h"
  20 #include "ldp_global.h"
  21 #include "ldp_pdu_setup.h"
  22 #include "ldp_label_rel_with.h"
  23 #include "ldp_label_mapping.h"
  24 #include "ldp_label_request.h"
  25
  26 #include "mpls_timer_impl.h"
  27 #include "mpls_fib_impl.h"
  28 #include "mpls_lock_impl.h"
  29 #include "mpls_tree_impl.h"
  30 #include "mpls_trace_impl.h"
  31 #include "mpls_mm_impl.h"
  32 #include "mpls_policy_impl.h"
  33
  34 #if MPLS_USE_LSR
  35 #include "lsr_cfg.h"
  36 #else
  37 #include "mpls_mpls_impl.h"
  38 #endif
  39
  40 mpls_return_enum ldp_label_mapping_with_xc(ldp_global * g, ldp_session * s,
  41   ldp_fec * f, ldp_attr ** us_attr, ldp_attr * ds_attr)
  42 {
  43   mpls_return_enum result = MPLS_SUCCESS;
  44   mpls_bool propogating = MPLS_BOOL_TRUE;
  45   mpls_bool egress = MPLS_BOOL_TRUE;
  46   mpls_bool created = MPLS_BOOL_FALSE;
  47
  48   MPLS_ASSERT(us_attr);
  49
  50   if (!(*us_attr)) {
  51     if (!((*us_attr) = ldp_attr_create(&f->info))) {
  52       return MPLS_FAILURE;
  53     }
  54     created = MPLS_BOOL_TRUE;
  55   }
  56   if (!ds_attr) {
  57     propogating = MPLS_BOOL_FALSE;
  58     egress = MPLS_BOOL_TRUE;
  59   }
  60
  61   Prepare_Label_Mapping_Attributes(g, s, &f->info, ds_attr, (*us_attr),
  62     propogating, MPLS_BOOL_TRUE, egress);
  63
  64   result = ldp_label_mapping_send(g, s, (*us_attr), ds_attr);
  65   if (result != MPLS_SUCCESS) {
  66     if (created == MPLS_BOOL_TRUE) {
  67       ldp_attr_delete(*us_attr);
  68     }
  69     return result;
  70   }
  71
  72   if (created == MPLS_BOOL_TRUE) {
  73     result = ldp_attr_insert_upstream2(g, s, (*us_attr), f);
  74     if (result != MPLS_SUCCESS) {
  75       ldp_attr_delete(*us_attr);
  76       return result;
  77     }
  78   }
  79
  80   if (ds_attr && ds_attr->outlabel && created == MPLS_BOOL_TRUE) {
  81
  82     LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL,
  83       LDP_TRACE_FLAG_BINDING, "Cross Connect Added\n");
  84
  85     result = ldp_inlabel_add_outlabel(g,(*us_attr)->inlabel,ds_attr->outlabel);
  86     if (result != MPLS_SUCCESS) {
  87       return result;
  88     }
  89   }
  90   return MPLS_SUCCESS;
  91 }
  92
  93 ldp_session *ldp_get_next_hop_session_for_fec2(ldp_fec * f, ldp_nexthop *nh) {
  94   ldp_session *session = NULL;
  95   /*
  96    * find the info about the next hop for this FEC
  97    */
  98   if (nh->addr && nh->addr->session_root.count > 0) {
  99     session = mpls_link_list_head_data(&nh->addr->session_root);
 100   } else if (nh->iff && nh->iff->is_p2p == MPLS_BOOL_TRUE &&
 101     &nh->iff->entity) {
 102     ldp_adj *adj = MPLS_LIST_HEAD(&nh->iff->entity->adj_root);
 103     session = adj ? adj->session : NULL;
 104   }
 105   return session;
 106 }
 107
 108 mpls_return_enum ldp_get_next_hop_session_for_fec(ldp_global * g,
 109   mpls_fec * fec, mpls_nexthop *nh, ldp_session ** next_hop_session)
 110 {
 111   ldp_fec *f = NULL;
 112   ldp_nexthop *n = NULL;
 113
 114   MPLS_ASSERT(next_hop_session);
 115
 116   if (!(f = ldp_fec_find(g, fec))) {
 117     return MPLS_NO_ROUTE;
 118   }
 119
 120   if (!(n = ldp_fec_nexthop_find(f, nh))) {
 121     return MPLS_NO_ROUTE;
 122   }
 123
 124   *next_hop_session = ldp_get_next_hop_session_for_fec2(f,n);
 125   return (*next_hop_session) ? MPLS_SUCCESS : MPLS_FAILURE;
 126 }
 127
 128 mpls_return_enum Check_Received_Attributes(ldp_global * g, ldp_session * s,
 129   ldp_attr * r_attr, uint16_t type)
 130 {
 131   int count = 0;
 132   int i;
 133
 134   if (!r_attr->hopCountTlvExists) { /* CRa.1 */
 135     goto Check_Received_Attributes_5;
 136   }
 137
 138   if (r_attr->hopCountTlv.hcValue >= s->cfg_hop_count_limit) { /* CRa.2 */
 139     LDP_PRINT(g->user_data, "CRa.2\n");
 140     goto Check_Received_Attributes_6;
 141   }
 142
 143   if (!r_attr->pathVecTlvExists) { /* CRa.3 */
 144     goto Check_Received_Attributes_5;
 145   }
 146
 147   for (i = 0; i < MPLS_MAXHOPSNUMBER; i++) { /* CRa.4 */
 148     if (r_attr->pathVecTlv.lsrId[i]) {
 149       count++;
 150       if (r_attr->pathVecTlv.lsrId[i] == g->lsr_identifier.u.ipv4) {
 151         goto Check_Received_Attributes_6;
 152         LDP_PRINT(g->user_data, "CRa.4a\n");
 153       }
 154       if (count > s->oper_path_vector_limit) {
 155         goto Check_Received_Attributes_6;
 156         LDP_PRINT(g->user_data, "CRa.4b\n");
 157       }
 158     }
 159   }
 160
 161 Check_Received_Attributes_5:
 162   return MPLS_SUCCESS;
 163
 164 Check_Received_Attributes_6:
 165   if (type != MPLS_LBLMAP_MSGTYPE) {
 166     ldp_notif_send(g, s, r_attr, LDP_NOTIF_LOOP_DETECTED); /* CRa.7 */
 167   }
 168   return MPLS_FAILURE;           /* CRa.8 */
 169 }
 170
 171 void Prepare_Label_Mapping_Attributes(ldp_global * g, ldp_session * s,
 172   mpls_fec * fec, ldp_attr * r_attr, ldp_attr * s_attr, mpls_bool propogating,
 173   mpls_bool already, mpls_bool egress)
 174 {
 175   ldp_attr dummy;
 176   int i;
 177
 178   /* NOTE: PMpA.21 is the end of the procedure (ie return) */
 179   /* this function uses goto quite extensivly for a REASON!! */
 180   /* Check Appedix A of the LDP draft */
 181
 182   LDP_ENTER(g->user_data, "Prepare_Label_Mapping_Attributes");
 183
 184   if (!r_attr) {
 185     memset(&dummy, 0, sizeof(ldp_attr));
 186     mpls_fec2fec_tlv(fec, &dummy.fecTlv, 0);
 187     dummy.fecTlvExists = 1;
 188     dummy.fecTlv.numberFecElements = 1;
 189     r_attr = &dummy;
 190   }
 191
 192   if (!(s->oper_loop_detection == LDP_LOOP_HOPCOUNT ||
 193     s->oper_loop_detection == LDP_LOOP_HOPCOUNT_PATHVECTOR ||
 194     r_attr->hopCountTlvExists)) { /* PMpA.1 */
 195     LDP_EXIT(g->user_data, "Prepare_Label_Mapping_Attributes");
 196     return;
 197   }
 198
 199   if (egress) {/* PMpA.2 */
 200     /* I'm egress (for now) */
 201     s_attr->hopCountTlvExists = 1;
 202     s_attr->hopCountTlv.hcValue = 1; /* PMpA.3 */
 203     LDP_EXIT(g->user_data, "Prepare_Label_Mapping_Attributes");
 204     return;
 205   }
 206
 207   if (!(r_attr->hopCountTlvExists)) { /* PMpA.4 */
 208     goto Prepare_Label_Mapping_Attributes_8;
 209   }
 210
 211   if (!(g->ttl_less_domain == MPLS_BOOL_TRUE &&
 212     s->cfg_remote_in_ttl_less_domain == MPLS_BOOL_TRUE)) { /* PMpA.5 */
 213     goto Prepare_Label_Mapping_Attributes_7;
 214   }
 215
 216   s_attr->hopCountTlvExists = 1;
 217   s_attr->hopCountTlv.hcValue = 1; /* PMpA.6 */
 218   goto Prepare_Label_Mapping_Attributes_9;
 219
 220 Prepare_Label_Mapping_Attributes_7:
 221   s_attr->hopCountTlvExists = 1;
 222   s_attr->hopCountTlv.hcValue = (r_attr->hopCountTlv.hcValue) ?
 223     (r_attr->hopCountTlv.hcValue + 1) : 0;
 224   goto Prepare_Label_Mapping_Attributes_9;
 225
 226 Prepare_Label_Mapping_Attributes_8:
 227   s_attr->hopCountTlvExists = 1;
 228   s_attr->hopCountTlv.hcValue = 0;
 229
 230 Prepare_Label_Mapping_Attributes_9:
 231   if (s->oper_loop_detection == LDP_LOOP_NONE) {
 232     LDP_EXIT(g->user_data, "Prepare_Label_Mapping_Attributes");
 233     return;
 234   }
 235
 236   if (r_attr->pathVecTlvExists) { /* PMpA.10 */
 237     goto Prepare_Label_Mapping_Attributes_19;
 238   }
 239
 240   if (propogating == MPLS_BOOL_FALSE) { /* PMpA.11 */
 241     goto Prepare_Label_Mapping_Attributes_20;
 242   }
 243
 244   if (g->label_merge != MPLS_BOOL_TRUE) { /* PMpA.12 */
 245     goto Prepare_Label_Mapping_Attributes_14;
 246   }
 247
 248   if (already == MPLS_BOOL_FALSE) {   /* PMpA.13 */
 249     goto Prepare_Label_Mapping_Attributes_20;
 250   }
 251
 252 Prepare_Label_Mapping_Attributes_14:
 253   if (!r_attr->hopCountTlvExists) {
 254     LDP_EXIT(g->user_data, "Prepare_Label_Mapping_Attributes");
 255     return;
 256   }
 257
 258   if (r_attr->hopCountTlv.hcValue == 0) { /* PMpA.15 */
 259     goto Prepare_Label_Mapping_Attributes_20;
 260   }
 261
 262   if (already == MPLS_BOOL_FALSE) {   /* PMpA.16 */
 263     LDP_EXIT(g->user_data, "Prepare_Label_Mapping_Attributes");
 264     return;
 265   }
 266
 267   /* r_attr contain PrevHopCount _IF_ we had one */
 268   LDP_EXIT(g->user_data, "Prepare_Label_Mapping_Attributes");
 269   return;                       /* PMpA.17 */
 270
 271   if (r_attr->hopCountTlv.hcValue != 0) { /* PMpA.18 */
 272     LDP_EXIT(g->user_data, "Prepare_Label_Mapping_Attributes");
 273     return;
 274   }
 275
 276 Prepare_Label_Mapping_Attributes_19:
 277   s_attr->pathVecTlvExists = 1;
 278   s_attr->pathVecTlv.lsrId[0] = g->lsr_identifier.u.ipv4;
 279   for (i = 1; i < (MPLS_MAXHOPSNUMBER - 1); i++) {
 280     if (r_attr->pathVecTlv.lsrId[i - 1]) {
 281       s_attr->pathVecTlv.lsrId[0] = r_attr->pathVecTlv.lsrId[i - 1];
 282     }
 283   }
 284
 285   LDP_EXIT(g->user_data, "Prepare_Label_Mapping_Attributes");
 286   return;
 287
 288 Prepare_Label_Mapping_Attributes_20:
 289   s_attr->pathVecTlvExists = 1;
 290   s_attr->pathVecTlv.lsrId[0] = g->lsr_identifier.u.ipv4;
 291
 292   LDP_EXIT(g->user_data, "Prepare_Label_Mapping_Attributes");
 293   return;
 294 }
 295
 296 void map2attr(mplsLdpLblMapMsg_t * map, ldp_attr * attr, uint32_t flag)
 297 {
 298   attr->msg_id = map->baseMsg.msgId;
 299
 300   if (map->fecTlvExists && flag & LDP_ATTR_FEC) {
 301     memcpy(&attr->fecTlv, &map->fecTlv, sizeof(mplsLdpFecTlv_t));
 302     attr->fecTlvExists = 1;
 303   }
 304   if (map->genLblTlvExists && flag & LDP_ATTR_LABEL) {
 305     memcpy(&attr->genLblTlv, &map->genLblTlv, sizeof(mplsLdpGenLblTlv_t));
 306     attr->genLblTlvExists = 1;
 307   } else if (map->atmLblTlvExists && flag & LDP_ATTR_LABEL) {
 308     memcpy(&attr->atmLblTlv, &map->atmLblTlv, sizeof(mplsLdpAtmLblTlv_t));
 309     attr->atmLblTlvExists = 1;
 310   } else if (map->frLblTlvExists && flag & LDP_ATTR_LABEL) {
 311     memcpy(&attr->frLblTlv, &map->frLblTlv, sizeof(mplsLdpFrLblTlv_t));
 312     attr->frLblTlvExists = 1;
 313   }
 314   if (map->hopCountTlvExists && flag & LDP_ATTR_HOPCOUNT) {
 315     memcpy(&attr->hopCountTlv, &map->hopCountTlv, sizeof(mplsLdpHopTlv_t));
 316     attr->hopCountTlvExists = 1;
 317   }
 318   if (map->pathVecTlvExists && flag & LDP_ATTR_PATH) {
 319     memcpy(&attr->pathVecTlv, &map->pathVecTlv, sizeof(mplsLdpPathTlv_t));
 320     attr->pathVecTlvExists = 1;
 321   }
 322   if (map->lblMsgIdTlvExists && flag & LDP_ATTR_MSGID) {
 323     memcpy(&attr->lblMsgIdTlv, &map->lblMsgIdTlv, sizeof(mplsLdpLblMsgIdTlv_t));
 324     attr->lblMsgIdTlvExists = 1;
 325   }
 326   if (map->lspidTlvExists && flag & LDP_ATTR_LSPID) {
 327     memcpy(&attr->lspidTlv, &map->lspidTlv, sizeof(mplsLdpLspIdTlv_t));
 328     attr->lspidTlvExists = 1;
 329   }
 330   if (map->trafficTlvExists && flag & LDP_ATTR_TRAFFIC) {
 331     memcpy(&attr->trafficTlv, &map->trafficTlv, sizeof(mplsLdpTrafficTlv_t));
 332     attr->trafficTlvExists = 1;
 333   }
 334 }
 335
 336 void attr2map(ldp_attr * attr, mplsLdpLblMapMsg_t * map)
 337 {
 338   if (attr->fecTlvExists) {
 339     memcpy(&map->fecTlv, &attr->fecTlv, sizeof(mplsLdpFecTlv_t));
 340     map->fecTlvExists = 1;
 341   }
 342   if (attr->genLblTlvExists) {
 343     memcpy(&map->genLblTlv, &attr->genLblTlv, sizeof(mplsLdpGenLblTlv_t));
 344     map->genLblTlvExists = 1;
 345   }
 346   if (attr->atmLblTlvExists) {
 347     memcpy(&map->atmLblTlv, &attr->atmLblTlv, sizeof(mplsLdpAtmLblTlv_t));
 348     map->atmLblTlvExists = 1;
 349   }
 350   if (attr->frLblTlvExists) {
 351     memcpy(&map->frLblTlv, &attr->frLblTlv, sizeof(mplsLdpFrLblTlv_t));
 352     map->frLblTlvExists = 1;
 353   }
 354   if (attr->hopCountTlvExists) {
 355     memcpy(&map->hopCountTlv, &attr->hopCountTlv, sizeof(mplsLdpHopTlv_t));
 356     map->hopCountTlvExists = 1;
 357   }
 358   if (attr->pathVecTlvExists) {
 359     memcpy(&map->pathVecTlv, &attr->pathVecTlv, sizeof(mplsLdpPathTlv_t));
 360     map->pathVecTlvExists = 1;
 361   }
 362   if (attr->lblMsgIdTlvExists) {
 363     memcpy(&map->lblMsgIdTlv, &attr->lblMsgIdTlv, sizeof(mplsLdpLblMsgIdTlv_t));
 364     map->lblMsgIdTlvExists = 1;
 365   }
 366   if (attr->lspidTlvExists) {
 367     memcpy(&map->lspidTlv, &attr->lspidTlv, sizeof(mplsLdpLspIdTlv_t));
 368     map->lspidTlvExists = 1;
 369   }
 370   if (attr->trafficTlvExists) {
 371     memcpy(&map->trafficTlv, &attr->trafficTlv, sizeof(mplsLdpTrafficTlv_t));
 372     map->trafficTlvExists = 1;
 373   }
 374 }
 375
 376 void ldp_label_mapping_initial_callback(mpls_timer_handle timer, void *extra,
 377   mpls_cfg_handle handle)
 378 {
 379   ldp_session *s = (ldp_session *) extra;
 380   ldp_global *g = (ldp_global*)handle;
 381   ldp_attr *ds_attr = NULL;
 382   ldp_attr *us_attr = NULL;
 383   ldp_session *nh_session = NULL;
 384   mpls_bool done = MPLS_BOOL_FALSE;
 385   ldp_fec *f;
 386   ldp_nexthop *nh;
 387
 388   LDP_ENTER(g->user_data, "ldp_label_mapping_initial_callback");
 389
 390   LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_TIMER,
 391     "Initial Label Mapping fired: session(%d)\n", s->index);
 392
 393   mpls_lock_get(g->global_lock);
 394
 395   mpls_timer_stop(g->timer_handle, timer);
 396
 397   if ((f = MPLS_LIST_HEAD(&g->fec))) {
 398     do {
 399       if ((nh = MPLS_LIST_HEAD(&f->nh_root))) {
 400         do {
 401           switch (f->info.type) {
 402             case MPLS_FEC_PREFIX:
 403               LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL,
 404                 LDP_TRACE_FLAG_ROUTE, "Processing prefix FEC: %08x/%d ",
 405                 f->info.u.prefix.network.u.ipv4, f->info.u.prefix.length);
 406               break;
 407             case MPLS_FEC_HOST:
 408               LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL,
 409                 LDP_TRACE_FLAG_ROUTE, "Processing host FEC: %08x ",
 410                 f->info.u.host.u.ipv4);
 411               break;
 412             case MPLS_FEC_L2CC:
 413               LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL,
 414                 LDP_TRACE_FLAG_ROUTE, "Processingu L2CC FEC: %d %d %d ",
 415                 f->info.u.l2cc.connection_id, f->info.u.l2cc.group_id,
 416                 f->info.u.l2cc.type);
 417               break;
 418             default:
 419               MPLS_ASSERT(0);
 420           }
 421
 422           if (nh->type & MPLS_NH_IP) {
 423             LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL,
 424               LDP_TRACE_FLAG_ROUTE, "via %08x\n", nh->addr->address.u.ipv4);
 425           }
 426           if (nh->type & MPLS_NH_IF) {
 427             LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL,
 428               LDP_TRACE_FLAG_ROUTE, "via %p\n", nh->iff->handle);
 429           }
 430
 431           /* are we allowed to export this route from the rib */
 432           if (mpls_policy_export_check(g->user_data, &f->info, &nh->info) ==
 433             MPLS_BOOL_FALSE) {
 434             LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL,
 435               LDP_TRACE_FLAG_POLICY, "Rejected by export policy\n");
 436             continue;
 437           }
 438
 439           /* have we already sent a mapping for this fec to the new session? */
 440           if ((us_attr = ldp_attr_find_upstream_state2(g, s, f,
 441             LDP_LSP_STATE_MAP_SENT))) {
 442             /* no need to sent another mapping */
 443             LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL,
 444               LDP_TRACE_FLAG_ROUTE, "Already sent this FEC to session %d\n",
 445               s->index);
 446             continue;
 447           }
 448
 449           if (!(nh_session = ldp_get_next_hop_session_for_fec2(f,nh))) {
 450             ds_attr = NULL;
 451           } else {
 452             if (nh_session->index == s->index) {
 453               LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL,
 454                 LDP_TRACE_FLAG_ROUTE, "Nexthop session(%d) == session(%d)\n",
 455                 nh_session->index, s->index);
 456               continue;
 457             }
 458             ds_attr = ldp_attr_find_downstream_state2(g, nh_session, f,
 459               LDP_LSP_STATE_MAP_RECV);
 460           }
 461
 462           if ((g->label_merge != MPLS_BOOL_TRUE) &&
 463             ldp_attr_num_us2ds(ds_attr)) {
 464             /* we have a ds label, but can't use it */
 465             ds_attr = NULL;
 466           }
 467
 468           us_attr = NULL;
 469           if (ds_attr) {
 470             /* we can use it, merge on baby */
 471             ldp_label_mapping_with_xc(g, s, f, &us_attr, ds_attr);
 472           } else {
 473             /* we don't have a ds label */
 474
 475             /* we will be egress? */
 476             if (g->lsp_control_mode == LDP_CONTROL_ORDERED) {
 477               if (mpls_policy_egress_check(g->user_data, &f->info,
 478                 &nh->info) == MPLS_BOOL_TRUE) {
 479                 ldp_label_mapping_with_xc(g, s, f, &us_attr, NULL);
 480               }
 481             } else {
 482               ldp_label_mapping_with_xc(g, s, f, &us_attr, NULL);
 483             }
 484           }
 485         } while ((nh = MPLS_LIST_NEXT(&f->nh_root, nh, _fec)));
 486       }
 487     } while ((f = MPLS_LIST_NEXT(&g->fec, f, _global)));
 488     done = MPLS_BOOL_TRUE;
 489   }
 490
 491   done = MPLS_BOOL_TRUE;
 492
 493   if (done == MPLS_BOOL_TRUE) {
 494     mpls_timer_delete(g->timer_handle, timer);
 495     MPLS_REFCNT_RELEASE(s, ldp_session_delete);
 496     s->initial_distribution_timer = (mpls_timer_handle) 0;
 497   } else {
 498     mpls_timer_start(g->timer_handle, timer, MPLS_TIMER_ONESHOT);
 499     /* need to mark the session with where it left off */
 500   }
 501
 502   mpls_lock_release(g->global_lock);
 503
 504   LDP_EXIT(g->user_data, "ldp_label_mapping_initial_callback");
 505 }
 506
 507 mpls_return_enum ldp_label_mapping_send(ldp_global * g, ldp_session * s,
 508   ldp_attr * us_attr, ldp_attr * ds_attr)
 509 {
 510   ldp_inlabel *in = NULL;
 511   ldp_attr *us_temp;
 512
 513   LDP_ENTER(g->user_data, "ldp_label_mapping_send");
 514   MPLS_ASSERT(us_attr);
 515
 516   if ((in = ldp_inlabel_create_complete(g, s, us_attr)) == NULL) { /* SL.1-3 */
 517     goto Send_Label_9;
 518   }
 519
 520   LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_BINDING,
 521     "In Label Added\n");
 522
 523   us_attr->state = LDP_LSP_STATE_MAP_SENT;
 524
 525   us_attr->msg_id = g->message_identifier;
 526   ldp_label_mapping_prepare_msg(s->tx_message, g->message_identifier++,
 527     us_attr);
 528
 529   if (ldp_mesg_send_tcp(g, s, s->tx_message) != MPLS_SUCCESS) { /* SL.4 */
 530     LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_SEND, LDP_TRACE_FLAG_ERROR,
 531       "Failed sending Label Mapping to %s\n",
 532       s->session_name);
 533     goto ldp_label_mapping_send_error;
 534   }
 535
 536   ldp_attr_add_us2ds(us_attr, ds_attr);
 537
 538   LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_SEND, LDP_TRACE_FLAG_LABEL,
 539     "Label Mapping Sent to %s for %08x/%d\n",
 540     s->session_name,
 541     us_attr->fecTlv.fecElArray[0].addressEl.address,
 542     us_attr->fecTlv.fecElArray[0].addressEl.preLen);
 543
 544   us_attr->state = LDP_LSP_STATE_MAP_SENT; /* SL.6,7 */
 545
 546   LDP_EXIT(g->user_data, "ldp_label_mapping_send");
 547   return MPLS_SUCCESS;           /* SL.8 */
 548
 549 Send_Label_9:
 550   LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_STATE,
 551     "No Label Resources\n");
 552
 553   while ((us_temp = ldp_attr_find_upstream_state2(g, s, us_attr->fec,
 554         LDP_LSP_STATE_REQ_RECV)) != NULL) { /* SL.9 */
 555     ldp_notif_send(g, s, us_temp, LDP_NOTIF_NO_LABEL_RESOURCES_AVAILABLE);
 556     /* SL.10 */
 557     s->no_label_resource_sent = MPLS_BOOL_TRUE; /* SL.12 */
 558     us_temp->state = LDP_LSP_STATE_NO_LABEL_RESOURCE_SENT; /* SL.13 */
 559   }
 560
 561   LDP_EXIT(g->user_data, "ldp_label_mapping_send");
 562
 563   return MPLS_SUCCESS;
 564
 565 ldp_label_mapping_send_error:
 566
 567   LDP_EXIT(g->user_data, "ldp_label_mapping_send-error");
 568   return MPLS_FAILURE;
 569 }
 570
 571 void ldp_label_mapping_prepare_msg(ldp_mesg * msg, uint32_t msgid,
 572   ldp_attr * s_attr)
 573 {
 574   mplsLdpLblMapMsg_t *map = NULL;
 575   int i;
 576
 577   MPLS_ASSERT(msg);
 578
 579   ldp_mesg_prepare(msg, MPLS_LBLMAP_MSGTYPE, msgid);
 580   map = &msg->u.map;
 581
 582   if (s_attr->fecTlvExists) {
 583     /* JLEU: only 1 FEC is allowed!! */
 584     map->fecTlvExists = 1;
 585     map->baseMsg.msgLength += setupFecTlv(&map->fecTlv);
 586     map->baseMsg.msgLength += addFecElem2FecTlv(&map->fecTlv,
 587       &s_attr->fecTlv.fecElArray[0]);
 588   }
 589   if (s_attr->genLblTlvExists) {
 590     map->genLblTlvExists = 1;
 591     map->baseMsg.msgLength += setupGenLblTlv(&map->genLblTlv,
 592       s_attr->genLblTlv.label);
 593   }
 594   if (s_attr->atmLblTlvExists) {
 595     map->atmLblTlvExists = 1;
 596     map->baseMsg.msgLength += setupAtmLblTlv(&map->atmLblTlv, 0, 0,
 597       s_attr->atmLblTlv.flags.flags.vpi, s_attr->atmLblTlv.vci);
 598   }
 599   if (s_attr->frLblTlvExists) {
 600     map->frLblTlvExists = 1;
 601     map->baseMsg.msgLength += setupFrLblTlv(&map->frLblTlv, 0,
 602       s_attr->frLblTlv.flags.flags.len, s_attr->frLblTlv.flags.flags.dlci);
 603   }
 604   if (s_attr->hopCountTlvExists) {
 605     map->hopCountTlvExists = 1;
 606     map->baseMsg.msgLength += setupHopCountTlv(&map->hopCountTlv,
 607       s_attr->hopCountTlv.hcValue);
 608   }
 609   if (s_attr->pathVecTlvExists) {
 610     map->pathVecTlvExists = 1;
 611     map->baseMsg.msgLength += setupPathTlv(&map->pathVecTlv);
 612     for (i = 0; i < MPLS_MAXHOPSNUMBER; i++) {
 613       if (s_attr->pathVecTlv.lsrId[i]) {
 614         map->baseMsg.msgLength += addLsrId2PathTlv(&map->pathVecTlv,
 615           s_attr->pathVecTlv.lsrId[i]);
 616       }
 617     }
 618   }
 619 #if 0
 620   if (s_attr->lblMsgIdTlvExists) {
 621   }
 622   if (s_attr->lspidTlvExists) {
 623   }
 624   if (s_attr->trafficTlvExists) {
 625   }
 626 #endif
 627 }
 628
 629 mpls_return_enum ldp_label_mapping_process(ldp_global * g, ldp_session * s,
 630   ldp_adj * a, ldp_entity * e, ldp_attr * r_attr, ldp_fec * f)
 631 {
 632   mpls_return_enum retval = MPLS_SUCCESS;
 633   ldp_session *peer = NULL;
 634   ldp_attr_list *us_list = NULL;
 635   ldp_attr_list *ds_list = NULL;
 636   ldp_attr *ds_attr = NULL;
 637   ldp_attr *ds_temp = NULL;
 638   ldp_attr *us_attr = NULL;
 639   ldp_attr *us_temp = NULL;
 640   ldp_attr dumb_attr;
 641   ldp_nexthop *nh = NULL;
 642
 643   ldp_outlabel *out = NULL;
 644   mpls_bool requested = MPLS_BOOL_FALSE;
 645   ldp_attr *existing = NULL;
 646   mpls_bool need_request = MPLS_BOOL_FALSE;
 647
 648   LDP_ENTER(g->user_data, "ldp_label_mapping_process");
 649
 650   LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_RECV, LDP_TRACE_FLAG_LABEL,
 651     "Label Mapping Recv from %s for %08x/%d\n",
 652     s->session_name,
 653     r_attr->fecTlv.fecElArray[0].addressEl.address,
 654     r_attr->fecTlv.fecElArray[0].addressEl.preLen);
 655
 656   if ((ds_attr = ldp_attr_find_downstream_state2(g, s, f,
 657         LDP_LSP_STATE_REQ_SENT)) != NULL) { /* LMp.1 */
 658     /* just remove the req from the tree, we will use the r_attr sent to us */
 659     ldp_attr_delete_downstream(g, s, ds_attr);
 660     requested = MPLS_BOOL_TRUE;
 661   } else {
 662     requested = MPLS_BOOL_FALSE;
 663   }
 664
 665   ds_attr = r_attr;
 666   ds_attr->state = LDP_LSP_STATE_MAP_RECV; /* LMp.2 */
 667
 668   /*
 669    * ds_attr is the mapping we will keep and is NOT in the tree, unless
 670    * it is an update mapping ...
 671    */
 672   if (Check_Received_Attributes(g, s, ds_attr, MPLS_LBLMAP_MSGTYPE) ==
 673     MPLS_SUCCESS) { /* LMp.3 */
 674     goto LMp_9;
 675   }
 676
 677   /*
 678    * A loop was detected
 679    */
 680   if ((ds_list = ldp_attr_find_downstream_all2(g, s, f))) {
 681     ds_temp = MPLS_LIST_HEAD(ds_list);
 682     /*
 683      * check all the labels this session has received from "s" for "fec"
 684      * do we have a duplicat?
 685      */
 686     while (ds_temp) {
 687       if ((ds_temp->state == LDP_LSP_STATE_MAP_RECV) && /* LMp.4 */
 688         ldp_attr_is_equal(ds_temp, ds_attr, LDP_ATTR_LABEL) == /* LMp.5 */
 689         MPLS_BOOL_TRUE) {
 690         /* remove record of the label and remove it switching */
 691         ldp_attr_remove_complete(g, ds_temp, MPLS_BOOL_TRUE); /* LMp.6,7 */
 692         /*
 693          * I think this is supposed to be 32 NOT 33, we need to release
 694          * it don't we?
 695          */
 696         goto LMp_33;
 697       }
 698       ds_temp = MPLS_LIST_NEXT(ds_list, ds_temp, _fs);
 699     }
 700   }
 701
 702   LDP_PRINT(g->user_data, "Receive_Label_Map_8: send release");
 703   if (ldp_label_release_send(g, s, ds_attr, LDP_NOTIF_LOOP_DETECTED) !=
 704     MPLS_SUCCESS) { /* LMp.8 */
 705     retval = MPLS_FAILURE;
 706   }
 707   goto LMp_33;
 708
 709 LMp_9:
 710   /*
 711    * No Loop Detected
 712    */
 713   ds_temp = ldp_attr_find_downstream_state2(g, s, f, LDP_LSP_STATE_MAP_RECV);
 714   if (requested == MPLS_BOOL_TRUE ||
 715       g->label_merge == MPLS_BOOL_FALSE || !ds_temp) {
 716     /* !merging then this is always a new LSP
 717      * merging w/o a recv'd mapping is a new LSP
 718      * this check comes from Note 6
 719      */
 720     goto LMp_11;
 721   }
 722
 723   /* searching all recv'd attrs for matched mappings,
 724    * stop after finding 1st match
 725    */
 726   if ((ds_list = ldp_attr_find_downstream_all2(g, s, f))) {
 727     ds_temp = MPLS_LIST_HEAD(ds_list);
 728     while (ds_temp) {
 729       if (ds_temp->state == LDP_LSP_STATE_MAP_RECV) { /* LMp.9 */
 730         if (ldp_attr_is_equal(ds_attr, ds_temp, LDP_ATTR_LABEL) ==
 731           MPLS_BOOL_TRUE) { /* LMp.10 */
 732           /*
 733            * this mapping matches an existing mapping, but it
 734            * could contain updated attributes
 735            */
 736           existing = ds_temp;
 737           break;
 738         } else {
 739           /*
 740            * we have been given another label for the same FEC and we
 741            * didn't request it, release it
 742            */
 743           LDP_PRINT(g->user_data, "LMp.10 dup without req\n");
 744           goto LMp_32;
 745         }
 746       }
 747       ds_temp = MPLS_LIST_NEXT(ds_list, ds_temp, _fs);
 748     }
 749   }
 750   if (existing) {
 751     ldp_attr2ldp_attr(ds_attr, existing, LDP_ATTR_HOPCOUNT | LDP_ATTR_PATH |
 752       LDP_ATTR_MSGID | LDP_ATTR_LSPID | LDP_ATTR_TRAFFIC);
 753     ds_attr = existing;
 754     /*
 755      * no need to free ds_attr, since it was not added to the tree it
 756      * will be deleted when we exit ldp_label_mapping_process(), see
 757      * ldp_state_process().
 758      */
 759   }
 760   /*
 761    * from this point on.... if this is an updated mapping then ds_attr
 762    * is the existing mapping which has now been update, else ds_attr
 763    * is the new mapping
 764    */
 765
 766 LMp_11:
 767   /*
 768    * existing ONLY has a value for updated label mapping
 769    */
 770   nh = ldp_nexthop_for_fec_session(f,s);                         /* LMp.11 */
 771
 772   /*
 773    * the following departs from the procedure, it allows for filtering
 774    * of label mappings
 775    *
 776    * Are we configured to accept and INSTALL this mapping?
 777    */
 778   if (mpls_policy_import_check(g->user_data, &f->info, &nh->info) ==
 779     MPLS_BOOL_FALSE) {
 780     /*
 781      * policy has rejected it, store it away
 782      */
 783     if (existing) {
 784       ds_attr->filtered = MPLS_BOOL_TRUE;
 785       if (ds_attr->outlabel && ds_attr->outlabel->switching == MPLS_BOOL_TRUE) {
 786         /* the mapping has been filtered, but the original wasn't? */
 787         MPLS_ASSERT(0);
 788       }
 789     } else {
 790       ds_attr->filtered = MPLS_BOOL_TRUE;
 791       if (ldp_attr_insert_downstream(g, s, ds_attr) != MPLS_SUCCESS) {
 792         retval = MPLS_FAILURE;
 793       }
 794     }
 795     goto LMp_33;
 796   }
 797
 798   if (!nh) {                                                     /* LMp.12 */
 799     /*
 800      * if we did not find a nh hop for this FEC that corresponded to the
 801      * MsgSource then the MsgSource is not a nexthop for the FEC
 802      */
 803     if (g->label_retention_mode == LDP_RETENTION_CONSERVATIVE) { /* LMp.13C */
 804       LDP_PRINT(g->user_data, "LMp.13C conservative\n");
 805       goto LMp_32;
 806     }
 807
 808     /*
 809      * store it away
 810      */
 811     LDP_PRINT(g->user_data, "index: %3d %08x/%d %d\n", ds_attr->index,
 812       ds_attr->fecTlv.fecElArray[0].addressEl.address,
 813       ds_attr->fecTlv.fecElArray[0].addressEl.preLen, ds_attr->state);
 814
 815     if (!existing) {
 816       /* LMp.13L */
 817       if (ldp_attr_insert_downstream(g, s, ds_attr) != MPLS_SUCCESS) {
 818         retval = MPLS_FAILURE;
 819       }
 820     }
 821     goto LMp_33;
 822   }
 823
 824   /*
 825    * this is slightly different form the procedure, we can still be
 826    * transit for a FEC we are not configured to be ingress for.
 827    * Either way we only need to do the "install for fwd/switching"
 828    * only once.  We could arrive here multiple times due to updates,
 829    * only install it the first time
 830    */
 831   if ((!existing) || (!existing->outlabel)) {
 832     /*
 833      * we haven't installed it yet.
 834      * Either new (!existing), or a result of a "Detect FEC Nexthop Change"
 835      * and we had this mapping in our database (!existing->outlabel))
 836      */
 837
 838     if (!(out = ldp_outlabel_create_complete(g, s, ds_attr, nh))) {
 839       LDP_PRINT(g->user_data, "LMp.15 failure creating outlabel\n");
 840       goto LMp_32;
 841     }
 842
 843     LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_BINDING,
 844       "Out Label Added\n");
 845   }
 846
 847   /*
 848    * are we configured to act as ingress for this FEC?
 849    */
 850   if (mpls_policy_ingress_check(g->user_data, &f->info, &nh->info) ==
 851     MPLS_BOOL_TRUE) { /* LMp.14 */
 852     /*
 853      * yep, bind the label to the FEC
 854      */
 855     if (ds_attr->ingress != MPLS_BOOL_TRUE) {
 856 #if MPLS_USE_LSR
 857       lsr_ftn ftn;
 858       ftn.outsegment_index = ds_attr->outlabel->info.handle;
 859       memcpy(&ftn.fec, &f->info, sizeof(mpls_fec));
 860       lsr_cfg_ftn_set2(g->lsr_handle, &ftn, LSR_CFG_ADD|LSR_FTN_CFG_FEC|
 861         LSR_FTN_CFG_OUTSEGMENT);
 862 #else
 863       mpls_mpls_fec2out_add(g->mpls_handle, &f->info, &ds_attr->outlabel->info);
 864 #endif
 865       ds_attr->ingress = MPLS_BOOL_TRUE;
 866       ds_attr->outlabel->merge_count++;
 867       LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_ALL, LDP_TRACE_FLAG_BINDING,
 868         "FEC Binding Added\n");
 869     }
 870   }
 871
 872   /* create a set of attrs that we will fill and compare against
 873    * if this mapping were to be propogate these are the attrs it would have
 874    * by comparing what we did sent in the past to these, we con figure out
 875    * if we need to send an updated mapping
 876    */
 877   memset(&dumb_attr, 0, sizeof(ldp_attr));
 878   mpls_fec2fec_tlv(&f->info, &dumb_attr.fecTlv, 0);
 879   dumb_attr.fecTlvExists = 1;
 880   dumb_attr.fecTlv.numberFecElements = 1;
 881
 882   /*
 883    * by definition (we received a label mapping that will be used) this
 884    * LSR is _not_ the egress, so calculate a hop and path based on the
 885    * mapping we received.  We will compare this with mapping that have
 886    * already been sent.  If they differ, we will send an updated mapping
 887    */
 888   Prepare_Label_Mapping_Attributes(g, s, &f->info, ds_attr, &dumb_attr,
 889     MPLS_BOOL_TRUE, MPLS_BOOL_TRUE, MPLS_BOOL_FALSE);
 890
 891   if (!existing) {
 892     /*
 893      * this is the first time we've seen this mapping, add it to the database.
 894      * all future updates will modify this entry in place
 895      */
 896     /* LMp.16 */
 897     if (ldp_attr_insert_downstream(g, s, ds_attr) != MPLS_SUCCESS) {
 898       retval = MPLS_FAILURE;
 899       goto LMp_33;
 900     }
 901   }
 902
 903   peer = MPLS_LIST_HEAD(&g->session);
 904   while (peer) {                                        /* LMp.17 */
 905
 906     if (peer->state != LDP_STATE_OPERATIONAL) {
 907       goto next_peer;
 908     }
 909
 910     /*
 911      * it is just as easy to walk the list of all upstream attr for this
 912      * peer as it is to the individual check to see if we have sent a
 913      * label mapping for this FEC LSP
 914      */
 915
 916     /* LMp.22 - 27 */
 917     if ((us_list = ldp_attr_find_upstream_all2(g, peer, f))) {  /* LMp.23 */
 918       us_temp = MPLS_LIST_HEAD(us_list);
 919       while (us_temp) {
 920         /*
 921          * if we have sent a label mapping for the FEC and that label mapping
 922          * was an done in independent mode or it is part of an existing
 923          * recieved label mapping
 924          */
 925         /* LMp.18 */
 926         if ((us_temp->state == LDP_LSP_STATE_MAP_SENT) &&
 927           ((!existing) || (existing->index == us_temp->ds_attr->index))) {
 928           /* are the recieved attrs the same as the ones we've already sent */
 929           if (ldp_attr_is_equal(us_temp, &dumb_attr,
 930               LDP_ATTR_HOPCOUNT | LDP_ATTR_PATH) != MPLS_BOOL_TRUE) {
 931             /* send an updated label mapping */
 932             if (ldp_label_mapping_with_xc(g, us_temp->session, f, &us_temp,
 933                 ds_attr) != MPLS_SUCCESS) {                     /* LMp.24-26 */
 934               retval = MPLS_FAILURE;
 935               goto LMp_33;
 936             }
 937           }
 938         }
 939         us_temp = MPLS_LIST_NEXT(us_list, us_temp, _fs);
 940       }
 941     }
 942
 943     if ((peer->oper_distribution_mode == LDP_DISTRIBUTION_UNSOLICITED) &&
 944       (g->lsp_control_mode == LDP_CONTROL_ORDERED)) { /* LMp.19 */
 945
 946       /*
 947        * if we're not merging and we have multiple ORDERED DU sessions,
 948        * we will to start requesting labels after we propogate the mapping to
 949        * the first peer
 950        */
 951       if (need_request == MPLS_BOOL_TRUE) {
 952         if (ldp_attr_find_downstream_state2(g, peer, f,
 953             LDP_LSP_STATE_REQ_SENT) == NULL) {
 954           /*
 955            * we don't have a request for FEC to peer outstanding, make one
 956            */
 957           ds_temp = NULL;
 958           if (ldp_label_request_for_xc(g, peer, &f->info, NULL, &ds_temp) !=
 959             MPLS_SUCCESS) {
 960             retval = MPLS_FAILURE;
 961             goto LMp_33;
 962           }
 963         }
 964       } else {
 965         /*
 966          * We're in DU more, either we're merging, or we're not merging and
 967          * this is the first peer we're propogating this mapping to
 968          */
 969         /* LMp.20-21,30 */
 970         us_attr = NULL;
 971         if (ldp_label_mapping_with_xc(g, peer, f, &us_attr, ds_attr) !=
 972           MPLS_SUCCESS) {
 973           retval = MPLS_FAILURE;
 974           goto LMp_33;
 975         }
 976         /*
 977          * if we're not merging, we will need to request a label for
 978          * the next DU peer
 979          */
 980         if (g->label_merge == MPLS_BOOL_FALSE) {
 981           need_request = MPLS_BOOL_TRUE;
 982         }
 983       }
 984     }
 985
 986     /* LMp.28 */
 987     while ((us_temp = ldp_attr_find_upstream_state2(g, peer, f,
 988       LDP_LSP_STATE_REQ_RECV))) {
 989
 990       if (peer->oper_distribution_mode == LDP_DISTRIBUTION_UNSOLICITED) {
 991         if (need_request == MPLS_BOOL_TRUE) {
 992           if (ldp_attr_find_downstream_state2(g, peer, f,
 993             LDP_LSP_STATE_REQ_SENT) == NULL) {
 994             /*
 995              * we don't have a request for FEC to peer outstanding
 996              */
 997             ds_temp = NULL;
 998             if (ldp_label_request_for_xc(g, peer, &f->info, us_temp,
 999                 &ds_temp) != MPLS_SUCCESS) {
1000               retval = MPLS_FAILURE;
1001               goto LMp_33;
1002             }
1003           }
1004         } else {
1005           if (ldp_label_mapping_with_xc(g, peer, f, &us_temp,
1006             ds_attr) != MPLS_SUCCESS) {
1007             retval = MPLS_FAILURE;
1008             goto LMp_33;
1009           }
1010         }
1011       } else {
1012         if ((us_list = ldp_attr_find_upstream_all2(g, peer, f))) {
1013           us_temp = MPLS_LIST_HEAD(ds_list);
1014           while (us_temp) {
1015             if (us_temp->state == LDP_LSP_STATE_REQ_RECV) {
1016               if (need_request == MPLS_BOOL_TRUE) {
1017                 if (ldp_attr_find_downstream_state2(g, peer, f,
1018                   LDP_LSP_STATE_REQ_SENT) == NULL) {
1019                   /*
1020                    * we don't have a request for FEC to peer outstanding
1021                    */
1022                   ds_temp = NULL;
1023                   if (ldp_label_request_for_xc(g, peer, &f->info, us_temp,
1024                       &ds_temp) != MPLS_SUCCESS) {
1025                     retval = MPLS_FAILURE;
1026                     goto LMp_33;
1027                   }
1028                 }
1029               } else {
1030                 if (ldp_label_mapping_with_xc(g, peer, f, &us_temp,
1031                     ds_attr) != MPLS_SUCCESS) {
1032                   retval = MPLS_FAILURE;
1033                   goto LMp_33;
1034                 }
1035                 /*
1036                  * if we're not merging, we will need to request a label for
1037                  * the next DU peer
1038                  */
1039                 if (g->label_merge == MPLS_BOOL_FALSE) {
1040                   need_request = MPLS_BOOL_TRUE;
1041                 }
1042               }
1043             }
1044             us_temp = MPLS_LIST_NEXT(us_list, us_temp, _fs);
1045           }
1046         }
1047       }
1048     }
1049
1050   next_peer:
1051     peer = MPLS_LIST_NEXT(&g->session, peer, _global);
1052   }
1053
1054 LMp_33:
1055   LDP_EXIT(g->user_data, "ldp_label_mapping_process");
1056   return retval;
1057
1058 LMp_32:
1059   LDP_PRINT(g->user_data, "Receive_Label_Map_32: send release");
1060   if (ldp_label_release_send(g, s, ds_attr, LDP_NOTIF_NONE) != MPLS_SUCCESS) {
1061     retval = MPLS_FAILURE;
1062   }
1063   LDP_EXIT(g->user_data, "ldp_label_mapping_process");
1064   return retval;
1065 }