rsvpte/rsvpte_cfg.c

   1 /*
   2  *  Copyright (C) James R. Leu 2003
   3  *  jleu@mindspring.com
   4  *
   5  *  This software is covered under the LGPL, for more
   6  *  info check out http://www.gnu.org/copyleft/lgpl.html
   7  */
   8
   9 #include "rsvpte_struct.h"
  10 #include "rsvpte_cfg.h"
  11 #include "rsvpte_global.h"
  12 #include "rsvpte_if.h"
  13 #include "mpls_ifmgr_impl.h"
  14 #include "mpls_lock_impl.h"
  15 #include "mpls_trace_impl.h"
  16 #include "mpls_tree_impl.h"
  17
  18 mpls_cfg_handle rsvpte_cfg_open(mpls_instance_handle data)
  19 {
  20   rsvpte_global *g = rsvpte_global_create(data);
  21
  22   LDP_ENTER(data, "rsvpte_cfg_open");
  23   LDP_EXIT(data, "rsvpte_cfg_open");
  24
  25   return (mpls_cfg_handle) g;
  26 }
  27
  28 void rsvpte_cfg_close(mpls_cfg_handle g)
  29 {
  30   LDP_ENTER((mpls_instance_handle) g->user_data, "rsvpte_cfg_close");
  31   rsvpte_global_delete(g);
  32   LDP_EXIT((mpls_instance_handle) g->user_data, "rsvpte_cfg_close");
  33 }
  34
  35 /******************* GLOBAL **********************/
  36
  37 mpls_return_enum rsvpte_cfg_global_get(mpls_cfg_handle handle, rsvpte_global * g,
  38   uint32_t flag)
  39 {
  40   rsvpte_global *global = (rsvpte_global *) handle;
  41
  42   MPLS_ASSERT(global !=NULL);
  43
  44   LDP_ENTER(global->user_data, "rsvpte_cfg_global_get");
  45
  46   mpls_lock_get(global->global_lock); /* LOCK */
  47
  48   if (flag & RSVPTE_GLOBAL_CFG_LSR_IDENTIFIER) {
  49     memcpy(&(g->lsr_identifier), &(global->lsr_identifier),
  50       sizeof(mpls_inet_addr));
  51   }
  52   if (flag & RSVPTE_GLOBAL_CFG_ADMIN_STATE) {
  53     g->admin_state = global->admin_state;
  54   }
  55 #if MPLS_USE_LSR
  56   if (flag & RSVPTE_GLOBAL_CFG_LSR_HANDLE) {
  57     g->lsr_handle = global->lsr_handle;
  58   }
  59 #endif
  60
  61   mpls_lock_release(global->global_lock); /* UNLOCK */
  62
  63   LDP_EXIT(global->user_data, "rsvpte_cfg_global_get");
  64
  65   return MPLS_SUCCESS;
  66 }
  67
  68 mpls_return_enum rsvpte_cfg_global_test(mpls_cfg_handle handle, rsvpte_global * g,
  69   uint32_t flag)
  70 {
  71   rsvpte_global *global = (rsvpte_global *) handle;
  72   mpls_return_enum retval = MPLS_SUCCESS;
  73
  74   MPLS_ASSERT(global !=NULL);
  75
  76   LDP_ENTER(global->user_data, "rsvpte_cfg_global_test");
  77
  78   mpls_lock_get(global->global_lock); /* LOCK */
  79
  80   if (global->admin_state == MPLS_ADMIN_ENABLE && (flag & RSVPTE_GLOBAL_CFG_WHEN_DOWN))
  81     retval = MPLS_FAILURE;
  82
  83   mpls_lock_release(global->global_lock); /* UNLOCK */
  84
  85   LDP_EXIT(global->user_data, "rsvpte_cfg_global_test");
  86
  87   return retval;
  88 }
  89
  90 mpls_return_enum rsvpte_cfg_global_set(mpls_cfg_handle handle, rsvpte_global * g,
  91   uint32_t flag)
  92 {
  93   rsvpte_global *global = (rsvpte_global *) handle;
  94   mpls_return_enum retval = MPLS_FAILURE;
  95
  96   MPLS_ASSERT(global !=NULL);
  97
  98   LDP_ENTER(global->user_data, "rsvpte_cfg_global_set");
  99
 100   mpls_lock_get(global->global_lock); /* LOCK */
 101
 102   if ((global->admin_state == MPLS_ADMIN_ENABLE && (flag & RSVPTE_GLOBAL_CFG_WHEN_DOWN)))
 103     goto rsvpte_cfg_global_set_end;
 104
 105   if (flag & RSVPTE_GLOBAL_CFG_LSR_IDENTIFIER) {
 106     memcpy(&(global->lsr_identifier), &(g->lsr_identifier),
 107       sizeof(mpls_inet_addr));
 108   }
 109 #if MPLS_USE_LSR
 110   if (flag & RSVPTE_GLOBAL_CFG_LSR_HANDLE) {
 111     global->lsr_handle = g->lsr_handle ;
 112   }
 113 #endif
 114   if (flag & RSVPTE_GLOBAL_CFG_ADMIN_STATE) {
 115     if (global->admin_state == MPLS_ADMIN_ENABLE && g->admin_state == MPLS_ADMIN_DISABLE) {
 116       rsvpte_global_shutdown(global);
 117     } else if (global->admin_state == MPLS_ADMIN_DISABLE && g->admin_state ==
 118       MPLS_ADMIN_ENABLE) {
 119       rsvpte_global_startup(global);
 120     }
 121   }
 122
 123   retval = MPLS_SUCCESS;
 124
 125 rsvpte_cfg_global_set_end:
 126
 127   mpls_lock_release(global->global_lock); /* UNLOCK */
 128
 129   LDP_EXIT(global->user_data, "rsvpte_cfg_global_set");
 130
 131   return retval;
 132 }
 133
 134 /******************* INTERFACE **********************/
 135
 136 mpls_return_enum rsvpte_cfg_if_get(mpls_cfg_handle handle, rsvpte_if * i, uint32_t flag)
 137 {
 138   rsvpte_global *global = (rsvpte_global *) handle;
 139   rsvpte_if *iff = NULL;
 140   mpls_return_enum retval = MPLS_FAILURE;
 141
 142   MPLS_ASSERT(global !=NULL && i != NULL);
 143
 144   LDP_ENTER(global->user_data, "rsvpte_cfg_if_get");
 145
 146   mpls_lock_get(global->global_lock); /* LOCK */
 147
 148   if (rsvpte_global_find_if_index(global, i->index, &iff) != MPLS_SUCCESS)
 149       goto rsvpte_cfg_if_get_end;
 150
 151   if (flag & RSVPTE_IF_CFG_NAME) {
 152     strncpy(i->name, iff->name, MPLS_MAX_IF_NAME);
 153   }
 154   if (flag & RSVPTE_IF_CFG_LABEL_SPACE) {
 155     i->label_space = iff->label_space;
 156   }
 157   if (flag & RSVPTE_IF_CFG_ADMIN_STATE) {
 158     i->admin_state = iff->admin_state;
 159   }
 160   if (flag & RSVPTE_IF_CFG_OPER_STATE) {
 161     i->oper_state = iff->oper_state;
 162   }
 163   if (flag & RSVPTE_IF_CFG_LOCAL_SOURCE_ADDR) {
 164     memcpy(&i->local_source_address, &iff->local_source_address,
 165       sizeof(mpls_inet_addr));
 166   }
 167   retval = MPLS_SUCCESS;
 168
 169 rsvpte_cfg_if_get_end:
 170   mpls_lock_release(global->global_lock); /* UNLOCK */
 171
 172   LDP_EXIT(global->user_data, "rsvpte_cfg_if_get");
 173
 174   return retval;
 175 }
 176
 177 mpls_return_enum rsvpte_cfg_if_getnext(mpls_cfg_handle handle, rsvpte_if * i,
 178   uint32_t flag)
 179 {
 180   rsvpte_global *g = (rsvpte_global *) handle;
 181   rsvpte_if *iff = NULL;
 182   mpls_return_enum r = MPLS_FAILURE;
 183   mpls_bool done = MPLS_BOOL_FALSE;
 184   int index;
 185
 186   LDP_ENTER(g->user_data, "rsvpte_cfg_if_getnext");
 187
 188   if (i->index == 0) {
 189     index = 1;
 190   } else {
 191     index = i->index + 1;
 192   }
 193
 194   mpls_lock_get(g->global_lock); /* LOCK */
 195   while (done == MPLS_BOOL_FALSE) {
 196     switch ((r = rsvpte_global_find_if_index(g, index, &iff))) {
 197       case MPLS_SUCCESS:
 198       case MPLS_END_OF_LIST:
 199         done = MPLS_BOOL_TRUE;
 200         break;
 201       case MPLS_FAILURE:
 202         break;
 203       default:
 204         MPLS_ASSERT(0);
 205     }
 206     index++;
 207   }
 208   mpls_lock_release(g->global_lock); /* UNLOCK */
 209
 210   if (r == MPLS_SUCCESS) {
 211     i->index = iff->index;
 212     LDP_EXIT(g->user_data, "rsvpte_cfg_if_getnext");
 213     return rsvpte_cfg_if_get(g, i, flag);
 214   }
 215   LDP_EXIT(g->user_data, "rsvpte_cfg_if_getnext");
 216   return r;
 217 }
 218
 219 mpls_return_enum rsvpte_cfg_if_test(mpls_cfg_handle handle, rsvpte_if * i,
 220   uint32_t flag)
 221 {
 222   rsvpte_global *global = (rsvpte_global *) handle;
 223   rsvpte_if *iff = NULL;
 224   mpls_return_enum retval = MPLS_FAILURE;
 225
 226   MPLS_ASSERT(global !=NULL && i != NULL);
 227
 228   LDP_ENTER(global->user_data, "rsvpte_cfg_if_test");
 229
 230   mpls_lock_get(global->global_lock); /* LOCK */
 231
 232   if (!(flag & RSVPTE_CFG_ADD)) {
 233     rsvpte_global_find_if_index(global, i->index, &iff);
 234   } else {
 235     retval = MPLS_SUCCESS;
 236     goto rsvpte_cfg_if_test_end;
 237   }
 238
 239   if ((iff == NULL) ||
 240     ((rsvpte_if_is_active(iff) == MPLS_BOOL_TRUE) &&
 241 (flag & RSVPTE_IF_CFG_WHEN_DOWN))) goto rsvpte_cfg_if_test_end;
 242
 243   if (flag & RSVPTE_CFG_DEL) {
 244           /*
 245     if (iff->entity != NULL)
 246       goto rsvpte_cfg_if_test_end;
 247            */
 248   }
 249   retval = MPLS_SUCCESS;
 250
 251 rsvpte_cfg_if_test_end:
 252   mpls_lock_release(global->global_lock); /* UNLOCK */
 253
 254   LDP_EXIT(global->user_data, "rsvpte_cfg_if_test");
 255
 256   return retval;
 257 }
 258
 259 mpls_return_enum rsvpte_cfg_if_set(mpls_cfg_handle handle, rsvpte_if * i, uint32_t flag)
 260 {
 261   rsvpte_global *global = (rsvpte_global*)handle;
 262   rsvpte_if *iff = NULL;
 263   mpls_return_enum retval = MPLS_FAILURE;
 264
 265   MPLS_ASSERT(global !=NULL && i != NULL);
 266
 267   LDP_ENTER(global->user_data, "rsvpte_cfg_if_set");
 268
 269   mpls_lock_get(global->global_lock); /* LOCK */
 270
 271   if (flag & RSVPTE_CFG_ADD) {
 272     if ((iff = rsvpte_if_create()) == NULL) {
 273       goto rsvpte_cfg_if_set_end;
 274     }
 275     if (mpls_if_handle_verify(global->ifmgr_handle, i->handle) == MPLS_BOOL_FALSE) {
 276       i->handle = mpls_ifmgr_open_if(global->ifmgr_handle, i->name);
 277     }
 278     iff->handle = i->handle;
 279     i->index = iff->index;
 280     strncpy(iff->name, i->name, MPLS_MAX_IF_NAME);
 281     _rsvpte_global_add_if(global, iff);
 282   } else {
 283     rsvpte_global_find_if_index(global, i->index, &iff);
 284   }
 285
 286   if ((iff == NULL) ||
 287     ((rsvpte_if_is_active(iff) == MPLS_BOOL_TRUE) &&
 288 (flag & RSVPTE_IF_CFG_WHEN_DOWN))) goto rsvpte_cfg_if_set_end;
 289
 290   if (flag & RSVPTE_CFG_DEL) {
 291     _rsvpte_global_del_if(global, iff);
 292
 293     retval = MPLS_SUCCESS;
 294     goto rsvpte_cfg_if_set_end;
 295   }
 296   if (flag & RSVPTE_IF_CFG_LABEL_SPACE) {
 297     iff->label_space = i->label_space;
 298   }
 299   if (flag & RSVPTE_IF_CFG_ADMIN_STATE) {
 300     if (iff->admin_state == MPLS_ADMIN_ENABLE && i->admin_state ==
 301       MPLS_ADMIN_DISABLE) {
 302       rsvpte_if_shutdown(global, iff);
 303     } else if (iff->admin_state == MPLS_ADMIN_DISABLE && i->admin_state ==
 304       MPLS_ADMIN_ENABLE) {
 305       rsvpte_if_startup(global, iff);
 306     }
 307   }
 308
 309   retval = MPLS_SUCCESS;
 310
 311 rsvpte_cfg_if_set_end:
 312   mpls_lock_release(global->global_lock); /* UNLOCK */
 313
 314   LDP_EXIT(global->user_data, "rsvpte_cfg_if_set");
 315
 316   return retval;
 317 }