ldp/ldp_if.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 <stdlib.h>
  11 #include <netinet/in.h>
  12 #include <sys/socket.h>
  13 #include "ldp_struct.h"
  14 #include "ldp_global.h"
  15 #include "ldp_entity.h"
  16 #include "ldp_nexthop.h"
  17 #include "ldp_nortel.h"
  18 #include "ldp_addr.h"
  19 #include "ldp_if.h"
  20 #include "ldp_fec.h"
  21 #include "ldp_mesg.h"
  22 #include "ldp_buf.h"
  23 #include "ldp_hello.h"
  24
  25 #include "mpls_assert.h"
  26 #include "mpls_mm_impl.h"
  27 #include "mpls_compare.h"
  28 #include "mpls_socket_impl.h"
  29 #include "mpls_timer_impl.h"
  30 #include "mpls_ifmgr_impl.h"
  31 #include "mpls_trace_impl.h"
  32
  33 extern uint32_t _ldp_sub_entity_next_index;
  34
  35 ldp_if *ldp_if_create(ldp_global *g)
  36 {
  37   ldp_if *i = (ldp_if *) mpls_malloc(sizeof(ldp_if));
  38
  39   if (i) {
  40     memset(i, 0, sizeof(ldp_if));
  41     /*
  42      * note: this is init to 1 for a reason!
  43      * We're placing it in the global list, so this is our refcnt
  44      * when this refcnt gets to zero, it will be removed from the
  45      * global list and deleted
  46      */
  47     /*
  48      * TESTING: jleu 6/7/2004, since I want the iff to be cleaned up
  49      * when it no longer has a nexthop, fec, or label, the only things that
  50      * should increment the ref are those (nh, fec, label etc), not global
  51      * nor inserting into the tree.
  52     MPLS_REFCNT_INIT(i, 1);
  53      */
  54     MPLS_LIST_ELEM_INIT(i, _global);
  55     MPLS_LIST_INIT(&i->nh_root, ldp_nexthop);
  56     MPLS_LIST_INIT(&i->addr_root, ldp_addr);
  57     i->label_space = -1;
  58     i->dest.addr.type = MPLS_FAMILY_IPV4;
  59     i->dest.addr.u.ipv4 = INADDR_ALLRTRS_GROUP;
  60     i->tx_buffer = ldp_buf_create(MPLS_PDUMAXLEN);
  61     i->tx_message = ldp_mesg_create();
  62     i->index = _ldp_if_get_next_index();
  63     i->oper_state = MPLS_OPER_DOWN;
  64     i->is_p2p = MPLS_BOOL_FALSE;
  65     _ldp_global_add_if(g, i);
  66   }
  67   return i;
  68 }
  69
  70 void ldp_if_delete(ldp_global *g, ldp_if * i)
  71 {
  72   fprintf(stderr, "if delete: %p\n", i);
  73   MPLS_REFCNT_ASSERT(i, 0);
  74   mpls_free(i->tx_buffer);
  75   mpls_free(i->tx_message);
  76   i->tx_buffer = NULL;
  77   i->tx_message = NULL;
  78   _ldp_global_del_if(g, i);
  79   mpls_free(i);
  80 }
  81
  82 /*
  83  * ldp_if_insert and ldp_if_remove should ONLY be used in conjuction with
  84  * adding and removing nexthops (or fecs).
  85  */
  86
  87 ldp_if *ldp_if_insert(ldp_global *g, mpls_if_handle handle)
  88 {
  89   ldp_if *iff = NULL;
  90
  91   MPLS_ASSERT(g);
  92   MPLS_ASSERT(mpls_if_handle_verify(g->ifmgr_handle, handle) == MPLS_BOOL_TRUE);
  93
  94   if ((iff = ldp_if_create(g)) == NULL) {
  95     LDP_PRINT(g->user_data,"ldp_if_insert: unable to alloc ldp_if\n");
  96     return NULL;
  97   }
  98   iff->handle = handle;
  99   return iff;
 100 }
 101
 102 #if 0
 103 void ldp_if_remove(ldp_global *g, ldp_if *iff)
 104 {
 105   MPLS_ASSERT(g && iff);
 106   MPLS_REFCNT_RELEASE2(g, iff, ldp_if_delete);
 107 }
 108 #endif
 109
 110 void ldp_if_add_nexthop(ldp_if * i, ldp_nexthop * n)
 111 {
 112   ldp_nexthop *np = NULL;
 113
 114   MPLS_ASSERT(i && n);
 115   MPLS_REFCNT_HOLD(n);
 116
 117   ldp_nexthop_add_if(n,i);
 118
 119   np = MPLS_LIST_HEAD(&i->nh_root);
 120   while (np != NULL) {
 121     if (np->index > n->index) {
 122        MPLS_LIST_INSERT_BEFORE(&i->nh_root, np, n, _if);
 123        return;
 124     }
 125     np = MPLS_LIST_NEXT(&i->nh_root, np, _if);
 126   }
 127   MPLS_LIST_ADD_TAIL(&i->nh_root, n, _if, ldp_nexthop);
 128 }
 129
 130 void ldp_if_del_nexthop(ldp_global *g, ldp_if * i, ldp_nexthop * n)
 131 {
 132   MPLS_ASSERT(i && n);
 133   MPLS_LIST_REMOVE(&i->nh_root, n, _if);
 134   ldp_nexthop_del_if(g, n);
 135   MPLS_REFCNT_RELEASE2(g, n, ldp_nexthop_delete);
 136 }
 137
 138 void ldp_if_add_addr(ldp_if * i, ldp_addr * a)
 139 {
 140   ldp_addr *ap = NULL;
 141
 142   MPLS_ASSERT(i && a);
 143   MPLS_REFCNT_HOLD(a);
 144
 145   ldp_addr_add_if(a,i);
 146
 147   ap = MPLS_LIST_HEAD(&i->addr_root);
 148   while (ap != NULL) {
 149     if (ap->index > a->index) {
 150        MPLS_LIST_INSERT_BEFORE(&i->addr_root, ap, a, _if);
 151        return;
 152     }
 153     ap = MPLS_LIST_NEXT(&i->addr_root, ap, _if);
 154   }
 155   MPLS_LIST_ADD_TAIL(&i->addr_root, a, _if, ldp_addr);
 156 }
 157
 158 void ldp_if_del_addr(ldp_global *g, ldp_if * i, ldp_addr * a)
 159 {
 160   MPLS_ASSERT(i && a);
 161   MPLS_LIST_REMOVE(&i->addr_root, a, _if);
 162   ldp_addr_del_if(g, a);
 163   MPLS_REFCNT_RELEASE2(g, a, ldp_addr_delete);
 164 }
 165
 166 mpls_return_enum ldp_if_find_addr_index(ldp_if *i, int index, ldp_addr **a)
 167 {
 168   ldp_addr *ap = NULL;
 169
 170   MPLS_ASSERT(i);
 171
 172   if (index > 0) {
 173
 174     /* because we sort our inserts by index, this lets us know
 175        if we've "walked" past the end of the list */
 176
 177     ap = MPLS_LIST_TAIL(&i->addr_root);
 178     if (!ap || ap->index < index) {
 179       *a = NULL;
 180       return MPLS_END_OF_LIST;
 181     }
 182
 183     ap = MPLS_LIST_HEAD(&i->addr_root);
 184     do {
 185       if (ap->index == index) {
 186         *a = ap;
 187         return MPLS_SUCCESS;
 188       }
 189     } while((ap = MPLS_LIST_NEXT(&i->addr_root, ap, _if)));
 190   }
 191   *a = NULL;
 192   return MPLS_FAILURE;
 193 }
 194
 195 ldp_addr *ldp_if_addr_find(ldp_if *i, mpls_inet_addr *a)
 196 {
 197   ldp_addr *ap = NULL;
 198
 199   MPLS_ASSERT(i && a);
 200
 201   ap = MPLS_LIST_HEAD(&i->addr_root);
 202
 203   while(ap) {
 204     if (!mpls_inet_addr_compare(&ap->address, a)) {
 205       return ap;
 206     }
 207     ap = MPLS_LIST_NEXT(&i->addr_root, ap, _if);
 208   }
 209   return NULL;
 210 }
 211
 212 mpls_return_enum ldp_if_startup(ldp_global * g, ldp_if * i)
 213 {
 214   ldp_entity *e = NULL;
 215
 216   LDP_ENTER(g->user_data, "ldp_if_startup");
 217
 218   MPLS_ASSERT(i != NULL);
 219   e = i->entity;
 220   MPLS_ASSERT(e != NULL);
 221   MPLS_ASSERT(e->p.iff != NULL);
 222
 223   if (mpls_socket_multicast_if_join(g->socket_handle, g->hello_socket, i,
 224       &i->dest.addr) == MPLS_FAILURE) {
 225     goto ldp_if_startup_delay;
 226   }
 227
 228   i->dest.port = e->remote_udp_port;
 229   if (ldp_hello_send(g, e) == MPLS_FAILURE) {
 230     ldp_if_shutdown(g, i);
 231     return MPLS_FAILURE;
 232   }
 233   i->oper_state = MPLS_OPER_UP;
 234
 235   LDP_EXIT(g->user_data, "ldp_if_startup");
 236
 237   return MPLS_SUCCESS;
 238
 239 ldp_if_startup_delay:
 240
 241   /*
 242    * when a interface update comes in, it will search the global
 243    * list of interfaces, and start up the interface then
 244    */
 245   i->oper_state = MPLS_OPER_DOWN;
 246
 247   LDP_EXIT(g->user_data, "ldp_if_startup-delayed");
 248
 249   return MPLS_SUCCESS;
 250 }
 251
 252 mpls_return_enum ldp_if_shutdown(ldp_global * g, ldp_if * i)
 253 {
 254   ldp_entity *e = NULL;
 255
 256   MPLS_ASSERT(i != NULL && ((e = i->entity) != NULL));
 257
 258   LDP_ENTER(g->user_data, "ldp_if_shutdown");
 259
 260   i->oper_state = MPLS_OPER_DOWN;
 261
 262   mpls_socket_multicast_if_drop(g->socket_handle, g->hello_socket, i,
 263     &i->dest.addr);
 264
 265   mpls_timer_stop(g->timer_handle, i->hellotime_send_timer);
 266   mpls_timer_delete(g->timer_handle, i->hellotime_send_timer);
 267   i->hellotime_send_timer_duration = 0;
 268   i->hellotime_send_timer = 0;
 269
 270  /*
 271   * jleu: I'm not sure why these were here, I'm commenting them out,
 272   * because I do not see a corresponding HOLD in ldp_if_startup
 273   MPLS_REFCNT_RELEASE(e, ldp_entity_delete);
 274   MPLS_ASSERT(e != NULL);
 275   */
 276
 277   if (i->hello) {
 278     ldp_mesg_delete(i->hello);
 279     i->hello = NULL;
 280   }
 281
 282   LDP_EXIT(g->user_data, "ldp_if_shutdown");
 283
 284   return MPLS_SUCCESS;
 285 }
 286
 287 mpls_bool ldp_if_is_active(ldp_if * i)
 288 {
 289   if (i && i->entity && i->entity->admin_state == MPLS_ADMIN_ENABLE)
 290     return MPLS_BOOL_TRUE;
 291
 292   return MPLS_BOOL_FALSE;
 293 }
 294
 295 mpls_return_enum _ldp_if_add_entity(ldp_if * i, ldp_entity * e)
 296 {
 297   if (i && e) {
 298     MPLS_REFCNT_HOLD(e);
 299     i->entity = e;
 300     return MPLS_SUCCESS;
 301   }
 302   return MPLS_FAILURE;
 303 }
 304
 305 ldp_entity *ldp_if_get_entity(ldp_if * i)
 306 {
 307   return i->entity;
 308 }
 309
 310 mpls_return_enum _ldp_if_del_entity(ldp_if * i)
 311 {
 312   if (i && i->entity) {
 313     MPLS_REFCNT_RELEASE(i->entity, ldp_entity_delete);
 314     i->entity = NULL;
 315     return MPLS_SUCCESS;
 316   }
 317   return MPLS_FAILURE;
 318 }
 319
 320 uint32_t _ldp_if_get_next_index()
 321 {
 322   uint32_t retval = _ldp_sub_entity_next_index;
 323
 324   _ldp_sub_entity_next_index++;
 325   if (retval > _ldp_sub_entity_next_index) {
 326     _ldp_sub_entity_next_index = 1;
 327   }
 328   return retval;
 329 }