lsr/lsr_global.c

   1
   2 /*
   3  *  Copyright (C) James R. Leu 2002
   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 "lsr_struct.h"
  11 #include "lsr_global.h"
  12 #include "lsr_outsegment.h"
  13 #include "lsr_insegment.h"
  14 #include "lsr_xconnect.h"
  15 #include "lsr_ftn.h"
  16 #include "lsr_if.h"
  17
  18 #include "mpls_ifmgr_impl.h"
  19 #include "mpls_mpls_impl.h"
  20 #include "mpls_lock_impl.h"
  21 #include "mpls_mm_impl.h"
  22 #include "mpls_trace_impl.h"
  23
  24 lsr_global *lsr_global_create(mpls_instance_handle data)
  25 {
  26   lsr_global *g = (lsr_global *) mpls_malloc(sizeof(lsr_global));
  27
  28   if (g) {
  29     memset(g, 0, sizeof(lsr_global));
  30
  31     LDP_ENTER(g->user_data, "lsr_global_create");
  32
  33     g->global_lock = mpls_lock_create("_lsr_global_lock_");
  34     mpls_lock_get(g->global_lock);
  35
  36     MPLS_LIST_INIT(&g->outsegment, lsr_outsegment);
  37     MPLS_LIST_INIT(&g->insegment, lsr_insegment);
  38     MPLS_LIST_INIT(&g->xconnect, lsr_xconnect);
  39     MPLS_LIST_INIT(&g->ftn, lsr_ftn);
  40     MPLS_LIST_INIT(&g->iff, lsr_if);
  41
  42     g->admin_state = MPLS_ADMIN_DISABLE;
  43     g->user_data = data;
  44
  45     mpls_lock_release(g->global_lock);
  46
  47     LDP_EXIT(g->user_data, "lsr_global_create");
  48   }
  49
  50   return g;
  51 }
  52
  53 mpls_return_enum lsr_global_startup(lsr_global * g)
  54 {
  55   MPLS_ASSERT(g != NULL);
  56
  57   LDP_ENTER(g->user_data, "lsr_global_startup");
  58
  59   g->ifmgr_handle = mpls_ifmgr_open(g->user_data, g);
  60   if (mpls_ifmgr_handle_verify(g->ifmgr_handle) == MPLS_BOOL_FALSE) {
  61     goto lsr_global_startup_cleanup;
  62   }
  63
  64   g->mpls_handle = mpls_mpls_open(g->user_data);
  65   if (mpls_mpls_handle_verify(g->mpls_handle) == MPLS_BOOL_FALSE) {
  66     goto lsr_global_startup_cleanup;
  67   }
  68
  69   g->admin_state = MPLS_ADMIN_ENABLE;
  70
  71   LDP_EXIT(g->user_data, "lsr_global_startup");
  72   return MPLS_SUCCESS;
  73
  74 lsr_global_startup_cleanup:
  75   lsr_global_shutdown(g);
  76
  77   LDP_EXIT(g->user_data, "lsr_global_startup-error");
  78
  79   return MPLS_FAILURE;
  80 }
  81
  82 mpls_return_enum lsr_global_shutdown(lsr_global * g)
  83 {
  84   MPLS_ASSERT(g);
  85
  86   LDP_ENTER(g->user_data, "lsr_global_shutdown");
  87
  88   g->admin_state = MPLS_ADMIN_DISABLE;
  89
  90   mpls_lock_release(g->global_lock);
  91   mpls_lock_get(g->global_lock);
  92
  93   mpls_ifmgr_close(g->ifmgr_handle);
  94   mpls_mpls_close(g->mpls_handle);
  95
  96   LDP_EXIT(g->user_data, "lsr_global_shutdown");
  97
  98   return MPLS_SUCCESS;
  99 }
 100
 101 mpls_return_enum lsr_global_delete(lsr_global * g)
 102 {
 103   if (g) {
 104     mpls_lock_delete(g->global_lock);
 105     LDP_PRINT(g->user_data, "global delete\n");
 106     mpls_free(g);
 107   }
 108   return MPLS_SUCCESS;
 109 }
 110
 111 /* struct if */
 112
 113 mpls_return_enum _lsr_global_add_if(lsr_global * g, lsr_if * i)
 114 {
 115   lsr_if *ip = NULL;
 116
 117   if (g && i) {
 118     MPLS_REFCNT_HOLD(i);
 119     ip = MPLS_LIST_HEAD(&g->iff);
 120     while (ip != NULL) {
 121       if (ip->index > i->index) {
 122         MPLS_LIST_INSERT_BEFORE(&g->iff, ip, i, _global);
 123         return MPLS_SUCCESS;
 124       }
 125       ip = MPLS_LIST_NEXT(&g->iff, ip, _global);
 126     }
 127     MPLS_LIST_ADD_TAIL(&g->iff, i, _global, lsr_if);
 128     return MPLS_SUCCESS;
 129   }
 130   return MPLS_FAILURE;
 131 }
 132
 133 mpls_return_enum _lsr_global_del_if(lsr_global * g, lsr_if * i)
 134 {
 135   if (g && i) {
 136     MPLS_LIST_REMOVE(&g->iff, i, _global);
 137     MPLS_REFCNT_RELEASE(i, lsr_if_delete);
 138     return MPLS_SUCCESS;
 139   }
 140   return MPLS_FAILURE;
 141 }
 142
 143 mpls_return_enum lsr_global_find_if_index(lsr_global * g, uint32_t index,
 144   lsr_if ** iff)
 145 {
 146   lsr_if *i = NULL;
 147
 148   if (g && index > 0) {
 149
 150     /* because we sort our inserts by index, this lets us know
 151        if we've "walked" past the end of the list */
 152
 153     i = MPLS_LIST_TAIL(&g->iff);
 154     if (i == NULL || i->index < index) {
 155       *iff = NULL;
 156       return MPLS_END_OF_LIST;
 157     }
 158
 159     i = MPLS_LIST_HEAD(&g->iff);
 160     while (i != NULL) {
 161       if (i->index == index) {
 162         *iff = i;
 163         return MPLS_SUCCESS;
 164       }
 165       i = MPLS_LIST_NEXT(&g->iff, i, _global);
 166     }
 167   }
 168   *iff = NULL;
 169   return MPLS_FAILURE;
 170 }
 171
 172 lsr_if * lsr_global_find_if_handle(lsr_global * g, mpls_if_handle ifhandle)
 173 {
 174   lsr_if *i = NULL;
 175
 176   if (g && mpls_if_handle_verify(g->ifmgr_handle, ifhandle) == MPLS_BOOL_TRUE) {
 177     i = MPLS_LIST_HEAD(&g->iff);
 178     while (i != NULL) {
 179       if (!mpls_if_handle_compare(i->handle, ifhandle)) {
 180         return i;
 181       }
 182       i = MPLS_LIST_NEXT(&g->iff, i, _global);
 183     }
 184   }
 185   return NULL;
 186 }
 187
 188 /* struct outsegment */
 189
 190 mpls_return_enum _lsr_global_add_outsegment(lsr_global * g, lsr_outsegment * o)
 191 {
 192   lsr_outsegment *op = NULL;
 193
 194   if (g && o) {
 195     MPLS_REFCNT_HOLD(o);
 196     op = MPLS_LIST_HEAD(&g->outsegment);
 197     while (op != NULL) {
 198       if (op->index > o->index) {
 199         MPLS_LIST_INSERT_BEFORE(&g->outsegment, op, o, _global);
 200         return MPLS_SUCCESS;
 201       }
 202       op = MPLS_LIST_NEXT(&g->outsegment, op, _global);
 203     }
 204     MPLS_LIST_ADD_TAIL(&g->outsegment, o, _global, lsr_outsegment);
 205     return MPLS_SUCCESS;
 206   }
 207   return MPLS_FAILURE;
 208 }
 209
 210 mpls_return_enum _lsr_global_del_outsegment(lsr_global * g, lsr_outsegment * o)
 211 {
 212   if (g && o) {
 213     MPLS_LIST_REMOVE(&g->outsegment, o, _global);
 214     MPLS_REFCNT_RELEASE(o, lsr_outsegment_delete);
 215     return MPLS_SUCCESS;
 216   }
 217   return MPLS_FAILURE;
 218 }
 219
 220 mpls_return_enum lsr_global_find_outsegment_index(lsr_global * g,
 221   uint32_t index, lsr_outsegment ** outsegment)
 222 {
 223   lsr_outsegment *o = NULL;
 224
 225   if (g && index > 0) {
 226
 227     /* because we sort our inserts by index, this lets us know
 228        if we've "walked" past the end of the list */
 229
 230     o = MPLS_LIST_TAIL(&g->outsegment);
 231     if (o == NULL || o->index < index) {
 232       *outsegment = NULL;
 233       return MPLS_END_OF_LIST;
 234     }
 235
 236     o = MPLS_LIST_HEAD(&g->outsegment);
 237     while (o != NULL) {
 238       if (o->index == index) {
 239         *outsegment = o;
 240         return MPLS_SUCCESS;
 241       }
 242       o = MPLS_LIST_NEXT(&g->outsegment, o, _global);
 243     }
 244   }
 245   *outsegment = NULL;
 246   return MPLS_FAILURE;
 247 }
 248
 249 /* struct insegment */
 250
 251 mpls_return_enum _lsr_global_add_insegment(lsr_global * g, lsr_insegment * i)
 252 {
 253   lsr_insegment *ip = NULL;
 254
 255   if (g && i) {
 256     MPLS_REFCNT_HOLD(i);
 257     ip = MPLS_LIST_HEAD(&g->insegment);
 258     while (ip != NULL) {
 259       if (ip->index > i->index) {
 260         MPLS_LIST_INSERT_BEFORE(&g->insegment, ip, i, _global);
 261         return MPLS_SUCCESS;
 262       }
 263       ip = MPLS_LIST_NEXT(&g->insegment, ip, _global);
 264     }
 265     MPLS_LIST_ADD_TAIL(&g->insegment, i, _global, lsr_insegment);
 266     return MPLS_SUCCESS;
 267   }
 268   return MPLS_FAILURE;
 269 }
 270
 271 mpls_return_enum _lsr_global_del_insegment(lsr_global * g, lsr_insegment * i)
 272 {
 273   if (g && i) {
 274     MPLS_LIST_REMOVE(&g->insegment, i, _global);
 275     MPLS_REFCNT_RELEASE(i, lsr_insegment_delete);
 276     return MPLS_SUCCESS;
 277   }
 278   return MPLS_FAILURE;
 279 }
 280
 281 mpls_return_enum lsr_global_find_insegment_index(lsr_global * g,
 282   uint32_t index, lsr_insegment ** insegment)
 283 {
 284   lsr_insegment *i = NULL;
 285
 286   if (g && index > 0) {
 287
 288     /* because we sort our inserts by index, this lets us know
 289        if we've "walked" past the end of the list */
 290
 291     i = MPLS_LIST_TAIL(&g->insegment);
 292     if (i == NULL || i->index < index) {
 293       *insegment = NULL;
 294       return MPLS_END_OF_LIST;
 295     }
 296
 297     i = MPLS_LIST_HEAD(&g->insegment);
 298     while (i != NULL) {
 299       if (i->index == index) {
 300         *insegment = i;
 301         return MPLS_SUCCESS;
 302       }
 303       i = MPLS_LIST_NEXT(&g->insegment, i, _global);
 304     }
 305   }
 306   *insegment = NULL;
 307   return MPLS_FAILURE;
 308 }
 309
 310 /* struct xconnect */
 311
 312 mpls_return_enum _lsr_global_add_xconnect(lsr_global * g, lsr_xconnect * x)
 313 {
 314   lsr_xconnect *xp = NULL;
 315
 316   if (g && x) {
 317     MPLS_REFCNT_HOLD(x);
 318     xp = MPLS_LIST_HEAD(&g->xconnect);
 319     while (xp != NULL) {
 320       if (xp->index > x->index) {
 321         MPLS_LIST_INSERT_BEFORE(&g->xconnect, xp, x, _global);
 322         return MPLS_SUCCESS;
 323       }
 324       xp = MPLS_LIST_NEXT(&g->xconnect, xp, _global);
 325     }
 326     MPLS_LIST_ADD_TAIL(&g->xconnect, x, _global, lsr_xconnect);
 327     return MPLS_SUCCESS;
 328   }
 329   return MPLS_FAILURE;
 330 }
 331
 332 mpls_return_enum _lsr_global_del_xconnect(lsr_global * g, lsr_xconnect * x)
 333 {
 334   if (g && x) {
 335     MPLS_LIST_REMOVE(&g->xconnect, x, _global);
 336     MPLS_REFCNT_RELEASE(x, lsr_xconnect_delete);
 337     return MPLS_SUCCESS;
 338   }
 339   return MPLS_FAILURE;
 340 }
 341
 342 mpls_return_enum lsr_global_find_xconnect_index(lsr_global * g,
 343   uint32_t index, lsr_xconnect ** xconnect)
 344 {
 345   lsr_xconnect *x = NULL;
 346
 347   if (g && index > 0) {
 348
 349     /* because we sort our inserts by index, this lets us know
 350        if we've "walked" past the end of the list */
 351
 352     x = MPLS_LIST_TAIL(&g->xconnect);
 353     if (x == NULL || x->index < index) {
 354       *xconnect = NULL;
 355       return MPLS_END_OF_LIST;
 356     }
 357
 358     x = MPLS_LIST_HEAD(&g->xconnect);
 359     while (x != NULL) {
 360       if (x->index == index) {
 361         *xconnect = x;
 362         return MPLS_SUCCESS;
 363       }
 364       x = MPLS_LIST_NEXT(&g->xconnect, x, _global);
 365     }
 366   }
 367   *xconnect = NULL;
 368   return MPLS_FAILURE;
 369 }
 370
 371 mpls_return_enum lsr_global_find_xconnect_index2(lsr_global * g,
 372   uint32_t in, uint32_t out, lsr_xconnect ** xconnect)
 373 {
 374   lsr_insegment *iseg = NULL;
 375   lsr_xconnect *x = NULL;
 376
 377   if (g && in > 0 && out > 0) {
 378
 379     if (lsr_global_find_insegment_index(g,in,&iseg) != MPLS_SUCCESS) {
 380       return MPLS_FAILURE;
 381     }
 382
 383     x = MPLS_LIST_HEAD(&iseg->xconnect_root);
 384     while (x != NULL) {
 385       if (x->outsegment && x->outsegment->index == out) {
 386         *xconnect = x;
 387         return MPLS_SUCCESS;
 388       }
 389       x = MPLS_LIST_NEXT(&iseg->xconnect_root, x, _insegment);
 390     }
 391   }
 392   *xconnect = NULL;
 393   return MPLS_FAILURE;
 394 }
 395
 396 /* struct ftn */
 397
 398 void _lsr_global_add_ftn(lsr_global * g, lsr_ftn * f)
 399 {
 400   lsr_ftn *fp = NULL;
 401
 402   MPLS_ASSERT(g && f);
 403
 404   MPLS_REFCNT_HOLD(f);
 405   fp = MPLS_LIST_HEAD(&g->ftn);
 406   while (fp != NULL) {
 407     if (fp->index > f->index) {
 408       MPLS_LIST_INSERT_BEFORE(&g->ftn, fp, f, _global);
 409       return;
 410     }
 411     fp = MPLS_LIST_NEXT(&g->ftn, fp, _global);
 412   }
 413   MPLS_LIST_ADD_TAIL(&g->ftn, f, _global, lsr_ftn);
 414 }
 415
 416 void _lsr_global_del_ftn(lsr_global * g, lsr_ftn * f)
 417 {
 418   MPLS_ASSERT(g && f);
 419   MPLS_LIST_REMOVE(&g->ftn, f, _global);
 420   MPLS_REFCNT_RELEASE(f, lsr_ftn_delete);
 421 }
 422
 423 mpls_return_enum lsr_global_find_ftn_index(lsr_global * g,
 424   uint32_t index, lsr_ftn ** ftn)
 425 {
 426   lsr_ftn *f = NULL;
 427
 428   MPLS_ASSERT(g && index > 0);
 429
 430   /* because we sort our inserts by index, this lets us know
 431      if we've "walked" past the end of the list */
 432
 433   f = MPLS_LIST_TAIL(&g->ftn);
 434   if (f == NULL || f->index < index) {
 435     *ftn = NULL;
 436     return MPLS_END_OF_LIST;
 437   }
 438
 439   f = MPLS_LIST_HEAD(&g->ftn);
 440   while (f != NULL) {
 441     if (f->index == index) {
 442       *ftn = f;
 443       return MPLS_SUCCESS;
 444     }
 445     f = MPLS_LIST_NEXT(&g->ftn, f, _global);
 446   }
 447   *ftn = NULL;
 448   return MPLS_FAILURE;
 449 }
 450
 451 mpls_return_enum lsr_global_find_ftn_index2(lsr_global * g,
 452   lsr_ftn * f, lsr_ftn ** ftn)
 453 {
 454   lsr_ftn *fp = NULL;
 455
 456   if (g && f) {
 457     fp = MPLS_LIST_HEAD(&g->ftn);
 458     while (fp != NULL) {
 459       if (fp->outsegment->index == f->outsegment_index) {
 460         if (fp->fec.type == f->fec.type) {
 461           switch(fp->fec.type) {
 462             case MPLS_FEC_PREFIX:
 463               if (fp->fec.u.prefix.network.u.ipv4 == f->fec.u.prefix.network.u.ipv4 &&
 464                 fp->fec.u.prefix.length == f->fec.u.prefix.length) {
 465                 *ftn = fp;
 466                 return MPLS_SUCCESS;
 467               }
 468               break;
 469             case MPLS_FEC_HOST:
 470               if (fp->fec.u.host.u.ipv4 == f->fec.u.host.u.ipv4) {
 471                 *ftn = fp;
 472                 return MPLS_SUCCESS;
 473               }
 474               break;
 475             case MPLS_FEC_L2CC:
 476               if (fp->fec.u.l2cc.connection_id == f->fec.u.l2cc.connection_id &&
 477                 fp->fec.u.l2cc.group_id == f->fec.u.l2cc.group_id &&
 478                 fp->fec.u.l2cc.type == f->fec.u.l2cc.type) {
 479                 *ftn = fp;
 480                 return MPLS_SUCCESS;
 481               }
 482               break;
 483             default:
 484               MPLS_ASSERT(0);
 485           }
 486         }
 487       }
 488       fp = MPLS_LIST_NEXT(&g->ftn, fp, _global);
 489     }
 490   }
 491   *ftn = NULL;
 492   return MPLS_FAILURE;
 493 }