ldp/ldp_addr.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 <string.h>
  12 #include <sys/socket.h>
  13 #include "ldp_struct.h"
  14 #include "ldp_global.h"
  15 #include "ldp_session.h"
  16 #include "ldp_entity.h"
  17 #include "ldp_pdu_setup.h"
  18 #include "ldp_addr.h"
  19 #include "ldp_nexthop.h"
  20 #include "ldp_if.h"
  21 #include "ldp_buf.h"
  22 #include "ldp_mesg.h"
  23 #include "mpls_list.h"
  24 #include "mpls_ifmgr_impl.h"
  25 #include "mpls_mm_impl.h"
  26 #include "mpls_trace_impl.h"
  27 #include "mpls_tree_impl.h"
  28
  29 static uint32_t _ldp_addr_next_index = 1;
  30
  31 ldp_addr *ldp_addr_create(ldp_global *g, mpls_inet_addr * address)
  32 {
  33   ldp_addr *a = (ldp_addr *) mpls_malloc(sizeof(ldp_addr));
  34
  35   if (a) {
  36    /*
  37     * note: this is init to 1 for a reason!
  38     * We're placing it in the global list, so this is our refcnt
  39     * when this refcnt gets to zero, it will be removed from the
  40     * global list and deleted
  41     */
  42     /*
  43      * TESTING: jleu 6/7/2004, since I want the addr to be cleaned up
  44      * when it no longer has a nexthop, fec, or label, the only things that
  45      * should increment the ref are those (nh, fec, label etc), not global
  46      * nor inserting into the tree.
  47     MPLS_REFCNT_INIT(a, 1);
  48      */
  49     MPLS_REFCNT_INIT(a, 0);
  50     mpls_link_list_init(&a->session_root);
  51     MPLS_LIST_INIT(&a->nh_root, ldp_nexthop);
  52     MPLS_LIST_ELEM_INIT(a, _global);
  53     MPLS_LIST_ELEM_INIT(a, _if);
  54     memcpy(&a->address, address, sizeof(mpls_inet_addr));
  55     a->index = _ldp_addr_get_next_index();
  56     _ldp_global_add_addr(g, a);
  57     ldp_addr_insert2(g, a);
  58   }
  59   return a;
  60 }
  61
  62 void ldp_addr_delete(ldp_global *g, ldp_addr * a)
  63 {
  64   fprintf(stderr, "addr delete: %p\n", a);
  65   MPLS_REFCNT_ASSERT(a, 0);
  66   ldp_addr_remove(g, &a->address);
  67   _ldp_global_del_addr(g, a);
  68   mpls_free(a);
  69 }
  70
  71 ldp_addr *ldp_addr_find(ldp_global *g, mpls_inet_addr * address)
  72 {
  73   ldp_addr *addr = NULL;
  74
  75   if (mpls_tree_get(g->addr_tree, address->u.ipv4, 32, (void **)&addr) !=
  76     MPLS_SUCCESS) {
  77     return NULL;
  78   }
  79   return addr;
  80 }
  81
  82 ldp_addr *ldp_addr_insert(ldp_global *g, mpls_inet_addr * address)
  83 {
  84   ldp_addr *addr = NULL;
  85
  86   if ((addr = ldp_addr_create(g, address)) == NULL) {
  87     LDP_PRINT(g->user_data, "ldp_addr_insert: error creating address\n");
  88     return NULL;
  89   }
  90   return addr;
  91 }
  92
  93 mpls_return_enum ldp_addr_insert2(ldp_global *g, ldp_addr *addr)
  94 {
  95   if (mpls_tree_insert(g->addr_tree, addr->address.u.ipv4, 32, (void *)addr) !=
  96     MPLS_SUCCESS) {
  97     LDP_PRINT(g->user_data, "ldp_addr_insert2: error adding addr\n");
  98     MPLS_REFCNT_RELEASE2(g, addr, ldp_addr_delete);
  99     return MPLS_FATAL;
 100   }
 101   return MPLS_SUCCESS;
 102 }
 103
 104 void ldp_addr_remove(ldp_global *g, mpls_inet_addr * address)
 105 {
 106   ldp_addr *addr = NULL;
 107   mpls_tree_remove(g->addr_tree, address->u.ipv4, 32, (void **)&addr);
 108 }
 109
 110 void ldp_addr_add_if(ldp_addr * a, ldp_if * i)
 111 {
 112   MPLS_ASSERT(a && i);
 113   MPLS_REFCNT_HOLD(i);
 114   a->iff = i;
 115 }
 116
 117 void ldp_addr_del_if(ldp_global *g, ldp_addr * a)
 118 {
 119   MPLS_ASSERT(a);
 120   MPLS_REFCNT_RELEASE2(g, a->iff, ldp_if_delete);
 121   a->iff = NULL;
 122 }
 123
 124 mpls_bool ldp_addr_is_empty(ldp_addr *a)
 125 {
 126     if (a->iff == NULL && MPLS_LIST_EMPTY(&a->nh_root) &&
 127       MPLS_LIST_EMPTY(&a->session_root)) {
 128       return MPLS_BOOL_TRUE;
 129     }
 130     return MPLS_BOOL_FALSE;
 131 }
 132
 133 mpls_return_enum _ldp_addr_add_session(ldp_addr * a, ldp_session * s)
 134 {
 135   MPLS_ASSERT(a && s);
 136   MPLS_REFCNT_HOLD(s);
 137   if (mpls_link_list_add_tail(&a->session_root, s) == MPLS_SUCCESS) {
 138     return MPLS_SUCCESS;
 139   }
 140   MPLS_REFCNT_RELEASE(s, ldp_session_delete);
 141   return MPLS_FAILURE;
 142 }
 143
 144 void _ldp_addr_del_session(ldp_addr * a, ldp_session * s)
 145 {
 146   MPLS_ASSERT(a && s);
 147   mpls_link_list_remove_data(&a->session_root, s);
 148   MPLS_REFCNT_RELEASE(s, ldp_session_delete);
 149 }
 150
 151 void ldp_addr_add_nexthop(ldp_addr * a, ldp_nexthop * nh)
 152 {
 153   ldp_nexthop *np = NULL;
 154
 155   MPLS_ASSERT(a && nh);
 156   MPLS_REFCNT_HOLD(nh);
 157
 158   ldp_nexthop_add_addr(nh,a);
 159
 160   np = MPLS_LIST_HEAD(&a->nh_root);
 161   while (np != NULL) {
 162     if (np->index > nh->index) {
 163        MPLS_LIST_INSERT_BEFORE(&a->nh_root, np, nh, _addr);
 164        return;
 165     }
 166     np = MPLS_LIST_NEXT(&a->nh_root, np, _addr);
 167   }
 168   MPLS_LIST_ADD_TAIL(&a->nh_root, nh, _addr, ldp_nexthop);
 169 }
 170
 171 void ldp_addr_del_nexthop(ldp_global *g, ldp_addr * a, ldp_nexthop * nh)
 172 {
 173   MPLS_ASSERT(a && nh);
 174   MPLS_LIST_REMOVE(&a->nh_root, nh, _addr);
 175   ldp_nexthop_del_addr(g, nh);
 176   MPLS_REFCNT_RELEASE2(g, nh, ldp_nexthop_delete);
 177 }
 178
 179 uint32_t _ldp_addr_get_next_index()
 180 {
 181   uint32_t retval = _ldp_addr_next_index;
 182
 183   _ldp_addr_next_index++;
 184   if (retval > _ldp_addr_next_index) {
 185     _ldp_addr_next_index = 1;
 186   }
 187   return retval;
 188 }
 189
 190 void ldp_addr_mesg_prepare(ldp_mesg * msg, ldp_global * g, uint32_t msgid,
 191   mpls_inet_addr * addr)
 192 {
 193   MPLS_MSGPTR(Adr);
 194
 195   LDP_ENTER(g->user_data, "ldp_addr_mesg_prepare");
 196
 197   ldp_mesg_prepare(msg, MPLS_ADDR_MSGTYPE, msgid);
 198   MPLS_MSGPARAM(Adr) = &msg->u.addr;
 199
 200   MPLS_MSGPARAM(Adr)->adrListTlvExists = 1;
 201   MPLS_MSGPARAM(Adr)->baseMsg.msgLength +=
 202     setupAddrTlv(&(MPLS_MSGPARAM(Adr)->addressList));
 203
 204   MPLS_MSGPARAM(Adr)->baseMsg.msgLength +=
 205     addAddrElem2AddrTlv(&(MPLS_MSGPARAM(Adr)->addressList), addr->u.ipv4);
 206
 207   LDP_EXIT(g->user_data, "ldp_addr_mesg_prepare");
 208 }
 209
 210 void ldp_waddr_mesg_prepare(ldp_mesg * msg, ldp_global * g, uint32_t msgid,
 211   mpls_inet_addr * addr)
 212 {
 213   MPLS_MSGPTR(Adr);
 214
 215   LDP_ENTER(g->user_data, "ldp_waddr_mesg_prepare");
 216
 217   ldp_mesg_prepare(msg, MPLS_ADDRWITH_MSGTYPE, msgid);
 218   MPLS_MSGPARAM(Adr) = &msg->u.addr;
 219
 220   MPLS_MSGPARAM(Adr)->adrListTlvExists = 1;
 221   MPLS_MSGPARAM(Adr)->baseMsg.msgLength +=
 222     setupAddrTlv(&(MPLS_MSGPARAM(Adr)->addressList));
 223
 224   MPLS_MSGPARAM(Adr)->baseMsg.msgLength +=
 225     addAddrElem2AddrTlv(&(MPLS_MSGPARAM(Adr)->addressList), addr->u.ipv4);
 226
 227   LDP_EXIT(g->user_data, "ldp_waddr_mesg_prepare");
 228 }
 229
 230 mpls_return_enum ldp_addr_send(ldp_global * g, ldp_session * s,
 231   mpls_inet_addr * a)
 232 {
 233   mpls_return_enum result = MPLS_FAILURE;
 234
 235   MPLS_ASSERT(s && a);
 236
 237   LDP_ENTER(g->user_data, "ldp_addr_send");
 238
 239   ldp_addr_mesg_prepare(s->tx_message, g, g->message_identifier++, a);
 240
 241   LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_SEND, LDP_TRACE_FLAG_ADDRESS,
 242     "Addr Send: session(%d)\n", s->index);
 243
 244   result = ldp_mesg_send_tcp(g, s, s->tx_message);
 245
 246   LDP_EXIT(g->user_data, "ldp_addr_send");
 247
 248   return result;
 249 }
 250
 251 mpls_return_enum ldp_waddr_send(ldp_global * g, ldp_session * s,
 252   mpls_inet_addr * a)
 253 {
 254   mpls_return_enum result = MPLS_FAILURE;
 255
 256   MPLS_ASSERT(s && a);
 257
 258   LDP_ENTER(g->user_data, "ldp_waddr_send");
 259
 260   ldp_waddr_mesg_prepare(s->tx_message, g, g->message_identifier++, a);
 261
 262   LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_SEND, LDP_TRACE_FLAG_ADDRESS,
 263     "Addr Withdraw Send: session(%d)\n", s->index);
 264
 265   result = ldp_mesg_send_tcp(g, s, s->tx_message);
 266
 267   LDP_EXIT(g->user_data, "ldp_waddr_send");
 268
 269   return result;
 270 }
 271
 272 mpls_return_enum ldp_addr_process(ldp_global * g, ldp_session * s,
 273   ldp_entity * e, ldp_mesg * msg)
 274 {
 275   mplsLdpAdrMsg_t *body = &msg->u.addr;
 276   mpls_inet_addr inet;
 277   ldp_addr *addr = NULL;
 278   ldp_nexthop *nh = NULL;
 279   ldp_fec *fec = NULL;
 280   int len = (body->addressList.baseTlv.length - MPLS_ADDFAMFIXLEN) /
 281     MPLS_IPv4LEN;
 282   int i;
 283
 284   LDP_ENTER(g->user_data, "ldp_addr_process");
 285
 286   LDP_TRACE_LOG(g->user_data, MPLS_TRACE_STATE_RECV, LDP_TRACE_FLAG_ADDRESS,
 287     "Addr Recv: session(%d)\n", s->index);
 288
 289   for (i = 0; i < len; i++) {
 290     inet.type = MPLS_FAMILY_IPV4;
 291     inet.u.ipv4 = body->addressList.address[i];
 292
 293     if (msg->u.generic.flags.flags.msgType == MPLS_ADDR_MSGTYPE) {
 294       if (!(addr = ldp_addr_find(g, &inet))) {
 295         /* it's not in the tree, put it there! */
 296         if ((addr = ldp_addr_insert(g, &inet)) == NULL) {
 297           LDP_PRINT(g->user_data, "ldp_addr_process: error adding addr\n");
 298           goto ldp_addr_process_end;
 299         }
 300       }
 301
 302       /* the addr is in the tree */
 303       if (ldp_session_add_addr(g, s, addr) == MPLS_FAILURE) {
 304         LDP_PRINT(g->user_data,
 305           "ldp_addr_process: error adding address to session\n");
 306         return MPLS_FAILURE;
 307       }
 308
 309       nh = MPLS_LIST_HEAD(&addr->nh_root);
 310       while (nh != NULL) {
 311         fec = nh->fec;
 312         /* create cross connect */
 313         /* send label mapping */
 314         nh = MPLS_LIST_NEXT(&addr->nh_root, nh, _addr);
 315       }
 316     } else {
 317       /* addr withdrawl */
 318       if ((addr = ldp_addr_find(g, &inet))) {
 319         nh = MPLS_LIST_HEAD(&addr->nh_root);
 320         while (fec != NULL) {
 321           /* send label withdrawl */
 322           /* delete cross connect */
 323           nh = MPLS_LIST_NEXT(&addr->nh_root, nh, _addr);
 324         }
 325
 326         ldp_session_del_addr(g, s, addr);
 327       }
 328     }
 329   }
 330
 331   LDP_EXIT(g->user_data, "ldp_addr_process");
 332
 333   return MPLS_SUCCESS;
 334
 335 ldp_addr_process_end:
 336
 337   LDP_EXIT(g->user_data, "ldp_addr_process-error");
 338
 339   return MPLS_FAILURE;
 340 }