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_LABEL_SPACE) {
 152     i->label_space = iff->label_space;
 153   }
 154   if (flag & RSVPTE_IF_CFG_ADMIN_STATE) {
 155     i->admin_state = iff->admin_state;
 156   }
 157   if (flag & RSVPTE_IF_CFG_OPER_STATE) {
 158     i->oper_state = iff->oper_state;
 159   }
 160   retval = MPLS_SUCCESS;
 161
 162 rsvpte_cfg_if_get_end:
 163   mpls_lock_release(global->global_lock); /* UNLOCK */
 164
 165   LDP_EXIT(global->user_data, "rsvpte_cfg_if_get");
 166
 167   return retval;
 168 }
 169
 170 mpls_return_enum rsvpte_cfg_if_getnext(mpls_cfg_handle handle, rsvpte_if * i,
 171   uint32_t flag)
 172 {
 173   rsvpte_global *g = (rsvpte_global *) handle;
 174   rsvpte_if *iff = NULL;
 175   mpls_return_enum r = MPLS_FAILURE;
 176   mpls_bool done = MPLS_BOOL_FALSE;
 177   int index;
 178
 179   LDP_ENTER(g->user_data, "rsvpte_cfg_if_getnext");
 180
 181   if (i->index == 0) {
 182     index = 1;
 183   } else {
 184     index = i->index + 1;
 185   }
 186
 187   mpls_lock_get(g->global_lock); /* LOCK */
 188   while (done == MPLS_BOOL_FALSE) {
 189     switch ((r = rsvpte_global_find_if_index(g, index, &iff))) {
 190       case MPLS_SUCCESS:
 191       case MPLS_END_OF_LIST:
 192         done = MPLS_BOOL_TRUE;
 193         break;
 194       case MPLS_FAILURE:
 195         break;
 196       default:
 197         MPLS_ASSERT(0);
 198     }
 199     index++;
 200   }
 201   mpls_lock_release(g->global_lock); /* UNLOCK */
 202
 203   if (r == MPLS_SUCCESS) {
 204     i->index = iff->index;
 205     LDP_EXIT(g->user_data, "rsvpte_cfg_if_getnext");
 206     return rsvpte_cfg_if_get(g, i, flag);
 207   }
 208   LDP_EXIT(g->user_data, "rsvpte_cfg_if_getnext");
 209   return r;
 210 }
 211
 212 mpls_return_enum rsvpte_cfg_if_test(mpls_cfg_handle handle, rsvpte_if * i,
 213   uint32_t flag)
 214 {
 215   rsvpte_global *global = (rsvpte_global *) handle;
 216   rsvpte_if *iff = NULL;
 217   mpls_return_enum retval = MPLS_FAILURE;
 218
 219   MPLS_ASSERT(global !=NULL && i != NULL);
 220
 221   LDP_ENTER(global->user_data, "rsvpte_cfg_if_test");
 222
 223   mpls_lock_get(global->global_lock); /* LOCK */
 224
 225   if (!(flag & RSVPTE_CFG_ADD)) {
 226     rsvpte_global_find_if_index(global, i->index, &iff);
 227   } else {
 228     retval = MPLS_SUCCESS;
 229     goto rsvpte_cfg_if_test_end;
 230   }
 231
 232   if ((iff == NULL) ||
 233     ((rsvpte_if_is_active(iff) == MPLS_BOOL_TRUE) &&
 234 (flag & RSVPTE_IF_CFG_WHEN_DOWN))) goto rsvpte_cfg_if_test_end;
 235
 236   if (flag & RSVPTE_CFG_DEL) {
 237           /*
 238     if (iff->entity != NULL)
 239       goto rsvpte_cfg_if_test_end;
 240            */
 241   }
 242   retval = MPLS_SUCCESS;
 243
 244 rsvpte_cfg_if_test_end:
 245   mpls_lock_release(global->global_lock); /* UNLOCK */
 246
 247   LDP_EXIT(global->user_data, "rsvpte_cfg_if_test");
 248
 249   return retval;
 250 }
 251
 252 mpls_return_enum rsvpte_cfg_if_set(mpls_cfg_handle handle, rsvpte_if * i, uint32_t flag)
 253 {
 254   rsvpte_global *global = (rsvpte_global*)handle;
 255   rsvpte_if *iff = NULL;
 256   mpls_return_enum retval = MPLS_FAILURE;
 257
 258   MPLS_ASSERT(global !=NULL && i != NULL);
 259
 260   LDP_ENTER(global->user_data, "rsvpte_cfg_if_set");
 261
 262   mpls_lock_get(global->global_lock); /* LOCK */
 263
 264   if (flag & RSVPTE_CFG_ADD) {
 265     if ((iff = rsvpte_if_create()) == NULL) {
 266       goto rsvpte_cfg_if_set_end;
 267     }
 268     if (mpls_if_handle_verify(global->ifmgr_handle, i->handle) == MPLS_BOOL_FALSE) {
 269       goto rsvpte_cfg_if_set_end;
 270     }
 271     iff->handle = i->handle;
 272     i->index = iff->index;
 273     _rsvpte_global_add_if(global, iff);
 274   } else {
 275     rsvpte_global_find_if_index(global, i->index, &iff);
 276   }
 277
 278   if ((iff == NULL) ||
 279     ((rsvpte_if_is_active(iff) == MPLS_BOOL_TRUE) &&
 280 (flag & RSVPTE_IF_CFG_WHEN_DOWN))) goto rsvpte_cfg_if_set_end;
 281
 282   if (flag & RSVPTE_CFG_DEL) {
 283     _rsvpte_global_del_if(global, iff);
 284
 285     retval = MPLS_SUCCESS;
 286     goto rsvpte_cfg_if_set_end;
 287   }
 288   if (flag & RSVPTE_IF_CFG_LABEL_SPACE) {
 289     iff->label_space = i->label_space;
 290   }
 291   if (flag & RSVPTE_IF_CFG_ADMIN_STATE) {
 292     if (iff->admin_state == MPLS_ADMIN_ENABLE && i->admin_state ==
 293       MPLS_ADMIN_DISABLE) {
 294       rsvpte_if_shutdown(global, iff);
 295     } else if (iff->admin_state == MPLS_ADMIN_DISABLE && i->admin_state ==
 296       MPLS_ADMIN_ENABLE) {
 297       rsvpte_if_startup(global, iff);
 298     }
 299   }
 300
 301   retval = MPLS_SUCCESS;
 302
 303 rsvpte_cfg_if_set_end:
 304   mpls_lock_release(global->global_lock); /* UNLOCK */
 305
 306   LDP_EXIT(global->user_data, "rsvpte_cfg_if_set");
 307
 308   return retval;
 309 }