eigrpd/eigrp_fsm.c

   1 /*
   2  * EIGRPd Finite State Machine (DUAL).
   3  * Copyright (C) 2013-2014
   4  * Authors:
   5  *   Donnie Savage
   6  *   Jan Janovic
   7  *   Matej Perina
   8  *   Peter Orsag
   9  *   Peter Paluch
  10  *
  11  * This file is part of GNU Zebra.
  12  *
  13  * GNU Zebra is free software; you can redistribute it and/or modify it
  14  * under the terms of the GNU General Public License as published by the
  15  * Free Software Foundation; either version 2, or (at your option) any
  16  * later version.
  17  *
  18  * GNU Zebra is distributed in the hope that it will be useful, but
  19  * WITHOUT ANY WARRANTY; without even the implied warranty of
  20  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  21  * General Public License for more details.
  22  *
  23  * You should have received a copy of the GNU General Public License along
  24  * with this program; see the file COPYING; if not, write to the Free Software
  25  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
  26  *
  27  * This file contains functions for executing logic of finite state machine
  28  *
  29  *                                +------------ +
  30  *                                |     (7)     |
  31  *                                |             v
  32  *                    +=====================================+
  33  *                    |                                     |
  34  *                    |              Passive                |
  35  *                    |                                     |
  36  *                    +=====================================+
  37  *                        ^     |     ^     ^     ^    |
  38  *                     (3)|     |  (1)|     |  (1)|    |
  39  *                        |  (0)|     |  (3)|     | (2)|
  40  *                        |     |     |     |     |    +---------------+
  41  *                        |     |     |     |     |                     \
  42  *              +--------+      |     |     |     +-----------------+    \
  43  *            /                /     /      |                        \    \
  44  *          /                /     /        +----+                    \    \
  45  *         |                |     |               |                    |    |
  46  *         |                v     |               |                    |    v
  47  *    +===========+   (6)  +===========+       +===========+   (6) +===========+
  48  *    |           |------->|           |  (5)  |           |-------->| |
  49  *    |           |   (4)  |           |------>|           |   (4)   | |
  50  *    | ACTIVE 0  |<-------| ACTIVE 1  |       | ACTIVE 2  |<--------| ACTIVE 3
  51  * |
  52  * +--|           |     +--|           |    +--|           |      +--| |
  53  * |  +===========+     |  +===========+    |  +===========+      |
  54  * +===========+
  55  * |       ^  |(5)      |      ^            |    ^    ^           |         ^
  56  * |       |  +---------|------|------------|----+    |           |         |
  57  * +-------+            +------+            +---------+           +---------+
  58  *    (7)                 (7)                  (7)                   (7)
  59  *
  60  * 0- input event other than query from successor, FC not satisfied
  61  * 1- last reply, FD is reset
  62  * 2- query from successor, FC not satisfied
  63  * 3- last reply, FC satisfied with current value of FDij
  64  * 4- distance increase while in active state
  65  * 5- query from successor while in active state
  66  * 6- last reply, FC not satisfied with current value of FDij
  67  * 7- state not changed, usually by receiving not last reply
  68  */
  69
  70 #include <thread.h>
  71 #include <zebra.h>
  72
  73 #include "prefix.h"
  74 #include "table.h"
  75 #include "memory.h"
  76 #include "log.h"
  77 #include "linklist.h"
  78 #include "vty.h"
  79
  80 #include "eigrpd/eigrp_structs.h"
  81 #include "eigrpd/eigrpd.h"
  82 #include "eigrpd/eigrp_interface.h"
  83 #include "eigrpd/eigrp_neighbor.h"
  84 #include "eigrpd/eigrp_packet.h"
  85 #include "eigrpd/eigrp_zebra.h"
  86 #include "eigrpd/eigrp_vty.h"
  87 #include "eigrpd/eigrp_network.h"
  88 #include "eigrpd/eigrp_dump.h"
  89 #include "eigrpd/eigrp_topology.h"
  90 #include "eigrpd/eigrp_fsm.h"
  91
  92 /*
  93  * Prototypes
  94  */
  95 int eigrp_fsm_event_keep_state(struct eigrp_fsm_action_message *);
  96 int eigrp_fsm_event_nq_fcn(struct eigrp_fsm_action_message *);
  97 int eigrp_fsm_event_q_fcn(struct eigrp_fsm_action_message *);
  98 int eigrp_fsm_event_lr(struct eigrp_fsm_action_message *);
  99 int eigrp_fsm_event_dinc(struct eigrp_fsm_action_message *);
 100 int eigrp_fsm_event_lr_fcs(struct eigrp_fsm_action_message *);
 101 int eigrp_fsm_event_lr_fcn(struct eigrp_fsm_action_message *);
 102 int eigrp_fsm_event_qact(struct eigrp_fsm_action_message *);
 103
 104 //---------------------------------------------------------------------
 105
 106 /*
 107  * NSM - field of fields of struct containing one function each.
 108  * Which function is used depends on actual state of FSM and occurred
 109  * event(arrow in diagram). Usage:
 110  * NSM[actual/starting state][occurred event].func
 111  * Functions are should be executed within separate thread.
 112  */
 113 struct {
 114         int (*func)(struct eigrp_fsm_action_message *);
 115 } NSM[EIGRP_FSM_STATE_MAX][EIGRP_FSM_EVENT_MAX] = {
 116         {
 117                 // PASSIVE STATE
 118                 {eigrp_fsm_event_nq_fcn},     /* Event 0 */
 119                 {eigrp_fsm_event_keep_state}, /* Event 1 */
 120                 {eigrp_fsm_event_q_fcn},      /* Event 2 */
 121                 {eigrp_fsm_event_keep_state}, /* Event 3 */
 122                 {eigrp_fsm_event_keep_state}, /* Event 4 */
 123                 {eigrp_fsm_event_keep_state}, /* Event 5 */
 124                 {eigrp_fsm_event_keep_state}, /* Event 6 */
 125                 {eigrp_fsm_event_keep_state}, /* Event 7 */
 126         },
 127         {
 128                 // Active 0 state
 129                 {eigrp_fsm_event_keep_state}, /* Event 0 */
 130                 {eigrp_fsm_event_keep_state}, /* Event 1 */
 131                 {eigrp_fsm_event_keep_state}, /* Event 2 */
 132                 {eigrp_fsm_event_lr_fcs},     /* Event 3 */
 133                 {eigrp_fsm_event_keep_state}, /* Event 4 */
 134                 {eigrp_fsm_event_qact},       /* Event 5 */
 135                 {eigrp_fsm_event_lr_fcn},     /* Event 6 */
 136                 {eigrp_fsm_event_keep_state}, /* Event 7 */
 137         },
 138         {
 139                 // Active 1 state
 140                 {eigrp_fsm_event_keep_state}, /* Event 0 */
 141                 {eigrp_fsm_event_lr},    /* Event 1 */
 142                 {eigrp_fsm_event_keep_state}, /* Event 2 */
 143                 {eigrp_fsm_event_keep_state}, /* Event 3 */
 144                 {eigrp_fsm_event_dinc},       /* Event 4 */
 145                 {eigrp_fsm_event_qact},       /* Event 5 */
 146                 {eigrp_fsm_event_keep_state}, /* Event 6 */
 147                 {eigrp_fsm_event_keep_state}, /* Event 7 */
 148         },
 149         {
 150                 // Active 2 state
 151                 {eigrp_fsm_event_keep_state}, /* Event 0 */
 152                 {eigrp_fsm_event_keep_state}, /* Event 1 */
 153                 {eigrp_fsm_event_keep_state}, /* Event 2 */
 154                 {eigrp_fsm_event_lr_fcs},     /* Event 3 */
 155                 {eigrp_fsm_event_keep_state}, /* Event 4 */
 156                 {eigrp_fsm_event_keep_state}, /* Event 5 */
 157                 {eigrp_fsm_event_lr_fcn},     /* Event 6 */
 158                 {eigrp_fsm_event_keep_state}, /* Event 7 */
 159         },
 160         {
 161                 // Active 3 state
 162                 {eigrp_fsm_event_keep_state}, /* Event 0 */
 163                 {eigrp_fsm_event_lr},    /* Event 1 */
 164                 {eigrp_fsm_event_keep_state}, /* Event 2 */
 165                 {eigrp_fsm_event_keep_state}, /* Event 3 */
 166                 {eigrp_fsm_event_dinc},       /* Event 4 */
 167                 {eigrp_fsm_event_keep_state}, /* Event 5 */
 168                 {eigrp_fsm_event_keep_state}, /* Event 6 */
 169                 {eigrp_fsm_event_keep_state}, /* Event 7 */
 170         },
 171 };
 172
 173 static const char *packet_type2str(uint8_t packet_type)
 174 {
 175         if (packet_type == EIGRP_OPC_UPDATE)
 176                 return "Update";
 177         if (packet_type == EIGRP_OPC_REQUEST)
 178                 return "Request";
 179         if (packet_type == EIGRP_OPC_QUERY)
 180                 return "Query";
 181         if (packet_type == EIGRP_OPC_REPLY)
 182                 return "Reply";
 183         if (packet_type == EIGRP_OPC_HELLO)
 184                 return "Hello";
 185         if (packet_type == EIGRP_OPC_IPXSAP)
 186                 return "IPXSAP";
 187         if (packet_type == EIGRP_OPC_ACK)
 188                 return "Ack";
 189         if (packet_type == EIGRP_OPC_SIAQUERY)
 190                 return "SIA Query";
 191         if (packet_type == EIGRP_OPC_SIAREPLY)
 192                 return "SIA Reply";
 193
 194         return "Unknown";
 195 }
 196
 197 static const char *prefix_state2str(enum eigrp_fsm_states state)
 198 {
 199         switch (state) {
 200         case EIGRP_FSM_STATE_PASSIVE:
 201                 return "Passive";
 202         case EIGRP_FSM_STATE_ACTIVE_0:
 203                 return "Active oij0";
 204         case EIGRP_FSM_STATE_ACTIVE_1:
 205                 return "Active oij1";
 206         case EIGRP_FSM_STATE_ACTIVE_2:
 207                 return "Active oij2";
 208         case EIGRP_FSM_STATE_ACTIVE_3:
 209                 return "Active oij3";
 210         }
 211
 212         return "Unknown";
 213 }
 214
 215 static const char *fsm_state2str(enum eigrp_fsm_events event)
 216 {
 217         switch (event) {
 218         case EIGRP_FSM_KEEP_STATE:
 219                 return "Keep State Event";
 220         case EIGRP_FSM_EVENT_NQ_FCN:
 221                 return "Non Query Event Feasability not satisfied";
 222         case EIGRP_FSM_EVENT_LR:
 223                 return "Last Reply Event";
 224         case EIGRP_FSM_EVENT_Q_FCN:
 225                 return "Query Event Feasability not satisified";
 226         case EIGRP_FSM_EVENT_LR_FCS:
 227                 return "Last Reply Event Feasability satisified";
 228         case EIGRP_FSM_EVENT_DINC:
 229                 return "Distance Increase Event";
 230         case EIGRP_FSM_EVENT_QACT:
 231                 return "Query from Successor while in active state";
 232         case EIGRP_FSM_EVENT_LR_FCN:
 233                 return "Last Reply Event, Feasibility not satisfied";
 234         };
 235
 236         return "Unknown";
 237 }
 238
 239 static const char *change2str(enum metric_change change)
 240 {
 241         switch (change) {
 242         case METRIC_DECREASE:
 243                 return "Decrease";
 244         case METRIC_SAME:
 245                 return "Same";
 246         case METRIC_INCREASE:
 247                 return "Increase";
 248         }
 249
 250         return "Unknown";
 251 }
 252 /*
 253  * Main function in which are make decisions which event occurred.
 254  * msg - argument of type struct eigrp_fsm_action_message contain
 255  * details about what happen
 256  *
 257  * Return number of occurred event (arrow in diagram).
 258  *
 259  */
 260 static enum eigrp_fsm_events
 261 eigrp_get_fsm_event(struct eigrp_fsm_action_message *msg)
 262 {
 263         // Loading base information from message
 264         // struct eigrp *eigrp = msg->eigrp;
 265         struct eigrp_prefix_entry *prefix = msg->prefix;
 266         struct eigrp_nexthop_entry *entry = msg->entry;
 267         uint8_t actual_state = prefix->state;
 268         enum metric_change change;
 269
 270         if (entry == NULL) {
 271                 entry = eigrp_nexthop_entry_new();
 272                 entry->adv_router = msg->adv_router;
 273                 entry->ei = msg->adv_router->ei;
 274                 entry->prefix = prefix;
 275                 msg->entry = entry;
 276         }
 277
 278         /*
 279          * Calculate resultant metrics and insert to correct position
 280          * in entries list
 281          */
 282         change = eigrp_topology_update_distance(msg);
 283
 284         /* Store for display later */
 285         msg->change = change;
 286
 287         switch (actual_state) {
 288         case EIGRP_FSM_STATE_PASSIVE: {
 289                 struct eigrp_nexthop_entry *head =
 290                         listnode_head(prefix->entries);
 291
 292                 if (head->reported_distance < prefix->fdistance) {
 293                         return EIGRP_FSM_KEEP_STATE;
 294                 }
 295                 /*
 296                  * if best entry doesn't satisfy feasibility condition it means
 297                  * move to active state
 298                  * dependently if it was query from successor
 299                  */
 300                 if (msg->packet_type == EIGRP_OPC_QUERY) {
 301                         return EIGRP_FSM_EVENT_Q_FCN;
 302                 } else {
 303                         return EIGRP_FSM_EVENT_NQ_FCN;
 304                 }
 305
 306                 break;
 307         }
 308         case EIGRP_FSM_STATE_ACTIVE_0: {
 309                 if (msg->packet_type == EIGRP_OPC_REPLY) {
 310                         struct eigrp_nexthop_entry *head =
 311                                 listnode_head(prefix->entries);
 312
 313                         listnode_delete(prefix->rij, entry->adv_router);
 314                         if (prefix->rij->count)
 315                                 return EIGRP_FSM_KEEP_STATE;
 316
 317                         zlog_info("All reply received\n");
 318                         if (head->reported_distance < prefix->fdistance) {
 319                                 return EIGRP_FSM_EVENT_LR_FCS;
 320                         }
 321
 322                         return EIGRP_FSM_EVENT_LR_FCN;
 323                 } else if (msg->packet_type == EIGRP_OPC_QUERY
 324                            && (entry->flags
 325                                & EIGRP_NEXTHOP_ENTRY_SUCCESSOR_FLAG)) {
 326                         return EIGRP_FSM_EVENT_QACT;
 327                 }
 328
 329                 return EIGRP_FSM_KEEP_STATE;
 330
 331                 break;
 332         }
 333         case EIGRP_FSM_STATE_ACTIVE_1: {
 334                 if (msg->packet_type == EIGRP_OPC_QUERY
 335                     && (entry->flags & EIGRP_NEXTHOP_ENTRY_SUCCESSOR_FLAG)) {
 336                         return EIGRP_FSM_EVENT_QACT;
 337                 } else if (msg->packet_type == EIGRP_OPC_REPLY) {
 338                         listnode_delete(prefix->rij, entry->adv_router);
 339
 340                         if (change == METRIC_INCREASE
 341                             && (entry->flags
 342                                 & EIGRP_NEXTHOP_ENTRY_SUCCESSOR_FLAG)) {
 343                                 return EIGRP_FSM_EVENT_DINC;
 344                         } else if (prefix->rij->count) {
 345                                 return EIGRP_FSM_KEEP_STATE;
 346                         } else {
 347                                 zlog_info("All reply received\n");
 348                                 return EIGRP_FSM_EVENT_LR;
 349                         }
 350                 } else if (msg->packet_type == EIGRP_OPC_UPDATE
 351                            && change == METRIC_INCREASE
 352                            && (entry->flags
 353                                & EIGRP_NEXTHOP_ENTRY_SUCCESSOR_FLAG)) {
 354                         return EIGRP_FSM_EVENT_DINC;
 355                 }
 356                 return EIGRP_FSM_KEEP_STATE;
 357
 358                 break;
 359         }
 360         case EIGRP_FSM_STATE_ACTIVE_2: {
 361                 if (msg->packet_type == EIGRP_OPC_REPLY) {
 362                         struct eigrp_nexthop_entry *head =
 363                                 listnode_head(prefix->entries);
 364
 365                         listnode_delete(prefix->rij, entry->adv_router);
 366                         if (prefix->rij->count) {
 367                                 return EIGRP_FSM_KEEP_STATE;
 368                         } else {
 369                                 zlog_info("All reply received\n");
 370                                 if (head->reported_distance
 371                                     < prefix->fdistance) {
 372                                         return EIGRP_FSM_EVENT_LR_FCS;
 373                                 }
 374
 375                                 return EIGRP_FSM_EVENT_LR_FCN;
 376                         }
 377                 }
 378                 return EIGRP_FSM_KEEP_STATE;
 379
 380                 break;
 381         }
 382         case EIGRP_FSM_STATE_ACTIVE_3: {
 383                 if (msg->packet_type == EIGRP_OPC_REPLY) {
 384                         listnode_delete(prefix->rij, entry->adv_router);
 385
 386                         if (change == METRIC_INCREASE
 387                             && (entry->flags
 388                                 & EIGRP_NEXTHOP_ENTRY_SUCCESSOR_FLAG)) {
 389                                 return EIGRP_FSM_EVENT_DINC;
 390                         } else if (prefix->rij->count) {
 391                                 return EIGRP_FSM_KEEP_STATE;
 392                         } else {
 393                                 zlog_info("All reply received\n");
 394                                 return EIGRP_FSM_EVENT_LR;
 395                         }
 396                 } else if (msg->packet_type == EIGRP_OPC_UPDATE
 397                            && change == METRIC_INCREASE
 398                            && (entry->flags
 399                                & EIGRP_NEXTHOP_ENTRY_SUCCESSOR_FLAG)) {
 400                         return EIGRP_FSM_EVENT_DINC;
 401                 }
 402                 return EIGRP_FSM_KEEP_STATE;
 403
 404                 break;
 405         }
 406         }
 407
 408         return EIGRP_FSM_KEEP_STATE;
 409 }
 410
 411 /*
 412  * Function made to execute in separate thread.
 413  * Load argument from thread and execute proper NSM function
 414  */
 415 int eigrp_fsm_event(struct eigrp_fsm_action_message *msg)
 416 {
 417         enum eigrp_fsm_events event = eigrp_get_fsm_event(msg);
 418
 419         zlog_info(
 420                 "EIGRP AS: %d State: %s Event: %s Network: %s Packet Type: %s Reply RIJ Count: %d change: %s",
 421                 msg->eigrp->AS, prefix_state2str(msg->prefix->state),
 422                 fsm_state2str(event), eigrp_topology_ip_string(msg->prefix),
 423                 packet_type2str(msg->packet_type), msg->prefix->rij->count,
 424                 change2str(msg->change));
 425         (*(NSM[msg->prefix->state][event].func))(msg);
 426
 427         return 1;
 428 }
 429
 430 /*
 431  * Function of event 0.
 432  *
 433  */
 434 int eigrp_fsm_event_nq_fcn(struct eigrp_fsm_action_message *msg)
 435 {
 436         struct eigrp *eigrp = msg->eigrp;
 437         struct eigrp_prefix_entry *prefix = msg->prefix;
 438         struct list *successors = eigrp_topology_get_successor(prefix);
 439         struct eigrp_nexthop_entry *ne;
 440
 441         assert(successors); // If this is NULL we have shit the bed, fun huh?
 442
 443         ne = listnode_head(successors);
 444         prefix->state = EIGRP_FSM_STATE_ACTIVE_1;
 445         prefix->rdistance = prefix->distance = prefix->fdistance = ne->distance;
 446         prefix->reported_metric = ne->total_metric;
 447
 448         if (eigrp_nbr_count_get()) {
 449                 prefix->req_action |= EIGRP_FSM_NEED_QUERY;
 450                 listnode_add(eigrp->topology_changes_internalIPV4, prefix);
 451         } else {
 452                 eigrp_fsm_event_lr(msg); // in the case that there are no more
 453                                          // neighbors left
 454         }
 455
 456         list_delete_and_null(&successors);
 457
 458         return 1;
 459 }
 460
 461 int eigrp_fsm_event_q_fcn(struct eigrp_fsm_action_message *msg)
 462 {
 463         struct eigrp *eigrp = msg->eigrp;
 464         struct eigrp_prefix_entry *prefix = msg->prefix;
 465         struct list *successors = eigrp_topology_get_successor(prefix);
 466         struct eigrp_nexthop_entry *ne;
 467
 468         assert(successors); // If this is NULL somebody poked us in the eye.
 469
 470         ne = listnode_head(successors);
 471         prefix->state = EIGRP_FSM_STATE_ACTIVE_3;
 472         prefix->rdistance = prefix->distance = prefix->fdistance = ne->distance;
 473         prefix->reported_metric = ne->total_metric;
 474         if (eigrp_nbr_count_get()) {
 475                 prefix->req_action |= EIGRP_FSM_NEED_QUERY;
 476                 listnode_add(eigrp->topology_changes_internalIPV4, prefix);
 477         } else {
 478                 eigrp_fsm_event_lr(msg); // in the case that there are no more
 479                                          // neighbors left
 480         }
 481
 482         list_delete_and_null(&successors);
 483
 484         return 1;
 485 }
 486
 487 int eigrp_fsm_event_keep_state(struct eigrp_fsm_action_message *msg)
 488 {
 489         struct eigrp_prefix_entry *prefix = msg->prefix;
 490         struct eigrp_nexthop_entry *ne = listnode_head(prefix->entries);
 491
 492         if (prefix->state == EIGRP_FSM_STATE_PASSIVE) {
 493                 if (!eigrp_metrics_is_same(prefix->reported_metric,
 494                                            ne->total_metric)) {
 495                         prefix->rdistance = prefix->fdistance =
 496                                 prefix->distance = ne->distance;
 497                         prefix->reported_metric = ne->total_metric;
 498                         if (msg->packet_type == EIGRP_OPC_QUERY)
 499                                 eigrp_send_reply(msg->adv_router, prefix);
 500                         prefix->req_action |= EIGRP_FSM_NEED_UPDATE;
 501                         listnode_add(
 502                                 (eigrp_lookup())->topology_changes_internalIPV4,
 503                                 prefix);
 504                 }
 505                 eigrp_topology_update_node_flags(prefix);
 506                 eigrp_update_routing_table(prefix);
 507         }
 508
 509         if (msg->packet_type == EIGRP_OPC_QUERY)
 510                 eigrp_send_reply(msg->adv_router, prefix);
 511
 512         return 1;
 513 }
 514
 515 int eigrp_fsm_event_lr(struct eigrp_fsm_action_message *msg)
 516 {
 517         struct eigrp *eigrp = msg->eigrp;
 518         struct eigrp_prefix_entry *prefix = msg->prefix;
 519         struct eigrp_nexthop_entry *ne = listnode_head(prefix->entries);
 520
 521         prefix->fdistance = prefix->distance = prefix->rdistance = ne->distance;
 522         prefix->reported_metric = ne->total_metric;
 523
 524         if (prefix->state == EIGRP_FSM_STATE_ACTIVE_3) {
 525                 struct list *successors = eigrp_topology_get_successor(prefix);
 526
 527                 assert(successors); // It's like Napolean and Waterloo
 528
 529                 ne = listnode_head(successors);
 530                 eigrp_send_reply(ne->adv_router, prefix);
 531                 list_delete_and_null(&successors);
 532         }
 533
 534         prefix->state = EIGRP_FSM_STATE_PASSIVE;
 535         prefix->req_action |= EIGRP_FSM_NEED_UPDATE;
 536         listnode_add(eigrp->topology_changes_internalIPV4, prefix);
 537         eigrp_topology_update_node_flags(prefix);
 538         eigrp_update_routing_table(prefix);
 539         eigrp_update_topology_table_prefix(eigrp->topology_table, prefix);
 540
 541         return 1;
 542 }
 543
 544 int eigrp_fsm_event_dinc(struct eigrp_fsm_action_message *msg)
 545 {
 546         struct list *successors = eigrp_topology_get_successor(msg->prefix);
 547         struct eigrp_nexthop_entry *ne;
 548
 549         assert(successors); // Trump and his big hands
 550
 551         ne = listnode_head(successors);
 552         msg->prefix->state = msg->prefix->state == EIGRP_FSM_STATE_ACTIVE_1
 553                                      ? EIGRP_FSM_STATE_ACTIVE_0
 554                                      : EIGRP_FSM_STATE_ACTIVE_2;
 555         msg->prefix->distance = ne->distance;
 556         if (!msg->prefix->rij->count)
 557                 (*(NSM[msg->prefix->state][eigrp_get_fsm_event(msg)].func))(
 558                         msg);
 559
 560
 561         list_delete_and_null(&successors);
 562         return 1;
 563 }
 564
 565 int eigrp_fsm_event_lr_fcs(struct eigrp_fsm_action_message *msg)
 566 {
 567         struct eigrp *eigrp = msg->eigrp;
 568         struct eigrp_prefix_entry *prefix = msg->prefix;
 569         struct eigrp_nexthop_entry *ne = listnode_head(prefix->entries);
 570
 571         prefix->state = EIGRP_FSM_STATE_PASSIVE;
 572         prefix->distance = prefix->rdistance = ne->distance;
 573         prefix->reported_metric = ne->total_metric;
 574         prefix->fdistance = prefix->fdistance > prefix->distance
 575                                     ? prefix->distance
 576                                     : prefix->fdistance;
 577         if (prefix->state == EIGRP_FSM_STATE_ACTIVE_2) {
 578                 struct list *successors = eigrp_topology_get_successor(prefix);
 579
 580                 assert(successors); // Having a spoon and all you need is a
 581                                     // knife
 582                 ne = listnode_head(successors);
 583                 eigrp_send_reply(ne->adv_router, prefix);
 584
 585                 list_delete_and_null(&successors);
 586         }
 587         prefix->req_action |= EIGRP_FSM_NEED_UPDATE;
 588         listnode_add(eigrp->topology_changes_internalIPV4, prefix);
 589         eigrp_topology_update_node_flags(prefix);
 590         eigrp_update_routing_table(prefix);
 591         eigrp_update_topology_table_prefix(eigrp->topology_table, prefix);
 592
 593         return 1;
 594 }
 595
 596 int eigrp_fsm_event_lr_fcn(struct eigrp_fsm_action_message *msg)
 597 {
 598         struct eigrp *eigrp = msg->eigrp;
 599         struct eigrp_prefix_entry *prefix = msg->prefix;
 600         struct eigrp_nexthop_entry *best_successor;
 601         struct list *successors = eigrp_topology_get_successor(prefix);
 602
 603         assert(successors); // Routing without a stack
 604
 605         prefix->state = prefix->state == EIGRP_FSM_STATE_ACTIVE_0
 606                                 ? EIGRP_FSM_STATE_ACTIVE_1
 607                                 : EIGRP_FSM_STATE_ACTIVE_3;
 608
 609         best_successor = listnode_head(successors);
 610         prefix->rdistance = prefix->distance = best_successor->distance;
 611         prefix->reported_metric = best_successor->total_metric;
 612
 613         if (eigrp_nbr_count_get()) {
 614                 prefix->req_action |= EIGRP_FSM_NEED_QUERY;
 615                 listnode_add(eigrp->topology_changes_internalIPV4, prefix);
 616         } else {
 617                 eigrp_fsm_event_lr(msg); // in the case that there are no more
 618                                          // neighbors left
 619         }
 620
 621         list_delete_and_null(&successors);
 622
 623         return 1;
 624 }
 625
 626 int eigrp_fsm_event_qact(struct eigrp_fsm_action_message *msg)
 627 {
 628         struct list *successors = eigrp_topology_get_successor(msg->prefix);
 629         struct eigrp_nexthop_entry *ne;
 630
 631         assert(successors); // Cats and no Dogs
 632
 633         ne = listnode_head(successors);
 634         msg->prefix->state = EIGRP_FSM_STATE_ACTIVE_2;
 635         msg->prefix->distance = ne->distance;
 636
 637         list_delete_and_null(&successors);
 638         return 1;
 639 }